This is a collection of thoughts on AIDA Styles and on their use in the new plotter.
This is an object that can save and retrieve styles from a store (xml file on disk, database table). The basic xml style definition is the AIDA one. Next to the style itself we also identified the need to define Style Rules that should also be saved/retrieved to/from the store:
<styleStore>
<styles>
<style>
.......
<rules>
<rule>
.......
</rule>
</rules>
</style>
</styles>
</styleStore>
|
Multiple stores might be loaded at once: System Store, Personal Store, Group Store, Experiment Store. Their information is grouped and managed by a Style Registry
It should be possible to define rules on how to attach a style to a particular plot object. Multiple rules might be applied to a given style. It should be possible to apply rules to:
A style registry combines the styles and rules from different style stores and provides the right set of styles (with the appropriate Style Order) for a given plot object.
We have to define the order in which the styles are applied to an object:
GUI front end for viewing and editing individual styles or combinations of styles.
We already have a first version of the style editor. We need to add the possibility to view the information contained in a style registry, i.e. the chain of styles contributing to a given object and the set of rules that have contributed to it.
Let's leave Style Store out of this discussion just for the moment.
So Style Registry is created and is getting populated by (or just acts as a manager/façade for) the Style Stores, but it has access to Style/Rules information.
Just before object is plotted/printed and we know the object's path in a Tree, object's type, order of the object in particular IPlotterRegion, etc. All this information is used to query the Style Registry and create a cumulative IPlotterStyle for the implicit parameters.
Information that we need:
If any styles are passed explicitly to the plotter, this implicit cumulative style will be set as parent (or merged in as a lower priority Style).
I've set three interfaces that might do the job (below), have a look.
IPlotterStore in StyleRegistry is identified by a name (storeName). Store names have to be unique.
Also StyleRegistry can manage the Categories: list of all available keys and set of current values.
public interface IStyleRegistry {
// To work with Style Stores
String[] getAvailableStoreNames();
IStyleStore getStore(String storeName);
// To work with categories, this can be a separate service
// Available category keys are filled from Rules of all available Stores
String[] getAvailableCategoryKeys();
String getCategoryValue(String categoryKey);
void setCategoryCurrentValue(String categoryKey, String categoryValue);
// Following methods are used to obtain cumulative IPlotterStyle
// for particular region, object, action, and (possibly) categories
IPlotterStyle getStyleForState(IPlotterState state);
}
|
Style Rule has type and value. Rule applies to the IPlotterState if state has approptiate type, and rule value is compatible with the state value.
import hep.aida.IPlotterStyle;
/**
* This interface can be implemented as "In-Memory" copy of persistent
* facility, or as keeping live connections and committing any change
* immediately.
*/public interface IStyleStore {
String getStoreName();
String getStoreType();
boolean isReadOnly();
void addStyle(String styleName, IPlotterStyle style);
boolean hasStyle(String styleName);
IPlotterStyle getStyle(String styleName);
/**
* Remove Style and all Rules associated with it from the Store
*/
IPlotterStyle removeStyle(String styleName);
String[] getAllStyleNames();
IStyleRule[] getRulesForStyle(String styleName);
void addRuleForStyle(String styleName, IStyleRule rule);
void setRuleForStyle(String styleName, IStyleRule rule);
void removeRuleForStyle(String styleName, IStyleRule rule);
void removeAllRulesForStyle(String styleName);
/**
* Write all information from Store to the undelying persistent
* facility: XML file, database, etc.
*/
void commit();
/**
* Close all connections and free all resources.
* Store is not usable after this method is executed.
*/
void close();
}
|
Style Rule has type and value. Rule applies to the IPlotterState if state has approptiate type, and rule value is compatible with the state value.Rules can be logically groupped together with "OR" or "AND" operation.
Also Rule has a priority - defines the order in which Style that corresponds to this Rule will be used if Rule does apply.
public interface IStyleRule {
// Possible types of Style Rules
static int CLASS = 0; // Class of the object: hep.aida.IHistogram1D
static int PATH = 1; // Position of the object in a Tree
static int ORDER = 2; // Order in the IPlotterRegion: specific number, or cyclical
static int ATTRIBUTE = 3; // Arbitrary "key=value" pair, evalyated by the Rule
// From AIDA object's annotation any entry with "plotterState." prefix in key
// will be stripped of this prefix and put into PlotterState with ATTRIBUTE
// type before obtaining Style from the StyleRegistry
static int ACTION = 4; // What is going to happen with the object: plotting, printing
static int CATEGORY = 5; // "experiment=GLAST", "quality=preliminary"
// ACTION seems like a sub-type of CATEGORY: "printing=true"
// Operations that chain rules together
static int AND = 0;
static int OR = 1;
int getType();
/*\*
* Priority determines the order in which corresponding IPlotterStyle
* should be used when assembling the cumulative IPlotterStyle
\*/
int getPriority();
String getDescription();
void addRule(IStyleRule rule, int operation);
/*\*
* Determines if this rule should be used.
*
* If type=CATEGORY, same rule as for AIDA options should be applied:
* have to pass "key=value" pair as value, for only "key" \-> "key=true",
\*/
boolean ruleApplies(int type, String value);
/*\*
* Or maybe it is better to hide this type/"key=value" complexity and do this:
\*/
boolean ruleApplies(IPlotterState state);
}
|
/*\*
\* This object encapsulates information about relevant
\* IPlotterRegion, object, and actions.
\* It is used for obtaining implicit IPlotterStyle
*/
public interface IPlotterState {
// IStyleRule types are used here
String getValueForType(int styleRuleType);
}
|