Thanks for the quick and informative reply! This really solved my issue.

Keep up the good work!

kind regards,

Sean Luke wrote:
> On May 5, 2008, at 11:11 AM, Björn Raupach wrote:
>> hope this software is still alive ;-)
> Very much so.
>> Everything worked right out of the box, except some naming conflict - 
>> Java 6 introduces also some kind of console.
> Yeah.  We're gonna have to deal with that.  :-(
>> But I am having trouble with adding a 
>> TimeSeriesChartingPropertyInspector. I would like to display some 
>> property of my agents in a timeseries chart. There is a 
>> TimeSeriesChartingPropertyInspector in the source, but it is never 
>> referenced. Searching the mailing list didn't help much either. Could 
>> you help me out? How to display variables of agents in a proper way?
> A very good question.  But it's got an easy answer.  
> PropertyInspectors are dynamically loaded at runtime, so you'll not 
> find them referred to anywhere among the symbols of the program.  
> Instead, they're listed in the 
> sim/portrayal/inspector/propertyinspector.classes file.  When you 
> click on the magnifying class of any element in a SimpleInspector in 
> MASON, and its type matches the registered types of a 
> PropertyInspector (for example, <double> or <int> among others for 
> TimeSeriesChartingPropertyInspector), you'll be able to choose that 
> inspector in the pop-up menu.
> Some information you will find useful can be found in the 
> docs/howto.html file:
>     - How to create a time series chart programmatically rather than 
> automatically ** USEFUL
>     - How to create a PropertyInspector (see below for an explanation 
> of what that is)
>     - How to add a Slider or Pop-up Menu to an Inspected Property
>     - How to create a Field Portrayal Inspector
>     - How to create an inspector which holds other inspectors
> Now some background in case you're interested.  MASON's inspector 
> mechanism is a little more complicated than I'd like, mostly due to 
> some historical changes.  There are basically three kinds of inspectors:
> - SimpleInspectors, which let you examine and manipulate the 
> properties of entire object.  There are two uses for SimpleInspectors: 
> (1) to inspect the primary model object directly -- or the object the 
> model offers to represent itself -- and (2) to inspect various 
> individual elements in the model as the user requests (in fact, 
> elements' Portrayals can return inspectors other than 
> SimpleInspectors, but they usually don't).
> - PropertyInspectors, which let you examine a specific property in an 
> object all on its own.  The important distinction here is that an 
> SimpleInspector works on an *object*, whereas a PropertyInspector 
> works on an <object, property> pair.  PropertyInspectors do not 
> register themselves for specific properties: but rather they're 
> registered for *types* of properties (doubles, ints, arrays of 
> different kinds, various classes, etc.), and so are available for any 
> property of their registered type(s).
> Let's look at HeatBugs for a moment as an example:
>     java
> 1. If you click on the "Model" tab, MASON calls 
> HeatBugsWithUI.getSimulationInspectedObject() to get the object to 
> inspect.  By default this returns the underlying SimState (the 
> HeatBugs object).  MASON then constructs a SimpleInspector based on 
> that object.
> 2. Next, run the simulation and pause it, then double-click on a 
> heatbug.  You may need to zoom in a bit go nail it.  You'll get the 
> inspectors window pop up.  Here MASON has queried all the Fields in 
> your model (in this case, the Heat model (a DoubleGrid2D) and the Bugs 
> model (a SparseGrid2D) for every element which intersects with the 
> point where you double-clicked.  It then requests an Inspector 
> (typically it gets a SimpleInspector) from the SimplePortrayal 
> responsible for each of those elements.  MASON then sticks all those 
> Inspectors in a list, which is what you see.
> 3. Now click on the Heat in the Inspector List if it's not already 
> selected, and you'll see it has a single Property called "Value".  
> Next to the Value is a small magnifying glass icon.  Click on that and 
> you see you can Stream or Chart this Property.  These are the 
> PropertyInspectors which have registered themselves as available for 
> the <double> type, which is what this Property returns.  MASON 
> gathered these by calling PropertyInspector.getPopupMenu(), which 
> loads all the PropertyInspectors if they've not been loaded, and then 
> examines the PropertyInspector.classes Bag for all 
> PropertyInspectors.  For each one, it calls types(), to return an 
> array of types, and searches them for the presence of the <double> 
> type.  The ones that match the type are made available in the menu.
> 4. Choose "Chart" on the pop-up menu, and a chart is popped up.  
> Here's your TimeSeriesChartingPropertyInspector!  This is done by 
> calling PropertyInspector.makeInspector(...) to construct the 
> inspector.  At this point, your PropertyInspector has two ways to back 
> out of being created.  First, your PropertyInspector can pop up a 
> dialog asking the user whether it should be constructed or not -- if 
> the user cancels, then your PropertyInspector sets isValidInspector() 
> to return true and makeInspector() will return null.  Second, your 
> PropertyInspector can opt not to create a separate window.  For 
> example, TimeSeriesChartingPropertyInspector has the ability to chart 
> multiple properties in the same window, so it only creates one window 
> initially and the others are just glommed into that window as the user 
> requests.  to do this, its shouldCreateFrame() method returns false.
> Sean

Bjoern Raupach
Information Technology Group
Department of Engineering, KaHo Sint-Lieven
Gebr. Desmetstraat 1, B-9000 Gent, Belgium
E-mail: [log in to unmask]