ECSP034609A

Markup language and object model for vector graphics

Abstract

A model object element and a vector graphics reference language to use that model object element in a way that allows program code designers to consciously interface with the data structure of the graphic scene. The vector graphics model object element generally corresponds to figure elements and other elements including image and video element that are mapped to the graphic scene model object. The reference can be translated to data including elements of the tree element that are translated into objects in a graphical scene data structure. Another reference can be translated directly into data and calls that create the objects of the graphic scene. The reference language provides different ways to describe an element, including a simple row format or complex property syntax, which can be named, allowing repeated use elsewhere in the reference.

ECSP034609A, drawing sheet 1 — Sheet 1 of 25

Term

No projected expiry on record.

60 claims: 3 independent, 57 dependent

1
En un ambiente de computación, un sistema que comprende:un mecanismo que interpreta referencias para construir un elemento denominado elemento árbol, teniendo al menos algunos de los elementos del elemento árbol información asociada de propiedades que corresponden a un elemento objeto modelo;una capa de interconexión de la escena gráfica, que comprende un juego de al menos una interconexión que puebla una escena gráfica con objetos en respuesta a pedidos para crear los objetos, correspondiendo los objetos a un objeto modelo de escena gráfica;y un traductor que traduce al menos algunos de los elementos e información de propiedades del elemento árbol -114en pedidos hechos a la capa de interconexión de la escena gráfica para que cree objetos en la escena gráfica.
2
El sistema de la reivindicación 1 en donde los elementos del elemento objeto modelo substancialmente se correlacionan con los objetos del objeto modelo de la escena gráfica.
3
El sistema de la reivindicación 1 donde la referencia incluye texto en línea incluyendo una fila que define las propiedades de un elemento, y el traductor se comunica con un tipo de conversor para convertir la fila en una propiedad del objeto.
4
El sistema de la reivindicación 1 de este documento en donde la referencia incluye texto en línea que comprende sintaxis de propiedad compleja.
5
El sistema de la reivindicación 4 en donde el texto en línea es identificado con una referencia a la que se hace referencia en otro lugar de la referencia.
6
El sistema de la reivindicación 4 en donde el texto en línea es identificado con una referencia que se refiere a un archivo.
7
El sistema de la reivindicación 4 en donde el texto en línea es identificado con una referencia que corresponde a un archivo que puede ser bajado desde un sitio remoto de una red.
8
El sistema de la reivindicación 1 en donde la referencia incluye texto en línea que comprende sintaxis de -115- propiedades complejas correspondientes a un recurso gráfico.
9
El sistema de la reinvindicación 8 en donde el recurso gráfico describe un objeto pincel visual, proporcionando el traductor información a nivel recurso para comunicarse directamente con la capa de interconexión de la escena gráfica para crear un objeto visual de pintura correspondiente a un elemento descrito por la sintaxis de propiedad compleja.
10
El sistema de la reivindicación 9 en donde la información a nivel de recurso es identificada con una referencia a la que se hace referencia en otro lugar de la referencia.
11
El sistema de la reivindicación 9 en donde la información a nivel de recurso es identificada con una referencia que se refiere a un archivo.
12
El sistema de la reivindicación 9 en donde la información a nivel de recurso es identificada con una referencia que se refiere a un archivo que podría ser bajado de un lugar remoto en una red.
13
El sistema de la reivindicación 1 en donde uno de los elementos del elemento objeto modelo comprende un elemento imagen.
14
El sistema de la reivindicación 1 en donde uno de los elementos del elemento objeto modelo comprende un elemento video. -116-
15
El sistema de la reivindicación 1 en donde uno de los elementos del elemento objeto modelo comprende un elemento lienzo que contiene μη elemento forma.
16
El sistema de la reivindicación 1 en donde uno de los elementos del elemento objeto modelo comprende un elemento forma.
17
El sistema de la reivindicación 16 en donde el elemento forma comprende un elemento rectángulo.
18
El sistema de la reivindicación 16 en donde el elemento forma comprende un elemento polilínea.
19
El sistema de la reivindicación 16 en donde el elemento forma comprende un elemento polígono.
20
El sistema de la reivindicación 16 en donde el. elemento forma comprende un elemento sendero.
21
El sistema de la reivindicación 16 en donde el elemento forma comprende un elemento línea.
22
El sistema de la reivindicación 16 en donde el elemento forma comprende un elemento elipse.
23
El sistema de la reivindicación 16 en donde el elemento forma comprende un elemento círculo.
24
El sistema de la reivindicación 16 en donde el elemento forma incluye información de propiedades del relleno.
25
El sistema de la reivindicación 16 en donde el elemento forma incluye información de propiedades de rasgo. -117-
26
El sistema de la reivindicación 16 en donde el elemento forma incluye información sobre las propiedades del recorte.
27
El sistema de la reivindicación 16 en donde el elemento figura incluye información de propiedades de transformación.
28
El sistema de la reivindicación 16 en donde el elemento figura incluye información de efecto.
29
El sistema de la reivindicación 16 en donde el elemento figura incluye información de opacidad.
30
El sistema de la reivindicación 16 en donde el elemento figura incluye información de modo de mezcla.
31
El sistema de la reivindicación 1 que comprende aún más un motor que procesa la estructura de información de la escena gráfica y proporciona órdenes al menos a un componente de gráficos de nivel más bajo.
32
El sistema de la reivindicación 31 en donde el motor traslada la estructura de datos de la escena gráfica.
33
El sistema de la reivindicación 31 en donde el motor transmite la estructura de datos de la escena gráfica.
34
El sistema de la reivindicación 1 en donde el traductor pide ejemplificar de manera concreta al menos un constructor para crear los objetos.
35
Un método implementado en computador, que comprende:análisis de referencia, la referencia incluye -118- etiquetas e información asociada de propiedades de acuerdo con un objeto modelo;interpretando una etiqueta en la referencia para determinar si la etiqueta está dirigida a un nivel elemento o a un nivel recurso, y a) si la etiqueta está dirigida a un nivel elemento, creando un elemento basado en la etiqueta y los datos de propiedad asociados con la etiqueta, añadiendo el elemento a un elemento árbol para luego traducirlo en un objeto de la escena gráfica en una estructura de datos de escena gráfica;y b) si la etiqueta está dirigida a un nivel recurso, proporcionando la información para crear directamente un objeto de la escena gráfica en la estructura de datos de la escena gráfica a través de una interconexión con la estructura de datos de la escena gráfica.
36
El método de la reivindicación 35 en donde los objetos del elemento objeto modelo substancialmente se correlacionan con objetos en la estructura de datos de la escena gráfica.
37
El método de la reivindicación 35 en donde la referencia incluye texto en línea para una etiqueta con valor de propiedad y posterior compresión, comunicando con un conversor tipo para convertir el texto en línea en un objeto propiedad.
38
El método de la reivindicación 35 en donde la referencia incluye texto en línea para una etiqueta de -119- valor de propiedad teniendo de referencia a otro texto en la referencia, y en donde interpretar la etiqueta de valor de propiedad comprende interpretar el otro texto.
39
El método de la reivindicación 35 en donde la 5 referencia incluye etiquetas que comprenden sintaxis de propiedad compleja para un elemento, y en donde se interpretan las etiquetas comprendiendo interpretación de la sintaxis de propiedad compleja para determinar que las etiquetas son dirigidas a nivel elemento. 10
40
El método de la reivindicación 35 en donde la referencia incluye etiquetas que especifican sintaxis de propiedad compleja para un elemento, y en donde interpretar las etiquetas comprende interpretar la sintaxis de propiedad compleja para determinar que el elemento está 15 dirigido a nivel recurso.
41
El método de la reivindicación 40 en donde interpretar la sintaxis de propiedad compleja comprende detectar que la sintaxis de propiedad compleja describe una propiedad correspondiente a un objeto visual pincel. 20
42
El método de la reivindicación 40 en donde las etiquetas definen un objeto visual pincel al que se hace referencia por un elemento en el elemento árbol.
43
Un medio legible por computadora que tenga instrucciones ejecutables por computadora para realizar el 25 método de la reinvindicación 35. -120-
44
Un medio legible por computadora que tiene almacenado en él una estructura de datos, que comprende:un primer juego de datos que comprende un primer juego de etiquetas y datos de propieda'd, en el cual el contexto en el cual el primer juego de etiquetas es interpretado indica que el primer juego de etiquetas está dirigido a un nivel elemento;un segundo juego de datos que comprende un segundo juego de etiquetas e información de propiedad segunda, en el cual el contexto en el cual el segundo juego de etiquetas que es interpretado corresponde a sintaxis de propiedad compleja e indica que el segundo juego de etiquetas está dirigido a un nivel recurso;y cuando la estructura de datos es interpretada, el primer juego de datos resulta en datos correspondientes al primer juego de etiquetas siendo creadas e insertadas dentro de un árbol a nivel elemento basado sobre la primera información en el primer juego de texto, y el segundo juego de datos resulta en datos correpondientes al segundo juego de etiquetas siendo proporcionadas para crear directamente un objeto escena gráfica en una estructura de datos de la escena gráfica a nivel recurso a través de una interconexión con la estructura de datos de la escena gráfica, basado en la segunda información en el segundo juego de textos. -121-
45
La estructura de datos de la reivindicación 44 que además incluye un tercer juego de datos que comprenden una fila correspondiente al valor propiedad.
46
La estructura de datos de la reivindicación 44 en donde el primer juego de etiquetas especifica un identificador, y además comprende un tercer juego de datos que hace referencia al identificador.
47
La estructura de datos de la reivindicación 46 en donde cuando es interpretado, el tercer juego de datos resulta en datos correspondientes al primer juego de etiquetas siendo añadidas a un árbol a nivel elemento en un árbol de localización para el cercer juego de datos.
48
La estructura de datos de la reivindicación 44 en donde el segundo juego de etiquetas incluye un identificador, y además comprende un tercer juego de datos que hace referencia al identificador.
49
La estructura de datos de la reivindicación 44 en donde el segundo juego de itiquetas incluye datos formateados en una sintaxis de propiedad compleja en línea en la referencia.
50
La estructura de datos de la reivindicación 49 en donde la sintaxis de propiedad compleja describe un elemento a nivel recurso que tiene una propiedad de relleno que corresponde a un objeto visual paint. -122-
51
La estructura de datos de la reinvindicación 44 en donde la sintaxis de propiedad compleja describe propiedades de un elemento imagen.
52
La estructura de datos de la reinvindicación 49 en donde la sintaxis de propiedad compleja describe propiedades de un elemento video.
53
La estructura de datos de la reinvindicación 44 en el primer juego de etiquetas describe propiedades de un elemento figura.
54
La estructura de datos de la reinvindicación 53 además comprende datos en la estructura de datos que describe un elemento lienzo que contiene el elemento forma.
55
La estructura de datos de la reinvindicación 53 en donde las propiedades del elemento figura comprenden datos de propiedades del relleno.
56
La estructura de datos de la reinvindicación 53 en donde las propiedades del elemento forma comprenden datos de propiedad de rasgos.
57
Los estructura de datos de la reinvindicción 44 en donde las propiedades del primer elemento incluyen datos de recorte.
58
La estructura de datos de la reinvindicación 44 en donde las propiedades del primer elemento incluyen datos de transformación. -123-
59
La estructura de datos de la reinvindicación 44 en donde las propiedades del primer elemento incluyen datos de opacidad.
60
La estructura de datos de la reinvindicación 44 en 5 donde las propiedades del primer elemento incluyen datos de modo de mezcla.

Independent claims60

773 paragraphs in 18 sections, as filed

REFERENCE LANGUAGE AND MODEL OBJECT FOR GRAPHICS

VECTORS

The present invention is related to the following pending United States patent applications: Serial No. 10/184, 796 entitled Multi-Level Graphics Processing Method and System; Serial No. 10/185,775 entitled Intelligent Data Storage Structure for Immediate Mode Graphics; each filed June 27, 2002; and the United States Patent Application titled Visual Interconnection and Graphic Scene (Legal Registration No. 3470';, filed concurrently with this document. Each related application is assigned to the patentee of the present patent application and incorporated herein by reference in its entirety.

FIELD OF THE INVENTION

The invention relates generally to computer systems, and more particularly to the processing of graphics and video information for display on computer systems.

BACKGROUND OF THE INVENTION

The limits of the traditional out-of-the-box model for accessing graphics in computer systems are being reached, in part because memory and transmission speeds have not kept up with advances in mainframe and/or desktop processors. graphics. In general, the current model (eg, WM_PAINT) to prepare a frame requires too much data processing to keep up with the reload rate of the computer when you want to add complex graphical effects. As a result, when attempting to include complex graphics effects in conventional graphics models, instead of completing the changes resulting in perceptible visual effects in time for the next frame, the changes can be added on top of different frames causing effects that are visually and remarkably undesirable.

A new model for controlling graphics output is described in US Patent Application Serial Nos. 10/184, 795, 10/184, 796, and 10/185, 775. This new model provides a number of important improvements. in graphics processing technology. For example, US Serial No. 10/184, 795 is generally directed toward a multi-level graphics processing method and system, in which a higher-level component (eg. of a system

-2op) operates computationally intensive aspects of creating a render scene, updating animation parameters and translating render scene data structures at a relatively low operational rate to pass simplified data structures and/or render commands to a component low level. Because high-level processing greatly simplifies the data, the low-level component can operate at a faster rate, (relative to the high-level component), such as one that corresponds to the frame reload rate of a data subsystem. graphics to process the data consistently for the graphics subsystem. When using animation, rather than having to redraw an entire scene with changes, low-level processing can interpolate the ranges of parameters needed to obtain instantaneous values that when put together give a slightly changed scene at each frame, providing a fluid animation.

US Serial No. 10/184, 796 describes a graphics scene in parameters that provide mutable (animated) values and graphics containers in parameters such that program code that wishes to draw graphics (eg, a program application or component of the operating system) can selectively change certain aspects of the graphical scene description, while leaving other aspects intact. The program code

-3can also reuse already built portions of the scene graph, with possibly different parameters. As can be appreciated, the ability to easily change the appearance of displayed items through the use of parameters and/or the reuse of existing parts of a graphics scene provides substantial advantages in the overall efficiency of graphics processing.

US Serial No. 10/185, 775 generally describes a data storage structure and related mechanisms for storing visual information through objects and data in a graphical scene. The data structure is generally associated with mechanisms that intelligently control the distribution and use of the visual information contained therein. For example, unless specifically called for in the application of the program, most information stored in the data structure has no external reference, allowing this information to be optimized or otherwise processed.

As can be seen, this provides efficiency and conservation of resources, eg. the data in the data storage structure may be processed in a different format that is more compact or reduces repetition, need for subsequent processing or such as a bitmap or other post-processing output.

-4While the above improvements provide substantial benefits in graphics processing technology, there is still a need for a way for programs to effectively use this improved graphics model and its other related enhancements in a direct way. What is needed is a comprehensive and straightforward way for programs to take advantage of the many features and graphics processing capabilities provided by the improved graphics model and thereby produce complex graphics in an efficient manner.

SUMMARY OF THE INVENTION

Briefly, the present invention provides an elementary object model and a vector graphics reference language for accessing that elementary object model in a way that allows program code programmers to interface consistently with the data structure of a graphics scene. to produce graphics. The vector graphics reference language comprises an interchangeable format for expressing vector graphics through the elementary object model. When interpreted, the reference is parsed into data including elements in an element tree that are translated into the objects of a scene graph data structure. At the tree element level, a property system and a presenter system are provided to provide

-5Rich programmability features, including inheritance and event features, making it clear for designers to design possibly complex scenes. In general, vector graphics elements correspond to shape elements and other elements including image and video that map to the graphics scene objects of the graphics scene model object. The properties and other resources of the vector graphic elements are also mapped to similar properties and resources of the model object of the graphic scene.

The vector graphics system can therefore program at the element level, where each of the drawing shapes is represented as an element at the same level as the rest of the programmable elements of a page or scene, allowing interaction with the system. presenter, events and properties. The vector graphics system also provides a mechanism for programming at a resource level, in which designers can essentially shortcut between the tree element and the rendering system to program directly in the visual API layer that interfaces with the tree structure. graphic scene data. This provides a more efficient and lightweight way to get the appropriate object, despite losing some element-level programmability. In one implementation,

-6when programming a visual brush fill, the parser can directly call the layer API with the data level resource to create a corresponding paint visual object (which is also a mapping between the model object element and the model object element). graphic scene). In this two-tier system, element-level vector graphics are parsed into created elements that need translation into objects, while resource-level vector graphics are parsed and directly stored efficiently. At the same time, the data at the resource level or the objects created in that way can be referenced by elements and parts of the element tree. For this purpose, items including visual painting elements can be named. The scene designer therefore has the ability to balance efficiency and programmability as necessary.

The element class hierarchy includes a shapes class, an image class, a video class, and a canvas class. Elements of the shape class include rectangle, polyline, polygon, path, line, and ellipse. Each element may include or be associated with fill (property), feature, clipping, transform, filter effect, and mask information. Shapes correspond to geometry (of the graphic scene model object) that are drawn with inherited and cascading display properties and are used

-7to build the pen and brush needed to draw the shapes. The image class is more specific than the shape class and can include more background graphic information, while the video class allows video (or other similar multimedia) to be projected within a displayed element. The canvas class can act as a shape container to keep shapes lightweight.

In one implementation, the reference code is interpreted by a parser/translator which typically adds element-level elements to an element tree or property system and attaches presenters to those elements. The renderer system then takes the tree element with the attached renderers and translates the information into objects (via a constructor) and calls a visual API layer that interleashes with the scene renderer and creates the renderer scene objects.

The reference language provides different ways to describe an element, including a simple row format or a complex object annotation (a complex property syntax). For a simple row format, the parser, translator, and/or presenter system uses a type converter to convert the string into an appropriate visual API object. When the padding attribute is too complex to fit within a single row, a complex property syntax is used, which may be inlined in the reference to describe the set of properties.

-8Because the same getter model is shared between the element level and the API level, many of the objects are the same, making parsing or translation highly efficient and providing other benefits. A resource instance can also be located elsewhere (eg in the reference or a file) and can be referred to by its name. In this way, a scene designer can reuse an element from the element tree throughout a scene, including elements described by complex property syntax.

Other benefits and advantages will become apparent from the following detailed description when viewed in conjunction with the drawings in which:

BRIEF DESCRIPTION OF THE DRAWINGS

FIGURE 1 is a block diagram representing an exemplary computing system into which the present invention may be incorporated;

FIG. 2 is a block diagram generally representing a graphic layer architecture into which the present invention may be incorporated;

FIG. 3 is a representation of a graphics scene of visual and associated components for processing a particular graphics scene, translating the graphics scene for

-9 provide graphic commands and other information in accordance with an aspect of the present invention;

FIG. 4 is a representation of a graphical scene of validation visuals, drawing visuals, and associated primitive drawings constructed in accordance with one aspect of the present invention;

FIG. 5 is a visual class representation of a model object in accordance with one aspect of the present invention;

FIG. 6 is a representation of various other objects of the model object, in accordance with one aspect of the present invention;

FIG. 7 is a diagram representing the transformation of visual information in accordance with one aspect of the present invention;

FIGS. 8A and 8B are representations of transformations of visual information on a geometric scale and on a non-uniform scale respectively, in accordance with one aspect of the present invention;

FIGS. 9A-9C are block diagrams of surface visuals and other visual components in accordance with one aspect of the present invention;

FIGS. 10A and 10B are diagrams representing HWnd visuals in accordance with one aspect of the present invention;

-10FIG. 11 is a diagram representing layered visuals in accordance with one aspect of the present invention;

FIG. 12 is a geometric class representation of the model object, in accordance with one aspect of the present invention;

FIG. 13 is a representation of a PathGeometric structure in accordance with one aspect of the present invention;

FIG. 14 is a representation of a graphical scene of primitive visuals and drawings showing examples of graphics produced by the primitives, in accordance with one aspect of the present invention,

FIG. 15 is a brush class representation of the model object according to one aspect of the present invention;

FIG. 16 is a representation of graphics produced as a result of information in a linear gradient of the brush object, in accordance with one aspect of the present invention;

FIG. 17 is a representation of graphics obtained as a result of information on a radial gradient of the brush object, in accordance with one aspect of the present invention;

FIG. 18 is a representation of graphs obtained as a result of having multiple values expanded in accordance with one aspect of the present invention,

FIG. 19 is a representation of graphics obtained as a result of various tile values, in accordance with one aspect of the present invention;

FIG. 20 is a flowchart generally representing logic for interpreting a visual object, including a brush object, to generate graphics in accordance with one aspect of the present invention,

FIG. 21 is a representation of a grid and a transformed grid, resulting from the information in a visual brush object, in accordance with one aspect of the present invention;

FIG. 22 is a representation of a grid and a transformed grid, with graphics thereon drawn from a visual, in accordance with one aspect of the present invention;

FIG. 23 is a representation of a nine-grid brush object in accordance with one aspect of the present invention;

FIG. 24 is a representation of the model object transformation class, in accordance with one aspect of the present invention;

-12FIG. 25 is a representation of the element class of the model object element, in accordance with one aspect of the present invention;

FIG. 26 is a representation of components for interpreting reference language code when interacting with the visual API layer, in accordance with one aspect of the present invention; and

FIG. 27 is a representation of clipping through a geometric path in accordance with one aspect of the present invention.

-13 DETAILED DESCRIPTION

EXEMPLARY OPERATING ENVIRONMENT

FIGURE 1 illustrates an example of a suitable computing system environment 100 in which the invention may be implemented. The computing system environment 100 is only one example of a suitable environment and is not intended to suggest any limitation as to the scope of its use or the functionality of the invention. Nor should it be construed that the computing environment 100 has any dependencies or requirements related to any component or combination of components illustrated in the exemplary operating environment 100.

The invention is operational with numerous other general or special purpose computing system environments or configurations. Examples of known computing systems, environments, and/or configurations that might be suitable for use with the invention include, without limitation, personal computers, servers, laptop or handheld computers, tablet devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable electronic devices, network personal computers, mini computers, mainframe computers, distributed computing environments including any of the aforementioned systems or apparatus and the like.

-14 The invention can be described in the general context of computer executable instructions, such as program modules executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform particular tasks or implement particular types of abstract information. The invention can also be included in distributed computing environments, where tasks perform remote processing appliances that are linked through a communications network. In a distributed computing environment, program modules may be located on both local and remote computer storage including memory storage devices.

Referring to FIG. 1, an exemplary system for implementing the invention includes a general purpose computing device in the form of a computer 110. Components of computer 110 may include, without limitation, a processing unit 120, system memory 120, and system transmission unit 121 that couples various component systems including the memory system to the processing unit 120. Transmission system 121 can be any of several different types of transmission structures including a memory transmission or memory controller, a path

-15 peripheral transmission and one local using any of the various transmission architectures. By way of example, and without limitation, such architectures include Broadcast Industry Standard Architecture (ISA), Micro Channel Architecture (MCA), Enhanced ISA (EISA), local Video Electronics Standards Association (VESA), Accelerated Graphics Port (AGP), and Peripheral Component Interconnect (PCI) also known as Mezzanine transmission.

Computer 110 typically includes a variety of computer-readable media. Computer-readable media can be any of the available media that can be accessed by computer 110 and includes both volatile and non-volatile media as well as removable and non-removable media. By way of example, and without limitation, computer-readable media may comprise storage and communication media. Storage media includes both volatile and non-volatile, removable and non-removable, implemented with any method or technology for storing information such as computer-readable instructions, data structures, program modules, or other data. Computer storage media includes, without limitation, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROMs, digital versatile disks (DVDs) or other optical storage disks, magnetic cassettes, magnetic tape, storage on

-16magnetic disk or other magnetic storage devices, or any other means that can be used to store the desired information and that can be accessed through a computer 110. Communication media typically encompasses computer-readable instructions, data structures, program modules, or other data in a modulated data signal such as a transmitter waveform or other transport mechanism including any information delivery medium. The term "modulated data signal" means a signal that has one or more of its characteristics set or changed in such a way as to encode information in the signal. By way of example, and without limitation, communication media includes wired media such as a wired network or direct wired connections, and wireless media such as acoustic, RF, infrared, and other wireless media. Combinations of any of the above shall also be included within the scope of computer readable media.

The memory system 130 includes storage media in the form of volatile and non-volatile memory such as read-only memory (ROM) 131 and random access memory (RAM) 132. A basic input/output system (BIOS) 133, which contains the basic routines that help transfer information between elements within a computer 110 during startup, it is typically

-17 stored in ROM 131. RAM 132 typically contains data and/or program modules that are immediately accessible and/or operated by a processing unit 120. By way of example, without limitation, FIG. 1 illustrates the operating system 134, application programs 135, other program modules 136, and program data 137.

Computer 110 may also include other removable or non-removable volatile or non-volatile storage media. By way of example only, FIG. 1 illustrates a hard drive 141 reading from or writing to non-removable, non-volatile magnetic media, a magnetic port 151 reading from or writing to a removable non-volatile magnetic drive 152, and an optical drive port 155 that reads from or writes to a non-volatile, removable optical disk 156 such as a CD ROM or other optical media. Other removable, non-removable, volatile, and nonvolatile electronic storage media that may be used in an exemplary operating environment include, without limitation, magnetic tape cassettes, flash memory cards, digital versatile disks, digital video tape, solid state RAM , solid state ROM, and others like that. The hard disk drive 141 is typically connected to the system transmission line 121 through a non-removable memory interconnect such as interface 140, and the magnetic disk drive 151 and optical disk drive 155 are connected to each other.

-18 typically connected to the system transmission line 121 by a removable memory interconnect, such as an interface 150.

The drives and their associated storage media, listed above and illustrated in FIG. 1, provide storage of computer-readable instructions, data structures, program modules, and other information for computer 110. In FIG. 1, for example hard disk drive 141 is illustrated as operating system storage 144, application programs 145, other program modules 146, and program information 147. Note that these components can either be the same or different from the operating system 134, application programs 135, other program modules 136, and program data 137. To the operating system 144, application programs 145, other program modules 146, and program data 147 have been given herein different numbers to illustrate that they are, at least, different copies. A user can enter commands and information into the computer 110 through input devices such as a tablet 164 (electronic digitizer), microphone 163, keyboard 162, and pointing device 161, commonly referred to as a mouse, trackball, or pad. of touch. Other input devices (not shown) may include a joystick, game pad, satellite disk, scanner, and

-19 others like that. These devices and other input devices are often connected to processor unit 120 via a user input interface 160 that is coupled to the transmission system, but may be connected to other interface and transmission structures such as a port. parallel, game port, or a Universal Serial Bus (USB). A monitor 191 or other type of display device is also connected to the transmission system 121 through an interface as a video interface 190. The monitor 191 may also be integrated by a touch screen panel 193 or the like that can input digitized data such as handwriting into the computing system 110 through an interface, such as a touch screen interface 192. Note that the monitor or touch screen panel may be physically attached to a case in which the computing device 110 is embedded, such as a tablet PC, with the touch screen panel 193 essentially serving as the tablet 164. Additionally, computers such as computing device 110 may also include other output peripheral devices such as speakers 195 and printer 196, which may be connected through an output peripheral interface 194 or the like.

-20 The computer 110 can operate in a network environment using logical connections to one or more remote computers, such as a remote computer 180. The remote computer 180 can be a personal computer, a server, a router, a network PC, a peer device or other common network nodes, and typically includes many or all of the elements described above relating to computer 110, although only one memory storage device 181 is illustrated in FIG 1. The logical connections described in FIG. 1 include a local area network (LAN) 171 and a wide area network (WAN) 173, but may also include other networks. Such network environments are common in offices, corporate networks, intranets, and the Internet.

When used in a LAN environment, computer 110 is connected to LAN 171 via network connections or adapter 170. When used in a WAN environment, computer 110 typically includes a modem 172 or other means for establishing communications over the WAN 173, such as the Internet. Modem 172, which may be internal or external, may be connected to system transmission 121 through a user input interface 160 or other appropriate mechanism. In a network environment, the program modules described relative to computer 100, or portions thereof, may be stored on a remote storage device.

-21memory storage. By way of example, and without limitation, FIG. 1 illustrates remote application programs 185 located in a memory device 181. It will be appreciated that the network connections shown are examples and that other means may be used to establish the communication link between the computers.

GRAPHICS ARCHITECTURE

One aspect of the present invention is generally directed at enabling program coding, such as an application or operating system component, to communicate drawing instructions or other information (eg image bitmap) to graphics components to produce graphics on the system. deployment. To this end, the present invention provides a reference language together with a set of shape elements and other elements, a grouping and composition system, and integration with a general property system in a model object to allow programs to populate a scene. graph with data structures, drawing primitives (commands), and other graph-related information. When rendered, the graphic scene results in graphics that are displayed on the screen.

The FIG. 2 depicts a general, layered architecture 200 in which the present invention can be implemented. As depicted in FIG. 2, you can develop a code

-22of program 202 (eg, a program application or operating system component or the like) to produce graphics data in one or more ways, including through images 204, through vector graphics elements 206, and/or through of function or method calls sent directly to a visual application programming interface (API) layer 212. Direct interaction with the API layer is described in more detail in the above-mentioned pending patent application entitled Visual and Scene Graphics Interface.

In general, imaging 204 provides program code 202 with a mechanism for loading, editing and saving images, eg. bitmaps. These images can be used by other parts of the system, and there is also a way to use the primitive drawing code to draw directly on an image.

In accordance with one aspect of the present invention, vector graphics elements 206 provide another way of drawing graphics, consistent with the rest of the model object (as described below). Vector graphics Elements 206 may be created via a reference language, in which an element or property system 208 and a presenter system 210 process the appropriate calls to the visual layer (API) 212. As described below with reference to the

-23FIG. 26, in general vector graphics elements 206 are parsed into objects of the model object from which a graphics scene is drawn, which can be provided to the graphics scene via an element level through the property/element system 208 and the presenter system 210, or may be provided in a more resource efficient manner, as also described below.

In one implementation, the layered graphics architecture 200 includes a high-level compositing and animation engine 214, which includes or is associated with a data storage structure 216. The data storage structure 216 contains a graphic scene composed of hierarchically organized objects that are managed according to a defined model object, as described below. In general, the visual API layer 212 provides the program code 202 (and presenter system 210) with an interface to the memory fetch structure 216, including the ability to create objects, open and close objects to provide information to them, and so on. onwards. In other words, the high-level compositing and animation engine 214 exposes a unified media API 212 layer by which designers can express intent about graphics and media to display graphic information and provide an underlying platform with sufficient

-24information so that the platform can optimize the use of the equipment for the program code. For example, the underlying platform will be responsible for fetching memory, negotiating resources, and integrating media.

In one implementation, the high-level compositing and animation engine 214 passes an instruction stream and possibly other data (eg, pointing to bitmaps) to a fast, low-level compositing and animation engine 218 . Within this document, the terms high level and low level are similar to those used in other computer programs where in general, the lower a programming component is in relation to larger components, the closer that component is to the hardware. Thus, for example, graphics information sent from a high-level animation and compositing engine 214 may be received in a low-level animation and compositing engine 218, where the information is used to send graphics information to the subsystem. graphic including team 222.

The high-level animation and compositing engine 214 in conjunction with the program code 202 constructs a graphics scene to represent a graphics scene provided by the program code 202. For example, each item to be drawn may be loaded with drawing instructions. drawing that the system can store in the data structure 216 of the graphical scene. How I know

-25Described later, there are numerous ways to specify this data structure 26 , and what is being drawn. Furthermore, the high-level compositing and animation engine 214 integrates timing and animation systems 220 to provide declarative (or other) animation control and timing control. Note that the animation system allows animate values to be passed essentially anywhere in the system, including, for example, at the element level property 208, within the visual layer API 212, and to any of the other resources. The time system is exposed on the element and visual levels.

The low-level compositing and animation engine 218 handles the compositing, animation, and rendering of the scene, which is then provided to the graphics subsystem 222. The low-level engine 218 composes the renderings for the multi-application scenes, and with the rendering components, implements the actual rendering of the graphics on the screen. Note, however, that it may sometimes be necessary and/or advantageous for some of the representations to occur at higher levels. For example, while the lower layers respond to multiple application requests, the higher layers respond on a per-application basis where it is possible via the image mechanisms 204 to perform more delayed or application presentations.

-26specific at higher levels, and pass references to a bitmap at lower levels.

GRAPHIC SCENE MODEL OBJECT

As described below, the presentation model is shared by the highest level, control-based vector graphics elements 206, and the lowest level objects created by the visual API layer 212 used in the data structure 216 of the graphic scene. This provides a significant amount of correlation between the higher level items of the present invention and the lower level objects. The following paragraph describes an implementation of the scene graph model object.

FIGS. 3 and 4 show examples of graphic scenes 300 and 400, respectively, including a base object referred to as a visual. In general, a visual comprises an object that represents a virtual surface to the user and has a visual representation for display. As depicted in FIG. 5, a base class visual provides the base functionality for other visual types, that is, visual class 500 is an abstract base class from which visual types are derived (eg 501-506).

As presented in FIG. 3, a top level (or root) visual 302 is connected to a visual management object 304

-27which also has a relationship (eg via a handle) to a window (HWnd) 306 or similar ad in which graphical information is produced by program code. The VisualManager 304 manages the drawing of the major visual level (and any children of that visual) to that window 306. FIG. 6 shows the VisualManager as one of a set of other objects 620 in the graphics system model object described herein.

To draw, the visual manager 304 processes, (translates or transmits) the graphics scene as programmed by the dispatcher 308, and provides graphics instructions and other information to the low-level component 218 (FIG. 2) so that its corresponding window 306 as generally described in US Patent Application Serial Nos. 10/184,795, 10/184,796, and 10/185,775. Graphics scene processing ordinarily is scheduled by dispatcher 308 at a rate that is relatively slower than the reload rate of lower level component 218 and/or graphics subsystem 222. The FIG. 3 displays a number of hierarchically arranged visual children 310-315 below the top-level (root) visual 302, some of which are represented as having been populated by drawing contexts 316, 317 (appearing as dashed boxes for represent its temporary nature) with associated instruction lists 318 and 319,

-28respectively, containing primitive drawings and other visuals. Visuals can also contain other property information, as the following visual example class shows:

Public abstract class Visual: Visual Component {

public Transform Transform { get; set; } public float Opacity { get; set; } public BlendMode BlendMode { get; set; } public Geometry Clip { get; set; } public bool Show { get; set; } public HitTest Result Hit Test (point point) ; public bool IsDescendant(Visual visual);

public static Point TransformToDescendant ( Visual reference,

Visual descendant,

point point);

public static Point TransferFromDescendant( Visual referent,

Visual descendant,

point point);

public Rect Calculate Bounds(); // Loose bounds public Rect CalculateTight Bounds(); // public bool HitTestable { get; set; } public bool HitTestlgnoreChildren { get; set; } public bool HitTest Final { get; set; }

A transform, set by the transform property, defines the coordinate system for the subgraph of a visual. The coordinate system before the transformation is called the pre-transformation coordinate system, the one after the transformation is called the post-transformation coordinate system, which means that a visual with a transformation is equivalent to a visual with a transform node as parent. The FIG. 7 usually

-29provides an example of transformation, identifying the coordinate system before and after the transformation relative to a visual. To get or set the transform of a visual, the transform property can be used.

Note that coordinate transformations can be applied uniformly to anything, just like a bitmap. Note that this does not mean that transformations are always applied to bitmaps, but that what you get is affected by transformations anyway. As an example, if the user draws a circle with a round pen that is one inch wide and then scales the X direction by two to that circle, the pen will be two inches wide on the left and right and only one inch wide top and bottom. This is sometimes referred to as a bitmap compositing or transformation (rather than a skeleton or geometric scale that affects geography only). The FIG. 8A is a representation of a scaled transformation, with an untransformed image 800 appearing on the left and a non-uniformly scaled transformed image 802 appearing on the right. The FIG. 8B is a representation of a scaled transformation, with the untransformed image 800 appearing on the left and a geometrically scaled transformed image 804 appearing on the right.

-30Regarding the coordinate transformation of a visual, TransfoansformTm(.Udant transforms a point from the reference visual to a downward visual. The point is transformed from the post-transformation coordinate space of the reference visual to the post-transformation coordinate space of the downward sight.

TransformFromDescendant transforms a point from the descending sight to the parent chain of the reference sight. The point is transformed from the post-transformation coordinate space of the descending sight to the post-transformation coordinate space of the reference sight. The CalculateBounds method returns the bounding box of the Visual's content in a post-transformation coordinate space. Note that there may be an alternative version of the API where more specific specifications are allowed as to how the transformation of a visual is interpreted during a coordinate transformation. For example, the transformation in the reference and downward visual may or may not be taken into account. In this alternative there are therefore four options: the coordinates can be transformed from pre-transformation to pre-transformation space, from pre-transformation to post-transformation space, from post-transformation to pre-transformation space, and from post-transformation to post-transformation space. The same concept applies to hit-testing,

-31ej ., hit-testmg can start you in pre-transformation or post-transformation coordinate space, and the results of the hit-test can be pre-transformation or post-transformation coordinate space.

The clipping property sets (and gets) the clipped region of a visual. Any Geometry (the geometry class is described later in Fig. 12) can be used as the cut region, and the cut region is applied in the Post-Transformation coordinate space. In one implementation, an automatic definition of the clipping region is null, eg, no clipping that can be defined as an infinitely large clipping rectangle from --") to (+“, +”).

The Opacity property gets/sets the opacity value of the visual, such that the content of the visual is blended on the drawing surface based on the selected opacity value and blend mode. The BlendMode property can be used to set (or get) the blend mode used. For example, an opacity value (alpha) can be set between 0.0 and 1.0, with a mode set to linear alpha blending set as the mode, eg, Color = alpha + foreground color + (1.0-alpha) + foreground color. background). Other services such as properties of

-32 special effects can be included in a visual, eg, blurry, monochrome, and so on.

The various services (including transform, opacity, clipping) can be pushed or jumped in a drawing context, and push/jump operations can be packaged, as long as a jump call equals a push call. For example PushTransform(...); pushOpacity(...); PopTransform(,,,); is illegal, because before the PopTransform call, PopOpacity needs to be called.

The PushTransform method pushes a (unreadable) transform. The PopTransform triggers the transform pushed by the equal PushTransform call:

void PushTransform(Transform transform);

void PushTransform(Matrix matrix);

void PopTransform(); .

Similarly the PushOpacity method pushes an opacity value. Subsequent drawing operations are obtained on a temporary surface with the specified opacity value and then composited within the scene. PopOpacity triggers the opacity pushed by the equals call to PushOpacity:

void PushOpacity(float opacity);

void PushOpacity(NumberAnimationBase opacity), void PopOpacity();

The PushClip method pushes a clip geometry.

Subsequent drawing operations are subject to geometry. Clipping is applied in the post space

-33transformation. PopClip jumps to the clipping region pushed by an equal Push Clip call:

void PushClip(GeometryClip);

void PopClip();

Note that push operations can be arbitrarily packed as long as jump operations equal push operations. For example, the following is valid:

PushTransformf. . .);

DrawLine(. . .) ;

PushClip(. . .);

DrawLine(. . .) ;

PopClip();

PushTransform(. . .) ;

DrawRect(. . .) ;

PopTransform();

PopTransform() ;

Hit-testing is performed on the post-transformation coordinate space, and returns an identity of each hit-testable visual that is flagged, eg, when it detects a feather or mouse click. An alternate version of the pipeline may allow hit-testing to start in the pre-transformation coordinate space relative to the visual where hit-testing has started. The visuals that are flagged are returned in order from right to left, with the deepest first. Hit checking can be controlled with several flags, including hit-testable, which determines if the visual is hit-testable (automatic is true), and HitTestFinal, which determines if the visual is hit-testable.

-34hit checking stops when the visual is pointed, if a Visual is pointed and the visual's HitTestFinal property is true, the hit checking is addressed and returns the results collected up to this point (automatic is false). Another flag is HitTestlgnoreChildren, which determines if the children of a visual should be considered when performing a hit check on a visual (automatic is false).

A ProxyVisual is a visual that can be added more than once in the rendering scene. Since any visual referenced by a ProxyVisual can be reached by different paths from the root, the read services (TransformToDescendent, TransformFromDescendent, and HitTest) do not work through a ProxyVisual. In essence, there is a statutory path from any visual to the root of the visual tree and that path is not (illegible).

As depicted in FIG. 5, several types of visuals are defined in the model object, including ContainerVisuals 501, DrawingVisuales 502, ValidationVisuals 503, SurfaceVisuales 504 and HwndVisuales 505. The table below sets out example methods of a DrawingVisual:

-35public class DrawingVisual : Visual {

public DrawingVisual();

public IDrawingContext Open(); public IDrawingContext Append();

}

A DrawingVisual is a container for graphical content (lines, text, images, and more). Note that it is possible to add a Visual to a DrawingVisual, but in some implementations this is not allowed. The DrawingVisual 502 includes an Open method, which returns an IDrawingContext that can be used to populate the DrawingVisual, eg, with other visuals and drawing primitives, as described below. In one implementation, for various reasons also described below, a DrawingVisual can only be opened once to populate its drawing context; in other words, such a DrawingVisual is immutable. After a DrawingVisual has been populated, the DrawingVisual is closed using a Close method, eg, on the drawing context. Note that a call to Open can delete any content (children) of a visual, however in an alternative implementation, an Add method is provided to open a current visual so that it is added to that visual. In other words, an OpenToAdd call works like an Open, except that the current content of the DrawingVisual is not cleared on open.

-36The following is an example of how a drawing content is used to populate a visual:

ContainerVisual cvl = new ContainerVisual(); DrawingVisual dvl - new DrawingVisual();

// Open a drawing context. The context // will automatically close when // the used block is exited. This will also // replace any content that might be // already in dvl. using (IDrawingContext of = dvl.Open()) {

dc.DrawLine (new Pen(Brushes.Blue), new Point (. .

.), newPoint(. . .));

} //Add dvl to the children collection of cvl cvl.Children.Add(dvl);

//Add another arbitrary visual to cvl cvl.Children.Add(SomeOtherVisual);

//Create another DrawingVisual

DrawingVisual dv2 = new DrawingVisual();

Using (IDrawingContext de = dv2.0pen()) //This sets a new coordinate system //where everything is twice as large dv.PushTransform(newScale(2.0, 2.0==;

//This line is drawn in a new //scale coordinate system dc.DrawLine (new Pen(Brushes.Red), new Point (. . new Point (. . .)) ;

//This reverts to the original coordinate system, dv.PopTransform();

dc.DrawLine (new Pen(Brushes.Green), new Point (. . .), new Point (. . .)) ;

//Add dv2 to the children collection of cvl; cvl.Children.Add(dv2);

In general, a ValidationVisual 503 is conceptually similar to a DrawingVisual, except that a ValidationVisual

-37is populated when the system requests it to be populated, rather than when the program code wants to populate it. For example, as described in US Serial No. 10/185, 775, the high-level compositing and animation engine 214 (FIG. 2) can invalidate graphical scene information as resources are needed, such as when part of a graphic scene is not visible. For example if some parts are rolled out of view, clipped, and so on. If the invalidated data of the graphic scene is needed later, the called program code 202 will be called again to redraw (validate) the invalidated portion of the graphic scene. To this end, a typical usage scenario is for program code to subclass the ValidationVisual and override the OnValidate method. When the system calls the OnValidate method, a drawing context is passed, and the program uses the drawing context to repopulate the ValidationVisual.

The following example shows a way to implement a simple ValidationVisual, which for example draws a line with a certain color. The color of the line can be changed by calling SetColor. To force the ValidationVisual to update, SetColor calls Override to force the graphics subsystem to revalidate the ValidationVisual:

-38Public class MyValidationVisual : ValidationVisual {

public override void OnValidate(IDrawingContext de) { dc.DrawLine(m_color, ...) ;

} public void SetColor(Color newColor) {

m_color = color;

invalidate(); // Forces a redraw of the // ValidationVisual to reflect // the color change.

} private Color m_color

This example shows how to use the ValidationVisual: MyValidationVisual myW 0 new MyValidationVisual(); Container . Children. Add(myW) ;

myW.SetColor(newColor(...));

FIG. 4 shows an example rendering scene 400 in which ContainerVisual and DrawingVisuals are related in a rendering scene, and have associated information in the form of drawing primitives, (in corresponding drawing contexts). The ContainerVisual is a container for Visuals, and ContainerVisual can be packaged inside each other. The children of a ContainerVisual can be manipulated with a VisualCollection that returned a Children property of the ContainerVisual. The order of the Visuals in the VisualCollection determines in what order the

-39Visuals are produced, eg . Visuals are drawn from lowest to highest index from back to front (paint order). For example, with the appropriate parameters where the visual that draws a tree renders red, green, and blue rectangles hierarchically under a visual container, the following code would result in three rectangles drawn (translating to the right and down), one red rectangle behind , a green rectangle in the middle and a blue rectangle in front:

VisualCollection ve -m cv.Children;

ve.Add(new DrawingVisual());

vc.Add(new DrawingVisual());

fpr (int i 0 0; i < vc.Count; i++) {

DrawingVisual v = (DrawingVisual) (ve[i]);

If (v ¡ 0 null) {

v.Transform 0 Transform.CreateTanslation(i * 20.Of, i*20f);

IDrawingContext de = v.0pen();

de.DrawRectangie( new Brush (colors [i]), null, newPoint2D (0, 0), newPoint2D(100.Of, 100.0f)),

v.Close(of);

} )

As depicted in FIG. 5 , another type of visual is a SurfaceVisual 504. In general, as depicted in FIG. 3, a SurfaceVisual object 315 references a surface memory (bitmap) 322 to which

-40the program code 202 (FIG. 2) can access. The client program code 202 may provide its own surface memory, or it may request that the memory be allocated by the surface object.

Program code 202 has the option of opening a

SurfaceVisual and obtain a drawing context 323, within which the program code 202 can write data in pixels 324 or the like and directly place those pixels on the surface. This is depicted in FIG. 3 by the dashed lines between the surface object 323 (shown as a broken box to represent its temporary nature) and the pixel information 324.

Program code 202 also has an option to create a surface visual manager 330 and a visual subgraphic 322 associated with the SurfaceVisual 315. This option is depicted in FIG. 3 along the dashed line between surface object 322 and surface visual manager 330. Note that visual subgraph 332 may also contain other surface visuals, as also shown in FIG. 3. The visual surface manager 330 (also shown as a type of other object in the set 620 of FIG. 6 ) walks the visual subgraph 332 to update the bitmat

322 of the Surface Visual. Furthermore, note that this translation is organized by dispatcher 308, and for efficiency

-41 can be checked to control how often this 322 bitmap is updated. The surface visual manager 330 does not have to translate the sub-graphic visual 322 each time at the same rate that the top level visual manager 302 carries the rest of the graphic scene.

With respect to surfaces, as described below with reference to FIGS. 9A-9C in general the present graphical model thus allows compositing a set of surface visuals, an immediate way to produce vector and bitmap primitives within a surface, compositing a surface on the desktop or another surface, and control which surface in a list of surfaces is used to compose on it or draw on it. A surface list is defined as a collection of one or more surfaces (eg frames/separators) or physical memory (system or video) used to store visual compositions or graphic drawings, or both. One of the surfaces in the surface list can be set as the current back gap where drawings and/or compositions are made, and one of the surfaces in the surface list can be set as the current primary, or front gap, used to compose on another blank obtained.

The surfaces can be used in a myriad of ways. By way of example, FIG. 9A shows the

-42composition on a surface. In FIG. 9A, a surface visual manager 900 connects a surface list 902 as a production target to a visual tree 904. During each compositing cycle, visuals are composited onto the surface from the surface list that is currently serving as the surface list. active surface list support. The surface being composited may be a client-owned/high-level compositing engine 214 surface (FIG. 2) for in-process compositing scenarios, a surface owned by a low-level compositing engine 218 for scenarios, where the client does not need the bits but where the low-level compositing engine needs them to composit the surface onto another target produced, or a cross-process surface, for scenarios where the client needs access to the surface bits and where the low-level compositing engine 218 also needs the surface for other compositing work.

The composition is controlled by a time service that is attached to the Visual Manager. An example of the time service is a manual mode that could be used in the following example:

-43:r // create a manual time service and attach a visual manager

TimingService timingService = new

ManualTimingService(visualManager);

//compose the visual tree into the current support buffer of the surface visualManager.Render();

foreach (Tick tick in timingService) {

//advance the support buffer to the next frame on the surface surfaceList.NextFrame();

//advance the time of the visual tree timingService.Tick(tick);

//compose the visual tree into the current buffer support surface visualManager.Render();

}

Another way to use a surface is with the immediate get mode on a surface, through a context. Attaching a surface list to a visual (a surface visual) allows you to immediately output to the surface the surface list that is currently serving as the active support buffer for the surface list. This production is done by obtaining a drawing context from the surface visual and executing a drawing command in that context, as described below. Note that getting a drawing context locks the surface so that no other compositing operations can be done on it. Each draw command is executed immediately, and vectors and other surfaces can be

-44be drawn (mixed) on the surface. However, other visuals cannot be drawn on the surface, but can be composited on the surface by associating them with a visual manager, as previously described (eg in FIG. 9A).

//attach a surface list to a visual SurfaceVisual surface Visual = new SurfaceVisual(surfaceList);

//allow production in immediate mode to the surface of) support buffer (and block)

BaseDrawingContext of = SurfaceVisual.Open();

//draw a line (immediately) at the current support cushion of the surface dc.DrawLine(pen, startPoint, endPoint);

//unlock the surface - we're done with fetching in immediate mode surfaceVisual.Close(de);

Another use for surfaces is when compositing a surface over another achieved target. To this end, once a surface list is attached to a surface visual, the surface can then be attached as a node in a visual tree, and the surface from the surface list that is currently serving as the primary buffer or front can be superimposed on another surface or on the desktop. This is illustrated in FIG. 9B and in the example below:

//attach a surface list to a visual SurfaceVisual surface Visual = new SurfaceVisual(surfaceList);

//Add SurfaceVisual to a visual tree to composite //on top of another fetched target rootVisual.Add(surfaceVisual);

-45The live composition to and from a surface is represented in FIG. 9C, where the capabilities described above are combined such that composing to the rear buffer surface of a list surface and composing from the front buffer surface of a list surface (eg to the desktop) occur simultaneously. Note that to eliminate the undesirable effect of video known as tearing, the surface list should have at least two surfaces, a front surface and a back buffer. A surface used as in FIG: 9C is probably proprietary to a low-level engine 218, or is a cross-processed surface to make the composition in the low-level engine 218 work better.

Surfaces are built as independent objects, as detailed in the following builder examples:

public class surface -46 {

// create and assign a blank surface with no initial information public Surface (int width, int height, int dpi,

pixelFormat pixelFormat,

SurfaceFlags flags) //create a surface using the provided memory public Surface(int width, int height, int dpi,

pixelFormat pixelFormat,

IntPrt pixels, // memory managed for Surface Intstrice) // create from source (eg Clone) public Surface (Surface sourceSurface,

SurfaceFlags flags) //create from File or ULR public Surface(String filename,

SurfaceFlags flags) //create from Stream public Surface(System.IO.Stream stream;

surfaceFalgs flags) //Create from HBITMAP (which cannot be selected in an HDC)

public class SurfaceList //Create a list of blank surfaces (without initial information).

Public SurfaceList(int width, int height, int dpi,

pixelFormat pixelFormat,

Int numSurfaces,

SurfaceFlags flags) //create a SurfaceList using the specified surfaces //All surfaces must have identical properties (w, h, dpi, etc.).

-47public SurfaceList(Surface [] surfaces) //flip front buffer with rear buffer first in line public Flip() //flip rear buffer to the next surface public Next() public int FrontBufferlndex { get; set} public int BackBufferIndex {get; set} public Surface GetFrontBuffer() public Surface GetBackBuffer() public Surface GetSurface(int surfacelndex)

Once constructed, a surface and/or a list of surfaces can be attached to a surface visual or manager visual.

//Create a visual surface public SurfaceDrawingVisual (Surface surface) public SurfaceDrawingVisual (SurfaceList surfaceList) //Create a visual manager with a target surface obtained public VisualManager (Surface surface) public VisualManager (SurfaceList surfaceList)

Furthermore, a surface can obtain information from a decoder, and/or send its information to an encoder for writing to a specific file format. Surfaces can also receive/send information to and from effect interconnects. A surface can be constructed for any pixel format from the full set of format types supported by the surface. However, some settings may be

-48made to the specified pixel format, eg. if the specified pixel format is less than 32 bits per pixel, then the format will be promoted to 32 bits per pixel. When bits are required from a surface in the original format, the surface will be copied to a buffer of the required pixel format using a format conversion filter.

Returning to FIG. 5, yet another visual is a HwndVisual 505, which positions a Win32 child HWnd in the graphics scene. More particularly, legacy programs will continue to operate via the WM_PAINT (or similar) method which draws a child HWnd (or similar) based on previous graphics technology. To support such programs in the new model of graphics processing, the HwndVisual allows the Hwnd to be contained in a graphics scene and translated as a parent visual is repositioned, as shown in FIG. 10A. As a result of the limitations of the existing Hwnds, however, when you get a child Hwnd it can only sit on top of other windows, and cannot be rotated or scaled like the other visuals described above. Some clipping is possible, as depicted in FIG. 10B, where the dashed lines indicate the displayed rectangle of HWnd being clipped during relative movement with respect to its parent visual.

-49Other types of visuals 506 are also feasible, and the present model object is extensible to allow others to be developed. For example, as depicted in FIG. 11, a layered visual 1100 allows an application designer to separately control information in a visual across multiple information streams, providing a finer granulation of control relative to visuals having a single information stream.

Note that similar control granulation can be obtained by having eg . three separate child visuals under a single parent visual, however this requires program code to work with multiple visuals, which is more complicated than working with a single layered visual having multiple layer indices.

By way of example, in FIG. 11, background information, content information and border information are contained in a single layered visual, but are separated from each other as indices by a layer value, eg. 0, 1, or 2, respectively. Layers can be inserted, even pasted to either side, and/or deleted, with the order of the layers (eg from left to right as shown) defining an implicit Z-order of exposure. Note that for security, child content and other information in a layered visual cannot be enumerated.

-50Other types of visuals include container visuals, and redirected child HWnd visuals, in which the content is drawn on a bitmap, and embedded in a visual surface. Three-dimensional visuals allow a connection between two-dimensional and three-dimensional worlds, eg. A camera-like vision is possible through a two-dimensional visual that looks into a three-dimensional world.

Many resource objects are immutable once created, which means that once they are created they cannot be changed for various reasons, including continuation simplification issues, to prevent corruption by other people, and to simplify their interaction. with elements and APIs. Note that this generally simplifies the system. It should be noted, however, that it is feasible to have a system where such objects are mutable, but for example would require handling a dependency graph. For example, while it is possible to have a system where such objects are mutable, if program code changes the binding set in a Visual, the visual would need to be produced again, thus requiring a notification/logging mechanism, e.g. eg, if a new setting is assigned to a visual, the visual registers itself with the setting in notifications (eg a setting change notification). Therefore, in one implementation, to

For the sake of simplification, resource objects are immutable.

These resource objects can be defined with a constructor, which is a direct and generic way of creating an object, or by using a companion building object, as described later. For example, to create a SolidColorBrush, (brush objects are described below), a constructor can be used: Brush MyBrush = new SolidColorBrush(Colors.Red);

The user can also use the static members of the brushes class to get a set of predefined colors.

Since immutable objects cannot be changed, to effectively change an object, the user needs to create a new object and replace the old one with it. To this end, many of the system resource objects can use the construction pattern, in which immutable objects are created with a constructor class, which is a mutable companion class. The user creates an immutable object that reflects the parameters set in the constructor, creates a new constructor for that object, and initializes it from the immutable object. The user then changes the constructor as needed. Once done, the user can construct a new object, changing the constructor and reusing it to create another immutable object. Note that it is desirable to have

-52immutable objects with set properties, and that immutable objects cannot be changed, but can only be replaced by triggering a property change event.

Therefore, instead of using a constructor to create a SolidColorBrush as described above, a SolidColorBrushBuilder can be used:

SolidColorBrushBuilder MyBuilder = new

SolidColorBrushBuilder();

MyBuilder.Color = Colors.Red;

Brush MyBrush = MyBruilder.ToBrush();

Most objects that take static values can also take animation objects. For example, in the DrawingContext there is an overlap on DrawCircle that takes a PointAnimationBase for the center of the circle. In this way, the user can specify rich animation information at the primitive level. For resource objects there is an animation collection in addition to the base value. These are composed in such a way that if the user wanted to animate the example above, they could specify the following example line before building the brush:

MyBuilder .colorAnimation.Add(new ColorAnimation(...) ) ;

Note that an object with animation parameters is still immutable, because its animation parameters are static. However, when the scene graph is rendered (translated), the meaning of the animation parameters changes over time, giving the appearance of animated, not static, information.

-53As described above, you can draw visuals by populating their drawing contexts with various drawing primitives, including geometry, ImageData, and VideoData. Furthermore, there is a set of resources and classes that are shared by the entire party. This includes Feathers, Brushes, Geometry, Transform, and Effects. The IDrawingContext exposes a set of drawing operations that can be used to populate a DrawingVisual, ValidationVisual. IsurfaceDrwaingContext, a base pipeline to the Idrawing context, can be used to populate a SurfaceVisual. In other words, the drawing context exposes a set of drawing operations; For each draw operation there are two methods, one that takes constants as arguments, and one that takes animators as arguments.

The DrawLine method draws a line with a specified pen from the start point to the end point. Public void DrawLine(Pen pen, Point Star, Point end);

Public void DrawLine(

pen pen,

PointAnimationBase start, PointAnimationBase end);

The DrawRoundedRectanble method draws a rounded rectangle with the specified brush and pen; brush and pen can be null.

-54Public void DrawRoundedRectangle (

Brush, brush,

pen, pen

Pin topLeft,

Size size,

fleet radious);

Public void DrawRoundedRectangle (

Brush, brush,

pen pen,

PointAnimationBase topLeft, SizeAnimationBase size, NumberAnimationBase radius); public void DrawRoundedRectangble (

Brush brush,

pen pen,

Point topLeft,

Point bottomRight, float rx, float ry);

public void DrawRoundedRectangle (

Brush brush,

pen pen,

PointAnimationBase topLeft,

PointAnimationBAse bottomRight, NumberAnimationBase radiusX, NumberAnimationBase radiusY);

The DrawGeometry method draws a path with the specified brush and pen; brush and pen can be null.

Public void DrfawGeometry ( Brush, brush,

Pen pen, Geometry geometry);

The DrawRectanble method draws a rectangle with the specified brush and pen; brush and pen can be null.

-55Public void DrawRectangle(

Brush brush, Pen pen, Point top Left, Size size);

Public void DrawRectangble ( Brush brush, Pen pen,

PointAnimationBase TopLeft, SizeAnimationBase size);

The DrawSurface method draws a surface.

Public void DrawSurface(

Surface surface, Point topLeft, Size size, Float opacity);

Public void DrawSurface( Surface image, PointAnimationBase topLeft, SizeAnimationBase size, NumberAnimationBase opacity);

Geometry is a type of class (FIG. 12) that defines a vector graphics skeleton, without features or fill. Each geometry object is a simple shape (LineGeometry, EllipseGeometry, RectangularGeometry), a single complex image (PathGeometry), or a list of such GeometryList shapes with a specified combined operation (eg union, intersection, and so on). These objects form a hierarchy class that is depicted in FIG. 12.

As depicted in FIG. 13, the PathGeometry is a collection of Figure objects. Instead, each of the Shape objects is composed of one or more Segment objects.

-56that actually define the shape of the figure. A Figure is a subsection of a Geometry that defines a collection of segments. This collection of segments is a single connected series of two-dimensional segment objects. The Figure can be either a closed figure with a defined area, or simply a connected series of Segments that define a curve, but no included area.

The fill area of a PathGeouiuetry is defined by taking the contained Figures that have a true fill property, and applying a FillMode to determine the enclosed area. Note that the FillMode enumeration specifies how the areas of intersection of the Figure objects contained in a Geometry will be combined to form the resulting area of the Geometry. An Alternative rule determines whether a point is inside the canvas by conceptually drawing a ray from that point to infinity in any direction, and then examining the places where a segment of the figure crosses the ray. Starting with a count of zero and adding one each time a Segment crosses the ray from left to right and subtracting one each time a route segment crosses the ray from right to left, after counting the crossings, if the result is zero then the point is off the trail. Otherwise, it's in. A winding ruler determines if a point on the canvas is inside, and works conceptually by drawing a ray

-57from that point to infinity in any direction and counting the number of path segments from the given way the ray crosses. If this number is odd, the point is in, if it is even, the point is out.

As FIG. 14 depicts, when drawing geometry (eg, a rectangle), a brush or pen can be specified, as described below. Furthermore, the pen object also has a brush object. A brush object defines how to graphically fill a plane, and there is a class hierarchy of brush objects. This is represented in FIG. 14 by the filled rectangle 1402 that results when the visual including the rectangle and brush instructions and parameters are processed.

As described below, some types of Brushes (such as gradients and nine grids) measure themselves. When used, the size of these brushes is obtained from the bounding box, ie, when the GradientUnits/DestinationUnits for the Brush is set to ObjectBoundingBox, the bounding box of the primitive being drawn is used. If those properties are set to UserSpaceOnUse, then the coordinate space is used.

A Pen object snaps to a Brush along with the Width, LineJoin, LineCap, MiterLimit, DashArray, and DashOffset properties, as the following example represents:

-5810 public enum system.Windows.Media.PenLineCap {

Butt, Round, Square }

public enum System.Windows.MediaPenLineJoin {

Miter, Round, Bevel }

public class System.Windows.Media.Pen {

//Constructors public Pen(Color color, fleet width);

public Pen(Brush brush, fleet width);

//Properties public float [] DashArray { get; ) public float DshOffset { get; } public FloatAnimationCollection DashOffsetAnimations { get; } public PenLineCap LineCap { get; } public PenLineJin LineJoin { get; } public float MiterLimit { get; } public FloatAnimationCollection MiterLimitAnimations { get; } public float Opacity { get; } public FloatAnimationCollectionOpacityAnimations { get; } public Brush Bruish { get; } public float Width { get; ) public FloatAnimationCollection WidthAnimations { get;} } public sealed class System.Windows.MediaPenBujilder : Builder {

// Fields //Constructors public PenBuilder();

public PenBuilder(Color color);

public PenBuilder(Brush brush);

-59public PenBuilder(Penpen);

//Properties public float [] DashArray { get; set; } public float DAshOffset { get; set; } public FloatAnimationCollectionBuilder

DashOffsetAdnimations { get; } public PenLineCap LineCap { get; set; } public PenLineJoin Line Join { get; set; } public float MiterLimit { get; set; } public FloatAnimationCollectionBuilder MiterLimitAnimations { get; } public float Opacity { get; set; } public FloatAnimationCollectionBuilderOpacityAnimations { get; } public Brush Brush { get; set; ) public float Width { get; set; } public FloatAnimationCollectionBuilder WidthAnimations { get; } // Methods public Pen ToPen();

}

As mentioned above, the graphics model object of the present invention includes a Brush model object, which is generally directed towards the concept of covering a plane with pixels. Examples of brush types are represented in the hierarchy of FIG. 15 and, under a base class of Brush, includes SolidColorBrush, GradientBrush, ImaGrush, VisualBrush (which can reference Visual), and NineGridBrush. GradientBrush includes LinearGradient and RadialGradient objects. As described above, Brush objects are immutable.

-60Public abstract class System.Windows.Media.Brush {

float Opacity { get; }

FloatAnimationCollection OpacityAnimations { get; }

The following sets an example of the Brush class

Builders:

Public abstract class System.Window.Media.BrushBuilder : Builder {

public virtual BrushToBrush();

public override sealed object Createlnstance();

{ returnToBrush();

} float Opacity { get; set; }

FloatAnimationCollectionBuilder OpacityAnimations { get; } }

Note that Brush objects can recognize how they relate to the coordinate system when they are used and/or how they relate to the bounding box of the shape on which they are being used. In general, information such as size can be inferred from the object on which the brush is drawn. More particularly, many of the brush types use a coordinate system to specify some of their parameters. This coordinate system can either be defined as relative to the simple bounding box of the shape to which the brush is applied, or it can be relative to the coordinate space that is active at the time the brush is used. These are known

-61respectively, as ObjectBoundingBox mode and

UserSpaceOnUse.

Public enum System.Windows.MediaBrushMappingMode {

Obj ec tBoundingBox,

UserSpaceOnUse, }

A SolidColorBrush object fills the identified plane with a solid color. If there is an alpha component to the color, it is combined in a multiplicative manner with the corresponding opacity attribute in the Brush base class. The following example sets a SolidColorBrush object:

Public sealed classSystem.Windows.Media.SolidColorBrush :

Brush {

// Constructors public SolidColorBrush(); // initialize to black public SolidColorBrush(Color color);

public SolidColorBrush(System.Windows.Media.Animation.ColorComposer colorComposer);

// Properties public Color Color { get; } public IEnumerator ColorAnimations { get; } }

public class System.Windows.Media.SolidColorBrushBuilder : BrushBuilder {

// Builders public SolidColorBrushBuilder();

public SolidColorBrushBuilder(Color color);

public SolidColorBrushBuilder(SolidColorBrush scp);

// Properties public Color Color { get; set; } publicAnimationList ColorAnimations { get; }

-62// Methods public virtual Brush ToBrush();

GadientBrush objects, or simply gradients, provide a gradient fill, and are drawn by specifying a set of gradient stops, which specify the colors along some sort of progression. The gradient is drawn by performing linear interpolations between the gradient stops in a 2.2 RGB gamut of color space; interpolations across other gamuts of other color spaces (HSB, CMYK, and the like) are also feasible. Two types of gradient objects include linear and radial gradients.

In general, gradients are made up of a list of gradient stops. Each of these gradient stops contains a color (with its alpha value included) and an offset. If there are no specified stops of gradient, the brush is drawn in transparent solid black, as if no brush had been specified at all. If there is only one specified stop of gradient, the brush is drawn with a solid color of the single color specified. As in other resource classes, the gradient stop class (example in the table below) is immutable.

-63Public class System.Windows.Media.GradientStop {

public GradientStop(Color color, Float offset);

public Color Color { get; } public AnimationEnumerator ColorAnimations { get; } public float fOCET { get; } public AnimationEnumerator OffsetAnimations { get; } } public class System.Windows.MediaGradientStopBuilder : Builder {

public GradientStopBuilder();

public GradientStopBuilder(Color color, float offset);

public Color Color ( get; set; } public AnimationList ColorAnimations { get; } public float FOCET { get; set; } public AnimationList OffsetAnimations { get; } public GradientStop ToGradientStop ();

}

There is also a collection class, as stated by the

Following example:

Public class System.Windows.MediaGradientStopCollection : ICollection {

public GradientStopCollection(); // empty list public GradientStopCollection (GradientStop [] GradientStops);

public GradientStopCollection(ICollection c) ;

// IEnumerable public IEnumerator GetEnumerator();

// ICollection public voic CopyTo (Array array, int Index);

public bool ICollection.IsSynchronized { ge { return false; } } public intCount { get; }

Public object ICollection.SyncRoog { get; } // Extra functions public GradientStop this [int index] { get; } public bool Contains(GradientStop value);

public int IndexOf(GradientStop value); // return first one public int IndexOf(GradientStop value, int startIndex);

-64public int IndexOf(GradientStop value, int startIndex, int count);

public int LstlndexOf(GradientStop value);

public int LastIndexOf(GradientStop value, int StarIndex);

public int LastIndexOf(GradientStop value, int startIndex, int count);

public GradientStopCollection GetRange(int Index, int count);

} public class

System.Windows.Media.GradientStopCollectionBuilder : Builder, IList (

public GradientStopCollectionBuilder();

public GradientStopCollectionBuilder(GradientStop [] GradientStops);

public GradientStopCollectionBuilder(ICollection c); public GradientStopCollectionBuilder(GradientStopCollection GradientStops);

// IEnumerable public IEnumerator GetEnumerator();

// ICollection public void CopyTo(Array array, int index);

public bool ICollection.IsSynchronized { get { return false; } } public int Count { get; ) public object ICollection.SyncRoot { get; } // public IList bool IsFixedSize { get { return false; } } public bol IsReadOnly { get { return false; } } public object Ilist.this [int index] {get; set] public int IList.Add(object value);

public void Clear();

public bool IList.Contains(object value);

public int IList.IndexOf(object value); // returns first one public void IList.Insert(int index, object value); public void IList.Remove(object value); // removes first one.

Public void RemoveAt(intIndex);

// Extra functions public GradientStop this [int Index] { get; set } public Int Add(GradientStop value);

public bool Contains(GradientStop value);

-65public int IndexOf(GradientStop value); // returns first one public int IndexOf(GradientStop value, int startIndex);

public int IndexOf(GradientStop value, int startIndex, int count);

public int LastIndexOf(GradientStop value);

public int LastIndexOf(GradientStop value, int startIndex);

public int LastIndexOf(Gradient Stop value, int startIndexz, int count);

public void Insert(int index, GradientStop value);

public void Remove(GradientStop value); // removes first one public void AddRange(ICollection c);

public void InsertRange(int Index, ICollection c);

public void RemoveRange(int Index, int count);

public void SetRange(int Index, ICollection c);

public Gradient StopCollectionBuilder GetRange(int index, int count);

// Capacity is a key. It will throw an exception if it is set to less than count.

Public int Capacity { get; set; ) // Builder overloads public override object Build();

public override void ResetBuilder();

public override void SetBuilder(Object example);

public GradientStopCollection ToGradientStopCollection

EITHER;

}

As represented in the box below, the GradientSpreadMethod method specifies how the gradient should be drawn outside of the specified vector or space. There are three values, including hash, in which the border colors (first and last) are used to fill the remaining space, to reflect, in which the stops are displayed in reverse order repeatedly to fill the space, and to repeat , where the

-66stops are repeated in order until the space is filled:

Public enum System.Windows.Media.GradientSpreadMethod {

Pad,

reflect,

repeat

J

The FIG. 16 shows examples of the GradientSpreadMethod method. Each shape has a linear gradient that goes from white to gray. The solid line represents the gradient vector.

The LinearGradient brush specifies a linear gradient along a vector. The individual stops specify colored stops along that vector. An example is shown in the following table:

Public class System.Windows.Media.LinearGradient : GradientBrush {

// Sets up a gradient with two colors and a specified //gradient vector to fill the //object to which the gradient is applied.

// This implies the ObjectBoundingBox for the //GradientUnits property public LinearGradient(Color colori, Color color2, float angle);

public BrushMappingMode GradientUnits { get; } public Transform GradientTransform { get; } public GradientSpreadMethod SpreadMethod { get } // Gradient Vector public Point VectorStart { get } public PointAnimationCollection VectorStartAnimations { get } public Point VectorEnd { get } public PointAnimationCollection VectorEndAnimations { get }

-67// GradientStops public GradientStopCollection GradientStops { get } }

public class System.Window.Media.LinearGradientBuilder: GradientBrushBuilder {

public LinearGradientBuilder();

public LinearGradientBuilder(Color colori, Color color2, float angle);

public LinearGradientBuilder(LinearGradient lg) ;

// GradientUnits: Default is ObjectBoundingBox public BrushMappingMode GradientUnits { get; set; } // GradientTransform: Default is identity public Transform GradientTransform { get; set; } // SpreadMethod: Default is Pad public GradientSpreadMethod SpreadMethod { get; set; } // Gradient Vector // Default vector is (0,0) - (1,0) public Point VectorStart { get; set; ) public pointAnimationCollectionBuilder VectorStartAnimations { get; set; } public Point VectorEnd { get; set; } public PointAnimationCollectionBuilder VectorEndAnimations { get; set; } // Gradient Stops public void AddStop(Color color, float offset);

public GradientStopCollectionBuilder GradientStops { get; set; } {

}

The RadialGradient is similar in programming model to the linear gradient. However, while the linear gradient has a start and end point to define the gradient vector, the radial gradient has a circle along with a focal point to define the behavior of the gradient. The circle defines the end point of the gradient, that is, a gradient stop of 1.0 defines the color in the circle. Point

-68focal defines the center of the gradient. A gradient stop at 0.0 defines the color at the focal point.

FIG: 17 shows a radial gradient from white to gray. The outer circle represents the gradient circle while the dot marks the focal point. This gradient example has the SpreadMethod placed on Pad:

Public class System.Windows.Media.RadialGradient : GradientBrush {

// sets a gradient with two colors.

// This implies an ObjectBoundingBox for the property // GradientUnits along with a center at (.5, 0.5) // a radius of 0.5 and a focal point at (0.5, 0.5) public RadialGradient(Color colori, Color color2);

public BrushMappingMode GradientUnits { get } public Transform GradientTransform { get ) public GradientSpreadMethod SpreadMethod { get } // Gradient definition public Point CircleCenter { get ) public PointAnimationCollection CircleCenterAnimations ( get ) public float CircleRadious { get } public FloatAnimationCollection Circles public Focus { get } public PointAnimationCollection FocusAnimations { get } // Gradient stops public GradientStopCollection GradientStops { get ) )

public class System.Windows.Media.RadialGradientBuilder :

GradientBrushBuilder {

public RadialGradientBuilder();

public RadialGradient(Color colori, Color color2=; public RadialGradientBuilder(RadialGradient rg) ;

// GradientUnits: Default is ObjectBoundingBopx public BrushMappingMode GradientUnits { get; set; } // GradientTransform: Default is identity public Transform GradientTransform { get; set; ) // SpreadMethod: Default is Pad

-69public GradientSpreadMethod Spread Method { get; set; } // Gradient definition public Point CircleCenter { get; set }//Default: (0.5, 0.5) public PointAnimationCollectionBuilder CircleCenterAnimations { get; set; } public float CircleRadius { get; set; )// Default: 0.5 public FloatAnimationCollectionBuilder FocusAnimation { get; set; } public Point Focus { get; set; } Default : (0.5, 0.5) public PointanimationCollectionBuilder FocusAnimations { get; set; } // Gradient Stops public void AddStop(Color color, float offset);

public GradientStopCollectionBuilder GradientStops { get; set; }

Another brush object depicted in FIG. 15 is a VisualBrush object. Conceptually, the VisualBrush provides a method for drawing a visual repeatedly, with a tile-like fill. Visual Paint objects also provide a mechanism for language references to work directly with the API layer at the resource level, as described later. An example of such a filler is depicted in FIG. 14 with the visual brush referencing a visual (and any child visual) that specifies a single circular shape 1420, where that circular shape fills a rectangle 1422. Thus, the VisualBrush object can reference a visual to define how to draw that brush, the one that introduces a kind of multiple use of visuals. In this way, a program can use an arbitrary metafile of graphics to fill

-70an area through a brush or pen. Since this is a compressed way to store and use arbitrary graphics, it serves as a graphics resource. The following is an example of a VisualBrush object:

public class System.Windows.Media.VisualBrush : Brush {

public VisualBrush(Visualv);

public BrushMappingMode DestinationUnits { get; } public BrushMappingMode ContentUnits { get; } public Transform Transform { get; } public Rect ViewBox { get; } public Stretch Stretch { get; } public HorizontalAlign HorizontalAlign { get; } public VerticalAlign VerticalAlign { get; } public Point Origin { get; } public PointAnimationCollection OriginAnimations {get;} public Size Size { get; } public SizeAnimation Collect.ion SizeAnimations { get; } // Visual public Visual Visual { get; } }

public class System.Windows.Media.VisualBrushBuilder : BrushBuilder {

public VisualBrushBuilder();

public VisualBrushBuilder(Visual v) ;

public VisualBrushBuilder(VisualBrush vb);

// DestinationUnits; Default is ObjectBoundingBox public BrushMappingMode DestinationUnits { get; set} // ContentUnits: Default is ObjectBounding Box public BrushMappingMode ContentUnits { get; set} // Transform; Default is Identity public Transform Transform { get; set} // ViewBox: Default is (0,0,0,0) - unset and ignored public Rect ViewBox { get; set} // Stretch: Default is None - and ignored // because the ViewBox is not set public Stretch Stretch { get; set} // HorizontalAlign; Default is Center and ignored public HorizontalAlign HorizontalAlign { get; set}

-71// VerticalAlign: Default is Center and ignored public VerticalAlign VerticalAlign { get; set) // Origin: Default is (0,0) public Point Origin { get; set) public PointAnimationCollectionBuilder OriginAnimations { get; set) // Size: Default is (1,1) public Size Size { get; set) public SizeAnimationCollectionBuilder SizeAnimations { get; set) //Visual: Default is null - nothing drawn public Visual Visual { get; set)

The contents of a VisualBrush have no intrinsic limits and effectively describe an infinite plane. These contents exist in their own coordinate space, and the space being filled by the VisualBrush is the local coordinate space at the time of application. Content space is mapped to local space based on the ViewBox, ViewPort, Alignments, and Stretch properties. The ViewBox is specified in content space, and this rectangle is outlined within the ViewPort rectangle (as specified by the Origin and Size properties).

The ViewPort defines where the contents will eventually be drawn, creating the base tile for this Brush. If the value of DestinationUnits is UserSpaceOnUse, the Origin and Size properties are considered to be in local space at application time. If instead of the DestinationUnits value is

-72ObjectBoundingBox, then the Origin and Size are considered to be in coordinate space, where 0,0 is the upper left corner of the bounding box of the objects being painted, and 1,1 is the lower right corner of the same box. For example, let's consider a RectangleGeometry being filled, which is drawn from 100,100 to 200,200. In such an example, if the DestinationUnits is UserSpaceOnUse, an Origin of 100,100 and a Size of 100,100 would describe the entire content area. If DestinationUnits is ObjectBoundingBox, an Origin of 0.0 and a Size of 1.1 would describe the entire content area. If the Size is empty, this Brush does not produce anything.

The ViewBox is specified in the content space. This rectangle is transformed to fit inside the ViewPort as determined by the Alignment and Extent properties. If there is no Extent, then no scale is applied to the content. If the Extent is Padding, then the ViewBox is scaled independently in both X and Y to make it the same size as the ViewPort. If the Fill is Uniform or UniformToFill, the logic is similar but scales the X and Y dimensions evenly, preserving the appearance of the content. If Extent is Uniform, the ViewBox is scaled to have more constrained dimension equal to the ViewPort size. If Extent is UniformToFill, the ViewBox is scaled so that it has

-73minus constrained dimension equal to ViewPort size.

In other words, both Uniform and UniformToFill preserve aspect ratio, but Uniform makes sure that the entire ViewBox is inside the ViewPort (potentially leaving portions of the ViewPort uncovered by the ViewBox), and UniformToFill makes sure that the entire ViewPort is filled by the ViewBox (potentially causing portions of the ViewBox to be outside of the ViewPort). If the ViewBox is empty, then no Extension will be applied. Note that snapping will still occur, and will position the point of the ViewBox.

The FIG. 18 represents a single 1800 tile of graphics obtained with various stretch settings, including an 800 tile when stretch is set to none. Tile 1802 is a representation of when Extent is on Uniform, tile 1804 when Extent is on UniformToFill and tile 1806 when Extent is on Fill .

Once the ViewPort is determined (based on DestinationUnits) and the size of the ViewBox is determined (based on Extent), the ViewBox needs to be positioned inside the ViewPort. If the ViewBox is the same size as the ViewPort (if Extent is set to Fill, or if one of the other three Extent values happens), then the ViewBox is positioned in Origin such that it is identical to the ViewPort. Otherwise, HorizontalAlignment and

-74VerticalAlignment are considered. Based on these properties, the ViewBox is aligned in both the X and Y dimensions. If the HorizontalAlignment is Left, then the left edge of the ViewBox will be positioned on the left edge of the ViewPort. If it is Center, then the center of the ViewBox will be located in the center of the ViewPort, and if it is Right, then the right edges will match. The process is repeated with dimension Y.

If the ViewBox is (0,0,0,0) it is considered not set, therefore ContentUnits are considered. If ContentUnits are UserSpaceOnUse, no scaling or compensation occurs, and the contents are drawn into the ViewPort without any transformation. If ContentUnits are in the ObjectBoudnmingBox, then the Source content is aligned to the Source ViewPort, and the contents are scaled to the width and height of the object box.

When a space is filled with a VisualBrush, the contents are outlined within the ViewPort as indicated above, and attached to the ViewPort. This forms the base tile in Brush's TileMode. Finally, if set, the Brush transformation is applied and happens after all others like outline, scale, offset, etc.

The TileMode enumeration is used to describe if and how the space is filled by your Brush. A brush that

-75can be tiled has a defined rectangular tile, and this tile has a base location within the space being filled. The rest of the space is filled based on the TileMode value. The FIG. 19 depicts graphic examples with various TileMode selections, including none 1900, Tile 1092, FlipX 1904, FlipY 1906, and FlipXY 1908. The top left tile in the various graphic examples comprises the base tile.

The FIG. 20 depicts a process for generating the pixels for the brush. Note that the logic described in FIG. 20 is only one possible way of implementing the logic, and it should be understood that other, more efficient ways are feasible. For example, there are possibly more efficient ways to process the information, such that the content is not drawn every time, but the tile is drawn and stored in memory. However, FIG. twenty provides a direct description.

In general each time the content of the patterns is drawn, a new coordinate system is created. The origin and offset of each iteration is specified by the Origin and Size properties filtered through the DestinationUnits and Transform properties.

A coordinate frame is set based on the DestinationUnits property. For this purpose, if in step 2000, the DestinationUnits property is UserSpaceOnUse, the

The current coordinate frame at the time the brush is used is the initial coordinate frame, through Step 2002. If instead of being in Step 2004 the property is ObjectBoundingBox, the box containing the geometry in which this brush applied is used, represented by step 2004, to establish a new coordinate frame such that the top left corner of the bounding box aligns to (0,0) and the bottom left corner of the bounding box aligns to (1,1) . In both cases, in step

2006, the Transform property is applied to this coordinate frame, which essentially defines a grid

The FIG. 21 represents a VisualBrush grid that is defined for the tiles of a VisualBrush. The first circle is a simple grid and the second has Skew Transformation in the x-direction of 47.

In step 2008, the visual is drawn within each grid cell, as depicted in FIG. 22, where the visual draws the appropriate information. If in step 2010 there is a specific ViewBox, the Visual fits inside the grid cell as specified by the ViewBox, Stretch, HorizontalAlign, and VerticalAlign attributes, via step 2010. The DestinationUnits and

Transforms are used to apply the correct transformation so that the visual aligns with the grid box.

-77If no ViewBox is specified, then a new coordinate system is set for the content drawing in step 2014.

The coordinate frame is set such that its origin is at the Origin point for that particular grid cell being drawn.

A clip is applied in step 2018 based on the Size property such that the tile is not drawn outside the cell bounds. The Origin and Size are modified appropriately based on the DestinationUnits property.

The coordinate system is then modified, based on the SourceUnits property. For this purpose, if in step 2020 the SourceUnits property is ObjectBoundingBox, the appropriate scale of transformation is applied in step 2026, otherwise it is UserSpaceOnUse and no new transformation is applied. The Transform property is applied in step 2024, and the content is drawn in step 2026.

Note that if any part of the size is zero, nothing is drawn, and if Extent is none, the transformation for the ViewBox is done such that one unit in the new coordinate frame is equal to one unit in the old coordinate frame. . The transformation essentially becomes an offset based on the alignment attributes and the size of the ViewBox. As

-78described above in steps 2010 and 2012, the Extent and Alignment properties only apply when there is a specific ViewBox. The ViewBox specifies a new coordinate system for the contents, and the Extension helps specify how those contents are outlined within the ViewBox. The align option aligns the ViewBox, not the contents. So, for example, if the viewbox is set to 0 0 10 10 and something is drawn at -10, -10 and aligned to the top left corner, it will be clipped.

Returning to FIG. 15, an image brush can be thought of as a special case of VisualBrush. Although a program could be a visual, put an image inside it and attach it to the VisualBrush, the API to do so would be cumbersome. Since there isn't necessarily a content coordinate frame, the ViewBox and ContentUnits property no longer apply. Public class System.Windows.Media.ImageGrush : Brush {

public ImageBrush(ImageData image);

public BrushMappingMode DestinationUnits { get; } public Transform Transform { get; } public Stretch Stretch { get; } public HorizontalAlign HorizontalAlign { get; } public VerticalAlign VerticalAlign { get; } public Point Origin { get; } public PointAnimationCollection OriginAnimations { get; } public Size Size { get; } public SizeAnimationCollection SizeAnimations { get; } ~TT public ImageData ImageData { get; } }

public class System.Windows.Media.ImageBrushBuilder : BrushBuilder {

public ImageBrushBuilder() ;

public ImageBrushBuilder(ImageDate image);

public ImageBrushBuilder(ImageBrushib);

// DestinationUnits: Default is ObjectBoundingBox public BrushMappingMode DestinationUnits { get; set; } // Transform: Default is identity public Transform Transform { get; set; } // Stretch: Default is None public Stretch Stretch { get; set; } // HorizontalAlign: Default is Center public HorizontalAlign HorizontalAlign { get; set; } // VerticalAlign: Default is Center public VerticalAlign VerticalAlign { get; set; } // Origin: Default is (0,0) public Point Origin { get; set; } public PointAnimationCollectionBuilder OriginAnimations { get; set; } // Size: Default is (1,1) .

public Size Size { get; set; } public SizeAnimationCollectionBuilder SizeAnimations { get; set; } //ImageData: Default is null - - nothing drawn public ImageData ImageData { get; set; }

NineGridBrush is very similar to ImageBrush except that the image is twisted based on size. In essence, NineGridBrush can be thought of as a custom type of Extent, in which certain parts of the image are stretched, while others (for example the borders) are not.

So while the image size in ImageBrush will cause simple scaling, the NineGridBrush will produce non-uniform scaling to the desired size. The units of the unscaled areas are the user's units when

-80 The brush is applied, which means that ContentUnits (if it existed for NineGridBrush) will be set to UserUnitOnUse. The Brush's transform property can be used effectively. Note that edge members are counted from the edge of the image.

By way of example, FIG. 23 represents a nine-grid image being enlarged from a first instance 2302 to a second instance 2304, with four types of areas. As depicted in FIG. 23, to keep the same border, the areas marked a are expanded horizontally, the areas marked b are expanded vertically, the areas marked c are expanded horizontally and vertically, and the areas marked d are not changed in size.

public class System.Windows.Media.NineGridBrush : Brush {

public NineGridBrush(ImageData image, int LeftBorder, int Right Border, int TopBorder, int BottomBorder);

public BushMappingMode DestinationUnits { get; } public Transiorm Transiorm { get; } public Pint Origin { get; } public PointAnimationCollection OriginAnimations { get; } public Size Size { get; } public SizeAnimationCollection SizeAnimations { get; } public int LefBorder { get; } public int RightBorder { get; } public int TopBorder { get; } public int BottomBorder { get; ) public ImageData ImageData { get; } }

-81public class System.Window.Media.NineGridBrushBuilder : Brush Builder (

public NineGridBrushBuilder();

public NineGridBrushBruilder(ImageData image, int LeftBorder, int Right Border, int TopBorder, int BottomBorder;

public NineGridBrushBuilder(NineGridBrush ngb);

// DestinationUnits: Default is ObjectBoundingBox public BrushMappingMode DestinationUnits { get; set } // Transform: Default is identity public Transform Transform { get; set } // Origin: Default is (0,0) public Point Origin { get; set } public PointAnimationCollectionBuilder OriginAnimations { get; set } // Size: Default is (1,1) public Size Size { get; set } public SizeAnimationCollectionBuilder SizeAnimations { get; set } // *Border: default to 0 public int LeftBorder { get; set } public int RightBorder { get; set } public int TopBorder { get; set } public int BottomBorder { get; set } // ImageData: Default is null - nothing drawn public ImageData ImageData { get; set } }

As generally described above, the graphics object model of the present invention includes a Transformation model object, which includes the types of transformations represented in the hierarchy of FIG. 24, under a basic Transformation class. These different types of components that make a transformation can include TransformList, TranslateTransform, RotateTransform, ScaleTransform,

-82SkewTransform, and MatrixTransform. Individual properties can be animated, for example a program designer can animate the Angle property of a RotateTransform.

Matrices for 2D calculations are represented as a 3x3 matrix. For the necessary transformations, only six values are needed instead of a total 3x3 matrix. These are called and defined as follows:

^MOO mOl

MIO thousand 0 ^M20 m21

When a matrix is multiplied by a point, it transforms that point from the new coordinate system to the previous coordinate system:

Γ mOOmOlO^

[X newCoordSys Y newcoordSys 1], m10 m11 0 = [X oldCoordSys Y oldCoordSys 1 ] < m20 m21 1/

Transformations can be packaged at any level. Whenever a new transformation is applied it is the same as subsequently multiplying it over the current transformation matrix:

<td>[X newCoordSys Y newCoordSys 1]</td><td>m102 m112 0</td><td></td><td>n10-i m11you 0 =</td>

[X oldCoordSys YoldCoordSys 1]

J

-83Most places in the API don't take an Array directly, but instead use the class

Transformation that supports animation.

Public struct System.Windows.Media.Array {

// Build and fit public Matrix(); // defaults to identity public Matrix( double mOO, double mOl, double mlO, double mil, double m20, double m 21);

// Identity public static readonly Matrix Identity;

public void SetIdentity();

public bool Islidentity { get; } public static Matrix operator *(Matrix matrixl, Matrix matrix 12);

public static Point operator *(Array array, Point Point);

// These functions reinitialize the current matrix with //the specified transformation matrix public void SetTranslation (double dx, double dy); public void SetTranslation(Size offset);

public void SetRotation(double angle); // degrees public void SetRotation(double angle, Point center); // degrees public void SetRotationRadians(double angle);

public void SetRotationRadians(double angle, Point center);

public void SetScaling(double sx, double sy) ;

public void SetScaling(double sx, double sy, Point center);

public void SetSkewK(Double angle); // degrees public void SetSkewY(double angle); // degrees public void SetSkewXRadians(double angle); publc void SetSkewYRadians(double angle);

// These functions further multiply the // current matrix with the specified transformation public void ApplyTranslation(double dx, double dy) ; public void ApplyRotation(double angle); // degrees public void ApplyRoration(double angle, Point center);

// degrees

-84 public void ApplyRotationRadian(double angle);

public void ApplyRotationRadian(double angle, Point center);

public voic ApplyScaling(double sx, double sy) ;

public void ApplyScaling(double sx, double sy, Point center);

public void ApplySkewX(double angle); // degrees public void ApplySkewY(double angle); // negrees public void ApplySkewXRadians(double angle); public void ApplySkewYRadians(double angle);

public void ApplyMatrix(Matrix matrix);

// Investment public double Determinant { get; } public bool Islnvertible { get; } public void InvertO; // Throws ArgumentException if !Islnvertable public static Matrix Invert(Matrix matrix);

// Individual members public double M00 { get; set;} public double M01 { get;set;} public double MIO { get; set;) public double Mil { get; set;} public double M20 { get; set;} public double M21 { get; set;} };

REFERENCE LANGUAGE AND MODEL OBJECT FOR VECTOR GRAPHICS

In accordance with one aspect of the present invention, a reference language and model object element is provided to facilitate user programs and tools to interact with the information in the graphical scene structure 216 without requiring specific knowledge of the details of the scene. API 212 layer (FIG. 2). In general, a vector graphics reference language is provided that comprises an interchange format, together with a reference-based authority format for expressing vector graphics via the object element.

-85model. Through this language (eg HTML or XML type content) the reference can be programmed. Then, to build the scene graph, the reference is translated and translated into appropriate visual layer API objects as described above. At this higher operational level, a tree element, a property system, and a display system are provided to handle most complexities, making it perfect for scene designers to design possibly complex scenes.

In general, the vector graphics system provides a set of shape and other elements, integration with a general property system, a grouping and composition system, and a two-stage approach (item level and resource level) so that the user can program in a way that meets their needs for flexibility and performance. Continuing with one aspect of the present invention, the model object element for working with vector graphics is mapped to the model object of the graphics scene. In other words, the vector graphics system and the visual layer API share a set of resources at the model object element level, for example, the Brush object is used when drawing in the visual layer API and is also the type of fill property on Shape. Therefore, in addition to having elements that map to objects in the

-86scene graphics, the reference language shares a number of primitive resources (eg brushes, transformations, and so on) with the visual layer API. The vector graphics system also exposes and extends the animation capabilities of the Visual API layer, which is widely shared between levels.

Furthermore, as described below, the vector graphics system can program at different profiles, or levels, including an element level and a resource level. In the level element, each of the drawing shapes is represented as an element at the same level as the rest of the programmable elements on a page or screen. This means that forms fully interact with the presenter system, events, and properties. At the resource level, the vector graphics system operates in a purely resource format, similar to a traditional graphics metafile. The resource level is efficient, but has somewhat limited support for cascading properties, for scheduling events, and for detailed scriptability. The scene designer therefore has the ability to balance efficiency with programmability as necessary.

Continuing with one aspect of the present invention, the resource-level vector graphics system is also mapped to the visual layer API, because the resource-level reference in an implementation is expressed as a

-87 Visual Brush. When the resource reference is translated, a visual object is created. The visual is set within a VisualBrush that can be used by shapes, controls, and other elements at the element level.

The FIG. 25 is a representation of the element class hierarchy 2500. The reference language classes for the model object of the present invention are represented by shaded squares, and include a shape class 2502, an image class 2504, a video class 2506, and a class canvas 2508. Elements of the shape class include rectangle 2510, polyline 2513, polygon 2514, path 2516, line 2518, and ellipse 2520. Note that in some implementations, a circle element may not be rendered as indicated by dashed boxes 2522 in FIG. 25, however for the purpose of the various examples included here, the circle element 2522 will be described. Each element may include or be associated with fill (property) information, feature data, slice data, transform data, filter effect data, or mask data.

As described later, shapes correspond to geometry that is drawn with inherited and cascading properties. The layout properties are used to build the pen and brush needed to draw the shapes. In one implementation, forms are full presenters like other control elements. Without

-88However, in another implementation a canvas class can be provided 2508 as a shape container, and shapes can only be drawn when they are in a canvas element. For example, to keep images light, shapes can be prevented from having presenters attached. Instead, the canvas has a presenter attached to it and draws the shapes. The canvas element is described in more detail below.

As also described below, the image class is more specific than the shape, and may for example include border information which may be complex. For example, a border of one color can be specified on the top, a different color on the sides, with the possibility of various thicknesses and other specified properties. The position, size rotation, and scale can be set for an image or for a similar framed element, such as text or video. Note that image and video elements can exist and be displayed outside of a canvas element, and also inherit from BoxedElements, for example, to get support for such an element's background, borders, and padding.

The video element allows video (or other similar multimedia) to be played within a displayed element. In this way, the vector graphics system provides a reference interconnection to the API layer that is consistent and seamless across the

-89multimedia, including text, 2D graphics, 3D graphics, animation, video, still images, and audio. This allows designers to learn to work with one medium and easily integrate another medium into applications and documents. The vector graphics system also allows media to be animated in the same way as other elements and again gives designers the ability to use media like other elements, without sacrificing the intrinsic quirks of each individual medium. For example, a designer can use the same naming scheme for rotation, scaling, animation, drawing, compositing, and other effects across different media types, easily creating rich applications as well as allowing construction of an efficient implementation of production and composition underneath.

The FIG. 26 depicts an implementation in which reference code 2602 is interpreted by a translator/translator 2604. In general, translator/translator 2604 adds elements to an element tree or property system 208 (also shown in FIG. 2) and appends presenters to those items. The presenter system 210 then takes the tree element 210 with the attached presenters and translates the information into objects and calls to the visual layer API 212. Note that no

all items need to be translated, only those that have presenters attached.

In general, an item is an item layer object that participates in the property, event, and distribution and presentation systems. The translator finds the tags and decides whether those tags help define an element or a resource object.

In the special case of a VisualBrush, the same tags can be interpreted as elements or also interpreted as resource objects, depending on the context in which those tags appear, eg. depending on whether they appear in a complex property syntax or not.

In accordance with one aspect of the present invention, the reference language provides different ways of describing a resource, including a simple line format or a complex object annotation. For a simple line format, the translator/translator 2604 uses a converter type 2608 to convert a line into an appropriate API visual object. As an example, in the following reference line, the value of the Fill property can be converted to a brush object, through the type 2608 converter;

-91As can easily be seen, converting that tag-based reference line to a single parameter line is straightforward for a brush object and provides a simple way for a scene designer to add a shape and its attributes to a scene.

However, there are times when the fill attribute is too complex to fit on a single line. In such a situation, complex property syntax, which may be on one line in the reference, is used to set this property. For example, the following complex property syntax fills a circle with a gradient instead of a solid color, specifying the colors at different stops of the gradient (which can range from 0 to 1):

In addition to being present inline in the reference, a resource instance may be located elsewhere (for example in the reference or in a file that may be local or on a remote network and appropriately downloaded), referenced by a name (for example a text name, reference or other suitable identifier). Thus, cCircle CenterX=10 CenterY=10 Radius=5> <Circle.Fill>

<Circle.Fill>

</Circle>

-92a designer can reuse an element from the element tree throughout the scene, including elements described by complex property syntax.

The translater handles referencing complex property syntax by accessing the type 2608 converter as needed, and also matching the parameters specified for object properties, thus handling the complexity for the scene designer. Therefore, the translator does not simply set the objects, but also puts attributes on them. Note that the portkey actually starts a constructor to create objects, since objects are immutable.

Because the same getter model is shared between the item level and the API level, many of the objects are essentially the same. This makes translation highly efficient, and also allows for different types of programming languages (eg C# type languages) and the ability to easily convert from the reference to your own syntax and vice versa. Note that as depicted in FIG: 26, other programming language 2610 may add elements to the element tree, or may interface directly with the visual API layer 212.

As also depicted in FIG. 26, and according to one aspect of the present invention, the same reference 2602 can be used to program at the level

-93element and resource level. As described above, the element level gives the designer full programmability, use of the property system that provides inherited characters (eg, style sheet-like features), and events (eg, where an element can have code attached to it). to change its appearance, position, and so on in response to user event input). However, the present invention also provides a resource-level mechanism by which designers can essentially shortcut between the element tree and the presenting system and program directly in the visual API layer. For many types of static forms, images and so on where element-level features are not needed, this provides a more efficient and lightweight way of producing the appropriate object. For this effect, the portkey recognizes that a fill of type visual brush is present, and directly calls API layer 212 with resource level information 2612 to create the object. In other words, as depicted in FIG: 22, element-level vector graphics are translated into created elements, which then need translation into objects, while resource-level vector graphics are translated and directly stored efficiently.

As an example, the following reference is derived directly from the model object for the object

-94LinearGradient, and fills an outer circle with a

VisualBrush. The content of that VisualBrush is defined by the inner reference. Note that this syntax is commonly used to express various brushes, transformations, and animations:

cCircle.Fill> cVisualBrush xmlns=...>

cCircle CenterX=0.5 CenterY-0.5 Radius=0.25 Fill=Blue/>

cCircle CenterX=0.6 CenterY=0.6 Radius=0.25 Fill=Green/>

cCircle CenterX=0.7 CenterY=0.7 Radius=0.254 Fill=Red/>

cCircle CenterX= 0.8 CenterY=0.8 Radius=110.25 Fill=LemonChiffon/>

w/visualBrush>

c/Circle.Fill>

c/Circle>

Note that while these brush-filled visuals are efficiently stored, the resource level information (or the objects created with it) can be referenced by elements and part of the element tree 208, as generally depicted in FIG. 26. For this purpose, these visual brush resources may be named (eg with a name, reference or other suitable identifier) and referred to as other described resources via complex property syntax.

Going back to an explanation of the canvas, as mentioned above in an implementation. Alternatively, the shapes can be kept light and therefore can

-95required to be contained in a canvas. In this alternate implementation, when content is retrieved, it is retrieved on an infinite, device-independent canvas that has an associated coordinate system. The canvas element can therefore place content according to absolute coordinates. The canvas element can optionally define a viewport, which specifies a crop, a transformation, the preferred aspect ratio, and a way to outline the viewport within a parent space. If no viewport is set, the canvas element only specifies a grouping of drawing primitives and can set a transform, opacity, and other composition attributes.

The following is a: referential example for a canvas swatch: cCanvas Background=black Top=100 Left=100Height=600' Width=800>

</Canvas

Note that in one implementation, when coordinates are specified without units then they are considered logical 96th pixels. inch, and in the example above, the line will be 200 pixels long. In addition to coordinates, other properties include width, horizontal height, and vertical alignment, and ViewBox

-96(of type rect; not automatically set, or (0,0,0,0), which means no snapping is done, and the stretch and align properties are ignored). As generally described above with reference to FIGS. 18 to 20, other properties include stretch, which when unspecified preserves the original size, or can: 1) specify a padding in which aspect ratio is not preserved and scales the content to fill the bounds set above /left/width/height; 2) specify uniform, which scales the size evenly until the image fills the set top/left/width/height bounds; or 3) specify UniformToFill, which scales the size uniformly to fill the borders set at the top/left/width/height, and crops as necessary.

To further map to the lower level model object, the transform property sets a new coordinate frame for the element's children, while the clip property constrains the region in which content can be drawn on the canvas, with the automatic cutting path defined as the bounding box. The ZIndex property can be used to specify the order of appearance of elements contained on the canvas within a panel.

-97The ViewBox specifies a new coordinate system for the content, eg. redefining the scope and origin of the viewport. The extension helps specify how those contents are outlined within the viewport. The ViewBox attribute value is a list of four unitless numbers <min-x>, <min-y>, <width>, and <height>, separated by whitespace and/or commas, and is of type Rect.

rectangle in the confining space. Works

The ViewBox rect specifies the user's outline of the box just like inserting an xscale and yscale.

option is additional graphics.

The stretch property (in the case where it is different from none) provides control to preserve the aspect ratio of the

An additional transformation is applied to the descendants of a given element so that they acquire specific effects.

In the example above, the effective result of the rectangle in the reference example above under each extension rule would be:

None - from (100,600 to (200,650)

Padding - from (100,100) to (900, 700)

Uniform - from (100,?) to (900,?) - the new height will be 400, and it will be centered based on horizontal and vertical alignment.

UniformToFill - from (?,100) to ?,700) the new width is 1200, and it will be centered again based on horizontal and vertical alignment.

-98If there is a transformation on the canvas, it is essentially applied on the outline of the ViewBox (eg on the tree). Note that this drawing will extend any of the elements on a canvas such as frames, text and so on, and not just the shapes. Furthermore, note that if a Viewbox is specified, the canvas no longer fits its content, but rather has a specific size. If y-width and y-height are specified, then the span/align properties are used to fit the viewbox within the specified width and height.

Elements of the model object can each have a clipping attribute applied to them. On some elements, notably forms, this is directly exposed as a common language time property, while on others (eg most controls) this property is set via a DynamicProperty.

In general, the clipping path constrains the region in which content can be drawn, as generally depicted in FIG. 27 showing an uncropped figure button 2702 and a figure 2704 in which a clipping path is specified (where the dashed lines represent the clipping path). Conceptually, any parts of the drawing that fall outside the region bounded by the current active clipping path will not be drawn. You can think

-99that a clipping path is a mask where those pixels outside the clipping path are black with an alpha value of zero and those pixels inside the clipping path are white with an alpha value of one (with the possible exception of anti -aliasing along the edge of the silhouette).

A clipping path is defined by a Geometry object, either inline or more typically in a resource section. A clipping path is used and/or referenced using the clipping property on an element, as the following example shows:

<def:Resources>

</Geometry>

</def:Resources>

<Element Clip=%resource; MyClip

Note that animating a Clip is similar to animating transformations:

<Element.Clip> <Circle .../> <Rectangle ... >

</Rectangle>

<Element.Clip>

. . . children . . .

</Element>

A path is drawn by specifying geometric information and properties such as Fill, Stroke, and

-100Width of Feature on Path element. An example reference for a trail is specified as follows:

The trail information line is of the geometric type. A more explanatory and complete way to specify a drawn path is through the complex property syntax, as described above. The reference (as in the following example) is fed directly into the geometric construction classes described above:

<Path>

<Path.Data> cCircleGeometry ... /> <RectangleGeometry ... /> <PathGeometry ... />

</Path.Data>

<Path.Fill value=red />

<Path.Stroke value=blue /> </Path>

The path information row is also described using the following annotations to describe the grammar for a path information row:

*: 0 or more +: 1 or more ?: 0 or 1

() : grouping |: separate alternatives Quotes enclose literals

The following table shows the row of trail information described with this annotation (note that in a

-101implementation, FillMode can be specified here instead of an element-level property):

svg-path wsp* moveto-drawto-command-groups? wsp* moveto-drawto-command-groups: moveto-drawto-command-group | moveto-drawto-command-group wsp* moveto-drawtocommand-groups moveto-drawto-command-group:

moveto wsp* drawto-commands?

drawto-commands; drawto-command | drawto-command wsp* drawto-commands drawto-command:

( M | m ) wsp* moveto-argument-sequence moveto-argument-sequence: coordinate-pair | coordinate-pair comma-wsp? lineto-argument-sequence closepath:

( Z | z lineto:

( L | 1 ) wsp* lineto-argument-sequence lineto-argument-sequence: coordinate-pair | coordinate-pair comma-wsp? lineto-argument-sequence horizontal-lineto ( H | h ) wsp* horizontal-lineto-argument-sequence

-102horizontal-lineto.argument-sequence:

coordinate | coordinate comma-wsp? horizontal-lineto-argumentsequence vertical-lineto:

( V | v ) wsp* vertical-lineto-argument-sequence vertical-lineto-argument-sequence:

coordinate | coordinate comma-wsp? vertrical-lineto-argumentsequence curveto:

( C | c ) wsp* curveto-argument-sequence curveto-argument-sequence:

curveto-argument | curveto-argument comma-wsp? curveto-argument-sequence curveto-argument:

coordinate-pair comma-wsp? coordinate-pair comma-wsp? coordinate-pair smooth-curveto:

( S! | s ) wsp* smooth-curveto-argument-sequence smoo th-curveto-argument t-sequence;

smooth-curveto-argument | smooth-curveto-argument comma-wsp? smooth-curvetoargument-sequence smooth-curveto-argument:

coordinate-pair comma-wsp? coordinate-apir quadratic-bezier-curveto:

( Q | q ) wsp* quadratic-bezier-curveto-argumentsequence quadra ti c-be zi er-curve to-argument-sequence:

quatratic-bezier-curveto-argument | quadratic-bezier-curveto-argument comma-wsp? quadratic-bezier-curveto-argument-sequence quadratic-bezier-curveto-argument:

coordinate-pair comma-wsp? coordinate-pair smooth-quadratic-bezier-curveto:

( T | t ) wsp* smooth-quadratic-bezier-curvetoargument-sequence

-103smooth-quadratic-bezier-curveto-argument-sequence: coordinate-pair | coordinate-pair comma-wsp? smooth-quadratic-beziercurveto-argument-sequence elliptical-arc:

( A | a ) wsp* elliptical-arc-argument-sequence elliptical-arc-argument-sequence: elliptical-arc-argument |elliptical-arc-argument comma-wsp? elliptical-arcargument-sequence elliptical-arc-argument: nonnegatie-number comma-wsp? nonnegative-number commawsp?

number comma-wsp flag comma-wsp flag comma-wsp coordinate-pair coordinate-pair:

coordinate comma-wsp? coordinate coordinate:

number nonnegative-number: integer-constant | floating-point-constant number:

sign? integer-constant | sign? floating-point-constant flag:

II Q II | II *| II comma-wsp:

(wsp+ comma? wsp*) | (comma wsp*) starts:

II II /

integer-constant: digit-sequence floating-point-constant: fractional-constant exponent?

| digit-sequence exponent fractional-constant digit-sequence? . digit-sequence

-104| digit sequence .

exponent:

( e | E ) sign? digit-sequence sign:

If | » f | II _ l<

digit sequence: digit | digit digit-sequence digit: 0 ti Q II

whatsapp:

(#x20) | #x9 | #xD | #for)

The image element (FIG. 25) indicates that the content of an entire file may result in a given rectangle within the user's current coordinate system. The image (indicated by the image tag) can refer to rasterized image files such as PNG or JPEG, or to files of the image/wvg MIME type, as indicated in the following example: <Image Topp=200 Left=200 Width-'ΊΟΟρχ Height=100px Source=myimage.png>

</Image>

The following table provides information on some example properties for images:

<td>Name</td><td>Guy</td><td>R/RW</td><td>Automatic Value</td><td>Description</td>

<td>Top</td><td>BoxUnit</td><td></td><td></td><td>Coordinate for the upper side of the Image</td>

<td>left t</td><td>BoxUnit</td><td></td><td></td><td>Coordinate for the left side of the Image</td>

<td>Width</td><td>BoxUnit</td><td></td><td></td><td>Image Width</td>

-105-

<td>Height</td><td>BoxUnit</td><td></td><td></td><td>Image Height</td>

<td>source</td><td>ImageData</td><td></td><td></td><td>Image Source</td>

<td>IPR</td><td>float</td><td></td><td> (96?)</td><td>Target DPI to use for size</td>

<td>HorizontalAlign</td><td>enum { Left (?), Center (?), Right (?) 1</td><td></td><td>Center</td><td></td>

<td>VerticalAlign</td><td>enum { Top (?), Middle {?), Bottom (?) }</td><td></td><td>Half</td><td></td>

<td>Stretch</td><td>enum Stretch { None, fill, Uniform, UniformToFill</td><td></td><td>None</td><td>None: Preserves the original size Padding: aspect ratio is not preserved and content is scaled to fill the bounds set by tlbh</td>

<td></td><td></td><td></td><td></td><td>Uniform: Scales the size evenly until the image fits within the limits set by the tlwh.</td>

<td></td><td></td><td></td><td></td><td>UniformToFill: Scales size uniformly to fill the borders set by tlbh, and clips.</td>

<td>ReadyState</td><td>enuim { MetaDataReady, Loading, Loaded LoadError }</td><td></td><td></td><td></td>

<td>LoadCounter</td><td>int</td><td>Read</td><td>null</td><td>Counter that increments when ReadyState is being loaded</td>

<td>Yam</td><td>String</td><td></td><td></td><td>Alternate text for the Image.</td>

As described above, shapes correspond to geometry drawn with inherited and cascading display properties. The following tables give examples of shape properties for the basic shape elements described above (Rectangle, Ellipse, Line,

-106Polyline, Polygon). Note that these basic shapes can have feature properties, fill properties, be used as clipping paths, have inherited characteristics, and be applied at both the element and resource levels:

<td>Name</td><td>Guy</td><td>R/RW</td><td>Automatic Value</td><td>Description</td>

<td>fill</td><td>Brush</td><td>RW</td><td>null</td><td>Coordinate for the upper side of the line</td>

<td>FillOpacity</td><td>float</td><td>RW</td><td> 1.0</td><td>Coordinate for the left side of the line</td>

<td>Stroke</td><td>Brush</td><td>RW</td><td>null</td><td>Width of the line</td>

<td>StrokeOpacity</td><td>float</td><td>RW</td><td> 1.0</td><td>height of the line</td>

<td>StroWidth</td><td>Box Unit</td><td>RW</td><td>ipx</td><td>Trace width. lpx= 1/96 of an inch</td>

<td>FillRule</td><td>enum { EvenOdd, NonZero }</td><td>RX</td><td>EvenOdd</td><td>FillRule indicates the algorithm that will be used to determine which parts of the canvas are included within the shape.</td>

<td>StrokeLineCap</td><td>enum { Butt, Round, Square, Diamond )</td><td>RW</td><td>butt</td><td>StrokeLineCap specifies the shape to be used at the end of open subpaths when the feature is passed.</td>

<td>StrokeLineJoint</td><td>enum { Miter, Round, Bevel 1</td><td>RW</td><td>Miter</td><td>StrokeLineJoin specifies the shape to be used for the corners of paths (or other vector shapes) that are activated when the feature is passed.</td>

<td>StrokeMiterLimit</td><td>float</td><td>RW</td><td> 4.0</td><td>The limit of the radius from MiterLength to the StrokeWidth. Value to be >= 1</td>

<td>S t roke Da shArray</td><td>PointList</td><td>RW</td><td>null</td><td>StrokeDashArray controls the pattern of dashes and gaps used to draw trails. <dasharray> contains a comma-separated list of spaces or numbers that specify the length of the alternating dashes and the</td>

-107-

<td></td><td></td><td></td><td></td><td>gaps in user units. If an odd number of values is provided, then the list of values is iterated to yield an even number of values. Therefore, stroke-dasharrayh: 5 3 2 is equivalent to stroke-dasharray: 5 3 2 5 3 2.</td>

<td>StrokeDashOffset</td><td>point</td><td>RW</td><td></td><td>StrokeDashoffset specifies the distance within the dash pattern to start the who.</td>

<td>transform</td><td>transform</td><td>RW</td><td>null</td><td>Transform sets a new coordinate box for the element's children.</td>

<td>clip</td><td>Geometry</td><td>RW</td><td>null</td><td>Clipping restricts the region in which paint can be applied to the canvas. The automatic clipping path is defined as the bounding box.</td>

The following is an example of a reference syntax for a rectangle:

<Rectangle Top=600 Left=100 Width=100 Height=50

Fill=red Stroke=blue StrokeWidth=10/>

A rectangle has the following properties on the model object (note that rectangles are read/write, have automatic values equal to zero, support inheritance, and apply to both element and resource levels):

<td>Name</td><td>Guy</td><td>Description</td>

<td>Top</td><td>BoxUnit</td><td>Coordinate for the upper side of the line</td>

<td>left t</td><td>BoxUnit</td><td>Coordinate for the left side of the line</td>

<td>Width</td><td>BoxUnit</td><td>Width of the line</td>

-108-

<td>Height</td><td>BoxUnit</td><td>height of the line</td>

<td>RadiusX</td><td>BoxUnit</td><td>For rounded rectangles, the X axis of the radius of the ellipse is used to round the corners of the rectangle. If a negative X axis of the radius is specified, the absolute value of the radius will be used.</td>

The following is an example of a reference syntax for a circle:

cCircle CenterX=600 CenterY=100 Fill=red Stroke=blue StrokeWidth=10/>

A circle has the following properties on the model object (note that circles are read/write, have automatic values equal to zero, support inheritance, and apply at both element levels):

<td>Name</td><td>Guy</td><td>Description</td>

<td>CenterX</td><td>BoxUnit</td><td>X coordinate of the center of the circle</td>

<td>CenterY</td><td>BoxUnit</td><td>Y coordinate of the center of the circle</td>

<td>radius</td><td>BoxUnit</td><td>circle radius</td>

The following is an example of the reference syntax for an ellipse:

An ellipse has the following properties on the model object (note that ellipses are read/write, have automatic values equal to zero, support inheritance, and apply to both element and resource levels):

-109-

<td>Name</td><td>Guy</td><td>Description</td>

<td>CenterX</td><td>Coordinate</td><td>X coordinate of the center of the ellipse</td>

<td>CenterY</td><td>Coordinate</td><td>Y coordinate of the center of the ellipse</td>

<td>RadiusX</td><td>Length</td><td>The radius x axis of the ellipse. If a negative X-axis radius is specified, the absolute value of the radius will be used.</td>

<td>radiusY</td><td>Length</td><td>The Y axis of the radius of the ellipse. If a negative Y-axis radius is specified, the absolute value of the radius will be used.</td>

The following is an example of a reference syntax for a line:

<Linexl=100! yl=”300 x2=300 y2=100 StrokeWidth=5 />

A line has the following properties on the model object (note that lines are read/write, have automatic values equal to zero, support inheritance, and apply to both element and resource levels):

<td>Name</td><td>Guy</td><td>Description</td>

<td>eleventh</td><td>BoxUnit</td><td>The X axis coordinate of the start of the line. Automatic value is 0</td>

<td>Y1</td><td>BoxUnit</td><td>The Y-axis coordinate of the start of the line. Automatic value is 0</td>

<td>X2</td><td>BoxUnit</td><td>The X axis coordinate of the end of the line. The automatic value is 0”</td>

<td>Y2</td><td>BoxUnit</td><td>The y-axis coordinate of the end of the line. Automatic value is 0</td>

The polyline defines a set of connected straight line segments. Typically, a polyline defines an open figure.

The following is an example of the reference syntax for a polyline:

-110<Polyline Fill-none Stroke=blue StrokeWidth=10cm Points=50,375

150.375 150,3215 250,325 250,375

350.375 350,250 450,250 450,375

550.375 550,175 650,175 650,375

750.375 750,100 850,100 850,375

950.375 950,25 1050,25 1050,375

1150,375 />

A polyline has the following properties on the model object (note that lines are read/write, have automatic values equal to null, support inheritance, and apply to both element and resource levels):

<td>Name</td><td>Guy</td><td>Description</td>

<td>points</td><td>PointCollection</td><td>The points that make up the polyline. Coordinate values are in the user's coordinate system.</td>

The polygon element defines a closed shape comprising a set of connected straight line segments.

The following is an example of the reference syntax for a polygon:

<Polygon Fill=red Stroke=blue StrokeWidth=10 points=350.75 379.161 469.161, 397.215 423.301 350.250, 277.301 303, 215

231,161 321,161 />

-111A polygon has the following properties on the model object (note that lines are read/write, have automatic values equal to null, support inheritance, and apply at both element and resource levels):

<td>Name</td><td>Guy</td><td>Description</td>

<td>points</td><td>PointCollection</td><td>The points that make a polygon. Coordinate values are in the user's coordinate system. If an odd number of coordinates is provided, then the element is in error.</td>

The grammar for point specifications in polyline and polygon elements is described with the following note:

*: 0 or more +: 1 or more ?= 0 or 1

(): grouping |: separate alternatives quotes enclose literals

The following table describes the point specifications on the polyline and polygon elements using the note above:

list-of-pints:

wsp* coordinate-pairs? wsp* coordinate-pairs: coordinate-pair | coordinate-pair comma-wsp coordinate-pairs coordinate-pair:

coordinate comma-wsp coordinate

-112coordinate:

number number:

sign? integer-constant | sign? floating-point-constant comma-wsp:

(wsp* comma? wsp*) | (curtain wsp*) starts:

II u /

integer-constant: digit-sequence floating-point-constant: fractional-constant exponent?

| digit-sequence exponent fractional-constant:

digit-sequence? . digit-sequence | digit-sequence .

exponent:

( e | E ) sign? digit-sequence sign:

YO! | II | II _ II digit-sequence:

digit | digit digit-sequence digit:

ii η η I ii i μ I n 9 11 I 11 o 11 I 11 Λ ιι I 11 c 11 I 11 £ 11 I 11 Π 11 I it p ti wsp:

(#x20 | #x9 | #xD | #xA)+

CONCLUSION

As can be seen from the detailed description above, there is provision for a system, method, and model element/object that provides various mechanisms for program code to interface with a graphical scene. He

-113system, method, and model object are easy to use, yet powerful, flexible, and extensible.

While the invention is susceptible to various modifications and alternative constructions, certain embodiments illustrated herein are shown in the drawings and have been described in detail above. It is to be understood, however, that it is not intended to limit the invention to the specific forms included, rather to the contrary, it is intended to cover all modifications, alternative constructions, and equivalents that fall within the spirit and scope of the invention.

WHAT IS CLAIMED IS:

59 members in 28 offices

This recordMember, by publication date18 more offices are in the list below

Members59

Family members, oldest first
Document	Office	Kind
NO20032205D0	Norway	D0	2003-05-15
HU0301289D0	Hungary	D0	2003-07-28
IL155881A0	Israel	A0	2003-12-23
IL155881D0	Israel	D0	2003-12-23
ZA200303553B	South Africa	B	2004-04-22
CA2428471A1	Canada	A1	2004-09-27
NO20032205L	Norway	L	2004-09-28
EP1462998A2	European Patent Office (EPO)	A2	2004-09-29
MXPA03004410A	Mexico	A	2004-09-29
US2004189667A1	United States of America	A1	2004-09-30
US2004194020A1	United States of America	A1	2004-09-30
TW200419376A	Taiwan Province of China	A	2004-10-01
CN1534476A	China	A	2004-10-06
KR20040086042A	Republic of Korea	A	2004-10-08
AU2003204007A1	Australia	A1	2004-10-14
JP2004295857A	Japan	A	2004-10-21
TR2003000696A2	Türkiye	A2	2004-10-21
TR200300696A2	Türkiye	A2	2004-10-21
ECSP034609AThis record	Ecuador	A	2004-10-26
HU0301289A2	Hungary	A2	2004-10-28
HUP0301289A2	Hungary	A2	2004-10-28
BR0302004A	Brazil	A	2004-11-03
CO5460278A1	Colombia	A1	2004-11-30
HK1066311A	Hong Kong, China	A	2005-03-18
HK1066311A1	Hong Kong, China	A1	2005-03-18
HRP20030389A2	Croatia	A2	2005-04-30
WO2005045800A1	World Intellectual Property Organization (WIPO)	A1	2005-05-19
NZ525857A	New Zealand	A	2005-06-24
EP1559094A1	European Patent Office (EPO)	A1	2005-08-03
CN1705976A	China	A	2005-12-07
EP1462998A3	European Patent Office (EPO)	A3	2005-12-07
KR20060002735A	Republic of Korea	A	2006-01-09
GT200300184A	Guatemala	A	2006-04-21
SG127696A1	Singapore	A1	2006-12-29
JP2007509436A	Japan	A	2007-04-12
NZ535067A	New Zealand	A	2007-05-31
RU2321892C2	Russian Federation	C2	2008-04-10
EP1462998B1	European Patent Office (EPO)	B1	2008-07-30
AT403198T	Austria	T	2008-08-15
ATE403198T1	Austria	T1	2008-08-15
US7417645B2	United States of America	B2	2008-08-26
DE60322505D1	Germany	D1	2008-09-11
IL155881A	Israel	A	2008-11-03
US7486294B2	United States of America	B2	2009-02-03
HRP20030389B1	Croatia	B1	2009-06-30
JP4290477B2	Japan	B2	2009-07-08
CN100533381C	China	C	2009-08-26
AU2003204007B2	Australia	B2	2009-09-17
NO328434B1	Norway	B1	2010-02-15
CN1534476B	China	B	2010-05-26
KR100996738B1	Republic of Korea	B1	2010-11-25
TWI336042B	Taiwan Province of China	B	2011-01-11
HU0301289A3	Hungary	A3	2011-04-28
HUP0301289A3	Hungary	A3	2011-04-28
MY143630A	Malaysia	A	2011-06-15
JP4796500B2	Japan	B2	2011-10-19
KR101109395B1	Republic of Korea	B1	2012-01-30
CA2428471C	Canada	C	2012-09-04
RO123609B1	Romania	B1	2014-07-30

Markup language and object model for vector graphics

Abstract

Term

REFERENCE LANGUAGE AND MODEL OBJECT FOR GRAPHICS

VECTORS

FIELD OF THE INVENTION

BACKGROUND OF THE INVENTION

SUMMARY OF THE INVENTION

BRIEF DESCRIPTION OF THE DRAWINGS

-13 DETAILED DESCRIPTION

EXEMPLARY OPERATING ENVIRONMENT

GRAPHICS ARCHITECTURE

GRAPHIC SCENE MODEL OBJECT

EITHER;

J

J

REFERENCE LANGUAGE AND MODEL OBJECT FOR VECTOR GRAPHICS

II II /

CONCLUSION

WHAT IS CLAIMED IS:

Members59

Numbers

Titles2

Classification

Abstract

Term

REFERENCE LANGUAGE AND MODEL OBJECT FOR GRAPHICS

VECTORS

CROSS REFERENCE FOR RELATED APPLICATIONS

FIELD OF THE INVENTION

BACKGROUND OF THE INVENTION

SUMMARY OF THE INVENTION

BRIEF DESCRIPTION OF THE DRAWINGS

-13 DETAILED DESCRIPTION

EXEMPLARY OPERATING ENVIRONMENT

GRAPHICS ARCHITECTURE

GRAPHIC SCENE MODEL OBJECT

EITHER;

J

J

REFERENCE LANGUAGE AND MODEL OBJECT FOR VECTOR GRAPHICS

II II /

CONCLUSION

WHAT IS CLAIMED IS:

Members59

Numbers

Titles2

Classification