GNU Octave  4.0.0
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-2015 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 #ifdef HAVE_CONFIG_H
29 #include <config.h>
30 #endif
31 
32 #include <cctype>
33 
34 #include <algorithm>
35 #include <list>
36 #include <map>
37 #include <set>
38 #include <sstream>
39 #include <string>
40 
41 #include "caseless-str.h"
42 
43 #include "gripes.h"
44 #include "oct-handle.h"
45 #include "oct-map.h"
46 #include "oct-mutex.h"
47 #include "oct-refcount.h"
48 #include "ov.h"
49 #include "txt-eng-ft.h"
50 
51 // FIXME: maybe this should be a configure option?
52 // Matlab defaults to "Helvetica", but that causes problems for many
53 // gnuplot users.
54 #if !defined (OCTAVE_DEFAULT_FONTNAME)
55 #define OCTAVE_DEFAULT_FONTNAME "*"
56 #endif
57 
59 
60 // ---------------------------------------------------------------------
61 
63 {
64 public:
65  base_scaler (void) { }
66 
67  virtual ~base_scaler (void) { }
68 
69  virtual Matrix scale (const Matrix& m) const
70  {
71  error ("invalid axis scale");
72  return m;
73  }
74 
75  virtual NDArray scale (const NDArray& m) const
76  {
77  error ("invalid axis scale");
78  return m;
79  }
80 
81  virtual double scale (double d) const
82  {
83  error ("invalid axis scale");
84  return d;
85  }
86 
87  virtual double unscale (double d) const
88  {
89  error ("invalid axis scale");
90  return d;
91  }
92 
93  virtual base_scaler* clone () const
94  { return new base_scaler (); }
95 
96  virtual bool is_linear (void) const
97  { return false; }
98 };
99 
100 class lin_scaler : public base_scaler
101 {
102 public:
103  lin_scaler (void) { }
104 
105  Matrix scale (const Matrix& m) const { return m; }
106 
107  NDArray scale (const NDArray& m) const { return m; }
108 
109  double scale (double d) const { return d; }
110 
111  double unscale (double d) const { return d; }
112 
113  base_scaler* clone (void) const { return new lin_scaler (); }
114 
115  bool is_linear (void) const { return true; }
116 };
117 
118 class log_scaler : public base_scaler
119 {
120 public:
121  log_scaler (void) { }
122 
123  Matrix scale (const Matrix& m) const
124  {
125  Matrix retval (m.rows (), m.cols ());
126 
127  do_scale (m.data (), retval.fortran_vec (), m.numel ());
128 
129  return retval;
130  }
131 
132  NDArray scale (const NDArray& m) const
133  {
134  NDArray retval (m.dims ());
135 
136  do_scale (m.data (), retval.fortran_vec (), m.numel ());
137 
138  return retval;
139  }
140 
141  double scale (double d) const
142  { return log10 (d); }
143 
144  double unscale (double d) const
145  { return pow (10.0, d); }
146 
147  base_scaler* clone (void) const
148  { return new log_scaler (); }
149 
150 private:
151  void do_scale (const double *src, double *dest, int n) const
152  {
153  for (int i = 0; i < n; i++)
154  dest[i] = log10 (src[i]);
155  }
156 };
157 
159 {
160 public:
161  neg_log_scaler (void) { }
162 
163  Matrix scale (const Matrix& m) const
164  {
165  Matrix retval (m.rows (), m.cols ());
166 
167  do_scale (m.data (), retval.fortran_vec (), m.numel ());
168 
169  return retval;
170  }
171 
172  NDArray scale (const NDArray& m) const
173  {
174  NDArray retval (m.dims ());
175 
176  do_scale (m.data (), retval.fortran_vec (), m.numel ());
177 
178  return retval;
179  }
180 
181  double scale (double d) const
182  { return -log10 (-d); }
183 
184  double unscale (double d) const
185  { return -pow (10.0, -d); }
186 
187  base_scaler* clone (void) const
188  { return new neg_log_scaler (); }
189 
190 private:
191  void do_scale (const double *src, double *dest, int n) const
192  {
193  for (int i = 0; i < n; i++)
194  dest[i] = -log10 (-src[i]);
195  }
196 };
197 
198 class scaler
199 {
200 public:
201  scaler (void) : rep (new base_scaler ()) { }
202 
203  scaler (const scaler& s) : rep (s.rep->clone ()) { }
204 
205  scaler (const std::string& s)
206  : rep (s == "log"
207  ? new log_scaler ()
208  : (s == "neglog" ? new neg_log_scaler ()
209  : (s == "linear" ? new lin_scaler () : new base_scaler ())))
210  { }
211 
212  ~scaler (void) { delete rep; }
213 
214  Matrix scale (const Matrix& m) const
215  { return rep->scale (m); }
216 
217  NDArray scale (const NDArray& m) const
218  { return rep->scale (m); }
219 
220  double scale (double d) const
221  { return rep->scale (d); }
222 
223  double unscale (double d) const
224  { return rep->unscale (d); }
225 
226  bool is_linear (void) const
227  { return rep->is_linear (); }
228 
230  {
231  if (rep)
232  {
233  delete rep;
234  rep = 0;
235  }
236 
237  rep = s.rep->clone ();
238 
239  return *this;
240  }
241 
242  scaler& operator = (const std::string& s)
243  {
244  if (rep)
245  {
246  delete rep;
247  rep = 0;
248  }
249 
250  if (s == "log")
251  rep = new log_scaler ();
252  else if (s == "neglog")
253  rep = new neg_log_scaler ();
254  else if (s == "linear")
255  rep = new lin_scaler ();
256  else
257  rep = new base_scaler ();
258 
259  return *this;
260  }
261 
262 private:
264 };
265 
266 // ---------------------------------------------------------------------
267 
268 class property;
269 
271 
273 {
274 public:
275  friend class property;
276 
277 public:
279  : id (-1), count (1), name (), parent (), hidden (), listeners ()
280  { }
281 
282  base_property (const std::string& s, const graphics_handle& h)
283  : id (-1), count (1), name (s), parent (h), hidden (false), listeners ()
284  { }
285 
287  : id (-1), count (1), name (p.name), parent (p.parent),
288  hidden (p.hidden), listeners ()
289  { }
290 
291  virtual ~base_property (void) { }
292 
293  bool ok (void) const { return parent.ok (); }
294 
295  std::string get_name (void) const { return name; }
296 
297  void set_name (const std::string& s) { name = s; }
298 
299  graphics_handle get_parent (void) const { return parent; }
300 
301  void set_parent (const graphics_handle& h) { parent = h; }
302 
303  bool is_hidden (void) const { return hidden; }
304 
305  void set_hidden (bool flag) { hidden = flag; }
306 
307  virtual bool is_radio (void) const { return false; }
308 
309  int get_id (void) const { return id; }
310 
311  void set_id (int d) { id = d; }
312 
313  // Sets property value, notifies graphics toolkit.
314  // If do_run is true, runs associated listeners.
315  OCTINTERP_API bool set (const octave_value& v, bool do_run = true,
316  bool do_notify_toolkit = true);
317 
318  virtual octave_value get (void) const
319  {
320  error ("get: invalid property \"%s\"", name.c_str ());
321  return octave_value ();
322  }
323 
324 
325  virtual std::string values_as_string (void) const
326  {
327  error ("values_as_string: invalid property \"%s\"", name.c_str ());
328  return std::string ();
329  }
330 
331  virtual Cell values_as_cell (void) const
332  {
333  error ("values_as_cell: invalid property \"%s\"", name.c_str ());
334  return Cell ();
335  }
336 
338  {
339  set (val);
340  return *this;
341  }
342 
344  {
345  octave_value_list& l = listeners[mode];
346  l.resize (l.length () + 1, v);
347  }
348 
350  listener_mode mode = POSTSET)
351  {
352  octave_value_list& l = listeners[mode];
353 
354  if (v.is_defined ())
355  {
356  bool found = false;
357  int i;
358 
359  for (i = 0; i < l.length (); i++)
360  {
361  if (v.internal_rep () == l(i).internal_rep ())
362  {
363  found = true;
364  break;
365  }
366  }
367  if (found)
368  {
369  for (int j = i; j < l.length () - 1; j++)
370  l(j) = l(j + 1);
371 
372  l.resize (l.length () - 1);
373  }
374  }
375  else
376  {
377  if (mode == PERSISTENT)
378  l.resize (0);
379  else
380  {
381  octave_value_list lnew (0);
383  for (int i = l.length () - 1; i >= 0 ; i--)
384  {
385  for (int j = 0; j < lp.length (); j++)
386  {
387  if (l(i).internal_rep () == lp(j).internal_rep ())
388  {
389  lnew.resize (lnew.length () + 1, l(i));
390  break;
391  }
392  }
393  }
394  l = lnew;
395  }
396  }
397 
398  }
399 
401 
402  virtual base_property* clone (void) const
403  { return new base_property (*this); }
404 
405 protected:
406  virtual bool do_set (const octave_value&)
407  {
408  error ("set: invalid property \"%s\"", name.c_str ());
409  return false;
410  }
411 
412 private:
413  typedef std::map<listener_mode, octave_value_list> listener_map;
414  typedef std::map<listener_mode, octave_value_list>::iterator
416  typedef std::map<listener_mode, octave_value_list>::const_iterator
418 
419 private:
420  int id;
422  std::string name;
424  bool hidden;
425  listener_map listeners;
426 };
427 
428 // ---------------------------------------------------------------------
429 
431 {
432 public:
433  string_property (const std::string& s, const graphics_handle& h,
434  const std::string& val = "")
435  : base_property (s, h), str (val) { }
436 
438  : base_property (p), str (p.str) { }
439 
440  octave_value get (void) const
441  { return octave_value (str); }
442 
443  std::string string_value (void) const { return str; }
444 
446  {
447  set (val);
448  return *this;
449  }
450 
451  base_property* clone (void) const { return new string_property (*this); }
452 
453 protected:
454  bool do_set (const octave_value& val)
455  {
456  if (val.is_string ())
457  {
458  std::string new_str = val.string_value ();
459 
460  if (new_str != str)
461  {
462  str = new_str;
463  return true;
464  }
465  }
466  else
467  error ("set: invalid string property value for \"%s\"",
468  get_name ().c_str ());
469  return false;
470  }
471 
472 private:
473  std::string str;
474 };
475 
476 // ---------------------------------------------------------------------
477 
479 {
480 public:
482 
483  string_array_property (const std::string& s, const graphics_handle& h,
484  const std::string& val = "", const char& sep = '|',
485  const desired_enum& typ = string_t)
486  : base_property (s, h), desired_type (typ), separator (sep), str ()
487  {
488  size_t pos = 0;
489 
490  while (true)
491  {
492  size_t new_pos = val.find_first_of (separator, pos);
493 
494  if (new_pos == std::string::npos)
495  {
496  str.append (val.substr (pos));
497  break;
498  }
499  else
500  str.append (val.substr (pos, new_pos - pos));
501 
502  pos = new_pos + 1;
503  }
504  }
505 
506  string_array_property (const std::string& s, const graphics_handle& h,
507  const Cell& c, const char& sep = '|',
508  const desired_enum& typ = string_t)
509  : base_property (s, h), desired_type (typ), separator (sep), str ()
510  {
511  if (c.is_cellstr ())
512  {
513  string_vector strings (c.numel ());
514 
515  for (octave_idx_type i = 0; i < c.numel (); i++)
516  strings[i] = c(i).string_value ();
517 
518  str = strings;
519  }
520  else
521  error ("set: invalid order property value for \"%s\"",
522  get_name ().c_str ());
523  }
524 
527  separator (p.separator), str (p.str) { }
528 
529  octave_value get (void) const
530  {
531  if (desired_type == string_t)
532  return octave_value (string_value ());
533  else
534  return octave_value (cell_value ());
535  }
536 
537  std::string string_value (void) const
538  {
539  std::string s;
540 
541  for (octave_idx_type i = 0; i < str.length (); i++)
542  {
543  s += str[i];
544  if (i != str.length () - 1)
545  s += separator;
546  }
547 
548  return s;
549  }
550 
551  Cell cell_value (void) const {return Cell (str);}
552 
553  string_vector string_vector_value (void) const { return str; }
554 
556  {
557  set (val);
558  return *this;
559  }
560 
561  base_property* clone (void) const
562  { return new string_array_property (*this); }
563 
564 protected:
565  bool do_set (const octave_value& val)
566  {
567  if (val.is_string () && val.rows () == 1)
568  {
569  bool replace = false;
570  std::string new_str = val.string_value ();
571  string_vector strings;
572  size_t pos = 0;
573 
574  // Split single string on delimiter (usually '|')
575  while (pos != std::string::npos)
576  {
577  size_t new_pos = new_str.find_first_of (separator, pos);
578 
579  if (new_pos == std::string::npos)
580  {
581  strings.append (new_str.substr (pos));
582  break;
583  }
584  else
585  strings.append (new_str.substr (pos, new_pos - pos));
586 
587  pos = new_pos + 1;
588  }
589 
590  if (str.numel () == strings.numel ())
591  {
592  for (octave_idx_type i = 0; i < str.numel (); i++)
593  if (strings[i] != str[i])
594  {
595  replace = true;
596  break;
597  }
598  }
599  else
600  replace = true;
601 
603 
604  if (replace)
605  {
606  str = strings;
607  return true;
608  }
609  }
610  else if (val.is_string ()) // multi-row character matrix
611  {
612  bool replace = false;
613  charMatrix chm = val.char_matrix_value ();
614  octave_idx_type nel = chm.rows ();
615  string_vector strings (nel);
616 
617  if (nel != str.numel ())
618  replace = true;
619  for (octave_idx_type i = 0; i < nel; i++)
620  {
621  strings[i] = chm.row_as_string (i);
622  if (!replace && strings[i] != str[i])
623  replace = true;
624  }
625 
627 
628  if (replace)
629  {
630  str = strings;
631  return true;
632  }
633  }
634  else if (val.is_cellstr ())
635  {
636  bool replace = false;
637  Cell new_cell = val.cell_value ();
638 
639  string_vector strings = new_cell.cellstr_value ();
640 
641  octave_idx_type nel = strings.length ();
642 
643  if (nel != str.length ())
644  replace = true;
645  else
646  {
647  for (octave_idx_type i = 0; i < nel; i++)
648  {
649  if (strings[i] != str[i])
650  {
651  replace = true;
652  break;
653  }
654  }
655  }
656 
658 
659  if (replace)
660  {
661  str = strings;
662  return true;
663  }
664  }
665  else
666  error ("set: invalid string property value for \"%s\"",
667  get_name ().c_str ());
668  return false;
669  }
670 
671 private:
673  char separator;
675 };
676 
677 // ---------------------------------------------------------------------
678 
680 {
681 public:
682  enum type { char_t, cellstr_t };
683 
684  text_label_property (const std::string& s, const graphics_handle& h,
685  const std::string& val = "")
686  : base_property (s, h), value (val), stored_type (char_t)
687  { }
688 
689  text_label_property (const std::string& s, const graphics_handle& h,
690  const NDArray& nda)
691  : base_property (s, h), stored_type (char_t)
692  {
693  octave_idx_type nel = nda.numel ();
694 
695  value.resize (nel);
696 
697  for (octave_idx_type i = 0; i < nel; i++)
698  {
699  std::ostringstream buf;
700  buf << nda(i);
701  value[i] = buf.str ();
702  }
703  }
704 
705  text_label_property (const std::string& s, const graphics_handle& h,
706  const Cell& c)
708  {
709  octave_idx_type nel = c.numel ();
710 
711  value.resize (nel);
712 
713  for (octave_idx_type i = 0; i < nel; i++)
714  {
715  octave_value tmp = c(i);
716 
717  if (tmp.is_string ())
718  value[i] = c(i).string_value ();
719  else
720  {
721  double d = c(i).double_value ();
722 
723  if (! error_state)
724  {
725  std::ostringstream buf;
726  buf << d;
727  value[i] = buf.str ();
728  }
729  else
730  break;
731  }
732  }
733  }
734 
737  { }
738 
739  bool empty (void) const
740  {
741  octave_value tmp = get ();
742  return tmp.is_empty ();
743  }
744 
745  octave_value get (void) const
746  {
747  if (stored_type == char_t)
748  return octave_value (char_value ());
749  else
750  return octave_value (cell_value ());
751  }
752 
753  std::string string_value (void) const
754  {
755  return value.empty () ? std::string () : value[0];
756  }
757 
758  string_vector string_vector_value (void) const { return value; }
759 
760  charMatrix char_value (void) const { return charMatrix (value, ' '); }
761 
762  Cell cell_value (void) const {return Cell (value); }
763 
765  {
766  set (val);
767  return *this;
768  }
769 
770  base_property* clone (void) const { return new text_label_property (*this); }
771 
772 protected:
773 
774  bool do_set (const octave_value& val)
775  {
776  if (val.is_string ())
777  {
778  value = val.all_strings ();
779 
781  }
782  else if (val.is_cell ())
783  {
784  Cell c = val.cell_value ();
785 
786  octave_idx_type nel = c.numel ();
787 
788  value.resize (nel);
789 
790  for (octave_idx_type i = 0; i < nel; i++)
791  {
792  octave_value tmp = c(i);
793 
794  if (tmp.is_string ())
795  value[i] = c(i).string_value ();
796  else
797  {
798  double d = c(i).double_value ();
799 
800  if (! error_state)
801  {
802  std::ostringstream buf;
803  buf << d;
804  value[i] = buf.str ();
805  }
806  else
807  return false;
808  }
809  }
810 
812  }
813  else
814  {
815  NDArray nda = val.array_value ();
816 
817  if (! error_state)
818  {
819  octave_idx_type nel = nda.numel ();
820 
821  value.resize (nel);
822 
823  for (octave_idx_type i = 0; i < nel; i++)
824  {
825  std::ostringstream buf;
826  buf << nda(i);
827  value[i] = buf.str ();
828  }
829 
831  }
832  else
833  {
834  error ("set: invalid string property value for \"%s\"",
835  get_name ().c_str ());
836 
837  return false;
838  }
839  }
840 
841  return true;
842  }
843 
844 private:
847 };
848 
849 // ---------------------------------------------------------------------
850 
852 {
853 public:
854  OCTINTERP_API radio_values (const std::string& opt_string = std::string ());
855 
856  radio_values (const radio_values& a)
858 
859  radio_values& operator = (const radio_values& a)
860  {
861  if (&a != this)
862  {
865  }
866 
867  return *this;
868  }
869 
870  std::string default_value (void) const { return default_val; }
871 
872  bool validate (const std::string& val, std::string& match)
873  {
874  bool retval = true;
875 
876  if (! contains (val, match))
877  {
878  error ("invalid value = %s", val.c_str ());
879  retval = false;
880  }
881 
882  return retval;
883  }
884 
885  bool contains (const std::string& val, std::string& match)
886  {
887  size_t k = 0;
888 
889  size_t len = val.length ();
890 
891  std::string first_match;
892 
893  for (std::set<caseless_str>::const_iterator p = possible_vals.begin ();
894  p != possible_vals.end (); p++)
895  {
896  if (p->compare (val, len))
897  {
898  if (len == p->length ())
899  {
900  // We found a full match (consider the case of val ==
901  // "replace" with possible values "replace" and
902  // "replacechildren"). Any other matches are
903  // irrelevant, so set match and return now.
904 
905  match = *p;
906  return true;
907  }
908  else
909  {
910  if (k == 0)
911  first_match = *p;
912 
913  k++;
914  }
915  }
916  }
917 
918  if (k == 1)
919  {
920  match = first_match;
921  return true;
922  }
923  else
924  return false;
925  }
926 
927  std::string values_as_string (void) const;
928 
929  Cell values_as_cell (void) const;
930 
931  octave_idx_type nelem (void) const { return possible_vals.size (); }
932 
933 private:
934  // Might also want to cache
935  std::string default_val;
936  std::set<caseless_str> possible_vals;
937 };
938 
940 {
941 public:
942  radio_property (const std::string& nm, const graphics_handle& h,
943  const radio_values& v = radio_values ())
944  : base_property (nm, h),
945  vals (v), current_val (v.default_value ()) { }
946 
947  radio_property (const std::string& nm, const graphics_handle& h,
948  const std::string& v)
949  : base_property (nm, h),
950  vals (v), current_val (vals.default_value ()) { }
951 
952  radio_property (const std::string& nm, const graphics_handle& h,
953  const radio_values& v, const std::string& def)
954  : base_property (nm, h),
955  vals (v), current_val (def) { }
956 
958  : base_property (p), vals (p.vals), current_val (p.current_val) { }
959 
960  octave_value get (void) const { return octave_value (current_val); }
961 
962  const std::string& current_value (void) const { return current_val; }
963 
964  std::string values_as_string (void) const { return vals.values_as_string (); }
965 
966  Cell values_as_cell (void) const { return vals.values_as_cell (); }
967 
968  bool is (const caseless_str& v) const
969  { return v.compare (current_val); }
970 
971  bool is_radio (void) const { return true; }
972 
974  {
975  set (val);
976  return *this;
977  }
978 
979  base_property* clone (void) const { return new radio_property (*this); }
980 
981 protected:
982  bool do_set (const octave_value& newval)
983  {
984  if (newval.is_string ())
985  {
986  std::string s = newval.string_value ();
987 
988  std::string match;
989 
990  if (vals.validate (s, match))
991  {
992  if (match != current_val)
993  {
994  if (s.length () != match.length ())
995  warning_with_id ("Octave:abbreviated-property-match",
996  "%s: allowing %s to match %s value %s",
997  "set", s.c_str (), get_name ().c_str (),
998  match.c_str ());
999  current_val = match;
1000  return true;
1001  }
1002  }
1003  else
1004  error ("set: invalid value for radio property \"%s\" (value = %s)",
1005  get_name ().c_str (), s.c_str ());
1006  }
1007  else
1008  error ("set: invalid value for radio property \"%s\"",
1009  get_name ().c_str ());
1010  return false;
1011  }
1012 
1013 private:
1015  std::string current_val;
1016 };
1017 
1018 // ---------------------------------------------------------------------
1019 
1021 {
1022 public:
1023  color_values (double r = 0, double g = 0, double b = 1)
1024  : xrgb (1, 3)
1025  {
1026  xrgb(0) = r;
1027  xrgb(1) = g;
1028  xrgb(2) = b;
1029 
1030  validate ();
1031  }
1032 
1033  color_values (const std::string& str)
1034  : xrgb (1, 3)
1035  {
1036  if (! str2rgb (str))
1037  error ("invalid color specification: %s", str.c_str ());
1038  }
1039 
1041  : xrgb (c.xrgb)
1042  { }
1043 
1045  {
1046  if (&c != this)
1047  xrgb = c.xrgb;
1048 
1049  return *this;
1050  }
1051 
1052  bool operator == (const color_values& c) const
1053  {
1054  return (xrgb(0) == c.xrgb(0)
1055  && xrgb(1) == c.xrgb(1)
1056  && xrgb(2) == c.xrgb(2));
1057  }
1058 
1059  bool operator != (const color_values& c) const
1060  { return ! (*this == c); }
1061 
1062  Matrix rgb (void) const { return xrgb; }
1063 
1064  operator octave_value (void) const { return xrgb; }
1065 
1066  void validate (void) const
1067  {
1068  for (int i = 0; i < 3; i++)
1069  {
1070  if (xrgb(i) < 0 || xrgb(i) > 1)
1071  {
1072  error ("invalid RGB color specification");
1073  break;
1074  }
1075  }
1076  }
1077 
1078 private:
1080 
1081  OCTINTERP_API bool str2rgb (const std::string& str);
1082 };
1083 
1085 {
1086 public:
1088  : base_property ("", graphics_handle ()),
1090  current_val (v.default_value ())
1091  { }
1092 
1094  : base_property ("", graphics_handle ()),
1096  current_val (v.default_value ())
1097  { }
1098 
1099  color_property (const std::string& nm, const graphics_handle& h,
1100  const color_values& c = color_values (),
1101  const radio_values& v = radio_values ())
1102  : base_property (nm, h),
1104  current_val (v.default_value ())
1105  { }
1106 
1107  color_property (const std::string& nm, const graphics_handle& h,
1108  const radio_values& v)
1109  : base_property (nm, h),
1111  current_val (v.default_value ())
1112  { }
1113 
1114  color_property (const std::string& nm, const graphics_handle& h,
1115  const std::string& v)
1116  : base_property (nm, h),
1118  current_val (radio_val.default_value ())
1119  { }
1120 
1121  color_property (const std::string& nm, const graphics_handle& h,
1122  const color_property& v)
1123  : base_property (nm, h),
1126  { }
1127 
1131  current_val (p.current_val) { }
1132 
1133  octave_value get (void) const
1134  {
1135  if (current_type == color_t)
1136  return color_val.rgb ();
1137 
1138  return current_val;
1139  }
1140 
1141  bool is_rgb (void) const { return (current_type == color_t); }
1142 
1143  bool is_radio (void) const { return (current_type == radio_t); }
1144 
1145  bool is (const std::string& v) const
1146  { return (is_radio () && current_val == v); }
1147 
1148  Matrix rgb (void) const
1149  {
1150  if (current_type != color_t)
1151  error ("color has no rgb value");
1152 
1153  return color_val.rgb ();
1154  }
1155 
1156  const std::string& current_value (void) const
1157  {
1158  if (current_type != radio_t)
1159  error ("color has no radio value");
1160 
1161  return current_val;
1162  }
1163 
1165  {
1166  set (val);
1167  return *this;
1168  }
1169 
1170  operator octave_value (void) const { return get (); }
1171 
1172  base_property* clone (void) const { return new color_property (*this); }
1173 
1174  std::string values_as_string (void) const
1175  { return radio_val.values_as_string (); }
1176 
1177  Cell values_as_cell (void) const { return radio_val.values_as_cell (); }
1178 
1179 protected:
1180  OCTINTERP_API bool do_set (const octave_value& newval);
1181 
1182 private:
1186  std::string current_val;
1187 };
1188 
1189 // ---------------------------------------------------------------------
1190 
1192 {
1193 public:
1194  double_property (const std::string& nm, const graphics_handle& h,
1195  double d = 0)
1196  : base_property (nm, h),
1197  current_val (d) { }
1198 
1200  : base_property (p), current_val (p.current_val) { }
1201 
1202  octave_value get (void) const { return octave_value (current_val); }
1203 
1204  double double_value (void) const { return current_val; }
1205 
1207  {
1208  set (val);
1209  return *this;
1210  }
1211 
1212  base_property* clone (void) const { return new double_property (*this); }
1213 
1214 protected:
1215  bool do_set (const octave_value& v)
1216  {
1217  if (v.is_scalar_type () && v.is_real_type ())
1218  {
1219  double new_val = v.double_value ();
1220 
1221  if (new_val != current_val)
1222  {
1223  current_val = new_val;
1224  return true;
1225  }
1226  }
1227  else
1228  error ("set: invalid value for double property \"%s\"",
1229  get_name ().c_str ());
1230  return false;
1231  }
1232 
1233 private:
1234  double current_val;
1235 };
1236 
1237 // ---------------------------------------------------------------------
1238 
1240 {
1241 public:
1243  : base_property ("", graphics_handle ()),
1244  current_type (double_t), dval (d), radio_val (v),
1245  current_val (v.default_value ())
1246  { }
1247 
1248  double_radio_property (const std::string& nm, const graphics_handle& h,
1249  const std::string& v)
1250  : base_property (nm, h),
1251  current_type (radio_t), dval (0), radio_val (v),
1252  current_val (radio_val.default_value ())
1253  { }
1254 
1255  double_radio_property (const std::string& nm, const graphics_handle& h,
1256  const double_radio_property& v)
1257  : base_property (nm, h),
1260  { }
1261 
1264  dval (p.dval), radio_val (p.radio_val),
1265  current_val (p.current_val) { }
1266 
1267  octave_value get (void) const
1268  {
1269  if (current_type == double_t)
1270  return dval;
1271 
1272  return current_val;
1273  }
1274 
1275  bool is_double (void) const { return (current_type == double_t); }
1276 
1277  bool is_radio (void) const { return (current_type == radio_t); }
1278 
1279  bool is (const std::string& v) const
1280  { return (is_radio () && current_val == v); }
1281 
1282  double double_value (void) const
1283  {
1284  if (current_type != double_t)
1285  error ("%s: property has no double", get_name ().c_str ());
1286 
1287  return dval;
1288  }
1289 
1290  const std::string& current_value (void) const
1291  {
1292  if (current_type != radio_t)
1293  error ("%s: property has no radio value");
1294 
1295  return current_val;
1296  }
1297 
1299  {
1300  set (val);
1301  return *this;
1302  }
1303 
1304  operator octave_value (void) const { return get (); }
1305 
1306  base_property* clone (void) const
1307  { return new double_radio_property (*this); }
1308 
1309 protected:
1310  OCTINTERP_API bool do_set (const octave_value& v);
1311 
1312 private:
1314  double dval;
1316  std::string current_val;
1317 };
1318 
1319 // ---------------------------------------------------------------------
1320 
1322 {
1323 public:
1325  : base_property ("", graphics_handle ()), data (Matrix ()),
1326  xmin (), xmax (), xminp (), xmaxp (),
1328  {
1329  get_data_limits ();
1330  }
1331 
1332  array_property (const std::string& nm, const graphics_handle& h,
1333  const octave_value& m)
1334  : base_property (nm, h), data (m.is_sparse_type () ? m.full_value () : m),
1335  xmin (), xmax (), xminp (), xmaxp (),
1337  {
1338  get_data_limits ();
1339  }
1340 
1341  // This copy constructor is only intended to be used
1342  // internally to access min/max values; no need to
1343  // copy constraints.
1345  : base_property (p), data (p.data),
1346  xmin (p.xmin), xmax (p.xmax), xminp (p.xminp), xmaxp (p.xmaxp),
1348  { }
1349 
1350  octave_value get (void) const { return data; }
1351 
1352  void add_constraint (const std::string& type)
1353  { type_constraints.insert (type); }
1354 
1355  void add_constraint (const dim_vector& dims)
1356  { size_constraints.push_back (dims); }
1357 
1358  double min_val (void) const { return xmin; }
1359  double max_val (void) const { return xmax; }
1360  double min_pos (void) const { return xminp; }
1361  double max_neg (void) const { return xmaxp; }
1362 
1363  Matrix get_limits (void) const
1364  {
1365  Matrix m (1, 4);
1366 
1367  m(0) = min_val ();
1368  m(1) = max_val ();
1369  m(2) = min_pos ();
1370  m(3) = max_neg ();
1371 
1372  return m;
1373  }
1374 
1376  {
1377  set (val);
1378  return *this;
1379  }
1380 
1381  base_property* clone (void) const
1382  {
1383  array_property *p = new array_property (*this);
1384 
1387 
1388  return p;
1389  }
1390 
1391 protected:
1392  bool do_set (const octave_value& v)
1393  {
1394  octave_value tmp = v.is_sparse_type () ? v.full_value () : v;
1395 
1396  if (validate (tmp))
1397  {
1398  // FIXME: should we check for actual data change?
1399  if (! is_equal (tmp))
1400  {
1401  data = tmp;
1402 
1403  get_data_limits ();
1404 
1405  return true;
1406  }
1407  }
1408  else
1409  error ("invalid value for array property \"%s\"",
1410  get_name ().c_str ());
1411 
1412  return false;
1413  }
1414 
1415 private:
1416  OCTINTERP_API bool validate (const octave_value& v);
1417 
1418  OCTINTERP_API bool is_equal (const octave_value& v) const;
1419 
1420  OCTINTERP_API void get_data_limits (void);
1421 
1422 protected:
1424  double xmin;
1425  double xmax;
1426  double xminp;
1427  double xmaxp;
1428  std::set<std::string> type_constraints;
1429  std::list<dim_vector> size_constraints;
1430 };
1431 
1433 {
1434 public:
1435  row_vector_property (const std::string& nm, const graphics_handle& h,
1436  const octave_value& m)
1437  : array_property (nm, h, m)
1438  {
1439  add_constraint (dim_vector (-1, 1));
1440  add_constraint (dim_vector (1, -1));
1441  add_constraint (dim_vector (0, 0));
1442  }
1443 
1445  : array_property (p)
1446  {
1447  add_constraint (dim_vector (-1, 1));
1448  add_constraint (dim_vector (1, -1));
1449  add_constraint (dim_vector (0, 0));
1450  }
1451 
1452  void add_constraint (const std::string& type)
1453  {
1455  }
1456 
1457  void add_constraint (const dim_vector& dims)
1458  {
1460  }
1461 
1463  {
1464  size_constraints.remove (dim_vector (1, -1));
1465  size_constraints.remove (dim_vector (-1, 1));
1466 
1467  add_constraint (dim_vector (1, len));
1468  add_constraint (dim_vector (len, 1));
1469  }
1470 
1472  {
1473  set (val);
1474  return *this;
1475  }
1476 
1477  base_property* clone (void) const
1478  {
1479  row_vector_property *p = new row_vector_property (*this);
1480 
1483 
1484  return p;
1485  }
1486 
1487 protected:
1488  bool do_set (const octave_value& v)
1489  {
1490  bool retval = array_property::do_set (v);
1491 
1492  if (! error_state)
1493  {
1494  dim_vector dv = data.dims ();
1495 
1496  if (dv(0) > 1 && dv(1) == 1)
1497  {
1498  int tmp = dv(0);
1499  dv(0) = dv(1);
1500  dv(1) = tmp;
1501 
1502  data = data.reshape (dv);
1503  }
1504 
1505  return retval;
1506  }
1507 
1508  return false;
1509  }
1510 
1511 private:
1512  OCTINTERP_API bool validate (const octave_value& v);
1513 };
1514 
1515 // ---------------------------------------------------------------------
1516 
1518 {
1519 public:
1520  bool_property (const std::string& nm, const graphics_handle& h,
1521  bool val)
1522  : radio_property (nm, h, radio_values (val ? "{on}|off" : "on|{off}"))
1523  { }
1524 
1525  bool_property (const std::string& nm, const graphics_handle& h,
1526  const char* val)
1527  : radio_property (nm, h, radio_values ("on|off"), val)
1528  { }
1529 
1531  : radio_property (p) { }
1532 
1533  bool is_on (void) const { return is ("on"); }
1534 
1536  {
1537  set (val);
1538  return *this;
1539  }
1540 
1541  base_property* clone (void) const { return new bool_property (*this); }
1542 
1543 protected:
1544  bool do_set (const octave_value& val)
1545  {
1546  if (val.is_bool_scalar ())
1547  return radio_property::do_set (val.bool_value () ? "on" : "off");
1548  else
1549  return radio_property::do_set (val);
1550  }
1551 };
1552 
1553 // ---------------------------------------------------------------------
1554 
1556 {
1557 public:
1558  handle_property (const std::string& nm, const graphics_handle& h,
1559  const graphics_handle& val = graphics_handle ())
1560  : base_property (nm, h),
1561  current_val (val) { }
1562 
1564  : base_property (p), current_val (p.current_val) { }
1565 
1566  octave_value get (void) const { return current_val.as_octave_value (); }
1567 
1568  graphics_handle handle_value (void) const { return current_val; }
1569 
1571  {
1572  set (val);
1573  return *this;
1574  }
1575 
1577  {
1578  set (octave_value (h.value ()));
1579  return *this;
1580  }
1581 
1582  void invalidate (void) { current_val = octave_NaN; }
1583 
1584  base_property* clone (void) const { return new handle_property (*this); }
1585 
1586 protected:
1587  OCTINTERP_API bool do_set (const octave_value& v);
1588 
1589 private:
1591 };
1592 
1593 // ---------------------------------------------------------------------
1594 
1596 {
1597 public:
1598  any_property (const std::string& nm, const graphics_handle& h,
1599  const octave_value& m = Matrix ())
1600  : base_property (nm, h), data (m) { }
1601 
1603  : base_property (p), data (p.data) { }
1604 
1605  octave_value get (void) const { return data; }
1606 
1608  {
1609  set (val);
1610  return *this;
1611  }
1612 
1613  base_property* clone (void) const { return new any_property (*this); }
1614 
1615 protected:
1616  bool do_set (const octave_value& v)
1617  {
1618  data = v;
1619  return true;
1620  }
1621 
1622 private:
1624 };
1625 
1626 // ---------------------------------------------------------------------
1627 
1629 {
1630 public:
1633  {
1634  do_init_children (Matrix ());
1635  }
1636 
1637  children_property (const std::string& nm, const graphics_handle& h,
1638  const Matrix& val)
1639  : base_property (nm, h), children_list ()
1640  {
1641  do_init_children (val);
1642  }
1643 
1645  : base_property (p), children_list ()
1646  {
1648  }
1649 
1651  {
1652  set (val);
1653  return *this;
1654  }
1655 
1656  base_property* clone (void) const { return new children_property (*this); }
1657 
1658  bool remove_child (double val)
1659  {
1660  return do_remove_child (val);
1661  }
1662 
1663  void adopt (double val)
1664  {
1665  do_adopt_child (val);
1666  }
1667 
1668  Matrix get_children (void) const
1669  {
1670  return do_get_children (false);
1671  }
1672 
1673  Matrix get_hidden (void) const
1674  {
1675  return do_get_children (true);
1676  }
1677 
1678  Matrix get_all (void) const
1679  {
1680  return do_get_all_children ();
1681  }
1682 
1683  octave_value get (void) const
1684  {
1685  return octave_value (get_children ());
1686  }
1687 
1688  void delete_children (bool clear = false)
1689  {
1691  }
1692 
1694  {
1695  for (children_list_iterator p = children_list.begin ();
1696  p != children_list.end (); p++)
1697  {
1698  if (*p == old_gh)
1699  {
1700  *p = new_gh.value ();
1701  return;
1702  }
1703  }
1704 
1705  error ("children_list::renumber: child not found!");
1706  }
1707 
1708 private:
1709  typedef std::list<double>::iterator children_list_iterator;
1710  typedef std::list<double>::const_iterator const_children_list_iterator;
1711  std::list<double> children_list;
1712 
1713 protected:
1714  bool do_set (const octave_value& val)
1715  {
1716  const Matrix new_kids = val.matrix_value ();
1717 
1718  octave_idx_type nel = new_kids.numel ();
1719 
1720  const Matrix new_kids_column = new_kids.reshape (dim_vector (nel, 1));
1721 
1722  bool is_ok = true;
1723  bool add_hidden = true;
1724 
1725  if (! error_state)
1726  {
1727  const Matrix visible_kids = do_get_children (false);
1728 
1729  if (visible_kids.numel () == new_kids.numel ())
1730  {
1731  Matrix t1 = visible_kids.sort ();
1732  Matrix t2 = new_kids_column.sort ();
1733  Matrix t3 = get_hidden ().sort ();
1734 
1735  if (t1 != t2)
1736  is_ok = false;
1737 
1738  if (t1 == t3)
1739  add_hidden = false;
1740  }
1741  else
1742  is_ok = false;
1743 
1744  if (! is_ok)
1745  error ("set: new children must be a permutation of existing children");
1746  }
1747  else
1748  {
1749  is_ok = false;
1750  error ("set: expecting children to be array of graphics handles");
1751  }
1752 
1753  if (is_ok)
1754  {
1755  Matrix tmp = new_kids_column;
1756 
1757  if (add_hidden)
1758  tmp.stack (get_hidden ());
1759 
1760  children_list.clear ();
1761 
1762  // Don't use do_init_children here, as that reverses the
1763  // order of the list, and we don't want to do that if setting
1764  // the child list directly.
1765 
1766  for (octave_idx_type i = 0; i < tmp.numel (); i++)
1767  children_list.push_back (tmp.xelem (i));
1768  }
1769 
1770  return is_ok;
1771  }
1772 
1773 private:
1774  void do_init_children (const Matrix& val)
1775  {
1776  children_list.clear ();
1777  for (octave_idx_type i = 0; i < val.numel (); i++)
1778  children_list.push_front (val.xelem (i));
1779  }
1780 
1781  void do_init_children (const std::list<double>& val)
1782  {
1783  children_list.clear ();
1784  for (const_children_list_iterator p = val.begin (); p != val.end (); p++)
1785  children_list.push_front (*p);
1786  }
1787 
1788  Matrix do_get_children (bool return_hidden) const;
1789 
1791  {
1792  Matrix retval (children_list.size (), 1);
1793  octave_idx_type i = 0;
1794 
1795  for (const_children_list_iterator p = children_list.begin ();
1796  p != children_list.end (); p++)
1797  retval(i++) = *p;
1798  return retval;
1799  }
1800 
1801  bool do_remove_child (double child)
1802  {
1803  for (children_list_iterator p = children_list.begin ();
1804  p != children_list.end (); p++)
1805  {
1806  if (*p == child)
1807  {
1808  children_list.erase (p);
1809  return true;
1810  }
1811  }
1812  return false;
1813  }
1814 
1815  void do_adopt_child (double val)
1816  {
1817  children_list.push_front (val);
1818  }
1819 
1820  void do_delete_children (bool clear);
1821 };
1822 
1823 
1824 
1825 // ---------------------------------------------------------------------
1826 
1828 {
1829 public:
1830  callback_property (const std::string& nm, const graphics_handle& h,
1831  const octave_value& m)
1832  : base_property (nm, h), callback (m), executing (false) { }
1833 
1835  : base_property (p), callback (p.callback), executing (false) { }
1836 
1837  octave_value get (void) const { return callback; }
1838 
1839  OCTINTERP_API void execute (const octave_value& data = octave_value ()) const;
1840 
1841  bool is_defined (void) const
1842  {
1843  return (callback.is_defined () && ! callback.is_empty ());
1844  }
1845 
1847  {
1848  set (val);
1849  return *this;
1850  }
1851 
1852  base_property* clone (void) const { return new callback_property (*this); }
1853 
1854 protected:
1855  bool do_set (const octave_value& v)
1856  {
1857  if (validate (v))
1858  {
1859  callback = v;
1860  return true;
1861  }
1862  else
1863  error ("invalid value for callback property \"%s\"",
1864  get_name ().c_str ());
1865  return false;
1866  }
1867 
1868 private:
1869  OCTINTERP_API bool validate (const octave_value& v) const;
1870 
1871 private:
1873 
1874  // If TRUE, we are executing this callback.
1875  mutable bool executing;
1876 };
1877 
1878 // ---------------------------------------------------------------------
1879 
1881 {
1882 public:
1883  property (void) : rep (new base_property ("", graphics_handle ()))
1884  { }
1885 
1886  property (base_property *bp, bool persist = false) : rep (bp)
1887  { if (persist) rep->count++; }
1888 
1889  property (const property& p) : rep (p.rep)
1890  {
1891  rep->count++;
1892  }
1893 
1894  ~property (void)
1895  {
1896  if (--rep->count == 0)
1897  delete rep;
1898  }
1899 
1900  bool ok (void) const
1901  { return rep->ok (); }
1902 
1903  std::string get_name (void) const
1904  { return rep->get_name (); }
1905 
1906  void set_name (const std::string& name)
1907  { rep->set_name (name); }
1908 
1910  { return rep->get_parent (); }
1911 
1912  void set_parent (const graphics_handle& h)
1913  { rep->set_parent (h); }
1914 
1915  bool is_hidden (void) const
1916  { return rep->is_hidden (); }
1917 
1918  void set_hidden (bool flag)
1919  { rep->set_hidden (flag); }
1920 
1921  bool is_radio (void) const
1922  { return rep->is_radio (); }
1923 
1924  int get_id (void) const
1925  { return rep->get_id (); }
1926 
1927  void set_id (int d)
1928  { rep->set_id (d); }
1929 
1930  octave_value get (void) const
1931  { return rep->get (); }
1932 
1933  bool set (const octave_value& val, bool do_run = true,
1934  bool do_notify_toolkit = true)
1935  { return rep->set (val, do_run, do_notify_toolkit); }
1936 
1937  std::string values_as_string (void) const
1938  { return rep->values_as_string (); }
1939 
1940  Cell values_as_cell (void) const
1941  { return rep->values_as_cell (); }
1942 
1943  property& operator = (const octave_value& val)
1944  {
1945  *rep = val;
1946  return *this;
1947  }
1948 
1949  property& operator = (const property& p)
1950  {
1951  if (rep && --rep->count == 0)
1952  delete rep;
1953 
1954  rep = p.rep;
1955  rep->count++;
1956 
1957  return *this;
1958  }
1959 
1961  { rep->add_listener (v, mode); }
1962 
1964  listener_mode mode = POSTSET)
1965  { rep->delete_listener (v, mode); }
1966 
1968  { rep->run_listeners (mode); }
1969 
1970  OCTINTERP_API static
1971  property create (const std::string& name, const graphics_handle& parent,
1972  const caseless_str& type,
1973  const octave_value_list& args);
1974 
1975  property clone (void) const
1976  { return property (rep->clone ()); }
1977 
1978  /*
1979  const string_property& as_string_property (void) const
1980  { return *(dynamic_cast<string_property*> (rep)); }
1981 
1982  const radio_property& as_radio_property (void) const
1983  { return *(dynamic_cast<radio_property*> (rep)); }
1984 
1985  const color_property& as_color_property (void) const
1986  { return *(dynamic_cast<color_property*> (rep)); }
1987 
1988  const double_property& as_double_property (void) const
1989  { return *(dynamic_cast<double_property*> (rep)); }
1990 
1991  const bool_property& as_bool_property (void) const
1992  { return *(dynamic_cast<bool_property*> (rep)); }
1993 
1994  const handle_property& as_handle_property (void) const
1995  { return *(dynamic_cast<handle_property*> (rep)); }
1996  */
1997 
1998 private:
2000 };
2001 
2002 // ---------------------------------------------------------------------
2003 
2004 typedef std::pair <std::string, octave_value> pval_pair;
2005 
2006 class pval_vector : public std::vector <pval_pair>
2007 {
2008 public:
2009  const_iterator find (const std::string pname) const
2010  {
2011  const_iterator it;
2012 
2013  for (it = (*this).begin (); it != (*this).end (); it++)
2014  if (pname.compare ((*it).first) == 0)
2015  return it;
2016 
2017  return (*this).end ();
2018  }
2019 
2020  iterator find (const std::string pname)
2021  {
2022  iterator it;
2023 
2024  for (it = (*this).begin (); it != (*this).end (); it++)
2025  if (pname.compare ((*it).first) == 0)
2026  return it;
2027 
2028  return (*this).end ();
2029  }
2030 
2031  octave_value lookup (const std::string pname) const
2032  {
2033  octave_value retval;
2034 
2035  const_iterator it = find (pname);
2036 
2037  if (it != (*this).end ())
2038  retval = (*it).second;
2039 
2040  return retval;
2041  }
2042 
2043  octave_value& operator [] (const std::string pname)
2044  {
2045  iterator it = find (pname);
2046 
2047  if (it == (*this).end ())
2048  {
2049  push_back (pval_pair (pname, octave_value ()));
2050  return (*this).back ().second;
2051  }
2052 
2053  return (*it).second;
2054  }
2055 
2056  void erase (const std::string pname)
2057  {
2058  iterator it = find (pname);
2059  if (it != (*this).end ())
2060  erase (it);
2061  }
2062 
2063  void erase (iterator it)
2064  {
2065  std::vector <pval_pair>::erase (it);
2066  }
2067 
2068 };
2069 
2071 {
2072 public:
2074  typedef std::map<std::string, pval_map_type> plist_map_type;
2075 
2076  typedef pval_map_type::iterator pval_map_iterator;
2077  typedef pval_map_type::const_iterator pval_map_const_iterator;
2078 
2079  typedef plist_map_type::iterator plist_map_iterator;
2080  typedef plist_map_type::const_iterator plist_map_const_iterator;
2081 
2082  property_list (const plist_map_type& m = plist_map_type ())
2083  : plist_map (m) { }
2084 
2085  ~property_list (void) { }
2086 
2087  void set (const caseless_str& name, const octave_value& val);
2088 
2089  octave_value lookup (const caseless_str& name) const;
2090 
2091  plist_map_iterator begin (void) { return plist_map.begin (); }
2092  plist_map_const_iterator begin (void) const { return plist_map.begin (); }
2093 
2094  plist_map_iterator end (void) { return plist_map.end (); }
2095  plist_map_const_iterator end (void) const { return plist_map.end (); }
2096 
2097  plist_map_iterator find (const std::string& go_name)
2098  {
2099  return plist_map.find (go_name);
2100  }
2101 
2102  plist_map_const_iterator find (const std::string& go_name) const
2103  {
2104  return plist_map.find (go_name);
2105  }
2106 
2107  octave_scalar_map as_struct (const std::string& prefix_arg) const;
2108 
2109 private:
2110  plist_map_type plist_map;
2111 };
2112 
2113 // ---------------------------------------------------------------------
2114 
2115 class graphics_toolkit;
2116 class graphics_object;
2117 
2119 {
2120 public:
2121  friend class graphics_toolkit;
2122 
2123 public:
2124  base_graphics_toolkit (const std::string& nm)
2125  : name (nm), count (0) { }
2126 
2127  virtual ~base_graphics_toolkit (void) { }
2128 
2129  std::string get_name (void) const { return name; }
2130 
2131  virtual bool is_valid (void) const { return false; }
2132 
2133  virtual void redraw_figure (const graphics_object&) const
2134  { gripe_invalid ("redraw_figure"); }
2135 
2136  virtual void print_figure (const graphics_object&, const std::string&,
2137  const std::string&, bool,
2138  const std::string& = "") const
2139  { gripe_invalid ("print_figure"); }
2140 
2141  virtual Matrix get_canvas_size (const graphics_handle&) const
2142  {
2143  gripe_invalid ("get_canvas_size");
2144  return Matrix (1, 2, 0.0);
2145  }
2146 
2147  virtual double get_screen_resolution (void) const
2148  {
2149  gripe_invalid ("get_screen_resolution");
2150  return 72.0;
2151  }
2152 
2153  virtual Matrix get_screen_size (void) const
2154  {
2155  gripe_invalid ("get_screen_size");
2156  return Matrix (1, 2, 0.0);
2157  }
2158 
2159  // Callback function executed when the given graphics object
2160  // changes. This allows the graphics toolkit to act on property
2161  // changes if needed.
2162  virtual void update (const graphics_object&, int)
2163  { gripe_invalid ("base_graphics_toolkit::update"); }
2164 
2165  void update (const graphics_handle&, int);
2166 
2167  // Callback function executed when the given graphics object is
2168  // created. This allows the graphics toolkit to do toolkit-specific
2169  // initializations for a newly created object.
2170  virtual bool initialize (const graphics_object&)
2171  { gripe_invalid ("base_graphics_toolkit::initialize"); return false; }
2172 
2173  bool initialize (const graphics_handle&);
2174 
2175  // Callback function executed just prior to deleting the given
2176  // graphics object. This allows the graphics toolkit to perform
2177  // toolkit-specific cleanup operations before an object is deleted.
2178  virtual void finalize (const graphics_object&)
2179  { gripe_invalid ("base_graphics_toolkit::finalize"); }
2180 
2181  void finalize (const graphics_handle&);
2182 
2183  // Close the graphics toolkit.
2184  virtual void close (void)
2185  { gripe_invalid ("base_graphics_toolkit::close"); }
2186 
2187 private:
2188  std::string name;
2190 
2191 private:
2192  void gripe_invalid (const std::string& fname) const
2193  {
2194  if (! is_valid ())
2195  error ("%s: invalid graphics toolkit", fname.c_str ());
2196  }
2197 };
2198 
2200 {
2201 public:
2203  : rep (new base_graphics_toolkit ("unknown"))
2204  {
2205  rep->count++;
2206  }
2207 
2209  : rep (b)
2210  {
2211  rep->count++;
2212  }
2213 
2215  : rep (b.rep)
2216  {
2217  rep->count++;
2218  }
2219 
2221  {
2222  if (--rep->count == 0)
2223  delete rep;
2224  }
2225 
2227  {
2228  if (rep != b.rep)
2229  {
2230  if (--rep->count == 0)
2231  delete rep;
2232 
2233  rep = b.rep;
2234  rep->count++;
2235  }
2236 
2237  return *this;
2238  }
2239 
2240  operator bool (void) const { return rep->is_valid (); }
2241 
2242  std::string get_name (void) const { return rep->get_name (); }
2243 
2244  void redraw_figure (const graphics_object& go) const
2245  { rep->redraw_figure (go); }
2246 
2247  void print_figure (const graphics_object& go, const std::string& term,
2248  const std::string& file, bool mono,
2249  const std::string& debug_file = "") const
2250  { rep->print_figure (go, term, file, mono, debug_file); }
2251 
2253  { return rep->get_canvas_size (fh); }
2254 
2255  double get_screen_resolution (void) const
2256  { return rep->get_screen_resolution (); }
2257 
2259  { return rep->get_screen_size (); }
2260 
2261  // Notifies graphics toolkit that object't property has changed.
2262  void update (const graphics_object& go, int id)
2263  { rep->update (go, id); }
2264 
2265  void update (const graphics_handle& h, int id)
2266  { rep->update (h, id); }
2267 
2268  // Notifies graphics toolkit that new object was created.
2269  bool initialize (const graphics_object& go)
2270  { return rep->initialize (go); }
2271 
2272  bool initialize (const graphics_handle& h)
2273  { return rep->initialize (h); }
2274 
2275  // Notifies graphics toolkit that object was destroyed.
2276  // This is called only for explicitly deleted object. Children are
2277  // deleted implicitly and graphics toolkit isn't notified.
2278  void finalize (const graphics_object& go)
2279  { rep->finalize (go); }
2280 
2281  void finalize (const graphics_handle& h)
2282  { rep->finalize (h); }
2283 
2284  // Close the graphics toolkit.
2285  void close (void) { rep->close (); }
2286 
2287 private:
2288 
2290 };
2291 
2293 {
2294 public:
2295 
2297  {
2298  return instance_ok () ? instance->do_get_toolkit () : graphics_toolkit ();
2299  }
2300 
2301  static void register_toolkit (const std::string& name)
2302  {
2303  if (instance_ok ())
2304  instance->do_register_toolkit (name);
2305  }
2306 
2307  static void unregister_toolkit (const std::string& name)
2308  {
2309  if (instance_ok ())
2311  }
2312 
2313  static void load_toolkit (const graphics_toolkit& tk)
2314  {
2315  if (instance_ok ())
2316  instance->do_load_toolkit (tk);
2317  }
2318 
2319  static void unload_toolkit (const std::string& name)
2320  {
2321  if (instance_ok ())
2322  instance->do_unload_toolkit (name);
2323  }
2324 
2325  static graphics_toolkit find_toolkit (const std::string& name)
2326  {
2327  return instance_ok ()
2328  ? instance->do_find_toolkit (name) : graphics_toolkit ();
2329  }
2330 
2332  {
2333  return instance_ok () ? instance->do_available_toolkits_list () : Cell ();
2334  }
2335 
2337  {
2338  return instance_ok () ? instance->do_loaded_toolkits_list () : Cell ();
2339  }
2340 
2341  static void unload_all_toolkits (void)
2342  {
2343  if (instance_ok ())
2345  }
2346 
2347  static std::string default_toolkit (void)
2348  {
2349  return instance_ok () ? instance->do_default_toolkit () : std::string ();
2350  }
2351 
2352 private:
2353 
2354  gtk_manager (void) { }
2355 
2356  ~gtk_manager (void) { }
2357 
2358  OCTINTERP_API static void create_instance (void);
2359 
2360  static bool instance_ok (void)
2361  {
2362  bool retval = true;
2363 
2364  if (! instance)
2365  create_instance ();
2366 
2367  if (! instance)
2368  {
2369  ::error ("unable to create gh_manager!");
2370 
2371  retval = false;
2372  }
2373 
2374  return retval;
2375  }
2376 
2377  static void cleanup_instance (void) { delete instance; instance = 0; }
2378 
2380 
2381  // The name of the default toolkit.
2382  std::string dtk;
2383 
2384  // The list of toolkits that we know about.
2385  std::set<std::string> available_toolkits;
2386 
2387  // The list of toolkits we have actually loaded.
2388  std::map<std::string, graphics_toolkit> loaded_toolkits;
2389 
2390  typedef std::set<std::string>::iterator available_toolkits_iterator;
2391 
2392  typedef std::set<std::string>::const_iterator
2394 
2395  typedef std::map<std::string, graphics_toolkit>::iterator
2397 
2398  typedef std::map<std::string, graphics_toolkit>::const_iterator
2400 
2401  graphics_toolkit do_get_toolkit (void) const;
2402 
2403  void do_register_toolkit (const std::string& name);
2404 
2405  void do_unregister_toolkit (const std::string& name);
2406 
2408  {
2409  loaded_toolkits[tk.get_name ()] = tk;
2410  }
2411 
2412  void do_unload_toolkit (const std::string& name)
2413  {
2414  loaded_toolkits.erase (name);
2415  }
2416 
2417  graphics_toolkit do_find_toolkit (const std::string& name) const
2418  {
2419  const_loaded_toolkits_iterator p = loaded_toolkits.find (name);
2420 
2421  if (p != loaded_toolkits.end ())
2422  return p->second;
2423  else
2424  return graphics_toolkit ();
2425  }
2426 
2428  {
2429  Cell m (1 , available_toolkits.size ());
2430 
2431  octave_idx_type i = 0;
2432  for (const_available_toolkits_iterator p = available_toolkits.begin ();
2433  p != available_toolkits.end (); p++)
2434  m(i++) = *p;
2435 
2436  return m;
2437  }
2438 
2440  {
2441  Cell m (1 , loaded_toolkits.size ());
2442 
2443  octave_idx_type i = 0;
2444  for (const_loaded_toolkits_iterator p = loaded_toolkits.begin ();
2445  p != loaded_toolkits.end (); p++)
2446  m(i++) = p->first;
2447 
2448  return m;
2449  }
2450 
2452  {
2453  while (! loaded_toolkits.empty ())
2454  {
2455  loaded_toolkits_iterator p = loaded_toolkits.begin ();
2456 
2457  std::string name = p->first;
2458 
2459  p->second.close ();
2460 
2461  // The toolkit may have unloaded itself. If not, we'll do
2462  // it here.
2463  if (loaded_toolkits.find (name) != loaded_toolkits.end ())
2464  unload_toolkit (name);
2465  }
2466  }
2467 
2468  std::string do_default_toolkit (void) { return dtk; }
2469 };
2470 
2471 // ---------------------------------------------------------------------
2472 
2473 class base_graphics_object;
2474 class graphics_object;
2475 
2477 {
2478 public:
2479  base_properties (const std::string& ty = "unknown",
2480  const graphics_handle& mh = graphics_handle (),
2481  const graphics_handle& p = graphics_handle ());
2482 
2483  virtual ~base_properties (void) { }
2484 
2485  virtual std::string graphics_object_name (void) const { return "unknown"; }
2486 
2487  void mark_modified (void);
2488 
2489  void override_defaults (base_graphics_object& obj);
2490 
2491  virtual void init_integerhandle (const octave_value&)
2492  {
2493  panic_impossible ();
2494  }
2495 
2496  // Look through DEFAULTS for properties with given CLASS_NAME, and
2497  // apply them to the current object with set (virtual method).
2498 
2499  void set_from_list (base_graphics_object& obj, property_list& defaults);
2500 
2501  void insert_property (const std::string& name, property p)
2502  {
2503  p.set_name (name);
2504  p.set_parent (__myhandle__);
2505  all_props[name] = p;
2506  }
2507 
2508  virtual void set (const caseless_str&, const octave_value&);
2509 
2510  virtual octave_value get (const caseless_str& pname) const;
2511 
2512  virtual octave_value get (const std::string& pname) const
2513  {
2514  return get (caseless_str (pname));
2515  }
2516 
2517  virtual octave_value get (const char *pname) const
2518  {
2519  return get (caseless_str (pname));
2520  }
2521 
2522  virtual octave_value get (bool all = false) const;
2523 
2524  virtual property get_property (const caseless_str& pname);
2525 
2526  virtual bool has_property (const caseless_str&) const
2527  {
2528  panic_impossible ();
2529  return false;
2530  }
2531 
2532  bool is_modified (void) const { return is___modified__ (); }
2533 
2534  virtual void remove_child (const graphics_handle& h)
2535  {
2536  if (children.remove_child (h.value ()))
2537  {
2538  children.run_listeners ();
2539  mark_modified ();
2540  }
2541  }
2542 
2543  virtual void adopt (const graphics_handle& h)
2544  {
2545  children.adopt (h.value ());
2546  children.run_listeners ();
2547  mark_modified ();
2548  }
2549 
2550  virtual graphics_toolkit get_toolkit (void) const;
2551 
2552  virtual Matrix
2553  get_boundingbox (bool /*internal*/ = false,
2554  const Matrix& /*parent_pix_size*/ = Matrix ()) const
2555  { return Matrix (1, 4, 0.0); }
2556 
2557  virtual void update_boundingbox (void);
2558 
2559  virtual void update_autopos (const std::string& elem_type);
2560 
2561  virtual void add_listener (const caseless_str&, const octave_value&,
2563 
2564  virtual void delete_listener (const caseless_str&, const octave_value&,
2566 
2567  void set_tag (const octave_value& val) { tag = val; }
2568 
2569  void set_parent (const octave_value& val);
2570 
2571  Matrix get_children (void) const
2572  {
2573  return children.get_children ();
2574  }
2575 
2577  {
2578  return children.get_all ();
2579  }
2580 
2582  {
2583  return children.get_hidden ();
2584  }
2585 
2586  void set_modified (const octave_value& val) { set___modified__ (val); }
2587 
2588  void set___modified__ (const octave_value& val) { __modified__ = val; }
2589 
2590  void reparent (const graphics_handle& new_parent) { parent = new_parent; }
2591 
2592  // Update data limits for AXIS_TYPE (xdata, ydata, etc.) in the parent
2593  // axes object.
2594 
2595  virtual void update_axis_limits (const std::string& axis_type) const;
2596 
2597  virtual void update_axis_limits (const std::string& axis_type,
2598  const graphics_handle& h) const;
2599 
2600  virtual void update_uicontextmenu (void) const;
2601 
2602  virtual void delete_children (bool clear = false)
2603  {
2604  children.delete_children (clear);
2605  }
2606 
2608  {
2609  children.renumber (old_gh, new_gh);
2610  }
2611 
2613  {
2614  parent = new_gh;
2615  }
2616 
2617  static property_list::pval_map_type factory_defaults (void);
2618 
2619  // FIXME: these functions should be generated automatically by the
2620  // genprops.awk script.
2621  //
2622  // EMIT_BASE_PROPERTIES_GET_FUNCTIONS
2623 
2624  virtual octave_value get_alim (void) const { return octave_value (); }
2625  virtual octave_value get_clim (void) const { return octave_value (); }
2626  virtual octave_value get_xlim (void) const { return octave_value (); }
2627  virtual octave_value get_ylim (void) const { return octave_value (); }
2628  virtual octave_value get_zlim (void) const { return octave_value (); }
2629 
2630  virtual bool is_aliminclude (void) const { return false; }
2631  virtual bool is_climinclude (void) const { return false; }
2632  virtual bool is_xliminclude (void) const { return false; }
2633  virtual bool is_yliminclude (void) const { return false; }
2634  virtual bool is_zliminclude (void) const { return false; }
2635 
2636  bool is_handle_visible (void) const;
2637 
2638  std::set<std::string> dynamic_property_names (void) const;
2639 
2640  bool has_dynamic_property (const std::string& pname);
2641 
2642 protected:
2643  std::set<std::string> dynamic_properties;
2644 
2645  void set_dynamic (const caseless_str& pname, const octave_value& val);
2646 
2647  octave_value get_dynamic (const caseless_str& pname) const;
2648 
2649  octave_value get_dynamic (bool all = false) const;
2650 
2651  property get_property_dynamic (const caseless_str& pname);
2652 
2653 public:
2654 
2655 
2656  static std::set<std::string> core_property_names (void);
2657 
2658  static std::set<std::string> readonly_property_names (void);
2659 
2660  static bool has_core_property (const caseless_str& pname);
2661 
2662  static bool has_readonly_property (const caseless_str& pname);
2663 
2664  std::set<std::string> all_property_names (void) const;
2665 
2666 protected:
2667 
2688 
2689 public:
2690 
2691  enum
2692  {
2693  ID_BEINGDELETED = 0,
2694  ID_BUSYACTION = 1,
2695  ID_BUTTONDOWNFCN = 2,
2696  ID_CHILDREN = 3,
2697  ID_CLIPPING = 4,
2698  ID_CREATEFCN = 5,
2699  ID_DELETEFCN = 6,
2700  ID_HANDLEVISIBILITY = 7,
2701  ID_HITTEST = 8,
2702  ID_INTERRUPTIBLE = 9,
2703  ID_PARENT = 10,
2704  ID_SELECTED = 11,
2705  ID_SELECTIONHIGHLIGHT = 12,
2706  ID_TAG = 13,
2707  ID_TYPE = 14,
2708  ID_UICONTEXTMENU = 15,
2709  ID_USERDATA = 16,
2710  ID_VISIBLE = 17,
2711  ID___MODIFIED__ = 18,
2712  ID___MYHANDLE__ = 19
2713  };
2714 
2715  bool is_beingdeleted (void) const { return beingdeleted.is_on (); }
2716  std::string get_beingdeleted (void) const { return beingdeleted.current_value (); }
2717 
2718  bool busyaction_is (const std::string& v) const { return busyaction.is (v); }
2719  std::string get_busyaction (void) const { return busyaction.current_value (); }
2720 
2721  void execute_buttondownfcn (const octave_value& data = octave_value ()) const { buttondownfcn.execute (data); }
2722  octave_value get_buttondownfcn (void) const { return buttondownfcn.get (); }
2723 
2724  bool is_clipping (void) const { return clipping.is_on (); }
2725  std::string get_clipping (void) const { return clipping.current_value (); }
2726 
2727  void execute_createfcn (const octave_value& data = octave_value ()) const { createfcn.execute (data); }
2728  octave_value get_createfcn (void) const { return createfcn.get (); }
2729 
2730  void execute_deletefcn (const octave_value& data = octave_value ()) const { deletefcn.execute (data); }
2731  octave_value get_deletefcn (void) const { return deletefcn.get (); }
2732 
2733  bool handlevisibility_is (const std::string& v) const { return handlevisibility.is (v); }
2734  std::string get_handlevisibility (void) const { return handlevisibility.current_value (); }
2735 
2736  bool is_hittest (void) const { return hittest.is_on (); }
2737  std::string get_hittest (void) const { return hittest.current_value (); }
2738 
2739  bool is_interruptible (void) const { return interruptible.is_on (); }
2740  std::string get_interruptible (void) const { return interruptible.current_value (); }
2741 
2742  graphics_handle get_parent (void) const { return parent.handle_value (); }
2743 
2744  bool is_selected (void) const { return selected.is_on (); }
2745  std::string get_selected (void) const { return selected.current_value (); }
2746 
2747  bool is_selectionhighlight (void) const { return selectionhighlight.is_on (); }
2748  std::string get_selectionhighlight (void) const { return selectionhighlight.current_value (); }
2749 
2750  std::string get_tag (void) const { return tag.string_value (); }
2751 
2752  std::string get_type (void) const { return type.string_value (); }
2753 
2754  graphics_handle get_uicontextmenu (void) const { return uicontextmenu.handle_value (); }
2755 
2756  octave_value get_userdata (void) const { return userdata.get (); }
2757 
2758  bool is_visible (void) const { return visible.is_on (); }
2759  std::string get_visible (void) const { return visible.current_value (); }
2760 
2761  bool is___modified__ (void) const { return __modified__.is_on (); }
2762  std::string get___modified__ (void) const { return __modified__.current_value (); }
2763 
2764  graphics_handle get___myhandle__ (void) const { return __myhandle__; }
2765 
2766 
2767  void set_beingdeleted (const octave_value& val)
2768  {
2769  if (! error_state)
2770  {
2771  if (beingdeleted.set (val, true))
2772  {
2773  mark_modified ();
2774  }
2775  }
2776  }
2777 
2778  void set_busyaction (const octave_value& val)
2779  {
2780  if (! error_state)
2781  {
2782  if (busyaction.set (val, true))
2783  {
2784  mark_modified ();
2785  }
2786  }
2787  }
2788 
2790  {
2791  if (! error_state)
2792  {
2793  if (buttondownfcn.set (val, true))
2794  {
2795  mark_modified ();
2796  }
2797  }
2798  }
2799 
2800  void set_children (const octave_value& val)
2801  {
2802  if (! error_state)
2803  {
2804  if (children.set (val, true))
2805  {
2806  mark_modified ();
2807  }
2808  }
2809  }
2810 
2811  void set_clipping (const octave_value& val)
2812  {
2813  if (! error_state)
2814  {
2815  if (clipping.set (val, true))
2816  {
2817  mark_modified ();
2818  }
2819  }
2820  }
2821 
2822  void set_createfcn (const octave_value& val)
2823  {
2824  if (! error_state)
2825  {
2826  if (createfcn.set (val, true))
2827  {
2828  mark_modified ();
2829  }
2830  }
2831  }
2832 
2833  void set_deletefcn (const octave_value& val)
2834  {
2835  if (! error_state)
2836  {
2837  if (deletefcn.set (val, true))
2838  {
2839  mark_modified ();
2840  }
2841  }
2842  }
2843 
2845  {
2846  if (! error_state)
2847  {
2848  if (handlevisibility.set (val, true))
2849  {
2850  mark_modified ();
2851  }
2852  }
2853  }
2854 
2855  void set_hittest (const octave_value& val)
2856  {
2857  if (! error_state)
2858  {
2859  if (hittest.set (val, true))
2860  {
2861  mark_modified ();
2862  }
2863  }
2864  }
2865 
2867  {
2868  if (! error_state)
2869  {
2870  if (interruptible.set (val, true))
2871  {
2872  mark_modified ();
2873  }
2874  }
2875  }
2876 
2877  void set_selected (const octave_value& val)
2878  {
2879  if (! error_state)
2880  {
2881  if (selected.set (val, true))
2882  {
2883  mark_modified ();
2884  }
2885  }
2886  }
2887 
2889  {
2890  if (! error_state)
2891  {
2892  if (selectionhighlight.set (val, true))
2893  {
2894  mark_modified ();
2895  }
2896  }
2897  }
2898 
2900  {
2901  if (! error_state)
2902  {
2903  if (uicontextmenu.set (val, true))
2904  {
2905  update_uicontextmenu ();
2906  mark_modified ();
2907  }
2908  }
2909  }
2910 
2911  void set_userdata (const octave_value& val)
2912  {
2913  if (! error_state)
2914  {
2915  if (userdata.set (val, true))
2916  {
2917  mark_modified ();
2918  }
2919  }
2920  }
2921 
2922  void set_visible (const octave_value& val)
2923  {
2924  if (! error_state)
2925  {
2926  if (visible.set (val, true))
2927  {
2928  mark_modified ();
2929  }
2930  }
2931  }
2932 
2933 
2934 protected:
2936  {
2937  bool operator () (const caseless_str& a, const caseless_str& b) const
2938  {
2939  std::string a1 = a;
2940  std::transform (a1.begin (), a1.end (), a1.begin (), tolower);
2941  std::string b1 = b;
2942  std::transform (b1.begin (), b1.end (), b1.begin (), tolower);
2943 
2944  return a1 < b1;
2945  }
2946  };
2947 
2948  std::map<caseless_str, property, cmp_caseless_str> all_props;
2949 
2950 protected:
2951  void insert_static_property (const std::string& name, base_property& p)
2952  { insert_property (name, property (&p, true)); }
2953 
2954  virtual void init (void) { }
2955 };
2956 
2958 {
2959 public:
2960  friend class graphics_object;
2961 
2962  base_graphics_object (void) : count (1), toolkit_flag (false) { }
2963 
2964  virtual ~base_graphics_object (void) { }
2965 
2966  virtual void mark_modified (void)
2967  {
2968  if (valid_object ())
2970  else
2971  error ("base_graphics_object::mark_modified: invalid graphics object");
2972  }
2973 
2975  {
2976  if (valid_object ())
2978  else
2979  error ("base_graphics_object::override_defaults: invalid graphics object");
2980  }
2981 
2983  const std::string go_name) const;
2984 
2985  virtual void set_from_list (property_list& plist)
2986  {
2987  if (valid_object ())
2988  get_properties ().set_from_list (*this, plist);
2989  else
2990  error ("base_graphics_object::set_from_list: invalid graphics object");
2991  }
2992 
2993  virtual void set (const caseless_str& pname, const octave_value& pval)
2994  {
2995  if (valid_object ())
2996  get_properties ().set (pname, pval);
2997  else
2998  error ("base_graphics_object::set: invalid graphics object");
2999  }
3000 
3001  virtual void set_defaults (const std::string&)
3002  {
3003  error ("base_graphics_object::set_defaults: invalid graphics object");
3004  }
3005 
3006  virtual octave_value get (bool all = false) const
3007  {
3008  if (valid_object ())
3009  return get_properties ().get (all);
3010  else
3011  {
3012  error ("base_graphics_object::get: invalid graphics object");
3013  return octave_value ();
3014  }
3015  }
3016 
3017  virtual octave_value get (const caseless_str& pname) const
3018  {
3019  if (valid_object ())
3020  return get_properties ().get (pname);
3021  else
3022  {
3023  error ("base_graphics_object::get: invalid graphics object");
3024  return octave_value ();
3025  }
3026  }
3027 
3028  virtual octave_value get_default (const caseless_str&) const;
3029 
3030  virtual octave_value get_factory_default (const caseless_str&) const;
3031 
3032  virtual octave_value get_defaults (void) const
3033  {
3034  error ("base_graphics_object::get_defaults: invalid graphics object");
3035  return octave_value ();
3036  }
3037 
3038  virtual property_list get_defaults_list (void) const
3039  {
3040  if (! valid_object ())
3041  error ("base_graphics_object::get_defaults_list: invalid graphics object");
3042  return property_list ();
3043  }
3044 
3045  virtual octave_value get_factory_defaults (void) const
3046  {
3047  error ("base_graphics_object::get_factory_defaults: invalid graphics object");
3048  return octave_value ();
3049  }
3050 
3052  {
3053  error ("base_graphics_object::get_factory_defaults_list: invalid graphics object");
3054  return property_list ();
3055  }
3056 
3057  virtual bool has_readonly_property (const caseless_str& pname) const
3058  {
3060  }
3061 
3062  virtual std::string values_as_string (void);
3063 
3064  virtual std::string value_as_string (const std::string& prop);
3065 
3066  virtual octave_scalar_map values_as_struct (void);
3067 
3068  virtual graphics_handle get_parent (void) const
3069  {
3070  if (valid_object ())
3071  return get_properties ().get_parent ();
3072  else
3073  {
3074  error ("base_graphics_object::get_parent: invalid graphics object");
3075  return graphics_handle ();
3076  }
3077  }
3078 
3080  {
3081  if (valid_object ())
3082  return get_properties ().get___myhandle__ ();
3083  else
3084  {
3085  error ("base_graphics_object::get_handle: invalid graphics object");
3086  return graphics_handle ();
3087  }
3088  }
3089 
3090  virtual void remove_child (const graphics_handle& h)
3091  {
3092  if (valid_object ())
3094  else
3095  error ("base_graphics_object::remove_child: invalid graphics object");
3096  }
3097 
3098  virtual void adopt (const graphics_handle& h)
3099  {
3100  if (valid_object ())
3101  get_properties ().adopt (h);
3102  else
3103  error ("base_graphics_object::adopt: invalid graphics object");
3104  }
3105 
3106  virtual void reparent (const graphics_handle& np)
3107  {
3108  if (valid_object ())
3109  get_properties ().reparent (np);
3110  else
3111  error ("base_graphics_object::reparent: invalid graphics object");
3112  }
3113 
3114  virtual void defaults (void) const
3115  {
3116  if (valid_object ())
3117  {
3118  std::string msg = (type () + "::defaults");
3119  gripe_not_implemented (msg.c_str ());
3120  }
3121  else
3122  error ("base_graphics_object::default: invalid graphics object");
3123  }
3124 
3126  {
3127  static base_properties properties;
3128  error ("base_graphics_object::get_properties: invalid graphics object");
3129  return properties;
3130  }
3131 
3132  virtual const base_properties& get_properties (void) const
3133  {
3134  static base_properties properties;
3135  error ("base_graphics_object::get_properties: invalid graphics object");
3136  return properties;
3137  }
3138 
3139  virtual void update_axis_limits (const std::string& axis_type);
3140 
3141  virtual void update_axis_limits (const std::string& axis_type,
3142  const graphics_handle& h);
3143 
3144  virtual bool valid_object (void) const { return false; }
3145 
3146  bool valid_toolkit_object (void) const { return toolkit_flag; }
3147 
3148  virtual std::string type (void) const
3149  {
3150  return (valid_object () ? get_properties ().graphics_object_name ()
3151  : "unknown");
3152  }
3153 
3154  bool isa (const std::string& go_name) const
3155  {
3156  return type () == go_name;
3157  }
3158 
3159  virtual graphics_toolkit get_toolkit (void) const
3160  {
3161  if (valid_object ())
3162  return get_properties ().get_toolkit ();
3163  else
3164  {
3165  error ("base_graphics_object::get_toolkit: invalid graphics object");
3166  return graphics_toolkit ();
3167  }
3168  }
3169 
3170  virtual void add_property_listener (const std::string& nm,
3171  const octave_value& v,
3172  listener_mode mode = POSTSET)
3173  {
3174  if (valid_object ())
3175  get_properties ().add_listener (nm, v, mode);
3176  }
3177 
3178  virtual void delete_property_listener (const std::string& nm,
3179  const octave_value& v,
3180  listener_mode mode = POSTSET)
3181  {
3182  if (valid_object ())
3183  get_properties ().delete_listener (nm, v, mode);
3184  }
3185 
3186  virtual void remove_all_listeners (void);
3187 
3188  virtual void reset_default_properties (void);
3189 
3190 protected:
3191  virtual void initialize (const graphics_object& go)
3192  {
3193  if (! toolkit_flag)
3194  toolkit_flag = get_toolkit ().initialize (go);
3195  }
3196 
3197  virtual void finalize (const graphics_object& go)
3198  {
3199  if (toolkit_flag)
3200  {
3201  get_toolkit ().finalize (go);
3202  toolkit_flag = false;
3203  }
3204  }
3205 
3206  virtual void update (const graphics_object& go, int id)
3207  {
3208  if (toolkit_flag)
3209  get_toolkit ().update (go, id);
3210  }
3211 
3212 protected:
3213  // A reference count.
3215 
3216  // A flag telling whether this object is a valid object
3217  // in the backend context.
3219 
3220  // No copying!
3221 
3223 
3225  {
3226  return *this;
3227  }
3228 };
3229 
3231 {
3232 public:
3233  graphics_object (void) : rep (new base_graphics_object ()) { }
3234 
3236  : rep (new_rep) { }
3237 
3238  graphics_object (const graphics_object& obj) : rep (obj.rep)
3239  {
3240  rep->count++;
3241  }
3242 
3243  graphics_object& operator = (const graphics_object& obj)
3244  {
3245  if (rep != obj.rep)
3246  {
3247  if (--rep->count == 0)
3248  delete rep;
3249 
3250  rep = obj.rep;
3251  rep->count++;
3252  }
3253 
3254  return *this;
3255  }
3256 
3258  {
3259  if (--rep->count == 0)
3260  delete rep;
3261  }
3262 
3263  void mark_modified (void) { rep->mark_modified (); }
3264 
3266  {
3267  rep->override_defaults (obj);
3268  }
3269 
3270  void override_defaults (void)
3271  {
3272  rep->override_defaults (*rep);
3273  }
3274 
3276  const std::string go_name) const
3277  {
3278  rep->build_user_defaults_map (def, go_name);
3279  }
3280 
3281  void set_from_list (property_list& plist) { rep->set_from_list (plist); }
3282 
3283  void set (const caseless_str& name, const octave_value& val)
3284  {
3285  rep->set (name, val);
3286  }
3287 
3288  void set (const octave_value_list& args);
3289 
3290  void set (const Array<std::string>& names, const Cell& values,
3291  octave_idx_type row);
3292 
3293  void set (const octave_map& m);
3294 
3295  void set_value_or_default (const caseless_str& name,
3296  const octave_value& val);
3297 
3298  void set_defaults (const std::string& mode) { rep->set_defaults (mode); }
3299 
3300  octave_value get (bool all = false) const { return rep->get (all); }
3301 
3302  octave_value get (const caseless_str& name) const
3303  {
3304  return name.compare ("default")
3305  ? get_defaults ()
3306  : (name.compare ("factory")
3307  ? get_factory_defaults () : rep->get (name));
3308  }
3309 
3310  octave_value get (const std::string& name) const
3311  {
3312  return get (caseless_str (name));
3313  }
3314 
3315  octave_value get (const char *name) const
3316  {
3317  return get (caseless_str (name));
3318  }
3319 
3321  {
3322  return rep->get_default (name);
3323  }
3324 
3326  {
3327  return rep->get_factory_default (name);
3328  }
3329 
3330  octave_value get_defaults (void) const { return rep->get_defaults (); }
3331 
3333  {
3334  return rep->get_defaults_list ();
3335  }
3336 
3338  {
3339  return rep->get_factory_defaults ();
3340  }
3341 
3343  {
3344  return rep->get_factory_defaults_list ();
3345  }
3346 
3347  bool has_readonly_property (const caseless_str& pname) const
3348  {
3349  return rep->has_readonly_property (pname);
3350  }
3351 
3352  std::string values_as_string (void) { return rep->values_as_string (); }
3353 
3354  std::string value_as_string (const std::string& prop)
3355  {
3356  return rep->value_as_string (prop);
3357  }
3358 
3359  octave_map values_as_struct (void) { return rep->values_as_struct (); }
3360 
3361  graphics_handle get_parent (void) const { return rep->get_parent (); }
3362 
3363  graphics_handle get_handle (void) const { return rep->get_handle (); }
3364 
3365  graphics_object get_ancestor (const std::string& type) const;
3366 
3367  void remove_child (const graphics_handle& h) { rep->remove_child (h); }
3368 
3369  void adopt (const graphics_handle& h) { rep->adopt (h); }
3370 
3371  void reparent (const graphics_handle& h) { rep->reparent (h); }
3372 
3373  void defaults (void) const { rep->defaults (); }
3374 
3375  bool isa (const std::string& go_name) const { return rep->isa (go_name); }
3376 
3377  base_properties& get_properties (void) { return rep->get_properties (); }
3378 
3379  const base_properties& get_properties (void) const
3380  {
3381  return rep->get_properties ();
3382  }
3383 
3384  void update_axis_limits (const std::string& axis_type)
3385  {
3386  rep->update_axis_limits (axis_type);
3387  }
3388 
3389  void update_axis_limits (const std::string& axis_type,
3390  const graphics_handle& h)
3391  {
3392  rep->update_axis_limits (axis_type, h);
3393  }
3394 
3395  bool valid_object (void) const { return rep->valid_object (); }
3396 
3397  std::string type (void) const { return rep->type (); }
3398 
3399  operator bool (void) const { return rep->valid_object (); }
3400 
3401  // FIXME: these functions should be generated automatically by the
3402  // genprops.awk script.
3403  //
3404  // EMIT_GRAPHICS_OBJECT_GET_FUNCTIONS
3405 
3406  octave_value get_alim (void) const
3407  { return get_properties ().get_alim (); }
3408 
3409  octave_value get_clim (void) const
3410  { return get_properties ().get_clim (); }
3411 
3412  octave_value get_xlim (void) const
3413  { return get_properties ().get_xlim (); }
3414 
3415  octave_value get_ylim (void) const
3416  { return get_properties ().get_ylim (); }
3417 
3418  octave_value get_zlim (void) const
3419  { return get_properties ().get_zlim (); }
3420 
3421  bool is_aliminclude (void) const
3422  { return get_properties ().is_aliminclude (); }
3423 
3424  bool is_climinclude (void) const
3425  { return get_properties ().is_climinclude (); }
3426 
3427  bool is_xliminclude (void) const
3428  { return get_properties ().is_xliminclude (); }
3429 
3430  bool is_yliminclude (void) const
3431  { return get_properties ().is_yliminclude (); }
3432 
3433  bool is_zliminclude (void) const
3434  { return get_properties ().is_zliminclude (); }
3435 
3436  bool is_handle_visible (void) const
3437  { return get_properties ().is_handle_visible (); }
3438 
3439  graphics_toolkit get_toolkit (void) const { return rep->get_toolkit (); }
3440 
3441  void add_property_listener (const std::string& nm, const octave_value& v,
3442  listener_mode mode = POSTSET)
3443  { rep->add_property_listener (nm, v, mode); }
3444 
3445  void delete_property_listener (const std::string& nm, const octave_value& v,
3446  listener_mode mode = POSTSET)
3447  { rep->delete_property_listener (nm, v, mode); }
3448 
3449  void initialize (void) { rep->initialize (*this); }
3450 
3451  void finalize (void) { rep->finalize (*this); }
3452 
3453  void update (int id) { rep->update (*this, id); }
3454 
3456  { rep->reset_default_properties (); }
3457 
3458 private:
3460 };
3461 
3462 // ---------------------------------------------------------------------
3463 
3465 {
3466 public:
3468  {
3469  public:
3470  void remove_child (const graphics_handle& h);
3471 
3472  Matrix get_boundingbox (bool internal = false,
3473  const Matrix& parent_pix_size = Matrix ()) const;
3474 
3475  // See the genprops.awk script for an explanation of the
3476  // properties declarations.
3477 
3478  // FIXME: Properties that still dont have callbacks are:
3479  // language, monitorpositions, pointerlocation, pointerwindow.
3480  // Note that these properties are not yet used by Octave, so setting
3481  // them will have no effect.
3482 
3483  // Programming note: Keep property list sorted if new ones are added.
3484 
3485 public:
3486  properties (const graphics_handle& mh, const graphics_handle& p);
3487 
3488  ~properties (void) { }
3489 
3490  void set (const caseless_str& pname, const octave_value& val);
3491 
3492  octave_value get (bool all = false) const;
3493 
3494  octave_value get (const caseless_str& pname) const;
3495 
3496  octave_value get (const std::string& pname) const
3497  {
3498  return get (caseless_str (pname));
3499  }
3500 
3501  octave_value get (const char *pname) const
3502  {
3503  return get (caseless_str (pname));
3504  }
3505 
3506  property get_property (const caseless_str& pname);
3507 
3508  std::string graphics_object_name (void) const { return go_name; }
3509 
3511 
3512 private:
3513  static std::string go_name;
3514 
3515 public:
3516 
3517 
3518  static std::set<std::string> core_property_names (void);
3519 
3520  static std::set<std::string> readonly_property_names (void);
3521 
3522  static bool has_core_property (const caseless_str& pname);
3523 
3524  static bool has_readonly_property (const caseless_str& pname);
3525 
3526  std::set<std::string> all_property_names (void) const;
3527 
3528  bool has_property (const caseless_str& pname) const;
3529 
3530 private:
3531 
3552 
3553 public:
3554 
3555  enum
3556  {
3557  ID_CALLBACKOBJECT = 1000,
3558  ID_COMMANDWINDOWSIZE = 1001,
3559  ID_CURRENTFIGURE = 1002,
3560  ID_DIARY = 1003,
3561  ID_DIARYFILE = 1004,
3562  ID_ECHO = 1005,
3563  ID_ERRORMESSAGE = 1006,
3564  ID_FIXEDWIDTHFONTNAME = 1007,
3565  ID_FORMAT = 1008,
3566  ID_FORMATSPACING = 1009,
3567  ID_LANGUAGE = 1010,
3568  ID_MONITORPOSITIONS = 1011,
3569  ID_POINTERLOCATION = 1012,
3570  ID_POINTERWINDOW = 1013,
3571  ID_RECURSIONLIMIT = 1014,
3572  ID_SCREENDEPTH = 1015,
3573  ID_SCREENPIXELSPERINCH = 1016,
3574  ID_SCREENSIZE = 1017,
3575  ID_SHOWHIDDENHANDLES = 1018,
3576  ID_UNITS = 1019
3577  };
3578 
3579  graphics_handle get_callbackobject (void) const { return callbackobject.handle_value (); }
3580 
3581  octave_value get_commandwindowsize (void) const { return commandwindowsize.get (); }
3582 
3583  graphics_handle get_currentfigure (void) const { return currentfigure.handle_value (); }
3584 
3585  bool is_diary (void) const;
3586  std::string get_diary (void) const;
3587 
3588  std::string get_diaryfile (void) const;
3589 
3590  bool is_echo (void) const;
3591  std::string get_echo (void) const;
3592 
3593  std::string get_errormessage (void) const;
3594 
3595  std::string get_fixedwidthfontname (void) const { return fixedwidthfontname.string_value (); }
3596 
3597  bool format_is (const std::string& v) const;
3598  std::string get_format (void) const;
3599 
3600  bool formatspacing_is (const std::string& v) const;
3601  std::string get_formatspacing (void) const;
3602 
3603  std::string get_language (void) const { return language.string_value (); }
3604 
3605  octave_value get_monitorpositions (void) const { return monitorpositions.get (); }
3606 
3607  octave_value get_pointerlocation (void) const { return pointerlocation.get (); }
3608 
3609  double get_pointerwindow (void) const { return pointerwindow.double_value (); }
3610 
3611  double get_recursionlimit (void) const;
3612 
3613  double get_screendepth (void) const { return screendepth.double_value (); }
3614 
3615  double get_screenpixelsperinch (void) const { return screenpixelsperinch.double_value (); }
3616 
3617  octave_value get_screensize (void) const { return screensize.get (); }
3618 
3619  bool is_showhiddenhandles (void) const { return showhiddenhandles.is_on (); }
3620  std::string get_showhiddenhandles (void) const { return showhiddenhandles.current_value (); }
3621 
3622  bool units_is (const std::string& v) const { return units.is (v); }
3623  std::string get_units (void) const { return units.current_value (); }
3624 
3625 
3626  void set_callbackobject (const octave_value& val);
3627 
3629  {
3630  if (! error_state)
3631  {
3632  if (commandwindowsize.set (val, true))
3633  {
3634  mark_modified ();
3635  }
3636  }
3637  }
3638 
3639  void set_currentfigure (const octave_value& val);
3640 
3641  void set_diary (const octave_value& val);
3642 
3643  void set_diaryfile (const octave_value& val);
3644 
3645  void set_echo (const octave_value& val);
3646 
3647  void set_errormessage (const octave_value& val)
3648  {
3649  if (! error_state)
3650  {
3651  if (errormessage.set (val, true))
3652  {
3653  mark_modified ();
3654  }
3655  }
3656  }
3657 
3659  {
3660  if (! error_state)
3661  {
3662  if (fixedwidthfontname.set (val, true))
3663  {
3664  mark_modified ();
3665  }
3666  }
3667  }
3668 
3669  void set_format (const octave_value& val);
3670 
3671  void set_formatspacing (const octave_value& val);
3672 
3673  void set_language (const octave_value& val)
3674  {
3675  if (! error_state)
3676  {
3677  if (language.set (val, true))
3678  {
3679  mark_modified ();
3680  }
3681  }
3682  }
3683 
3685  {
3686  if (! error_state)
3687  {
3688  if (monitorpositions.set (val, true))
3689  {
3690  mark_modified ();
3691  }
3692  }
3693  }
3694 
3696  {
3697  if (! error_state)
3698  {
3699  if (pointerlocation.set (val, true))
3700  {
3701  mark_modified ();
3702  }
3703  }
3704  }
3705 
3707  {
3708  if (! error_state)
3709  {
3710  if (pointerwindow.set (val, true))
3711  {
3712  mark_modified ();
3713  }
3714  }
3715  }
3716 
3717  void set_recursionlimit (const octave_value& val);
3718 
3719  void set_screendepth (const octave_value& val)
3720  {
3721  if (! error_state)
3722  {
3723  if (screendepth.set (val, true))
3724  {
3725  mark_modified ();
3726  }
3727  }
3728  }
3729 
3731  {
3732  if (! error_state)
3733  {
3734  if (screenpixelsperinch.set (val, true))
3735  {
3736  mark_modified ();
3737  }
3738  }
3739  }
3740 
3741  void set_screensize (const octave_value& val)
3742  {
3743  if (! error_state)
3744  {
3745  if (screensize.set (val, true))
3746  {
3747  mark_modified ();
3748  }
3749  }
3750  }
3751 
3753  {
3754  if (! error_state)
3755  {
3756  if (showhiddenhandles.set (val, true))
3757  {
3758  mark_modified ();
3759  }
3760  }
3761  }
3762 
3763  void set_units (const octave_value& val)
3764  {
3765  if (! error_state)
3766  {
3767  if (units.set (val, true))
3768  {
3769  update_units ();
3770  mark_modified ();
3771  }
3772  }
3773  }
3774 
3775  void update_units (void);
3776 
3777 
3778  private:
3779  std::list<graphics_handle> cbo_stack;
3780 
3781  };
3782 
3783 private:
3785 
3786 public:
3787 
3789  : xproperties (0, graphics_handle ()), default_properties () { }
3790 
3791  ~root_figure (void) { }
3792 
3793  void mark_modified (void) { }
3794 
3796  {
3797  // Now override with our defaults. If the default_properties
3798  // list includes the properties for all defaults (line,
3799  // surface, etc.) then we don't have to know the type of OBJ
3800  // here, we just call its set function and let it decide which
3801  // properties from the list to use.
3802  obj.set_from_list (default_properties);
3803  }
3804 
3805  void set (const caseless_str& name, const octave_value& value)
3806  {
3807  if (name.compare ("default", 7))
3808  // strip "default", pass rest to function that will
3809  // parse the remainder and add the element to the
3810  // default_properties map.
3811  default_properties.set (name.substr (7), value);
3812  else
3813  xproperties.set (name, value);
3814  }
3815 
3816  octave_value get (const caseless_str& name) const
3817  {
3818  octave_value retval;
3819 
3820  if (name.compare ("default", 7))
3821  return get_default (name.substr (7));
3822  else if (name.compare ("factory", 7))
3823  return get_factory_default (name.substr (7));
3824  else
3825  retval = xproperties.get (name);
3826 
3827  return retval;
3828  }
3829 
3831  {
3832  octave_value retval = default_properties.lookup (name);
3833 
3834  if (retval.is_undefined ())
3835  {
3836  // no default property found, use factory default
3837  retval = factory_properties.lookup (name);
3838 
3839  if (retval.is_undefined ())
3840  error ("get: invalid default property '%s'", name.c_str ());
3841  }
3842 
3843  return retval;
3844  }
3845 
3847  {
3848  octave_value retval = factory_properties.lookup (name);
3849 
3850  if (retval.is_undefined ())
3851  error ("get: invalid factory default property '%s'", name.c_str ());
3852 
3853  return retval;
3854  }
3855 
3857  {
3858  return default_properties.as_struct ("default");
3859  }
3860 
3862  {
3863  return default_properties;
3864  }
3865 
3867  {
3868  return factory_properties.as_struct ("factory");
3869  }
3870 
3872  {
3873  return factory_properties;
3874  }
3875 
3876  base_properties& get_properties (void) { return xproperties; }
3877 
3878  const base_properties& get_properties (void) const { return xproperties; }
3879 
3880  bool valid_object (void) const { return true; }
3881 
3882  void reset_default_properties (void);
3883 
3884  bool has_readonly_property (const caseless_str& pname) const
3885  {
3886  bool retval = xproperties.has_readonly_property (pname);
3887  if (! retval)
3888  retval = base_properties::has_readonly_property (pname);
3889  return retval;
3890  }
3891 
3892 private:
3894 
3896 
3897  static property_list::plist_map_type init_factory_properties (void);
3898 };
3899 
3900 // ---------------------------------------------------------------------
3901 
3903 {
3904 public:
3906  {
3907  public:
3909  {
3910  integerhandle = val;
3911  }
3912 
3913  void remove_child (const graphics_handle& h);
3914 
3915  void set_visible (const octave_value& val);
3916 
3918  {
3919  if (! toolkit)
3920  toolkit = gtk_manager::get_toolkit ();
3921 
3922  return toolkit;
3923  }
3924 
3925  void set_toolkit (const graphics_toolkit& b);
3926 
3928  {
3929  if (! error_state)
3930  {
3931  if (val.is_string ())
3932  {
3933  std::string nm = val.string_value ();
3935  if (b.get_name () != nm)
3936  {
3937  error ("set___graphics_toolkit__: invalid graphics toolkit");
3938  }
3939  else
3940  {
3941  if (nm != get___graphics_toolkit__ ())
3942  {
3943  set_toolkit (b);
3944  mark_modified ();
3945  }
3946  }
3947  }
3948  else
3949  error ("set___graphics_toolkit__ must be a string");
3950  }
3951  }
3952 
3953  void adopt (const graphics_handle& h);
3954 
3955  void set_position (const octave_value& val,
3956  bool do_notify_toolkit = true);
3957 
3958  void set_outerposition (const octave_value& val,
3959  bool do_notify_toolkit = true);
3960 
3961  Matrix get_boundingbox (bool internal = false,
3962  const Matrix& parent_pix_size = Matrix ()) const;
3963 
3964  void set_boundingbox (const Matrix& bb, bool internal = false,
3965  bool do_notify_toolkit = true);
3966 
3967  Matrix map_from_boundingbox (double x, double y) const;
3968 
3969  Matrix map_to_boundingbox (double x, double y) const;
3970 
3971  void update_units (const caseless_str& old_units);
3972 
3973  void update_paperunits (const caseless_str& old_paperunits);
3974 
3975  std::string get_title (void) const;
3976 
3977  // See the genprops.awk script for an explanation of the
3978  // properties declarations.
3979  // Programming note: Keep property list sorted if new ones are added.
3980 
3981 public:
3982  properties (const graphics_handle& mh, const graphics_handle& p);
3983 
3984  ~properties (void) { }
3985 
3986  void set (const caseless_str& pname, const octave_value& val);
3987 
3988  octave_value get (bool all = false) const;
3989 
3990  octave_value get (const caseless_str& pname) const;
3991 
3992  octave_value get (const std::string& pname) const
3993  {
3994  return get (caseless_str (pname));
3995  }
3996 
3997  octave_value get (const char *pname) const
3998  {
3999  return get (caseless_str (pname));
4000  }
4001 
4002  property get_property (const caseless_str& pname);
4003 
4004  std::string graphics_object_name (void) const { return go_name; }
4005 
4007 
4008 private:
4009  static std::string go_name;
4010 
4011 public:
4012 
4013 
4014  static std::set<std::string> core_property_names (void);
4015 
4016  static std::set<std::string> readonly_property_names (void);
4017 
4018  static bool has_core_property (const caseless_str& pname);
4019 
4020  static bool has_readonly_property (const caseless_str& pname);
4021 
4022  std::set<std::string> all_property_names (void) const;
4023 
4024  bool has_property (const caseless_str& pname) const;
4025 
4026 private:
4027 
4087 
4088 public:
4089 
4090  enum
4091  {
4092  ID_ALPHAMAP = 2000,
4093  ID_BUTTONDOWNFCN = 2001,
4094  ID_CLOSEREQUESTFCN = 2002,
4095  ID_COLOR = 2003,
4096  ID_COLORMAP = 2004,
4097  ID_CURRENTAXES = 2005,
4098  ID_CURRENTCHARACTER = 2006,
4099  ID_CURRENTOBJECT = 2007,
4100  ID_CURRENTPOINT = 2008,
4101  ID_DOCKCONTROLS = 2009,
4102  ID_DOUBLEBUFFER = 2010,
4103  ID_FILENAME = 2011,
4104  ID_INTEGERHANDLE = 2012,
4105  ID_INVERTHARDCOPY = 2013,
4106  ID_KEYPRESSFCN = 2014,
4107  ID_KEYRELEASEFCN = 2015,
4108  ID_MENUBAR = 2016,
4109  ID_MINCOLORMAP = 2017,
4110  ID_NAME = 2018,
4111  ID_NEXTPLOT = 2019,
4112  ID_NUMBERTITLE = 2020,
4113  ID_OUTERPOSITION = 2021,
4114  ID_PAPERORIENTATION = 2022,
4115  ID_PAPERPOSITION = 2023,
4116  ID_PAPERPOSITIONMODE = 2024,
4117  ID_PAPERSIZE = 2025,
4118  ID_PAPERTYPE = 2026,
4119  ID_PAPERUNITS = 2027,
4120  ID_POINTER = 2028,
4121  ID_POINTERSHAPECDATA = 2029,
4122  ID_POINTERSHAPEHOTSPOT = 2030,
4123  ID_POSITION = 2031,
4124  ID_RENDERER = 2032,
4125  ID_RENDERERMODE = 2033,
4126  ID_RESIZE = 2034,
4127  ID_RESIZEFCN = 2035,
4128  ID_SELECTIONTYPE = 2036,
4129  ID_TOOLBAR = 2037,
4130  ID_UNITS = 2038,
4131  ID_WINDOWBUTTONDOWNFCN = 2039,
4132  ID_WINDOWBUTTONMOTIONFCN = 2040,
4133  ID_WINDOWBUTTONUPFCN = 2041,
4134  ID_WINDOWKEYPRESSFCN = 2042,
4135  ID_WINDOWKEYRELEASEFCN = 2043,
4136  ID_WINDOWSCROLLWHEELFCN = 2044,
4137  ID_WINDOWSTYLE = 2045,
4138  ID_WVISUAL = 2046,
4139  ID_WVISUALMODE = 2047,
4140  ID_XDISPLAY = 2048,
4141  ID_XVISUAL = 2049,
4142  ID_XVISUALMODE = 2050,
4143  ID___MOUSE_MODE__ = 2051,
4144  ID___PAN_MODE__ = 2052,
4145  ID___ROTATE_MODE__ = 2053,
4146  ID___ZOOM_MODE__ = 2054,
4147  ID___ENHANCED__ = 2055,
4148  ID___GRAPHICS_TOOLKIT__ = 2056,
4149  ID___GUIDATA__ = 2057,
4150  ID___PLOT_STREAM__ = 2058
4151  };
4152 
4153  octave_value get_alphamap (void) const { return alphamap.get (); }
4154 
4155  void execute_buttondownfcn (const octave_value& data = octave_value ()) const { buttondownfcn.execute (data); }
4156  octave_value get_buttondownfcn (void) const { return buttondownfcn.get (); }
4157 
4158  void execute_closerequestfcn (const octave_value& data = octave_value ()) const { closerequestfcn.execute (data); }
4159  octave_value get_closerequestfcn (void) const { return closerequestfcn.get (); }
4160 
4161  bool color_is_rgb (void) const { return color.is_rgb (); }
4162  bool color_is (const std::string& v) const { return color.is (v); }
4163  Matrix get_color_rgb (void) const { return (color.is_rgb () ? color.rgb () : Matrix ()); }
4164  octave_value get_color (void) const { return color.get (); }
4165 
4166  octave_value get_colormap (void) const { return colormap.get (); }
4167 
4168  graphics_handle get_currentaxes (void) const { return currentaxes.handle_value (); }
4169 
4170  std::string get_currentcharacter (void) const { return currentcharacter.string_value (); }
4171 
4172  graphics_handle get_currentobject (void) const { return currentobject.handle_value (); }
4173 
4174  octave_value get_currentpoint (void) const { return currentpoint.get (); }
4175 
4176  bool is_dockcontrols (void) const { return dockcontrols.is_on (); }
4177  std::string get_dockcontrols (void) const { return dockcontrols.current_value (); }
4178 
4179  bool is_doublebuffer (void) const { return doublebuffer.is_on (); }
4180  std::string get_doublebuffer (void) const { return doublebuffer.current_value (); }
4181 
4182  std::string get_filename (void) const { return filename.string_value (); }
4183 
4184  bool is_integerhandle (void) const { return integerhandle.is_on (); }
4185  std::string get_integerhandle (void) const { return integerhandle.current_value (); }
4186 
4187  bool is_inverthardcopy (void) const { return inverthardcopy.is_on (); }
4188  std::string get_inverthardcopy (void) const { return inverthardcopy.current_value (); }
4189 
4190  void execute_keypressfcn (const octave_value& data = octave_value ()) const { keypressfcn.execute (data); }
4191  octave_value get_keypressfcn (void) const { return keypressfcn.get (); }
4192 
4193  void execute_keyreleasefcn (const octave_value& data = octave_value ()) const { keyreleasefcn.execute (data); }
4194  octave_value get_keyreleasefcn (void) const { return keyreleasefcn.get (); }
4195 
4196  bool menubar_is (const std::string& v) const { return menubar.is (v); }
4197  std::string get_menubar (void) const { return menubar.current_value (); }
4198 
4199  double get_mincolormap (void) const { return mincolormap.double_value (); }
4200 
4201  std::string get_name (void) const { return name.string_value (); }
4202 
4203  bool nextplot_is (const std::string& v) const { return nextplot.is (v); }
4204  std::string get_nextplot (void) const { return nextplot.current_value (); }
4205 
4206  bool is_numbertitle (void) const { return numbertitle.is_on (); }
4207  std::string get_numbertitle (void) const { return numbertitle.current_value (); }
4208 
4209  octave_value get_outerposition (void) const { return outerposition.get (); }
4210 
4211  bool paperorientation_is (const std::string& v) const { return paperorientation.is (v); }
4212  std::string get_paperorientation (void) const { return paperorientation.current_value (); }
4213 
4214  octave_value get_paperposition (void) const { return paperposition.get (); }
4215 
4216  bool paperpositionmode_is (const std::string& v) const { return paperpositionmode.is (v); }
4217  std::string get_paperpositionmode (void) const { return paperpositionmode.current_value (); }
4218 
4219  octave_value get_papersize (void) const { return papersize.get (); }
4220 
4221  bool papertype_is (const std::string& v) const { return papertype.is (v); }
4222  std::string get_papertype (void) const { return papertype.current_value (); }
4223 
4224  bool paperunits_is (const std::string& v) const { return paperunits.is (v); }
4225  std::string get_paperunits (void) const { return paperunits.current_value (); }
4226 
4227  bool pointer_is (const std::string& v) const { return pointer.is (v); }
4228  std::string get_pointer (void) const { return pointer.current_value (); }
4229 
4230  octave_value get_pointershapecdata (void) const { return pointershapecdata.get (); }
4231 
4232  octave_value get_pointershapehotspot (void) const { return pointershapehotspot.get (); }
4233 
4234  octave_value get_position (void) const { return position.get (); }
4235 
4236  bool renderer_is (const std::string& v) const { return renderer.is (v); }
4237  std::string get_renderer (void) const { return renderer.current_value (); }
4238 
4239  bool renderermode_is (const std::string& v) const { return renderermode.is (v); }
4240  std::string get_renderermode (void) const { return renderermode.current_value (); }
4241 
4242  bool is_resize (void) const { return resize.is_on (); }
4243  std::string get_resize (void) const { return resize.current_value (); }
4244 
4245  void execute_resizefcn (const octave_value& data = octave_value ()) const { resizefcn.execute (data); }
4246  octave_value get_resizefcn (void) const { return resizefcn.get (); }
4247 
4248  bool selectiontype_is (const std::string& v) const { return selectiontype.is (v); }
4249  std::string get_selectiontype (void) const { return selectiontype.current_value (); }
4250 
4251  bool toolbar_is (const std::string& v) const { return toolbar.is (v); }
4252  std::string get_toolbar (void) const { return toolbar.current_value (); }
4253 
4254  bool units_is (const std::string& v) const { return units.is (v); }
4255  std::string get_units (void) const { return units.current_value (); }
4256 
4257  void execute_windowbuttondownfcn (const octave_value& data = octave_value ()) const { windowbuttondownfcn.execute (data); }
4258  octave_value get_windowbuttondownfcn (void) const { return windowbuttondownfcn.get (); }
4259 
4260  void execute_windowbuttonmotionfcn (const octave_value& data = octave_value ()) const { windowbuttonmotionfcn.execute (data); }
4261  octave_value get_windowbuttonmotionfcn (void) const { return windowbuttonmotionfcn.get (); }
4262 
4263  void execute_windowbuttonupfcn (const octave_value& data = octave_value ()) const { windowbuttonupfcn.execute (data); }
4264  octave_value get_windowbuttonupfcn (void) const { return windowbuttonupfcn.get (); }
4265 
4266  void execute_windowkeypressfcn (const octave_value& data = octave_value ()) const { windowkeypressfcn.execute (data); }
4267  octave_value get_windowkeypressfcn (void) const { return windowkeypressfcn.get (); }
4268 
4269  void execute_windowkeyreleasefcn (const octave_value& data = octave_value ()) const { windowkeyreleasefcn.execute (data); }
4270  octave_value get_windowkeyreleasefcn (void) const { return windowkeyreleasefcn.get (); }
4271 
4272  void execute_windowscrollwheelfcn (const octave_value& data = octave_value ()) const { windowscrollwheelfcn.execute (data); }
4273  octave_value get_windowscrollwheelfcn (void) const { return windowscrollwheelfcn.get (); }
4274 
4275  bool windowstyle_is (const std::string& v) const { return windowstyle.is (v); }
4276  std::string get_windowstyle (void) const { return windowstyle.current_value (); }
4277 
4278  std::string get_wvisual (void) const { return wvisual.string_value (); }
4279 
4280  bool wvisualmode_is (const std::string& v) const { return wvisualmode.is (v); }
4281  std::string get_wvisualmode (void) const { return wvisualmode.current_value (); }
4282 
4283  std::string get_xdisplay (void) const { return xdisplay.string_value (); }
4284 
4285  std::string get_xvisual (void) const { return xvisual.string_value (); }
4286 
4287  bool xvisualmode_is (const std::string& v) const { return xvisualmode.is (v); }
4288  std::string get_xvisualmode (void) const { return xvisualmode.current_value (); }
4289 
4290  bool __mouse_mode___is (const std::string& v) const { return __mouse_mode__.is (v); }
4291  std::string get___mouse_mode__ (void) const { return __mouse_mode__.current_value (); }
4292 
4293  octave_value get___pan_mode__ (void) const { return __pan_mode__.get (); }
4294 
4295  octave_value get___rotate_mode__ (void) const { return __rotate_mode__.get (); }
4296 
4297  octave_value get___zoom_mode__ (void) const { return __zoom_mode__.get (); }
4298 
4299  bool is___enhanced__ (void) const { return __enhanced__.is_on (); }
4300  std::string get___enhanced__ (void) const { return __enhanced__.current_value (); }
4301 
4302  std::string get___graphics_toolkit__ (void) const { return __graphics_toolkit__.string_value (); }
4303 
4304  octave_value get___guidata__ (void) const { return __guidata__.get (); }
4305 
4306  octave_value get___plot_stream__ (void) const { return __plot_stream__.get (); }
4307 
4308 
4309  void set_alphamap (const octave_value& val)
4310  {
4311  if (! error_state)
4312  {
4313  if (alphamap.set (val, true))
4314  {
4315  mark_modified ();
4316  }
4317  }
4318  }
4319 
4321  {
4322  if (! error_state)
4323  {
4324  if (buttondownfcn.set (val, true))
4325  {
4326  mark_modified ();
4327  }
4328  }
4329  }
4330 
4332  {
4333  if (! error_state)
4334  {
4335  if (closerequestfcn.set (val, true))
4336  {
4337  mark_modified ();
4338  }
4339  }
4340  }
4341 
4342  void set_color (const octave_value& val)
4343  {
4344  if (! error_state)
4345  {
4346  if (color.set (val, true))
4347  {
4348  mark_modified ();
4349  }
4350  }
4351  }
4352 
4353  void set_colormap (const octave_value& val)
4354  {
4355  if (! error_state)
4356  {
4357  if (colormap.set (val, true))
4358  {
4359  mark_modified ();
4360  }
4361  }
4362  }
4363 
4364  void set_currentaxes (const octave_value& val);
4365 
4367  {
4368  if (! error_state)
4369  {
4370  if (currentcharacter.set (val, true))
4371  {
4372  mark_modified ();
4373  }
4374  }
4375  }
4376 
4378  {
4379  if (! error_state)
4380  {
4381  if (currentobject.set (val, true))
4382  {
4383  mark_modified ();
4384  }
4385  }
4386  }
4387 
4388  void set_currentpoint (const octave_value& val)
4389  {
4390  if (! error_state)
4391  {
4392  if (currentpoint.set (val, true))
4393  {
4394  mark_modified ();
4395  }
4396  }
4397  }
4398 
4399  void set_dockcontrols (const octave_value& val)
4400  {
4401  if (! error_state)
4402  {
4403  if (dockcontrols.set (val, true))
4404  {
4405  mark_modified ();
4406  }
4407  }
4408  }
4409 
4410  void set_doublebuffer (const octave_value& val)
4411  {
4412  if (! error_state)
4413  {
4414  if (doublebuffer.set (val, true))
4415  {
4416  mark_modified ();
4417  }
4418  }
4419  }
4420 
4421  void set_filename (const octave_value& val)
4422  {
4423  if (! error_state)
4424  {
4425  if (filename.set (val, true))
4426  {
4427  mark_modified ();
4428  }
4429  }
4430  }
4431 
4432  void set_integerhandle (const octave_value& val);
4433 
4435  {
4436  if (! error_state)
4437  {
4438  if (inverthardcopy.set (val, true))
4439  {
4440  mark_modified ();
4441  }
4442  }
4443  }
4444 
4445  void set_keypressfcn (const octave_value& val)
4446  {
4447  if (! error_state)
4448  {
4449  if (keypressfcn.set (val, true))
4450  {
4451  mark_modified ();
4452  }
4453  }
4454  }
4455 
4457  {
4458  if (! error_state)
4459  {
4460  if (keyreleasefcn.set (val, true))
4461  {
4462  mark_modified ();
4463  }
4464  }
4465  }
4466 
4467  void set_menubar (const octave_value& val)
4468  {
4469  if (! error_state)
4470  {
4471  if (menubar.set (val, true))
4472  {
4473  mark_modified ();
4474  }
4475  }
4476  }
4477 
4478  void set_mincolormap (const octave_value& val)
4479  {
4480  if (! error_state)
4481  {
4482  if (mincolormap.set (val, true))
4483  {
4484  mark_modified ();
4485  }
4486  }
4487  }
4488 
4489  void set_name (const octave_value& val)
4490  {
4491  if (! error_state)
4492  {
4493  if (name.set (val, true))
4494  {
4495  mark_modified ();
4496  }
4497  }
4498  }
4499 
4500  void set_nextplot (const octave_value& val)
4501  {
4502  if (! error_state)
4503  {
4504  if (nextplot.set (val, true))
4505  {
4506  mark_modified ();
4507  }
4508  }
4509  }
4510 
4511  void set_numbertitle (const octave_value& val)
4512  {
4513  if (! error_state)
4514  {
4515  if (numbertitle.set (val, true))
4516  {
4517  mark_modified ();
4518  }
4519  }
4520  }
4521 
4523  {
4524  if (! error_state)
4525  {
4526  if (paperorientation.set (val, true))
4527  {
4528  update_paperorientation ();
4529  mark_modified ();
4530  }
4531  }
4532  }
4533 
4534  void update_paperorientation (void);
4535 
4537  {
4538  if (! error_state)
4539  {
4540  if (paperposition.set (val, false))
4541  {
4542  set_paperpositionmode ("manual");
4543  paperposition.run_listeners (POSTSET);
4544  mark_modified ();
4545  }
4546  else
4547  set_paperpositionmode ("manual");
4548  }
4549  }
4550 
4552  {
4553  if (! error_state)
4554  {
4555  if (paperpositionmode.set (val, true))
4556  {
4557  update_paperpositionmode ();
4558  mark_modified ();
4559  }
4560  }
4561  }
4562 
4563  void set_papersize (const octave_value& val)
4564  {
4565  if (! error_state)
4566  {
4567  if (papersize.set (val, true))
4568  {
4569  update_papersize ();
4570  mark_modified ();
4571  }
4572  }
4573  }
4574 
4575  void update_papersize (void);
4576 
4577  void set_papertype (const octave_value& val);
4578 
4579  void update_papertype (void);
4580 
4581  void set_paperunits (const octave_value& val);
4582 
4583  void set_pointer (const octave_value& val)
4584  {
4585  if (! error_state)
4586  {
4587  if (pointer.set (val, true))
4588  {
4589  mark_modified ();
4590  }
4591  }
4592  }
4593 
4595  {
4596  if (! error_state)
4597  {
4598  if (pointershapecdata.set (val, true))
4599  {
4600  mark_modified ();
4601  }
4602  }
4603  }
4604 
4606  {
4607  if (! error_state)
4608  {
4609  if (pointershapehotspot.set (val, true))
4610  {
4611  mark_modified ();
4612  }
4613  }
4614  }
4615 
4616  void set_renderer (const octave_value& val)
4617  {
4618  if (! error_state)
4619  {
4620  if (renderer.set (val, true))
4621  {
4622  mark_modified ();
4623  }
4624  }
4625  }
4626 
4627  void set_renderermode (const octave_value& val)
4628  {
4629  if (! error_state)
4630  {
4631  if (renderermode.set (val, true))
4632  {
4633  mark_modified ();
4634  }
4635  }
4636  }
4637 
4638  void set_resize (const octave_value& val)
4639  {
4640  if (! error_state)
4641  {
4642  if (resize.set (val, true))
4643  {
4644  mark_modified ();
4645  }
4646  }
4647  }
4648 
4649  void set_resizefcn (const octave_value& val)
4650  {
4651  if (! error_state)
4652  {
4653  if (resizefcn.set (val, true))
4654  {
4655  mark_modified ();
4656  }
4657  }
4658  }
4659 
4661  {
4662  if (! error_state)
4663  {
4664  if (selectiontype.set (val, true))
4665  {
4666  mark_modified ();
4667  }
4668  }
4669  }
4670 
4671  void set_toolbar (const octave_value& val)
4672  {
4673  if (! error_state)
4674  {
4675  if (toolbar.set (val, true))
4676  {
4677  mark_modified ();
4678  }
4679  }
4680  }
4681 
4682  void set_units (const octave_value& val);
4683 
4685  {
4686  if (! error_state)
4687  {
4688  if (windowbuttondownfcn.set (val, true))
4689  {
4690  mark_modified ();
4691  }
4692  }
4693  }
4694 
4696  {
4697  if (! error_state)
4698  {
4699  if (windowbuttonmotionfcn.set (val, true))
4700  {
4701  mark_modified ();
4702  }
4703  }
4704  }
4705 
4707  {
4708  if (! error_state)
4709  {
4710  if (windowbuttonupfcn.set (val, true))
4711  {
4712  mark_modified ();
4713  }
4714  }
4715  }
4716 
4718  {
4719  if (! error_state)
4720  {
4721  if (windowkeypressfcn.set (val, true))
4722  {
4723  mark_modified ();
4724  }
4725  }
4726  }
4727 
4729  {
4730  if (! error_state)
4731  {
4732  if (windowkeyreleasefcn.set (val, true))
4733  {
4734  mark_modified ();
4735  }
4736  }
4737  }
4738 
4740  {
4741  if (! error_state)
4742  {
4743  if (windowscrollwheelfcn.set (val, true))
4744  {
4745  mark_modified ();
4746  }
4747  }
4748  }
4749 
4750  void set_windowstyle (const octave_value& val)
4751  {
4752  if (! error_state)
4753  {
4754  if (windowstyle.set (val, true))
4755  {
4756  mark_modified ();
4757  }
4758  }
4759  }
4760 
4761  void set_wvisual (const octave_value& val)
4762  {
4763  if (! error_state)
4764  {
4765  if (wvisual.set (val, true))
4766  {
4767  mark_modified ();
4768  }
4769  }
4770  }
4771 
4772  void set_wvisualmode (const octave_value& val)
4773  {
4774  if (! error_state)
4775  {
4776  if (wvisualmode.set (val, true))
4777  {
4778  mark_modified ();
4779  }
4780  }
4781  }
4782 
4783  void set_xdisplay (const octave_value& val)
4784  {
4785  if (! error_state)
4786  {
4787  if (xdisplay.set (val, true))
4788  {
4789  mark_modified ();
4790  }
4791  }
4792  }
4793 
4794  void set_xvisual (const octave_value& val)
4795  {
4796  if (! error_state)
4797  {
4798  if (xvisual.set (val, true))
4799  {
4800  mark_modified ();
4801  }
4802  }
4803  }
4804 
4805  void set_xvisualmode (const octave_value& val)
4806  {
4807  if (! error_state)
4808  {
4809  if (xvisualmode.set (val, true))
4810  {
4811  mark_modified ();
4812  }
4813  }
4814  }
4815 
4816  void set___mouse_mode__ (const octave_value& val);
4817 
4818  void set___pan_mode__ (const octave_value& val)
4819  {
4820  if (! error_state)
4821  {
4822  if (__pan_mode__.set (val, true))
4823  {
4824  mark_modified ();
4825  }
4826  }
4827  }
4828 
4830  {
4831  if (! error_state)
4832  {
4833  if (__rotate_mode__.set (val, true))
4834  {
4835  mark_modified ();
4836  }
4837  }
4838  }
4839 
4841  {
4842  if (! error_state)
4843  {
4844  if (__zoom_mode__.set (val, true))
4845  {
4846  mark_modified ();
4847  }
4848  }
4849  }
4850 
4851  void set___enhanced__ (const octave_value& val)
4852  {
4853  if (! error_state)
4854  {
4855  if (__enhanced__.set (val, true))
4856  {
4857  mark_modified ();
4858  }
4859  }
4860  }
4861 
4862  void set___guidata__ (const octave_value& val)
4863  {
4864  if (! error_state)
4865  {
4866  if (__guidata__.set (val, true))
4867  {
4868  mark_modified ();
4869  }
4870  }
4871  }
4872 
4874  {
4875  if (! error_state)
4876  {
4877  if (__plot_stream__.set (val, true))
4878  {
4879  mark_modified ();
4880  }
4881  }
4882  }
4883 
4884 
4885  protected:
4886  void init (void)
4887  {
4888  alphamap.add_constraint (dim_vector (-1, 1));
4889  colormap.add_constraint (dim_vector (-1, 3));
4890  outerposition.add_constraint (dim_vector (1, 4));
4891  paperposition.add_constraint (dim_vector (1, 4));
4892  papersize.add_constraint (dim_vector (1, 2));
4893  pointershapecdata.add_constraint (dim_vector (16, 16));
4894  pointershapehotspot.add_constraint (dim_vector (1, 2));
4895  position.add_constraint (dim_vector (1, 4));
4896  }
4897 
4898  private:
4899  Matrix get_auto_paperposition (void);
4900 
4902  {
4903  if (paperpositionmode.is ("auto"))
4904  paperposition.set (get_auto_paperposition ());
4905  }
4906 
4908  };
4909 
4910 private:
4912 
4913 public:
4915  : base_graphics_object (), xproperties (mh, p), default_properties ()
4916  { }
4917 
4918  ~figure (void) { }
4919 
4921  {
4922  // Allow parent (root figure) to override first (properties knows how
4923  // to find the parent object).
4924  xproperties.override_defaults (obj);
4925 
4926  // Now override with our defaults. If the default_properties
4927  // list includes the properties for all defaults (line,
4928  // surface, etc.) then we don't have to know the type of OBJ
4929  // here, we just call its set function and let it decide which
4930  // properties from the list to use.
4931  obj.set_from_list (default_properties);
4932  }
4933 
4934  void set (const caseless_str& name, const octave_value& value)
4935  {
4936  if (name.compare ("default", 7))
4937  // strip "default", pass rest to function that will
4938  // parse the remainder and add the element to the
4939  // default_properties map.
4940  default_properties.set (name.substr (7), value);
4941  else
4942  xproperties.set (name, value);
4943  }
4944 
4945  octave_value get (const caseless_str& name) const
4946  {
4947  octave_value retval;
4948 
4949  if (name.compare ("default", 7))
4950  retval = get_default (name.substr (7));
4951  else
4952  retval = xproperties.get (name);
4953 
4954  return retval;
4955  }
4956 
4957  octave_value get_default (const caseless_str& name) const;
4958 
4960  {
4961  return default_properties.as_struct ("default");
4962  }
4963 
4965  {
4966  return default_properties;
4967  }
4968 
4969  base_properties& get_properties (void) { return xproperties; }
4970 
4971  const base_properties& get_properties (void) const { return xproperties; }
4972 
4973  bool valid_object (void) const { return true; }
4974 
4975  void reset_default_properties (void);
4976 
4977  bool has_readonly_property (const caseless_str& pname) const
4978  {
4979  bool retval = xproperties.has_readonly_property (pname);
4980  if (! retval)
4981  retval = base_properties::has_readonly_property (pname);
4982  return retval;
4983  }
4984 
4985 private:
4987 };
4988 
4989 // ---------------------------------------------------------------------
4990 
4992 {
4993 public:
4995  : xform (xform_eye ()), xform_inv (xform_eye ()),
4996  sx ("linear"), sy ("linear"), sz ("linear"), zlim (1, 2, 0.0)
4997  {
4998  zlim(1) = 1.0;
4999  }
5000 
5001  graphics_xform (const Matrix& xm, const Matrix& xim,
5002  const scaler& x, const scaler& y, const scaler& z,
5003  const Matrix& zl)
5004  : xform (xm), xform_inv (xim), sx (x), sy (y), sz (z), zlim (zl) { }
5005 
5007  : xform (g.xform), xform_inv (g.xform_inv), sx (g.sx),
5008  sy (g.sy), sz (g.sz), zlim (g.zlim) { }
5009 
5010  ~graphics_xform (void) { }
5011 
5012  graphics_xform& operator = (const graphics_xform& g)
5013  {
5014  xform = g.xform;
5015  xform_inv = g.xform_inv;
5016  sx = g.sx;
5017  sy = g.sy;
5018  sz = g.sz;
5019  zlim = g.zlim;
5020 
5021  return *this;
5022  }
5023 
5024  static ColumnVector xform_vector (double x, double y, double z);
5025 
5026  static Matrix xform_eye (void);
5027 
5028  ColumnVector transform (double x, double y, double z,
5029  bool use_scale = true) const;
5030 
5031  ColumnVector untransform (double x, double y, double z,
5032  bool use_scale = true) const;
5033 
5034  ColumnVector untransform (double x, double y, bool use_scale = true) const
5035  { return untransform (x, y, (zlim(0)+zlim(1))/2, use_scale); }
5036 
5037  Matrix xscale (const Matrix& m) const { return sx.scale (m); }
5038  Matrix yscale (const Matrix& m) const { return sy.scale (m); }
5039  Matrix zscale (const Matrix& m) const { return sz.scale (m); }
5040 
5041  Matrix scale (const Matrix& m) const
5042  {
5043  bool has_z = (m.columns () > 2);
5044 
5045  if (sx.is_linear () && sy.is_linear ()
5046  && (! has_z || sz.is_linear ()))
5047  return m;
5048 
5049  Matrix retval (m.dims ());
5050 
5051  int r = m.rows ();
5052 
5053  for (int i = 0; i < r; i++)
5054  {
5055  retval(i,0) = sx.scale (m(i,0));
5056  retval(i,1) = sy.scale (m(i,1));
5057  if (has_z)
5058  retval(i,2) = sz.scale (m(i,2));
5059  }
5060 
5061  return retval;
5062  }
5063 
5064 private:
5067  scaler sx, sy, sz;
5069 };
5070 
5071 enum
5072 {
5077 };
5078 
5080 {
5081 public:
5083  {
5084  public:
5085  void set_defaults (base_graphics_object& obj, const std::string& mode);
5086 
5087  void remove_child (const graphics_handle& h);
5088 
5089  const scaler& get_x_scaler (void) const { return sx; }
5090  const scaler& get_y_scaler (void) const { return sy; }
5091  const scaler& get_z_scaler (void) const { return sz; }
5092 
5093  Matrix get_boundingbox (bool internal = false,
5094  const Matrix& parent_pix_size = Matrix ()) const;
5095  Matrix get_extent (bool with_text = false,
5096  bool only_text_height=false) const;
5097 
5098  double get_fontsize_points (double box_pix_height = 0) const;
5099 
5101  {
5102  if (units_is ("normalized"))
5103  {
5104  sync_positions ();
5106  }
5107  }
5108 
5109  void update_camera (void);
5110  void update_axes_layout (void);
5111  void update_aspectratios (void);
5112  void update_transform (void)
5113  {
5114  update_aspectratios ();
5115  update_camera ();
5116  update_axes_layout ();
5117  }
5118 
5119  void sync_positions (void);
5120 
5121  void update_autopos (const std::string& elem_type);
5122  void update_xlabel_position (void);
5123  void update_ylabel_position (void);
5124  void update_zlabel_position (void);
5125  void update_title_position (void);
5126 
5128  { return graphics_xform (x_render, x_render_inv, sx, sy, sz, x_zlim); }
5129 
5130  Matrix get_transform_matrix (void) const { return x_render; }
5131  Matrix get_inverse_transform_matrix (void) const { return x_render_inv; }
5132  Matrix get_opengl_matrix_1 (void) const { return x_gl_mat1; }
5133  Matrix get_opengl_matrix_2 (void) const { return x_gl_mat2; }
5134  Matrix get_transform_zlim (void) const { return x_zlim; }
5135 
5136  int get_xstate (void) const { return xstate; }
5137  int get_ystate (void) const { return ystate; }
5138  int get_zstate (void) const { return zstate; }
5139  double get_xPlane (void) const { return xPlane; }
5140  double get_xPlaneN (void) const { return xPlaneN; }
5141  double get_yPlane (void) const { return yPlane; }
5142  double get_yPlaneN (void) const { return yPlaneN; }
5143  double get_zPlane (void) const { return zPlane; }
5144  double get_zPlaneN (void) const { return zPlaneN; }
5145  double get_xpTick (void) const { return xpTick; }
5146  double get_xpTickN (void) const { return xpTickN; }
5147  double get_ypTick (void) const { return ypTick; }
5148  double get_ypTickN (void) const { return ypTickN; }
5149  double get_zpTick (void) const { return zpTick; }
5150  double get_zpTickN (void) const { return zpTickN; }
5151  double get_x_min (void) const { return std::min (xPlane, xPlaneN); }
5152  double get_x_max (void) const { return std::max (xPlane, xPlaneN); }
5153  double get_y_min (void) const { return std::min (yPlane, yPlaneN); }
5154  double get_y_max (void) const { return std::max (yPlane, yPlaneN); }
5155  double get_z_min (void) const { return std::min (zPlane, zPlaneN); }
5156  double get_z_max (void) const { return std::max (zPlane, zPlaneN); }
5157  double get_fx (void) const { return fx; }
5158  double get_fy (void) const { return fy; }
5159  double get_fz (void) const { return fz; }
5160  double get_xticklen (void) const { return xticklen; }
5161  double get_yticklen (void) const { return yticklen; }
5162  double get_zticklen (void) const { return zticklen; }
5163  double get_xtickoffset (void) const { return xtickoffset; }
5164  double get_ytickoffset (void) const { return ytickoffset; }
5165  double get_ztickoffset (void) const { return ztickoffset; }
5166  bool get_x2Dtop (void) const { return x2Dtop; }
5167  bool get_y2Dright (void) const { return y2Dright; }
5168  bool get_layer2Dtop (void) const { return layer2Dtop; }
5169  bool get_is2D (void) const { return is2D; }
5170  bool get_xySym (void) const { return xySym; }
5171  bool get_xyzSym (void) const { return xyzSym; }
5172  bool get_zSign (void) const { return zSign; }
5173  bool get_nearhoriz (void) const { return nearhoriz; }
5174 
5175  ColumnVector pixel2coord (double px, double py) const
5176  { return get_transform ().untransform (px, py, (x_zlim(0)+x_zlim(1))/2); }
5177 
5178  ColumnVector coord2pixel (double x, double y, double z) const
5179  { return get_transform ().transform (x, y, z); }
5180 
5181  void zoom_about_point (const std::string& mode, double x, double y,
5182  double factor, bool push_to_zoom_stack = true);
5183  void zoom (const std::string& mode, double factor,
5184  bool push_to_zoom_stack = true);
5185  void zoom (const std::string& mode, const Matrix& xl, const Matrix& yl,
5186  bool push_to_zoom_stack = true);
5187 
5188  void translate_view (const std::string& mode,
5189  double x0, double x1, double y0, double y1,
5190  bool push_to_zoom_stack = true);
5191 
5192  void pan (const std::string& mode, double factor,
5193  bool push_to_zoom_stack = true);
5194 
5195  void rotate3d (double x0, double x1, double y0, double y1,
5196  bool push_to_zoom_stack = true);
5197 
5198  void rotate_view (double delta_az, double delta_el,
5199  bool push_to_zoom_stack = true);
5200 
5201  void unzoom (void);
5202  void push_zoom_stack (void);
5203  void clear_zoom_stack (bool do_unzoom = true);
5204 
5205  void update_units (const caseless_str& old_units);
5206 
5207  void update_fontunits (const caseless_str& old_fontunits);
5208 
5209  private:
5210  scaler sx, sy, sz;
5212  Matrix x_gl_mat1, x_gl_mat2;
5214  std::list<octave_value> zoom_stack;
5215 
5216  // Axes layout data
5217  int xstate, ystate, zstate;
5218  double xPlane, xPlaneN, yPlane, yPlaneN, zPlane, zPlaneN;
5219  double xpTick, xpTickN, ypTick, ypTickN, zpTick, zpTickN;
5220  double fx, fy, fz;
5221  double xticklen, yticklen, zticklen;
5222  double xtickoffset, ytickoffset, ztickoffset;
5223  bool x2Dtop, y2Dright, layer2Dtop, is2D;
5224  bool xySym, xyzSym, zSign, nearhoriz;
5225 
5226 #if HAVE_FREETYPE
5227  // FreeType renderer, used for calculation of text (tick labels) size
5229 #endif
5230 
5231  void set_text_child (handle_property& h, const std::string& who,
5232  const octave_value& v);
5233 
5234  void delete_text_child (handle_property& h);
5235 
5236  // See the genprops.awk script for an explanation of the
5237  // properties declarations.
5238  // Programming note: Keep property list sorted if new ones are added.
5239 
5240 public:
5241  properties (const graphics_handle& mh, const graphics_handle& p);
5242 
5243  ~properties (void) { }
5244 
5245  void set (const caseless_str& pname, const octave_value& val);
5246 
5247  octave_value get (bool all = false) const;
5248 
5249  octave_value get (const caseless_str& pname) const;
5250 
5251  octave_value get (const std::string& pname) const
5252  {
5253  return get (caseless_str (pname));
5254  }
5255 
5256  octave_value get (const char *pname) const
5257  {
5258  return get (caseless_str (pname));
5259  }
5260 
5261  property get_property (const caseless_str& pname);
5262 
5263  std::string graphics_object_name (void) const { return go_name; }
5264 
5266 
5267 private:
5268  static std::string go_name;
5269 
5270 public:
5271 
5272 
5273  static std::set<std::string> core_property_names (void);
5274 
5275  static std::set<std::string> readonly_property_names (void);
5276 
5277  static bool has_core_property (const caseless_str& pname);
5278 
5279  static bool has_readonly_property (const caseless_str& pname);
5280 
5281  std::set<std::string> all_property_names (void) const;
5282 
5283  bool has_property (const caseless_str& pname) const;
5284 
5285 private:
5286 
5386 
5387 public:
5388 
5389  enum
5390  {
5391  ID_ACTIVEPOSITIONPROPERTY = 3000,
5392  ID_ALIM = 3001,
5393  ID_ALIMMODE = 3002,
5394  ID_AMBIENTLIGHTCOLOR = 3003,
5395  ID_BOX = 3004,
5396  ID_CAMERAPOSITION = 3005,
5397  ID_CAMERAPOSITIONMODE = 3006,
5398  ID_CAMERATARGET = 3007,
5399  ID_CAMERATARGETMODE = 3008,
5400  ID_CAMERAUPVECTOR = 3009,
5401  ID_CAMERAUPVECTORMODE = 3010,
5402  ID_CAMERAVIEWANGLE = 3011,
5403  ID_CAMERAVIEWANGLEMODE = 3012,
5404  ID_CLIM = 3013,
5405  ID_CLIMMODE = 3014,
5406  ID_COLOR = 3015,
5407  ID_COLORORDER = 3016,
5408  ID_CURRENTPOINT = 3017,
5409  ID_DATAASPECTRATIO = 3018,
5410  ID_DATAASPECTRATIOMODE = 3019,
5411  ID_DRAWMODE = 3020,
5412  ID_FONTANGLE = 3021,
5413  ID_FONTNAME = 3022,
5414  ID_FONTSIZE = 3023,
5415  ID_FONTUNITS = 3024,
5416  ID_FONTWEIGHT = 3025,
5417  ID_GRIDLINESTYLE = 3026,
5418  ID_INTERPRETER = 3027,
5419  ID_LAYER = 3028,
5420  ID_LINESTYLEORDER = 3029,
5421  ID_LINEWIDTH = 3030,
5422  ID_MINORGRIDLINESTYLE = 3031,
5423  ID_MOUSEWHEELZOOM = 3032,
5424  ID_NEXTPLOT = 3033,
5425  ID_OUTERPOSITION = 3034,
5426  ID_PLOTBOXASPECTRATIO = 3035,
5427  ID_PLOTBOXASPECTRATIOMODE = 3036,
5428  ID_POSITION = 3037,
5429  ID_PROJECTION = 3038,
5430  ID_TICKDIR = 3039,
5431  ID_TICKDIRMODE = 3040,
5432  ID_TICKLENGTH = 3041,
5433  ID_TIGHTINSET = 3042,
5434  ID_TITLE = 3043,
5435  ID_UNITS = 3044,
5436  ID_VIEW = 3045,
5437  ID_XAXISLOCATION = 3046,
5438  ID_XCOLOR = 3047,
5439  ID_XDIR = 3048,
5440  ID_XGRID = 3049,
5441  ID_XLABEL = 3050,
5442  ID_XLIM = 3051,
5443  ID_XLIMMODE = 3052,
5444  ID_XMINORGRID = 3053,
5445  ID_XMINORTICK = 3054,
5446  ID_XSCALE = 3055,
5447  ID_XTICK = 3056,
5448  ID_XTICKLABEL = 3057,
5449  ID_XTICKLABELMODE = 3058,
5450  ID_XTICKMODE = 3059,
5451  ID_YAXISLOCATION = 3060,
5452  ID_YCOLOR = 3061,
5453  ID_YDIR = 3062,
5454  ID_YGRID = 3063,
5455  ID_YLABEL = 3064,
5456  ID_YLIM = 3065,
5457  ID_YLIMMODE = 3066,
5458  ID_YMINORGRID = 3067,
5459  ID_YMINORTICK = 3068,
5460  ID_YSCALE = 3069,
5461  ID_YTICK = 3070,
5462  ID_YTICKLABEL = 3071,
5463  ID_YTICKLABELMODE = 3072,
5464  ID_YTICKMODE = 3073,
5465  ID_ZCOLOR = 3074,
5466  ID_ZDIR = 3075,
5467  ID_ZGRID = 3076,
5468  ID_ZLABEL = 3077,
5469  ID_ZLIM = 3078,
5470  ID_ZLIMMODE = 3079,
5471  ID_ZMINORGRID = 3080,
5472  ID_ZMINORTICK = 3081,
5473  ID_ZSCALE = 3082,
5474  ID_ZTICK = 3083,
5475  ID_ZTICKLABEL = 3084,
5476  ID_ZTICKLABELMODE = 3085,
5477  ID_ZTICKMODE = 3086,
5478  ID___HOLD_ALL__ = 3087,
5479  ID_AUTOPOS_TAG = 3088,
5480  ID_LOOSEINSET = 3089,
5481  ID_X_VIEWTRANSFORM = 3090,
5482  ID_X_PROJECTIONTRANSFORM = 3091,
5483  ID_X_VIEWPORTTRANSFORM = 3092,
5484  ID_X_NORMRENDERTRANSFORM = 3093,
5485  ID_X_RENDERTRANSFORM = 3094,
5486  ID_XMTICK = 3095,
5487  ID_YMTICK = 3096,
5488  ID_ZMTICK = 3097,
5489  ID_FONTSIZE_POINTS = 3098
5490  };
5491 
5492  bool activepositionproperty_is (const std::string& v) const { return activepositionproperty.is (v); }
5493  std::string get_activepositionproperty (void) const { return activepositionproperty.current_value (); }
5494 
5495  octave_value get_alim (void) const { return alim.get (); }
5496 
5497  bool alimmode_is (const std::string& v) const { return alimmode.is (v); }
5498  std::string get_alimmode (void) const { return alimmode.current_value (); }
5499 
5500  bool ambientlightcolor_is_rgb (void) const { return ambientlightcolor.is_rgb (); }
5501  bool ambientlightcolor_is (const std::string& v) const { return ambientlightcolor.is (v); }
5502  Matrix get_ambientlightcolor_rgb (void) const { return (ambientlightcolor.is_rgb () ? ambientlightcolor.rgb () : Matrix ()); }
5503  octave_value get_ambientlightcolor (void) const { return ambientlightcolor.get (); }
5504 
5505  bool is_box (void) const { return box.is_on (); }
5506  std::string get_box (void) const { return box.current_value (); }
5507 
5508  octave_value get_cameraposition (void) const { return cameraposition.get (); }
5509 
5510  bool camerapositionmode_is (const std::string& v) const { return camerapositionmode.is (v); }
5511  std::string get_camerapositionmode (void) const { return camerapositionmode.current_value (); }
5512 
5513  octave_value get_cameratarget (void) const { return cameratarget.get (); }
5514 
5515  bool cameratargetmode_is (const std::string& v) const { return cameratargetmode.is (v); }
5516  std::string get_cameratargetmode (void) const { return cameratargetmode.current_value (); }
5517 
5518  octave_value get_cameraupvector (void) const { return cameraupvector.get (); }
5519 
5520  bool cameraupvectormode_is (const std::string& v) const { return cameraupvectormode.is (v); }
5521  std::string get_cameraupvectormode (void) const { return cameraupvectormode.current_value (); }
5522 
5523  double get_cameraviewangle (void) const { return cameraviewangle.double_value (); }
5524 
5525  bool cameraviewanglemode_is (const std::string& v) const { return cameraviewanglemode.is (v); }
5526  std::string get_cameraviewanglemode (void) const { return cameraviewanglemode.current_value (); }
5527 
5528  octave_value get_clim (void) const { return clim.get (); }
5529 
5530  bool climmode_is (const std::string& v) const { return climmode.is (v); }
5531  std::string get_climmode (void) const { return climmode.current_value (); }
5532 
5533  bool color_is_rgb (void) const { return color.is_rgb (); }
5534  bool color_is (const std::string& v) const { return color.is (v); }
5535  Matrix get_color_rgb (void) const { return (color.is_rgb () ? color.rgb () : Matrix ()); }
5536  octave_value get_color (void) const { return color.get (); }
5537 
5538  octave_value get_colororder (void) const { return colororder.get (); }
5539 
5540  octave_value get_currentpoint (void) const { return currentpoint.get (); }
5541 
5542  octave_value get_dataaspectratio (void) const { return dataaspectratio.get (); }
5543 
5544  bool dataaspectratiomode_is (const std::string& v) const { return dataaspectratiomode.is (v); }
5545  std::string get_dataaspectratiomode (void) const { return dataaspectratiomode.current_value (); }
5546 
5547  bool drawmode_is (const std::string& v) const { return drawmode.is (v); }
5548  std::string get_drawmode (void) const { return drawmode.current_value (); }
5549 
5550  bool fontangle_is (const std::string& v) const { return fontangle.is (v); }
5551  std::string get_fontangle (void) const { return fontangle.current_value (); }
5552 
5553  std::string get_fontname (void) const { return fontname.string_value (); }
5554 
5555  double get_fontsize (void) const { return fontsize.double_value (); }
5556 
5557  bool fontunits_is (const std::string& v) const { return fontunits.is (v); }
5558  std::string get_fontunits (void) const { return fontunits.current_value (); }
5559 
5560  bool fontweight_is (const std::string& v) const { return fontweight.is (v); }
5561  std::string get_fontweight (void) const { return fontweight.current_value (); }
5562 
5563  bool gridlinestyle_is (const std::string& v) const { return gridlinestyle.is (v); }
5564  std::string get_gridlinestyle (void) const { return gridlinestyle.current_value (); }
5565 
5566  bool interpreter_is (const std::string& v) const { return interpreter.is (v); }
5567  std::string get_interpreter (void) const { return interpreter.current_value (); }
5568 
5569  bool layer_is (const std::string& v) const { return layer.is (v); }
5570  std::string get_layer (void) const { return layer.current_value (); }
5571 
5572  octave_value get_linestyleorder (void) const { return linestyleorder.get (); }
5573 
5574  double get_linewidth (void) const { return linewidth.double_value (); }
5575 
5576  bool minorgridlinestyle_is (const std::string& v) const { return minorgridlinestyle.is (v); }
5577  std::string get_minorgridlinestyle (void) const { return minorgridlinestyle.current_value (); }
5578 
5579  double get_mousewheelzoom (void) const { return mousewheelzoom.double_value (); }
5580 
5581  bool nextplot_is (const std::string& v) const { return nextplot.is (v); }
5582  std::string get_nextplot (void) const { return nextplot.current_value (); }
5583 
5584  octave_value get_outerposition (void) const { return outerposition.get (); }
5585 
5586  octave_value get_plotboxaspectratio (void) const { return plotboxaspectratio.get (); }
5587 
5588  bool plotboxaspectratiomode_is (const std::string& v) const { return plotboxaspectratiomode.is (v); }
5589  std::string get_plotboxaspectratiomode (void) const { return plotboxaspectratiomode.current_value (); }
5590 
5591  octave_value get_position (void) const { return position.get (); }
5592 
5593  bool projection_is (const std::string& v) const { return projection.is (v); }
5594  std::string get_projection (void) const { return projection.current_value (); }
5595 
5596  bool tickdir_is (const std::string& v) const { return tickdir.is (v); }
5597  std::string get_tickdir (void) const { return tickdir.current_value (); }
5598 
5599  bool tickdirmode_is (const std::string& v) const { return tickdirmode.is (v); }
5600  std::string get_tickdirmode (void) const { return tickdirmode.current_value (); }
5601 
5602  octave_value get_ticklength (void) const { return ticklength.get (); }
5603 
5604  octave_value get_tightinset (void) const { return tightinset.get (); }
5605 
5606  graphics_handle get_title (void) const { return title.handle_value (); }
5607 
5608  bool units_is (const std::string& v) const { return units.is (v); }
5609  std::string get_units (void) const { return units.current_value (); }
5610 
5611  octave_value get_view (void) const { return view.get (); }
5612 
5613  bool xaxislocation_is (const std::string& v) const { return xaxislocation.is (v); }
5614  std::string get_xaxislocation (void) const { return xaxislocation.current_value (); }
5615 
5616  bool xcolor_is_rgb (void) const { return xcolor.is_rgb (); }
5617  bool xcolor_is (const std::string& v) const { return xcolor.is (v); }
5618  Matrix get_xcolor_rgb (void) const { return (xcolor.is_rgb () ? xcolor.rgb () : Matrix ()); }
5619  octave_value get_xcolor (void) const { return xcolor.get (); }
5620 
5621  bool xdir_is (const std::string& v) const { return xdir.is (v); }
5622  std::string get_xdir (void) const { return xdir.current_value (); }
5623 
5624  bool is_xgrid (void) const { return xgrid.is_on (); }
5625  std::string get_xgrid (void) const { return xgrid.current_value (); }
5626 
5627  graphics_handle get_xlabel (void) const { return xlabel.handle_value (); }
5628 
5629  octave_value get_xlim (void) const { return xlim.get (); }
5630 
5631  bool xlimmode_is (const std::string& v) const { return xlimmode.is (v); }
5632  std::string get_xlimmode (void) const { return xlimmode.current_value (); }
5633 
5634  bool is_xminorgrid (void) const { return xminorgrid.is_on (); }
5635  std::string get_xminorgrid (void) const { return xminorgrid.current_value (); }
5636 
5637  bool is_xminortick (void) const { return xminortick.is_on (); }
5638  std::string get_xminortick (void) const { return xminortick.current_value (); }
5639 
5640  bool xscale_is (const std::string& v) const { return xscale.is (v); }
5641  std::string get_xscale (void) const { return xscale.current_value (); }
5642 
5643  octave_value get_xtick (void) const { return xtick.get (); }
5644 
5645  octave_value get_xticklabel (void) const { return xticklabel.get (); }
5646 
5647  bool xticklabelmode_is (const std::string& v) const { return xticklabelmode.is (v); }
5648  std::string get_xticklabelmode (void) const { return xticklabelmode.current_value (); }
5649 
5650  bool xtickmode_is (const std::string& v) const { return xtickmode.is (v); }
5651  std::string get_xtickmode (void) const { return xtickmode.current_value (); }
5652 
5653  bool yaxislocation_is (const std::string& v) const { return yaxislocation.is (v); }
5654  std::string get_yaxislocation (void) const { return yaxislocation.current_value (); }
5655 
5656  bool ycolor_is_rgb (void) const { return ycolor.is_rgb (); }
5657  bool ycolor_is (const std::string& v) const { return ycolor.is (v); }
5658  Matrix get_ycolor_rgb (void) const { return (ycolor.is_rgb () ? ycolor.rgb () : Matrix ()); }
5659  octave_value get_ycolor (void) const { return ycolor.get (); }
5660 
5661  bool ydir_is (const std::string& v) const { return ydir.is (v); }
5662  std::string get_ydir (void) const { return ydir.current_value (); }
5663 
5664  bool is_ygrid (void) const { return ygrid.is_on (); }
5665  std::string get_ygrid (void) const { return ygrid.current_value (); }
5666 
5667  graphics_handle get_ylabel (void) const { return ylabel.handle_value (); }
5668 
5669  octave_value get_ylim (void) const { return ylim.get (); }
5670 
5671  bool ylimmode_is (const std::string& v) const { return ylimmode.is (v); }
5672  std::string get_ylimmode (void) const { return ylimmode.current_value (); }
5673 
5674  bool is_yminorgrid (void) const { return yminorgrid.is_on (); }
5675  std::string get_yminorgrid (void) const { return yminorgrid.current_value (); }
5676 
5677  bool is_yminortick (void) const { return yminortick.is_on (); }
5678  std::string get_yminortick (void) const { return yminortick.current_value (); }
5679 
5680  bool yscale_is (const std::string& v) const { return yscale.is (v); }
5681  std::string get_yscale (void) const { return yscale.current_value (); }
5682 
5683  octave_value get_ytick (void) const { return ytick.get (); }
5684 
5685  octave_value get_yticklabel (void) const { return yticklabel.get (); }
5686 
5687  bool yticklabelmode_is (const std::string& v) const { return yticklabelmode.is (v); }
5688  std::string get_yticklabelmode (void) const { return yticklabelmode.current_value (); }
5689 
5690  bool ytickmode_is (const std::string& v) const { return ytickmode.is (v); }
5691  std::string get_ytickmode (void) const { return ytickmode.current_value (); }
5692 
5693  bool zcolor_is_rgb (void) const { return zcolor.is_rgb (); }
5694  bool zcolor_is (const std::string& v) const { return zcolor.is (v); }
5695  Matrix get_zcolor_rgb (void) const { return (zcolor.is_rgb () ? zcolor.rgb () : Matrix ()); }
5696  octave_value get_zcolor (void) const { return zcolor.get (); }
5697 
5698  bool zdir_is (const std::string& v) const { return zdir.is (v); }
5699  std::string get_zdir (void) const { return zdir.current_value (); }
5700 
5701  bool is_zgrid (void) const { return zgrid.is_on (); }
5702  std::string get_zgrid (void) const { return zgrid.current_value (); }
5703 
5704  graphics_handle get_zlabel (void) const { return zlabel.handle_value (); }
5705 
5706  octave_value get_zlim (void) const { return zlim.get (); }
5707 
5708  bool zlimmode_is (const std::string& v) const { return zlimmode.is (v); }
5709  std::string get_zlimmode (void) const { return zlimmode.current_value (); }
5710 
5711  bool is_zminorgrid (void) const { return zminorgrid.is_on (); }
5712  std::string get_zminorgrid (void) const { return zminorgrid.current_value (); }
5713 
5714  bool is_zminortick (void) const { return zminortick.is_on (); }
5715  std::string get_zminortick (void) const { return zminortick.current_value (); }
5716 
5717  bool zscale_is (const std::string& v) const { return zscale.is (v); }
5718  std::string get_zscale (void) const { return zscale.current_value (); }
5719 
5720  octave_value get_ztick (void) const { return ztick.get (); }
5721 
5722  octave_value get_zticklabel (void) const { return zticklabel.get (); }
5723 
5724  bool zticklabelmode_is (const std::string& v) const { return zticklabelmode.is (v); }
5725  std::string get_zticklabelmode (void) const { return zticklabelmode.current_value (); }
5726 
5727  bool ztickmode_is (const std::string& v) const { return ztickmode.is (v); }
5728  std::string get_ztickmode (void) const { return ztickmode.current_value (); }
5729 
5730  bool is___hold_all__ (void) const { return __hold_all__.is_on (); }
5731  std::string get___hold_all__ (void) const { return __hold_all__.current_value (); }
5732 
5733  bool autopos_tag_is (const std::string& v) const { return autopos_tag.is (v); }
5734  std::string get_autopos_tag (void) const { return autopos_tag.current_value (); }
5735 
5736  octave_value get_looseinset (void) const { return looseinset.get (); }
5737 
5738  octave_value get_x_viewtransform (void) const { return x_viewtransform.get (); }
5739 
5740  octave_value get_x_projectiontransform (void) const { return x_projectiontransform.get (); }
5741 
5742  octave_value get_x_viewporttransform (void) const { return x_viewporttransform.get (); }
5743 
5744  octave_value get_x_normrendertransform (void) const { return x_normrendertransform.get (); }
5745 
5746  octave_value get_x_rendertransform (void) const { return x_rendertransform.get (); }
5747 
5748  octave_value get_xmtick (void) const { return xmtick.get (); }
5749 
5750  octave_value get_ymtick (void) const { return ymtick.get (); }
5751 
5752  octave_value get_zmtick (void) const { return zmtick.get (); }
5753 
5754 
5756  {
5757  if (! error_state)
5758  {
5759  if (activepositionproperty.set (val, true))
5760  {
5761  mark_modified ();
5762  }
5763  }
5764  }
5765 
5766  void set_alim (const octave_value& val)
5767  {
5768  if (! error_state)
5769  {
5770  if (alim.set (val, false))
5771  {
5772  set_alimmode ("manual");
5773  alim.run_listeners (POSTSET);
5774  mark_modified ();
5775  }
5776  else
5777  set_alimmode ("manual");
5778  }
5779  }
5780 
5781  void set_alimmode (const octave_value& val)
5782  {
5783  if (! error_state)
5784  {
5785  if (alimmode.set (val, true))
5786  {
5787  mark_modified ();
5788  }
5789  }
5790  }
5791 
5793  {
5794  if (! error_state)
5795  {
5796  if (ambientlightcolor.set (val, true))
5797  {
5798  mark_modified ();
5799  }
5800  }
5801  }
5802 
5803  void set_box (const octave_value& val)
5804  {
5805  if (! error_state)
5806  {
5807  if (box.set (val, true))
5808  {
5809  mark_modified ();
5810  }
5811  }
5812  }
5813 
5815  {
5816  if (! error_state)
5817  {
5818  if (cameraposition.set (val, false))
5819  {
5820  set_camerapositionmode ("manual");
5821  cameraposition.run_listeners (POSTSET);
5822  mark_modified ();
5823  }
5824  else
5825  set_camerapositionmode ("manual");
5826  }
5827  }
5828 
5830  {
5831  if (! error_state)
5832  {
5833  if (camerapositionmode.set (val, true))
5834  {
5835  mark_modified ();
5836  }
5837  }
5838  }
5839 
5840  void set_cameratarget (const octave_value& val)
5841  {
5842  if (! error_state)
5843  {
5844  if (cameratarget.set (val, false))
5845  {
5846  set_cameratargetmode ("manual");
5847  cameratarget.run_listeners (POSTSET);
5848  mark_modified ();
5849  }
5850  else
5851  set_cameratargetmode ("manual");
5852  }
5853  }
5854 
5856  {
5857  if (! error_state)
5858  {
5859  if (cameratargetmode.set (val, true))
5860  {
5861  mark_modified ();
5862  }
5863  }
5864  }
5865 
5867  {
5868  if (! error_state)
5869  {
5870  if (cameraupvector.set (val, false))
5871  {
5872  set_cameraupvectormode ("manual");
5873  cameraupvector.run_listeners (POSTSET);
5874  mark_modified ();
5875  }
5876  else
5877  set_cameraupvectormode ("manual");
5878  }
5879  }
5880 
5882  {
5883  if (! error_state)
5884  {
5885  if (cameraupvectormode.set (val, true))
5886  {
5887  mark_modified ();
5888  }
5889  }
5890  }
5891 
5893  {
5894  if (! error_state)
5895  {
5896  if (cameraviewangle.set (val, false))
5897  {
5898  set_cameraviewanglemode ("manual");
5899  cameraviewangle.run_listeners (POSTSET);
5900  mark_modified ();
5901  }
5902  else
5903  set_cameraviewanglemode ("manual");
5904  }
5905  }
5906 
5908  {
5909  if (! error_state)
5910  {
5911  if (cameraviewanglemode.set (val, true))
5912  {
5913  mark_modified ();
5914  }
5915  }
5916  }
5917 
5918  void set_clim (const octave_value& val)
5919  {
5920  if (! error_state)
5921  {
5922  if (clim.set (val, false))
5923  {
5924  set_climmode ("manual");
5925  clim.run_listeners (POSTSET);
5926  mark_modified ();
5927  }
5928  else
5929  set_climmode ("manual");
5930  }
5931  }
5932 
5933  void set_climmode (const octave_value& val)
5934  {
5935  if (! error_state)
5936  {
5937  if (climmode.set (val, false))
5938  {
5939  update_axis_limits ("climmode");
5940  climmode.run_listeners (POSTSET);
5941  mark_modified ();
5942  }
5943  }
5944  }
5945 
5946  void set_color (const octave_value& val)
5947  {
5948  if (! error_state)
5949  {
5950  if (color.set (val, true))
5951  {
5952  mark_modified ();
5953  }
5954  }
5955  }
5956 
5957  void set_colororder (const octave_value& val)
5958  {
5959  if (! error_state)
5960  {
5961  if (colororder.set (val, true))
5962  {
5963  mark_modified ();
5964  }
5965  }
5966  }
5967 
5968  void set_currentpoint (const octave_value& val)
5969  {
5970  if (! error_state)
5971  {
5972  if (currentpoint.set (val, true))
5973  {
5974  mark_modified ();
5975  }
5976  }
5977  }
5978 
5980  {
5981  if (! error_state)
5982  {
5983  if (dataaspectratio.set (val, false))
5984  {
5985  set_dataaspectratiomode ("manual");
5986  update_dataaspectratio ();
5987  dataaspectratio.run_listeners (POSTSET);
5988  mark_modified ();
5989  }
5990  else
5991  set_dataaspectratiomode ("manual");
5992  }
5993  }
5994 
5996  {
5997  if (! error_state)
5998  {
5999  if (dataaspectratiomode.set (val, true))
6000  {
6001  update_dataaspectratiomode ();
6002  mark_modified ();
6003  }
6004  }
6005  }
6006 
6007  void set_drawmode (const octave_value& val)
6008  {
6009  if (! error_state)
6010  {
6011  if (drawmode.set (val, true))
6012  {
6013  mark_modified ();
6014  }
6015  }
6016  }
6017 
6018  void set_fontangle (const octave_value& val)
6019  {
6020  if (! error_state)
6021  {
6022  if (fontangle.set (val, true))
6023  {
6024  update_fontangle ();
6025  mark_modified ();
6026  }
6027  }
6028  }
6029 
6030  void set_fontname (const octave_value& val)
6031  {
6032  if (! error_state)
6033  {
6034  if (fontname.set (val, true))
6035  {
6036  update_fontname ();
6037  mark_modified ();
6038  }
6039  }
6040  }
6041 
6042  void set_fontsize (const octave_value& val)
6043  {
6044  if (! error_state)
6045  {
6046  if (fontsize.set (val, true))
6047  {
6048  update_fontsize ();
6049  mark_modified ();
6050  }
6051  }
6052  }
6053 
6054  void set_fontunits (const octave_value& val);
6055 
6056  void update_fontunits (void);
6057 
6058  void set_fontweight (const octave_value& val)
6059  {
6060  if (! error_state)
6061  {
6062  if (fontweight.set (val, true))
6063  {
6064  update_fontweight ();
6065  mark_modified ();
6066  }
6067  }
6068  }
6069 
6071  {
6072  if (! error_state)
6073  {
6074  if (gridlinestyle.set (val, true))
6075  {
6076  mark_modified ();
6077  }
6078  }
6079  }
6080 
6081  void set_interpreter (const octave_value& val)
6082  {
6083  if (! error_state)
6084  {
6085  if (interpreter.set (val, true))
6086  {
6087  mark_modified ();
6088  }
6089  }
6090  }
6091 
6092  void set_layer (const octave_value& val)
6093  {
6094  if (! error_state)
6095  {
6096  if (layer.set (val, true))
6097  {
6098  update_layer ();
6099  mark_modified ();
6100  }
6101  }
6102  }
6103 
6104  void set_linestyleorder (const octave_value& val);
6105 
6106  void set_linewidth (const octave_value& val)
6107  {
6108  if (! error_state)
6109  {
6110  if (linewidth.set (val, true))
6111  {
6112  mark_modified ();
6113  }
6114  }
6115  }
6116 
6118  {
6119  if (! error_state)
6120  {
6121  if (minorgridlinestyle.set (val, true))
6122  {
6123  mark_modified ();
6124  }
6125  }
6126  }
6127 
6129  {
6130  if (! error_state)
6131  {
6132  if (mousewheelzoom.set (val, true))
6133  {
6134  mark_modified ();
6135  }
6136  }
6137  }
6138 
6139  void set_nextplot (const octave_value& val)
6140  {
6141  if (! error_state)
6142  {
6143  if (nextplot.set (val, true))
6144  {
6145  mark_modified ();
6146  }
6147  }
6148  }
6149 
6151  {
6152  if (! error_state)
6153  {
6154  if (outerposition.set (val, true))
6155  {
6156  update_outerposition ();
6157  mark_modified ();
6158  }
6159  }
6160  }
6161 
6163  {
6164  if (! error_state)
6165  {
6166  if (plotboxaspectratio.set (val, false))
6167  {
6168  set_plotboxaspectratiomode ("manual");
6169  update_plotboxaspectratio ();
6170  plotboxaspectratio.run_listeners (POSTSET);
6171  mark_modified ();
6172  }
6173  else
6174  set_plotboxaspectratiomode ("manual");
6175  }
6176  }
6177 
6179  {
6180  if (! error_state)
6181  {
6182  if (plotboxaspectratiomode.set (val, true))
6183  {
6184  update_plotboxaspectratiomode ();
6185  mark_modified ();
6186  }
6187  }
6188  }
6189 
6190  void set_position (const octave_value& val)
6191  {
6192  if (! error_state)
6193  {
6194  if (position.set (val, true))
6195  {
6196  update_position ();
6197  mark_modified ();
6198  }
6199  }
6200  }
6201 
6202  void set_projection (const octave_value& val)
6203  {
6204  if (! error_state)
6205  {
6206  if (projection.set (val, true))
6207  {
6208  mark_modified ();
6209  }
6210  }
6211  }
6212 
6213  void set_tickdir (const octave_value& val)
6214  {
6215  if (! error_state)
6216  {
6217  if (tickdir.set (val, false))
6218  {
6219  set_tickdirmode ("manual");
6220  update_tickdir ();
6221  tickdir.run_listeners (POSTSET);
6222  mark_modified ();
6223  }
6224  else
6225  set_tickdirmode ("manual");
6226  }
6227  }
6228 
6229  void set_tickdirmode (const octave_value& val)
6230  {
6231  if (! error_state)
6232  {
6233  if (tickdirmode.set (val, true))
6234  {
6235  update_tickdirmode ();
6236  mark_modified ();
6237  }
6238  }
6239  }
6240 
6241  void set_ticklength (const octave_value& val)
6242  {
6243  if (! error_state)
6244  {
6245  if (ticklength.set (val, true))
6246  {
6247  update_ticklength ();
6248  mark_modified ();
6249  }
6250  }
6251  }
6252 
6253  void set_tightinset (const octave_value& val)
6254  {
6255  if (! error_state)
6256  {
6257  if (tightinset.set (val, true))
6258  {
6259  mark_modified ();
6260  }
6261  }
6262  }
6263 
6264  void set_title (const octave_value& val);
6265 
6266  void set_units (const octave_value& val);
6267 
6268  void update_units (void);
6269 
6270  void set_view (const octave_value& val)
6271  {
6272  if (! error_state)
6273  {
6274  if (view.set (val, true))
6275  {
6276  update_view ();
6277  mark_modified ();
6278  }
6279  }
6280  }
6281 
6283  {
6284  if (! error_state)
6285  {
6286  if (xaxislocation.set (val, true))
6287  {
6288  update_xaxislocation ();
6289  mark_modified ();
6290  }
6291  }
6292  }
6293 
6294  void set_xcolor (const octave_value& val)
6295  {
6296  if (! error_state)
6297  {
6298  if (xcolor.set (val, true))
6299  {
6300  mark_modified ();
6301  }
6302  }
6303  }
6304 
6305  void set_xdir (const octave_value& val)
6306  {
6307  if (! error_state)
6308  {
6309  if (xdir.set (val, true))
6310  {
6311  update_xdir ();
6312  mark_modified ();
6313  }
6314  }
6315  }
6316 
6317  void set_xgrid (const octave_value& val)
6318  {
6319  if (! error_state)
6320  {
6321  if (xgrid.set (val, true))
6322  {
6323  mark_modified ();
6324  }
6325  }
6326  }
6327 
6328  void set_xlabel (const octave_value& val);
6329 
6330  void set_xlim (const octave_value& val)
6331  {
6332  if (! error_state)
6333  {
6334  if (xlim.set (val, false))
6335  {
6336  set_xlimmode ("manual");
6337  update_xlim ();
6338  xlim.run_listeners (POSTSET);
6339  mark_modified ();
6340  }
6341  else
6342  set_xlimmode ("manual");
6343  }
6344  }
6345 
6346  void set_xlimmode (const octave_value& val)
6347  {
6348  if (! error_state)
6349  {
6350  if (xlimmode.set (val, false))
6351  {
6352  update_axis_limits ("xlimmode");
6353  xlimmode.run_listeners (POSTSET);
6354  mark_modified ();
6355  }
6356  }
6357  }
6358 
6359  void set_xminorgrid (const octave_value& val)
6360  {
6361  if (! error_state)
6362  {
6363  if (xminorgrid.set (val, true))
6364  {
6365  mark_modified ();
6366  }
6367  }
6368  }
6369 
6370  void set_xminortick (const octave_value& val)
6371  {
6372  if (! error_state)
6373  {
6374  if (xminortick.set (val, true))
6375  {
6376  mark_modified ();
6377  }
6378  }
6379  }
6380 
6381  void set_xscale (const octave_value& val)
6382  {
6383  if (! error_state)
6384  {
6385  if (xscale.set (val, false))
6386  {
6387  update_xscale ();
6388  update_axis_limits ("xscale");
6389  xscale.run_listeners (POSTSET);
6390  mark_modified ();
6391  }
6392  }
6393  }
6394 
6395  void set_xtick (const octave_value& val)
6396  {
6397  if (! error_state)
6398  {
6399  if (xtick.set (val, false))
6400  {
6401  set_xtickmode ("manual");
6402  update_xtick ();
6403  xtick.run_listeners (POSTSET);
6404  mark_modified ();
6405  }
6406  else
6407  set_xtickmode ("manual");
6408  }
6409  }
6410 
6411  void set_xticklabel (const octave_value& val);
6412 
6414  {
6415  if (! error_state)
6416  {
6417  if (xticklabelmode.set (val, true))
6418  {
6419  update_xticklabelmode ();
6420  mark_modified ();
6421  }
6422  }
6423  }
6424 
6425  void set_xtickmode (const octave_value& val)
6426  {
6427  if (! error_state)
6428  {
6429  if (xtickmode.set (val, true))
6430  {
6431  update_xtickmode ();
6432  mark_modified ();
6433  }
6434  }
6435  }
6436 
6438  {
6439  if (! error_state)
6440  {
6441  if (yaxislocation.set (val, true))
6442  {
6443  update_yaxislocation ();
6444  mark_modified ();
6445  }
6446  }
6447  }
6448 
6449  void set_ycolor (const octave_value& val)
6450  {
6451  if (! error_state)
6452  {
6453  if (ycolor.set (val, true))
6454  {
6455  mark_modified ();
6456  }
6457  }
6458  }
6459 
6460  void set_ydir (const octave_value& val)
6461  {
6462  if (! error_state)
6463  {
6464  if (ydir.set (val, true))
6465  {
6466  update_ydir ();
6467  mark_modified ();
6468  }
6469  }
6470  }
6471 
6472  void set_ygrid (const octave_value& val)
6473  {
6474  if (! error_state)
6475  {
6476  if (ygrid.set (val, true))
6477  {
6478  mark_modified ();
6479  }
6480  }
6481  }
6482 
6483  void set_ylabel (const octave_value& val);
6484 
6485  void set_ylim (const octave_value& val)
6486  {
6487  if (! error_state)
6488  {
6489  if (ylim.set (val, false))
6490  {
6491  set_ylimmode ("manual");
6492  update_ylim ();
6493  ylim.run_listeners (POSTSET);
6494  mark_modified ();
6495  }
6496  else
6497  set_ylimmode ("manual");
6498  }
6499  }
6500 
6501  void set_ylimmode (const octave_value& val)
6502  {
6503  if (! error_state)
6504  {
6505  if (ylimmode.set (val, false))
6506  {
6507  update_axis_limits ("ylimmode");
6508  ylimmode.run_listeners (POSTSET);
6509  mark_modified ();
6510  }
6511  }
6512  }
6513 
6514  void set_yminorgrid (const octave_value& val)
6515  {
6516  if (! error_state)
6517  {
6518  if (yminorgrid.set (val, true))
6519  {
6520  mark_modified ();
6521  }
6522  }
6523  }
6524 
6525  void set_yminortick (const octave_value& val)
6526  {
6527  if (! error_state)
6528  {
6529  if (yminortick.set (val, true))
6530  {
6531  mark_modified ();
6532  }
6533  }
6534  }
6535 
6536  void set_yscale (const octave_value& val)
6537  {
6538  if (! error_state)
6539  {
6540  if (yscale.set (val, false))
6541  {
6542  update_yscale ();
6543  update_axis_limits ("yscale");
6544  yscale.run_listeners (POSTSET);
6545  mark_modified ();
6546  }
6547  }
6548  }
6549 
6550  void set_ytick (const octave_value& val)
6551  {
6552  if (! error_state)
6553  {
6554  if (ytick.set (val, false))
6555  {
6556  set_ytickmode ("manual");
6557  update_ytick ();
6558  ytick.run_listeners (POSTSET);
6559  mark_modified ();
6560  }
6561  else
6562  set_ytickmode ("manual");
6563  }
6564  }
6565 
6566  void set_yticklabel (const octave_value& val);
6567 
6569  {
6570  if (! error_state)
6571  {
6572  if (yticklabelmode.set (val, true))
6573  {
6574  update_yticklabelmode ();
6575  mark_modified ();
6576  }
6577  }
6578  }
6579 
6580  void set_ytickmode (const octave_value& val)
6581  {
6582  if (! error_state)
6583  {
6584  if (ytickmode.set (val, true))
6585  {
6586  update_ytickmode ();
6587  mark_modified ();
6588  }
6589  }
6590  }
6591 
6592  void set_zcolor (const octave_value& val)
6593  {
6594  if (! error_state)
6595  {
6596  if (zcolor.set (val, true))
6597  {
6598  mark_modified ();
6599  }
6600  }
6601  }
6602 
6603  void set_zdir (const octave_value& val)
6604  {
6605  if (! error_state)
6606  {
6607  if (zdir.set (val, true))
6608  {
6609  update_zdir ();
6610  mark_modified ();
6611  }
6612  }
6613  }
6614 
6615  void set_zgrid (const octave_value& val)
6616  {
6617  if (! error_state)
6618  {
6619  if (zgrid.set (val, true))
6620  {
6621  mark_modified ();
6622  }
6623  }
6624  }
6625 
6626  void set_zlabel (const octave_value& val);
6627 
6628  void set_zlim (const octave_value& val)
6629  {
6630  if (! error_state)
6631  {
6632  if (zlim.set (val, false))
6633  {
6634  set_zlimmode ("manual");
6635  update_zlim ();
6636  zlim.run_listeners (POSTSET);
6637  mark_modified ();
6638  }
6639  else
6640  set_zlimmode ("manual");
6641  }
6642  }
6643 
6644  void set_zlimmode (const octave_value& val)
6645  {
6646  if (! error_state)
6647  {
6648  if (zlimmode.set (val, false))
6649  {
6650  update_axis_limits ("zlimmode");
6651  zlimmode.run_listeners (POSTSET);
6652  mark_modified ();
6653  }
6654  }
6655  }
6656 
6657  void set_zminorgrid (const octave_value& val)
6658  {
6659  if (! error_state)
6660  {
6661  if (zminorgrid.set (val, true))
6662  {
6663  mark_modified ();
6664  }
6665  }
6666  }
6667 
6668  void set_zminortick (const octave_value& val)
6669  {
6670  if (! error_state)
6671  {
6672  if (zminortick.set (val, true))
6673  {
6674  mark_modified ();
6675  }
6676  }
6677  }
6678 
6679  void set_zscale (const octave_value& val)
6680  {
6681  if (! error_state)
6682  {
6683  if (zscale.set (val, false))
6684  {
6685  update_zscale ();
6686  update_axis_limits ("zscale");
6687  zscale.run_listeners (POSTSET);
6688  mark_modified ();
6689  }
6690  }
6691  }
6692 
6693  void set_ztick (const octave_value& val)
6694  {
6695  if (! error_state)
6696  {
6697  if (ztick.set (val, false))
6698  {
6699  set_ztickmode ("manual");
6700  update_ztick ();
6701  ztick.run_listeners (POSTSET);
6702  mark_modified ();
6703  }
6704  else
6705  set_ztickmode ("manual");
6706  }
6707  }
6708 
6709  void set_zticklabel (const octave_value& val);
6710 
6712  {
6713  if (! error_state)
6714  {
6715  if (zticklabelmode.set (val, true))
6716  {
6717  update_zticklabelmode ();
6718  mark_modified ();
6719  }
6720  }
6721  }
6722 
6723  void set_ztickmode (const octave_value& val)
6724  {
6725  if (! error_state)
6726  {
6727  if (ztickmode.set (val, true))
6728  {
6729  update_ztickmode ();
6730  mark_modified ();
6731  }
6732  }
6733  }
6734 
6735  void set___hold_all__ (const octave_value& val)
6736  {
6737  if (! error_state)
6738  {
6739  if (__hold_all__.set (val, true))
6740  {
6741  mark_modified ();
6742  }
6743  }
6744  }
6745 
6746  void set_autopos_tag (const octave_value& val)
6747  {
6748  if (! error_state)
6749  {
6750  if (autopos_tag.set (val, true))
6751  {
6752  mark_modified ();
6753  }
6754  }
6755  }
6756 
6757  void set_looseinset (const octave_value& val)
6758  {
6759  if (! error_state)
6760  {
6761  if (looseinset.set (val, true))
6762  {
6763  update_looseinset ();
6764  mark_modified ();
6765  }
6766  }
6767  }
6768 
6770  {
6771  if (! error_state)
6772  {
6773  if (x_viewtransform.set (val, true))
6774  {
6775  mark_modified ();
6776  }
6777  }
6778  }
6779 
6781  {
6782  if (! error_state)
6783  {
6784  if (x_projectiontransform.set (val, true))
6785  {
6786  mark_modified ();
6787  }
6788  }
6789  }
6790 
6792  {
6793  if (! error_state)
6794  {
6795  if (x_viewporttransform.set (val, true))
6796  {
6797  mark_modified ();
6798  }
6799  }
6800  }
6801 
6803  {
6804  if (! error_state)
6805  {
6806  if (x_normrendertransform.set (val, true))
6807  {
6808  mark_modified ();
6809  }
6810  }
6811  }
6812 
6814  {
6815  if (! error_state)
6816  {
6817  if (x_rendertransform.set (val, true))
6818  {
6819  mark_modified ();
6820  }
6821  }
6822  }
6823 
6824  void set_xmtick (const octave_value& val)
6825  {
6826  if (! error_state)
6827  {
6828  if (xmtick.set (val, true))
6829  {
6830  mark_modified ();
6831  }
6832  }
6833  }
6834 
6835  void set_ymtick (const octave_value& val)
6836  {
6837  if (! error_state)
6838  {
6839  if (ymtick.set (val, true))
6840  {
6841  mark_modified ();
6842  }
6843  }
6844  }
6845 
6846  void set_zmtick (const octave_value& val)
6847  {
6848  if (! error_state)
6849  {
6850  if (zmtick.set (val, true))
6851  {
6852  mark_modified ();
6853  }
6854  }
6855  }
6856 
6858  {
6859  if (! error_state)
6860  {
6861  if (fontsize_points.set (val, true))
6862  {
6863  mark_modified ();
6864  }
6865  }
6866  }
6867 
6868 
6869  protected:
6870  void init (void);
6871 
6872  private:
6873 
6874  std::string
6875  get_scale (const std::string& scale, const Matrix& lims)
6876  {
6877  std::string retval = scale;
6878 
6879  if (scale == "log" && lims.numel () > 1 && lims(0) < 0 && lims(1) < 0)
6880  retval = "neglog";
6881 
6882  return retval;
6883  }
6884 
6885  void update_xscale (void)
6886  {
6887  sx = get_scale (get_xscale (), xlim.get ().matrix_value ());
6888  }
6889 
6890  void update_yscale (void)
6891  {
6892  sy = get_scale (get_yscale (), ylim.get ().matrix_value ());
6893  }
6894 
6895  void update_zscale (void)
6896  {
6897  sz = get_scale (get_zscale (), zlim.get ().matrix_value ());
6898  }
6899 
6900  void update_view (void) { sync_positions (); }
6901  void update_dataaspectratio (void) { sync_positions (); }
6902  void update_dataaspectratiomode (void) { sync_positions (); }
6903  void update_plotboxaspectratio (void) { sync_positions (); }
6904  void update_plotboxaspectratiomode (void) { sync_positions (); }
6905 
6906  void update_layer (void) { update_axes_layout (); }
6908  {
6909  sync_positions ();
6910  update_axes_layout ();
6911  update_ylabel_position ();
6912  }
6914  {
6915  sync_positions ();
6916  update_axes_layout ();
6917  update_xlabel_position ();
6918  }
6919 
6920  void update_xdir (void) { update_camera (); update_axes_layout (); }
6921  void update_ydir (void) { update_camera (); update_axes_layout (); }
6922  void update_zdir (void) { update_camera (); update_axes_layout (); }
6923 
6924  void update_ticklength (void);
6925  void update_tickdir (void) { update_ticklength (); }
6926  void update_tickdirmode (void) { update_ticklength (); }
6927 
6928  void update_xtick (void)
6929  {
6930  if (xticklabelmode.is ("auto"))
6931  calc_ticklabels (xtick, xticklabel, xscale.is ("log"));
6932  sync_positions ();
6933  }
6934  void update_ytick (void)
6935  {
6936  if (yticklabelmode.is ("auto"))
6937  calc_ticklabels (ytick, yticklabel, yscale.is ("log"));
6938  sync_positions ();
6939  }
6940  void update_ztick (void)
6941  {
6942  if (zticklabelmode.is ("auto"))
6943  calc_ticklabels (ztick, zticklabel, zscale.is ("log"));
6944  sync_positions ();
6945  }
6946 
6947  void update_xtickmode (void)
6948  {
6949  if (xtickmode.is ("auto"))
6950  {
6951  calc_ticks_and_lims (xlim, xtick, xmtick, xlimmode.is ("auto"),
6952  xscale.is ("log"));
6953  update_xtick ();
6954  }
6955  }
6956  void update_ytickmode (void)
6957  {
6958  if (ytickmode.is ("auto"))
6959  {
6960  calc_ticks_and_lims (ylim, ytick, ymtick, ylimmode.is ("auto"),
6961  yscale.is ("log"));
6962  update_ytick ();
6963  }
6964  }
6965  void update_ztickmode (void)
6966  {
6967  if (ztickmode.is ("auto"))
6968  {
6969  calc_ticks_and_lims (zlim, ztick, zmtick, zlimmode.is ("auto"),
6970  zscale.is ("log"));
6971  update_ztick ();
6972  }
6973  }
6974 
6976  {
6977  if (xticklabelmode.is ("auto"))
6978  calc_ticklabels (xtick, xticklabel, xscale.is ("log"));
6979  }
6981  {
6982  if (yticklabelmode.is ("auto"))
6983  calc_ticklabels (ytick, yticklabel, yscale.is ("log"));
6984  }
6986  {
6987  if (zticklabelmode.is ("auto"))
6988  calc_ticklabels (ztick, zticklabel, zscale.is ("log"));
6989  }
6990 
6991  void update_font (void);
6992  void update_fontname (void)
6993  {
6994  update_font ();
6995  sync_positions ();
6996  }
6997  void update_fontsize (void)
6998  {
6999  update_font ();
7000  sync_positions ();
7001  }
7002  void update_fontangle (void)
7003  {
7004  update_font ();
7005  sync_positions ();
7006  }
7007  void update_fontweight (void)
7008  {
7009  update_font ();
7010  sync_positions ();
7011  }
7012 
7014  {
7015  set_activepositionproperty ("outerposition");
7016  caseless_str old_units = get_units ();
7017  set_units ("normalized");
7018  Matrix outerbox = outerposition.get ().matrix_value ();
7019  Matrix innerbox = position.get ().matrix_value ();
7020  Matrix linset = looseinset.get ().matrix_value ();
7021  Matrix tinset = tightinset.get ().matrix_value ();
7022  outerbox(2) = outerbox(2) + outerbox(0);
7023  outerbox(3) = outerbox(3) + outerbox(1);
7024  innerbox(0) = outerbox(0) + std::max (linset(0), tinset(0));
7025  innerbox(1) = outerbox(1) + std::max (linset(1), tinset(1));
7026  innerbox(2) = outerbox(2) - std::max (linset(2), tinset(2));
7027  innerbox(3) = outerbox(3) - std::max (linset(3), tinset(3));
7028  innerbox(2) = innerbox(2) - innerbox(0);
7029  innerbox(3) = innerbox(3) - innerbox(1);
7030  position = innerbox;
7031  set_units (old_units);
7032  update_transform ();
7033  }
7034 
7035  void update_position (void)
7036  {
7037  set_activepositionproperty ("position");
7038  caseless_str old_units = get_units ();
7039  set_units ("normalized");
7040  Matrix outerbox = outerposition.get ().matrix_value ();
7041  Matrix innerbox = position.get ().matrix_value ();
7042  Matrix linset = looseinset.get ().matrix_value ();
7043  Matrix tinset = tightinset.get ().matrix_value ();
7044  innerbox(2) = innerbox(2) + innerbox(0);
7045  innerbox(3) = innerbox(3) + innerbox(1);
7046  outerbox(0) = innerbox(0) - std::max (linset(0), tinset(0));
7047  outerbox(1) = innerbox(1) - std::max (linset(1), tinset(1));
7048  outerbox(2) = innerbox(2) + std::max (linset(2), tinset(2));
7049  outerbox(3) = innerbox(3) + std::max (linset(3), tinset(3));
7050  outerbox(2) = outerbox(2) - outerbox(0);
7051  outerbox(3) = outerbox(3) - outerbox(1);
7052  outerposition = outerbox;
7053  set_units (old_units);
7054  update_transform ();
7055  }
7056 
7057  void update_looseinset (void)
7058  {
7059  caseless_str old_units = get_units ();
7060  set_units ("normalized");
7061  Matrix innerbox = position.get ().matrix_value ();
7062  innerbox(2) = innerbox(2) + innerbox(0);
7063  innerbox(3) = innerbox(3) + innerbox(1);
7064  Matrix outerbox = outerposition.get ().matrix_value ();
7065  outerbox(2) = outerbox(2) + outerbox(0);
7066  outerbox(3) = outerbox(3) + outerbox(1);
7067  Matrix linset = looseinset.get ().matrix_value ();
7068  Matrix tinset = tightinset.get ().matrix_value ();
7069  if (activepositionproperty.is ("position"))
7070  {
7071  outerbox(0) = innerbox(0) - std::max (linset(0), tinset(0));
7072  outerbox(1) = innerbox(1) - std::max (linset(1), tinset(1));
7073  outerbox(2) = innerbox(2) + std::max (linset(2), tinset(2));
7074  outerbox(3) = innerbox(3) + std::max (linset(3), tinset(3));
7075  outerbox(2) = outerbox(2) - outerbox(0);
7076  outerbox(3) = outerbox(3) - outerbox(1);
7077  outerposition = outerbox;
7078  }
7079  else
7080  {
7081  innerbox(0) = outerbox(0) + std::max (linset(0), tinset(0));
7082  innerbox(1) = outerbox(1) + std::max (linset(1), tinset(1));
7083  innerbox(2) = outerbox(2) - std::max (linset(2), tinset(2));
7084  innerbox(3) = outerbox(3) - std::max (linset(3), tinset(3));
7085  innerbox(2) = innerbox(2) - innerbox(0);
7086  innerbox(3) = innerbox(3) - innerbox(1);
7087  position = innerbox;
7088  }
7089  set_units (old_units);
7090  update_transform ();
7091  }
7092 
7093  double calc_tick_sep (double minval, double maxval);
7094  void calc_ticks_and_lims (array_property& lims, array_property& ticks,
7095  array_property& mticks,
7096  bool limmode_is_auto, bool is_logscale);
7097  void calc_ticklabels (const array_property& ticks, any_property& labels,
7098  bool is_logscale);
7099  Matrix get_ticklabel_extents (const Matrix& ticks,
7100  const string_vector& ticklabels,
7101  const Matrix& limits);
7102 
7104  {
7105  if (lims.get ().is_empty ())
7106  return;
7107 
7108  Matrix l = lims.get ().matrix_value ();
7109  if (l(0) > l(1))
7110  {
7111  l(0) = 0;
7112  l(1) = 1;
7113  lims = l;
7114  }
7115  else if (l(0) == l(1))
7116  {
7117  l(0) -= 0.5;
7118  l(1) += 0.5;
7119  lims = l;
7120  }
7121  }
7122 
7123  Matrix calc_tightbox (const Matrix& init_pos);
7124 
7125  public:
7126  Matrix get_axis_limits (double xmin, double xmax,
7127  double min_pos, double max_neg,
7128  bool logscale);
7129 
7130  void update_xlim ()
7131  {
7132  if (xtickmode.is ("auto"))
7133  calc_ticks_and_lims (xlim, xtick, xmtick, xlimmode.is ("auto"),
7134  xscale.is ("log"));
7135  if (xticklabelmode.is ("auto"))
7136  calc_ticklabels (xtick, xticklabel, xscale.is ("log"));
7137 
7138  fix_limits (xlim);
7139 
7140  update_xscale ();
7141 
7142  update_axes_layout ();
7143  }
7144 
7145  void update_ylim (void)
7146  {
7147  if (ytickmode.is ("auto"))
7148  calc_ticks_and_lims (ylim, ytick, ymtick, ylimmode.is ("auto"),
7149  yscale.is ("log"));
7150  if (yticklabelmode.is ("auto"))
7151  calc_ticklabels (ytick, yticklabel, yscale.is ("log"));
7152 
7153  fix_limits (ylim);
7154 
7155  update_yscale ();
7156 
7157  update_axes_layout ();
7158  }
7159 
7160  void update_zlim (void)
7161  {
7162  if (ztickmode.is ("auto"))
7163  calc_ticks_and_lims (zlim, ztick, zmtick, zlimmode.is ("auto"),
7164  zscale.is ("log"));
7165  if (zticklabelmode.is ("auto"))
7166  calc_ticklabels (ztick, zticklabel, zscale.is ("log"));
7167 
7168  fix_limits (zlim);
7169 
7170  update_zscale ();
7171 
7172  update_axes_layout ();
7173  }
7174 
7175  };
7176 
7177 private:
7179 
7180 public:
7181  axes (const graphics_handle& mh, const graphics_handle& p)
7182  : base_graphics_object (), xproperties (mh, p), default_properties ()
7183  {
7184  xproperties.update_transform ();
7185  }
7186 
7187  ~axes (void) { }
7188 
7190  {
7191  // Allow parent (figure) to override first (properties knows how
7192  // to find the parent object).
7193  xproperties.override_defaults (obj);
7194 
7195  // Now override with our defaults. If the default_properties
7196  // list includes the properties for all defaults (line,
7197  // surface, etc.) then we don't have to know the type of OBJ
7198  // here, we just call its set function and let it decide which
7199  // properties from the list to use.
7200  obj.set_from_list (default_properties);
7201  }
7202 
7203  void set (const caseless_str& name, const octave_value& value)
7204  {
7205  if (name.compare ("default", 7))
7206  // strip "default", pass rest to function that will
7207  // parse the remainder and add the element to the
7208  // default_properties map.
7209  default_properties.set (name.substr (7), value);
7210  else
7211  xproperties.set (name, value);
7212  }
7213 
7214  void set_defaults (const std::string& mode)
7215  {
7216  xproperties.set_defaults (*this, mode);
7217  }
7218 
7219  octave_value get (const caseless_str& name) const
7220  {
7221  octave_value retval;
7222 
7223  // FIXME: finish this.
7224  if (name.compare ("default", 7))
7225  retval = get_default (name.substr (7));
7226  else
7227  retval = xproperties.get (name);
7228 
7229  return retval;
7230  }
7231 
7232  octave_value get_default (const caseless_str& name) const;
7233 
7235  {
7236  return default_properties.as_struct ("default");
7237  }
7238 
7240  {
7241  return default_properties;
7242  }
7243 
7244  base_properties& get_properties (void) { return xproperties; }
7245 
7246  const base_properties& get_properties (void) const { return xproperties; }
7247 
7248  void update_axis_limits (const std::string& axis_type);
7249 
7250  void update_axis_limits (const std::string& axis_type,
7251  const graphics_handle& h);
7252 
7253  bool valid_object (void) const { return true; }
7254 
7255  void reset_default_properties (void);
7256 
7257  bool has_readonly_property (const caseless_str& pname) const
7258  {
7259  bool retval = xproperties.has_readonly_property (pname);
7260  if (! retval)
7261  retval = base_properties::has_readonly_property (pname);
7262  return retval;
7263  }
7264 
7265 protected:
7266  void initialize (const graphics_object& go);
7267 
7268 private:
7270 };
7271 
7272 // ---------------------------------------------------------------------
7273 
7275 {
7276 public:
7278  {
7279  public:
7280  // See the genprops.awk script for an explanation of the
7281  // properties declarations.
7282  // Programming note: Keep property list sorted if new ones are added.
7283 
7284 public:
7285  properties (const graphics_handle& mh, const graphics_handle& p);
7286 
7287  ~properties (void) { }
7288 
7289  void set (const caseless_str& pname, const octave_value& val);
7290 
7291  octave_value get (bool all = false) const;
7292 
7293  octave_value get (const caseless_str& pname) const;
7294 
7295  octave_value get (const std::string& pname) const
7296  {
7297  return get (caseless_str (pname));
7298  }
7299 
7300  octave_value get (const char *pname) const
7301  {
7302  return get (caseless_str (pname));
7303  }
7304 
7305  property get_property (const caseless_str& pname);
7306 
7307  std::string graphics_object_name (void) const { return go_name; }
7308 
7310 
7311 private:
7312  static std::string go_name;
7313 
7314 public:
7315 
7316 
7317  static std::set<std::string> core_property_names (void);
7318 
7319  static std::set<std::string> readonly_property_names (void);
7320 
7321  static bool has_core_property (const caseless_str& pname);
7322 
7323  static bool has_readonly_property (const caseless_str& pname);
7324 
7325  std::set<std::string> all_property_names (void) const;
7326 
7327  bool has_property (const caseless_str& pname) const;
7328 
7329 private:
7330 
7353 
7354 public:
7355 
7356  enum
7357  {
7358  ID_COLOR = 4000,
7359  ID_DISPLAYNAME = 4001,
7360  ID_ERASEMODE = 4002,
7361  ID_INTERPRETER = 4003,
7362  ID_LINESTYLE = 4004,
7363  ID_LINEWIDTH = 4005,
7364  ID_MARKER = 4006,
7365  ID_MARKEREDGECOLOR = 4007,
7366  ID_MARKERFACECOLOR = 4008,
7367  ID_MARKERSIZE = 4009,
7368  ID_XDATA = 4010,
7369  ID_XDATASOURCE = 4011,
7370  ID_YDATA = 4012,
7371  ID_YDATASOURCE = 4013,
7372  ID_ZDATA = 4014,
7373  ID_ZDATASOURCE = 4015,
7374  ID_XLIM = 4016,
7375  ID_YLIM = 4017,
7376  ID_ZLIM = 4018,
7377  ID_XLIMINCLUDE = 4019,
7378  ID_YLIMINCLUDE = 4020,
7379  ID_ZLIMINCLUDE = 4021
7380  };
7381 
7382  bool color_is_rgb (void) const { return color.is_rgb (); }
7383  bool color_is (const std::string& v) const { return color.is (v); }
7384  Matrix get_color_rgb (void) const { return (color.is_rgb () ? color.rgb () : Matrix ()); }
7385  octave_value get_color (void) const { return color.get (); }
7386 
7387  std::string get_displayname (void) const { return displayname.string_value (); }
7388 
7389  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
7390  std::string get_erasemode (void) const { return erasemode.current_value (); }
7391 
7392  bool interpreter_is (const std::string& v) const { return interpreter.is (v); }
7393  std::string get_interpreter (void) const { return interpreter.current_value (); }
7394 
7395  bool linestyle_is (const std::string& v) const { return linestyle.is (v); }
7396  std::string get_linestyle (void) const { return linestyle.current_value (); }
7397 
7398  double get_linewidth (void) const { return linewidth.double_value (); }
7399 
7400  bool marker_is (const std::string& v) const { return marker.is (v); }
7401  std::string get_marker (void) const { return marker.current_value (); }
7402 
7403  bool markeredgecolor_is_rgb (void) const { return markeredgecolor.is_rgb (); }
7404  bool markeredgecolor_is (const std::string& v) const { return markeredgecolor.is (v); }
7405  Matrix get_markeredgecolor_rgb (void) const { return (markeredgecolor.is_rgb () ? markeredgecolor.rgb () : Matrix ()); }
7406  octave_value get_markeredgecolor (void) const { return markeredgecolor.get (); }
7407 
7408  bool markerfacecolor_is_rgb (void) const { return markerfacecolor.is_rgb (); }
7409  bool markerfacecolor_is (const std::string& v) const { return markerfacecolor.is (v); }
7410  Matrix get_markerfacecolor_rgb (void) const { return (markerfacecolor.is_rgb () ? markerfacecolor.rgb () : Matrix ()); }
7411  octave_value get_markerfacecolor (void) const { return markerfacecolor.get (); }
7412 
7413  double get_markersize (void) const { return markersize.double_value (); }
7414 
7415  octave_value get_xdata (void) const { return xdata.get (); }
7416 
7417  std::string get_xdatasource (void) const { return xdatasource.string_value (); }
7418 
7419  octave_value get_ydata (void) const { return ydata.get (); }
7420 
7421  std::string get_ydatasource (void) const { return ydatasource.string_value (); }
7422 
7423  octave_value get_zdata (void) const { return zdata.get (); }
7424 
7425  std::string get_zdatasource (void) const { return zdatasource.string_value (); }
7426 
7427  octave_value get_xlim (void) const { return xlim.get (); }
7428 
7429  octave_value get_ylim (void) const { return ylim.get (); }
7430 
7431  octave_value get_zlim (void) const { return zlim.get (); }
7432 
7433  bool is_xliminclude (void) const { return xliminclude.is_on (); }
7434  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
7435 
7436  bool is_yliminclude (void) const { return yliminclude.is_on (); }
7437  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
7438 
7439  bool is_zliminclude (void) const { return zliminclude.is_on (); }
7440  std::string get_zliminclude (void) const { return zliminclude.current_value (); }
7441 
7442 
7443  void set_color (const octave_value& val)
7444  {
7445  if (! error_state)
7446  {
7447  if (color.set (val, true))
7448  {
7449  mark_modified ();
7450  }
7451  }
7452  }
7453 
7454  void set_displayname (const octave_value& val)
7455  {
7456  if (! error_state)
7457  {
7458  if (displayname.set (val, true))
7459  {
7460  mark_modified ();
7461  }
7462  }
7463  }
7464 
7465  void set_erasemode (const octave_value& val)
7466  {
7467  if (! error_state)
7468  {
7469  if (erasemode.set (val, true))
7470  {
7471  mark_modified ();
7472  }
7473  }
7474  }
7475 
7476  void set_interpreter (const octave_value& val)
7477  {
7478  if (! error_state)
7479  {
7480  if (interpreter.set (val, true))
7481  {
7482  mark_modified ();
7483  }
7484  }
7485  }
7486 
7487  void set_linestyle (const octave_value& val)
7488  {
7489  if (! error_state)
7490  {
7491  if (linestyle.set (val, true))
7492  {
7493  mark_modified ();
7494  }
7495  }
7496  }
7497 
7498  void set_linewidth (const octave_value& val)
7499  {
7500  if (! error_state)
7501  {
7502  if (linewidth.set (val, true))
7503  {
7504  mark_modified ();
7505  }
7506  }
7507  }
7508 
7509  void set_marker (const octave_value& val)
7510  {
7511  if (! error_state)
7512  {
7513  if (marker.set (val, true))
7514  {
7515  mark_modified ();
7516  }
7517  }
7518  }
7519 
7521  {
7522  if (! error_state)
7523  {
7524  if (markeredgecolor.set (val, true))
7525  {
7526  mark_modified ();
7527  }
7528  }
7529  }
7530 
7532  {
7533  if (! error_state)
7534  {
7535  if (markerfacecolor.set (val, true))
7536  {
7537  mark_modified ();
7538  }
7539  }
7540  }
7541 
7542  void set_markersize (const octave_value& val)
7543  {
7544  if (! error_state)
7545  {
7546  if (markersize.set (val, true))
7547  {
7548  mark_modified ();
7549  }
7550  }
7551  }
7552 
7553  void set_xdata (const octave_value& val)
7554  {
7555  if (! error_state)
7556  {
7557  if (xdata.set (val, true))
7558  {
7559  update_xdata ();
7560  mark_modified ();
7561  }
7562  }
7563  }
7564 
7565  void set_xdatasource (const octave_value& val)
7566  {
7567  if (! error_state)
7568  {
7569  if (xdatasource.set (val, true))
7570  {
7571  mark_modified ();
7572  }
7573  }
7574  }
7575 
7576  void set_ydata (const octave_value& val)
7577  {
7578  if (! error_state)
7579  {
7580  if (ydata.set (val, true))
7581  {
7582  update_ydata ();
7583  mark_modified ();
7584  }
7585  }
7586  }
7587 
7588  void set_ydatasource (const octave_value& val)
7589  {
7590  if (! error_state)
7591  {
7592  if (ydatasource.set (val, true))
7593  {
7594  mark_modified ();
7595  }
7596  }
7597  }
7598 
7599  void set_zdata (const octave_value& val)
7600  {
7601  if (! error_state)
7602  {
7603  if (zdata.set (val, true))
7604  {
7605  update_zdata ();
7606  mark_modified ();
7607  }
7608  }
7609  }
7610 
7611  void set_zdatasource (const octave_value& val)
7612  {
7613  if (! error_state)
7614  {
7615  if (zdatasource.set (val, true))
7616  {
7617  mark_modified ();
7618  }
7619  }
7620  }
7621 
7622  void set_xlim (const octave_value& val)
7623  {
7624  if (! error_state)
7625  {
7626  if (xlim.set (val, false))
7627  {
7628  update_axis_limits ("xlim");
7629  xlim.run_listeners (POSTSET);
7630  mark_modified ();
7631  }
7632  }
7633  }
7634 
7635  void set_ylim (const octave_value& val)
7636  {
7637  if (! error_state)
7638  {
7639  if (ylim.set (val, false))
7640  {
7641  update_axis_limits ("ylim");
7642  ylim.run_listeners (POSTSET);
7643  mark_modified ();
7644  }
7645  }
7646  }
7647 
7648  void set_zlim (const octave_value& val)
7649  {
7650  if (! error_state)
7651  {
7652  if (zlim.set (val, false))
7653  {
7654  update_axis_limits ("zlim");
7655  zlim.run_listeners (POSTSET);
7656  mark_modified ();
7657  }
7658  }
7659  }
7660 
7661  void set_xliminclude (const octave_value& val)
7662  {
7663  if (! error_state)
7664  {
7665  if (xliminclude.set (val, false))
7666  {
7667  update_axis_limits ("xliminclude");
7668  xliminclude.run_listeners (POSTSET);
7669  mark_modified ();
7670  }
7671  }
7672  }
7673 
7674  void set_yliminclude (const octave_value& val)
7675  {
7676  if (! error_state)
7677  {
7678  if (yliminclude.set (val, false))
7679  {
7680  update_axis_limits ("yliminclude");
7681  yliminclude.run_listeners (POSTSET);
7682  mark_modified ();
7683  }
7684  }
7685  }
7686 
7687  void set_zliminclude (const octave_value& val)
7688  {
7689  if (! error_state)
7690  {
7691  if (zliminclude.set (val, false))
7692  {
7693  update_axis_limits ("zliminclude");
7694  zliminclude.run_listeners (POSTSET);
7695  mark_modified ();
7696  }
7697  }
7698  }
7699 
7700 
7701  private:
7702  Matrix compute_xlim (void) const;
7703  Matrix compute_ylim (void) const;
7704 
7705  void update_xdata (void) { set_xlim (compute_xlim ()); }
7706 
7707  void update_ydata (void) { set_ylim (compute_ylim ()); }
7708 
7709  void update_zdata (void)
7710  {
7711  set_zlim (zdata.get_limits ());
7712  set_zliminclude (get_zdata ().numel () > 0);
7713  }
7714  };
7715 
7716 private:
7718 
7719 public:
7720  line (const graphics_handle& mh, const graphics_handle& p)
7721  : base_graphics_object (), xproperties (mh, p)
7722  { }
7723 
7724  ~line (void) { }
7725 
7726  base_properties& get_properties (void) { return xproperties; }
7727 
7728  const base_properties& get_properties (void) const { return xproperties; }
7729 
7730  bool valid_object (void) const { return true; }
7731 
7732  bool has_readonly_property (const caseless_str& pname) const
7733  {
7734  bool retval = xproperties.has_readonly_property (pname);
7735  if (! retval)
7736  retval = base_properties::has_readonly_property (pname);
7737  return retval;
7738  }
7739 };
7740 
7741 // ---------------------------------------------------------------------
7742 
7744 {
7745 public:
7747  {
7748  public:
7749  double get_fontsize_points (double box_pix_height = 0) const;
7750 
7751  void set_position (const octave_value& val)
7752  {
7753  if (! error_state)
7754  {
7755  octave_value new_val (val);
7756 
7757  if (new_val.numel () == 2)
7758  {
7759  dim_vector dv (1, 3);
7760 
7761  new_val = new_val.resize (dv, true);
7762  }
7763 
7764  if (position.set (new_val, false))
7765  {
7766  set_positionmode ("manual");
7767  update_position ();
7768  position.run_listeners (POSTSET);
7769  mark_modified ();
7770  }
7771  else
7772  set_positionmode ("manual");
7773  }
7774  }
7775 
7776  // See the genprops.awk script for an explanation of the
7777  // properties declarations.
7778 
7779 public:
7780  properties (const graphics_handle& mh, const graphics_handle& p);
7781 
7782  ~properties (void) { }
7783 
7784  void set (const caseless_str& pname, const octave_value& val);
7785 
7786  octave_value get (bool all = false) const;
7787 
7788  octave_value get (const caseless_str& pname) const;
7789 
7790  octave_value get (const std::string& pname) const
7791  {
7792  return get (caseless_str (pname));
7793  }
7794 
7795  octave_value get (const char *pname) const
7796  {
7797  return get (caseless_str (pname));
7798  }
7799 
7800  property get_property (const caseless_str& pname);
7801 
7802  std::string graphics_object_name (void) const { return go_name; }
7803 
7805 
7806 private:
7807  static std::string go_name;
7808 
7809 public:
7810 
7811 
7812  static std::set<std::string> core_property_names (void);
7813 
7814  static std::set<std::string> readonly_property_names (void);
7815 
7816  static bool has_core_property (const caseless_str& pname);
7817 
7818  static bool has_readonly_property (const caseless_str& pname);
7819 
7820  std::set<std::string> all_property_names (void) const;
7821 
7822  bool has_property (const caseless_str& pname) const;
7823 
7824 private:
7825 
7860 
7861 public:
7862 
7863  enum
7864  {
7865  ID_BACKGROUNDCOLOR = 5000,
7866  ID_COLOR = 5001,
7867  ID_DISPLAYNAME = 5002,
7868  ID_EDGECOLOR = 5003,
7869  ID_EDITING = 5004,
7870  ID_ERASEMODE = 5005,
7871  ID_EXTENT = 5006,
7872  ID_FONTANGLE = 5007,
7873  ID_FONTNAME = 5008,
7874  ID_FONTSIZE = 5009,
7875  ID_FONTUNITS = 5010,
7876  ID_FONTWEIGHT = 5011,
7877  ID_HORIZONTALALIGNMENT = 5012,
7878  ID_INTERPRETER = 5013,
7879  ID_LINESTYLE = 5014,
7880  ID_LINEWIDTH = 5015,
7881  ID_MARGIN = 5016,
7882  ID_POSITION = 5017,
7883  ID_ROTATION = 5018,
7884  ID_STRING = 5019,
7885  ID_UNITS = 5020,
7886  ID_VERTICALALIGNMENT = 5021,
7887  ID_XLIM = 5022,
7888  ID_YLIM = 5023,
7889  ID_ZLIM = 5024,
7890  ID_XLIMINCLUDE = 5025,
7891  ID_YLIMINCLUDE = 5026,
7892  ID_ZLIMINCLUDE = 5027,
7893  ID_POSITIONMODE = 5028,
7894  ID_ROTATIONMODE = 5029,
7895  ID_HORIZONTALALIGNMENTMODE = 5030,
7896  ID_VERTICALALIGNMENTMODE = 5031,
7897  ID_AUTOPOS_TAG = 5032,
7898  ID_FONTSIZE_POINTS = 5033
7899  };
7900 
7901  bool backgroundcolor_is_rgb (void) const { return backgroundcolor.is_rgb (); }
7902  bool backgroundcolor_is (const std::string& v) const { return backgroundcolor.is (v); }
7903  Matrix get_backgroundcolor_rgb (void) const { return (backgroundcolor.is_rgb () ? backgroundcolor.rgb () : Matrix ()); }
7904  octave_value get_backgroundcolor (void) const { return backgroundcolor.get (); }
7905 
7906  bool color_is_rgb (void) const { return color.is_rgb (); }
7907  bool color_is (const std::string& v) const { return color.is (v); }
7908  Matrix get_color_rgb (void) const { return (color.is_rgb () ? color.rgb () : Matrix ()); }
7909  octave_value get_color (void) const { return color.get (); }
7910 
7911  std::string get_displayname (void) const { return displayname.string_value (); }
7912 
7913  bool edgecolor_is_rgb (void) const { return edgecolor.is_rgb (); }
7914  bool edgecolor_is (const std::string& v) const { return edgecolor.is (v); }
7915  Matrix get_edgecolor_rgb (void) const { return (edgecolor.is_rgb () ? edgecolor.rgb () : Matrix ()); }
7916  octave_value get_edgecolor (void) const { return edgecolor.get (); }
7917 
7918  bool is_editing (void) const { return editing.is_on (); }
7919  std::string get_editing (void) const { return editing.current_value (); }
7920 
7921  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
7922  std::string get_erasemode (void) const { return erasemode.current_value (); }
7923 
7924  octave_value get_extent (void) const;
7925 
7926  bool fontangle_is (const std::string& v) const { return fontangle.is (v); }
7927  std::string get_fontangle (void) const { return fontangle.current_value (); }
7928 
7929  std::string get_fontname (void) const { return fontname.string_value (); }
7930 
7931  double get_fontsize (void) const { return fontsize.double_value (); }
7932 
7933  bool fontunits_is (const std::string& v) const { return fontunits.is (v); }
7934  std::string get_fontunits (void) const { return fontunits.current_value (); }
7935 
7936  bool fontweight_is (const std::string& v) const { return fontweight.is (v); }
7937  std::string get_fontweight (void) const { return fontweight.current_value (); }
7938 
7939  bool horizontalalignment_is (const std::string& v) const { return horizontalalignment.is (v); }
7940  std::string get_horizontalalignment (void) const { return horizontalalignment.current_value (); }
7941 
7942  bool interpreter_is (const std::string& v) const { return interpreter.is (v); }
7943  std::string get_interpreter (void) const { return interpreter.current_value (); }
7944 
7945  bool linestyle_is (const std::string& v) const { return linestyle.is (v); }
7946  std::string get_linestyle (void) const { return linestyle.current_value (); }
7947 
7948  double get_linewidth (void) const { return linewidth.double_value (); }
7949 
7950  double get_margin (void) const { return margin.double_value (); }
7951 
7952  octave_value get_position (void) const { return position.get (); }
7953 
7954  double get_rotation (void) const { return rotation.double_value (); }
7955 
7956  octave_value get_string (void) const { return string.get (); }
7957 
7958  bool units_is (const std::string& v) const { return units.is (v); }
7959  std::string get_units (void) const { return units.current_value (); }
7960 
7961  bool verticalalignment_is (const std::string& v) const { return verticalalignment.is (v); }
7962  std::string get_verticalalignment (void) const { return verticalalignment.current_value (); }
7963 
7964  octave_value get_xlim (void) const { return xlim.get (); }
7965 
7966  octave_value get_ylim (void) const { return ylim.get (); }
7967 
7968  octave_value get_zlim (void) const { return zlim.get (); }
7969 
7970  bool is_xliminclude (void) const { return xliminclude.is_on (); }
7971  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
7972 
7973  bool is_yliminclude (void) const { return yliminclude.is_on (); }
7974  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
7975 
7976  bool is_zliminclude (void) const { return zliminclude.is_on (); }
7977  std::string get_zliminclude (void) const { return zliminclude.current_value (); }
7978 
7979  bool positionmode_is (const std::string& v) const { return positionmode.is (v); }
7980  std::string get_positionmode (void) const { return positionmode.current_value (); }
7981 
7982  bool rotationmode_is (const std::string& v) const { return rotationmode.is (v); }
7983  std::string get_rotationmode (void) const { return rotationmode.current_value (); }
7984 
7985  bool horizontalalignmentmode_is (const std::string& v) const { return horizontalalignmentmode.is (v); }
7986  std::string get_horizontalalignmentmode (void) const { return horizontalalignmentmode.current_value (); }
7987 
7988  bool verticalalignmentmode_is (const std::string& v) const { return verticalalignmentmode.is (v); }
7989  std::string get_verticalalignmentmode (void) const { return verticalalignmentmode.current_value (); }
7990 
7991  bool autopos_tag_is (const std::string& v) const { return autopos_tag.is (v); }
7992  std::string get_autopos_tag (void) const { return autopos_tag.current_value (); }
7993 
7994 
7996  {
7997  if (! error_state)
7998  {
7999  if (backgroundcolor.set (val, true))
8000  {
8001  mark_modified ();
8002  }
8003  }
8004  }
8005 
8006  void set_color (const octave_value& val)
8007  {
8008  if (! error_state)
8009  {
8010  if (color.set (val, true))
8011  {
8012  update_color ();
8013  mark_modified ();
8014  }
8015  }
8016  }
8017 
8018  void set_displayname (const octave_value& val)
8019  {
8020  if (! error_state)
8021  {
8022  if (displayname.set (val, true))
8023  {
8024  mark_modified ();
8025  }
8026  }
8027  }
8028 
8029  void set_edgecolor (const octave_value& val)
8030  {
8031  if (! error_state)
8032  {
8033  if (edgecolor.set (val, true))
8034  {
8035  mark_modified ();
8036  }
8037  }
8038  }
8039 
8040  void set_editing (const octave_value& val)
8041  {
8042  if (! error_state)
8043  {
8044  if (editing.set (val, true))
8045  {
8046  mark_modified ();
8047  }
8048  }
8049  }
8050 
8051  void set_erasemode (const octave_value& val)
8052  {
8053  if (! error_state)
8054  {
8055  if (erasemode.set (val, true))
8056  {
8057  mark_modified ();
8058  }
8059  }
8060  }
8061 
8062  void set_extent (const octave_value& val)
8063  {
8064  if (! error_state)
8065  {
8066  if (extent.set (val, true))
8067  {
8068  mark_modified ();
8069  }
8070  }
8071  }
8072 
8073  void set_fontangle (const octave_value& val)
8074  {
8075  if (! error_state)
8076  {
8077  if (fontangle.set (val, true))
8078  {
8079  update_fontangle ();
8080  mark_modified ();
8081  }
8082  }
8083  }
8084 
8085  void set_fontname (const octave_value& val)
8086  {
8087  if (! error_state)
8088  {
8089  if (fontname.set (val, true))
8090  {
8091  update_fontname ();
8092  mark_modified ();
8093  }
8094  }
8095  }
8096 
8097  void set_fontsize (const octave_value& val)
8098  {
8099  if (! error_state)
8100  {
8101  if (fontsize.set (val, true))
8102  {
8103  update_fontsize ();
8104  mark_modified ();
8105  }
8106  }
8107  }
8108 
8109  void set_fontunits (const octave_value& val);
8110 
8111  void update_fontunits (void);
8112 
8113  void set_fontweight (const octave_value& val)
8114  {
8115  if (! error_state)
8116  {
8117  if (fontweight.set (val, true))
8118  {
8119  update_fontweight ();
8120  mark_modified ();
8121  }
8122  }
8123  }
8124 
8126  {
8127  if (! error_state)
8128  {
8129  if (horizontalalignment.set (val, false))
8130  {
8131  set_horizontalalignmentmode ("manual");
8132  update_horizontalalignment ();
8133  horizontalalignment.run_listeners (POSTSET);
8134  mark_modified ();
8135  }
8136  else
8137  set_horizontalalignmentmode ("manual");
8138  }
8139  }
8140 
8141  void set_interpreter (const octave_value& val)
8142  {
8143  if (! error_state)
8144  {
8145  if (interpreter.set (val, true))
8146  {
8147  update_interpreter ();
8148  mark_modified ();
8149  }
8150  }
8151  }
8152 
8153  void set_linestyle (const octave_value& val)
8154  {
8155  if (! error_state)
8156  {
8157  if (linestyle.set (val, true))
8158  {
8159  mark_modified ();
8160  }
8161  }
8162  }
8163 
8164  void set_linewidth (const octave_value& val)
8165  {
8166  if (! error_state)
8167  {
8168  if (linewidth.set (val, true))
8169  {
8170  mark_modified ();
8171  }
8172  }
8173  }
8174 
8175  void set_margin (const octave_value& val)
8176  {
8177  if (! error_state)
8178  {
8179  if (margin.set (val, true))
8180  {
8181  mark_modified ();
8182  }
8183  }
8184  }
8185 
8186  void set_rotation (const octave_value& val)
8187  {
8188  if (! error_state)
8189  {
8190  if (rotation.set (val, false))
8191  {
8192  set_rotationmode ("manual");
8193  update_rotation ();
8194  rotation.run_listeners (POSTSET);
8195  mark_modified ();
8196  }
8197  else
8198  set_rotationmode ("manual");
8199  }
8200  }
8201 
8202  void set_string (const octave_value& val)
8203  {
8204  if (! error_state)
8205  {
8206  if (string.set (val, true))
8207  {
8208  update_string ();
8209  mark_modified ();
8210  }
8211  }
8212  }
8213 
8214  void set_units (const octave_value& val)
8215  {
8216  if (! error_state)
8217  {
8218  if (units.set (val, true))
8219  {
8220  update_units ();
8221  mark_modified ();
8222  }
8223  }
8224  }
8225 
8227  {
8228  if (! error_state)
8229  {
8230  if (verticalalignment.set (val, false))
8231  {
8232  set_verticalalignmentmode ("manual");
8233  update_verticalalignment ();
8234  verticalalignment.run_listeners (POSTSET);
8235  mark_modified ();
8236  }
8237  else
8238  set_verticalalignmentmode ("manual");
8239  }
8240  }
8241 
8242  void set_xlim (const octave_value& val)
8243  {
8244  if (! error_state)
8245  {
8246  if (xlim.set (val, false))
8247  {
8248  update_axis_limits ("xlim");
8249  xlim.run_listeners (POSTSET);
8250  mark_modified ();
8251  }
8252  }
8253  }
8254 
8255  void set_ylim (const octave_value& val)
8256  {
8257  if (! error_state)
8258  {
8259  if (ylim.set (val, false))
8260  {
8261  update_axis_limits ("ylim");
8262  ylim.run_listeners (POSTSET);
8263  mark_modified ();
8264  }
8265  }
8266  }
8267 
8268  void set_zlim (const octave_value& val)
8269  {
8270  if (! error_state)
8271  {
8272  if (zlim.set (val, false))
8273  {
8274  update_axis_limits ("zlim");
8275  zlim.run_listeners (POSTSET);
8276  mark_modified ();
8277  }
8278  }
8279  }
8280 
8281  void set_xliminclude (const octave_value& val)
8282  {
8283  if (! error_state)
8284  {
8285  if (xliminclude.set (val, false))
8286  {
8287  update_axis_limits ("xliminclude");
8288  xliminclude.run_listeners (POSTSET);
8289  mark_modified ();
8290  }
8291  }
8292  }
8293 
8294  void set_yliminclude (const octave_value& val)
8295  {
8296  if (! error_state)
8297  {
8298  if (yliminclude.set (val, false))
8299  {
8300  update_axis_limits ("yliminclude");
8301  yliminclude.run_listeners (POSTSET);
8302  mark_modified ();
8303  }
8304  }
8305  }
8306 
8307  void set_zliminclude (const octave_value& val)
8308  {
8309  if (! error_state)
8310  {
8311  if (zliminclude.set (val, false))
8312  {
8313  update_axis_limits ("zliminclude");
8314  zliminclude.run_listeners (POSTSET);
8315  mark_modified ();
8316  }
8317  }
8318  }
8319 
8320  void set_positionmode (const octave_value& val)
8321  {
8322  if (! error_state)
8323  {
8324  if (positionmode.set (val, true))
8325  {
8326  update_positionmode ();
8327  mark_modified ();
8328  }
8329  }
8330  }
8331 
8332  void set_rotationmode (const octave_value& val)
8333  {
8334  if (! error_state)
8335  {
8336  if (rotationmode.set (val, true))
8337  {
8338  update_rotationmode ();
8339  mark_modified ();
8340  }
8341  }
8342  }
8343 
8345  {
8346  if (! error_state)
8347  {
8348  if (horizontalalignmentmode.set (val, true))
8349  {
8350  update_horizontalalignmentmode ();
8351  mark_modified ();
8352  }
8353  }
8354  }
8355 
8357  {
8358  if (! error_state)
8359  {
8360  if (verticalalignmentmode.set (val, true))
8361  {
8362  update_verticalalignmentmode ();
8363  mark_modified ();
8364  }
8365  }
8366  }
8367 
8368  void set_autopos_tag (const octave_value& val)
8369  {
8370  if (! error_state)
8371  {
8372  if (autopos_tag.set (val, true))
8373  {
8374  mark_modified ();
8375  }
8376  }
8377  }
8378 
8380  {
8381  if (! error_state)
8382  {
8383  if (fontsize_points.set (val, true))
8384  {
8385  mark_modified ();
8386  }
8387  }
8388  }
8389 
8390 
8391  Matrix get_data_position (void) const;
8392  Matrix get_extent_matrix (void) const;
8393  const uint8NDArray& get_pixels (void) const { return pixels; }
8394 #if HAVE_FREETYPE
8395  // FreeType renderer, used for calculation of text size
8397 #endif
8398 
8399  protected:
8400  void init (void)
8401  {
8402  position.add_constraint (dim_vector (1, 3));
8403  cached_units = get_units ();
8404  update_font ();
8405  }
8406 
8407  private:
8408  void update_position (void)
8409  {
8410  Matrix pos = get_data_position ();
8411  Matrix lim;
8412 
8413  lim = Matrix (1, 3, pos(0));
8414  lim(2) = (lim(2) <= 0 ? octave_Inf : lim(2));
8415  set_xlim (lim);
8416 
8417  lim = Matrix (1, 3, pos(1));
8418  lim(2) = (lim(2) <= 0 ? octave_Inf : lim(2));
8419  set_ylim (lim);
8420 
8421  if (pos.numel () == 3)
8422  {
8423  lim = Matrix (1, 3, pos(2));
8424  lim(2) = (lim(2) <= 0 ? octave_Inf : lim(2));
8425  set_zliminclude ("on");
8426  set_zlim (lim);
8427  }
8428  else
8429  set_zliminclude ("off");
8430  }
8431 
8432  void update_text_extent (void);
8433 
8434  void request_autopos (void);
8435  void update_positionmode (void) { request_autopos (); }
8436  void update_rotationmode (void) { request_autopos (); }
8437  void update_horizontalalignmentmode (void) { request_autopos (); }
8438  void update_verticalalignmentmode (void) { request_autopos (); }
8439 
8440  void update_font (void);
8441  void update_string (void) { request_autopos (); update_text_extent (); }
8442  void update_rotation (void) { update_text_extent (); }
8443  void update_color (void) { update_font (); update_text_extent (); }
8444  void update_fontname (void) { update_font (); update_text_extent (); }
8445  void update_fontsize (void) { update_font (); update_text_extent (); }
8446  void update_fontangle (void) { update_font (); update_text_extent (); }
8447  void update_fontweight (void) { update_font (); update_text_extent (); }
8448  void update_interpreter (void) { update_text_extent (); }
8449  void update_horizontalalignment (void) { update_text_extent (); }
8450  void update_verticalalignment (void) { update_text_extent (); }
8451 
8452  void update_units (void);
8453  void update_fontunits (const caseless_str& old_fontunits);
8454 
8455  private:
8456  std::string cached_units;
8458  };
8459 
8460 private:
8462 
8463 public:
8464  text (const graphics_handle& mh, const graphics_handle& p)
8465  : base_graphics_object (), xproperties (mh, p)
8466  {
8467  xproperties.set_clipping ("off");
8468  }
8469 
8470  ~text (void) { }
8471 
8472  base_properties& get_properties (void) { return xproperties; }
8473 
8474  const base_properties& get_properties (void) const { return xproperties; }
8475 
8476  bool valid_object (void) const { return true; }
8477 
8478  bool has_readonly_property (const caseless_str& pname) const
8479  {
8480  bool retval = xproperties.has_readonly_property (pname);
8481  if (! retval)
8482  retval = base_properties::has_readonly_property (pname);
8483  return retval;
8484  }
8485 };
8486 
8487 // ---------------------------------------------------------------------
8488 
8490 {
8491 public:
8493  {
8494  public:
8495  bool is_aliminclude (void) const
8496  { return (aliminclude.is_on () && alphadatamapping.is ("scaled")); }
8497  std::string get_aliminclude (void) const
8498  { return aliminclude.current_value (); }
8499 
8500  bool is_climinclude (void) const
8501  { return (climinclude.is_on () && cdatamapping.is ("scaled")); }
8502  std::string get_climinclude (void) const
8503  { return climinclude.current_value (); }
8504 
8505  octave_value get_color_data (void) const;
8506 
8507  void initialize_data (void) { update_cdata (); }
8508 
8509  // See the genprops.awk script for an explanation of the
8510  // properties declarations.
8511  // Programming note: Keep property list sorted if new ones are added.
8512 
8513 public:
8514  properties (const graphics_handle& mh, const graphics_handle& p);
8515 
8516  ~properties (void) { }
8517 
8518  void set (const caseless_str& pname, const octave_value& val);
8519 
8520  octave_value get (bool all = false) const;
8521 
8522  octave_value get (const caseless_str& pname) const;
8523 
8524  octave_value get (const std::string& pname) const
8525  {
8526  return get (caseless_str (pname));
8527  }
8528 
8529  octave_value get (const char *pname) const
8530  {
8531  return get (caseless_str (pname));
8532  }
8533 
8534  property get_property (const caseless_str& pname);
8535 
8536  std::string graphics_object_name (void) const { return go_name; }
8537 
8539 
8540 private:
8541  static std::string go_name;
8542 
8543 public:
8544 
8545 
8546  static std::set<std::string> core_property_names (void);
8547 
8548  static std::set<std::string> readonly_property_names (void);
8549 
8550  static bool has_core_property (const caseless_str& pname);
8551 
8552  static bool has_readonly_property (const caseless_str& pname);
8553 
8554  std::set<std::string> all_property_names (void) const;
8555 
8556  bool has_property (const caseless_str& pname) const;
8557 
8558 private:
8559 
8578 
8579 public:
8580 
8581  enum
8582  {
8583  ID_ALPHADATA = 6000,
8584  ID_ALPHADATAMAPPING = 6001,
8585  ID_CDATA = 6002,
8586  ID_CDATAMAPPING = 6003,
8587  ID_DISPLAYNAME = 6004,
8588  ID_ERASEMODE = 6005,
8589  ID_XDATA = 6006,
8590  ID_YDATA = 6007,
8591  ID_ALIM = 6008,
8592  ID_CLIM = 6009,
8593  ID_XLIM = 6010,
8594  ID_YLIM = 6011,
8595  ID_ALIMINCLUDE = 6012,
8596  ID_CLIMINCLUDE = 6013,
8597  ID_XLIMINCLUDE = 6014,
8598  ID_YLIMINCLUDE = 6015,
8599  ID_XDATAMODE = 6016,
8600  ID_YDATAMODE = 6017
8601  };
8602 
8603  octave_value get_alphadata (void) const { return alphadata.get (); }
8604 
8605  bool alphadatamapping_is (const std::string& v) const { return alphadatamapping.is (v); }
8606  std::string get_alphadatamapping (void) const { return alphadatamapping.current_value (); }
8607 
8608  octave_value get_cdata (void) const { return cdata.get (); }
8609 
8610  bool cdatamapping_is (const std::string& v) const { return cdatamapping.is (v); }
8611  std::string get_cdatamapping (void) const { return cdatamapping.current_value (); }
8612 
8613  std::string get_displayname (void) const { return displayname.string_value (); }
8614 
8615  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
8616  std::string get_erasemode (void) const { return erasemode.current_value (); }
8617 
8618  octave_value get_xdata (void) const { return xdata.get (); }
8619 
8620  octave_value get_ydata (void) const { return ydata.get (); }
8621 
8622  octave_value get_alim (void) const { return alim.get (); }
8623 
8624  octave_value get_clim (void) const { return clim.get (); }
8625 
8626  octave_value get_xlim (void) const { return xlim.get (); }
8627 
8628  octave_value get_ylim (void) const { return ylim.get (); }
8629 
8630  bool is_xliminclude (void) const { return xliminclude.is_on (); }
8631  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
8632 
8633  bool is_yliminclude (void) const { return yliminclude.is_on (); }
8634  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
8635 
8636  bool xdatamode_is (const std::string& v) const { return xdatamode.is (v); }
8637  std::string get_xdatamode (void) const { return xdatamode.current_value (); }
8638 
8639  bool ydatamode_is (const std::string& v) const { return ydatamode.is (v); }
8640  std::string get_ydatamode (void) const { return ydatamode.current_value (); }
8641 
8642 
8643  void set_alphadata (const octave_value& val)
8644  {
8645  if (! error_state)
8646  {
8647  if (alphadata.set (val, true))
8648  {
8649  update_alphadata ();
8650  mark_modified ();
8651  }
8652  }
8653  }
8654 
8656  {
8657  if (! error_state)
8658  {
8659  if (alphadatamapping.set (val, false))
8660  {
8661  update_axis_limits ("alphadatamapping");
8662  alphadatamapping.run_listeners (POSTSET);
8663  mark_modified ();
8664  }
8665  }
8666  }
8667 
8668  void set_cdata (const octave_value& val)
8669  {
8670  if (! error_state)
8671  {
8672  if (cdata.set (val, true))
8673  {
8674  update_cdata ();
8675  mark_modified ();
8676  }
8677  }
8678  }
8679 
8680  void set_cdatamapping (const octave_value& val)
8681  {
8682  if (! error_state)
8683  {
8684  if (cdatamapping.set (val, false))
8685  {
8686  update_axis_limits ("cdatamapping");
8687  cdatamapping.run_listeners (POSTSET);
8688  mark_modified ();
8689  }
8690  }
8691  }
8692 
8693  void set_displayname (const octave_value& val)
8694  {
8695  if (! error_state)
8696  {
8697  if (displayname.set (val, true))
8698  {
8699  mark_modified ();
8700  }
8701  }
8702  }
8703 
8704  void set_erasemode (const octave_value& val)
8705  {
8706  if (! error_state)
8707  {
8708  if (erasemode.set (val, true))
8709  {
8710  mark_modified ();
8711  }
8712  }
8713  }
8714 
8715  void set_xdata (const octave_value& val)
8716  {
8717  if (! error_state)
8718  {
8719  if (xdata.set (val, false))
8720  {
8721  set_xdatamode ("manual");
8722  update_xdata ();
8723  xdata.run_listeners (POSTSET);
8724  mark_modified ();
8725  }
8726  else
8727  set_xdatamode ("manual");
8728  }
8729  }
8730 
8731  void set_ydata (const octave_value& val)
8732  {
8733  if (! error_state)
8734  {
8735  if (ydata.set (val, false))
8736  {
8737  set_ydatamode ("manual");
8738  update_ydata ();
8739  ydata.run_listeners (POSTSET);
8740  mark_modified ();
8741  }
8742  else
8743  set_ydatamode ("manual");
8744  }
8745  }
8746 
8747  void set_alim (const octave_value& val)
8748  {
8749  if (! error_state)
8750  {
8751  if (alim.set (val, false))
8752  {
8753  update_axis_limits ("alim");
8754  alim.run_listeners (POSTSET);
8755  mark_modified ();
8756  }
8757  }
8758  }
8759 
8760  void set_clim (const octave_value& val)
8761  {
8762  if (! error_state)
8763  {
8764  if (clim.set (val, false))
8765  {
8766  update_axis_limits ("clim");
8767  clim.run_listeners (POSTSET);
8768  mark_modified ();
8769  }
8770  }
8771  }
8772 
8773  void set_xlim (const octave_value& val)
8774  {
8775  if (! error_state)
8776  {
8777  if (xlim.set (val, false))
8778  {
8779  update_axis_limits ("xlim");
8780  xlim.run_listeners (POSTSET);
8781  mark_modified ();
8782  }
8783  }
8784  }
8785 
8786  void set_ylim (const octave_value& val)
8787  {
8788  if (! error_state)
8789  {
8790  if (ylim.set (val, false))
8791  {
8792  update_axis_limits ("ylim");
8793  ylim.run_listeners (POSTSET);
8794  mark_modified ();
8795  }
8796  }
8797  }
8798 
8799  void set_aliminclude (const octave_value& val)
8800  {
8801  if (! error_state)
8802  {
8803  if (aliminclude.set (val, false))
8804  {
8805  update_axis_limits ("aliminclude");
8806  aliminclude.run_listeners (POSTSET);
8807  mark_modified ();
8808  }
8809  }
8810  }
8811 
8812  void set_climinclude (const octave_value& val)
8813  {
8814  if (! error_state)
8815  {
8816  if (climinclude.set (val, false))
8817  {
8818  update_axis_limits ("climinclude");
8819  climinclude.run_listeners (POSTSET);
8820  mark_modified ();
8821  }
8822  }
8823  }
8824 
8825  void set_xliminclude (const octave_value& val)
8826  {
8827  if (! error_state)
8828  {
8829  if (xliminclude.set (val, false))
8830  {
8831  update_axis_limits ("xliminclude");
8832  xliminclude.run_listeners (POSTSET);
8833  mark_modified ();
8834  }
8835  }
8836  }
8837 
8838  void set_yliminclude (const octave_value& val)
8839  {
8840  if (! error_state)
8841  {
8842  if (yliminclude.set (val, false))
8843  {
8844  update_axis_limits ("yliminclude");
8845  yliminclude.run_listeners (POSTSET);
8846  mark_modified ();
8847  }
8848  }
8849  }
8850 
8851  void set_xdatamode (const octave_value& val)
8852  {
8853  if (! error_state)
8854  {
8855  if (xdatamode.set (val, true))
8856  {
8857  mark_modified ();
8858  }
8859  }
8860  }
8861 
8862  void set_ydatamode (const octave_value& val)
8863  {
8864  if (! error_state)
8865  {
8866  if (ydatamode.set (val, true))
8867  {
8868  mark_modified ();
8869  }
8870  }
8871  }
8872 
8873 
8874  protected:
8875  void init (void)
8876  {
8877  xdata.add_constraint (2);
8878  ydata.add_constraint (2);
8879  cdata.add_constraint ("double");
8880  cdata.add_constraint ("single");
8881  cdata.add_constraint ("logical");
8882  cdata.add_constraint ("uint8");
8883  cdata.add_constraint ("uint16");
8884  cdata.add_constraint ("int16");
8885  cdata.add_constraint ("real");
8886  cdata.add_constraint (dim_vector (-1, -1));
8887  cdata.add_constraint (dim_vector (-1, -1, 3));
8888  alphadata.add_constraint (dim_vector (-1, -1));
8889  alphadata.add_constraint ("double");
8890  alphadata.add_constraint ("uint8");
8891  }
8892 
8893  private:
8894  void update_alphadata (void)
8895  {
8896  if (alphadatamapping_is ("scaled"))
8897  set_alim (alphadata.get_limits ());
8898  else
8899  alim = alphadata.get_limits ();
8900  }
8901 
8902  void update_cdata (void)
8903  {
8904  if (cdatamapping_is ("scaled"))
8905  set_clim (cdata.get_limits ());
8906  else
8907  clim = cdata.get_limits ();
8908 
8909  if (xdatamode.is ("auto"))
8910  update_xdata ();
8911 
8912  if (ydatamode.is ("auto"))
8913  update_ydata ();
8914  }
8915 
8916  void update_xdata (void)
8917  {
8918  if (xdata.get ().is_empty ())
8919  set_xdatamode ("auto");
8920 
8921  if (xdatamode.is ("auto"))
8922  {
8923  set_xdata (get_auto_xdata ());
8924  set_xdatamode ("auto");
8925  }
8926 
8927  Matrix limits = xdata.get_limits ();
8928  float dp = pixel_xsize ();
8929 
8930  limits(0) = limits(0) - dp;
8931  limits(1) = limits(1) + dp;
8932  set_xlim (limits);
8933  }
8934 
8935  void update_ydata (void)
8936  {
8937  if (ydata.get ().is_empty ())
8938  set_ydatamode ("auto");
8939 
8940  if (ydatamode.is ("auto"))
8941  {
8942  set_ydata (get_auto_ydata ());
8943  set_ydatamode ("auto");
8944  }
8945 
8946  Matrix limits = ydata.get_limits ();
8947  float dp = pixel_ysize ();
8948 
8949  limits(0) = limits(0) - dp;
8950  limits(1) = limits(1) + dp;
8951  set_ylim (limits);
8952  }
8953 
8955  {
8956  dim_vector dv = get_cdata ().dims ();
8957  Matrix data;
8958  if (dv(1) > 0.)
8959  {
8960  data = Matrix (1, 2, 1);
8961  data(1) = dv(1);
8962  }
8963  return data;
8964  }
8965 
8967  {
8968  dim_vector dv = get_cdata ().dims ();
8969  Matrix data;
8970  if (dv(0) > 0.)
8971  {
8972  data = Matrix (1, 2, 1);
8973  data(1) = dv(0);
8974  }
8975  return data;
8976  }
8977 
8978  float pixel_size (octave_idx_type dim, const Matrix limits)
8979  {
8980  octave_idx_type l = dim - 1;
8981  float dp;
8982 
8983  if (l > 0 && limits(0) != limits(1))
8984  dp = (limits(1) - limits(0))/(2*l);
8985  else
8986  {
8987  if (limits(1) == limits(2))
8988  dp = 0.5;
8989  else
8990  dp = (limits(1) - limits(0))/2;
8991  }
8992  return dp;
8993  }
8994 
8995  public:
8996  float pixel_xsize (void)
8997  {
8998  return pixel_size ((get_cdata ().dims ())(1), xdata.get_limits ());
8999  }
9000 
9001  float pixel_ysize (void)
9002  {
9003  return pixel_size ((get_cdata ().dims ())(0), ydata.get_limits ());
9004  }
9005  };
9006 
9007 private:
9009 
9010 public:
9011  image (const graphics_handle& mh, const graphics_handle& p)
9012  : base_graphics_object (), xproperties (mh, p)
9013  {
9014  xproperties.initialize_data ();
9015  }
9016 
9017  ~image (void) { }
9018 
9019  base_properties& get_properties (void) { return xproperties; }
9020 
9021  const base_properties& get_properties (void) const { return xproperties; }
9022 
9023  bool valid_object (void) const { return true; }
9024 
9025  bool has_readonly_property (const caseless_str& pname) const
9026  {
9027  bool retval = xproperties.has_readonly_property (pname);
9028  if (! retval)
9029  retval = base_properties::has_readonly_property (pname);
9030  return retval;
9031  }
9032 };
9033 
9034 // ---------------------------------------------------------------------
9035 
9037 {
9038 public:
9040  {
9041  public:
9042  octave_value get_color_data (void) const;
9043 
9044  // Matlab allows incoherent data to be stored into patch properties.
9045  // The patch should then be ignored by the renderer.
9046  bool has_bad_data (std::string &msg) const
9047  {
9048  msg = bad_data_msg;
9049  return ! msg.empty ();
9050  }
9051 
9052  bool is_aliminclude (void) const
9053  { return (aliminclude.is_on () && alphadatamapping.is ("scaled")); }
9054  std::string get_aliminclude (void) const
9055  { return aliminclude.current_value (); }
9056 
9057  bool is_climinclude (void) const
9058  { return (climinclude.is_on () && cdatamapping.is ("scaled")); }
9059  std::string get_climinclude (void) const
9060  { return climinclude.current_value (); }
9061 
9062  // See the genprops.awk script for an explanation of the
9063  // properties declarations.
9064  // Programming note: Keep property list sorted if new ones are added.
9065 
9066 public:
9067  properties (const graphics_handle& mh, const graphics_handle& p);
9068 
9069  ~properties (void) { }
9070 
9071  void set (const caseless_str& pname, const octave_value& val);
9072 
9073  octave_value get (bool all = false) const;
9074 
9075  octave_value get (const caseless_str& pname) const;
9076 
9077  octave_value get (const std::string& pname) const
9078  {
9079  return get (caseless_str (pname));
9080  }
9081 
9082  octave_value get (const char *pname) const
9083  {
9084  return get (caseless_str (pname));
9085  }
9086 
9087  property get_property (const caseless_str& pname);
9088 
9089  std::string graphics_object_name (void) const { return go_name; }
9090 
9092 
9093 private:
9094  static std::string go_name;
9095 
9096 public:
9097 
9098 
9099  static std::set<std::string> core_property_names (void);
9100 
9101  static std::set<std::string> readonly_property_names (void);
9102 
9103  static bool has_core_property (const caseless_str& pname);
9104 
9105  static bool has_readonly_property (const caseless_str& pname);
9106 
9107  std::set<std::string> all_property_names (void) const;
9108 
9109  bool has_property (const caseless_str& pname) const;
9110 
9111 private:
9112 
9156 
9157 public:
9158 
9159  enum
9160  {
9161  ID_ALPHADATAMAPPING = 7000,
9162  ID_AMBIENTSTRENGTH = 7001,
9163  ID_BACKFACELIGHTING = 7002,
9164  ID_CDATA = 7003,
9165  ID_CDATAMAPPING = 7004,
9166  ID_DIFFUSESTRENGTH = 7005,
9167  ID_DISPLAYNAME = 7006,
9168  ID_EDGEALPHA = 7007,
9169  ID_EDGECOLOR = 7008,
9170  ID_EDGELIGHTING = 7009,
9171  ID_ERASEMODE = 7010,
9172  ID_FACEALPHA = 7011,
9173  ID_FACECOLOR = 7012,
9174  ID_FACELIGHTING = 7013,
9175  ID_FACES = 7014,
9176  ID_FACEVERTEXALPHADATA = 7015,
9177  ID_FACEVERTEXCDATA = 7016,
9178  ID_INTERPRETER = 7017,
9179  ID_LINESTYLE = 7018,
9180  ID_LINEWIDTH = 7019,
9181  ID_MARKER = 7020,
9182  ID_MARKEREDGECOLOR = 7021,
9183  ID_MARKERFACECOLOR = 7022,
9184  ID_MARKERSIZE = 7023,
9185  ID_NORMALMODE = 7024,
9186  ID_SPECULARCOLORREFLECTANCE = 7025,
9187  ID_SPECULAREXPONENT = 7026,
9188  ID_SPECULARSTRENGTH = 7027,
9189  ID_VERTEXNORMALS = 7028,
9190  ID_VERTICES = 7029,
9191  ID_XDATA = 7030,
9192  ID_YDATA = 7031,
9193  ID_ZDATA = 7032,
9194  ID_ALIM = 7033,
9195  ID_CLIM = 7034,
9196  ID_XLIM = 7035,
9197  ID_YLIM = 7036,
9198  ID_ZLIM = 7037,
9199  ID_ALIMINCLUDE = 7038,
9200  ID_CLIMINCLUDE = 7039,
9201  ID_XLIMINCLUDE = 7040,
9202  ID_YLIMINCLUDE = 7041,
9203  ID_ZLIMINCLUDE = 7042
9204  };
9205 
9206  bool alphadatamapping_is (const std::string& v) const { return alphadatamapping.is (v); }
9207  std::string get_alphadatamapping (void) const { return alphadatamapping.current_value (); }
9208 
9209  double get_ambientstrength (void) const { return ambientstrength.double_value (); }
9210 
9211  bool backfacelighting_is (const std::string& v) const { return backfacelighting.is (v); }
9212  std::string get_backfacelighting (void) const { return backfacelighting.current_value (); }
9213 
9214  octave_value get_cdata (void) const { return cdata.get (); }
9215 
9216  bool cdatamapping_is (const std::string& v) const { return cdatamapping.is (v); }
9217  std::string get_cdatamapping (void) const { return cdatamapping.current_value (); }
9218 
9219  double get_diffusestrength (void) const { return diffusestrength.double_value (); }
9220 
9221  std::string get_displayname (void) const { return displayname.string_value (); }
9222 
9223  bool edgealpha_is_double (void) const { return edgealpha.is_double (); }
9224  bool edgealpha_is (const std::string& v) const { return edgealpha.is (v); }
9225  double get_edgealpha_double (void) const { return (edgealpha.is_double () ? edgealpha.double_value () : 0); }
9226  octave_value get_edgealpha (void) const { return edgealpha.get (); }
9227 
9228  bool edgecolor_is_rgb (void) const { return edgecolor.is_rgb (); }
9229  bool edgecolor_is (const std::string& v) const { return edgecolor.is (v); }
9230  Matrix get_edgecolor_rgb (void) const { return (edgecolor.is_rgb () ? edgecolor.rgb () : Matrix ()); }
9231  octave_value get_edgecolor (void) const { return edgecolor.get (); }
9232 
9233  bool edgelighting_is (const std::string& v) const { return edgelighting.is (v); }
9234  std::string get_edgelighting (void) const { return edgelighting.current_value (); }
9235 
9236  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
9237  std::string get_erasemode (void) const { return erasemode.current_value (); }
9238 
9239  bool facealpha_is_double (void) const { return facealpha.is_double (); }
9240  bool facealpha_is (const std::string& v) const { return facealpha.is (v); }
9241  double get_facealpha_double (void) const { return (facealpha.is_double () ? facealpha.double_value () : 0); }
9242  octave_value get_facealpha (void) const { return facealpha.get (); }
9243 
9244  bool facecolor_is_rgb (void) const { return facecolor.is_rgb (); }
9245  bool facecolor_is (const std::string& v) const { return facecolor.is (v); }
9246  Matrix get_facecolor_rgb (void) const { return (facecolor.is_rgb () ? facecolor.rgb () : Matrix ()); }
9247  octave_value get_facecolor (void) const { return facecolor.get (); }
9248 
9249  bool facelighting_is (const std::string& v) const { return facelighting.is (v); }
9250  std::string get_facelighting (void) const { return facelighting.current_value (); }
9251 
9252  octave_value get_faces (void) const { return faces.get (); }
9253 
9254  octave_value get_facevertexalphadata (void) const { return facevertexalphadata.get (); }
9255 
9256  octave_value get_facevertexcdata (void) const { return facevertexcdata.get (); }
9257 
9258  bool interpreter_is (const std::string& v) const { return interpreter.is (v); }
9259  std::string get_interpreter (void) const { return interpreter.current_value (); }
9260 
9261  bool linestyle_is (const std::string& v) const { return linestyle.is (v); }
9262  std::string get_linestyle (void) const { return linestyle.current_value (); }
9263 
9264  double get_linewidth (void) const { return linewidth.double_value (); }
9265 
9266  bool marker_is (const std::string& v) const { return marker.is (v); }
9267  std::string get_marker (void) const { return marker.current_value (); }
9268 
9269  bool markeredgecolor_is_rgb (void) const { return markeredgecolor.is_rgb (); }
9270  bool markeredgecolor_is (const std::string& v) const { return markeredgecolor.is (v); }
9271  Matrix get_markeredgecolor_rgb (void) const { return (markeredgecolor.is_rgb () ? markeredgecolor.rgb () : Matrix ()); }
9272  octave_value get_markeredgecolor (void) const { return markeredgecolor.get (); }
9273 
9274  bool markerfacecolor_is_rgb (void) const { return markerfacecolor.is_rgb (); }
9275  bool markerfacecolor_is (const std::string& v) const { return markerfacecolor.is (v); }
9276  Matrix get_markerfacecolor_rgb (void) const { return (markerfacecolor.is_rgb () ? markerfacecolor.rgb () : Matrix ()); }
9277  octave_value get_markerfacecolor (void) const { return markerfacecolor.get (); }
9278 
9279  double get_markersize (void) const { return markersize.double_value (); }
9280 
9281  bool normalmode_is (const std::string& v) const { return normalmode.is (v); }
9282  std::string get_normalmode (void) const { return normalmode.current_value (); }
9283 
9284  double get_specularcolorreflectance (void) const { return specularcolorreflectance.double_value (); }
9285 
9286  double get_specularexponent (void) const { return specularexponent.double_value (); }
9287 
9288  double get_specularstrength (void) const { return specularstrength.double_value (); }
9289 
9290  octave_value get_vertexnormals (void) const { return vertexnormals.get (); }
9291 
9292  octave_value get_vertices (void) const { return vertices.get (); }
9293 
9294  octave_value get_xdata (void) const { return xdata.get (); }
9295 
9296  octave_value get_ydata (void) const { return ydata.get (); }
9297 
9298  octave_value get_zdata (void) const { return zdata.get (); }
9299 
9300  octave_value get_alim (void) const { return alim.get (); }
9301 
9302  octave_value get_clim (void) const { return clim.get (); }
9303 
9304  octave_value get_xlim (void) const { return xlim.get (); }
9305 
9306  octave_value get_ylim (void) const { return ylim.get (); }
9307 
9308  octave_value get_zlim (void) const { return zlim.get (); }
9309 
9310  bool is_xliminclude (void) const { return xliminclude.is_on (); }
9311  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
9312 
9313  bool is_yliminclude (void) const { return yliminclude.is_on (); }
9314  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
9315 
9316  bool is_zliminclude (void) const { return zliminclude.is_on (); }
9317  std::string get_zliminclude (void) const { return zliminclude.current_value (); }
9318 
9319 
9321  {
9322  if (! error_state)
9323  {
9324  if (alphadatamapping.set (val, false))
9325  {
9326  update_axis_limits ("alphadatamapping");
9327  alphadatamapping.run_listeners (POSTSET);
9328  mark_modified ();
9329  }
9330  }
9331  }
9332 
9334  {
9335  if (! error_state)
9336  {
9337  if (ambientstrength.set (val, true))
9338  {
9339  mark_modified ();
9340  }
9341  }
9342  }
9343 
9345  {
9346  if (! error_state)
9347  {
9348  if (backfacelighting.set (val, true))
9349  {
9350  mark_modified ();
9351  }
9352  }
9353  }
9354 
9355  void set_cdata (const octave_value& val)
9356  {
9357  if (! error_state)
9358  {
9359  if (cdata.set (val, true))
9360  {
9361  update_cdata ();
9362  mark_modified ();
9363  }
9364  }
9365  }
9366 
9367  void set_cdatamapping (const octave_value& val)
9368  {
9369  if (! error_state)
9370  {
9371  if (cdatamapping.set (val, false))
9372  {
9373  update_axis_limits ("cdatamapping");
9374  cdatamapping.run_listeners (POSTSET);
9375  mark_modified ();
9376  }
9377  }
9378  }
9379 
9381  {
9382  if (! error_state)
9383  {
9384  if (diffusestrength.set (val, true))
9385  {
9386  mark_modified ();
9387  }
9388  }
9389  }
9390 
9391  void set_displayname (const octave_value& val)
9392  {
9393  if (! error_state)
9394  {
9395  if (displayname.set (val, true))
9396  {
9397  mark_modified ();
9398  }
9399  }
9400  }
9401 
9402  void set_edgealpha (const octave_value& val)
9403  {
9404  if (! error_state)
9405  {
9406  if (edgealpha.set (val, true))
9407  {
9408  mark_modified ();
9409  }
9410  }
9411  }
9412 
9413  void set_edgecolor (const octave_value& val)
9414  {
9415  if (! error_state)
9416  {
9417  if (edgecolor.set (val, true))
9418  {
9419  mark_modified ();
9420  }
9421  }
9422  }
9423 
9424  void set_edgelighting (const octave_value& val)
9425  {
9426  if (! error_state)
9427  {
9428  if (edgelighting.set (val, true))
9429  {
9430  mark_modified ();
9431  }
9432  }
9433  }
9434 
9435  void set_erasemode (const octave_value& val)
9436  {
9437  if (! error_state)
9438  {
9439  if (erasemode.set (val, true))
9440  {
9441  mark_modified ();
9442  }
9443  }
9444  }
9445 
9446  void set_facealpha (const octave_value& val)
9447  {
9448  if (! error_state)
9449  {
9450  if (facealpha.set (val, true))
9451  {
9452  mark_modified ();
9453  }
9454  }
9455  }
9456 
9457  void set_facecolor (const octave_value& val)
9458  {
9459  if (! error_state)
9460  {
9461  if (facecolor.set (val, true))
9462  {
9463  mark_modified ();
9464  }
9465  }
9466  }
9467 
9468  void set_facelighting (const octave_value& val)
9469  {
9470  if (! error_state)
9471  {
9472  if (facelighting.set (val, true))
9473  {
9474  mark_modified ();
9475  }
9476  }
9477  }
9478 
9479  void set_faces (const octave_value& val)
9480  {
9481  if (! error_state)
9482  {
9483  if (faces.set (val, true))
9484  {
9485  update_faces ();
9486  mark_modified ();
9487  }
9488  }
9489  }
9490 
9492  {
9493  if (! error_state)
9494  {
9495  if (facevertexalphadata.set (val, true))
9496  {
9497  mark_modified ();
9498  }
9499  }
9500  }
9501 
9503  {
9504  if (! error_state)
9505  {
9506  if (facevertexcdata.set (val, true))
9507  {
9508  update_facevertexcdata ();
9509  mark_modified ();
9510  }
9511  }
9512  }
9513 
9514  void set_interpreter (const octave_value& val)
9515  {
9516  if (! error_state)
9517  {
9518  if (interpreter.set (val, true))
9519  {
9520  mark_modified ();
9521  }
9522  }
9523  }
9524 
9525  void set_linestyle (const octave_value& val)
9526  {
9527  if (! error_state)
9528  {
9529  if (linestyle.set (val, true))
9530  {
9531  mark_modified ();
9532  }
9533  }
9534  }
9535 
9536  void set_linewidth (const octave_value& val)
9537  {
9538  if (! error_state)
9539  {
9540  if (linewidth.set (val, true))
9541  {
9542  mark_modified ();
9543  }
9544  }
9545  }
9546 
9547  void set_marker (const octave_value& val)
9548  {
9549  if (! error_state)
9550  {
9551  if (marker.set (val, true))
9552  {
9553  mark_modified ();
9554  }
9555  }
9556  }
9557 
9559  {
9560  if (! error_state)
9561  {
9562  if (markeredgecolor.set (val, true))
9563  {
9564  mark_modified ();
9565  }
9566  }
9567  }
9568 
9570  {
9571  if (! error_state)
9572  {
9573  if (markerfacecolor.set (val, true))
9574  {
9575  mark_modified ();
9576  }
9577  }
9578  }
9579 
9580  void set_markersize (const octave_value& val)
9581  {
9582  if (! error_state)
9583  {
9584  if (markersize.set (val, true))
9585  {
9586  mark_modified ();
9587  }
9588  }
9589  }
9590 
9591  void set_normalmode (const octave_value& val)
9592  {
9593  if (! error_state)
9594  {
9595  if (normalmode.set (val, true))
9596  {
9597  mark_modified ();
9598  }
9599  }
9600  }
9601 
9603  {
9604  if (! error_state)
9605  {
9606  if (specularcolorreflectance.set (val, true))
9607  {
9608  mark_modified ();
9609  }
9610  }
9611  }
9612 
9614  {
9615  if (! error_state)
9616  {
9617  if (specularexponent.set (val, true))
9618  {
9619  mark_modified ();
9620  }
9621  }
9622  }
9623 
9625  {
9626  if (! error_state)
9627  {
9628  if (specularstrength.set (val, true))
9629  {
9630  mark_modified ();
9631  }
9632  }
9633  }
9634 
9636  {
9637  if (! error_state)
9638  {
9639  if (vertexnormals.set (val, true))
9640  {
9641  mark_modified ();
9642  }
9643  }
9644  }
9645 
9646  void set_vertices (const octave_value& val)
9647  {
9648  if (! error_state)
9649  {
9650  if (vertices.set (val, true))
9651  {
9652  update_vertices ();
9653  mark_modified ();
9654  }
9655  }
9656  }
9657 
9658  void set_xdata (const octave_value& val)
9659  {
9660  if (! error_state)
9661  {
9662  if (xdata.set (val, true))
9663  {
9664  update_xdata ();
9665  mark_modified ();
9666  }
9667  }
9668  }
9669 
9670  void set_ydata (const octave_value& val)
9671  {
9672  if (! error_state)
9673  {
9674  if (ydata.set (val, true))
9675  {
9676  update_ydata ();
9677  mark_modified ();
9678  }
9679  }
9680  }
9681 
9682  void set_zdata (const octave_value& val)
9683  {
9684  if (! error_state)
9685  {
9686  if (zdata.set (val, true))
9687  {
9688  update_zdata ();
9689  mark_modified ();
9690  }
9691  }
9692  }
9693 
9694  void set_alim (const octave_value& val)
9695  {
9696  if (! error_state)
9697  {
9698  if (alim.set (val, false))
9699  {
9700  update_axis_limits ("alim");
9701  alim.run_listeners (POSTSET);
9702  mark_modified ();
9703  }
9704  }
9705  }
9706 
9707  void set_clim (const octave_value& val)
9708  {
9709  if (! error_state)
9710  {
9711  if (clim.set (val, false))
9712  {
9713  update_axis_limits ("clim");
9714  clim.run_listeners (POSTSET);
9715  mark_modified ();
9716  }
9717  }
9718  }
9719 
9720  void set_xlim (const octave_value& val)
9721  {
9722  if (! error_state)
9723  {
9724  if (xlim.set (val, false))
9725  {
9726  update_axis_limits ("xlim");
9727  xlim.run_listeners (POSTSET);
9728  mark_modified ();
9729  }
9730  }
9731  }
9732 
9733  void set_ylim (const octave_value& val)
9734  {
9735  if (! error_state)
9736  {
9737  if (ylim.set (val, false))
9738  {
9739  update_axis_limits ("ylim");
9740  ylim.run_listeners (POSTSET);
9741  mark_modified ();
9742  }
9743  }
9744  }
9745 
9746  void set_zlim (const octave_value& val)
9747  {
9748  if (! error_state)
9749  {
9750  if (zlim.set (val, false))
9751  {
9752  update_axis_limits ("zlim");
9753  zlim.run_listeners (POSTSET);
9754  mark_modified ();
9755  }
9756  }
9757  }
9758 
9759  void set_aliminclude (const octave_value& val)
9760  {
9761  if (! error_state)
9762  {
9763  if (aliminclude.set (val, false))
9764  {
9765  update_axis_limits ("aliminclude");
9766  aliminclude.run_listeners (POSTSET);
9767  mark_modified ();
9768  }
9769  }
9770  }
9771 
9772  void set_climinclude (const octave_value& val)
9773  {
9774  if (! error_state)
9775  {
9776  if (climinclude.set (val, false))
9777  {
9778  update_axis_limits ("climinclude");
9779  climinclude.run_listeners (POSTSET);
9780  mark_modified ();
9781  }
9782  }
9783  }
9784 
9785  void set_xliminclude (const octave_value& val)
9786  {
9787  if (! error_state)
9788  {
9789  if (xliminclude.set (val, false))
9790  {
9791  update_axis_limits ("xliminclude");
9792  xliminclude.run_listeners (POSTSET);
9793  mark_modified ();
9794  }
9795  }
9796  }
9797 
9798  void set_yliminclude (const octave_value& val)
9799  {
9800  if (! error_state)
9801  {
9802  if (yliminclude.set (val, false))
9803  {
9804  update_axis_limits ("yliminclude");
9805  yliminclude.run_listeners (POSTSET);
9806  mark_modified ();
9807  }
9808  }
9809  }
9810 
9811  void set_zliminclude (const octave_value& val)
9812  {
9813  if (! error_state)
9814  {
9815  if (zliminclude.set (val, false))
9816  {
9817  update_axis_limits ("zliminclude");
9818  zliminclude.run_listeners (POSTSET);
9819  mark_modified ();
9820  }
9821  }
9822  }
9823 
9824 
9825  protected:
9826  void init (void)
9827  {
9828  xdata.add_constraint (dim_vector (-1, -1));
9829  ydata.add_constraint (dim_vector (-1, -1));
9830  zdata.add_constraint (dim_vector (-1, -1));
9831  faces.add_constraint (dim_vector (-1, -1));
9832  vertices.add_constraint (dim_vector (-1, 2));
9833  vertices.add_constraint (dim_vector (-1, 3));
9834  cdata.add_constraint (dim_vector (-1, -1));
9835  cdata.add_constraint (dim_vector (-1, -1, 3));
9836  facevertexcdata.add_constraint (dim_vector (-1, 1));
9837  facevertexcdata.add_constraint (dim_vector (-1, 3));
9838  facevertexalphadata.add_constraint (dim_vector (-1, 1));
9839  vertexnormals.add_constraint (dim_vector (-1, -1));
9840  }
9841 
9842  private:
9843  std::string bad_data_msg;
9844 
9845  void update_faces (void) { update_data ();}
9846 
9847  void update_vertices (void) { update_data ();}
9848 
9849  void update_facevertexcdata (void) { update_data ();}
9850 
9851  void update_fvc (void);
9852 
9853  void update_xdata (void)
9854  {
9855  if (get_xdata ().is_empty ())
9856  {
9857  // For compatibility with matlab behavior,
9858  // if x/ydata are set empty, silently empty other *data and
9859  // faces properties while vertices remain unchanged.
9860  set_ydata (Matrix ());
9861  set_zdata (Matrix ());
9862  set_cdata (Matrix ());
9863  set_faces (Matrix ());
9864  }
9865  else
9866  update_fvc ();
9867 
9868  set_xlim (xdata.get_limits ());
9869  }
9870 
9871  void update_ydata (void)
9872  {
9873  if (get_ydata ().is_empty ())
9874  {
9875  set_xdata (Matrix ());
9876  set_zdata (Matrix ());
9877  set_cdata (Matrix ());
9878  set_faces (Matrix ());
9879  }
9880  else
9881  update_fvc ();
9882 
9883  set_ylim (ydata.get_limits ());
9884  }
9885 
9886  void update_zdata (void)
9887  {
9888  update_fvc ();
9889  set_zlim (zdata.get_limits ());
9890  }
9891 
9892  void update_cdata (void)
9893  {
9894  update_fvc ();
9895 
9896  if (cdatamapping_is ("scaled"))
9897  set_clim (cdata.get_limits ());
9898  else
9899  clim = cdata.get_limits ();
9900  }
9901 
9902 
9903  void update_data (void);
9904  };
9905 
9906 private:
9908 
9909 public:
9910  patch (const graphics_handle& mh, const graphics_handle& p)
9911  : base_graphics_object (), xproperties (mh, p)
9912  { }
9913 
9914  ~patch (void) { }
9915 
9916  base_properties& get_properties (void) { return xproperties; }
9917 
9918  const base_properties& get_properties (void) const { return xproperties; }
9919 
9920  bool valid_object (void) const { return true; }
9921 
9922  bool has_readonly_property (const caseless_str& pname) const
9923  {
9924  bool retval = xproperties.has_readonly_property (pname);
9925  if (! retval)
9926  retval = base_properties::has_readonly_property (pname);
9927  return retval;
9928  }
9929 };
9930 
9931 // ---------------------------------------------------------------------
9932 
9934 {
9935 public:
9937  {
9938  public:
9939  octave_value get_color_data (void) const;
9940 
9941  bool is_aliminclude (void) const
9942  { return (aliminclude.is_on () && alphadatamapping.is ("scaled")); }
9943  std::string get_aliminclude (void) const
9944  { return aliminclude.current_value (); }
9945 
9946  bool is_climinclude (void) const
9947  { return (climinclude.is_on () && cdatamapping.is ("scaled")); }
9948  std::string get_climinclude (void) const
9949  { return climinclude.current_value (); }
9950 
9951  // See the genprops.awk script for an explanation of the
9952  // properties declarations.
9953  // Programming note: Keep property list sorted if new ones are added.
9954 
9955 public:
9956  properties (const graphics_handle& mh, const graphics_handle& p);
9957 
9958  ~properties (void) { }
9959 
9960  void set (const caseless_str& pname, const octave_value& val);
9961 
9962  octave_value get (bool all = false) const;
9963 
9964  octave_value get (const caseless_str& pname) const;
9965 
9966  octave_value get (const std::string& pname) const
9967  {
9968  return get (caseless_str (pname));
9969  }
9970 
9971  octave_value get (const char *pname) const
9972  {
9973  return get (caseless_str (pname));
9974  }
9975 
9976  property get_property (const caseless_str& pname);
9977 
9978  std::string graphics_object_name (void) const { return go_name; }
9979 
9981 
9982 private:
9983  static std::string go_name;
9984 
9985 public:
9986 
9987 
9988  static std::set<std::string> core_property_names (void);
9989 
9990  static std::set<std::string> readonly_property_names (void);
9991 
9992  static bool has_core_property (const caseless_str& pname);
9993 
9994  static bool has_readonly_property (const caseless_str& pname);
9995 
9996  std::set<std::string> all_property_names (void) const;
9997 
9998  bool has_property (const caseless_str& pname) const;
9999 
10000 private:
10001 
10047 
10048 public:
10049 
10050  enum
10051  {
10052  ID_ALPHADATA = 8000,
10053  ID_ALPHADATAMAPPING = 8001,
10054  ID_AMBIENTSTRENGTH = 8002,
10055  ID_BACKFACELIGHTING = 8003,
10056  ID_CDATA = 8004,
10057  ID_CDATAMAPPING = 8005,
10058  ID_CDATASOURCE = 8006,
10059  ID_DIFFUSESTRENGTH = 8007,
10060  ID_DISPLAYNAME = 8008,
10061  ID_EDGEALPHA = 8009,
10062  ID_EDGECOLOR = 8010,
10063  ID_EDGELIGHTING = 8011,
10064  ID_ERASEMODE = 8012,
10065  ID_FACEALPHA = 8013,
10066  ID_FACECOLOR = 8014,
10067  ID_FACELIGHTING = 8015,
10068  ID_INTERPRETER = 8016,
10069  ID_LINESTYLE = 8017,
10070  ID_LINEWIDTH = 8018,
10071  ID_MARKER = 8019,
10072  ID_MARKEREDGECOLOR = 8020,
10073  ID_MARKERFACECOLOR = 8021,
10074  ID_MARKERSIZE = 8022,
10075  ID_MESHSTYLE = 8023,
10076  ID_NORMALMODE = 8024,
10077  ID_SPECULARCOLORREFLECTANCE = 8025,
10078  ID_SPECULAREXPONENT = 8026,
10079  ID_SPECULARSTRENGTH = 8027,
10080  ID_VERTEXNORMALS = 8028,
10081  ID_XDATA = 8029,
10082  ID_XDATASOURCE = 8030,
10083  ID_YDATA = 8031,
10084  ID_YDATASOURCE = 8032,
10085  ID_ZDATA = 8033,
10086  ID_ZDATASOURCE = 8034,
10087  ID_ALIM = 8035,
10088  ID_CLIM = 8036,
10089  ID_XLIM = 8037,
10090  ID_YLIM = 8038,
10091  ID_ZLIM = 8039,
10092  ID_ALIMINCLUDE = 8040,
10093  ID_CLIMINCLUDE = 8041,
10094  ID_XLIMINCLUDE = 8042,
10095  ID_YLIMINCLUDE = 8043,
10096  ID_ZLIMINCLUDE = 8044
10097  };
10098 
10099  octave_value get_alphadata (void) const { return alphadata.get (); }
10100 
10101  bool alphadatamapping_is (const std::string& v) const { return alphadatamapping.is (v); }
10102  std::string get_alphadatamapping (void) const { return alphadatamapping.current_value (); }
10103 
10104  double get_ambientstrength (void) const { return ambientstrength.double_value (); }
10105 
10106  bool backfacelighting_is (const std::string& v) const { return backfacelighting.is (v); }
10107  std::string get_backfacelighting (void) const { return backfacelighting.current_value (); }
10108 
10109  octave_value get_cdata (void) const { return cdata.get (); }
10110 
10111  bool cdatamapping_is (const std::string& v) const { return cdatamapping.is (v); }
10112  std::string get_cdatamapping (void) const { return cdatamapping.current_value (); }
10113 
10114  std::string get_cdatasource (void) const { return cdatasource.string_value (); }
10115 
10116  double get_diffusestrength (void) const { return diffusestrength.double_value (); }
10117 
10118  std::string get_displayname (void) const { return displayname.string_value (); }
10119 
10120  bool edgealpha_is_double (void) const { return edgealpha.is_double (); }
10121  bool edgealpha_is (const std::string& v) const { return edgealpha.is (v); }
10122  double get_edgealpha_double (void) const { return (edgealpha.is_double () ? edgealpha.double_value () : 0); }
10123  octave_value get_edgealpha (void) const { return edgealpha.get (); }
10124 
10125  bool edgecolor_is_rgb (void) const { return edgecolor.is_rgb (); }
10126  bool edgecolor_is (const std::string& v) const { return edgecolor.is (v); }
10127  Matrix get_edgecolor_rgb (void) const { return (edgecolor.is_rgb () ? edgecolor.rgb () : Matrix ()); }
10128  octave_value get_edgecolor (void) const { return edgecolor.get (); }
10129 
10130  bool edgelighting_is (const std::string& v) const { return edgelighting.is (v); }
10131  std::string get_edgelighting (void) const { return edgelighting.current_value (); }
10132 
10133  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
10134  std::string get_erasemode (void) const { return erasemode.current_value (); }
10135 
10136  bool facealpha_is_double (void) const { return facealpha.is_double (); }
10137  bool facealpha_is (const std::string& v) const { return facealpha.is (v); }
10138  double get_facealpha_double (void) const { return (facealpha.is_double () ? facealpha.double_value () : 0); }
10139  octave_value get_facealpha (void) const { return facealpha.get (); }
10140 
10141  bool facecolor_is_rgb (void) const { return facecolor.is_rgb (); }
10142  bool facecolor_is (const std::string& v) const { return facecolor.is (v); }
10143  Matrix get_facecolor_rgb (void) const { return (facecolor.is_rgb () ? facecolor.rgb () : Matrix ()); }
10144  octave_value get_facecolor (void) const { return facecolor.get (); }
10145 
10146  bool facelighting_is (const std::string& v) const { return facelighting.is (v); }
10147  std::string get_facelighting (void) const { return facelighting.current_value (); }
10148 
10149  bool interpreter_is (const std::string& v) const { return interpreter.is (v); }
10150  std::string get_interpreter (void) const { return interpreter.current_value (); }
10151 
10152  bool linestyle_is (const std::string& v) const { return linestyle.is (v); }
10153  std::string get_linestyle (void) const { return linestyle.current_value (); }
10154 
10155  double get_linewidth (void) const { return linewidth.double_value (); }
10156 
10157  bool marker_is (const std::string& v) const { return marker.is (v); }
10158  std::string get_marker (void) const { return marker.current_value (); }
10159 
10160  bool markeredgecolor_is_rgb (void) const { return markeredgecolor.is_rgb (); }
10161  bool markeredgecolor_is (const std::string& v) const { return markeredgecolor.is (v); }
10162  Matrix get_markeredgecolor_rgb (void) const { return (markeredgecolor.is_rgb () ? markeredgecolor.rgb () : Matrix ()); }
10163  octave_value get_markeredgecolor (void) const { return markeredgecolor.get (); }
10164 
10165  bool markerfacecolor_is_rgb (void) const { return markerfacecolor.is_rgb (); }
10166  bool markerfacecolor_is (const std::string& v) const { return markerfacecolor.is (v); }
10167  Matrix get_markerfacecolor_rgb (void) const { return (markerfacecolor.is_rgb () ? markerfacecolor.rgb () : Matrix ()); }
10168  octave_value get_markerfacecolor (void) const { return markerfacecolor.get (); }
10169 
10170  double get_markersize (void) const { return markersize.double_value (); }
10171 
10172  bool meshstyle_is (const std::string& v) const { return meshstyle.is (v); }
10173  std::string get_meshstyle (void) const { return meshstyle.current_value (); }
10174 
10175  bool normalmode_is (const std::string& v) const { return normalmode.is (v); }
10176  std::string get_normalmode (void) const { return normalmode.current_value (); }
10177 
10178  double get_specularcolorreflectance (void) const { return specularcolorreflectance.double_value (); }
10179 
10180  double get_specularexponent (void) const { return specularexponent.double_value (); }
10181 
10182  double get_specularstrength (void) const { return specularstrength.double_value (); }
10183 
10184  octave_value get_vertexnormals (void) const { return vertexnormals.get (); }
10185 
10186  octave_value get_xdata (void) const { return xdata.get (); }
10187 
10188  std::string get_xdatasource (void) const { return xdatasource.string_value (); }
10189 
10190  octave_value get_ydata (void) const { return ydata.get (); }
10191 
10192  std::string get_ydatasource (void) const { return ydatasource.string_value (); }
10193 
10194  octave_value get_zdata (void) const { return zdata.get (); }
10195 
10196  std::string get_zdatasource (void) const { return zdatasource.string_value (); }
10197 
10198  octave_value get_alim (void) const { return alim.get (); }
10199 
10200  octave_value get_clim (void) const { return clim.get (); }
10201 
10202  octave_value get_xlim (void) const { return xlim.get (); }
10203 
10204  octave_value get_ylim (void) const { return ylim.get (); }
10205 
10206  octave_value get_zlim (void) const { return zlim.get (); }
10207 
10208  bool is_xliminclude (void) const { return xliminclude.is_on (); }
10209  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
10210 
10211  bool is_yliminclude (void) const { return yliminclude.is_on (); }
10212  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
10213 
10214  bool is_zliminclude (void) const { return zliminclude.is_on (); }
10215  std::string get_zliminclude (void) const { return zliminclude.current_value (); }
10216 
10217 
10218  void set_alphadata (const octave_value& val)
10219  {
10220  if (! error_state)
10221  {
10222  if (alphadata.set (val, true))
10223  {
10224  update_alphadata ();
10225  mark_modified ();
10226  }
10227  }
10228  }
10229 
10231  {
10232  if (! error_state)
10233  {
10234  if (alphadatamapping.set (val, false))
10235  {
10236  update_axis_limits ("alphadatamapping");
10237  alphadatamapping.run_listeners (POSTSET);
10238  mark_modified ();
10239  }
10240  }
10241  }
10242 
10244  {
10245  if (! error_state)
10246  {
10247  if (ambientstrength.set (val, true))
10248  {
10249  mark_modified ();
10250  }
10251  }
10252  }
10253 
10255  {
10256  if (! error_state)
10257  {
10258  if (backfacelighting.set (val, true))
10259  {
10260  mark_modified ();
10261  }
10262  }
10263  }
10264 
10265  void set_cdata (const octave_value& val)
10266  {
10267  if (! error_state)
10268  {
10269  if (cdata.set (val, true))
10270  {
10271  update_cdata ();
10272  mark_modified ();
10273  }
10274  }
10275  }
10276 
10277  void set_cdatamapping (const octave_value& val)
10278  {
10279  if (! error_state)
10280  {
10281  if (cdatamapping.set (val, false))
10282  {
10283  update_axis_limits ("cdatamapping");
10284  cdatamapping.run_listeners (POSTSET);
10285  mark_modified ();
10286  }
10287  }
10288  }
10289 
10290  void set_cdatasource (const octave_value& val)
10291  {
10292  if (! error_state)
10293  {
10294  if (cdatasource.set (val, true))
10295  {
10296  mark_modified ();
10297  }
10298  }
10299  }
10300 
10302  {
10303  if (! error_state)
10304  {
10305  if (diffusestrength.set (val, true))
10306  {
10307  mark_modified ();
10308  }
10309  }
10310  }
10311 
10312  void set_displayname (const octave_value& val)
10313  {
10314  if (! error_state)
10315  {
10316  if (displayname.set (val, true))
10317  {
10318  mark_modified ();
10319  }
10320  }
10321  }
10322 
10323  void set_edgealpha (const octave_value& val)
10324  {
10325  if (! error_state)
10326  {
10327  if (edgealpha.set (val, true))
10328  {
10329  mark_modified ();
10330  }
10331  }
10332  }
10333 
10334  void set_edgecolor (const octave_value& val)
10335  {
10336  if (! error_state)
10337  {
10338  if (edgecolor.set (val, true))
10339  {
10340  mark_modified ();
10341  }
10342  }
10343  }
10344 
10345  void set_edgelighting (const octave_value& val)
10346  {
10347  if (! error_state)
10348  {
10349  if (edgelighting.set (val, true))
10350  {
10351  mark_modified ();
10352  }
10353  }
10354  }
10355 
10356  void set_erasemode (const octave_value& val)
10357  {
10358  if (! error_state)
10359  {
10360  if (erasemode.set (val, true))
10361  {
10362  mark_modified ();
10363  }
10364  }
10365  }
10366 
10367  void set_facealpha (const octave_value& val)
10368  {
10369  if (! error_state)
10370  {
10371  if (facealpha.set (val, true))
10372  {
10373  mark_modified ();
10374  }
10375  }
10376  }
10377 
10378  void set_facecolor (const octave_value& val)
10379  {
10380  if (! error_state)
10381  {
10382  if (facecolor.set (val, true))
10383  {
10384  mark_modified ();
10385  }
10386  }
10387  }
10388 
10389  void set_facelighting (const octave_value& val)
10390  {
10391  if (! error_state)
10392  {
10393  if (facelighting.set (val, true))
10394  {
10395  mark_modified ();
10396  }
10397  }
10398  }
10399 
10400  void set_interpreter (const octave_value& val)
10401  {
10402  if (! error_state)
10403  {
10404  if (interpreter.set (val, true))
10405  {
10406  mark_modified ();
10407  }
10408  }
10409  }
10410 
10411  void set_linestyle (const octave_value& val)
10412  {
10413  if (! error_state)
10414  {
10415  if (linestyle.set (val, true))
10416  {
10417  mark_modified ();
10418  }
10419  }
10420  }
10421 
10422  void set_linewidth (const octave_value& val)
10423  {
10424  if (! error_state)
10425  {
10426  if (linewidth.set (val, true))
10427  {
10428  mark_modified ();
10429  }
10430  }
10431  }
10432 
10433  void set_marker (const octave_value& val)
10434  {
10435  if (! error_state)
10436  {
10437  if (marker.set (val, true))
10438  {
10439  mark_modified ();
10440  }
10441  }
10442  }
10443 
10445  {
10446  if (! error_state)
10447  {
10448  if (markeredgecolor.set (val, true))
10449  {
10450  mark_modified ();
10451  }
10452  }
10453  }
10454 
10456  {
10457  if (! error_state)
10458  {
10459  if (markerfacecolor.set (val, true))
10460  {
10461  mark_modified ();
10462  }
10463  }
10464  }
10465 
10466  void set_markersize (const octave_value& val)
10467  {
10468  if (! error_state)
10469  {
10470  if (markersize.set (val, true))
10471  {
10472  mark_modified ();
10473  }
10474  }
10475  }
10476 
10477  void set_meshstyle (const octave_value& val)
10478  {
10479  if (! error_state)
10480  {
10481  if (meshstyle.set (val, true))
10482  {
10483  mark_modified ();
10484  }
10485  }
10486  }
10487 
10488  void set_normalmode (const octave_value& val)
10489  {
10490  if (! error_state)
10491  {
10492  if (normalmode.set (val, true))
10493  {
10494  update_normalmode ();
10495  mark_modified ();
10496  }
10497  }
10498  }
10499 
10501  {
10502  if (! error_state)
10503  {
10504  if (specularcolorreflectance.set (val, true))
10505  {
10506  mark_modified ();
10507  }
10508  }
10509  }
10510 
10512  {
10513  if (! error_state)
10514  {
10515  if (specularexponent.set (val, true))
10516  {
10517  mark_modified ();
10518  }
10519  }
10520  }
10521 
10523  {
10524  if (! error_state)
10525  {
10526  if (specularstrength.set (val, true))
10527  {
10528  mark_modified ();
10529  }
10530  }
10531  }
10532 
10534  {
10535  if (! error_state)
10536  {
10537  if (vertexnormals.set (val, true))
10538  {
10539  update_vertexnormals ();
10540  mark_modified ();
10541  }
10542  }
10543  }
10544 
10545  void set_xdata (const octave_value& val)
10546  {
10547  if (! error_state)
10548  {
10549  if (xdata.set (val, true))
10550  {
10551  update_xdata ();
10552  mark_modified ();
10553  }
10554  }
10555  }
10556 
10557  void set_xdatasource (const octave_value& val)
10558  {
10559  if (! error_state)
10560  {
10561  if (xdatasource.set (val, true))
10562  {
10563  mark_modified ();
10564  }
10565  }
10566  }
10567 
10568  void set_ydata (const octave_value& val)
10569  {
10570  if (! error_state)
10571  {
10572  if (ydata.set (val, true))
10573  {
10574  update_ydata ();
10575  mark_modified ();
10576  }
10577  }
10578  }
10579 
10580  void set_ydatasource (const octave_value& val)
10581  {
10582  if (! error_state)
10583  {
10584  if (ydatasource.set (val, true))
10585  {
10586  mark_modified ();
10587  }
10588  }
10589  }
10590 
10591  void set_zdata (const octave_value& val)
10592  {
10593  if (! error_state)
10594  {
10595  if (zdata.set (val, true))
10596  {
10597  update_zdata ();
10598  mark_modified ();
10599  }
10600  }
10601  }
10602 
10603  void set_zdatasource (const octave_value& val)
10604  {
10605  if (! error_state)
10606  {
10607  if (zdatasource.set (val, true))
10608  {
10609  mark_modified ();
10610  }
10611  }
10612  }
10613 
10614  void set_alim (const octave_value& val)
10615  {
10616  if (! error_state)
10617  {
10618  if (alim.set (val, false))
10619  {
10620  update_axis_limits ("alim");
10621  alim.run_listeners (POSTSET);
10622  mark_modified ();
10623  }
10624  }
10625  }
10626 
10627  void set_clim (const octave_value& val)
10628  {
10629  if (! error_state)
10630  {
10631  if (clim.set (val, false))
10632  {
10633  update_axis_limits ("clim");
10634  clim.run_listeners (POSTSET);
10635  mark_modified ();
10636  }
10637  }
10638  }
10639 
10640  void set_xlim (const octave_value& val)
10641  {
10642  if (! error_state)
10643  {
10644  if (xlim.set (val, false))
10645  {
10646  update_axis_limits ("xlim");
10647  xlim.run_listeners (POSTSET);
10648  mark_modified ();
10649  }
10650  }
10651  }
10652 
10653  void set_ylim (const octave_value& val)
10654  {
10655  if (! error_state)
10656  {
10657  if (ylim.set (val, false))
10658  {
10659  update_axis_limits ("ylim");
10660  ylim.run_listeners (POSTSET);
10661  mark_modified ();
10662  }
10663  }
10664  }
10665 
10666  void set_zlim (const octave_value& val)
10667  {
10668  if (! error_state)
10669  {
10670  if (zlim.set (val, false))
10671  {
10672  update_axis_limits ("zlim");
10673  zlim.run_listeners (POSTSET);
10674  mark_modified ();
10675  }
10676  }
10677  }
10678 
10679  void set_aliminclude (const octave_value& val)
10680  {
10681  if (! error_state)
10682  {
10683  if (aliminclude.set (val, false))
10684  {
10685  update_axis_limits ("aliminclude");
10686  aliminclude.run_listeners (POSTSET);
10687  mark_modified ();
10688  }
10689  }
10690  }
10691 
10692  void set_climinclude (const octave_value& val)
10693  {
10694  if (! error_state)
10695  {
10696  if (climinclude.set (val, false))
10697  {
10698  update_axis_limits ("climinclude");
10699  climinclude.run_listeners (POSTSET);
10700  mark_modified ();
10701  }
10702  }
10703  }
10704 
10705  void set_xliminclude (const octave_value& val)
10706  {
10707  if (! error_state)
10708  {
10709  if (xliminclude.set (val, false))
10710  {
10711  update_axis_limits ("xliminclude");
10712  xliminclude.run_listeners (POSTSET);
10713  mark_modified ();
10714  }
10715  }
10716  }
10717 
10718  void set_yliminclude (const octave_value& val)
10719  {
10720  if (! error_state)
10721  {
10722  if (yliminclude.set (val, false))
10723  {
10724  update_axis_limits ("yliminclude");
10725  yliminclude.run_listeners (POSTSET);
10726  mark_modified ();
10727  }
10728  }
10729  }
10730 
10731  void set_zliminclude (const octave_value& val)
10732  {
10733  if (! error_state)
10734  {
10735  if (zliminclude.set (val, false))
10736  {
10737  update_axis_limits ("zliminclude");
10738  zliminclude.run_listeners (POSTSET);
10739  mark_modified ();
10740  }
10741  }
10742  }
10743 
10744 
10745  protected:
10746  void init (void)
10747  {
10748  xdata.add_constraint (dim_vector (-1, -1));
10749  ydata.add_constraint (dim_vector (-1, -1));
10750  zdata.add_constraint (dim_vector (-1, -1));
10751  cdata.add_constraint ("double");
10752  cdata.add_constraint ("single");
10753  cdata.add_constraint (dim_vector (-1, -1));
10754  cdata.add_constraint (dim_vector (-1, -1, 3));
10755  alphadata.add_constraint ("double");
10756  alphadata.add_constraint ("uint8");
10757  alphadata.add_constraint (dim_vector (-1, -1));
10758  vertexnormals.add_constraint (dim_vector (-1, -1, 3));
10759  vertexnormals.add_constraint (dim_vector (0, 0));
10760  }
10761 
10762  private:
10763  void update_alphadata (void)
10764  {
10765  if (alphadatamapping_is ("scaled"))
10766  set_alim (alphadata.get_limits ());
10767  else
10768  alim = alphadata.get_limits ();
10769  }
10770 
10771  void update_cdata (void)
10772  {
10773  if (cdatamapping_is ("scaled"))
10774  set_clim (cdata.get_limits ());
10775  else
10776  clim = cdata.get_limits ();
10777  }
10778 
10779  void update_xdata (void)
10780  {
10781  update_normals ();
10782  set_xlim (xdata.get_limits ());
10783  }
10784 
10785  void update_ydata (void)
10786  {
10787  update_normals ();
10788  set_ylim (ydata.get_limits ());
10789  }
10790 
10791  void update_zdata (void)
10792  {
10793  update_normals ();
10794  set_zlim (zdata.get_limits ());
10795  }
10796 
10797  void update_normals (void);
10798 
10799  void update_normalmode (void)
10800  { update_normals (); }
10801 
10803  { set_normalmode ("manual"); }
10804  };
10805 
10806 private:
10808 
10809 public:
10811  : base_graphics_object (), xproperties (mh, p)
10812  { }
10813 
10814  ~surface (void) { }
10815 
10816  base_properties& get_properties (void) { return xproperties; }
10817 
10818  const base_properties& get_properties (void) const { return xproperties; }
10819 
10820  bool valid_object (void) const { return true; }
10821 
10822  bool has_readonly_property (const caseless_str& pname) const
10823  {
10824  bool retval = xproperties.has_readonly_property (pname);
10825  if (! retval)
10826  retval = base_properties::has_readonly_property (pname);
10827  return retval;
10828  }
10829 };
10830 
10831 // ---------------------------------------------------------------------
10832 
10834 {
10835 public:
10837  {
10838  public:
10840  {
10842  update_limits ();
10843  }
10844 
10845  void adopt (const graphics_handle& h)
10846  {
10847 
10849  update_limits (h);
10850  }
10851 
10852  // See the genprops.awk script for an explanation of the
10853  // properties declarations.
10854  // Programming note: Keep property list sorted if new ones are added.
10855 
10856 public:
10857  properties (const graphics_handle& mh, const graphics_handle& p);
10858 
10859  ~properties (void) { }
10860 
10861  void set (const caseless_str& pname, const octave_value& val);
10862 
10863  octave_value get (bool all = false) const;
10864 
10865  octave_value get (const caseless_str& pname) const;
10866 
10867  octave_value get (const std::string& pname) const
10868  {
10869  return get (caseless_str (pname));
10870  }
10871 
10872  octave_value get (const char *pname) const
10873  {
10874  return get (caseless_str (pname));
10875  }
10876 
10877  property get_property (const caseless_str& pname);
10878 
10879  std::string graphics_object_name (void) const { return go_name; }
10880 
10882 
10883 private:
10884  static std::string go_name;
10885 
10886 public:
10887 
10888 
10889  static std::set<std::string> core_property_names (void);
10890 
10891  static std::set<std::string> readonly_property_names (void);
10892 
10893  static bool has_core_property (const caseless_str& pname);
10894 
10895  static bool has_readonly_property (const caseless_str& pname);
10896 
10897  std::set<std::string> all_property_names (void) const;
10898 
10899  bool has_property (const caseless_str& pname) const;
10900 
10901 private:
10902 
10915 
10916 public:
10917 
10918  enum
10919  {
10920  ID_DISPLAYNAME = 9000,
10921  ID_ERASEMODE = 9001,
10922  ID_ALIM = 9002,
10923  ID_CLIM = 9003,
10924  ID_XLIM = 9004,
10925  ID_YLIM = 9005,
10926  ID_ZLIM = 9006,
10927  ID_ALIMINCLUDE = 9007,
10928  ID_CLIMINCLUDE = 9008,
10929  ID_XLIMINCLUDE = 9009,
10930  ID_YLIMINCLUDE = 9010,
10931  ID_ZLIMINCLUDE = 9011
10932  };
10933 
10934  std::string get_displayname (void) const { return displayname.string_value (); }
10935 
10936  bool erasemode_is (const std::string& v) const { return erasemode.is (v); }
10937  std::string get_erasemode (void) const { return erasemode.current_value (); }
10938 
10939  octave_value get_alim (void) const { return alim.get (); }
10940 
10941  octave_value get_clim (void) const { return clim.get (); }
10942 
10943  octave_value get_xlim (void) const { return xlim.get (); }
10944 
10945  octave_value get_ylim (void) const { return ylim.get (); }
10946 
10947  octave_value get_zlim (void) const { return zlim.get (); }
10948 
10949  bool is_aliminclude (void) const { return aliminclude.is_on (); }
10950  std::string get_aliminclude (void) const { return aliminclude.current_value (); }
10951 
10952  bool is_climinclude (void) const { return climinclude.is_on (); }
10953  std::string get_climinclude (void) const { return climinclude.current_value (); }
10954 
10955  bool is_xliminclude (void) const { return xliminclude.is_on (); }
10956  std::string get_xliminclude (void) const { return xliminclude.current_value (); }
10957 
10958  bool is_yliminclude (void) const { return yliminclude.is_on (); }
10959  std::string get_yliminclude (void) const { return yliminclude.current_value (); }
10960 
10961  bool is_zliminclude (void) const { return zliminclude.is_on (); }
10962  std::string get_zliminclude (void) const { return zliminclude.current_value (); }
10963 
10964 
10965  void set_displayname (const octave_value& val)
10966  {
10967  if (! error_state)
10968  {
10969  if (displayname.set (val, true))
10970  {
10971  mark_modified ();
10972  }
10973  }
10974  }
10975 
10976  void set_erasemode (const octave_value& val)
10977  {
10978  if (! error_state)
10979  {
10980  if (erasemode.set (val, true))
10981  {
10982  mark_modified ();
10983  }
10984  }
10985  }
10986 
10987  void set_alim (const octave_value& val)
10988  {
10989  if (! error_state)
10990  {
10991  if (alim.set (val, true))
10992  {
10993  mark_modified ();
10994  }
10995  }
10996  }
10997 
10998  void set_clim (const octave_value& val)
10999  {
11000  if (! error_state)
11001  {
11002  if (clim.set (val, true))
11003  {
11004  mark_modified ();
11005  }
11006  }
11007  }
11008 
11009  void set_xlim (const octave_value& val)
11010  {
11011  if (! error_state)
11012  {
11013  if (xlim.set (val, true))
11014  {
11015  mark_modified ();
11016  }
11017  }
11018  }
11019 
11020  void set_ylim (const octave_value& val)
11021  {
11022  if (! error_state)
11023  {
11024  if (ylim.set (val, true))
11025  {
11026  mark_modified ();
11027  }
11028  }
11029  }
11030 
11031  void set_zlim (const octave_value& val)
11032  {
11033  if (! error_state)
11034  {
11035  if (zlim.set (val, true))
11036  {
11037  mark_modified ();
11038  }
11039  }
11040  }
11041 
11042  void set_aliminclude (const octave_value& val)
11043  {
11044  if (! error_state)
11045  {
11046  if (aliminclude.set (val, true))
11047  {
11048  mark_modified ();
11049  }
11050  }
11051  }
11052 
11053  void set_climinclude (const octave_value& val)
11054  {
11055  if (! error_state)
11056  {
11057  if (climinclude.set (val, true))
11058  {
11059  mark_modified ();
11060  }
11061  }
11062  }
11063 
11064  void set_xliminclude (const octave_value& val)
11065  {
11066  if (! error_state)
11067  {
11068  if (xliminclude.set (val, true))
11069  {
11070  mark_modified ();
11071  }
11072  }
11073  }
11074 
11075  void set_yliminclude (const octave_value& val)
11076  {
11077  if (! error_state)
11078  {
11079  if (yliminclude.set (val, true))
11080  {
11081  mark_modified ();
11082  }
11083  }
11084  }
11085 
11086  void set_zliminclude (const octave_value& val)
11087  {
11088  if (! error_state)
11089  {
11090  if (zliminclude.set (val, true))
11091  {
11092  mark_modified ();
11093  }
11094  }
11095  }
11096 
11097 
11098  private:
11099  void update_limits (void) const;
11100 
11101  void update_limits (const graphics_handle& h) const;
11102 
11103  protected:
11104  void init (void)
11105  { }
11106 
11107  };
11108 
11109 private:
11111 
11112 public:
11114  : base_graphics_object (), xproperties (mh, p)
11115  { }
11116 
11117  ~hggroup (void) { }
11118 
11119  base_properties& get_properties (void) { return xproperties; }
11120 
11121  const base_properties& get_properties (void) const { return xproperties; }
11122 
11123  bool valid_object (void) const { return true; }
11124 
11125  void update_axis_limits (const std::string& axis_type);
11126 
11127  void update_axis_limits (const std::string& axis_type,
11128  const graphics_handle& h);
11129 
11130  bool has_readonly_property (const caseless_str& pname) const
11131  {
11132  bool retval = xproperties.has_readonly_property (pname);
11133  if (! retval)
11134  retval = base_properties::has_readonly_property (pname);
11135  return retval;
11136  }
11137 
11138 };
11139 
11140 // ---------------------------------------------------------------------
11141 
11143 {
11144 public:
11146  {
11147  public:
11149  {
11151  }
11152 
11153  void adopt (const graphics_handle& h)
11154  {
11156  }
11157 
11158  // See the genprops.awk script for an explanation of the
11159  // properties declarations.
11160  // Programming note: Keep property list sorted if new ones are added.
11161 
11162 public:
11163  properties (const graphics_handle& mh, const graphics_handle& p);
11164 
11165  ~properties (void) { }
11166 
11167  void set (const caseless_str& pname, const octave_value& val);
11168 
11169  octave_value get (bool all = false) const;
11170 
11171  octave_value get (const caseless_str& pname) const;
11172 
11173  octave_value get (const std::string& pname) const
11174  {
11175  return get (caseless_str (pname));
11176  }
11177 
11178  octave_value get (const char *pname) const
11179  {
11180  return get (caseless_str (pname));
11181  }
11182 
11183  property get_property (const caseless_str& pname);
11184 
11185  std::string graphics_object_name (void) const { return go_name; }
11186 
11188 
11189 private:
11190  static std::string go_name;
11191 
11192 public:
11193 
11194 
11195  static std::set<std::string> core_property_names (void);
11196 
11197  static std::set<std::string> readonly_property_names (void);
11198 
11199  static bool has_core_property (const caseless_str& pname);
11200 
11201  static bool has_readonly_property (const caseless_str& pname);
11202 
11203  std::set<std::string> all_property_names (void) const;
11204 
11205  bool has_property (const caseless_str& pname) const;
11206 
11207 private:
11208 
11219 
11220 public:
11221 
11222  enum
11223  {
11224  ID___OBJECT__ = 10000,
11225  ID_ACCELERATOR = 10001,
11226  ID_CALLBACK = 10002,
11227  ID_CHECKED = 10003,
11228  ID_ENABLE = 10004,
11229  ID_FOREGROUNDCOLOR = 10005,
11230  ID_LABEL = 10006,
11231  ID_POSITION = 10007,
11232  ID_SEPARATOR = 10008,
11233  ID_FLTK_LABEL = 10009
11234  };
11235 
11236  octave_value get___object__ (void) const { return __object__.get (); }
11237 
11238  std::string get_accelerator (void) const { return accelerator.string_value (); }
11239 
11240  void execute_callback (const octave_value& data = octave_value ()) const { callback.execute (data); }
11241  octave_value get_callback (void) const { return callback.get (); }
11242 
11243  bool is_checked (void) const { return checked.is_on (); }
11244  std::string get_checked (void) const { return checked.current_value (); }
11245 
11246  bool is_enable (void) const { return enable.is_on (); }
11247  std::string get_enable (void) const { return enable.current_value (); }
11248 
11249  bool foregroundcolor_is_rgb (void) const { return foregroundcolor.is_rgb (); }
11250  bool foregroundcolor_is (const std::string& v) const { return foregroundcolor.is (v); }
11251  Matrix get_foregroundcolor_rgb (void) const { return (foregroundcolor.is_rgb () ? foregroundcolor.rgb () : Matrix ()); }
11252  octave_value get_foregroundcolor (void) const { return foregroundcolor.get (); }
11253 
11254  std::string get_label (void) const { return label.string_value (); }
11255 
11256  double get_position (void) const { return position.double_value (); }
11257 
11258  bool is_separator (void) const { return separator.is_on (); }
11259  std::string get_separator (void) const { return separator.current_value (); }
11260 
11261  std::string get_fltk_label (void) const { return fltk_label.string_value (); }
11262 
11263 
11264  void set___object__ (const octave_value& val)
11265  {
11266  if (! error_state)
11267  {
11268  if (__object__.set (val, true))
11269  {
11270  mark_modified ();
11271  }
11272  }
11273  }
11274 
11275  void set_accelerator (const octave_value& val)
11276  {
11277  if (! error_state)
11278  {
11279  if (accelerator.set (val, true))
11280  {
11281  mark_modified ();
11282  }
11283  }
11284  }
11285 
11286  void set_callback (const octave_value& val)
11287  {
11288  if (! error_state)
11289  {
11290  if (callback.set (val, true))
11291  {
11292  mark_modified ();
11293  }
11294  }
11295  }
11296 
11297  void set_checked (const octave_value& val)
11298  {
11299  if (! error_state)
11300  {
11301  if (checked.set (val, true))
11302  {
11303  mark_modified ();
11304  }
11305  }
11306  }
11307 
11308  void set_enable (const octave_value& val)
11309  {
11310  if (! error_state)
11311  {
11312  if (enable.set (val, true))
11313  {
11314  mark_modified ();
11315  }
11316  }
11317  }
11318 
11320  {
11321  if (! error_state)
11322  {
11323  if (foregroundcolor.set (val, true))
11324  {
11325  mark_modified ();
11326  }
11327  }
11328  }
11329 
11330  void set_label (const octave_value& val)
11331  {
11332  if (! error_state)
11333  {
11334  if (label.set (val, true))
11335  {
11336  mark_modified ();
11337  }
11338  }
11339  }
11340 
11341  void set_position (const octave_value& val)
11342  {
11343  if (! error_state)
11344  {
11345  if (position.set (val, true))
11346  {
11347  mark_modified ();
11348  }
11349  }
11350  }
11351 
11352  void set_separator (const octave_value& val)
11353  {
11354  if (! error_state)
11355  {
11356  if (separator.set (val, true))
11357  {
11358  mark_modified ();
11359  }
11360  }
11361  }
11362 
11363  void set_fltk_label (const octave_value& val)
11364  {
11365  if (! error_state)
11366  {
11367  if (fltk_label.set (val, true))
11368  {
11369  mark_modified ();
11370  }
11371  }
11372  }
11373 
11374 
11375  protected:
11376  void init (void)
11377  { }
11378  };
11379 
11380 private:
11382 
11383 public:
11385  : base_graphics_object (), xproperties (mh, p)
11386  { }
11387 
11388  ~uimenu (void) { }
11389 
11390  base_properties& get_properties (void) { return xproperties; }
11391 
11392  const base_properties& get_properties (void) const { return xproperties; }
11393 
11394  bool valid_object (void) const { return true; }
11395 
11396  bool has_readonly_property (const caseless_str& pname) const
11397  {
11398  bool retval = xproperties.has_readonly_property (pname);
11399  if (! retval)
11400  retval = base_properties::has_readonly_property (pname);
11401  return retval;
11402  }
11403 
11404 };
11405 
11406 // ---------------------------------------------------------------------
11407 
11408 class OCTINTERP_API uicontextmenu : public base_graphics_object
11409 {
11410 public:
11412  {
11413  public:
11414 
11416  { dependent_obj_list.push_back (gh); }
11417 
11418  // FIXME: the list may contain duplicates.
11419  // Should we return only unique elements?
11420  const std::list<graphics_handle> get_dependent_obj_list (void)
11421  { return dependent_obj_list; }
11422 
11423  // See the genprops.awk script for an explanation of the
11424  // properties declarations.
11425  // Programming note: Keep property list sorted if new ones are added.
11426 
11427 public:
11428  properties (const graphics_handle& mh, const graphics_handle& p);
11429 
11430  ~properties (void) { }
11431 
11432  void set (const caseless_str& pname, const octave_value& val);
11433 
11434  octave_value get (bool all = false) const;
11435 
11436  octave_value get (const caseless_str& pname) const;
11437 
11438  octave_value get (const std::string& pname) const
11439  {
11440  return get (caseless_str (pname));
11441  }
11442 
11443  octave_value get (const char *pname) const
11444  {
11445  return get (caseless_str (pname));
11446  }
11447 
11448  property get_property (const caseless_str& pname);
11449 
11450  std::string graphics_object_name (void) const { return go_name; }
11451 
11453 
11454 private:
11455  static std::string go_name;
11456 
11457 public:
11458 
11459 
11460  static std::set<std::string> core_property_names (void);
11461 
11462  static std::set<std::string> readonly_property_names (void);
11463 
11464  static bool has_core_property (const caseless_str& pname);
11465 
11466  static bool has_readonly_property (const caseless_str& pname);
11467 
11468  std::set<std::string> all_property_names (void) const;
11469 
11470  bool has_property (const caseless_str& pname) const;
11471 
11472 private:
11473 
11477 
11478 public:
11479 
11480  enum
11481  {
11482  ID___OBJECT__ = 11000,
11483  ID_CALLBACK = 11001,
11484  ID_POSITION = 11002
11485  };
11486 
11487  octave_value get___object__ (void) const { return __object__.get (); }
11488 
11489  void execute_callback (const octave_value& data = octave_value ()) const { callback.execute (data); }
11490  octave_value get_callback (void) const { return callback.get (); }
11491 
11492  octave_value get_position (void) const { return position.get (); }
11493 
11494 
11495  void set___object__ (const octave_value& val)
11496  {
11497  if (! error_state)
11498  {
11499  if (__object__.set (val, true))
11500  {
11501  mark_modified ();
11502  }
11503  }
11504  }
11505 
11506  void set_callback (const octave_value& val)
11507  {
11508  if (! error_state)
11509  {
11510  if (callback.set (val, true))
11511  {
11512  mark_modified ();
11513  }
11514  }
11515  }
11516 
11517  void set_position (const octave_value& val)
11518  {
11519  if (! error_state)
11520  {
11521  if (position.set (val, true))
11522  {
11523  mark_modified ();
11524  }
11525  }
11526  }
11527 
11528 
11529  protected:
11530  void init (void)
11531  {
11532  position.add_constraint (dim_vector (1, 2));
11533  position.add_constraint (dim_vector (2, 1));
11534  visible.set (octave_value (false));
11535  }
11536 
11537  private:
11538  // List of objects that might depend on this uicontextmenu object
11539  std::list<graphics_handle> dependent_obj_list;
11540  };
11541 
11542 private:
11544 
11545 public:
11547  : base_graphics_object (), xproperties (mh, p)
11548  { }
11549 
11550  ~uicontextmenu (void);
11551 
11552  base_properties& get_properties (void) { return xproperties; }
11553 
11554  const base_properties& get_properties (void) const { return xproperties; }
11555 
11556  bool valid_object (void) const { return true; }
11557 
11558  bool has_readonly_property (const caseless_str& pname) const
11559  {
11560  bool retval = xproperties.has_readonly_property (pname);
11561  if (! retval)
11562  retval = base_properties::has_readonly_property (pname);
11563  return retval;
11564  }
11565 
11566 };
11567 
11568 // ---------------------------------------------------------------------
11569 
11571 {
11572 public:
11574  {
11575  public:
11576  Matrix get_boundingbox (bool internal = false,
11577  const Matrix& parent_pix_size = Matrix ()) const;
11578 
11579  double get_fontsize_points (double box_pix_height = 0) const;
11580 
11581  // See the genprops.awk script for an explanation of the
11582  // properties declarations.
11583  // Programming note: Keep property list sorted if new ones are added.
11584 
11585 public:
11586  properties (const graphics_handle& mh, const graphics_handle& p);
11587 
11588  ~properties (void) { }
11589 
11590  void set (const caseless_str& pname, const octave_value& val);
11591 
11592  octave_value get (bool all = false) const;
11593 
11594  octave_value get (const caseless_str& pname) const;
11595 
11596  octave_value get (const std::string& pname) const
11597  {
11598  return get (caseless_str (pname));
11599  }
11600 
11601  octave_value get (const char *pname) const
11602  {
11603  return get (caseless_str (pname));
11604  }
11605 
11606  property get_property (const caseless_str& pname);
11607 
11608  std::string graphics_object_name (void) const { return go_name; }
11609 
11611 
11612 private:
11613  static std::string go_name;
11614 
11615 public:
11616 
11617 
11618  static std::set<std::string> core_property_names (void);
11619 
11620  static std::set<std::string> readonly_property_names (void);
11621 
11622  static bool has_core_property (const caseless_str& pname);
11623 
11624  static bool has_readonly_property (const caseless_str& pname);
11625 
11626  std::set<std::string> all_property_names (void) const;
11627 
11628  bool has_property (const caseless_str& pname) const;
11629 
11630 private:
11631 
11658 
11659 public:
11660 
11661  enum
11662  {
11663  ID___OBJECT__ = 12000,
11664  ID_BACKGROUNDCOLOR = 12001,
11665  ID_CALLBACK = 12002,
11666  ID_CDATA = 12003,
11667  ID_CLIPPING = 12004,
11668  ID_ENABLE = 12005,
11669  ID_EXTENT = 12006,
11670  ID_FONTANGLE = 12007,
11671  ID_FONTNAME = 12008,
11672  ID_FONTSIZE = 12009,
11673  ID_FONTUNITS = 12010,
11674  ID_FONTWEIGHT = 12011,
11675  ID_FOREGROUNDCOLOR = 12012,
11676  ID_HORIZONTALALIGNMENT = 12013,
11677  ID_KEYPRESSFCN = 12014,
11678  ID_LISTBOXTOP = 12015,
11679  ID_MAX = 12016,
11680  ID_MIN = 12017,
11681  ID_POSITION = 12018,
11682  ID_SLIDERSTEP = 12019,
11683  ID_STRING = 12020,
11684  ID_STYLE = 12021,
11685  ID_TOOLTIPSTRING = 12022,
11686  ID_UNITS = 12023,
11687  ID_VALUE = 12024,
11688  ID_VERTICALALIGNMENT = 12025
11689  };
11690 
11691  octave_value get___object__ (void) const { return __object__.get (); }
11692 
11693  bool backgroundcolor_is_rgb (void) const { return backgroundcolor.is_rgb (); }
11694  bool backgroundcolor_is (const std::string& v) const { return backgroundcolor.is (v); }
11695  Matrix get_backgroundcolor_rgb (void) const { return (backgroundcolor.is_rgb () ? backgroundcolor.rgb () : Matrix ()); }
11696  octave_value get_backgroundcolor (void) const { return backgroundcolor.get (); }
11697 
11698  void execute_callback (const octave_value& data = octave_value ()) const { callback.execute (data); }
11699  octave_value get_callback (void) const { return callback.get (); }
11700 
11701  octave_value get_cdata (void) const { return cdata.get (); }
11702 
11703  bool is_clipping (void) const { return clipping.is_on (); }
11704  std::string get_clipping (void) const { return clipping.current_value (); }
11705 
11706  bool enable_is (const std::string& v) const { return enable.is (v); }
11707  std::string get_enable (void) const { return enable.current_value (); }
11708 
11709  octave_value get_extent (void) const;
11710 
11711  bool fontangle_is (const std::string& v) const { return fontangle.is (v); }
11712  std::string get_fontangle (void) const { return fontangle.current_value (); }
11713 
11714  std::string get_fontname (void) const { return fontname.string_value (); }
11715 
11716  double get_fontsize (void) const { return fontsize.double_value (); }
11717 
11718  bool fontunits_is (const std::string& v) const { return fontunits.is (v); }
11719  std::string get_fontunits (void) const { return fontunits.current_value (); }
11720 
11721  bool fontweight_is (const std::string& v) const { return fontweight.is (v); }
11722  std::string get_fontweight (void) const { return fontweight.current_value (); }
11723 
11724  bool foregroundcolor_is_rgb (void) const { return foregroundcolor.is_rgb (); }
11725  bool foregroundcolor_is (const std::string& v) const { return foregroundcolor.is (v); }
11726  Matrix get_foregroundcolor_rgb (void) const { return (foregroundcolor.is_rgb () ? foregroundcolor.rgb () : Matrix ()); }
11727  octave_value get_foregroundcolor (void) const { return foregroundcolor.get (); }
11728 
11729  bool horizontalalignment_is (const std::string& v) const { return horizontalalignment.is (v); }
11730  std::string get_horizontalalignment (void) const { return horizontalalignment.current_value (); }
11731 
11732  void execute_keypressfcn (const octave_value& data = octave_value ()) const { keypressfcn.execute (data); }
11733  octave_value get_keypressfcn (void) const { return keypressfcn.get (); }
11734 
11735  double get_listboxtop (void) const { return listboxtop.double_value (); }
11736 
11737  double get_max (void) const { return max.double_value (); }
11738 
11739  double get_min (void) const { return min.double_value (); }
11740 
11741  octave_value get_position (void) const { return position.get (); }
11742 
11743  octave_value get_sliderstep (void) const { return sliderstep.get (); }
11744 
11745  std::string get_string_string (void) const { return string.string_value (); }
11746  string_vector get_string_vector (void) const { return string.string_vector_value (); }
11747  octave_value get_string (void) const { return string.get (); }
11748 
11749  bool style_is (const std::string& v) const { return style.is (v); }
11750  std::string get_style (void) const { return style.current_value (); }
11751 
11752  std::string get_tooltipstring (void) const { return tooltipstring.string_value (); }
11753 
11754  bool units_is (const std::string& v) const { return units.is (v); }
11755  std::string get_units (void) const { return units.current_value (); }
11756 
11757  octave_value get_value (void) const { return value.get (); }
11758 
11759  bool verticalalignment_is (const std::string& v) const { return verticalalignment.is (v); }
11760  std::string get_verticalalignment (void) const { return verticalalignment.current_value (); }
11761 
11762 
11763  void set___object__ (const octave_value& val)
11764  {
11765  if (! error_state)
11766  {
11767  if (__object__.set (val, true))
11768  {
11769  mark_modified ();
11770  }
11771  }
11772  }
11773 
11775  {
11776  if (! error_state)
11777  {
11778  if (backgroundcolor.set (val, true))
11779  {
11780  mark_modified ();
11781  }
11782  }
11783  }
11784 
11785  void set_callback (const octave_value& val)
11786  {
11787  if (! error_state)
11788  {
11789  if (callback.set (val, true))
11790  {
11791  mark_modified ();
11792  }
11793  }
11794  }
11795 
11796  void set_cdata (const octave_value& val)
11797  {
11798  if (! error_state)
11799  {
11800  if (cdata.set (val, true))
11801  {
11802  mark_modified ();
11803  }
11804  }
11805  }
11806 
11807  void set_clipping (const octave_value& val)
11808  {
11809  if (! error_state)
11810  {
11811  if (clipping.set (val, true))
11812  {
11813  mark_modified ();
11814  }
11815  }
11816  }
11817 
11818  void set_enable (const octave_value& val)
11819  {
11820  if (! error_state)
11821  {
11822  if (enable.set (val, true))
11823  {
11824  mark_modified ();
11825  }
11826  }
11827  }
11828 
11829  void set_extent (const octave_value& val)
11830  {
11831  if (! error_state)
11832  {
11833  if (extent.set (val, true))
11834  {
11835  mark_modified ();
11836  }
11837  }
11838  }
11839 
11840  void set_fontangle (const octave_value& val)
11841  {
11842  if (! error_state)
11843  {
11844  if (fontangle.set (val, true))
11845  {
11846  update_fontangle ();
11847  mark_modified ();
11848  }
11849  }
11850  }
11851 
11852  void set_fontname (const octave_value& val)
11853  {
11854  if (! error_state)
11855  {
11856  if (fontname.set (val, true))
11857  {
11858  update_fontname ();
11859  mark_modified ();
11860  }
11861  }
11862  }
11863 
11864  void set_fontsize (const octave_value& val)
11865  {
11866  if (! error_state)
11867  {
11868  if (fontsize.set (val, true))
11869  {
11870  update_fontsize ();
11871  mark_modified ();
11872  }
11873  }
11874  }
11875 
11876  void set_fontunits (const octave_value& val);
11877 
11878  void set_fontweight (const octave_value& val)
11879  {
11880  if (! error_state)
11881  {
11882  if (fontweight.set (val, true))
11883  {
11884  update_fontweight ();
11885  mark_modified ();
11886  }
11887  }
11888  }
11889 
11891  {
11892  if (! error_state)
11893  {
11894  if (foregroundcolor.set (val, true))
11895  {
11896  mark_modified ();
11897  }
11898  }
11899  }
11900 
11902  {
11903  if (! error_state)
11904  {
11905  if (horizontalalignment.set (val, true))
11906  {
11907  mark_modified ();
11908  }
11909  }
11910  }
11911 
11912  void set_keypressfcn (const octave_value& val)
11913  {
11914  if (! error_state)
11915  {
11916  if (keypressfcn.set (val, true))
11917  {
11918  mark_modified ();
11919  }
11920  }
11921  }
11922 
11923  void set_listboxtop (const octave_value& val)
11924  {
11925  if (! error_state)
11926  {
11927  if (listboxtop.set (val, true))
11928  {
11929  mark_modified ();
11930  }
11931  }
11932  }
11933 
11934  void set_max (const octave_value& val)
11935  {
11936  if (! error_state)
11937  {
11938  if (max.set (val, true))
11939  {
11940  mark_modified ();
11941  }
11942  }
11943  }
11944 
11945  void set_min (const octave_value& val)
11946  {
11947  if (! error_state)
11948  {
11949  if (min.set (val, true))
11950  {
11951  mark_modified ();
11952  }
11953  }
11954  }
11955 
11956  void set_position (const octave_value& val)
11957  {
11958  if (! error_state)
11959  {
11960  if (position.set (val, true))
11961  {
11962  mark_modified ();
11963  }
11964  }
11965  }
11966 
11967  void set_sliderstep (const octave_value& val)
11968  {
11969  if (! error_state)
11970  {
11971  if (sliderstep.set (val, true))
11972  {
11973  mark_modified ();
11974  }
11975  }
11976  }
11977 
11978  void set_string (const octave_value& val)
11979  {
11980  if (! error_state)
11981  {
11982  if (string.set (val, true))
11983  {
11984  update_string ();
11985  mark_modified ();
11986  }
11987  }
11988  }
11989 
11990  void set_style (const octave_value& val);
11991 
11993  {
11994  if (! error_state)
11995  {
11996  if (tooltipstring.set (val, true))
11997  {
11998  mark_modified ();
11999  }
12000  }
12001  }
12002 
12003  void set_units (const octave_value& val)
12004  {
12005  if (! error_state)
12006  {
12007  if (units.set (val, true))
12008  {
12009  update_units ();
12010  mark_modified ();
12011  }
12012  }
12013  }
12014 
12015  void set_value (const octave_value& val)
12016  {
12017  if (! error_state)
12018  {
12019  if (value.set (val, true))
12020  {
12021  mark_modified ();
12022  }
12023  }
12024  }
12025 
12027  {
12028  if (! error_state)
12029  {
12030  if (verticalalignment.set (val, true))
12031  {
12032  mark_modified ();
12033  }
12034  }
12035  }
12036 
12037 
12038  private:
12039  std::string cached_units;
12040 
12041  protected:
12042  void init (void)
12043  {
12044  cdata.add_constraint ("double");
12045  cdata.add_constraint ("single");
12046  cdata.add_constraint (dim_vector (-1, -1, 3));
12047  position.add_constraint (dim_vector (1, 4));
12048  sliderstep.add_constraint (dim_vector (1, 2));
12049  cached_units = get_units ();
12050  }
12051 
12052  void update_text_extent (void);
12053 
12054  void update_string (void) { update_text_extent (); }
12055  void update_fontname (void) { update_text_extent (); }
12056  void update_fontsize (void) { update_text_extent (); }
12057  void update_fontangle (void) { update_text_extent (); }
12058  void update_fontweight (void) { update_text_extent (); }
12059  void update_fontunits (const caseless_str& old_units);
12060 
12061  void update_units (void);
12062 
12063  };
12064 
12065 private:
12067 
12068 public:
12070  : base_graphics_object (), xproperties (mh, p)
12071  { }
12072 
12073  ~uicontrol (void) { }
12074 
12075  base_properties& get_properties (void) { return xproperties; }
12076 
12077  const base_properties& get_properties (void) const { return xproperties; }
12078 
12079  bool valid_object (void) const { return true; }
12080 
12081  bool has_readonly_property (const caseless_str& pname) const
12082  {
12083  bool retval = xproperties.has_readonly_property (pname);
12084  if (! retval)
12085  retval = base_properties::has_readonly_property (pname);
12086  return retval;
12087  }
12088 };
12089 
12090 // ---------------------------------------------------------------------
12091 
12093 {
12094 public:
12096  {
12097  public:
12098  Matrix get_boundingbox (bool internal = false,
12099  const Matrix& parent_pix_size = Matrix ()) const;
12100 
12101  double get_fontsize_points (double box_pix_height = 0) const;
12102 
12103  // See the genprops.awk script for an explanation of the
12104  // properties declarations.
12105  // Programming note: Keep property list sorted if new ones are added.
12106 
12107 public:
12108  properties (const graphics_handle& mh, const graphics_handle& p);
12109 
12110  ~properties (void) { }
12111 
12112  void set (const caseless_str& pname, const octave_value& val);
12113 
12114  octave_value get (bool all = false) const;
12115 
12116  octave_value get (const caseless_str& pname) const;
12117 
12118  octave_value get (const std::string& pname) const
12119  {
12120  return get (caseless_str (pname));
12121  }
12122 
12123  octave_value get (const char *pname) const
12124  {
12125  return get (caseless_str (pname));
12126  }
12127 
12128  property get_property (const caseless_str& pname);
12129 
12130  std::string graphics_object_name (void) const { return go_name; }
12131 
12133 
12134 private:
12135  static std::string go_name;
12136 
12137 public:
12138 
12139 
12140  static std::set<std::string> core_property_names (void);
12141 
12142  static std::set<std::string> readonly_property_names (void);
12143 
12144  static bool has_core_property (const caseless_str& pname);
12145 
12146  static bool has_readonly_property (const caseless_str& pname);
12147 
12148  std::set<std::string> all_property_names (void) const;
12149 
12150  bool has_property (const caseless_str& pname) const;
12151 
12152 private:
12153 
12171 
12172 public:
12173 
12174  enum
12175  {
12176  ID___OBJECT__ = 13000,
12177  ID_BACKGROUNDCOLOR = 13001,
12178  ID_BORDERTYPE = 13002,
12179  ID_BORDERWIDTH = 13003,
12180  ID_FONTANGLE = 13004,
12181  ID_FONTNAME = 13005,
12182  ID_FONTSIZE = 13006,
12183  ID_FONTUNITS = 13007,
12184  ID_FONTWEIGHT = 13008,
12185  ID_FOREGROUNDCOLOR = 13009,
12186  ID_HIGHLIGHTCOLOR = 13010,
12187  ID_POSITION = 13011,
12188  ID_RESIZEFCN = 13012,
12189  ID_SHADOWCOLOR = 13013,
12190  ID_TITLE = 13014,
12191  ID_TITLEPOSITION = 13015,
12192  ID_UNITS = 13016
12193  };
12194 
12195  octave_value get___object__ (void) const { return __object__.get (); }
12196 
12197  bool backgroundcolor_is_rgb (void) const { return backgroundcolor.is_rgb (); }
12198  bool backgroundcolor_is (const std::string& v) const { return backgroundcolor.is (v); }
12199  Matrix get_backgroundcolor_rgb (void) const { return (backgroundcolor.is_rgb () ? backgroundcolor.rgb () : Matrix ()); }
12200  octave_value get_backgroundcolor (void) const { return backgroundcolor.get (); }
12201 
12202  bool bordertype_is (const std::string& v) const { return bordertype.is (v); }
12203  std::string get_bordertype (void) const { return bordertype.current_value (); }
12204 
12205  double get_borderwidth (void) const { return borderwidth.double_value (); }
12206 
12207  bool fontangle_is (const std::string& v) const { return fontangle.is (v); }
12208  std::string get_fontangle (void) const { return fontangle.current_value (); }
12209 
12210  std::string get_fontname (void) const { return fontname.string_value (); }
12211 
12212  double get_fontsize (void) const { return fontsize.double_value (); }
12213 
12214  bool fontunits_is (const std::string& v) const { return fontunits.is (v); }
12215  std::string get_fontunits (void) const { return fontunits.current_value (); }
12216 
12217  bool fontweight_is (const std::string& v) const { return fontweight.is (v); }
12218  std::string get_fontweight (void) const { return fontweight.current_value (); }
12219 
12220  bool foregroundcolor_is_rgb (void) const { return foregroundcolor.is_rgb (); }
12221  bool foregroundcolor_is (const std::string& v) const { return foregroundcolor.is (v); }
12222  Matrix get_foregroundcolor_rgb (void) const { return (foregroundcolor.is_rgb () ? foregroundcolor.rgb () : Matrix ()); }
12223  octave_value get_foregroundcolor (void) const { return foregroundcolor.get (); }
12224 
12225  bool highlightcolor_is_rgb (void) const { return highlightcolor.is_rgb (); }
12226  bool highlightcolor_is (const std::string& v) const { return highlightcolor.is (v); }
12227  Matrix get_highlightcolor_rgb (void) const { return (highlightcolor.is_rgb () ? highlightcolor.rgb () : Matrix ()); }
12228  octave_value get_highlightcolor (void) const { return highlightcolor.get (); }
12229 
12230  octave_value get_position (void) const { return position.get (); }
12231 
12232  void execute_resizefcn (const octave_value& data = octave_value ()) const { resizefcn.execute (data); }
12233  octave_value get_resizefcn (void) const { return resizefcn.get (); }
12234 
12235  bool shadowcolor_is_rgb (void) const { return shadowcolor.is_rgb (); }
12236  bool shadowcolor_is (const std::string& v) const { return shadowcolor.is (v); }
12237  Matrix get_shadowcolor_rgb (void) const { return (shadowcolor.is_rgb () ? shadowcolor.rgb () : Matrix ()); }
12238  octave_value get_shadowcolor (void) const { return shadowcolor.get (); }
12239 
12240  std::string get_title (void) const { return title.string_value (); }
12241 
12242  bool titleposition_is (const std::string& v) const { return titleposition.is (v); }
12243  std::string get_titleposition (void) const { return titleposition.current_value (); }
12244 
12245  bool units_is (const std::string& v) const { return units.is (v); }
12246  std::string get_units (void) const { return units.current_value (); }
12247 
12248 
12249  void set___object__ (const octave_value& val)
12250  {
12251  if (! error_state)
12252  {
12253  if (__object__.set (val, true))
12254  {
12255  mark_modified ();
12256  }
12257  }
12258  }
12259 
12261  {
12262  if (! error_state)
12263  {
12264  if (backgroundcolor.set (val, true))
12265  {
12266  mark_modified ();
12267  }
12268  }
12269  }
12270 
12271  void set_bordertype (const octave_value& val)
12272  {
12273  if (! error_state)
12274  {
12275  if (bordertype.set (val, true))
12276  {
12277  mark_modified ();
12278  }
12279  }
12280  }
12281 
12282  void set_borderwidth (const octave_value& val)
12283  {
12284  if (! error_state)
12285  {
12286  if (borderwidth.set (val, true))
12287  {
12288  mark_modified ();
12289  }
12290  }
12291  }
12292 
12293  void set_fontangle (const octave_value& val)
12294  {
12295  if (! error_state)
12296  {
12297  if (fontangle.set (val, true))
12298  {
12299  mark_modified ();
12300  }
12301  }
12302  }
12303 
12304  void set_fontname (const octave_value& val)
12305  {
12306  if (! error_state)
12307  {
12308  if (fontname.set (val, true))
12309  {
12310  mark_modified ();
12311  }
12312  }
12313  }
12314 
12315  void set_fontsize (const octave_value& val)
12316  {
12317  if (! error_state)
12318  {
12319  if (fontsize.set (val, true))
12320  {
12321  mark_modified ();
12322  }
12323  }
12324  }
12325 
12326  void set_fontunits (const octave_value& val);
12327 
12328  void set_fontweight (const octave_value& val)
12329  {
12330  if (! error_state)
12331  {
12332  if (fontweight.set (val, true))
12333  {
12334  mark_modified ();
12335  }
12336  }
12337  }
12338 
12340  {
12341  if (! error_state)
12342  {
12343  if (foregroundcolor.set (val, true))
12344  {
12345  mark_modified ();
12346  }
12347  }
12348  }
12349 
12351  {
12352  if (! error_state)
12353  {
12354  if (highlightcolor.set (val, true))
12355  {
12356  mark_modified ();
12357  }
12358  }
12359  }
12360 
12361  void set_position (const octave_value& val)
12362  {
12363  if (! error_state)
12364  {
12365  if (position.set (val, true))
12366  {
12367  mark_modified ();
12368  }
12369  }
12370  }
12371 
12372  void set_resizefcn (const octave_value& val)
12373  {
12374  if (! error_state)
12375  {
12376  if (resizefcn.set (val, true))
12377  {
12378  mark_modified ();
12379  }
12380  }
12381  }
12382 
12383  void set_shadowcolor (const octave_value& val)
12384  {
12385  if (! error_state)
12386  {
12387  if (shadowcolor.set (val, true))
12388  {
12389  mark_modified ();
12390  }
12391  }
12392  }
12393 
12394  void set_title (const octave_value& val)
12395  {
12396  if (! error_state)
12397  {
12398  if (title.set (val, true))
12399  {
12400  mark_modified ();
12401  }
12402  }
12403  }
12404 
12406  {
12407  if (! error_state)
12408  {
12409  if (titleposition.set (val, true))
12410  {
12411  mark_modified ();
12412  }
12413  }
12414  }
12415 
12416  void set_units (const octave_value& val);
12417 
12418 
12419  protected:
12420  void init (void)
12421  {
12422  position.add_constraint (dim_vector (1, 4));
12423  }
12424 
12425  void update_units (const caseless_str& old_units);
12426  void update_fontunits (const caseless_str& old_units);
12427 
12428  };
12429 
12430 private:
12432 
12433 public:
12435  : base_graphics_object (), xproperties (mh, p)
12436  { }
12437 
12438  ~uipanel (void) { }
12439 
12440  base_properties& get_properties (void) { return xproperties; }
12441 
12442  const base_properties& get_properties (void) const { return xproperties; }
12443 
12444  bool valid_object (void) const { return true; }
12445 
12446  bool has_readonly_property (const caseless_str& pname) const
12447  {
12448  bool retval = xproperties.has_readonly_property (pname);
12449  if (! retval)
12450  retval = base_properties::has_readonly_property (pname);
12451  return retval;
12452  }
12453 };
12454 
12455 // ---------------------------------------------------------------------
12456 
12458 {
12459 public:
12461  {
12462  public:
12463  // See the genprops.awk script for an explanation of the
12464  // properties declarations.
12465  // Programming note: Keep property list sorted if new ones are added.
12466 
12467 public:
12468  properties (const graphics_handle& mh, const graphics_handle& p);
12469 
12470  ~properties (void) { }
12471 
12472  void set (const caseless_str& pname, const octave_value& val);
12473 
12474  octave_value get (bool all = false) const;
12475 
12476  octave_value get (const caseless_str& pname) const;
12477 
12478  octave_value get (const std::string& pname) const
12479  {
12480  return get (caseless_str (pname));
12481  }
12482 
12483  octave_value get (const char *pname) const
12484  {
12485  return get (caseless_str (pname));
12486  }
12487 
12488  property get_property (const caseless_str& pname);
12489 
12490  std::string graphics_object_name (void) const { return go_name; }
12491 
12493 
12494 private:
12495  static std::string go_name;
12496 
12497 public:
12498 
12499 
12500  static std::set<std::string> core_property_names (void);
12501 
12502  static std::set<std::string> readonly_property_names (void);
12503 
12504  static bool has_core_property (const caseless_str& pname);
12505 
12506  static bool has_readonly_property (const caseless_str& pname);
12507 
12508  std::set<std::string> all_property_names (void) const;
12509 
12510  bool has_property (const caseless_str& pname) const;
12511 
12512 private:
12513 
12515 
12516 public:
12517 
12518  enum
12519  {
12520  ID___OBJECT__ = 14000
12521  };
12522 
12523  octave_value get___object__ (void) const { return __object__.get (); }
12524 
12525 
12526  void set___object__ (const octave_value& val)
12527  {
12528  if (! error_state)
12529  {
12530  if (__object__.set (val, true))
12531  {
12532  mark_modified ();
12533  }
12534  }
12535  }
12536 
12537 
12538  protected:
12539  void init (void)
12540  { }
12541  };
12542 
12543 private:
12545 
12546 public:
12548  : base_graphics_object (), xproperties (mh, p), default_properties ()
12549  { }
12550 
12551  ~uitoolbar (void) { }
12552 
12554  {
12555  // Allow parent (figure) to override first (properties knows how
12556  // to find the parent object).
12557  xproperties.override_defaults (obj);
12558 
12559  // Now override with our defaults. If the default_properties
12560  // list includes the properties for all defaults (line,
12561  // surface, etc.) then we don't have to know the type of OBJ
12562  // here, we just call its set function and let it decide which
12563  // properties from the list to use.
12564  obj.set_from_list (default_properties);
12565  }
12566 
12567  void set (const caseless_str& name, const octave_value& value)
12568  {
12569  if (name.compare ("default", 7))
12570  // strip "default", pass rest to function that will
12571  // parse the remainder and add the element to the
12572  // default_properties map.
12573  default_properties.set (name.substr (7), value);
12574  else
12575  xproperties.set (name, value);
12576  }
12577 
12578  octave_value get (const caseless_str& name) const
12579  {
12580  octave_value retval;
12581 
12582  if (name.compare ("default", 7))
12583  retval = get_default (name.substr (7));
12584  else
12585  retval = xproperties.get (name);
12586 
12587  return retval;
12588  }
12589 
12590  octave_value get_default (const caseless_str& name) const;
12591 
12593  {
12594  return default_properties.as_struct ("default");
12595  }
12596 
12598  {
12599  return default_properties;
12600  }
12601 
12602  base_properties& get_properties (void) { return xproperties; }
12603 
12604  const base_properties& get_properties (void) const { return xproperties; }
12605 
12606  bool valid_object (void) const { return true; }
12607 
12608  void reset_default_properties (void);
12609 
12610  bool has_readonly_property (const caseless_str& pname) const
12611  {
12612  bool retval = xproperties.has_readonly_property (pname);
12613  if (! retval)
12614  retval = base_properties::has_readonly_property (pname);
12615  return retval;
12616  }
12617 
12618 private:
12620 };
12621 
12622 // ---------------------------------------------------------------------
12623 
12625 {
12626 public:
12628  {
12629  public:
12630  // See the genprops.awk script for an explanation of the
12631  // properties declarations.
12632  // Programming note: Keep property list sorted if new ones are added.
12633 
12634 public:
12635  properties (const graphics_handle& mh, const graphics_handle& p);
12636 
12637  ~properties (void) { }
12638 
12639  void set (const caseless_str& pname, const octave_value& val);
12640 
12641  octave_value get (bool all = false) const;
12642 
12643  octave_value get (const caseless_str& pname) const;
12644 
12645  octave_value get (const std::string& pname) const
12646  {
12647  return get (caseless_str (pname));
12648  }
12649 
12650  octave_value get (const char *pname) const
12651  {
12652  return get (caseless_str (pname));
12653  }
12654 
12655  property get_property (const caseless_str& pname);
12656 
12657  std::string graphics_object_name (void) const { return go_name; }
12658 
12660 
12661 private:
12662  static std::string go_name;
12663 
12664 public:
12665 
12666 
12667  static std::set<std::string> core_property_names (void);
12668 
12669  static std::set<std::string> readonly_property_names (void);
12670 
12671  static bool has_core_property (const caseless_str& pname);
12672 
12673  static bool has_readonly_property (const caseless_str& pname);
12674 
12675  std::set<std::string> all_property_names (void) const;
12676 
12677  bool has_property (const caseless_str& pname) const;
12678 
12679 private:
12680 
12687 
12688 public:
12689 
12690  enum
12691  {
12692  ID___OBJECT__ = 15000,
12693  ID_CDATA = 15001,
12694  ID_CLICKEDCALLBACK = 15002,
12695  ID_ENABLE = 15003,
12696  ID_SEPARATOR = 15004,
12697  ID_TOOLTIPSTRING = 15005
12698  };
12699 
12700  octave_value get___object__ (void) const { return __object__.get (); }
12701 
12702  octave_value get_cdata (void) const { return cdata.get (); }
12703 
12704  void execute_clickedcallback (const octave_value& data = octave_value ()) const { clickedcallback.execute (data); }
12705  octave_value get_clickedcallback (void) const { return clickedcallback.get (); }
12706 
12707  bool is_enable (void) const { return enable.is_on (); }
12708  std::string get_enable (void) const { return enable.current_value (); }
12709 
12710  bool is_separator (void) const { return separator.is_on (); }
12711  std::string get_separator (void) const { return separator.current_value (); }
12712 
12713  std::string get_tooltipstring (void) const { return tooltipstring.string_value (); }
12714 
12715 
12716  void set___object__ (const octave_value& val)
12717  {
12718  if (! error_state)
12719  {
12720  if (__object__.set (val, true))
12721  {
12722  mark_modified ();
12723  }
12724  }
12725  }
12726 
12727  void set_cdata (const octave_value& val)
12728  {
12729  if (! error_state)
12730  {
12731  if (cdata.set (val, true))
12732  {
12733  mark_modified ();
12734  }
12735  }
12736  }
12737 
12739  {
12740  if (! error_state)
12741  {
12742  if (clickedcallback.set (val, true))
12743  {
12744  mark_modified ();
12745  }
12746  }
12747  }
12748 
12749  void set_enable (const octave_value& val)
12750  {
12751  if (! error_state)
12752  {
12753  if (enable.set (val, true))
12754  {
12755  mark_modified ();
12756  }
12757  }
12758  }
12759 
12760  void set_separator (const octave_value& val)
12761  {
12762  if (! error_state)
12763  {
12764  if (separator.set (val, true))
12765  {
12766  mark_modified ();
12767  }
12768  }
12769  }
12770 
12772  {
12773  if (! error_state)
12774  {
12775  if (tooltipstring.set (val, true))
12776  {
12777  mark_modified ();
12778  }
12779  }
12780  }
12781 
12782 
12783  protected:
12784  void init (void)
12785  {
12786  cdata.add_constraint ("double");
12787  cdata.add_constraint ("single");
12788  cdata.add_constraint (dim_vector (-1, -1, 3));
12789  }
12790  };
12791 
12792 private:
12794 
12795 public:
12797  : base_graphics_object (), xproperties (mh, p)
12798  { }
12799 
12800  ~uipushtool (void) { }
12801 
12802  base_properties& get_properties (void) { return xproperties; }
12803 
12804  const base_properties& get_properties (void) const { return xproperties; }
12805 
12806  bool valid_object (void) const { return true; }
12807 
12808  bool has_readonly_property (const caseless_str& pname) const
12809  {
12810  bool retval = xproperties.has_readonly_property (pname);
12811  if (! retval)
12812  retval = base_properties::has_readonly_property (pname);
12813  return retval;
12814  }
12815 
12816 };
12817 
12818 // ---------------------------------------------------------------------
12819 
12821 {
12822 public:
12824  {
12825  public:
12826  // See the genprops.awk script for an explanation of the
12827  // properties declarations.
12828  // Programming note: Keep property list sorted if new ones are added.
12829 
12830 public:
12831  properties (const graphics_handle& mh, const graphics_handle& p);
12832 
12833  ~properties (void) { }
12834 
12835  void set (const caseless_str& pname, const octave_value& val);
12836 
12837  octave_value get (bool all = false) const;
12838 
12839  octave_value get (const caseless_str& pname) const;
12840 
12841  octave_value get (const std::string& pname) const
12842  {
12843  return get (caseless_str (pname));
12844  }
12845 
12846  octave_value get (const char *pname) const
12847  {
12848  return get (caseless_str (pname));
12849  }
12850 
12851  property get_property (const caseless_str& pname);
12852 
12853  std::string graphics_object_name (void) const { return go_name; }
12854 
12856 
12857 private:
12858  static std::string go_name;
12859 
12860 public:
12861 
12862 
12863  static std::set<std::string> core_property_names (void);
12864 
12865  static std::set<std::string> readonly_property_names (void);
12866 
12867  static bool has_core_property (const caseless_str& pname);
12868 
12869  static bool has_readonly_property (const caseless_str& pname);
12870 
12871  std::set<std::string> all_property_names (void) const;
12872 
12873  bool has_property (const caseless_str& pname) const;
12874 
12875 private:
12876 
12886 
12887 public:
12888 
12889  enum
12890  {
12891  ID___OBJECT__ = 16000,
12892  ID_CDATA = 16001,
12893  ID_CLICKEDCALLBACK = 16002,
12894  ID_ENABLE = 16003,
12895  ID_OFFCALLBACK = 16004,
12896  ID_ONCALLBACK = 16005,
12897  ID_SEPARATOR = 16006,
12898  ID_STATE = 16007,
12899  ID_TOOLTIPSTRING = 16008
12900  };
12901 
12902  octave_value get___object__ (void) const { return __object__.get (); }
12903 
12904  octave_value get_cdata (void) const { return cdata.get (); }
12905 
12906  void execute_clickedcallback (const octave_value& data = octave_value ()) const { clickedcallback.execute (data); }
12907  octave_value get_clickedcallback (void) const { return clickedcallback.get (); }
12908 
12909  bool is_enable (void) const { return enable.is_on (); }
12910  std::string get_enable (void) const { return enable.current_value (); }
12911 
12912  void execute_offcallback (const octave_value& data = octave_value ()) const { offcallback.execute (data); }
12913  octave_value get_offcallback (void) const { return offcallback.get (); }
12914 
12915  void execute_oncallback (const octave_value& data = octave_value ()) const { oncallback.execute (data); }
12916  octave_value get_oncallback (void) const { return oncallback.get (); }
12917 
12918  bool is_separator (void) const { return separator.is_on (); }
12919  std::string get_separator (void) const { return separator.current_value (); }
12920 
12921  bool is_state (void) const { return state.is_on (); }
12922  std::string get_state (void) const { return state.current_value (); }
12923 
12924  std::string get_tooltipstring (void) const { return tooltipstring.string_value (); }
12925 
12926 
12927  void set___object__ (const octave_value& val)
12928  {
12929  if (! error_state)
12930  {
12931  if (__object__.set (val, true))
12932  {
12933  mark_modified ();
12934  }
12935  }
12936  }
12937 
12938  void set_cdata (const octave_value& val)
12939  {
12940  if (! error_state)
12941  {
12942  if (cdata.set (val, true))
12943  {
12944  mark_modified ();
12945  }
12946  }
12947  }
12948 
12950  {
12951  if (! error_state)
12952  {
12953  if (clickedcallback.set (val, true))
12954  {
12955  mark_modified ();
12956  }
12957  }
12958  }
12959 
12960  void set_enable (const octave_value& val)
12961  {
12962  if (! error_state)
12963  {
12964  if (enable.set (val, true))
12965  {
12966  mark_modified ();
12967  }
12968  }
12969  }
12970 
12971  void set_offcallback (const octave_value& val)
12972  {
12973  if (! error_state)
12974  {
12975  if (offcallback.set (val, true))
12976  {
12977  mark_modified ();
12978  }
12979  }
12980  }
12981 
12982  void set_oncallback (const octave_value& val)
12983  {
12984  if (! error_state)
12985  {
12986  if (oncallback.set (val, true))
12987  {
12988  mark_modified ();
12989  }
12990  }
12991  }
12992 
12993  void set_separator (const octave_value& val)
12994  {
12995  if (! error_state)
12996  {
12997  if (separator.set (val, true))
12998  {
12999  mark_modified ();
13000  }
13001  }
13002  }
13003 
13004  void set_state (const octave_value& val)
13005  {
13006  if (! error_state)
13007  {
13008  if (state.set (val, true))
13009  {
13010  mark_modified ();
13011  }
13012  }
13013  }
13014 
13016  {
13017  if (! error_state)
13018  {
13019  if (tooltipstring.set (val, true))
13020  {
13021  mark_modified ();
13022  }
13023  }
13024  }
13025 
13026 
13027  protected:
13028  void init (void)
13029  {
13030  cdata.add_constraint ("double");
13031  cdata.add_constraint ("single");
13032  cdata.add_constraint (dim_vector (-1, -1, 3));
13033  }
13034  };
13035 
13036 private:
13038 
13039 public:
13041  : base_graphics_object (), xproperties (mh, p)
13042  { }
13043 
13044  ~uitoggletool (void) { }
13045 
13046  base_properties& get_properties (void) { return xproperties; }
13047 
13048  const base_properties& get_properties (void) const { return xproperties; }
13049 
13050  bool valid_object (void) const { return true; }
13051 
13052  bool has_readonly_property (const caseless_str& pname) const
13053  {
13054  bool retval = xproperties.has_readonly_property (pname);
13055  if (! retval)
13056  retval = base_properties::has_readonly_property (pname);
13057  return retval;
13058  }
13059 
13060 };
13061 
13062 // ---------------------------------------------------------------------
13063 
13065 get_property_from_handle (double handle, const std::string& property,
13066  const std::string& func);
13067 bool
13068 set_property_in_handle (double handle, const std::string& property,
13069  const octave_value& arg, const std::string& func);
13070 
13071 // ---------------------------------------------------------------------
13072 
13073 class graphics_event;
13074 
13075 class
13077 {
13078 public:
13079  friend class graphics_event;
13080 
13081  base_graphics_event (void) : count (1) { }
13082 
13083  virtual ~base_graphics_event (void) { }
13084 
13085  virtual void execute (void) = 0;
13086 
13087 private:
13089 };
13090 
13091 class
13093 {
13094 public:
13095  typedef void (*event_fcn) (void*);
13096 
13097  graphics_event (void) : rep (0) { }
13098 
13100  {
13101  rep->count++;
13102  }
13103 
13105  {
13106  if (rep && --rep->count == 0)
13107  delete rep;
13108  }
13109 
13111  {
13112  if (rep != e.rep)
13113  {
13114  if (rep && --rep->count == 0)
13115  delete rep;
13116 
13117  rep = e.rep;
13118  if (rep)
13119  rep->count++;
13120  }
13121 
13122  return *this;
13123  }
13124 
13125  void execute (void)
13126  { if (rep) rep->execute (); }
13127 
13128  bool ok (void) const
13129  { return (rep != 0); }
13130 
13131  static graphics_event
13133  const std::string& name,
13134  const octave_value& data = Matrix ());
13135 
13136  static graphics_event
13138  const octave_value& cb,
13139  const octave_value& data = Matrix ());
13140 
13141  static graphics_event
13142  create_function_event (event_fcn fcn, void *data = 0);
13143 
13144  static graphics_event
13145  create_set_event (const graphics_handle& h, const std::string& name,
13146  const octave_value& value,
13147  bool notify_toolkit = true);
13148 private:
13150 };
13151 
13153 {
13154 protected:
13155 
13156  gh_manager (void);
13157 
13158 public:
13159 
13160  static void create_instance (void);
13161 
13162  static bool instance_ok (void)
13163  {
13164  bool retval = true;
13165 
13166  if (! instance)
13167  create_instance ();
13168 
13169  if (! instance)
13170  {
13171  ::error ("unable to create gh_manager!");
13172 
13173  retval = false;
13174  }
13175 
13176  return retval;
13177  }
13178 
13179  static void cleanup_instance (void) { delete instance; instance = 0; }
13180 
13181  static graphics_handle get_handle (bool integer_figure_handle)
13182  {
13183  return instance_ok ()
13184  ? instance->do_get_handle (integer_figure_handle)
13185  : graphics_handle ();
13186  }
13187 
13188  static void free (const graphics_handle& h)
13189  {
13190  if (instance_ok ())
13191  instance->do_free (h);
13192  }
13193 
13194  static void renumber_figure (const graphics_handle& old_gh,
13195  const graphics_handle& new_gh)
13196  {
13197  if (instance_ok ())
13198  instance->do_renumber_figure (old_gh, new_gh);
13199  }
13200 
13201  static graphics_handle lookup (double val)
13202  {
13203  return instance_ok () ? instance->do_lookup (val) : graphics_handle ();
13204  }
13205 
13207  {
13208  return val.is_real_scalar ()
13209  ? lookup (val.double_value ()) : graphics_handle ();
13210  }
13211 
13212  static graphics_object get_object (double val)
13213  {
13214  return get_object (lookup (val));
13215  }
13216 
13218  {
13219  return instance_ok () ? instance->do_get_object (h) : graphics_object ();
13220  }
13221 
13222  static graphics_handle
13223  make_graphics_handle (const std::string& go_name,
13224  const graphics_handle& parent,
13225  bool integer_figure_handle = false,
13226  bool do_createfcn = true,
13227  bool do_notify_toolkit = true)
13228  {
13229  return instance_ok ()
13230  ? instance->do_make_graphics_handle (go_name, parent,
13231  integer_figure_handle,
13232  do_createfcn, do_notify_toolkit)
13233  : graphics_handle ();
13234  }
13235 
13237  bool do_notify_toolkit = true)
13238  {
13239  return instance_ok ()
13240  ? instance->do_make_figure_handle (val, do_notify_toolkit)
13241  : graphics_handle ();
13242  }
13243 
13244  static void push_figure (const graphics_handle& h)
13245  {
13246  if (instance_ok ())
13247  instance->do_push_figure (h);
13248  }
13249 
13250  static void pop_figure (const graphics_handle& h)
13251  {
13252  if (instance_ok ())
13253  instance->do_pop_figure (h);
13254  }
13255 
13257  {
13258  return instance_ok ()
13259  ? instance->do_current_figure () : graphics_handle ();
13260  }
13261 
13262  static Matrix handle_list (bool show_hidden = false)
13263  {
13264  return instance_ok ()
13265  ? instance->do_handle_list (show_hidden) : Matrix ();
13266  }
13267 
13268  static void lock (void)
13269  {
13270  if (instance_ok ())
13271  instance->do_lock ();
13272  }
13273 
13274  static bool try_lock (void)
13275  {
13276  if (instance_ok ())
13277  return instance->do_try_lock ();
13278  else
13279  return false;
13280  }
13281 
13282  static void unlock (void)
13283  {
13284  if (instance_ok ())
13285  instance->do_unlock ();
13286  }
13287 
13288  static Matrix figure_handle_list (bool show_hidden = false)
13289  {
13290  return instance_ok ()
13291  ? instance->do_figure_handle_list (show_hidden) : Matrix ();
13292  }
13293 
13294  static void execute_listener (const graphics_handle& h,
13295  const octave_value& l)
13296  {
13297  if (instance_ok ())
13298  instance->do_execute_listener (h, l);
13299  }
13300 
13301  static void execute_callback (const graphics_handle& h,
13302  const std::string& name,
13303  const octave_value& data = Matrix ())
13304  {
13305  octave_value cb;
13306 
13307  if (true)
13308  {
13309  gh_manager::auto_lock lock;
13310 
13311  graphics_object go = get_object (h);
13312 
13313  if (go.valid_object ())
13314  cb = go.get (name);
13315  }
13316 
13317  if (! error_state)
13318  execute_callback (h, cb, data);
13319  }
13320 
13321  static void execute_callback (const graphics_handle& h,
13322  const octave_value& cb,
13323  const octave_value& data = Matrix ())
13324  {
13325  if (instance_ok ())
13326  instance->do_execute_callback (h, cb, data);
13327  }
13328 
13329  static void post_callback (const graphics_handle& h,
13330  const std::string& name,
13331  const octave_value& data = Matrix ())
13332  {
13333  if (instance_ok ())
13334  instance->do_post_callback (h, name, data);
13335  }
13336 
13337  static void post_function (graphics_event::event_fcn fcn, void* data = 0)
13338  {
13339  if (instance_ok ())
13340  instance->do_post_function (fcn, data);
13341  }
13342 
13343  static void post_set (const graphics_handle& h, const std::string& name,
13344  const octave_value& value, bool notify_toolkit = true)
13345  {
13346  if (instance_ok ())
13347  instance->do_post_set (h, name, value, notify_toolkit);
13348  }
13349 
13350  static int process_events (void)
13351  {
13352  return (instance_ok () ? instance->do_process_events () : 0);
13353  }
13354 
13355  static int flush_events (void)
13356  {
13357  return (instance_ok () ? instance->do_process_events (true) : 0);
13358  }
13359 
13360  static void enable_event_processing (bool enable = true)
13361  {
13362  if (instance_ok ())
13363  instance->do_enable_event_processing (enable);
13364  }
13365 
13366  static bool is_handle_visible (const graphics_handle& h)
13367  {
13368  bool retval = false;
13369 
13370  graphics_object go = get_object (h);
13371 
13372  if (go.valid_object ())
13373  retval = go.is_handle_visible ();
13374 
13375  return retval;
13376  }
13377 
13378  static void close_all_figures (void)
13379  {
13380  if (instance_ok ())
13381  instance->do_close_all_figures ();
13382  }
13383 
13384 public:
13386  {
13387  public:
13388  auto_lock (bool wait = true)
13389  : octave_autolock (instance_ok ()
13390  ? instance->graphics_lock
13391  : octave_mutex (),
13392  wait)
13393  { }
13394 
13395  private:
13396 
13397  // No copying!
13398  auto_lock (const auto_lock&);
13399  auto_lock& operator = (const auto_lock&);
13400  };
13401 
13402 private:
13403 
13405 
13406  typedef std::map<graphics_handle, graphics_object>::iterator iterator;
13407  typedef std::map<graphics_handle, graphics_object>::const_iterator
13409 
13410  typedef std::set<graphics_handle>::iterator free_list_iterator;
13411  typedef std::set<graphics_handle>::const_iterator const_free_list_iterator;
13412 
13413  typedef std::list<graphics_handle>::iterator figure_list_iterator;
13414  typedef std::list<graphics_handle>::const_iterator const_figure_list_iterator;
13415 
13416  // A map of handles to graphics objects.
13417  std::map<graphics_handle, graphics_object> handle_map;
13418 
13419  // The available graphics handles.
13420  std::set<graphics_handle> handle_free_list;
13421 
13422  // The next handle available if handle_free_list is empty.
13423  double next_handle;
13424 
13425  // The allocated figure handles. Top of the stack is most recently
13426  // created.
13427  std::list<graphics_handle> figure_list;
13428 
13429  // The lock for accessing the graphics sytsem.
13431 
13432  // The list of events queued by graphics toolkits.
13433  std::list<graphics_event> event_queue;
13434 
13435  // The stack of callback objects.
13436  std::list<graphics_object> callback_objects;
13437 
13438  // A flag telling whether event processing must be constantly on.
13440 
13441  graphics_handle do_get_handle (bool integer_figure_handle);
13442 
13443  void do_free (const graphics_handle& h);
13444 
13445  void do_renumber_figure (const graphics_handle& old_gh,
13446  const graphics_handle& new_gh);
13447 
13449  {
13450  iterator p = (xisnan (val) ? handle_map.end () : handle_map.find (val));
13451 
13452  return (p != handle_map.end ()) ? p->first : graphics_handle ();
13453  }
13454 
13456  {
13457  iterator p = (h.ok () ? handle_map.find (h) : handle_map.end ());
13458 
13459  return (p != handle_map.end ()) ? p->second : graphics_object ();
13460  }
13461 
13462  graphics_handle do_make_graphics_handle (const std::string& go_name,
13463  const graphics_handle& p,
13464  bool integer_figure_handle,
13465  bool do_createfcn,
13466  bool do_notify_toolkit);
13467 
13468  graphics_handle do_make_figure_handle (double val, bool do_notify_toolkit);
13469 
13470  Matrix do_handle_list (bool show_hidden)
13471  {
13472  Matrix retval (1, handle_map.size ());
13473 
13474  octave_idx_type i = 0;
13475  for (const_iterator p = handle_map.begin (); p != handle_map.end (); p++)
13476  {
13477  graphics_handle h = p->first;
13478 
13479  if (show_hidden || is_handle_visible (h))
13480  retval(i++) = h.value ();
13481  }
13482 
13483  retval.resize (1, i);
13484 
13485  return retval;
13486  }
13487 
13488  Matrix do_figure_handle_list (bool show_hidden)
13489  {
13490  Matrix retval (1, figure_list.size ());
13491 
13492  octave_idx_type i = 0;
13493  for (const_figure_list_iterator p = figure_list.begin ();
13494  p != figure_list.end ();
13495  p++)
13496  {
13497  graphics_handle h = *p;
13498 
13499  if (show_hidden || is_handle_visible (h))
13500  retval(i++) = h.value ();
13501  }
13502 
13503  retval.resize (1, i);
13504 
13505  return retval;
13506  }
13507 
13508  void do_push_figure (const graphics_handle& h);
13509 
13510  void do_pop_figure (const graphics_handle& h);
13511 
13513  {
13514  graphics_handle retval;
13515 
13516  for (const_figure_list_iterator p = figure_list.begin ();
13517  p != figure_list.end ();
13518  p++)
13519  {
13520  graphics_handle h = *p;
13521 
13522  if (is_handle_visible (h))
13523  retval = h;
13524  }
13525 
13526  return retval;
13527  }
13528 
13529  void do_lock (void) { graphics_lock.lock (); }
13530 
13531  bool do_try_lock (void) { return graphics_lock.try_lock (); }
13532 
13533  void do_unlock (void) { graphics_lock.unlock (); }
13534 
13535  void do_execute_listener (const graphics_handle& h, const octave_value& l);
13536 
13537  void do_execute_callback (const graphics_handle& h, const octave_value& cb,
13538  const octave_value& data);
13539 
13540  void do_post_callback (const graphics_handle& h, const std::string& name,
13541  const octave_value& data);
13542 
13543  void do_post_function (graphics_event::event_fcn fcn, void* fcn_data);
13544 
13545  void do_post_set (const graphics_handle& h, const std::string& name,
13546  const octave_value& value, bool notify_toolkit = true);
13547 
13548  int do_process_events (bool force = false);
13549 
13550  void do_close_all_figures (void);
13551 
13552  static void restore_gcbo (void)
13553  {
13554  if (instance_ok ())
13555  instance->do_restore_gcbo ();
13556  }
13557 
13558  void do_restore_gcbo (void);
13559 
13560  void do_post_event (const graphics_event& e);
13561 
13562  void do_enable_event_processing (bool enable = true);
13563 };
13564 
13565 void get_children_limits (double& min_val, double& max_val,
13566  double& min_pos, double& max_neg,
13567  const Matrix& kids, char limit_type);
13568 
13570 
13571 // This function is NOT equivalent to the scripting language function gcf.
13573 
13574 // This function is NOT equivalent to the scripting language function gca.
13576 
13577 OCTINTERP_API void close_all_figures (void);
13578 
13579 #endif
bool_property zliminclude
Definition: graphics.h:7352
std::string get_fontunits(void) const
Definition: graphics.h:11719
bool is_rgb(void) const
Definition: graphics.h:1141
void set_callback(const octave_value &val)
Definition: graphics.h:11785
void set_interpreter(const octave_value &val)
Definition: graphics.h:10400
octave_value get_zcolor(void) const
Definition: graphics.h:5696
double get_screen_resolution(void) const
Definition: graphics.h:2255
static void close_all_figures(void)
Definition: graphics.h:13378
void validate(void) const
Definition: graphics.h:1066
void set___enhanced__(const octave_value &val)
Definition: graphics.h:4851
array_property currentpoint
Definition: graphics.h:4036
void set_windowkeypressfcn(const octave_value &val)
Definition: graphics.h:4717
enum double_radio_property::current_enum current_type
radio_property fontunits
Definition: graphics.h:7836
bool is_climinclude(void) const
Definition: graphics.h:9946
bool_property zliminclude
Definition: graphics.h:9155
void set_createfcn(const octave_value &val)
Definition: graphics.h:2822
radio_property yticklabelmode
Definition: graphics.h:5359
void do_register_toolkit(const std::string &name)
Definition: graphics.cc:11076
bool do_set(const octave_value &newval)
Definition: graphics.h:982
virtual base_property * clone(void) const
Definition: graphics.h:402
void execute_closerequestfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4158
std::string get_linestyle(void) const
Definition: graphics.h:10153
void set_specularstrength(const octave_value &val)
Definition: graphics.h:10522
std::string get_interpreter(void) const
Definition: graphics.h:10150
std::map< graphics_handle, graphics_object >::iterator iterator
Definition: graphics.h:13406
void set_faces(const octave_value &val)
Definition: graphics.h:9479
const std::string & current_value(void) const
Definition: graphics.h:1290
radio_property verticalalignment
Definition: graphics.h:11657
void set_activepositionproperty(const octave_value &val)
Definition: graphics.h:5755
std::string get_xdisplay(void) const
Definition: graphics.h:4283
static void pop_figure(const graphics_handle &h)
Definition: graphics.h:13250
std::string graphics_object_name(void) const
Definition: graphics.h:5263
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:9469
row_vector_property ylim
Definition: graphics.h:8571
const base_properties & get_properties(void) const
Definition: graphics.h:11554
bool_property enable
Definition: graphics.h:11213
bool camerapositionmode_is(const std::string &v) const
Definition: graphics.h:5510
std::string get_marker(void) const
Definition: graphics.h:7401
static bool has_readonly_property(const caseless_str &pname)
std::string get_name(void) const
Definition: graphics.h:2129
bool is_radio(void) const
Definition: graphics.h:1277
octave_value get_xlim(void) const
Definition: graphics.h:9304
void set_linewidth(const octave_value &val)
Definition: graphics.h:8164
void warning_with_id(const char *id, const char *fmt,...)
Definition: error.cc:696
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:12081
bool facealpha_is_double(void) const
Definition: graphics.h:10136
graphics_handle get_currentaxes(void) const
Definition: graphics.h:4168
array_property colororder
Definition: graphics.h:5303
Matrix get_color_rgb(void) const
Definition: graphics.h:4163
graphics_event(const graphics_event &e)
Definition: graphics.h:13099
int bool
Definition: mex.h:56
void do_unload_toolkit(const std::string &name)
Definition: graphics.h:2412
Matrix scale(const Matrix &m) const
Definition: graphics.h:214
void set_resizefcn(const octave_value &val)
Definition: graphics.h:12372
static void clear(octave_shlib &oct_file)
Definition: dynamic-ld.cc:236
callback_property clickedcallback
Definition: graphics.h:12683
const base_properties & get_properties(void) const
Definition: graphics.h:11392
void set_xdisplay(const octave_value &val)
Definition: graphics.h:4783
std::string do_default_toolkit(void)
Definition: graphics.h:2468
row_vector_property ylim
Definition: graphics.h:10908
octave_value get_default(const caseless_str &name) const
Definition: graphics.h:3320
static void unload_all_toolkits(void)
Definition: graphics.h:2341
plist_map_iterator find(const std::string &go_name)
Definition: graphics.h:2097
void update_ztick(void)
Definition: graphics.h:6940
base_graphics_toolkit * rep
Definition: graphics.h:2289
bool valid_object(void) const
Definition: graphics.h:7253
octave_value get_xticklabel(void) const
Definition: graphics.h:5645
string_property tag
Definition: graphics.h:2681
octave_value get_clim(void) const
Definition: graphics.h:8624
bool ytickmode_is(const std::string &v) const
Definition: graphics.h:5690
void set(const caseless_str &pname, const octave_value &val)
Matrix get_children(void) const
Definition: graphics.h:1668
octave_value data
Definition: graphics.h:1623
Matrix do_handle_list(bool show_hidden)
Definition: graphics.h:13470
bool is_separator(void) const
Definition: graphics.h:12918
radio_values radio_val
Definition: graphics.h:1315
std::string get_interpreter(void) const
Definition: graphics.h:7943
std::string get_enable(void) const
Definition: graphics.h:12910
callback_property keypressfcn
Definition: graphics.h:11646
void set_drawmode(const octave_value &val)
Definition: graphics.h:6007
void set_fontname(const octave_value &val)
Definition: graphics.h:6030
void set_climinclude(const octave_value &val)
Definition: graphics.h:9772
static std::string go_name
Definition: graphics.h:9983
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:1099
void set_numbertitle(const octave_value &val)
Definition: graphics.h:4511
std::string get_clipping(void) const
Definition: graphics.h:2725
static std::string go_name
Definition: graphics.h:11190
bool_property yliminclude
Definition: graphics.h:8575
ft_render renderer
Definition: graphics.h:8396
row_vector_property zlim
Definition: graphics.h:7349
graphics_handle get_parent(void) const
Definition: graphics.h:3361
double get_zPlaneN(void) const
Definition: graphics.h:5144
string_property fontname
Definition: graphics.h:7834
callback_property closerequestfcn
Definition: graphics.h:4030
std::string dtk
Definition: graphics.h:2382
octave_value get_position(void) const
Definition: graphics.h:5591
void set_mincolormap(const octave_value &val)
Definition: graphics.h:4478
octave_value get_alphadata(void) const
Definition: graphics.h:8603
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:11396
Matrix get_markeredgecolor_rgb(void) const
Definition: graphics.h:7405
std::string get_title(void) const
Definition: graphics.h:12240
Matrix get_opengl_matrix_1(void) const
Definition: graphics.h:5132
octave_value get_zlim(void) const
Definition: graphics.h:9308
array_property xdata
Definition: graphics.h:10031
row_vector_property zlim
Definition: graphics.h:10909
radio_property activepositionproperty
Definition: graphics.h:5287
void add_constraint(const std::string &type)
Definition: graphics.h:1352
std::string get_zticklabelmode(void) const
Definition: graphics.h:5725
auto_lock(bool wait=true)
Definition: graphics.h:13388
radio_property horizontalalignmentmode
Definition: graphics.h:7856
base_graphics_object(const base_graphics_object &)
Definition: graphics.h:3222
std::string get_busyaction(void) const
Definition: graphics.h:2719
void set_displayname(const octave_value &val)
Definition: graphics.h:10965
radio_property verticalalignmentmode
Definition: graphics.h:7857
void delete_listener(const octave_value &v=octave_value(), listener_mode mode=POSTSET)
Definition: graphics.h:1963
octave_value get_default(const caseless_str &name) const
Definition: graphics.h:3830
std::string get_zliminclude(void) const
Definition: graphics.h:7977
std::string get_linestyle(void) const
Definition: graphics.h:7946
property_list get_defaults_list(void) const
Definition: graphics.h:12597
void set_ambientstrength(const octave_value &val)
Definition: graphics.h:10243
radio_property interpreter
Definition: graphics.h:7334
std::string get_xlimmode(void) const
Definition: graphics.h:5632
bool is_zliminclude(void) const
Definition: graphics.h:10214
virtual void reparent(const graphics_handle &np)
Definition: graphics.h:3106
Definition: Cell.h:35
row_vector_property xlim
Definition: graphics.h:10039
array_property cdata
Definition: graphics.h:12878
std::string get_paperorientation(void) const
Definition: graphics.h:4212
void set_pointerlocation(const octave_value &val)
Definition: graphics.h:3695
void set_ylimmode(const octave_value &val)
Definition: graphics.h:6501
void set_zlim(const octave_value &val)
Definition: graphics.h:10666
bool handlevisibility_is(const std::string &v) const
Definition: graphics.h:2733
row_vector_property(const std::string &nm, const graphics_handle &h, const octave_value &m)
Definition: graphics.h:1435
std::string get_xliminclude(void) const
Definition: graphics.h:7971
std::string get_nextplot(void) const
Definition: graphics.h:4204
std::set< std::string > dynamic_properties
Definition: graphics.h:2643
radio_values & operator=(const radio_values &a)
Definition: graphics.h:859
void set_wvisual(const octave_value &val)
Definition: graphics.h:4761
octave_refcount< int > count
Definition: graphics.h:13088
radio_property toolbar
Definition: graphics.h:4065
Matrix get_markeredgecolor_rgb(void) const
Definition: graphics.h:9271
void set_screendepth(const octave_value &val)
Definition: graphics.h:3719
octave_value get___object__(void) const
Definition: graphics.h:12902
bool_property clipping
Definition: graphics.h:11636
void set_alphadata(const octave_value &val)
Definition: graphics.h:8643
radio_property zscale
Definition: graphics.h:5369
base_property * clone(void) const
Definition: graphics.h:1613
void set_interpreter(const octave_value &val)
Definition: graphics.h:9514
std::string get_facelighting(void) const
Definition: graphics.h:10147
static void post_callback(const graphics_handle &h, const std::string &name, const octave_value &data=Matrix())
Definition: graphics.h:13329
void set_xlim(const octave_value &val)
Definition: graphics.h:7622
radio_property alimmode
Definition: graphics.h:5289
void set_linestyle(const octave_value &val)
Definition: graphics.h:10411
std::string values_as_string(void) const
Definition: graphics.cc:1119
std::string string_value(void) const
Definition: graphics.h:537
void set_zlim(const octave_value &val)
Definition: graphics.h:9746
std::string get_backfacelighting(void) const
Definition: graphics.h:9212
row_vector_property zlim
Definition: graphics.h:9150
std::string graphics_object_name(void) const
Definition: graphics.h:3508
text_label_property(const std::string &s, const graphics_handle &h, const NDArray &nda)
Definition: graphics.h:689
Matrix get_facecolor_rgb(void) const
Definition: graphics.h:10143
double get_borderwidth(void) const
Definition: graphics.h:12205
double_radio_property edgealpha
Definition: graphics.h:9120
static std::string go_name
Definition: graphics.h:11613
octave_value get_cameraupvector(void) const
Definition: graphics.h:5518
void set_xscale(const octave_value &val)
Definition: graphics.h:6381
bool is_real_type(void) const
Definition: ov.h:651
std::string values_as_string(void) const
Definition: graphics.h:964
std::string get_alphadatamapping(void) const
Definition: graphics.h:8606
void set_name(const std::string &name)
Definition: graphics.h:1906
void set_zdata(const octave_value &val)
Definition: graphics.h:10591
OCTINTERP_API bool validate(const octave_value &v)
bool_property numbertitle
Definition: graphics.h:4048
bool enable_is(const std::string &v) const
Definition: graphics.h:11706
virtual bool do_set(const octave_value &)
Definition: graphics.h:406
void set_fontweight(const octave_value &val)
Definition: graphics.h:11878
octave_value get_ambientlightcolor(void) const
Definition: graphics.h:5503
any_property __object__
Definition: graphics.h:12154
bool linestyle_is(const std::string &v) const
Definition: graphics.h:9261
octave_value get_position(void) const
Definition: graphics.h:11741
void update_looseinset(void)
Definition: graphics.h:7057
octave_value get_xcolor(void) const
Definition: graphics.h:5619
double get_fontsize(void) const
Definition: graphics.h:5555
NDArray scale(const NDArray &m) const
Definition: graphics.h:172
octave_idx_type nelem(void) const
Definition: graphics.h:931
properties xproperties
Definition: graphics.h:11543
bool zcolor_is(const std::string &v) const
Definition: graphics.h:5694
void set_ydata(const octave_value &val)
Definition: graphics.h:9670
color_property(const std::string &nm, const graphics_handle &h, const radio_values &v)
Definition: graphics.h:1107
void override_defaults(base_graphics_object &obj)
Definition: graphics.h:4920
int get_zstate(void) const
Definition: graphics.h:5138
std::map< graphics_handle, graphics_object > handle_map
Definition: graphics.h:13417
void mark_modified(void)
Definition: graphics.h:3793
void update_zticklabelmode(void)
Definition: graphics.h:6985
void set_position(const octave_value &val)
Definition: graphics.h:11341
double get_edgealpha_double(void) const
Definition: graphics.h:9225
OCTINTERP_API bool is_equal(const octave_value &v) const
Definition: graphics.cc:1376
void update_alphadata(void)
Definition: graphics.h:8894
bool_property zminorgrid
Definition: graphics.h:5367
bool interpreter_is(const std::string &v) const
Definition: graphics.h:5566
enum color_property::current_enum current_type
bool color_is_rgb(void) const
Definition: graphics.h:7382
bool_property separator
Definition: graphics.h:11217
octave_value get_pointershapecdata(void) const
Definition: graphics.h:4230
virtual bool is_climinclude(void) const
Definition: graphics.h:2631
void set_selected(const octave_value &val)
Definition: graphics.h:2877
bool valid_object(void) const
Definition: graphics.h:11123
radio_property zdir
Definition: graphics.h:5362
bool projection_is(const std::string &v) const
Definition: graphics.h:5593
void set_cdata(const octave_value &val)
Definition: graphics.h:9355
bool cdatamapping_is(const std::string &v) const
Definition: graphics.h:9216
callback_property buttondownfcn
Definition: graphics.h:4029
octave_value get(bool all=false) const
bool xlimmode_is(const std::string &v) const
Definition: graphics.h:5631
radio_property minorgridlinestyle
Definition: graphics.h:5318
string_property fontname
Definition: graphics.h:11640
bool backgroundcolor_is_rgb(void) const
Definition: graphics.h:7901
std::string get_backfacelighting(void) const
Definition: graphics.h:10107
bool is_visible(void) const
Definition: graphics.h:2758
Cell values_as_cell(void) const
Definition: graphics.h:966
~line(void)
Definition: graphics.h:7724
bool interpreter_is(const std::string &v) const
Definition: graphics.h:10149
property(base_property *bp, bool persist=false)
Definition: graphics.h:1886
double_property linewidth
Definition: graphics.h:7841
double double_value(void) const
Definition: graphics.h:1282
void set_alphamap(const octave_value &val)
Definition: graphics.h:4309
base_properties & get_properties(void)
Definition: graphics.h:12075
void set___object__(const octave_value &val)
Definition: graphics.h:12249
bool_property xliminclude
Definition: graphics.h:7851
row_vector_property ytick
Definition: graphics.h:5357
double_radio_property(const std::string &nm, const graphics_handle &h, const std::string &v)
Definition: graphics.h:1248
void update_alphadata(void)
Definition: graphics.h:10763
radio_property zlimmode
Definition: graphics.h:5366
std::string get_verticalalignment(void) const
Definition: graphics.h:11760
row_vector_property value
Definition: graphics.h:11656
void set_zdatasource(const octave_value &val)
Definition: graphics.h:7611
void override_defaults(base_graphics_object &obj)
Definition: graphics.cc:3073
void(* event_fcn)(void *)
Definition: graphics.h:13095
bool is_xliminclude(void) const
Definition: graphics.h:10955
virtual property get_property(const caseless_str &pname)
color_property & operator=(const octave_value &val)
Definition: graphics.h:1164
property_list get_defaults_list(void) const
Definition: graphics.h:7239
float pixel_size(octave_idx_type dim, const Matrix limits)
Definition: graphics.h:8978
bool backgroundcolor_is_rgb(void) const
Definition: graphics.h:11693
bool foregroundcolor_is(const std::string &v) const
Definition: graphics.h:11250
octave_value get_xlim(void) const
Definition: graphics.h:5629
base_property * clone(void) const
Definition: graphics.h:1212
static graphics_object get_object(const graphics_handle &h)
Definition: graphics.h:13217
double_property recursionlimit
Definition: graphics.h:3546
bool alphadatamapping_is(const std::string &v) const
Definition: graphics.h:9206
octave_value reshape(const dim_vector &dv) const
Definition: ov.h:498
octave_idx_type rows(void) const
Definition: ov.h:473
static graphics_toolkit get_toolkit(void)
Definition: graphics.h:2296
std::string get_yaxislocation(void) const
Definition: graphics.h:5654
row_vector_property alim
Definition: graphics.h:10037
std::set< graphics_handle > handle_free_list
Definition: graphics.h:13420
bool_property xminorgrid
Definition: graphics.h:5340
virtual void update(const graphics_object &, int)
Definition: graphics.h:2162
static std::string go_name
Definition: graphics.h:3513
std::string get_zliminclude(void) const
Definition: graphics.h:9317
double_property specularcolorreflectance
Definition: graphics.h:10027
void set(const caseless_str &name, const octave_value &value)
Definition: graphics.h:4934
radio_property fontweight
Definition: graphics.h:11643
void set_ylim(const octave_value &val)
Definition: graphics.h:11020
std::string get_name(void) const
Definition: graphics.h:4201
void update_xtick(void)
Definition: graphics.h:6928
Matrix get_backgroundcolor_rgb(void) const
Definition: graphics.h:12199
void set_backfacelighting(const octave_value &val)
Definition: graphics.h:9344
bool fontangle_is(const std::string &v) const
Definition: graphics.h:11711
void set___object__(const octave_value &val)
Definition: graphics.h:11264
double get_x_max(void) const
Definition: graphics.h:5152
void execute_callback(const octave_value &data=octave_value()) const
Definition: graphics.h:11489
void update_fontsize(void)
Definition: graphics.h:12056
void set_linewidth(const octave_value &val)
Definition: graphics.h:10422
octave_value get_edgecolor(void) const
Definition: graphics.h:10128
std::string get_fontunits(void) const
Definition: graphics.h:7934
octave_value get_zlim(void) const
Definition: graphics.h:10206
void set_ytick(const octave_value &val)
Definition: graphics.h:6550
void set_min(const octave_value &val)
Definition: graphics.h:11945
bool_property box
Definition: graphics.h:5291
bool_property(const bool_property &p)
Definition: graphics.h:1530
static std::set< std::string > core_property_names(void)
void set_xdata(const octave_value &val)
Definition: graphics.h:7553
bool zticklabelmode_is(const std::string &v) const
Definition: graphics.h:5724
void update_string(void)
Definition: graphics.h:8441
void set_renderermode(const octave_value &val)
Definition: graphics.h:4627
static void register_toolkit(const std::string &name)
Definition: graphics.h:2301
void set_displayname(const octave_value &val)
Definition: graphics.h:10312
bool gridlinestyle_is(const std::string &v) const
Definition: graphics.h:5563
std::string get_menubar(void) const
Definition: graphics.h:4197
bool_property xliminclude
Definition: graphics.h:10912
void set_pointerwindow(const octave_value &val)
Definition: graphics.h:3706
void set_clim(const octave_value &val)
Definition: graphics.h:9707
void set_commandwindowsize(const octave_value &val)
Definition: graphics.h:3628
void erase(const std::string pname)
Definition: graphics.h:2056
bool xisnan(double x)
Definition: lo-mappers.cc:144
bool edgealpha_is(const std::string &v) const
Definition: graphics.h:9224
bool do_set(const octave_value &val)
Definition: graphics.h:1714
void update_zdir(void)
Definition: graphics.h:6922
void set_markeredgecolor(const octave_value &val)
Definition: graphics.h:10444
octave_value full_value(void) const
Definition: ov.h:385
bool foregroundcolor_is(const std::string &v) const
Definition: graphics.h:11725
~hggroup(void)
Definition: graphics.h:11117
double_property markersize
Definition: graphics.h:9136
graphics_handle get_xlabel(void) const
Definition: graphics.h:5627
std::string get_xvisual(void) const
Definition: graphics.h:4285
void set_horizontalalignmentmode(const octave_value &val)
Definition: graphics.h:8344
std::string graphics_object_name(void) const
Definition: graphics.h:12657
octave_value get_markerfacecolor(void) const
Definition: graphics.h:10168
octave_value get_edgecolor(void) const
Definition: graphics.h:7916
void set_ydata(const octave_value &val)
Definition: graphics.h:7576
color_property ycolor
Definition: graphics.h:5348
static Cell available_toolkits_list(void)
Definition: graphics.h:2331
base_property * clone(void) const
Definition: graphics.h:1656
color_property(const radio_values &v, const color_values &c)
Definition: graphics.h:1093
std::string get_layer(void) const
Definition: graphics.h:5570
void set_windowscrollwheelfcn(const octave_value &val)
Definition: graphics.h:4739
std::string get_cdatamapping(void) const
Definition: graphics.h:8611
bool_property aliminclude
Definition: graphics.h:10910
void set_cameraupvectormode(const octave_value &val)
Definition: graphics.h:5881
bool color_is_rgb(void) const
Definition: graphics.h:5533
radio_property & operator=(const octave_value &val)
Definition: graphics.h:973
std::string get_tooltipstring(void) const
Definition: graphics.h:11752
properties xproperties
Definition: graphics.h:7717
void set_normalmode(const octave_value &val)
Definition: graphics.h:9591
std::string get_xtickmode(void) const
Definition: graphics.h:5651
std::string get_xticklabelmode(void) const
Definition: graphics.h:5648
void insert_property(const std::string &name, property p)
Definition: graphics.h:2501
octave_value get_plotboxaspectratio(void) const
Definition: graphics.h:5586
double_property fontsize_points
Definition: graphics.h:5385
radio_property windowstyle
Definition: graphics.h:4073
std::string get_state(void) const
Definition: graphics.h:12922
void set_callback(const octave_value &val)
Definition: graphics.h:11506
bool yaxislocation_is(const std::string &v) const
Definition: graphics.h:5653
bool xvisualmode_is(const std::string &v) const
Definition: graphics.h:4287
bool isa(const std::string &go_name) const
Definition: graphics.h:3375
octave_value get_ylim(void) const
Definition: graphics.h:7429
virtual bool is_radio(void) const
Definition: graphics.h:307
any_property __object__
Definition: graphics.h:12877
bool markeredgecolor_is_rgb(void) const
Definition: graphics.h:7403
octave_value get_currentpoint(void) const
Definition: graphics.h:5540
double_property markersize
Definition: graphics.h:7340
void set_cdata(const octave_value &val)
Definition: graphics.h:10265
std::string get_dataaspectratiomode(void) const
Definition: graphics.h:5545
std::string get_separator(void) const
Definition: graphics.h:12919
octave_value get_factory_defaults(void) const
Definition: graphics.h:3337
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:4977
virtual std::string values_as_string(void) const
Definition: graphics.h:325
octave_value & operator[](const std::string pname)
Definition: graphics.h:2043
void update_yaxislocation(void)
Definition: graphics.h:6907
std::string string_value(void) const
Definition: graphics.h:753
std::string get_yticklabelmode(void) const
Definition: graphics.h:5688
virtual void init_integerhandle(const octave_value &)
Definition: graphics.h:2491
graphics_handle get_zlabel(void) const
Definition: graphics.h:5704
~uimenu(void)
Definition: graphics.h:11388
void set_enable(const octave_value &val)
Definition: graphics.h:11818
std::string get_fontangle(void) const
Definition: graphics.h:12208
bool linestyle_is(const std::string &v) const
Definition: graphics.h:7395
void set_rotationmode(const octave_value &val)
Definition: graphics.h:8332
void set_zliminclude(const octave_value &val)
Definition: graphics.h:11086
virtual bool is_aliminclude(void) const
Definition: graphics.h:2630
octave_value get_cdata(void) const
Definition: graphics.h:8608
row_vector_property zlim
Definition: graphics.h:5365
radio_property alphadatamapping
Definition: graphics.h:9113
octave_value get_buttondownfcn(void) const
Definition: graphics.h:2722
void set_selectionhighlight(const octave_value &val)
Definition: graphics.h:2888
bool erasemode_is(const std::string &v) const
Definition: graphics.h:7921
octave_value get_xdata(void) const
Definition: graphics.h:9294
bool_property aliminclude
Definition: graphics.h:9151
OCTINTERP_API graphics_handle gcf(void)
Definition: graphics.cc:2611
std::set< caseless_str > possible_vals
Definition: graphics.h:936
color_property backgroundcolor
Definition: graphics.h:12155
bool_property interruptible
Definition: graphics.h:2677
void set_linewidth(const octave_value &val)
Definition: graphics.h:6106
void set_highlightcolor(const octave_value &val)
Definition: graphics.h:12350
void update_ztickmode(void)
Definition: graphics.h:6965
std::set< std::string >::const_iterator const_available_toolkits_iterator
Definition: graphics.h:2393
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:12610
radio_property erasemode
Definition: graphics.h:7333
octave_idx_type numel(void) const
Number of elements in the array.
Definition: Array.h:275
property_list get_defaults_list(void) const
Definition: graphics.h:4964
bool get_nearhoriz(void) const
Definition: graphics.h:5173
Matrix do_get_all_children(void) const
Definition: graphics.h:1790
double_property screendepth
Definition: graphics.h:3547
std::string get_type(void) const
Definition: graphics.h:2752
void update_fontangle(void)
Definition: graphics.h:12057
row_vector_property zlim
Definition: graphics.h:7850
void set_alphadatamapping(const octave_value &val)
Definition: graphics.h:10230
bool units_is(const std::string &v) const
Definition: graphics.h:11754
void execute_windowbuttonmotionfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4260
string_property xvisual
Definition: graphics.h:4077
std::string get_checked(void) const
Definition: graphics.h:11244
Matrix xscale(const Matrix &m) const
Definition: graphics.h:5037
void set_markersize(const octave_value &val)
Definition: graphics.h:10466
static std::string go_name
Definition: graphics.h:11455
void set_markersize(const octave_value &val)
Definition: graphics.h:7542
std::map< listener_mode, octave_value_list >::iterator listener_map_iterator
Definition: graphics.h:415
void set_yaxislocation(const octave_value &val)
Definition: graphics.h:6437
array_property sliderstep
Definition: graphics.h:11651
handle_property(const handle_property &p)
Definition: graphics.h:1563
void set_ztick(const octave_value &val)
Definition: graphics.h:6693
void finalize(const graphics_object &go)
Definition: graphics.h:2278
bool minorgridlinestyle_is(const std::string &v) const
Definition: graphics.h:5576
virtual void defaults(void) const
Definition: graphics.h:3114
octave_value get_windowbuttonupfcn(void) const
Definition: graphics.h:4264
void set_value(const octave_value &val)
Definition: graphics.h:12015
octave_value get_callback(void) const
Definition: graphics.h:11241
octave_idx_type length(void) const
Definition: oct-obj.h:89
base_property * clone(void) const
Definition: graphics.h:1477
void set_specularstrength(const octave_value &val)
Definition: graphics.h:9624
std::string get_autopos_tag(void) const
Definition: graphics.h:7992
callback_property oncallback
Definition: graphics.h:12882
OCTINTERP_API bool do_set(const octave_value &v)
Definition: graphics.cc:1275
void set_aliminclude(const octave_value &val)
Definition: graphics.h:10679
array_property ydata
Definition: graphics.h:9144
radio_property formatspacing
Definition: graphics.h:3541
void set_marker(const octave_value &val)
Definition: graphics.h:7509
base_scaler * rep
Definition: graphics.h:263
octave_value get___object__(void) const
Definition: graphics.h:12523
static void execute_callback(const graphics_handle &h, const octave_value &cb, const octave_value &data=Matrix())
Definition: graphics.h:13321
bool is_zliminclude(void) const
Definition: graphics.h:9316
const base_properties & get_properties(void) const
Definition: graphics.h:12442
std::string get___hold_all__(void) const
Definition: graphics.h:5731
std::string get_fontweight(void) const
Definition: graphics.h:12218
std::string value_as_string(const std::string &prop)
Definition: graphics.h:3354
void set_state(const octave_value &val)
Definition: graphics.h:13004
bool is_radio(void) const
Definition: graphics.h:1921
Matrix get_backgroundcolor_rgb(void) const
Definition: graphics.h:7903
double max_neg(void) const
Definition: graphics.h:1361
void update_tickdir(void)
Definition: graphics.h:6925
color_property edgecolor
Definition: graphics.h:9121
const base_properties & get_properties(void) const
Definition: graphics.h:3379
bool is_climinclude(void) const
Definition: graphics.h:9057
void set_verticalalignmentmode(const octave_value &val)
Definition: graphics.h:8356
row_vector_property zmtick
Definition: graphics.h:5384
base_property(const base_property &p)
Definition: graphics.h:286
virtual Matrix get_screen_size(void) const
Definition: graphics.h:2153
virtual ~base_property(void)
Definition: graphics.h:291
octave_refcount< int > count
Definition: graphics.h:2189
row_vector_property xlim
Definition: graphics.h:7848
radio_property ytickmode
Definition: graphics.h:5360
std::string get___mouse_mode__(void) const
Definition: graphics.h:4291
bool is_scalar_type(void) const
Definition: ov.h:657
octave_value get_x_viewtransform(void) const
Definition: graphics.h:5738
row_vector_property ydata
Definition: graphics.h:7343
static std::string go_name
Definition: graphics.h:12495
std::string get_autopos_tag(void) const
Definition: graphics.h:5734
octave_value get_windowkeyreleasefcn(void) const
Definition: graphics.h:4270
octave_value get_callback(void) const
Definition: graphics.h:11490
std::string default_value(void) const
Definition: graphics.h:870
array_property plotboxaspectratio
Definition: graphics.h:5322
static bool has_readonly_property(const caseless_str &pname)
double_property specularstrength
Definition: graphics.h:9140
void set_box(const octave_value &val)
Definition: graphics.h:5803
bool renderermode_is(const std::string &v) const
Definition: graphics.h:4239
~patch(void)
Definition: graphics.h:9914
std::string get___graphics_toolkit__(void) const
Definition: graphics.h:4302
bool is_climinclude(void) const
Definition: graphics.h:3424
Matrix get_color_rgb(void) const
Definition: graphics.h:5535
bool fontweight_is(const std::string &v) const
Definition: graphics.h:5560
const base_properties & get_properties(void) const
Definition: graphics.h:3878
bool_property echo
Definition: graphics.h:3537
bool is_defined(void) const
Definition: ov.h:520
row_vector_property ylim
Definition: graphics.h:5352
void set_fontsize(const octave_value &val)
Definition: graphics.h:6042
void set_paperposition(const octave_value &val)
Definition: graphics.h:4536
octave_value get_zdata(void) const
Definition: graphics.h:7423
handle_property xlabel
Definition: graphics.h:5337
void set_ylim(const octave_value &val)
Definition: graphics.h:9733
virtual ~base_graphics_event(void)
Definition: graphics.h:13083
static bool has_readonly_property(const caseless_str &pname)
bool operator==(const color_values &c) const
Definition: graphics.h:1052
double get_linewidth(void) const
Definition: graphics.h:7948
bool backgroundcolor_is(const std::string &v) const
Definition: graphics.h:7902
array_property cameraposition
Definition: graphics.h:5292
void insert_static_property(const std::string &name, base_property &p)
Definition: graphics.h:2951
std::string name
Definition: graphics.h:2188
bool try_lock(void)
Definition: oct-mutex.h:93
void adopt(const graphics_handle &h)
Definition: graphics.h:10845
bool busyaction_is(const std::string &v) const
Definition: graphics.h:2718
std::string get_xliminclude(void) const
Definition: graphics.h:8631
void update_layer(void)
Definition: graphics.h:6906
color_values & operator=(const color_values &c)
Definition: graphics.h:1044
static bool has_readonly_property(const caseless_str &pname)
std::string get_erasemode(void) const
Definition: graphics.h:7390
void execute_deletefcn(const octave_value &data=octave_value()) const
Definition: graphics.h:2730
void execute_buttondownfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4155
std::string get_tooltipstring(void) const
Definition: graphics.h:12924
void set_hidden(bool flag)
Definition: graphics.h:1918
bool empty(void) const
Definition: str-vec.h:73
octave_value get_alim(void) const
Definition: graphics.h:5495
bool paperpositionmode_is(const std::string &v) const
Definition: graphics.h:4216
patch(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:9910
double_property fontsize_points
Definition: graphics.h:7859
bool is_xliminclude(void) const
Definition: graphics.h:10208
bool interpreter_is(const std::string &v) const
Definition: graphics.h:7392
std::string get_horizontalalignment(void) const
Definition: graphics.h:11730
void execute_offcallback(const octave_value &data=octave_value()) const
Definition: graphics.h:12912
Cell cell_value(void) const
Definition: graphics.h:762
double_property listboxtop
Definition: graphics.h:11647
octave_value get_offcallback(void) const
Definition: graphics.h:12913
const base_properties & get_properties(void) const
Definition: graphics.h:13048
std::string get_minorgridlinestyle(void) const
Definition: graphics.h:5577
bool_property yminorgrid
Definition: graphics.h:5354
void set_fontangle(const octave_value &val)
Definition: graphics.h:8073
void set_color(const octave_value &val)
Definition: graphics.h:5946
bool ok(void) const
Definition: oct-handle.h:105
void set_alim(const octave_value &val)
Definition: graphics.h:9694
double get_z_max(void) const
Definition: graphics.h:5156
~surface(void)
Definition: graphics.h:10814
~uipushtool(void)
Definition: graphics.h:12800
octave_value get_alim(void) const
Definition: graphics.h:9300
void set_deletefcn(const octave_value &val)
Definition: graphics.h:2833
bool cameraupvectormode_is(const std::string &v) const
Definition: graphics.h:5520
row_vector_property xlim
Definition: graphics.h:5338
string_property title
Definition: graphics.h:12168
std::set< std::string > type_constraints
Definition: graphics.h:1428
void set_zliminclude(const octave_value &val)
Definition: graphics.h:7687
bool operator!=(const color_values &c) const
Definition: graphics.h:1059
void set_parent(const graphics_handle &h)
Definition: graphics.h:1912
const_iterator find(const std::string pname) const
Definition: graphics.h:2009
const base_properties & get_properties(void) const
Definition: graphics.h:11121
bool yscale_is(const std::string &v) const
Definition: graphics.h:5680
bool isa(const std::string &go_name) const
Definition: graphics.h:3154
static bool try_lock(void)
Definition: graphics.h:13274
octave_value get_zlim(void) const
Definition: graphics.h:5706
bool cdatamapping_is(const std::string &v) const
Definition: graphics.h:8610
void set_zdata(const octave_value &val)
Definition: graphics.h:9682
void set_alim(const octave_value &val)
Definition: graphics.h:5766
octave_value get_faces(void) const
Definition: graphics.h:9252
double get_fy(void) const
Definition: graphics.h:5158
void set_tickdirmode(const octave_value &val)
Definition: graphics.h:6229
bool is_yliminclude(void) const
Definition: graphics.h:10958
octave_value get_markeredgecolor(void) const
Definition: graphics.h:10163
void reparent(const graphics_handle &new_parent)
Definition: graphics.h:2590
static bool has_readonly_property(const caseless_str &pname)
row_vector_property clim
Definition: graphics.h:9147
void set_xvisualmode(const octave_value &val)
Definition: graphics.h:4805
virtual void add_listener(const caseless_str &, const octave_value &, listener_mode=POSTSET)
Definition: graphics.cc:3157
radio_property interpreter
Definition: graphics.h:5314
bool verticalalignment_is(const std::string &v) const
Definition: graphics.h:11759
octave_value get_paperposition(void) const
Definition: graphics.h:4214
graphics_object(const graphics_object &obj)
Definition: graphics.h:3238
octave_value get_oncallback(void) const
Definition: graphics.h:12916
static bool has_readonly_property(const caseless_str &pname)
Complex xmax(const Complex &x, const Complex &y)
Definition: lo-mappers.cc:269
array_property cameratarget
Definition: graphics.h:5294
octave_value lookup(const std::string pname) const
Definition: graphics.h:2031
void set_erasemode(const octave_value &val)
Definition: graphics.h:10976
static std::string go_name
Definition: graphics.h:5268
static void push_figure(const graphics_handle &h)
Definition: graphics.h:13244
virtual octave_value get_xlim(void) const
Definition: graphics.h:2626
static std::string go_name
Definition: graphics.h:4009
bool markerfacecolor_is(const std::string &v) const
Definition: graphics.h:9275
OCTINTERP_API void run_listeners(listener_mode mode=POSTSET)
Definition: graphics.cc:1071
void mark_modified(void)
Definition: graphics.cc:3064
Cell values_as_cell(void) const
Definition: graphics.h:1940
bool_property climinclude
Definition: graphics.h:10911
bool positionmode_is(const std::string &v) const
Definition: graphics.h:7979
void set_from_list(property_list &plist)
Definition: graphics.h:3281
virtual octave_value get_alim(void) const
Definition: graphics.h:2624
double_property mousewheelzoom
Definition: graphics.h:5319
array_property(const std::string &nm, const graphics_handle &h, const octave_value &m)
Definition: graphics.h:1332
float pixel_ysize(void)
Definition: graphics.h:9001
virtual graphics_toolkit get_toolkit(void) const
Definition: graphics.h:3159
bool shadowcolor_is(const std::string &v) const
Definition: graphics.h:12236
radio_property yaxislocation
Definition: graphics.h:5347
void set_markeredgecolor(const octave_value &val)
Definition: graphics.h:7520
void update_dataaspectratio(void)
Definition: graphics.h:6901
std::string get_camerapositionmode(void) const
Definition: graphics.h:5511
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:7732
bool fontunits_is(const std::string &v) const
Definition: graphics.h:7933
void set_pointer(const octave_value &val)
Definition: graphics.h:4583
graphics_toolkit get_toolkit(void) const
Definition: graphics.h:3439
bool_property __modified__
Definition: graphics.h:2686
const std::string & current_value(void) const
Definition: graphics.h:962
virtual std::string graphics_object_name(void) const
Definition: graphics.h:2485
void set_inverthardcopy(const octave_value &val)
Definition: graphics.h:4434
void set_backfacelighting(const octave_value &val)
Definition: graphics.h:10254
double scale(double d) const
Definition: graphics.h:220
pval_map_type::const_iterator pval_map_const_iterator
Definition: graphics.h:2077
octave_value get_userdata(void) const
Definition: graphics.h:2756
static void execute_listener(const graphics_handle &h, const octave_value &l)
Definition: graphics.h:13294
row_vector_property xdata
Definition: graphics.h:8566
std::string get_numbertitle(void) const
Definition: graphics.h:4207
void set_clickedcallback(const octave_value &val)
Definition: graphics.h:12949
void update_fontname(void)
Definition: graphics.h:8444
octave_value get_x_normrendertransform(void) const
Definition: graphics.h:5744
properties xproperties
Definition: graphics.h:13037
bool edgelighting_is(const std::string &v) const
Definition: graphics.h:10130
void set_cdata(const octave_value &val)
Definition: graphics.h:8668
Matrix x_gl_mat2
Definition: graphics.h:5212
void set_toolbar(const octave_value &val)
Definition: graphics.h:4671
void error(const char *fmt,...)
Definition: error.cc:476
handle_property currentfigure
Definition: graphics.h:3534
void finalize(void)
Definition: graphics.h:3451
octave_value get_closerequestfcn(void) const
Definition: graphics.h:4159
color_property markerfacecolor
Definition: graphics.h:7339
radio_property(const std::string &nm, const graphics_handle &h, const radio_values &v=radio_values())
Definition: graphics.h:942
void set_enable(const octave_value &val)
Definition: graphics.h:12749
void update_cdata(void)
Definition: graphics.h:10771
void update_xticklabelmode(void)
Definition: graphics.h:6975
bool zscale_is(const std::string &v) const
Definition: graphics.h:5717
bool ok(void) const
Definition: graphics.h:1900
std::string get_gridlinestyle(void) const
Definition: graphics.h:5564
bool markeredgecolor_is_rgb(void) const
Definition: graphics.h:9269
void set_name(const octave_value &val)
Definition: graphics.h:4489
double current_val
Definition: graphics.h:1234
void do_scale(const double *src, double *dest, int n) const
Definition: graphics.h:191
void update_rotationmode(void)
Definition: graphics.h:8436
void execute_windowkeyreleasefcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4269
octave_value get_string(void) const
Definition: graphics.h:11747
double xmaxp
Definition: graphics.h:1427
void set_x_normrendertransform(const octave_value &val)
Definition: graphics.h:6802
void set_keypressfcn(const octave_value &val)
Definition: graphics.h:11912
void set_plotboxaspectratio(const octave_value &val)
Definition: graphics.h:6162
base_graphics_event * rep
Definition: graphics.h:13149
array_property facevertexcdata
Definition: graphics.h:9129
void set_windowstyle(const octave_value &val)
Definition: graphics.h:4750
uitoolbar(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:12547
std::string get_climinclude(void) const
Definition: graphics.h:10953
bool valid_object(void) const
Definition: graphics.h:4973
bool_property & operator=(const octave_value &val)
Definition: graphics.h:1535
void set_visible(const octave_value &val)
Definition: graphics.h:2922
std::string get_ytickmode(void) const
Definition: graphics.h:5691
void set(const caseless_str &name, const octave_value &val)
Definition: graphics.cc:1888
virtual ~base_graphics_toolkit(void)
Definition: graphics.h:2127
void set_horizontalalignment(const octave_value &val)
Definition: graphics.h:11901
void update_xdir(void)
Definition: graphics.h:6920
void set_tickdir(const octave_value &val)
Definition: graphics.h:6213
any_property __guidata__
Definition: graphics.h:4085
std::string get_units(void) const
Definition: graphics.h:5609
radio_property style
Definition: graphics.h:11653
bool erasemode_is(const std::string &v) const
Definition: graphics.h:10936
Matrix zscale(const Matrix &m) const
Definition: graphics.h:5039
std::string graphics_object_name(void) const
Definition: graphics.h:7307
bool xcolor_is_rgb(void) const
Definition: graphics.h:5616
std::list< dim_vector > size_constraints
Definition: graphics.h:1429
void set_separator(const octave_value &val)
Definition: graphics.h:11352
const base_properties & get_properties(void) const
Definition: graphics.h:8474
radio_property units
Definition: graphics.h:11655
radio_property projection
Definition: graphics.h:5325
bool foregroundcolor_is_rgb(void) const
Definition: graphics.h:11249
void set_cameraupvector(const octave_value &val)
Definition: graphics.h:5866
properties xproperties
Definition: graphics.h:12544
bool titleposition_is(const std::string &v) const
Definition: graphics.h:12242
octave_value get_zlim(void) const
Definition: graphics.h:7968
virtual Matrix get_boundingbox(bool=false, const Matrix &=Matrix()) const
Definition: graphics.h:2553
static string_vector names(const map_type &lst)
Definition: help.cc:782
pval_map_type::iterator pval_map_iterator
Definition: graphics.h:2076
base_property * clone(void) const
Definition: graphics.h:1584
octave_value get_ylim(void) const
Definition: graphics.h:5669
virtual void initialize(const graphics_object &go)
Definition: graphics.h:3191
std::string get_tooltipstring(void) const
Definition: graphics.h:12713
static Matrix figure_handle_list(bool show_hidden=false)
Definition: graphics.h:13288
root_figure(void)
Definition: graphics.h:3788
bool linestyle_is(const std::string &v) const
Definition: graphics.h:10152
void set_bordertype(const octave_value &val)
Definition: graphics.h:12271
void set_fontweight(const octave_value &val)
Definition: graphics.h:6058
void set___pan_mode__(const octave_value &val)
Definition: graphics.h:4818
std::string get_ylimmode(void) const
Definition: graphics.h:5672
row_vector_property alim
Definition: graphics.h:5288
void set_fontname(const octave_value &val)
Definition: graphics.h:11852
array_property x_projectiontransform
Definition: graphics.h:5378
void adopt(const graphics_handle &h)
Definition: graphics.h:3369
double get_linewidth(void) const
Definition: graphics.h:5574
void set_erasemode(const octave_value &val)
Definition: graphics.h:10356
radio_property normalmode
Definition: graphics.h:10026
OCTINTERP_API bool str2rgb(const std::string &str)
Definition: graphics.cc:1159
property(const property &p)
Definition: graphics.h:1889
bool contains(const std::string &val, std::string &match)
Definition: graphics.h:885
string_property fontname
Definition: graphics.h:5309
radio_property xlimmode
Definition: graphics.h:5339
graphics_toolkit(base_graphics_toolkit *b)
Definition: graphics.h:2208
string_array_property string
Definition: graphics.h:11652
base_scaler * clone(void) const
Definition: graphics.h:147
string_vector get_string_vector(void) const
Definition: graphics.h:11746
void set_doublebuffer(const octave_value &val)
Definition: graphics.h:4410
void set_ydata(const octave_value &val)
Definition: graphics.h:8731
color_property highlightcolor
Definition: graphics.h:12164
base_property(const std::string &s, const graphics_handle &h)
Definition: graphics.h:282
callback_property clickedcallback
Definition: graphics.h:12879
std::set< graphics_handle >::iterator free_list_iterator
Definition: graphics.h:13410
bool toolbar_is(const std::string &v) const
Definition: graphics.h:4251
void set_clim(const octave_value &val)
Definition: graphics.h:10998
static void restore_gcbo(void)
Definition: graphics.h:13552
bool valid_toolkit_object(void) const
Definition: graphics.h:3146
radio_property(const std::string &nm, const graphics_handle &h, const std::string &v)
Definition: graphics.h:947
void set_xmtick(const octave_value &val)
Definition: graphics.h:6824
~uitoggletool(void)
Definition: graphics.h:13044
property_list get_defaults_list(void) const
Definition: graphics.h:3332
~text(void)
Definition: graphics.h:8470
radio_property marker
Definition: graphics.h:9133
axes(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:7181
std::string get_tickdir(void) const
Definition: graphics.h:5597
void set_meshstyle(const octave_value &val)
Definition: graphics.h:10477
row_vector_property alim
Definition: graphics.h:9146
array_property cdata
Definition: graphics.h:8562
any_property zticklabel
Definition: graphics.h:5371
bool backfacelighting_is(const std::string &v) const
Definition: graphics.h:9211
any_property __object__
Definition: graphics.h:11632
void update_ydata(void)
Definition: graphics.h:10785
bool verticalalignmentmode_is(const std::string &v) const
Definition: graphics.h:7988
bool valid_object(void) const
Definition: graphics.h:13050
void set_diffusestrength(const octave_value &val)
Definition: graphics.h:9380
void set_marker(const octave_value &val)
Definition: graphics.h:10433
string_property fontname
Definition: graphics.h:12159
double get_diffusestrength(void) const
Definition: graphics.h:10116
std::string get_aliminclude(void) const
Definition: graphics.h:10950
bool edgecolor_is_rgb(void) const
Definition: graphics.h:7913
static void load_toolkit(const graphics_toolkit &tk)
Definition: graphics.h:2313
octave_value resize(const dim_vector &dv, bool fill=false) const
Definition: ov.h:507
Cell do_available_toolkits_list(void) const
Definition: graphics.h:2427
double get_ambientstrength(void) const
Definition: graphics.h:9209
bool xcolor_is(const std::string &v) const
Definition: graphics.h:5617
uipushtool(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:12796
Complex xmin(const Complex &x, const Complex &y)
Definition: lo-mappers.cc:263
void execute_keypressfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4190
bool is_selectionhighlight(void) const
Definition: graphics.h:2747
octave_value get_position(void) const
Definition: graphics.h:11492
void update_interpreter(void)
Definition: graphics.h:8448
void do_restore_gcbo(void)
Definition: graphics.cc:9492
std::string graphics_object_name(void) const
Definition: graphics.h:7802
std::string get_titleposition(void) const
Definition: graphics.h:12243
properties xproperties
Definition: graphics.h:3784
base_graphics_object(void)
Definition: graphics.h:2962
octave_value get_clim(void) const
Definition: graphics.h:10941
bool is_cell(void) const
Definition: ov.h:529
bool fontunits_is(const std::string &v) const
Definition: graphics.h:11718
bool normalmode_is(const std::string &v) const
Definition: graphics.h:9281
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:483
octave_value get_edgealpha(void) const
Definition: graphics.h:9226
void set_position(const octave_value &val)
Definition: graphics.h:7751
radio_property renderermode
Definition: graphics.h:4061
octave_value get_xdata(void) const
Definition: graphics.h:8618
bool erasemode_is(const std::string &v) const
Definition: graphics.h:8615
std::string get_fontunits(void) const
Definition: graphics.h:12215
void set_xtick(const octave_value &val)
Definition: graphics.h:6395
bool paperorientation_is(const std::string &v) const
Definition: graphics.h:4211
bool is_clipping(void) const
Definition: graphics.h:11703
void add_listener(const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:1960
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:13223
base_property * clone(void) const
Definition: graphics.h:1381
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:12446
std::string get_enable(void) const
Definition: graphics.h:11247
std::string get_erasemode(void) const
Definition: graphics.h:7922
bool ydatamode_is(const std::string &v) const
Definition: graphics.h:8639
void set_showhiddenhandles(const octave_value &val)
Definition: graphics.h:3752
std::string get_currentcharacter(void) const
Definition: graphics.h:4170
virtual void close(void)
Definition: graphics.h:2184
radio_property edgelighting
Definition: graphics.h:10013
octave_idx_type lookup(const T *x, octave_idx_type n, T y)
void set_ycolor(const octave_value &val)
Definition: graphics.h:6449
octave_value get_ymtick(void) const
Definition: graphics.h:5750
color_property color
Definition: graphics.h:5302
color_values color_val
Definition: graphics.h:1184
any_property __object__
Definition: graphics.h:12681
void update_yscale(void)
Definition: graphics.h:6890
void update_paperpositionmode(void)
Definition: graphics.h:4901
~property_list(void)
Definition: graphics.h:2085
octave_value get_colormap(void) const
Definition: graphics.h:4166
octave_value get_factory_default(const caseless_str &name) const
Definition: graphics.h:3846
std::string get_tickdirmode(void) const
Definition: graphics.h:5600
octave_value get_backgroundcolor(void) const
Definition: graphics.h:11696
void set_max(const octave_value &val)
Definition: graphics.h:11934
bool is_yliminclude(void) const
Definition: graphics.h:10211
bool foregroundcolor_is_rgb(void) const
Definition: graphics.h:12220
bool backgroundcolor_is(const std::string &v) const
Definition: graphics.h:11694
bool rotationmode_is(const std::string &v) const
Definition: graphics.h:7982
void update_xdata(void)
Definition: graphics.h:7705
std::string get_enable(void) const
Definition: graphics.h:12708
void set_autopos_tag(const octave_value &val)
Definition: graphics.h:6746
std::string get_xaxislocation(void) const
Definition: graphics.h:5614
~uitoolbar(void)
Definition: graphics.h:12551
std::string get___modified__(void) const
Definition: graphics.h:2762
octave_value get_monitorpositions(void) const
Definition: graphics.h:3605
~gtk_manager(void)
Definition: graphics.h:2356
octave_value get_alim(void) const
Definition: graphics.h:10939
text_label_property string
Definition: graphics.h:7845
Cell values_as_cell(void) const
Definition: graphics.h:1177
void set_enable(const octave_value &val)
Definition: graphics.h:11308
double get_markersize(void) const
Definition: graphics.h:9279
array_property x_viewtransform
Definition: graphics.h:5377
log_scaler(void)
Definition: graphics.h:121
bool foregroundcolor_is_rgb(void) const
Definition: graphics.h:11724
std::string get_style(void) const
Definition: graphics.h:11750
listener_map listeners
Definition: graphics.h:425
bool facecolor_is(const std::string &v) const
Definition: graphics.h:10142
void set_fontsize_points(const octave_value &val)
Definition: graphics.h:8379
octave_value get_alphadata(void) const
Definition: graphics.h:10099
std::string get_cdatamapping(void) const
Definition: graphics.h:10112
void set_xminortick(const octave_value &val)
Definition: graphics.h:6370
color_property shadowcolor
Definition: graphics.h:12167
bool interpreter_is(const std::string &v) const
Definition: graphics.h:9258
void update_view(void)
Definition: graphics.h:6900
std::string get_yliminclude(void) const
Definition: graphics.h:10212
bool markeredgecolor_is(const std::string &v) const
Definition: graphics.h:10161
octave_value get_ylim(void) const
Definition: graphics.h:10945
void set_menubar(const octave_value &val)
Definition: graphics.h:4467
children_property(const std::string &nm, const graphics_handle &h, const Matrix &val)
Definition: graphics.h:1637
octave_value get_clickedcallback(void) const
Definition: graphics.h:12705
array_property monitorpositions
Definition: graphics.h:3543
bool ambientlightcolor_is_rgb(void) const
Definition: graphics.h:5500
radio_property erasemode
Definition: graphics.h:7831
bool do_set(const octave_value &v)
Definition: graphics.h:1215
void set_zgrid(const octave_value &val)
Definition: graphics.h:6615
radio_property units
Definition: graphics.h:4066
void set_xaxislocation(const octave_value &val)
Definition: graphics.h:6282
double_property fontsize
Definition: graphics.h:12160
string_property ydatasource
Definition: graphics.h:7344
radio_property nextplot
Definition: graphics.h:5320
virtual void set_from_list(property_list &plist)
Definition: graphics.h:2985
double_radio_property & operator=(const octave_value &val)
Definition: graphics.h:1298
static bool is_handle_visible(const graphics_handle &h)
Definition: graphics.h:13366
void set_linewidth(const octave_value &val)
Definition: graphics.h:7498
octave_value get_ytick(void) const
Definition: graphics.h:5683
void set_displayname(const octave_value &val)
Definition: graphics.h:8693
property_list default_properties
Definition: graphics.h:12619
void set_keypressfcn(const octave_value &val)
Definition: graphics.h:4445
void execute_windowbuttonupfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4263
row_vector_property ylim
Definition: graphics.h:7348
bool cdatamapping_is(const std::string &v) const
Definition: graphics.h:10111
bool ylimmode_is(const std::string &v) const
Definition: graphics.h:5671
void update_faces(void)
Definition: graphics.h:9845
std::string get_marker(void) const
Definition: graphics.h:9267
virtual void delete_children(bool clear=false)
Definition: graphics.h:2602
void set_rotation(const octave_value &val)
Definition: graphics.h:8186
std::string get_positionmode(void) const
Definition: graphics.h:7980
color_values(const color_values &c)
Definition: graphics.h:1040
virtual Matrix scale(const Matrix &m) const
Definition: graphics.h:69
std::string get_ydatasource(void) const
Definition: graphics.h:10192
radio_property paperorientation
Definition: graphics.h:4050
std::string get_units(void) const
Definition: graphics.h:7959
string_property zdatasource
Definition: graphics.h:10036
std::string get_rotationmode(void) const
Definition: graphics.h:7983
string_property cdatasource
Definition: graphics.h:10008
color_property markerfacecolor
Definition: graphics.h:10023
bool edgecolor_is(const std::string &v) const
Definition: graphics.h:10126
octave_value get_xmtick(void) const
Definition: graphics.h:5748
radio_property drawmode
Definition: graphics.h:5307
bool erasemode_is(const std::string &v) const
Definition: graphics.h:10133
octave_value get_facevertexalphadata(void) const
Definition: graphics.h:9254
std::string get_xscale(void) const
Definition: graphics.h:5641
pval_vector pval_map_type
Definition: graphics.h:2073
void update_zdata(void)
Definition: graphics.h:7709
void execute_oncallback(const octave_value &data=octave_value()) const
Definition: graphics.h:12915
radio_property positionmode
Definition: graphics.h:7854
static std::string default_toolkit(void)
Definition: graphics.h:2347
octave_value get_ylim(void) const
Definition: graphics.h:9306
std::string get_climinclude(void) const
Definition: graphics.h:9948
string_property displayname
Definition: graphics.h:7332
double get_xticklen(void) const
Definition: graphics.h:5160
std::string get_renderer(void) const
Definition: graphics.h:4237
radio_property units
Definition: graphics.h:3551
bool xdir_is(const std::string &v) const
Definition: graphics.h:5621
std::string string_value(void) const
Definition: graphics.h:443
void set_cameratarget(const octave_value &val)
Definition: graphics.h:5840
void delete_property_listener(const std::string &nm, const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:3445
void update_position(void)
Definition: graphics.h:7035
std::string graphics_object_name(void) const
Definition: graphics.h:12130
NDArray scale(const NDArray &m) const
Definition: graphics.h:132
array_property faces
Definition: graphics.h:9127
void set_specularcolorreflectance(const octave_value &val)
Definition: graphics.h:10500
bool zlimmode_is(const std::string &v) const
Definition: graphics.h:5708
graphics_xform(const Matrix &xm, const Matrix &xim, const scaler &x, const scaler &y, const scaler &z, const Matrix &zl)
Definition: graphics.h:5001
void set_aliminclude(const octave_value &val)
Definition: graphics.h:9759
void set_ticklength(const octave_value &val)
Definition: graphics.h:6241
radio_property alphadatamapping
Definition: graphics.h:10003
void set_verticalalignment(const octave_value &val)
Definition: graphics.h:12026
color_property foregroundcolor
Definition: graphics.h:11644
bool verticalalignment_is(const std::string &v) const
Definition: graphics.h:7961
double get_facealpha_double(void) const
Definition: graphics.h:10138
bool is(const caseless_str &v) const
Definition: graphics.h:968
radio_property cameraviewanglemode
Definition: graphics.h:5299
bool is_zminortick(void) const
Definition: graphics.h:5714
void update_zlim(void)
Definition: graphics.h:7160
virtual std::string type(void) const
Definition: graphics.h:3148
bool units_is(const std::string &v) const
Definition: graphics.h:12245
std::string get_name(void) const
Definition: graphics.h:1903
bool_property enable
Definition: graphics.h:12684
children_property & operator=(const octave_value &val)
Definition: graphics.h:1650
static void unlock(void)
Definition: graphics.h:13282
octave_value get_edgecolor(void) const
Definition: graphics.h:9231
std::string get_drawmode(void) const
Definition: graphics.h:5548
std::string get_interpreter(void) const
Definition: graphics.h:9259
std::string row_as_string(octave_idx_type, bool strip_ws=false) const
Definition: chMatrix.cc:84
Matrix get_edgecolor_rgb(void) const
Definition: graphics.h:10127
octave_value get_defaults(void) const
Definition: graphics.h:4959
radio_property wvisualmode
Definition: graphics.h:4075
void update_cdata(void)
Definition: graphics.h:9892
std::string bad_data_msg
Definition: graphics.h:9843
std::string get_language(void) const
Definition: graphics.h:3603
octave_mutex graphics_lock
Definition: graphics.h:13430
desired_enum desired_type
Definition: graphics.h:672
callback_property offcallback
Definition: graphics.h:12881
virtual void init(void)
Definition: graphics.h:2954
void set_tightinset(const octave_value &val)
Definition: graphics.h:6253
octave_value get_facealpha(void) const
Definition: graphics.h:9242
std::string cached_units
Definition: graphics.h:12039
void set_colormap(const octave_value &val)
Definition: graphics.h:4353
virtual property_list get_factory_defaults_list(void) const
Definition: graphics.h:3051
void set_fixedwidthfontname(const octave_value &val)
Definition: graphics.h:3658
void set_separator(const octave_value &val)
Definition: graphics.h:12760
void set_zscale(const octave_value &val)
Definition: graphics.h:6679
graphics_handle current_val
Definition: graphics.h:1590
std::string get_tag(void) const
Definition: graphics.h:2750
Matrix yscale(const Matrix &m) const
Definition: graphics.h:5038
~uipanel(void)
Definition: graphics.h:12438
octave_value get_view(void) const
Definition: graphics.h:5611
static void unregister_toolkit(const std::string &name)
Definition: graphics.h:2307
virtual graphics_handle get_parent(void) const
Definition: graphics.h:3068
octave_value get___plot_stream__(void) const
Definition: graphics.h:4306
~axes(void)
Definition: graphics.h:7187
std::string get_cdatamapping(void) const
Definition: graphics.h:9217
handle_property zlabel
Definition: graphics.h:5364
bool markerfacecolor_is(const std::string &v) const
Definition: graphics.h:10166
virtual void set(const caseless_str &pname, const octave_value &pval)
Definition: graphics.h:2993
std::map< graphics_handle, graphics_object >::const_iterator const_iterator
Definition: graphics.h:13408
void remove_child(const graphics_handle &h)
Definition: graphics.h:11148
void renumber_child(graphics_handle old_gh, graphics_handle new_gh)
Definition: graphics.h:2607
void update_xscale(void)
Definition: graphics.h:6885
bool_property showhiddenhandles
Definition: graphics.h:3550
std::string get_editing(void) const
Definition: graphics.h:7919
void set_markerfacecolor(const octave_value &val)
Definition: graphics.h:10455
void set_cdata(const octave_value &val)
Definition: graphics.h:11796
void set_renderer(const octave_value &val)
Definition: graphics.h:4616
void update_axis_limits(const std::string &axis_type)
Definition: graphics.h:3384
color_property color
Definition: graphics.h:7331
void set_xlim(const octave_value &val)
Definition: graphics.h:8242
double_property borderwidth
Definition: graphics.h:12157
octave_value get_defaults(void) const
Definition: graphics.h:12592
bool alphadatamapping_is(const std::string &v) const
Definition: graphics.h:8605
void set_view(const octave_value &val)
Definition: graphics.h:6270
void set_hidden(bool flag)
Definition: graphics.h:305
void set_clipping(const octave_value &val)
Definition: graphics.h:11807
any_property __plot_stream__
Definition: graphics.h:4086
graphics_handle do_current_figure(void) const
Definition: graphics.h:13512
octave_value get_cdata(void) const
Definition: graphics.h:12904
double_property ambientstrength
Definition: graphics.h:10004
std::string get_zminorgrid(void) const
Definition: graphics.h:5712
bool_property resize
Definition: graphics.h:4062
Matrix get_markerfacecolor_rgb(void) const
Definition: graphics.h:9276
octave_idx_type rows(void) const
Definition: Array.h:313
property_list get_factory_defaults_list(void) const
Definition: graphics.h:3342
void gripe_invalid(const std::string &fname) const
Definition: graphics.h:2192
Matrix get_backgroundcolor_rgb(void) const
Definition: graphics.h:11695
octave_value get(bool all=false) const
Definition: graphics.h:3300
bool is_aliminclude(void) const
Definition: graphics.h:9052
bool_property yliminclude
Definition: graphics.h:7852
F77_RET_T const double const double double * d
std::string graphics_object_name(void) const
Definition: graphics.h:9089
radio_property __mouse_mode__
Definition: graphics.h:4079
void set_ylim(const octave_value &val)
Definition: graphics.h:7635
color_values(const std::string &str)
Definition: graphics.h:1033
void set_yliminclude(const octave_value &val)
Definition: graphics.h:8838
array_property alphamap
Definition: graphics.h:4028
octave_value get___object__(void) const
Definition: graphics.h:11691
static graphics_handle lookup(const octave_value &val)
Definition: graphics.h:13206
std::string get_fontweight(void) const
Definition: graphics.h:7937
void fix_limits(array_property &lims)
Definition: graphics.h:7103
void delete_listener(const octave_value &v=octave_value(), listener_mode mode=POSTSET)
Definition: graphics.h:349
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:11558
Matrix get_foregroundcolor_rgb(void) const
Definition: graphics.h:12222
void set_alimmode(const octave_value &val)
Definition: graphics.h:5781
octave_value get___rotate_mode__(void) const
Definition: graphics.h:4295
std::string get_selectionhighlight(void) const
Definition: graphics.h:2748
octave_value get(bool all=false) const
void set_ydata(const octave_value &val)
Definition: graphics.h:10568
bool markerfacecolor_is_rgb(void) const
Definition: graphics.h:7408
double get_xpTickN(void) const
Definition: graphics.h:5146
bool validate(const std::string &val, std::string &match)
Definition: graphics.h:872
void set_xliminclude(const octave_value &val)
Definition: graphics.h:11064
string_vector all_strings(bool pad=false) const
Definition: ov.h:894
void set_cdatasource(const octave_value &val)
Definition: graphics.h:10290
const base_properties & get_properties(void) const
Definition: graphics.h:4971
bool highlightcolor_is(const std::string &v) const
Definition: graphics.h:12226
std::string get_enable(void) const
Definition: graphics.h:11707
OCTINTERP_API bool do_set(const octave_value &newval)
Definition: graphics.cc:1201
property_list default_properties
Definition: graphics.h:7269
std::string get_fixedwidthfontname(void) const
Definition: graphics.h:3595
text_label_property(const std::string &s, const graphics_handle &h, const Cell &c)
Definition: graphics.h:705
color_property markeredgecolor
Definition: graphics.h:9134
graphics_xform get_transform(void) const
Definition: graphics.h:5127
void set_wvisualmode(const octave_value &val)
Definition: graphics.h:4772
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:10822
void override_defaults(base_graphics_object &obj)
Definition: graphics.h:7189
string_array_property(const string_array_property &p)
Definition: graphics.h:525
base_property * clone(void) const
Definition: graphics.h:1541
void update_color(void)
Definition: graphics.h:8443
bool climmode_is(const std::string &v) const
Definition: graphics.h:5530
base_properties & get_properties(void)
Definition: graphics.h:9916
octave_value get_xdata(void) const
Definition: graphics.h:10186
void set_ylim(const octave_value &val)
Definition: graphics.h:6485
bool_property doublebuffer
Definition: graphics.h:4038
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:3347
void set_edgecolor(const octave_value &val)
Definition: graphics.h:10334
void set_xliminclude(const octave_value &val)
Definition: graphics.h:8281
string_property filename
Definition: graphics.h:4039
bool do_set(const octave_value &v)
Definition: graphics.h:1392
octave_value get_ylim(void) const
Definition: graphics.h:7966
void set_markersize(const octave_value &val)
Definition: graphics.h:9580
double_property specularexponent
Definition: graphics.h:9139
array_property position
Definition: graphics.h:11650
array_property alphadata
Definition: graphics.h:10002
ColumnVector coord2pixel(double x, double y, double z) const
Definition: graphics.h:5178
bool is_doublebuffer(void) const
Definition: graphics.h:4179
std::string get_wvisualmode(void) const
Definition: graphics.h:4281
void execute_callback(const octave_value &data=octave_value()) const
Definition: graphics.h:11240
double_radio_property(const double_radio_property &p)
Definition: graphics.h:1262
void set_displayname(const octave_value &val)
Definition: graphics.h:9391
void update_xlim()
Definition: graphics.h:7130
~graphics_xform(void)
Definition: graphics.h:5010
void set_yminorgrid(const octave_value &val)
Definition: graphics.h:6514
bool_property(const std::string &nm, const graphics_handle &h, bool val)
Definition: graphics.h:1520
void set_zlim(const octave_value &val)
Definition: graphics.h:11031
color_property(const std::string &nm, const graphics_handle &h, const color_property &v)
Definition: graphics.h:1121
void set_color(const octave_value &val)
Definition: graphics.h:8006
virtual void update_boundingbox(void)
Definition: graphics.cc:3134
bool dataaspectratiomode_is(const std::string &v) const
Definition: graphics.h:5544
string_array_property & operator=(const octave_value &val)
Definition: graphics.h:555
bool markerfacecolor_is_rgb(void) const
Definition: graphics.h:9274
void set_cdata(const octave_value &val)
Definition: graphics.h:12727
bool do_set(const octave_value &v)
Definition: graphics.h:1616
void set_diffusestrength(const octave_value &val)
Definition: graphics.h:10301
void set___guidata__(const octave_value &val)
Definition: graphics.h:4862
void set_climinclude(const octave_value &val)
Definition: graphics.h:8812
void set_xdatasource(const octave_value &val)
Definition: graphics.h:10557
bool markeredgecolor_is_rgb(void) const
Definition: graphics.h:10160
std::string get_papertype(void) const
Definition: graphics.h:4222
color_property foregroundcolor
Definition: graphics.h:12163
any_property(const any_property &p)
Definition: graphics.h:1602
callback_property callback
Definition: graphics.h:11211
bool is_xliminclude(void) const
Definition: graphics.h:9310
bool_property xgrid
Definition: graphics.h:5336
std::map< caseless_str, property, cmp_caseless_str > all_props
Definition: graphics.h:2948
std::string get_zgrid(void) const
Definition: graphics.h:5702
octave_value get(void) const
Definition: graphics.h:1350
void set_xdata(const octave_value &val)
Definition: graphics.h:8715
bool fontweight_is(const std::string &v) const
Definition: graphics.h:7936
void set_erasemode(const octave_value &val)
Definition: graphics.h:8051
virtual void adopt(const graphics_handle &h)
Definition: graphics.h:3098
octave_value get_ydata(void) const
Definition: graphics.h:8620
Cell cell_value(void) const
Definition: ov.cc:1566
double get_edgealpha_double(void) const
Definition: graphics.h:10122
graphics_toolkit(const graphics_toolkit &b)
Definition: graphics.h:2214
octave_value get_factory_defaults(void) const
Definition: graphics.h:3866
octave_value get_cdata(void) const
Definition: graphics.h:12702
octave_value get(void) const
Definition: graphics.h:1605
void set_vertices(const octave_value &val)
Definition: graphics.h:9646
array_property colormap
Definition: graphics.h:4032
bool color_is(const std::string &v) const
Definition: graphics.h:7383
octave_value get_alim(void) const
Definition: graphics.h:10198
std::string get_verticalalignment(void) const
Definition: graphics.h:7962
double get_specularexponent(void) const
Definition: graphics.h:9286
bool nextplot_is(const std::string &v) const
Definition: graphics.h:4203
bool units_is(const std::string &v) const
Definition: graphics.h:4254
callback_property windowbuttonmotionfcn
Definition: graphics.h:4068
void set_interruptible(const octave_value &val)
Definition: graphics.h:2866
octave_value get_backgroundcolor(void) const
Definition: graphics.h:12200
callback_property & operator=(const octave_value &val)
Definition: graphics.h:1846
base_property * clone(void) const
Definition: graphics.h:451
void set_xliminclude(const octave_value &val)
Definition: graphics.h:7661
text_label_property & operator=(const octave_value &val)
Definition: graphics.h:764
void do_scale(const double *src, double *dest, int n) const
Definition: graphics.h:151
double get_diffusestrength(void) const
Definition: graphics.h:9219
bool marker_is(const std::string &v) const
Definition: graphics.h:9266
bool edgealpha_is_double(void) const
Definition: graphics.h:9223
std::string get_normalmode(void) const
Definition: graphics.h:10176
void set_dataaspectratiomode(const octave_value &val)
Definition: graphics.h:5995
static property_list::pval_map_type factory_defaults(void)
array_property cameraupvector
Definition: graphics.h:5296
double ztickoffset
Definition: graphics.h:5222
bool valid_object(void) const
Definition: graphics.h:12806
bool ztickmode_is(const std::string &v) const
Definition: graphics.h:5727
array_property dataaspectratio
Definition: graphics.h:5305
virtual void finalize(const graphics_object &go)
Definition: graphics.h:3197
array_property cdata
Definition: graphics.h:12682
std::string current_val
Definition: graphics.h:1186
virtual bool valid_object(void) const
Definition: graphics.h:3144
void set_errormessage(const octave_value &val)
Definition: graphics.h:3647
bool is_hittest(void) const
Definition: graphics.h:2736
bool edgecolor_is(const std::string &v) const
Definition: graphics.h:9229
void set_ydatasource(const octave_value &val)
Definition: graphics.h:10580
virtual ~base_scaler(void)
Definition: graphics.h:67
void set_fontname(const octave_value &val)
Definition: graphics.h:8085
array_property extent
Definition: graphics.h:7832
bool is_aliminclude(void) const
Definition: graphics.h:3421
void execute_resizefcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4245
bool_property climinclude
Definition: graphics.h:10043
const dim_vector & dims(void) const
Return a const-reference so that dims ()(i) works efficiently.
Definition: Array.h:337
radio_property handlevisibility
Definition: graphics.h:2675
void update_yticklabelmode(void)
Definition: graphics.h:6980
void set_defaults(const std::string &mode)
Definition: graphics.h:3298
radio_property zticklabelmode
Definition: graphics.h:5372
double get_zpTickN(void) const
Definition: graphics.h:5150
property_list default_properties
Definition: graphics.h:4986
base_property * clone(void) const
Definition: graphics.h:561
bool_property separator
Definition: graphics.h:12685
void set_xtickmode(const octave_value &val)
Definition: graphics.h:6425
std::string get_erasemode(void) const
Definition: graphics.h:10937
void set_buttondownfcn(const octave_value &val)
Definition: graphics.h:4320
void do_adopt_child(double val)
Definition: graphics.h:1815
void execute_createfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:2727
Matrix get_hidden(void) const
Definition: graphics.h:1673
virtual void print_figure(const graphics_object &, const std::string &, const std::string &, bool, const std::string &="") const
Definition: graphics.h:2136
static void free(const graphics_handle &h)
Definition: graphics.h:13188
bool get_xyzSym(void) const
Definition: graphics.h:5171
void set_clipping(const octave_value &val)
Definition: graphics.h:2811
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:7257
void close(void)
Definition: graphics.h:2285
double_radio_property facealpha
Definition: graphics.h:9124
string_property zdatasource
Definition: graphics.h:7346
bool is_separator(void) const
Definition: graphics.h:11258
void set_alim(const octave_value &val)
Definition: graphics.h:8747
std::string get_fontangle(void) const
Definition: graphics.h:7927
string_property currentcharacter
Definition: graphics.h:4034
std::string values_as_string(void) const
Definition: graphics.h:1174
bool valid_object(void) const
Definition: graphics.h:3880
void set_fontsize(const octave_value &val)
Definition: graphics.h:8097
std::string get_aliminclude(void) const
Definition: graphics.h:9054
OCTINTERP_API graphics_handle gca(void)
Definition: graphics.cc:2620
Matrix get_limits(void) const
Definition: graphics.h:1363
bool initialize(const graphics_handle &h)
Definition: graphics.h:2272
static bool instance_ok(void)
Definition: graphics.h:13162
void execute(void)
Definition: graphics.h:13125
void set_edgecolor(const octave_value &val)
Definition: graphics.h:9413
array_property zdata
Definition: graphics.h:9145
void set_tooltipstring(const octave_value &val)
Definition: graphics.h:11992
virtual base_scaler * clone() const
Definition: graphics.h:93
~root_figure(void)
Definition: graphics.h:3791
std::string get_bordertype(void) const
Definition: graphics.h:12203
Array< std::string > cellstr_value(void) const
Definition: Cell.cc:146
bool_property enable
Definition: graphics.h:12880
int get_id(void) const
Definition: graphics.h:1924
double unscale(double d) const
Definition: graphics.h:111
bool_property yliminclude
Definition: graphics.h:10913
bool is_radio(void) const
Definition: graphics.h:1143
array_property screensize
Definition: graphics.h:3549
radio_property gridlinestyle
Definition: graphics.h:5313
std::string get_aliminclude(void) const
Definition: graphics.h:8497
void set_yscale(const octave_value &val)
Definition: graphics.h:6536
bool ok(void) const
Definition: graphics.h:293
octave_value get_createfcn(void) const
Definition: graphics.h:2728
void set_position(const octave_value &val)
Definition: graphics.h:11956
radio_property backfacelighting
Definition: graphics.h:9115
Matrix scale(const Matrix &m) const
Definition: graphics.h:5041
any_property & operator=(const octave_value &val)
Definition: graphics.h:1607
void init(void)
Definition: graphics.h:9826
std::string get_yliminclude(void) const
Definition: graphics.h:7974
void set_interpreter(const octave_value &val)
Definition: graphics.h:6081
octave_value get_clim(void) const
Definition: graphics.h:9302
base_scaler(void)
Definition: graphics.h:65
bool fontweight_is(const std::string &v) const
Definition: graphics.h:11721
octave_value data
Definition: graphics.h:1423
string_property displayname
Definition: graphics.h:10903
text_label_property(const text_label_property &p)
Definition: graphics.h:735
virtual octave_value get_defaults(void) const
Definition: graphics.h:3032
lin_scaler(void)
Definition: graphics.h:103
bool markerfacecolor_is_rgb(void) const
Definition: graphics.h:10165
std::string cached_units
Definition: graphics.h:8456
void set_alphadatamapping(const octave_value &val)
Definition: graphics.h:8655
bool_property(const std::string &nm, const graphics_handle &h, const char *val)
Definition: graphics.h:1525
bool_property yliminclude
Definition: graphics.h:7351
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:13052
virtual octave_value get_clim(void) const
Definition: graphics.h:2625
bool is___enhanced__(void) const
Definition: graphics.h:4299
string_property xdatasource
Definition: graphics.h:7342
uicontextmenu(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:11546
std::string get_displayname(void) const
Definition: graphics.h:8613
void update_vertices(void)
Definition: graphics.h:9847
void update_zdata(void)
Definition: graphics.h:10791
radio_property xvisualmode
Definition: graphics.h:4078
scaler & operator=(const scaler &s)
Definition: graphics.h:229
static bool has_readonly_property(const caseless_str &pname)
void set_tooltipstring(const octave_value &val)
Definition: graphics.h:13015
void set_foregroundcolor(const octave_value &val)
Definition: graphics.h:12339
string_property diaryfile
Definition: graphics.h:3536
bool_property xliminclude
Definition: graphics.h:8574
void update_ydata(void)
Definition: graphics.h:7707
radio_property horizontalalignment
Definition: graphics.h:7838
void initialize(void)
Definition: graphics.h:3449
virtual void execute(void)=0
void do_unlock(void)
Definition: graphics.h:13533
std::string get_meshstyle(void) const
Definition: graphics.h:10173
octave_value get_callback(void) const
Definition: graphics.h:11699
std::string get_yminorgrid(void) const
Definition: graphics.h:5675
color_property color
Definition: graphics.h:4031
const std::string & current_value(void) const
Definition: graphics.h:1156
double unscale(double d) const
Definition: graphics.h:223
double get_specularstrength(void) const
Definition: graphics.h:10182
#define OCTINTERP_API
Definition: mexproto.h:66
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:506
bool is_hidden(void) const
Definition: graphics.h:303
virtual octave_value get_factory_defaults(void) const
Definition: graphics.h:3045
Matrix get_transform_matrix(void) const
Definition: graphics.h:5130
bool erasemode_is(const std::string &v) const
Definition: graphics.h:7389
radio_property units
Definition: graphics.h:7846
void set_alphadata(const octave_value &val)
Definition: graphics.h:10218
color_property foregroundcolor
Definition: graphics.h:11214
Matrix rgb(void) const
Definition: graphics.h:1062
static void replace(QString &text, const QRegExp &re, const QString &after)
Definition: parser.cc:566
string_property displayname
Definition: graphics.h:7828
std::list< double >::iterator children_list_iterator
Definition: graphics.h:1709
double value(void) const
Definition: oct-handle.h:70
double next_handle
Definition: graphics.h:13423
std::list< graphics_handle >::iterator figure_list_iterator
Definition: graphics.h:13413
color_values(double r=0, double g=0, double b=1)
Definition: graphics.h:1023
void update_fontangle(void)
Definition: graphics.h:8446
const scaler & get_y_scaler(void) const
Definition: graphics.h:5090
void delete_children(bool clear=false)
Definition: graphics.h:1688
void set_currentpoint(const octave_value &val)
Definition: graphics.h:5968
std::string get_xdatasource(void) const
Definition: graphics.h:10188
Matrix get_markerfacecolor_rgb(void) const
Definition: graphics.h:7410
bool bordertype_is(const std::string &v) const
Definition: graphics.h:12202
std::string get_pointer(void) const
Definition: graphics.h:4228
void set_pointershapehotspot(const octave_value &val)
Definition: graphics.h:4605
virtual void update(const graphics_object &go, int id)
Definition: graphics.h:3206
void set_x_viewtransform(const octave_value &val)
Definition: graphics.h:6769
void set_projection(const octave_value &val)
Definition: graphics.h:6202
octave_value get_foregroundcolor(void) const
Definition: graphics.h:11727
radio_property xtickmode
Definition: graphics.h:5346
property & operator=(const octave_value &val)
Definition: graphics.h:1943
octave_value get_foregroundcolor(void) const
Definition: graphics.h:11252
graphics_handle get_parent(void) const
Definition: graphics.h:299
virtual octave_value get_zlim(void) const
Definition: graphics.h:2628
static std::string go_name
Definition: graphics.h:9094
Matrix get_inverse_transform_matrix(void) const
Definition: graphics.h:5131
Matrix get_children(void) const
Definition: graphics.h:2571
bool is_sparse_type(void) const
Definition: ov.h:666
std::set< graphics_handle >::const_iterator const_free_list_iterator
Definition: graphics.h:13411
Array< T > sort(int dim=0, sortmode mode=ASCENDING) const
Definition: Array.cc:1766
bool xdatamode_is(const std::string &v) const
Definition: graphics.h:8636
bool renderer_is(const std::string &v) const
Definition: graphics.h:4236
Cell cell_value(void) const
Definition: graphics.h:551
#define octave_Inf
Definition: lo-ieee.h:31
bool fontunits_is(const std::string &v) const
Definition: graphics.h:5557
bool papertype_is(const std::string &v) const
Definition: graphics.h:4221
int event_processing
Definition: graphics.h:13439
void set_filename(const octave_value &val)
Definition: graphics.h:4421
graphics_toolkit do_get_toolkit(void) const
Definition: graphics.cc:11036
void set_units(const octave_value &val)
Definition: graphics.h:12003
octave_value get_defaults(void) const
Definition: graphics.h:3856
double_property screenpixelsperinch
Definition: graphics.h:3548
octave_idx_type numel(const octave_value_list &idx)
Definition: ov.h:395
void set_linewidth(const octave_value &val)
Definition: graphics.h:9536
color_property(const std::string &nm, const graphics_handle &h, const std::string &v)
Definition: graphics.h:1114
void update_verticalalignment(void)
Definition: graphics.h:8450
properties xproperties
Definition: graphics.h:11110
Matrix get_ycolor_rgb(void) const
Definition: graphics.h:5658
std::string get_fontunits(void) const
Definition: graphics.h:5558
void set_displayname(const octave_value &val)
Definition: graphics.h:8018
OCTINTERP_API void close_all_figures(void)
bool is_real_scalar(void) const
Definition: ov.h:535
void set_fontsize(const octave_value &val)
Definition: graphics.h:11864
bool is_xliminclude(void) const
Definition: graphics.h:8630
void set_xticklabelmode(const octave_value &val)
Definition: graphics.h:6413
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:3884
string_property displayname
Definition: graphics.h:9119
Matrix get_ambientlightcolor_rgb(void) const
Definition: graphics.h:5502
Matrix xrgb
Definition: graphics.h:1079
string_vector string_vector_value(void) const
Definition: graphics.h:758
callback_property windowbuttondownfcn
Definition: graphics.h:4067
double min_pos(void) const
Definition: graphics.h:1360
void set_listboxtop(const octave_value &val)
Definition: graphics.h:11923
bool is_beingdeleted(void) const
Definition: graphics.h:2715
octave_value get___object__(void) const
Definition: graphics.h:12700
void set_xdir(const octave_value &val)
Definition: graphics.h:6305
array_property cdata
Definition: graphics.h:11635
octave_value get_zticklabel(void) const
Definition: graphics.h:5722
std::string string_value(bool force=false) const
Definition: ov.h:897
void set_ylim(const octave_value &val)
Definition: graphics.h:8786
plist_map_iterator end(void)
Definition: graphics.h:2094
void set_accelerator(const octave_value &val)
Definition: graphics.h:11275
bool valid_object(void) const
Definition: graphics.h:11556
uitoggletool(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:13040
bool is_xliminclude(void) const
Definition: graphics.h:7970
void set_edgelighting(const octave_value &val)
Definition: graphics.h:10345
void update_outerposition(void)
Definition: graphics.h:7013
void defaults(void) const
Definition: graphics.h:3373
std::map< listener_mode, octave_value_list > listener_map
Definition: graphics.h:413
bool is_climinclude(void) const
Definition: graphics.h:10952
void print_figure(const graphics_object &go, const std::string &term, const std::string &file, bool mono, const std::string &debug_file="") const
Definition: graphics.h:2247
std::string graphics_object_name(void) const
Definition: graphics.h:8536
void mark_modified(void)
Definition: graphics.h:3263
bool_property zliminclude
Definition: graphics.h:10046
bool paperunits_is(const std::string &v) const
Definition: graphics.h:4224
text(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:8464
double get_markersize(void) const
Definition: graphics.h:7413
virtual void delete_listener(const caseless_str &, const octave_value &, listener_mode=POSTSET)
Definition: graphics.cc:3167
array_property position
Definition: graphics.h:11476
void set_xliminclude(const octave_value &val)
Definition: graphics.h:9785
std::string get_alimmode(void) const
Definition: graphics.h:5498
void set_ytickmode(const octave_value &val)
Definition: graphics.h:6580
virtual Cell values_as_cell(void) const
Definition: graphics.h:331
bool is_editing(void) const
Definition: graphics.h:7918
octave_value get_x_rendertransform(void) const
Definition: graphics.h:5746
std::string current_val
Definition: graphics.h:1015
static std::string go_name
Definition: graphics.h:10884
ColumnVector xform_vector(void)
Definition: graphics.cc:5243
base_scaler * clone(void) const
Definition: graphics.h:113
radio_property autopos_tag
Definition: graphics.h:7858
bool backgroundcolor_is(const std::string &v) const
Definition: graphics.h:12198
void set_aliminclude(const octave_value &val)
Definition: graphics.h:8799
octave_value get_factory_default(const caseless_str &name) const
Definition: graphics.h:3325
virtual ~base_properties(void)
Definition: graphics.h:2483
virtual void adopt(const graphics_handle &h)
Definition: graphics.h:2543
bool xscale_is(const std::string &v) const
Definition: graphics.h:5640
std::string graphics_object_name(void) const
Definition: graphics.h:12853
gtk_manager(void)
Definition: graphics.h:2354
bool fontangle_is(const std::string &v) const
Definition: graphics.h:7926
void resize(octave_idx_type n, const std::string &rfv=std::string())
Definition: str-vec.h:91
color_property markeredgecolor
Definition: graphics.h:10022
bool fontangle_is(const std::string &v) const
Definition: graphics.h:12207
Matrix scale(const Matrix &m) const
Definition: graphics.h:123
void update_xdata(void)
Definition: graphics.h:10779
std::string get_interpreter(void) const
Definition: graphics.h:5567
bool set(const octave_value &val, bool do_run=true, bool do_notify_toolkit=true)
Definition: graphics.h:1933
void set_xlim(const octave_value &val)
Definition: graphics.h:9720
void set(const caseless_str &pname, const octave_value &val)
octave_value get_windowscrollwheelfcn(void) const
Definition: graphics.h:4273
void set_specularcolorreflectance(const octave_value &val)
Definition: graphics.h:9602
double get_mousewheelzoom(void) const
Definition: graphics.h:5579
radio_property normalmode
Definition: graphics.h:9137
int get_ystate(void) const
Definition: graphics.h:5137
callback_property callback
Definition: graphics.h:11634
std::string get_beingdeleted(void) const
Definition: graphics.h:2716
octave_refcount< int > count
Definition: graphics.h:421
array_property pointershapecdata
Definition: graphics.h:4057
std::string get_zliminclude(void) const
Definition: graphics.h:10962
bool is_double(void) const
Definition: graphics.h:1275
double get_fx(void) const
Definition: graphics.h:5157
octave_value get(void) const
Definition: graphics.h:1837
void gripe_not_implemented(const char *fcn)
Definition: gripes.cc:40
void set_alphadatamapping(const octave_value &val)
Definition: graphics.h:9320
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:9025
bool do_set(const octave_value &v)
Definition: graphics.h:1855
octave_value get_color(void) const
Definition: graphics.h:4164
void set(const caseless_str &pname, const octave_value &val)
radio_property erasemode
Definition: graphics.h:8565
std::string get_edgelighting(void) const
Definition: graphics.h:9234
bool_property checked
Definition: graphics.h:11212
Matrix get_zcolor_rgb(void) const
Definition: graphics.h:5695
double get_yPlane(void) const
Definition: graphics.h:5141
void update_zscale(void)
Definition: graphics.h:6895
void do_delete_children(bool clear)
Definition: graphics.cc:1553
octave_value get_zmtick(void) const
Definition: graphics.h:5752
handle_property uicontextmenu
Definition: graphics.h:2683
plist_map_const_iterator begin(void) const
Definition: graphics.h:2092
uicontrol(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:12069
void set_tooltipstring(const octave_value &val)
Definition: graphics.h:12771
void renumber(graphics_handle old_gh, graphics_handle new_gh)
Definition: graphics.h:1693
row_vector_property zdata
Definition: graphics.h:7345
property_list(const plist_map_type &m=plist_map_type())
Definition: graphics.h:2082
row_vector_property ylim
Definition: graphics.h:10040
bool is_enable(void) const
Definition: graphics.h:12909
std::string get_zlimmode(void) const
Definition: graphics.h:5709
double get_specularcolorreflectance(void) const
Definition: graphics.h:9284
octave_value get_ydata(void) const
Definition: graphics.h:7419
double get_ypTickN(void) const
Definition: graphics.h:5148
void set_editing(const octave_value &val)
Definition: graphics.h:8040
octave_value get_resizefcn(void) const
Definition: graphics.h:12233
bool is_enable(void) const
Definition: graphics.h:12707
double_property fontsize
Definition: graphics.h:5310
void execute_windowbuttondownfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4257
string_vector str
Definition: graphics.h:674
std::string get_zscale(void) const
Definition: graphics.h:5718
radio_property xdatamode
Definition: graphics.h:8576
bool is_string(void) const
Definition: ov.h:562
bool facealpha_is(const std::string &v) const
Definition: graphics.h:9240
std::string get_name(void) const
Definition: graphics.h:2242
virtual void update_autopos(const std::string &elem_type)
Definition: graphics.cc:3148
figure(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:4914
Matrix get_shadowcolor_rgb(void) const
Definition: graphics.h:12237
bool facealpha_is(const std::string &v) const
Definition: graphics.h:10137
radio_property cameraupvectormode
Definition: graphics.h:5297
base_properties & get_properties(void)
Definition: graphics.h:12440
std::string get_ydatasource(void) const
Definition: graphics.h:7421
octave_value get(void) const
Definition: graphics.h:1133
color_property markerfacecolor
Definition: graphics.h:9135
void set_foregroundcolor(const octave_value &val)
Definition: graphics.h:11890
octave_value get_vertexnormals(void) const
Definition: graphics.h:9290
row_vector_property xmtick
Definition: graphics.h:5382
double get_margin(void) const
Definition: graphics.h:7950
~scaler(void)
Definition: graphics.h:212
virtual octave_value get(void) const
Definition: graphics.h:318
void update_fontsize(void)
Definition: graphics.h:8445
void set_yliminclude(const octave_value &val)
Definition: graphics.h:8294
void set_alim(const octave_value &val)
Definition: graphics.h:10614
std::set< std::string > all_property_names(void) const
virtual bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:3057
std::string graphics_object_name(void) const
Definition: graphics.h:11608
std::string get_box(void) const
Definition: graphics.h:5506
void set_facealpha(const octave_value &val)
Definition: graphics.h:10367
std::string get_ztickmode(void) const
Definition: graphics.h:5728
std::string get_cameraupvectormode(void) const
Definition: graphics.h:5521
iterator find(const std::string pname)
Definition: graphics.h:2020
const T * data(void) const
Definition: Array.h:479
void update_fontweight(void)
Definition: graphics.h:7007
bool get_y2Dright(void) const
Definition: graphics.h:5167
radio_property tickdirmode
Definition: graphics.h:5327
std::string get_visible(void) const
Definition: graphics.h:2759
int error_state
Definition: error.cc:101
radio_property fontangle
Definition: graphics.h:5308
Matrix rgb(void) const
Definition: graphics.h:1148
bool is_handle_visible(void) const
Definition: graphics.h:3436
void set___modified__(const octave_value &val)
Definition: graphics.h:2588
base_properties & get_properties(void)
Definition: graphics.h:7244
row_vector_property xlim
Definition: graphics.h:10907
bool is_enable(void) const
Definition: graphics.h:11246
std::string get_ygrid(void) const
Definition: graphics.h:5665
array_property(void)
Definition: graphics.h:1324
double min_val(void) const
Definition: graphics.h:1358
void add_constraint(const dim_vector &dims)
Definition: graphics.h:1457
void set_xlim(const octave_value &val)
Definition: graphics.h:6330
bool zdir_is(const std::string &v) const
Definition: graphics.h:5698
Matrix get_edgecolor_rgb(void) const
Definition: graphics.h:9230
row_vector_property ymtick
Definition: graphics.h:5383
void set_nextplot(const octave_value &val)
Definition: graphics.h:4500
octave_value get_clim(void) const
Definition: graphics.h:10200
string_vector & append(const std::string &s)
Definition: str-vec.cc:140
double get_fontsize(void) const
Definition: graphics.h:12212
void set_zliminclude(const octave_value &val)
Definition: graphics.h:9811
~graphics_object(void)
Definition: graphics.h:3257
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:1830
radio_property meshstyle
Definition: graphics.h:10025
bool_property xminortick
Definition: graphics.h:5341
octave_value get_facecolor(void) const
Definition: graphics.h:10144
void set_interpreter(const octave_value &val)
Definition: graphics.h:8141
radio_property plotboxaspectratiomode
Definition: graphics.h:5323
std::string get_alphadatamapping(void) const
Definition: graphics.h:9207
void set_alim(const octave_value &val)
Definition: graphics.h:10987
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:8478
radio_values radio_val
Definition: graphics.h:1185
octave_value get_cdata(void) const
Definition: graphics.h:10109
string_property fixedwidthfontname
Definition: graphics.h:3539
std::string get_cameraviewanglemode(void) const
Definition: graphics.h:5526
array_property looseinset
Definition: graphics.h:5376
radio_property units
Definition: graphics.h:5331
void update_string(void)
Definition: graphics.h:12054
Matrix do_get_children(bool return_hidden) const
Definition: graphics.cc:1514
octave_value get_clim(void) const
Definition: graphics.h:5528
octave_value get_markeredgecolor(void) const
Definition: graphics.h:9272
octave_value get_clim(void) const
Definition: graphics.h:3409
radio_property linestyle
Definition: graphics.h:7840
Cell values_as_cell(void) const
Definition: graphics.cc:1148
std::string get_alphadatamapping(void) const
Definition: graphics.h:10102
bool edgecolor_is_rgb(void) const
Definition: graphics.h:10125
virtual double unscale(double d) const
Definition: graphics.h:87
octave_int< T > pow(const octave_int< T > &a, const octave_int< T > &b)
virtual const base_properties & get_properties(void) const
Definition: graphics.h:3132
graphics_event & operator=(const graphics_event &e)
Definition: graphics.h:13110
bool autopos_tag_is(const std::string &v) const
Definition: graphics.h:5733
void set_yliminclude(const octave_value &val)
Definition: graphics.h:7674
bool do_set(const octave_value &val)
Definition: graphics.h:774
void set_zticklabelmode(const octave_value &val)
Definition: graphics.h:6711
std::list< double > children_list
Definition: graphics.h:1711
double_property linewidth
Definition: graphics.h:10020
double get_listboxtop(void) const
Definition: graphics.h:11735
double_property diffusestrength
Definition: graphics.h:10009
void set_color(const octave_value &val)
Definition: graphics.h:4342
virtual bool is_valid(void) const
Definition: graphics.h:2131
bool normalmode_is(const std::string &v) const
Definition: graphics.h:10175
void set_edgecolor(const octave_value &val)
Definition: graphics.h:8029
bool is_yliminclude(void) const
Definition: graphics.h:3430
handle_property(const std::string &nm, const graphics_handle &h, const graphics_handle &val=graphics_handle())
Definition: graphics.h:1558
double get_specularstrength(void) const
Definition: graphics.h:9288
octave_value get_alim(void) const
Definition: graphics.h:3406
radio_property cameratargetmode
Definition: graphics.h:5295
std::string graphics_object_name(void) const
Definition: graphics.h:10879
bool markeredgecolor_is(const std::string &v) const
Definition: graphics.h:9270
color_property edgecolor
Definition: graphics.h:10012
radio_property alphadatamapping
Definition: graphics.h:8561
bool ambientlightcolor_is(const std::string &v) const
Definition: graphics.h:5501
void set_papersize(const octave_value &val)
Definition: graphics.h:4563
void set_fltk_label(const octave_value &val)
Definition: graphics.h:11363
bool is_cellstr(void) const
Definition: ov.h:532
array_property position
Definition: graphics.h:7843
array_property papersize
Definition: graphics.h:4053
void update_normalmode(void)
Definition: graphics.h:10799
radio_property fontangle
Definition: graphics.h:11639
base_property * rep
Definition: graphics.h:1999
void set_x_viewporttransform(const octave_value &val)
Definition: graphics.h:6791
#define panic_impossible()
Definition: error.h:33
void do_init_children(const Matrix &val)
Definition: graphics.h:1774
base_properties & get_properties(void)
Definition: graphics.h:11552
void set_defaults(base_graphics_object &obj, const std::string &mode)
Definition: graphics.cc:4978
void set_zdatasource(const octave_value &val)
Definition: graphics.h:10603
std::string get_toolbar(void) const
Definition: graphics.h:4252
octave_value get(bool all=false) const
void set_callback(const octave_value &val)
Definition: graphics.h:11286
virtual void remove_child(const graphics_handle &h)
Definition: graphics.h:3090
handle_property parent
Definition: graphics.h:2678
std::string get_renderermode(void) const
Definition: graphics.h:4240
bool cameratargetmode_is(const std::string &v) const
Definition: graphics.h:5515
handle_property callbackobject
Definition: graphics.h:3532
virtual base_properties & get_properties(void)
Definition: graphics.h:3125
std::map< std::string, graphics_toolkit >::const_iterator const_loaded_toolkits_iterator
Definition: graphics.h:2399
std::list< graphics_handle > dependent_obj_list
Definition: graphics.h:11539
bool plotboxaspectratiomode_is(const std::string &v) const
Definition: graphics.h:5588
radio_property verticalalignment
Definition: graphics.h:7847
graphics_object(base_graphics_object *new_rep)
Definition: graphics.h:3235
bool units_is(const std::string &v) const
Definition: graphics.h:3622
std::string get_resize(void) const
Definition: graphics.h:4243
bool horizontalalignment_is(const std::string &v) const
Definition: graphics.h:11729
std::string get_climinclude(void) const
Definition: graphics.h:8502
std::string get_linestyle(void) const
Definition: graphics.h:9262
octave_value get_sliderstep(void) const
Definition: graphics.h:11743
void set_marker(const octave_value &val)
Definition: graphics.h:9547
radio_property paperpositionmode
Definition: graphics.h:4052
string_property xdatasource
Definition: graphics.h:10032
std::string get_wvisual(void) const
Definition: graphics.h:4278
Matrix get_foregroundcolor_rgb(void) const
Definition: graphics.h:11726
radio_property edgelighting
Definition: graphics.h:9122
virtual ~base_graphics_object(void)
Definition: graphics.h:2964
std::string get_units(void) const
Definition: graphics.h:4255
bool units_is(const std::string &v) const
Definition: graphics.h:7958
void set_xdata(const octave_value &val)
Definition: graphics.h:10545
std::string get_units(void) const
Definition: graphics.h:3623
double get_y_max(void) const
Definition: graphics.h:5154
radio_property yscale
Definition: graphics.h:5356
row_vector_property xlim
Definition: graphics.h:8570
radio_property fontunits
Definition: graphics.h:11642
void set_ylim(const octave_value &val)
Definition: graphics.h:8255
std::string get_zdir(void) const
Definition: graphics.h:5699
std::string graphics_object_name(void) const
Definition: graphics.h:11450
static void unload_toolkit(const std::string &name)
Definition: graphics.h:2319
double_radio_property edgealpha
Definition: graphics.h:10011
callback_property deletefcn
Definition: graphics.h:2674
base_properties & get_properties(void)
Definition: graphics.h:3377
Matrix do_figure_handle_list(bool show_hidden)
Definition: graphics.h:13488
std::string get_showhiddenhandles(void) const
Definition: graphics.h:3620
std::string get_fontname(void) const
Definition: graphics.h:11714
~graphics_toolkit(void)
Definition: graphics.h:2220
virtual void remove_child(const graphics_handle &h)
Definition: graphics.h:2534
void set_position(const octave_value &val)
Definition: graphics.h:6190
base_property * clone(void) const
Definition: graphics.h:770
void update_ytick(void)
Definition: graphics.h:6934
std::string get_units(void) const
Definition: graphics.h:11755
static std::string go_name
Definition: graphics.h:12662
property_list get_factory_defaults_list(void) const
Definition: graphics.h:3871
double get_screenpixelsperinch(void) const
Definition: graphics.h:3615
double get_ytickoffset(void) const
Definition: graphics.h:5164
row_vector_property xdata
Definition: graphics.h:7341
std::string get_paperunits(void) const
Definition: graphics.h:4225
radio_property fontunits
Definition: graphics.h:12161
std::string get_xdatasource(void) const
Definition: graphics.h:7417
std::string get_displayname(void) const
Definition: graphics.h:9221
void set_climinclude(const octave_value &val)
Definition: graphics.h:11053
const base_properties & get_properties(void) const
Definition: graphics.h:9021
virtual void redraw_figure(const graphics_object &) const
Definition: graphics.h:2133
static std::string go_name
Definition: graphics.h:12135
void set_windowbuttonupfcn(const octave_value &val)
Definition: graphics.h:4706
void update_cdata(void)
Definition: graphics.h:8902
bool drawmode_is(const std::string &v) const
Definition: graphics.h:5547
void reset_default_properties(void)
Definition: graphics.h:3455
void set_cameraviewangle(const octave_value &val)
Definition: graphics.h:5892
Matrix get_color_rgb(void) const
Definition: graphics.h:7384
bool is_cellstr(void) const
Definition: Cell.cc:127
void set_parent(const graphics_handle &h)
Definition: graphics.h:301
std::string get_accelerator(void) const
Definition: graphics.h:11238
std::string name
Definition: graphics.h:422
bool is_radio(void) const
Definition: graphics.h:971
void set___zoom_mode__(const octave_value &val)
Definition: graphics.h:4840
double get_xPlaneN(void) const
Definition: graphics.h:5140
string_property label
Definition: graphics.h:11215
void set_position(const octave_value &val)
Definition: graphics.h:12361
std::string get___enhanced__(void) const
Definition: graphics.h:4300
any_property linestyleorder
Definition: graphics.h:5316
octave_value get___object__(void) const
Definition: graphics.h:11487
void set_displayname(const octave_value &val)
Definition: graphics.h:7454
std::string get_label(void) const
Definition: graphics.h:11254
octave_value get_pointerlocation(void) const
Definition: graphics.h:3607
void update_ydata(void)
Definition: graphics.h:8935
bool is_hidden(void) const
Definition: graphics.h:1915
static Matrix handle_list(bool show_hidden=false)
Definition: graphics.h:13262
const base_properties & get_properties(void) const
Definition: graphics.h:7246
callback_property windowkeyreleasefcn
Definition: graphics.h:4071
std::string get_windowstyle(void) const
Definition: graphics.h:4276
std::string get_marker(void) const
Definition: graphics.h:10158
octave_value get_dataaspectratio(void) const
Definition: graphics.h:5542
void set_id(int d)
Definition: graphics.h:1927
void set_clim(const octave_value &val)
Definition: graphics.h:5918
void update_xtickmode(void)
Definition: graphics.h:6947
static bool has_readonly_property(const caseless_str &pname)
callback_property windowkeypressfcn
Definition: graphics.h:4070
graphics_toolkit toolkit
Definition: graphics.h:4907
bool do_try_lock(void)
Definition: graphics.h:13531
~graphics_event(void)
Definition: graphics.h:13104
void init(void)
Definition: graphics.h:8400
octave_value get_currentpoint(void) const
Definition: graphics.h:4174
color_property color
Definition: graphics.h:7827
octave_value get_xlim(void) const
Definition: graphics.h:8626
bool_property inverthardcopy
Definition: graphics.h:4041
bool valid_object(void) const
Definition: graphics.h:7730
octave_value get_zlim(void) const
Definition: graphics.h:7431
octave_value get_linestyleorder(void) const
Definition: graphics.h:5572
radio_property fontweight
Definition: graphics.h:12162
bool_property selectionhighlight
Definition: graphics.h:2680
Definition: dMatrix.h:35
void set_minorgridlinestyle(const octave_value &val)
Definition: graphics.h:6117
properties xproperties
Definition: graphics.h:8461
property_list get_defaults_list(void) const
Definition: graphics.h:3861
bool get_layer2Dtop(void) const
Definition: graphics.h:5168
std::string get_string_string(void) const
Definition: graphics.h:11745
array_property outerposition
Definition: graphics.h:5321
void renumber_parent(graphics_handle new_gh)
Definition: graphics.h:2612
static void enable_event_processing(bool enable=true)
Definition: graphics.h:13360
void do_unregister_toolkit(const std::string &name)
Definition: graphics.cc:11087
const base_properties & get_properties(void) const
Definition: graphics.h:12804
static bool persist
Definition: octave.cc:166
octave_value lookup(const caseless_str &name) const
Definition: graphics.cc:2025
void set_ztickmode(const octave_value &val)
Definition: graphics.h:6723
base_properties & get_properties(void)
Definition: graphics.h:8472
void set___object__(const octave_value &val)
Definition: graphics.h:12526
bool wvisualmode_is(const std::string &v) const
Definition: graphics.h:4280
bool_property separator
Definition: graphics.h:12883
std::string get_xliminclude(void) const
Definition: graphics.h:9311
void update_ylim(void)
Definition: graphics.h:7145
graphics_toolkit & operator=(const graphics_toolkit &b)
Definition: graphics.h:2226
string_property displayname
Definition: graphics.h:10010
radio_property linestyle
Definition: graphics.h:7335
static graphics_event create_function_event(event_fcn fcn, void *data=0)
Definition: graphics.cc:9458
bool marker_is(const std::string &v) const
Definition: graphics.h:7400
void adopt(double val)
Definition: graphics.h:1663
bool_property climinclude
Definition: graphics.h:9152
const base_properties & get_properties(void) const
Definition: graphics.h:12077
std::list< graphics_handle >::const_iterator const_figure_list_iterator
Definition: graphics.h:13414
octave_value get_zlim(void) const
Definition: graphics.h:3418
virtual bool is_yliminclude(void) const
Definition: graphics.h:2633
color_property edgecolor
Definition: graphics.h:7829
double unscale(double d) const
Definition: graphics.h:144
std::string get_clipping(void) const
Definition: graphics.h:11704
bool layer_is(const std::string &v) const
Definition: graphics.h:5569
array_property commandwindowsize
Definition: graphics.h:3533
std::string get_filename(void) const
Definition: graphics.h:4182
octave_value get_screensize(void) const
Definition: graphics.h:3617
void set_zdata(const octave_value &val)
Definition: graphics.h:7599
void set_cdata(const octave_value &val)
Definition: graphics.h:12938
void do_load_toolkit(const graphics_toolkit &tk)
Definition: graphics.h:2407
void set_xlim(const octave_value &val)
Definition: graphics.h:11009
bool_property dockcontrols
Definition: graphics.h:4037
void set_string(const octave_value &val)
Definition: graphics.h:11978
properties xproperties
Definition: graphics.h:12431
octave_value get_position(void) const
Definition: graphics.h:4234
void set_windowbuttondownfcn(const octave_value &val)
Definition: graphics.h:4684
void override_defaults(base_graphics_object &obj)
Definition: graphics.h:3265
double get_mincolormap(void) const
Definition: graphics.h:4199
dim_vector dims(void) const
Definition: ov.h:470
octave_value get_cameraposition(void) const
Definition: graphics.h:5508
bool is_aliminclude(void) const
Definition: graphics.h:10949
void set_zminorgrid(const octave_value &val)
Definition: graphics.h:6657
callback_property(const callback_property &p)
Definition: graphics.h:1834
void set_paperpositionmode(const octave_value &val)
Definition: graphics.h:4551
virtual void delete_property_listener(const std::string &nm, const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:3178
octave_value get_keyreleasefcn(void) const
Definition: graphics.h:4194
bool fontunits_is(const std::string &v) const
Definition: graphics.h:12214
Matrix matrix_value(bool frc_str_conv=false) const
Definition: ov.h:773
double max_val(void) const
Definition: graphics.h:1359
Matrix get_screen_size(void) const
Definition: graphics.h:2258
bool is_yliminclude(void) const
Definition: graphics.h:8633
void set_fontsize_points(const octave_value &val)
Definition: graphics.h:6857
radio_property tickdir
Definition: graphics.h:5326
bool autopos_tag_is(const std::string &v) const
Definition: graphics.h:7991
properties xproperties
Definition: graphics.h:9907
bool initialize(const graphics_object &go)
Definition: graphics.h:2269
Cell do_loaded_toolkits_list(void) const
Definition: graphics.h:2439
array_property zdata
Definition: graphics.h:10035
double get_linewidth(void) const
Definition: graphics.h:10155
const base_properties & get_properties(void) const
Definition: graphics.h:7728
octave_value get_papersize(void) const
Definition: graphics.h:4219
string_vector value
Definition: graphics.h:845
void update_fontweight(void)
Definition: graphics.h:12058
bool alphadatamapping_is(const std::string &v) const
Definition: graphics.h:10101
static std::string go_name
Definition: graphics.h:7807
array_property pointerlocation
Definition: graphics.h:3544
plist_map_const_iterator end(void) const
Definition: graphics.h:2095
Matrix get_xcolor_rgb(void) const
Definition: graphics.h:5618
array_property vertices
Definition: graphics.h:9142
void set(const caseless_str &name, const octave_value &val)
Definition: graphics.h:3283
std::string get_xminorgrid(void) const
Definition: graphics.h:5635
std::string get_xgrid(void) const
Definition: graphics.h:5625
row_vector_property(const row_vector_property &p)
Definition: graphics.h:1444
static graphics_event create_callback_event(const graphics_handle &h, const std::string &name, const octave_value &data=Matrix())
Definition: graphics.cc:9434
graphics_handle parent
Definition: graphics.h:423
OCTINTERP_API void execute(const octave_value &data=octave_value()) const
Definition: graphics.cc:1599
std::string get_fontweight(void) const
Definition: graphics.h:11722
std::string get_verticalalignmentmode(void) const
Definition: graphics.h:7989
octave_value get_vertices(void) const
Definition: graphics.h:9292
double_property(const double_property &p)
Definition: graphics.h:1199
double get_screendepth(void) const
Definition: graphics.h:3613
static void execute_callback(const graphics_handle &h, const std::string &name, const octave_value &data=Matrix())
Definition: graphics.h:13301
any_property(const std::string &nm, const graphics_handle &h, const octave_value &m=Matrix())
Definition: graphics.h:1598
~figure(void)
Definition: graphics.h:4918
std::string get_xdatamode(void) const
Definition: graphics.h:8637
graphics_handle get_currentobject(void) const
Definition: graphics.h:4172
bool is_state(void) const
Definition: graphics.h:12921
bool is_clipping(void) const
Definition: graphics.h:2724
double_property linewidth
Definition: graphics.h:7336
charMatrix char_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:814
std::list< double >::const_iterator const_children_list_iterator
Definition: graphics.h:1710
void set_defaults(const std::string &mode)
Definition: graphics.h:7214
void set_clickedcallback(const octave_value &val)
Definition: graphics.h:12738
static void cleanup_instance(void)
Definition: graphics.h:13179
double get_min(void) const
Definition: graphics.h:11739
octave_value get_ycolor(void) const
Definition: graphics.h:5659
std::string get_projection(void) const
Definition: graphics.h:5594
void update_fontweight(void)
Definition: graphics.h:8447
base_properties & get_properties(void)
Definition: graphics.h:10816
static bool has_core_property(const caseless_str &pname)
void update_verticalalignmentmode(void)
Definition: graphics.h:8438
std::string get_doublebuffer(void) const
Definition: graphics.h:4180
octave_value get_tightinset(void) const
Definition: graphics.h:5604
bool is_yliminclude(void) const
Definition: graphics.h:7436
void set(const caseless_str &pname, const octave_value &val)
double get_xPlane(void) const
Definition: graphics.h:5139
void set_fontname(const octave_value &val)
Definition: graphics.h:12304
std::string get_erasemode(void) const
Definition: graphics.h:8616
void set_foregroundcolor(const octave_value &val)
Definition: graphics.h:11319
bool get_zSign(void) const
Definition: graphics.h:5172
bool is_resize(void) const
Definition: graphics.h:4242
std::string get_zliminclude(void) const
Definition: graphics.h:10215
void update(const graphics_handle &h, int id)
Definition: graphics.h:2265
static gh_manager * instance
Definition: graphics.h:13404
octave_value get_keypressfcn(void) const
Definition: graphics.h:11733
void set_xgrid(const octave_value &val)
Definition: graphics.h:6317
double arg(double x)
Definition: lo-mappers.h:37
bool valid_object(void) const
Definition: graphics.h:9920
std::string get_selected(void) const
Definition: graphics.h:2745
void add_dependent_obj(graphics_handle gh)
Definition: graphics.h:11415
row_vector_property ylim
Definition: graphics.h:7849
bool_property aliminclude
Definition: graphics.h:10042
array_property vertexnormals
Definition: graphics.h:9141
std::set< std::string > available_toolkits
Definition: graphics.h:2385
octave_value get_string(void) const
Definition: graphics.h:7956
bool edgealpha_is(const std::string &v) const
Definition: graphics.h:10121
radio_property fontunits
Definition: graphics.h:5311
octave_value get_windowkeypressfcn(void) const
Definition: graphics.h:4267
void init(void)
Definition: graphics.h:4886
void finalize(const graphics_handle &h)
Definition: graphics.h:2281
radio_property ydir
Definition: graphics.h:5349
void set_extent(const octave_value &val)
Definition: graphics.h:8062
void set_cdatamapping(const octave_value &val)
Definition: graphics.h:9367
std::map< std::string, graphics_toolkit >::iterator loaded_toolkits_iterator
Definition: graphics.h:2396
T & xelem(octave_idx_type n)
Definition: Array.h:353
radio_property interpreter
Definition: graphics.h:9130
void set_xdatamode(const octave_value &val)
Definition: graphics.h:8851
double get_yPlaneN(void) const
Definition: graphics.h:5142
graphics_toolkit get_toolkit(void) const
Definition: graphics.h:3917
void update_rotation(void)
Definition: graphics.h:8442
void set_aliminclude(const octave_value &val)
Definition: graphics.h:11042
string_property(const string_property &p)
Definition: graphics.h:437
bool is_zminorgrid(void) const
Definition: graphics.h:5711
virtual double scale(double d) const
Definition: graphics.h:81
virtual void set_defaults(const std::string &)
Definition: graphics.h:3001
base_graphics_toolkit(const std::string &nm)
Definition: graphics.h:2124
std::string get_separator(void) const
Definition: graphics.h:11259
static graphics_toolkit find_toolkit(const std::string &name)
Definition: graphics.h:2325
bool edgealpha_is_double(void) const
Definition: graphics.h:10120
octave_value get_shadowcolor(void) const
Definition: graphics.h:12238
double_radio_property facealpha
Definition: graphics.h:10015
radio_property climmode
Definition: graphics.h:5301
radio_property ztickmode
Definition: graphics.h:5373
octave_value get_looseinset(void) const
Definition: graphics.h:5736
octave_refcount< int > count
Definition: graphics.h:3214
string_property(const std::string &s, const graphics_handle &h, const std::string &val="")
Definition: graphics.h:433
octave_value get_deletefcn(void) const
Definition: graphics.h:2731
std::string get_climmode(void) const
Definition: graphics.h:5531
void set_xvisual(const octave_value &val)
Definition: graphics.h:4794
graphics_handle get_title(void) const
Definition: graphics.h:5606
void set_markerfacecolor(const octave_value &val)
Definition: graphics.h:7531
row_vector_property clim
Definition: graphics.h:10038
void set_cameraviewanglemode(const octave_value &val)
Definition: graphics.h:5907
static bool has_readonly_property(const caseless_str &pname)
double get_ypTick(void) const
Definition: graphics.h:5147
base_graphics_object * rep
Definition: graphics.h:3459
graphics_handle do_lookup(double val)
Definition: graphics.h:13448
string_property tooltipstring
Definition: graphics.h:12885
array_property facevertexalphadata
Definition: graphics.h:9128
bool units_is(const std::string &v) const
Definition: graphics.h:5608
void set_mousewheelzoom(const octave_value &val)
Definition: graphics.h:6128
Matrix get_auto_xdata(void)
Definition: graphics.h:8954
void set_erasemode(const octave_value &val)
Definition: graphics.h:9435
virtual bool is_xliminclude(void) const
Definition: graphics.h:2632
static std::string go_name
Definition: graphics.h:12858
static bool has_readonly_property(const caseless_str &pname)
void set_color(const octave_value &val)
Definition: graphics.h:7443
row_vector_property alim
Definition: graphics.h:10905
radio_property format
Definition: graphics.h:3540
string_property type
Definition: graphics.h:2682
octave_value get_windowbuttonmotionfcn(void) const
Definition: graphics.h:4261
void execute_buttondownfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:2721
void override_defaults(base_graphics_object &obj)
Definition: graphics.h:12553
base_properties & get_properties(void)
Definition: graphics.h:11390
bool is_aliminclude(void) const
Definition: graphics.h:9941
virtual void finalize(const graphics_object &)
Definition: graphics.h:2178
double_property fontsize
Definition: graphics.h:11641
string_property __graphics_toolkit__
Definition: graphics.h:4084
bool get_xySym(void) const
Definition: graphics.h:5170
void override_defaults(base_graphics_object &obj)
Definition: graphics.h:3795
double_property min
Definition: graphics.h:11649
properties xproperties
Definition: graphics.h:10807
std::string get_yliminclude(void) const
Definition: graphics.h:7437
std::string graphics_object_name(void) const
Definition: graphics.h:11185
double xminp
Definition: graphics.h:1426
bool_property xliminclude
Definition: graphics.h:10044
const scaler & get_x_scaler(void) const
Definition: graphics.h:5089
void set_backgroundcolor(const octave_value &val)
Definition: graphics.h:12260
radio_property menubar
Definition: graphics.h:4044
std::string get_yliminclude(void) const
Definition: graphics.h:10959
std::string type(void) const
Definition: graphics.h:3397
std::string get_xliminclude(void) const
Definition: graphics.h:10209
array_property & operator=(const octave_value &val)
Definition: graphics.h:1375
graphics_handle get_parent(void) const
Definition: graphics.h:1909
callback_property createfcn
Definition: graphics.h:2673
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:11130
radio_property titleposition
Definition: graphics.h:12169
graphics_handle get_uicontextmenu(void) const
Definition: graphics.h:2754
bool_property yliminclude
Definition: graphics.h:10045
handle_property currentaxes
Definition: graphics.h:4033
std::string get_fontname(void) const
Definition: graphics.h:12210
base_property * clone(void) const
Definition: graphics.h:1852
octave_value get_edgealpha(void) const
Definition: graphics.h:10123
octave_value get_defaults(void) const
Definition: graphics.h:3330
void set_linestyle(const octave_value &val)
Definition: graphics.h:9525
bool valid_object(void) const
Definition: graphics.h:3395
std::string current_val
Definition: graphics.h:1316
bool facecolor_is_rgb(void) const
Definition: graphics.h:9244
double get_rotation(void) const
Definition: graphics.h:7954
OCTINTERP_API bool validate(const octave_value &v)
Definition: graphics.cc:1319
void set_enable(const octave_value &val)
Definition: graphics.h:12960
void set_autopos_tag(const octave_value &val)
Definition: graphics.h:8368
double_property mincolormap
Definition: graphics.h:4045
bool_property yminortick
Definition: graphics.h:5355
charNDArray max(char d, const charNDArray &m)
Definition: chNDArray.cc:233
std::string get_xvisualmode(void) const
Definition: graphics.h:4288
array_property paperposition
Definition: graphics.h:4051
void update_xdata(void)
Definition: graphics.h:8916
radio_property dataaspectratiomode
Definition: graphics.h:5306
bool is(const std::string &v) const
Definition: graphics.h:1145
void set_x_projectiontransform(const octave_value &val)
Definition: graphics.h:6780
void set_clim(const octave_value &val)
Definition: graphics.h:10627
octave_idx_type length(void) const
Number of elements in the array.
Definition: Array.h:267
void set_ydatasource(const octave_value &val)
Definition: graphics.h:7588
radio_property rotationmode
Definition: graphics.h:7855
octave_value get_ydata(void) const
Definition: graphics.h:10190
double_property ambientstrength
Definition: graphics.h:9114
std::map< listener_mode, octave_value_list >::const_iterator listener_map_const_iterator
Definition: graphics.h:417
radio_property nextplot
Definition: graphics.h:4047
std::string get_fontname(void) const
Definition: graphics.h:7929
void set_extent(const octave_value &val)
Definition: graphics.h:11829
static graphics_handle make_figure_handle(double val, bool do_notify_toolkit=true)
Definition: graphics.h:13236
bool is_bool_scalar(void) const
Definition: ov.h:547
bool is_empty(void) const
Definition: ov.h:526
double get_facealpha_double(void) const
Definition: graphics.h:9241
row_vector_property clim
Definition: graphics.h:10906
bool edgecolor_is(const std::string &v) const
Definition: graphics.h:7914
void run_listeners(listener_mode mode=POSTSET)
Definition: graphics.h:1967
bool is_checked(void) const
Definition: graphics.h:11243
bool_property editing
Definition: graphics.h:7830
void set_pointershapecdata(const octave_value &val)
Definition: graphics.h:4594
void set_facevertexalphadata(const octave_value &val)
Definition: graphics.h:9491
void set_keyreleasefcn(const octave_value &val)
Definition: graphics.h:4456
bool alimmode_is(const std::string &v) const
Definition: graphics.h:5497
void update_tickdirmode(void)
Definition: graphics.h:6926
bool menubar_is(const std::string &v) const
Definition: graphics.h:4196
octave_value get_markeredgecolor(void) const
Definition: graphics.h:7406
void set___object__(const octave_value &val)
Definition: graphics.h:11495
void update(const graphics_object &go, int id)
Definition: graphics.h:2262
void set_zdir(const octave_value &val)
Definition: graphics.h:6603
bool fontangle_is(const std::string &v) const
Definition: graphics.h:5550
octave_value get_facealpha(void) const
Definition: graphics.h:10139
radio_property interpreter
Definition: graphics.h:7839
void set_handlevisibility(const octave_value &val)
Definition: graphics.h:2844
octave_value get_color(void) const
Definition: graphics.h:7385
bool is_zliminclude(void) const
Definition: graphics.h:7976
bool xticklabelmode_is(const std::string &v) const
Definition: graphics.h:5647
radio_property autopos_tag
Definition: graphics.h:5375
Matrix scale(const Matrix &m) const
Definition: graphics.h:163
void set_cameratargetmode(const octave_value &val)
Definition: graphics.h:5855
Matrix get_opengl_matrix_2(void) const
Definition: graphics.h:5133
graphics_handle __myhandle__
Definition: graphics.h:2687
children_property children
Definition: graphics.h:2671
NDArray array_value(bool frc_str_conv=false) const
Definition: ov.h:779
std::string get_fltk_label(void) const
Definition: graphics.h:11261
virtual Matrix get_canvas_size(const graphics_handle &) const
Definition: graphics.h:2141
virtual octave_value get(const caseless_str &pname) const
Matrix stack(const Matrix &a) const
Definition: dMatrix.cc:532
string_vector string_vector_value(void) const
Definition: graphics.h:553
void set_currentpoint(const octave_value &val)
Definition: graphics.h:4388
void set_windowbuttonmotionfcn(const octave_value &val)
Definition: graphics.h:4695
base_properties & get_properties(void)
Definition: graphics.h:3876
radio_property fontweight
Definition: graphics.h:5312
handle_property title
Definition: graphics.h:5330
double scale(double d) const
Definition: graphics.h:109
bool do_set(const octave_value &val)
Definition: graphics.h:1544
radio_property papertype
Definition: graphics.h:4054
bool zcolor_is_rgb(void) const
Definition: graphics.h:5693
void set___rotate_mode__(const octave_value &val)
Definition: graphics.h:4829
bool is___hold_all__(void) const
Definition: graphics.h:5730
void update_ytickmode(void)
Definition: graphics.h:6956
void set_children(const octave_value &val)
Definition: graphics.h:2800
properties xproperties
Definition: graphics.h:7178
graphics_handle get_currentfigure(void) const
Definition: graphics.h:3583
void set___object__(const octave_value &val)
Definition: graphics.h:12927
void add_listener(const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:343
virtual property_list get_defaults_list(void) const
Definition: graphics.h:3038
bool edgelighting_is(const std::string &v) const
Definition: graphics.h:9233
void set_resize(const octave_value &val)
Definition: graphics.h:4638
ColumnVector pixel2coord(double px, double py) const
Definition: graphics.h:5175
static int flush_events(void)
Definition: graphics.h:13355
static void cleanup_instance(void)
Definition: graphics.h:2377
void set_resizefcn(const octave_value &val)
Definition: graphics.h:4649
bool_property aliminclude
Definition: graphics.h:8572
bool interpreter_is(const std::string &v) const
Definition: graphics.h:7942
std::set< std::string >::iterator available_toolkits_iterator
Definition: graphics.h:2390
std::string graphics_object_name(void) const
Definition: graphics.h:9978
callback_property keyreleasefcn
Definition: graphics.h:4043
std::string values_as_string(void) const
Definition: graphics.h:1937
double get_xtickoffset(void) const
Definition: graphics.h:5163
octave_value get_resizefcn(void) const
Definition: graphics.h:4246
color_property backgroundcolor
Definition: graphics.h:7826
void set___hold_all__(const octave_value &val)
Definition: graphics.h:6735
double get_fz(void) const
Definition: graphics.h:5159
bool fontweight_is(const std::string &v) const
Definition: graphics.h:12217
any_property __object__
Definition: graphics.h:11209
base_property * clone(void) const
Definition: graphics.h:1172
std::string get_scale(const std::string &scale, const Matrix &lims)
Definition: graphics.h:6875
void set_cameraposition(const octave_value &val)
Definition: graphics.h:5814
array_property outerposition
Definition: graphics.h:4049
std::string default_val
Definition: graphics.h:935
std::string get_horizontalalignment(void) const
Definition: graphics.h:7940
octave_value get_defaults(void) const
Definition: graphics.h:7234
bool tickdir_is(const std::string &v) const
Definition: graphics.h:5596
bool __mouse_mode___is(const std::string &v) const
Definition: graphics.h:4290
void set_screenpixelsperinch(const octave_value &val)
Definition: graphics.h:3730
octave_value get_xlim(void) const
Definition: graphics.h:7964
void set_linestyle(const octave_value &val)
Definition: graphics.h:7487
bool selectiontype_is(const std::string &v) const
Definition: graphics.h:4248
double_property specularstrength
Definition: graphics.h:10029
void set_interpreter(const octave_value &val)
Definition: graphics.h:7476
radio_property cdatamapping
Definition: graphics.h:9117
bool is_ygrid(void) const
Definition: graphics.h:5664
double get_position(void) const
Definition: graphics.h:11256
double_radio_property(const std::string &nm, const graphics_handle &h, const double_radio_property &v)
Definition: graphics.h:1255
bool ok(void) const
Definition: graphics.h:13128
#define octave_NaN
Definition: lo-ieee.h:37
bool_property zliminclude
Definition: graphics.h:7853
row_vector_property xlim
Definition: graphics.h:9148
graphics_object(void)
Definition: graphics.h:3233
void invalidate(void)
Definition: graphics.h:1582
bool is_box(void) const
Definition: graphics.h:5505
properties xproperties
Definition: graphics.h:9008
void set_monitorpositions(const octave_value &val)
Definition: graphics.h:3684
string_property ydatasource
Definition: graphics.h:10034
std::string get_zdatasource(void) const
Definition: graphics.h:7425
std::string get_interpreter(void) const
Definition: graphics.h:7393
bool nextplot_is(const std::string &v) const
Definition: graphics.h:5581
void set_xlimmode(const octave_value &val)
Definition: graphics.h:6346
double_property specularcolorreflectance
Definition: graphics.h:9138
callback_property resizefcn
Definition: graphics.h:4063
void add_constraint(const dim_vector &dims)
Definition: graphics.h:1355
string_property & operator=(const octave_value &val)
Definition: graphics.h:445
any_property userdata
Definition: graphics.h:2684
void set_position(const octave_value &val)
Definition: graphics.h:11517
bool valid_object(void) const
Definition: graphics.h:9023
const base_properties & get_properties(void) const
Definition: graphics.h:9918
void set_dockcontrols(const octave_value &val)
Definition: graphics.h:4399
ColumnVector untransform(double x, double y, bool use_scale=true) const
Definition: graphics.h:5034
radio_property ydatamode
Definition: graphics.h:8577
void set_facecolor(const octave_value &val)
Definition: graphics.h:9457
radio_values(const radio_values &a)
Definition: graphics.h:856
octave_value get_zlim(void) const
Definition: graphics.h:10947
array_property vertexnormals
Definition: graphics.h:10030
bool bool_value(bool warn=false) const
Definition: ov.h:805
void set_yminortick(const octave_value &val)
Definition: graphics.h:6525
bool_property ygrid
Definition: graphics.h:5350
scaler(void)
Definition: graphics.h:201
bool windowstyle_is(const std::string &v) const
Definition: graphics.h:4275
bool erasemode_is(const std::string &v) const
Definition: graphics.h:9236
base_properties & get_properties(void)
Definition: graphics.h:7726
virtual bool initialize(const graphics_object &)
Definition: graphics.h:2170
void set_xlim(const octave_value &val)
Definition: graphics.h:10640
std::map< std::string, pval_map_type > plist_map_type
Definition: graphics.h:2074
void init(void)
Definition: graphics.h:11376
void init(void)
Definition: graphics.h:8875
void set_facelighting(const octave_value &val)
Definition: graphics.h:9468
properties xproperties
Definition: graphics.h:4911
octave_value get_cameratarget(void) const
Definition: graphics.h:5513
static std::string go_name
Definition: graphics.h:7312
double get_yticklen(void) const
Definition: graphics.h:5161
radio_property ylimmode
Definition: graphics.h:5353
radio_property erasemode
Definition: graphics.h:10014
octave_value get_markerfacecolor(void) const
Definition: graphics.h:7411
void update_horizontalalignment(void)
Definition: graphics.h:8449
void remove_child(const graphics_handle &h)
Definition: graphics.h:3367
octave_value get_x_projectiontransform(void) const
Definition: graphics.h:5740
double get_markersize(void) const
Definition: graphics.h:10170
virtual NDArray scale(const NDArray &m) const
Definition: graphics.h:75
bool_property diary
Definition: graphics.h:3535
const base_properties & get_properties(void) const
Definition: graphics.h:10818
std::list< graphics_handle > cbo_stack
Definition: graphics.h:3779
bool foregroundcolor_is(const std::string &v) const
Definition: graphics.h:12221
void set_erasemode(const octave_value &val)
Definition: graphics.h:8704
void set_userdata(const octave_value &val)
Definition: graphics.h:2911
void init_integerhandle(const octave_value &val)
Definition: graphics.h:3908
std::string get_xliminclude(void) const
Definition: graphics.h:10956
array_property pointershapehotspot
Definition: graphics.h:4058
radio_property facelighting
Definition: graphics.h:9126
octave_value get___object__(void) const
Definition: graphics.h:12195
std::list< graphics_event > event_queue
Definition: graphics.h:13433
bool remove_child(double val)
Definition: graphics.h:1658
~image(void)
Definition: graphics.h:9017
void set_id(int d)
Definition: graphics.h:311
double get_fontsize(void) const
Definition: graphics.h:11716
base_properties & get_properties(void)
Definition: graphics.h:12602
void set_zlimmode(const octave_value &val)
Definition: graphics.h:6644
std::string get_erasemode(void) const
Definition: graphics.h:9237
double_property & operator=(const octave_value &val)
Definition: graphics.h:1206
std::string get_selectiontype(void) const
Definition: graphics.h:4249
static graphics_handle lookup(double val)
Definition: graphics.h:13201
radio_property renderer
Definition: graphics.h:4060
std::string get_interruptible(void) const
Definition: graphics.h:2740
static bool has_readonly_property(const caseless_str &pname)
virtual graphics_toolkit get_toolkit(void) const
Definition: graphics.cc:3123
void set_xlim(const octave_value &val)
Definition: graphics.h:8773
base_properties & get_properties(void)
Definition: graphics.h:9019
bool color_is_rgb(void) const
Definition: graphics.h:7906
NDArray scale(const NDArray &m) const
Definition: graphics.h:107
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:1627
bool is_interruptible(void) const
Definition: graphics.h:2739
void set_xcolor(const octave_value &val)
Definition: graphics.h:6294
radio_property linestyle
Definition: graphics.h:9131
std::string get_normalmode(void) const
Definition: graphics.h:9282
double_property cameraviewangle
Definition: graphics.h:5298
std::pair< std::string, octave_value > pval_pair
Definition: graphics.h:2004
int get_xstate(void) const
Definition: graphics.h:5136
double_property linewidth
Definition: graphics.h:5317
any_property __zoom_mode__
Definition: graphics.h:4082
void set_screensize(const octave_value &val)
Definition: graphics.h:3741
octave_value get_cdata(void) const
Definition: graphics.h:9214
array_property view
Definition: graphics.h:5332
properties xproperties
Definition: graphics.h:12066
void update_xdata(void)
Definition: graphics.h:9853
bool backgroundcolor_is_rgb(void) const
Definition: graphics.h:12197
void execute_clickedcallback(const octave_value &data=octave_value()) const
Definition: graphics.h:12906
bool is_separator(void) const
Definition: graphics.h:12710
octave_value get___pan_mode__(void) const
Definition: graphics.h:4293
octave_value get_xlim(void) const
Definition: graphics.h:3412
row_vector_property clim
Definition: graphics.h:5300
~uicontrol(void)
Definition: graphics.h:12073
double get_z_min(void) const
Definition: graphics.h:5155
octave_handle graphics_handle
Definition: graphics.h:58
handle_property currentobject
Definition: graphics.h:4035
void set_fontangle(const octave_value &val)
Definition: graphics.h:6018
octave_value get_facecolor(void) const
Definition: graphics.h:9247
void add_property_listener(const std::string &nm, const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:3441
void set_units(const octave_value &val)
Definition: graphics.h:3763
OCTINTERP_API bool set(const octave_value &v, bool do_run=true, bool do_notify_toolkit=true)
Definition: graphics.cc:1046
octave_map values_as_struct(void)
Definition: graphics.h:3359
octave_value get_ylim(void) const
Definition: graphics.h:3415
static bool instance_ok(void)
Definition: graphics.h:2360
void set_specularexponent(const octave_value &val)
Definition: graphics.h:10511
octave_value get_foregroundcolor(void) const
Definition: graphics.h:12223
void set_closerequestfcn(const octave_value &val)
Definition: graphics.h:4331
color_property xcolor
Definition: graphics.h:5334
bool_property beingdeleted
Definition: graphics.h:2668
void set_facelighting(const octave_value &val)
Definition: graphics.h:10389
void set_xdata(const octave_value &val)
Definition: graphics.h:9658
double get_cameraviewangle(void) const
Definition: graphics.h:5523
radio_property marker
Definition: graphics.h:7337
bool tickdirmode_is(const std::string &v) const
Definition: graphics.h:5599
radio_property fontweight
Definition: graphics.h:7837
std::string get_inverthardcopy(void) const
Definition: graphics.h:4188
graphics_xform(void)
Definition: graphics.h:4994
graphics_toolkit(void)
Definition: graphics.h:2202
plist_map_type plist_map
Definition: graphics.h:2110
static OCTINTERP_API void create_instance(void)
Definition: graphics.cc:11027
bool color_is(const std::string &v) const
Definition: graphics.h:7907
void set_ymtick(const octave_value &val)
Definition: graphics.h:6835
radio_values vals
Definition: graphics.h:1014
void update_horizontalalignmentmode(void)
Definition: graphics.h:8437
void set_climmode(const octave_value &val)
Definition: graphics.h:5933
bool_property xliminclude
Definition: graphics.h:7350
array_property ydata
Definition: graphics.h:10033
void set_looseinset(const octave_value &val)
Definition: graphics.h:6757
plist_map_iterator begin(void)
Definition: graphics.h:2091
virtual void add_property_listener(const std::string &nm, const octave_value &v, listener_mode mode=POSTSET)
Definition: graphics.h:3170
bool valid_object(void) const
Definition: graphics.h:8476
double scale(double d) const
Definition: graphics.h:181
handle_property & operator=(const octave_value &val)
Definition: graphics.h:1570
virtual octave_value get_ylim(void) const
Definition: graphics.h:2627
void set_title(const octave_value &val)
Definition: graphics.h:12394
void set_xminorgrid(const octave_value &val)
Definition: graphics.h:6359
bool_property __enhanced__
Definition: graphics.h:4083
virtual bool is_linear(void) const
Definition: graphics.h:96
bool empty(void) const
Definition: graphics.h:739
std::string get_separator(void) const
Definition: graphics.h:12711
void update_zdata(void)
Definition: graphics.h:9886
void update_position(void)
Definition: graphics.h:8408
NDArray scale(const NDArray &m) const
Definition: graphics.h:217
row_vector_property clim
Definition: graphics.h:8569
double_radio_property(double d, const radio_values &v)
Definition: graphics.h:1242
bool is_yminorgrid(void) const
Definition: graphics.h:5674
property(void)
Definition: graphics.h:1883
bool is_integerhandle(void) const
Definition: graphics.h:4184
static bool has_readonly_property(const caseless_str &pname)
bool is_yliminclude(void) const
Definition: graphics.h:9313
Matrix get_auto_ydata(void)
Definition: graphics.h:8966
bool_property climinclude
Definition: graphics.h:8573
std::string get_xdir(void) const
Definition: graphics.h:5622
virtual void mark_modified(void)
Definition: graphics.h:2966
static graphics_handle get_handle(bool integer_figure_handle)
Definition: graphics.h:13181
void set_backgroundcolor(const octave_value &val)
Definition: graphics.h:11774
radio_property horizontalalignment
Definition: graphics.h:11645
void set_x_rendertransform(const octave_value &val)
Definition: graphics.h:6813
color_property ambientlightcolor
Definition: graphics.h:5290
Matrix get_all_children(void) const
Definition: graphics.h:2576
double double_value(void) const
Definition: graphics.h:1204
bool is_on(void) const
Definition: graphics.h:1533
void update_ydir(void)
Definition: graphics.h:6921
double get_specularexponent(void) const
Definition: graphics.h:10180
bool is_xliminclude(void) const
Definition: graphics.h:7433
void set___object__(const octave_value &val)
Definition: graphics.h:12716
uipanel(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:12434
callback_property windowscrollwheelfcn
Definition: graphics.h:4072
void execute_windowscrollwheelfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4272
array_property x_rendertransform
Definition: graphics.h:5381
bool is_xminortick(void) const
Definition: graphics.h:5637
octave_value get_ticklength(void) const
Definition: graphics.h:5602
octave_value get_xlim(void) const
Definition: graphics.h:10202
bool compare(const std::string &s, size_t limit=std::string::npos) const
Definition: caseless-str.h:76
color_property markeredgecolor
Definition: graphics.h:7338
void set_zlim(const octave_value &val)
Definition: graphics.h:7648
array_property currentpoint
Definition: graphics.h:5304
row_vector_property xlim
Definition: graphics.h:7347
radio_property fontangle
Definition: graphics.h:12158
array_property tightinset
Definition: graphics.h:5329
bool is_modified(void) const
Definition: graphics.h:2532
double_property fontsize
Definition: graphics.h:7835
void set_outerposition(const octave_value &val)
Definition: graphics.h:6150
double get_x_min(void) const
Definition: graphics.h:5151
Matrix get_hidden_children(void) const
Definition: graphics.h:2581
row_vector_property zlim
Definition: graphics.h:10041
void set_fontangle(const octave_value &val)
Definition: graphics.h:11840
graphics_object do_get_object(const graphics_handle &h)
Definition: graphics.h:13455
bool valid_object(void) const
Definition: graphics.h:12079
array_property position
Definition: graphics.h:4059
octave_value get_position(void) const
Definition: graphics.h:7952
octave_value get_alphamap(void) const
Definition: graphics.h:4153
double get_y_min(void) const
Definition: graphics.h:5153
static void renumber_figure(const graphics_handle &old_gh, const graphics_handle &new_gh)
Definition: graphics.h:13194
string_property name
Definition: graphics.h:4046
void set_ambientstrength(const octave_value &val)
Definition: graphics.h:9333
double get_xpTick(void) const
Definition: graphics.h:5145
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:12808
bool pointer_is(const std::string &v) const
Definition: graphics.h:4227
bool facealpha_is_double(void) const
Definition: graphics.h:9239
void scale(Matrix &m, double x, double y, double z)
Definition: graphics.cc:5281
void execute_callback(const octave_value &data=octave_value()) const
Definition: graphics.h:11698
void set_horizontalalignment(const octave_value &val)
Definition: graphics.h:8125
callback_property buttondownfcn
Definition: graphics.h:2670
std::string get_aliminclude(void) const
Definition: graphics.h:9943
graphics_handle get_callbackobject(void) const
Definition: graphics.h:3579
std::string get_ydir(void) const
Definition: graphics.h:5662
radio_property erasemode
Definition: graphics.h:10904
bool backfacelighting_is(const std::string &v) const
Definition: graphics.h:10106
bool is_dockcontrols(void) const
Definition: graphics.h:4176
void set_sliderstep(const octave_value &val)
Definition: graphics.h:11967
void set_verticalalignment(const octave_value &val)
Definition: graphics.h:8226
void set_name(const std::string &s)
Definition: graphics.h:297
bool valid_object(void) const
Definition: graphics.h:12606
bool ycolor_is(const std::string &v) const
Definition: graphics.h:5657
Matrix xform
Definition: graphics.h:5065
bool is_defined(void) const
Definition: graphics.h:1841
bool is_linear(void) const
Definition: graphics.h:115
std::string get_yliminclude(void) const
Definition: graphics.h:8634
static graphics_object get_object(double val)
Definition: graphics.h:13212
void set___graphics_toolkit__(const octave_value &val)
Definition: graphics.h:3927
~property(void)
Definition: graphics.h:1894
bool_property clipping
Definition: graphics.h:2672
radio_property facelighting
Definition: graphics.h:10017
std::string get_yscale(void) const
Definition: graphics.h:5681
surface(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:10810
bool is_xminorgrid(void) const
Definition: graphics.h:5634
void set_specularexponent(const octave_value &val)
Definition: graphics.h:9613
bool is_undefined(void) const
Definition: ov.h:523
void update_fontname(void)
Definition: graphics.h:6992
bool is(const std::string &v) const
Definition: graphics.h:1279
any_property __pan_mode__
Definition: graphics.h:4080
uint8NDArray pixels
Definition: graphics.h:8457
bool_property visible
Definition: graphics.h:2685
void set_fontweight(const octave_value &val)
Definition: graphics.h:8113
bool get_is2D(void) const
Definition: graphics.h:5169
double get_zpTick(void) const
Definition: graphics.h:5149
uimenu(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:11384
std::string get_handlevisibility(void) const
Definition: graphics.h:2734
void set_borderwidth(const octave_value &val)
Definition: graphics.h:12282
double get_specularcolorreflectance(void) const
Definition: graphics.h:10178
radio_property busyaction
Definition: graphics.h:2669
std::string get_fontweight(void) const
Definition: graphics.h:5561
void remove_child(const graphics_handle &h)
Definition: graphics.h:10839
radio_property(const radio_property &p)
Definition: graphics.h:957
double get_linewidth(void) const
Definition: graphics.h:7398
bool_property __hold_all__
Definition: graphics.h:5374
void resize(octave_idx_type n, const octave_value &rfv=octave_value())
Definition: oct-obj.h:93
static property_list factory_properties
Definition: graphics.h:3895
BEGIN_BASE_PROPERTIES bool_property off radio_property queue cancel callback_property Matrix() children_property children gf
std::string values_as_string(void)
Definition: graphics.h:3352
std::string get_hittest(void) const
Definition: graphics.h:2737
void update_plotboxaspectratiomode(void)
Definition: graphics.h:6904
string_property tooltipstring
Definition: graphics.h:12686
ColumnVector transform(const Matrix &m, double x, double y, double z)
Definition: graphics.cc:5259
static void post_function(graphics_event::event_fcn fcn, void *data=0)
Definition: graphics.h:13337
bool_property integerhandle
Definition: graphics.h:4040
double get_ambientstrength(void) const
Definition: graphics.h:10104
graphics_handle get_parent(void) const
Definition: graphics.h:2742
hggroup(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:11113
octave_value get(bool all=false) const
void update_fontsize(void)
Definition: graphics.h:6997
void set_offcallback(const octave_value &val)
Definition: graphics.h:12971
std::string get_units(void) const
Definition: graphics.h:12246
static std::set< std::string > readonly_property_names(void)
array_property position
Definition: graphics.h:5324
radio_property(const std::string &nm, const graphics_handle &h, const radio_values &v, const std::string &def)
Definition: graphics.h:952
double_property markersize
Definition: graphics.h:10024
radio_property xdir
Definition: graphics.h:5335
array_property(const array_property &p)
Definition: graphics.h:1344
void set_xliminclude(const octave_value &val)
Definition: graphics.h:10705
void set_zliminclude(const octave_value &val)
Definition: graphics.h:8307
void set_string(const octave_value &val)
Definition: graphics.h:8202
bool xaxislocation_is(const std::string &v) const
Definition: graphics.h:5613
void set_facecolor(const octave_value &val)
Definition: graphics.h:10378
void set___object__(const octave_value &val)
Definition: graphics.h:11763
array_property extent
Definition: graphics.h:11638
OCTINTERP_API int calc_dimensions(const graphics_object &gh)
Definition: graphics.cc:10619
void update_fontname(void)
Definition: graphics.h:12055
void update_boundingbox(void)
Definition: graphics.h:5100
callback_property windowbuttonupfcn
Definition: graphics.h:4069
void add_constraint(const std::string &type)
Definition: graphics.h:1452
double_property position
Definition: graphics.h:11216
string_property tooltipstring
Definition: graphics.h:11654
virtual void update_axis_limits(const std::string &axis_type) const
Definition: graphics.cc:3082
virtual bool is_zliminclude(void) const
Definition: graphics.h:2634
std::string get_yminortick(void) const
Definition: graphics.h:5678
base_properties & get_properties(void)
Definition: graphics.h:11119
Matrix get_markeredgecolor_rgb(void) const
Definition: graphics.h:10162
void set_zminortick(const octave_value &val)
Definition: graphics.h:6668
std::string get_zminortick(void) const
Definition: graphics.h:5715
graphics_toolkit do_find_toolkit(const std::string &name) const
Definition: graphics.h:2417
properties xproperties
Definition: graphics.h:12793
octave_value get_ztick(void) const
Definition: graphics.h:5720
listener_mode
Definition: graphics.h:270
float pixel_xsize(void)
Definition: graphics.h:8996
array_property cdata
Definition: graphics.h:9116
void set_checked(const octave_value &val)
Definition: graphics.h:11297
void set_zlim(const octave_value &val)
Definition: graphics.h:6628
void initialize_data(void)
Definition: graphics.h:8507
void set_paperorientation(const octave_value &val)
Definition: graphics.h:4522
std::string get_integerhandle(void) const
Definition: graphics.h:4185
base_property * clone(void) const
Definition: graphics.h:979
radio_property backfacelighting
Definition: graphics.h:10005
std::string get_facelighting(void) const
Definition: graphics.h:9250
bool_property hittest
Definition: graphics.h:2676
void set_normalmode(const octave_value &val)
Definition: graphics.h:10488
string_property fltk_label
Definition: graphics.h:11218
callback_property callback
Definition: graphics.h:11475
octave_value get_xlim(void) const
Definition: graphics.h:7427
std::string str
Definition: graphics.h:473
string_property wvisual
Definition: graphics.h:4074
static bool match(const std::string &filename_arg, const std::string &path_elt_arg)
Definition: kpse.cc:1738
void set_beingdeleted(const octave_value &val)
Definition: graphics.h:2767
double_property margin
Definition: graphics.h:7842
radio_property erasemode
Definition: graphics.h:9123
octave_value get_ylim(void) const
Definition: graphics.h:8628
std::string get_fontangle(void) const
Definition: graphics.h:5551
void set___plot_stream__(const octave_value &val)
Definition: graphics.h:4873
row_vector_property ylim
Definition: graphics.h:9149
double get_zticklen(void) const
Definition: graphics.h:5162
void set_dataaspectratio(const octave_value &val)
Definition: graphics.h:5979
double_property specularexponent
Definition: graphics.h:10028
std::string get_yliminclude(void) const
Definition: graphics.h:9314
color_property zcolor
Definition: graphics.h:5361
radio_property pointer
Definition: graphics.h:4056
octave_value get_colororder(void) const
Definition: graphics.h:5538
void set_gridlinestyle(const octave_value &val)
Definition: graphics.h:6070
void reparent(const graphics_handle &h)
Definition: graphics.h:3371
bool_property selected
Definition: graphics.h:2679
std::list< graphics_object > callback_objects
Definition: graphics.h:13436
color_property(const color_values &c, const radio_values &v)
Definition: graphics.h:1087
std::string get_activepositionproperty(void) const
Definition: graphics.h:5493
bool xtickmode_is(const std::string &v) const
Definition: graphics.h:5650
octave_value get_outerposition(void) const
Definition: graphics.h:5584
octave_value get_property_from_handle(double handle, const std::string &property, const std::string &func)
Definition: graphics.cc:11647
octave_value get_vertexnormals(void) const
Definition: graphics.h:10184
bool is_climinclude(void) const
Definition: graphics.h:8500
virtual void override_defaults(base_graphics_object &obj)
Definition: graphics.h:2974
void set_yliminclude(const octave_value &val)
Definition: graphics.h:10718
void set_edgealpha(const octave_value &val)
Definition: graphics.h:9402
array_property xdata
Definition: graphics.h:9143
octave_value get___object__(void) const
Definition: graphics.h:11236
bool facecolor_is(const std::string &v) const
Definition: graphics.h:9245
virtual double get_screen_resolution(void) const
Definition: graphics.h:2147
Matrix scale(const Matrix &m) const
Definition: graphics.h:105
void set_language(const octave_value &val)
Definition: graphics.h:3673
property clone(void) const
Definition: graphics.h:1975
graphics_handle get_handle(void) const
Definition: graphics.h:3363
void update(int id)
Definition: graphics.h:3453
virtual void set(const caseless_str &, const octave_value &)
std::string get_dockcontrols(void) const
Definition: graphics.h:4177
Matrix x_render_inv
Definition: graphics.h:5211
charMatrix char_value(void) const
Definition: graphics.h:760
void add_constraint(octave_idx_type len)
Definition: graphics.h:1462
void update_fontangle(void)
Definition: graphics.h:7002
std::map< std::string, graphics_toolkit > loaded_toolkits
Definition: graphics.h:2388
octave_value get_outerposition(void) const
Definition: graphics.h:4209
ft_render text_renderer
Definition: graphics.h:5228
void execute_keyreleasefcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4193
radio_property interpreter
Definition: graphics.h:10018
bool ycolor_is_rgb(void) const
Definition: graphics.h:5656
void set_fontangle(const octave_value &val)
Definition: graphics.h:12293
static Cell loaded_toolkits_list(void)
Definition: graphics.h:2336
std::string get_ydatamode(void) const
Definition: graphics.h:8640
bool linestyle_is(const std::string &v) const
Definition: graphics.h:7945
void set_fontsize(const octave_value &val)
Definition: graphics.h:12315
std::list< graphics_handle > figure_list
Definition: graphics.h:13427
radio_property marker
Definition: graphics.h:10021
graphics_handle get___myhandle__(void) const
Definition: graphics.h:2764
void set_modified(const octave_value &val)
Definition: graphics.h:2586
double_property diffusestrength
Definition: graphics.h:9118
OCTINTERP_API radio_values(const std::string &opt_string=std::string())
Definition: graphics.cc:1084
octave_value get___zoom_mode__(void) const
Definition: graphics.h:4297
void redraw_figure(const graphics_object &go) const
Definition: graphics.h:2244
octave_value get_xdata(void) const
Definition: graphics.h:7415
bool shadowcolor_is_rgb(void) const
Definition: graphics.h:12235
bool is_zliminclude(void) const
Definition: graphics.h:7439
radio_property xaxislocation
Definition: graphics.h:5333
std::string get_erasemode(void) const
Definition: graphics.h:10134
static OCTINTERP_API gtk_manager * instance
Definition: graphics.h:2379
double_property max
Definition: graphics.h:11648
void set_separator(const octave_value &val)
Definition: graphics.h:12993
base_property & operator=(const octave_value &val)
Definition: graphics.h:337
void set_titleposition(const octave_value &val)
Definition: graphics.h:12405
void set_ydatamode(const octave_value &val)
Definition: graphics.h:8862
octave_value get_ydata(void) const
Definition: graphics.h:9296
radio_property selectiontype
Definition: graphics.h:4064
const std::list< graphics_handle > get_dependent_obj_list(void)
Definition: graphics.h:11420
radio_property xscale
Definition: graphics.h:5342
void set_ygrid(const octave_value &val)
Definition: graphics.h:6472
Matrix get_edgecolor_rgb(void) const
Definition: graphics.h:7915
bool marker_is(const std::string &v) const
Definition: graphics.h:10157
Matrix get_markerfacecolor_rgb(void) const
Definition: graphics.h:10167
MArray< T > reshape(const dim_vector &new_dims) const
Definition: MArray.h:71
octave_value get_cdata(void) const
Definition: graphics.h:11701
void set_busyaction(const octave_value &val)
Definition: graphics.h:2778
bool is_numbertitle(void) const
Definition: graphics.h:4206
bool is_showhiddenhandles(void) const
Definition: graphics.h:3619
void set_fontweight(const octave_value &val)
Definition: graphics.h:12328
bool cameraviewanglemode_is(const std::string &v) const
Definition: graphics.h:5525
static bool has_readonly_property(const caseless_str &pname)
octave_scalar_map as_struct(const std::string &prefix_arg) const
Definition: graphics.cc:2118
std::string get_xminortick(void) const
Definition: graphics.h:5638
row_vector_property ztick
Definition: graphics.h:5370
octave_value get_x_viewporttransform(void) const
Definition: graphics.h:5742
bool do_set(const octave_value &val)
Definition: graphics.h:565
void set_layer(const octave_value &val)
Definition: graphics.h:6092
std::string get_displayname(void) const
Definition: graphics.h:10118
void set_clim(const octave_value &val)
Definition: graphics.h:8760
void set_positionmode(const octave_value &val)
Definition: graphics.h:8320
any_property xticklabel
Definition: graphics.h:5344
void do_lock(void)
Definition: graphics.h:13529
std::string get_xliminclude(void) const
Definition: graphics.h:7434
double double_value(bool frc_str_conv=false) const
Definition: ov.h:759
void set_currentobject(const octave_value &val)
Definition: graphics.h:4377
octave_idx_type cols(void) const
Definition: Array.h:321
bool edgecolor_is_rgb(void) const
Definition: graphics.h:9228
octave_value get_markerfacecolor(void) const
Definition: graphics.h:9277
void set_zcolor(const octave_value &val)
Definition: graphics.h:6592
base_properties & get_properties(void)
Definition: graphics.h:13046
void set_ambientlightcolor(const octave_value &val)
Definition: graphics.h:5792
bool is___modified__(void) const
Definition: graphics.h:2761
octave_value get_buttondownfcn(void) const
Definition: graphics.h:4156
bool markerfacecolor_is(const std::string &v) const
Definition: graphics.h:7409
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:7218
octave_value get_value(void) const
Definition: graphics.h:11757
std::string get_zliminclude(void) const
Definition: graphics.h:7440
bool valid_object(void) const
Definition: graphics.h:11394
bool valid_object(void) const
Definition: graphics.h:12444
std::string graphics_object_name(void) const
Definition: graphics.h:4004
void erase(iterator it)
Definition: graphics.h:2063
bool highlightcolor_is_rgb(void) const
Definition: graphics.h:12225
octave_value get_keypressfcn(void) const
Definition: graphics.h:4191
void set_xdatasource(const octave_value &val)
Definition: graphics.h:7565
std::string get_nextplot(void) const
Definition: graphics.h:5582
graphics_object & operator=(const graphics_object &obj)
Definition: graphics.h:3243
color_property backgroundcolor
Definition: graphics.h:11633
radio_property paperunits
Definition: graphics.h:4055
static void initialize(void)
Definition: mkoctfile.cc:111
graphics_handle get_handle(void) const
Definition: graphics.h:3079
double get_linewidth(void) const
Definition: graphics.h:9264
string_property xdisplay
Definition: graphics.h:4076
bool_property yliminclude
Definition: graphics.h:9154
bool facelighting_is(const std::string &v) const
Definition: graphics.h:10146
bool is_yliminclude(void) const
Definition: graphics.h:7973
base_scaler * clone(void) const
Definition: graphics.h:187
void adopt(const graphics_handle &h)
Definition: graphics.h:11153
Matrix get_highlightcolor_rgb(void) const
Definition: graphics.h:12227
void set_oncallback(const octave_value &val)
Definition: graphics.h:12982
std::string get_cdatasource(void) const
Definition: graphics.h:10114
string_property accelerator
Definition: graphics.h:11210
scaler(const scaler &s)
Definition: graphics.h:203
std::string get_name(void) const
Definition: graphics.h:295
radio_property linestyle
Definition: graphics.h:10019
base_properties & get_properties(void)
Definition: graphics.h:4969
OCTINTERP_API bool validate(const octave_value &v) const
Definition: graphics.cc:1570
bool has_readonly_property(const caseless_str &pname) const
Definition: graphics.h:9922
virtual bool has_property(const caseless_str &) const
Definition: graphics.h:2526
void update_facevertexcdata(void)
Definition: graphics.h:9849
octave_value get_alim(void) const
Definition: graphics.h:8622
std::string get_paperpositionmode(void) const
Definition: graphics.h:4217
row_vector_property & operator=(const octave_value &val)
Definition: graphics.h:1471
octave_value get___guidata__(void) const
Definition: graphics.h:4304
string_property displayname
Definition: graphics.h:8564
void set_edgealpha(const octave_value &val)
Definition: graphics.h:10323
handle_property ylabel
Definition: graphics.h:5351
double get_pointerwindow(void) const
Definition: graphics.h:3609
const scaler & get_z_scaler(void) const
Definition: graphics.h:5091
void update_axis_limits(const std::string &axis_type, const graphics_handle &h)
Definition: graphics.h:3389
double get_max(void) const
Definition: graphics.h:11737
properties xproperties
Definition: graphics.h:11381
array_property ticklength
Definition: graphics.h:5328
array_property alphadata
Definition: graphics.h:8560
bool ydir_is(const std::string &v) const
Definition: graphics.h:5661
Matrix get_transform_zlim(void) const
Definition: graphics.h:5134
Matrix xform_inv
Definition: graphics.h:5066
bool do_remove_child(double child)
Definition: graphics.h:1801
octave_value as_octave_value(void) const
Definition: oct-handle.h:72
array_property cdata
Definition: graphics.h:10006
bool is_yminortick(void) const
Definition: graphics.h:5677
void update_ydata(void)
Definition: graphics.h:9871
plist_map_const_iterator find(const std::string &go_name) const
Definition: graphics.h:2102
bool is_inverthardcopy(void) const
Definition: graphics.h:4187
std::string get_fontangle(void) const
Definition: graphics.h:11712
void set_margin(const octave_value &val)
Definition: graphics.h:8175
bool markeredgecolor_is(const std::string &v) const
Definition: graphics.h:7404
void set_backgroundcolor(const octave_value &val)
Definition: graphics.h:7995
bool meshstyle_is(const std::string &v) const
Definition: graphics.h:10172
octave_value get_ylim(void) const
Definition: graphics.h:10204
base_property(void)
Definition: graphics.h:278
octave_value callback
Definition: graphics.h:1872
bool is_zliminclude(void) const
Definition: graphics.h:10961
bool_property xliminclude
Definition: graphics.h:9153
void update_plotboxaspectratio(void)
Definition: graphics.h:6903
std::string get_fontname(void) const
Definition: graphics.h:5553
octave_value get_backgroundcolor(void) const
Definition: graphics.h:7904
bool is_zliminclude(void) const
Definition: graphics.h:3433
void set_uicontextmenu(const octave_value &val)
Definition: graphics.h:2899
void set_edgelighting(const octave_value &val)
Definition: graphics.h:9424
void execute_resizefcn(const octave_value &data=octave_value()) const
Definition: graphics.h:12232
void set_vertexnormals(const octave_value &val)
Definition: graphics.h:9635
void set_markerfacecolor(const octave_value &val)
Definition: graphics.h:9569
graphics_event(void)
Definition: graphics.h:13097
any_property __rotate_mode__
Definition: graphics.h:4081
void set_camerapositionmode(const octave_value &val)
Definition: graphics.h:5829
std::string get_cameratargetmode(void) const
Definition: graphics.h:5516
void build_user_defaults_map(property_list::pval_map_type &def, const std::string go_name) const
Definition: graphics.h:3275
octave_value get_highlightcolor(void) const
Definition: graphics.h:12228
text_label_property(const std::string &s, const graphics_handle &h, const std::string &val="")
Definition: graphics.h:684
void set_tag(const octave_value &val)
Definition: graphics.h:2567
void set_cdatamapping(const octave_value &val)
Definition: graphics.h:8680
scaler(const std::string &s)
Definition: graphics.h:205
radio_property cdatamapping
Definition: graphics.h:8563
void set_nextplot(const octave_value &val)
Definition: graphics.h:6139
std::string get_displayname(void) const
Definition: graphics.h:10934
void update_xaxislocation(void)
Definition: graphics.h:6913
bool do_set(const octave_value &v)
Definition: graphics.h:1488
void set_xliminclude(const octave_value &val)
Definition: graphics.h:8825
octave_value get_zdata(void) const
Definition: graphics.h:9298
bool do_set(const octave_value &val)
Definition: graphics.h:454
void lock(void)
Definition: oct-mutex.h:83
std::string get_edgelighting(void) const
Definition: graphics.h:10131
int get_id(void) const
Definition: graphics.h:309
void set_ylim(const octave_value &val)
Definition: graphics.h:10653
static bool has_readonly_property(const caseless_str &pname)
callback_property resizefcn
Definition: graphics.h:12166
octave_value get_facevertexcdata(void) const
Definition: graphics.h:9256
std::string get_displayname(void) const
Definition: graphics.h:7387
bool_property zgrid
Definition: graphics.h:5363
void override_defaults(void)
Definition: graphics.h:3270
const uint8NDArray & get_pixels(void) const
Definition: graphics.h:8393
std::list< octave_value > zoom_stack
Definition: graphics.h:5214
void set_shadowcolor(const octave_value &val)
Definition: graphics.h:12383
static bool has_readonly_property(const caseless_str &pname)
any_property __object__
Definition: graphics.h:12514
bool is_aliminclude(void) const
Definition: graphics.h:8495
array_property x_normrendertransform
Definition: graphics.h:5380
void set_label(const octave_value &val)
Definition: graphics.h:11330
std::string get_climinclude(void) const
Definition: graphics.h:9059
const base_properties & get_properties(void) const
Definition: graphics.h:12604
row_vector_property ydata
Definition: graphics.h:8567
radio_property fontangle
Definition: graphics.h:7833
bool color_is(const std::string &v) const
Definition: graphics.h:5534
base_properties & get_properties(void)
Definition: graphics.h:12802
std::string graphics_object_name(void) const
Definition: graphics.h:12490
void set_yticklabelmode(const octave_value &val)
Definition: graphics.h:6568
static void lock(void)
Definition: graphics.h:13268
bool yticklabelmode_is(const std::string &v) const
Definition: graphics.h:5687
radio_property layer
Definition: graphics.h:5315
children_property(const children_property &p)
Definition: graphics.h:1644
void set_facealpha(const octave_value &val)
Definition: graphics.h:9446
bool is_zgrid(void) const
Definition: graphics.h:5701
double unscale(double d) const
Definition: graphics.h:184
void set_yliminclude(const octave_value &val)
Definition: graphics.h:9798
void execute_windowkeypressfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:4266
bool valid_object(void) const
Definition: graphics.h:10820
octave_value get(void) const
Definition: graphics.h:1267
octave_idx_type columns(void) const
Definition: Array.h:322
double get_ztickoffset(void) const
Definition: graphics.h:5165
static bool is_handle_visible(const graphics_handle &h)
Definition: graphics.cc:9789
Matrix get_all(void) const
Definition: graphics.h:1678
bool style_is(const std::string &v) const
Definition: graphics.h:11749
void update_dataaspectratiomode(void)
Definition: graphics.h:6902
bool_property zminortick
Definition: graphics.h:5368
static void set_format(double d, int &fw)
Definition: pr-output.cc:651
children_property(void)
Definition: graphics.h:1631
octave_value get_zdata(void) const
Definition: graphics.h:10194
bool is_xliminclude(void) const
Definition: graphics.h:3427
callback_property keypressfcn
Definition: graphics.h:4042
plist_map_type::const_iterator plist_map_const_iterator
Definition: graphics.h:2080
Matrix get_canvas_size(const graphics_handle &fh) const
Definition: graphics.h:2252
static bool has_readonly_property(const caseless_str &pname)
std::string get_displayname(void) const
Definition: graphics.h:7911
line(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:7720
void set_erasemode(const octave_value &val)
Definition: graphics.h:7465
void set_hittest(const octave_value &val)
Definition: graphics.h:2855
radio_property cdatamapping
Definition: graphics.h:10007
void set_selectiontype(const octave_value &val)
Definition: graphics.h:4660
array_property x_viewporttransform
Definition: graphics.h:5379
bool has_bad_data(std::string &msg) const
Definition: graphics.h:9046
octave_value get_windowbuttondownfcn(void) const
Definition: graphics.h:4258
void set_vertexnormals(const octave_value &val)
Definition: graphics.h:10533
void xform(ColumnVector &v, const Matrix &m)
Definition: graphics.cc:5293
image(const graphics_handle &mh, const graphics_handle &p)
Definition: graphics.h:9011
void set_cdatamapping(const octave_value &val)
Definition: graphics.h:10277
static graphics_handle current_figure(void)
Definition: graphics.h:13256
bool facecolor_is_rgb(void) const
Definition: graphics.h:10141
void set_units(const octave_value &val)
Definition: graphics.h:8214
double get_zPlane(void) const
Definition: graphics.h:5143
radio_property enable
Definition: graphics.h:11637
octave_value get_color(void) const
Definition: graphics.h:7909
bool is_linear(void) const
Definition: graphics.h:226
bool facelighting_is(const std::string &v) const
Definition: graphics.h:9249
void set_from_list(base_graphics_object &obj, property_list &defaults)
Definition: graphics.cc:2877
bool color_is(const std::string &v) const
Definition: graphics.h:4162
void do_unload_all_toolkits(void)
Definition: graphics.h:2451
static std::string go_name
Definition: graphics.h:8541
std::string get_linestyle(void) const
Definition: graphics.h:7396
void set(const caseless_str &name, const octave_value &value)
Definition: graphics.h:12567
bool activepositionproperty_is(const std::string &v) const
Definition: graphics.h:5492
void update_vertexnormals(void)
Definition: graphics.h:10802
graphics_handle get_ylabel(void) const
Definition: graphics.h:5667
double scale(double d) const
Definition: graphics.h:141
void update_transform(void)
Definition: graphics.h:5112
string_property language
Definition: graphics.h:3542
bool set_property_in_handle(double handle, const std::string &property, const octave_value &arg, const std::string &func)
Definition: graphics.cc:11664
bool_property zliminclude
Definition: graphics.h:10914
graphics_handle handle_value(void) const
Definition: graphics.h:1568
void update_positionmode(void)
Definition: graphics.h:8435
void set_buttondownfcn(const octave_value &val)
Definition: graphics.h:2789
string_property errormessage
Definition: graphics.h:3538
void set(const caseless_str &name, const octave_value &value)
Definition: graphics.h:7203
double_property(const std::string &nm, const graphics_handle &h, double d=0)
Definition: graphics.h:1194
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:9502
void set_currentcharacter(const octave_value &val)
Definition: graphics.h:4366
color_property(const color_property &p)
Definition: graphics.h:1128
double get_fontsize(void) const
Definition: graphics.h:7931
void set_plotboxaspectratiomode(const octave_value &val)
Definition: graphics.h:6178
any_property yticklabel
Definition: graphics.h:5358
bool is_selected(void) const
Definition: graphics.h:2744
bool horizontalalignmentmode_is(const std::string &v) const
Definition: graphics.h:7985
static void post_set(const graphics_handle &h, const std::string &name, const octave_value &value, bool notify_toolkit=true)
Definition: graphics.h:13343
color_property facecolor
Definition: graphics.h:10016
F77_RET_T const double * x
void set_linestyle(const octave_value &val)
Definition: graphics.h:8153
std::string get_plotboxaspectratiomode(void) const
Definition: graphics.h:5589
radio_property units
Definition: graphics.h:12170
charNDArray min(char d, const charNDArray &m)
Definition: chNDArray.cc:210
Matrix get_foregroundcolor_rgb(void) const
Definition: graphics.h:11251
octave_value get_xlim(void) const
Definition: graphics.h:10943
color_property facecolor
Definition: graphics.h:9125
void set_zliminclude(const octave_value &val)
Definition: graphics.h:10731
void set_markeredgecolor(const octave_value &val)
Definition: graphics.h:9558
void set_yliminclude(const octave_value &val)
Definition: graphics.h:11075
bool get_x2Dtop(void) const
Definition: graphics.h:5166
octave_value get_commandwindowsize(void) const
Definition: graphics.h:3581
void do_init_children(const std::list< double > &val)
Definition: graphics.h:1781
std::string get_zdatasource(void) const
Definition: graphics.h:10196
OCTINTERP_API bool do_set(const octave_value &v)
Definition: graphics.cc:1474
OCTINTERP_API void get_data_limits(void)
Definition: graphics.cc:1434
void set_zlim(const octave_value &val)
Definition: graphics.h:8268
void set(const caseless_str &name, const octave_value &value)
Definition: graphics.h:3805
void execute_keypressfcn(const octave_value &data=octave_value()) const
Definition: graphics.h:11732
Matrix get_facecolor_rgb(void) const
Definition: graphics.h:9246
void set_zmtick(const octave_value &val)
Definition: graphics.h:6846
void set_climinclude(const octave_value &val)
Definition: graphics.h:10692
graphics_xform(const graphics_xform &g)
Definition: graphics.h:5006
octave_value get_clickedcallback(void) const
Definition: graphics.h:12907
octave_value get_color(void) const
Definition: graphics.h:5536
double_property pointerwindow
Definition: graphics.h:3545
octave_value get_yticklabel(void) const
Definition: graphics.h:5685
base_property * clone(void) const
Definition: graphics.h:1306
Matrix get_color_rgb(void) const
Definition: graphics.h:7908
bool color_is_rgb(void) const
Definition: graphics.h:4161
octave_value get_xtick(void) const
Definition: graphics.h:5643
double_property linewidth
Definition: graphics.h:9132
void set_ydir(const octave_value &val)
Definition: graphics.h:6460
void execute_clickedcallback(const octave_value &data=octave_value()) const
Definition: graphics.h:12704
radio_property bordertype
Definition: graphics.h:12156
bool is_xgrid(void) const
Definition: graphics.h:5624
static int process_events(void)
Definition: graphics.h:13350
neg_log_scaler(void)
Definition: graphics.h:161
void set_windowkeyreleasefcn(const octave_value &val)
Definition: graphics.h:4728
octave_value get_pointershapehotspot(void) const
Definition: graphics.h:4232
std::string get_horizontalalignmentmode(void) const
Definition: graphics.h:7986
property_list default_properties
Definition: graphics.h:3893
octave_value get_position(void) const
Definition: graphics.h:12230
void set_colororder(const octave_value &val)
Definition: graphics.h:5957
T::properties & properties(graphics_object obj)
radio_property camerapositionmode
Definition: graphics.h:5293
bool horizontalalignment_is(const std::string &v) const
Definition: graphics.h:7939
array_property position
Definition: graphics.h:12165
plist_map_type::iterator plist_map_iterator
Definition: graphics.h:2079
void unlock(void)
Definition: oct-mutex.h:88
row_vector_property xtick
Definition: graphics.h:5343
double_property rotation
Definition: graphics.h:7844
row_vector_property alim
Definition: graphics.h:8568
radio_property xticklabelmode
Definition: graphics.h:5345