Versions Compared

Old Version 17

changes.mady.by.user Unknown User (serbo)

Saved on

compared with

New Version Current

changes.mady.by.user Unknown User (serbo)

Saved on

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.
Comment: Migration of unmigrated content due to installation of a new plugin

...

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:

  • object type: hep.aida.IHistogram1D, org.myproject.MyData1D
  • object path: with path expressions like "MC/**"
  • plot order: a specific order position, 0, 7 or a cyclical recurrence (3) -> every third plot
  • action: like printing (plots for printing might require less details)
  • category: "experiment=GLAST, quality=preliminary"

Style Registry

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:

  • passed style (when plotting)
  • explicit in annotation (like labels)
  • implicit:
    • action
    • category
    • plot order
    • path
    • type

Style Editor

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.

Comments to AIDA Styles

  • does isVisible() belong to IBaseStyle?
  • can we plot an object by passing only an IDataStyle (rather than an IPlotterStyle)?

 

Ideas for Implementation

...

Also StyleRegistry can manage the Categories: list of all available keys and set of current values.

Code Block
package hep.aida.ref.plotter.style.registry;

import hep.aida.IPlotterStyle;

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[] getAvailableCategoryValues(String getCategoryValue categoryKey);
   
    String getCategoryCurrentValue(String categoryKey);
   
    void setCategoryCurrentValue(String categoryKey, String categoryValue);
   
    // Following methods are used to obtain cumulative IPlotterStyle
    // for particular plotter, region, object, action, and (possibly) categories
   
    IPlotterStyle getStyleForState(IPlotterState state);
}

IStyleStore interface:

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.  

Code Block
package hep.aida.ref.plotter.style.registry;

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 {
   
    // Key for AIDA type of object that the Style is going to be used with
    public static String STYLE_PREVIEW_TYPE = "STYLE_PREVIEW_TYPE";
   
    // Key for Style name
    public static String STYLE_STORE_NAME = "STYLE_STORE_NAME";
           
    String getStoreName();
   
    String getStoreType();
   
    boolean isReadOnly();
   
   
    // Manage Styles
   
    boolean hasStyle(String styleName);
   
    void addStyle(String styleName, IPlotterStyle style);
   
    booleanvoid hasStyleaddStyle(String styleName, IPlotterStyle style, IStyleRule rule);
   
    IPlotterStyle getStyle(String styleName);
   
    /**
     * Remove Style and allRule Rules associated with it from the Store
     */
    IPlotterStyle removeStyle(String styleName);
   
    String[] getAllStyleNames();
   
   
    // Create new Rule for this Store - Store acts as a Rule Factory
   
    IStyleRule[] getRulesForStylecreateRule(String styleName);
   
   
    void addRuleForStyle(String styleName, IStyleRule rule); // Manage Rules - only one rule per style is allowed
   
    voidIStyleRule setRuleForStylegetRuleForStyle(String styleName, IStyleRule rule);
   
    void removeRuleForStylesetRuleForStyle(String styleName, IStyleRule rule);
   
    void removeAllRulesForStyleremoveRuleForStyle(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();
          
}

IStyleRule interface:

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.

contains expression that is evaluated at run-time

Code Block

package hep.aida.ref.plotter.style.registry;
Code Block

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:
     \*/
    
    public static String PATH = "Path";
    public static String OBJECT = "Object";
    public static String OBJECTTYPE = "ObjectType";
    public static String NULL = "Null";
    public static String ATTRIBUTE = "attribute(\"\")";
    public static String OVERLAYINDEX = "OverlayIndex";
    public static String OVERLAYTOTAL = "OverlayTotal";
    public static String REGIONINDEX = "RegionIndex";
    public static String REGIONTOTAL = "RegionTotal";
       
    String getDescription();
   
    // Evaluates the Rule   
    boolean ruleApplies(IPlotterState state);
}

...

  • CLASS
    • Plotted object is exactly instance of specified class
    • Plotted object is derived from specified class
  • PATH
    • Path contains specified sub-path
      • Case sensitive
      • NOT Case sensitive
    • Regular expression
  • ORDER
    • Absolute number of overlaid plots, like 3-rd
    • Position in the recurring sequence, like 4-th out of 7
  • ATTRIBUTE: match "key=value" pair
    • Case sensitive
    • NOT Case sensitive
  • ACTION: match action name
    • Case sensitive
    • NOT Case sensitive
  • CATEGORY: match "key=value" pair
    • Case sensitive
    • NOT Case sensitive

IPlotterState interface:

code
Code Block
package hep.aida.ref.plotter.style.registry;

/*\*
 \ * This object encapsulates information about relevant
 \ * IPlotterRegion, object, and actions.
 \ * It is used for obtaining implicit IPlotterStyle
  */

import java.util.Map;

public interface IPlotterState {
   
    // IStyleRule types are used here
    String getValueForType(int styleRuleType);
   
}



    static String ATTRIBUTE_KEY_PREFIX = "IPlotterState";
           
    Object getObject();   
    String getObjectPath();
   
    int getOverlayIndex();
    int getOverlayTotal();
   
    int getRegionIndex();
    int getRegionTotal();
   
    String getAttribute(String key);
   
    Map getAttributes();   
   
    void clear();
}