US 7594166 B1
A method and system for rendering dynamic web page images on a display is disclosed. Code is encapsulated in an external behavior component for affecting the behavior of elements inserted into an HTML document. A simple reference is attached to the element in the document to associate the element with the external behavior component. When the document is provided to a renderer and the renderer parses the element in the document, the renderer accesses the external component to modify a behavior of the page image. Multiple documents can reuse external behavior components, and an element can be associated with multiple external behavior components. The associations between elements and external behavior components may be maintained in cascading style sheets, inline with the elements, and in various formats.
1. A computer-readable medium having computer-executable instructions for performing a method of rendering a web page image, the method comprising:
receiving an HTML document having an element thereon, the HTML document including information associating the element with an external component that is encapsulated and external to the HTML document such that multiple instances of the external component are used with a plurality of different HTML documents including the HTML document having the element thereon and wherein the information associating the element with the external component is maintained in a cascading style sheet;
rendering a page image corresponding to at least part of the HTML document, the page image including a representation of the element and the page image being rendered by a renderer configured to:
modify the page image by accessing one or more extensible markup language (XML) namespaces specified by the external component to initiate drawing of information on the page image based at least in part on code included in the one or more XML namespaces;
make a plurality of calls to the one or more XML namespaces to initiate the drawing of the information on the page image; and
draw the information on the page image responsive to one or more of the plurality of calls to the one or more XML namespaces;
instantiating the external component to reveal one or more of the XML namespaces specified by the external component, the one or more of the XML namespaces being external to the HTML document and specifying one or more behaviors to be applied to the element; and
accessing the one or more XML namespaces to retrieve a new behavior to be applied to the representation of the element rendered on the page image, the new behavior being configured to enhance a default behavior for the element.
2. The computer-readable medium of
3. The computer-readable medium of
4. The computer-readable medium of
5. The computer-readable medium of
6. The computer-readable medium of
7. The computer-readable medium of
8. The computer-readable medium of
9. The computer-readable medium of
10. The computer-readable medium of
11. The computer-readable medium of
12. The computer-readable medium of
13. The computer-readable medium of
14. The computer-readable medium of
15. The computer-readable medium of
16. A computer-implemented method of providing dynamic effects to an HTML document, comprising,
encapsulating code in an external component that affects a behavior of one or more elements contained in the HTML document while being external to the HTML document, including elements of different HTML documents, wherein code for determining a behavior of the one more elements contained in the HTML document is not included in the HTML document and is defined by one or more extensible markup language (XML) namespaces associated with the external component;
inserting an element into the HTML document;
attaching a reference in the HTML document to associate the element with an instance of the external component, such that another instance of the element is referenced by a different HTML document, and wherein the reference associating the element with the external component is maintained in a cascading style sheet and comprises a reference to the one or more XML namespaces; and
providing the HTML document to a renderer, wherein the renderer is capable of instantiating the external component, the renderer being configured to:
modify a page image by accessing the one or more XML namespaces associated with the external component to initiate drawing of information on the page image based at least in part on code included in the one or more XML namespaces;
make a plurality of calls to the one or more XML namespaces to initiate the drawing of the information on the page image;
draw the information on the page image responsive to one or more of the plurality of calls to the one or more XML namespaces;
instantiate the external component to reveal one or more of the XML namespaces associated with the external component the one or more of the XML namespaces being external to the HTML document and specifying one or more behaviors to be applied to the element; and
access the one or more XML namespaces to retrieve a new behavior to be applied to a representation of the element rendered on the page image the new behavior being configured to enhance a default behavior for the element.
17. The method of
18. The method of
19. The method of
20. The method of
21. The method of
22. The method of
23. The method of
24. The method of
25. The method of
26. The method of
27. The method of
28. A computer system including at least one processor for rendering page images on a display, comprising:
an external component encapsulating code for modifying a behavior of one or more elements, the external component operable to be instantiated multiple times and operable to modify elements in a plurality of different HTML documents while being external to the HTML documents and wherein information associating the one or more elements with the external component is maintained in a cascading style sheet, wherein code for determining a behavior of the one or more elements is included in one or more extensible markup language (XML) namespaces that are defined externally to the HTML documents and that are associated with the external component; and
at least one processing unit comprising a renderer connected to the display for rendering the page images, the renderer being configured to:
modify one or more of the page images by accessing one or more of the XML namespaces associated with the external component to initiate drawing of information on the one or more of the page images based at least in part on code included in the one or more XML namespaces;
make a plurality of calls to the one or more XML namespaces to initiate the drawing of the information on the one or more of the page images; and
draw the information on the one or more of the page image responsive to one or more of the plurality of calls to the one or more XML namespaces;
the renderer being further configured to:
instantiate the external component to reveal one or more of the XML namespaces associated with the external component the one or more of the XML namespaces being external to the HTML document and specifying one or more behaviors to be applied to the one or more elements; and
access the one or more XML namespaces to retrieve a new behavior to be applied to the representation of the one or more elements rendered on the page image, the new behavior being configured to enhance a default behavior for the one or more elements.
29. The system of
30. The system of
31. The system of
32. The system of
33. The system of
34. The system of
35. The system of
36. The system of
37. The system of
38. The system of
39. The system of
40. The system of
41. The system of
42. The system of
43. The system of
The invention relates generally to computer systems, and more particularly to the creation and subsequent rendering of interactive web pages on a computer system.
Browsers display web pages by interpreting Hypertext Markup Language (HTML), which includes sets of tags nested within other sets of tags around content to render. To assist the authors and designers in creating such web pages, a recent development is the use of cascading style sheets, via which the author or designer may globally specify styles for selected page elements, including appearance information such as color and point sizes of text, page margins, and leading (spacing between lines). A style sheet is essentially a template that controls the formatting of HTML tags on a page, and can be linked to a page or embedded in a page. Style sheets separate the formatting information from the actual content on HTML pages, whereby it has become easier for authors and designers to design and revise pages.
An improvement to how a web page may be made to appear to a viewer is Dynamic HTML (DHTML), which enhances the appearance of a page's elements by adding effects thereto. Dynamic HTML (DHTML) also allows an HTML document to become interactive, which is accomplished by allowing HTML elements or tags within the HTML document to be programmable, such that script can change the content and attributes of the HTML page. For example, a script on the page may allow a list to be expanded or collapsed in response to a mouse click, without needing to retrieve a different HTML document from the server. The script resides on the same page as the other elements, even when the script is obtained from a separate file, since that script is particular to the page and is essentially imported into the page when the HTML document is loaded.
In essence, three job disciplines are involved in creating a DHTML page, i.e., a content provider, designer, and engineer. The content provider is the author of the content of the document, while the designer decides on the look and feel of the document, and typically adds any formatting information. The engineer adds the dynamic functionality using script. In many situations, these jobs are not performed by one highly-skilled person, but by three separate individuals of different skill levels, as many authors and designers are uncomfortable with programming. This, along with the fact that the script resides on the same page as the other elements, makes DHTML expensive and fragile to use in web documents. More particularly, as the engineer applies one or more scripts to every page, the process becomes expensive and error prone, as subsequent content changes by the author or designer may affect the script. At the same time, the engineer may affect the layout or content of the document when adding the script to the page. Even for those authors and designers who are comfortable with programming concepts and with using script to add dynamic functionality to a document, having the script and content in the same file makes the page creation and maintenance processes relatively slow and difficult to manage.
Briefly, the present invention provides a method and system for adding script-like behavior to an element via a component that is external to the page. An external behavior is created for affecting the behavior of elements inserted into an HTML document by encapsulating code in an external behavior component, preferably a COM (component object model) object. A designer or the like adds simple tags to the document to associate the external behavior component with selected elements, thereby separating script from content. These associations between elements and external behavior components may be maintained in cascading style sheets, inline with the elements, and in various formats.
When the document is provided to a renderer and the renderer parses the element in the document, the renderer accesses the associated external component to modify a behavior of the page image. For example, the properties or location of a displayed element associated with the external behavior component may be changed on an event such as a mouseover event. An external behavior component can provide mask behavior to control the format and type of user data input. Another external behavior component can draw on the image when accessed by the renderer.
Multiple documents can reuse external behavior components, enabling, for example, an entire web site to share a common behavior. An element can be associated with multiple external behavior components to provide multiple effects, such as changing color and expanding a list when clicked by a user.
Other advantages will become apparent from the following detailed description when taken in conjunction with the drawings, in which:
With reference to
A number of program modules may be stored on the hard disk, magnetic disk 29, optical disk 31, ROM 24 or RAM 25, including an operating system 35 (preferably Windows NT), one or more application programs 36, other program modules 37 and program data 38. A user may enter commands and information into the personal computer 20 through input devices such as a keyboard 40 and pointing device 42. Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner or the like. These and other input devices are often connected to the processing unit 21 through a serial port interface 46 that is coupled to the system bus, but may be connected by other interfaces, such as a parallel port, game port or universal serial bus (USB). A monitor 47 or other type of display device is also connected to the system bus 23 via an interface, such as a video adapter 48. In addition to the monitor 47, personal computers typically include other peripheral output devices (not shown), such as speakers and printers.
The personal computer 20 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 49. The remote computer 49 may be another personal computer, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the personal computer 20, although only a memory storage device 50 has been illustrated in
When used in a LAN networking environment, the personal computer 20 is connected to the local network 51 through a network interface or adapter 53. When used in a WAN networking environment, the personal computer 20 typically includes a modem 54 or other means for establishing communications over the wide area network 52, such as the Internet. The modem 54, which may be internal or external, is connected to the system bus 23 via the serial port interface 46. In a networked environment, program modules depicted relative to the personal computer 20, or portions thereof, may be stored in the remote memory storage device. It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used.
DHTML behaviors (e.g., 60,
In general, an HTML document, or page, may be considered a document tree, in that elements are contained by other elements in a hierarchical manner. As shown in
When applied to a standard HTML element on a page, a behavior component 60 enhances that element's default behavior. For example, a behavior component can be written to toggle the display property of an element's children on a mouse click. When such a behavior component 60 is applied to a standard element on a page, the behavior component 60 enhances the unordered list's default behavior to expand and collapse when clicked. Another behavior component (e.g., 60, of
In accordance with one aspect of the invention and as represented in
To use a behavior component (e.g., 60, of
In accordance with one aspect of the invention, once developed, a page designer or the like may then use the declarative HTML tag syntax that is already familiar to the designer in order to refer to the behavior component. To this end, the designer includes a behavior attribute, essentially a reference to the behavior component, such as in an embedded style in the cascading style sheet block, and also attaches a tag to each element that implements that behavior component. In other words, using existing cascading style sheet support in the renderer 66, a behavior can be added to an element. The behavior property in cascading style sheets typically has the following syntax:
This syntax can be used in any standard style declaration, for example, in an Inline style declaration on an element, as described below. For example, to add a fly (move across the screen) behavior to a DIV element, a designer enters:
As also described below, a class can also be declared to apply to elements in the document. For example, a flyme class may be defined, and can be applied to a DIV element:
A new, custom tag may also be defined with a behavior attached, as also described below, for example:
The renderer 66 handles the association between the tag and the behavior component, along with the instantiation of the behavior component and the interfacing thereto, whereby script is no longer needed on the page. The result is dynamic HTML via a substantially cleaner, script-free page.
By way of example, as shown in
Although HTC provides a quick and easy way to create DHTML behaviors using scripting languages such as Microsoft® Visual Basic® Scripting Edition (VBScript) and Microsoft® JScript® (compatible with ECMA 262 language specification), like other components used on the Internet today, behaviors can be alternatively implemented using Windows® Scripting Components (WSC) or C++. Note that when using the behavior attribute, the type of behavior, i.e., a behavior implemented as a binary component (using C++ or any compiled code), a default behavior (built into the renderer 66), or as a component written in script (either as an HTML Component or as a scriptlet) determines the syntax used to apply the behavior to an element using cascading style sheets. In the case of a Component Script and HTML implementation, the STYLE can specify a URL for the script that implements the component. In the case of a binary implementation of the component, the url in the style would refer to the ID of an OBJECT tag that declares a binary component to supply a factory for the component.
When different instances of a behavior component are attached, a style subobject of the element is used, as set forth in the following example:
Another way in which cascading style sheets may be used to implement a behavior on an element is by defining an embedded style, using a class name as a selector. Note that the selector begins with a period (.), which is the syntax for class names as selectors. This causes each element assigned the class name of HILITE to behave as defined in hilite.htc. An example using a class name is shown below:
As shown in
In general, the designer typically specifies the behavior attribute based on how many elements are to have the behavior applied. For example, defining the behavior inline or through script is appropriate for applying the behavior to a select number of elements, while defining an embedded style is appropriate for applying the behavior to a set of elements globally.
Another way in which a behavior may be applied to an element is via scripting, using the addBehavior method. The addBehavior method is a dynamic way of applying a behavior to an element. When the method is called, the behavior is appended to a list of behaviors being applied to the element (as opposed to overwriting the behavior that might have already been attached to that element at the time the method was called). Once attached, the behavior can be detached anytime using the removeBehavior method. The following example demonstrates how a behavior that implements a mouseover highlighting effect could be dynamically attached to each of the LI elements on a page using addBehavior. Subsequently, the behavior may be detached using removeBehavior in a similar manner.
Note that a behavior attached to an element through cascading style sheets, using a style rule defined in the document, is automatically detached from the element as soon as the element is removed from the document tree. Once the element is removed, all associations of that element to any element in the document tree, such as style sheet rules that specify behaviors, are stripped from the element as well. Conversely, a behavior attached to an element through an inline style, or through the addBehavior method, is not automatically detached from the element when the element is removed from the document hierarchy. These two methods of applying behaviors have no dependencies on the containing document, and therefore the behavior remains applied to the element even as it is removed from the document tree. The removeBehavior method can be invoked to explicitly detach this type of behavior from the element.
Multiple behaviors can be applied to an element, for example by specifying a space-delimited list of URLs for the behavior attribute, as shown in the following code. This particular sample demonstrates how two behaviors can be applied to an element to achieve a combination of effects:
When applying multiple behaviors to an element, conflicts may occur, for example if both behaviors operate to change an element's color. Conflicts are resolved based on the order in which the behavior was applied to the element. Using the above example, the “collapsing.htc” behavior is applied first, followed by the “hilite.htc” behavior, with each subsequent behavior taking precedence over the previous behavior. In the above example, if there are no conflicting style assignments between the two behaviors, any style changes made by both behaviors are applied unaltered to the element. If, however, both behaviors set the element's color, for example, the second (hilite.htc) behavior's color prevails because it was applied to the element later than the first behavior (collapse.htc). The same rule applies when resolving name conflicts, such as with property, method, or event names exposed by multiple behaviors.
The behavior property of an element can be overridden when multiple styles are applied to an element, (similar, for example, to the overriding of the color property). When resolving style conflicts in an HTML document, the cascading style sheet rules of cascading and inheritance prevail, wherein the order of specificity, from greatest to least, is (1) inline styles; (2) ID; (3) CLASS; and (4) HTML element. In the following example, both the “Collapsing” class and the inline style for the LI element define the behavior attribute.
As a component, a DHTML behavior may expose properties, methods, and events that define its object model. When a behavior is applied to an element, the element's properties, methods, and events are extended to include those exposed by the behavior.
Turning to an explanation of the present invention from the perspective of the renderer 66, the renderer 66 operates in response to an event to interpret the appropriate page elements. In keeping with the present invention, when an element in the HTML document having a behavior component attached is parsed by the renderer 66, instead of having to run a script, the renderer 66 instantiates (or uses if already instantiated) the behavior component to perform some action. Instantiation of behavior component may require downloading, and, if a download is required, the component may be downloaded and instantiated on a separate thread whereby the parsing of the main document is not halted.
As generally described below, when an event is received, (e.g., from some event detector 72,
If no event handler is attached, the event bubbles up through the hierarchy of elements until the top of the hierarchy has been reached, (i.e., until the event bubbles up to the window object), as represented by steps 516-518. If an event handler 74 is attached to the current element, such as to handle mouseover events, at step 504 the event handler 74 is called to carry out its actions and return. For example, as represented via steps 506-508, the event handler 74 may determine if a behavior component needs to be instantiated (step 508), and if so, instantiates the behavior (step 508). Then, the event handler 74 (or renderer) calls a method of that behavior (step 510) on an interface 76, passing it any needed information (e.g., the rendered element's coordinates) to carry out its actions to affect the element's appearance or behavior, (e.g., to change the rendered element's color). Note that some or all of the event handler functions described herein may be performed by the renderer 66, e.g., instantiating the behavior as needed, and calling a method thereof, while other event handler operations may be written into the behavior component. A dashed box is used to represent the event handler 74 in
An event handler can cancel the bubbling of an event, as represented by step 512, wherein the event is considered fully handled. Otherwise the event handling process branches to step 516, where the event bubbles up through the hierarchical tree of elements via steps 516 and 518. A final default action (optional at step 520, shown as a dashed box) may be taken if the event not canceled by a handler at step 512.
Basic interfaces for calling an instantiated behavior component are set forth below, along with accompanying information:
The IElementBehavior interface is an event sink that receives notifications from Mshtml.dll concerning the activities of Dynamic HTML (DHTML) behaviors. This interface is obtained from the IElementBehaviorFactory::FindBehavior method, described below.
IElementBehavior is the basic interface to be implemented by a DHTML Behavior component. Init( ) is called on the Behavior when it is instantiated, and is used to pass the IElementBehaviorSite to the Behavior component. The behavior component may cache this pointer for later use, and the pointer is passed to the behavior component without the interface addressed. Notify( ) is a generic mechanism to send down arbitrary notifications to the component. Notifications that are currently sent include BEHAVIOREVENT_CONTENTREADY, fired once when the content of the element has been initially parsed (not every time the content changes). The other notification is the BEHAVIOREVENT_DOCUMENTREADY notification, which is sent when the contents of the document have been parsed. This is equivalent to the onload event or readystate which is fired when the entire document, including images, OBJECTS, SCRIPTS, and so forth have also downloaded. The DOCUMENTREADY notification is sent after the document has finished parsing.
The IElementBehaviorCategory interface provides DHTML behaviors a means of identifying their category. Using identification by category, related behaviors may be easily located.
The IElementBehaviorFactory interface provides DHTML behavior implementations.
The IElementBehaviorRender Interface enables a behavior component to participate in the rendering of text and objects. If the behavior component does not need to participate in such rendering, this interface need not be implemented.
The IElementBehaviorSiteCategory interface provides DHTML behaviors a means of identifying other related behaviors by category. Using identification by category, related behaviors may be easily located.
The IElementBehaviorSite interface is the fundamental means of communication that a component has with MSHTML.dll. This interface is first received by the IElementBehavior::Init notification. The IElementBehaviorSiteOM, IBindHost and IServiceProvider interfaces can be accessed through the IElementBehaviorSite interface by using QueryInterface.
The IElementBehaviorSiteOM interface is responsible for providing event services to behavior components. To access this interface, use QueryInterface on the IElementBehaviorSite interface returned by the IElementBehavior::Init notification method.
In keeping with the present invention, behaviors can extend an existing HTML element by adding functionality via an Object Model. An example is the mask edit behavior, wherein behavior is applied to input elements that allow data entry. The mask behavior provides a combination of restricted input and formatted output. For example, a mask behavior component can be applied through one of several preset formats to many common types of forms fields, such as date, time, and phone number fields, whereby the user may only enter appropriate data (e.g., numbers) in appropriate fields. To this end, when information is entered, the behavior may provide visual cues about the type of acceptable information (e.g., a slash “/” between numeric mm/dd/yy date entries) and/or feedback about incorrect entries. A sample htc (HTML Component) file that provides entry fields for date, money and time entries via mask behavior is set forth below:
In accordance with another aspect of the present invention, new tags may be used for applying behaviors to elements instead of existing tags. For example, a CIRCLE or SQUARE tag may be used for vector graphics. New tags are parsed and the document tree built as though it were a standard container tag with clearly defined parsing rules for a containing tag.
To this end, behavior components define functionality for new tags that follow an XML namespace syntax, and thus new tags are declared using a declaration on the HTML tag, for example:
The new tags that follow XML syntax would be able to have virtually any HTML within them. If any ill-formed, overlapping, or implied HTML tags are present, the renderer 66 will build the document tree to the best of its ability and render the page image accordingly. Note that use of @media all to contain the custom tag declarations is optional, which allows a downlevel browser to ignore the content, (as some browsers dislike the use of the backslash within cascading style sheets, although permitted).
In accordance with another aspect of the present invention, behaviors may be used to render complex drawings. As described above, an extensible tag can use the renderer 66 to handle rendering of its data simply by placing the relevant content in the document tree, whereby the renderer 66's rendering abilities do the rest. However there are definite aspects of rendering that the renderer 66 cannot achieve, such as circles, curves and line drawing.
To allow an extensible tag component to extend the browser's abilities in this area, a new drawing interface is established which the behavior component implements, and the renderer 66 calls at appropriate times during its rendering. When called, the drawing behavior component is passed a drawing surface that is windowless, such that any drawing can fit into a specified z-index and be subject to any filter and transition effects.
The renderer 66 draws in four passes, namely, 1) Background, the background of the document; 2) Negative-Z, any Z-index layers below the current element of interest; 3) Content—the content of the current element; and 4) Positive-Z, any Z-Index layers that are above the element.
The extensible tag behavior component may prevent the renderer 66 from drawing any of the above four rendering layers, and also may provide drawing at any five additional layers that interleave renderer's layers. As represented in
This interface is implemented by any component which wants to participate in the rendering of text and objects.
As can be seen from the foregoing detailed description, there is provided a method and system wherein dynamic functionality is encapsulated in a tag or class, and the behavior component is external to the page, providing clean, robust, powerful and extensible dynamic functionality to web page elements that may be reused across multiple pages. A simple declarative syntax greatly simplifies applying a behavior to an element.
While the invention is susceptible to various modifications and alternative constructions, certain illustrated embodiments thereof are shown in the drawings and have been described above in detail. It should be understood, however, that there is no intention to limit the invention to the specific form or forms disclosed, but on the contrary, the intention is to cover all modifications, alternative constructions, and equivalents falling within the spirit and scope of the invention.
Citations de brevets
Citations hors brevets