Mercurial > octave-nkf

comparison src/graphics.cc @ 7189:e8d953d03f6a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2007-11-26 20:42:09 by dbateman]
author dbateman
date Mon, 26 Nov 2007 20:42:11 +0000
parents 6525eb2fba0f
children a927a2871a93
comparison
equal deleted inserted replaced
7188:fdd7cd70dc14 7189:e8d953d03f6a
217 return *this; 217 return *this;
218 } 218 }
219 219
220 220
221 void 221 void
222 property_list::set (const property_name& name, const octave_value& val) 222 property_list::set (const caseless_str& name, const octave_value& val)
223 { 223 {
224 size_t offset = 0; 224 size_t offset = 0;
225 225
226 size_t len = name.length (); 226 size_t len = name.length ();
227 227
228 if (len > 4) 228 if (len > 4)
229 { 229 {
230 property_name pfx = name.substr (0, 4); 230 caseless_str pfx = name.substr (0, 4);
231 231
232 if (pfx.compare ("axes") || pfx.compare ("line") 232 if (pfx.compare ("axes") || pfx.compare ("line")
233 || pfx.compare ("text")) 233 || pfx.compare ("text"))
234 offset = 4; 234 offset = 4;
235 else if (len > 5) 235 else if (len > 5)
264 std::transform (pname.begin (), pname.end (), pname.begin (), tolower); 264 std::transform (pname.begin (), pname.end (), pname.begin (), tolower);
265 265
266 bool remove = false; 266 bool remove = false;
267 if (val.is_string ()) 267 if (val.is_string ())
268 { 268 {
269 property_name tval = val.string_value (); 269 caseless_str tval = val.string_value ();
270 270
271 remove = tval.compare ("remove"); 271 remove = tval.compare ("remove");
272 } 272 }
273 273
274 pval_map_type& pval_map = plist_map[pfx]; 274 pval_map_type& pval_map = plist_map[pfx];
288 if (offset == 0) 288 if (offset == 0)
289 error ("invalid default property specification"); 289 error ("invalid default property specification");
290 } 290 }
291 291
292 octave_value 292 octave_value
293 property_list::lookup (const property_name& name) const 293 property_list::lookup (const caseless_str& name) const
294 { 294 {
295 octave_value retval; 295 octave_value retval;
296 296
297 size_t offset = 0; 297 size_t offset = 0;
298 298
299 size_t len = name.length (); 299 size_t len = name.length ();
300 300
301 if (len > 4) 301 if (len > 4)
302 { 302 {
303 property_name pfx = name.substr (0, 4); 303 caseless_str pfx = name.substr (0, 4);
304 304
305 if (pfx.compare ("axes") || pfx.compare ("line") 305 if (pfx.compare ("axes") || pfx.compare ("line")
306 || pfx.compare ("text")) 306 || pfx.compare ("text"))
307 offset = 4; 307 offset = 4;
308 else if (len > 5) 308 else if (len > 5)
396 rep->defaults (); 396 rep->defaults ();
397 else if (nargin % 2 == 0) 397 else if (nargin % 2 == 0)
398 { 398 {
399 for (int i = 0; i < nargin; i += 2) 399 for (int i = 0; i < nargin; i += 2)
400 { 400 {
401 property_name name = args(i).string_value (); 401 caseless_str name = args(i).string_value ();
402 402
403 if (! error_state) 403 if (! error_state)
404 { 404 {
405 octave_value val = args(i+1); 405 octave_value val = args(i+1);
406 406
407 if (val.is_string ()) 407 if (val.is_string ())
408 { 408 {
409 property_name tval = val.string_value (); 409 caseless_str tval = val.string_value ();
410 410
411 if (tval.compare ("default")) 411 if (tval.compare ("default"))
412 val = get_default (name); 412 val = get_default (name);
413 else if (tval.compare ("factory")) 413 else if (tval.compare ("factory"))
414 val = get_factory_default (name); 414 val = get_factory_default (name);
483 } 483 }
484 484
485 gh_manager *gh_manager::instance = 0; 485 gh_manager *gh_manager::instance = 0;
486 486
487 static void 487 static void
488 xset (const graphics_handle& h, const property_name& name, 488 xset (const graphics_handle& h, const caseless_str& name,
489 const octave_value& val) 489 const octave_value& val)
490 { 490 {
491 graphics_object obj = gh_manager::get_object (h); 491 graphics_object obj = gh_manager::get_object (h);
492 obj.set (name, val); 492 obj.set (name, val);
493 } 493 }
502 } 502 }
503 } 503 }
504 504
505 505
506 static octave_value 506 static octave_value
507 xget (const graphics_handle& h, const property_name& name) 507 xget (const graphics_handle& h, const caseless_str& name)
508 { 508 {
509 graphics_object obj = gh_manager::get_object (h); 509 graphics_object obj = gh_manager::get_object (h);
510 return obj.get (name); 510 return obj.get (name);
511 } 511 }
512 512
782 else 782 else
783 gripe_set_invalid ("currentfigure"); 783 gripe_set_invalid ("currentfigure");
784 } 784 }
785 785
786 void 786 void
787 root_figure::properties::set (const property_name& name, 787 root_figure::properties::set (const caseless_str& name,
788 const octave_value& val) 788 const octave_value& val)
789 { 789 {
790 if (name.compare ("tag")) 790 if (name.compare ("tag"))
791 set_tag (val); 791 set_tag (val);
792 else if (name.compare ("currentfigure")) 792 else if (name.compare ("currentfigure"))
811 811
812 return m; 812 return m;
813 } 813 }
814 814
815 octave_value 815 octave_value
816 root_figure::properties::get (const property_name& name) const 816 root_figure::properties::get (const caseless_str& name) const
817 { 817 {
818 octave_value retval; 818 octave_value retval;
819 819
820 if (name.compare ("tag")) 820 if (name.compare ("tag"))
821 retval = type; 821 retval = type;
842 842
843 figure::properties::properties (const graphics_handle& mh, 843 figure::properties::properties (const graphics_handle& mh,
844 const graphics_handle& p) 844 const graphics_handle& p)
845 : base_properties (go_name, mh, p), 845 : base_properties (go_name, mh, p),
846 __plot_stream__ (Matrix ()), 846 __plot_stream__ (Matrix ()),
847 __enhanced__ (false),
847 nextplot ("replace"), 848 nextplot ("replace"),
848 closerequestfcn (make_fcn_handle ("closereq")), 849 closerequestfcn (make_fcn_handle ("closereq")),
849 currentaxes (octave_NaN), 850 currentaxes (octave_NaN),
850 colormap (), 851 colormap (),
851 visible ("on"), 852 visible ("on"),
877 visible = val; 878 visible = val;
878 } 879 }
879 } 880 }
880 881
881 void 882 void
882 figure::properties::set (const property_name& name, const octave_value& val) 883 figure::properties::set (const caseless_str& name, const octave_value& val)
883 { 884 {
884 bool modified = true; 885 bool modified = true;
885 886
886 if (name.compare ("tag")) 887 if (name.compare ("tag"))
887 set_tag (val); 888 set_tag (val);
892 __modified__ = val.bool_value (); 893 __modified__ = val.bool_value ();
893 modified = false; 894 modified = false;
894 } 895 }
895 else if (name.compare ("__plot_stream__")) 896 else if (name.compare ("__plot_stream__"))
896 set___plot_stream__ (val); 897 set___plot_stream__ (val);
898 else if (name.compare ("__enhanced__"))
899 set___enhanced__ (val);
897 else if (name.compare ("nextplot")) 900 else if (name.compare ("nextplot"))
898 set_nextplot (val); 901 set_nextplot (val);
899 else if (name.compare ("closerequestfcn")) 902 else if (name.compare ("closerequestfcn"))
900 set_closerequestfcn (val); 903 set_closerequestfcn (val);
901 else if (name.compare ("currentaxes")) 904 else if (name.compare ("currentaxes"))
925 m.assign ("type", type); 928 m.assign ("type", type);
926 m.assign ("parent", parent.as_octave_value ()); 929 m.assign ("parent", parent.as_octave_value ());
927 m.assign ("children", children); 930 m.assign ("children", children);
928 m.assign ("__modified__", __modified__); 931 m.assign ("__modified__", __modified__);
929 m.assign ("__plot_stream__", __plot_stream__); 932 m.assign ("__plot_stream__", __plot_stream__);
933 m.assign ("__enhanced__", __enhanced__);
930 m.assign ("nextplot", nextplot); 934 m.assign ("nextplot", nextplot);
931 m.assign ("closerequestfcn", closerequestfcn); 935 m.assign ("closerequestfcn", closerequestfcn);
932 m.assign ("currentaxes", currentaxes.as_octave_value ()); 936 m.assign ("currentaxes", currentaxes.as_octave_value ());
933 m.assign ("colormap", colormap); 937 m.assign ("colormap", colormap);
934 m.assign ("visible", visible); 938 m.assign ("visible", visible);
936 940
937 return m; 941 return m;
938 } 942 }
939 943
940 octave_value 944 octave_value
941 figure::properties::get (const property_name& name) const 945 figure::properties::get (const caseless_str& name) const
942 { 946 {
943 octave_value retval; 947 octave_value retval;
944 948
945 if (name.compare ("tag")) 949 if (name.compare ("tag"))
946 retval = tag; 950 retval = tag;
952 retval = children; 956 retval = children;
953 else if (name.compare ("__modified__")) 957 else if (name.compare ("__modified__"))
954 retval = __modified__; 958 retval = __modified__;
955 else if (name.compare ("__plot_stream__")) 959 else if (name.compare ("__plot_stream__"))
956 retval = __plot_stream__; 960 retval = __plot_stream__;
961 else if (name.compare ("__enhanced__"))
962 retval = __enhanced__;
957 else if (name.compare ("nextplot")) 963 else if (name.compare ("nextplot"))
958 retval = nextplot; 964 retval = nextplot;
959 else if (name.compare ("closerequestfcn")) 965 else if (name.compare ("closerequestfcn"))
960 retval = closerequestfcn; 966 retval = closerequestfcn;
961 else if (name.compare ("currentaxes")) 967 else if (name.compare ("currentaxes"))
1006 1012
1007 return m; 1013 return m;
1008 } 1014 }
1009 1015
1010 octave_value 1016 octave_value
1011 figure::get_default (const property_name& name) const 1017 figure::get_default (const caseless_str& name) const
1012 { 1018 {
1013 octave_value retval = default_properties.lookup (name); 1019 octave_value retval = default_properties.lookup (name);
1014 1020
1015 if (retval.is_undefined ()) 1021 if (retval.is_undefined ())
1016 { 1022 {
1104 xaxislocation ("bottom"), 1110 xaxislocation ("bottom"),
1105 yaxislocation ("left"), 1111 yaxislocation ("left"),
1106 view (), 1112 view (),
1107 visible ("on"), 1113 visible ("on"),
1108 nextplot ("replace"), 1114 nextplot ("replace"),
1109 outerposition () 1115 outerposition (),
1116 __colorbar__ (radio_values ("{none}|north|south|east|west|northoutside|southoutside|eastoutside|westoutside"))
1110 { 1117 {
1111 Matrix tlim (1, 2, 0.0); 1118 Matrix tlim (1, 2, 0.0);
1112 tlim(1) = 1; 1119 tlim(1) = 1;
1113 xlim = tlim; 1120 xlim = tlim;
1114 ylim = tlim; 1121 ylim = tlim;
1190 { 1197 {
1191 set_zlabel (::reparent (val, "set", "zlabel", __myhandle__, false)); 1198 set_zlabel (::reparent (val, "set", "zlabel", __myhandle__, false));
1192 } 1199 }
1193 1200
1194 void 1201 void
1195 axes::properties::set (const property_name& name, const octave_value& val) 1202 axes::properties::set (const caseless_str& name, const octave_value& val)
1196 { 1203 {
1197 bool modified = true; 1204 bool modified = true;
1198 1205
1199 if (name.compare ("tag")) 1206 if (name.compare ("tag"))
1200 set_tag (val); 1207 set_tag (val);
1305 set_visible (val); 1312 set_visible (val);
1306 else if (name.compare ("nextplot")) 1313 else if (name.compare ("nextplot"))
1307 set_nextplot (val); 1314 set_nextplot (val);
1308 else if (name.compare ("outerposition")) 1315 else if (name.compare ("outerposition"))
1309 set_outerposition (val); 1316 set_outerposition (val);
1317 else if (name.compare ("__colorbar__"))
1318 set___colorbar__ (val);
1310 else 1319 else
1311 { 1320 {
1312 modified = false; 1321 modified = false;
1313 warning ("set: invalid property `%s'", name.c_str ()); 1322 warning ("set: invalid property `%s'", name.c_str ());
1314 } 1323 }
1390 Matrix touterposition (1, 4, 0.0); 1399 Matrix touterposition (1, 4, 0.0);
1391 touterposition(2) = 1; 1400 touterposition(2) = 1;
1392 touterposition(3) = 1; 1401 touterposition(3) = 1;
1393 outerposition = touterposition; 1402 outerposition = touterposition;
1394 } 1403 }
1404
1405 __colorbar__ = radio_property (radio_values ("{none}|north|south|east|west|northoutside|southoutside|eastoutside|westoutside"));
1395 1406
1396 delete_children (); 1407 delete_children ();
1397 1408
1398 children = Matrix (); 1409 children = Matrix ();
1399 1410
1494 m.assign ("yaxislocation", yaxislocation); 1505 m.assign ("yaxislocation", yaxislocation);
1495 m.assign ("view", view); 1506 m.assign ("view", view);
1496 m.assign ("visible", visible); 1507 m.assign ("visible", visible);
1497 m.assign ("nextplot", nextplot); 1508 m.assign ("nextplot", nextplot);
1498 m.assign ("outerposition", outerposition); 1509 m.assign ("outerposition", outerposition);
1510 m.assign ("__colorbar__", __colorbar__);
1499 1511
1500 return m; 1512 return m;
1501 } 1513 }
1502 1514
1503 octave_value 1515 octave_value
1504 axes::properties::get (const property_name& name) const 1516 axes::properties::get (const caseless_str& name) const
1505 { 1517 {
1506 octave_value retval; 1518 octave_value retval;
1507 1519
1508 if (name.compare ("tag")) 1520 if (name.compare ("tag"))
1509 retval = tag; 1521 retval = tag;
1613 retval = visible; 1625 retval = visible;
1614 else if (name.compare ("nextplot")) 1626 else if (name.compare ("nextplot"))
1615 retval = nextplot; 1627 retval = nextplot;
1616 else if (name.compare ("outerposition")) 1628 else if (name.compare ("outerposition"))
1617 retval = outerposition; 1629 retval = outerposition;
1630 else if (name.compare ("__colorbar__"))
1631 retval = __colorbar__;
1618 else 1632 else
1619 warning ("get: invalid property `%s'", name.c_str ()); 1633 warning ("get: invalid property `%s'", name.c_str ());
1620 1634
1621 return retval; 1635 return retval;
1622 } 1636 }
1719 Matrix touterposition (1, 4, 0.0); 1733 Matrix touterposition (1, 4, 0.0);
1720 touterposition(2) = 1; 1734 touterposition(2) = 1;
1721 touterposition(3) = 1; 1735 touterposition(3) = 1;
1722 1736
1723 m["outerposition"] = touterposition; 1737 m["outerposition"] = touterposition;
1738 m["__colorbar__"] = radio_property (radio_values ("{none}|north|south|east|west|northoutside|southoutside|eastoutside|westoutside"));
1724 1739
1725 return m; 1740 return m;
1726 } 1741 }
1727 1742
1728 octave_value 1743 octave_value
1729 axes::get_default (const property_name& name) const 1744 axes::get_default (const caseless_str& name) const
1730 { 1745 {
1731 octave_value retval = default_properties.lookup (name); 1746 octave_value retval = default_properties.lookup (name);
1732 1747
1733 if (retval.is_undefined ()) 1748 if (retval.is_undefined ())
1734 { 1749 {
1771 linewidth (0.5), 1786 linewidth (0.5),
1772 marker ("none"), 1787 marker ("none"),
1773 markeredgecolor ("auto"), 1788 markeredgecolor ("auto"),
1774 markerfacecolor ("none"), 1789 markerfacecolor ("none"),
1775 markersize (1), 1790 markersize (1),
1776 keylabel ("") 1791 keylabel (""),
1792 interpreter (radio_values ("{tex}|none|latex"))
1777 { } 1793 { }
1778 1794
1779 void 1795 void
1780 line::properties::set (const property_name& name, const octave_value& val) 1796 line::properties::set (const caseless_str& name, const octave_value& val)
1781 { 1797 {
1782 bool modified = true; 1798 bool modified = true;
1783 1799
1784 if (name.compare ("tag")) 1800 if (name.compare ("tag"))
1785 set_tag (val); 1801 set_tag (val);
1820 set_markerfacecolor (val); 1836 set_markerfacecolor (val);
1821 else if (name.compare ("markersize")) 1837 else if (name.compare ("markersize"))
1822 set_markersize (val); 1838 set_markersize (val);
1823 else if (name.compare ("keylabel")) 1839 else if (name.compare ("keylabel"))
1824 set_keylabel (val); 1840 set_keylabel (val);
1841 else if (name.compare ("interpreter"))
1842 set_interpreter (val);
1825 else 1843 else
1826 { 1844 {
1827 modified = false; 1845 modified = false;
1828 warning ("set: invalid property `%s'", name.c_str ()); 1846 warning ("set: invalid property `%s'", name.c_str ());
1829 } 1847 }
1855 m.assign ("marker", marker); 1873 m.assign ("marker", marker);
1856 m.assign ("markeredgecolor", markeredgecolor); 1874 m.assign ("markeredgecolor", markeredgecolor);
1857 m.assign ("markerfacecolor", markerfacecolor); 1875 m.assign ("markerfacecolor", markerfacecolor);
1858 m.assign ("markersize", markersize); 1876 m.assign ("markersize", markersize);
1859 m.assign ("keylabel", keylabel); 1877 m.assign ("keylabel", keylabel);
1878 m.assign ("interpreter", interpreter);
1860 1879
1861 return m; 1880 return m;
1862 } 1881 }
1863 1882
1864 octave_value 1883 octave_value
1865 line::properties::get (const property_name& name) const 1884 line::properties::get (const caseless_str& name) const
1866 { 1885 {
1867 octave_value retval; 1886 octave_value retval;
1868 1887
1869 if (name.compare ("tag")) 1888 if (name.compare ("tag"))
1870 retval = tag; 1889 retval = tag;
1904 retval = markerfacecolor; 1923 retval = markerfacecolor;
1905 else if (name.compare ("markersize")) 1924 else if (name.compare ("markersize"))
1906 retval = markersize; 1925 retval = markersize;
1907 else if (name.compare ("keylabel")) 1926 else if (name.compare ("keylabel"))
1908 retval = keylabel; 1927 retval = keylabel;
1928 else if (name.compare ("interpreter"))
1929 retval = interpreter;
1909 else 1930 else
1910 warning ("get: invalid property `%s'", name.c_str ()); 1931 warning ("get: invalid property `%s'", name.c_str ());
1911 1932
1912 return retval; 1933 return retval;
1913 } 1934 }
1930 m["marker"] = "none"; 1951 m["marker"] = "none";
1931 m["markeredgecolor"] = "auto"; 1952 m["markeredgecolor"] = "auto";
1932 m["markerfacecolor"] = "none"; 1953 m["markerfacecolor"] = "none";
1933 m["markersize"] = 1; 1954 m["markersize"] = 1;
1934 m["keylabel"] = ""; 1955 m["keylabel"] = "";
1956 m["interpreter"] =
1957 radio_property (radio_values ("{tex}|none|latex"));
1935 1958
1936 return m; 1959 return m;
1937 } 1960 }
1938 1961
1939 std::string line::properties::go_name ("line"); 1962 std::string line::properties::go_name ("line");
1950 horizontalalignment ("left"), 1973 horizontalalignment ("left"),
1951 color (Matrix (1, 3, 0.0)), 1974 color (Matrix (1, 3, 0.0)),
1952 fontname ("Helvetica"), 1975 fontname ("Helvetica"),
1953 fontsize (10), 1976 fontsize (10),
1954 fontangle (radio_values ("{normal}|italic|oblique")), 1977 fontangle (radio_values ("{normal}|italic|oblique")),
1955 fontweight (radio_values ("{normal}|bold|demi|light")) 1978 fontweight (radio_values ("{normal}|bold|demi|light")),
1979 interpreter (radio_values ("{tex}|none|latex"))
1956 { } 1980 { }
1957 1981
1958 void 1982 void
1959 text::properties::set (const property_name& name, const octave_value& val) 1983 text::properties::set (const caseless_str& name, const octave_value& val)
1960 { 1984 {
1961 bool modified = true; 1985 bool modified = true;
1962 1986
1963 if (name.compare ("tag")) 1987 if (name.compare ("tag"))
1964 set_tag (val); 1988 set_tag (val);
1989 set_fontsize (val); 2013 set_fontsize (val);
1990 else if (name.compare ("fontangle")) 2014 else if (name.compare ("fontangle"))
1991 set_fontangle (val); 2015 set_fontangle (val);
1992 else if (name.compare ("fontweight")) 2016 else if (name.compare ("fontweight"))
1993 set_fontweight (val); 2017 set_fontweight (val);
2018 else if (name.compare ("interpreter"))
2019 set_interpreter (val);
1994 else 2020 else
1995 { 2021 {
1996 modified = false; 2022 modified = false;
1997 warning ("set: invalid property `%s'", name.c_str ()); 2023 warning ("set: invalid property `%s'", name.c_str ());
1998 } 2024 }
2019 m.assign ("color", color); 2045 m.assign ("color", color);
2020 m.assign ("fontname", fontname); 2046 m.assign ("fontname", fontname);
2021 m.assign ("fontsize", fontsize); 2047 m.assign ("fontsize", fontsize);
2022 m.assign ("fontangle", fontangle); 2048 m.assign ("fontangle", fontangle);
2023 m.assign ("fontweight", fontweight); 2049 m.assign ("fontweight", fontweight);
2050 m.assign ("interpreter", interpreter);
2024 2051
2025 return m; 2052 return m;
2026 } 2053 }
2027 2054
2028 octave_value 2055 octave_value
2029 text::properties::get (const property_name& name) const 2056 text::properties::get (const caseless_str& name) const
2030 { 2057 {
2031 octave_value retval; 2058 octave_value retval;
2032 2059
2033 if (name.compare ("tag")) 2060 if (name.compare ("tag"))
2034 retval = tag; 2061 retval = tag;
2058 retval = fontsize; 2085 retval = fontsize;
2059 else if (name.compare ("fontangle")) 2086 else if (name.compare ("fontangle"))
2060 retval = fontangle; 2087 retval = fontangle;
2061 else if (name.compare ("fontweight")) 2088 else if (name.compare ("fontweight"))
2062 retval = fontweight; 2089 retval = fontweight;
2090 else if (name.compare ("interpreter"))
2091 retval = interpreter;
2063 else 2092 else
2064 warning ("get: invalid property `%s'", name.c_str ()); 2093 warning ("get: invalid property `%s'", name.c_str ());
2065 2094
2066 return retval; 2095 return retval;
2067 } 2096 }
2078 m["horizontalalignment"] = "left"; 2107 m["horizontalalignment"] = "left";
2079 m["color"] = Matrix (1, 3, 1.0); 2108 m["color"] = Matrix (1, 3, 1.0);
2080 m["fontname"] = "Helvetica"; 2109 m["fontname"] = "Helvetica";
2081 m["fontsize"] = 10; 2110 m["fontsize"] = 10;
2082 m["fontangle"] = 2111 m["fontangle"] =
2083 string_property ("normal", radio_values ("{normal}|italic|oblique")); 2112 radio_property (radio_values ("{normal}|italic|oblique"));
2084 m["fontweight"] = 2113 m["fontweight"] =
2085 string_property ("normal", radio_values ("{normal}|bold|demi|light")); 2114 radio_property (radio_values ("{normal}|bold|demi|light"));
2115 m["interpreter"] =
2116 radio_property (radio_values ("{tex}|none|latex"));
2086 2117
2087 return m; 2118 return m;
2088 } 2119 }
2089 2120
2090 std::string text::properties::go_name ("text"); 2121 std::string text::properties::go_name ("text");
2098 xdata (Matrix ()), 2129 xdata (Matrix ()),
2099 ydata (Matrix ()) 2130 ydata (Matrix ())
2100 { } 2131 { }
2101 2132
2102 void 2133 void
2103 image::properties::set (const property_name& name, 2134 image::properties::set (const caseless_str& name,
2104 const octave_value& val) 2135 const octave_value& val)
2105 { 2136 {
2106 bool modified = true; 2137 bool modified = true;
2107 2138
2108 if (name.compare ("tag")) 2139 if (name.compare ("tag"))
2148 2179
2149 return m; 2180 return m;
2150 } 2181 }
2151 2182
2152 octave_value 2183 octave_value
2153 image::properties::get (const property_name& name) const 2184 image::properties::get (const caseless_str& name) const
2154 { 2185 {
2155 octave_value retval; 2186 octave_value retval;
2156 2187
2157 if (name.compare ("tag")) 2188 if (name.compare ("tag"))
2158 retval = tag; 2189 retval = tag;
2208 linewidth (0.5), 2239 linewidth (0.5),
2209 marker ("none"), 2240 marker ("none"),
2210 markeredgecolor ("auto"), 2241 markeredgecolor ("auto"),
2211 markerfacecolor ("none"), 2242 markerfacecolor ("none"),
2212 markersize (1), 2243 markersize (1),
2213 keylabel ("") 2244 keylabel (""),
2245 interpreter (radio_values ("{tex}|none|latex"))
2214 { } 2246 { }
2215 2247
2216 void 2248 void
2217 patch::properties::set (const property_name& name, 2249 patch::properties::set (const caseless_str& name,
2218 const octave_value& val) 2250 const octave_value& val)
2219 { 2251 {
2220 bool modified = true; 2252 bool modified = true;
2221 2253
2222 if (name.compare ("tag")) 2254 if (name.compare ("tag"))
2260 set_markerfacecolor (val); 2292 set_markerfacecolor (val);
2261 else if (name.compare ("markersize")) 2293 else if (name.compare ("markersize"))
2262 set_markersize (val); 2294 set_markersize (val);
2263 else if (name.compare ("keylabel")) 2295 else if (name.compare ("keylabel"))
2264 set_keylabel (val); 2296 set_keylabel (val);
2297 else if (name.compare ("interpreter"))
2298 set_interpreter (val);
2265 else 2299 else
2266 { 2300 {
2267 modified = false; 2301 modified = false;
2268 warning ("set: invalid property `%s'", name.c_str ()); 2302 warning ("set: invalid property `%s'", name.c_str ());
2269 } 2303 }
2296 m.assign ("marker", marker); 2330 m.assign ("marker", marker);
2297 m.assign ("markeredgecolor", markeredgecolor); 2331 m.assign ("markeredgecolor", markeredgecolor);
2298 m.assign ("markerface", markerfacecolor); 2332 m.assign ("markerface", markerfacecolor);
2299 m.assign ("markersize", markersize); 2333 m.assign ("markersize", markersize);
2300 m.assign ("keylabel", keylabel); 2334 m.assign ("keylabel", keylabel);
2335 m.assign ("interpreter", interpreter);
2301 2336
2302 return m; 2337 return m;
2303 } 2338 }
2304 2339
2305 octave_value 2340 octave_value
2306 patch::properties::get (const property_name& name) const 2341 patch::properties::get (const caseless_str& name) const
2307 { 2342 {
2308 octave_value retval; 2343 octave_value retval;
2309 2344
2310 if (name.compare ("tag")) 2345 if (name.compare ("tag"))
2311 retval = tag; 2346 retval = tag;
2347 retval = markerfacecolor; 2382 retval = markerfacecolor;
2348 else if (name.compare ("markersize")) 2383 else if (name.compare ("markersize"))
2349 retval = markersize; 2384 retval = markersize;
2350 else if (name.compare ("keylabel")) 2385 else if (name.compare ("keylabel"))
2351 retval = keylabel; 2386 retval = keylabel;
2387 else if (name.compare ("interpreter"))
2388 retval = interpreter;
2352 else 2389 else
2353 warning ("get: invalid property `%s'", name.c_str ()); 2390 warning ("get: invalid property `%s'", name.c_str ());
2354 2391
2355 return retval; 2392 return retval;
2356 } 2393 }
2374 m["marker"] = "none"; 2411 m["marker"] = "none";
2375 m["markeredgecolor"] = "auto"; 2412 m["markeredgecolor"] = "auto";
2376 m["markerfacecolor"] = "none"; 2413 m["markerfacecolor"] = "none";
2377 m["markersize"] = 1; 2414 m["markersize"] = 1;
2378 m["keylabel"] = ""; 2415 m["keylabel"] = "";
2416 m["interpreter"] =
2417 radio_property (radio_values ("{tex}|none|latex"));
2379 2418
2380 return m; 2419 return m;
2381 } 2420 }
2382 2421
2383 std::string patch::properties::go_name ("patch"); 2422 std::string patch::properties::go_name ("patch");
2398 linewidth (0.5), 2437 linewidth (0.5),
2399 marker ("none"), 2438 marker ("none"),
2400 markeredgecolor ("auto"), 2439 markeredgecolor ("auto"),
2401 markerfacecolor ("none"), 2440 markerfacecolor ("none"),
2402 markersize (1), 2441 markersize (1),
2403 keylabel ("") 2442 keylabel (""),
2443 interpreter (radio_values ("{tex}|none|latex"))
2404 { } 2444 { }
2405 2445
2406 void 2446 void
2407 surface::properties::set (const property_name& name, 2447 surface::properties::set (const caseless_str& name,
2408 const octave_value& val) 2448 const octave_value& val)
2409 { 2449 {
2410 bool modified = true; 2450 bool modified = true;
2411 2451
2412 if (name.compare ("tag")) 2452 if (name.compare ("tag"))
2446 set_markerfacecolor (val); 2486 set_markerfacecolor (val);
2447 else if (name.compare ("markersize")) 2487 else if (name.compare ("markersize"))
2448 set_markersize (val); 2488 set_markersize (val);
2449 else if (name.compare ("keylabel")) 2489 else if (name.compare ("keylabel"))
2450 set_keylabel (val); 2490 set_keylabel (val);
2491 else if (name.compare ("interpreter"))
2492 set_interpreter (val);
2451 else 2493 else
2452 { 2494 {
2453 modified = false; 2495 modified = false;
2454 warning ("set: invalid property `%s'", name.c_str ()); 2496 warning ("set: invalid property `%s'", name.c_str ());
2455 } 2497 }
2480 m.assign ("marker", marker); 2522 m.assign ("marker", marker);
2481 m.assign ("markeredgecolor", markeredgecolor); 2523 m.assign ("markeredgecolor", markeredgecolor);
2482 m.assign ("markerface", markerfacecolor); 2524 m.assign ("markerface", markerfacecolor);
2483 m.assign ("markersize", markersize); 2525 m.assign ("markersize", markersize);
2484 m.assign ("keylabel", keylabel); 2526 m.assign ("keylabel", keylabel);
2527 m.assign ("interpreter", interpreter);
2485 2528
2486 return m; 2529 return m;
2487 } 2530 }
2488 2531
2489 octave_value 2532 octave_value
2490 surface::properties::get (const property_name& name) const 2533 surface::properties::get (const caseless_str& name) const
2491 { 2534 {
2492 octave_value retval; 2535 octave_value retval;
2493 2536
2494 if (name.compare ("tag")) 2537 if (name.compare ("tag"))
2495 retval = tag; 2538 retval = tag;
2527 retval = markerfacecolor; 2570 retval = markerfacecolor;
2528 else if (name.compare ("markersize")) 2571 else if (name.compare ("markersize"))
2529 retval = markersize; 2572 retval = markersize;
2530 else if (name.compare ("keylabel")) 2573 else if (name.compare ("keylabel"))
2531 retval = keylabel; 2574 retval = keylabel;
2575 else if (name.compare ("interpreter"))
2576 retval = interpreter;
2532 else 2577 else
2533 warning ("get: invalid property `%s'", name.c_str ()); 2578 warning ("get: invalid property `%s'", name.c_str ());
2534 2579
2535 return retval; 2580 return retval;
2536 } 2581 }
2552 m["marker"] = "none"; 2597 m["marker"] = "none";
2553 m["markeredgecolor"] = "auto"; 2598 m["markeredgecolor"] = "auto";
2554 m["markerfacecolor"] = "none"; 2599 m["markerfacecolor"] = "none";
2555 m["markersize"] = 1; 2600 m["markersize"] = 1;
2556 m["keylabel"] = ""; 2601 m["keylabel"] = "";
2602 m["interpreter"] =
2603 radio_property (radio_values ("{tex}|none|latex"));
2557 2604
2558 return m; 2605 return m;
2559 } 2606 }
2560 2607
2561 std::string surface::properties::go_name ("surface"); 2608 std::string surface::properties::go_name ("surface");
2562 2609
2563 // --------------------------------------------------------------------- 2610 // ---------------------------------------------------------------------
2564 2611
2565 octave_value 2612 octave_value
2566 base_graphics_object::get_default (const property_name& name) const 2613 base_graphics_object::get_default (const caseless_str& name) const
2567 { 2614 {
2568 graphics_handle parent = get_parent (); 2615 graphics_handle parent = get_parent ();
2569 graphics_object parent_obj = gh_manager::get_object (parent); 2616 graphics_object parent_obj = gh_manager::get_object (parent);
2570 2617
2571 return parent_obj.get_default (type () + name); 2618 return parent_obj.get_default (type () + name);
2572 } 2619 }
2573 2620
2574 octave_value 2621 octave_value
2575 base_graphics_object::get_factory_default (const property_name& name) const 2622 base_graphics_object::get_factory_default (const caseless_str& name) const
2576 { 2623 {
2577 graphics_object parent_obj = gh_manager::get_object (0); 2624 graphics_object parent_obj = gh_manager::get_object (0);
2578 2625
2579 return parent_obj.get_factory_default (type () + name); 2626 return parent_obj.get_factory_default (type () + name);
2580 } 2627 }
2763 { 2810 {
2764 if (nargin == 1) 2811 if (nargin == 1)
2765 vlist(n) = obj.get (); 2812 vlist(n) = obj.get ();
2766 else 2813 else
2767 { 2814 {
2768 property_name property = args(1).string_value (); 2815 caseless_str property = args(1).string_value ();
2769 2816
2770 if (! error_state) 2817 if (! error_state)
2771 vlist(n) = obj.get (property); 2818 vlist(n) = obj.get (property);
2772 else 2819 else
2773 { 2820 {
3073 graphics_object obj = gh_manager::get_object (handle); 3120 graphics_object obj = gh_manager::get_object (handle);
3074 octave_value retval; 3121 octave_value retval;
3075 3122
3076 if (obj) 3123 if (obj)
3077 { 3124 {
3078 property_name p = std::string (property); 3125 caseless_str p = std::string (property);
3079 retval = obj.get (p); 3126 retval = obj.get (p);
3080 } 3127 }
3081 else 3128 else
3082 error ("%s: invalid handle (= %g)", func.c_str(), handle); 3129 error ("%s: invalid handle (= %g)", func.c_str(), handle);
3083 3130
3091 graphics_object obj = gh_manager::get_object (handle); 3138 graphics_object obj = gh_manager::get_object (handle);
3092 int ret = false; 3139 int ret = false;
3093 3140
3094 if (obj) 3141 if (obj)
3095 { 3142 {
3096 property_name p = std::string (property); 3143 caseless_str p = std::string (property);
3097 obj.set (p, arg); 3144 obj.set (p, arg);
3098 if (!error_state) 3145 if (!error_state)
3099 ret = true; 3146 ret = true;
3100 } 3147 }
3101 else 3148 else