octave-nkf: libinterp/corefcn/graphics.cc comparison

comparison libinterp/corefcn/graphics.cc @ 20597:bc6daa38ff50

eliminate more simple uses of error_state * graphics.cc: Eliminate simple uses of error_state.

author	John W. Eaton <jwe@octave.org>
date	Tue, 06 Oct 2015 14:47:41 -0400
parents	dcfbf4c1c3c8
children	ba2b07c13913

comparison

equal deleted inserted replaced

-:87b557ee8e5d
+:bc6daa38ff50
 if (fig.valid_object ())
 {
 Matrix _cmap = fig.get (caseless_str ("colormap")).matrix_value ();
-if (! error_state)
+cmap = _cmap;
-cmap = _cmap;
 }
 if (is_scaled)
 {
 graphics_object ax = go.get_ancestor ("axes");
 if (ax.valid_object ())
 {
 Matrix _clim = ax.get (caseless_str ("clim")).matrix_value ();
-if (! error_state)
+clim = _clim;
-clim = _clim;
 }
 }
 dv.resize (cdim);
 dv(cdim-1) = 3;
 if (go)
 go.update (id);
 }
 // run listeners
-if (do_run && ! error_state)
+if (do_run)
 run_listeners (POSTSET);
 return true;
 }
 base_property::run_listeners (listener_mode mode)
 {
 const octave_value_list& l = listeners[mode];
 for (int i = 0; i < l.length (); i++)
-{
+gh_manager::execute_listener (parent, l(i));
-gh_manager::execute_listener (parent, l(i));
-if (error_state)
-break;
-}
 }
 radio_values::radio_values (const std::string& opt_string)
 : default_val (), possible_vals ()
 {
 }
 }
 else
 {
 color_values col (s);
 if (! error_state)
 {
 if (current_type != color_t || col != color_val)
 {
 color_val = col;
 Matrix m = val.matrix_value ();
 if (m.numel () == 3)
 {
 color_values col (m(0), m(1), m(2));
-if (! error_state)
+if (current_type != color_t || col != color_val)
 {
-if (current_type != color_t || col != color_val)
+color_val = col;
-{
+current_type = color_t;
-color_val = col;
+return true;
-current_type = color_t;
-return true;
-}
 }
 }
 else
 error ("invalid value for color property \"%s\"",
 get_name ().c_str ());
 if (type.compare ("string"))
 {
 std::string sv = (args.length () > 0 ? args(0).string_value () : "");
-if (! error_state)
+retval = property (new string_property (name, h, sv));
-retval = property (new string_property (name, h, sv));
 }
 else if (type.compare ("any"))
 {
 octave_value ov = args.length () > 0 ? args(0)
 : octave_value (Matrix ());
 }
 else if (type.compare ("double"))
 {
 double dv = (args.length () > 0 ? args(0).double_value () : 0.0);
-if (! error_state)
+retval = property (new double_property (name, h, dv));
-retval = property (new double_property (name, h, dv));
 }
 else if (type.compare ("handle"))
 {
 double hv = (args.length () > 0 ? args(0).double_value () : octave_NaN);
-if (! error_state)
+graphics_handle gh (hv);
-{
-graphics_handle gh (hv);
+retval = property (new handle_property (name, h, gh));
-retval = property (new handle_property (name, h, gh));
-}
 }
 else if (type.compare ("boolean"))
 {
 retval = property (new bool_property (name, h, false));
 radio_values rv;
 if (args.length () > 1)
 rv = radio_values (args(1).string_value ());
-if (! error_state)
+retval = property (new color_property (name, h, cv, rv));
-{
-retval = property (new color_property (name, h, cv, rv));
+if (args.length () > 0 && ! args(0).is_empty ())
+retval.set (args(0));
-if (! error_state)
+else
-{
+retval.set (rv.default_value ());
-if (args.length () > 0 && ! args(0).is_empty ())
-retval.set (args(0));
-else
-retval.set (rv.default_value ());
-}
-}
 }
 else
 {
 caseless_str go_name, go_rest;
 if (go.valid_object ())
 {
 property prop = go.get_properties ().get_property (go_rest);
-if (! error_state)
+retval = prop.clone ();
-{
-retval = prop.clone ();
+retval.set_parent (h);
+retval.set_name (name);
-retval.set_parent (h);
-retval.set_name (name);
+if (args.length () > 0)
+retval.set (args(0));
-if (args.length () > 0)
-retval.set (args(0));
-}
 }
 else
 error ("addproperty: invalid object type (= %s)",
 go_name.c_str ());
 }
 }
 void
 figure::properties::set___mouse_mode__ (const octave_value& val_arg)
 {
-if (! error_state)
+std::string direction = "in";
-{
-std::string direction = "in";
+octave_value val = val_arg;
-octave_value val = val_arg;
+if (val.is_string ())
+{
-if (val.is_string ())
+std::string modestr = val.string_value ();
-{
-std::string modestr = val.string_value ();
+if (modestr == "zoom in")
+{
-if (modestr == "zoom in")
+val = modestr = "zoom";
+direction = "in";
+}
+else if (modestr == "zoom out")
+{
+val = modestr = "zoom";
+direction = "out";
+}
+if (__mouse_mode__.set (val, true))
+{
+std::string mode = __mouse_mode__.current_value ();
+octave_scalar_map pm = get___pan_mode__ ().scalar_map_value ();
+pm.setfield ("Enable", mode == "pan" ? "on" : "off");
+set___pan_mode__ (pm);
+octave_scalar_map rm = get___rotate_mode__ ().scalar_map_value ();
+rm.setfield ("Enable", mode == "rotate" ? "on" : "off");
+set___rotate_mode__ (rm);
+octave_scalar_map zm = get___zoom_mode__ ().scalar_map_value ();
+zm.setfield ("Enable", mode == "zoom" ? "on" : "off");
+zm.setfield ("Direction", direction);
+set___zoom_mode__ (zm);
+mark_modified ();
+}
+else if (modestr == "zoom")
+{
+octave_scalar_map zm = get___zoom_mode__ ().scalar_map_value ();
+std::string curr_direction
+= zm.getfield ("Direction").string_value ();
+if (direction != curr_direction)
 {
-val = modestr = "zoom";
-direction = "in";
-}
-else if (modestr == "zoom out")
-{
-val = modestr = "zoom";
-direction = "out";
-}
-if (__mouse_mode__.set (val, true))
-{
-std::string mode = __mouse_mode__.current_value ();
-octave_scalar_map pm = get___pan_mode__ ().scalar_map_value ();
-pm.setfield ("Enable", mode == "pan" ? "on" : "off");
-set___pan_mode__ (pm);
-octave_scalar_map rm = get___rotate_mode__ ().scalar_map_value ();
-rm.setfield ("Enable", mode == "rotate" ? "on" : "off");
-set___rotate_mode__ (rm);
-octave_scalar_map zm = get___zoom_mode__ ().scalar_map_value ();
-zm.setfield ("Enable", mode == "zoom" ? "on" : "off");
 zm.setfield ("Direction", direction);
 set___zoom_mode__ (zm);
 mark_modified ();
-}
-else if (modestr == "zoom")
-{
-octave_scalar_map zm = get___zoom_mode__ ().scalar_map_value ();
-std::string curr_direction
-= zm.getfield ("Direction").string_value ();
-if (direction != curr_direction)
-{
-zm.setfield ("Direction", direction);
-set___zoom_mode__ (zm);
-mark_modified ();
-}
 }
 }
 }
 }
 else
 error ("invalid %s property '%s'", pfx.c_str (), pname.c_str ());
 }
 }
-if (! error_state && offset == 0)
+if (offset == 0)
 error ("invalid default property specification");
 }
 octave_value
 property_list::lookup (const caseless_str& name) const
 if (! error_state)
 {
 octave_value val = args(i+1);
 set_value_or_default (pname, val);
-if (error_state)
-break;
 }
 else
 error ("set: expecting argument %d to be a property name", i);
 }
 }
 {
 caseless_str pname = pnames(column);
 octave_value val  = values(row, column);
 set_value_or_default (pname, val);
-if (error_state)
-break;
 }
 }
 /*
 ## test set with cell array arguments
 caseless_str pname = m.keys ()[p];
 octave_value val = octave_value (m.contents (pname).elem (m.numel () - 1));
 set_value_or_default (pname, val);
-if (error_state)
-break;
 }
 }
 /*
 ## test set ticklabels for compatibility
 if (sval.compare ("default") == 0)
 {
 default_val = get_default (pname);
-if (error_state)
-return;
 rep->set (pname, default_val);
 }
 else if (sval.compare ("factory") == 0)
 {
 default_val = get_factory_default (pname);
-if (error_state)
-return;
 rep->set (pname, default_val);
 }
 else
 {
 retval = true;
 else if (val.is_numeric_type () && val.is_real_type ())
 {
 const NDArray handles = val.array_value ();
-if (! error_state)
+boolNDArray result (handles.dims ());
-{
-boolNDArray result (handles.dims ());
+for (octave_idx_type i = 0; i < handles.numel (); i++)
+result.xelem (i) = is_handle (handles(i));
-for (octave_idx_type i = 0; i < handles.numel (); i++)
-result.xelem (i) = is_handle (handles(i));
+retval = result;
-retval = result;
-}
 }
 return retval;
 }
 if (it != all_props.end ())
 it->second.set (val);
 else
 error ("set: unknown property \"%s\"", pname.c_str ());
-if (! error_state)
+dynamic_properties.insert (pname);
-{
-dynamic_properties.insert (pname);
+mark_modified ();
-mark_modified ();
-}
 }
 property
 base_properties::get_property_dynamic (const caseless_str& pname)
 {
 const octave_value& val,
 listener_mode mode)
 {
 property p = get_property (pname);
-if (! error_state && p.ok ())
+if (p.ok ())
 p.add_listener (val, mode);
 }
 void
 base_properties::delete_listener (const caseless_str& pname,
 const octave_value& val,
 listener_mode mode)
 {
 property p = get_property (pname);
-if (! error_state && p.ok ())
+if (p.ok ())
 p.delete_listener (val, mode);
 }
 // ---------------------------------------------------------------------
 // ask whether it is OK to delete the listener for the given
 // property.  How can we know in advance that it will be OK?
 unwind_protect frame;
-frame.protect_var (error_state);
 frame.protect_var (discard_error_messages);
 frame.protect_var (Vdebug_on_error);
 frame.protect_var (Vdebug_on_warning);
 discard_error_messages = true;
 Vdebug_on_error = false;
 Vdebug_on_warning = false;
 property p = get_properties ().get_property (pa->first);
-if (! error_state && p.ok ())
+if (p.ok ())
 p.delete_listener ();
 }
 }
 void
 void
 root_figure::properties::set_callbackobject (const octave_value& v)
 {
 graphics_handle val (v);
-if (error_state)
-return;
 if (xisnan (val.value ()))
 {
 if (! cbo_stack.empty ())
 {
 val = cbo_stack.front ();
 void
 root_figure::properties::set_currentfigure (const octave_value& v)
 {
 graphics_handle val (v);
-if (error_state)
-return;
 if (xisnan (val.value ()) || is_handle (val))
 {
 currentfigure = val;
 if (val.ok ())
 }
 void
 figure::properties::set_integerhandle (const octave_value& val)
 {
-if (! error_state)
+if (integerhandle.set (val, true))
 {
-if (integerhandle.set (val, true))
+bool int_fig_handle = integerhandle.is_on ();
-{
-bool int_fig_handle = integerhandle.is_on ();
+graphics_object this_go = gh_manager::get_object (__myhandle__);
-graphics_object this_go = gh_manager::get_object (__myhandle__);
+graphics_handle old_myhandle = __myhandle__;
-graphics_handle old_myhandle = __myhandle__;
+__myhandle__ = gh_manager::get_handle (int_fig_handle);
-__myhandle__ = gh_manager::get_handle (int_fig_handle);
+gh_manager::renumber_figure (old_myhandle, __myhandle__);
-gh_manager::renumber_figure (old_myhandle, __myhandle__);
+graphics_object parent_go = gh_manager::get_object (get_parent ());
-graphics_object parent_go = gh_manager::get_object (get_parent ());
+base_properties& props = parent_go.get_properties ();
-base_properties& props = parent_go.get_properties ();
+props.renumber_child (old_myhandle, __myhandle__);
-props.renumber_child (old_myhandle, __myhandle__);
+Matrix kids = get_children ();
-Matrix kids = get_children ();
+for (octave_idx_type i = 0; i < kids.numel (); i++)
+{
-for (octave_idx_type i = 0; i < kids.numel (); i++)
+graphics_object kid = gh_manager::get_object (kids(i));
-{
-graphics_object kid = gh_manager::get_object (kids(i));
+kid.get_properties ().renumber_parent (__myhandle__);
+}
-kid.get_properties ().renumber_parent (__myhandle__);
-}
+graphics_handle cf = gh_manager::current_figure ();
-graphics_handle cf = gh_manager::current_figure ();
+if (__myhandle__ == cf)
+xset (0, "currentfigure", __myhandle__.value ());
-if (__myhandle__ == cf)
-xset (0, "currentfigure", __myhandle__.value ());
+this_go.update (integerhandle.get_id ());
-this_go.update (integerhandle.get_id ());
+mark_modified ();
-mark_modified ();
-}
 }
 }
 // FIXME: This should update monitorpositions and pointerlocation, but as these
 // properties aren't yet used, it doesn't matter that they aren't set either.
 void
 figure::properties::set_currentaxes (const octave_value& val)
 {
 graphics_handle hax (val);
-if (error_state)
-return;
 if (xisnan (hax.value ()) || is_handle (hax))
 currentaxes = hax;
 else
 gripe_set_invalid ("currentaxes");
 }
 void
 figure::properties::set_visible (const octave_value& val)
 {
 std::string sval = val.string_value ();
-if (! error_state)
+if (sval == "on")
-{
+xset (0, "currentfigure", __myhandle__.value ());
-if (sval == "on")
-xset (0, "currentfigure", __myhandle__.value ());
+visible = val;
-visible = val;
-}
 }
 Matrix
 figure::properties::get_boundingbox (bool internal, const Matrix&) const
 {
 void
 figure::properties::set_position (const octave_value& v,
 bool do_notify_toolkit)
 {
-if (! error_state)
+Matrix old_bb, new_bb;
-{
+bool modified = false;
-Matrix old_bb, new_bb;
-bool modified = false;
+old_bb = get_boundingbox (true);
+modified = position.set (v, false, do_notify_toolkit);
-old_bb = get_boundingbox (true);
+new_bb = get_boundingbox (true);
-modified = position.set (v, false, do_notify_toolkit);
-new_bb = get_boundingbox (true);
+if (old_bb != new_bb)
+{
-if (old_bb != new_bb)
+if (old_bb(2) != new_bb(2) || old_bb(3) != new_bb(3))
 {
-if (old_bb(2) != new_bb(2) || old_bb(3) != new_bb(3))
+execute_resizefcn ();
-{
+update_boundingbox ();
-execute_resizefcn ();
+}
-update_boundingbox ();
+}
-}
-}
+if (modified)
+{
-if (modified)
+position.run_listeners (POSTSET);
-{
+mark_modified ();
-position.run_listeners (POSTSET);
+}
-mark_modified ();
-}
+if (paperpositionmode.is ("auto"))
+paperposition.set (get_auto_paperposition ());
-if (paperpositionmode.is ("auto"))
-paperposition.set (get_auto_paperposition ());
-}
 }
 void
 figure::properties::set_outerposition (const octave_value& v,
 bool do_notify_toolkit)
 {
-if (! error_state)
+if (outerposition.set (v, true, do_notify_toolkit))
-{
+mark_modified ();
-if (outerposition.set (v, true, do_notify_toolkit))
+}
-{
+void
+figure::properties::set_paperunits (const octave_value& val)
+{
+caseless_str punits = val.string_value ();
+caseless_str ptype = get_papertype ();
+if (punits.compare ("normalized") && ptype.compare ("<custom>"))
+error ("set: can't set paperunits to normalized when papertype is custom");
+else
+{
+caseless_str old_paperunits = get_paperunits ();
+if (paperunits.set (val, true))
+{
+update_paperunits (old_paperunits);
 mark_modified ();
 }
 }
 }
 void
-figure::properties::set_paperunits (const octave_value& val)
-{
-if (! error_state)
-{
-caseless_str punits = val.string_value ();
-caseless_str ptype = get_papertype ();
-if (! error_state)
-{
-if (punits.compare ("normalized") && ptype.compare ("<custom>"))
-error ("set: can't set paperunits to normalized when papertype is custom");
-else
-{
-caseless_str old_paperunits = get_paperunits ();
-if (paperunits.set (val, true))
-{
-update_paperunits (old_paperunits);
-mark_modified ();
-}
-}
-}
-}
-}
-void
 figure::properties::set_papertype (const octave_value& val)
 {
-if (! error_state)
+caseless_str ptype = val.string_value ();
-{
+caseless_str punits = get_paperunits ();
-caseless_str ptype = val.string_value ();
-caseless_str punits = get_paperunits ();
+if (punits.compare ("normalized") && ptype.compare ("<custom>"))
-if (! error_state)
+error ("set: can't set paperunits to normalized when papertype is custom");
-{
+else
-if (punits.compare ("normalized") && ptype.compare ("<custom>"))
+{
-error ("set: can't set paperunits to normalized when papertype is custom");
+if (papertype.set (val, true))
-else
+{
-{
+update_papertype ();
-if (papertype.set (val, true))
+mark_modified ();
-{
-update_papertype ();
-mark_modified ();
-}
-}
 }
 }
 }
 static Matrix
 */
 void
 figure::properties::set_units (const octave_value& val)
 {
-if (! error_state)
+caseless_str old_units = get_units ();
-{
-caseless_str old_units = get_units ();
+if (units.set (val, true))
-if (units.set (val, true))
+{
-{
+update_units (old_units);
-update_units (old_units);
+mark_modified ();
-mark_modified ();
-}
 }
 }
 void
 figure::properties::update_units (const caseless_str& old_units)
 error ("set: expecting text graphics object or character string for %s property, found %s",
 who.c_str (), cname.c_str ());
 }
-if (! error_state)
+xset (val, "handlevisibility", "off");
-{
-xset (val, "handlevisibility", "off");
+gh_manager::free (hp.handle_value ());
-gh_manager::free (hp.handle_value ());
+base_properties::remove_child (hp.handle_value ());
-base_properties::remove_child (hp.handle_value ());
+hp = val;
-hp = val;
+adopt (hp.handle_value ());
-adopt (hp.handle_value ());
-}
 }
 void
 axes::properties::set_xlabel (const octave_value& v)
 {
 }
 void
 axes::properties::set_xticklabel (const octave_value& val)
 {
-if (! error_state)
+if (xticklabel.set (convert_ticklabel_string (val), false))
 {
-if (xticklabel.set (convert_ticklabel_string (val), false))
+set_xticklabelmode ("manual");
-{
+xticklabel.run_listeners (POSTSET);
-set_xticklabelmode ("manual");
+mark_modified ();
-xticklabel.run_listeners (POSTSET);
+}
-mark_modified ();
+else
-}
+set_xticklabelmode ("manual");
-else
-set_xticklabelmode ("manual");
+sync_positions ();
-sync_positions ();
-}
 }
 void
 axes::properties::set_yticklabel (const octave_value& val)
 {
-if (! error_state)
+if (yticklabel.set (convert_ticklabel_string (val), false))
 {
-if (yticklabel.set (convert_ticklabel_string (val), false))
+set_yticklabelmode ("manual");
-{
+yticklabel.run_listeners (POSTSET);
-set_yticklabelmode ("manual");
+mark_modified ();
-yticklabel.run_listeners (POSTSET);
+}
-mark_modified ();
+else
-}
+set_yticklabelmode ("manual");
-else
-set_yticklabelmode ("manual");
+sync_positions ();
-sync_positions ();
-}
 }
 void
 axes::properties::set_zticklabel (const octave_value& val)
 {
-if (! error_state)
+if (zticklabel.set (convert_ticklabel_string (val), false))
 {
-if (zticklabel.set (convert_ticklabel_string (val), false))
+set_zticklabelmode ("manual");
-{
+zticklabel.run_listeners (POSTSET);
-set_zticklabelmode ("manual");
+mark_modified ();
-zticklabel.run_listeners (POSTSET);
+}
-mark_modified ();
+else
-}
+set_zticklabelmode ("manual");
-else
-set_zticklabelmode ("manual");
+sync_positions ();
-sync_positions ();
-}
 }
 // Almost identical to convert_ticklabel_string but it only accepts
 // cellstr or string, not numeric input.
 static octave_value
 }
 void
 axes::properties::set_linestyleorder (const octave_value& val)
 {
-if (! error_state)
+linestyleorder.set (convert_linestyleorder_string (val), false);
-{
-linestyleorder.set (convert_linestyleorder_string (val), false);
-}
 }
 void
 axes::properties::set_units (const octave_value& val)
 {
-if (! error_state)
+caseless_str old_units = get_units ();
-{
-caseless_str old_units = get_units ();
+if (units.set (val, true))
-if (units.set (val, true))
+{
-{
+update_units (old_units);
-update_units (old_units);
+mark_modified ();
-mark_modified ();
-}
 }
 }
 void
 axes::properties::update_units (const caseless_str& old_units)
 }
 void
 axes::properties::set_fontunits (const octave_value& val)
 {
-if (! error_state)
+caseless_str old_fontunits = get_fontunits ();
-{
-caseless_str old_fontunits = get_fontunits ();
+if (fontunits.set (val, true))
-if (fontunits.set (val, true))
+{
-{
+update_fontunits (old_fontunits);
-update_fontunits (old_fontunits);
+mark_modified ();
-mark_modified ();
-}
 }
 }
 void
 axes::properties::update_fontunits (const caseless_str& old_units)
 {
 if (data.is_matrix_type ())
 {
 Matrix m = data.matrix_value ();
-if (! error_state && m.numel () == 4)
+if (m.numel () == 4)
 {
 double val;
 val = m(0);
 if (xfinite (val) && val < min_val)
 }
 void
 text::properties::set_fontunits (const octave_value& val)
 {
-if (! error_state)
+caseless_str old_fontunits = get_fontunits ();
-{
-caseless_str old_fontunits = get_fontunits ();
+if (fontunits.set (val, true))
-if (fontunits.set (val, true))
+{
-{
+update_fontunits (old_fontunits);
-update_fontunits (old_fontunits);
+mark_modified ();
-mark_modified ();
-}
 }
 }
 void
 text::properties::update_fontunits (const caseless_str& old_units)
 }
 void
 uicontrol::properties::set_fontunits (const octave_value& val)
 {
-if (! error_state)
+caseless_str old_fontunits = get_fontunits ();
-{
-caseless_str old_fontunits = get_fontunits ();
+if (fontunits.set (val, true))
-if (fontunits.set (val, true))
+{
-{
+update_fontunits (old_fontunits);
-update_fontunits (old_fontunits);
+mark_modified ();
-mark_modified ();
-}
 }
 }
 void
 uicontrol::properties::update_fontunits (const caseless_str& old_units)
 }
 void
 uipanel::properties::set_units (const octave_value& val)
 {
-if (! error_state)
+caseless_str old_units = get_units ();
-{
-caseless_str old_units = get_units ();
+if (units.set (val, true))
-if (units.set (val, true))
+{
-{
+update_units (old_units);
-update_units (old_units);
+mark_modified ();
-mark_modified ();
-}
 }
 }
 void
 uipanel::properties::update_units (const caseless_str& old_units)
 }
 void
 uipanel::properties::set_fontunits (const octave_value& val)
 {
-if (! error_state)
+caseless_str old_fontunits = get_fontunits ();
-{
-caseless_str old_fontunits = get_fontunits ();
+if (fontunits.set (val, true))
-if (fontunits.set (val, true))
+{
-{
+update_fontunits (old_fontunits);
-update_fontunits (old_fontunits);
+mark_modified ();
-mark_modified ();
-}
 }
 }
 void
 uipanel::properties::update_fontunits (const caseless_str& old_units)
 || cb.cell_value ()(0).is_function_handle ()))
 {
 Cell c = cb.cell_value ();
 fcn = c(0).function_value ();
-if (! error_state)
-{
+for (int i = 1; i < c.numel () ; i++)
-for (int i = 1; i < c.numel () ; i++)
+args(1+i) = c(i);
-args(1+i) = c(i);
-}
 }
 else
 {
 std::string nm = cb.class_name ();
 error ("trying to execute non-executable object (class = %s)",
 nm.c_str ());
 }
-if (fcn && ! error_state)
+if (fcn)
 feval (fcn, args);
 END_INTERRUPT_WITH_EXCEPTIONS;
 }
 }
 retval = true;
 else if (val.is_numeric_type () && val.is_real_type ())
 {
 const NDArray handles = val.array_value ();
-if (! error_state)
+boolNDArray result (handles.dims ());
-{
-boolNDArray result (handles.dims ());
+for (octave_idx_type i = 0; i < handles.numel (); i++)
+result.xelem (i) = is_handle_visible (handles(i));
-for (octave_idx_type i = 0; i < handles.numel (); i++)
-result.xelem (i) = is_handle_visible (handles(i));
+retval = result;
-retval = result;
-}
 }
 return retval;
 }
 else
 {
 // get vector of graphics handles
 ColumnVector hcv (args(0).vector_value ());
-if (! error_state)
+// loop over graphics objects
-{
+for (octave_idx_type n = 0; n < hcv.numel (); n++)
-// loop over graphics objects
+gh_manager::get_object (hcv(n)).reset_default_properties ();
-for (octave_idx_type n = 0; n < hcv.numel (); n++)
-gh_manager::get_object (hcv(n)).reset_default_properties ();
+Fdrawnow ();
-if (! error_state)
-Fdrawnow ();
-}
 }
 return octave_value ();
 }
 if (nargout != 0)
 retval = pmap.getfield (property)(0);
 else
 {
 std::string s = go.value_as_string (property);
-if (! error_state)
 octave_stdout << s;
 }
 }
 else
 {
 error ("set: unknown property");
 if (nargout != 0)
 retval = go.values_as_struct ();
 else
 {
 std::string s = go.values_as_string ();
-if (! error_state)
 octave_stdout << s;
 }
 }
 else
 {
 go.set (args.splice (0, 1));
 {
 error ("set: invalid handle (= %g)", hcv(n));
 break;
 }
-if (error_state)
-break;
 request_drawnow = true;
 }
-if (! error_state && request_drawnow)
+if (request_drawnow)
 Vdrawnow_requested = true;
 }
 else
 error ("set: expecting graphics handle as first argument");
 }
 if (nargin == 1 && len > 1)
 {
 std::string typ0 = get_graphics_object_type (hcv(0));
+for (octave_idx_type n = 1; n < len; n++)
+{
+std::string typ = get_graphics_object_type (hcv(n));
+if (typ != typ0)
+{
+error ("get: vector of handles must all have same type");
+break;
+}
+}
+}
+if (nargin > 1 && args(1).is_cellstr ())
+{
+Array<std::string> plist = args(1).cellstr_value ();
 if (! error_state)
 {
-for (octave_idx_type n = 1; n < len; n++)
+octave_idx_type plen = plist.numel ();
+use_cell_format = true;
+vals.resize (dim_vector (len, plen));
+for (octave_idx_type n = 0; n < len; n++)
 {
-std::string typ = get_graphics_object_type (hcv(n));
+graphics_object go = gh_manager::get_object (hcv(n));
-if (error_state)
+if (go)
-break;
-if (typ != typ0)
 {
-error ("get: vector of handles must all have same type");
+for (octave_idx_type m = 0; m < plen; m++)
+{
+caseless_str property = plist(m);
+vals(n, m) = go.get (property);
+}
+}
+else
+{
+error ("get: invalid handle (= %g)", hcv(n));
 break;
 }
 }
 }
+else
+error ("get: expecting property name or cell array of property names as second argument");
 }
+else
-if (! error_state)
 {
-if (nargin > 1 && args(1).is_cellstr ())
+caseless_str property;
+if (nargin > 1)
 {
-Array<std::string> plist = args(1).cellstr_value ();
+property = args(1).string_value ();
-if (! error_state)
+if (error_state)
+error ("get: expecting property name or cell array of property names as second argument");
+}
+vals.resize (dim_vector (len, 1));
+for (octave_idx_type n = 0; n < len; n++)
+{
+graphics_object go = gh_manager::get_object (hcv(n));
+if (go)
 {
-octave_idx_type plen = plist.numel ();
+if (nargin == 1)
+vals(n) = go.get ();
-use_cell_format = true;
+else
+vals(n) = go.get (property);
-vals.resize (dim_vector (len, plen));
-for (octave_idx_type n = 0; ! error_state && n < len; n++)
-{
-graphics_object go = gh_manager::get_object (hcv(n));
-if (go)
-{
-for (octave_idx_type m = 0;
-! error_state && m < plen;
-m++)
-{
-caseless_str property = plist(m);
-vals(n, m) = go.get (property);
-}
-}
-else
-{
-error ("get: invalid handle (= %g)", hcv(n));
-break;
-}
-}
 }
 else
-error ("get: expecting property name or cell array of property names as second argument");
-}
-else
-{
-caseless_str property;
-if (nargin > 1)
 {
-property = args(1).string_value ();
+error ("get: invalid handle (= %g)", hcv(n));
+break;
-if (error_state)
-error ("get: expecting property name or cell array of property names as second argument");
-}
-vals.resize (dim_vector (len, 1));
-if (! error_state)
-{
-for (octave_idx_type n = 0; ! error_state && n < len; n++)
-{
-graphics_object go = gh_manager::get_object (hcv(n));
-if (go)
-{
-if (nargin == 1)
-vals(n) = go.get ();
-else
-vals(n) = go.get (property);
-}
-else
-{
-error ("get: invalid handle (= %g)", hcv(n));
-break;
-}
-}
 }
 }
 }
 }
 else
 error ("get: expecting graphics handle as first argument");
 }
 else
 print_usage ();
-if (! error_state)
+if (use_cell_format)
-{
+retval = vals;
-if (use_cell_format)
+else
+{
+octave_idx_type len = vals.numel ();
+if (len == 0)
+retval = Matrix ();
+else if (len == 1)
+retval = vals(0);
+else if (len > 1 && nargin == 1)
+{
+OCTAVE_LOCAL_BUFFER (octave_scalar_map, tmp, len);
+for (octave_idx_type n = 0; n < len; n++)
+tmp[n] = vals(n).scalar_map_value ();
+retval = octave_map::cat (0, len, tmp);
+}
+else
 retval = vals;
-else
-{
-octave_idx_type len = vals.numel ();
-if (len == 0)
-retval = Matrix ();
-else if (len == 1)
-retval = vals(0);
-else if (len > 1 && nargin == 1)
-{
-OCTAVE_LOCAL_BUFFER (octave_scalar_map, tmp, len);
-for (octave_idx_type n = 0; n < len; n++)
-tmp[n] = vals(n).scalar_map_value ();
-retval = octave_map::cat (0, len, tmp);
-}
-else
-retval = vals;
-}
 }
 return retval;
 }
 error ("get: expecting graphics handle as first argument");
 }
 else
 print_usage ();
-if (! error_state)
+octave_idx_type len = vals.numel ();
-{
-octave_idx_type len = vals.numel ();
+if (len > 1)
+retval = vals;
-if (len > 1)
+else if (len == 1)
-retval = vals;
+retval = vals(0);
-else if (len == 1)
-retval = vals(0);
-}
 return retval;
 }
 static octave_value
 {
 if (i < (xargs.length () - 1))
 {
 val = xargs(i+1).double_value ();
-if (! error_state)
+xargs = xargs.splice (i, 2);
-{
+break;
-xargs = xargs.splice (i, 2);
-break;
-}
 }
 else
 error ("__go_%s__: missing value for parent property",
 go_name.c_str ());
 }
-if (! error_state && xisnan (val))
+if (xisnan (val))
 val = args(0).double_value ();
 if (! error_state)
 {
 graphics_handle parent = gh_manager::lookup (val);
 xcreatefcn (h);
 xinitialize (h);
 retval = h.value ();
-if (! error_state)
+Vdrawnow_requested = true;
-Vdrawnow_requested = true;
 }
 else
 error ("__go%s__: unable to create graphics handle",
 go_name.c_str ());
 }
 {
 if (i < (xargs.length () - 1))
 {
 std::string pval = xargs(i+1).string_value ();
-if (! error_state)
+caseless_str on ("on");
-{
+int_fig_handle = on.compare (pval);
-caseless_str on ("on");
+xargs = xargs.splice (i, 2);
-int_fig_handle = on.compare (pval);
-xargs = xargs.splice (i, 2);
+break;
-break;
-}
 }
 }
 }
 h = gh_manager::make_graphics_handle ("figure", 0,
 error ("delete: invalid graphics object (= %g)", vals(i));
 break;
 }
 }
-if (! error_state)
+delete_graphics_objects (vals);
-delete_graphics_objects (vals);
 }
 else
 error ("delete: invalid graphics object");
 }
 else
 int nargin = args.length ();
 std::string mode = "";
 if (nargin == 2)
-{
+mode = args(1).string_value ();
-mode = args(1).string_value ();
-if (error_state)
-return retval;
-}
 if (nargin == 1 || nargin == 2)
 {
 graphics_handle h = octave_NaN;
 {
 octave_value_list args;
 args(0) = dtk;
 feval ("graphics_toolkit", args);
-if (! error_state)
+pl = loaded_toolkits.find (dtk);
-pl = loaded_toolkits.find (dtk);
 if (error_state || pl == loaded_toolkits.end ())
 error ("failed to load %s graphics toolkit", dtk.c_str ());
 else
 retval = pl->second;
 {
 if (args.length () == 0 || args.length () == 1)
 {
 Matrix hlist = gh_manager::figure_handle_list (true);
-for (int i = 0; ! error_state && i < hlist.numel (); i++)
+for (int i = 0; i < hlist.numel (); i++)
 {
 graphics_handle h = gh_manager::lookup (hlist(i));
 if (h.ok () && h != 0)
 {
 if (! go.get_properties ().has_property (name))
 {
 property p = property::create (name, gh, type,
 args.splice (0, 3));
-if (! error_state)
+go.get_properties ().insert_property (name, p);
-go.get_properties ().insert_property (name, p);
 }
 else
 error ("addproperty: a '%s' property already exists in the graphics object",
 name.c_str ());
 }
 if (go)
 {
 go.set (caseless_str (property), arg);
-if (! error_state)
+ret = true;
-ret = true;
 }
 else
 error ("%s: invalid handle (= %g)", func.c_str (), handle);
 return ret;
 args(0) = ov1;
 args(1) = ov2;
 octave_value_list result = feval ("isequal", args, 1);
-if (! error_state && result.length () > 0)
+if (result.length () > 0)
 return result(0).bool_value ();
 return false;
 }
 if (c.numel () >= 4)
 {
 double h = c(2).double_value ();
-if (! error_state)
+caseless_str pname = c(3).string_value ();
-{
-caseless_str pname = c(3).string_value ();
+gh_manager::auto_lock guard;
-if (! error_state)
+graphics_handle gh = gh_manager::lookup (h);
+if (gh.ok ())
+{
+graphics_object go = gh_manager::get_object (gh);
+if (go.get_properties ().has_property (pname))
 {
-gh_manager::auto_lock guard;
+go.get_properties ().delete_listener (pname, listener, mode);
-graphics_handle gh = gh_manager::lookup (h);
+if (mode == POSTSET)
+go.get_properties ().delete_listener (pname, listener,
-if (gh.ok ())
+PERSISTENT);
-{
-graphics_object go = gh_manager::get_object (gh);
-if (go.get_properties ().has_property (pname))
-{
-go.get_properties ().delete_listener (pname, listener,
-mode);
-if (mode == POSTSET)
-go.get_properties ().delete_listener (pname, listener,
-PERSISTENT);
-}
-}
 }
 }
 }
 }
 {
 if (args.length () > 3)
 {
 uint32_t id = args(2).uint32_scalar_value ().value ();
-if (! error_state)
+if (args.length () > 5)
 {
-if (args.length () > 5)
+double h = args(0).double_value ();
+caseless_str pname = args(4).string_value ();
+gh_manager::auto_lock guard;
+graphics_handle gh = gh_manager::lookup (h);
+if (gh.ok ())
 {
-double h = args(0).double_value ();
+graphics_object go = gh_manager::get_object (gh);
+octave_value pvalue = go.get (pname);
-if (! error_state)
-{
+if (compare_property_values (pvalue, args(5)))
-caseless_str pname = args(4).string_value ();
+waitfor_results[id] = true;
-if (! error_state)
-{
-gh_manager::auto_lock guard;
-graphics_handle gh = gh_manager::lookup (h);
-if (gh.ok ())
-{
-graphics_object go = gh_manager::get_object (gh);
-octave_value pvalue = go.get (pname);
-if (compare_property_values (pvalue, args(5)))
-waitfor_results[id] = true;
-}
-}
-}
 }
-else
+}
-waitfor_results[id] = true;
+else
-}
+waitfor_results[id] = true;
 }
 return octave_value_list ();
 }
 {
 if (args.length () > 2)
 {
 uint32_t id = args(2).uint32_scalar_value ().value ();
-if (! error_state)
+waitfor_results[id] = true;
-waitfor_results[id] = true;
 }
 return octave_value_list ();
 }
 int timeout = 0;
 if (args.length () > 1)
 {
 pname = args(1).string_value ();
 if (! error_state
 && ! pname.empty () && ! pname.compare ("timeout"))
 {
 if (pname.compare ("\\timeout"))
 pname = "timeout";
 }
 else if (error_state || pname.empty ())
 error ("waitfor: invalid property name, expected a non-empty string value");
 }
-if (! error_state
+if (timeout_index < 0 && args.length () > (max_arg_index + 1))
-&& timeout_index < 0 && args.length () > (max_arg_index + 1))
 {
 caseless_str s = args(max_arg_index + 1).string_value ();
 if (! error_state)
 {
 }
 else
 error ("waitfor: invalid parameter, expected 'timeout'");
 }
-if (! error_state && timeout_index >= 0)
+if (timeout_index >= 0)
 {
 if (args.length () > (timeout_index + 1))
 {
 timeout = static_cast<int>
 (args(timeout_index + 1).scalar_value ());
 return retval;
 }
 double h = args(0).double_value ();
-if (error_state)
-return retval;
 gh_manager::auto_lock guard;
 graphics_handle handle = gh_manager::lookup (h);
 if (! handle.ok ())
 dynamic_cast<axes::properties&> (ax.get_properties ());
 if (nargin == 2)
 {
 std::string opt = args(1).string_value ();
-if (error_state)
-return retval;
 if (opt == "out" || opt == "reset")
 {
 if (opt == "out")
 {
 else
 {
 std::string mode = args(1).string_value ();
 double factor = args(2).scalar_value ();
-if (error_state)
-return retval;
 ax_props.zoom (mode, factor);
 Vdrawnow_requested = true;
 }
 return retval;

Mercurial > octave-nkf

comparison libinterp/corefcn/graphics.cc @ 20597:bc6daa38ff50