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_listeners (POSTSET);
4441  mark_modified ();
4442  }
4443  else
4444  set_renderermode ("manual");
4445  }
4446  }
4447 
4449  {
4450  {
4451  if (renderermode.set (val, true))
4452  {
4453  mark_modified ();
4454  }
4455  }
4456  }
4457 
4459  {
4460  {
4461  if (resize.set (val, true))
4462  {
4463  mark_modified ();
4464  }
4465  }
4466  }
4467 
4469  {
4470  {
4471  if (resizefcn.set (val, true))
4472  {
4473  mark_modified ();
4474  }
4475  }
4476  }
4477 
4479  {
4480  {
4481  if (selectiontype.set (val, true))
4482  {
4483  mark_modified ();
4484  }
4485  }
4486  }
4487 
4489  {
4490  {
4491  if (sizechangedfcn.set (val, true))
4492  {
4493  mark_modified ();
4494  }
4495  }
4496  }
4497 
4499  {
4500  {
4501  if (toolbar.set (val, true))
4502  {
4503  mark_modified ();
4504  }
4505  }
4506  }
4507 
4508  void set_units (const octave_value& val);
4509 
4511  {
4512  {
4513  if (windowbuttondownfcn.set (val, true))
4514  {
4515  mark_modified ();
4516  }
4517  }
4518  }
4519 
4521  {
4522  {
4523  if (windowbuttonmotionfcn.set (val, true))
4524  {
4525  mark_modified ();
4526  }
4527  }
4528  }
4529 
4531  {
4532  {
4533  if (windowbuttonupfcn.set (val, true))
4534  {
4535  mark_modified ();
4536  }
4537  }
4538  }
4539 
4541  {
4542  {
4543  if (windowkeypressfcn.set (val, true))
4544  {
4545  mark_modified ();
4546  }
4547  }
4548  }
4549 
4551  {
4552  {
4553  if (windowkeyreleasefcn.set (val, true))
4554  {
4555  mark_modified ();
4556  }
4557  }
4558  }
4559 
4561  {
4562  {
4563  if (windowscrollwheelfcn.set (val, true))
4564  {
4565  mark_modified ();
4566  }
4567  }
4568  }
4569 
4571  {
4572  {
4573  if (windowstyle.set (val, true))
4574  {
4575  mark_modified ();
4576  }
4577  }
4578  }
4579 
4581  {
4582  {
4583  if (__gl_extensions__.set (val, true))
4584  {
4585  }
4586  }
4587  }
4588 
4590  {
4591  {
4592  if (__gl_renderer__.set (val, true))
4593  {
4594  }
4595  }
4596  }
4597 
4598  void set___gl_vendor__ (const octave_value& val) const
4599  {
4600  {
4601  if (__gl_vendor__.set (val, true))
4602  {
4603  }
4604  }
4605  }
4606 
4608  {
4609  {
4610  if (__gl_version__.set (val, true))
4611  {
4612  }
4613  }
4614  }
4615 
4617  {
4618  {
4619  if (__guidata__.set (val, true))
4620  {
4621  mark_modified ();
4622  }
4623  }
4624  }
4625 
4626  void set___mouse_mode__ (const octave_value& val);
4627 
4629  {
4630  {
4631  if (__pan_mode__.set (val, true))
4632  {
4633  mark_modified ();
4634  }
4635  }
4636  }
4637 
4639  {
4640  {
4641  if (__plot_stream__.set (val, true))
4642  {
4643  mark_modified ();
4644  }
4645  }
4646  }
4647 
4649  {
4650  {
4651  if (__rotate_mode__.set (val, true))
4652  {
4653  mark_modified ();
4654  }
4655  }
4656  }
4657 
4659  {
4660  {
4661  if (__zoom_mode__.set (val, true))
4662  {
4663  mark_modified ();
4664  }
4665  }
4666  }
4667 
4669  {
4670  {
4671  if (doublebuffer.set (val, true))
4672  {
4673  mark_modified ();
4674  }
4675  }
4676  }
4677 
4679  {
4680  {
4681  if (mincolormap.set (val, true))
4682  {
4683  mark_modified ();
4684  }
4685  }
4686  }
4687 
4689  {
4690  {
4691  if (wvisual.set (val, false))
4692  {
4693  set_wvisualmode ("manual");
4694  wvisual.run_listeners (POSTSET);
4695  mark_modified ();
4696  }
4697  else
4698  set_wvisualmode ("manual");
4699  }
4700  }
4701 
4703  {
4704  {
4705  if (wvisualmode.set (val, true))
4706  {
4707  mark_modified ();
4708  }
4709  }
4710  }
4711 
4713  {
4714  {
4715  if (xdisplay.set (val, true))
4716  {
4717  mark_modified ();
4718  }
4719  }
4720  }
4721 
4723  {
4724  {
4725  if (xvisual.set (val, false))
4726  {
4727  set_xvisualmode ("manual");
4728  xvisual.run_listeners (POSTSET);
4729  mark_modified ();
4730  }
4731  else
4732  set_xvisualmode ("manual");
4733  }
4734  }
4735 
4737  {
4738  {
4739  if (xvisualmode.set (val, true))
4740  {
4741  mark_modified ();
4742  }
4743  }
4744  }
4745 
4746 
4747  protected:
4748  void init (void)
4749  {
4750  alphamap.add_constraint (dim_vector (-1, 1));
4751  colormap.add_constraint (dim_vector (-1, 3));
4752  outerposition.add_constraint (dim_vector (1, 4));
4753  paperposition.add_constraint (dim_vector (1, 4));
4754  papersize.add_constraint (dim_vector (1, 2));
4755  pointershapecdata.add_constraint (dim_vector (16, 16));
4756  pointershapehotspot.add_constraint (dim_vector (1, 2));
4757  position.add_constraint (dim_vector (1, 4));
4758  }
4759 
4760  private:
4761  Matrix get_auto_paperposition (void);
4762 
4764  {
4765  if (paperpositionmode.is ("auto"))
4766  paperposition.set (get_auto_paperposition ());
4767  }
4768 
4770  };
4771 
4772 private:
4774 
4775 public:
4777  : base_graphics_object (), xproperties (mh, p), default_properties ()
4778  { }
4779 
4780  ~figure (void) { }
4781 
4783  {
4784  // Allow parent (root figure) to override first (properties knows how
4785  // to find the parent object).
4786  xproperties.override_defaults (obj);
4787 
4788  // Now override with our defaults. If the default_properties
4789  // list includes the properties for all defaults (line,
4790  // surface, etc.) then we don't have to know the type of OBJ
4791  // here, we just call its set function and let it decide which
4792  // properties from the list to use.
4793  obj.set_from_list (default_properties);
4794  }
4795 
4796  void set (const caseless_str& name, const octave_value& value)
4797  {
4798  if (name.compare ("default", 7))
4799  // strip "default", pass rest to function that will
4800  // parse the remainder and add the element to the
4801  // default_properties map.
4802  default_properties.set (name.substr (7), value);
4803  else
4804  xproperties.set (name, value);
4805  }
4806 
4807  octave_value get (const caseless_str& name) const
4808  {
4810 
4811  if (name.compare ("default", 7))
4812  retval = get_default (name.substr (7));
4813  else
4814  retval = xproperties.get (name);
4815 
4816  return retval;
4817  }
4818 
4819  octave_value get_default (const caseless_str& name) const;
4820 
4822  {
4823  return default_properties.as_struct ("default");
4824  }
4825 
4827  {
4828  return default_properties;
4829  }
4830 
4831  base_properties& get_properties (void) { return xproperties; }
4832 
4833  const base_properties& get_properties (void) const { return xproperties; }
4834 
4835  bool valid_object (void) const { return true; }
4836 
4837  void reset_default_properties (void);
4838 
4840  {
4841  bool retval = xproperties.has_readonly_property (pname);
4842  if (! retval)
4843  retval = base_properties::has_readonly_property (pname);
4844  return retval;
4845  }
4846 
4847 private:
4849 };
4850 
4851 // ---------------------------------------------------------------------
4852 
4854 {
4855 public:
4857  : xform (xform_eye ()), xform_inv (xform_eye ()),
4858  sx ("linear"), sy ("linear"), sz ("linear"), zlim (1, 2, 0.0)
4859  {
4860  zlim(1) = 1.0;
4861  }
4862 
4863  graphics_xform (const Matrix& xm, const Matrix& xim,
4864  const scaler& x, const scaler& y, const scaler& z,
4865  const Matrix& zl)
4866  : xform (xm), xform_inv (xim), sx (x), sy (y), sz (z), zlim (zl) { }
4867 
4869  : xform (g.xform), xform_inv (g.xform_inv), sx (g.sx),
4870  sy (g.sy), sz (g.sz), zlim (g.zlim) { }
4871 
4872  ~graphics_xform (void) { }
4873 
4874  graphics_xform& operator = (const graphics_xform& g)
4875  {
4876  xform = g.xform;
4877  xform_inv = g.xform_inv;
4878  sx = g.sx;
4879  sy = g.sy;
4880  sz = g.sz;
4881  zlim = g.zlim;
4882 
4883  return *this;
4884  }
4885 
4886  static ColumnVector xform_vector (double x, double y, double z);
4887 
4888  static Matrix xform_eye (void);
4889 
4890  ColumnVector transform (double x, double y, double z,
4891  bool use_scale = true) const;
4892 
4893  ColumnVector untransform (double x, double y, double z,
4894  bool use_scale = true) const;
4895 
4896  ColumnVector untransform (double x, double y, bool use_scale = true) const
4897  { return untransform (x, y, (zlim(0)+zlim(1))/2, use_scale); }
4898 
4899  Matrix xscale (const Matrix& m) const { return sx.scale (m); }
4900  Matrix yscale (const Matrix& m) const { return sy.scale (m); }
4901  Matrix zscale (const Matrix& m) const { return sz.scale (m); }
4902 
4903  Matrix scale (const Matrix& m) const
4904  {
4905  bool has_z = (m.columns () > 2);
4906 
4907  if (sx.is_linear () && sy.is_linear ()
4908  && (! has_z || sz.is_linear ()))
4909  return m;
4910 
4911  Matrix retval (m.dims ());
4912 
4913  int r = m.rows ();
4914 
4915  for (int i = 0; i < r; i++)
4916  {
4917  retval(i,0) = sx.scale (m(i,0));
4918  retval(i,1) = sy.scale (m(i,1));
4919  if (has_z)
4920  retval(i,2) = sz.scale (m(i,2));
4921  }
4922 
4923  return retval;
4924  }
4925 
4926 private:
4929  scaler sx, sy, sz;
4931 };
4932 
4933 enum
4934 {
4939 };
4940 
4942 {
4943 public:
4945  {
4946  public:
4947  void set_defaults (base_graphics_object& obj, const std::string& mode);
4948 
4949  void remove_child (const graphics_handle& h);
4950 
4951  const scaler& get_x_scaler (void) const { return sx; }
4952  const scaler& get_y_scaler (void) const { return sy; }
4953  const scaler& get_z_scaler (void) const { return sz; }
4954 
4955  Matrix get_boundingbox (bool internal = false,
4956  const Matrix& parent_pix_size = Matrix ()) const;
4957  Matrix get_extent (bool with_text = false,
4958  bool only_text_height=false) const;
4959 
4960  double get_fontsize_points (double box_pix_height = 0) const;
4961 
4963  {
4964  if (units_is ("normalized"))
4965  {
4966  sync_positions ();
4968  }
4969  }
4970 
4971  void update_camera (void);
4972  void update_axes_layout (void);
4973  void update_aspectratios (void);
4974  void update_transform (void)
4975  {
4976  update_aspectratios ();
4977  update_camera ();
4978  update_axes_layout ();
4979  }
4980 
4981  void sync_positions (void);
4982 
4983  void update_autopos (const std::string& elem_type);
4984  void update_xlabel_position (void);
4985  void update_ylabel_position (void);
4986  void update_zlabel_position (void);
4987  void update_title_position (void);
4988 
4990  { return graphics_xform (x_render, x_render_inv, sx, sy, sz, x_zlim); }
4991 
4992  Matrix get_transform_matrix (void) const { return x_render; }
4993  Matrix get_inverse_transform_matrix (void) const { return x_render_inv; }
4994  Matrix get_opengl_matrix_1 (void) const { return x_gl_mat1; }
4995  Matrix get_opengl_matrix_2 (void) const { return x_gl_mat2; }
4996  Matrix get_transform_zlim (void) const { return x_zlim; }
4997 
4998  int get_xstate (void) const { return xstate; }
4999  int get_ystate (void) const { return ystate; }
5000  int get_zstate (void) const { return zstate; }
5001  double get_xPlane (void) const { return xPlane; }
5002  double get_xPlaneN (void) const { return xPlaneN; }
5003  double get_yPlane (void) const { return yPlane; }
5004  double get_yPlaneN (void) const { return yPlaneN; }
5005  double get_zPlane (void) const { return zPlane; }
5006  double get_zPlaneN (void) const { return zPlaneN; }
5007  double get_xpTick (void) const { return xpTick; }
5008  double get_xpTickN (void) const { return xpTickN; }
5009  double get_ypTick (void) const { return ypTick; }
5010  double get_ypTickN (void) const { return ypTickN; }
5011  double get_zpTick (void) const { return zpTick; }
5012  double get_zpTickN (void) const { return zpTickN; }
5013  double get_x_min (void) const { return std::min (xPlane, xPlaneN); }
5014  double get_x_max (void) const { return std::max (xPlane, xPlaneN); }
5015  double get_y_min (void) const { return std::min (yPlane, yPlaneN); }
5016  double get_y_max (void) const { return std::max (yPlane, yPlaneN); }
5017  double get_z_min (void) const { return std::min (zPlane, zPlaneN); }
5018  double get_z_max (void) const { return std::max (zPlane, zPlaneN); }
5019  double get_fx (void) const { return fx; }
5020  double get_fy (void) const { return fy; }
5021  double get_fz (void) const { return fz; }
5022  double get_xticklen (void) const { return xticklen; }
5023  double get_yticklen (void) const { return yticklen; }
5024  double get_zticklen (void) const { return zticklen; }
5025  double get_xtickoffset (void) const { return xtickoffset; }
5026  double get_ytickoffset (void) const { return ytickoffset; }
5027  double get_ztickoffset (void) const { return ztickoffset; }
5028  bool get_x2Dtop (void) const { return x2Dtop; }
5029  bool get_y2Dright (void) const { return y2Dright; }
5030  bool get_layer2Dtop (void) const { return layer2Dtop; }
5031  bool get_is2D (void) const { return is2D; }
5032  bool get_xySym (void) const { return xySym; }
5033  bool get_xyzSym (void) const { return xyzSym; }
5034  bool get_zSign (void) const { return zSign; }
5035  bool get_nearhoriz (void) const { return nearhoriz; }
5036 
5037  ColumnVector pixel2coord (double px, double py) const
5038  { return get_transform ().untransform (px, py, (x_zlim(0)+x_zlim(1))/2); }
5039 
5040  ColumnVector coord2pixel (double x, double y, double z) const
5041  { return get_transform ().transform (x, y, z); }
5042 
5043  void zoom_about_point (const std::string& mode, double x, double y,
5044  double factor, bool push_to_zoom_stack = true);
5045  void zoom (const std::string& mode, double factor,
5046  bool push_to_zoom_stack = true);
5047  void zoom (const std::string& mode, const Matrix& xl, const Matrix& yl,
5048  bool push_to_zoom_stack = true);
5049 
5050  void translate_view (const std::string& mode,
5051  double x0, double x1, double y0, double y1,
5052  bool push_to_zoom_stack = true);
5053 
5054  void pan (const std::string& mode, double factor,
5055  bool push_to_zoom_stack = true);
5056 
5057  void rotate3d (double x0, double x1, double y0, double y1,
5058  bool push_to_zoom_stack = true);
5059 
5060  void rotate_view (double delta_az, double delta_el,
5061  bool push_to_zoom_stack = true);
5062 
5063  void unzoom (void);
5064  void push_zoom_stack (void);
5065  void clear_zoom_stack (bool do_unzoom = true);
5066 
5067  void update_units (const caseless_str& old_units);
5068 
5069  void update_fontunits (const caseless_str& old_fontunits);
5070 
5071  private:
5072  scaler sx, sy, sz;
5074  Matrix x_gl_mat1, x_gl_mat2;
5076  std::list<octave_value> zoom_stack;
5077 
5078  // Axes layout data
5079  int xstate, ystate, zstate;
5080  double xPlane, xPlaneN, yPlane, yPlaneN, zPlane, zPlaneN;
5081  double xpTick, xpTickN, ypTick, ypTickN, zpTick, zpTickN;
5082  double fx, fy, fz;
5083  double xticklen, yticklen, zticklen;
5084  double xtickoffset, ytickoffset, ztickoffset;
5085  bool x2Dtop, y2Dright, layer2Dtop, is2D;
5086  bool xySym, xyzSym, zSign, nearhoriz;
5087 
5088  // Text renderer, used for calculation of text (tick labels) size
5090 
5091  void set_text_child (handle_property& h, const std::string& who,
5092  const octave_value& v);
5093 
5094  void delete_text_child (handle_property& h);
5095 
5096  // See the genprops.awk script for an explanation of the
5097  // properties declarations.
5098 
5099  // FIXME: Several properties have been deleted from Matlab.
5100  // We should either immediately remove them or figure out a way
5101  // to deprecate them for a release or two.
5102  // Obsolete properties: drawmode
5103 
5104  // Programming note: Keep property list sorted if new ones are added.
5105 
5106 public:
5107  properties (const graphics_handle& mh, const graphics_handle& p);
5108 
5109  ~properties (void) { }
5110 
5111  void set (const caseless_str& pname, const octave_value& val);
5112 
5113  octave_value get (bool all = false) const;
5114 
5115  octave_value get (const caseless_str& pname) const;
5116 
5117  octave_value get (const std::string& pname) const
5118  {
5119  return get (caseless_str (pname));
5120  }
5121 
5122  octave_value get (const char *pname) const
5123  {
5124  return get (caseless_str (pname));
5125  }
5126 
5127  property get_property (const caseless_str& pname);
5128 
5129  std::string graphics_object_name (void) const { return go_name; }
5130 
5132 
5133 private:
5135 
5136 public:
5137 
5138 
5139  static std::set<std::string> core_property_names (void);
5140 
5141  static std::set<std::string> readonly_property_names (void);
5142 
5143  static bool has_core_property (const caseless_str& pname);
5144 
5145  static bool has_readonly_property (const caseless_str& pname);
5146 
5147  std::set<std::string> all_property_names (void) const;
5148 
5149  bool has_property (const caseless_str& pname) const;
5150 
5151 private:
5152 
5275 
5276 public:
5277 
5278  enum
5279  {
5280  ID_ACTIVEPOSITIONPROPERTY = 3000,
5281  ID_ALIM = 3001,
5282  ID_ALIMMODE = 3002,
5283  ID_AMBIENTLIGHTCOLOR = 3003,
5284  ID_BOX = 3004,
5285  ID_BOXSTYLE = 3005,
5286  ID_CAMERAPOSITION = 3006,
5287  ID_CAMERAPOSITIONMODE = 3007,
5288  ID_CAMERATARGET = 3008,
5289  ID_CAMERATARGETMODE = 3009,
5290  ID_CAMERAUPVECTOR = 3010,
5291  ID_CAMERAUPVECTORMODE = 3011,
5292  ID_CAMERAVIEWANGLE = 3012,
5293  ID_CAMERAVIEWANGLEMODE = 3013,
5294  ID_CLIM = 3014,
5295  ID_CLIMMODE = 3015,
5296  ID_CLIPPINGSTYLE = 3016,
5297  ID_COLOR = 3017,
5298  ID_COLORORDER = 3018,
5299  ID_COLORORDERINDEX = 3019,
5300  ID_CURRENTPOINT = 3020,
5301  ID_DATAASPECTRATIO = 3021,
5302  ID_DATAASPECTRATIOMODE = 3022,
5303  ID_DRAWMODE = 3023,
5304  ID_FONTANGLE = 3024,
5305  ID_FONTNAME = 3025,
5306  ID_FONTSIZE = 3026,
5307  ID_FONTUNITS = 3027,
5308  ID_FONTSMOOTHING = 3028,
5309  ID_FONTWEIGHT = 3029,
5310  ID_GRIDALPHA = 3030,
5311  ID_GRIDALPHAMODE = 3031,
5312  ID_GRIDCOLOR = 3032,
5313  ID_GRIDCOLORMODE = 3033,
5314  ID_GRIDLINESTYLE = 3034,
5315  ID_LABELFONTSIZEMULTIPLIER = 3035,
5316  ID_LAYER = 3036,
5317  ID_LINESTYLEORDER = 3037,
5318  ID_LINESTYLEORDERINDEX = 3038,
5319  ID_LINEWIDTH = 3039,
5320  ID_MINORGRIDALPHA = 3040,
5321  ID_MINORGRIDALPHAMODE = 3041,
5322  ID_MINORGRIDCOLOR = 3042,
5323  ID_MINORGRIDCOLORMODE = 3043,
5324  ID_MINORGRIDLINESTYLE = 3044,
5325  ID_NEXTPLOT = 3045,
5326  ID_OUTERPOSITION = 3046,
5327  ID_PLOTBOXASPECTRATIO = 3047,
5328  ID_PLOTBOXASPECTRATIOMODE = 3048,
5329  ID_PICKABLEPARTS = 3049,
5330  ID_POSITION = 3050,
5331  ID_PROJECTION = 3051,
5332  ID_SORTMETHOD = 3052,
5333  ID_TICKDIR = 3053,
5334  ID_TICKDIRMODE = 3054,
5335  ID_TICKLABELINTERPRETER = 3055,
5336  ID_TICKLENGTH = 3056,
5337  ID_TIGHTINSET = 3057,
5338  ID_TITLE = 3058,
5339  ID_TITLEFONTSIZEMULTIPLIER = 3059,
5340  ID_TITLEFONTWEIGHT = 3060,
5341  ID_UNITS = 3061,
5342  ID_VIEW = 3062,
5343  ID_XAXISLOCATION = 3063,
5344  ID_XCOLOR = 3064,
5345  ID_XCOLORMODE = 3065,
5346  ID_XDIR = 3066,
5347  ID_XGRID = 3067,
5348  ID_XLABEL = 3068,
5349  ID_XLIM = 3069,
5350  ID_XLIMMODE = 3070,
5351  ID_XMINORGRID = 3071,
5352  ID_XMINORTICK = 3072,
5353  ID_XSCALE = 3073,
5354  ID_XTICK = 3074,
5355  ID_XTICKLABEL = 3075,
5356  ID_XTICKLABELMODE = 3076,
5357  ID_XTICKLABELROTATION = 3077,
5358  ID_XTICKMODE = 3078,
5359  ID_YAXISLOCATION = 3079,
5360  ID_YCOLOR = 3080,
5361  ID_YCOLORMODE = 3081,
5362  ID_YDIR = 3082,
5363  ID_YGRID = 3083,
5364  ID_YLABEL = 3084,
5365  ID_YLIM = 3085,
5366  ID_YLIMMODE = 3086,
5367  ID_YMINORGRID = 3087,
5368  ID_YMINORTICK = 3088,
5369  ID_YSCALE = 3089,
5370  ID_YTICK = 3090,
5371  ID_YTICKLABEL = 3091,
5372  ID_YTICKLABELMODE = 3092,
5373  ID_YTICKLABELROTATION = 3093,
5374  ID_YTICKMODE = 3094,
5375  ID_ZCOLOR = 3095,
5376  ID_ZCOLORMODE = 3096,
5377  ID_ZDIR = 3097,
5378  ID_ZGRID = 3098,
5379  ID_ZLABEL = 3099,
5380  ID_ZLIM = 3100,
5381  ID_ZLIMMODE = 3101,
5382  ID_ZMINORGRID = 3102,
5383  ID_ZMINORTICK = 3103,
5384  ID_ZSCALE = 3104,
5385  ID_ZTICK = 3105,
5386  ID_ZTICKLABEL = 3106,
5387  ID_ZTICKLABELMODE = 3107,
5388  ID_ZTICKLABELROTATION = 3108,
5389  ID_ZTICKMODE = 3109,
5390  ID_MOUSEWHEELZOOM = 3110,
5391  ID_AUTOPOS_TAG = 3111,
5392  ID_LOOSEINSET = 3112,
5393  ID_X_VIEWTRANSFORM = 3113,
5394  ID_X_PROJECTIONTRANSFORM = 3114,
5395  ID_X_VIEWPORTTRANSFORM = 3115,
5396  ID_X_NORMRENDERTRANSFORM = 3116,
5397  ID_X_RENDERTRANSFORM = 3117,
5398  ID_XMTICK = 3118,
5399  ID_YMTICK = 3119,
5400  ID_ZMTICK = 3120,
5401  ID_FONTSIZE_POINTS = 3121
5402  };
5403 
5404  bool activepositionproperty_is (const std::string& v) const { return activepositionproperty.is (v); }
5405  std::string get_activepositionproperty (void) const { return activepositionproperty.current_value (); }
5406 
5407  octave_value get_alim (void) const { return alim.get (); }
5408 
5409  bool alimmode_is (const std::string& v) const { return alimmode.is (v); }
5410  std::string get_alimmode (void) const { return alimmode.current_value (); }
5411 
5412  bool ambientlightcolor_is_rgb (void) const { return ambientlightcolor.is_rgb (); }
5413  bool ambientlightcolor_is (const std::string& v) const { return ambientlightcolor.is (v); }
5414  Matrix get_ambientlightcolor_rgb (void) const { return (ambientlightcolor.is_rgb () ? ambientlightcolor.rgb () : Matrix ()); }
5415  octave_value get_ambientlightcolor (void) const { return ambientlightcolor.get (); }
5416 
5417  bool is_box (void) const { return box.is_on (); }
5418  std::string get_box (void) const { return box.current_value (); }
5419 
5420  bool boxstyle_is (const std::string& v) const { return boxstyle.is (v); }
5421  std::string get_boxstyle (void) const { return boxstyle.current_value (); }
5422 
5423  octave_value get_cameraposition (void) const { return cameraposition.get (); }
5424 
5425  bool camerapositionmode_is (const std::string& v) const { return camerapositionmode.is (v); }
5426  std::string get_camerapositionmode (void) const { return camerapositionmode.current_value (); }
5427 
5428  octave_value get_cameratarget (void) const { return cameratarget.get (); }
5429 
5430  bool cameratargetmode_is (const std::string& v) const { return cameratargetmode.is (v); }
5431  std::string get_cameratargetmode (void) const { return cameratargetmode.current_value (); }
5432 
5433  octave_value get_cameraupvector (void) const { return cameraupvector.get (); }
5434 
5435  bool cameraupvectormode_is (const std::string& v) const { return cameraupvectormode.is (v); }
5436  std::string get_cameraupvectormode (void) const { return cameraupvectormode.current_value (); }
5437 
5438  double get_cameraviewangle (void) const { return cameraviewangle.double_value (); }
5439 
5440  bool cameraviewanglemode_is (const std::string& v) const { return cameraviewanglemode.is (v); }
5441  std::string get_cameraviewanglemode (void) const { return cameraviewanglemode.current_value (); }
5442 
5443  octave_value get_clim (void) const { return clim.get (); }
5444 
5445  bool climmode_is (const std::string& v) const { return climmode.is (v); }
5446  std::string get_climmode (void) const { return climmode.current_value (); }
5447 
5448  bool clippingstyle_is (const std::string& v) const { return clippingstyle.is (v); }
5449  std::string get_clippingstyle (void) const { return clippingstyle.current_value (); }
5450 
5451  bool color_is_rgb (void) const { return color.is_rgb (); }
5452  bool color_is (const std::string& v) const { return color.is (v); }
5453  Matrix get_color_rgb (void) const { return (color.is_rgb () ? color.rgb () : Matrix ()); }
5454  octave_value get_color (void) const { return color.get (); }
5455 
5456  octave_value get_colororder (void) const { return colororder.get (); }
5457 
5458  double get_colororderindex (void) const { return colororderindex.double_value (); }
5459 
5460  octave_value get_currentpoint (void) const { return currentpoint.get (); }
5461 
5462  octave_value get_dataaspectratio (void) const { return dataaspectratio.get (); }
5463 
5464  bool dataaspectratiomode_is (const std::string& v) const { return dataaspectratiomode.is (v); }
5465  std::string get_dataaspectratiomode (void) const { return dataaspectratiomode.current_value (); }
5466 
5467  bool drawmode_is (const std::string& v) const { return drawmode.is (v); }
5468  std::string get_drawmode (void) const { return drawmode.current_value (); }
5469 
5470  bool fontangle_is (const std::string& v) const { return fontangle.is (v); }
5471  std::string get_fontangle (void) const { return fontangle.current_value (); }
5472 
5473  std::string get_fontname (void) const { return fontname.string_value (); }
5474 
5475  double get_fontsize (void) const { return fontsize.double_value (); }
5476 
5477  bool fontunits_is (const std::string& v) const { return fontunits.is (v); }
5478  std::string get_fontunits (void) const { return fontunits.current_value (); }
5479 
5480  bool is_fontsmoothing (void) const { return fontsmoothing.is_on (); }
5481  std::string get_fontsmoothing (void) const { return fontsmoothing.current_value (); }
5482 
5483  bool fontweight_is (const std::string& v) const { return fontweight.is (v); }
5484  std::string get_fontweight (void) const { return fontweight.current_value (); }
5485 
5486  double get_gridalpha (void) const { return gridalpha.double_value (); }
5487 
5488  bool gridalphamode_is (const std::string& v) const { return gridalphamode.is (v); }
5489  std::string get_gridalphamode (void) const { return gridalphamode.current_value (); }
5490 
5491  bool gridcolor_is_rgb (void) const { return gridcolor.is_rgb (); }
5492  bool gridcolor_is (const std::string& v) const { return gridcolor.is (v); }
5493  Matrix get_gridcolor_rgb (void) const { return (gridcolor.is_rgb () ? gridcolor.rgb () : Matrix ()); }
5494  octave_value get_gridcolor (void) const { return gridcolor.get (); }
5495 
5496  bool gridcolormode_is (const std::string& v) const { return gridcolormode.is (v); }
5497  std::string get_gridcolormode (void) const { return gridcolormode.current_value (); }
5498 
5499  bool gridlinestyle_is (const std::string& v) const { return gridlinestyle.is (v); }
5500  std::string get_gridlinestyle (void) const { return gridlinestyle.current_value (); }
5501 
5502  double get_labelfontsizemultiplier (void) const { return labelfontsizemultiplier.double_value (); }
5503 
5504  bool layer_is (const std::string& v) const { return layer.is (v); }
5505  std::string get_layer (void) const { return layer.current_value (); }
5506 
5507  octave_value get_linestyleorder (void) const { return linestyleorder.get (); }
5508 
5509  double get_linestyleorderindex (void) const { return linestyleorderindex.double_value (); }
5510 
5511  double get_linewidth (void) const { return linewidth.double_value (); }
5512 
5513  double get_minorgridalpha (void) const { return minorgridalpha.double_value (); }
5514 
5515  bool minorgridalphamode_is (const std::string& v) const { return minorgridalphamode.is (v); }
5516  std::string get_minorgridalphamode (void) const { return minorgridalphamode.current_value (); }
5517 
5518  bool minorgridcolor_is_rgb (void) const { return minorgridcolor.is_rgb (); }
5519  bool minorgridcolor_is (const std::string& v) const { return minorgridcolor.is (v); }
5520  Matrix get_minorgridcolor_rgb (void) const { return (minorgridcolor.is_rgb () ? minorgridcolor.rgb () : Matrix ()); }
5521  octave_value get_minorgridcolor (void) const { return minorgridcolor.get (); }
5522 
5523  bool minorgridcolormode_is (const std::string& v) const { return minorgridcolormode.is (v); }
5524  std::string get_minorgridcolormode (void) const { return minorgridcolormode.current_value (); }
5525 
5526  bool minorgridlinestyle_is (const std::string& v) const { return minorgridlinestyle.is (v); }
5527  std::string get_minorgridlinestyle (void) const { return minorgridlinestyle.current_value (); }
5528 
5529  bool nextplot_is (const std::string& v) const { return nextplot.is (v); }
5530  std::string get_nextplot (void) const { return nextplot.current_value (); }
5531 
5532  octave_value get_outerposition (void) const { return outerposition.get (); }
5533 
5534  octave_value get_plotboxaspectratio (void) const { return plotboxaspectratio.get (); }
5535 
5536  bool plotboxaspectratiomode_is (const std::string& v) const { return plotboxaspectratiomode.is (v); }
5537  std::string get_plotboxaspectratiomode (void) const { return plotboxaspectratiomode.current_value (); }
5538 
5539  bool pickableparts_is (const std::string& v) const { return pickableparts.is (v); }
5540  std::string get_pickableparts (void) const { return pickableparts.current_value (); }
5541 
5542  octave_value get_position (void) const { return position.get (); }
5543 
5544  bool projection_is (const std::string& v) const { return projection.is (v); }
5545  std::string get_projection (void) const { return projection.current_value (); }
5546 
5547  bool sortmethod_is (const std::string& v) const { return sortmethod.is (v); }
5548  std::string get_sortmethod (void) const { return sortmethod.current_value (); }
5549 
5550  bool tickdir_is (const std::string& v) const { return tickdir.is (v); }
5551  std::string get_tickdir (void) const { return tickdir.current_value (); }
5552 
5553  bool tickdirmode_is (const std::string& v) const { return tickdirmode.is (v); }
5554  std::string get_tickdirmode (void) const { return tickdirmode.current_value (); }
5555 
5556  bool ticklabelinterpreter_is (const std::string& v) const { return ticklabelinterpreter.is (v); }
5557  std::string get_ticklabelinterpreter (void) const { return ticklabelinterpreter.current_value (); }
5558 
5559  octave_value get_ticklength (void) const { return ticklength.get (); }
5560 
5561  octave_value get_tightinset (void) const { return tightinset.get (); }
5562 
5563  graphics_handle get_title (void) const { return title.handle_value (); }
5564 
5565  double get_titlefontsizemultiplier (void) const { return titlefontsizemultiplier.double_value (); }
5566 
5567  bool titlefontweight_is (const std::string& v) const { return titlefontweight.is (v); }
5568  std::string get_titlefontweight (void) const { return titlefontweight.current_value (); }
5569 
5570  bool units_is (const std::string& v) const { return units.is (v); }
5571  std::string get_units (void) const { return units.current_value (); }
5572 
5573  octave_value get_view (void) const { return view.get (); }
5574 
5575  bool xaxislocation_is (const std::string& v) const { return xaxislocation.is (v); }
5576  std::string get_xaxislocation (void) const { return xaxislocation.current_value (); }
5577 
5578  bool xcolor_is_rgb (void) const { return xcolor.is_rgb (); }
5579  bool xcolor_is (const std::string& v) const { return xcolor.is (v); }
5580  Matrix get_xcolor_rgb (void) const { return (xcolor.is_rgb () ? xcolor.rgb () : Matrix ()); }
5581  octave_value get_xcolor (void) const { return xcolor.get (); }
5582 
5583  bool xcolormode_is (const std::string& v) const { return xcolormode.is (v); }
5584  std::string get_xcolormode (void) const { return xcolormode.current_value (); }
5585 
5586  bool xdir_is (const std::string& v) const { return xdir.is (v); }
5587  std::string get_xdir (void) const { return xdir.current_value (); }
5588 
5589  bool is_xgrid (void) const { return xgrid.is_on (); }
5590  std::string get_xgrid (void) const { return xgrid.current_value (); }
5591 
5592  graphics_handle get_xlabel (void) const { return xlabel.handle_value (); }
5593 
5594  octave_value get_xlim (void) const { return xlim.get (); }
5595 
5596  bool xlimmode_is (const std::string& v) const { return xlimmode.is (v); }
5597  std::string get_xlimmode (void) const { return xlimmode.current_value (); }
5598 
5599  bool is_xminorgrid (void) const { return xminorgrid.is_on (); }
5600  std::string get_xminorgrid (void) const { return xminorgrid.current_value (); }
5601 
5602  bool is_xminortick (void) const { return xminortick.is_on (); }
5603  std::string get_xminortick (void) const { return xminortick.current_value (); }
5604 
5605  bool xscale_is (const std::string& v) const { return xscale.is (v); }
5606  std::string get_xscale (void) const { return xscale.current_value (); }
5607 
5608  octave_value get_xtick (void) const { return xtick.get (); }
5609 
5610  octave_value get_xticklabel (void) const { return xticklabel.get (); }
5611 
5612  bool xticklabelmode_is (const std::string& v) const { return xticklabelmode.is (v); }
5613  std::string get_xticklabelmode (void) const { return xticklabelmode.current_value (); }
5614 
5615  double get_xticklabelrotation (void) const { return xticklabelrotation.double_value (); }
5616 
5617  bool xtickmode_is (const std::string& v) const { return xtickmode.is (v); }
5618  std::string get_xtickmode (void) const { return xtickmode.current_value (); }
5619 
5620  bool yaxislocation_is (const std::string& v) const { return yaxislocation.is (v); }
5621  std::string get_yaxislocation (void) const { return yaxislocation.current_value (); }
5622 
5623  bool ycolor_is_rgb (void) const { return ycolor.is_rgb (); }
5624  bool ycolor_is (const std::string& v) const { return ycolor.is (v); }
5625  Matrix get_ycolor_rgb (void) const { return (ycolor.is_rgb () ? ycolor.rgb () : Matrix ()); }
5626  octave_value get_ycolor (void) const { return ycolor.get (); }
5627 
5628  bool ycolormode_is (const std::string& v) const { return ycolormode.is (v); }
5629  std::string get_ycolormode (void) const { return ycolormode.current_value (); }
5630 
5631  bool ydir_is (const std::string& v) const { return ydir.is (v); }
5632  std::string get_ydir (void) const { return ydir.current_value (); }
5633 
5634  bool is_ygrid (void) const { return ygrid.is_on (); }
5635  std::string get_ygrid (void) const { return ygrid.current_value (); }
5636 
5637  graphics_handle get_ylabel (void) const { return ylabel.handle_value (); }
5638 
5639  octave_value get_ylim (void) const { return ylim.get (); }
5640 
5641  bool ylimmode_is (const std::string& v) const { return ylimmode.is (v); }
5642  std::string get_ylimmode (void) const { return ylimmode.current_value (); }
5643 
5644  bool is_yminorgrid (void) const { return yminorgrid.is_on (); }
5645  std::string get_yminorgrid (void) const { return yminorgrid.current_value (); }
5646 
5647  bool is_yminortick (void) const { return yminortick.is_on (); }
5648  std::string get_yminortick (void) const { return yminortick.current_value (); }
5649 
5650  bool yscale_is (const std::string& v) const { return yscale.is (v); }
5651  std::string get_yscale (void) const { return yscale.current_value (); }
5652 
5653  octave_value get_ytick (void) const { return ytick.get (); }
5654 
5655  octave_value get_yticklabel (void) const { return yticklabel.get (); }
5656 
5657  bool yticklabelmode_is (const std::string& v) const { return yticklabelmode.is (v); }
5658  std::string get_yticklabelmode (void) const { return yticklabelmode.current_value (); }
5659 
5660  double get_yticklabelrotation (void) const { return yticklabelrotation.double_value (); }
5661 
5662  bool ytickmode_is (const std::string& v) const { return ytickmode.is (v); }
5663  std::string get_ytickmode (void) const { return ytickmode.current_value (); }
5664 
5665  bool zcolor_is_rgb (void) const { return zcolor.is_rgb (); }
5666  bool zcolor_is (const std::string& v) const { return zcolor.is (v); }
5667  Matrix get_zcolor_rgb (void) const { return (zcolor.is_rgb () ? zcolor.rgb () : Matrix ()); }
5668  octave_value get_zcolor (void) const { return zcolor.get (); }
5669 
5670  bool zcolormode_is (const std::string& v) const { return zcolormode.is (v); }
5671  std::string get_zcolormode (void) const { return zcolormode.current_value (); }
5672 
5673  bool zdir_is (const std::string& v) const { return zdir.is (v); }
5674  std::string get_zdir (void) const { return zdir.current_value (); }
5675 
5676  bool is_zgrid (void) const { return zgrid.is_on (); }
5677  std::string get_zgrid (void) const { return zgrid.current_value (); }
5678 
5679  graphics_handle get_zlabel (void) const { return zlabel.handle_value (); }
5680 
5681  octave_value get_zlim (void) const { return zlim.get (); }
5682 
5683  bool zlimmode_is (const std::string& v) const { return zlimmode.is (v); }
5684  std::string get_zlimmode (void) const { return zlimmode.current_value (); }
5685 
5686  bool is_zminorgrid (void) const { return zminorgrid.is_on (); }
5687  std::string get_zminorgrid (void) const { return zminorgrid.current_value (); }
5688 
5689  bool is_zminortick (void) const { return zminortick.is_on (); }
5690  std::string get_zminortick (void) const { return zminortick.current_value (); }
5691 
5692  bool zscale_is (const std::string& v) const { return zscale.is (v); }
5693  std::string get_zscale (void) const { return zscale.current_value (); }
5694 
5695  octave_value get_ztick (void) const { return ztick.get (); }
5696 
5697  octave_value get_zticklabel (void) const { return zticklabel.get (); }
5698 
5699  bool zticklabelmode_is (const std::string& v) const { return zticklabelmode.is (v); }
5700  std::string get_zticklabelmode (void) const { return zticklabelmode.current_value (); }
5701 
5702  double get_zticklabelrotation (void) const { return zticklabelrotation.double_value (); }
5703 
5704  bool ztickmode_is (const std::string& v) const { return ztickmode.is (v); }
5705  std::string get_ztickmode (void) const { return ztickmode.current_value (); }
5706 
5707  double get_mousewheelzoom (void) const { return mousewheelzoom.double_value (); }
5708 
5709  bool autopos_tag_is (const std::string& v) const { return autopos_tag.is (v); }
5710  std::string get_autopos_tag (void) const { return autopos_tag.current_value (); }
5711 
5712  octave_value get_looseinset (void) const { return looseinset.get (); }
5713 
5714  octave_value get_x_viewtransform (void) const { return x_viewtransform.get (); }
5715 
5716  octave_value get_x_projectiontransform (void) const { return x_projectiontransform.get (); }
5717 
5718  octave_value get_x_viewporttransform (void) const { return x_viewporttransform.get (); }
5719 
5720  octave_value get_x_normrendertransform (void) const { return x_normrendertransform.get (); }
5721 
5722  octave_value get_x_rendertransform (void) const { return x_rendertransform.get (); }
5723 
5724  octave_value get_xmtick (void) const { return xmtick.get (); }
5725 
5726  octave_value get_ymtick (void) const { return ymtick.get (); }
5727 
5728  octave_value get_zmtick (void) const { return zmtick.get (); }
5729 
5730 
5732  {
5733  {
5734  if (activepositionproperty.set (val, true))
5735  {
5736  mark_modified ();
5737  }
5738  }
5739  }
5740 
5741  void set_alim (const octave_value& val)
5742  {
5743  {
5744  if (alim.set (val, false))
5745  {
5746  set_alimmode ("manual");
5747  alim.run_listeners (POSTSET);
5748  mark_modified ();
5749  }
5750  else
5751  set_alimmode ("manual");
5752  }
5753  }
5754 
5756  {
5757  {
5758  if (alimmode.set (val, true))
5759  {
5760  mark_modified ();
5761  }
5762  }
5763  }
5764 
5766  {
5767  {
5768  if (ambientlightcolor.set (val, true))
5769  {
5770  mark_modified ();
5771  }
5772  }
5773  }
5774 
5775  void set_box (const octave_value& val)
5776  {
5777  {
5778  if (box.set (val, true))
5779  {
5780  mark_modified ();
5781  }
5782  }
5783  }
5784 
5786  {
5787  {
5788  if (boxstyle.set (val, true))
5789  {
5790  mark_modified ();
5791  }
5792  }
5793  }
5794 
5796  {
5797  {
5798  if (cameraposition.set (val, false))
5799  {
5800  set_camerapositionmode ("manual");
5801  cameraposition.run_listeners (POSTSET);
5802  mark_modified ();
5803  }
5804  else
5805  set_camerapositionmode ("manual");
5806  }
5807  }
5808 
5810  {
5811  {
5812  if (camerapositionmode.set (val, true))
5813  {
5814  mark_modified ();
5815  }
5816  }
5817  }
5818 
5820  {
5821  {
5822  if (cameratarget.set (val, false))
5823  {
5824  set_cameratargetmode ("manual");
5825  cameratarget.run_listeners (POSTSET);
5826  mark_modified ();
5827  }
5828  else
5829  set_cameratargetmode ("manual");
5830  }
5831  }
5832 
5834  {
5835  {
5836  if (cameratargetmode.set (val, true))
5837  {
5838  mark_modified ();
5839  }
5840  }
5841  }
5842 
5844  {
5845  {
5846  if (cameraupvector.set (val, false))
5847  {
5848  set_cameraupvectormode ("manual");
5849  cameraupvector.run_listeners (POSTSET);
5850  mark_modified ();
5851  }
5852  else
5853  set_cameraupvectormode ("manual");
5854  }
5855  }
5856 
5858  {
5859  {
5860  if (cameraupvectormode.set (val, true))
5861  {
5862  mark_modified ();
5863  }
5864  }
5865  }
5866 
5868  {
5869  {
5870  if (cameraviewangle.set (val, false))
5871  {
5872  set_cameraviewanglemode ("manual");
5873  cameraviewangle.run_listeners (POSTSET);
5874  mark_modified ();
5875  }
5876  else
5877  set_cameraviewanglemode ("manual");
5878  }
5879  }
5880 
5882  {
5883  {
5884  if (cameraviewanglemode.set (val, true))
5885  {
5886  mark_modified ();
5887  }
5888  }
5889  }
5890 
5891  void set_clim (const octave_value& val)
5892  {
5893  {
5894  if (clim.set (val, false))
5895  {
5896  set_climmode ("manual");
5897  clim.run_listeners (POSTSET);
5898  mark_modified ();
5899  }
5900  else
5901  set_climmode ("manual");
5902  }
5903  }
5904 
5906  {
5907  {
5908  if (climmode.set (val, false))
5909  {
5910  update_axis_limits ("climmode");
5911  climmode.run_listeners (POSTSET);
5912  mark_modified ();
5913  }
5914  }
5915  }
5916 
5918  {
5919  {
5920  if (clippingstyle.set (val, true))
5921  {
5922  mark_modified ();
5923  }
5924  }
5925  }
5926 
5928  {
5929  {
5930  if (color.set (val, true))
5931  {
5932  mark_modified ();
5933  }
5934  }
5935  }
5936 
5938  {
5939  {
5940  if (colororder.set (val, true))
5941  {
5942  mark_modified ();
5943  }
5944  }
5945  }
5946 
5948  {
5949  {
5950  if (colororderindex.set (val, true))
5951  {
5952  mark_modified ();
5953  }
5954  }
5955  }
5956 
5958  {
5959  {
5960  if (currentpoint.set (val, true))
5961  {
5962  mark_modified ();
5963  }
5964  }
5965  }
5966 
5968  {
5969  {
5970  if (dataaspectratio.set (val, false))
5971  {
5972  set_dataaspectratiomode ("manual");
5973  update_dataaspectratio ();
5974  dataaspectratio.run_listeners (POSTSET);
5975  mark_modified ();
5976  }
5977  else
5978  set_dataaspectratiomode ("manual");
5979  }
5980  }
5981 
5983  {
5984  {
5985  if (dataaspectratiomode.set (val, true))
5986  {
5987  update_dataaspectratiomode ();
5988  mark_modified ();
5989  }
5990  }
5991  }
5992 
5994  {
5995  {
5996  if (drawmode.set (val, true))
5997  {
5998  mark_modified ();
5999  }
6000  }
6001  }
6002 
6004  {
6005  {
6006  if (fontangle.set (val, true))
6007  {
6008  update_fontangle ();
6009  mark_modified ();
6010  }
6011  }
6012  }
6013 
6015  {
6016  {
6017  if (fontname.set (val, true))
6018  {
6019  update_fontname ();
6020  mark_modified ();
6021  }
6022  }
6023  }
6024 
6026  {
6027  {
6028  if (fontsize.set (val, true))
6029  {
6030  update_fontsize ();
6031  mark_modified ();
6032  }
6033  }
6034  }
6035 
6036  void set_fontunits (const octave_value& val);
6037 
6038  void update_fontunits (void);
6039 
6041  {
6042  {
6043  if (fontsmoothing.set (val, true))
6044  {
6045  mark_modified ();
6046  }
6047  }
6048  }
6049 
6051  {
6052  {
6053  if (fontweight.set (val, true))
6054  {
6055  update_fontweight ();
6056  mark_modified ();
6057  }
6058  }
6059  }
6060 
6062  {
6063  {
6064  if (gridalpha.set (val, false))
6065  {
6066  set_gridalphamode ("manual");
6067  gridalpha.run_listeners (POSTSET);
6068  mark_modified ();
6069  }
6070  else
6071  set_gridalphamode ("manual");
6072  }
6073  }
6074 
6076  {
6077  {
6078  if (gridalphamode.set (val, true))
6079  {
6080  mark_modified ();
6081  }
6082  }
6083  }
6084 
6086  {
6087  {
6088  if (gridcolor.set (val, true))
6089  {
6090  mark_modified ();
6091  }
6092  }
6093  }
6094 
6096  {
6097  {
6098  if (gridcolormode.set (val, true))
6099  {
6100  mark_modified ();
6101  }
6102  }
6103  }
6104 
6106  {
6107  {
6108  if (gridlinestyle.set (val, true))
6109  {
6110  mark_modified ();
6111  }
6112  }
6113  }
6114 
6116  {
6117  {
6118  if (labelfontsizemultiplier.set (val, true))
6119  {
6120  mark_modified ();
6121  }
6122  }
6123  }
6124 
6126  {
6127  {
6128  if (layer.set (val, true))
6129  {
6130  update_layer ();
6131  mark_modified ();
6132  }
6133  }
6134  }
6135 
6136  void set_linestyleorder (const octave_value& val);
6137 
6139  {
6140  {
6141  if (linestyleorderindex.set (val, true))
6142  {
6143  mark_modified ();
6144  }
6145  }
6146  }
6147 
6149  {
6150  {
6151  if (linewidth.set (val, true))
6152  {
6153  mark_modified ();
6154  }
6155  }
6156  }
6157 
6159  {
6160  {
6161  if (minorgridalpha.set (val, false))
6162  {
6163  set_minorgridalphamode ("manual");
6164  minorgridalpha.run_listeners (POSTSET);
6165  mark_modified ();
6166  }
6167  else
6168  set_minorgridalphamode ("manual");
6169  }
6170  }
6171 
6173  {
6174  {
6175  if (minorgridalphamode.set (val, true))
6176  {
6177  mark_modified ();
6178  }
6179  }
6180  }
6181 
6183  {
6184  {
6185  if (minorgridcolor.set (val, false))
6186  {
6187  set_minorgridcolormode ("manual");
6188  minorgridcolor.run_listeners (POSTSET);
6189  mark_modified ();
6190  }
6191  else
6192  set_minorgridcolormode ("manual");
6193  }
6194  }
6195 
6197  {
6198  {
6199  if (minorgridcolormode.set (val, true))
6200  {
6201  mark_modified ();
6202  }
6203  }
6204  }
6205 
6207  {
6208  {
6209  if (minorgridlinestyle.set (val, true))
6210  {
6211  mark_modified ();
6212  }
6213  }
6214  }
6215 
6217  {
6218  {
6219  if (nextplot.set (val, true))
6220  {
6221  mark_modified ();
6222  }
6223  }
6224  }
6225 
6227  {
6228  {
6229  if (outerposition.set (val, true))
6230  {
6231  update_outerposition ();
6232  mark_modified ();
6233  }
6234  }
6235  }
6236 
6238  {
6239  {
6240  if (plotboxaspectratio.set (val, false))
6241  {
6242  set_plotboxaspectratiomode ("manual");
6243  update_plotboxaspectratio ();
6244  plotboxaspectratio.run_listeners (POSTSET);
6245  mark_modified ();
6246  }
6247  else
6248  set_plotboxaspectratiomode ("manual");
6249  }
6250  }
6251 
6253  {
6254  {
6255  if (plotboxaspectratiomode.set (val, true))
6256  {
6257  update_plotboxaspectratiomode ();
6258  mark_modified ();
6259  }
6260  }
6261  }
6262 
6264  {
6265  {
6266  if (pickableparts.set (val, true))
6267  {
6268  mark_modified ();
6269  }
6270  }
6271  }
6272 
6274  {
6275  {
6276  if (position.set (val, true))
6277  {
6278  update_position ();
6279  mark_modified ();
6280  }
6281  }
6282  }
6283 
6285  {
6286  {
6287  if (projection.set (val, true))
6288  {
6289  mark_modified ();
6290  }
6291  }
6292  }
6293 
6295  {
6296  {
6297  if (sortmethod.set (val, true))
6298  {
6299  mark_modified ();
6300  }
6301  }
6302  }
6303 
6305  {
6306  {
6307  if (tickdir.set (val, false))
6308  {
6309  set_tickdirmode ("manual");
6310  update_tickdir ();
6311  tickdir.run_listeners (POSTSET);
6312  mark_modified ();
6313  }
6314  else
6315  set_tickdirmode ("manual");
6316  }
6317  }
6318 
6320  {
6321  {
6322  if (tickdirmode.set (val, true))
6323  {
6324  update_tickdirmode ();
6325  mark_modified ();
6326  }
6327  }
6328  }
6329 
6331  {
6332  {
6333  if (ticklabelinterpreter.set (val, true))
6334  {
6335  mark_modified ();
6336  }
6337  }
6338  }
6339 
6341  {
6342  {
6343  if (ticklength.set (val, true))
6344  {
6345  update_ticklength ();
6346  mark_modified ();
6347  }
6348  }
6349  }
6350 
6352  {
6353  {
6354  if (tightinset.set (val, true))
6355  {
6356  mark_modified ();
6357  }
6358  }
6359  }
6360 
6361  void set_title (const octave_value& val);
6362 
6364  {
6365  {
6366  if (titlefontsizemultiplier.set (val, true))
6367  {
6368  mark_modified ();
6369  }
6370  }
6371  }
6372 
6374  {
6375  {
6376  if (titlefontweight.set (val, true))
6377  {
6378  mark_modified ();
6379  }
6380  }
6381  }
6382 
6383  void set_units (const octave_value& val);
6384 
6385  void update_units (void);
6386 
6387  void set_view (const octave_value& val)
6388  {
6389  {
6390  if (view.set (val, true))
6391  {
6392  update_view ();
6393  mark_modified ();
6394  }
6395  }
6396  }
6397 
6399  {
6400  {
6401  if (xaxislocation.set (val, true))
6402  {
6403  update_xaxislocation ();
6404  mark_modified ();
6405  }
6406  }
6407  }
6408 
6410  {
6411  {
6412  if (xcolor.set (val, false))
6413  {
6414  set_xcolormode ("manual");
6415  update_xcolor ();
6416  xcolor.run_listeners (POSTSET);
6417  mark_modified ();
6418  }
6419  else
6420  set_xcolormode ("manual");
6421  }
6422  }
6423 
6425  {
6426  {
6427  if (xcolormode.set (val, true))
6428  {
6429  mark_modified ();
6430  }
6431  }
6432  }
6433 
6434  void set_xdir (const octave_value& val)
6435  {
6436  {
6437  if (xdir.set (val, true))
6438  {
6439  update_xdir ();
6440  mark_modified ();
6441  }
6442  }
6443  }
6444 
6446  {
6447  {
6448  if (xgrid.set (val, true))
6449  {
6450  mark_modified ();
6451  }
6452  }
6453  }
6454 
6455  void set_xlabel (const octave_value& val);
6456 
6457  void set_xlim (const octave_value& val)
6458  {
6459  {
6460  if (xlim.set (val, false))
6461  {
6462  set_xlimmode ("manual");
6463  update_xlim ();
6464  xlim.run_listeners (POSTSET);
6465  mark_modified ();
6466  }
6467  else
6468  set_xlimmode ("manual");
6469  }
6470  }
6471 
6473  {
6474  {
6475  if (xlimmode.set (val, false))
6476  {
6477  update_axis_limits ("xlimmode");
6478  xlimmode.run_listeners (POSTSET);
6479  mark_modified ();
6480  }
6481  }
6482  }
6483 
6485  {
6486  {
6487  if (xminorgrid.set (val, true))
6488  {
6489  mark_modified ();
6490  }
6491  }
6492  }
6493 
6495  {
6496  {
6497  if (xminortick.set (val, true))
6498  {
6499  mark_modified ();
6500  }
6501  }
6502  }
6503 
6505  {
6506  {
6507  if (xscale.set (val, false))
6508  {
6509  update_xscale ();
6510  update_axis_limits ("xscale");
6511  xscale.run_listeners (POSTSET);
6512  mark_modified ();
6513  }
6514  }
6515  }
6516 
6518  {
6519  {
6520  if (xtick.set (val, false))
6521  {
6522  set_xtickmode ("manual");
6523  update_xtick ();
6524  xtick.run_listeners (POSTSET);
6525  mark_modified ();
6526  }
6527  else
6528  set_xtickmode ("manual");
6529  }
6530  }
6531 
6532  void set_xticklabel (const octave_value& val);
6533 
6535  {
6536  {
6537  if (xticklabelmode.set (val, true))
6538  {
6539  update_xticklabelmode ();
6540  mark_modified ();
6541  }
6542  }
6543  }
6544 
6546  {
6547  {
6548  if (xticklabelrotation.set (val, true))
6549  {
6550  mark_modified ();
6551  }
6552  }
6553  }
6554 
6556  {
6557  {
6558  if (xtickmode.set (val, true))
6559  {
6560  update_xtickmode ();
6561  mark_modified ();
6562  }
6563  }
6564  }
6565 
6567  {
6568  {
6569  if (yaxislocation.set (val, true))
6570  {
6571  update_yaxislocation ();
6572  mark_modified ();
6573  }
6574  }
6575  }
6576 
6578  {
6579  {
6580  if (ycolor.set (val, false))
6581  {
6582  set_ycolormode ("manual");
6583  update_ycolor ();
6584  ycolor.run_listeners (POSTSET);
6585  mark_modified ();
6586  }
6587  else
6588  set_ycolormode ("manual");
6589  }
6590  }
6591 
6593  {
6594  {
6595  if (ycolormode.set (val, true))
6596  {
6597  mark_modified ();
6598  }
6599  }
6600  }
6601 
6602  void set_ydir (const octave_value& val)
6603  {
6604  {
6605  if (ydir.set (val, true))
6606  {
6607  update_ydir ();
6608  mark_modified ();
6609  }
6610  }
6611  }
6612 
6614  {
6615  {
6616  if (ygrid.set (val, true))
6617  {
6618  mark_modified ();
6619  }
6620  }
6621  }
6622 
6623  void set_ylabel (const octave_value& val);
6624 
6625  void set_ylim (const octave_value& val)
6626  {
6627  {
6628  if (ylim.set (val, false))
6629  {
6630  set_ylimmode ("manual");
6631  update_ylim ();
6632  ylim.run_listeners (POSTSET);
6633  mark_modified ();
6634  }
6635  else
6636  set_ylimmode ("manual");
6637  }
6638  }
6639 
6641  {
6642  {
6643  if (ylimmode.set (val, false))
6644  {
6645  update_axis_limits ("ylimmode");
6646  ylimmode.run_listeners (POSTSET);
6647  mark_modified ();
6648  }
6649  }
6650  }
6651 
6653  {
6654  {
6655  if (yminorgrid.set (val, true))
6656  {
6657  mark_modified ();
6658  }
6659  }
6660  }
6661 
6663  {
6664  {
6665  if (yminortick.set (val, true))
6666  {
6667  mark_modified ();
6668  }
6669  }
6670  }
6671 
6673  {
6674  {
6675  if (yscale.set (val, false))
6676  {
6677  update_yscale ();
6678  update_axis_limits ("yscale");
6679  yscale.run_listeners (POSTSET);
6680  mark_modified ();
6681  }
6682  }
6683  }
6684 
6686  {
6687  {
6688  if (ytick.set (val, false))
6689  {
6690  set_ytickmode ("manual");
6691  update_ytick ();
6692  ytick.run_listeners (POSTSET);
6693  mark_modified ();
6694  }
6695  else
6696  set_ytickmode ("manual");
6697  }
6698  }
6699 
6700  void set_yticklabel (const octave_value& val);
6701 
6703  {
6704  {
6705  if (yticklabelmode.set (val, true))
6706  {
6707  update_yticklabelmode ();
6708  mark_modified ();
6709  }
6710  }
6711  }
6712 
6714  {
6715  {
6716  if (yticklabelrotation.set (val, true))
6717  {
6718  mark_modified ();
6719  }
6720  }
6721  }
6722 
6724  {
6725  {
6726  if (ytickmode.set (val, true))
6727  {
6728  update_ytickmode ();
6729  mark_modified ();
6730  }
6731  }
6732  }
6733 
6735  {
6736  {
6737  if (zcolor.set (val, false))
6738  {
6739  set_zcolormode ("manual");
6740  update_zcolor ();
6741  zcolor.run_listeners (POSTSET);
6742  mark_modified ();
6743  }
6744  else
6745  set_zcolormode ("manual");
6746  }
6747  }
6748 
6750  {
6751  {
6752  if (zcolormode.set (val, true))
6753  {
6754  mark_modified ();
6755  }
6756  }
6757  }
6758 
6759  void set_zdir (const octave_value& val)
6760  {
6761  {
6762  if (zdir.set (val, true))
6763  {
6764  update_zdir ();
6765  mark_modified ();
6766  }
6767  }
6768  }
6769 
6771  {
6772  {
6773  if (zgrid.set (val, true))
6774  {
6775  mark_modified ();
6776  }
6777  }
6778  }
6779 
6780  void set_zlabel (const octave_value& val);
6781 
6782  void set_zlim (const octave_value& val)
6783  {
6784  {
6785  if (zlim.set (val, false))
6786  {
6787  set_zlimmode ("manual");
6788  update_zlim ();
6789  zlim.run_listeners (POSTSET);
6790  mark_modified ();
6791  }
6792  else
6793  set_zlimmode ("manual");
6794  }
6795  }
6796 
6798  {
6799  {
6800  if (zlimmode.set (val, false))
6801  {
6802  update_axis_limits ("zlimmode");
6803  zlimmode.run_listeners (POSTSET);
6804  mark_modified ();
6805  }
6806  }
6807  }
6808 
6810  {
6811  {
6812  if (zminorgrid.set (val, true))
6813  {
6814  mark_modified ();
6815  }
6816  }
6817  }
6818 
6820  {
6821  {
6822  if (zminortick.set (val, true))
6823  {
6824  mark_modified ();
6825  }
6826  }
6827  }
6828 
6830  {
6831  {
6832  if (zscale.set (val, false))
6833  {
6834  update_zscale ();
6835  update_axis_limits ("zscale");
6836  zscale.run_listeners (POSTSET);
6837  mark_modified ();
6838  }
6839  }
6840  }
6841 
6843  {
6844  {
6845  if (ztick.set (val, false))
6846  {
6847  set_ztickmode ("manual");
6848  update_ztick ();
6849  ztick.run_listeners (POSTSET);
6850  mark_modified ();
6851  }
6852  else
6853  set_ztickmode ("manual");
6854  }
6855  }
6856 
6857  void set_zticklabel (const octave_value& val);
6858 
6860  {
6861  {
6862  if (zticklabelmode.set (val, true))
6863  {
6864  update_zticklabelmode ();
6865  mark_modified ();
6866  }
6867  }
6868  }
6869 
6871  {
6872  {
6873  if (zticklabelrotation.set (val, true))
6874  {
6875  mark_modified ();
6876  }
6877  }
6878  }
6879 
6881  {
6882  {
6883  if (ztickmode.set (val, true))
6884  {
6885  update_ztickmode ();
6886  mark_modified ();
6887  }
6888  }
6889  }
6890 
6892  {
6893  {
6894  if (mousewheelzoom.set (val, true))
6895  {
6896  mark_modified ();
6897  }
6898  }
6899  }
6900 
6902  {
6903  {
6904  if (autopos_tag.set (val, true))
6905  {
6906  mark_modified ();
6907  }
6908  }
6909  }
6910 
6912  {
6913  {
6914  if (looseinset.set (val, true))
6915  {
6916  update_looseinset ();
6917  mark_modified ();
6918  }
6919  }
6920  }
6921 
6923  {
6924  {
6925  if (x_viewtransform.set (val, true))
6926  {
6927  mark_modified ();
6928  }
6929  }
6930  }
6931 
6933  {
6934  {
6935  if (x_projectiontransform.set (val, true))
6936  {
6937  mark_modified ();
6938  }
6939  }
6940  }
6941 
6943  {
6944  {
6945  if (x_viewporttransform.set (val, true))
6946  {
6947  mark_modified ();
6948  }
6949  }
6950  }
6951 
6953  {
6954  {
6955  if (x_normrendertransform.set (val, true))
6956  {
6957  mark_modified ();
6958  }
6959  }
6960  }
6961 
6963  {
6964  {
6965  if (x_rendertransform.set (val, true))
6966  {
6967  mark_modified ();
6968  }
6969  }
6970  }
6971 
6973  {
6974  {
6975  if (xmtick.set (val, true))
6976  {
6977  mark_modified ();
6978  }
6979  }
6980  }
6981 
6983  {
6984  {
6985  if (ymtick.set (val, true))
6986  {
6987  mark_modified ();
6988  }
6989  }
6990  }
6991 
6993  {
6994  {
6995  if (zmtick.set (val, true))
6996  {
6997  mark_modified ();
6998  }
6999  }
7000  }
7001 
7003  {
7004  {
7005  if (fontsize_points.set (val, true))
7006  {
7007  mark_modified ();
7008  }
7009  }
7010  }
7011 
7012 
7013  protected:
7014  void init (void);
7015 
7016  private:
7017 
7018  std::string
7019  get_scale (const std::string& scale, const Matrix& lims)
7020  {
7022 
7023  if (scale == "log" && lims.numel () > 1 && lims(0) < 0 && lims(1) < 0)
7024  retval = "neglog";
7025 
7026  return retval;
7027  }
7028 
7029  void update_xscale (void)
7030  {
7031  sx = get_scale (get_xscale (), xlim.get ().matrix_value ());
7032  }
7033 
7034  void update_yscale (void)
7035  {
7036  sy = get_scale (get_yscale (), ylim.get ().matrix_value ());
7037  }
7038 
7039  void update_zscale (void)
7040  {
7041  sz = get_scale (get_zscale (), zlim.get ().matrix_value ());
7042  }
7043 
7044  void update_label_color (handle_property label, color_property col);
7045  void update_xcolor (void)
7046  { update_label_color (xlabel, xcolor); }
7047 
7048  void update_ycolor (void)
7049  { update_label_color (ylabel, ycolor); }
7050 
7051  void update_zcolor (void)
7052  { update_label_color (zlabel, zcolor); }
7053 
7054  void update_view (void) { sync_positions (); }
7055  void update_dataaspectratio (void) { sync_positions (); }
7056  void update_dataaspectratiomode (void) { sync_positions (); }
7057  void update_plotboxaspectratio (void) { sync_positions (); }
7058  void update_plotboxaspectratiomode (void) { sync_positions (); }
7059 
7060  void update_layer (void) { update_axes_layout (); }
7062  {
7063  // FIXME: Remove warning with "zero" in 4.6
7064  if (yaxislocation_is ("zero"))
7065  warning_with_id ("Octave:deprecated-property",
7066  "Setting 'yaxislocation' to 'zero' is deprecated, "
7067  "set to 'origin' instead.");
7068  sync_positions ();
7069  update_axes_layout ();
7070  update_ylabel_position ();
7071  }
7073  {
7074  // FIXME: Remove warning with "zero" in 4.6
7075  if (xaxislocation_is ("zero"))
7076  warning_with_id ("Octave:deprecated-property",
7077  "Setting 'xaxislocation' to 'zero' is deprecated, "
7078  "set to 'origin' instead.");
7079  sync_positions ();
7080  update_axes_layout ();
7081  update_xlabel_position ();
7082  }
7083 
7084  void update_xdir (void) { update_camera (); update_axes_layout (); }
7085  void update_ydir (void) { update_camera (); update_axes_layout (); }
7086  void update_zdir (void) { update_camera (); update_axes_layout (); }
7087 
7088  void update_ticklength (void);
7089  void update_tickdir (void) { update_ticklength (); }
7090  void update_tickdirmode (void) { update_ticklength (); }
7091 
7092  void update_xtick (void)
7093  {
7094  if (xticklabelmode.is ("auto"))
7095  calc_ticklabels (xtick, xticklabel, xscale.is ("log"));
7096  sync_positions ();
7097  }
7098  void update_ytick (void)
7099  {
7100  if (yticklabelmode.is ("auto"))
7101  calc_ticklabels (ytick, yticklabel, yscale.is ("log"));
7102  sync_positions ();
7103  }
7104  void update_ztick (void)
7105  {
7106  if (zticklabelmode.is ("auto"))
7107  calc_ticklabels (ztick, zticklabel, zscale.is ("log"));
7108  sync_positions ();
7109  }
7110 
7111  void update_xtickmode (void)
7112  {
7113  if (xtickmode.is ("auto"))
7114  {
7115  calc_ticks_and_lims (xlim, xtick, xmtick, xlimmode.is ("auto"),
7116  xscale.is ("log"));
7117  update_xtick ();
7118  }
7119  }
7120  void update_ytickmode (void)
7121  {
7122  if (ytickmode.is ("auto"))
7123  {
7124  calc_ticks_and_lims (ylim, ytick, ymtick, ylimmode.is ("auto"),
7125  yscale.is ("log"));
7126  update_ytick ();
7127  }
7128  }
7129  void update_ztickmode (void)
7130  {
7131  if (ztickmode.is ("auto"))
7132  {
7133  calc_ticks_and_lims (zlim, ztick, zmtick, zlimmode.is ("auto"),
7134  zscale.is ("log"));
7135  update_ztick ();
7136  }
7137  }
7138 
7140  {
7141  if (xticklabelmode.is ("auto"))
7142  calc_ticklabels (xtick, xticklabel, xscale.is ("log"));
7143  }
7145  {
7146  if (yticklabelmode.is ("auto"))
7147  calc_ticklabels (ytick, yticklabel, yscale.is ("log"));
7148  }
7150  {
7151  if (zticklabelmode.is ("auto"))
7152  calc_ticklabels (ztick, zticklabel, zscale.is ("log"));
7153  }
7154 
7155  void update_font (void);
7156  void update_fontname (void)
7157  {
7158  update_font ();
7159  sync_positions ();
7160  }
7161  void update_fontsize (void)
7162  {
7163  update_font ();
7164  sync_positions ();
7165  }
7166  void update_fontangle (void)
7167  {
7168  update_font ();
7169  sync_positions ();
7170  }
7171  void update_fontweight (void)
7172  {
7173  update_font ();
7174  sync_positions ();
7175  }
7176 
7178  {
7179  set_activepositionproperty ("outerposition");
7180  caseless_str old_units = get_units ();
7181  set_units ("normalized");
7182  Matrix outerbox = outerposition.get ().matrix_value ();
7183  Matrix innerbox = position.get ().matrix_value ();
7184  Matrix linset = looseinset.get ().matrix_value ();
7185  Matrix tinset = tightinset.get ().matrix_value ();
7186  outerbox(2) = outerbox(2) + outerbox(0);
7187  outerbox(3) = outerbox(3) + outerbox(1);
7188  innerbox(0) = outerbox(0) + std::max (linset(0), tinset(0));
7189  innerbox(1) = outerbox(1) + std::max (linset(1), tinset(1));
7190  innerbox(2) = outerbox(2) - std::max (linset(2), tinset(2));
7191  innerbox(3) = outerbox(3) - std::max (linset(3), tinset(3));
7192  innerbox(2) = innerbox(2) - innerbox(0);
7193  innerbox(3) = innerbox(3) - innerbox(1);
7194  position = innerbox;
7195  set_units (old_units);
7196  update_transform ();
7197  }
7198 
7199  void update_position (void)
7200  {
7201  set_activepositionproperty ("position");
7202  caseless_str old_units = get_units ();
7203  set_units ("normalized");
7204  Matrix outerbox = outerposition.get ().matrix_value ();
7205  Matrix innerbox = position.get ().matrix_value ();
7206  Matrix linset = looseinset.get ().matrix_value ();
7207  Matrix tinset = tightinset.get ().matrix_value ();
7208  innerbox(2) = innerbox(2) + innerbox(0);
7209  innerbox(3) = innerbox(3) + innerbox(1);
7210  outerbox(0) = innerbox(0) - std::max (linset(0), tinset(0));
7211  outerbox(1) = innerbox(1) - std::max (linset(1), tinset(1));
7212  outerbox(2) = innerbox(2) + std::max (linset(2), tinset(2));
7213  outerbox(3) = innerbox(3) + std::max (linset(3), tinset(3));
7214  outerbox(2) = outerbox(2) - outerbox(0);
7215  outerbox(3) = outerbox(3) - outerbox(1);
7216  outerposition = outerbox;
7217  set_units (old_units);
7218  update_transform ();
7219  }
7220 
7221  void update_looseinset (void)
7222  {
7223  caseless_str old_units = get_units ();
7224  set_units ("normalized");
7225  Matrix innerbox = position.get ().matrix_value ();
7226  innerbox(2) = innerbox(2) + innerbox(0);
7227  innerbox(3) = innerbox(3) + innerbox(1);
7228  Matrix outerbox = outerposition.get ().matrix_value ();
7229  outerbox(2) = outerbox(2) + outerbox(0);
7230  outerbox(3) = outerbox(3) + outerbox(1);
7231  Matrix linset = looseinset.get ().matrix_value ();
7232  Matrix tinset = tightinset.get ().matrix_value ();
7233  if (activepositionproperty.is ("position"))
7234  {
7235  outerbox(0) = innerbox(0) - std::max (linset(0), tinset(0));
7236  outerbox(1) = innerbox(1) - std::max (linset(1), tinset(1));
7237  outerbox(2) = innerbox(2) + std::max (linset(2), tinset(2));
7238  outerbox(3) = innerbox(3) + std::max (linset(3), tinset(3));
7239  outerbox(2) = outerbox(2) - outerbox(0);
7240  outerbox(3) = outerbox(3) - outerbox(1);
7241  outerposition = outerbox;
7242  }
7243  else
7244  {
7245  innerbox(0) = outerbox(0) + std::max (linset(0), tinset(0));
7246  innerbox(1) = outerbox(1) + std::max (linset(1), tinset(1));
7247  innerbox(2) = outerbox(2) - std::max (linset(2), tinset(2));
7248  innerbox(3) = outerbox(3) - std::max (linset(3), tinset(3));
7249  innerbox(2) = innerbox(2) - innerbox(0);
7250  innerbox(3) = innerbox(3) - innerbox(1);
7251  position = innerbox;
7252  }
7253  set_units (old_units);
7254  update_transform ();
7255  }
7256 
7257  double calc_tick_sep (double minval, double maxval);
7258  void calc_ticks_and_lims (array_property& lims, array_property& ticks,
7259  array_property& mticks,
7260  bool limmode_is_auto, bool is_logscale);
7261  void calc_ticklabels (const array_property& ticks, any_property& labels,
7262  bool is_logscale);
7263  Matrix get_ticklabel_extents (const Matrix& ticks,
7264  const string_vector& ticklabels,
7265  const Matrix& limits);
7266 
7268  {
7269  if (lims.get ().is_empty ())
7270  return;
7271 
7272  Matrix l = lims.get ().matrix_value ();
7273  if (l(0) > l(1))
7274  {
7275  l(0) = 0;
7276  l(1) = 1;
7277  lims = l;
7278  }
7279  else if (l(0) == l(1))
7280  {
7281  l(0) -= 0.5;
7282  l(1) += 0.5;
7283  lims = l;
7284  }
7285  }
7286 
7287  Matrix calc_tightbox (const Matrix& init_pos);
7288 
7289  public:
7290  Matrix get_axis_limits (double xmin, double xmax,
7291  double min_pos, double max_neg,
7292  bool logscale);
7293 
7294  void update_xlim ()
7295  {
7296  if (xtickmode.is ("auto"))
7297  calc_ticks_and_lims (xlim, xtick, xmtick, xlimmode.is ("auto"),
7298  xscale.is ("log"));
7299  if (xticklabelmode.is ("auto"))
7300  calc_ticklabels (xtick, xticklabel, xscale.is ("log"));
7301 
7302  fix_limits (xlim);
7303 
7304  update_xscale ();
7305 
7306  update_axes_layout ();
7307  }
7308 
7309  void update_ylim (void)
7310  {
7311  if (ytickmode.is ("auto"))
7312  calc_ticks_and_lims (ylim, ytick, ymtick, ylimmode.is ("auto"),
7313  yscale.is ("log"));
7314  if (yticklabelmode.is ("auto"))
7315  calc_ticklabels (ytick, yticklabel, yscale.is ("log"));
7316 
7317  fix_limits (ylim);
7318 
7319  update_yscale ();
7320 
7321  update_axes_layout ();
7322  }
7323 
7324  void update_zlim (void)
7325  {
7326  if (ztickmode.is ("auto"))
7327  calc_ticks_and_lims (zlim, ztick, zmtick, zlimmode.is ("auto"),
7328  zscale.is ("log"));
7329  if (zticklabelmode.is ("auto"))
7330  calc_ticklabels (ztick, zticklabel, zscale.is ("log"));
7331 
7332  fix_limits (zlim);
7333 
7334  update_zscale ();
7335 
7336  update_axes_layout ();
7337  }
7338 
7339  };
7340 
7341 private:
7343 
7344 public:
7346  : base_graphics_object (), xproperties (mh, p), default_properties ()
7347  {
7348  xproperties.update_transform ();
7349  }
7350 
7351  ~axes (void) { }
7352 
7354  {
7355  // Allow parent (figure) to override first (properties knows how
7356  // to find the parent object).
7357  xproperties.override_defaults (obj);
7358 
7359  // Now override with our defaults. If the default_properties
7360  // list includes the properties for all defaults (line,
7361  // surface, etc.) then we don't have to know the type of OBJ
7362  // here, we just call its set function and let it decide which
7363  // properties from the list to use.
7364  obj.set_from_list (default_properties);
7365  }
7366 
7367  void set (const caseless_str& name, const octave_value& value)
7368  {
7369  if (name.compare ("default", 7))
7370  // strip "default", pass rest to function that will
7371  // parse the remainder and add the element to the
7372  // default_properties map.
7373  default_properties.set (name.substr (7), value);
7374  else
7375  xproperties.set (name, value);
7376  }
7377 
7378  void set_defaults (const std::string& mode)
7379  {
7380  xproperties.set_defaults (*this, mode);
7381  }
7382 
7383  octave_value get (const caseless_str& name) const
7384  {
7386 
7387  // FIXME: finish this.
7388  if (name.compare ("default", 7))
7389  retval = get_default (name.substr (7));
7390  else
7391  retval = xproperties.get (name);
7392 
7393  return retval;
7394  }
7395 
7396  octave_value get_default (const caseless_str& name) const;
7397 
7399  {
7400  return default_properties.as_struct ("default");
7401  }
7402 
7404  {
7405  return default_properties;
7406  }
7407 
7408  base_properties& get_properties (void) { return xproperties; }
7409 
7410  const base_properties& get_properties (void) const { return xproperties; }
7411 
7412  void update_axis_limits (const std::string& axis_type);
7413 
7414  void update_axis_limits (const std::string& axis_type,
7415  const graphics_handle& h);
7416 
7417  bool valid_object (void) const { return true; }
7418 
7419  void reset_default_properties (void);
7420 
7422  {
7423  bool retval = xproperties.has_readonly_property (pname);
7424  if (! retval)
7425  retval = base_properties::has_readonly_property (pname);
7426  return retval;
7427  }
7428 
7429 protected:
7430  void initialize (const graphics_object& go);
7431 
7432 private:
7434 };
7435 
7436 // ---------------------------------------------------------------------
7437 
7439 {
7440 public:
7442  {
7443  public:
7444  // See the genprops.awk script for an explanation of the
7445  // properties declarations.
7446  // Programming note: Keep property list sorted if new ones are added.
7447 
7448 public:
7449  properties (const graphics_handle& mh, const graphics_handle& p);
7450 
7451  ~properties (void) { }
7452 
7453  void set (const caseless_str& pname, const octave_value& val);
7454 
7455  octave_value get (bool all = false) const;
7456 
7457  octave_value get (const caseless_str& pname) const;
7458 
7459  octave_value get (const std::string& pname) const
7460  {
7461  return get (caseless_str (pname));
7462  }
7463 
7464  octave_value get (const char *pname) const
7465  {
7466  return get (caseless_str (pname));
7467  }
7468 
7469  property get_property (const caseless_str& pname);
7470 
7471  std::string graphics_object_name (void) const { return go_name; }
7472 
7474 
7475 private:
7477 
7478 public:
7479 
7480 
7481  static std::set<std::string> core_property_names (void);
7482 
7483  static std::set<std::string> readonly_property_names (void);
7484 
7485  static bool has_core_property (const caseless_str& pname);
7486 
7487  static bool has_readonly_property (const caseless_str& pname);
7488 
7489  std::set<std::string> all_property_names (void) const;
7490 
7491  bool has_property (const caseless_str& pname) const;
7492 
7493 private:
7494 
7517 
7518 public:
7519 
7520  enum
7521  {
7522  ID_COLOR = 4000,
7523  ID_DISPLAYNAME = 4001,
7524  ID_ERASEMODE = 4002,
7525  ID_INTERPRETER = 4003,
7526  ID_LINESTYLE = 4004,
7527  ID_LINEWIDTH = 4005,
7528  ID_MARKER = 4006,
7529  ID_MARKEREDGECOLOR = 4007,
7530  ID_MARKERFACECOLOR = 4008,
7531  ID_MARKERSIZE = 4009,
7532  ID_XDATA = 4010,
7533  ID_XDATASOURCE = 4011,
7534  ID_YDATA = 4012,
7535  ID_YDATASOURCE = 4013,
7536  ID_ZDATA = 4014,
7537  ID_ZDATASOURCE = 4015,
7538  ID_XLIM = 4016,
7539  ID_YLIM = 4017,
7540  ID_ZLIM = 4018,
7541  ID_XLIMINCLUDE = 4019,
7542  ID_YLIMINCLUDE = 4020,
7543  ID_ZLIMINCLUDE = 4021
7544  };
7545 
7546  bool color_is_rgb (void) const { return color.is_rgb (); }
7547  bool color_is (const std::string& v) const { return color.is (v); }
7548  Matrix get_color_rgb (void) const { return (color.is_rgb () ? color.rgb () : Matrix ()); }
7549  octave_value get_color (void) const { return color.get (); }
7550 
7551  std::string get_displayname (void) const { return displayname.string_value (); }
7552 
7553  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
7554  std::string get_erasemode (void) const { return erasemode.current_value (); }
7555 
7556  bool interpreter_is (const std::string& v) const { return interpreter.is (v); }
7557  std::string get_interpreter (void) const { return interpreter.current_value (); }
7558 
7559  bool linestyle_is (const std::string& v) const { return linestyle.is (v); }
7560  std::string get_linestyle (void) const { return linestyle.current_value (); }
7561 
7562  double get_linewidth (void) const { return linewidth.double_value (); }
7563 
7564  bool marker_is (const std::string& v) const { return marker.is (v); }
7565  std::string get_marker (void) const { return marker.current_value (); }
7566 
7567  bool markeredgecolor_is_rgb (void) const { return markeredgecolor.is_rgb (); }
7568  bool markeredgecolor_is (const std::string& v) const { return markeredgecolor.is (v); }
7569  Matrix get_markeredgecolor_rgb (void) const { return (markeredgecolor.is_rgb () ? markeredgecolor.rgb () : Matrix ()); }
7570  octave_value get_markeredgecolor (void) const { return markeredgecolor.get (); }
7571 
7572  bool markerfacecolor_is_rgb (void) const { return markerfacecolor.is_rgb (); }
7573  bool markerfacecolor_is (const std::string& v) const { return markerfacecolor.is (v); }
7574  Matrix get_markerfacecolor_rgb (void) const { return (markerfacecolor.is_rgb () ? markerfacecolor.rgb () : Matrix ()); }
7575  octave_value get_markerfacecolor (void) const { return markerfacecolor.get (); }
7576 
7577  double get_markersize (void) const { return markersize.double_value (); }
7578 
7579  octave_value get_xdata (void) const { return xdata.get (); }
7580 
7581  std::string get_xdatasource (void) const { return xdatasource.string_value (); }
7582 
7583  octave_value get_ydata (void) const { return ydata.get (); }
7584 
7585  std::string get_ydatasource (void) const { return ydatasource.string_value (); }
7586 
7587  octave_value get_zdata (void) const { return zdata.get (); }
7588 
7589  std::string get_zdatasource (void) const { return zdatasource.string_value (); }
7590 
7591  octave_value get_xlim (void) const { return xlim.get (); }
7592 
7593  octave_value get_ylim (void) const { return ylim.get (); }
7594 
7595  octave_value get_zlim (void) const { return zlim.get (); }
7596 
7597  bool is_xliminclude (void) const { return xliminclude.is_on (); }
7598  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
7599 
7600  bool is_yliminclude (void) const { return yliminclude.is_on (); }
7601  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
7602 
7603  bool is_zliminclude (void) const { return zliminclude.is_on (); }
7604  std::string get_zliminclude (void) const { return zliminclude.current_value (); }
7605 
7606 
7608  {
7609  {
7610  if (color.set (val, true))
7611  {
7612  mark_modified ();
7613  }
7614  }
7615  }
7616 
7618  {
7619  {
7620  if (displayname.set (val, true))
7621  {
7622  mark_modified ();
7623  }
7624  }
7625  }
7626 
7628  {
7629  {
7630  if (erasemode.set (val, true))
7631  {
7632  mark_modified ();
7633  }
7634  }
7635  }
7636 
7638  {
7639  {
7640  if (interpreter.set (val, true))
7641  {
7642  mark_modified ();
7643  }
7644  }
7645  }
7646 
7648  {
7649  {
7650  if (linestyle.set (val, true))
7651  {
7652  mark_modified ();
7653  }
7654  }
7655  }
7656 
7658  {
7659  {
7660  if (linewidth.set (val, true))
7661  {
7662  mark_modified ();
7663  }
7664  }
7665  }
7666 
7668  {
7669  {
7670  if (marker.set (val, true))
7671  {
7672  mark_modified ();
7673  }
7674  }
7675  }
7676 
7678  {
7679  {
7680  if (markeredgecolor.set (val, true))
7681  {
7682  mark_modified ();
7683  }
7684  }
7685  }
7686 
7688  {
7689  {
7690  if (markerfacecolor.set (val, true))
7691  {
7692  mark_modified ();
7693  }
7694  }
7695  }
7696 
7698  {
7699  {
7700  if (markersize.set (val, true))
7701  {
7702  mark_modified ();
7703  }
7704  }
7705  }
7706 
7708  {
7709  {
7710  if (xdata.set (val, true))
7711  {
7712  update_xdata ();
7713  mark_modified ();
7714  }
7715  }
7716  }
7717 
7719  {
7720  {
7721  if (xdatasource.set (val, true))
7722  {
7723  mark_modified ();
7724  }
7725  }
7726  }
7727 
7729  {
7730  {
7731  if (ydata.set (val, true))
7732  {
7733  update_ydata ();
7734  mark_modified ();
7735  }
7736  }
7737  }
7738 
7740  {
7741  {
7742  if (ydatasource.set (val, true))
7743  {
7744  mark_modified ();
7745  }
7746  }
7747  }
7748 
7750  {
7751  {
7752  if (zdata.set (val, true))
7753  {
7754  update_zdata ();
7755  mark_modified ();
7756  }
7757  }
7758  }
7759 
7761  {
7762  {
7763  if (zdatasource.set (val, true))
7764  {
7765  mark_modified ();
7766  }
7767  }
7768  }
7769 
7770  void set_xlim (const octave_value& val)
7771  {
7772  {
7773  if (xlim.set (val, false))
7774  {
7775  update_axis_limits ("xlim");
7776  xlim.run_listeners (POSTSET);
7777  mark_modified ();
7778  }
7779  }
7780  }
7781 
7782  void set_ylim (const octave_value& val)
7783  {
7784  {
7785  if (ylim.set (val, false))
7786  {
7787  update_axis_limits ("ylim");
7788  ylim.run_listeners (POSTSET);
7789  mark_modified ();
7790  }
7791  }
7792  }
7793 
7794  void set_zlim (const octave_value& val)
7795  {
7796  {
7797  if (zlim.set (val, false))
7798  {
7799  update_axis_limits ("zlim");
7800  zlim.run_listeners (POSTSET);
7801  mark_modified ();
7802  }
7803  }
7804  }
7805 
7807  {
7808  {
7809  if (xliminclude.set (val, false))
7810  {
7811  update_axis_limits ("xliminclude");
7812  xliminclude.run_listeners (POSTSET);
7813  mark_modified ();
7814  }
7815  }
7816  }
7817 
7819  {
7820  {
7821  if (yliminclude.set (val, false))
7822  {
7823  update_axis_limits ("yliminclude");
7824  yliminclude.run_listeners (POSTSET);
7825  mark_modified ();
7826  }
7827  }
7828  }
7829 
7831  {
7832  {
7833  if (zliminclude.set (val, false))
7834  {
7835  update_axis_limits ("zliminclude");
7836  zliminclude.run_listeners (POSTSET);
7837  mark_modified ();
7838  }
7839  }
7840  }
7841 
7842 
7843  private:
7844  Matrix compute_xlim (void) const;
7845  Matrix compute_ylim (void) const;
7846 
7847  void update_xdata (void) { set_xlim (compute_xlim ()); }
7848 
7849  void update_ydata (void) { set_ylim (compute_ylim ()); }
7850 
7851  void update_zdata (void)
7852  {
7853  set_zlim (zdata.get_limits ());
7854  set_zliminclude (get_zdata ().numel () > 0);
7855  }
7856  };
7857 
7858 private:
7860 
7861 public:
7863  : base_graphics_object (), xproperties (mh, p)
7864  { }
7865 
7866  ~line (void) { }
7867 
7868  base_properties& get_properties (void) { return xproperties; }
7869 
7870  const base_properties& get_properties (void) const { return xproperties; }
7871 
7872  bool valid_object (void) const { return true; }
7873 
7875  {
7876  bool retval = xproperties.has_readonly_property (pname);
7877  if (! retval)
7878  retval = base_properties::has_readonly_property (pname);
7879  return retval;
7880  }
7881 };
7882 
7883 // ---------------------------------------------------------------------
7884 
7886 {
7887 public:
7889  {
7890  public:
7891  double get_fontsize_points (double box_pix_height = 0) const;
7892 
7894  {
7895  octave_value new_val (val);
7896 
7897  if (new_val.numel () == 2)
7898  {
7899  dim_vector dv (1, 3);
7900 
7901  new_val = new_val.resize (dv, true);
7902  }
7903 
7904  if (position.set (new_val, false))
7905  {
7906  set_positionmode ("manual");
7907  update_position ();
7908  position.run_listeners (POSTSET);
7909  mark_modified ();
7910  }
7911  else
7912  set_positionmode ("manual");
7913  }
7914 
7915  // See the genprops.awk script for an explanation of the
7916  // properties declarations.
7917 
7918 public:
7919  properties (const graphics_handle& mh, const graphics_handle& p);
7920 
7921  ~properties (void) { }
7922 
7923  void set (const caseless_str& pname, const octave_value& val);
7924 
7925  octave_value get (bool all = false) const;
7926 
7927  octave_value get (const caseless_str& pname) const;
7928 
7929  octave_value get (const std::string& pname) const
7930  {
7931  return get (caseless_str (pname));
7932  }
7933 
7934  octave_value get (const char *pname) const
7935  {
7936  return get (caseless_str (pname));
7937  }
7938 
7939  property get_property (const caseless_str& pname);
7940 
7941  std::string graphics_object_name (void) const { return go_name; }
7942 
7944 
7945 private:
7947 
7948 public:
7949 
7950 
7951  static std::set<std::string> core_property_names (void);
7952 
7953  static std::set<std::string> readonly_property_names (void);
7954 
7955  static bool has_core_property (const caseless_str& pname);
7956 
7957  static bool has_readonly_property (const caseless_str& pname);
7958 
7959  std::set<std::string> all_property_names (void) const;
7960 
7961  bool has_property (const caseless_str& pname) const;
7962 
7963 private:
7964 
7999 
8000 public:
8001 
8002  enum
8003  {
8004  ID_BACKGROUNDCOLOR = 5000,
8005  ID_COLOR = 5001,
8006  ID_DISPLAYNAME = 5002,
8007  ID_EDGECOLOR = 5003,
8008  ID_EDITING = 5004,
8009  ID_ERASEMODE = 5005,
8010  ID_EXTENT = 5006,
8011  ID_FONTANGLE = 5007,
8012  ID_FONTNAME = 5008,
8013  ID_FONTSIZE = 5009,
8014  ID_FONTUNITS = 5010,
8015  ID_FONTWEIGHT = 5011,
8016  ID_HORIZONTALALIGNMENT = 5012,
8017  ID_INTERPRETER = 5013,
8018  ID_LINESTYLE = 5014,
8019  ID_LINEWIDTH = 5015,
8020  ID_MARGIN = 5016,
8021  ID_POSITION = 5017,
8022  ID_ROTATION = 5018,
8023  ID_STRING = 5019,
8024  ID_UNITS = 5020,
8025  ID_VERTICALALIGNMENT = 5021,
8026  ID_XLIM = 5022,
8027  ID_YLIM = 5023,
8028  ID_ZLIM = 5024,
8029  ID_XLIMINCLUDE = 5025,
8030  ID_YLIMINCLUDE = 5026,
8031  ID_ZLIMINCLUDE = 5027,
8032  ID_POSITIONMODE = 5028,
8033  ID_ROTATIONMODE = 5029,
8034  ID_HORIZONTALALIGNMENTMODE = 5030,
8035  ID_VERTICALALIGNMENTMODE = 5031,
8036  ID_AUTOPOS_TAG = 5032,
8037  ID_FONTSIZE_POINTS = 5033
8038  };
8039 
8040  bool backgroundcolor_is_rgb (void) const { return backgroundcolor.is_rgb (); }
8041  bool backgroundcolor_is (const std::string& v) const { return backgroundcolor.is (v); }
8042  Matrix get_backgroundcolor_rgb (void) const { return (backgroundcolor.is_rgb () ? backgroundcolor.rgb () : Matrix ()); }
8043  octave_value get_backgroundcolor (void) const { return backgroundcolor.get (); }
8044 
8045  bool color_is_rgb (void) const { return color.is_rgb (); }
8046  bool color_is (const std::string& v) const { return color.is (v); }
8047  Matrix get_color_rgb (void) const { return (color.is_rgb () ? color.rgb () : Matrix ()); }
8048  octave_value get_color (void) const { return color.get (); }
8049 
8050  std::string get_displayname (void) const { return displayname.string_value (); }
8051 
8052  bool edgecolor_is_rgb (void) const { return edgecolor.is_rgb (); }
8053  bool edgecolor_is (const std::string& v) const { return edgecolor.is (v); }
8054  Matrix get_edgecolor_rgb (void) const { return (edgecolor.is_rgb () ? edgecolor.rgb () : Matrix ()); }
8055  octave_value get_edgecolor (void) const { return edgecolor.get (); }
8056 
8057  bool is_editing (void) const { return editing.is_on (); }
8058  std::string get_editing (void) const { return editing.current_value (); }
8059 
8060  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
8061  std::string get_erasemode (void) const { return erasemode.current_value (); }
8062 
8063  octave_value get_extent (void) const;
8064 
8065  bool fontangle_is (const std::string& v) const { return fontangle.is (v); }
8066  std::string get_fontangle (void) const { return fontangle.current_value (); }
8067 
8068  std::string get_fontname (void) const { return fontname.string_value (); }
8069 
8070  double get_fontsize (void) const { return fontsize.double_value (); }
8071 
8072  bool fontunits_is (const std::string& v) const { return fontunits.is (v); }
8073  std::string get_fontunits (void) const { return fontunits.current_value (); }
8074 
8075  bool fontweight_is (const std::string& v) const { return fontweight.is (v); }
8076  std::string get_fontweight (void) const { return fontweight.current_value (); }
8077 
8078  bool horizontalalignment_is (const std::string& v) const { return horizontalalignment.is (v); }
8079  std::string get_horizontalalignment (void) const { return horizontalalignment.current_value (); }
8080 
8081  bool interpreter_is (const std::string& v) const { return interpreter.is (v); }
8082  std::string get_interpreter (void) const { return interpreter.current_value (); }
8083 
8084  bool linestyle_is (const std::string& v) const { return linestyle.is (v); }
8085  std::string get_linestyle (void) const { return linestyle.current_value (); }
8086 
8087  double get_linewidth (void) const { return linewidth.double_value (); }
8088 
8089  double get_margin (void) const { return margin.double_value (); }
8090 
8091  octave_value get_position (void) const { return position.get (); }
8092 
8093  double get_rotation (void) const { return rotation.double_value (); }
8094 
8095  octave_value get_string (void) const { return string.get (); }
8096 
8097  bool units_is (const std::string& v) const { return units.is (v); }
8098  std::string get_units (void) const { return units.current_value (); }
8099 
8100  bool verticalalignment_is (const std::string& v) const { return verticalalignment.is (v); }
8101  std::string get_verticalalignment (void) const { return verticalalignment.current_value (); }
8102 
8103  octave_value get_xlim (void) const { return xlim.get (); }
8104 
8105  octave_value get_ylim (void) const { return ylim.get (); }
8106 
8107  octave_value get_zlim (void) const { return zlim.get (); }
8108 
8109  bool is_xliminclude (void) const { return xliminclude.is_on (); }
8110  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
8111 
8112  bool is_yliminclude (void) const { return yliminclude.is_on (); }
8113  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
8114 
8115  bool is_zliminclude (void) const { return zliminclude.is_on (); }
8116  std::string get_zliminclude (void) const { return zliminclude.current_value (); }
8117 
8118  bool positionmode_is (const std::string& v) const { return positionmode.is (v); }
8119  std::string get_positionmode (void) const { return positionmode.current_value (); }
8120 
8121  bool rotationmode_is (const std::string& v) const { return rotationmode.is (v); }
8122  std::string get_rotationmode (void) const { return rotationmode.current_value (); }
8123 
8124  bool horizontalalignmentmode_is (const std::string& v) const { return horizontalalignmentmode.is (v); }
8125  std::string get_horizontalalignmentmode (void) const { return horizontalalignmentmode.current_value (); }
8126 
8127  bool verticalalignmentmode_is (const std::string& v) const { return verticalalignmentmode.is (v); }
8128  std::string get_verticalalignmentmode (void) const { return verticalalignmentmode.current_value (); }
8129 
8130  bool autopos_tag_is (const std::string& v) const { return autopos_tag.is (v); }
8131  std::string get_autopos_tag (void) const { return autopos_tag.current_value (); }
8132 
8133 
8135  {
8136  {
8137  if (backgroundcolor.set (val, true))
8138  {
8139  mark_modified ();
8140  }
8141  }
8142  }
8143 
8145  {
8146  {
8147  if (color.set (val, true))
8148  {
8149  update_color ();
8150  mark_modified ();
8151  }
8152  }
8153  }
8154 
8156  {
8157  {
8158  if (displayname.set (val, true))
8159  {
8160  mark_modified ();
8161  }
8162  }
8163  }
8164 
8166  {
8167  {
8168  if (edgecolor.set (val, true))
8169  {
8170  mark_modified ();
8171  }
8172  }
8173  }
8174 
8176  {
8177  {
8178  if (editing.set (val, true))
8179  {
8180  mark_modified ();
8181  }
8182  }
8183  }
8184 
8186  {
8187  {
8188  if (erasemode.set (val, true))
8189  {
8190  mark_modified ();
8191  }
8192  }
8193  }
8194 
8196  {
8197  {
8198  if (extent.set (val, true))
8199  {
8200  mark_modified ();
8201  }
8202  }
8203  }
8204 
8206  {
8207  {
8208  if (fontangle.set (val, true))
8209  {
8210  update_fontangle ();
8211  mark_modified ();
8212  }
8213  }
8214  }
8215 
8217  {
8218  {
8219  if (fontname.set (val, true))
8220  {
8221  update_fontname ();
8222  mark_modified ();
8223  }
8224  }
8225  }
8226 
8228  {
8229  {
8230  if (fontsize.set (val, true))
8231  {
8232  update_fontsize ();
8233  mark_modified ();
8234  }
8235  }
8236  }
8237 
8238  void set_fontunits (const octave_value& val);
8239 
8240  void update_fontunits (void);
8241 
8243  {
8244  {
8245  if (fontweight.set (val, true))
8246  {
8247  update_fontweight ();
8248  mark_modified ();
8249  }
8250  }
8251  }
8252 
8254  {
8255  {
8256  if (horizontalalignment.set (val, false))
8257  {
8258  set_horizontalalignmentmode ("manual");
8259  update_horizontalalignment ();
8260  horizontalalignment.run_listeners (POSTSET);
8261  mark_modified ();
8262  }
8263  else
8264  set_horizontalalignmentmode ("manual");
8265  }
8266  }
8267 
8269  {
8270  {
8271  if (interpreter.set (val, true))
8272  {
8273  update_interpreter ();
8274  mark_modified ();
8275  }
8276  }
8277  }
8278 
8280  {
8281  {
8282  if (linestyle.set (val, true))
8283  {
8284  mark_modified ();
8285  }
8286  }
8287  }
8288 
8290  {
8291  {
8292  if (linewidth.set (val, true))
8293  {
8294  mark_modified ();
8295  }
8296  }
8297  }
8298 
8300  {
8301  {
8302  if (margin.set (val, true))
8303  {
8304  mark_modified ();
8305  }
8306  }
8307  }
8308 
8310  {
8311  {
8312  if (rotation.set (val, false))
8313  {
8314  set_rotationmode ("manual");
8315  update_rotation ();
8316  rotation.run_listeners (POSTSET);
8317  mark_modified ();
8318  }
8319  else
8320  set_rotationmode ("manual");
8321  }
8322  }
8323 
8325  {
8326  {
8327  if (string.set (val, true))
8328  {
8329  update_string ();
8330  mark_modified ();
8331  }
8332  }
8333  }
8334 
8336  {
8337  {
8338  if (units.set (val, true))
8339  {
8340  update_units ();
8341  mark_modified ();
8342  }
8343  }
8344  }
8345 
8347  {
8348  {
8349  if (verticalalignment.set (val, false))
8350  {
8351  set_verticalalignmentmode ("manual");
8352  update_verticalalignment ();
8353  verticalalignment.run_listeners (POSTSET);
8354  mark_modified ();
8355  }
8356  else
8357  set_verticalalignmentmode ("manual");
8358  }
8359  }
8360 
8361  void set_xlim (const octave_value& val)
8362  {
8363  {
8364  if (xlim.set (val, false))
8365  {
8366  update_axis_limits ("xlim");
8367  xlim.run_listeners (POSTSET);
8368  mark_modified ();
8369  }
8370  }
8371  }
8372 
8373  void set_ylim (const octave_value& val)
8374  {
8375  {
8376  if (ylim.set (val, false))
8377  {
8378  update_axis_limits ("ylim");
8379  ylim.run_listeners (POSTSET);
8380  mark_modified ();
8381  }
8382  }
8383  }
8384 
8385  void set_zlim (const octave_value& val)
8386  {
8387  {
8388  if (zlim.set (val, false))
8389  {
8390  update_axis_limits ("zlim");
8391  zlim.run_listeners (POSTSET);
8392  mark_modified ();
8393  }
8394  }
8395  }
8396 
8398  {
8399  {
8400  if (xliminclude.set (val, false))
8401  {
8402  update_axis_limits ("xliminclude");
8403  xliminclude.run_listeners (POSTSET);
8404  mark_modified ();
8405  }
8406  }
8407  }
8408 
8410  {
8411  {
8412  if (yliminclude.set (val, false))
8413  {
8414  update_axis_limits ("yliminclude");
8415  yliminclude.run_listeners (POSTSET);
8416  mark_modified ();
8417  }
8418  }
8419  }
8420 
8422  {
8423  {
8424  if (zliminclude.set (val, false))
8425  {
8426  update_axis_limits ("zliminclude");
8427  zliminclude.run_listeners (POSTSET);
8428  mark_modified ();
8429  }
8430  }
8431  }
8432 
8434  {
8435  {
8436  if (positionmode.set (val, true))
8437  {
8438  update_positionmode ();
8439  mark_modified ();
8440  }
8441  }
8442  }
8443 
8445  {
8446  {
8447  if (rotationmode.set (val, true))
8448  {
8449  update_rotationmode ();
8450  mark_modified ();
8451  }
8452  }
8453  }
8454 
8456  {
8457  {
8458  if (horizontalalignmentmode.set (val, true))
8459  {
8460  update_horizontalalignmentmode ();
8461  mark_modified ();
8462  }
8463  }
8464  }
8465 
8467  {
8468  {
8469  if (verticalalignmentmode.set (val, true))
8470  {
8471  update_verticalalignmentmode ();
8472  mark_modified ();
8473  }
8474  }
8475  }
8476 
8478  {
8479  {
8480  if (autopos_tag.set (val, true))
8481  {
8482  mark_modified ();
8483  }
8484  }
8485  }
8486 
8488  {
8489  {
8490  if (fontsize_points.set (val, true))
8491  {
8492  mark_modified ();
8493  }
8494  }
8495  }
8496 
8497 
8498  Matrix get_data_position (void) const;
8499  Matrix get_extent_matrix (void) const;
8500  const uint8NDArray& get_pixels (void) const { return pixels; }
8501 
8502  // Text renderer, used for calculation of text size
8504 
8505  protected:
8506  void init (void)
8507  {
8508  position.add_constraint (dim_vector (1, 3));
8509  cached_units = get_units ();
8510  update_font ();
8511  }
8512 
8513  private:
8514  void update_position (void)
8515  {
8516  Matrix pos = get_data_position ();
8517  Matrix lim;
8518 
8519  lim = Matrix (1, 3, pos(0));
8520  lim(2) = (lim(2) <= 0 ? octave::numeric_limits<double>::Inf () : lim(2));
8521  set_xlim (lim);
8522 
8523  lim = Matrix (1, 3, pos(1));
8524  lim(2) = (lim(2) <= 0 ? octave::numeric_limits<double>::Inf () : lim(2));
8525  set_ylim (lim);
8526 
8527  if (pos.numel () == 3)
8528  {
8529  lim = Matrix (1, 3, pos(2));
8530  lim(2) = (lim(2) <= 0 ? octave::numeric_limits<double>::Inf () : lim(2));
8531  set_zliminclude ("on");
8532  set_zlim (lim);
8533  }
8534  else
8535  set_zliminclude ("off");
8536  }
8537 
8538  void update_text_extent (void);
8539 
8540  void request_autopos (void);
8541  void update_positionmode (void) { request_autopos (); }
8542  void update_rotationmode (void) { request_autopos (); }
8543  void update_horizontalalignmentmode (void) { request_autopos (); }
8544  void update_verticalalignmentmode (void) { request_autopos (); }
8545 
8546  void update_font (void);
8547  void update_string (void) { request_autopos (); update_text_extent (); }
8548  void update_rotation (void) { update_text_extent (); }
8549  void update_color (void) { update_font (); update_text_extent (); }
8550  void update_fontname (void) { update_font (); update_text_extent (); }
8551  void update_fontsize (void) { update_font (); update_text_extent (); }
8552  void update_fontangle (void) { update_font (); update_text_extent (); }
8553  void update_fontweight (void) { update_font (); update_text_extent (); }
8554  void update_interpreter (void) { update_text_extent (); }
8555  void update_horizontalalignment (void) { update_text_extent (); }
8556  void update_verticalalignment (void) { update_text_extent (); }
8557 
8558  void update_units (void);
8559  void update_fontunits (const caseless_str& old_fontunits);
8560 
8561  private:
8564  };
8565 
8566 private:
8568 
8569 public:
8571  : base_graphics_object (), xproperties (mh, p)
8572  {
8573  xproperties.set_clipping ("off");
8574  }
8575 
8576  ~text (void) { }
8577 
8578  base_properties& get_properties (void) { return xproperties; }
8579 
8580  const base_properties& get_properties (void) const { return xproperties; }
8581 
8582  bool valid_object (void) const { return true; }
8583 
8585  {
8586  bool retval = xproperties.has_readonly_property (pname);
8587  if (! retval)
8588  retval = base_properties::has_readonly_property (pname);
8589  return retval;
8590  }
8591 };
8592 
8593 // ---------------------------------------------------------------------
8594 
8596 {
8597 public:
8599  {
8600  public:
8601  bool is_aliminclude (void) const
8602  { return (aliminclude.is_on () && alphadatamapping.is ("scaled")); }
8604  { return aliminclude.current_value (); }
8605 
8606  bool is_climinclude (void) const
8607  { return (climinclude.is_on () && cdatamapping.is ("scaled")); }
8609  { return climinclude.current_value (); }
8610 
8611  octave_value get_color_data (void) const;
8612 
8613  void initialize_data (void) { update_cdata (); }
8614 
8615  // See the genprops.awk script for an explanation of the
8616  // properties declarations.
8617  // Programming note: Keep property list sorted if new ones are added.
8618 
8619 public:
8620  properties (const graphics_handle& mh, const graphics_handle& p);
8621 
8622  ~properties (void) { }
8623 
8624  void set (const caseless_str& pname, const octave_value& val);
8625 
8626  octave_value get (bool all = false) const;
8627 
8628  octave_value get (const caseless_str& pname) const;
8629 
8630  octave_value get (const std::string& pname) const
8631  {
8632  return get (caseless_str (pname));
8633  }
8634 
8635  octave_value get (const char *pname) const
8636  {
8637  return get (caseless_str (pname));
8638  }
8639 
8640  property get_property (const caseless_str& pname);
8641 
8642  std::string graphics_object_name (void) const { return go_name; }
8643 
8645 
8646 private:
8648 
8649 public:
8650 
8651 
8652  static std::set<std::string> core_property_names (void);
8653 
8654  static std::set<std::string> readonly_property_names (void);
8655 
8656  static bool has_core_property (const caseless_str& pname);
8657 
8658  static bool has_readonly_property (const caseless_str& pname);
8659 
8660  std::set<std::string> all_property_names (void) const;
8661 
8662  bool has_property (const caseless_str& pname) const;
8663 
8664 private:
8665 
8684 
8685 public:
8686 
8687  enum
8688  {
8689  ID_ALPHADATA = 6000,
8690  ID_ALPHADATAMAPPING = 6001,
8691  ID_CDATA = 6002,
8692  ID_CDATAMAPPING = 6003,
8693  ID_DISPLAYNAME = 6004,
8694  ID_ERASEMODE = 6005,
8695  ID_XDATA = 6006,
8696  ID_YDATA = 6007,
8697  ID_ALIM = 6008,
8698  ID_CLIM = 6009,
8699  ID_XLIM = 6010,
8700  ID_YLIM = 6011,
8701  ID_ALIMINCLUDE = 6012,
8702  ID_CLIMINCLUDE = 6013,
8703  ID_XLIMINCLUDE = 6014,
8704  ID_YLIMINCLUDE = 6015,
8705  ID_XDATAMODE = 6016,
8706  ID_YDATAMODE = 6017
8707  };
8708 
8709  octave_value get_alphadata (void) const { return alphadata.get (); }
8710 
8711  bool alphadatamapping_is (const std::string& v) const { return alphadatamapping.is (v); }
8712  std::string get_alphadatamapping (void) const { return alphadatamapping.current_value (); }
8713 
8714  octave_value get_cdata (void) const { return cdata.get (); }
8715 
8716  bool cdatamapping_is (const std::string& v) const { return cdatamapping.is (v); }
8717  std::string get_cdatamapping (void) const { return cdatamapping.current_value (); }
8718 
8719  std::string get_displayname (void) const { return displayname.string_value (); }
8720 
8721  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
8722  std::string get_erasemode (void) const { return erasemode.current_value (); }
8723 
8724  octave_value get_xdata (void) const { return xdata.get (); }
8725 
8726  octave_value get_ydata (void) const { return ydata.get (); }
8727 
8728  octave_value get_alim (void) const { return alim.get (); }
8729 
8730  octave_value get_clim (void) const { return clim.get (); }
8731 
8732  octave_value get_xlim (void) const { return xlim.get (); }
8733 
8734  octave_value get_ylim (void) const { return ylim.get (); }
8735 
8736  bool is_xliminclude (void) const { return xliminclude.is_on (); }
8737  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
8738 
8739  bool is_yliminclude (void) const { return yliminclude.is_on (); }
8740  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
8741 
8742  bool xdatamode_is (const std::string& v) const { return xdatamode.is (v); }
8743  std::string get_xdatamode (void) const { return xdatamode.current_value (); }
8744 
8745  bool ydatamode_is (const std::string& v) const { return ydatamode.is (v); }
8746  std::string get_ydatamode (void) const { return ydatamode.current_value (); }
8747 
8748 
8750  {
8751  {
8752  if (alphadata.set (val, true))
8753  {
8754  update_alphadata ();
8755  mark_modified ();
8756  }
8757  }
8758  }
8759 
8761  {
8762  {
8763  if (alphadatamapping.set (val, false))
8764  {
8765  update_axis_limits ("alphadatamapping");
8766  alphadatamapping.run_listeners (POSTSET);
8767  mark_modified ();
8768  }
8769  }
8770  }
8771 
8773  {
8774  {
8775  if (cdata.set (val, true))
8776  {
8777  update_cdata ();
8778  mark_modified ();
8779  }
8780  }
8781  }
8782 
8784  {
8785  {
8786  if (cdatamapping.set (val, false))
8787  {
8788  update_axis_limits ("cdatamapping");
8789  cdatamapping.run_listeners (POSTSET);
8790  mark_modified ();
8791  }
8792  }
8793  }
8794 
8796  {
8797  {
8798  if (displayname.set (val, true))
8799  {
8800  mark_modified ();
8801  }
8802  }
8803  }
8804 
8806  {
8807  {
8808  if (erasemode.set (val, true))
8809  {
8810  mark_modified ();
8811  }
8812  }
8813  }
8814 
8816  {
8817  {
8818  if (xdata.set (val, false))
8819  {
8820  set_xdatamode ("manual");
8821  update_xdata ();
8822  xdata.run_listeners (POSTSET);
8823  mark_modified ();
8824  }
8825  else
8826  set_xdatamode ("manual");
8827  }
8828  }
8829 
8831  {
8832  {
8833  if (ydata.set (val, false))
8834  {
8835  set_ydatamode ("manual");
8836  update_ydata ();
8837  ydata.run_listeners (POSTSET);
8838  mark_modified ();
8839  }
8840  else
8841  set_ydatamode ("manual");
8842  }
8843  }
8844 
8845  void set_alim (const octave_value& val)
8846  {
8847  {
8848  if (alim.set (val, false))
8849  {
8850  update_axis_limits ("alim");
8851  alim.run_listeners (POSTSET);
8852  mark_modified ();
8853  }
8854  }
8855  }
8856 
8857  void set_clim (const octave_value& val)
8858  {
8859  {
8860  if (clim.set (val, false))
8861  {
8862  update_axis_limits ("clim");
8863  clim.run_listeners (POSTSET);
8864  mark_modified ();
8865  }
8866  }
8867  }
8868 
8869  void set_xlim (const octave_value& val)
8870  {
8871  {
8872  if (xlim.set (val, false))
8873  {
8874  update_axis_limits ("xlim");
8875  xlim.run_listeners (POSTSET);
8876  mark_modified ();
8877  }
8878  }
8879  }
8880 
8881  void set_ylim (const octave_value& val)
8882  {
8883  {
8884  if (ylim.set (val, false))
8885  {
8886  update_axis_limits ("ylim");
8887  ylim.run_listeners (POSTSET);
8888  mark_modified ();
8889  }
8890  }
8891  }
8892 
8894  {
8895  {
8896  if (aliminclude.set (val, false))
8897  {
8898  update_axis_limits ("aliminclude");
8899  aliminclude.run_listeners (POSTSET);
8900  mark_modified ();
8901  }
8902  }
8903  }
8904 
8906  {
8907  {
8908  if (climinclude.set (val, false))
8909  {
8910  update_axis_limits ("climinclude");
8911  climinclude.run_listeners (POSTSET);
8912  mark_modified ();
8913  }
8914  }
8915  }
8916 
8918  {
8919  {
8920  if (xliminclude.set (val, false))
8921  {
8922  update_axis_limits ("xliminclude");
8923  xliminclude.run_listeners (POSTSET);
8924  mark_modified ();
8925  }
8926  }
8927  }
8928 
8930  {
8931  {
8932  if (yliminclude.set (val, false))
8933  {
8934  update_axis_limits ("yliminclude");
8935  yliminclude.run_listeners (POSTSET);
8936  mark_modified ();
8937  }
8938  }
8939  }
8940 
8942  {
8943  {
8944  if (xdatamode.set (val, true))
8945  {
8946  mark_modified ();
8947  }
8948  }
8949  }
8950 
8952  {
8953  {
8954  if (ydatamode.set (val, true))
8955  {
8956  mark_modified ();
8957  }
8958  }
8959  }
8960 
8961 
8962  protected:
8963  void init (void)
8964  {
8965  xdata.add_constraint (2);
8966  xdata.add_constraint (dim_vector (0, 0));
8967  ydata.add_constraint (2);
8968  ydata.add_constraint (dim_vector (0, 0));
8969  cdata.add_constraint ("double");
8970  cdata.add_constraint ("single");
8971  cdata.add_constraint ("logical");
8972  cdata.add_constraint ("uint8");
8973  cdata.add_constraint ("uint16");
8974  cdata.add_constraint ("int16");
8975  cdata.add_constraint ("real");
8976  cdata.add_constraint (dim_vector (-1, -1));
8977  cdata.add_constraint (dim_vector (-1, -1, 3));
8978  alphadata.add_constraint (dim_vector (-1, -1));
8979  alphadata.add_constraint ("double");
8980  alphadata.add_constraint ("uint8");
8981  }
8982 
8983  private:
8984  void update_alphadata (void)
8985  {
8986  if (alphadatamapping_is ("scaled"))
8987  set_alim (alphadata.get_limits ());
8988  else
8989  alim = alphadata.get_limits ();
8990  }
8991 
8992  void update_cdata (void)
8993  {
8994  if (cdatamapping_is ("scaled"))
8995  set_clim (cdata.get_limits ());
8996  else
8997  clim = cdata.get_limits ();
8998 
8999  if (xdatamode.is ("auto"))
9000  update_xdata ();
9001 
9002  if (ydatamode.is ("auto"))
9003  update_ydata ();
9004  }
9005 
9006  void update_xdata (void)
9007  {
9008  if (xdata.get ().is_empty ())
9009  set_xdatamode ("auto");
9010 
9011  if (xdatamode.is ("auto"))
9012  {
9013  set_xdata (get_auto_xdata ());
9014  set_xdatamode ("auto");
9015  }
9016 
9017  Matrix limits = xdata.get_limits ();
9018  float dp = pixel_xsize ();
9019 
9020  limits(0) = limits(0) - dp;
9021  limits(1) = limits(1) + dp;
9022  set_xlim (limits);
9023  }
9024 
9025  void update_ydata (void)
9026  {
9027  if (ydata.get ().is_empty ())
9028  set_ydatamode ("auto");
9029 
9030  if (ydatamode.is ("auto"))
9031  {
9032  set_ydata (get_auto_ydata ());
9033  set_ydatamode ("auto");
9034  }
9035 
9036  Matrix limits = ydata.get_limits ();
9037  float dp = pixel_ysize ();
9038 
9039  limits(0) = limits(0) - dp;
9040  limits(1) = limits(1) + dp;
9041  set_ylim (limits);
9042  }
9043 
9045  {
9046  dim_vector dv = get_cdata ().dims ();
9047  Matrix data;
9048  if (dv(1) > 0.)
9049  {
9050  data = Matrix (1, 2, 1);
9051  data(1) = dv(1);
9052  }
9053  return data;
9054  }
9055 
9057  {
9058  dim_vector dv = get_cdata ().dims ();
9059  Matrix data;
9060  if (dv(0) > 0.)
9061  {
9062  data = Matrix (1, 2, 1);
9063  data(1) = dv(0);
9064  }
9065  return data;
9066  }
9067 
9068  float pixel_size (octave_idx_type dim, const Matrix limits)
9069  {
9070  octave_idx_type l = dim - 1;
9071  float dp;
9072 
9073  if (l > 0 && limits(0) != limits(1))
9074  dp = (limits(1) - limits(0))/(2*l);
9075  else
9076  {
9077  if (limits(1) == limits(2))
9078  dp = 0.5;
9079  else
9080  dp = (limits(1) - limits(0))/2;
9081  }
9082  return dp;
9083  }
9084 
9085  public:
9086  float pixel_xsize (void)
9087  {
9088  return pixel_size ((get_cdata ().dims ())(1), xdata.get_limits ());
9089  }
9090 
9091  float pixel_ysize (void)
9092  {
9093  return pixel_size ((get_cdata ().dims ())(0), ydata.get_limits ());
9094  }
9095  };
9096 
9097 private:
9099 
9100 public:
9102  : base_graphics_object (), xproperties (mh, p)
9103  {
9104  xproperties.initialize_data ();
9105  }
9106 
9107  ~image (void) { }
9108 
9109  base_properties& get_properties (void) { return xproperties; }
9110 
9111  const base_properties& get_properties (void) const { return xproperties; }
9112 
9113  bool valid_object (void) const { return true; }
9114 
9116  {
9117  bool retval = xproperties.has_readonly_property (pname);
9118  if (! retval)
9119  retval = base_properties::has_readonly_property (pname);
9120  return retval;
9121  }
9122 };
9123 
9124 // ---------------------------------------------------------------------
9125 
9127 {
9128 public:
9130  {
9131  // See the genprops.awk script for an explanation of the
9132  // properties declarations.
9133  // Programming note: Keep property list sorted if new ones are added.
9134 
9135 public:
9136  properties (const graphics_handle& mh, const graphics_handle& p);
9137 
9138  ~properties (void) { }
9139 
9140  void set (const caseless_str& pname, const octave_value& val);
9141 
9142  octave_value get (bool all = false) const;
9143 
9144  octave_value get (const caseless_str& pname) const;
9145 
9146  octave_value get (const std::string& pname) const
9147  {
9148  return get (caseless_str (pname));
9149  }
9150 
9151  octave_value get (const char *pname) const
9152  {
9153  return get (caseless_str (pname));
9154  }
9155 
9156  property get_property (const caseless_str& pname);
9157 
9158  std::string graphics_object_name (void) const { return go_name; }
9159 
9161 
9162 private:
9164 
9165 public:
9166 
9167 
9168  static std::set<std::string> core_property_names (void);
9169 
9170  static std::set<std::string> readonly_property_names (void);
9171 
9172  static bool has_core_property (const caseless_str& pname);
9173 
9174  static bool has_readonly_property (const caseless_str& pname);
9175 
9176  std::set<std::string> all_property_names (void) const;
9177 
9178  bool has_property (const caseless_str& pname) const;
9179 
9180 private:
9181 
9185 
9186 public:
9187 
9188  enum
9189  {
9190  ID_COLOR = 7000,
9191  ID_POSITION = 7001,
9192  ID_STYLE = 7002
9193  };
9194 
9195  bool color_is_rgb (void) const { return color.is_rgb (); }
9196  bool color_is (const std::string& v) const { return color.is (v); }
9197  Matrix get_color_rgb (void) const { return (color.is_rgb () ? color.rgb () : Matrix ()); }
9198  octave_value get_color (void) const { return color.get (); }
9199 
9200  octave_value get_position (void) const { return position.get (); }
9201 
9202  bool style_is (const std::string& v) const { return style.is (v); }
9203  std::string get_style (void) const { return style.current_value (); }
9204 
9205 
9207  {
9208  {
9209  if (color.set (val, true))
9210  {
9211  mark_modified ();
9212  }
9213  }
9214  }
9215 
9217  {
9218  {
9219  if (position.set (val, true))
9220  {
9221  mark_modified ();
9222  }
9223  }
9224  }
9225 
9227  {
9228  {
9229  if (style.set (val, true))
9230  {
9231  mark_modified ();
9232  }
9233  }
9234  }
9235 
9236 
9237  protected:
9238  void init (void)
9239  {
9240  position.add_constraint (dim_vector (1, 3));
9241  }
9242  };
9243 
9244 private:
9246 
9247 public:
9249  : base_graphics_object (), xproperties (mh, p)
9250  { }
9251 
9252  ~light (void) { }
9253 
9254  base_properties& get_properties (void) { return xproperties; }
9255 
9256  const base_properties& get_properties (void) const { return xproperties; }
9257 
9258  bool valid_object (void) const { return true; }
9259 
9261  {
9262  bool retval = xproperties.has_readonly_property (pname);
9263  if (! retval)
9264  retval = base_properties::has_readonly_property (pname);
9265  return retval;
9266  }
9267 };
9268 
9269 // ---------------------------------------------------------------------
9270 
9272 {
9273 public:
9275  {
9276  public:
9277  octave_value get_color_data (void) const;
9278 
9279  // Matlab allows incoherent data to be stored into patch properties.
9280  // The patch should then be ignored by the renderer.
9281  bool has_bad_data (std::string &msg) const
9282  {
9283  msg = bad_data_msg;
9284  return ! msg.empty ();
9285  }
9286 
9287  bool is_aliminclude (void) const
9288  { return (aliminclude.is_on () && alphadatamapping.is ("scaled")); }
9290  { return aliminclude.current_value (); }
9291 
9292  bool is_climinclude (void) const
9293  { return (climinclude.is_on () && cdatamapping.is ("scaled")); }
9295  { return climinclude.current_value (); }
9296 
9297  // See the genprops.awk script for an explanation of the
9298  // properties declarations.
9299  // Programming note: Keep property list sorted if new ones are added.
9300 
9301 public:
9302  properties (const graphics_handle& mh, const graphics_handle& p);
9303 
9304  ~properties (void) { }
9305 
9306  void set (const caseless_str& pname, const octave_value& val);
9307 
9308  octave_value get (bool all = false) const;
9309 
9310  octave_value get (const caseless_str& pname) const;
9311 
9312  octave_value get (const std::string& pname) const
9313  {
9314  return get (caseless_str (pname));
9315  }
9316 
9317  octave_value get (const char *pname) const
9318  {
9319  return get (caseless_str (pname));
9320  }
9321 
9322  property get_property (const caseless_str& pname);
9323 
9324  std::string graphics_object_name (void) const { return go_name; }
9325 
9327 
9328 private:
9330 
9331 public:
9332 
9333 
9334  static std::set<std::string> core_property_names (void);
9335 
9336  static std::set<std::string> readonly_property_names (void);
9337 
9338  static bool has_core_property (const caseless_str& pname);
9339 
9340  static bool has_readonly_property (const caseless_str& pname);
9341 
9342  std::set<std::string> all_property_names (void) const;
9343 
9344  bool has_property (const caseless_str& pname) const;
9345 
9346 private:
9347 
9394 
9395 public:
9396 
9397  enum
9398  {
9399  ID_ALPHADATAMAPPING = 8000,
9400  ID_AMBIENTSTRENGTH = 8001,
9401  ID_BACKFACELIGHTING = 8002,
9402  ID_CDATA = 8003,
9403  ID_CDATAMAPPING = 8004,
9404  ID_DIFFUSESTRENGTH = 8005,
9405  ID_DISPLAYNAME = 8006,
9406  ID_EDGEALPHA = 8007,
9407  ID_EDGECOLOR = 8008,
9408  ID_EDGELIGHTING = 8009,
9409  ID_ERASEMODE = 8010,
9410  ID_FACEALPHA = 8011,
9411  ID_FACECOLOR = 8012,
9412  ID_FACELIGHTING = 8013,
9413  ID_FACENORMALS = 8014,
9414  ID_FACENORMALSMODE = 8015,
9415  ID_FACES = 8016,
9416  ID_FACEVERTEXALPHADATA = 8017,
9417  ID_FACEVERTEXCDATA = 8018,
9418  ID_INTERPRETER = 8019,
9419  ID_LINESTYLE = 8020,
9420  ID_LINEWIDTH = 8021,
9421  ID_MARKER = 8022,
9422  ID_MARKEREDGECOLOR = 8023,
9423  ID_MARKERFACECOLOR = 8024,
9424  ID_MARKERSIZE = 8025,
9425  ID_NORMALMODE = 8026,
9426  ID_SPECULARCOLORREFLECTANCE = 8027,
9427  ID_SPECULAREXPONENT = 8028,
9428  ID_SPECULARSTRENGTH = 8029,
9429  ID_VERTEXNORMALS = 8030,
9430  ID_VERTEXNORMALSMODE = 8031,
9431  ID_VERTICES = 8032,
9432  ID_XDATA = 8033,
9433  ID_YDATA = 8034,
9434  ID_ZDATA = 8035,
9435  ID_ALIM = 8036,
9436  ID_CLIM = 8037,
9437  ID_XLIM = 8038,
9438  ID_YLIM = 8039,
9439  ID_ZLIM = 8040,
9440  ID_ALIMINCLUDE = 8041,
9441  ID_CLIMINCLUDE = 8042,
9442  ID_XLIMINCLUDE = 8043,
9443  ID_YLIMINCLUDE = 8044,
9444  ID_ZLIMINCLUDE = 8045
9445  };
9446 
9447  bool alphadatamapping_is (const std::string& v) const { return alphadatamapping.is (v); }
9448  std::string get_alphadatamapping (void) const { return alphadatamapping.current_value (); }
9449 
9450  double get_ambientstrength (void) const { return ambientstrength.double_value (); }
9451 
9452  bool backfacelighting_is (const std::string& v) const { return backfacelighting.is (v); }
9453  std::string get_backfacelighting (void) const { return backfacelighting.current_value (); }
9454 
9455  octave_value get_cdata (void) const { return cdata.get (); }
9456 
9457  bool cdatamapping_is (const std::string& v) const { return cdatamapping.is (v); }
9458  std::string get_cdatamapping (void) const { return cdatamapping.current_value (); }
9459 
9460  double get_diffusestrength (void) const { return diffusestrength.double_value (); }
9461 
9462  std::string get_displayname (void) const { return displayname.string_value (); }
9463 
9464  bool edgealpha_is_double (void) const { return edgealpha.is_double (); }
9465  bool edgealpha_is (const std::string& v) const { return edgealpha.is (v); }
9466  double get_edgealpha_double (void) const { return (edgealpha.is_double () ? edgealpha.double_value () : 0); }
9467  octave_value get_edgealpha (void) const { return edgealpha.get (); }
9468 
9469  bool edgecolor_is_rgb (void) const { return edgecolor.is_rgb (); }
9470  bool edgecolor_is (const std::string& v) const { return edgecolor.is (v); }
9471  Matrix get_edgecolor_rgb (void) const { return (edgecolor.is_rgb () ? edgecolor.rgb () : Matrix ()); }
9472  octave_value get_edgecolor (void) const { return edgecolor.get (); }
9473 
9474  bool edgelighting_is (const std::string& v) const { return edgelighting.is (v); }
9475  std::string get_edgelighting (void) const { return edgelighting.current_value (); }
9476 
9477  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
9478  std::string get_erasemode (void) const { return erasemode.current_value (); }
9479 
9480  bool facealpha_is_double (void) const { return facealpha.is_double (); }
9481  bool facealpha_is (const std::string& v) const { return facealpha.is (v); }
9482  double get_facealpha_double (void) const { return (facealpha.is_double () ? facealpha.double_value () : 0); }
9483  octave_value get_facealpha (void) const { return facealpha.get (); }
9484 
9485  bool facecolor_is_rgb (void) const { return facecolor.is_rgb (); }
9486  bool facecolor_is (const std::string& v) const { return facecolor.is (v); }
9487  Matrix get_facecolor_rgb (void) const { return (facecolor.is_rgb () ? facecolor.rgb () : Matrix ()); }
9488  octave_value get_facecolor (void) const { return facecolor.get (); }
9489 
9490  bool facelighting_is (const std::string& v) const { return facelighting.is (v); }
9491  std::string get_facelighting (void) const { return facelighting.current_value (); }
9492 
9493  octave_value get_facenormals (void) const { return facenormals.get (); }
9494 
9495  bool facenormalsmode_is (const std::string& v) const { return facenormalsmode.is (v); }
9496  std::string get_facenormalsmode (void) const { return facenormalsmode.current_value (); }
9497 
9498  octave_value get_faces (void) const { return faces.get (); }
9499 
9500  octave_value get_facevertexalphadata (void) const { return facevertexalphadata.get (); }
9501 
9502  octave_value get_facevertexcdata (void) const { return facevertexcdata.get (); }
9503 
9504  bool interpreter_is (const std::string& v) const { return interpreter.is (v); }
9505  std::string get_interpreter (void) const { return interpreter.current_value (); }
9506 
9507  bool linestyle_is (const std::string& v) const { return linestyle.is (v); }
9508  std::string get_linestyle (void) const { return linestyle.current_value (); }
9509 
9510  double get_linewidth (void) const { return linewidth.double_value (); }
9511 
9512  bool marker_is (const std::string& v) const { return marker.is (v); }
9513  std::string get_marker (void) const { return marker.current_value (); }
9514 
9515  bool markeredgecolor_is_rgb (void) const { return markeredgecolor.is_rgb (); }
9516  bool markeredgecolor_is (const std::string& v) const { return markeredgecolor.is (v); }
9517  Matrix get_markeredgecolor_rgb (void) const { return (markeredgecolor.is_rgb () ? markeredgecolor.rgb () : Matrix ()); }
9518  octave_value get_markeredgecolor (void) const { return markeredgecolor.get (); }
9519 
9520  bool markerfacecolor_is_rgb (void) const { return markerfacecolor.is_rgb (); }
9521  bool markerfacecolor_is (const std::string& v) const { return markerfacecolor.is (v); }
9522  Matrix get_markerfacecolor_rgb (void) const { return (markerfacecolor.is_rgb () ? markerfacecolor.rgb () : Matrix ()); }
9523  octave_value get_markerfacecolor (void) const { return markerfacecolor.get (); }
9524 
9525  double get_markersize (void) const { return markersize.double_value (); }
9526 
9527  double get_specularcolorreflectance (void) const { return specularcolorreflectance.double_value (); }
9528 
9529  double get_specularexponent (void) const { return specularexponent.double_value (); }
9530 
9531  double get_specularstrength (void) const { return specularstrength.double_value (); }
9532 
9533  octave_value get_vertexnormals (void) const { return vertexnormals.get (); }
9534 
9535  bool vertexnormalsmode_is (const std::string& v) const { return vertexnormalsmode.is (v); }
9536  std::string get_vertexnormalsmode (void) const { return vertexnormalsmode.current_value (); }
9537 
9538  octave_value get_vertices (void) const { return vertices.get (); }
9539 
9540  octave_value get_xdata (void) const { return xdata.get (); }
9541 
9542  octave_value get_ydata (void) const { return ydata.get (); }
9543 
9544  octave_value get_zdata (void) const { return zdata.get (); }
9545 
9546  octave_value get_alim (void) const { return alim.get (); }
9547 
9548  octave_value get_clim (void) const { return clim.get (); }
9549 
9550  octave_value get_xlim (void) const { return xlim.get (); }
9551 
9552  octave_value get_ylim (void) const { return ylim.get (); }
9553 
9554  octave_value get_zlim (void) const { return zlim.get (); }
9555 
9556  bool is_xliminclude (void) const { return xliminclude.is_on (); }
9557  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
9558 
9559  bool is_yliminclude (void) const { return yliminclude.is_on (); }
9560  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
9561 
9562  bool is_zliminclude (void) const { return zliminclude.is_on (); }
9563  std::string get_zliminclude (void) const { return zliminclude.current_value (); }
9564 
9565 
9567  {
9568  {
9569  if (alphadatamapping.set (val, false))
9570  {
9571  update_axis_limits ("alphadatamapping");
9572  alphadatamapping.run_listeners (POSTSET);
9573  mark_modified ();
9574  }
9575  }
9576  }
9577 
9579  {
9580  {
9581  if (ambientstrength.set (val, true))
9582  {
9583  mark_modified ();
9584  }
9585  }
9586  }
9587 
9589  {
9590  {
9591  if (backfacelighting.set (val, true))
9592  {
9593  mark_modified ();
9594  }
9595  }
9596  }
9597 
9599  {
9600  {
9601  if (cdata.set (val, true))
9602  {
9603  update_cdata ();
9604  mark_modified ();
9605  }
9606  }
9607  }
9608 
9610  {
9611  {
9612  if (cdatamapping.set (val, false))
9613  {
9614  update_axis_limits ("cdatamapping");
9615  cdatamapping.run_listeners (POSTSET);
9616  mark_modified ();
9617  }
9618  }
9619  }
9620 
9622  {
9623  {
9624  if (diffusestrength.set (val, true))
9625  {
9626  mark_modified ();
9627  }
9628  }
9629  }
9630 
9632  {
9633  {
9634  if (displayname.set (val, true))
9635  {
9636  mark_modified ();
9637  }
9638  }
9639  }
9640 
9642  {
9643  {
9644  if (edgealpha.set (val, true))
9645  {
9646  mark_modified ();
9647  }
9648  }
9649  }
9650 
9652  {
9653  {
9654  if (edgecolor.set (val, true))
9655  {
9656  mark_modified ();
9657  }
9658  }
9659  }
9660 
9662  {
9663  {
9664  if (edgelighting.set (val, true))
9665  {
9666  mark_modified ();
9667  }
9668  }
9669  }
9670 
9672  {
9673  {
9674  if (erasemode.set (val, true))
9675  {
9676  mark_modified ();
9677  }
9678  }
9679  }
9680 
9682  {
9683  {
9684  if (facealpha.set (val, true))
9685  {
9686  mark_modified ();
9687  }
9688  }
9689  }
9690 
9692  {
9693  {
9694  if (facecolor.set (val, true))
9695  {
9696  mark_modified ();
9697  }
9698  }
9699  }
9700 
9702  {
9703  {
9704  if (facelighting.set (val, true))
9705  {
9706  mark_modified ();
9707  }
9708  }
9709  }
9710 
9712  {
9713  {
9714  if (facenormals.set (val, false))
9715  {
9716  set_facenormalsmode ("manual");
9717  facenormals.run_listeners (POSTSET);
9718  mark_modified ();
9719  }
9720  else
9721  set_facenormalsmode ("manual");
9722  }
9723  }
9724 
9726  {
9727  {
9728  if (facenormalsmode.set (val, true))
9729  {
9730  mark_modified ();
9731  }
9732  }
9733  }
9734 
9736  {
9737  {
9738  if (faces.set (val, true))
9739  {
9740  update_faces ();
9741  mark_modified ();
9742  }
9743  }
9744  }
9745 
9747  {
9748  {
9749  if (facevertexalphadata.set (val, true))
9750  {
9751  mark_modified ();
9752  }
9753  }
9754  }
9755 
9757  {
9758  {
9759  if (facevertexcdata.set (val, true))
9760  {
9761  update_facevertexcdata ();
9762  mark_modified ();
9763  }
9764  }
9765  }
9766 
9768  {
9769  {
9770  if (interpreter.set (val, true))
9771  {
9772  mark_modified ();
9773  }
9774  }
9775  }
9776 
9778  {
9779  {
9780  if (linestyle.set (val, true))
9781  {
9782  mark_modified ();
9783  }
9784  }
9785  }
9786 
9788  {
9789  {
9790  if (linewidth.set (val, true))
9791  {
9792  mark_modified ();
9793  }
9794  }
9795  }
9796 
9798  {
9799  {
9800  if (marker.set (val, true))
9801  {
9802  mark_modified ();
9803  }
9804  }
9805  }
9806 
9808  {
9809  {
9810  if (markeredgecolor.set (val, true))
9811  {
9812  mark_modified ();
9813  }
9814  }
9815  }
9816 
9818  {
9819  {
9820  if (markerfacecolor.set (val, true))
9821  {
9822  mark_modified ();
9823  }
9824  }
9825  }
9826 
9828  {
9829  {
9830  if (markersize.set (val, true))
9831  {
9832  mark_modified ();
9833  }
9834  }
9835  }
9836 
9838  {
9839  {
9840  if (specularcolorreflectance.set (val, true))
9841  {
9842  mark_modified ();
9843  }
9844  }
9845  }
9846 
9848  {
9849  {
9850  if (specularexponent.set (val, true))
9851  {
9852  mark_modified ();
9853  }
9854  }
9855  }
9856 
9858  {
9859  {
9860  if (specularstrength.set (val, true))
9861  {
9862  mark_modified ();
9863  }
9864  }
9865  }
9866 
9868  {
9869  {
9870  if (vertexnormals.set (val, false))
9871  {
9872  set_vertexnormalsmode ("manual");
9873  vertexnormals.run_listeners (POSTSET);
9874  mark_modified ();
9875  }
9876  else
9877  set_vertexnormalsmode ("manual");
9878  }
9879  }
9880 
9882  {
9883  {
9884  if (vertexnormalsmode.set (val, true))
9885  {
9886  mark_modified ();
9887  }
9888  }
9889  }
9890 
9892  {
9893  {
9894  if (vertices.set (val, true))
9895  {
9896  update_vertices ();
9897  mark_modified ();
9898  }
9899  }
9900  }
9901 
9903  {
9904  {
9905  if (xdata.set (val, true))
9906  {
9907  update_xdata ();
9908  mark_modified ();
9909  }
9910  }
9911  }
9912 
9914  {
9915  {
9916  if (ydata.set (val, true))
9917  {
9918  update_ydata ();
9919  mark_modified ();
9920  }
9921  }
9922  }
9923 
9925  {
9926  {
9927  if (zdata.set (val, true))
9928  {
9929  update_zdata ();
9930  mark_modified ();
9931  }
9932  }
9933  }
9934 
9935  void set_alim (const octave_value& val)
9936  {
9937  {
9938  if (alim.set (val, false))
9939  {
9940  update_axis_limits ("alim");
9941  alim.run_listeners (POSTSET);
9942  mark_modified ();
9943  }
9944  }
9945  }
9946 
9947  void set_clim (const octave_value& val)
9948  {
9949  {
9950  if (clim.set (val, false))
9951  {
9952  update_axis_limits ("clim");
9953  clim.run_listeners (POSTSET);
9954  mark_modified ();
9955  }
9956  }
9957  }
9958 
9959  void set_xlim (const octave_value& val)
9960  {
9961  {
9962  if (xlim.set (val, false))
9963  {
9964  update_axis_limits ("xlim");
9965  xlim.run_listeners (POSTSET);
9966  mark_modified ();
9967  }
9968  }
9969  }
9970 
9971  void set_ylim (const octave_value& val)
9972  {
9973  {
9974  if (ylim.set (val, false))
9975  {
9976  update_axis_limits ("ylim");
9977  ylim.run_listeners (POSTSET);
9978  mark_modified ();
9979  }
9980  }
9981  }
9982 
9983  void set_zlim (const octave_value& val)
9984  {
9985  {
9986  if (zlim.set (val, false))
9987  {
9988  update_axis_limits ("zlim");
9989  zlim.run_listeners (POSTSET);
9990  mark_modified ();
9991  }
9992  }
9993  }
9994 
9996  {
9997  {
9998  if (aliminclude.set (val, false))
9999  {
10000  update_axis_limits ("aliminclude");
10001  aliminclude.run_listeners (POSTSET);
10002  mark_modified ();
10003  }
10004  }
10005  }
10006 
10008  {
10009  {
10010  if (climinclude.set (val, false))
10011  {
10012  update_axis_limits ("climinclude");
10013  climinclude.run_listeners (POSTSET);
10014  mark_modified ();
10015  }
10016  }
10017  }
10018 
10020  {
10021  {
10022  if (xliminclude.set (val, false))
10023  {
10024  update_axis_limits ("xliminclude");
10025  xliminclude.run_listeners (POSTSET);
10026  mark_modified ();
10027  }
10028  }
10029  }
10030 
10032  {
10033  {
10034  if (yliminclude.set (val, false))
10035  {
10036  update_axis_limits ("yliminclude");
10037  yliminclude.run_listeners (POSTSET);
10038  mark_modified ();
10039  }
10040  }
10041  }
10042 
10044  {
10045  {
10046  if (zliminclude.set (val, false))
10047  {
10048  update_axis_limits ("zliminclude");
10049  zliminclude.run_listeners (POSTSET);
10050  mark_modified ();
10051  }
10052  }
10053  }
10054 
10055 
10056  protected:
10057  void init (void)
10058  {
10059  xdata.add_constraint (dim_vector (-1, -1));
10060  ydata.add_constraint (dim_vector (-1, -1));
10061  zdata.add_constraint (dim_vector (-1, -1));
10062  faces.add_constraint (dim_vector (-1, -1));
10063  vertices.add_constraint (dim_vector (-1, 2));
10064  vertices.add_constraint (dim_vector (-1, 3));
10065  cdata.add_constraint (dim_vector (-1, -1));
10066  cdata.add_constraint (dim_vector (-1, -1, 3));
10067  facevertexcdata.add_constraint (dim_vector (-1, 1));
10068  facevertexcdata.add_constraint (dim_vector (-1, 3));
10069  facevertexalphadata.add_constraint (dim_vector (-1, 1));
10070  facenormals.add_constraint (dim_vector (-1, 3));
10071  facenormals.add_constraint (dim_vector (0, 0));
10072  vertexnormals.add_constraint (dim_vector (-1, 3));
10073  vertexnormals.add_constraint (dim_vector (0, 0));
10074  }
10075 
10076  private:
10078 
10079  void update_faces (void) { update_data ();}
10080 
10081  void update_vertices (void) { update_data ();}
10082 
10083  void update_facevertexcdata (void) { update_data ();}
10084 
10085  void update_fvc (void);
10086 
10087  void update_xdata (void)
10088  {
10089  if (get_xdata ().is_empty ())
10090  {
10091  // For compatibility with matlab behavior,
10092  // if x/ydata are set empty, silently empty other *data and
10093  // faces properties while vertices remain unchanged.
10094  set_ydata (Matrix ());
10095  set_zdata (Matrix ());
10096  set_cdata (Matrix ());
10097  set_faces (Matrix ());
10098  }
10099  else
10100  update_fvc ();
10101 
10102  set_xlim (xdata.get_limits ());
10103  }
10104 
10105  void update_ydata (void)
10106  {
10107  if (get_ydata ().is_empty ())
10108  {
10109  set_xdata (Matrix ());
10110  set_zdata (Matrix ());
10111  set_cdata (Matrix ());
10112  set_faces (Matrix ());
10113  }
10114  else
10115  update_fvc ();
10116 
10117  set_ylim (ydata.get_limits ());
10118  }
10119 
10120  void update_zdata (void)
10121  {
10122  update_fvc ();
10123  set_zlim (zdata.get_limits ());
10124  }
10125 
10126  void update_cdata (void)
10127  {
10128  update_fvc ();
10129 
10130  if (cdatamapping_is ("scaled"))
10131  set_clim (cdata.get_limits ());
10132  else
10133  clim = cdata.get_limits ();
10134  }
10135 
10136  void update_data (void);
10137 
10139  {
10140  warning_with_id ("Octave:deprecated-property",
10141  "patch: Property 'normalmode' is deprecated and will be removed "
10142  "from a future version of Octave. Use 'vertexnormalsmode' instead.");
10143  set_vertexnormalsmode (val);
10144  }
10145 
10147  {
10148  warning_with_id ("Octave:deprecated-property",
10149  "patch: Property 'normalmode' is deprecated and will be removed "
10150  "from a future version of Octave. Use 'vertexnormalsmode' instead.");
10151  return vertexnormalsmode.current_value ();
10152  }
10153  };
10154 
10155 private:
10157 
10158 public:
10160  : base_graphics_object (), xproperties (mh, p)
10161  { }
10162 
10163  ~patch (void) { }
10164 
10165  base_properties& get_properties (void) { return xproperties; }
10166 
10167  const base_properties& get_properties (void) const { return xproperties; }
10168 
10169  bool valid_object (void) const { return true; }
10170 
10172  {
10173  bool retval = xproperties.has_readonly_property (pname);
10174  if (! retval)
10175  retval = base_properties::has_readonly_property (pname);
10176  return retval;
10177  }
10178 };
10179 
10180 // ---------------------------------------------------------------------
10181 
10183 {
10184 public:
10186  {
10187  public:
10188  octave_value get_color_data (void) const;
10189 
10190  bool is_aliminclude (void) const
10191  { return (aliminclude.is_on () && alphadatamapping.is ("scaled")); }
10193  { return aliminclude.current_value (); }
10194 
10195  bool is_climinclude (void) const
10196  { return (climinclude.is_on () && cdatamapping.is ("scaled")); }
10198  { return climinclude.current_value (); }
10199 
10200  // See the genprops.awk script for an explanation of the
10201  // properties declarations.
10202  // Programming note: Keep property list sorted if new ones are added.
10203 
10204 public:
10205  properties (const graphics_handle& mh, const graphics_handle& p);
10206 
10207  ~properties (void) { }
10208 
10209  void set (const caseless_str& pname, const octave_value& val);
10210 
10211  octave_value get (bool all = false) const;
10212 
10213  octave_value get (const caseless_str& pname) const;
10214 
10215  octave_value get (const std::string& pname) const
10216  {
10217  return get (caseless_str (pname));
10218  }
10219 
10220  octave_value get (const char *pname) const
10221  {
10222  return get (caseless_str (pname));
10223  }
10224 
10225  property get_property (const caseless_str& pname);
10226 
10227  std::string graphics_object_name (void) const { return go_name; }
10228 
10230 
10231 private:
10233 
10234 public:
10235 
10236 
10237  static std::set<std::string> core_property_names (void);
10238 
10239  static std::set<std::string> readonly_property_names (void);
10240 
10241  static bool has_core_property (const caseless_str& pname);
10242 
10243  static bool has_readonly_property (const caseless_str& pname);
10244 
10245  std::set<std::string> all_property_names (void) const;
10246 
10247  bool has_property (const caseless_str& pname) const;
10248 
10249 private:
10250 
10299 
10300 public:
10301 
10302  enum
10303  {
10304  ID_ALPHADATA = 9000,
10305  ID_ALPHADATAMAPPING = 9001,
10306  ID_AMBIENTSTRENGTH = 9002,
10307  ID_BACKFACELIGHTING = 9003,
10308  ID_CDATA = 9004,
10309  ID_CDATAMAPPING = 9005,
10310  ID_CDATASOURCE = 9006,
10311  ID_DIFFUSESTRENGTH = 9007,
10312  ID_DISPLAYNAME = 9008,
10313  ID_EDGEALPHA = 9009,
10314  ID_EDGECOLOR = 9010,
10315  ID_EDGELIGHTING = 9011,
10316  ID_ERASEMODE = 9012,
10317  ID_FACEALPHA = 9013,
10318  ID_FACECOLOR = 9014,
10319  ID_FACELIGHTING = 9015,
10320  ID_FACENORMALS = 9016,
10321  ID_FACENORMALSMODE = 9017,
10322  ID_INTERPRETER = 9018,
10323  ID_LINESTYLE = 9019,
10324  ID_LINEWIDTH = 9020,
10325  ID_MARKER = 9021,
10326  ID_MARKEREDGECOLOR = 9022,
10327  ID_MARKERFACECOLOR = 9023,
10328  ID_MARKERSIZE = 9024,
10329  ID_MESHSTYLE = 9025,
10330  ID_NORMALMODE = 9026,
10331  ID_SPECULARCOLORREFLECTANCE = 9027,
10332  ID_SPECULAREXPONENT = 9028,
10333  ID_SPECULARSTRENGTH = 9029,
10334  ID_VERTEXNORMALS = 9030,
10335  ID_VERTEXNORMALSMODE = 9031,
10336  ID_XDATA = 9032,
10337  ID_XDATASOURCE = 9033,
10338  ID_YDATA = 9034,
10339  ID_YDATASOURCE = 9035,
10340  ID_ZDATA = 9036,
10341  ID_ZDATASOURCE = 9037,
10342  ID_ALIM = 9038,
10343  ID_CLIM = 9039,
10344  ID_XLIM = 9040,
10345  ID_YLIM = 9041,
10346  ID_ZLIM = 9042,
10347  ID_ALIMINCLUDE = 9043,
10348  ID_CLIMINCLUDE = 9044,
10349  ID_XLIMINCLUDE = 9045,
10350  ID_YLIMINCLUDE = 9046,
10351  ID_ZLIMINCLUDE = 9047
10352  };
10353 
10354  octave_value get_alphadata (void) const { return alphadata.get (); }
10355 
10356  bool alphadatamapping_is (const std::string& v) const { return alphadatamapping.is (v); }
10357  std::string get_alphadatamapping (void) const { return alphadatamapping.current_value (); }
10358 
10359  double get_ambientstrength (void) const { return ambientstrength.double_value (); }
10360 
10361  bool backfacelighting_is (const std::string& v) const { return backfacelighting.is (v); }
10362  std::string get_backfacelighting (void) const { return backfacelighting.current_value (); }
10363 
10364  octave_value get_cdata (void) const { return cdata.get (); }
10365 
10366  bool cdatamapping_is (const std::string& v) const { return cdatamapping.is (v); }
10367  std::string get_cdatamapping (void) const { return cdatamapping.current_value (); }
10368 
10369  std::string get_cdatasource (void) const { return cdatasource.string_value (); }
10370 
10371  double get_diffusestrength (void) const { return diffusestrength.double_value (); }
10372 
10373  std::string get_displayname (void) const { return displayname.string_value (); }
10374 
10375  bool edgealpha_is_double (void) const { return edgealpha.is_double (); }
10376  bool edgealpha_is (const std::string& v) const { return edgealpha.is (v); }
10377  double get_edgealpha_double (void) const { return (edgealpha.is_double () ? edgealpha.double_value () : 0); }
10378  octave_value get_edgealpha (void) const { return edgealpha.get (); }
10379 
10380  bool edgecolor_is_rgb (void) const { return edgecolor.is_rgb (); }
10381  bool edgecolor_is (const std::string& v) const { return edgecolor.is (v); }
10382  Matrix get_edgecolor_rgb (void) const { return (edgecolor.is_rgb () ? edgecolor.rgb () : Matrix ()); }
10383  octave_value get_edgecolor (void) const { return edgecolor.get (); }
10384 
10385  bool edgelighting_is (const std::string& v) const { return edgelighting.is (v); }
10386  std::string get_edgelighting (void) const { return edgelighting.current_value (); }
10387 
10388  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
10389  std::string get_erasemode (void) const { return erasemode.current_value (); }
10390 
10391  bool facealpha_is_double (void) const { return facealpha.is_double (); }
10392  bool facealpha_is (const std::string& v) const { return facealpha.is (v); }
10393  double get_facealpha_double (void) const { return (facealpha.is_double () ? facealpha.double_value () : 0); }
10394  octave_value get_facealpha (void) const { return facealpha.get (); }
10395 
10396  bool facecolor_is_rgb (void) const { return facecolor.is_rgb (); }
10397  bool facecolor_is (const std::string& v) const { return facecolor.is (v); }
10398  Matrix get_facecolor_rgb (void) const { return (facecolor.is_rgb () ? facecolor.rgb () : Matrix ()); }
10399  octave_value get_facecolor (void) const { return facecolor.get (); }
10400 
10401  bool facelighting_is (const std::string& v) const { return facelighting.is (v); }
10402  std::string get_facelighting (void) const { return facelighting.current_value (); }
10403 
10404  octave_value get_facenormals (void) const { return facenormals.get (); }
10405 
10406  bool facenormalsmode_is (const std::string& v) const { return facenormalsmode.is (v); }
10407  std::string get_facenormalsmode (void) const { return facenormalsmode.current_value (); }
10408 
10409  bool interpreter_is (const std::string& v) const { return interpreter.is (v); }
10410  std::string get_interpreter (void) const { return interpreter.current_value (); }
10411 
10412  bool linestyle_is (const std::string& v) const { return linestyle.is (v); }
10413  std::string get_linestyle (void) const { return linestyle.current_value (); }
10414 
10415  double get_linewidth (void) const { return linewidth.double_value (); }
10416 
10417  bool marker_is (const std::string& v) const { return marker.is (v); }
10418  std::string get_marker (void) const { return marker.current_value (); }
10419 
10420  bool markeredgecolor_is_rgb (void) const { return markeredgecolor.is_rgb (); }
10421  bool markeredgecolor_is (const std::string& v) const { return markeredgecolor.is (v); }
10422  Matrix get_markeredgecolor_rgb (void) const { return (markeredgecolor.is_rgb () ? markeredgecolor.rgb () : Matrix ()); }
10423  octave_value get_markeredgecolor (void) const { return markeredgecolor.get (); }
10424 
10425  bool markerfacecolor_is_rgb (void) const { return markerfacecolor.is_rgb (); }
10426  bool markerfacecolor_is (const std::string& v) const { return markerfacecolor.is (v); }
10427  Matrix get_markerfacecolor_rgb (void) const { return (markerfacecolor.is_rgb () ? markerfacecolor.rgb () : Matrix ()); }
10428  octave_value get_markerfacecolor (void) const { return markerfacecolor.get (); }
10429 
10430  double get_markersize (void) const { return markersize.double_value (); }
10431 
10432  bool meshstyle_is (const std::string& v) const { return meshstyle.is (v); }
10433  std::string get_meshstyle (void) const { return meshstyle.current_value (); }
10434 
10435  double get_specularcolorreflectance (void) const { return specularcolorreflectance.double_value (); }
10436 
10437  double get_specularexponent (void) const { return specularexponent.double_value (); }
10438 
10439  double get_specularstrength (void) const { return specularstrength.double_value (); }
10440 
10441  octave_value get_vertexnormals (void) const { return vertexnormals.get (); }
10442 
10443  bool vertexnormalsmode_is (const std::string& v) const { return vertexnormalsmode.is (v); }
10444  std::string get_vertexnormalsmode (void) const { return vertexnormalsmode.current_value (); }
10445 
10446  octave_value get_xdata (void) const { return xdata.get (); }
10447 
10448  std::string get_xdatasource (void) const { return xdatasource.string_value (); }
10449 
10450  octave_value get_ydata (void) const { return ydata.get (); }
10451 
10452  std::string get_ydatasource (void) const { return ydatasource.string_value (); }
10453 
10454  octave_value get_zdata (void) const { return zdata.get (); }
10455 
10456  std::string get_zdatasource (void) const { return zdatasource.string_value (); }
10457 
10458  octave_value get_alim (void) const { return alim.get (); }
10459 
10460  octave_value get_clim (void) const { return clim.get (); }
10461 
10462  octave_value get_xlim (void) const { return xlim.get (); }
10463 
10464  octave_value get_ylim (void) const { return ylim.get (); }
10465 
10466  octave_value get_zlim (void) const { return zlim.get (); }
10467 
10468  bool is_xliminclude (void) const { return xliminclude.is_on (); }
10469  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
10470 
10471  bool is_yliminclude (void) const { return yliminclude.is_on (); }
10472  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
10473 
10474  bool is_zliminclude (void) const { return zliminclude.is_on (); }
10475  std::string get_zliminclude (void) const { return zliminclude.current_value (); }
10476 
10477 
10479  {
10480  {
10481  if (alphadata.set (val, true))
10482  {
10483  update_alphadata ();
10484  mark_modified ();
10485  }
10486  }
10487  }
10488 
10490  {
10491  {
10492  if (alphadatamapping.set (val, false))
10493  {
10494  update_axis_limits ("alphadatamapping");
10495  alphadatamapping.run_listeners (POSTSET);
10496  mark_modified ();
10497  }
10498  }
10499  }
10500 
10502  {
10503  {
10504  if (ambientstrength.set (val, true))
10505  {
10506  mark_modified ();
10507  }
10508  }
10509  }
10510 
10512  {
10513  {
10514  if (backfacelighting.set (val, true))
10515  {
10516  mark_modified ();
10517  }
10518  }
10519  }
10520 
10522  {
10523  {
10524  if (cdata.set (val, true))
10525  {
10526  update_cdata ();
10527  mark_modified ();
10528  }
10529  }
10530  }
10531 
10533  {
10534  {
10535  if (cdatamapping.set (val, false))
10536  {
10537  update_axis_limits ("cdatamapping");
10538  cdatamapping.run_listeners (POSTSET);
10539  mark_modified ();
10540  }
10541  }
10542  }
10543 
10545  {
10546  {
10547  if (cdatasource.set (val, true))
10548  {
10549  mark_modified ();
10550  }
10551  }
10552  }
10553 
10555  {
10556  {
10557  if (diffusestrength.set (val, true))
10558  {
10559  mark_modified ();
10560  }
10561  }
10562  }
10563 
10565  {
10566  {
10567  if (displayname.set (val, true))
10568  {
10569  mark_modified ();
10570  }
10571  }
10572  }
10573 
10575  {
10576  {
10577  if (edgealpha.set (val, true))
10578  {
10579  mark_modified ();
10580  }
10581  }
10582  }
10583 
10585  {
10586  {
10587  if (edgecolor.set (val, true))
10588  {
10589  mark_modified ();
10590  }
10591  }
10592  }
10593 
10595  {
10596  {
10597  if (edgelighting.set (val, true))
10598  {
10599  mark_modified ();
10600  }
10601  }
10602  }
10603 
10605  {
10606  {
10607  if (erasemode.set (val, true))
10608  {
10609  mark_modified ();
10610  }
10611  }
10612  }
10613 
10615  {
10616  {
10617  if (facealpha.set (val, true))
10618  {
10619  mark_modified ();
10620  }
10621  }
10622  }
10623 
10625  {
10626  {
10627  if (facecolor.set (val, true))
10628  {
10629  mark_modified ();
10630  }
10631  }
10632  }
10633 
10635  {
10636  {
10637  if (facelighting.set (val, true))
10638  {
10639  mark_modified ();
10640  }
10641  }
10642  }
10643 
10645  {
10646  {
10647  if (facenormals.set (val, false))
10648  {
10649  set_facenormalsmode ("manual");
10650  facenormals.run_listeners (POSTSET);
10651  mark_modified ();
10652  }
10653  else
10654  set_facenormalsmode ("manual");
10655  }
10656  }
10657 
10659  {
10660  {
10661  if (facenormalsmode.set (val, true))
10662  {
10663  mark_modified ();
10664  }
10665  }
10666  }
10667 
10669  {
10670  {
10671  if (interpreter.set (val, true))
10672  {
10673  mark_modified ();
10674  }
10675  }
10676  }
10677 
10679  {
10680  {
10681  if (linestyle.set (val, true))
10682  {
10683  mark_modified ();
10684  }
10685  }
10686  }
10687 
10689  {
10690  {
10691  if (linewidth.set (val, true))
10692  {
10693  mark_modified ();
10694  }
10695  }
10696  }
10697 
10699  {
10700  {
10701  if (marker.set (val, true))
10702  {
10703  mark_modified ();
10704  }
10705  }
10706  }
10707 
10709  {
10710  {
10711  if (markeredgecolor.set (val, true))
10712  {
10713  mark_modified ();
10714  }
10715  }
10716  }
10717 
10719  {
10720  {
10721  if (markerfacecolor.set (val, true))
10722  {
10723  mark_modified ();
10724  }
10725  }
10726  }
10727 
10729  {
10730  {
10731  if (markersize.set (val, true))
10732  {
10733  mark_modified ();
10734  }
10735  }
10736  }
10737 
10739  {
10740  {
10741  if (meshstyle.set (val, true))
10742  {
10743  mark_modified ();
10744  }
10745  }
10746  }
10747 
10749  {
10750  {
10751  if (specularcolorreflectance.set (val, true))
10752  {
10753  mark_modified ();
10754  }
10755  }
10756  }
10757 
10759  {
10760  {
10761  if (specularexponent.set (val, true))
10762  {
10763  mark_modified ();
10764  }
10765  }
10766  }
10767 
10769  {
10770  {
10771  if (specularstrength.set (val, true))
10772  {
10773  mark_modified ();
10774  }
10775  }
10776  }
10777 
10779  {
10780  {
10781  if (vertexnormals.set (val, false))
10782  {
10783  set_vertexnormalsmode ("manual");
10784  vertexnormals.run_listeners (POSTSET);
10785  mark_modified ();
10786  }
10787  else
10788  set_vertexnormalsmode ("manual");
10789  }
10790  }
10791 
10793  {
10794  {
10795  if (vertexnormalsmode.set (val, true))
10796  {
10797  update_vertexnormalsmode ();
10798  mark_modified ();
10799  }
10800  }
10801  }
10802 
10804  {
10805  {
10806  if (xdata.set (val, true))
10807  {
10808  update_xdata ();
10809  mark_modified ();
10810  }
10811  }
10812  }
10813 
10815  {
10816  {
10817  if (xdatasource.set (val, true))
10818  {
10819  mark_modified ();
10820  }
10821  }
10822  }
10823 
10825  {
10826  {
10827  if (ydata.set (val, true))
10828  {
10829  update_ydata ();
10830  mark_modified ();
10831  }
10832  }
10833  }
10834 
10836  {
10837  {
10838  if (ydatasource.set (val, true))
10839  {
10840  mark_modified ();
10841  }
10842  }
10843  }
10844 
10846  {
10847  {
10848  if (zdata.set (val, true))
10849  {
10850  update_zdata ();
10851  mark_modified ();
10852  }
10853  }
10854  }
10855 
10857  {
10858  {
10859  if (zdatasource.set (val, true))
10860  {
10861  mark_modified ();
10862  }
10863  }
10864  }
10865 
10866  void set_alim (const octave_value& val)
10867  {
10868  {
10869  if (alim.set (val, false))
10870  {
10871  update_axis_limits ("alim");
10872  alim.run_listeners (POSTSET);
10873  mark_modified ();
10874  }
10875  }
10876  }
10877 
10878  void set_clim (const octave_value& val)
10879  {
10880  {
10881  if (clim.set (val, false))
10882  {
10883  update_axis_limits ("clim");
10884  clim.run_listeners (POSTSET);
10885  mark_modified ();
10886  }
10887  }
10888  }
10889 
10890  void set_xlim (const octave_value& val)
10891  {
10892  {
10893  if (xlim.set (val, false))
10894  {
10895  update_axis_limits ("xlim");
10896  xlim.run_listeners (POSTSET);
10897  mark_modified ();
10898  }
10899  }
10900  }
10901 
10902  void set_ylim (const octave_value& val)
10903  {
10904  {
10905  if (ylim.set (val, false))
10906  {
10907  update_axis_limits ("ylim");
10908  ylim.run_listeners (POSTSET);
10909  mark_modified ();
10910  }
10911  }
10912  }
10913 
10914  void set_zlim (const octave_value& val)
10915  {
10916  {
10917  if (zlim.set (val, false))
10918  {
10919  update_axis_limits ("zlim");
10920  zlim.run_listeners (POSTSET);
10921  mark_modified ();
10922  }
10923  }
10924  }
10925 
10927  {
10928  {
10929  if (aliminclude.set (val, false))
10930  {
10931  update_axis_limits ("aliminclude");
10932  aliminclude.run_listeners (POSTSET);
10933  mark_modified ();
10934  }
10935  }
10936  }
10937 
10939  {
10940  {
10941  if (climinclude.set (val, false))
10942  {
10943  update_axis_limits ("climinclude");
10944  climinclude.run_listeners (POSTSET);
10945  mark_modified ();
10946  }
10947  }
10948  }
10949 
10951  {
10952  {
10953  if (xliminclude.set (val, false))
10954  {
10955  update_axis_limits ("xliminclude");
10956  xliminclude.run_listeners (POSTSET);
10957  mark_modified ();
10958  }
10959  }
10960  }
10961 
10963  {
10964  {
10965  if (yliminclude.set (val, false))
10966  {
10967  update_axis_limits ("yliminclude");
10968  yliminclude.run_listeners (POSTSET);
10969  mark_modified ();
10970  }
10971  }
10972  }
10973 
10975  {
10976  {
10977  if (zliminclude.set (val, false))
10978  {
10979  update_axis_limits ("zliminclude");
10980  zliminclude.run_listeners (POSTSET);
10981  mark_modified ();
10982  }
10983  }
10984  }
10985 
10986 
10987  protected:
10988  void init (void)
10989  {
10990  xdata.add_constraint (dim_vector (-1, -1));
10991  ydata.add_constraint (dim_vector (-1, -1));
10992  zdata.add_constraint (dim_vector (-1, -1));
10993  cdata.add_constraint ("double");
10994  cdata.add_constraint ("single");
10995  cdata.add_constraint (dim_vector (-1, -1));
10996  cdata.add_constraint (dim_vector (-1, -1, 3));
10997  alphadata.add_constraint ("double");
10998  alphadata.add_constraint ("uint8");
10999  alphadata.add_constraint (dim_vector (-1, -1));
11000  facenormals.add_constraint (dim_vector (-1, -1, 3));
11001  facenormals.add_constraint (dim_vector (0, 0));
11002  vertexnormals.add_constraint (dim_vector (-1, -1, 3));
11003  vertexnormals.add_constraint (dim_vector (0, 0));
11004  }
11005 
11006  private:
11007  void update_alphadata (void)
11008  {
11009  if (alphadatamapping_is ("scaled"))
11010  set_alim (alphadata.get_limits ());
11011  else
11012  alim = alphadata.get_limits ();
11013  }
11014 
11015  void update_cdata (void)
11016  {
11017  if (cdatamapping_is ("scaled"))
11018  set_clim (cdata.get_limits ());
11019  else
11020  clim = cdata.get_limits ();
11021  }
11022 
11023  void update_xdata (void)
11024  {
11025  update_vertex_normals ();
11026  set_xlim (xdata.get_limits ());
11027  }
11028 
11029  void update_ydata (void)
11030  {
11031  update_vertex_normals ();
11032  set_ylim (ydata.get_limits ());
11033  }
11034 
11035  void update_zdata (void)
11036  {
11037  update_vertex_normals ();
11038  set_zlim (zdata.get_limits ());
11039  }
11040 
11041  void update_vertex_normals (void);
11042 
11044  { update_vertex_normals (); }
11045 
11047  {
11048  warning_with_id ("Octave:deprecated-property",
11049  "surface: Property 'normalmode' is deprecated and will be removed "
11050  "from a future version of Octave. Use 'vertexnormalsmode' instead.");
11051  set_vertexnormalsmode (val);
11052  }
11053 
11055  {
11056  warning_with_id ("Octave:deprecated-property",
11057  "surface: Property 'normalmode' is deprecated and will be removed "
11058  "from a future version of Octave. Use 'vertexnormalsmode' instead.");
11059  return vertexnormalsmode.current_value ();
11060  }
11061  };
11062 
11063 private:
11065 
11066 public:
11068  : base_graphics_object (), xproperties (mh, p)
11069  { }
11070 
11071  ~surface (void) { }
11072 
11073  base_properties& get_properties (void) { return xproperties; }
11074 
11075  const base_properties& get_properties (void) const { return xproperties; }
11076 
11077  bool valid_object (void) const { return true; }
11078 
11080  {
11081  bool retval = xproperties.has_readonly_property (pname);
11082  if (! retval)
11083  retval = base_properties::has_readonly_property (pname);
11084  return retval;
11085  }
11086 };
11087 
11088 // ---------------------------------------------------------------------
11089 
11091 {
11092 public:
11094  {
11095  public:
11097  {
11099  update_limits ();
11100  }
11101 
11102  void adopt (const graphics_handle& h)
11103  {
11104 
11106  update_limits (h);
11107  }
11108 
11109  // See the genprops.awk script for an explanation of the
11110  // properties declarations.
11111  // Programming note: Keep property list sorted if new ones are added.
11112 
11113 public:
11114  properties (const graphics_handle& mh, const graphics_handle& p);
11115 
11116  ~properties (void) { }
11117 
11118  void set (const caseless_str& pname, const octave_value& val);
11119 
11120  octave_value get (bool all = false) const;
11121 
11122  octave_value get (const caseless_str& pname) const;
11123 
11124  octave_value get (const std::string& pname) const
11125  {
11126  return get (caseless_str (pname));
11127  }
11128 
11129  octave_value get (const char *pname) const
11130  {
11131  return get (caseless_str (pname));
11132  }
11133 
11134  property get_property (const caseless_str& pname);
11135 
11136  std::string graphics_object_name (void) const { return go_name; }
11137 
11139 
11140 private:
11142 
11143 public:
11144 
11145 
11146  static std::set<std::string> core_property_names (void);
11147 
11148  static std::set<std::string> readonly_property_names (void);
11149 
11150  static bool has_core_property (const caseless_str& pname);
11151 
11152  static bool has_readonly_property (const caseless_str& pname);
11153 
11154  std::set<std::string> all_property_names (void) const;
11155 
11156  bool has_property (const caseless_str& pname) const;
11157 
11158 private:
11159 
11172 
11173 public:
11174 
11175  enum
11176  {
11177  ID_DISPLAYNAME = 10000,
11178  ID_ERASEMODE = 10001,
11179  ID_ALIM = 10002,
11180  ID_CLIM = 10003,
11181  ID_XLIM = 10004,
11182  ID_YLIM = 10005,
11183  ID_ZLIM = 10006,
11184  ID_ALIMINCLUDE = 10007,
11185  ID_CLIMINCLUDE = 10008,
11186  ID_XLIMINCLUDE = 10009,
11187  ID_YLIMINCLUDE = 10010,
11188  ID_ZLIMINCLUDE = 10011
11189  };
11190 
11191  std::string get_displayname (void) const { return displayname.string_value (); }
11192 
11193  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
11194  std::string get_erasemode (void) const { return erasemode.current_value (); }
11195 
11196  octave_value get_alim (void) const { return alim.get (); }
11197 
11198  octave_value get_clim (void) const { return clim.get (); }
11199 
11200  octave_value get_xlim (void) const { return xlim.get (); }
11201 
11202  octave_value get_ylim (void) const { return ylim.get (); }
11203 
11204  octave_value get_zlim (void) const { return zlim.get (); }
11205 
11206  bool is_aliminclude (void) const { return aliminclude.is_on (); }
11207  std::string get_aliminclude (void) const { return aliminclude.current_value (); }
11208 
11209  bool is_climinclude (void) const { return climinclude.is_on (); }
11210  std::string get_climinclude (void) const { return climinclude.current_value (); }
11211 
11212  bool is_xliminclude (void) const { return xliminclude.is_on (); }
11213  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
11214 
11215  bool is_yliminclude (void) const { return yliminclude.is_on (); }
11216  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
11217 
11218  bool is_zliminclude (void) const { return zliminclude.is_on (); }
11219  std::string get_zliminclude (void) const { return zliminclude.current_value (); }
11220 
11221 
11223  {
11224  {
11225  if (displayname.set (val, true))
11226  {
11227  mark_modified ();
11228  }
11229  }
11230  }
11231 
11233  {
11234  {
11235  if (erasemode.set (val, true))
11236  {
11237  mark_modified ();
11238  }
11239  }
11240  }
11241 
11242  void set_alim (const octave_value& val)
11243  {
11244  {
11245  if (alim.set (val, true))
11246  {
11247  mark_modified ();
11248  }
11249  }
11250  }
11251 
11252  void set_clim (const octave_value& val)
11253  {
11254  {
11255  if (clim.set (val, true))
11256  {
11257  mark_modified ();
11258  }
11259  }
11260  }
11261 
11262  void set_xlim (const octave_value& val)
11263  {
11264  {
11265  if (xlim.set (val, true))
11266  {
11267  mark_modified ();
11268  }
11269  }
11270  }
11271 
11272  void set_ylim (const octave_value& val)
11273  {
11274  {
11275  if (ylim.set (val, true))
11276  {
11277  mark_modified ();
11278  }
11279  }
11280  }
11281 
11282  void set_zlim (const octave_value& val)
11283  {
11284  {
11285  if (zlim.set (val, true))
11286  {
11287  mark_modified ();
11288  }
11289  }
11290  }
11291 
11293  {
11294  {
11295  if (aliminclude.set (val, true))
11296  {
11297  mark_modified ();
11298  }
11299  }
11300  }
11301 
11303  {
11304  {
11305  if (climinclude.set (val, true))
11306  {
11307  mark_modified ();
11308  }
11309  }
11310  }
11311 
11313  {
11314  {
11315  if (xliminclude.set (val, true))
11316  {
11317  mark_modified ();
11318  }
11319  }
11320  }
11321 
11323  {
11324  {
11325  if (yliminclude.set (val, true))
11326  {
11327  mark_modified ();
11328  }
11329  }
11330  }
11331 
11333  {
11334  {
11335  if (zliminclude.set (val, true))
11336  {
11337  mark_modified ();
11338  }
11339  }
11340  }
11341 
11342 
11343  private:
11344  void update_limits (void) const;
11345 
11346  void update_limits (const graphics_handle& h) const;
11347 
11348  protected:
11349  void init (void)
11350  { }
11351 
11352  };
11353 
11354 private:
11356 
11357 public:
11359  : base_graphics_object (), xproperties (mh, p)
11360  { }
11361 
11362  ~hggroup (void) { }
11363 
11364  base_properties& get_properties (void) { return xproperties; }
11365 
11366  const base_properties& get_properties (void) const { return xproperties; }
11367 
11368  bool valid_object (void) const { return true; }
11369 
11370  void update_axis_limits (const std::string& axis_type);
11371 
11372  void update_axis_limits (const std::string& axis_type,
11373  const graphics_handle& h);
11374 
11376  {
11377  bool retval = xproperties.has_readonly_property (pname);
11378  if (! retval)
11379  retval = base_properties::has_readonly_property (pname);
11380  return retval;
11381  }
11382 
11383 };
11384 
11385 // ---------------------------------------------------------------------
11386 
11388 {
11389 public:
11391  {
11392  public:
11394  {
11396  }
11397 
11398  void adopt (const graphics_handle& h)
11399  {
11401  }
11402 
11403  // See the genprops.awk script for an explanation of the
11404  // properties declarations.
11405  // Programming note: Keep property list sorted if new ones are added.
11406 
11407 public:
11408  properties (const graphics_handle& mh, const graphics_handle& p);
11409 
11410  ~properties (void) { }
11411 
11412  void set (const caseless_str& pname, const octave_value& val);
11413 
11414  octave_value get (bool all = false) const;
11415 
11416  octave_value get (const caseless_str& pname) const;
11417 
11418  octave_value get (const std::string& pname) const
11419  {
11420  return get (caseless_str (pname));
11421  }
11422 
11423  octave_value get (const char *pname) const
11424  {
11425  return get (caseless_str (pname));
11426  }
11427 
11428  property get_property (const caseless_str& pname);
11429 
11430  std::string graphics_object_name (void) const { return go_name; }
11431 
11433 
11434 private:
11436 
11437 public:
11438 
11439 
11440  static std::set<std::string> core_property_names (void);
11441 
11442  static std::set<std::string> readonly_property_names (void);
11443 
11444  static bool has_core_property (const caseless_str& pname);
11445 
11446  static bool has_readonly_property (const caseless_str& pname);
11447 
11448  std::set<std::string> all_property_names (void) const;
11449 
11450  bool has_property (const caseless_str& pname) const;
11451 
11452 private:
11453 
11464 
11465 public:
11466 
11467  enum
11468  {
11469  ID___OBJECT__ = 11000,
11470  ID_ACCELERATOR = 11001,
11471  ID_CALLBACK = 11002,
11472  ID_CHECKED = 11003,
11473  ID_ENABLE = 11004,
11474  ID_FOREGROUNDCOLOR = 11005,
11475  ID_LABEL = 11006,
11476  ID_POSITION = 11007,
11477  ID_SEPARATOR = 11008,
11478  ID_FLTK_LABEL = 11009
11479  };
11480 
11481  octave_value get___object__ (void) const { return __object__.get (); }
11482 
11483  std::string get_accelerator (void) const { return accelerator.string_value (); }
11484 
11485  void execute_callback (const octave_value& data = octave_value ()) const { callback.execute (data); }
11486  octave_value get_callback (void) const { return callback.get (); }
11487 
11488  bool is_checked (void) const { return checked.is_on (); }
11489  std::string get_checked (void) const { return checked.current_value (); }
11490 
11491  bool is_enable (void) const { return enable.is_on (); }
11492  std::string get_enable (void) const { return enable.current_value (); }
11493 
11494  bool foregroundcolor_is_rgb (void) const { return foregroundcolor.is_rgb (); }
11495  bool foregroundcolor_is (const std::string& v) const { return foregroundcolor.is (v); }
11496  Matrix get_foregroundcolor_rgb (void) const { return (foregroundcolor.is_rgb () ? foregroundcolor.rgb () : Matrix ()); }
11497  octave_value get_foregroundcolor (void) const { return foregroundcolor.get (); }
11498 
11499  std::string get_label (void) const { return label.string_value (); }
11500 
11501  double get_position (void) const { return position.double_value (); }
11502 
11503  bool is_separator (void) const { return separator.is_on (); }
11504  std::string get_separator (void) const { return separator.current_value (); }
11505 
11506  std::string get_fltk_label (void) const { return fltk_label.string_value (); }
11507 
11508 
11510  {
11511  {
11512  if (__object__.set (val, true))
11513  {
11514  mark_modified ();
11515  }
11516  }
11517  }
11518 
11520  {
11521  {
11522  if (accelerator.set (val, true))
11523  {
11524  mark_modified ();
11525  }
11526  }
11527  }
11528 
11530  {
11531  {
11532  if (callback.set (val, true))
11533  {
11534  mark_modified ();
11535  }
11536  }
11537  }
11538 
11540  {
11541  {
11542  if (checked.set (val, true))
11543  {
11544  mark_modified ();
11545  }
11546  }
11547  }
11548 
11550  {
11551  {
11552  if (enable.set (val, true))
11553  {
11554  mark_modified ();
11555  }
11556  }
11557  }
11558 
11560  {
11561  {
11562  if (foregroundcolor.set (val, true))
11563  {
11564  mark_modified ();
11565  }
11566  }
11567  }
11568 
11570  {
11571  {
11572  if (label.set (val, true))
11573  {
11574  mark_modified ();
11575  }
11576  }
11577  }
11578 
11580  {
11581  {
11582  if (position.set (val, true))
11583  {
11584  mark_modified ();
11585  }
11586  }
11587  }
11588 
11590  {
11591  {
11592  if (separator.set (val, true))
11593  {
11594  mark_modified ();
11595  }
11596  }
11597  }
11598 
11600  {
11601  {
11602  if (fltk_label.set (val, true))
11603  {
11604  mark_modified ();
11605  }
11606  }
11607  }
11608 
11609 
11610  protected:
11611  void init (void)
11612  { }
11613  };
11614 
11615 private:
11617 
11618 public:
11620  : base_graphics_object (), xproperties (mh, p)
11621  { }
11622 
11623  ~uimenu (void) { }
11624 
11625  base_properties& get_properties (void) { return xproperties; }
11626 
11627  const base_properties& get_properties (void) const { return xproperties; }
11628 
11629  bool valid_object (void) const { return true; }
11630 
11632  {
11633  bool retval = xproperties.has_readonly_property (pname);
11634  if (! retval)
11635  retval = base_properties::has_readonly_property (pname);
11636  return retval;
11637  }
11638 
11639 };
11640 
11641 // ---------------------------------------------------------------------
11642 
11643 class OCTINTERP_API uicontextmenu : public base_graphics_object
11644 {
11645 public:
11647  {
11648  public:
11649 
11651  { dependent_obj_list.push_back (gh); }
11652 
11653  // FIXME: the list may contain duplicates.
11654  // Should we return only unique elements?
11655  const std::list<graphics_handle> get_dependent_obj_list (void)
11656  { return dependent_obj_list; }
11657 
11658  // See the genprops.awk script for an explanation of the
11659  // properties declarations.
11660  // Programming note: Keep property list sorted if new ones are added.
11661 
11662 public:
11663  properties (const graphics_handle& mh, const graphics_handle& p);
11664 
11665  ~properties (void) { }
11666 
11667  void set (const caseless_str& pname, const octave_value& val);
11668 
11669  octave_value get (bool all = false) const;
11670 
11671  octave_value get (const caseless_str& pname) const;
11672 
11673  octave_value get (const std::string& pname) const
11674  {
11675  return get (caseless_str (pname));
11676  }
11677 
11678  octave_value get (const char *pname) const
11679  {
11680  return get (caseless_str (pname));
11681  }
11682 
11683  property get_property (const caseless_str& pname);
11684 
11685  std::string graphics_object_name (void) const { return go_name; }
11686 
11688 
11689 private:
11691 
11692 public:
11693 
11694 
11695  static std::set<std::string> core_property_names (void);
11696 
11697  static std::set<std::string> readonly_property_names (void);
11698 
11699  static bool has_core_property (const caseless_str& pname);
11700 
11701  static bool has_readonly_property (const caseless_str& pname);
11702 
11703  std::set<std::string> all_property_names (void) const;
11704 
11705  bool has_property (const caseless_str& pname) const;
11706 
11707 private:
11708 
11712 
11713 public:
11714 
11715  enum
11716  {
11717  ID___OBJECT__ = 12000,
11718  ID_CALLBACK = 12001,
11719  ID_POSITION = 12002
11720  };
11721 
11722  octave_value get___object__ (void) const { return __object__.get (); }
11723 
11724  void execute_callback (const octave_value& data = octave_value ()) const { callback.execute (data); }
11725  octave_value get_callback (void) const { return callback.get (); }
11726 
11727  octave_value get_position (void) const { return position.get (); }
11728 
11729 
11731  {
11732  {
11733  if (__object__.set (val, true))
11734  {
11735  mark_modified ();
11736  }
11737  }
11738  }
11739 
11741  {
11742  {
11743  if (callback.set (val, true))
11744  {
11745  mark_modified ();
11746  }
11747  }
11748  }
11749 
11751  {
11752  {
11753  if (position.set (val, true))
11754  {
11755  mark_modified ();
11756  }
11757  }
11758  }
11759 
11760 
11761  protected:
11762  void init (void)
11763  {
11764  position.add_constraint (dim_vector (1, 2));
11765  position.add_constraint (dim_vector (2, 1));
11766  visible.set (octave_value (false));
11767  }
11768 
11769  private:
11770  // List of objects that might depend on this uicontextmenu object
11771  std::list<graphics_handle> dependent_obj_list;
11772  };
11773 
11774 private:
11776 
11777 public:
11779  : base_graphics_object (), xproperties (mh, p)
11780  { }
11781 
11782  ~uicontextmenu (void);
11783 
11784  base_properties& get_properties (void) { return xproperties; }
11785 
11786  const base_properties& get_properties (void) const { return xproperties; }
11787 
11788  bool valid_object (void) const { return true; }
11789 
11791  {
11792  bool retval = xproperties.has_readonly_property (pname);
11793  if (! retval)
11794  retval = base_properties::has_readonly_property (pname);
11795  return retval;
11796  }
11797 
11798 };
11799 
11800 // ---------------------------------------------------------------------
11801 
11803 {
11804 public:
11806  {
11807  public:
11808  Matrix get_boundingbox (bool internal = false,
11809  const Matrix& parent_pix_size = Matrix ()) const;
11810 
11811  double get_fontsize_points (double box_pix_height = 0) const;
11812 
11813  // See the genprops.awk script for an explanation of the
11814  // properties declarations.
11815  // Programming note: Keep property list sorted if new ones are added.
11816 
11817 public:
11818  properties (const graphics_handle& mh, const graphics_handle& p);
11819 
11820  ~properties (void) { }
11821 
11822  void set (const caseless_str& pname, const octave_value& val);
11823 
11824  octave_value get (bool all = false) const;
11825 
11826  octave_value get (const caseless_str& pname) const;
11827 
11828  octave_value get (const std::string& pname) const
11829  {
11830  return get (caseless_str (pname));
11831  }
11832 
11833  octave_value get (const char *pname) const
11834  {
11835  return get (caseless_str (pname));
11836  }
11837 
11838  property get_property (const caseless_str& pname);
11839 
11840  std::string graphics_object_name (void) const { return go_name; }
11841 
11843 
11844 private:
11846 
11847 public:
11848 
11849 
11850  static std::set<std::string> core_property_names (void);
11851 
11852  static std::set<std::string> readonly_property_names (void);
11853 
11854  static bool has_core_property (const caseless_str& pname);
11855 
11856  static bool has_readonly_property (const caseless_str& pname);
11857 
11858  std::set<std::string> all_property_names (void) const;
11859 
11860  bool has_property (const caseless_str& pname) const;
11861 
11862 private:
11863 
11890 
11891 public:
11892 
11893  enum
11894  {
11895  ID___OBJECT__ = 13000,
11896  ID_BACKGROUNDCOLOR = 13001,
11897  ID_CALLBACK = 13002,
11898  ID_CDATA = 13003,
11899  ID_CLIPPING = 13004,
11900  ID_ENABLE = 13005,
11901  ID_EXTENT = 13006,
11902  ID_FONTANGLE = 13007,
11903  ID_FONTNAME = 13008,
11904  ID_FONTSIZE = 13009,
11905  ID_FONTUNITS = 13010,
11906  ID_FONTWEIGHT = 13011,
11907  ID_FOREGROUNDCOLOR = 13012,
11908  ID_HORIZONTALALIGNMENT = 13013,
11909  ID_KEYPRESSFCN = 13014,
11910  ID_LISTBOXTOP = 13015,
11911  ID_MAX = 13016,
11912  ID_MIN = 13017,
11913  ID_POSITION = 13018,
11914  ID_SLIDERSTEP = 13019,
11915  ID_STRING = 13020,
11916  ID_STYLE = 13021,
11917  ID_TOOLTIPSTRING = 13022,
11918  ID_UNITS = 13023,
11919  ID_VALUE = 13024,
11920  ID_VERTICALALIGNMENT = 13025
11921  };
11922 
11923  octave_value get___object__ (void) const { return __object__.get (); }
11924 
11925  bool backgroundcolor_is_rgb (void) const { return backgroundcolor.is_rgb (); }
11926  bool backgroundcolor_is (const std::string& v) const { return backgroundcolor.is (v); }
11927  Matrix get_backgroundcolor_rgb (void) const { return (backgroundcolor.is_rgb () ? backgroundcolor.rgb () : Matrix ()); }
11928  octave_value get_backgroundcolor (void) const { return backgroundcolor.get (); }
11929 
11930  void execute_callback (const octave_value& data = octave_value ()) const { callback.execute (data); }
11931  octave_value get_callback (void) const { return callback.get (); }
11932 
11933  octave_value get_cdata (void) const { return cdata.get (); }
11934 
11935  bool is_clipping (void) const { return clipping.is_on (); }
11936  std::string get_clipping (void) const { return clipping.current_value (); }
11937 
11938  bool enable_is (const std::string& v) const { return enable.is (v); }
11939  std::string get_enable (void) const { return enable.current_value (); }
11940 
11941  octave_value get_extent (void) const;
11942 
11943  bool fontangle_is (const std::string& v) const { return fontangle.is (v); }
11944  std::string get_fontangle (void) const { return fontangle.current_value (); }
11945 
11946  std::string get_fontname (void) const { return fontname.string_value (); }
11947 
11948  double get_fontsize (void) const { return fontsize.double_value (); }
11949 
11950  bool fontunits_is (const std::string& v) const { return fontunits.is (v); }
11951  std::string get_fontunits (void) const { return fontunits.current_value (); }
11952 
11953  bool fontweight_is (const std::string& v) const { return fontweight.is (v); }
11954  std::string get_fontweight (void) const { return fontweight.current_value (); }
11955 
11956  bool foregroundcolor_is_rgb (void) const { return foregroundcolor.is_rgb (); }
11957  bool foregroundcolor_is (const std::string& v) const { return foregroundcolor.is (v); }
11958  Matrix get_foregroundcolor_rgb (void) const { return (foregroundcolor.is_rgb () ? foregroundcolor.rgb () : Matrix ()); }
11959  octave_value get_foregroundcolor (void) const { return foregroundcolor.get (); }
11960 
11961  bool horizontalalignment_is (const std::string& v) const { return horizontalalignment.is (v); }
11962  std::string get_horizontalalignment (void) const { return horizontalalignment.current_value (); }
11963 
11964  void execute_keypressfcn (const octave_value& data = octave_value ()) const { keypressfcn.execute (data); }
11965  octave_value get_keypressfcn (void) const { return keypressfcn.get (); }
11966 
11967  double get_listboxtop (void) const { return listboxtop.double_value (); }
11968 
11969  double get_max (void) const { return max.double_value (); }
11970 
11971  double get_min (void) const { return min.double_value (); }
11972 
11973  octave_value get_position (void) const { return position.get (); }
11974 
11975  octave_value get_sliderstep (void) const { return sliderstep.get (); }
11976 
11977  std::string get_string_string (void) const { return string.string_value (); }
11978  string_vector get_string_vector (void) const { return string.string_vector_value (); }
11979  octave_value get_string (void) const { return string.get (); }
11980 
11981  bool style_is (const std::string& v) const { return style.is (v); }
11982  std::string get_style (void) const { return style.current_value (); }
11983 
11984  std::string get_tooltipstring (void) const { return tooltipstring.string_value (); }
11985 
11986  bool units_is (const std::string& v) const { return units.is (v); }
11987  std::string get_units (void) const { return units.current_value (); }
11988 
11989  octave_value get_value (void) const { return value.get (); }
11990 
11991  bool verticalalignment_is (const std::string& v) const { return verticalalignment.is (v); }
11992  std::string get_verticalalignment (void) const { return verticalalignment.current_value (); }
11993 
11994 
11996  {
11997  {
11998  if (__object__.set (val, true))
11999  {
12000  mark_modified ();
12001  }
12002  }
12003  }
12004 
12006  {
12007  {
12008  if (backgroundcolor.set (val, true))
12009  {
12010  mark_modified ();
12011  }
12012  }
12013  }
12014 
12016  {
12017  {
12018  if (callback.set (val, true))
12019  {
12020  mark_modified ();
12021  }
12022  }
12023  }
12024 
12026  {
12027  {
12028  if (cdata.set (val, true))
12029  {
12030  mark_modified ();
12031  }
12032  }
12033  }
12034 
12036  {
12037  {
12038  if (clipping.set (val, true))
12039  {
12040  mark_modified ();
12041  }
12042  }
12043  }
12044 
12046  {
12047  {
12048  if (enable.set (val, true))
12049  {
12050  mark_modified ();
12051  }
12052  }
12053  }
12054 
12056  {
12057  {
12058  if (extent.set (val, true))
12059  {
12060  mark_modified ();
12061  }
12062  }
12063  }
12064 
12066  {
12067  {
12068  if (fontangle.set (val, true))
12069  {
12070  update_fontangle ();
12071  mark_modified ();
12072  }
12073  }
12074  }
12075 
12077  {
12078  {
12079  if (fontname.set (val, true))
12080  {
12081  update_fontname ();
12082  mark_modified ();
12083  }
12084  }
12085  }
12086 
12088  {
12089  {
12090  if (fontsize.set (val, true))
12091  {
12092  update_fontsize ();
12093  mark_modified ();
12094  }
12095  }
12096  }
12097 
12098  void set_fontunits (const octave_value& val);
12099 
12101  {
12102  {
12103  if (fontweight.set (val, true))
12104  {
12105  update_fontweight ();
12106  mark_modified ();
12107  }
12108  }
12109  }
12110 
12112  {
12113  {
12114  if (foregroundcolor.set (val, true))
12115  {
12116  mark_modified ();
12117  }
12118  }
12119  }
12120 
12122  {
12123  {
12124  if (horizontalalignment.set (val, true))
12125  {
12126  mark_modified ();
12127  }
12128  }
12129  }
12130 
12132  {
12133  {
12134  if (keypressfcn.set (val, true))
12135  {
12136  mark_modified ();
12137  }
12138  }
12139  }
12140 
12142  {
12143  {
12144  if (listboxtop.set (val, true))
12145  {
12146  mark_modified ();
12147  }
12148  }
12149  }
12150 
12151  void set_max (const octave_value& val)
12152  {
12153  {
12154  if (max.set (val, true))
12155  {
12156  mark_modified ();
12157  }
12158  }
12159  }
12160 
12161  void set_min (const octave_value& val)
12162  {
12163  {
12164  if (min.set (val, true))
12165  {
12166  mark_modified ();
12167  }
12168  }
12169  }
12170 
12172  {
12173  {
12174  if (position.set (val, true))
12175  {
12176  mark_modified ();
12177  }
12178  }
12179  }
12180 
12182  {
12183  {
12184  if (sliderstep.set (val, true))
12185  {
12186  mark_modified ();
12187  }
12188  }
12189  }
12190 
12192  {
12193  {
12194  if (string.set (val, true))
12195  {
12196  update_string ();
12197  mark_modified ();
12198  }
12199  }
12200  }
12201 
12202  void set_style (const octave_value& val);
12203 
12205  {
12206  {
12207  if (tooltipstring.set (val, true))
12208  {
12209  mark_modified ();
12210  }
12211  }
12212  }
12213 
12215  {
12216  {
12217  if (units.set (val, true))
12218  {
12219  update_units ();
12220  mark_modified ();
12221  }
12222  }
12223  }
12224 
12226  {
12227  {
12228  if (value.set (val, true))
12229  {
12230  mark_modified ();
12231  }
12232  }
12233  }
12234 
12236  {
12237  {
12238  if (verticalalignment.set (val, true))
12239  {
12240  mark_modified ();
12241  }
12242  }
12243  }
12244 
12245 
12246  private:
12248 
12249  protected:
12250  void init (void)
12251  {
12252  cdata.add_constraint ("double");
12253  cdata.add_constraint ("single");
12254  cdata.add_constraint (dim_vector (-1, -1, 3));
12255  position.add_constraint (dim_vector (1, 4));
12256  sliderstep.add_constraint (dim_vector (1, 2));
12257  cached_units = get_units ();
12258  }
12259 
12260  void update_text_extent (void);
12261 
12262  void update_string (void) { update_text_extent (); }
12263  void update_fontname (void) { update_text_extent (); }
12264  void update_fontsize (void) { update_text_extent (); }
12265  void update_fontangle (void) { update_text_extent (); }
12266  void update_fontweight (void) { update_text_extent (); }
12267  void update_fontunits (const caseless_str& old_units);
12268 
12269  void update_units (void);
12270 
12271  };
12272 
12273 private:
12275 
12276 public:
12278  : base_graphics_object (), xproperties (mh, p)
12279  { }
12280 
12281  ~uicontrol (void) { }
12282 
12283  base_properties& get_properties (void) { return xproperties; }
12284 
12285  const base_properties& get_properties (void) const { return xproperties; }
12286 
12287  bool valid_object (void) const { return true; }
12288 
12290  {
12291  bool retval = xproperties.has_readonly_property (pname);
12292  if (! retval)
12293  retval = base_properties::has_readonly_property (pname);
12294  return retval;
12295  }
12296 };
12297 
12298 // ---------------------------------------------------------------------
12299 
12301 {
12302 public:
12304  {
12305  public:
12306  Matrix get_boundingbox (bool internal = false,
12307  const Matrix& parent_pix_size = Matrix ()) const;
12308 
12309  double get_fontsize_points (double box_pix_height = 0) const;
12310 
12311  // See the genprops.awk script for an explanation of the
12312  // properties declarations.
12313  // Programming note: Keep property list sorted if new ones are added.
12314 
12315 public:
12316  properties (const graphics_handle& mh, const graphics_handle& p);
12317 
12318  ~properties (void) { }
12319 
12320  void set (const caseless_str& pname, const octave_value& val);
12321 
12322  octave_value get (bool all = false) const;
12323 
12324  octave_value get (const caseless_str& pname) const;
12325 
12326  octave_value get (const std::string& pname) const
12327  {
12328  return get (caseless_str (pname));
12329  }
12330 
12331  octave_value get (const char *pname) const
12332  {
12333  return get (caseless_str (pname));
12334  }
12335 
12336  property get_property (const caseless_str& pname);
12337 
12338  std::string graphics_object_name (void) const { return go_name; }
12339 
12341 
12342 private:
12344 
12345 public:
12346 
12347 
12348  static std::set<std::string> core_property_names (void);
12349 
12350  static std::set<std::string> readonly_property_names (void);
12351 
12352  static bool has_core_property (const caseless_str& pname);
12353 
12354  static bool has_readonly_property (const caseless_str& pname);
12355 
12356  std::set<std::string> all_property_names (void) const;
12357 
12358  bool has_property (const caseless_str& pname) const;
12359 
12360 private:
12361 
12383 
12384 public:
12385 
12386  enum
12387  {
12388  ID___OBJECT__ = 14000,
12389  ID_BACKGROUNDCOLOR = 14001,
12390  ID_BORDERTYPE = 14002,
12391  ID_BORDERWIDTH = 14003,
12392  ID_CLIPPING = 14004,
12393  ID_FONTANGLE = 14005,
12394  ID_FONTNAME = 14006,
12395  ID_FONTSIZE = 14007,
12396  ID_FONTUNITS = 14008,
12397  ID_FONTWEIGHT = 14009,
12398  ID_FOREGROUNDCOLOR = 14010,
12399  ID_HIGHLIGHTCOLOR = 14011,
12400  ID_POSITION = 14012,
12401  ID_RESIZEFCN = 14013,
12402  ID_SELECTEDOBJECT = 14014,
12403  ID_SELECTIONCHANGEDFCN = 14015,
12404  ID_SHADOWCOLOR = 14016,
12405  ID_SIZECHANGEDFCN = 14017,
12406  ID_UNITS = 14018,
12407  ID_TITLE = 14019,
12408  ID_TITLEPOSITION = 14020
12409  };
12410 
12411  octave_value get___object__ (void) const { return __object__.get (); }
12412 
12413  bool backgroundcolor_is_rgb (void) const { return backgroundcolor.is_rgb (); }
12414  bool backgroundcolor_is (const std::string& v) const { return backgroundcolor.is (v); }
12415  Matrix get_backgroundcolor_rgb (void) const { return (backgroundcolor.is_rgb () ? backgroundcolor.rgb () : Matrix ()); }
12416  octave_value get_backgroundcolor (void) const { return backgroundcolor.get (); }
12417 
12418  bool bordertype_is (const std::string& v) const { return bordertype.is (v); }
12419  std::string get_bordertype (void) const { return bordertype.current_value (); }
12420 
12421  double get_borderwidth (void) const { return borderwidth.double_value (); }
12422 
12423  bool is_clipping (void) const { return clipping.is_on (); }
12424  std::string get_clipping (void) const { return clipping.current_value (); }
12425 
12426  bool fontangle_is (const std::string& v) const { return fontangle.is (v); }
12427  std::string get_fontangle (void) const { return fontangle.current_value (); }
12428 
12429  std::string get_fontname (void) const { return fontname.string_value (); }
12430 
12431  double get_fontsize (void) const { return fontsize.double_value (); }
12432 
12433  bool fontunits_is (const std::string& v) const { return fontunits.is (v); }
12434  std::string get_fontunits (void) const { return fontunits.current_value (); }
12435 
12436  bool fontweight_is (const std::string& v) const { return fontweight.is (v); }
12437  std::string get_fontweight (void) const { return fontweight.current_value (); }
12438 
12439  bool foregroundcolor_is_rgb (void) const { return foregroundcolor.is_rgb (); }
12440  bool foregroundcolor_is (const std::string& v) const { return foregroundcolor.is (v); }
12441  Matrix get_foregroundcolor_rgb (void) const { return (foregroundcolor.is_rgb () ? foregroundcolor.rgb () : Matrix ()); }
12442  octave_value get_foregroundcolor (void) const { return foregroundcolor.get (); }
12443 
12444  bool highlightcolor_is_rgb (void) const { return highlightcolor.is_rgb (); }
12445  bool highlightcolor_is (const std::string& v) const { return highlightcolor.is (v); }
12446  Matrix get_highlightcolor_rgb (void) const { return (highlightcolor.is_rgb () ? highlightcolor.rgb () : Matrix ()); }
12447  octave_value get_highlightcolor (void) const { return highlightcolor.get (); }
12448 
12449  octave_value get_position (void) const { return position.get (); }
12450 
12451  void execute_resizefcn (const octave_value& data = octave_value ()) const { resizefcn.execute (data); }
12452  octave_value get_resizefcn (void) const { return resizefcn.get (); }
12453 
12454  graphics_handle get_selectedobject (void) const { return selectedobject.handle_value (); }
12455 
12456  void execute_selectionchangedfcn (const octave_value& data = octave_value ()) const { selectionchangedfcn.execute (data); }
12457  octave_value get_selectionchangedfcn (void) const { return selectionchangedfcn.get (); }
12458 
12459  bool shadowcolor_is_rgb (void) const { return shadowcolor.is_rgb (); }
12460  bool shadowcolor_is (const std::string& v) const { return shadowcolor.is (v); }
12461  Matrix get_shadowcolor_rgb (void) const { return (shadowcolor.is_rgb () ? shadowcolor.rgb () : Matrix ()); }
12462  octave_value get_shadowcolor (void) const { return shadowcolor.get (); }
12463 
12464  void execute_sizechangedfcn (const octave_value& data = octave_value ()) const { sizechangedfcn.execute (data); }
12465  octave_value get_sizechangedfcn (void) const { return sizechangedfcn.get (); }
12466 
12467  bool units_is (const std::string& v) const { return units.is (v); }
12468  std::string get_units (void) const { return units.current_value (); }
12469 
12470  std::string get_title (void) const { return title.string_value (); }
12471 
12472  bool titleposition_is (const std::string& v) const { return titleposition.is (v); }
12473  std::string get_titleposition (void) const { return titleposition.current_value (); }
12474 
12475 
12477  {
12478  {
12479  if (__object__.set (val, true))
12480  {
12481  mark_modified ();
12482  }
12483  }
12484  }
12485 
12487  {
12488  {
12489  if (backgroundcolor.set (val, true))
12490  {
12491  mark_modified ();
12492  }
12493  }
12494  }
12495 
12497  {
12498  {
12499  if (bordertype.set (val, true))
12500  {
12501  mark_modified ();
12502  }
12503  }
12504  }
12505 
12507  {
12508  {
12509  if (borderwidth.set (val, true))
12510  {
12511  mark_modified ();
12512  }
12513  }
12514  }
12515 
12517  {
12518  {
12519  if (clipping.set (val, true))
12520  {
12521  mark_modified ();
12522  }
12523  }
12524  }
12525 
12527  {
12528  {
12529  if (fontangle.set (val, true))
12530  {
12531  mark_modified ();
12532  }
12533  }
12534  }
12535 
12537  {
12538  {
12539  if (fontname.set (val, true))
12540  {
12541  mark_modified ();
12542  }
12543  }
12544  }
12545 
12547  {
12548  {
12549  if (fontsize.set (val, true))
12550  {
12551  mark_modified ();
12552  }
12553  }
12554  }
12555 
12556  void set_fontunits (const octave_value& val);
12557 
12559  {
12560  {
12561  if (fontweight.set (val, true))
12562  {
12563  mark_modified ();
12564  }
12565  }
12566  }
12567 
12569  {
12570  {
12571  if (foregroundcolor.set (val, true))
12572  {
12573  mark_modified ();
12574  }
12575  }
12576  }
12577 
12579  {
12580  {
12581  if (highlightcolor.set (val, true))
12582  {
12583  mark_modified ();
12584  }
12585  }
12586  }
12587 
12589  {
12590  {
12591  if (position.set (val, true))
12592  {
12593  mark_modified ();
12594  }
12595  }
12596  }
12597 
12599  {
12600  {
12601  if (resizefcn.set (val, true))
12602  {
12603  mark_modified ();
12604  }
12605  }
12606  }
12607 
12608  void set_selectedobject (const octave_value& val);
12609 
12611  {
12612  {
12613  if (selectionchangedfcn.set (val, true))
12614  {
12615  mark_modified ();
12616  }
12617  }
12618  }
12619 
12621  {
12622  {
12623  if (shadowcolor.set (val, true))
12624  {
12625  mark_modified ();
12626  }
12627  }
12628  }
12629 
12631  {
12632  {
12633  if (sizechangedfcn.set (val, true))
12634  {
12635  mark_modified ();
12636  }
12637  }
12638  }
12639 
12640  void set_units (const octave_value& val);
12641 
12643  {
12644  {
12645  if (title.set (val, true))
12646  {
12647  mark_modified ();
12648  }
12649  }
12650  }
12651 
12653  {
12654  {
12655  if (titleposition.set (val, true))
12656  {
12657  mark_modified ();
12658  }
12659  }
12660  }
12661 
12662 
12663  protected:
12664  void init (void)
12665  {
12666  position.add_constraint (dim_vector (1, 4));
12667  }
12668 
12669  // void update_text_extent (void);
12670  // void update_string (void) { update_text_extent (); }
12671  // void update_fontname (void) { update_text_extent (); }
12672  // void update_fontsize (void) { update_text_extent (); }
12673  // void update_fontangle (void) { update_text_extent (); }
12674  // void update_fontweight (void) { update_text_extent (); }
12675 
12676  void update_units (const caseless_str& old_units);
12677  void update_fontunits (const caseless_str& old_units);
12678 
12679  };
12680 
12681 private:
12683 
12684 public:
12686  : base_graphics_object (), xproperties (mh, p)
12687  { }
12688 
12689  ~uibuttongroup (void) { }
12690 
12691  base_properties& get_properties (void) { return xproperties; }
12692 
12693  const base_properties& get_properties (void) const { return xproperties; }
12694 
12695  bool valid_object (void) const { return true; }
12696 
12698  {
12699  bool retval = xproperties.has_readonly_property (pname);
12700  if (! retval)
12701  retval = base_properties::has_readonly_property (pname);
12702  return retval;
12703  }
12704 
12705 };
12706 
12707 // ---------------------------------------------------------------------
12708 
12710 {
12711 public:
12713  {
12714  public:
12715  Matrix get_boundingbox (bool internal = false,
12716  const Matrix& parent_pix_size = Matrix ()) const;
12717 
12718  double get_fontsize_points (double box_pix_height = 0) const;
12719 
12720  // See the genprops.awk script for an explanation of the
12721  // properties declarations.
12722  // Programming note: Keep property list sorted if new ones are added.
12723 
12724 public:
12725  properties (const graphics_handle& mh, const graphics_handle& p);
12726 
12727  ~properties (void) { }
12728 
12729  void set (const caseless_str& pname, const octave_value& val);
12730 
12731  octave_value get (bool all = false) const;
12732 
12733  octave_value get (const caseless_str& pname) const;
12734 
12735  octave_value get (const std::string& pname) const
12736  {
12737  return get (caseless_str (pname));
12738  }
12739 
12740  octave_value get (const char *pname) const
12741  {
12742  return get (caseless_str (pname));
12743  }
12744 
12745  property get_property (const caseless_str& pname);
12746 
12747  std::string graphics_object_name (void) const { return go_name; }
12748 
12750 
12751 private:
12753 
12754 public:
12755 
12756 
12757  static std::set<std::string> core_property_names (void);
12758 
12759  static std::set<std::string> readonly_property_names (void);
12760 
12761  static bool has_core_property (const caseless_str& pname);
12762 
12763  static bool has_readonly_property (const caseless_str& pname);
12764 
12765  std::set<std::string> all_property_names (void) const;
12766 
12767  bool has_property (const caseless_str& pname) const;
12768 
12769 private:
12770 
12788 
12789 public:
12790 
12791  enum
12792  {
12793  ID___OBJECT__ = 15000,
12794  ID_BACKGROUNDCOLOR = 15001,
12795  ID_BORDERTYPE = 15002,
12796  ID_BORDERWIDTH = 15003,
12797  ID_FONTANGLE = 15004,
12798  ID_FONTNAME = 15005,
12799  ID_FONTSIZE = 15006,
12800  ID_FONTUNITS = 15007,
12801  ID_FONTWEIGHT = 15008,
12802  ID_FOREGROUNDCOLOR = 15009,
12803  ID_HIGHLIGHTCOLOR = 15010,
12804  ID_POSITION = 15011,
12805  ID_RESIZEFCN = 15012,
12806  ID_SHADOWCOLOR = 15013,
12807  ID_TITLE = 15014,
12808  ID_TITLEPOSITION = 15015,
12809  ID_UNITS = 15016
12810  };
12811 
12812  octave_value get___object__ (void) const { return __object__.get (); }
12813 
12814  bool backgroundcolor_is_rgb (void) const { return backgroundcolor.is_rgb (); }
12815  bool backgroundcolor_is (const std::string& v) const { return backgroundcolor.is (v); }
12816  Matrix get_backgroundcolor_rgb (void) const { return (backgroundcolor.is_rgb () ? backgroundcolor.rgb () : Matrix ()); }
12817  octave_value get_backgroundcolor (void) const { return backgroundcolor.get (); }
12818 
12819  bool bordertype_is (const std::string& v) const { return bordertype.is (v); }
12820  std::string get_bordertype (void) const { return bordertype.current_value (); }
12821 
12822  double get_borderwidth (void) const { return borderwidth.double_value (); }
12823 
12824  bool fontangle_is (const std::string& v) const { return fontangle.is (v); }
12825  std::string get_fontangle (void) const { return fontangle.current_value (); }
12826 
12827  std::string get_fontname (void) const { return fontname.string_value (); }
12828 
12829  double get_fontsize (void) const { return fontsize.double_value (); }
12830 
12831  bool fontunits_is (const std::string& v) const { return fontunits.is (v); }
12832  std::string get_fontunits (void) const { return fontunits.current_value (); }
12833 
12834  bool fontweight_is (const std::string& v) const { return fontweight.is (v); }
12835  std::string get_fontweight (void) const { return fontweight.current_value (); }
12836 
12837  bool foregroundcolor_is_rgb (void) const { return foregroundcolor.is_rgb (); }
12838  bool foregroundcolor_is (const std::string& v) const { return foregroundcolor.is (v); }
12839  Matrix get_foregroundcolor_rgb (void) const { return (foregroundcolor.is_rgb () ? foregroundcolor.rgb () : Matrix ()); }
12840  octave_value get_foregroundcolor (void) const { return foregroundcolor.get (); }
12841 
12842  bool highlightcolor_is_rgb (void) const { return highlightcolor.is_rgb (); }
12843  bool highlightcolor_is (const std::string& v) const { return highlightcolor.is (v); }
12844  Matrix get_highlightcolor_rgb (void) const { return (highlightcolor.is_rgb () ? highlightcolor.rgb () : Matrix ()); }
12845  octave_value get_highlightcolor (void) const { return highlightcolor.get (); }
12846 
12847  octave_value get_position (void) const { return position.get (); }
12848 
12849  void execute_resizefcn (const octave_value& data = octave_value ()) const { resizefcn.execute (data); }
12850  octave_value get_resizefcn (void) const { return resizefcn.get (); }
12851 
12852  bool shadowcolor_is_rgb (void) const { return shadowcolor.is_rgb (); }
12853  bool shadowcolor_is (const std::string& v) const { return shadowcolor.is (v); }
12854  Matrix get_shadowcolor_rgb (void) const { return (shadowcolor.is_rgb () ? shadowcolor.rgb () : Matrix ()); }
12855  octave_value get_shadowcolor (void) const { return shadowcolor.get (); }
12856 
12857  std::string get_title (void) const { return title.string_value (); }
12858 
12859  bool titleposition_is (const std::string& v) const { return titleposition.is (v); }
12860  std::string get_titleposition (void) const { return titleposition.current_value (); }
12861 
12862  bool units_is (const std::string& v) const { return units.is (v); }
12863  std::string get_units (void) const { return units.current_value (); }
12864 
12865 
12867  {
12868  {
12869  if (__object__.set (val, true))
12870  {
12871  mark_modified ();
12872  }
12873  }
12874  }
12875 
12877  {
12878  {
12879  if (backgroundcolor.set (val, true))
12880  {
12881  mark_modified ();
12882  }
12883  }
12884  }
12885 
12887  {
12888  {
12889  if (bordertype.set (val, true))
12890  {
12891  mark_modified ();
12892  }
12893  }
12894  }
12895 
12897  {
12898  {
12899  if (borderwidth.set (val, true))
12900  {
12901  mark_modified ();
12902  }
12903  }
12904  }
12905 
12907  {
12908  {
12909  if (fontangle.set (val, true))
12910  {
12911  mark_modified ();
12912  }
12913  }
12914  }
12915 
12917  {
12918  {
12919  if (fontname.set (val, true))
12920  {
12921  mark_modified ();
12922  }
12923  }
12924  }
12925 
12927  {
12928  {
12929  if (fontsize.set (val, true))
12930  {
12931  mark_modified ();
12932  }
12933  }
12934  }
12935 
12936  void set_fontunits (const octave_value& val);
12937 
12939  {
12940  {
12941  if (fontweight.set (val, true))
12942  {
12943  mark_modified ();
12944  }
12945  }
12946  }
12947 
12949  {
12950  {
12951  if (foregroundcolor.set (val, true))
12952  {
12953  mark_modified ();
12954  }
12955  }
12956  }
12957 
12959  {
12960  {
12961  if (highlightcolor.set (val, true))
12962  {
12963  mark_modified ();
12964  }
12965  }
12966  }
12967 
12969  {
12970  {
12971  if (position.set (val, true))
12972  {
12973  mark_modified ();
12974  }
12975  }
12976  }
12977 
12979  {
12980  {
12981  if (resizefcn.set (val, true))
12982  {
12983  mark_modified ();
12984  }
12985  }
12986  }
12987 
12989  {
12990  {
12991  if (shadowcolor.set (val, true))
12992  {
12993  mark_modified ();
12994  }
12995  }
12996  }
12997 
12999  {
13000  {
13001  if (title.set (val, true))
13002  {
13003  mark_modified ();
13004  }
13005  }
13006  }
13007 
13009  {
13010  {
13011  if (titleposition.set (val, true))
13012  {
13013  mark_modified ();
13014  }
13015  }
13016  }
13017 
13018  void set_units (const octave_value& val);
13019 
13020 
13021  protected:
13022  void init (void)
13023  {
13024  position.add_constraint (dim_vector (1, 4));
13025  }
13026 
13027  void update_units (const caseless_str& old_units);
13028  void update_fontunits (const caseless_str& old_units);
13029 
13030  };
13031 
13032 private:
13034 
13035 public:
13037  : base_graphics_object (), xproperties (mh, p)
13038  { }
13039 
13040  ~uipanel (void) { }
13041 
13042  base_properties& get_properties (void) { return xproperties; }
13043 
13044  const base_properties& get_properties (void) const { return xproperties; }
13045 
13046  bool valid_object (void) const { return true; }
13047 
13049  {
13050  bool retval = xproperties.has_readonly_property (pname);
13051  if (! retval)
13052  retval = base_properties::has_readonly_property (pname);
13053  return retval;
13054  }
13055 };
13056 
13057 // ---------------------------------------------------------------------
13058 
13060 {
13061 public:
13063  {
13064  public:
13065  // See the genprops.awk script for an explanation of the
13066  // properties declarations.
13067  // Programming note: Keep property list sorted if new ones are added.
13068 
13069 public:
13070  properties (const graphics_handle& mh, const graphics_handle& p);
13071 
13072  ~properties (void) { }
13073 
13074  void set (const caseless_str& pname, const octave_value& val);
13075 
13076  octave_value get (bool all = false) const;
13077 
13078  octave_value get (const caseless_str& pname) const;
13079 
13080  octave_value get (const std::string& pname) const
13081  {
13082  return get (caseless_str (pname));
13083  }
13084 
13085  octave_value get (const char *pname) const
13086  {
13087  return get (caseless_str (pname));
13088  }
13089 
13090  property get_property (const caseless_str& pname);
13091 
13092  std::string graphics_object_name (void) const { return go_name; }
13093 
13095 
13096 private:
13098 
13099 public:
13100 
13101 
13102  static std::set<std::string> core_property_names (void);
13103 
13104  static std::set<std::string> readonly_property_names (void);
13105 
13106  static bool has_core_property (const caseless_str& pname);
13107 
13108  static bool has_readonly_property (const caseless_str& pname);
13109 
13110  std::set<std::string> all_property_names (void) const;
13111 
13112  bool has_property (const caseless_str& pname) const;
13113 
13114 private:
13115 
13117 
13118 public:
13119 
13120  enum
13121  {
13122  ID___OBJECT__ = 16000
13123  };
13124 
13125  octave_value get___object__ (void) const { return __object__.get (); }
13126 
13127 
13129  {
13130  {
13131  if (__object__.set (val, true))
13132  {
13133  mark_modified ();
13134  }
13135  }
13136  }
13137 
13138 
13139  protected:
13140  void init (void)
13141  { }
13142  };
13143 
13144 private:
13146 
13147 public:
13149  : base_graphics_object (), xproperties (mh, p), default_properties ()
13150  { }
13151 
13152  ~uitoolbar (void) { }
13153 
13155  {
13156  // Allow parent (figure) to override first (properties knows how
13157  // to find the parent object).
13158  xproperties.override_defaults (obj);
13159 
13160  // Now override with our defaults. If the default_properties
13161  // list includes the properties for all defaults (line,
13162  // surface, etc.) then we don't have to know the type of OBJ
13163  // here, we just call its set function and let it decide which
13164  // properties from the list to use.
13165  obj.set_from_list (default_properties);
13166  }
13167 
13168  void set (const caseless_str& name, const octave_value& value)
13169  {
13170  if (name.compare ("default", 7))
13171  // strip "default", pass rest to function that will
13172  // parse the remainder and add the element to the
13173  // default_properties map.
13174  default_properties.set (name.substr (7), value);
13175  else
13176  xproperties.set (name, value);
13177  }
13178 
13179  octave_value get (const caseless_str& name) const
13180  {
13182 
13183  if (name.compare ("default", 7))
13184  retval = get_default (name.substr (7));
13185  else
13186  retval = xproperties.get (name);
13187 
13188  return retval;
13189  }
13190 
13191  octave_value get_default (const caseless_str& name) const;
13192 
13194  {
13195  return default_properties.as_struct ("default");
13196  }
13197 
13199  {
13200  return default_properties;
13201  }
13202 
13203  base_properties& get_properties (void) { return xproperties; }
13204 
13205  const base_properties& get_properties (void) const { return xproperties; }
13206 
13207  bool valid_object (void) const { return true; }
13208 
13209  void reset_default_properties (void);
13210 
13212  {
13213  bool retval = xproperties.has_readonly_property (pname);
13214  if (! retval)
13215  retval = base_properties::has_readonly_property (pname);
13216  return retval;
13217  }
13218 
13219 private:
13221 };
13222 
13223 // ---------------------------------------------------------------------
13224 
13226 {
13227 public:
13229  {
13230  public:
13231  // See the genprops.awk script for an explanation of the
13232  // properties declarations.
13233  // Programming note: Keep property list sorted if new ones are added.
13234 
13235 public:
13236  properties (const graphics_handle& mh, const graphics_handle& p);
13237 
13238  ~properties (void) { }
13239 
13240  void set (const caseless_str& pname, const octave_value& val);
13241 
13242  octave_value get (bool all = false) const;
13243 
13244  octave_value get (const caseless_str& pname) const;
13245 
13246  octave_value get (const std::string& pname) const
13247  {
13248  return get (caseless_str (pname));
13249  }
13250 
13251  octave_value get (const char *pname) const
13252  {
13253  return get (caseless_str (pname));
13254  }
13255 
13256  property get_property (const caseless_str& pname);
13257 
13258  std::string graphics_object_name (void) const { return go_name; }
13259 
13261 
13262 private:
13264 
13265 public:
13266 
13267 
13268  static std::set<std::string> core_property_names (void);
13269 
13270  static std::set<std::string> readonly_property_names (void);
13271 
13272  static bool has_core_property (const caseless_str& pname);
13273 
13274  static bool has_readonly_property (const caseless_str& pname);
13275 
13276  std::set<std::string> all_property_names (void) const;
13277 
13278  bool has_property (const caseless_str& pname) const;
13279 
13280 private:
13281 
13288 
13289 public:
13290 
13291  enum
13292  {
13293  ID___OBJECT__ = 17000,
13294  ID_CDATA = 17001,
13295  ID_CLICKEDCALLBACK = 17002,
13296  ID_ENABLE = 17003,
13297  ID_SEPARATOR = 17004,
13298  ID_TOOLTIPSTRING = 17005
13299  };
13300 
13301  octave_value get___object__ (void) const { return __object__.get (); }
13302 
13303  octave_value get_cdata (void) const { return cdata.get (); }
13304 
13305  void execute_clickedcallback (const octave_value& data = octave_value ()) const { clickedcallback.execute (data); }
13306  octave_value get_clickedcallback (void) const { return clickedcallback.get (); }
13307 
13308  bool is_enable (void) const { return enable.is_on (); }
13309  std::string get_enable (void) const { return enable.current_value (); }
13310 
13311  bool is_separator (void) const { return separator.is_on (); }
13312  std::string get_separator (void) const { return separator.current_value (); }
13313 
13314  std::string get_tooltipstring (void) const { return tooltipstring.string_value (); }
13315 
13316 
13318  {
13319  {
13320  if (__object__.set (val, true))
13321  {
13322  mark_modified ();
13323  }
13324  }
13325  }
13326 
13328  {
13329  {
13330  if (cdata.set (val, true))
13331  {
13332  mark_modified ();
13333  }
13334  }
13335  }
13336 
13338  {
13339  {
13340  if (clickedcallback.set (val, true))
13341  {
13342  mark_modified ();
13343  }
13344  }
13345  }
13346 
13348  {
13349  {
13350  if (enable.set (val, true))
13351  {
13352  mark_modified ();
13353  }
13354  }
13355  }
13356 
13358  {
13359  {
13360  if (separator.set (val, true))
13361  {
13362  mark_modified ();
13363  }
13364  }
13365  }
13366 
13368  {
13369  {
13370  if (tooltipstring.set (val, true))
13371  {
13372  mark_modified ();
13373  }
13374  }
13375  }
13376 
13377 
13378  protected:
13379  void init (void)
13380  {
13381  cdata.add_constraint ("double");
13382  cdata.add_constraint ("single");
13383  cdata.add_constraint (dim_vector (-1, -1, 3));
13384  }
13385  };
13386 
13387 private:
13389 
13390 public:
13392  : base_graphics_object (), xproperties (mh, p)
13393  { }
13394 
13395  ~uipushtool (void) { }
13396 
13397  base_properties& get_properties (void) { return xproperties; }
13398 
13399  const base_properties& get_properties (void) const { return xproperties; }
13400 
13401  bool valid_object (void) const { return true; }
13402 
13404  {
13405  bool retval = xproperties.has_readonly_property (pname);
13406  if (! retval)
13407  retval = base_properties::has_readonly_property (pname);
13408  return retval;
13409  }
13410 
13411 };
13412 
13413 // ---------------------------------------------------------------------
13414 
13416 {
13417 public:
13419  {
13420  public:
13421  // See the genprops.awk script for an explanation of the
13422  // properties declarations.
13423  // Programming note: Keep property list sorted if new ones are added.
13424 
13425 public:
13426  properties (const graphics_handle& mh, const graphics_handle& p);
13427 
13428  ~properties (void) { }
13429 
13430  void set (const caseless_str& pname, const octave_value& val);
13431 
13432  octave_value get (bool all = false) const;
13433 
13434  octave_value get (const caseless_str& pname) const;
13435 
13436  octave_value get (const std::string& pname) const
13437  {
13438  return get (caseless_str (pname));
13439  }
13440 
13441  octave_value get (const char *pname) const
13442  {
13443  return get (caseless_str (pname));
13444  }
13445 
13446  property get_property (const caseless_str& pname);
13447 
13448  std::string graphics_object_name (void) const { return go_name; }
13449 
13451 
13452 private:
13454 
13455 public:
13456 
13457 
13458  static std::set<std::string> core_property_names (void);
13459 
13460  static std::set<std::string> readonly_property_names (void);
13461 
13462  static bool has_core_property (const caseless_str& pname);
13463 
13464  static bool has_readonly_property (const caseless_str& pname);
13465 
13466  std::set<std::string> all_property_names (void) const;
13467 
13468  bool has_property (const caseless_str& pname) const;
13469 
13470 private:
13471 
13481 
13482 public:
13483 
13484  enum
13485  {
13486  ID___OBJECT__ = 18000,
13487  ID_CDATA = 18001,
13488  ID_CLICKEDCALLBACK = 18002,
13489  ID_ENABLE = 18003,
13490  ID_OFFCALLBACK = 18004,
13491  ID_ONCALLBACK = 18005,
13492  ID_SEPARATOR = 18006,
13493  ID_STATE = 18007,
13494  ID_TOOLTIPSTRING = 18008
13495  };
13496 
13497  octave_value get___object__ (void) const { return __object__.get (); }
13498 
13499  octave_value get_cdata (void) const { return cdata.get (); }
13500 
13501  void execute_clickedcallback (const octave_value& data = octave_value ()) const { clickedcallback.execute (data); }
13502  octave_value get_clickedcallback (void) const { return clickedcallback.get (); }
13503 
13504  bool is_enable (void) const { return enable.is_on (); }
13505  std::string get_enable (void) const { return enable.current_value (); }
13506 
13507  void execute_offcallback (const octave_value& data = octave_value ()) const { offcallback.execute (data); }
13508  octave_value get_offcallback (void) const { return offcallback.get (); }
13509 
13510  void execute_oncallback (const octave_value& data = octave_value ()) const { oncallback.execute (data); }
13511  octave_value get_oncallback (void) const { return oncallback.get (); }
13512 
13513  bool is_separator (void) const { return separator.is_on (); }
13514  std::string get_separator (void) const { return separator.current_value (); }
13515 
13516  bool is_state (void) const { return state.is_on (); }
13517  std::string get_state (void) const { return state.current_value (); }
13518 
13519  std::string get_tooltipstring (void) const { return tooltipstring.string_value (); }
13520 
13521 
13523  {
13524  {
13525  if (__object__.set (val, true))
13526  {
13527  mark_modified ();
13528  }
13529  }
13530  }
13531 
13533  {
13534  {
13535  if (cdata.set (val, true))
13536  {
13537  mark_modified ();
13538  }
13539  }
13540  }
13541 
13543  {
13544  {
13545  if (clickedcallback.set (val, true))
13546  {
13547  mark_modified ();
13548  }
13549  }
13550  }
13551 
13553  {
13554  {
13555  if (enable.set (val, true))
13556  {
13557  mark_modified ();
13558  }
13559  }
13560  }
13561 
13563  {
13564  {
13565  if (offcallback.set (val, true))
13566  {
13567  mark_modified ();
13568  }
13569  }
13570  }
13571 
13573  {
13574  {
13575  if (oncallback.set (val, true))
13576  {
13577  mark_modified ();
13578  }
13579  }
13580  }
13581 
13583  {
13584  {
13585  if (separator.set (val, true))
13586  {
13587  mark_modified ();
13588  }
13589  }
13590  }
13591 
13593  {
13594  {
13595  if (state.set (val, true))
13596  {
13597  mark_modified ();
13598  }
13599  }
13600  }
13601 
13603  {
13604  {
13605  if (tooltipstring.set (val, true))
13606  {
13607  mark_modified ();
13608  }
13609  }
13610  }
13611 
13612 
13613  protected:
13614  void init (void)
13615  {
13616  cdata.add_constraint ("double");
13617  cdata.add_constraint ("single");
13618  cdata.add_constraint (dim_vector (-1, -1, 3));
13619  }
13620  };
13621 
13622 private:
13624 
13625 public:
13627  : base_graphics_object (), xproperties (mh, p)
13628  { }
13629 
13630  ~uitoggletool (void) { }
13631 
13632  base_properties& get_properties (void) { return xproperties; }
13633 
13634  const base_properties& get_properties (void) const { return xproperties; }
13635 
13636  bool valid_object (void) const { return true; }
13637 
13639  {
13640  bool retval = xproperties.has_readonly_property (pname);
13641  if (! retval)
13642  retval = base_properties::has_readonly_property (pname);
13643  return retval;
13644  }
13645 
13646 };
13647 
13648 // ---------------------------------------------------------------------
13649 
13651 get_property_from_handle (double handle, const std::string& property,
13652  const std::string& func);
13653 bool
13654 set_property_in_handle (double handle, const std::string& property,
13655  const octave_value& arg, const std::string& func);
13656 
13657 // ---------------------------------------------------------------------
13658 
13659 class graphics_event;
13660 
13661 class
13663 {
13664 public:
13665  friend class graphics_event;
13666 
13667  base_graphics_event (void) : count (1) { }
13668 
13669  virtual ~base_graphics_event (void) { }
13670 
13671  virtual void execute (void) = 0;
13672 
13673 private:
13675 };
13676 
13677 class
13679 {
13680 public:
13681  typedef void (*event_fcn) (void*);
13682 
13683  graphics_event (void) : rep (0) { }
13684 
13686  {
13687  rep->count++;
13688  }
13689 
13691  {
13692  if (rep && --rep->count == 0)
13693  delete rep;
13694  }
13695 
13697  {
13698  if (rep != e.rep)
13699  {
13700  if (rep && --rep->count == 0)
13701  delete rep;
13702 
13703  rep = e.rep;
13704  if (rep)
13705  rep->count++;
13706  }
13707 
13708  return *this;
13709  }
13710 
13711  void execute (void)
13712  { if (rep) rep->execute (); }
13713 
13714  bool ok (void) const
13715  { return (rep != 0); }
13716 
13717  static graphics_event
13719  const std::string& name,
13720  const octave_value& data = Matrix ());
13721 
13722  static graphics_event
13724  const octave_value& cb,
13725  const octave_value& data = Matrix ());
13726 
13727  static graphics_event
13728  create_function_event (event_fcn fcn, void *data = 0);
13729 
13730  static graphics_event
13731  create_set_event (const graphics_handle& h, const std::string& name,
13732  const octave_value& value,
13733  bool notify_toolkit = true);
13734 private:
13736 };
13737 
13739 {
13740 protected:
13741 
13742  gh_manager (void);
13743 
13744 public:
13745 
13746  static void create_instance (void);
13747 
13748  static bool instance_ok (void)
13749  {
13750  bool retval = true;
13751 
13752  if (! instance)
13753  create_instance ();
13754 
13755  if (! instance)
13756  error ("unable to create gh_manager!");
13757 
13758  return retval;
13759  }
13760 
13761  static void cleanup_instance (void) { delete instance; instance = 0; }
13762 
13763  static graphics_handle get_handle (bool integer_figure_handle)
13764  {
13765  return instance_ok ()
13766  ? instance->do_get_handle (integer_figure_handle)
13767  : graphics_handle ();
13768  }
13769 
13770  static void free (const graphics_handle& h)
13771  {
13772  if (instance_ok ())
13773  instance->do_free (h);
13774  }
13775 
13776  static void renumber_figure (const graphics_handle& old_gh,
13777  const graphics_handle& new_gh)
13778  {
13779  if (instance_ok ())
13780  instance->do_renumber_figure (old_gh, new_gh);
13781  }
13782 
13783  static graphics_handle lookup (double val)
13784  {
13785  return instance_ok () ? instance->do_lookup (val) : graphics_handle ();
13786  }
13787 
13789  {
13790  return val.is_real_scalar ()
13791  ? lookup (val.double_value ()) : graphics_handle ();
13792  }
13793 
13795  {
13796  return get_object (lookup (val));
13797  }
13798 
13800  {
13801  return instance_ok () ? instance->do_get_object (h) : graphics_object ();
13802  }
13803 
13804  static graphics_handle
13806  const graphics_handle& parent,
13807  bool integer_figure_handle = false,
13808  bool do_createfcn = true,
13809  bool do_notify_toolkit = true)
13810  {
13811  return instance_ok ()
13812  ? instance->do_make_graphics_handle (go_name, parent,
13813  integer_figure_handle,
13814  do_createfcn, do_notify_toolkit)
13815  : graphics_handle ();
13816  }
13817 
13819  bool do_notify_toolkit = true)
13820  {
13821  return instance_ok ()
13822  ? instance->do_make_figure_handle (val, do_notify_toolkit)
13823  : graphics_handle ();
13824  }
13825 
13826  static void push_figure (const graphics_handle& h)
13827  {
13828  if (instance_ok ())
13829  instance->do_push_figure (h);
13830  }
13831 
13832  static void pop_figure (const graphics_handle& h)
13833  {
13834  if (instance_ok ())
13835  instance->do_pop_figure (h);
13836  }
13837 
13839  {
13840  return instance_ok ()
13841  ? instance->do_current_figure () : graphics_handle ();
13842  }
13843 
13844  static Matrix handle_list (bool show_hidden = false)
13845  {
13846  return instance_ok ()
13847  ? instance->do_handle_list (show_hidden) : Matrix ();
13848  }
13849 
13850  static void lock (void)
13851  {
13852  if (instance_ok ())
13853  instance->do_lock ();
13854  }
13855 
13856  static bool try_lock (void)
13857  {
13858  if (instance_ok ())
13859  return instance->do_try_lock ();
13860  else
13861  return false;
13862  }
13863 
13864  static void unlock (void)
13865  {
13866  if (instance_ok ())
13867  instance->do_unlock ();
13868  }
13869 
13870  static Matrix figure_handle_list (bool show_hidden = false)
13871  {
13872  return instance_ok ()
13873  ? instance->do_figure_handle_list (show_hidden) : Matrix ();
13874  }
13875 
13876  static void execute_listener (const graphics_handle& h,
13877  const octave_value& l)
13878  {
13879  if (instance_ok ())
13880  instance->do_execute_listener (h, l);
13881  }
13882 
13883  static void execute_callback (const graphics_handle& h,
13884  const std::string& name,
13885  const octave_value& data = Matrix ())
13886  {
13887  octave_value cb;
13888 
13889  if (true)
13890  {
13891  gh_manager::auto_lock lock;
13892 
13893  graphics_object go = get_object (h);
13894 
13895  if (go.valid_object ())
13896  cb = go.get (name);
13897  }
13898 
13899  execute_callback (h, cb, data);
13900  }
13901 
13902  static void execute_callback (const graphics_handle& h,
13903  const octave_value& cb,
13904  const octave_value& data = Matrix ())
13905  {
13906  if (instance_ok ())
13907  instance->do_execute_callback (h, cb, data);
13908  }
13909 
13910  static void post_callback (const graphics_handle& h,
13911  const std::string& name,
13912  const octave_value& data = Matrix ())
13913  {
13914  if (instance_ok ())
13915  instance->do_post_callback (h, name, data);
13916  }
13917 
13918  static void post_function (graphics_event::event_fcn fcn, void* data = 0)
13919  {
13920  if (instance_ok ())
13921  instance->do_post_function (fcn, data);
13922  }
13923 
13924  static void post_set (const graphics_handle& h, const std::string& name,
13925  const octave_value& value, bool notify_toolkit = true)
13926  {
13927  if (instance_ok ())
13928  instance->do_post_set (h, name, value, notify_toolkit);
13929  }
13930 
13931  static int process_events (void)
13932  {
13933  return (instance_ok () ? instance->do_process_events () : 0);
13934  }
13935 
13936  static int flush_events (void)
13937  {
13938  return (instance_ok () ? instance->do_process_events (true) : 0);
13939  }
13940 
13941  static void enable_event_processing (bool enable = true)
13942  {
13943  if (instance_ok ())
13944  instance->do_enable_event_processing (enable);
13945  }
13946 
13947  static bool is_handle_visible (const graphics_handle& h)
13948  {
13949  bool retval = false;
13950 
13951  graphics_object go = get_object (h);
13952 
13953  if (go.valid_object ())
13954  retval = go.is_handle_visible ();
13955 
13956  return retval;
13957  }
13958 
13959  static void close_all_figures (void)
13960  {
13961  if (instance_ok ())
13962  instance->do_close_all_figures ();
13963  }
13964 
13965 public:
13967  {
13968  public:
13969  auto_lock (bool wait = true)
13970  : octave_autolock (instance_ok ()
13971  ? instance->graphics_lock
13972  : octave_mutex (),
13973  wait)
13974  { }
13975 
13976  private:
13977 
13978  // No copying!
13979  auto_lock (const auto_lock&);
13980  auto_lock& operator = (const auto_lock&);
13981  };
13982 
13983 private:
13984 
13986 
13987  typedef std::map<graphics_handle, graphics_object>::iterator iterator;
13988  typedef std::map<graphics_handle, graphics_object>::const_iterator
13990 
13991  typedef std::set<graphics_handle>::iterator free_list_iterator;
13992  typedef std::set<graphics_handle>::const_iterator const_free_list_iterator;
13993 
13994  typedef std::list<graphics_handle>::iterator figure_list_iterator;
13995  typedef std::list<graphics_handle>::const_iterator const_figure_list_iterator;
13996 
13997  // A map of handles to graphics objects.
13998  std::map<graphics_handle, graphics_object> handle_map;
13999 
14000  // The available graphics handles.
14001  std::set<graphics_handle> handle_free_list;
14002 
14003  // The next handle available if handle_free_list is empty.
14004  double next_handle;
14005 
14006  // The allocated figure handles. Top of the stack is most recently
14007  // created.
14008  std::list<graphics_handle> figure_list;
14009 
14010  // The lock for accessing the graphics sytsem.
14012 
14013  // The list of events queued by graphics toolkits.
14014  std::list<graphics_event> event_queue;
14015 
14016  // The stack of callback objects.
14017  std::list<graphics_object> callback_objects;
14018 
14019  // A flag telling whether event processing must be constantly on.
14021 
14022  graphics_handle do_get_handle (bool integer_figure_handle);
14023 
14024  void do_free (const graphics_handle& h);
14025 
14026  void do_renumber_figure (const graphics_handle& old_gh,
14027  const graphics_handle& new_gh);
14028 
14030  {
14031  iterator p = (octave::math::isnan (val) ? handle_map.end ()
14032  : handle_map.find (val));
14033 
14034  return (p != handle_map.end ()) ? p->first : graphics_handle ();
14035  }
14036 
14038  {
14039  iterator p = (h.ok () ? handle_map.find (h) : handle_map.end ());
14040 
14041  return (p != handle_map.end ()) ? p->second : graphics_object ();
14042  }
14043 
14044  graphics_handle do_make_graphics_handle (const std::string& go_name,
14045  const graphics_handle& p,
14046  bool integer_figure_handle,
14047  bool do_createfcn,
14048  bool do_notify_toolkit);
14049 
14050  graphics_handle do_make_figure_handle (double val, bool do_notify_toolkit);
14051 
14052  Matrix do_handle_list (bool show_hidden)
14053  {
14054  Matrix retval (1, handle_map.size ());
14055 
14056  octave_idx_type i = 0;
14057  for (const auto& h_iter : handle_map)
14058  {
14059  graphics_handle h = h_iter.first;
14060 
14061  if (show_hidden || is_handle_visible (h))
14062  retval(i++) = h.value ();
14063  }
14064 
14065  retval.resize (1, i);
14066 
14067  return retval;
14068  }
14069 
14070  Matrix do_figure_handle_list (bool show_hidden)
14071  {
14072  Matrix retval (1, figure_list.size ());
14073 
14074  octave_idx_type i = 0;
14075  for (const auto& hfig : figure_list)
14076  {
14077  if (show_hidden || is_handle_visible (hfig))
14078  retval(i++) = hfig.value ();
14079  }
14080 
14081  retval.resize (1, i);
14082 
14083  return retval;
14084  }
14085 
14086  void do_push_figure (const graphics_handle& h);
14087 
14088  void do_pop_figure (const graphics_handle& h);
14089 
14091  {
14093 
14094  for (const auto& hfig : figure_list)
14095  {
14096  if (is_handle_visible (hfig))
14097  retval = hfig;
14098  }
14099 
14100  return retval;
14101  }
14102 
14103  void do_lock (void) { graphics_lock.lock (); }
14104 
14105  bool do_try_lock (void) { return graphics_lock.try_lock (); }
14106 
14107  void do_unlock (void) { graphics_lock.unlock (); }
14108 
14109  void do_execute_listener (const graphics_handle& h, const octave_value& l);
14110 
14111  void do_execute_callback (const graphics_handle& h, const octave_value& cb,
14112  const octave_value& data);
14113 
14114  void do_post_callback (const graphics_handle& h, const std::string& name,
14115  const octave_value& data);
14116 
14117  void do_post_function (graphics_event::event_fcn fcn, void* fcn_data);
14118 
14119  void do_post_set (const graphics_handle& h, const std::string& name,
14120  const octave_value& value, bool notify_toolkit = true);
14121 
14122  int do_process_events (bool force = false);
14123 
14124  void do_close_all_figures (void);
14125 
14126  static void restore_gcbo (void)
14127  {
14128  if (instance_ok ())
14129  instance->do_restore_gcbo ();
14130  }
14131 
14132  void do_restore_gcbo (void);
14133 
14134  void do_post_event (const graphics_event& e);
14135 
14136  void do_enable_event_processing (bool enable = true);
14137 };
14138 
14139 void get_children_limits (double& min_val, double& max_val,
14140  double& min_pos, double& max_neg,
14141  const Matrix& kids, char limit_type);
14142 
14144 
14145 // This function is NOT equivalent to the scripting language function gcf.
14147 
14148 // This function is NOT equivalent to the scripting language function gca.
14150 
14151 OCTINTERP_API void close_all_figures (void);
14152 
14153 #endif
bool_property zliminclude
Definition: graphics.h:7516
std::string get_fontunits(void) const
Definition: graphics.h:11951
bool is_rgb(void) const
Definition: graphics.h:1104
void set_callback(const octave_value &val)
Definition: graphics.h:12015
void set_interpreter(const octave_value &val)
Definition: graphics.h:10668
octave_value get_zcolor(void) const
Definition: graphics.h:5668
double get_screen_resolution(void) const
Definition: graphics.h:2208
static void close_all_figures(void)
Definition: graphics.h:13959
void validate(void) const
Definition: graphics.h:1032
array_property currentpoint
Definition: graphics.h:3869
void set_windowkeypressfcn(const octave_value &val)
Definition: graphics.h:4540
enum double_radio_property::current_enum current_type
radio_property fontunits
Definition: graphics.h:7975
bool is_climinclude(void) const
Definition: graphics.h:10195
bool_property zliminclude
Definition: graphics.h:9393
void set_createfcn(const octave_value &val)
Definition: graphics.h:2763
radio_property yticklabelmode
Definition: graphics.h:5245
void do_register_toolkit(const std::string &name)
Definition: graphics.cc:10935
bool do_set(const octave_value &newval)
Definition: graphics.h:952
virtual base_property * clone(void) const
Definition: graphics.h:392
void execute_closerequestfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4001
std::string get_linestyle(void) const
Definition: graphics.h:10413
void set_specularstrength(const octave_value &val)
Definition: graphics.h:10768
std::string get_interpreter(void) const
Definition: graphics.h:10410
radio_property sortmethod
Definition: graphics.h:5205
std::map< graphics_handle, graphics_object >::iterator iterator
Definition: graphics.h:13987
void set_faces(const octave_value &val)
Definition: graphics.h:9735
const std::string & current_value(void) const
Definition: graphics.h:1252
radio_property verticalalignment
Definition: graphics.h:11889
void set_activepositionproperty(const octave_value &val)
Definition: graphics.h:5731
std::string get_xdisplay(void) const
Definition: graphics.h:4155
static void pop_figure(const graphics_handle &h)
Definition: graphics.h:13832
std::string graphics_object_name(void) const
Definition: graphics.h:5129
static graphics_event create_set_event(const graphics_handle &h, const std::string &name, const octave_value &value, bool notify_toolkit=true)
Definition: graphics.cc:9499
row_vector_property ylim
Definition: graphics.h:8677
const base_properties & get_properties(void) const
Definition: graphics.h:11786
bool_property enable
Definition: graphics.h:11458
bool camerapositionmode_is(const std::string &v) const
Definition: graphics.h:5425
std::string get_marker(void) const
Definition: graphics.h:7565
static bool has_readonly_property(const caseless_str &pname)
std::string get_name(void) const
Definition: graphics.h:2079
bool is_radio(void) const
Definition: graphics.h:1239
octave_value get_xlim(void) const
Definition: graphics.h:9550
void set_linewidth(const octave_value &val)
Definition: graphics.h:8289
void warning_with_id(const char *id, const char *fmt,...)
Definition: error.cc:803
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:12289
bool facealpha_is_double(void) const
Definition: graphics.h:10391
graphics_handle get_currentaxes(void) const
Definition: graphics.h:4011
array_property colororder
Definition: graphics.h:5171
Matrix get_color_rgb(void) const
Definition: graphics.h:4006
graphics_event(const graphics_event &e)
Definition: graphics.h:13685
void do_unload_toolkit(const std::string &name)
Definition: graphics.h:2361
Matrix scale(const Matrix &m) const
Definition: graphics.h:208
void set_resizefcn(const octave_value &val)
Definition: graphics.h:12978
callback_property clickedcallback
Definition: graphics.h:13284
const base_properties & get_properties(void) const
Definition: graphics.h:11627
bool bordertype_is(const std::string &v) const
Definition: graphics.h:12418
void set_xdisplay(const octave_value &val)
Definition: graphics.h:4712
std::string do_default_toolkit(void)
Definition: graphics.h:2414
row_vector_property ylim
Definition: graphics.h:11165
octave_value get_default(const caseless_str &name) const
Definition: graphics.h:3231
static void unload_all_toolkits(void)
Definition: graphics.h:2294
plist_map_iterator find(const std::string &go_name)
Definition: graphics.h:2047
void update_ztick(void)
Definition: graphics.h:7104
bool gridalphamode_is(const std::string &v) const
Definition: graphics.h:5488
base_graphics_toolkit * rep
Definition: graphics.h:2242
bool valid_object(void) const
Definition: graphics.h:7417
octave_value get_xticklabel(void) const
Definition: graphics.h:5610
string_property tag
Definition: graphics.h:2627
octave_value get_clim(void) const
Definition: graphics.h:8730
radio_property fontweight
Definition: graphics.h:12371
bool ytickmode_is(const std::string &v) const
Definition: graphics.h:5662
void set(const caseless_str &pname, const octave_value &val)
Matrix get_children(void) const
Definition: graphics.h:1624
octave_value data
Definition: graphics.h:1579
Matrix do_handle_list(bool show_hidden)
Definition: graphics.h:14052
bool is_separator(void) const
Definition: graphics.h:13513
radio_values radio_val
Definition: graphics.h:1277
std::string get_interpreter(void) const
Definition: graphics.h:8082
std::string get_enable(void) const
Definition: graphics.h:13505
callback_property keypressfcn
Definition: graphics.h:11878
void set_drawmode(const octave_value &val)
Definition: graphics.h:5993
void set_fontname(const octave_value &val)
Definition: graphics.h:6014
void set_climinclude(const octave_value &val)
Definition: graphics.h:10007
static std::string go_name
Definition: graphics.h:10232
color_property(const std::string &nm, const graphics_handle &h, const color_values &c=color_values(), const radio_values &v=radio_values())
Definition: graphics.h:1062
void set_numbertitle(const octave_value &val)
Definition: graphics.h:4337
std::string get_clipping(void) const
Definition: graphics.h:2671
static std::string go_name
Definition: graphics.h:11435
bool_property yliminclude
Definition: graphics.h:8681
row_vector_property zlim
Definition: graphics.h:7513
graphics_handle get_parent(void) const
Definition: graphics.h:3272
light(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:9248
double get_zPlaneN(void) const
Definition: graphics.h:5006
bool vertexnormalsmode_is(const std::string &v) const
Definition: graphics.h:10443
string_property fontname
Definition: graphics.h:7973
callback_property closerequestfcn
Definition: graphics.h:3863
std::string dtk
Definition: graphics.h:2331
octave_value get_position(void) const
Definition: graphics.h:5542
void set_mincolormap(const octave_value &val)
Definition: graphics.h:4678
octave_value get_alphadata(void) const
Definition: graphics.h:8709
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:11631
std::string get_titleposition(void) const
Definition: graphics.h:12473
Matrix get_markeredgecolor_rgb(void) const
Definition: graphics.h:7569
std::string get_title(void) const
Definition: graphics.h:12857
Matrix get_opengl_matrix_1(void) const
Definition: graphics.h:4994
octave_value get_zlim(void) const
Definition: graphics.h:9554
array_property xdata
Definition: graphics.h:10283
row_vector_property zlim
Definition: graphics.h:11166
radio_property activepositionproperty
Definition: graphics.h:5153
void add_constraint(const std::string &type)
Definition: graphics.h:1314
std::string get_zticklabelmode(void) const
Definition: graphics.h:5700
auto_lock(bool wait=true)
Definition: graphics.h:13969
radio_property horizontalalignmentmode
Definition: graphics.h:7995
base_graphics_object(const base_graphics_object &)
Definition: graphics.h:3133
double get_colororderindex(void) const
Definition: graphics.h:5458
std::string get_busyaction(void) const
Definition: graphics.h:2665
void set_displayname(const octave_value &val)
Definition: graphics.h:11222
radio_property verticalalignmentmode
Definition: graphics.h:7996
void delete_listener(const octave_value &v=octave_value(), listener_mode mode=POSTSET)
Definition: graphics.h:1913
octave_value get_default(const caseless_str &name) const
Definition: graphics.h:3665
std::string get_zliminclude(void) const
Definition: graphics.h:8116
std::string get_linestyle(void) const
Definition: graphics.h:8085
property_list get_defaults_list(void) const
Definition: graphics.h:13198
void set_ambientstrength(const octave_value &val)
Definition: graphics.h:10501
radio_property interpreter
Definition: graphics.h:7498
std::string get_xlimmode(void) const
Definition: graphics.h:5597
bool is_zliminclude(void) const
Definition: graphics.h:10474
void set_sizechangedfcn(const octave_value &val)
Definition: graphics.h:4488
virtual void reparent(const graphics_handle &np)
Definition: graphics.h:3022
Definition: Cell.h:37
row_vector_property xlim
Definition: graphics.h:10291
array_property cdata
Definition: graphics.h:13473
For example cd octave end example noindent changes the current working directory to file
Definition: dirfns.cc:120
bool units_is(const std::string &v) const
Definition: graphics.h:12467
std::string get_paperorientation(void) const
Definition: graphics.h:4053
void set_pointerlocation(const octave_value &val)
Definition: graphics.h:3539
void set_ylimmode(const octave_value &val)
Definition: graphics.h:6640
void set_zlim(const octave_value &val)
Definition: graphics.h:10914
bool handlevisibility_is(const std::string &v) const
Definition: graphics.h:2679
row_vector_property(const std::string &nm, const graphics_handle &h, const octave_value &m)
Definition: graphics.h:1395
radio_property bordertype
Definition: graphics.h:12364
std::string get_xliminclude(void) const
Definition: graphics.h:8110
std::string get_nextplot(void) const
Definition: graphics.h:4045
void set_titlefontweight(const octave_value &val)
Definition: graphics.h:6373
std::set< std::string > dynamic_properties
Definition: graphics.h:2589
radio_values & operator=(const radio_values &a)
Definition: graphics.h:835
void set_wvisual(const octave_value &val)
Definition: graphics.h:4688
octave_refcount< int > count
Definition: graphics.h:13674
radio_property toolbar
Definition: graphics.h:3898
bool ticklabelinterpreter_is(const std::string &v) const
Definition: graphics.h:5556
Matrix get_markeredgecolor_rgb(void) const
Definition: graphics.h:9517
void set_screendepth(const octave_value &val)
Definition: graphics.h:3559
octave_value get___object__(void) const
Definition: graphics.h:13497
bool_property clipping
Definition: graphics.h:11868
void set_alphadata(const octave_value &val)
Definition: graphics.h:8749
radio_property zscale
Definition: graphics.h:5257
base_property * clone(void) const
Definition: graphics.h:1569
void set_interpreter(const octave_value &val)
Definition: graphics.h:9767
std::string get_facelighting(void) const
Definition: graphics.h:10402
static void post_callback(const graphics_handle &h, const std::string &name, const octave_value &data=Matrix())
Definition: graphics.h:13910
radio_property ticklabelinterpreter
Definition: graphics.h:5208
void set_xlim(const octave_value &val)
Definition: graphics.h:7770
radio_property alimmode
Definition: graphics.h:5155
void set_linestyle(const octave_value &val)
Definition: graphics.h:10678
std::string values_as_string(void) const
Definition: graphics.cc:1214
std::string string_value(void) const
Definition: graphics.h:522
void set_zlim(const octave_value &val)
Definition: graphics.h:9983
std::string get_backfacelighting(void) const
Definition: graphics.h:9453
row_vector_property zlim
Definition: graphics.h:9388
std::string graphics_object_name(void) const
Definition: graphics.h:3423
text_label_property(const std::string &s, const graphics_handle &h, const NDArray &nda)
Definition: graphics.h:675
bool minorgridalphamode_is(const std::string &v) const
Definition: graphics.h:5515
Matrix get_facecolor_rgb(void) const
Definition: graphics.h:10398
double get_borderwidth(void) const
Definition: graphics.h:12822
double_radio_property edgealpha
Definition: graphics.h:9355
static std::string go_name
Definition: graphics.h:11845
octave_value get_cameraupvector(void) const
Definition: graphics.h:5433
void set_xscale(const octave_value &val)
Definition: graphics.h:6504
bool is_real_type(void) const
Definition: ov.h:667
std::string values_as_string(void) const
Definition: graphics.h:934
std::string get_alphadatamapping(void) const
Definition: graphics.h:8712
std::string get_graphicssmoothing(void) const
Definition: graphics.h:4025
void set_name(const std::string &name)
Definition: graphics.h:1856
void set_zdata(const octave_value &val)
Definition: graphics.h:10845
bool style_is(const std::string &v) const
Definition: graphics.h:9202
OCTINTERP_API bool validate(const octave_value &v)
bool_property numbertitle
Definition: graphics.h:3880
void set___gl_vendor__(const octave_value &val) const
Definition: graphics.h:4598
bool enable_is(const std::string &v) const
Definition: graphics.h:11938
virtual bool do_set(const octave_value &)
Definition: graphics.h:396
void set_fontweight(const octave_value &val)
Definition: graphics.h:12100
octave_value get_ambientlightcolor(void) const
Definition: graphics.h:5415
any_property __object__
Definition: graphics.h:12771
bool linestyle_is(const std::string &v) const
Definition: graphics.h:9507
octave_value get_position(void) const
Definition: graphics.h:11973
void update_looseinset(void)
Definition: graphics.h:7221
octave_value get_xcolor(void) const
Definition: graphics.h:5581
double get_fontsize(void) const
Definition: graphics.h:5475
NDArray scale(const NDArray &m) const
Definition: graphics.h:166
octave_idx_type nelem(void) const
Definition: graphics.h:901
properties xproperties
Definition: graphics.h:11775
bool zcolor_is(const std::string &v) const
Definition: graphics.h:5666
void set_ydata(const octave_value &val)
Definition: graphics.h:9913
color_property(const std::string &nm, const graphics_handle &h, const radio_values &v)
Definition: graphics.h:1070
void set_sortmethod(const octave_value &val)
Definition: graphics.h:6294
void override_defaults(base_graphics_object &obj)
Definition: graphics.h:4782
int get_zstate(void) const
Definition: graphics.h:5000
std::map< graphics_handle, graphics_object > handle_map
Definition: graphics.h:13998
void mark_modified(void)
Definition: graphics.h:3628
void update_zticklabelmode(void)
Definition: graphics.h:7149
void set_position(const octave_value &val)
Definition: graphics.h:11579
double get_edgealpha_double(void) const
Definition: graphics.h:9466
OCTINTERP_API bool is_equal(const octave_value &v) const
Definition: graphics.cc:1467
void update_alphadata(void)
Definition: graphics.h:8984
bool_property zminorgrid
Definition: graphics.h:5255
enum color_property::current_enum current_type
bool color_is_rgb(void) const
Definition: graphics.h:7546
bool_property separator
Definition: graphics.h:11462
octave_value get_pointershapecdata(void) const
Definition: graphics.h:4071
virtual bool is_climinclude(void) const
Definition: graphics.h:2577
void set_selected(const octave_value &val)
Definition: graphics.h:2813
bool valid_object(void) const
Definition: graphics.h:11368
radio_property zdir
Definition: graphics.h:5250
bool projection_is(const std::string &v) const
Definition: graphics.h:5544
void set_cdata(const octave_value &val)
Definition: graphics.h:9598
bool cdatamapping_is(const std::string &v) const
Definition: graphics.h:9457
callback_property buttondownfcn
Definition: graphics.h:3862
octave_value get(bool all=false) const
bool xlimmode_is(const std::string &v) const
Definition: graphics.h:5596
radio_property minorgridlinestyle
Definition: graphics.h:5197
string_property fontname
Definition: graphics.h:11872
virtual void print_figure(const graphics_object &, const std::string &, const std::string &, const std::string &="") const
Definition: graphics.h:2086
bool backgroundcolor_is_rgb(void) const
Definition: graphics.h:8040
std::string get_backfacelighting(void) const
Definition: graphics.h:10362
bool color_is_rgb(void) const
Definition: graphics.h:9195
bool is_visible(void) const
Definition: graphics.h:2704
Cell values_as_cell(void) const
Definition: graphics.h:936
~line(void)
Definition: graphics.h:7866
bool interpreter_is(const std::string &v) const
Definition: graphics.h:10409
fname
Definition: load-save.cc:754
property(base_property *bp, bool persist=false)
Definition: graphics.h:1836
double_property linewidth
Definition: graphics.h:7980
double double_value(void) const
Definition: graphics.h:1244
void set_alphamap(const octave_value &val)
Definition: graphics.h:4163
base_properties & get_properties(void)
Definition: graphics.h:12283
void set___object__(const octave_value &val)
Definition: graphics.h:12866
bool_property xliminclude
Definition: graphics.h:7990
row_vector_property ytick
Definition: graphics.h:5243
double_radio_property(const std::string &nm, const graphics_handle &h, const std::string &v)
Definition: graphics.h:1210
void update_alphadata(void)
Definition: graphics.h:11007
radio_property zlimmode
Definition: graphics.h:5254
std::string get_vertexnormalsmode(void) const
Definition: graphics.h:10444
std::string get_verticalalignment(void) const
Definition: graphics.h:11992
row_vector_property value
Definition: graphics.h:11888
void set_zdatasource(const octave_value &val)
Definition: graphics.h:7760
void override_defaults(base_graphics_object &obj)
Definition: graphics.cc:3078
void(* event_fcn)(void *)
Definition: graphics.h:13681
bool is_xliminclude(void) const
Definition: graphics.h:11212
virtual property get_property(const caseless_str &pname)
color_property & operator=(const octave_value &val)
Definition: graphics.h:1127
property_list get_defaults_list(void) const
Definition: graphics.h:7403
float pixel_size(octave_idx_type dim, const Matrix limits)
Definition: graphics.h:9068
double get_titlefontsizemultiplier(void) const
Definition: graphics.h:5565
void set_minorgridcolormode(const octave_value &val)
Definition: graphics.h:6196
bool backgroundcolor_is_rgb(void) const
Definition: graphics.h:11925
bool foregroundcolor_is(const std::string &v) const
Definition: graphics.h:11495
octave_value get_xlim(void) const
Definition: graphics.h:5594
base_property * clone(void) const
Definition: graphics.h:1175
static graphics_object get_object(const graphics_handle &h)
Definition: graphics.h:13799
bool alphadatamapping_is(const std::string &v) const
Definition: graphics.h:9447
octave_value reshape(const dim_vector &dv) const
Definition: ov.h:515
octave_idx_type rows(void) const
Definition: ov.h:489
static graphics_toolkit get_toolkit(void)
Definition: graphics.h:2249
std::string get_yaxislocation(void) const
Definition: graphics.h:5621
row_vector_property alim
Definition: graphics.h:10289
std::set< graphics_handle > handle_free_list
Definition: graphics.h:14001
bool_property xminorgrid
Definition: graphics.h:5224
virtual void update(const graphics_object &, int)
Definition: graphics.h:2112
static std::string go_name
Definition: graphics.h:3428
std::string get_zliminclude(void) const
Definition: graphics.h:9563
double_property specularcolorreflectance
Definition: graphics.h:10278
bool gridcolormode_is(const std::string &v) const
Definition: graphics.h:5496
void set(const caseless_str &name, const octave_value &value)
Definition: graphics.h:4796
radio_property fontweight
Definition: graphics.h:11875
void set_ylim(const octave_value &val)
Definition: graphics.h:11272
std::string get_name(void) const
Definition: graphics.h:4042
void update_xtick(void)
Definition: graphics.h:7092
Matrix get_backgroundcolor_rgb(void) const
Definition: graphics.h:12816
void set_backfacelighting(const octave_value &val)
Definition: graphics.h:9588
bool fontangle_is(const std::string &v) const
Definition: graphics.h:11943
void set___object__(const octave_value &val)
Definition: graphics.h:11509
double get_x_max(void) const
Definition: graphics.h:5014
void execute_callback(const octave_value &data=octave_value()) const
Definition: graphics.h:11724
void update_fontsize(void)
Definition: graphics.h:12264
void set_linewidth(const octave_value &val)
Definition: graphics.h:10688
octave_value get_edgecolor(void) const
Definition: graphics.h:10383
std::string get_fontunits(void) const
Definition: graphics.h:8073
octave_value get_zlim(void) const
Definition: graphics.h:10466
void set_ytick(const octave_value &val)
Definition: graphics.h:6685
void set_min(const octave_value &val)
Definition: graphics.h:12161
bool_property box
Definition: graphics.h:5157
bool_property(const bool_property &p)
Definition: graphics.h:1486
static std::set< std::string > core_property_names(void)
void set_xdata(const octave_value &val)
Definition: graphics.h:7707
bool zticklabelmode_is(const std::string &v) const
Definition: graphics.h:5699
void update_string(void)
Definition: graphics.h:8547
void set_renderermode(const octave_value &val)
Definition: graphics.h:4448
static void register_toolkit(const std::string &name)
Definition: graphics.h:2254
octave_int< T > xmax(const octave_int< T > &x, const octave_int< T > &y)
void set_displayname(const octave_value &val)
Definition: graphics.h:10564
bool gridlinestyle_is(const std::string &v) const
Definition: graphics.h:5499
std::string get_menubar(void) const
Definition: graphics.h:4040
bool_property xliminclude
Definition: graphics.h:11169
void set_pointerwindow(const octave_value &val)
Definition: graphics.h:3549
void set_clim(const octave_value &val)
Definition: graphics.h:9947
void set_commandwindowsize(const octave_value &val)
Definition: graphics.h:3507
void erase(const std::string pname)
Definition: graphics.h:2006
bool edgealpha_is(const std::string &v) const
Definition: graphics.h:9465
bool do_set(const octave_value &val)
Definition: graphics.h:1669
void update_zdir(void)
Definition: graphics.h:7086
radio_property vertexnormalsmode
Definition: graphics.h:10282
void set_markeredgecolor(const octave_value &val)
Definition: graphics.h:10708
octave_value full_value(void) const
Definition: ov.h:386
bool foregroundcolor_is(const std::string &v) const
Definition: graphics.h:11957
~hggroup(void)
Definition: graphics.h:11362
double_property markersize
Definition: graphics.h:9373
graphics_handle get_xlabel(void) const
Definition: graphics.h:5592
std::string get_xvisual(void) const
Definition: graphics.h:4157
void set_horizontalalignmentmode(const octave_value &val)
Definition: graphics.h:8455
std::string graphics_object_name(void) const
Definition: graphics.h:13258
octave_value get_markerfacecolor(void) const
Definition: graphics.h:10428
octave_value get_edgecolor(void) const
Definition: graphics.h:8055
void set_ydata(const octave_value &val)
Definition: graphics.h:7728
color_property ycolor
Definition: graphics.h:5233
static Cell available_toolkits_list(void)
Definition: graphics.h:2284
base_property * clone(void) const
Definition: graphics.h:1612
color_property(const radio_values &v, const color_values &c)
Definition: graphics.h:1056
std::string get_layer(void) const
Definition: graphics.h:5505
void set_windowscrollwheelfcn(const octave_value &val)
Definition: graphics.h:4560
bool minorgridcolor_is(const std::string &v) const
Definition: graphics.h:5519
std::string get_cdatamapping(void) const
Definition: graphics.h:8717
bool_property aliminclude
Definition: graphics.h:11167
void set_cameraupvectormode(const octave_value &val)
Definition: graphics.h:5857
bool color_is_rgb(void) const
Definition: graphics.h:5451
radio_property & operator=(const octave_value &val)
Definition: graphics.h:943
Matrix get_gridcolor_rgb(void) const
Definition: graphics.h:5493
std::string get_tooltipstring(void) const
Definition: graphics.h:11984
properties xproperties
Definition: graphics.h:7859
void set_normalmode(const octave_value &val)
Definition: graphics.h:10138
std::string get_xtickmode(void) const
Definition: graphics.h:5618
std::string get_xticklabelmode(void) const
Definition: graphics.h:5613
void insert_property(const std::string &name, property p)
Definition: graphics.h:2447
octave_value get_plotboxaspectratio(void) const
Definition: graphics.h:5534
double_property fontsize_points
Definition: graphics.h:5274
radio_property windowstyle
Definition: graphics.h:3906
std::string get_state(void) const
Definition: graphics.h:13517
void set_callback(const octave_value &val)
Definition: graphics.h:11740
bool yaxislocation_is(const std::string &v) const
Definition: graphics.h:5620
bool xvisualmode_is(const std::string &v) const
Definition: graphics.h:4159
bool isa(const std::string &go_name) const
Definition: graphics.h:3286
octave_value get_ylim(void) const
Definition: graphics.h:7593
virtual bool is_radio(void) const
Definition: graphics.h:301
any_property __object__
Definition: graphics.h:13472
bool markeredgecolor_is_rgb(void) const
Definition: graphics.h:7567
octave_value get_currentpoint(void) const
Definition: graphics.h:5460
double_property minorgridalpha
Definition: graphics.h:5193
double_property markersize
Definition: graphics.h:7504
void set_cdata(const octave_value &val)
Definition: graphics.h:10521
std::string get_dataaspectratiomode(void) const
Definition: graphics.h:5465
std::string get_separator(void) const
Definition: graphics.h:13514
octave_value get_factory_defaults(void) const
Definition: graphics.h:3248
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:4839
virtual std::string values_as_string(void) const
Definition: graphics.h:317
octave_value & operator[](const std::string pname)
Definition: graphics.h:1993
void update_yaxislocation(void)
Definition: graphics.h:7061
std::string string_value(void) const
Definition: graphics.h:734
string_property __gl_renderer__
Definition: graphics.h:3908
std::string get_yticklabelmode(void) const
Definition: graphics.h:5658
virtual void init_integerhandle(const octave_value &)
Definition: graphics.h:2437
double get_fontsize(void) const
Definition: graphics.h:12431
graphics_handle get_zlabel(void) const
Definition: graphics.h:5679
~uimenu(void)
Definition: graphics.h:11623
void set_enable(const octave_value &val)
Definition: graphics.h:12045
std::string get_fontangle(void) const
Definition: graphics.h:12825
bool linestyle_is(const std::string &v) const
Definition: graphics.h:7559
void set_rotationmode(const octave_value &val)
Definition: graphics.h:8444
void set_zliminclude(const octave_value &val)
Definition: graphics.h:11332
virtual bool is_aliminclude(void) const
Definition: graphics.h:2576
octave_value get_cdata(void) const
Definition: graphics.h:8714
row_vector_property zlim
Definition: graphics.h:5253
radio_property alphadatamapping
Definition: graphics.h:9348
octave_value get_buttondownfcn(void) const
Definition: graphics.h:2668
void set_selectionhighlight(const octave_value &val)
Definition: graphics.h:2823
bool erasemode_is(const std::string &v) const
Definition: graphics.h:8060
octave_value get_xdata(void) const
Definition: graphics.h:9540
array_property facenormals
Definition: graphics.h:10267
bool_property aliminclude
Definition: graphics.h:9389
OCTINTERP_API graphics_handle gcf(void)
Definition: graphics.cc:2632
std::set< caseless_str > possible_vals
Definition: graphics.h:906
color_property backgroundcolor
Definition: graphics.h:12772
bool_property interruptible
Definition: graphics.h:2623
void set_linewidth(const octave_value &val)
Definition: graphics.h:6148
void set_highlightcolor(const octave_value &val)
Definition: graphics.h:12958
void update_ztickmode(void)
Definition: graphics.h:7129
std::set< std::string >::const_iterator const_available_toolkits_iterator
Definition: graphics.h:2342
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:13211
radio_property erasemode
Definition: graphics.h:7497
octave_idx_type numel(void) const
Number of elements in the array.
Definition: Array.h:363
property_list get_defaults_list(void) const
Definition: graphics.h:4826
bool get_nearhoriz(void) const
Definition: graphics.h:5035
octave_value get_position(void) const
Definition: graphics.h:9200
Matrix do_get_all_children(void) const
Definition: graphics.h:1745
void set_bordertype(const octave_value &val)
Definition: graphics.h:12496
double_property screendepth
Definition: graphics.h:3454
std::string get_type(void) const
Definition: graphics.h:2698
void update_fontangle(void)
Definition: graphics.h:12265
row_vector_property zlim
Definition: graphics.h:7989
void set_alphadatamapping(const octave_value &val)
Definition: graphics.h:10489
bool units_is(const std::string &v) const
Definition: graphics.h:11986
void execute_windowbuttonmotionfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4104
octave_value get_color(void) const
Definition: graphics.h:9198
string_property xvisual
Definition: graphics.h:3923
std::string get_checked(void) const
Definition: graphics.h:11489
Matrix xscale(const Matrix &m) const
Definition: graphics.h:4899
identity matrix If supplied two scalar respectively For allows like xample val
Definition: data.cc:5068
void set_markersize(const octave_value &val)
Definition: graphics.h:10728
void set_gridalphamode(const octave_value &val)
Definition: graphics.h:6075
static std::string go_name
Definition: graphics.h:11690
void set_markersize(const octave_value &val)
Definition: graphics.h:7697
std::map< listener_mode, octave_value_list >::iterator listener_map_iterator
Definition: graphics.h:404
void set_yaxislocation(const octave_value &val)
Definition: graphics.h:6566
array_property sliderstep
Definition: graphics.h:11883
handle_property(const handle_property &p)
Definition: graphics.h:1519
void set_ztick(const octave_value &val)
Definition: graphics.h:6842
void finalize(const graphics_object &go)
Definition: graphics.h:2231
bool minorgridlinestyle_is(const std::string &v) const
Definition: graphics.h:5526
virtual void defaults(void) const
Definition: graphics.h:3030
octave_value get_windowbuttonupfcn(void) const
Definition: graphics.h:4108
void set_value(const octave_value &val)
Definition: graphics.h:12225
octave_value get_callback(void) const
Definition: graphics.h:11486
octave_idx_type length(void) const
Definition: ovl.h:96
base_property * clone(void) const
Definition: graphics.h:1438
void set_specularstrength(const octave_value &val)
Definition: graphics.h:9857
std::string get_autopos_tag(void) const
Definition: graphics.h:8131
callback_property oncallback
Definition: graphics.h:13477
OCTINTERP_API bool do_set(const octave_value &v)
Definition: graphics.cc:1367
void set_aliminclude(const octave_value &val)
Definition: graphics.h:10926
array_property ydata
Definition: graphics.h:9382
void set_boxstyle(const octave_value &val)
Definition: graphics.h:5785
bool valid_object(void) const
Definition: graphics.h:9258
void set_marker(const octave_value &val)
Definition: graphics.h:7667
base_scaler * rep
Definition: graphics.h:257
octave_value get___object__(void) const
Definition: graphics.h:13125
static void execute_callback(const graphics_handle &h, const octave_value &cb, const octave_value &data=Matrix())
Definition: graphics.h:13902
bool backgroundcolor_is(const std::string &v) const
Definition: graphics.h:12414
bool is_zliminclude(void) const
Definition: graphics.h:9562
const base_properties & get_properties(void) const
Definition: graphics.h:13044
std::string get_fontweight(void) const
Definition: graphics.h:12835
std::string value_as_string(const std::string &prop)
Definition: graphics.h:3265
void set_state(const octave_value &val)
Definition: graphics.h:13592
bool is_radio(void) const
Definition: graphics.h:1871
Matrix get_backgroundcolor_rgb(void) const
Definition: graphics.h:8042
double max_neg(void) const
Definition: graphics.h:1323
void update_tickdir(void)
Definition: graphics.h:7089
color_property edgecolor
Definition: graphics.h:9356
const base_properties & get_properties(void) const
Definition: graphics.h:3290
Return the CPU time used by your Octave session The first output is the total time spent executing your process and is equal to the sum of second and third which are the number of CPU seconds spent executing in user mode and the number of CPU seconds spent executing in system mode
Definition: data.cc:6386
bool is_climinclude(void) const
Definition: graphics.h:9292
void set_verticalalignmentmode(const octave_value &val)
Definition: graphics.h:8466
row_vector_property zmtick
Definition: graphics.h:5273
base_property(const base_property &p)
Definition: graphics.h:280
virtual Matrix get_screen_size(void) const
Definition: graphics.h:2103
virtual ~base_property(void)
Definition: graphics.h:285
octave_refcount< int > count
Definition: graphics.h:2142
const base_properties & get_properties(void) const
Definition: graphics.h:9256
row_vector_property xlim
Definition: graphics.h:7987
radio_property ytickmode
Definition: graphics.h:5247
std::string get___mouse_mode__(void) const
Definition: graphics.h:4135
bool is_scalar_type(void) const
Definition: ov.h:673
base_properties & get_properties(void)
Definition: graphics.h:9254
octave_value get_x_viewtransform(void) const
Definition: graphics.h:5714
row_vector_property ydata
Definition: graphics.h:7507
static std::string go_name
Definition: graphics.h:13097
std::string get_autopos_tag(void) const
Definition: graphics.h:5710
octave_value get_windowkeyreleasefcn(void) const
Definition: graphics.h:4114
octave_value get_callback(void) const
Definition: graphics.h:11725
std::string default_value(void) const
Definition: graphics.h:846
array_property plotboxaspectratio
Definition: graphics.h:5200
double_property titlefontsizemultiplier
Definition: graphics.h:5212
static bool has_readonly_property(const caseless_str &pname)
std::string get_boxstyle(void) const
Definition: graphics.h:5421
double_property specularstrength
Definition: graphics.h:9377
void set_box(const octave_value &val)
Definition: graphics.h:5775
void set___gl_version__(const octave_value &val) const
Definition: graphics.h:4607
bool renderermode_is(const std::string &v) const
Definition: graphics.h:4080
~patch(void)
Definition: graphics.h:10163
std::string get___graphics_toolkit__(void) const
Definition: graphics.h:4130
bool is_climinclude(void) const
Definition: graphics.h:3335
std::string get_fontangle(void) const
Definition: graphics.h:12427
Matrix get_color_rgb(void) const
Definition: graphics.h:5453
bool fontweight_is(const std::string &v) const
Definition: graphics.h:5483
const base_properties & get_properties(void) const
Definition: graphics.h:3713
virtual NDArray scale(const NDArray &) const
Definition: graphics.h:72
bool is_defined(void) const
Definition: ov.h:536
row_vector_property ylim
Definition: graphics.h:5238
void set_fontsize(const octave_value &val)
Definition: graphics.h:6025
callback_property resizefcn
Definition: graphics.h:12375
void set_paperposition(const octave_value &val)
Definition: graphics.h:4360
octave_value get_zdata(void) const
Definition: graphics.h:7587
handle_property xlabel
Definition: graphics.h:5221
bool isnan(double x)
Definition: lo-mappers.cc:347
void set_ylim(const octave_value &val)
Definition: graphics.h:9971
virtual ~base_graphics_event(void)
Definition: graphics.h:13669
static bool has_readonly_property(const caseless_str &pname)
bool operator==(const color_values &c) const
Definition: graphics.h:1018
void set_shadowcolor(const octave_value &val)
Definition: graphics.h:12620
double get_linewidth(void) const
Definition: graphics.h:8087
bool backgroundcolor_is(const std::string &v) const
Definition: graphics.h:8041
array_property cameraposition
Definition: graphics.h:5159
void insert_static_property(const std::string &name, base_property &p)
Definition: graphics.h:2882
std::string name
Definition: graphics.h:2141
bool try_lock(void)
Definition: oct-mutex.h:95
void adopt(const graphics_handle &h)
Definition: graphics.h:11102
bool busyaction_is(const std::string &v) const
Definition: graphics.h:2664
std::string get_xliminclude(void) const
Definition: graphics.h:8737
void update_layer(void)
Definition: graphics.h:7060
color_values & operator=(const color_values &c)
Definition: graphics.h:1010
static bool has_readonly_property(const caseless_str &pname)
std::string get_erasemode(void) const
Definition: graphics.h:7554
void execute_deletefcn(const octave_value &data=octave_value()) const
Definition: graphics.h:2676
radio_property minorgridcolormode
Definition: graphics.h:5196
virtual double scale(double) const
Definition: graphics.h:77
void execute_buttondownfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:3998
std::string get_tooltipstring(void) const
Definition: graphics.h:13519
void set_hidden(bool flag)
Definition: graphics.h:1868
bool empty(void) const
Definition: str-vec.h:79
octave_value get_alim(void) const
Definition: graphics.h:5407
bool paperpositionmode_is(const std::string &v) const
Definition: graphics.h:4057
patch(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:10159
double_property fontsize_points
Definition: graphics.h:7998
bool is_xliminclude(void) const
Definition: graphics.h:10468
bool interpreter_is(const std::string &v) const
Definition: graphics.h:7556
std::string get_horizontalalignment(void) const
Definition: graphics.h:11962
void execute_offcallback(const octave_value &data=octave_value()) const
Definition: graphics.h:13507
bool highlightcolor_is(const std::string &v) const
Definition: graphics.h:12445
Cell cell_value(void) const
Definition: graphics.h:743
void set_position(const octave_value &val)
Definition: graphics.h:12588
double_property listboxtop
Definition: graphics.h:11879
octave_value get_offcallback(void) const
Definition: graphics.h:13508
const base_properties & get_properties(void) const
Definition: graphics.h:13634
std::string get_minorgridlinestyle(void) const
Definition: graphics.h:5527
bool_property yminorgrid
Definition: graphics.h:5240
callback_property sizechangedfcn
Definition: graphics.h:12379
void set_fontangle(const octave_value &val)
Definition: graphics.h:8205
void set_color(const octave_value &val)
Definition: graphics.h:5927
bool ok(void) const
Definition: oct-handle.h:109
for large enough k
Definition: lu.cc:606
void set_alim(const octave_value &val)
Definition: graphics.h:9935
double get_z_max(void) const
Definition: graphics.h:5018
~surface(void)
Definition: graphics.h:11071
~uipushtool(void)
Definition: graphics.h:13395
octave_value get_alim(void) const
Definition: graphics.h:9546
void set_deletefcn(const octave_value &val)
Definition: graphics.h:2773
bool cameraupvectormode_is(const std::string &v) const
Definition: graphics.h:5435
row_vector_property xlim
Definition: graphics.h:5222
string_property title
Definition: graphics.h:12785
std::set< std::string > type_constraints
Definition: graphics.h:1388
void set_zliminclude(const octave_value &val)
Definition: graphics.h:7830
bool operator!=(const color_values &c) const
Definition: graphics.h:1025
void set_parent(const graphics_handle &h)
Definition: graphics.h:1862
const_iterator find(const std::string pname) const
Definition: graphics.h:1959
const base_properties & get_properties(void) const
Definition: graphics.h:11366
bool yscale_is(const std::string &v) const
Definition: graphics.h:5650
bool isa(const std::string &go_name) const
Definition: graphics.h:3068
static bool try_lock(void)
Definition: graphics.h:13856
octave_value get_zlim(void) const
Definition: graphics.h:5681
bool cdatamapping_is(const std::string &v) const
Definition: graphics.h:8716
void set_zdata(const octave_value &val)
Definition: graphics.h:9924
void set_alim(const octave_value &val)
Definition: graphics.h:5741
octave_value get_faces(void) const
Definition: graphics.h:9498
double get_fy(void) const
Definition: graphics.h:5020
void set_tickdirmode(const octave_value &val)
Definition: graphics.h:6319
bool is_yliminclude(void) const
Definition: graphics.h:11215
octave_value get_markeredgecolor(void) const
Definition: graphics.h:10423
void reparent(const graphics_handle &new_parent)
Definition: graphics.h:2536
static bool has_readonly_property(const caseless_str &pname)
row_vector_property clim
Definition: graphics.h:9385
void set_xvisualmode(const octave_value &val)
Definition: graphics.h:4736
virtual void add_listener(const caseless_str &, const octave_value &, listener_mode=POSTSET)
Definition: graphics.cc:3162
std::string get_ycolormode(void) const
Definition: graphics.h:5629
bool verticalalignment_is(const std::string &v) const
Definition: graphics.h:11991
octave_value get_paperposition(void) const
Definition: graphics.h:4055
graphics_object(const graphics_object &obj)
Definition: graphics.h:3149
octave_value get_oncallback(void) const
Definition: graphics.h:13511
static bool has_readonly_property(const caseless_str &pname)
array_property cameratarget
Definition: graphics.h:5161
octave_value lookup(const std::string pname) const
Definition: graphics.h:1981
void set_erasemode(const octave_value &val)
Definition: graphics.h:11232
static std::string go_name
Definition: graphics.h:5134
static void push_figure(const graphics_handle &h)
Definition: graphics.h:13826
virtual octave_value get_xlim(void) const
Definition: graphics.h:2572
std::string get_fontsmoothing(void) const
Definition: graphics.h:5481
static std::string go_name
Definition: graphics.h:3842
bool markerfacecolor_is(const std::string &v) const
Definition: graphics.h:9521
OCTINTERP_API void run_listeners(listener_mode mode=POSTSET)
Definition: graphics.cc:1171
void mark_modified(void)
Definition: graphics.cc:3067
Cell values_as_cell(void) const
Definition: graphics.h:1890
string_property fontname
Definition: graphics.h:12368
array_property position
Definition: graphics.h:12374
bool_property climinclude
Definition: graphics.h:11168
bool positionmode_is(const std::string &v) const
Definition: graphics.h:8118
void set_from_list(property_list &plist)
Definition: graphics.h:3192
virtual octave_value get_alim(void) const
Definition: graphics.h:2570
radio_property xcolormode
Definition: graphics.h:5218
double_property mousewheelzoom
Definition: graphics.h:5263
array_property(const std::string &nm, const graphics_handle &h, const octave_value &m)
Definition: graphics.h:1294
float pixel_ysize(void)
Definition: graphics.h:9091
virtual graphics_toolkit get_toolkit(void) const
Definition: graphics.h:3073
bool shadowcolor_is(const std::string &v) const
Definition: graphics.h:12853
radio_property yaxislocation
Definition: graphics.h:5232
void set_markeredgecolor(const octave_value &val)
Definition: graphics.h:7677
void update_dataaspectratio(void)
Definition: graphics.h:7055
std::string get_camerapositionmode(void) const
Definition: graphics.h:5426
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:7874
bool fontunits_is(const std::string &v) const
Definition: graphics.h:8072
void set_pointer(const octave_value &val)
Definition: graphics.h:4404
graphics_toolkit get_toolkit(void) const
Definition: graphics.h:3350
bool_property __modified__
Definition: graphics.h:2632
const std::string & current_value(void) const
Definition: graphics.h:932
virtual std::string graphics_object_name(void) const
Definition: graphics.h:2431
void set_inverthardcopy(const octave_value &val)
Definition: graphics.h:4277
void set_backfacelighting(const octave_value &val)
Definition: graphics.h:10511
double scale(double d) const
Definition: graphics.h:214
pval_map_type::const_iterator pval_map_const_iterator
Definition: graphics.h:2027
octave_value get_userdata(void) const
Definition: graphics.h:2702
static void execute_listener(const graphics_handle &h, const octave_value &l)
Definition: graphics.h:13876
row_vector_property xdata
Definition: graphics.h:8672
bool color_is(const std::string &v) const
Definition: graphics.h:9196
std::string get_numbertitle(void) const
Definition: graphics.h:4048
void set_clickedcallback(const octave_value &val)
Definition: graphics.h:13542
void update_fontname(void)
Definition: graphics.h:8550
std::string get_facenormalsmode(void) const
Definition: graphics.h:9496
octave_value get_x_normrendertransform(void) const
Definition: graphics.h:5720
properties xproperties
Definition: graphics.h:13623
bool edgelighting_is(const std::string &v) const
Definition: graphics.h:10385
void set_cdata(const octave_value &val)
Definition: graphics.h:8772
Matrix x_gl_mat2
Definition: graphics.h:5074
void set_toolbar(const octave_value &val)
Definition: graphics.h:4498
void error(const char *fmt,...)
Definition: error.cc:570
handle_property currentfigure
Definition: graphics.h:3449
double_property gridalpha
Definition: graphics.h:5183
void finalize(void)
Definition: graphics.h:3362
octave_value get_closerequestfcn(void) const
Definition: graphics.h:4002
color_property markerfacecolor
Definition: graphics.h:7503
radio_property(const std::string &nm, const graphics_handle &h, const radio_values &v=radio_values())
Definition: graphics.h:912
void set_enable(const octave_value &val)
Definition: graphics.h:13347
void update_cdata(void)
Definition: graphics.h:11015
void update_xticklabelmode(void)
Definition: graphics.h:7139
bool zscale_is(const std::string &v) const
Definition: graphics.h:5692
bool ok(void) const
Definition: graphics.h:1850
std::string get_gridlinestyle(void) const
Definition: graphics.h:5500
bool markeredgecolor_is_rgb(void) const
Definition: graphics.h:9515
void set_name(const octave_value &val)
Definition: graphics.h:4317
double current_val
Definition: graphics.h:1196
void do_scale(const double *src, double *dest, int n) const
Definition: graphics.h:185
void update_rotationmode(void)
Definition: graphics.h:8542
radio_property pickableparts
Definition: graphics.h:5202
void execute_windowkeyreleasefcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4113
octave_value get_string(void) const
Definition: graphics.h:11979
double xmaxp
Definition: graphics.h:1387
void set_x_normrendertransform(const octave_value &val)
Definition: graphics.h:6952
bool_property fontsmoothing
Definition: graphics.h:5181
void set_keypressfcn(const octave_value &val)
Definition: graphics.h:12131
~light(void)
Definition: graphics.h:9252
void set_plotboxaspectratio(const octave_value &val)
Definition: graphics.h:6237
base_graphics_event * rep
Definition: graphics.h:13735
array_property facevertexcdata
Definition: graphics.h:9366
void set_windowstyle(const octave_value &val)
Definition: graphics.h:4570
uitoolbar(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:13148
std::string get_climinclude(void) const
Definition: graphics.h:11210
bool valid_object(void) const
Definition: graphics.h:4835
bool_property & operator=(const octave_value &val)
Definition: graphics.h:1491
void set_visible(const octave_value &val)
Definition: graphics.h:2854
std::string get_ytickmode(void) const
Definition: graphics.h:5663
void set(const caseless_str &name, const octave_value &val)
Definition: graphics.cc:1939
virtual ~base_graphics_toolkit(void)
Definition: graphics.h:2077
void set_horizontalalignment(const octave_value &val)
Definition: graphics.h:12121
void update_xdir(void)
Definition: graphics.h:7084
void set_tickdir(const octave_value &val)
Definition: graphics.h:6304
any_property __guidata__
Definition: graphics.h:3912
std::string get_units(void) const
Definition: graphics.h:5571
radio_property style
Definition: graphics.h:11885
bool erasemode_is(const std::string &v) const
Definition: graphics.h:11193
Matrix zscale(const Matrix &m) const
Definition: graphics.h:4901
std::string graphics_object_name(void) const
Definition: graphics.h:7471
bool xcolor_is_rgb(void) const
Definition: graphics.h:5578
std::list< dim_vector > size_constraints
Definition: graphics.h:1389
void set___object__(const octave_value &val)
Definition: graphics.h:12476
void set_separator(const octave_value &val)
Definition: graphics.h:11589
const base_properties & get_properties(void) const
Definition: graphics.h:8580
radio_property units
Definition: graphics.h:11887
void set_gridcolormode(const octave_value &val)
Definition: graphics.h:6095
radio_property style
Definition: graphics.h:9184
bool is_clipping(void) const
Definition: graphics.h:12423
radio_property projection
Definition: graphics.h:5204
bool foregroundcolor_is_rgb(void) const
Definition: graphics.h:11494
void set_graphicssmoothing(const octave_value &val)
Definition: graphics.h:4265
virtual double unscale(double) const
Definition: graphics.h:82
void set_cameraupvector(const octave_value &val)
Definition: graphics.h:5843
properties xproperties
Definition: graphics.h:13145
bool titleposition_is(const std::string &v) const
Definition: graphics.h:12859
octave_value get_zlim(void) const
Definition: graphics.h:8107
virtual Matrix get_boundingbox(bool=false, const Matrix &=Matrix()) const
Definition: graphics.h:2499
pval_map_type::iterator pval_map_iterator
Definition: graphics.h:2026
base_property * clone(void) const
Definition: graphics.h:1540
octave_value get_ylim(void) const
Definition: graphics.h:5639
virtual void initialize(const graphics_object &go)
Definition: graphics.h:3102
std::string get_tooltipstring(void) const
Definition: graphics.h:13314
static Matrix figure_handle_list(bool show_hidden=false)
Definition: graphics.h:13870
radio_property gridalphamode
Definition: graphics.h:5184
root_figure(void)
Definition: graphics.h:3623
bool linestyle_is(const std::string &v) const
Definition: graphics.h:10412
void set_bordertype(const octave_value &val)
Definition: graphics.h:12886
void set_fontweight(const octave_value &val)
Definition: graphics.h:6050
void set___pan_mode__(const octave_value &val)
Definition: graphics.h:4628
std::string get_ylimmode(void) const
Definition: graphics.h:5642
row_vector_property alim
Definition: graphics.h:5154
void set_fontname(const octave_value &val)
Definition: graphics.h:12076
array_property x_projectiontransform
Definition: graphics.h:5267
void adopt(const graphics_handle &h)
Definition: graphics.h:3280
double get_linewidth(void) const
Definition: graphics.h:5511
void set_erasemode(const octave_value &val)
Definition: graphics.h:10604
radio_property normalmode
Definition: graphics.h:10277
OCTINTERP_API bool str2rgb(const std::string &str)
Definition: graphics.cc:1254
property(const property &p)
Definition: graphics.h:1839
bool contains(const std::string &val, std::string &match)
Definition: graphics.h:858
string_property fontname
Definition: graphics.h:5178
radio_property xlimmode
Definition: graphics.h:5223
graphics_toolkit(base_graphics_toolkit *b)
Definition: graphics.h:2161
string_array_property string
Definition: graphics.h:11884
base_scaler * clone(void) const
Definition: graphics.h:141
string_vector get_string_vector(void) const
Definition: graphics.h:11978
void set_doublebuffer(const octave_value &val)
Definition: graphics.h:4668
void set_ydata(const octave_value &val)
Definition: graphics.h:8830
color_property highlightcolor
Definition: graphics.h:12781
base_property(const std::string &s, const graphics_handle &h)
Definition: graphics.h:276
callback_property clickedcallback
Definition: graphics.h:13474
std::set< graphics_handle >::iterator free_list_iterator
Definition: graphics.h:13991
bool toolbar_is(const std::string &v) const
Definition: graphics.h:4095
void set_clim(const octave_value &val)
Definition: graphics.h:11252
static void restore_gcbo(void)
Definition: graphics.h:14126
bool valid_toolkit_object(void) const
Definition: graphics.h:3060
radio_property(const std::string &nm, const graphics_handle &h, const std::string &v)
Definition: graphics.h:917
void set_xmtick(const octave_value &val)
Definition: graphics.h:6972
~uitoggletool(void)
Definition: graphics.h:13630
property_list get_defaults_list(void) const
Definition: graphics.h:3243
~text(void)
Definition: graphics.h:8576
radio_property marker
Definition: graphics.h:9370
bool sortmethod_is(const std::string &v) const
Definition: graphics.h:5547
bool pickableparts_is(const std::string &v) const
Definition: graphics.h:5539
axes(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:7345
std::string get_tickdir(void) const
Definition: graphics.h:5551
void set_meshstyle(const octave_value &val)
Definition: graphics.h:10738
row_vector_property alim
Definition: graphics.h:9384
array_property cdata
Definition: graphics.h:8668
any_property zticklabel
Definition: graphics.h:5259
bool backfacelighting_is(const std::string &v) const
Definition: graphics.h:9452
any_property __object__
Definition: graphics.h:11864
void update_ydata(void)
Definition: graphics.h:11029
bool verticalalignmentmode_is(const std::string &v) const
Definition: graphics.h:8127
bool valid_object(void) const
Definition: graphics.h:13636
void set_diffusestrength(const octave_value &val)
Definition: graphics.h:9621
void set_marker(const octave_value &val)
Definition: graphics.h:10698
string_property fontname
Definition: graphics.h:12776
double get_diffusestrength(void) const
Definition: graphics.h:10371
std::string get_aliminclude(void) const
Definition: graphics.h:11207
bool edgecolor_is_rgb(void) const
Definition: graphics.h:8052
static void load_toolkit(const graphics_toolkit &tk)
Definition: graphics.h:2266
octave_value resize(const dim_vector &dv, bool fill=false) const
Definition: ov.h:524
Cell do_available_toolkits_list(void) const
Definition: graphics.h:2376
double get_ambientstrength(void) const
Definition: graphics.h:9450
bool xcolor_is(const std::string &v) const
Definition: graphics.h:5579
uipushtool(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:13391
radio_property facenormalsmode
Definition: graphics.h:10268
void execute_keypressfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4033
bool is_selectionhighlight(void) const
Definition: graphics.h:2693
octave_value get_position(void) const
Definition: graphics.h:11727
void update_interpreter(void)
Definition: graphics.h:8554
void do_restore_gcbo(void)
Definition: graphics.cc:9522
std::string graphics_object_name(void) const
Definition: graphics.h:7941
std::string get_titleposition(void) const
Definition: graphics.h:12860
properties xproperties
Definition: graphics.h:3619
base_graphics_object(void)
Definition: graphics.h:2893
octave_value get_clim(void) const
Definition: graphics.h:11198
bool is_cell(void) const
Definition: ov.h:545
bool fontunits_is(const std::string &v) const
Definition: graphics.h:11950
string_array_property(const std::string &s, const graphics_handle &h, const std::string &val="", const char &sep= '|', const desired_enum &typ=string_t)
Definition: graphics.h:470
octave_value get_edgealpha(void) const
Definition: graphics.h:9467
void set_position(const octave_value &val)
Definition: graphics.h:7893
radio_property renderermode
Definition: graphics.h:3893
octave_value get_xdata(void) const
Definition: graphics.h:8724
bool erasemode_is(const std::string &v) const
Definition: graphics.h:8721
std::string get_fontunits(void) const
Definition: graphics.h:12832
void set_xtick(const octave_value &val)
Definition: graphics.h:6517
bool paperorientation_is(const std::string &v) const
Definition: graphics.h:4052
bool is_clipping(void) const
Definition: graphics.h:11935
void add_listener(const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:1910
static graphics_handle make_graphics_handle(const std::string &go_name, const graphics_handle &parent, bool integer_figure_handle=false, bool do_createfcn=true, bool do_notify_toolkit=true)
Definition: graphics.h:13805
base_property * clone(void) const
Definition: graphics.h:1343
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:13048
std::string get_enable(void) const
Definition: graphics.h:11492
void set___gl_extensions__(const octave_value &val) const
Definition: graphics.h:4580
std::string get_erasemode(void) const
Definition: graphics.h:8061
bool ydatamode_is(const std::string &v) const
Definition: graphics.h:8745
void set_showhiddenhandles(const octave_value &val)
Definition: graphics.h:3589
std::string get_currentcharacter(void) const
Definition: graphics.h:4013
virtual void close(void)
Definition: graphics.h:2137
radio_property titlefontweight
Definition: graphics.h:5213
radio_property edgelighting
Definition: graphics.h:10262
octave_idx_type lookup(const T *x, octave_idx_type n, T y)
void set_ycolor(const octave_value &val)
Definition: graphics.h:6577
octave_value get_ymtick(void) const
Definition: graphics.h:5726
color_property color
Definition: graphics.h:5170
color_values color_val
Definition: graphics.h:1147
any_property __object__
Definition: graphics.h:13282
void set_fontangle(const octave_value &val)
Definition: graphics.h:12526
void update_yscale(void)
Definition: graphics.h:7034
double_property zticklabelrotation
Definition: graphics.h:5261
void update_paperpositionmode(void)
Definition: graphics.h:4763
~property_list(void)
Definition: graphics.h:2035
octave_value get_colormap(void) const
Definition: graphics.h:4009
octave_value get_factory_default(const caseless_str &name) const
Definition: graphics.h:3681
std::string get_tickdirmode(void) const
Definition: graphics.h:5554
octave_value get_backgroundcolor(void) const
Definition: graphics.h:11928
void set_max(const octave_value &val)
Definition: graphics.h:12151
bool is_yliminclude(void) const
Definition: graphics.h:10471
bool foregroundcolor_is_rgb(void) const
Definition: graphics.h:12837
bool backgroundcolor_is(const std::string &v) const
Definition: graphics.h:11926
bool rotationmode_is(const std::string &v) const
Definition: graphics.h:8121
void update_xdata(void)
Definition: graphics.h:7847
std::string get_enable(void) const
Definition: graphics.h:13309
void set_autopos_tag(const octave_value &val)
Definition: graphics.h:6901
std::string get_xaxislocation(void) const
Definition: graphics.h:5576
~uitoolbar(void)
Definition: graphics.h:13152
std::string get___modified__(void) const
Definition: graphics.h:2708
std::string get_fontname(void) const
Definition: graphics.h:12429
octave_value get_monitorpositions(void) const
Definition: graphics.h:3486
~gtk_manager(void)
Definition: graphics.h:2309
octave_value get_alim(void) const
Definition: graphics.h:11196
text_label_property string
Definition: graphics.h:7984
Cell values_as_cell(void) const
Definition: graphics.h:1140
void set_enable(const octave_value &val)
Definition: graphics.h:11549
double get_markersize(void) const
Definition: graphics.h:9525
array_property x_viewtransform
Definition: graphics.h:5266
log_scaler(void)
Definition: graphics.h:115
void execute_sizechangedfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:12464
bool foregroundcolor_is_rgb(void) const
Definition: graphics.h:11956
bool vertexnormalsmode_is(const std::string &v) const
Definition: graphics.h:9535
std::string get_style(void) const
Definition: graphics.h:11982
listener_map listeners
Definition: graphics.h:414
bool facecolor_is(const std::string &v) const
Definition: graphics.h:10397
void set_fontsize_points(const octave_value &val)
Definition: graphics.h:8487
std::string get___gl_version__(void) const
Definition: graphics.h:4128
octave_value get_alphadata(void) const
Definition: graphics.h:10354
std::string get_cdatamapping(void) const
Definition: graphics.h:10367
void set_xminortick(const octave_value &val)
Definition: graphics.h:6494
color_property shadowcolor
Definition: graphics.h:12784
bool interpreter_is(const std::string &v) const
Definition: graphics.h:9504
void update_view(void)
Definition: graphics.h:7054
octave_value get_sizechangedfcn(void) const
Definition: graphics.h:12465
std::string get_yliminclude(void) const
Definition: graphics.h:10472
bool markeredgecolor_is(const std::string &v) const
Definition: graphics.h:10421
octave_value get_ylim(void) const
Definition: graphics.h:11202
void set_menubar(const octave_value &val)
Definition: graphics.h:4307
children_property(const std::string &nm, const graphics_handle &h, const Matrix &val)
Definition: graphics.h:1593
octave_value get_clickedcallback(void) const
Definition: graphics.h:13306
array_property monitorpositions
Definition: graphics.h:3451
bool ambientlightcolor_is_rgb(void) const
Definition: graphics.h:5412
radio_property erasemode
Definition: graphics.h:7970
bool do_set(const octave_value &v)
Definition: graphics.h:1178
void set_zgrid(const octave_value &val)
Definition: graphics.h:6770
radio_property units
Definition: graphics.h:3899
std::string get_minorgridalphamode(void) const
Definition: graphics.h:5516
void set_xaxislocation(const octave_value &val)
Definition: graphics.h:6398
double_property fontsize
Definition: graphics.h:12777
string_property ydatasource
Definition: graphics.h:7508
radio_property nextplot
Definition: graphics.h:5198
virtual void set_from_list(property_list &plist)
Definition: graphics.h:2915
double_radio_property & operator=(const octave_value &val)
Definition: graphics.h:1260
static bool is_handle_visible(const graphics_handle &h)
Definition: graphics.h:13947
void set_linewidth(const octave_value &val)
Definition: graphics.h:7657
octave_value get_ytick(void) const
Definition: graphics.h:5653
void set_displayname(const octave_value &val)
Definition: graphics.h:8795
property_list default_properties
Definition: graphics.h:13220
void set_keypressfcn(const octave_value &val)
Definition: graphics.h:4287
void execute_windowbuttonupfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4107
row_vector_property ylim
Definition: graphics.h:7512
bool cdatamapping_is(const std::string &v) const
Definition: graphics.h:10366
bool ylimmode_is(const std::string &v) const
Definition: graphics.h:5641
void set_fontweight(const octave_value &val)
Definition: graphics.h:12558
void update_faces(void)
Definition: graphics.h:10079
std::string get_marker(void) const
Definition: graphics.h:9513
virtual void delete_children(bool clear=false)
Definition: graphics.h:2548
void set_rotation(const octave_value &val)
Definition: graphics.h:8309
std::string get_positionmode(void) const
Definition: graphics.h:8119
color_values(const color_values &c)
Definition: graphics.h:1006
std::string get_ydatasource(void) const
Definition: graphics.h:10452
radio_property paperorientation
Definition: graphics.h:3882
std::string get_units(void) const
Definition: graphics.h:8098
string_property zdatasource
Definition: graphics.h:10288
std::string get_rotationmode(void) const
Definition: graphics.h:8122
string_property cdatasource
Definition: graphics.h:10257
color_property markerfacecolor
Definition: graphics.h:10274
graphics_handle gh
Definition: graphics.cc:11209
bool edgecolor_is(const std::string &v) const
Definition: graphics.h:10381
octave_value get_xmtick(void) const
Definition: graphics.h:5724
radio_property drawmode
Definition: graphics.h:5176
s
Definition: file-io.cc:2682
bool erasemode_is(const std::string &v) const
Definition: graphics.h:10388
octave_value get_facevertexalphadata(void) const
Definition: graphics.h:9500
std::string get_xscale(void) const
Definition: graphics.h:5606
pval_vector pval_map_type
Definition: graphics.h:2023
void update_zdata(void)
Definition: graphics.h:7851
void execute_oncallback(const octave_value &data=octave_value()) const
Definition: graphics.h:13510
radio_property positionmode
Definition: graphics.h:7993
octave_value get_resizefcn(void) const
Definition: graphics.h:12452
static std::string default_toolkit(void)
Definition: graphics.h:2300
octave_value get_ylim(void) const
Definition: graphics.h:9552
std::string get_climinclude(void) const
Definition: graphics.h:10197
string_property displayname
Definition: graphics.h:7496
std::string get_bordertype(void) const
Definition: graphics.h:12419
double get_xticklen(void) const
Definition: graphics.h:5022
std::string get_renderer(void) const
Definition: graphics.h:4078
radio_property units
Definition: graphics.h:3458
octave_value get_backgroundcolor(void) const
Definition: graphics.h:12416
bool xdir_is(const std::string &v) const
Definition: graphics.h:5586
std::string string_value(void) const
Definition: graphics.h:432
void set_cameratarget(const octave_value &val)
Definition: graphics.h:5819
void delete_property_listener(const std::string &nm, const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:3356
void update_position(void)
Definition: graphics.h:7199
std::string graphics_object_name(void) const
Definition: graphics.h:12747
NDArray scale(const NDArray &m) const
Definition: graphics.h:126
array_property faces
Definition: graphics.h:9364
void set_specularcolorreflectance(const octave_value &val)
Definition: graphics.h:10748
bool zlimmode_is(const std::string &v) const
Definition: graphics.h:5683
graphics_xform(const Matrix &xm, const Matrix &xim, const scaler &x, const scaler &y, const scaler &z, const Matrix &zl)
Definition: graphics.h:4863
void set_aliminclude(const octave_value &val)
Definition: graphics.h:9995
void set_ticklength(const octave_value &val)
Definition: graphics.h:6340
radio_property alphadatamapping
Definition: graphics.h:10252
void set_verticalalignment(const octave_value &val)
Definition: graphics.h:12235
color_property foregroundcolor
Definition: graphics.h:11876
bool verticalalignment_is(const std::string &v) const
Definition: graphics.h:8100
void print_figure(const graphics_object &go, const std::string &term, const std::string &file, const std::string &debug_file="") const
Definition: graphics.h:2200
double get_facealpha_double(void) const
Definition: graphics.h:10393
bool is(const caseless_str &v) const
Definition: graphics.h:938
radio_property cameraviewanglemode
Definition: graphics.h:5166
bool is_zminortick(void) const
Definition: graphics.h:5689
void update_zlim(void)
Definition: graphics.h:7324
virtual std::string type(void) const
Definition: graphics.h:3062
bool units_is(const std::string &v) const
Definition: graphics.h:12862
std::string get_name(void) const
Definition: graphics.h:1853
bool_property enable
Definition: graphics.h:13285
children_property & operator=(const octave_value &val)
Definition: graphics.h:1606
static void unlock(void)
Definition: graphics.h:13864
i e
Definition: data.cc:2724
octave_value get_edgecolor(void) const
Definition: graphics.h:9472
std::string get_drawmode(void) const
Definition: graphics.h:5468
std::string get_interpreter(void) const
Definition: graphics.h:9505
std::string row_as_string(octave_idx_type, bool strip_ws=false) const
Definition: chMatrix.cc:81
Matrix get_edgecolor_rgb(void) const
Definition: graphics.h:10382
octave_value get_defaults(void) const
Definition: graphics.h:4821
radio_property wvisualmode
Definition: graphics.h:3921
void update_cdata(void)
Definition: graphics.h:10126
std::string bad_data_msg
Definition: graphics.h:10077
octave_mutex graphics_lock
Definition: graphics.h:14011
desired_enum desired_type
Definition: graphics.h:658
callback_property offcallback
Definition: graphics.h:13476
virtual void init(void)
Definition: graphics.h:2885
void set_tightinset(const octave_value &val)
Definition: graphics.h:6351
octave_value get_facealpha(void) const
Definition: graphics.h:9483
std::string cached_units
Definition: graphics.h:12247
void set_colormap(const octave_value &val)
Definition: graphics.h:4203
virtual property_list get_factory_defaults_list(void) const
Definition: graphics.h:2974
void set_fixedwidthfontname(const octave_value &val)
Definition: graphics.h:3519
void set_separator(const octave_value &val)
Definition: graphics.h:13357
void set_zscale(const octave_value &val)
Definition: graphics.h:6829
graphics_handle current_val
Definition: graphics.h:1546
std::string get_tag(void) const
Definition: graphics.h:2696
Matrix yscale(const Matrix &m) const
Definition: graphics.h:4900
~uipanel(void)
Definition: graphics.h:13040
octave_value get_view(void) const
Definition: graphics.h:5573
static void unregister_toolkit(const std::string &name)
Definition: graphics.h:2260
virtual graphics_handle get_parent(void) const
Definition: graphics.h:2990
octave_value get___plot_stream__(void) const
Definition: graphics.h:4139
~axes(void)
Definition: graphics.h:7351
std::string get_cdatamapping(void) const
Definition: graphics.h:9458
handle_property zlabel
Definition: graphics.h:5252
bool markerfacecolor_is(const std::string &v) const
Definition: graphics.h:10426
octave::text_renderer txt_renderer
Definition: graphics.h:5089
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:9260
bool shadowcolor_is_rgb(void) const
Definition: graphics.h:12459
double_property xticklabelrotation
Definition: graphics.h:5230
void resize(octave_idx_type n, const std::string &rfv="")
Definition: str-vec.h:97
virtual void set(const caseless_str &pname, const octave_value &pval)
Definition: graphics.h:2923
std::map< graphics_handle, graphics_object >::const_iterator const_iterator
Definition: graphics.h:13989
void remove_child(const graphics_handle &h)
Definition: graphics.h:11393
void renumber_child(graphics_handle old_gh, graphics_handle new_gh)
Definition: graphics.h:2553
void update_xscale(void)
Definition: graphics.h:7029
bool_property showhiddenhandles
Definition: graphics.h:3457
std::string get_editing(void) const
Definition: graphics.h:8058
void set_markerfacecolor(const octave_value &val)
Definition: graphics.h:10718
void set_cdata(const octave_value &val)
Definition: graphics.h:12025
void set_renderer(const octave_value &val)
Definition: graphics.h:4434
void update_axis_limits(const std::string &axis_type)
Definition: graphics.h:3295
std::string get_ticklabelinterpreter(void) const
Definition: graphics.h:5557
std::string get_facenormalsmode(void) const
Definition: graphics.h:10407
color_property color
Definition: graphics.h:7495
void set_xlim(const octave_value &val)
Definition: graphics.h:8361
double_property borderwidth
Definition: graphics.h:12774
bool shadowcolor_is(const std::string &v) const
Definition: graphics.h:12460
octave_value get_defaults(void) const
Definition: graphics.h:13193
bool alphadatamapping_is(const std::string &v) const
Definition: graphics.h:8711
void set_view(const octave_value &val)
Definition: graphics.h:6387
void set_hidden(bool flag)
Definition: graphics.h:299
void set_clipping(const octave_value &val)
Definition: graphics.h:12035
any_property __plot_stream__
Definition: graphics.h:3915
callback_property sizechangedfcn
Definition: graphics.h:3897
graphics_handle do_current_figure(void) const
Definition: graphics.h:14090
octave_value get_cdata(void) const
Definition: graphics.h:13499
double_property ambientstrength
Definition: graphics.h:10253
std::string get_zminorgrid(void) const
Definition: graphics.h:5687
bool_property resize
Definition: graphics.h:3894
Matrix get_markerfacecolor_rgb(void) const
Definition: graphics.h:9522
void execute_sizechangedfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4092
octave_idx_type rows(void) const
Definition: Array.h:401
property_list get_factory_defaults_list(void) const
Definition: graphics.h:3253
octave_value arg
Definition: pr-output.cc:3440
Matrix get_backgroundcolor_rgb(void) const
Definition: graphics.h:11927
octave_value get(bool all=false) const
Definition: graphics.h:3211
bool is_aliminclude(void) const
Definition: graphics.h:9287
bool_property yliminclude
Definition: graphics.h:7991
void set_gridcolor(const octave_value &val)
Definition: graphics.h:6085
std::string graphics_object_name(void) const
Definition: graphics.h:9324
radio_property __mouse_mode__
Definition: graphics.h:3913
void set_ylim(const octave_value &val)
Definition: graphics.h:7782
color_values(const std::string &str)
Definition: graphics.h:999
octave_function * fcn
Definition: ov-class.cc:1743
void set_yliminclude(const octave_value &val)
Definition: graphics.h:8929
bool gridcolor_is(const std::string &v) const
Definition: graphics.h:5492
array_property alphamap
Definition: graphics.h:3861
octave_value get___object__(void) const
Definition: graphics.h:11923
static graphics_handle lookup(const octave_value &val)
Definition: graphics.h:13788
std::string get_fontweight(void) const
Definition: graphics.h:8076
void fix_limits(array_property &lims)
Definition: graphics.h:7267
void delete_listener(const octave_value &v=octave_value(), listener_mode mode=POSTSET)
Definition: graphics.h:339
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:11790
Matrix get_foregroundcolor_rgb(void) const
Definition: graphics.h:12839
void set_alimmode(const octave_value &val)
Definition: graphics.h:5755
octave_value get___rotate_mode__(void) const
Definition: graphics.h:4141
std::string get_selectionhighlight(void) const
Definition: graphics.h:2694
octave_value get(bool all=false) const
void set_ydata(const octave_value &val)
Definition: graphics.h:10824
bool markerfacecolor_is_rgb(void) const
Definition: graphics.h:7572
double get_xpTickN(void) const
Definition: graphics.h:5008
bool validate(const std::string &val, std::string &match)
Definition: graphics.h:848
void set_xliminclude(const octave_value &val)
Definition: graphics.h:11312
void set_cdatasource(const octave_value &val)
Definition: graphics.h:10544
F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_REAL const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T F77_REAL F77_REAL &F77_RET_T F77_DBLE F77_DBLE &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE * d
const base_properties & get_properties(void) const
Definition: graphics.h:4833
bool highlightcolor_is(const std::string &v) const
Definition: graphics.h:12843
std::string get_enable(void) const
Definition: graphics.h:11939
OCTINTERP_API bool do_set(const octave_value &newval)
Definition: graphics.cc:1296
property_list default_properties
Definition: graphics.h:7433
std::string get_fixedwidthfontname(void) const
Definition: graphics.h:3484
text_label_property(const std::string &s, const graphics_handle &h, const Cell &c)
Definition: graphics.h:691
color_property markeredgecolor
Definition: graphics.h:9371
graphics_xform get_transform(void) const
Definition: graphics.h:4989
void set_wvisualmode(const octave_value &val)
Definition: graphics.h:4702
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:11079
void override_defaults(base_graphics_object &obj)
Definition: graphics.h:7353
string_array_property(const string_array_property &p)
Definition: graphics.h:510
base_property * clone(void) const
Definition: graphics.h:1497
void update_color(void)
Definition: graphics.h:8549
bool climmode_is(const std::string &v) const
Definition: graphics.h:5445
bool titlefontweight_is(const std::string &v) const
Definition: graphics.h:5567
base_properties & get_properties(void)
Definition: graphics.h:10165
octave_value get_xdata(void) const
Definition: graphics.h:10446
void set_ylim(const octave_value &val)
Definition: graphics.h:6625
bool_property doublebuffer
Definition: graphics.h:3918
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:3258
void set_edgecolor(const octave_value &val)
Definition: graphics.h:10584
void set_xliminclude(const octave_value &val)
Definition: graphics.h:8397
string_property filename
Definition: graphics.h:3871
bool do_set(const octave_value &v)
Definition: graphics.h:1354
octave_value get_ylim(void) const
Definition: graphics.h:8105
void set_markersize(const octave_value &val)
Definition: graphics.h:9827
octave_value get_selectionchangedfcn(void) const
Definition: graphics.h:12457
double_property specularexponent
Definition: graphics.h:9376
array_property position
Definition: graphics.h:11882
array_property alphadata
Definition: graphics.h:10251
ColumnVector coord2pixel(double x, double y, double z) const
Definition: graphics.h:5040
bool is_doublebuffer(void) const
Definition: graphics.h:4145
std::string get_wvisualmode(void) const
Definition: graphics.h:4153
void execute_callback(const octave_value &data=octave_value()) const
Definition: graphics.h:11485
double_radio_property(const double_radio_property &p)
Definition: graphics.h:1224
void set_displayname(const octave_value &val)
Definition: graphics.h:9631
void update_xlim()
Definition: graphics.h:7294
~graphics_xform(void)
Definition: graphics.h:4872
void set_yminorgrid(const octave_value &val)
Definition: graphics.h:6652
bool_property graphicssmoothing
Definition: graphics.h:3872
bool_property(const std::string &nm, const graphics_handle &h, bool val)
Definition: graphics.h:1476
void set_zlim(const octave_value &val)
Definition: graphics.h:11282
color_property(const std::string &nm, const graphics_handle &h, const color_property &v)
Definition: graphics.h:1084
void set_color(const octave_value &val)
Definition: graphics.h:8144
virtual void update_boundingbox(void)
Definition: graphics.cc:3139
bool dataaspectratiomode_is(const std::string &v) const
Definition: graphics.h:5464
cell array If invoked with two or more scalar integer or a vector of integer values
Definition: ov-cell.cc:1205
bool zcolormode_is(const std::string &v) const
Definition: graphics.h:5670
std::string get_title(void) const
Definition: graphics.h:12470
string_array_property & operator=(const octave_value &val)
Definition: graphics.h:540
bool markerfacecolor_is_rgb(void) const
Definition: graphics.h:9520
void set_cdata(const octave_value &val)
Definition: graphics.h:13327
array_property facenormals
Definition: graphics.h:9362
bool do_set(const octave_value &v)
Definition: graphics.h:1572
void set_diffusestrength(const octave_value &val)
Definition: graphics.h:10554
void set_selectionchangedfcn(const octave_value &val)
Definition: graphics.h:12610
std::string get___gl_vendor__(void) const
Definition: graphics.h:4126
void set___guidata__(const octave_value &val)
Definition: graphics.h:4616
void set_climinclude(const octave_value &val)
Definition: graphics.h:8905
void set_xdatasource(const octave_value &val)
Definition: graphics.h:10814
bool markeredgecolor_is_rgb(void) const
Definition: graphics.h:10420
std::string get_papertype(void) const
Definition: graphics.h:4063
bool backgroundcolor_is_rgb(void) const
Definition: graphics.h:12413
color_property foregroundcolor
Definition: graphics.h:12780
calling an anonymous function involves an overhead quite comparable to the overhead of an m file function Passing a handle to a built in function is because the interpreter is not involved in the internal loop For a
Definition: cellfun.cc:398
any_property(const any_property &p)
Definition: graphics.h:1558
callback_property callback
Definition: graphics.h:11456
bool is_xliminclude(void) const
Definition: graphics.h:9556
bool_property xgrid
Definition: graphics.h:5220
std::map< caseless_str, property, cmp_caseless_str > all_props
Definition: graphics.h:2879
std::string get_zgrid(void) const
Definition: graphics.h:5677
OCTAVE_EXPORT octave_value_list search each directory of the loadpath for element of the cell array and return the first that matches If the second optional argument return a cell array containing the list of all files that have the same name in the path If no files are found
Definition: utils.cc:302
octave_value get(void) const
Definition: graphics.h:1312
void set_xdata(const octave_value &val)
Definition: graphics.h:8815
bool fontweight_is(const std::string &v) const
Definition: graphics.h:8075
double_property borderwidth
Definition: graphics.h:12365
void set_erasemode(const octave_value &val)
Definition: graphics.h:8185
virtual void adopt(const graphics_handle &h)
Definition: graphics.h:3014
octave_value get_ydata(void) const
Definition: graphics.h:8726
Cell cell_value(void) const
Definition: ov.cc:1687
double get_edgealpha_double(void) const
Definition: graphics.h:10377
graphics_toolkit(const graphics_toolkit &b)
Definition: graphics.h:2167
octave_value get_factory_defaults(void) const
Definition: graphics.h:3701
octave_value get_cdata(void) const
Definition: graphics.h:13303
octave_value get(void) const
Definition: graphics.h:1561
void set_vertices(const octave_value &val)
Definition: graphics.h:9891
array_property colormap
Definition: graphics.h:3865
bool color_is(const std::string &v) const
Definition: graphics.h:7547
octave_value get_alim(void) const
Definition: graphics.h:10458
std::string get_verticalalignment(void) const
Definition: graphics.h:8101
double get_specularexponent(void) const
Definition: graphics.h:9529
bool nextplot_is(const std::string &v) const
Definition: graphics.h:4044
bool units_is(const std::string &v) const
Definition: graphics.h:4098
callback_property windowbuttonmotionfcn
Definition: graphics.h:3901
void set_interruptible(const octave_value &val)
Definition: graphics.h:2803
octave_value get_position(void) const
Definition: graphics.h:12449
octave_value get_backgroundcolor(void) const
Definition: graphics.h:12817
callback_property & operator=(const octave_value &val)
Definition: graphics.h:1798
base_property * clone(void) const
Definition: graphics.h:440
JNIEnv void * args
Definition: ov-java.cc:67
color_property gridcolor
Definition: graphics.h:5185
void set_xliminclude(const octave_value &val)
Definition: graphics.h:7806
text_label_property & operator=(const octave_value &val)
Definition: graphics.h:745
void do_scale(const double *src, double *dest, int n) const
Definition: graphics.h:145
double get_diffusestrength(void) const
Definition: graphics.h:9460
bool marker_is(const std::string &v) const
Definition: graphics.h:9512
bool edgealpha_is_double(void) const
Definition: graphics.h:9464
std::string get_normalmode(void) const
Definition: graphics.h:11054
void set_dataaspectratiomode(const octave_value &val)
Definition: graphics.h:5982
static property_list::pval_map_type factory_defaults(void)
array_property cameraupvector
Definition: graphics.h:5163
double ztickoffset
Definition: graphics.h:5084
bool valid_object(void) const
Definition: graphics.h:13401
bool ztickmode_is(const std::string &v) const
Definition: graphics.h:5704
array_property dataaspectratio
Definition: graphics.h:5174
virtual void finalize(const graphics_object &go)
Definition: graphics.h:3108
array_property cdata
Definition: graphics.h:13283
std::string current_val
Definition: graphics.h:1149
virtual bool valid_object(void) const
Definition: graphics.h:3058
bool is_hittest(void) const
Definition: graphics.h:2682
bool edgecolor_is(const std::string &v) const
Definition: graphics.h:9470
void set_ydatasource(const octave_value &val)
Definition: graphics.h:10835
virtual ~base_scaler(void)
Definition: graphics.h:65
void set_fontname(const octave_value &val)
Definition: graphics.h:8216
array_property extent
Definition: graphics.h:7971
bool is_aliminclude(void) const
Definition: graphics.h:3332
void execute_resizefcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4086
bool_property climinclude
Definition: graphics.h:10295
const dim_vector & dims(void) const
Return a const-reference so that dims ()(i) works efficiently.
Definition: Array.h:439
radio_property handlevisibility
Definition: graphics.h:2621
void update_yticklabelmode(void)
Definition: graphics.h:7144
void set_gridalpha(const octave_value &val)
Definition: graphics.h:6061
void set_defaults(const std::string &mode)
Definition: graphics.h:3209
radio_property zticklabelmode
Definition: graphics.h:5260
double get_zpTickN(void) const
Definition: graphics.h:5012
property_list default_properties
Definition: graphics.h:4848
void set_highlightcolor(const octave_value &val)
Definition: graphics.h:12578
base_property * clone(void) const
Definition: graphics.h:546
bool_property separator
Definition: graphics.h:13286
void set_xtickmode(const octave_value &val)
Definition: graphics.h:6555
std::string get_erasemode(void) const
Definition: graphics.h:11194
void set_buttondownfcn(const octave_value &val)
Definition: graphics.h:4173
std::string get_pickableparts(void) const
Definition: graphics.h:5540
void do_adopt_child(double val)
Definition: graphics.h:1769
void execute_createfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:2673
Matrix get_hidden(void) const
Definition: graphics.h:1629
static void free(const graphics_handle &h)
Definition: graphics.h:13770
bool get_xyzSym(void) const
Definition: graphics.h:5033
void set_clipping(const octave_value &val)
Definition: graphics.h:2753
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:7421
void close(void)
Definition: graphics.h:2238
double_radio_property facealpha
Definition: graphics.h:9359
string_property zdatasource
Definition: graphics.h:7510
bool is_separator(void) const
Definition: graphics.h:11503
octave_value get_gridcolor(void) const
Definition: graphics.h:5494
void set_xticklabelrotation(const octave_value &val)
Definition: graphics.h:6545
void set_alim(const octave_value &val)
Definition: graphics.h:8845
std::string get_fontangle(void) const
Definition: graphics.h:8066
string_property currentcharacter
Definition: graphics.h:3867
std::string values_as_string(void) const
Definition: graphics.h:1137
bool valid_object(void) const
Definition: graphics.h:3715
void set_fontsize(const octave_value &val)
Definition: graphics.h:8227
std::string get_aliminclude(void) const
Definition: graphics.h:9289
OCTINTERP_API graphics_handle gca(void)
Definition: graphics.cc:2642
bool fontunits_is(const std::string &v) const
Definition: graphics.h:12433
Matrix get_limits(void) const
Definition: graphics.h:1325
bool initialize(const graphics_handle &h)
Definition: graphics.h:2225
static bool instance_ok(void)
Definition: graphics.h:13748
void execute(void)
Definition: graphics.h:13711
void set_edgecolor(const octave_value &val)
Definition: graphics.h:9651
array_property zdata
Definition: graphics.h:9383
void set_tooltipstring(const octave_value &val)
Definition: graphics.h:12204
virtual base_scaler * clone() const
Definition: graphics.h:87
~root_figure(void)
Definition: graphics.h:3626
std::string get_bordertype(void) const
Definition: graphics.h:12820
Array< std::string > cellstr_value(void) const
Definition: Cell.cc:142
double h
Definition: graphics.cc:11205
void set_pickableparts(const octave_value &val)
Definition: graphics.h:6263
bool_property enable
Definition: graphics.h:13475
int get_id(void) const
Definition: graphics.h:1874
double unscale(double d) const
Definition: graphics.h:105
bool_property yliminclude
Definition: graphics.h:11170
bool is_radio(void) const
Definition: graphics.h:1106
array_property screensize
Definition: graphics.h:3456
radio_property gridlinestyle
Definition: graphics.h:5187
std::string get_aliminclude(void) const
Definition: graphics.h:8603
void set_yscale(const octave_value &val)
Definition: graphics.h:6672
bool ok(void) const
Definition: graphics.h:287
octave_value get_createfcn(void) const
Definition: graphics.h:2674
void set_position(const octave_value &val)
Definition: graphics.h:12171
radio_property backfacelighting
Definition: graphics.h:9350
Matrix scale(const Matrix &m) const
Definition: graphics.h:4903
any_property & operator=(const octave_value &val)
Definition: graphics.h:1563
void init(void)
Definition: graphics.h:10057
std::string get_yliminclude(void) const
Definition: graphics.h:8113
void set_fontname(const octave_value &val)
Definition: graphics.h:12536
octave_value get_clim(void) const
Definition: graphics.h:9548
base_scaler(void)
Definition: graphics.h:63
OCTAVE_EXPORT octave_value_list any number nd example oindent prints the prompt xample Pick a any number!nd example oindent and waits for the user to enter a value The string entered by the user is evaluated as an so it may be a literal a variable name
Definition: input.cc:871
bool fontweight_is(const std::string &v) const
Definition: graphics.h:11953
octave_value data
Definition: graphics.h:1383
string_property displayname
Definition: graphics.h:11160
text_label_property(const text_label_property &p)
Definition: graphics.h:716
OCTAVE_EXPORT octave_value_list isdir nd deftypefn *std::string nm
Definition: utils.cc:941
virtual octave_value get_defaults(void) const
Definition: graphics.h:2956
lin_scaler(void)
Definition: graphics.h:97
bool markerfacecolor_is_rgb(void) const
Definition: graphics.h:10425
std::string cached_units
Definition: graphics.h:8562
void set_alphadatamapping(const octave_value &val)
Definition: graphics.h:8760
bool_property(const std::string &nm, const graphics_handle &h, const char *val)
Definition: graphics.h:1481
bool_property yliminclude
Definition: graphics.h:7515
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:13638
virtual octave_value get_clim(void) const
Definition: graphics.h:2571
string_property xdatasource
Definition: graphics.h:7506
uicontextmenu(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:11778
std::string get_displayname(void) const
Definition: graphics.h:8719
void update_vertices(void)
Definition: graphics.h:10081
void update_zdata(void)
Definition: graphics.h:11035
radio_property xvisualmode
Definition: graphics.h:3924
scaler & operator=(const scaler &s)
Definition: graphics.h:223
static bool has_readonly_property(const caseless_str &pname)
void set_tooltipstring(const octave_value &val)
Definition: graphics.h:13602
std::string get_fontunits(void) const
Definition: graphics.h:12434
radio_property clippingstyle
Definition: graphics.h:5169
void set_foregroundcolor(const octave_value &val)
Definition: graphics.h:12948
bool_property xliminclude
Definition: graphics.h:8680
void update_ydata(void)
Definition: graphics.h:7849
radio_property horizontalalignment
Definition: graphics.h:7977
void initialize(void)
Definition: graphics.h:3360
virtual void execute(void)=0
void do_unlock(void)
Definition: graphics.h:14107
std::string get_meshstyle(void) const
Definition: graphics.h:10433
octave_value get_callback(void) const
Definition: graphics.h:11931
std::string get_yminorgrid(void) const
Definition: graphics.h:5645
color_property color
Definition: graphics.h:3864
const std::string & current_value(void) const
Definition: graphics.h:1119
double unscale(double d) const
Definition: graphics.h:217
double get_specularstrength(void) const
Definition: graphics.h:10439
bool foregroundcolor_is_rgb(void) const
Definition: graphics.h:12439
#define OCTINTERP_API
Definition: mexproto.h:69
string_array_property(const std::string &s, const graphics_handle &h, const Cell &c, const char &sep= '|', const desired_enum &typ=string_t)
Definition: graphics.h:493
bool is_hidden(void) const
Definition: graphics.h:297
virtual octave_value get_factory_defaults(void) const
Definition: graphics.h:2969
Matrix get_transform_matrix(void) const
Definition: graphics.h:4992
bool erasemode_is(const std::string &v) const
Definition: graphics.h:7553
radio_property units
Definition: graphics.h:7985
void set_alphadata(const octave_value &val)
Definition: graphics.h:10478
color_property foregroundcolor
Definition: graphics.h:11459
radio_property boxstyle
Definition: graphics.h:5158
Matrix rgb(void) const
Definition: graphics.h:1028
static void replace(QString &text, const QRegExp &re, const QString &after)
Definition: parser.cc:561
string_property displayname
Definition: graphics.h:7967
std::list< double >::iterator children_list_iterator
Definition: graphics.h:1664
double value(void) const
Definition: oct-handle.h:74
double next_handle
Definition: graphics.h:14004
std::list< graphics_handle >::iterator figure_list_iterator
Definition: graphics.h:13994
color_values(double r=0, double g=0, double b=1)
Definition: graphics.h:989
void update_fontangle(void)
Definition: graphics.h:8552
const scaler & get_y_scaler(void) const
Definition: graphics.h:4952
void delete_children(bool clear=false)
Definition: graphics.h:1644
void set_currentpoint(const octave_value &val)
Definition: graphics.h:5957
std::string get_xdatasource(void) const
Definition: graphics.h:10448
Matrix get_markerfacecolor_rgb(void) const
Definition: graphics.h:7574
bool bordertype_is(const std::string &v) const
Definition: graphics.h:12819
std::string get_pointer(void) const
Definition: graphics.h:4069
void set_pointershapehotspot(const octave_value &val)
Definition: graphics.h:4424
virtual void update(const graphics_object &go, int id)
Definition: graphics.h:3117
void set_x_viewtransform(const octave_value &val)
Definition: graphics.h:6922
void set_projection(const octave_value &val)
Definition: graphics.h:6284
static bool has_readonly_property(const caseless_str &pname)
octave_value get_foregroundcolor(void) const
Definition: graphics.h:11959
radio_property xtickmode
Definition: graphics.h:5231
double get_minorgridalpha(void) const
Definition: graphics.h:5513
property & operator=(const octave_value &val)
Definition: graphics.h:1893
octave_value get_foregroundcolor(void) const
Definition: graphics.h:11497
graphics_handle get_parent(void) const
Definition: graphics.h:293
virtual octave_value get_zlim(void) const
Definition: graphics.h:2574
static std::string go_name
Definition: graphics.h:9329
Matrix get_inverse_transform_matrix(void) const
Definition: graphics.h:4993
Matrix get_children(void) const
Definition: graphics.h:2517
void set_clippingstyle(const octave_value &val)
Definition: graphics.h:5917
bool is_sparse_type(void) const
Definition: ov.h:682
std::set< graphics_handle >::const_iterator const_free_list_iterator
Definition: graphics.h:13992
Array< T > sort(int dim=0, sortmode mode=ASCENDING) const
Definition: Array.cc:1775
bool xdatamode_is(const std::string &v) const
Definition: graphics.h:8742
bool renderer_is(const std::string &v) const
Definition: graphics.h:4077
Cell cell_value(void) const
Definition: graphics.h:536
bool fontunits_is(const std::string &v) const
Definition: graphics.h:5477
bool papertype_is(const std::string &v) const
Definition: graphics.h:4062
int event_processing
Definition: graphics.h:14020
void set_filename(const octave_value &val)
Definition: graphics.h:4255
graphics_toolkit do_get_toolkit(void) const
Definition: graphics.cc:10900
void set_units(const octave_value &val)
Definition: graphics.h:12214
octave_value get_defaults(void) const
Definition: graphics.h:3691
double_property screenpixelsperinch
Definition: graphics.h:3455
octave_idx_type numel(const octave_value_list &idx)
Definition: ov.h:411
void set_linewidth(const octave_value &val)
Definition: graphics.h:9787
color_property(const std::string &nm, const graphics_handle &h, const std::string &v)
Definition: graphics.h:1077
void update_verticalalignment(void)
Definition: graphics.h:8556
properties xproperties
Definition: graphics.h:11355
Matrix get_ycolor_rgb(void) const
Definition: graphics.h:5625
std::string get_fontunits(void) const
Definition: graphics.h:5478
void set_displayname(const octave_value &val)
Definition: graphics.h:8155
OCTINTERP_API void close_all_figures(void)
bool is_real_scalar(void) const
Definition: ov.h:551
void set_fontsize(const octave_value &val)
Definition: graphics.h:12087
bool is_xliminclude(void) const
Definition: graphics.h:8736
void set_xticklabelmode(const octave_value &val)
Definition: graphics.h:6534
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:3719
string_property displayname
Definition: graphics.h:9354
Matrix get_ambientlightcolor_rgb(void) const
Definition: graphics.h:5414
Matrix xrgb
Definition: graphics.h:1042
string_vector string_vector_value(void) const
Definition: graphics.h:739
callback_property windowbuttondownfcn
Definition: graphics.h:3900
double min_pos(void) const
Definition: graphics.h:1322
void set_listboxtop(const octave_value &val)
Definition: graphics.h:12141
bool is_beingdeleted(void) const
Definition: graphics.h:2661
octave_value get___object__(void) const
Definition: graphics.h:13301
void set_xdir(const octave_value &val)
Definition: graphics.h:6434
array_property cdata
Definition: graphics.h:11867
octave_value get_zticklabel(void) const
Definition: graphics.h:5697
std::string string_value(bool force=false) const
Definition: ov.h:908
void set_ylim(const octave_value &val)
Definition: graphics.h:8881
plist_map_iterator end(void)
Definition: graphics.h:2044
void set_accelerator(const octave_value &val)
Definition: graphics.h:11519
void set_style(const octave_value &val)
Definition: graphics.h:9226
bool valid_object(void) const
Definition: graphics.h:11788
uitoggletool(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:13626
bool is_xliminclude(void) const
Definition: graphics.h:8109
void set_edgelighting(const octave_value &val)
Definition: graphics.h:10594
void update_outerposition(void)
Definition: graphics.h:7177
void defaults(void) const
Definition: graphics.h:3284
handle_property selectedobject
Definition: graphics.h:12376
std::map< listener_mode, octave_value_list > listener_map
Definition: graphics.h:402
bool is_climinclude(void) const
Definition: graphics.h:11209
std::string graphics_object_name(void) const
Definition: graphics.h:8642
void mark_modified(void)
Definition: graphics.h:3174
bool_property zliminclude
Definition: graphics.h:10298
bool paperunits_is(const std::string &v) const
Definition: graphics.h:4065
nd deftypefn *octave_map m
Definition: ov-struct.cc:2058
text(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:8570
double get_markersize(void) const
Definition: graphics.h:7577
virtual void delete_listener(const caseless_str &, const octave_value &, listener_mode=POSTSET)
Definition: graphics.cc:3173
octave_value get_shadowcolor(void) const
Definition: graphics.h:12462
array_property position
Definition: graphics.h:11711
void set_xliminclude(const octave_value &val)
Definition: graphics.h:10019
std::string get_alimmode(void) const
Definition: graphics.h:5410
void set_ytickmode(const octave_value &val)
Definition: graphics.h:6723
virtual Cell values_as_cell(void) const
Definition: graphics.h:322
bool is_editing(void) const
Definition: graphics.h:8057
octave_value get_x_rendertransform(void) const
Definition: graphics.h:5722
std::string current_val
Definition: graphics.h:981
static std::string go_name
Definition: graphics.h:11141
ColumnVector xform_vector(void)
Definition: graphics.cc:5096
base_scaler * clone(void) const
Definition: graphics.h:107
radio_property autopos_tag
Definition: graphics.h:7997
double_property labelfontsizemultiplier
Definition: graphics.h:5188
bool backgroundcolor_is(const std::string &v) const
Definition: graphics.h:12815
void set_aliminclude(const octave_value &val)
Definition: graphics.h:8893
octave_value get_factory_default(const caseless_str &name) const
Definition: graphics.h:3236
radio_property facenormalsmode
Definition: graphics.h:9363
virtual ~base_properties(void)
Definition: graphics.h:2429
virtual void adopt(const graphics_handle &h)
Definition: graphics.h:2489
bool xscale_is(const std::string &v) const
Definition: graphics.h:5605
std::string graphics_object_name(void) const
Definition: graphics.h:13448
gtk_manager(void)
Definition: graphics.h:2307
bool fontangle_is(const std::string &v) const
Definition: graphics.h:8065
color_property markeredgecolor
Definition: graphics.h:10273
bool fontangle_is(const std::string &v) const
Definition: graphics.h:12824
Matrix scale(const Matrix &m) const
Definition: graphics.h:117
void update_xdata(void)
Definition: graphics.h:11023
bool set(const octave_value &val, bool do_run=true, bool do_notify_toolkit=true)
Definition: graphics.h:1883
void set_xlim(const octave_value &val)
Definition: graphics.h:9959
void set(const caseless_str &pname, const octave_value &val)
double get_zticklabelrotation(void) const
Definition: graphics.h:5702
octave_value get_windowscrollwheelfcn(void) const
Definition: graphics.h:4117
void set_specularcolorreflectance(const octave_value &val)
Definition: graphics.h:9837
double get_mousewheelzoom(void) const
Definition: graphics.h:5707
radio_property normalmode
Definition: graphics.h:9374
string_property __gl_vendor__
Definition: graphics.h:3909
int get_ystate(void) const
Definition: graphics.h:4999
callback_property callback
Definition: graphics.h:11866
std::string get_beingdeleted(void) const
Definition: graphics.h:2662
octave_refcount< int > count
Definition: graphics.h:410
array_property pointershapecdata
Definition: graphics.h:3889
bool minorgridcolor_is_rgb(void) const
Definition: graphics.h:5518
std::string get_zliminclude(void) const
Definition: graphics.h:11219
bool is_double(void) const
Definition: graphics.h:1237
double get_fx(void) const
Definition: graphics.h:5019
octave_value get(void) const
Definition: graphics.h:1789
void set_alphadatamapping(const octave_value &val)
Definition: graphics.h:9566
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:9115
bool do_set(const octave_value &v)
Definition: graphics.h:1807
octave_value get_color(void) const
Definition: graphics.h:4007
void set(const caseless_str &pname, const octave_value &val)
radio_property erasemode
Definition: graphics.h:8671
std::string get_edgelighting(void) const
Definition: graphics.h:9475
void set_titleposition(const octave_value &val)
Definition: graphics.h:12652
bool_property checked
Definition: graphics.h:11457
Matrix get_zcolor_rgb(void) const
Definition: graphics.h:5667
double get_yPlane(void) const
Definition: graphics.h:5003
void update_zscale(void)
Definition: graphics.h:7039
void do_delete_children(bool clear)
Definition: graphics.cc:1636
octave_value get_zmtick(void) const
Definition: graphics.h:5728
handle_property uicontextmenu
Definition: graphics.h:2629
plist_map_const_iterator begin(void) const
Definition: graphics.h:2042
uicontrol(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:12277
void set_tooltipstring(const octave_value &val)
Definition: graphics.h:13367
void set___gl_renderer__(const octave_value &val) const
Definition: graphics.h:4589
void renumber(graphics_handle old_gh, graphics_handle new_gh)
Definition: graphics.h:1649
row_vector_property zdata
Definition: graphics.h:7509
property_list(const plist_map_type &m=plist_map_type())
Definition: graphics.h:2032
row_vector_property ylim
Definition: graphics.h:10292
void init(void)
Definition: graphics.h:9238
bool is_enable(void) const
Definition: graphics.h:13504
std::string get_zlimmode(void) const
Definition: graphics.h:5684
octave_value get_facenormals(void) const
Definition: graphics.h:10404
double get_specularcolorreflectance(void) const
Definition: graphics.h:9527
octave_value get_ydata(void) const
Definition: graphics.h:7583
double get_ypTickN(void) const
Definition: graphics.h:5010
void set_editing(const octave_value &val)
Definition: graphics.h:8175
octave_value get_resizefcn(void) const
Definition: graphics.h:12850
bool is_enable(void) const
Definition: graphics.h:13308
double_property fontsize
Definition: graphics.h:5179
void execute_windowbuttondownfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4101
string_vector str
Definition: graphics.h:660
std::string get_zscale(void) const
Definition: graphics.h:5693
radio_property xdatamode
Definition: graphics.h:8682
bool is_string(void) const
Definition: ov.h:578
bool facealpha_is(const std::string &v) const
Definition: graphics.h:9481
std::string get_name(void) const
Definition: graphics.h:2195
virtual void update_autopos(const std::string &elem_type)
Definition: graphics.cc:3153
figure(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:4776
Matrix get_shadowcolor_rgb(void) const
Definition: graphics.h:12854
bool facealpha_is(const std::string &v) const
Definition: graphics.h:10392
radio_property cameraupvectormode
Definition: graphics.h:5164
std::string str
Definition: hash.cc:118
base_properties & get_properties(void)
Definition: graphics.h:13042
std::string get_ydatasource(void) const
Definition: graphics.h:7585
octave_value get(void) const
Definition: graphics.h:1096
color_property markerfacecolor
Definition: graphics.h:9372
void set_foregroundcolor(const octave_value &val)
Definition: graphics.h:12111
octave_value get_vertexnormals(void) const
Definition: graphics.h:9533
row_vector_property xmtick
Definition: graphics.h:5271
double get_margin(void) const
Definition: graphics.h:8089
~scaler(void)
Definition: graphics.h:206
virtual octave_value get(void) const
Definition: graphics.h:312
void update_fontsize(void)
Definition: graphics.h:8551
void set_yliminclude(const octave_value &val)
Definition: graphics.h:8409
void set_alim(const octave_value &val)
Definition: graphics.h:10866
std::set< std::string > all_property_names(void) const
virtual bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:2979
string_property __gl_version__
Definition: graphics.h:3910
std::string graphics_object_name(void) const
Definition: graphics.h:11840
double_property linestyleorderindex
Definition: graphics.h:5191
std::string get_box(void) const
Definition: graphics.h:5418
void set_facealpha(const octave_value &val)
Definition: graphics.h:10614
std::string get_ztickmode(void) const
Definition: graphics.h:5705
std::string get_cameraupvectormode(void) const
Definition: graphics.h:5436
iterator find(const std::string pname)
Definition: graphics.h:1970
const T * data(void) const
Definition: Array.h:582
void update_fontweight(void)
Definition: graphics.h:7171
bool get_y2Dright(void) const
Definition: graphics.h:5029
radio_property tickdirmode
Definition: graphics.h:5207
std::string get_visible(void) const
Definition: graphics.h:2705
radio_property fontangle
Definition: graphics.h:5177
double get_yticklabelrotation(void) const
Definition: graphics.h:5660
Matrix rgb(void) const
Definition: graphics.h:1111
bool is_handle_visible(void) const
Definition: graphics.h:3347
void set___modified__(const octave_value &val)
Definition: graphics.h:2534
bool facenormalsmode_is(const std::string &v) const
Definition: graphics.h:9495
base_properties & get_properties(void)
Definition: graphics.h:7408
row_vector_property xlim
Definition: graphics.h:11164
bool is_enable(void) const
Definition: graphics.h:11491
std::string get_ygrid(void) const
Definition: graphics.h:5635
array_property(void)
Definition: graphics.h:1286
double min_val(void) const
Definition: graphics.h:1320
void add_constraint(const dim_vector &dims)
Definition: graphics.h:1417
void set_xlim(const octave_value &val)
Definition: graphics.h:6457
bool zdir_is(const std::string &v) const
Definition: graphics.h:5673
Matrix get_edgecolor_rgb(void) const
Definition: graphics.h:9471
row_vector_property ymtick
Definition: graphics.h:5272
std::string get_style(void) const
Definition: graphics.h:9203
bool titleposition_is(const std::string &v) const
Definition: graphics.h:12472
void set_nextplot(const octave_value &val)
Definition: graphics.h:4327
octave_value get_clim(void) const
Definition: graphics.h:10460
string_vector & append(const std::string &s)
Definition: str-vec.cc:107
double get_fontsize(void) const
Definition: graphics.h:12829
void set_zliminclude(const octave_value &val)
Definition: graphics.h:10043
~graphics_object(void)
Definition: graphics.h:3168
static bool has_readonly_property(const caseless_str &pname)
callback_property(const std::string &nm, const graphics_handle &h, const octave_value &m)
Definition: graphics.h:1782
radio_property meshstyle
Definition: graphics.h:10276
color_property highlightcolor
Definition: graphics.h:12373
bool_property xminortick
Definition: graphics.h:5225
octave_value get_facecolor(void) const
Definition: graphics.h:10399
void set_interpreter(const octave_value &val)
Definition: graphics.h:8268
radio_property plotboxaspectratiomode
Definition: graphics.h:5201
std::string get_alphadatamapping(void) const
Definition: graphics.h:9448
void set_alim(const octave_value &val)
Definition: graphics.h:11242
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:8584
radio_values radio_val
Definition: graphics.h:1148
void set_resizefcn(const octave_value &val)
Definition: graphics.h:12598
static bool has_readonly_property(const caseless_str &pname)
octave_value get_cdata(void) const
Definition: graphics.h:10364
string_property fixedwidthfontname
Definition: graphics.h:3450
std::string get_cameraviewanglemode(void) const
Definition: graphics.h:5441
array_property looseinset
Definition: graphics.h:5265
radio_property units
Definition: graphics.h:5214
void update_string(void)
Definition: graphics.h:12262
Matrix do_get_children(bool return_hidden) const
Definition: graphics.cc:1599
octave_value get_clim(void) const
Definition: graphics.h:5443
octave_value get_markeredgecolor(void) const
Definition: graphics.h:9518
octave_value get_clim(void) const
Definition: graphics.h:3320
radio_property linestyle
Definition: graphics.h:7979
Cell values_as_cell(void) const
Definition: graphics.cc:1243
std::string get_alphadatamapping(void) const
Definition: graphics.h:10357
bool edgecolor_is_rgb(void) const
Definition: graphics.h:10380
octave_int< T > pow(const octave_int< T > &a, const octave_int< T > &b)
double tmp
Definition: data.cc:6300
virtual const base_properties & get_properties(void) const
Definition: graphics.h:3046
graphics_event & operator=(const graphics_event &e)
Definition: graphics.h:13696
bool autopos_tag_is(const std::string &v) const
Definition: graphics.h:5709
void set_yliminclude(const octave_value &val)
Definition: graphics.h:7818
bool do_set(const octave_value &val)
Definition: graphics.h:755
void set_zticklabelmode(const octave_value &val)
Definition: graphics.h:6859
is false
Definition: cellfun.cc:398
std::list< double > children_list
Definition: graphics.h:1666
double_property linewidth
Definition: graphics.h:10271
double get_listboxtop(void) const
Definition: graphics.h:11967
double_property diffusestrength
Definition: graphics.h:10258
void set_fontsmoothing(const octave_value &val)
Definition: graphics.h:6040
void set_color(const octave_value &val)
Definition: graphics.h:4193
virtual bool is_valid(void) const
Definition: graphics.h:2081
void set_edgecolor(const octave_value &val)
Definition: graphics.h:8165
bool is_yliminclude(void) const
Definition: graphics.h:3341
handle_property(const std::string &nm, const graphics_handle &h, const graphics_handle &val=graphics_handle())
Definition: graphics.h:1514
double get_specularstrength(void) const
Definition: graphics.h:9531
octave_value get_alim(void) const
Definition: graphics.h:3317
radio_property cameratargetmode
Definition: graphics.h:5162
std::string graphics_object_name(void) const
Definition: graphics.h:11136
bool markeredgecolor_is(const std::string &v) const
Definition: graphics.h:9516
color_property edgecolor
Definition: graphics.h:10261
octave_value get_facenormals(void) const
Definition: graphics.h:9493
radio_property alphadatamapping
Definition: graphics.h:8667
bool ambientlightcolor_is(const std::string &v) const
Definition: graphics.h:5413
void set_facenormalsmode(const octave_value &val)
Definition: graphics.h:9725
void set_papersize(const octave_value &val)
Definition: graphics.h:4385
octave_value retval
Definition: data.cc:6294
radio_property minorgridalphamode
Definition: graphics.h:5194
void set_fltk_label(const octave_value &val)
Definition: graphics.h:11599
Matrix get_backgroundcolor_rgb(void) const
Definition: graphics.h:12415
bool is_cellstr(void) const
Definition: ov.h:548
array_property position
Definition: graphics.h:7982
array_property papersize
Definition: graphics.h:3885
radio_property fontangle
Definition: graphics.h:11871
base_property * rep
Definition: graphics.h:1949
radio_property vertexnormalsmode
Definition: graphics.h:9379
void set_x_viewporttransform(const octave_value &val)
Definition: graphics.h:6942
#define panic_impossible()
Definition: error.h:40
void do_init_children(const Matrix &val)
Definition: graphics.h:1730
base_properties & get_properties(void)
Definition: graphics.h:11784
void set_defaults(base_graphics_object &obj, const std::string &mode)
Definition: graphics.cc:4793
void set_zdatasource(const octave_value &val)
Definition: graphics.h:10856
void set_backgroundcolor(const octave_value &val)
Definition: graphics.h:12486
std::string get_toolbar(void) const
Definition: graphics.h:4096
octave_value get(bool all=false) const
void set_callback(const octave_value &val)
Definition: graphics.h:11529
virtual void remove_child(const graphics_handle &h)
Definition: graphics.h:3006
handle_property parent
Definition: graphics.h:2624
void set_color(const octave_value &val)
Definition: graphics.h:9206
std::string get_renderermode(void) const
Definition: graphics.h:4081
bool cameratargetmode_is(const std::string &v) const
Definition: graphics.h:5430
handle_property callbackobject
Definition: graphics.h:3447
void execute_selectionchangedfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:12456
virtual base_properties & get_properties(void)
Definition: graphics.h:3039
std::map< std::string, graphics_toolkit >::const_iterator const_loaded_toolkits_iterator
Definition: graphics.h:2348
std::list< graphics_handle > dependent_obj_list
Definition: graphics.h:11771
void update_vertexnormalsmode(void)
Definition: graphics.h:11043
bool plotboxaspectratiomode_is(const std::string &v) const
Definition: graphics.h:5536
radio_property verticalalignment
Definition: graphics.h:7986
graphics_object(base_graphics_object *new_rep)
Definition: graphics.h:3146
bool units_is(const std::string &v) const
Definition: graphics.h:3501
std::string get_resize(void) const
Definition: graphics.h:4084
bool horizontalalignment_is(const std::string &v) const
Definition: graphics.h:11961
std::string get_climinclude(void) const
Definition: graphics.h:8608
std::string get_linestyle(void) const
Definition: graphics.h:9508
double get_linestyleorderindex(void) const
Definition: graphics.h:5509
octave_value get_sliderstep(void) const
Definition: graphics.h:11975
void set_marker(const octave_value &val)
Definition: graphics.h:9797
radio_property paperpositionmode
Definition: graphics.h:3884
string_property xdatasource
Definition: graphics.h:10284
std::string get_wvisual(void) const
Definition: graphics.h:4150
Matrix get_foregroundcolor_rgb(void) const
Definition: graphics.h:11958
radio_property edgelighting
Definition: graphics.h:9357
virtual ~base_graphics_object(void)
Definition: graphics.h:2895
void set_vertexnormalsmode(const octave_value &val)
Definition: graphics.h:10792
std::string get_units(void) const
Definition: graphics.h:4099
bool units_is(const std::string &v) const
Definition: graphics.h:8097
void set_xdata(const octave_value &val)
Definition: graphics.h:10803
std::string get_units(void) const
Definition: graphics.h:3502
const base_properties & get_properties(void) const
Definition: graphics.h:12693
double get_y_max(void) const
Definition: graphics.h:5016
radio_property yscale
Definition: graphics.h:5242
void set_minorgridalpha(const octave_value &val)
Definition: graphics.h:6158
row_vector_property xlim
Definition: graphics.h:8676
string_property __gl_extensions__
Definition: graphics.h:3907
radio_property fontunits
Definition: graphics.h:11874
void set_ylim(const octave_value &val)
Definition: graphics.h:8373
std::string get_zdir(void) const
Definition: graphics.h:5674
std::string graphics_object_name(void) const
Definition: graphics.h:11685
static void unload_toolkit(const std::string &name)
Definition: graphics.h:2272
double_radio_property edgealpha
Definition: graphics.h:10260
callback_property deletefcn
Definition: graphics.h:2620
radio_property fontangle
Definition: graphics.h:12367
base_properties & get_properties(void)
Definition: graphics.h:3288
Matrix do_figure_handle_list(bool show_hidden)
Definition: graphics.h:14070
std::string get_showhiddenhandles(void) const
Definition: graphics.h:3499
std::string get_fontname(void) const
Definition: graphics.h:11946
~graphics_toolkit(void)
Definition: graphics.h:2173
virtual void remove_child(const graphics_handle &h)
Definition: graphics.h:2480
void set_position(const octave_value &val)
Definition: graphics.h:6273
base_property * clone(void) const
Definition: graphics.h:751
void update_ytick(void)
Definition: graphics.h:7098
std::string get_units(void) const
Definition: graphics.h:11987
static std::string go_name
Definition: graphics.h:13263
property_list get_factory_defaults_list(void) const
Definition: graphics.h:3706
double get_screenpixelsperinch(void) const
Definition: graphics.h:3494
double get_ytickoffset(void) const
Definition: graphics.h:5026
row_vector_property xdata
Definition: graphics.h:7505
std::string get_paperunits(void) const
Definition: graphics.h:4066
color_property backgroundcolor
Definition: graphics.h:12363
radio_property fontunits
Definition: graphics.h:12778
std::string get_xdatasource(void) const
Definition: graphics.h:7581
std::string get_displayname(void) const
Definition: graphics.h:9462
void set_climinclude(const octave_value &val)
Definition: graphics.h:11302
const base_properties & get_properties(void) const
Definition: graphics.h:9111
virtual void redraw_figure(const graphics_object &) const
Definition: graphics.h:2083
static std::string go_name
Definition: graphics.h:12752
void set_windowbuttonupfcn(const octave_value &val)
Definition: graphics.h:4530
callback_property selectionchangedfcn
Definition: graphics.h:12377
void update_cdata(void)
Definition: graphics.h:8992
bool drawmode_is(const std::string &v) const
Definition: graphics.h:5467
void reset_default_properties(void)
Definition: graphics.h:3366
void set_cameraviewangle(const octave_value &val)
Definition: graphics.h:5867
Matrix get_color_rgb(void) const
Definition: graphics.h:7548
bool is_cellstr(void) const
Definition: Cell.cc:123
void set_parent(const graphics_handle &h)
Definition: graphics.h:295
std::string get_accelerator(void) const
Definition: graphics.h:11483
std::string name
Definition: graphics.h:411
bool is_radio(void) const
Definition: graphics.h:941
void set___zoom_mode__(const octave_value &val)
Definition: graphics.h:4658
double get_xPlaneN(void) const
Definition: graphics.h:5002
string_property label
Definition: graphics.h:11460
void set_position(const octave_value &val)
Definition: graphics.h:12968
void set_clipping(const octave_value &val)
Definition: graphics.h:12516
any_property linestyleorder
Definition: graphics.h:5190
octave_value get___object__(void) const
Definition: graphics.h:11722
void set_displayname(const octave_value &val)
Definition: graphics.h:7617
std::string get_label(void) const
Definition: graphics.h:11499
octave_value get_pointerlocation(void) const
Definition: graphics.h:3488
void update_ydata(void)
Definition: graphics.h:9025
bool is_hidden(void) const
Definition: graphics.h:1865
static Matrix handle_list(bool show_hidden=false)
Definition: graphics.h:13844
const base_properties & get_properties(void) const
Definition: graphics.h:7410
idx type
Definition: ov.cc:3129
callback_property windowkeyreleasefcn
Definition: graphics.h:3904
std::string get_windowstyle(void) const
Definition: graphics.h:4120
std::string get_marker(void) const
Definition: graphics.h:10418
octave_value get_dataaspectratio(void) const
Definition: graphics.h:5462
void set_id(int d)
Definition: graphics.h:1877
void set_clim(const octave_value &val)
Definition: graphics.h:5891
void update_xtickmode(void)
Definition: graphics.h:7111
static bool has_readonly_property(const caseless_str &pname)
std::string get_gridcolormode(void) const
Definition: graphics.h:5497
callback_property windowkeypressfcn
Definition: graphics.h:3903
graphics_toolkit toolkit
Definition: graphics.h:4769
bool do_try_lock(void)
Definition: graphics.h:14105
~graphics_event(void)
Definition: graphics.h:13690
void init(void)
Definition: graphics.h:8506
octave_value get_currentpoint(void) const
Definition: graphics.h:4017
color_property color
Definition: graphics.h:7966
octave_value get_xlim(void) const
Definition: graphics.h:8732
bool_property inverthardcopy
Definition: graphics.h:3874
bool valid_object(void) const
Definition: graphics.h:7872
octave_value get_zlim(void) const
Definition: graphics.h:7595
octave_value get_linestyleorder(void) const
Definition: graphics.h:5507
radio_property fontweight
Definition: graphics.h:12779
bool_property selectionhighlight
Definition: graphics.h:2626
Definition: dMatrix.h:37
array_property position
Definition: graphics.h:9183
void set_minorgridlinestyle(const octave_value &val)
Definition: graphics.h:6206
properties xproperties
Definition: graphics.h:8567
sz
Definition: data.cc:5342
property_list get_defaults_list(void) const
Definition: graphics.h:3696
bool get_layer2Dtop(void) const
Definition: graphics.h:5030
std::string get_string_string(void) const
Definition: graphics.h:11977
array_property outerposition
Definition: graphics.h:5199
void renumber_parent(graphics_handle new_gh)
Definition: graphics.h:2558
static void enable_event_processing(bool enable=true)
Definition: graphics.h:13941
bool is_fontsmoothing(void) const
Definition: graphics.h:5480
void do_unregister_toolkit(const std::string &name)
Definition: graphics.cc:10946
double_property colororderindex
Definition: graphics.h:5172
const base_properties & get_properties(void) const
Definition: graphics.h:13399
octave_value lookup(const caseless_str &name) const
Definition: graphics.cc:2077
void set_ztickmode(const octave_value &val)
Definition: graphics.h:6880
base_properties & get_properties(void)
Definition: graphics.h:8578
void set___object__(const octave_value &val)
Definition: graphics.h:13128
bool wvisualmode_is(const std::string &v) const
Definition: graphics.h:4152
bool_property separator
Definition: graphics.h:13478
std::string get_xliminclude(void) const
Definition: graphics.h:9557
void update_ylim(void)
Definition: graphics.h:7309
graphics_toolkit & operator=(const graphics_toolkit &b)
Definition: graphics.h:2179
string_property displayname
Definition: graphics.h:10259
the sparsity preserving column transformation such that that defines the pivoting threshold can be given in which case it defines the c
Definition: lu.cc:138
radio_property linestyle
Definition: graphics.h:7499
static graphics_event create_function_event(event_fcn fcn, void *data=0)
Definition: graphics.cc:9488
bool marker_is(const std::string &v) const
Definition: graphics.h:7564
void adopt(double val)
Definition: graphics.h:1619
bool_property climinclude
Definition: graphics.h:9390
const base_properties & get_properties(void) const
Definition: graphics.h:12285
std::list< graphics_handle >::const_iterator const_figure_list_iterator
Definition: graphics.h:13995
octave_value get_zlim(void) const
Definition: graphics.h:3329
virtual bool is_yliminclude(void) const
Definition: graphics.h:2579
color_property edgecolor
Definition: graphics.h:7968
double unscale(double d) const
Definition: graphics.h:138
std::string get_clipping(void) const
Definition: graphics.h:11936
bool layer_is(const std::string &v) const
Definition: graphics.h:5504
array_property commandwindowsize
Definition: graphics.h:3448
the exceeded dimensions are set to if fewer subscripts than dimensions are the exceeding dimensions are merged into the final requested dimension For consider the following dims
Definition: sub2ind.cc:255
std::string get_filename(void) const
Definition: graphics.h:4022
octave_value get_screensize(void) const
Definition: graphics.h:3496
void set_zdata(const octave_value &val)
Definition: graphics.h:7749
void set_cdata(const octave_value &val)
Definition: graphics.h:13532
void do_load_toolkit(const graphics_toolkit &tk)
Definition: graphics.h:2356
void set_xlim(const octave_value &val)
Definition: graphics.h:11262
bool_property dockcontrols
Definition: graphics.h:3870
void set_string(const octave_value &val)
Definition: graphics.h:12191
properties xproperties
Definition: graphics.h:13033
void set_xcolormode(const octave_value &val)
Definition: graphics.h:6424
octave_value get_position(void) const
Definition: graphics.h:4075
void set_windowbuttondownfcn(const octave_value &val)
Definition: graphics.h:4510
void override_defaults(base_graphics_object &obj)
Definition: graphics.h:3176
double get_mincolormap(void) const
Definition: graphics.h:4148
dim_vector dims(void) const
Definition: ov.h:486
octave_value get_cameraposition(void) const
Definition: graphics.h:5423
bool is_aliminclude(void) const
Definition: graphics.h:11206
bool fontangle_is(const std::string &v) const
Definition: graphics.h:12426
void set_zminorgrid(const octave_value &val)
Definition: graphics.h:6809
callback_property(const callback_property &p)
Definition: graphics.h:1786
void set_paperpositionmode(const octave_value &val)
Definition: graphics.h:4374
radio_property gridcolormode
Definition: graphics.h:5186
string_vector string_vector_value(bool pad=false) const
Definition: ov.h:911
virtual void delete_property_listener(const std::string &nm, const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:3089
octave_value get_keyreleasefcn(void) const
Definition: graphics.h:4037
bool fontunits_is(const std::string &v) const
Definition: graphics.h:12831
Matrix matrix_value(bool frc_str_conv=false) const
Definition: ov.h:787
double max_val(void) const
Definition: graphics.h:1321
Matrix get_screen_size(void) const
Definition: graphics.h:2211
bool is_yliminclude(void) const
Definition: graphics.h:8739
void set_fontsize_points(const octave_value &val)
Definition: graphics.h:7002
radio_property tickdir
Definition: graphics.h:5206
bool autopos_tag_is(const std::string &v) const
Definition: graphics.h:8130
OCTINTERP_API radio_values(const std::string &opt_string="")
Definition: graphics.cc:1179
std::string pname
Definition: graphics.cc:11207
properties xproperties
Definition: graphics.h:10156
bool initialize(const graphics_object &go)
Definition: graphics.h:2222
Cell do_loaded_toolkits_list(void) const
Definition: graphics.h:2387
array_property zdata
Definition: graphics.h:10287
double get_linewidth(void) const
Definition: graphics.h:10415
const base_properties & get_properties(void) const
Definition: graphics.h:7870
octave_value get_papersize(void) const
Definition: graphics.h:4060
string_vector value
Definition: graphics.h:821
void update_fontweight(void)
Definition: graphics.h:12266
bool alphadatamapping_is(const std::string &v) const
Definition: graphics.h:10356
static std::string go_name
Definition: graphics.h:7946
array_property pointerlocation
Definition: graphics.h:3452
plist_map_const_iterator end(void) const
Definition: graphics.h:2045
void update_xcolor(void)
Definition: graphics.h:7045
Matrix get_xcolor_rgb(void) const
Definition: graphics.h:5580
array_property vertices
Definition: graphics.h:9380
std::string graphics_object_name(void) const
Definition: graphics.h:9158
void set(const caseless_str &name, const octave_value &val)
Definition: graphics.h:3194
std::string get_xminorgrid(void) const
Definition: graphics.h:5600
std::string get_xgrid(void) const
Definition: graphics.h:5590
octave_value get___object__(void) const
Definition: graphics.h:12411
row_vector_property(const row_vector_property &p)
Definition: graphics.h:1404
static graphics_event create_callback_event(const graphics_handle &h, const std::string &name, const octave_value &data=Matrix())
Definition: graphics.cc:9464
graphics_handle parent
Definition: graphics.h:412
OCTINTERP_API void execute(const octave_value &data=octave_value()) const
Definition: graphics.cc:1678
std::string get_fontweight(void) const
Definition: graphics.h:11954
std::string get_verticalalignmentmode(void) const
Definition: graphics.h:8128
octave_value get_vertices(void) const
Definition: graphics.h:9538
double_property(const double_property &p)
Definition: graphics.h:1162
double get_screendepth(void) const
Definition: graphics.h:3492
static void execute_callback(const graphics_handle &h, const std::string &name, const octave_value &data=Matrix())
Definition: graphics.h:13883
any_property(const std::string &nm, const graphics_handle &h, const octave_value &m=Matrix())
Definition: graphics.h:1554
~figure(void)
Definition: graphics.h:4780
std::string get_xdatamode(void) const
Definition: graphics.h:8743
graphics_handle get_currentobject(void) const
Definition: graphics.h:4015
bool is_state(void) const
Definition: graphics.h:13516
bool is_clipping(void) const
Definition: graphics.h:2670
double_property linewidth
Definition: graphics.h:7500
charMatrix char_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:828
std::list< double >::const_iterator const_children_list_iterator
Definition: graphics.h:1665
void set_defaults(const std::string &mode)
Definition: graphics.h:7378
void set_clickedcallback(const octave_value &val)
Definition: graphics.h:13337
static void cleanup_instance(void)
Definition: graphics.h:13761
double get_min(void) const
Definition: graphics.h:11971
octave_value get_ycolor(void) const
Definition: graphics.h:5626
std::string get_projection(void) const
Definition: graphics.h:5545
void update_fontweight(void)
Definition: graphics.h:8553
base_properties & get_properties(void)
Definition: graphics.h:11073
static bool has_core_property(const caseless_str &pname)
void update_verticalalignmentmode(void)
Definition: graphics.h:8544
std::string get_doublebuffer(void) const
Definition: graphics.h:4146
octave_value get_tightinset(void) const
Definition: graphics.h:5561
bool is_yliminclude(void) const
Definition: graphics.h:7600
void set(const caseless_str &pname, const octave_value &val)
double get_xPlane(void) const
Definition: graphics.h:5001
void set_fontname(const octave_value &val)
Definition: graphics.h:12916
std::string get_erasemode(void) const
Definition: graphics.h:8722
void set_foregroundcolor(const octave_value &val)
Definition: graphics.h:11559
bool get_zSign(void) const
Definition: graphics.h:5034
bool is_resize(void) const
Definition: graphics.h:4083
std::string get_zliminclude(void) const
Definition: graphics.h:10475
void update(const graphics_handle &h, int id)
Definition: graphics.h:2218
static gh_manager * instance
Definition: graphics.h:13985
octave_value get_keypressfcn(void) const
Definition: graphics.h:11965
void set_xgrid(const octave_value &val)
Definition: graphics.h:6445
bool valid_object(void) const
Definition: graphics.h:10169
std::string get_selected(void) const
Definition: graphics.h:2691
void add_dependent_obj(graphics_handle gh)
Definition: graphics.h:11650
row_vector_property ylim
Definition: graphics.h:7988
bool_property aliminclude
Definition: graphics.h:10294
array_property vertexnormals
Definition: graphics.h:9378
void set_vertexnormalsmode(const octave_value &val)
Definition: graphics.h:9881
std::set< std::string > available_toolkits
Definition: graphics.h:2334
octave_value get_string(void) const
Definition: graphics.h:8095
bool edgealpha_is(const std::string &v) const
Definition: graphics.h:10376
radio_property fontunits
Definition: graphics.h:5180
octave_value get_windowkeypressfcn(void) const
Definition: graphics.h:4111
void init(void)
Definition: graphics.h:4748
void finalize(const graphics_handle &h)
Definition: graphics.h:2234
radio_property ydir
Definition: graphics.h:5235
void set_extent(const octave_value &val)
Definition: graphics.h:8195
octave_value get_minorgridcolor(void) const
Definition: graphics.h:5521
void set_cdatamapping(const octave_value &val)
Definition: graphics.h:9609
std::map< std::string, graphics_toolkit >::iterator loaded_toolkits_iterator
Definition: graphics.h:2345
T & xelem(octave_idx_type n)
Definition: Array.h:455
radio_property interpreter
Definition: graphics.h:9367
void set_xdatamode(const octave_value &val)
Definition: graphics.h:8941
double get_yPlaneN(void) const
Definition: graphics.h:5004
graphics_toolkit get_toolkit(void) const
Definition: graphics.h:3752
void update_rotation(void)
Definition: graphics.h:8548
void set_aliminclude(const octave_value &val)
Definition: graphics.h:11292
string_property(const string_property &p)
Definition: graphics.h:426
bool is_zminorgrid(void) const
Definition: graphics.h:5686
virtual void set_defaults(const std::string &)
Definition: graphics.h:2931
base_graphics_toolkit(const std::string &nm)
Definition: graphics.h:2074
std::string get_separator(void) const
Definition: graphics.h:11504
static graphics_toolkit find_toolkit(const std::string &name)
Definition: graphics.h:2278
bool edgealpha_is_double(void) const
Definition: graphics.h:10375
octave_value get_shadowcolor(void) const
Definition: graphics.h:12855
double_radio_property facealpha
Definition: graphics.h:10264
radio_property climmode
Definition: graphics.h:5168
radio_property ztickmode
Definition: graphics.h:5262
octave_int< T > xmin(const octave_int< T > &x, const octave_int< T > &y)
octave_value get_looseinset(void) const
Definition: graphics.h:5712
octave_refcount< int > count
Definition: graphics.h:3125
string_property(const std::string &s, const graphics_handle &h, const std::string &val="")
Definition: graphics.h:422
octave_value get_deletefcn(void) const
Definition: graphics.h:2677
std::string get_climmode(void) const
Definition: graphics.h:5446
void set_xvisual(const octave_value &val)
Definition: graphics.h:4722
graphics_handle get_title(void) const
Definition: graphics.h:5563
void set_markerfacecolor(const octave_value &val)
Definition: graphics.h:7687
row_vector_property clim
Definition: graphics.h:10290
void set_cameraviewanglemode(const octave_value &val)
Definition: graphics.h:5881
double get_xticklabelrotation(void) const
Definition: graphics.h:5615
bool valid_object(void) const
Definition: graphics.h:12695
static bool has_readonly_property(const caseless_str &pname)
double get_ypTick(void) const
Definition: graphics.h:5009
base_graphics_object * rep
Definition: graphics.h:3370
graphics_handle do_lookup(double val)
Definition: graphics.h:14029
bool clippingstyle_is(const std::string &v) const
Definition: graphics.h:5448
string_property tooltipstring
Definition: graphics.h:13480
array_property facevertexalphadata
Definition: graphics.h:9365
bool units_is(const std::string &v) const
Definition: graphics.h:5570
void set_mousewheelzoom(const octave_value &val)
Definition: graphics.h:6891
bool xcolormode_is(const std::string &v) const
Definition: graphics.h:5583
Matrix get_auto_xdata(void)
Definition: graphics.h:9044
void set_erasemode(const octave_value &val)
Definition: graphics.h:9671
virtual bool is_xliminclude(void) const
Definition: graphics.h:2578
static std::string go_name
Definition: graphics.h:13453
static bool has_readonly_property(const caseless_str &pname)
void set_facenormals(const octave_value &val)
Definition: graphics.h:10644
void set_color(const octave_value &val)
Definition: graphics.h:7607
row_vector_property alim
Definition: graphics.h:11162
void warning(const char *fmt,...)
Definition: error.cc:788
string_property type
Definition: graphics.h:2628
octave_value get_windowbuttonmotionfcn(void) const
Definition: graphics.h:4105
void execute_buttondownfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:2667
void override_defaults(base_graphics_object &obj)
Definition: graphics.h:13154
base_properties & get_properties(void)
Definition: graphics.h:11625
bool is_aliminclude(void) const
Definition: graphics.h:10190
virtual void finalize(const graphics_object &)
Definition: graphics.h:2131
double_property fontsize
Definition: graphics.h:11873
string_property __graphics_toolkit__
Definition: graphics.h:3911
bool get_xySym(void) const
Definition: graphics.h:5032
void override_defaults(base_graphics_object &obj)
Definition: graphics.h:3630
double_property min
Definition: graphics.h:11881
properties xproperties
Definition: graphics.h:11064
std::string get_yliminclude(void) const
Definition: graphics.h:7601
std::string graphics_object_name(void) const
Definition: graphics.h:11430
double xminp
Definition: graphics.h:1386
bool_property xliminclude
Definition: graphics.h:10296
const scaler & get_x_scaler(void) const
Definition: graphics.h:4951
void set_backgroundcolor(const octave_value &val)
Definition: graphics.h:12876
radio_property menubar
Definition: graphics.h:3877
std::string get_yliminclude(void) const
Definition: graphics.h:11216
std::string type(void) const
Definition: graphics.h:3308
std::string get_xliminclude(void) const
Definition: graphics.h:10469
array_property & operator=(const octave_value &val)
Definition: graphics.h:1337
graphics_handle get_parent(void) const
Definition: graphics.h:1859
callback_property createfcn
Definition: graphics.h:2619
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:11375
radio_property titleposition
Definition: graphics.h:12786
graphics_handle get_uicontextmenu(void) const
Definition: graphics.h:2700
bool_property yliminclude
Definition: graphics.h:10297
handle_property currentaxes
Definition: graphics.h:3866
std::string get_fontname(void) const
Definition: graphics.h:12827
base_property * clone(void) const
Definition: graphics.h:1804
octave_value get_edgealpha(void) const
Definition: graphics.h:10378
octave_value get_defaults(void) const
Definition: graphics.h:3241
void set_linestyle(const octave_value &val)
Definition: graphics.h:9777
bool valid_object(void) const
Definition: graphics.h:3306
std::string current_val
Definition: graphics.h:1278
bool facecolor_is_rgb(void) const
Definition: graphics.h:9485
double get_rotation(void) const
Definition: graphics.h:8093
OCTINTERP_API bool validate(const octave_value &v)
Definition: graphics.cc:1409
void set_enable(const octave_value &val)
Definition: graphics.h:13552
void set_autopos_tag(const octave_value &val)
Definition: graphics.h:8477
properties xproperties
Definition: graphics.h:9245
double_property mincolormap
Definition: graphics.h:3919
bool_property yminortick
Definition: graphics.h:5241
charNDArray max(char d, const charNDArray &m)
Definition: chNDArray.cc:228
std::string get_xvisualmode(void) const
Definition: graphics.h:4160
octave_value get_foregroundcolor(void) const
Definition: graphics.h:12442
array_property paperposition
Definition: graphics.h:3883
void update_xdata(void)
Definition: graphics.h:9006
radio_property dataaspectratiomode
Definition: graphics.h:5175
bool is(const std::string &v) const
Definition: graphics.h:1108
void set_x_projectiontransform(const octave_value &val)
Definition: graphics.h:6932
void set_clim(const octave_value &val)
Definition: graphics.h:10878
void set_ydatasource(const octave_value &val)
Definition: graphics.h:7739
radio_property rotationmode
Definition: graphics.h:7994
octave_value get_ydata(void) const
Definition: graphics.h:10450
double_property ambientstrength
Definition: graphics.h:9349
std::map< listener_mode, octave_value_list >::const_iterator listener_map_const_iterator
Definition: graphics.h:406
radio_property nextplot
Definition: graphics.h:3879
std::string get_fontname(void) const
Definition: graphics.h:8068
void set_extent(const octave_value &val)
Definition: graphics.h:12055
static graphics_handle make_figure_handle(double val, bool do_notify_toolkit=true)
Definition: graphics.h:13818
bool is_bool_scalar(void) const
Definition: ov.h:563
bool is_empty(void) const
Definition: ov.h:542
double get_facealpha_double(void) const
Definition: graphics.h:9482
row_vector_property clim
Definition: graphics.h:11163
std::string get_vertexnormalsmode(void) const
Definition: graphics.h:9536
bool edgecolor_is(const std::string &v) const
Definition: graphics.h:8053
void run_listeners(listener_mode mode=POSTSET)
Definition: graphics.h:1917
bool is_checked(void) const
Definition: graphics.h:11488
bool_property editing
Definition: graphics.h:7969
void set_pointershapecdata(const octave_value &val)
Definition: graphics.h:4414
void set_facevertexalphadata(const octave_value &val)
Definition: graphics.h:9746
#define Inf
Definition: Faddeeva.cc:247
void set_keyreleasefcn(const octave_value &val)
Definition: graphics.h:4297
bool_property clipping
Definition: graphics.h:12366
Matrix get_shadowcolor_rgb(void) const
Definition: graphics.h:12461
bool alimmode_is(const std::string &v) const
Definition: graphics.h:5409
void update_tickdirmode(void)
Definition: graphics.h:7090
bool menubar_is(const std::string &v) const
Definition: graphics.h:4039
octave_value get_markeredgecolor(void) const
Definition: graphics.h:7570
void set___object__(const octave_value &val)
Definition: graphics.h:11730
void update(const graphics_object &go, int id)
Definition: graphics.h:2215
void set_zdir(const octave_value &val)
Definition: graphics.h:6759
bool fontangle_is(const std::string &v) const
Definition: graphics.h:5470
octave_value get_facealpha(void) const
Definition: graphics.h:10394
radio_property interpreter
Definition: graphics.h:7978
void set_handlevisibility(const octave_value &val)
Definition: graphics.h:2783
octave_value get_color(void) const
Definition: graphics.h:7549
bool is_zliminclude(void) const
Definition: graphics.h:8115
T::size_type numel(const T &str)
Definition: oct-string.cc:61
bool xticklabelmode_is(const std::string &v) const
Definition: graphics.h:5612
std::string graphics_object_name(void) const
Definition: graphics.h:12338
radio_property autopos_tag
Definition: graphics.h:5264
Matrix scale(const Matrix &m) const
Definition: graphics.h:157
void set_cameratargetmode(const octave_value &val)
Definition: graphics.h:5833
Matrix get_opengl_matrix_2(void) const
Definition: graphics.h:4995
graphics_handle __myhandle__
Definition: graphics.h:2633
children_property children
Definition: graphics.h:2617
NDArray array_value(bool frc_str_conv=false) const
Definition: ov.h:793
std::string get_fltk_label(void) const
Definition: graphics.h:11506
radio_property ycolormode
Definition: graphics.h:5234
virtual Matrix get_canvas_size(const graphics_handle &) const
Definition: graphics.h:2091
virtual octave_value get(const caseless_str &pname) const
Matrix stack(const Matrix &a) const
Definition: dMatrix.cc:326
string_vector string_vector_value(void) const
Definition: graphics.h:538
void set_currentpoint(const octave_value &val)
Definition: graphics.h:4235
void set_windowbuttonmotionfcn(const octave_value &val)
Definition: graphics.h:4520
base_properties & get_properties(void)
Definition: graphics.h:3711
radio_property fontweight
Definition: graphics.h:5182
handle_property title
Definition: graphics.h:5211
double scale(double d) const
Definition: graphics.h:103
bool do_set(const octave_value &val)
Definition: graphics.h:1500
radio_property papertype
Definition: graphics.h:3886
bool zcolor_is_rgb(void) const
Definition: graphics.h:5665
void set___rotate_mode__(const octave_value &val)
Definition: graphics.h:4648
std::string get___gl_renderer__(void) const
Definition: graphics.h:4124
void update_ytickmode(void)
Definition: graphics.h:7120
void set_ycolormode(const octave_value &val)
Definition: graphics.h:6592
void set_children(const octave_value &val)
Definition: graphics.h:2743
octave::text_renderer txt_renderer
Definition: graphics.h:8503
properties xproperties
Definition: graphics.h:7342
graphics_handle get_currentfigure(void) const
Definition: graphics.h:3482
void set_zcolormode(const octave_value &val)
Definition: graphics.h:6749
void set___object__(const octave_value &val)
Definition: graphics.h:13522
void add_listener(const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:333
virtual property_list get_defaults_list(void) const
Definition: graphics.h:2961
bool edgelighting_is(const std::string &v) const
Definition: graphics.h:9474
void set_resize(const octave_value &val)
Definition: graphics.h:4458
ColumnVector pixel2coord(double px, double py) const
Definition: graphics.h:5037
static int flush_events(void)
Definition: graphics.h:13936
static void cleanup_instance(void)
Definition: graphics.h:2326
void set_resizefcn(const octave_value &val)
Definition: graphics.h:4468
bool_property aliminclude
Definition: graphics.h:8678
bool interpreter_is(const std::string &v) const
Definition: graphics.h:8081
std::set< std::string >::iterator available_toolkits_iterator
Definition: graphics.h:2339
std::string graphics_object_name(void) const
Definition: graphics.h:10227
callback_property keyreleasefcn
Definition: graphics.h:3876
std::string values_as_string(void) const
Definition: graphics.h:1887
double get_xtickoffset(void) const
Definition: graphics.h:5025
octave_value get_resizefcn(void) const
Definition: graphics.h:4087
color_property backgroundcolor
Definition: graphics.h:7965
double get_fz(void) const
Definition: graphics.h:5021
bool fontweight_is(const std::string &v) const
Definition: graphics.h:12834
any_property __object__
Definition: graphics.h:11454
base_property * clone(void) const
Definition: graphics.h:1135
std::string get_scale(const std::string &scale, const Matrix &lims)
Definition: graphics.h:7019
void set_cameraposition(const octave_value &val)
Definition: graphics.h:5795
static std::string go_name
Definition: graphics.h:12343
array_property outerposition
Definition: graphics.h:3881
std::string default_val
Definition: graphics.h:905
std::string get_horizontalalignment(void) const
Definition: graphics.h:8079
octave_value get_defaults(void) const
Definition: graphics.h:7398
bool tickdir_is(const std::string &v) const
Definition: graphics.h:5550
bool __mouse_mode___is(const std::string &v) const
Definition: graphics.h:4134
void set_screenpixelsperinch(const octave_value &val)
Definition: graphics.h:3569
octave_value get_xlim(void) const
Definition: graphics.h:8103
void set_linestyle(const octave_value &val)
Definition: graphics.h:7647
bool selectiontype_is(const std::string &v) const
Definition: graphics.h:4089
void set_borderwidth(const octave_value &val)
Definition: graphics.h:12506
double_property specularstrength
Definition: graphics.h:10280
void set_interpreter(const octave_value &val)
Definition: graphics.h:7637
radio_property cdatamapping
Definition: graphics.h:9352
bool is_ygrid(void) const
Definition: graphics.h:5634
double get_position(void) const
Definition: graphics.h:11501
double_radio_property(const std::string &nm, const graphics_handle &h, const double_radio_property &v)
Definition: graphics.h:1217
bool ok(void) const
Definition: graphics.h:13714
bool_property zliminclude
Definition: graphics.h:7992
row_vector_property xlim
Definition: graphics.h:9386
graphics_object(void)
Definition: graphics.h:3144
void invalidate(void)
Definition: graphics.h:1538
bool is_box(void) const
Definition: graphics.h:5417
properties xproperties
Definition: graphics.h:9098
void set_monitorpositions(const octave_value &val)
Definition: graphics.h:3529
string_property ydatasource
Definition: graphics.h:10286
std::string get_zdatasource(void) const
Definition: graphics.h:7589
std::string get_interpreter(void) const
Definition: graphics.h:7557
bool nextplot_is(const std::string &v) const
Definition: graphics.h:5529
void set_xlimmode(const octave_value &val)
Definition: graphics.h:6472
double_property specularcolorreflectance
Definition: graphics.h:9375
callback_property resizefcn
Definition: graphics.h:3895
void add_constraint(const dim_vector &dims)
Definition: graphics.h:1317
string_property & operator=(const octave_value &val)
Definition: graphics.h:434
any_property userdata
Definition: graphics.h:2630
void set_position(const octave_value &val)
Definition: graphics.h:11750
bool valid_object(void) const
Definition: graphics.h:9113
const base_properties & get_properties(void) const
Definition: graphics.h:10167
void set_dockcontrols(const octave_value &val)
Definition: graphics.h:4245
ColumnVector untransform(double x, double y, bool use_scale=true) const
Definition: graphics.h:4896
radio_property ydatamode
Definition: graphics.h:8683
void set_facecolor(const octave_value &val)
Definition: graphics.h:9691
radio_values(const radio_values &a)
Definition: graphics.h:832
octave_value get_zlim(void) const
Definition: graphics.h:11204
array_property vertexnormals
Definition: graphics.h:10281
bool bool_value(bool warn=false) const
Definition: ov.h:819
void set_yminortick(const octave_value &val)
Definition: graphics.h:6662
bool_property ygrid
Definition: graphics.h:5236
~uibuttongroup(void)
Definition: graphics.h:12689
scaler(void)
Definition: graphics.h:195
bool windowstyle_is(const std::string &v) const
Definition: graphics.h:4119
bool erasemode_is(const std::string &v) const
Definition: graphics.h:9477
std::string get_minorgridcolormode(void) const
Definition: graphics.h:5524
base_properties & get_properties(void)
Definition: graphics.h:7868
virtual bool initialize(const graphics_object &)
Definition: graphics.h:2120
=val(i)}if ode{val(i)}occurs in table i
Definition: lookup.cc:239
void set_xlim(const octave_value &val)
Definition: graphics.h:10890
std::map< std::string, pval_map_type > plist_map_type
Definition: graphics.h:2024
void init(void)
Definition: graphics.h:11611
void init(void)
Definition: graphics.h:8963
void set_facelighting(const octave_value &val)
Definition: graphics.h:9701
properties xproperties
Definition: graphics.h:4773
octave_value get_cameratarget(void) const
Definition: graphics.h:5428
static std::string go_name
Definition: graphics.h:7476
double get_yticklen(void) const
Definition: graphics.h:5023
graphics_handle get_selectedobject(void) const
Definition: graphics.h:12454
void set_minorgridcolor(const octave_value &val)
Definition: graphics.h:6182
radio_property ylimmode
Definition: graphics.h:5239
radio_property erasemode
Definition: graphics.h:10263
octave_value get_markerfacecolor(void) const
Definition: graphics.h:7575
void update_horizontalalignment(void)
Definition: graphics.h:8555
void remove_child(const graphics_handle &h)
Definition: graphics.h:3278
octave_value get_x_projectiontransform(void) const
Definition: graphics.h:5716
double get_markersize(void) const
Definition: graphics.h:10430
const base_properties & get_properties(void) const
Definition: graphics.h:11075
std::list< graphics_handle > cbo_stack
Definition: graphics.h:3614
std::string get_zcolormode(void) const
Definition: graphics.h:5671
bool foregroundcolor_is(const std::string &v) const
Definition: graphics.h:12838
void set_erasemode(const octave_value &val)
Definition: graphics.h:8805
void set_userdata(const octave_value &val)
Definition: graphics.h:2844
void init_integerhandle(const octave_value &val)
Definition: graphics.h:3743
std::string get_xliminclude(void) const
Definition: graphics.h:11213
array_property pointershapehotspot
Definition: graphics.h:3890
void set_labelfontsizemultiplier(const octave_value &val)
Definition: graphics.h:6115
radio_property facelighting
Definition: graphics.h:9361
octave_value get___object__(void) const
Definition: graphics.h:12812
std::list< graphics_event > event_queue
Definition: graphics.h:14014
bool remove_child(double val)
Definition: graphics.h:1614
~image(void)
Definition: graphics.h:9107
void set_id(int d)
Definition: graphics.h:305
double get_fontsize(void) const
Definition: graphics.h:11948
base_properties & get_properties(void)
Definition: graphics.h:13203
void set_zlimmode(const octave_value &val)
Definition: graphics.h:6797
p
Definition: lu.cc:138
std::string get_erasemode(void) const
Definition: graphics.h:9478
OCTAVE_EXPORT octave_value_list or N dimensional array whose elements are all equal to the IEEE symbol zero divided by nd tex zero divided by nd ifnottex and any operation involving another NaN value(5+NaN).Note that NaN always compares not equal to NaN(NaN!
double_property & operator=(const octave_value &val)
Definition: graphics.h:1169
std::string get_selectiontype(void) const
Definition: graphics.h:4090
static graphics_handle lookup(double val)
Definition: graphics.h:13783
radio_property renderer
Definition: graphics.h:3892
std::string get_interruptible(void) const
Definition: graphics.h:2686
static bool has_readonly_property(const caseless_str &pname)
virtual graphics_toolkit get_toolkit(void) const
Definition: graphics.cc:3128
void set_xlim(const octave_value &val)
Definition: graphics.h:8869
bool is_graphicssmoothing(void) const
Definition: graphics.h:4024
base_properties & get_properties(void)
Definition: graphics.h:9109
bool color_is_rgb(void) const
Definition: graphics.h:8045
NDArray scale(const NDArray &m) const
Definition: graphics.h:101
static OCTINTERP_API property create(const std::string &name, const graphics_handle &parent, const caseless_str &type, const octave_value_list &args)
Definition: graphics.cc:1706
bool is_interruptible(void) const
Definition: graphics.h:2685
void set_xcolor(const octave_value &val)
Definition: graphics.h:6409
radio_property linestyle
Definition: graphics.h:9368
std::string get_normalmode(void) const
Definition: graphics.h:10146
double_property cameraviewangle
Definition: graphics.h:5165
std::pair< std::string, octave_value > pval_pair
Definition: graphics.h:1954
int get_xstate(void) const
Definition: graphics.h:4998
double_property linewidth
Definition: graphics.h:5192
any_property __zoom_mode__
Definition: graphics.h:3917
void set_screensize(const octave_value &val)
Definition: graphics.h:3579
octave_value get_cdata(void) const
Definition: graphics.h:9455
array_property view
Definition: graphics.h:5215
properties xproperties
Definition: graphics.h:12274
void update_xdata(void)
Definition: graphics.h:10087
bool backgroundcolor_is_rgb(void) const
Definition: graphics.h:12814
void execute_clickedcallback(const octave_value &data=octave_value()) const
Definition: graphics.h:13501
bool is_separator(void) const
Definition: graphics.h:13311
octave_value get___pan_mode__(void) const
Definition: graphics.h:4137
octave_value get_xlim(void) const
Definition: graphics.h:3323
row_vector_property clim
Definition: graphics.h:5167
~uicontrol(void)
Definition: graphics.h:12281
double get_z_min(void) const
Definition: graphics.h:5017
octave_handle graphics_handle
Definition: graphics.h:56
handle_property currentobject
Definition: graphics.h:3868
void set_fontangle(const octave_value &val)
Definition: graphics.h:6003
octave_value get_facecolor(void) const
Definition: graphics.h:9488
void add_property_listener(const std::string &nm, const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:3352
void set_units(const octave_value &val)
Definition: graphics.h:3599
virtual Matrix scale(const Matrix &) const
Definition: graphics.h:67
OCTINTERP_API bool set(const octave_value &v, bool do_run=true, bool do_notify_toolkit=true)
Definition: graphics.cc:1148
octave_map values_as_struct(void)
Definition: graphics.h:3270
octave_value get_ylim(void) const
Definition: graphics.h:3326
static bool instance_ok(void)
Definition: graphics.h:2313
void set_specularexponent(const octave_value &val)
Definition: graphics.h:10758
octave_value get_foregroundcolor(void) const
Definition: graphics.h:12840
void set_closerequestfcn(const octave_value &val)
Definition: graphics.h:4183
color_property xcolor
Definition: graphics.h:5217
bool_property beingdeleted
Definition: graphics.h:2614
void set_facelighting(const octave_value &val)
Definition: graphics.h:10634
void set_xdata(const octave_value &val)
Definition: graphics.h:9902
double get_cameraviewangle(void) const
Definition: graphics.h:5438
radio_property marker
Definition: graphics.h:7501
bool tickdirmode_is(const std::string &v) const
Definition: graphics.h:5553
radio_property fontweight
Definition: graphics.h:7976
std::string get_inverthardcopy(void) const
Definition: graphics.h:4031
graphics_xform(void)
Definition: graphics.h:4856
graphics_toolkit(void)
Definition: graphics.h:2155
plist_map_type plist_map
Definition: graphics.h:2060
static OCTINTERP_API void create_instance(void)
Definition: graphics.cc:10891
bool color_is(const std::string &v) const
Definition: graphics.h:8046
void set_ymtick(const octave_value &val)
Definition: graphics.h:6982
std::string get_clippingstyle(void) const
Definition: graphics.h:5449
radio_values vals
Definition: graphics.h:980
void update_horizontalalignmentmode(void)
Definition: graphics.h:8543
void set_climmode(const octave_value &val)
Definition: graphics.h:5905
bool_property xliminclude
Definition: graphics.h:7514
array_property ydata
Definition: graphics.h:10285
void set_looseinset(const octave_value &val)
Definition: graphics.h:6911
plist_map_iterator begin(void)
Definition: graphics.h:2041
virtual void add_property_listener(const std::string &nm, const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:3081
bool valid_object(void) const
Definition: graphics.h:8582
double scale(double d) const
Definition: graphics.h:175
handle_property & operator=(const octave_value &val)
Definition: graphics.h:1526
virtual octave_value get_ylim(void) const
Definition: graphics.h:2573
void set_title(const octave_value &val)
Definition: graphics.h:12998
void set_xminorgrid(const octave_value &val)
Definition: graphics.h:6484
virtual bool is_linear(void) const
Definition: graphics.h:90
bool empty(void) const
Definition: graphics.h:720
std::string get_separator(void) const
Definition: graphics.h:13312
void update_zdata(void)
Definition: graphics.h:10120
bool gridcolor_is_rgb(void) const
Definition: graphics.h:5491
void update_position(void)
Definition: graphics.h:8514
NDArray scale(const NDArray &m) const
Definition: graphics.h:211
std::string get_gridalphamode(void) const
Definition: graphics.h:5489
row_vector_property clim
Definition: graphics.h:8675
double_radio_property(double d, const radio_values &v)
Definition: graphics.h:1204
bool is_yminorgrid(void) const
Definition: graphics.h:5644
property(void)
Definition: graphics.h:1833
bool is_integerhandle(void) const
Definition: graphics.h:4027
static bool has_readonly_property(const caseless_str &pname)
bool is_yliminclude(void) const
Definition: graphics.h:9559
Matrix get_auto_ydata(void)
Definition: graphics.h:9056
bool_property climinclude
Definition: graphics.h:8679
std::string get_xdir(void) const
Definition: graphics.h:5587
virtual void mark_modified(void)
Definition: graphics.h:2897
static graphics_handle get_handle(bool integer_figure_handle)
Definition: graphics.h:13763
void set_backgroundcolor(const octave_value &val)
Definition: graphics.h:12005
radio_property horizontalalignment
Definition: graphics.h:11877
void set_x_rendertransform(const octave_value &val)
Definition: graphics.h:6962
void set_colororderindex(const octave_value &val)
Definition: graphics.h:5947
bool foregroundcolor_is(const std::string &v) const
Definition: graphics.h:12440
color_property ambientlightcolor
Definition: graphics.h:5156
Matrix get_all_children(void) const
Definition: graphics.h:2522
double double_value(void) const
Definition: graphics.h:1167
bool is_on(void) const
Definition: graphics.h:1489
void update_ydir(void)
Definition: graphics.h:7085
double get_specularexponent(void) const
Definition: graphics.h:10437
bool is_xliminclude(void) const
Definition: graphics.h:7597
void update_zcolor(void)
Definition: graphics.h:7051
void set___object__(const octave_value &val)
Definition: graphics.h:13317
uipanel(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:13036
callback_property windowscrollwheelfcn
Definition: graphics.h:3905
void execute_windowscrollwheelfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4116
array_property x_rendertransform
Definition: graphics.h:5270
bool is_xminortick(void) const
Definition: graphics.h:5602
string_property title
Definition: graphics.h:12381
octave_value get_ticklength(void) const
Definition: graphics.h:5559
octave_value get_xlim(void) const
Definition: graphics.h:10462
bool compare(const std::string &s, size_t limit=std::string::npos) const
Definition: caseless-str.h:76
color_property markeredgecolor
Definition: graphics.h:7502
Matrix get_minorgridcolor_rgb(void) const
Definition: graphics.h:5520
void set_zlim(const octave_value &val)
Definition: graphics.h:7794
array_property currentpoint
Definition: graphics.h:5173
color_property shadowcolor
Definition: graphics.h:12378
row_vector_property xlim
Definition: graphics.h:7511
radio_property fontangle
Definition: graphics.h:12775
array_property tightinset
Definition: graphics.h:5210
bool is_modified(void) const
Definition: graphics.h:2478
double_property fontsize
Definition: graphics.h:7974
void set_outerposition(const octave_value &val)
Definition: graphics.h:6226
double get_x_min(void) const
Definition: graphics.h:5013
Matrix get_hidden_children(void) const
Definition: graphics.h:2527
row_vector_property zlim
Definition: graphics.h:10293
void set_fontangle(const octave_value &val)
Definition: graphics.h:12065
graphics_object do_get_object(const graphics_handle &h)
Definition: graphics.h:14037
bool valid_object(void) const
Definition: graphics.h:12287
array_property position
Definition: graphics.h:3891
octave_value get_position(void) const
Definition: graphics.h:8091
octave_value get_alphamap(void) const
Definition: graphics.h:3996
double get_y_min(void) const
Definition: graphics.h:5015
uibuttongroup(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:12685
the element is set to zero In other the statement xample y
Definition: data.cc:5342
static void renumber_figure(const graphics_handle &old_gh, const graphics_handle &new_gh)
Definition: graphics.h:13776
void gripe_if_tkit_invalid(const std::string &fname) const
Definition: graphics.h:2145
string_property name
Definition: graphics.h:3878
void set_ambientstrength(const octave_value &val)
Definition: graphics.h:9578
double get_xpTick(void) const
Definition: graphics.h:5007
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:13403
bool pointer_is(const std::string &v) const
Definition: graphics.h:4068
std::string get_fontweight(void) const
Definition: graphics.h:12437
bool facealpha_is_double(void) const
Definition: graphics.h:9480
void scale(Matrix &m, double x, double y, double z)
Definition: graphics.cc:5150
b
Definition: cellfun.cc:398
OCTAVE_EXPORT octave_value_list or N dimensional array whose elements are all equal to the IEEE symbol NaN(Not a Number).NaN is the result of operations which do not produce a well defined 0 result.Common operations which produce a NaN are arithmetic with infinity ex($\infty-\infty $)
double get_gridalpha(void) const
Definition: graphics.h:5486
void execute_callback(const octave_value &data=octave_value()) const
Definition: graphics.h:11930
void set_horizontalalignment(const octave_value &val)
Definition: graphics.h:8253
callback_property buttondownfcn
Definition: graphics.h:2616
std::string get_aliminclude(void) const
Definition: graphics.h:10192
graphics_handle get_callbackobject(void) const
Definition: graphics.h:3478
std::string get_ydir(void) const
Definition: graphics.h:5632
radio_property erasemode
Definition: graphics.h:11161
bool backfacelighting_is(const std::string &v) const
Definition: graphics.h:10361
bool ycolormode_is(const std::string &v) const
Definition: graphics.h:5628
bool is_dockcontrols(void) const
Definition: graphics.h:4019
void set_sliderstep(const octave_value &val)
Definition: graphics.h:12181
void set_verticalalignment(const octave_value &val)
Definition: graphics.h:8346
void update_ycolor(void)
Definition: graphics.h:7048
void set_name(const std::string &s)
Definition: graphics.h:291
bool valid_object(void) const
Definition: graphics.h:13207
bool ycolor_is(const std::string &v) const
Definition: graphics.h:5624
Matrix xform
Definition: graphics.h:4927
bool is_defined(void) const
Definition: graphics.h:1793
bool is_linear(void) const
Definition: graphics.h:109
std::string get_yliminclude(void) const
Definition: graphics.h:8740
static graphics_object get_object(double val)
Definition: graphics.h:13794
void set___graphics_toolkit__(const octave_value &val)
Definition: graphics.h:3762
~property(void)
Definition: graphics.h:1844
bool_property clipping
Definition: graphics.h:2618
std::string get_clipping(void) const
Definition: graphics.h:12424
radio_property facelighting
Definition: graphics.h:10266
std::string get_yscale(void) const
Definition: graphics.h:5651
surface(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:11067
bool is_xminorgrid(void) const
Definition: graphics.h:5599
void set_specularexponent(const octave_value &val)
Definition: graphics.h:9847
bool is_undefined(void) const
Definition: ov.h:539
void update_fontname(void)
Definition: graphics.h:7156
bool is(const std::string &v) const
Definition: graphics.h:1241
void set_fontsize(const octave_value &val)
Definition: graphics.h:12546
any_property __pan_mode__
Definition: graphics.h:3914
uint8NDArray pixels
Definition: graphics.h:8563
bool_property visible
Definition: graphics.h:2631
void set_fontweight(const octave_value &val)
Definition: graphics.h:8242
bool get_is2D(void) const
Definition: graphics.h:5031
double get_zpTick(void) const
Definition: graphics.h:5011
uimenu(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:11619
std::string get_handlevisibility(void) const
Definition: graphics.h:2680
std::string get_titlefontweight(void) const
Definition: graphics.h:5568
void set_borderwidth(const octave_value &val)
Definition: graphics.h:12896
double get_specularcolorreflectance(void) const
Definition: graphics.h:10435
radio_property busyaction
Definition: graphics.h:2615
std::string get_fontweight(void) const
Definition: graphics.h:5484
void remove_child(const graphics_handle &h)
Definition: graphics.h:11096
radio_property(const radio_property &p)
Definition: graphics.h:927
double get_linewidth(void) const
Definition: graphics.h:7562
double_property yticklabelrotation
Definition: graphics.h:5246
void resize(octave_idx_type n, const octave_value &rfv=octave_value())
Definition: ovl.h:100
static property_list factory_properties
Definition: graphics.h:3730
std::string values_as_string(void)
Definition: graphics.h:3263
std::string get_hittest(void) const
Definition: graphics.h:2683
void update_plotboxaspectratiomode(void)
Definition: graphics.h:7058
string_property tooltipstring
Definition: graphics.h:13287
radio_property zcolormode
Definition: graphics.h:5249
ColumnVector transform(const Matrix &m, double x, double y, double z)
Definition: graphics.cc:5118
static void post_function(graphics_event::event_fcn fcn, void *data=0)
Definition: graphics.h:13918
std::string get___gl_extensions__(void) const
Definition: graphics.h:4122
bool_property integerhandle
Definition: graphics.h:3873
double get_ambientstrength(void) const
Definition: graphics.h:10359
graphics_handle get_parent(void) const
Definition: graphics.h:2688
hggroup(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:11358
octave_value get(bool all=false) const
void update_fontsize(void)
Definition: graphics.h:7161
void set_offcallback(const octave_value &val)
Definition: graphics.h:13562
std::string get_units(void) const
Definition: graphics.h:12863
static std::set< std::string > readonly_property_names(void)
array_property position
Definition: graphics.h:5203
radio_property(const std::string &nm, const graphics_handle &h, const radio_values &v, const std::string &def)
Definition: graphics.h:922
double_property markersize
Definition: graphics.h:10275
radio_property xdir
Definition: graphics.h:5219
array_property(const array_property &p)
Definition: graphics.h:1306
void set_xliminclude(const octave_value &val)
Definition: graphics.h:10950
void set_zliminclude(const octave_value &val)
Definition: graphics.h:8421
radio_property titleposition
Definition: graphics.h:12382
void set_string(const octave_value &val)
Definition: graphics.h:8324
bool xaxislocation_is(const std::string &v) const
Definition: graphics.h:5575
void set_facecolor(const octave_value &val)
Definition: graphics.h:10624
void set___object__(const octave_value &val)
Definition: graphics.h:11995
array_property extent
Definition: graphics.h:11870
void set_minorgridalphamode(const octave_value &val)
Definition: graphics.h:6172
OCTINTERP_API int calc_dimensions(const graphics_object &gh)
void update_fontname(void)
Definition: graphics.h:12263
void update_boundingbox(void)
Definition: graphics.h:4962
callback_property windowbuttonupfcn
Definition: graphics.h:3902
void add_constraint(const std::string &type)
Definition: graphics.h:1412
double_property position
Definition: graphics.h:11461
string_property tooltipstring
Definition: graphics.h:11886
virtual void update_axis_limits(const std::string &axis_type) const
Definition: graphics.cc:3087
virtual bool is_zliminclude(void) const
Definition: graphics.h:2580
std::string get_yminortick(void) const
Definition: graphics.h:5648
base_properties & get_properties(void)
Definition: graphics.h:11364
Matrix get_markeredgecolor_rgb(void) const
Definition: graphics.h:10422
void set_zminortick(const octave_value &val)
Definition: graphics.h:6819
std::string get_zminortick(void) const
Definition: graphics.h:5690
graphics_toolkit do_find_toolkit(const std::string &name) const
Definition: graphics.h:2366
properties xproperties
Definition: graphics.h:13388
octave_value get_ztick(void) const
Definition: graphics.h:5695
double get_borderwidth(void) const
Definition: graphics.h:12421
listener_mode
Definition: graphics.h:264
float pixel_xsize(void)
Definition: graphics.h:9086
array_property cdata
Definition: graphics.h:9351
void set_checked(const octave_value &val)
Definition: graphics.h:11539
void set_zlim(const octave_value &val)
Definition: graphics.h:6782
void initialize_data(void)
Definition: graphics.h:8613
void set_paperorientation(const octave_value &val)
Definition: graphics.h:4347
std::string get_integerhandle(void) const
Definition: graphics.h:4028
base_property * clone(void) const
Definition: graphics.h:949
radio_property backfacelighting
Definition: graphics.h:10254
std::string get_facelighting(void) const
Definition: graphics.h:9491
bool_property hittest
Definition: graphics.h:2622
void set_normalmode(const octave_value &val)
Definition: graphics.h:11046
string_property fltk_label
Definition: graphics.h:11463
callback_property callback
Definition: graphics.h:11710
octave_value get_xlim(void) const
Definition: graphics.h:7591
std::string str
Definition: graphics.h:460
string_property wvisual
Definition: graphics.h:3920
void set_beingdeleted(const octave_value &val)
Definition: graphics.h:2713
void set_position(const octave_value &val)
Definition: graphics.h:9216
double_property margin
Definition: graphics.h:7981
radio_property erasemode
Definition: graphics.h:9358
octave_value get_ylim(void) const
Definition: graphics.h:8734
std::string get_fontangle(void) const
Definition: graphics.h:5471
void set___plot_stream__(const octave_value &val)
Definition: graphics.h:4638
row_vector_property ylim
Definition: graphics.h:9387
double get_zticklen(void) const
Definition: graphics.h:5024
void set_dataaspectratio(const octave_value &val)
Definition: graphics.h:5967
double_property specularexponent
Definition: graphics.h:10279
std::string get_yliminclude(void) const
Definition: graphics.h:9560
color_property zcolor
Definition: graphics.h:5248
radio_property pointer
Definition: graphics.h:3888
octave_value get_colororder(void) const
Definition: graphics.h:5456
void set_gridlinestyle(const octave_value &val)
Definition: graphics.h:6105
void reparent(const graphics_handle &h)
Definition: graphics.h:3282
bool_property selected
Definition: graphics.h:2625
std::list< graphics_object > callback_objects
Definition: graphics.h:14017
color_property(const color_values &c, const radio_values &v)
Definition: graphics.h:1050
std::string get_activepositionproperty(void) const
Definition: graphics.h:5405
bool xtickmode_is(const std::string &v) const
Definition: graphics.h:5617
octave_value get_outerposition(void) const
Definition: graphics.h:5532
octave_value get_property_from_handle(double handle, const std::string &property, const std::string &func)
octave_value get_vertexnormals(void) const
Definition: graphics.h:10441
void set_title(const octave_value &val)
Definition: graphics.h:12642
bool is_climinclude(void) const
Definition: graphics.h:8606
virtual void override_defaults(base_graphics_object &obj)
Definition: graphics.h:2905
void set_yliminclude(const octave_value &val)
Definition: graphics.h:10962
void set_edgealpha(const octave_value &val)
Definition: graphics.h:9641
array_property xdata
Definition: graphics.h:9381
octave_value get___object__(void) const
Definition: graphics.h:11481
bool facecolor_is(const std::string &v) const
Definition: graphics.h:9486
virtual double get_screen_resolution(void) const
Definition: graphics.h:2097
Matrix scale(const Matrix &m) const
Definition: graphics.h:99
Matrix get_foregroundcolor_rgb(void) const
Definition: graphics.h:12441
property clone(void) const
Definition: graphics.h:1925
graphics_handle get_handle(void) const
Definition: graphics.h:3274
void update(int id)
Definition: graphics.h:3364
virtual void set(const caseless_str &, const octave_value &)
bool facenormalsmode_is(const std::string &v) const
Definition: graphics.h:10406
std::string get_dockcontrols(void) const
Definition: graphics.h:4020
Matrix x_render_inv
Definition: graphics.h:5073
charMatrix char_value(void) const
Definition: graphics.h:741
void add_constraint(octave_idx_type len)
Definition: graphics.h:1422
void update_fontangle(void)
Definition: graphics.h:7166
std::map< std::string, graphics_toolkit > loaded_toolkits
Definition: graphics.h:2337
octave_value get_outerposition(void) const
Definition: graphics.h:4050
void execute_keyreleasefcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4036
radio_property interpreter
Definition: graphics.h:10269
bool ycolor_is_rgb(void) const
Definition: graphics.h:5623
void set_fontangle(const octave_value &val)
Definition: graphics.h:12906
static Cell loaded_toolkits_list(void)
Definition: graphics.h:2289
std::string get_ydatamode(void) const
Definition: graphics.h:8746
bool linestyle_is(const std::string &v) const
Definition: graphics.h:8084
void set_fontsize(const octave_value &val)
Definition: graphics.h:12926
std::list< graphics_handle > figure_list
Definition: graphics.h:14008
radio_property marker
Definition: graphics.h:10272
graphics_handle get___myhandle__(void) const
Definition: graphics.h:2710
void set_modified(const octave_value &val)
Definition: graphics.h:2532
double_property diffusestrength
Definition: graphics.h:9353
octave_value get___zoom_mode__(void) const
Definition: graphics.h:4143
void set_sizechangedfcn(const octave_value &val)
Definition: graphics.h:12630
void redraw_figure(const graphics_object &go) const
Definition: graphics.h:2197
octave_value get_xdata(void) const
Definition: graphics.h:7579
bool shadowcolor_is_rgb(void) const
Definition: graphics.h:12852
bool is_zliminclude(void) const
Definition: graphics.h:7603
radio_property xaxislocation
Definition: graphics.h:5216
std::string get_erasemode(void) const
Definition: graphics.h:10389
static OCTINTERP_API gtk_manager * instance
Definition: graphics.h:2328
double_property max
Definition: graphics.h:11880
void set_separator(const octave_value &val)
Definition: graphics.h:13582
base_property & operator=(const octave_value &val)
Definition: graphics.h:327
void set_yticklabelrotation(const octave_value &val)
Definition: graphics.h:6713
void set_titleposition(const octave_value &val)
Definition: graphics.h:13008
void set_ydatamode(const octave_value &val)
Definition: graphics.h:8951
octave_value get_ydata(void) const
Definition: graphics.h:9542
radio_property selectiontype
Definition: graphics.h:3896
const std::list< graphics_handle > get_dependent_obj_list(void)
Definition: graphics.h:11655
radio_property xscale
Definition: graphics.h:5226
radio_property fontunits
Definition: graphics.h:12370
void set_ygrid(const octave_value &val)
Definition: graphics.h:6613
std::string get_xcolormode(void) const
Definition: graphics.h:5584
Matrix get_edgecolor_rgb(void) const
Definition: graphics.h:8054
void set_zticklabelrotation(const octave_value &val)
Definition: graphics.h:6870
bool minorgridcolormode_is(const std::string &v) const
Definition: graphics.h:5523
bool marker_is(const std::string &v) const
Definition: graphics.h:10417
Matrix get_markerfacecolor_rgb(void) const
Definition: graphics.h:10427
MArray< T > reshape(const dim_vector &new_dims) const
Definition: MArray.h:91
octave_value get_cdata(void) const
Definition: graphics.h:11933
void set_busyaction(const octave_value &val)
Definition: graphics.h:2723
bool is_numbertitle(void) const
Definition: graphics.h:4047
bool is_showhiddenhandles(void) const
Definition: graphics.h:3498
bool boxstyle_is(const std::string &v) const
Definition: graphics.h:5420
void set_fontweight(const octave_value &val)
Definition: graphics.h:12938
bool cameraviewanglemode_is(const std::string &v) const
Definition: graphics.h:5440
static bool has_readonly_property(const caseless_str &pname)
octave_scalar_map as_struct(const std::string &prefix_arg) const
Definition: graphics.cc:2171
std::string get_xminortick(void) const
Definition: graphics.h:5603
row_vector_property ztick
Definition: graphics.h:5258
octave_value get_x_viewporttransform(void) const
Definition: graphics.h:5718
bool do_set(const octave_value &val)
Definition: graphics.h:550
void set_layer(const octave_value &val)
Definition: graphics.h:6125
std::string get_displayname(void) const
Definition: graphics.h:10373
void set_clim(const octave_value &val)
Definition: graphics.h:8857
void set_positionmode(const octave_value &val)
Definition: graphics.h:8433
any_property xticklabel
Definition: graphics.h:5228
void do_lock(void)
Definition: graphics.h:14103
std::string get_xliminclude(void) const
Definition: graphics.h:7598
double double_value(bool frc_str_conv=false) const
Definition: ov.h:775
void set_currentobject(const octave_value &val)
Definition: graphics.h:4225
octave_idx_type cols(void) const
Definition: Array.h:409
bool edgecolor_is_rgb(void) const
Definition: graphics.h:9469
octave_value get_markerfacecolor(void) const
Definition: graphics.h:9523
void set_zcolor(const octave_value &val)
Definition: graphics.h:6734
base_properties & get_properties(void)
Definition: graphics.h:13632
void set_ambientlightcolor(const octave_value &val)
Definition: graphics.h:5765
std::string get_sortmethod(void) const
Definition: graphics.h:5548
bool is___modified__(void) const
Definition: graphics.h:2707
octave_value get_buttondownfcn(void) const
Definition: graphics.h:3999
octave_value get_sizechangedfcn(void) const
Definition: graphics.h:4093
bool markerfacecolor_is(const std::string &v) const
Definition: graphics.h:7573
Matrix get_color_rgb(void) const
Definition: graphics.h:9197
void get_children_limits(double &min_val, double &max_val, double &min_pos, double &max_neg, const Matrix &kids, char limit_type)
Definition: graphics.cc:7104
octave_value get_value(void) const
Definition: graphics.h:11989
std::string get_zliminclude(void) const
Definition: graphics.h:7604
bool valid_object(void) const
Definition: graphics.h:11629
bool valid_object(void) const
Definition: graphics.h:13046
std::string graphics_object_name(void) const
Definition: graphics.h:3837
void erase(iterator it)
Definition: graphics.h:2013
bool highlightcolor_is_rgb(void) const
Definition: graphics.h:12842
octave_value get_keypressfcn(void) const
Definition: graphics.h:4034
void set_xdatasource(const octave_value &val)
Definition: graphics.h:7718
std::string get_nextplot(void) const
Definition: graphics.h:5530
graphics_object & operator=(const graphics_object &obj)
Definition: graphics.h:3154
color_property backgroundcolor
Definition: graphics.h:11865
radio_property paperunits
Definition: graphics.h:3887
static void initialize(void)
Definition: mkoctfile.cc:123
graphics_handle get_handle(void) const
Definition: graphics.h:2998
double get_linewidth(void) const
Definition: graphics.h:9510
string_property xdisplay
Definition: graphics.h:3922
bool_property yliminclude
Definition: graphics.h:9392
bool facelighting_is(const std::string &v) const
Definition: graphics.h:10401
bool is_yliminclude(void) const
Definition: graphics.h:8112
base_scaler * clone(void) const
Definition: graphics.h:181
void adopt(const graphics_handle &h)
Definition: graphics.h:11398
Matrix get_highlightcolor_rgb(void) const
Definition: graphics.h:12844
void set_oncallback(const octave_value &val)
Definition: graphics.h:13572
std::string get_cdatasource(void) const
Definition: graphics.h:10369
Vector representing the dimensions (size) of an Array.
Definition: dim-vector.h:87
string_property accelerator
Definition: graphics.h:11455
scaler(const scaler &s)
Definition: graphics.h:197
std::string get_name(void) const
Definition: graphics.h:289
radio_property linestyle
Definition: graphics.h:10270
std::string get_units(void) const
Definition: graphics.h:12468
base_properties & get_properties(void)
Definition: graphics.h:4831
OCTINTERP_API bool validate(const octave_value &v) const
Definition: graphics.cc:1651
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:10171
virtual bool has_property(const caseless_str &) const
Definition: graphics.h:2472
void update_facevertexcdata(void)
Definition: graphics.h:10083
octave_value get_alim(void) const
Definition: graphics.h:8728
std::string get_paperpositionmode(void) const
Definition: graphics.h:4058
row_vector_property & operator=(const octave_value &val)
Definition: graphics.h:1432
octave_value get___guidata__(void) const
Definition: graphics.h:4132
string_property displayname
Definition: graphics.h:8670
void set_edgealpha(const octave_value &val)
Definition: graphics.h:10574
handle_property ylabel
Definition: graphics.h:5237
double get_pointerwindow(void) const
Definition: graphics.h:3490
const scaler & get_z_scaler(void) const
Definition: graphics.h:4953
void update_axis_limits(const std::string &axis_type, const graphics_handle &h)
Definition: graphics.h:3300
double get_max(void) const
Definition: graphics.h:11969
properties xproperties
Definition: graphics.h:11616
array_property ticklength
Definition: graphics.h:5209
array_property alphadata
Definition: graphics.h:8666
bool ydir_is(const std::string &v) const
Definition: graphics.h:5631
Matrix get_transform_zlim(void) const
Definition: graphics.h:4996
Matrix xform_inv
Definition: graphics.h:4928
bool do_remove_child(double child)
Definition: graphics.h:1756
octave_value as_octave_value(void) const
Definition: oct-handle.h:76
array_property cdata
Definition: graphics.h:10255
bool is_yminortick(void) const
Definition: graphics.h:5647
bool highlightcolor_is_rgb(void) const
Definition: graphics.h:12444
void update_ydata(void)
Definition: graphics.h:10105
plist_map_const_iterator find(const std::string &go_name) const
Definition: graphics.h:2052
bool is_inverthardcopy(void) const
Definition: graphics.h:4030
std::string get_fontangle(void) const
Definition: graphics.h:11944
void err_not_implemented(const char *fcn)
Definition: errwarn.cc:100
void set_margin(const octave_value &val)
Definition: graphics.h:8299
bool markeredgecolor_is(const std::string &v) const
Definition: graphics.h:7568
void set_backgroundcolor(const octave_value &val)
Definition: graphics.h:8134
bool meshstyle_is(const std::string &v) const
Definition: graphics.h:10432
octave_value get_ylim(void) const
Definition: graphics.h:10464
static void clear(octave::dynamic_library &oct_file)
Definition: dynamic-ld.cc:230
base_property(void)
Definition: graphics.h:272
octave_value callback
Definition: graphics.h:1822
color_property foregroundcolor
Definition: graphics.h:12372
bool is_zliminclude(void) const
Definition: graphics.h:11218
bool_property xliminclude
Definition: graphics.h:9391
color_property minorgridcolor
Definition: graphics.h:5195
void update_plotboxaspectratio(void)
Definition: graphics.h:7057
std::string get_fontname(void) const
Definition: graphics.h:5473
octave_value get_backgroundcolor(void) const
Definition: graphics.h:8043
bool is_zliminclude(void) const
Definition: graphics.h:3344
void set_uicontextmenu(const octave_value &val)
Definition: graphics.h:2833
void set_edgelighting(const octave_value &val)
Definition: graphics.h:9661
set(hf,"paperorientation") esult
Definition: graphics.cc:10111
If this string is the system will ring the terminal sometimes it is useful to be able to print the original representation of the string
Definition: utils.cc:854
void execute_resizefcn(const octave_value &data=octave_value()) const
Definition: graphics.h:12849
void set_vertexnormals(const octave_value &val)
Definition: graphics.h:9867
void set_markerfacecolor(const octave_value &val)
Definition: graphics.h:9817
graphics_event(void)
Definition: graphics.h:13683
any_property __rotate_mode__
Definition: graphics.h:3916
void set_camerapositionmode(const octave_value &val)
Definition: graphics.h:5809
std::string get_cameratargetmode(void) const
Definition: graphics.h:5431
void build_user_defaults_map(property_list::pval_map_type &def, const std::string go_name) const
Definition: graphics.h:3186
octave_value get_highlightcolor(void) const
Definition: graphics.h:12845
text_label_property(const std::string &s, const graphics_handle &h, const std::string &val="")
Definition: graphics.h:670
void set_tag(const octave_value &val)
Definition: graphics.h:2513
void set_cdatamapping(const octave_value &val)
Definition: graphics.h:8783
scaler(const std::string &s)
Definition: graphics.h:199
radio_property cdatamapping
Definition: graphics.h:8669
void set_nextplot(const octave_value &val)
Definition: graphics.h:6216
std::string get_displayname(void) const
Definition: graphics.h:11191
void update_xaxislocation(void)
Definition: graphics.h:7072
bool do_set(const octave_value &v)
Definition: graphics.h:1449
void set_xliminclude(const octave_value &val)
Definition: graphics.h:8917
octave_value get_zdata(void) const
Definition: graphics.h:9544
bool do_set(const octave_value &val)
Definition: graphics.h:443
void lock(void)
Definition: oct-mutex.h:85
std::string get_edgelighting(void) const
Definition: graphics.h:10386
static std::string go_name
Definition: graphics.h:9163
int get_id(void) const
Definition: graphics.h:303
void set_ylim(const octave_value &val)
Definition: graphics.h:10902
static bool has_readonly_property(const caseless_str &pname)
callback_property resizefcn
Definition: graphics.h:12783
octave_value get_facevertexcdata(void) const
Definition: graphics.h:9502
std::string get_displayname(void) const
Definition: graphics.h:7551
bool_property zgrid
Definition: graphics.h:5251
void override_defaults(void)
Definition: graphics.h:3181
const uint8NDArray & get_pixels(void) const
Definition: graphics.h:8500
std::list< octave_value > zoom_stack
Definition: graphics.h:5076
void set_shadowcolor(const octave_value &val)
Definition: graphics.h:12988
static bool has_readonly_property(const caseless_str &pname)
any_property __object__
Definition: graphics.h:13116
dim_vector dv
Definition: sub2ind.cc:263
bool is_aliminclude(void) const
Definition: graphics.h:8601
array_property x_normrendertransform
Definition: graphics.h:5269
void set_label(const octave_value &val)
Definition: graphics.h:11569
std::string get_climinclude(void) const
Definition: graphics.h:9294
const base_properties & get_properties(void) const
Definition: graphics.h:13205
row_vector_property ydata
Definition: graphics.h:8673
radio_property fontangle
Definition: graphics.h:7972
bool color_is(const std::string &v) const
Definition: graphics.h:5452
base_properties & get_properties(void)
Definition: graphics.h:13397
std::string graphics_object_name(void) const
Definition: graphics.h:13092
void set_yticklabelmode(const octave_value &val)
Definition: graphics.h:6702
static void lock(void)
Definition: graphics.h:13850
octave_value get_highlightcolor(void) const
Definition: graphics.h:12447
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:12697
double get_labelfontsizemultiplier(void) const
Definition: graphics.h:5502
bool yticklabelmode_is(const std::string &v) const
Definition: graphics.h:5657
radio_property layer
Definition: graphics.h:5189
children_property(const children_property &p)
Definition: graphics.h:1600
void set_facealpha(const octave_value &val)
Definition: graphics.h:9681
bool is_zgrid(void) const
Definition: graphics.h:5676
double unscale(double d) const
Definition: graphics.h:178
void set_yliminclude(const octave_value &val)
Definition: graphics.h:10031
void execute_windowkeypressfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4110
bool valid_object(void) const
Definition: graphics.h:11077
octave_value get(void) const
Definition: graphics.h:1229
double_property fontsize
Definition: graphics.h:12369
octave_idx_type columns(void) const
Definition: Array.h:410
double get_ztickoffset(void) const
Definition: graphics.h:5027
static bool is_handle_visible(const graphics_handle &h)
Definition: graphics.cc:9852
OCTAVE_EXPORT octave_value_list return the value of the option it must match the dimension of the state vector
Definition: DASPK-opts.cc:739
Matrix get_all(void) const
Definition: graphics.h:1634
void set_foregroundcolor(const octave_value &val)
Definition: graphics.h:12568
bool style_is(const std::string &v) const
Definition: graphics.h:11981
void update_dataaspectratiomode(void)
Definition: graphics.h:7056
bool_property zminortick
Definition: graphics.h:5256
children_property(void)
Definition: graphics.h:1587
octave_value get_zdata(void) const
Definition: graphics.h:10454
bool is_xliminclude(void) const
Definition: graphics.h:3338
void set_ticklabelinterpreter(const octave_value &val)
Definition: graphics.h:6330
callback_property keypressfcn
Definition: graphics.h:3875
plist_map_type::const_iterator plist_map_const_iterator
Definition: graphics.h:2030
Matrix get_canvas_size(const graphics_handle &fh) const
Definition: graphics.h:2205
static bool has_readonly_property(const caseless_str &pname)
std::string get_displayname(void) const
Definition: graphics.h:8050
line(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:7862
void set_erasemode(const octave_value &val)
Definition: graphics.h:7627
void set_hittest(const octave_value &val)
Definition: graphics.h:2793
radio_property cdatamapping
Definition: graphics.h:10256
void set_selectiontype(const octave_value &val)
Definition: graphics.h:4478
array_property x_viewporttransform
Definition: graphics.h:5268
bool has_bad_data(std::string &msg) const
Definition: graphics.h:9281
octave_value get_windowbuttondownfcn(void) const
Definition: graphics.h:4102
void set_vertexnormals(const octave_value &val)
Definition: graphics.h:10778
void xform(ColumnVector &v, const Matrix &m)
Definition: graphics.cc:5162
image(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:9101
void set_cdatamapping(const octave_value &val)
Definition: graphics.h:10532
static graphics_handle current_figure(void)
Definition: graphics.h:13838
bool facecolor_is_rgb(void) const
Definition: graphics.h:10396
void set_units(const octave_value &val)
Definition: graphics.h:8335
double get_zPlane(void) const
Definition: graphics.h:5005
radio_property enable
Definition: graphics.h:11869
octave_value get_color(void) const
Definition: graphics.h:8048
bool is_linear(void) const
Definition: graphics.h:220
bool facelighting_is(const std::string &v) const
Definition: graphics.h:9490
void set_from_list(base_graphics_object &obj, property_list &defaults)
Definition: graphics.cc:2902
bool color_is(const std::string &v) const
Definition: graphics.h:4005
properties xproperties
Definition: graphics.h:12682
void do_unload_all_toolkits(void)
Definition: graphics.h:2398
static std::string go_name
Definition: graphics.h:8647
std::string get_linestyle(void) const
Definition: graphics.h:7560
void set(const caseless_str &name, const octave_value &value)
Definition: graphics.h:13168
bool activepositionproperty_is(const std::string &v) const
Definition: graphics.h:5404
graphics_handle get_ylabel(void) const
Definition: graphics.h:5637
where the brackets indicate optional arguments and and character or cell array For character arrays the conversion is repeated for every row
Definition: str2double.cc:342
double scale(double d) const
Definition: graphics.h:135
void update_transform(void)
Definition: graphics.h:4974
color_property color
Definition: graphics.h:9182
bool set_property_in_handle(double handle, const std::string &property, const octave_value &arg, const std::string &func)
bool_property zliminclude
Definition: graphics.h:11171
graphics_handle handle_value(void) const
Definition: graphics.h:1524
void set_titlefontsizemultiplier(const octave_value &val)
Definition: graphics.h:6363
base_properties & get_properties(void)
Definition: graphics.h:12691
void update_positionmode(void)
Definition: graphics.h:8541
F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_REAL const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T F77_REAL F77_REAL &F77_RET_T F77_DBLE F77_DBLE &F77_RET_T const F77_DBLE * x
void set_buttondownfcn(const octave_value &val)
Definition: graphics.h:2733
void set(const caseless_str &name, const octave_value &value)
Definition: graphics.h:7367
double_property(const std::string &nm, const graphics_handle &h, double d=0)
Definition: graphics.h:1157
return octave_value(v1.char_array_value().concat(v2.char_array_value(), ra_idx),((a1.is_sq_string()||a2.is_sq_string())? '\'': '"'))
void set_facevertexcdata(const octave_value &val)
Definition: graphics.h:9756
void set_currentcharacter(const octave_value &val)
Definition: graphics.h:4215
color_property(const color_property &p)
Definition: graphics.h:1091
double get_fontsize(void) const
Definition: graphics.h:8070
void set_plotboxaspectratiomode(const octave_value &val)
Definition: graphics.h:6252
void execute_resizefcn(const octave_value &data=octave_value()) const
Definition: graphics.h:12451
any_property yticklabel
Definition: graphics.h:5244
bool is_selected(void) const
Definition: graphics.h:2690
bool horizontalalignmentmode_is(const std::string &v) const
Definition: graphics.h:8124
static void post_set(const graphics_handle &h, const std::string &name, const octave_value &value, bool notify_toolkit=true)
Definition: graphics.h:13924
color_property facecolor
Definition: graphics.h:10265
void set_linestyle(const octave_value &val)
Definition: graphics.h:8279
std::string get_plotboxaspectratiomode(void) const
Definition: graphics.h:5537
radio_property units
Definition: graphics.h:12787
charNDArray min(char d, const charNDArray &m)
Definition: chNDArray.cc:205
Matrix get_foregroundcolor_rgb(void) const
Definition: graphics.h:11496
octave_value get_xlim(void) const
Definition: graphics.h:11200
color_property facecolor
Definition: graphics.h:9360
void set_zliminclude(const octave_value &val)
Definition: graphics.h:10974
void set_markeredgecolor(const octave_value &val)
Definition: graphics.h:9807
void set_facenormals(const octave_value &val)
Definition: graphics.h:9711
void set_yliminclude(const octave_value &val)
Definition: graphics.h:11322
void set_linestyleorderindex(const octave_value &val)
Definition: graphics.h:6138
bool get_x2Dtop(void) const
Definition: graphics.h:5028
octave_value get_commandwindowsize(void) const
Definition: graphics.h:3480
void set_facenormalsmode(const octave_value &val)
Definition: graphics.h:10658
void do_init_children(const std::list< double > &val)
Definition: graphics.h:1737
std::string get_zdatasource(void) const
Definition: graphics.h:10456
Matrix get_highlightcolor_rgb(void) const
Definition: graphics.h:12446
OCTINTERP_API bool do_set(const octave_value &v)
Definition: graphics.cc:1566
OCTINTERP_API void get_data_limits(void)
Definition: graphics.cc:1526
void set_zlim(const octave_value &val)
Definition: graphics.h:8385
void set(const caseless_str &name, const octave_value &value)
Definition: graphics.h:3640
void execute_keypressfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:11964
Matrix get_facecolor_rgb(void) const
Definition: graphics.h:9487
void set_zmtick(const octave_value &val)
Definition: graphics.h:6992
void set_climinclude(const octave_value &val)
Definition: graphics.h:10938
graphics_xform(const graphics_xform &g)
Definition: graphics.h:4868
octave_value get_clickedcallback(void) const
Definition: graphics.h:13502
octave_value get_color(void) const
Definition: graphics.h:5454
double_property pointerwindow
Definition: graphics.h:3453
octave_value get_yticklabel(void) const
Definition: graphics.h:5655
base_property * clone(void) const
Definition: graphics.h:1268
Matrix get_color_rgb(void) const
Definition: graphics.h:8047
bool color_is_rgb(void) const
Definition: graphics.h:4004
octave_value get_xtick(void) const
Definition: graphics.h:5608
double_property linewidth
Definition: graphics.h:9369
void set_ydir(const octave_value &val)
Definition: graphics.h:6602
void execute_clickedcallback(const octave_value &data=octave_value()) const
Definition: graphics.h:13305
radio_property bordertype
Definition: graphics.h:12773
bool is_xgrid(void) const
Definition: graphics.h:5589
static int process_events(void)
Definition: graphics.h:13931
neg_log_scaler(void)
Definition: graphics.h:155
void set_windowkeyreleasefcn(const octave_value &val)
Definition: graphics.h:4550
octave_value get_pointershapehotspot(void) const
Definition: graphics.h:4073
std::string get_horizontalalignmentmode(void) const
Definition: graphics.h:8125
property_list default_properties
Definition: graphics.h:3728
octave_value get_position(void) const
Definition: graphics.h:12847
void set_colororder(const octave_value &val)
Definition: graphics.h:5937
T::properties & properties(graphics_object obj)
radio_property camerapositionmode
Definition: graphics.h:5160
bool horizontalalignment_is(const std::string &v) const
Definition: graphics.h:8078
radio_property units
Definition: graphics.h:12380
array_property position
Definition: graphics.h:12782
plist_map_type::iterator plist_map_iterator
Definition: graphics.h:2029
void unlock(void)
Definition: oct-mutex.h:90
row_vector_property xtick
Definition: graphics.h:5227
double_property rotation
Definition: graphics.h:7983
row_vector_property alim
Definition: graphics.h:8674
radio_property xticklabelmode
Definition: graphics.h:5229
bool fontweight_is(const std::string &v) const
Definition: graphics.h:12436