MATLAB: Can I store class properties in axes UserData

handle_classuserdata

I've been developing a class for a specialized kind of axes. Since we cannot derive classes from the built-in axes class, I have created a handle class that has an associated axes object as one of its properties. Since a figure with one of these specialized axes will be saved in a .fig file rather than a .mat file, I am storing my class properties in the UserData property of the associated axes object. My class constructor will then look for these properties if it is passed a .fig file as in input argument.

Some of my class properties are customized graphics objects, which class methods will expect to see. My problem is that when I attempt to set the value of one of these properties, it deletes all the other UserData fields and replaces all of them with this single value.

Here is a simplified version of what is happening:

Before setting the property for the graphics object I have this:

myAxes.UserData.myClassProperties

where myClassProperties is a struct with a couple dozen fields for the class properties, one of which is called 'EarthPatchHandle'. When I attempt to set that by doing this:

myAxes.UserData.myClassProperties.EarthPatchHandle = surfl(...);

All the other fields of myClassProperties disappear, and the only remaining field is EarthPatchHandle.

I suspect that I'm getting into trouble by storing a handle class object as a property of another handle class in the UserData property of another handle class, but I'm not sure about that.

Does anyone have any idea what's wrong with this?

[Note: there might well be a better design for what I'm trying to do, such as storing my full class object in the axes UserData, rather than individual properties. I'll start another question if that seems likely.]

Best Answer

So you want to create a custom plot type, along the same idea as the spider plot? If you're using release R2019b or later, take a look at part 3 of that blog series. In part 3 Sean walks through creating a custom spider plot chart.

As for why the UserData of your axes gets cleared using your current approach, see this documentation page for an explanation. Two axes properties are not reset when trying to create a new plot in an axes with its NextPlot property set to 'replace': Units and Position. The EarthPatchHandle field of the struct array myClassProperties stored in UserData doesn't remain, but it is recreated after the UserData property was cleared at the start of the surfl call.

Related Solutions

MATLAB: Do plotting commands delete axes UserData

This was a silly question - I just need to call

>> hold on

before plotting. I knew that about graphics objects, but hadn't realized that all the axes properties are replaced by new plot commands.

MATLAB: Multiple objects sharing a context menu

This is far too late top be of use to the person asking the question I am sure, but today I had to solve this same problem myself, did an internet search and bizarrely landed here to find my own suggestion which I hadn't even considered when thinking about a solution to this before my search today. So I have now implemented my idea and since it is just a general wrapper type class without any proprietary code I will add my solution here.

It may be there is some simpler way that both myself and the original asker of the question both missed, but even if there is, I enjoyed creating my own solution anyway!

classdef GraphicsObjectWithContextMenu < handle
  
  properties( SetAccess = immutable, GetAccess = private )
    hGraphics = [];
    
    hContextMenu = matlab.ui.container.ContextMenu.empty;
  end
  
  methods
    function obj = GraphicsObjectWithContextMenu( hGraphics )
      assert( isgraphics( hGraphics ), 'GraphicsObjectWithContextMenu:InvalidGraphicsObject', 'hGraphics must be a handle to a valid graphics object' );
      
      obj.hGraphics = hGraphics;
      
      obj.hContextMenu = uicontextmenu( );
      obj.hGraphics.UIContextMenu = obj.hContextMenu;
    end
    
    function addMenuItem( obj, menuItem, callback )
      validateattributes( menuItem, { 'matlab.ui.container.Menu' }, { 'scalar' } )
      validateattributes( callback, { 'function_handle' }, { 'scalar' } )
      assert( nargin( callback ) == 1, 'GraphicsObjectWithContextMenu:InvalidMenuCallback', 'callback must be a function handle of exactly 1 argument, representing the graphics object to which the context menu is attached' );
      
      menuItem.Parent = obj.hContextMenu;
      
      fCallback = @( src,evt ) callback( obj.hGraphics );
      menuItem.Callback = fCallback;
    end
  end
  
end

is the class I mentioned in the comments to the question. I had to put a little thought in to its structure as my original quickly thrown out suggestion didn't fully consider all the difficulties. Also this is not the only way to setup this class of course, it is just the way that I am happy with for my work.

Obviously some aspects of it are optional, but I like to validate things in my classes and assert where I consider it appropriate too for ease of usage, but that is just my preference - it is not crucial to the bare minimum solution.

And here is some simple example code to show it in use with multiple line objects. I just added one menu item to the context menu as it is the only one I need for my current work, but others can be added in just the same manner.

figure; hAxes = gca;
hold on
hLines(1) = plot( hAxes.XLim, [2 2], 'LineWidth', 2 );
hLines(2) = plot( hAxes.XLim, [3 3], 'LineWidth', 2 );
hLines(3) = plot( hAxes.XLim, [7 7], 'LineWidth', 2 );
hLines(4) = plot( hAxes.XLim, [8 8], 'LineWidth', 2 );
m1 = uimenu( 'Label', 'Remove' );
linesWithContextMenu = GraphicsObjectWithContextMenu.empty( 0, numel( hLines ) );
for n = 1:numel( hLines )
  linesWithContextMenu( n ) = GraphicsObjectWithContextMenu( hLines( n ) );
  linesWithContextMenu( n ).addMenuItem( m1.copy( ), @( lineHandle ) delete( lineHandle ) );
end

The key points of the solution are:

The handle-derived class allows you to wrap up an individual graphics object handle together with a context menu so that the context menu knows its triggering graphics object
The menu items have been added via a function which takes the callback as a separate argument to the menuItem in which it would normally live. This you can see is because the callback should have 1 variable argument, the graphics object handle, which this class function fills in to create the actual callback which the menu item will trigger. This means that your callback function can be anything you want that works with the handle of the graphics object that triggered the callback.
Usage should be very simple, but beware to take a copy of the menu item object when adding it to multiple objects, otherwise the same item will just keep getting re-parented and only the last object it is assigned to will actually have the context menu item.

Best Answer

Related Solutions

MATLAB: Do plotting commands delete axes UserData

MATLAB: Multiple objects sharing a context menu

Related Question