--- a/scripts/plot/struct2hdl.m
+++ b/scripts/plot/struct2hdl.m
@@ -18,188 +18,187 @@
 ## @deftypefn  {Function File} {@var{h} =} struct2hdl (@var{s})
 ## @deftypefnx {Function File} {@var{h} =} struct2hdl (@var{s}, @var{p})
 ## @deftypefnx {Function File} {@var{h} =} struct2hdl (@var{s}, @var{p}, @var{hilev})
-## Construct an object from the structure @var{s}.  The structure must
-## contain the fields "handle", "type", "children", "properties", and
+## Construct a handle object @var{h} from the structure @var{s}.  The structure
+## must contain the fields "handle", "type", "children", "properties", and
 ## "special".  If the handle of an existing figure or axes is specified,
-## @var{p}, the new object will be created as a child to that object.
-## If no object handle is provided, then a new figure and the necessary
+## @var{p}, the new object will be created as a child of that object.
+## If no object handle is provided then a new figure and the necessary
 ## children will be constructed using the default object values from
 ## the root figure.
 ##
-## A third boolean argument @var{hilev} can be passed to specify wether
-## the function should try to preserve listeners/calbacks e.g., for
-## legends or hggroups.  Default is false.
-## @seealso{findobj, get, hdl2struct, set}
+## A third boolean argument @var{hilev} can be passed to specify whether
+## the function should try to preserve listeners/callbacks, e.g., for
+## legends or hggroups.  The default is false.
+## @seealso{hdl2struct, findobj, get, set}
 ## @end deftypefn
 
 ## Author: pdiribarne <pdiribarne@new-host.home>
 ## Created: 2012-03-04
 
-function [ h, matchout ] = struct2hdl (hgS, matchin=[], hilev = false)
+function [h, pout] = struct2hdl (s, p=[], hilev = false)
 
-  fields = { "handle", "type", "children", "properties", "special"};
+  fields = {"handle", "type", "children", "properties", "special"};
   partypes = {"root", "figure", "axes", "hggroup"};
   othertypes = {"line", "patch", "surface", "image", "text"};
   alltypes = [partypes othertypes];
 
-  if (nargin > 3 || ! isstruct (hgS))
+  if (nargin > 3 || ! isstruct (s))
     print_usage ();
-  elseif (! all (isfield (hgS, fields)))
+  elseif (! all (isfield (s, fields)))
     print_usage ();
-  elseif (isscalar (matchin))
-    if (! ishandle (matchin))
-      error ("struct2hdl: argument #2 is not a handle to graphic object")
+  elseif (isscalar (p))
+    if (! ishandle (p))
+      error ("struct2hdl: P is not a handle to a graphic object");
     endif
-    if (any (strcmp (get (matchin).type, partypes)))
-      paridx = find (strcmp (get (matchin).type, alltypes));
-      kididx = find (strcmp (hgS.type, alltypes));
+    if (any (strcmp (get (p).type, partypes)))
+      paridx = find (strcmp (get (p).type, alltypes));
+      kididx = find (strcmp (s.type, alltypes));
       if (kididx <= paridx)
-        error ("struct2hdl: incompatible input handles")
+        error ("struct2hdl: incompatible input handles");
       endif
     else
-      error ("struct2hdl: %s object can't be parent object", get (matchin).type)
+      error ("struct2hdl: %s object can't be parent object", get (p).type);
     endif
-    hpar = matchin;
-    matchin = [NaN; hpar];
+    hpar = p;
+    p = [NaN; hpar];
     ## create appropriate parent if needed
-    if (any (strcmp (hgS.type, othertypes)))
+    if (any (strcmp (s.type, othertypes)))
       for ii = (paridx+1) : (numel (partypes)-1)
         eval (["hpar = " partypes{ii} "(\"parent\", hpar);"]);
-        matchin = [matchin [NaN; hpar]];
+        p = [p [NaN; hpar]];
       endfor
-    elseif (any (strcmp (hgS.type, {"hggroup", "axes"})))
+    elseif (any (strcmp (s.type, {"hggroup", "axes"})))
       for ii = (paridx+1) : (kididx-1)
         eval (["hpar = " partypes{ii} "(\"parent\", hpar);"]);
-        matchin = [matchin [NaN; hpar]];
+        p = [p [NaN; hpar]];
       endfor
     else
       par = NaN;
     endif
-  elseif (isempty (matchin))
-    if (any (strcmp (hgS.type, othertypes)))
+  elseif (isempty (p))
+    if (any (strcmp (s.type, othertypes)))
       par = axes ();
-    elseif (any (strcmp (hgS.type, {"hggroup", "axes"})))
+    elseif (any (strcmp (s.type, {"hggroup", "axes"})))
       par = figure ();
     else
       par = NaN;
     endif
-    matchin = [NaN; par];
+    p = [NaN; par];
   endif
-  ## read parent (last column) in matchin and remove it if duplicate
-  par = matchin (2,end);
-  tst = find (matchin (2,:) == par);
+  ## read parent (last column) in p and remove it if duplicate
+  par = p(2,end);
+  tst = find (p(2,:) == par);
   if (numel (tst) > 1)
-    matchin = matchin (1:2, 1:(tst(end)-1));
+    p = p(1:2, 1:(tst(end)-1));
   endif
 
   ## create object
-  if (strcmpi (hgS.type, "root"))
+  if (strcmp (s.type, "root"))
     h = 0;
-    hgS.properties = rmfield (hgS.properties, ...
+    s.properties = rmfield (s.properties, ...
                               {"callbackobject", "commandwindowsize", ...
                                "screendepth", "screenpixelsperinch", ...
                                "screensize"});
-  elseif (strcmpi (hgS.type, "figure"))
+  elseif (strcmp (s.type, "figure"))
     h = figure ();
-  elseif (strcmpi (hgS.type, "axes"))
+  elseif (strcmp (s.type, "axes"))
     ## legends and colorbars are "transformed" in normal axes
     ## if hilev is not requested
     if (! hilev)
-      if (strcmp (hgS.properties.tag, "legend"))
-        hgS.properties.tag = "";
-        hgS.properties.userdata = [];
+      if (strcmp (s.properties.tag, "legend"))
+        s.properties.tag = "";
+        s.properties.userdata = [];
         par = gcf;
-      elseif (strcmp (hgS.properties.tag, "colorbar"))
-        hgS.properties.tag = "";
-        hgS.properties.userdata = [];
+      elseif (strcmp (s.properties.tag, "colorbar"))
+        s.properties.tag = "";
+        s.properties.userdata = [];
         par = gcf;
       endif
     endif
 
-    [h, hgS] = createaxes (hgS, matchin, par);
-  elseif (strcmpi (hgS.type, "line"))
-    h = createline (hgS, par);
-  elseif (strcmpi (hgS.type, "patch"))
-    [h, hgS] = createpatch (hgS, par);
-  elseif (strcmpi (hgS.type, "text"))
-    h = createtext (hgS, par);
-  elseif (strcmpi (hgS.type, "image"))
-    h = createimage (hgS, par);
-  elseif (strcmpi (hgS.type, "surface"))
-    h = createsurface (hgS, par);
-  elseif (strcmpi (hgS.type, "hggroup"))
-    [h, hgS, matchin] = createhg (hgS, matchin, par, hilev);
+    [h, s] = createaxes (s, p, par);
+  elseif (strcmp (s.type, "line"))
+    h = createline (s, par);
+  elseif (strcmp (s.type, "patch"))
+    [h, s] = createpatch (s, par);
+  elseif (strcmp (s.type, "text"))
+    h = createtext (s, par);
+  elseif (strcmp (s.type, "image"))
+    h = createimage (s, par);
+  elseif (strcmp (s.type, "surface"))
+    h = createsurface (s, par);
+  elseif (strcmp (s.type, "hggroup"))
+    [h, s, p] = createhg (s, p, par, hilev);
   endif
 
   ## children
-  matchin = [matchin [hgS.handle; h]]; # [original; new]
-  kids = hgS.children;
+  p = [p [s.handle; h]];  # [original; new]
+  kids = s.children;
   nkids = length (kids);
   ii = 0;
-  while nkids
+  while (nkids)
     ii++;
-    if (! any (ii == hgS.special))
-      [h2, matchin] = struct2hdl (hgS.children(ii),
-                                  [matchin [hgS.handle; h]], hilev);
+    if (! any (ii == s.special))
+      [h2, p] = struct2hdl (s.children(ii), [p [s.handle; h]], hilev);
     endif
     nkids--;
   endwhile
 
   ## paste properties
-  setprops (hgS, h, matchin, hilev);
+  setprops (s, h, p, hilev);
 
-  matchout = matchin;
+  pout = p;
 
 endfunction
 
-function [h, hgSout] = createaxes (hgS, matchin, par);
+function [h, sout] = createaxes (s, p, par)
   ## regular axes
-  if (strcmpi (hgS.properties.tag, ""))
-    propval = {"position", hgS.properties.position};
+  if (strcmp (s.properties.tag, ""))
+    propval = {"position", s.properties.position};
     hid = {"autopos_tag", "looseinset"};
     for ii = 1:numel (hid)
       prop = hid{ii};
-      if (isfield (hgS.properties, prop))
-        val = hgS.properties.(prop);
+      if (isfield (s.properties, prop))
+        val = s.properties.(prop);
         propval = [propval, prop, val];
       endif
     endfor
     h = axes (propval{:}, "parent", par);
 
-    if isfield (hgS.properties, "__plotyy_axes__")
-      plty = hgS.properties.__plotyy_axes__;
-      addproperty ("__plotyy_axes__", h, "any")
-      tmp = [matchin [hgS.handle; h]];
-      tst = arrayfun (@(x) any (plty == x), tmp (1:2:end));
-      if sum (tst) == numel (plty)
+    if (isfield (s.properties, "__plotyy_axes__"))
+      plty = s.properties.__plotyy_axes__;
+      addproperty ("__plotyy_axes__", h, "any");
+      tmp = [p [s.handle; h]];
+      tst = arrayfun (@(x) any (plty == x), tmp(1:2:end));
+      if (sum (tst) == numel (plty))
         for ii = 1:numel (plty)
-          plty(ii) = tmp (find (tmp == plty(ii)) + 1);
+          plty(ii) = tmp(find (tmp == plty(ii)) + 1);
         endfor
         for ii = 1:numel (plty)
           set (plty(ii), "__plotyy_axes__", plty);
         endfor
       endif
-      hgS.properties = rmfield (hgS.properties, "__plotyy_axes__");
+      s.properties = rmfield (s.properties, "__plotyy_axes__");
     endif
 
     ## delete non-default and already set properties
-    fields = fieldnames (hgS.properties);
+    fields = fieldnames (s.properties);
     tst = cellfun (@(x) isprop (h, x), fields);
-    hgS.properties = rmfield (hgS.properties,  fields(find (tst == 0)));
+    s.properties = rmfield (s.properties, fields(find (tst == 0)));
 
-  elseif (strcmpi (hgS.properties.tag, "legend"))
+  elseif (strcmp (s.properties.tag, "legend"))
     ## legends
-    oldax = hgS.properties.userdata.handle;
-    idx = find (matchin == oldax);
-    newax = matchin(idx+1);
+    oldax = s.properties.userdata.handle;
+    idx = find (p == oldax);
+    newax = p(idx+1);
     strings = {};
-    kids = hgS.children;
-    kids(hgS.special) = [];
+    kids = s.children;
+    kids(s.special) = [];
     oldh = unique (arrayfun (@(x) x.properties.userdata(end), kids));
     for ii = 1:length (oldh)
-      idx = find (matchin(1:2:end) == oldh(ii)) * 2;
+      idx = find (p(1:2:end) == oldh(ii)) * 2;
       if (! isempty (idx))
-        newh(ii) = matchin (idx);
+        newh(ii) = p(idx);
         if (! strcmp (get (newh(ii), "type"), "hggroup"))
           str = get (newh(ii), "displayname");
           strings = [strings str];
@@ -208,93 +207,93 @@
           strings = [strings str];
         endif
       else
-        error ("struct2hdl: didn't find a legend item")
+        error ("struct2hdl: didn't find a legend item");
       endif
     endfor
-    location = hgS.properties.location;
-    orientation = hgS.properties.orientation;
-    textpos = hgS.properties.textposition;
-    box = hgS.properties.box;
+    location = s.properties.location;
+    orientation = s.properties.orientation;
+    textpos = s.properties.textposition;
+    box = s.properties.box;
 
     h = legend (newax, newh, strings, "location", location, ...
                 "orientation", orientation);
     set (h, "textposition", textpos); # bug makes "textposition"
-                                # redefine the legend
+                                      # redefine the legend
     h = legend (newax, newh, strings, "location", location, ...
                 "orientation", orientation);
     ## box
     if (strcmp (box, "on"))
-      legend boxon
+      legend ("boxon");
     endif
 
     ## visibility
     tst = arrayfun (@(x) strcmp (x.properties.visible, "on"), kids);
-    if !any (tst)
+    if (! any (tst))
       legend ("hide");
     endif
 
     ## remove all properties such as "textposition" that redefines
     ## the entire legend. Also remove chidren
-    hgS.properties = rmfield (hgS.properties, ...
-                                {"userdata", "xlabel",...
-                                 "ylabel", "zlabel", "location", ...
-                                 "title", "string","orientation", ...
-                                 "visible", "textposition"});
+    s.properties = rmfield (s.properties, ...
+                              {"userdata", "xlabel",...
+                               "ylabel", "zlabel", "location", ...
+                               "title", "string","orientation", ...
+                               "visible", "textposition"});
 
-    hgS.children = [];
+    s.children = [];
 
-  elseif (strcmpi (hgS.properties.tag, "colorbar"))
+  elseif (strcmp (s.properties.tag, "colorbar"))
     ## colorbar
-    oldax = hgS.properties.axes;
-    if (! isempty (idx = find (oldax == matchin)))
-      ax = matchin(idx+1);
-      location = hgS.properties.location;
+    oldax = s.properties.axes;
+    if (! isempty (idx = find (oldax == p)))
+      ax = p(idx+1);
+      location = s.properties.location;
       h = colorbar ("peer", ax, location);
-      hgS.properties = rmfield (hgS.properties, ...
-                              {"userdata", "xlabel" ...
-                               "ylabel", "zlabel", ...
-                               "title", "axes"});
-      hgS.children= [];
+      s.properties = rmfield (s.properties, ...
+                                {"userdata", "xlabel" ...
+                                 "ylabel", "zlabel", ...
+                                 "title", "axes"});
+      s.children= [];
     else
-      error ("hdl2struct: didn't find an object")
+      error ("hdl2struct: didn't find an object");
     endif
   endif
-  hgSout = hgS;
+  sout = s;
 endfunction
 
-function [h] = createline (hgS, par);
+function h = createline (s, par)
   h = line ("parent", par);
-  addmissingprops (h, hgS.properties);
+  addmissingprops (h, s.properties);
 endfunction
 
-function [h, hgSout] = createpatch (hgS, par);
-  prp.faces = hgS.properties.faces;
-  prp.vertices = hgS.properties.vertices;
-  prp.facevertexcdata = hgS.properties.facevertexcdata;
+function [h, sout] = createpatch (s, par)
+  prp.faces = s.properties.faces;
+  prp.vertices = s.properties.vertices;
+  prp.facevertexcdata = s.properties.facevertexcdata;
   h = patch (prp);
   set (h, "parent", par);
-  hgS.properties = rmfield (hgS.properties,
+  s.properties = rmfield (s.properties,
                             {"faces", "vertices", "facevertexcdata"});
-  addmissingprops (h, hgS.properties);
-  hgSout = hgS;
+  addmissingprops (h, s.properties);
+  sout = s;
 endfunction
 
-function [h] = createtext (hgS, par);
+function h = createtext (s, par)
   h = text ("parent", par);
-  addmissingprops (h, hgS.properties)
+  addmissingprops (h, s.properties);
 endfunction
 
-function [h] = createimage (hgS, par);
+function h = createimage (s, par)
   h = image ("parent", par);
-  addmissingprops (h, hgS.properties)
+  addmissingprops (h, s.properties);
 endfunction
 
-function [h] = createsurface (hgS, par);
+function h = createsurface (s, par)
   h = surface ("parent", par);
-  addmissingprops (h, hgS.properties)
+  addmissingprops (h, s.properties);
 endfunction
 
-function [h, hgSout, matchout] = createhg (hgS, matchin, par, hilev)
+function [h, sout, pout] = createhg (s, p, par, hilev)
   ## Here we infer from properties the type of hggroup we should build
   ## an call corresponding high level functions
   ## We manually set "hold on" to avoid next hggroup be deleted
@@ -302,57 +301,57 @@
 
   hold on;
   if (hilev)
-    [h, hgS, matchin] = createhg_hilev (hgS, matchin, par);
-    if (numel (hgS.children) != numel (get (h).children))
-      warning (["struct2hdl: couldn't infer the hggroup type. ", ...
+    [h, s, p] = createhg_hilev (s, p, par);
+    if (numel (s.children) != numel (get (h).children))
+      warning (["struct2hdl: could not infer the hggroup type. ", ...
                 "Will build objects but listener/callback functions ", ...
                 "will be lost"]);
-      if isfield (h, "bargroup")
+      if (isfield (h, "bargroup"))
         delete (get (h).bargroup);
       else
         delete (h);
       endif
       h = hggroup ("parent", par);
-      addmissingprops (h, hgS.properties);
-      hgS.special = [];
+      addmissingprops (h, s.properties);
+      s.special = [];
     else
-      oldkids = hgS.children;
+      oldkids = s.children;
       newkids = get (h).children;
       nkids = numel (oldkids);
       ii = 1;
-      while nkids
-        matchin = [matchin [oldkids(ii++).handle; newkids(nkids--)]];
+      while (nkids)
+        p = [p [oldkids(ii++).handle; newkids(nkids--)]];
       endwhile
     endif
   else
     h = hggroup ("parent", par);
-    addmissingprops (h, hgS.properties);
-    hgS.special = [];
+    addmissingprops (h, s.properties);
+    s.special = [];
   endif
-  hgSout = hgS;
-  matchout = matchin;
+  sout = s;
+  pout = p;
 endfunction
 
-function [h, hgSout, matchout] = createhg_hilev (hgS, matchin, par)
-  fields = hgS.properties;
+function [h, sout, pout] = createhg_hilev (s, p, par)
+  fields = s.properties;
   if (isfield (fields, "contourmatrix"))
     ## contours
-    xdata = hgS.properties.xdata;
-    ydata = hgS.properties.ydata;
-    zdata = hgS.properties.zdata;
-    levellist = hgS.properties.levellist;
-    textlist = hgS.properties.textlist;
+    xdata = s.properties.xdata;
+    ydata = s.properties.ydata;
+    zdata = s.properties.zdata;
+    levellist = s.properties.levellist;
+    textlist = s.properties.textlist;
 
     ## contour creation
-    if (isempty (hgS.children(1).properties.zdata))
-      if (strcmpi (hgS.properties.fill, "on"))
+    if (isempty (s.children(1).properties.zdata))
+      if (strcmpi (s.properties.fill, "on"))
         [cm2, h] = contourf (xdata, ydata, zdata, levellist);
       else
         [cm2, h] = contour (xdata, ydata, zdata, levellist);
       endif
 
       ## labels
-      if (strcmpi (hgS.properties.showtext, "on"))
+      if (strcmpi (s.properties.showtext, "on"))
         clabel (cm2, h, textlist);
       endif
     else
@@ -360,7 +359,7 @@
     endif
 
     ## delete already set properties and children
-    hgS.properties = rmfield (hgS.properties, ...
+    s.properties = rmfield (s.properties, ...
                               {"xdata", "ydata", "zdata", ...
                                "contourmatrix", "levellist", ...
                                "fill", "labelspacing", ...
@@ -372,16 +371,16 @@
 
   elseif (isfield (fields, "udata") && isfield (fields, "vdata"))
     ## quiver
-    xdata = hgS.properties.xdata;
-    ydata = hgS.properties.ydata;
+    xdata = s.properties.xdata;
+    ydata = s.properties.ydata;
 
-    udata = hgS.properties.udata;
-    vdata = hgS.properties.vdata;
+    udata = s.properties.udata;
+    vdata = s.properties.vdata;
 
     h = quiver (xdata, ydata, udata, vdata);
 
     ## delete already set properties and children
-    hgS.properties = rmfield (hgS.properties, ...
+    s.properties = rmfield (s.properties, ...
                               {"xdata", "ydata", "zdata", ...
                                "xdatasource", "ydatasource", "zdatasource", ...
                                "udata", "vdata", "wdata", ...
@@ -389,13 +388,13 @@
 
   elseif (isfield (fields, "format"))
     ##errorbar
-    form = hgS.properties.format;
-    xdata = hgS.properties.xdata;
-    ydata = hgS.properties.ydata;
-    xldata = hgS.properties.xldata;
-    ldata = hgS.properties.ldata;
-    xudata = hgS.properties.xudata;
-    udata = hgS.properties.udata;
+    form = s.properties.format;
+    xdata = s.properties.xdata;
+    ydata = s.properties.ydata;
+    xldata = s.properties.xldata;
+    ldata = s.properties.ldata;
+    xudata = s.properties.xudata;
+    udata = s.properties.udata;
 
     switch form
       case "xerr"
@@ -411,10 +410,10 @@
       case "boxxy"
         h = errorbar (xdata, ydata, xldata, xudata, ldata, udata, "#~>");
       otherwise
-        error ("struct2hdl: couldn't guess the errorbar format")
+        error ("struct2hdl: couldn't guess the errorbar format");
     endswitch
     ## delete already set properties
-    hgS.properties = rmfield (hgS.properties, ...
+    s.properties = rmfield (s.properties, ...
                               {"xdata", "ydata", ...
                                "xldata", "ldata", ...
                                "xudata", "udata", ...
@@ -429,20 +428,20 @@
     ## and rebuild the whole bargroup.
     ## The duplicate are deleted after calling "setprops"
 
-    bargroup = hgS.properties.bargroup;
-    oldh = hgS.handle;
+    bargroup = s.properties.bargroup;
+    oldh = s.handle;
 
-    temp = arrayfun (@(x) any(x == bargroup), [matchin(1:2:end) oldh]);
+    temp = arrayfun (@(x) any(x == bargroup), [p(1:2:end) oldh]);
     tst = sum (temp) == length (bargroup);
 
     if (isscalar (bargroup) || !tst)
-      xdata = hgS.properties.xdata;
-      ydata = hgS.properties.ydata;
+      xdata = s.properties.xdata;
+      ydata = s.properties.ydata;
 
       h = bar (xdata, ydata);
 
       ## delete already set properties,
-      hgS.properties = rmfield (hgS.properties, ...
+      s.properties = rmfield (s.properties, ...
                                 {"xdata", "ydata", ...
                                  "xdatasource", "ydatasource", ...
                                  "bargroup", ...
@@ -453,18 +452,18 @@
 
       ##build x/y matrix
       nbar = length (bargroup);
-      tmp = struct ("handle", NaN,"type", "", "children", [], "special", []);
+      tmp = struct ("handle", NaN, "type", "", "children", [], "special", []);
       for ii = 1:(nbar - 1)
-        idx = find (matchin(1:2:end) == bargroup(ii)) * 2;
-        hdl = matchin (idx);
+        idx = find (p(1:2:end) == bargroup(ii)) * 2;
+        hdl = p (idx);
         xdata = [xdata get(hdl).xdata];
         ydata = [ydata get(hdl).ydata];
         tmp.children(ii) = hdl2struct (hdl);
       endfor
 
-      xdata = [xdata hgS.properties.xdata];
-      ydata = [ydata hgS.properties.ydata];
-      width = hgS.properties.barwidth;
+      xdata = [xdata s.properties.xdata];
+      ydata = [ydata s.properties.ydata];
+      width = s.properties.barwidth;
       h = bar (ydata, width);
 
       ## replace previous handles in "match", copy props and delete redundant
@@ -472,82 +471,82 @@
         props = tmp.children(ii).properties;
         bl = props.baseline;
         tmp.children(ii).properties = rmfield (props, {"baseline", "bargroup"});
-        setprops (tmp.children(ii), h(ii), matchin, 1);
+        setprops (tmp.children(ii), h(ii), p, 1);
         delete (tmp.children(ii).handle);
         delete (bl);
-        idxpar = find (matchin == tmp.children(ii).handle);
-        matchin (idxpar) = h(ii);
+        idxpar = find (p == tmp.children(ii).handle);
+        p(idxpar) = h(ii);
         idxkid = idxpar - 2;
-        matchin (idxkid) = get (h(ii), "children");
+        p(idxkid) = get (h(ii), "children");
       endfor
-      matchin (2,((end-nbar+2):end)) = h (1:(end-1));
-      h = h (end);
+      p(2,((end-nbar+2):end)) = h(1:(end-1));
+      h = h(end);
 
       ## delete already set properties ,
-      hgS.properties = rmfield (hgS.properties, ...
+      s.properties = rmfield (s.properties, ...
                                 {"xdata", "ydata", "bargroup"...
                                  "barwidth", "baseline"});
     endif
   elseif (isfield (fields, "baseline"))
     ## stem plot
-    xdata = hgS.properties.xdata;
-    ydata = hgS.properties.ydata;
+    xdata = s.properties.xdata;
+    ydata = s.properties.ydata;
 
     h = stem (xdata, ydata);
 
     ## delete already set properties,
-    hgS.properties = rmfield (hgS.properties, ...
+    s.properties = rmfield (s.properties, ...
                               {"xdata", "ydata", ...
                                "xdatasource", "ydatasource", ...
                                "baseline"});
   elseif (isfield (fields, "basevalue"))
     ## area plot
-    xdata = hgS.properties.xdata;
-    ydata = hgS.properties.ydata;
-    level = hgS.properties.basevalue;
+    xdata = s.properties.xdata;
+    ydata = s.properties.ydata;
+    level = s.properties.basevalue;
 
     h = area (xdata, ydata, level);
 
     ## delete already set properties,
-    hgS.properties = rmfield (hgS.properties, ...
+    s.properties = rmfield (s.properties, ...
                               {"xdata", "ydata", ...
                                "xdatasource", "ydatasource"});
   else
-    warning ("struct2hdl: couldn't infer the hggroup type. Will build objects but listener/callback functions will be lost");
+    warning ("struct2hdl: could not infer the hggroup type. Will build objects but listener/callback functions will be lost");
     h = hggroup ("parent", par);
-    addmissingprops (h, hgS.properties);
-    hgS.special = [];           # children will be treated as normal children
+    addmissingprops (h, s.properties);
+    s.special = [];           # children will be treated as normal children
   endif
-  hgSout = hgS;
-  matchout = matchin;
+  sout = s;
+  pout = p;
 endfunction
 
-function setprops (hgS, h, matchin, hilev)
-  more off
-  if (strcmpi (hgS.properties.tag, ""))
-    specs = hgS.children(hgS.special);
+function setprops (s, h, p, hilev)
+  more off;
+  if (strcmpi (s.properties.tag, ""))
+    specs = s.children(s.special);
     hdls = arrayfun (@(x) x.handle, specs);
-    nh = length(hdls);
+    nh = length (hdls);
     msg = "";
     if (! nh)
-      set (h, hgS.properties);
+      set (h, s.properties);
     else
       ## Specials are objects that where automatically constructed with
       ## current object. Among them are "x(yz)labels", "title", high
       ## level hggroup children
-      fields = fieldnames (hgS.properties);
-      vals = struct2cell (hgS.properties);
+      fields = fieldnames (s.properties);
+      vals = struct2cell (s.properties);
       idx = find (cellfun (@(x) valcomp(x, hdls) , vals));
-      hgS.properties = rmfield (hgS.properties, fields(idx));
+      s.properties = rmfield (s.properties, fields(idx));
 
       ## set all properties but special handles
-      set (h, hgS.properties);
+      set (h, s.properties);
 
       ## find  props with val == (one of special handles)
       nf = length (idx);
       fields = fields(idx);
       vals = vals(idx);
-      while nf
+      while (nf)
         field = fields{nf};
         idx = find (hdls == vals{nf});
         spec = specs(idx);
@@ -561,39 +560,39 @@
       ## If hggroup children  were created by high level functions,
       ## copy only usefull properties.
       if (hilev)
-        if (strcmpi (hgS.type, "hggroup"))
-          nold = numel (hgS.children);
-          nnew = numel (get(h).children);
+        if (strcmp (s.type, "hggroup"))
+          nold = numel (s.children);
+          nnew = numel (get (h).children);
 
           if (nold == nnew)
-            hnew = get(h).children;
+            hnew = get (h).children;
             ii = 1;
-            while ii <= nnew
+            while (ii <= nnew)
               try
                 set (hnew (ii), "displayname", ...
-                     hgS.children(ii).properties.displayname);
+                     s.children(ii).properties.displayname);
               catch
-                sprintf ("struct2hdl: couldn't set hggroup children #%d props.", ii)
+                sprintf ("struct2hdl: couldn't set hggroup children #%d props.", ii);
               end_try_catch
               ii ++;
             endwhile
 
           else
-            error ("struct2hdl: non-conformant number of children in hgggroup")
+            error ("struct2hdl: non-conformant number of children in hgggroup");
           endif
         endif
       endif
     endif
 
-  elseif (strcmpi (hgS.properties.tag, "legend")
-          || strcmpi (hgS.properties.tag, "colorbar"))
-    set (h, hgS.properties);
+  elseif (strcmpi (s.properties.tag, "legend")
+          || strcmpi (s.properties.tag, "colorbar"))
+    set (h, s.properties);
   endif
 
 endfunction
 
 function out = valcomp (x, hdls)
-  if (isfloat(x) && isscalar(x))
+  if (isfloat (x) && isscalar (x))
     out = any (x == hdls);
   else
     out = 0;
@@ -606,10 +605,13 @@
   curfields = fieldnames (get (h));
   missing = cellfun (@(x) !any (strcmp (x, curfields)), oldfields);
   idx = find (missing);
-  for ii = 1:length(idx)
+  for ii = 1:length (idx)
     prop = oldfields{idx(ii)};
     if (! any (strcmp (prop, hid)))
       addproperty (prop, h, "any");
     endif
   endfor
 endfunction
+
+
+## FIXME: Need validation tests