Fresnel - Display Vocabulary for RDF

User Manual, 30 June 2005

This version:
http://www.w3.org/2005/04/fresnel-info/manual-20050726/
 
Latest version:
http://www.w3.org/2005/04/fresnel-info/manual/
Editors:
Chris Bizer, Freie Universität Berlin <chris@bizer.de>
Ryan Lee, MIT/CSAIL W3C <ryanlee@w3.org>
Emmanuel Pietriga, INRIA <emmanuel.pietriga@inria.fr>

Abstract

Fresnel is a simple, browser-independent vocabulary for specifying how to display RDF models.


Table of Contents

Appendices


1. Introduction

Fresnel is a simple, browser-independent vocabulary for specifying how to display an RDF model [1] and how to style it using existing style languages such as CSS [2].

Displaying RDF in a human-friendly manner by way of an RDF display vocabulary is done differently in every application [5-11] [16-17] [19]. Recognizing the general need for displaying RDF and wanting to avoid reinventing the wheel with each new application, the authors jointly developed Fresnel as an extensible ontology of core RDF display concepts.

Fresnel's design goals are to create an ontology that is:

Fresnel's two foundational concepts are lenses and formats. Lenses define which properties of an RDF resource are displayed and how these properties are ordered. Fresnel formats determine how the selected properties are rendered by specifying RDF-specific formatting attributes and by providing hooks to CSS [2], which is used to specify fonts, colors, margins, borders, and other decorative elements.

Fresnel concepts

Fresnel adheres to a strict separation between data selection and formatting. The Fresnel rendering process can be decomposed in three steps:

  1. Selection: the parts of the RDF graph to be displayed are selected and ordered using Fresnel lenses. The result of the selection step is an ordered tree of RDF nodes, not containing any formatting information yet.
  2. Formatting: Fresnel formats are then applied to the tree, adding formatting information and hooks to CSS classes to nodes of the tree.
  3. Output Generation: the result of the second step is rendered into the appropriate output format.

Possible output formats include:

The choice of what output format to support, and how to interpret the formatted tree produced by the second step to produce the actual output (i.e., the third step), is a prerogative of each application. Fresnel expresses RDF presentation knowledge in a declarative way; Fresnel applications should take all formatting information into account, but are free to interpret and adapt them in a way that is appropriate w.r.t their fundamental representation paradigm (e.g. nested box-based textual representation la XHTML+CSS, node-link diagram, etc.). In other words, Fresnel does not dictate how to transform the tree resulting from the formatting step into an actual target document of the chosen output format.

Terminology

Fresnel takes an ontology-centric view on RDF models. RDF models are described in terms of resources which are instances of classes. Instances have properties, and properties have property values.

1.1 FOAF Example

The following example shows how Fresnel can be used to render FOAF [4] persons. All examples use the Notation 3 syntax for RDF.

@prefix fresnel:  <http://www.w3.org/2004/09/fresnel#> .
@prefix foaf:     <http://xmlns.com/foaf/0.1/> .
@prefix rdf:      <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix xsd:      <http://www.w3.org/2001/XMLSchema#> .
@prefix :         <#>

# -----------------------------------------------
# 1.Fresnel Lenses for FOAF Person
# -----------------------------------------------

:foafPersonDefaultLens rdf:type fresnel:Lens ;
                       fresnel:purpose fresnel:defaultLens ;
                       fresnel:classLensDomain foaf:Person ;
                       fresnel:group :foafGroup ;
                       fresnel:showProperties ( foaf:name 
                                                foaf:surname 
                                                foaf:depiction ) .

:knowsLens rdf:type fresnel:Lens ;
           fresnel:classLensDomain foaf:Person ;
           fresnel:group :foafGroup ;
           fresnel:showProperties ( foaf:name 
                                    foaf:surname
                                    foaf:mbox 
                                    [ rdf:type fresnel:PropertyDescription ;
                                      fresnel:property foaf:knows ;
                                      fresnel:sublens :foafPersonDefaultLens ] ) .
			                      
# -----------------------------------------------
# 2. Fresnel Formats
# -----------------------------------------------

:foafGroup rdf:type fresnel:Group ;
           fresnel:stylesheetLink <http://www.example.org/example.css> . 

:depictFormat rdf:type fresnel:Format ;
              fresnel:propertyFormatDomain foaf:depiction ;
              fresnel:label fresnel:none ;
              fresnel:value fresnel:image ;
              fresnel:valueStyle "imageWithThickBorder"^^fresnel:styleClass ; 
              fresnel:group :foafGroup .
	
:urlFormat rdf:type fresnel:Format ;
           fresnel:propertyFormatDomain foaf:homepage ;
           fresnel:propertyFormatDomain foaf:mbox ;
           fresnel:value fresnel:externalLink ;
           fresnel:labelStyle "basicLabel"^^fresnel:styleClass ;
           fresnel:valueStyle "basicUrl"^^fresnel:styleClass ;
           fresnel:group :foafGroup .

This Fresnel example declares two lenses which apply to instances of class foaf:Person as specified by property fresnel:lensDomain. The first lens defines a view on foaf:Person containing three properties: foaf:name, foaf:surname, and foaf:depiction. A Fresnel browser would start with displaying this lens because it is marked with the purpose fresnel:defaultLens. The second lens displays a person together with all other persons she knows. The fresnel:sublens property specifies that the :foafPersonDefaultLens should be used to display known people.

The second part of the stylesheet contains formatting declarations. The first declaration is a reference to an external CSS stylesheet. :depictFormat specifies that all values of property foaf:depiction should be displayed as images with solid borders. :urlFormat specifies that values of foaf:homepage and foaf:mbox should be rendered as external links using CSS styling instructions associated with CSS classes basicLabel and basicUri (defined in the external stylesheet referenced earlier).

1.2 Vocabulary Modules

In order to make it easier for developers to implement, Fresnel is modularized along two axes:

1.3 Selector Languages

Selectors are used within Fresnel to specify which RDF instances and properties should be displayed or formatted. Fresnel includes three different selector languages offering increasing expressiveness:

1.3.1 Simple Selectors

Simple selectors are the easiest but least expressive way to point at elements of RDF models. A simple selector is a URI reference represented as a QName (qualified name), which is interpreted as an instance, a class, or a property depending on the context (lens domain selector, format domain selector, property selector).

:foafPersonLens rdf:type fresnel:Lens ;
                fresnel:classLensDomain foaf:Person .

1.3.2 FSL Selectors

Selectors can also be specified using the Fresnel Selector Language (FSL) [13]. FSL is strongly inspired by XPath, and was created by adapting the XPath syntax and concepts to RDF's graph-based model and by deriving pieces from different RDFPath proposals.

Example: the following format applies only to persons that are exactly 30 years old.

:foafPersonFormat rdf:type fresnel:Format ;
                  fresnel:instanceFormatDomain "foaf:Person[ex:age/'30']"^^fresnel:fslSelector.
More information about FSL can be found in the Fresnel Selector Language Manual.

Note that when considered as literal values, simple selectors are also valid FSL expressions (see below and [13]).

1.3.3 SPARQL Selectors

In addition to FSL, some browsers might also want to take advantage of the full expressive power of SPARQL [12].

:foafPersonFormat rdf:type fresnel:Format ;
        fresnel:instanceFormatDomain "SELECT ?person 
          WHERE { ?person rdf:type foaf:Person .
                  ?person foo:age ?age . FILTER ?age < 30 }"^^fresnel:sparqlSelector .

SPARQL queries used within Fresnel must always return exactly one node set, meaning that only one variable is allowed in the query's SELECT clause.

1.4 Fresnel Namespace

The shared namespace of all Fresnel vocabulary modules is :

http://www.w3.org/2004/09/fresnel#

2. The Core Lens Vocabulary

Fresnel lenses specify which properties of an instance (i.e., a resource) are shown. For example, a 'short summary' lens for FOAF persons might display the name and the email address of a person. The result of applying a lens or a group of lenses to an RDF graph is an ordered tree of RDF nodes. This tree doesn't contain any formatting information yet. Formatting instructions are added as a seperate step using Fresnel formats.

The core lens vocabulary is used to define:

2.1 Lens Domain

A lens domain is declared with property fresnel:instanceLensDomain and specifies the set of instances to which a lens applies. The value of fresnel:instanceLensDomain can be a selector expressed with any of the three languages introduced above (simple selectors, FSL expressions, SPARQL queries).

Simple Selectors

When defining a lens domain, a simple selector can either be interpreted in two ways:

The simple selector expression being a URI reference, it does not by itself give any indication of how the selector should be interpreted. Two different Fresnel lens domain properties are therefore used to unambiguously indicate how the selector should be interpreted:

# a lens applying to resource http://example.org#foo
:exLens rdf:type fresnel:Lens ;
                 fresnel:instanceLensDomain <http://example.org#foo> .

# a lens applying to all instances of class foaf:Person
:foafPersonLens rdf:type fresnel:Lens ;
                fresnel:classLensDomain foaf:Person .

# a lens applying to resource foaf:Person (defined in the FOAF RDF Schema)
:foafPersonClassLens rdf:type fresnel:Lens ;
                     fresnel:instanceLensDomain foaf:Person .

FSL Expressions and SPARQL Queries

Selectors expressed with FSL or SPARQL are always used in conjunction with property fresnel:instanceLensDomain and never with property fresnel:classLensDomain, as the above ambiguity problem does not arise in the context of FSL- and SPARQL-based selectors.

# a lens applying to resource http://example.org#foo
:exLens rdf:type fresnel:Lens ;
                 fresnel:instanceLensDomain "*[uri(.) = 'http://example.org#foo']"^^fresnel:fslSelector .

# a lens applying to all instances of class foaf:Person that are younger than 12
:childrenLens rdf:type fresnel:Lens ;
              fresnel:instanceLensDomain "foaf:Person[ex:age/text() < 12]"^^fresnel:fslSelector .

# a lens applying to all instances of class foaf:Person that know at least 5 other persons
:knowsManyPersonLens rdf:type fresnel:Lens ;
                     fresnel:instanceLensDomain "foaf:Person[count(foaf:knows/foaf:Person) >= 5]"^^fresnel:fslSelector .

# a lens applying to all resources (no matter what class they belong to)
# that have an ex:rating property equal to 100
:exLens2 rdf:type fresnel:Lens ;
                  fresnel:instanceLensDomain "*[ex:rating/'100']"^^fresnel:fslSelector .

FSL expressions take the form of paths in the RDF graph. The FSL specification as well as many examples are available at [13]. More information about SPARQL is also available [12].

2.2 Property Selection and Ordering

Lenses use fresnel:showProperties and fresnel:hideProperties to define which properties are displayed. The value of showProperties and hideProperties can be either a single property selector or an ordered list of property selectors. These selectors can be simple selectors (RDF property URIs), or FSL expressions returning RDF properties (i.e. ending by an arc location step, see [13]).

Example: the following lens shows property foaf:name first, followed by properties foaf:mbox and foaf:homepage.

:foafPersonShortLens rdf:type fresnel:Lens ;
                     fresnel:classLensDomain foaf:Person ;
                     fresnel:showProperties ( foaf:name
                                              foaf:mbox
                                              foaf:homepage ) .

Example: the following lens shows property foaf:name first, followed by the foaf:name property of resources known by the resource selected by the lens.

:foafPersonShortLens rdf:type fresnel:Lens ;
                              fresnel:classLensDomain foaf:Person ;
                              fresnel:showProperties ( foaf:name
                                                       "foaf:knows/*/foaf:name"^^fresnel:fslSelector ) .

Unknown Property Sets

RDF's flexible data model allows arbitrary properties from any vocabulary to be associated with resources. Lens authors cannot expect to know in advance all properties that instances to be displayed might use. This case can be handled using fresnel:allProperties. fresnel:allProperties is a placeholder for the names of all properties of the current instance that haven't already been explicitly named in the property list.

Example: The following lens shows the foaf:name property first, followed by the foaf:mbox and foaf:homepage properties. Afterwards, it displays all other properties of the current person but hides the dc:creator and dc:date properties.

:foafPersonShortLens rdf:type fresnel:Lens ;
                     fresnel:classLensDomain foaf:Person ;
                     fresnel:showProperties ( foaf:name
                                              foaf:mbox
                                              foaf:homepage
                                              fresnel:allProperties );
                     fresnel:hideProperties ( dc:creator
                                              dc:date ) .

Displaying RDF Collections and RDF Containers

The values of rdf:List, rdf:Bag, rdf:Seq, or rdf:Alt can be displayed using the fresnel:member pseudo-property. fresnel:member is a placeholder for rdf:_1, rdf:_2, ... and for the members of a rdf:List.

The following example shows how fresnel:member is used to display all members of a rdf:Bag.

:bagLens rdf:type fresnel:Lens ;
               fresnel:classLensDomain rdf:Bag ;
               fresnel:showProperties fresnel:member .
  

2.3 Lens Purpose Vocabulary

The idea behind the lens purpose vocabulary is to help the browser decide which lens to use in situations where more than one lens could apply, causing a conflict. Lens purposes depend on the application domain and the browser's display paradigm. Therefore, Fresnel provides an open interface for using domain- or browser-specific purposes and defines only two general purposes that might be useful across all browsers.

The fresnel:defaultLens purpose is intended to indicate a default lens for a specific class. Browsers might decide to show a lens with purpose fresnel:defaultLens in situations where there are several applicable lenses.

The fresnel:labelLens purpose indicates a lens that provides a short, human-readable label for an instance of a specific class. Browsers in need of labelling an instance (see fresnel:value) should implement the following behavior:

  1. Display an instance lens with the purpose fresnel:labelLens for the resource.
  2. If there is no instance label lens, display a class lens with the purpose fresnel:labelLens for the resource's class type.
  3. If there is no class label lens, display the browser's default label lens. Browsers might want to provide a default label lens which could for example specify that rdfs:label or dc:title values should be used for all resources.
  4. If the browser doesn't provide a default lens, display the URI of the resource.

Purposes are specified using the fresnel:purpose property.

Example: a fresnel:labelLens purpose for foaf:Person displaying only the person's name.

:foafPersonLabelLens rdf:type fresnel:Lens ;
                     fresnel:purpose fresnel:labelLens ;
                     fresnel:classLensDomain foaf:Person ;
                     fresnel:showProperties foaf:name .

2.4 Conflicts Between Lenses

If there is more than one lens applicable to an instance and the browser has not specified a particular one to use, through whatever mechanism it might use to do so, conflicts between lenses are resolved by implementing the following lens selection policy (each step refines the set of lenses to be considered, keeping only the most specific lenses):

  1. If the set of applicable lenses contains both lenses whose domain is a classLensDomain and lenses whose domain is an instanceLensDomain, remove lenses whose domain is a classLensDomain.
  2. If the set of applicable lenses contains lenses whose domain is expressed with a SPARQL query, only keep those (provided that the browser supports domains expressed with SPARQL).
  3. Else, if the set of applicable lenses contains lenses whose domain is expressed with an FSL expression, only keep those (provided that the browser supports domains expressed with FSL).

At this point, the set of applicable lenses is made of lenses that have all of their domains defined either as classLensDomain or instanceLensDomain. If the domain is a classLensDomain, selectors are necessarily simple selectors. If the domain is an instanceLensDomain, selectors are either all SPARQL queries or all FSL expressions, or all simple selectors. In all cases, if the set contains more than one lens, the following steps are used to select the lens to apply:

2.5. Using Sublenses

It is often beneficial to display instances together with related instances. For example, a browser might display a person together with her publications, projects or friends. This is accomplished by relating a lens to sublenses using property fresnel:sublens.

Example: the following lens uses a sublens to display a person together with her friends. It also specifies that the :foafPersonDefaultLens must be used to display this person's friends (i.e., foaf:knows property values).

:knowsLens rdf:type fresnel:Lens ;
           fresnel:classLensDomain foaf:Person ;
           fresnel:showProperties ( foaf:name 
                                    foaf:surname
                                    foaf:mbox 
                                    [ rdf:type fresnel:PropertyDescription ;
                                      fresnel:property foaf:knows ;
                                      fresnel:sublens :foafPersonDefaultLens ] ) .

Multiple Sublenses for Mixed Content

For handling properties whose values might belong to various classes, it is possible to specify multiple sublenses. The appropriate lens is chosen based on the domain of lenses declared as possible sublenses.

Example: the ex:activity property might contain a person's projects and hobbies. The following lens specifies that ex:activity values can be displayed either with lens :projectDefaultLens or lens :hobbyDefaultLens. What lens gets chosen depends on each value's type.

:activitiesLens rdf:type fresnel:Lens ;
                fresnel:classLensDomain foaf:Person ;
	        fresnel:showProperties ( foaf:name
                                         [ fresnel:property ex:activity ;
                                           fresnel:sublens :projectDefaultLens ;
                                           fresnel:sublens :hobbyDefaultLens ] ) .

:projectDefaultLens rdf:type fresnel:Lens ;
                    fresnel:classLensDomain ex:Project.

:hobbyDefaultLens rdf:type fresnel:Lens ;
                  fresnel:classLensDomain ex:Hobby.

Recursive Sublensing

Recursive sublens relationships can cause infinite loops. This problem can be addressed by specifying a maximum recursion depth.

Example: the following lens will display a hierarchy of foaf:knows relationships with a maximum path length of 5.

:knowsHierarchyLens rdf:type fresnel:Lens ;
          fresnel:classLensDomain foaf:Person ;
          fresnel:showProperties ( foaf:name
                                   [ rdf:type fresnel:PropertyDescription ;
                                     fresnel:property foaf:knows ;
                                     fresnel:sublens :knowsHierarchyLens ;
                                     fresnel:depth "5"^^xsd:nonNegativeInteger ] ) .

fresnel:use

Using the fresnel:use property together with fresnel:sublens specifies a specific fresnel:Group of lenses and formats which should be used to render the sublens. This allows the usage of multiple fresnel:Groups for rendering different parts of the output. An example of how multiple groups are used to display the content of a sublens as a table is found here.

:foafPersonDefaultLens rdf:type fresnel:Lens ;
                       fresnel:classLensDomain foaf:Person ;
                       fresnel:showProperties ( foaf:name
                                                foaf:surname
                                                [ rdf:type fresnel:PropertyDescription ;
                                                  fresnel:property foaf:knows ;
                                                  fresnel:sublens :friendsLens ;
                                                  fresnel:use :tableGroup ]
                                              ) .

3. The Core Format Vocabulary

Fresnel lenses specify what information is displayed. The format vocabulary is used to specify how information is displayed. The format vocabulary also provides a bridge between RDF and styling languages such as CSS [2] and the styling part of SVG [3], which are used to specify styling attributes like colors, fonts and borders through external stylesheets.

The core format vocabulary is used to format RDF properties by defining:

Formats are usually grouped together using a Fresnel group. See Section 4 for details about Fresnel groups.

3.1 Applying Formats

Formats for RDF properties and instances are defined by a fresnel:Format.

Formatting Properties

The fresnel:propertyFormatDomain property specifies the set of properties to which a format is applicable. A format can have more than one format domain.

Some use cases for formatting properties are:

Example: The following format applies to the foaf:depiction property:

:depictFormat rdf:type fresnel:Format ;
              fresnel:propertyFormatDomain foaf:depiction .

The value of a fresnel:propertyFormatDomain property can be an FSL expression returning properties (i.e. whose last step is an arc location step, see [13]).

Formatting Resources

In a similar way to lens domains, fresnel:classFormatDomain or fresnel:instanceFormatDomain are used to apply formats to instances identified either by their class or by other constraints. FSL expressions can be used as values of fresnel:instanceFormatDomain.

Some use cases for formatting instances are:

Example: draw a border around the area used to display instances of the class foaf:Person, by combining a class format with the fresnel:resourceStyle property.

:nameFormat rdf:type fresnel:Format ;
            fresnel:classFormatDomain foaf:Person ;
            fresnel:resourceStyle "withBorder"^^fresnel:styleClass .

Example: Display all persons that are younger than 21 using a special color (uses an FSL path expression).

:nameFormat rdf:type fresnel:Format ;
            fresnel:instanceFormatDomain "foaf:Person[foaf:age/text() < 21]"^^fresnel:fslSelector ;
            fresnel:resourceStyle "greenBackground"^^fresnel:styleClass  .

Explicitly linking a Lens and a Format

Besides the loose coupling of lenses and formats through format domains, it is also possible to explicitly link a lens and a format with fresnel:use as shown in the example below.

:foafPersonLabelLens fresnel:showProperties (
                       foaf:name [ rdf:type fresnel:PropertyDescription ;
                                   fresnel:property foaf:mbox ;
                                   fresnel:use :mboxFormat ]
                     ) .

:mboxFormat rdf:type fresnel:Format ;
            fresnel:valueFormat [fresnel:contentBefore "(" ;
                                 fresnel:contentAfter  ")" ] .

3.2 Labelling Properties

Fresnel's default behavior for labelling properties is to use the property's rdfs:label as defined by the corresponding RDF schema. If there is no rdfs:label for a property type then the property's URI is displayed instead. It is possible to customize this default behavior using fresnel:label.

fresnel:label is used to define whether a property label is displayed (fresnel:show, the default) or not (fresnel:none). A literal as the value of fresnel:label will be interpreted as a custom label for the property.

Example: do not show the label of the foaf:depiction property:

:depictFormat rdf:type fresnel:Format ;
              fresnel:propertyFormatDomain foaf:depiction ;
              fresnel:label fresnel:none .

Example: use a custom label for property foaf:knows:

:knowsFormat rdf:type fresnel:Format ;
            fresnel:propertyFormatDomain foaf:knows ;
            fresnel:label "This person knows the following people: "^^xsd:string .

Note: fresnel:label requires a fresnel:propertyFormatDomain to be associated to the fresnel:Format.

3.3 Displaying Property Values

The default behavior for displaying property values is:

  1. If the value is a literal, display it as text.
  2. If the current lens specifies a sublens for this property, display the value using the sublens.
  3. If the value is a resource or bNode, check if the default procedure is overridden by a format for this instance and apply it. If several formats apply, resolve conflicts between formats as described section Conflicts Between Formats.
  4. If the value is a resource or bNode, check if there is a label instance lens for this resource or bNode and display it.
  5. Else display the browser's default label lens. Browsers might want to provide a default label lens which could for instance specify that rdfs:label or dc:title values should be used by default.
  6. If there is no such lens, display the URI of the resource or the ID of the bNode.

This default behaviour can be overridden using property fresnel:value property, which specifies that all values of a property should be displayed:

Example: display values of the foaf:depiction property as images.

:depictFormat rdf:type fresnel:Format ;
              fresnel:propertyFormatDomain foaf:depiction ;
              fresnel:value fresnel:image .

Example: display values of the foaf:homepage property as external links.

:knowsFormat rdf:type fresnel:Format ;
             fresnel:propertyFormatDomain foaf:homepage ;
             fresnel:value fresnel:externalLink .

Example: display values of the foaf:mbox property as URIs.

:knowsFormat rdf:type fresnel:Format ;
             fresnel:propertyFormatDomain foaf:mbox ;
             fresnel:value fresnel:uri .

Note: fresnel:value requires a fresnel:propertyFormatDomain to be associated to the fresnel:Format.

In the case that the default behaviour is overridden, browsers might want to give the user the option to switch back to the default behaviour or to manually select the lens which he likes to use.

Conflicts Between Formats

If there is more than one format applicable to an instance and the browser has not specified a particular one to use, through whatever mechanism it might use to do so, conflicts between formats are resolved by implementing the following format selection policy (each step refines the set of formats to be considered, keeping only the most specific formats):

  1. If the set of applicable formats contains both formats whose domain is a classFormatDomain and formats whose domain is an instanceFormatDomain, remove formats whose domain is a classFormatDomain.
  2. If the set of applicable formats contains formats whose domain is expressed with an FSL expression, only keep those (provided that the browser supports domains expressed with FSL).

At this point, the set of applicable formats is made of formats that have all of their domains defined either as classFormatDomain or instanceFormatDomain. If the domain is a classFormatDomain, selectors are necessarily simple selectors. If the domain is an instanceFormatDomain, selectors are either all FSL expressions, or all simple selectors. In all cases, if the set contains more than one format, the following steps are used to select the format to apply:

3.4 Referring to CSS Classes

Fresnel relies on external CSS [2] stylesheets for defining colors, margins, fonts, borders, and other decorative elements. Stylesheets can also contain SVG [3] styling instructions such as strokes and brushes, that could typically be used by visual tools such as IsaViz [7] which represents RDF models as node-link diagrams.

Fresnel Abstract Box Model

Colors, margins, fonts and borders are defined as styling rules in stylesheets. The selectors (left-hand side) of these rules are standard CSS class names, which can be referred to from Fresnel by associating them with elements of the Fresnel abstract box model. This box model is a logical abstraction over different display paradigms RDF browsers might use, based on the RDF abstract syntax. The box model is interpreted depending on the display paradigm. E.g. when considering node-link diagrams like in IsaViz, the property box is interpreted as an arc, which can be styled using the SVG [3] brush styling instructions. In XHTML/CSS-based, text-oriented browsers like LongWell [6], it is interpreted as a rectangular shape.

The following table lists the various elements defined by the abstract box model. These elements all represent abstract regions of the representation space that Fresnel implementations must instantiate. How these abstract elements map to actual elements of the representation is browser-dependant and is to be decided by each browser implementor's. The only requirement is that the constraints expressed in the following table are met.

Abstract Box Model Element Description
Resource Box The resource box is a region that surrounds all properties of a single resource.
Usage example: specifying a border around the region that surrounds all properties of an instance.
Property Box The property box is a region that surrounds the area used to display a single property.
Usage example: Specifying the background color of the whole area that represents a property.
Label Box The label box contains the label of a property.
Value Box The value box contains one property value.
If the property value is displayed using a sublens, the value box will contain the resource box associated with the value.
Container Box The container box is not part of core but of the extended format vocabulary. It is listed here only for the sake of completeness.
The container box surrounds all instances that are currently displayed.
Usage example: Specifying the background color of the whole representation (e.g. of an HTML page, or SVG diagram).
A container box contains a set of resource boxes.

Example Instantiation of the Box Model

The following figure gives an example instantiation of the abstract box model, as might define a browser whose fundamental representation/layout paradigm would be based on nested boxes. Different instantiations are possible.

Fresnel abstract representation model
Example instantiation of the Fresnel abstract box model

 

Associating CSS Styling Rules with Elements of the Box Model

The CSS instructions found in a styling rule of an external stylesheet can be applied to elements of the box model by associating the CSS class name that defines the selector of this rule with the element of the box model. This association is based on the definition of styling hooks that can be declared using the following Fresnel properties.

Styling Hook Applicable to
fresnel:resourceStyle fresnel:Group instances, class formats and instance formats (see Formatting Instances )
fresnel:propertyStyle fresnel:Format and fresnel:Group instances (see Format Domain)
fresnel:labelStyle fresnel:Format and fresnel:Group instances
fresnel:valueStyle fresnel:Format and fresnel:Group instances
fresnel:containerStyle The container box is not part of Fresnel Core but of the Extended Format Vocabulary. It is listed here only for the sake of completeness.
fresnel:Group instances (see Grouping Lenses and Formats)

As several CSS classes can be declared on one XML element, styles are accumulated. For instance, a style associated with a fresnel:Group and another style associated with a fresnel:Format will both be used in assigning styles to matching selections.

CSS classes are assigned typed literals (datatype = fresnel:styleClass).

Example: In the following example, the CSS classes are used by :uriFormat to format the label and the value of property foaf:homepage.

:foafGroup rdf:type fresnel:Group .
	
:uriFormat rdf:type fresnel:Format ;
           fresnel:propertyFormatDomain foaf:homepage ;
           fresnel:labelStyle "basicLabel"^^fresnel:styleClass ;
           fresnel:valueStyle "basicUri"^^fresnel:styleClass ;
           fresnel:group :foafGroup .

Note: fresnel:propertyStyle, fresnel:labelStyle and fresnel:valueStyle require a fresnel:propertyFormatDomain to be associated to the fresnel:Format. fresnel:resourceStyle requires a fresnel:classFormatDomain or fresnel:instanceFormatDomain to be associated to the fresnel:Format.

3.5 Additional Content

Fresnel provides facilities for adding fixed content at various locations in the abstract box model. An example usage scenario is adding commas to a list of property values. It is also possible to specify additional content which is displayed if a property is missing.

Additional content is added by using the following Fresnel properties:

Property Description
fresnel:contentBefore Add content before the current box.
fresnel:contentAfter Add content after the current box.
Usage example: Add a comma between values of a list.
fresnel:contentFirst Add content before the first box (of a list of boxes).
Usage example: Add fixed headings.
If specified, replaces what is produced by fresnel:contentBefore for the first list element.
fresnel:contentLast Add content after the last box (of a list of boxes).
If specified, replaces what is produced by fresnel:contentAfter for the last list element.
Usage example: put a dot ('.') at the end of a list of property values. If the same set of CSS styling instructions declares a comma (',') as the value of fresnel:contentAfter, the dot replaces the comma after the last list element.
fresnel:contentNoValue Specify content that is displayed if a property is missing. Only valid in conjunction with fresnel:propertyFormat and fresnel:labelFormat.
Usage Example: "This person has no email adress".

fresnel:content{First,Last} has priority when a collision with fresnel:content{Before,After} occurs, meaning for the first example below that only a "." will appear at the end of the list and not the ", ." combination.

Additional content is added by using formatting hooks. All formatting hooks can be applied to a fresnel:Group and are also subject to the following constraints on applicability when used with a fresnel:Format: fresnel:propertyFormat, fresnel:valueFormat, and fresnel:valueFormat require a fresnel:propertyFormatDomain to be associated to the fresnel:Format. fresnel:resourceFormat requires a fresnel:classFormatDomain or fresnel:instanceFormatDomain to be associated to the fresnel:Format.

The following table summarizes Fresnel properties used to declare formatting hook:

Format Hook Explanation
fresnel:valueFormat Adds additional content before or after the property values.
Example: Commas between a list of values.
fresnel:labelFormat Adds additional content before or after the area used to display a property's label.
Example: Add a ':' character after the label.
fresnel:propertyFormat Adds additional content before or after the area used to display a property and its values.
Example: Add an explanation to a property.
fresnel:resourceFormat Adds additional content before or after the area used to display an instance.
Example: Add a disclaimer to resources shown by the browser.

Example: add commas between property values and a period to the end of a list of homepages.

:formatHomepage rdf:type fresnel:Format ;
                fresnel:propertyFormatDomain foaf:homepage ;
                fresnel:valueFormat [ fresnel:contentAfter ", "^^xsd:string ;
                                      fresnel:contentLast "."^^xsd:string ] ;
                fresnel:valueStyle "basicLabel"^^fresnel:styleClass .

Example: display a missing value message if a foaf:Person has no email address.

:formatMbox rdf:type fresnel:Format ;
            fresnel:propertyFormatDomain foaf:mbox ;
            fresnel:valueFormat [ fresnel:contentNoValue "This person has no email address."^^xsd:string ] .

Example: display an explanation for the knows property.

:formatMbox rdf:type fresnel:Format ;
            fresnel:propertyFormatDomain foaf:knows ;
            fresnel:propertyFormat [ fresnel:contentAfter "That a person knows somebody does mean
                                                              that the other person also knows her."^^xsd:string ] .

Example: display a disclaimer behind all person instances, if the information was found on ex:CrappyWebsite.

:formatMbox rdf:type fresnel:Format ;
            fresnel:instanceFormatDomain "foaf:Person[dc:author/ex:CrappyWebsite]"^^fresnel:fslSelector ;
            fresnel:resourceFormat [ fresnel:contentAfter "This information hasn't been verified by us
                                                                  and we don't take any warranty."^^xsd:string ] .

4. The Group Vocabulary

4.1 Grouping Formats and Lenses

Fresnel allows lenses and formats to be grouped so that browsers can easily determine which lenses and formats work together.

A browser should consider Fresnel groups when:

Groups also provide hooks for declaring:

Example: the following group says that CSS class globalResource should be used to style all instances generated by lenses of this group. Also, all labels should be followed by a colon character.

:foafGroup rdf:type fresnel:Group ;
           fresnel:resourceStyle "globalResource"^^fresnel:stlyeClass ;
fresnel:propertyStyle "globalProperty"^^fresnel:stlyeClass ;
fresnel:labelFormat [ :contentAfter ":" ] .

Lenses and formats are put into a group using the fresnel:group property.

:depictFormat rdf:type fresnel:Format ;
              fresnel:group :foafGroup .

4.2. Defining Primary Classes

In datasets with several classes of resources, certain classes might be more useful as starting points, or primaries. Or it might be interesting to provide different angles for viewing the data by defining a different presentation for each primary class. Primary classes should be returned as first-class results; secondary classes not listed as primaries should only be shown by sublenses.

Example: the person and project classes are considered as primaries. All unlisted classes are considered as secondaries.

:foafGroup rdf:type fresnel:Group ;
           fresnel:primaryClasses ( foaf:Person 
                                    foaf:Project ) .

Declaring some classes of the ontology as primaries also indicates to a browser that these classes are important and might therefore be included in content summaries or navigational structures.

5. Extended Lens Vocabulary

The extended lens vocabulary contains additional terms for

Browsers should implement this functionality or parts of it. If a lens contains terms from the extended vocabulary that a browser doesn't support then it should not use this lens.

5.1. Alternate and Merged Properties

Merged Properties

It is sometimes beneficial to merge the values of similar properties into one set of values for display purposes. For example, a browser might display all values of foaf:homepage and foaf:workHomepage together as a single property. This is accomplished using fresnel:mergeProperties and an RDF list of the properties to be merged. Note: using fresnel:use, it is possible to refer to a Fresnel format which contains an appropriate label for the merged properties.

Alternate Properties

There are often properties missing in instance data found on the Semantic Web because the author uses a similar term from another vocabulary to state the information. This case can be handled by specifying a list of alternate properties in a Fresnel lens. The browser will try to display the first property in the list. If there are no values found, then the browser will try the subsequent values in order. A sequence of alternate properties is specified using fresnel:alternateProperties and an rdf:List.

Example: The lens below uses a sequence of alternate properties to display the name of a person (name, label, title). It also merges the values of foaf:homepage, foaf:workplaceHomepage, foaf:schoolHomepage into a virtual property. This virtual property is labelled using the :formatMergeHomepage format.

:smartPersonLens rdf:type fresnel:Lens ;
                 fresnel:classLensDomain foaf:Person ;
                 fresnel:showProperties (
                     [rdf:type fresnel:PropertyDescription
                      fresnel:alternateProperties ( foaf:name
                                                    rdfs:label
                                                    dc:title )
                     ]
                     [rdf:type fresnel:PropertyDescription ;
                      fresnel:mergeProperties ( foaf:homepage
                                                foaf:workplaceHomepage
                                                foaf:schoolHomepage ) ;
                      fresnel:use :formatMergeHomepage ] ) .

:formatMergeHomepage rdf:type fresnel:Format ;
                     fresnel:label "This person has the following homepages: "^^xsd:string .

5.2. Lens Inheritance

Experience from Haystack shows that people often want to reuse an existing lens but with minor changes. Fresnel supports this requirement through lens inheritance.

A lens A which is related to another lens B using fresnel:extends inherits all properties and the order of these properties from lens B.

The properties from lens B are added to the beginning of the property list of lens A. It is also possible to add the properties at another position of the list by using the fresnel:super operator.

Multiple inheritance is not allowed. The browser should detect inheritance loops and stop the inheriting process when a loop is detected.

Example: The following example contains two lenses. The :identificationLens inherits the foaf:name and foaf:surname properties from the :foafPersonLens. These properties are added to the property list of :identificationLens between owl:sameAs and foaf:depiction.

:foafPersonLens rdf:type fresnel:Lens ;
                fresnel:classLensDomain foaf:Person ;
                fresnel:showProperties ( foaf:name
                                         foaf:surname ) .


:identificationLens rdf:type fresnel:Lens ;
                    fresnel:classLensDomain foaf:Person ;
                    fresnel:extends :foafPersonLens ; 
                    fresnel:showProperties ( rdf:type 
                                             owl:sameAs
                                             fresnel:super
                                             foaf:depiction ) .

5.3. Searching for Sublenses

It is also possible to select an appropriate lens using a Fresnel Selector Expression or a SPARQL query.

Example: the following lens searches for a sublens that is applicable to foaf:Persons and has a fresnel:purpose of ex:writeEmail using an FSL expression.

:emailLens rdf:type fresnel:Lens ;
           fresnel:classLensDomain foaf:Person ;
           fresnel:showProperties (
              foaf:name [fresnel:property foaf:knows ;
                         fresnel:sublens "fresnel:Lens[fresnel:lensDomain/foaf:Person
                                                         and fresnel:purpose/ex:writeEmail]"^^fresnel:fslSelector
                        ]
                                  ) .

6. Extended Format Vocabulary

The extended format vocabulary provides for:

Browsers should implement this functionality or parts of it. If a format contains terms from the extended vocabulary that a browser doesn't support, then it should not use this format.

6.1. Selector Pseudo-Classes

Fresnel supports the same pseudo class selectors as CSS. The selectors can be used to specify 'behavioral' formats.

Property Description
fresnel:link The :link pseudo-class applies to all links.
fresnel:visited The :visited pseudo-class applies to all visited links.
fresnel:active The active pseudo-class applies while an element is being activated by the user. For example, between the times the user presses the mouse button and releases it.
fresnel:hover The :hover pseudo-class applies while the user designates an element (with some pointing device), but does not activate it.
fresnel:firstLetter The :firstLetter pseudo-class allows you to format the first letter of a text.

Example: Highlight the value box of foaf:mbox values while the user designates it.

:mboxFormat rdf:type fresnel:Format ;
            fresnel:propertyFormatDomain foaf:mbox ;
            fresnel:valueStyle [ fresnel:hover "background-color: red"^^fresnel:stylingInstructions ].

6.2. Including External Media Files

The extended formatting vocabulary features terms for specifying that property values should be replaced with external media files. The formatting mechanism is the same as when displaying an image as a property value (like fresnel:value fresnel:image) in the core vocabulary.

The additional terms are:

Property Description
fresnel:video Retrieve the resource referenced by the property value and play it as a video clip.
fresnel:audio Retrieve the resource referenced by the property value and play it as an audio clip.
If a lens tries to play several audios at once, then the browser should provide for letting the user switch between them.
fresnel:animation Retrieve the resource named by the property value and display it as animated vector graphics or other animated format.
fresnel:html Retrieve an HTML document and display its body element inside the rendered output document.
fresnel:text Retrieve the resource named by the property value and display it as text format, such as pdf or MS word using an appropriate viewer.
fresnel:textstream Retrieve the resource named by the property value and display it as textstream using an appropriate viewer.

6.3. Linking directly to a CSS stylesheet

References to external stylesheets are declared by adding fresnel:stylesheetLink properties to the fresnel:Groups to which the fresnel:Formats belong. fresnel:stylesheetLink property values are the URLs of the external stylesheets. A browser might allow the user to switch between different external styesheets, if a fresnel:Group contains several fresnel:stylesheetLinks.

:foafGroup rdf:type fresnel:Group ;
           fresnel:stylesheetLink <http://www.example.org/example.css> ;
           fresnel:resourceStyle "globalResource"^^fresnel:stlyeClass ;
fresnel:propertyStyle "globalProperty"^^fresnel:stlyeClass .

6.4. Supporting Different Output Media

Different sets of formats for different output media can be specified by using the fresnel:purpose property on a Fresnel format or Fresnel format group.

Fresnel specifies format purposes for the following output media:

Resource Description
fresnel:screen Intended primarily for color computer screens.
fresnel:projection Intended for projected presentations, for example projectors or print to transparencies.
fresnel:print Intended for paged, opaque material and for documents viewed on screen in print preview mode.

Example: The purpose of the following group is set to fresnel:print, indicating that formats in this group are applicable for paged output formats.

:printGroup rdf:type fresnel:Group ;
            fresnel:purpose fresnel:print ;
            fresnel:stylesheetLink <http://www.example.org/example.css> ;
            fresnel:containerStyle "global"^^fresnel:stlyeClass ; 

6.5. Including CSS/SVG Styling Instructions directly into Fresnel Stylesheets

Some authors of Fresnel stylesheets might find it more convienient to include CSS styling instructions directly into Fresnel stylesheets instead of using styling hooks and CSS classes in an external stylesheet. Therefore the extended format vocabulary provides the ^^fresnel:stylingInstructions datatype for directly including styling instructions. Browsers which want to support this functionality might include the styleing instructions directly into the output document or use them to construct an external CSS stylesheet on the fly.

Example: The following Fresnel format defines that the label of the foaf:name property is displayed using the color grey and that the property values are displayed in black.

:nameFormat rdf:type fresnel:Format ;
            fresnel:propertyFormatDomain foaf:name ;
            fresnel:labelStyle "font-color: grey"^^fresnel:stylingInstructions ;
            fresnel:valueStyle "font-color: black"^^fresnel:stylingInstructions .

Example: The following Fresnel format defines that a line is drawn above the area representing the property foaf:mbox and that a line is drawn below each of the property values.

:mboxFormat rdf:type fresnel:Format ;
            fresnel:formatDomain foaf:mbox ;
            fresnel:propertyStyle "border-top: solid black"^^fresnel:stylingInstructions ;
            fresnel:valueStyle "border-bottom: solid black"^^fresnel:stylingInstructions .

Complete Example

The following example shows how a group of formats is applied to an instance of foaf:Person.

RDF data to be displayed:

:Chris rdf:type foaf:Person ;
       foaf:name "Chris Bizer" ;
       foaf:mbox <mailto:chris@bizer.de> ;
       foaf:mbox <mailto:bizer@gmx.de> ;
       foaf:depiction <http://www.wiwiss.fu-berlin.de/suhl/ueber_uns/team/Fotos/ChrisPassbild.jpg> .
    

Fresnel formats:

:foafGroup rdf:type fresnel:Group ;
           fresnel:stylesheetLink <http://www.example.org/example.css> ;
           fresnel:containerStyle "background-color: white;"^^fresnel:stylingInstructions ; 

:foafPersonFormat rdf:type fresnel:Format ;
                  fresnel:classFormatDomain foaf:Person ;
                  fresnel:resourceStyle "background-color: gray;"^^fresnel:stylingInstructions ;
                  fresnel:group :foafGroup .
	
:nameFormat rdf:type fresnel:Format ;
            fresnel:propertyFormatDomain foaf:name ;
            fresnel:propertyStyle "border-top: solid black;"^^fresnel:stylingInstructions ;
            fresnel:labelStyle "font-weight: bold;"^^fresnel:stylingInstructions ;
            fresnel:group :foafGroup .

:urlFormat rdf:type fresnel:Format ;
           fresnel:propertyFormatDomain foaf:homepage ;
           fresnel:propertyFormatDomain foaf:mbox ;
           fresnel:value fresnel:externalLink ;
           fresnel:propertyStyle "border-top: solid black;"^^fresnel:stylingInstructions ;
           fresnel:labelStyle "font-weight: bold;"^^fresnel:stylingInstructions ;
           fresnel:group :foafGroup .

:depictFormat rdf:type fresnel:Format ;
              fresnel:propertyFormatDomain foaf:depiction ;
              fresnel:label fresnel:none ;
              fresnel:value fresnel:image ;
              fresnel:propertyStyle "border-top: solid black;"^^fresnel:stylingInstructions ;
              fresnel:group :foafGroup .

Example of box model instantiation with styling instructions attached:

example instantiation of the box model

Output rendered by a text-oriented browser based on this box model example:

example rendering

 

A. Formal Specification

The OWL Specification of the Fresnel vocabularies is found at:

There are also informative versions of the vocabularies using N3 syntax: core.owl.n3, extended.owl.n3.

B. References

[1] Resource Description Framework (RDF): http://www.w3.org/RDF/

[2] Cascading Style Sheets (CSS): http://www.w3.org/Style/CSS/

[3] Scalable Vector Graphics (SVG): http://www.w3.org/Graphics/SVG/

[4] Friend of a Friend (FOAF) project: http://www.foaf-project.org/

[5] Haystack: http://haystack.csail.mit.edu/

[6] Longwell: http://simile.mit.edu/longwell/

[7] IsaViz: http://www.w3.org/2001/11/IsaViz/

[8] BrownSauce: http://brownsauce.sourceforge.net/

[9] SEAL: http://www.aifb.uni-karlsruhe.de/~sst/Research/Publications/semanticportal.pdf

[10] Topia: http://wwwis.win.tue.nl:8082/clustermap/index.html

[11] mSpace: http://www.mspace.fm/

[12] SPARQL: http://www.w3.org/TR/rdf-sparql-query/

[13] Fresnel Selector Language (FSL): http://www.w3.org/2005/04/fresnel-info/fsl/

[14] Dennis Quan, David R. Karger: How to Make a Semantic Web Browser. http://www.www2004.org/proceedings/docs/1p255.pdf

[15] Lloyd Rutledge, Jacco van Ossenbruggen and Lynda Hardman: Making RDF Presentable. http://homepages.cwi.nl/~media/publications/WWW2005.pdf

[16] Emmanuel Pietriga: Styling RDF Graphs with GSS. http://www.xml.com/pub/a/2003/12/03/gss.html

[17] David Huynh: Haystack's User Interface Framework. http://haystack.csail.mit.edu/documentation/ui.pdf

[18] Apache Cocoon Project. http://cocoon.apache.org/

[19] Welkin: a graph-based RDF visualizer. http://simile.mit.edu/welkin/


C. Change Log