GB2429815A

GB2429815A - Markup language document processing

Info

Publication number: GB2429815A
Application number: GB0517684A
Authority: GB
Inventors: Piers Wombwell
Original assignee: Ant Software Ltd
Current assignee: Ant Software Ltd
Priority date: 2005-08-31
Filing date: 2005-08-31
Publication date: 2007-03-07
Also published as: GB0517684D0

Abstract

Style data for a markup language document is stored in a data structure in an order according to importance values.

Description

I

Markup Language Document Processing This invention is generally concerned with the processing of data for markup language documents such as HTML (Hyper Text Markup Language), and in particular with methods, computer program code and systems for storing, retrieving and processing style data for markup language documents.

To illustrate problems which embodiments of the invention address we refer in particular to style sheets. A style sheet is generally part of a document object model (DOM), which provides an interface to facilitate access to and modification of the content, style and/or structure of a document.

Broadly speaking, a style sheet comprises a set of style rules that a browser employs when rendering a document for presentation. To aid understanding of the invention it is helpftil to refer to specific examples, and here we refer, in particular, to the CSS3 Colour Module Specification, for example the W3C draft of 14th May 2003 (http://www.w3.orQJTR/2003/CR-css3-color-200305 14).

Cascading Style Sheets (CSS) is a language for describing the rendering of HTML and XML documents on screen, and allows multiple style sheets to influence the rendering of a document. The process of combining style sheets is called cascading and the CSS specifications describe, among other things, how to select a style (property) for a document element when there are multiple conflicting style declarations. The specific details of this process are described in the CSS3 module: cascading and inheritance (the contents of which are hereby incorporated in their entirety by reference), which defines a process in which the input comprises a set of declarations that apply to the property of an element (along with the inherited value of the property and the initial value of the property), and in which a single, cascaded value is provided as an output.

For actual rendering of a document the cascaded value may require some further processing to convert the value into device-specific units - for example a font size may be specified in relative terms such as "1 Oem" (the final value of a property is determined by the specified value which, if necessary, is resolved into an absolute, computed value, which may be finally transformed, in accordance with limitations of a local environment, into an actual value).

The cascading process aims to identify a "winning declaration" from those that apply, based upon weight (a declaration may be marked as important), specificity and order of appearance. The CSS Specification defines that "the last declaration wins". Similarly the declaration with the highest weight "wins". The declaration with the highest specificity "wins", and the declarations are sorted according to first weight, second specificity and third order of appearance, the sorting process continuing until one winning declaration is found. In CSS selectors are used to select elements in an HTML or XML (extended markup language) document in order to attach style properties to them. Section 5 of the CSS 3 specification defines a set of pattern matching rules, the patterns being called selectors; if all conditions in a pattern are true for an element then the selector matches the element.

Examples of universal, type, descendant, child and sibling/adjacent selectors are as follows: * Universal selector E Matches an element of type E (e.g. bold for B) E F Matches element F E>F Matches element F that is a child of element B B+F Matches element F that is immediately preceded by element B (adjacent/sibling) It can be seen that some selectors (for example the descendant and adjacent/sibling (+)) selectors above may comprise two or more conditions.

In CSS a selector's specificity is determined by concatenating three (or four) numbers in a number system with a large base. In CSS 2 the specificity of a selector is calculated

as follows (taken from the specification):

* count the number of ID attributes in the selector ( a) * count the number of other attributes and pseudo-classes in the selector ( b) * count the number of element names in the selector (= c) * ignore pseudo-elements.

Examples:

* () /* a=0 b=O c=0 -> specificity = 0 *1 LI () / a=O b=O c=1 -> specificity = 1 / IJL LI {) 1* a=0 b=0 c=2 -> specificity = 2 */ UL OL+LI {} / a=0 b=0 c=3 -> specificity = 3 *1 Hi + *[RELUpI{} 7* a=0 b=]. c=1 -> specificity = 11 *7 UL OL LI.red {) / a=0 b=1 c=3 -> specificity = 13 */ LI.red.levei {} 7* a=0 b=2 c=1 -> specificity = 21 */ #x34y (} 7* a=1 b=0 c=0 -> specificity = 100 *1 In CSS 2.1 the number of pseudo-elements and the number of element names is allocated a further number (d) which is concatenated at the end of a, b, c.

To render a document the source is parsed to construct a document tree, the tree having a node for each element encoded or defined in the source markup language document.

The root of the document tree is typically the HTML or BODY element of a document and thereafter the tree is defined such that each node (element) has a single parent so that, for example, values of an element maybe inherited by the children of the element.

To briefly recap, a style sheet comprises a list of rules for processing document elements represented by a set of nodes. Each rule has a set of one or more properties for a node, for example for setting foreground/background colour, font and the like.

Generally each rule has an index so that a Document Object Model (DOM) is able to read and modify the sheet. Conventionally this index is the order the rules appear in the source file, the DOM enabling this order to be modified by a scripting language. The specificity of a rule may be determined from the rule, for example using the approach defined in a CSS specification such as CSS 2, CSS 2.1 or CSS 3. This specificity indicates the importance of a rule for a node as compared with one or more other rules that also match the node, the most specific rule "winning".

One solution to storing a style sheet is to define an array of rules matching the style sheet source. This facilitates creating and modifying the style sheet since the index matches what the DOM expects so that it can easily access each entry. Furthermore deletion and insertion of rules is straightforward since the array simply needs the relevant index removed/added and the higher entries shift in the appropriate direction.

However the search to see whether a rule matches a given node requires that every rule in the sheet is parsed, since a rule at the end of the sheet might have a higher specificity than one at the start.

The inventor has recognised that, in practice, style sheets are frequently accessed but rarely modified. It would therefore be beneficial to improve the speed with which style sheet data may be accessed.

According the present invention there is therefore provided a method of storing style data for a mark-up language document, the style data comprising a plurality of rules for applying styles to said document, a said rule comprising an identifier for identifying one or more elements of the document and associated property data defining a style of the identified element, a said rule having an associated importance value, in a case where two of said rules define conflicting styles for an identified element relative importance values of the rules determining which rule to apply, the method comprising storing said style data in a data structure in which said rules are ordered according to said importance values.

Preferably the identifier comprises a selector for selecting one or more elements of the document and the importance value is detennined by a specificity value of the selector defining the condition for the rule or declaration.

In embodiments, although there is a significant additional overhead when modifying the style data (style sheet) - because each time a rule is inserted (or deleted) the entire array needs searching to identify rules with higher indices to increase (or reduce) their index values - storing the rules in specificity order is overall significantly more efficient because, on average, looking up property data for an element is twice as fast. In embodiments matching a rule against a node is on average quicker since the search can terminate early. The search may comprise a simple, linear search of the rules but, in embodiments of the method, as soon as a rule matches (and contains the property required) it can be guaranteed that this is the most specific rule, so that there is no need to continue searching through the rest of the rules. Since looking up style information is a very frequent operation (although modifying style sheets is a rare operation) it is beneficial to increase the speed of the searching procedure at the expense of introducing an extra overhead when a style sheet needs to be modified.

A rule or selector may comprise a grouped rule or selector, that is a group of identifiers associated with common property data defining a common style for the group of document elements identified by the group of identifiers or selectors. Thus, for example, in the style data when a plurality of selectors share the same property declaration they may be grouped into a, -separated list, but in embodiments of the method such grouped rules are split into a plurality of separate rules each of which is allocated its own position in the order of importance according to its individual importance/specificity value.

In another aspect the invention provides a method of searching style data for a markup language document stored as described above, to identify a style to apply to an element of the document, the method comprising searching the style data structure for an identifier of the element in order of decreasing importance/specificity values of the rules.

Preferably the search is terminated on finding the first rule with an identifier matching the document element to which the style is to be applied. Thus the style of a markup language document may be determined by determining property data defining a style for each element of the document using this method.

In some preferred embodiments the method further comprises parsing the markup language document to determine a tree data structure for the document comprising a hierarchical representation of the document elements (in which each document element is represented by a node of the tree), and then assigning property data to each document element as previously described. When assigning property data to the document elements the tree is preferably traversed in a defined order, for example a top-down, left-right order.

Embodiments of the method further comprise rendering the document using the determined style rendering each document element using a style defined by property data identified by a rule in the style sheet, stored as described above. The markup language document may comprise a document in any conventional markup language including but not limited to HTML, XML, XHTML and the like. The document is typically rendered by a browser, but may be rendered visually and/or aurally, and hence the styles may comprise visual or aural styles, or both. The platform on which the browser operates may comprise any conventional platform including, but not limited to, a desktop computer, a mobile communications device such as a mobile phone or PDA (personal digital assistance), a television or other home multimedia entertainment device, a portable video and/or audio player, a printer, a speech synthesiser (or a device incorporating a speed synthesiser) or a combination of these.

Preferably the rules of the style data are stored in association with index data for use by a document object model (DOM).

The invention further provides processor control code to implement the above-described systems and methods, in particular on a data carrier such as a disk, CD- or DVD-ROM, programmed memory such as read-only memory (Firmware), or on a data carrier such as an optical or electrical signal carrier. Code (and/or data) to implement embodiments of the invention may comprise source, object or executable code in a conventional programming language (interpreted or compiled) such as C, or assembly code, code for setting up or controlling an ASIC (Application Specific Integrated Circuit) or FPGA (Field Programmable Gate Array), or code for a hardware description language such as Verilog (Trade Mark) or VHDL (Very high speed integrated circuit Hardware Description Language). As the skilled person will appreciate such code and/or data may be distributed between a plurality of coupled components in communication with one another.

In a related aspect the invention provides a data structure configured to store style data for a markup language document, the style data comprising a plurality of rules for applying styles to said document, a said rule comprising an identifier for identifying one or more elements of the document and associated property data defining a style of the identified element, a said rule having an associated importance value, in a case where two of said rules define conflicting styles for an identified element relative importance values of the rules determining which rule to apply, wherein said rules of said stored style data are ordered according to said importance values.

The data structure may be provided on a carrier, as described above. Preferably the data structure is further configured to store at least one grouped rule, as described above, as a plurality of substantially separate rules each at a position in the order of importance corresponding its respective specificity value. Preferably each rule has an associated index, as previously mentioned, in general the index values being out of sequence.

The invention further provides a computer system including a data structure and/or processor control code carrier as described above.

Thus in a further aspect the invention provides a computer system for rendering a markup language document, the system comprising: data memory configured to store style data for a markup language document, the style data comprising a plurality of rules for applying styles to said document, a said rule comprising an identifier for identifying one or more elements of the document and associated property data defining a style of the identified element, a said rule having an associated importance value, in a case where two of said rules define conflicting styles for an identified element relative importance values of the rules determining which rule to apply, and wherein said rules are ordered according to said importance values; program memory storing processor control code; and a processor, coupled to said data memory and to said program memory to load and implement said processor control code, and wherein said code comprises code to: search said style data structure in order of decreasing importance values of said rules to find, for an element of said document, the first rule with an identifier matching the element; and render the element using a style determined by property data associated with said first matching rule found for the element These and other aspects of the invention will now be further described, by way of example only, with reference to the accompanying figures in which: Figures Ia to Ic show respectively an example of an HTML document tree, and first and second examples of style sheet data structures; Figures 2a and 2b show flow diagrams of procedures for, respectively, storing rules in a style sheet by specificity, and searching for and applying style rules to render an HTML document; and Figure 3 shows a block diagram of a system configured to implement a procedure of figure 2.

Referring first to figure Ia, this shows an example of a simple HTML document tree, corresponding to the example HTML document source shown below: <HTML> <HEAD> <TITLE>Example</TITLE> <IHEAD> <BODY>

<}II>Example</H1>

This illustrates a document tree: This is Bold Text. <I?>

This is a second paragraph.

This is more Bold Text.

</BODY> </HTML> An example browser rendering for the above HTML document source is shown below:

Example

This illustrates a document tree: This is Bold Text.

This is a second paragraph.

This is more Bold Text.

The tree 10 of figure 1 a comprises a root node for the HTML tag, a first HEAD sub-tree 14 comprising HEAD and TITLE elements, and a second, BODY sub-tree 16 comprising an Hi element, first and second paragraph P elements I 6a, b and first and second bold B elements 16c, d. Bold element 16c is a descendant of paragraph element 16a whilst bold element 16d is a sibling element (at the same level and to the right- adjacent) of paragraph element 16b. In this example the tree is traversed in a top-down, left-right order.

Consider the following rules: Ri B { font-weight: bold} R2 PB {color: red} R3 B { color: green} The first rule fires for all B's, as does the third rule (R3), whilst the second rule fires if any B is a descendant of any P. It can therefore be seen that rule R2 is more specific than rule Ri and, as noted above, in a case of conflict the most specific matching rule is used, in this example R2. Such a conflict would arise, in the example of figure la, for the bold element 16c. It can also be seen that rule R3 potentially conflicts with rule RI and in such a case, if the specificitiès are the same the later rule (R.3) overrides the earlier rule (Ri). As previously mentioned details of cascading declarations in order of weight, specificity, and then order of appearance are described in the CSS 3 module: cascading and inheritance, for example, the W3C working draft of 19 February 2002, hereby incorporated by reference in its entirety, in particular the text at section 4 "cascading" and the text at section 7 "computing weight", as well as the selector's module, and the CSS 2.1 module 6, "assigiling property values, cascading and inheritance" at second 6.4.3, "calculating a selector's specificity", also incorporated by reference in their entirety.

Referring now to figure lb. for the above example set of rules the order of importance is rule R2 followed by rule R3 followed by rule Ri (in order of specificity, with rule R3 coming first in the style sheet because this overrides rule Ri). The style sheet data structure typically comprises an array stored in non-volatile memory or on a disk, for example at a server, and may be extended as illustrated for n rules.

Consider next the following set of rules, based upon the above example, in which rule 2 is a grouped rule comprising a, -separated list of selectors. Rule 2 now includes two conditions as an "OR" case, firing when any B is a descendant of any P or when a B is a next adjacent sibling to a P (for example bold element 16d is a sibling of paragraph element I 6b in the above example of figure Ia). In such a case rule R2 is split into, in this example, two separate rules R2a and R2b, as shown below: R2a P B { color: red} R2b P + B { color: red) Rules R2a and R2b are treated separately according to their respective specificity values, in this example, resulting in the style sheet data structure shown in Figure Ic. In this example, rules R2a and R2b have the same specificity, but in other examples, they may have very different specificities and may therefore be at widely separated locations in the style sheet data structure because of their different relative importances.

Referring now to figure 2a, this shows a procedure for scoring rules into a style sheet data structure such as that shown in figure lb or figure Ic. At step S200 the rules are read, then the rules are sorted by their specificity, and preferably by weight and order of appearance (S202) and the sorted rules are then written into the style sheet data structure in order of importance, putting the most important rules first.

Figure 2b shows a procedure for using the style sheet data structure of figure la or lb to render an HTML document. Thus at step S206 the procedure preferably begins by parsing the HTML document and constructing a document tree of the type illustrated in figure 1 a. The tree is then traversed in a defined order (S208) and for each node a rule is identified and used to assign one or more property values to the node (S2 18), these property values then being used to render the document (S220).

To assign property values to a node an example procedure sets a pointer to the start of the style sheet data array (S210), reads the rule at the pointer (S212), and determines whether the rule matches the element of the current node (S214). If there is no match the pointer is incremented and the next rule is read (S216), otherwise the search is stopped as the applicable rule has been found.

In a variant of the above described procedures when a browser is required to render ("draw") an element such as a paragraph then to find a property value for the element, such as colour, the style sheet is searched as described above, the search being terminated when the first matching rule is found.

Figure 3 shows a block diagram of a system 300 configured to implement the above described methods. This comprises a processor 302 coupled to working memory 304, and non-volatile memory 306 storing document tree construction code, style sheet processing code, browser code, user interface code and operating system code for processor 302 to load and implement as described above. This code may be provided on a removable storage medium, by way of example illustrated by disk 307 and/or downloaded from a remote source. As illustrated system 300 includes a network interface 310 for a cable, terrestrial, satellite or other feed, and a data store 308 for storing markup language (eg HTML) document data for a document to be rendered, for example web page data and/or electronic program guide data, and style sheet data describing a presentation format of the data. Generally the data in data store 308 is provided from a remote source via a broadcast and/or network link.

The example system 300 also includes a TV system 314 although in alternative arrangements the system 300 and in particular processor 302 and the program and data memory may be implemented within the TV system with additional stored code for one or more existing processors of the system. A remote control interface 312 for receiving browser and display commands from a remote control 316 is also provided, for example to control the loading of screen and display of mark-up language data pages as described above.

No doubt many other effective alternatives will occur to the skilled person. For example, property data associated with a rule may define content additionally or alternatively to presentation or rendering style of a markup language document element.

In a similar way property data may further additionally or alternatively define the behaviour of a markup language document element such as a response to a user event such as a click or key press, which may be used to implement a dynamic change in style. In this latter case, therefore, the property data may further comprise a portion of script.

It will be understood that the invention is not limited to the described embodiments and encompasses modifications apparent to those skilled in the art lying within the spirit and scope of the claims appended hereto.

Claims

CLAIMS: 1, A method of storing style data for a markup language document,

the style data comprising a plurality of i-ules for applying styles to said document, a said rule comprising an identifier for identifying one or more elements of the document and associated property data defining a style of the identified element, a said rule having an associated importance value, in a case where two of said rules define conflicting styles for an identified element relative importance values of the rules determining which rule to apply, the method comprising storing said style data in a data structure in which said rules are ordered according to said importance values.
2 A method as claimed in claim I where said identifier comprises a selector for selecting said one or more elements of the document, and wherein said importance value is determined by a specificity value, said specificity value being responsive to a specificity of said selector.
3. A method as claimed in claim 1 or 2 wherein one or more of said rules comprises a grouped rule comprising a group of said identifiers associated with common property data defining a common said style for a group of document elements identified by said group of identifiers, and wherein the method further comprises splitting said grouped rule into a group of rules for said group of identifiers, each with an individual respective associated importance value, and storing said split rules of said group in said data structure ordered according to said individual associated importance values.
4. A method of searching style data for a markup language document stored in accordance with the method of claim 1, 2 or 3 to identify a style to apply to an element of said document, the method comprising searching said style data structure for an identifier of said element in order of decreasing importance values of said rules.
5. A method as claimed in claim 4 further comprising terminating said search on finding the first said rule with an identifier matching said document element to which said style is to be applied.
6. A method of determining a style of a markup language document, the method comprising identifying elements of said document and, for each element, determining property data defining a style for the element using the method of claim 4 or 5.
7. A method as claimed in claim 6 further comprising determining a tree data structure for said document, said tree data structure encoding a hierarchical representation of said document elements, and assigning said property data to each said document element.
8. A method as claimed in claim 6 or 7 further comprising rendering said document using said determined styles.
9. A method as claimed in any preceding claim wherein said storing of said style data further comprises storing index data for a document object model in association with each said nile.
10. A carrier carrying process control code to, when running, implement the method of any preceding claim.
11. A data structure configured to store style data for a markup language document, the style data comprising a plurality of rules for applying styles to said document, a said nile comprising an identifier for identifying one or more elements of the document and associated property data defining a style of the identified element, a said rule having an associated importance value, in a case where two of said rules define conflicting styles for an identified element relative importance values of the rules determining which rule to apply, wherein said rules of said stored style data are ordered according to said importance values.
12. A data structure as claimed in claim 11 further configured to store at least one grouped rule comprising a group of said identifiers associated with common property data defining a common said style for a group of document elements identified by said group of identifiers, and wherein said grouped rule is stored as a plurality of rules, one for each rule of said group, each with an individual associated importance value.
13. A data structure as claimed in claim 11 or 12 further configured to store index data for a document object mode) in association with each said rule.
14. A computer system including the processor control code carrier or data structure of any one of claims lOto 13.
15. A computer system for rendering a markup language document, the system comprising: data memory configured to store style data for a markup language document, the style data comprising a plurality of rules for applying styles to said document, a said rule comprising an identifier for identifying one or more elements of the document and associated property data defining a style of the identified element, a said rule having an associated importance value, in a case where two of said rules define conflicting styles for an identified element relative importance values of the rules determining which rule to apply, and wherein said rules are ordered according to said importance values; program memory storing processor control code; and a processor, coupled to said data memory and to said program memory to load and implement said processor control code, and wherein said code comprises code to: search said style data structure in order of decreasing importance values of said rules to find, for an element of said document, the first rule with an identifier matching the element; and render the element using a style determined by property data associated with said first matching rule found for the element.
16. A method, carrier, data structure or computer system as claimed in any preceding claim wherein said mark up language comprises HTML or XML.