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 
4829  void