System for processing graphical information and other video information to be displayed by computer systems

The present invention relates to a system for processing graphical information and other video information, for display on computer systems, being in connection with the following patent applications, dependent in the United States: US 2003/0076328, entitled "System and multi-level graphics processing method; US 2003/0132937, entitled Generic parameterization for a scenic graph; US 2003/0076329, entitled Intelligent hidden data storage structure for graphics immediately; each filed on June 27, 2002; as well as the patent application in the United States, entitled Graphic and Visual Graphic Interfaces (Registered US Attorney 2003/0693673).

The invention relates, in general, to computer systems and, more particularly, to the processing of graphic information and other video information, for display on computer systems.

The limitations of the traditional direct-access model of access graphics on computer systems have been reached, in part, because memory and bus speeds have not kept pace with the progress of the main processors and / or the graphics processors. In general, the current model (for example, WM_PAINT) for preparing a framework requires too much data processing to keep up with the hardware refresh rate when complex graphics effects are desired. As a result, if the effects of complex graphics are tested, along with conventional graphics models, instead of completing changes resulting from visual effects, perceived over time, for the next frame, changes can be added over different frames, resulting in results that are not visually and perceptibly desired.

A new model, for extracting graphics, is described in US patent applications, mentioned above, with US serial numbers 2003/0076328; US 2003/0132937 and US 2003/0076328. This new model provides a number of significant improvements in graphics processing technology. For example, US Patent 2003/0076328 is generally oriented to a system and a method of processing multiple-level graphics, where a higher-level component (eg, an operating system) performs computational issues intensive building a scenic graph, updating the animation parameters and reviewing the data structures of the scenic graph, at a relatively low operating speed, to switch simplified data structures and / or graphics controls to a low-level component. Because high-level processing greatly simplifies data, the low-level component may operate at a higher speed (relative to the high-level component), such as a speed corresponding to the refresh rate of the frame in the graphics subsystem, to process the data in constant output data, for the graphics subsystem. If the animation is used, instead of having the entire scene redesigned, the low-level processing can interpolate the parameter ranges as needed to get instant values ​​that, when delivered, provide a slightly changed scene, for each frame, ensuring pleasant animation.

US Patent Application 2003/0132937 describes a scenic, parameterized graph that provides variable (animated) values, as well as containers of parameterized graphs, such as drawing that program code that wishes to draw graphs (for example, an application program or a component of the operating system), which can selectively modify certain aspects of the scenic graph description, while leaving other aspects intact. The program code can also reuse the already constructed portions of the scenic graph, along with different possible parameters. As can be appreciated, the ability to easily modify the appearance of the displayed elements by parameterizing and / or reusing the existing parts of a scenic graph effectively ensures substantial gains in processing the general graph.

RO 123609 Β1

US Patent Application 2003/0076329 generally describes a hidden data storage structure 1, as well as specified mechanisms for storing visual information, through objects and data from a scenic graph. The data structure is generally associated with 3 mechanisms that intelligently control how the visual information in it is populated and used. For example, with the exception specifically required by application program 5, most of the information stored in the data structure has no external reference to it, which allows this information to be optimized or otherwise processed. As can be appreciated, this 7 ensures efficiency and resource conservation, for example, data in the cache structure (hidden memory) of data can be processed in a different format, 9 which is more compact, and / or reduces the need for subsequent, repeated processing, such as a bitmap or other post processing results. 11 While the above enhancements provide substantial benefits in graphics processing technology, it is still necessary to find a way for programs to effectively use 13 this improved graphical model, as well as other improvements, described in a manner. direct. What is needed is a direct, yet intuitive, path for programs, to obtain 15 advantages over many features and graphics processing capabilities, ensured by the improved graphics model and, thus, to obtain complex graphics, 17 in - an efficient way.

Another example of an alternative 3D scene management is described in US Patent No. 6215495 B1, Brad Grantham, 2011. An original 3D scene, described in VRML format, is created. The components of the scene (geometry, materials, lights, images, moving images and sounds) are presented, as well as the relationships between them, static or dynamic. A number of objects, which represent the basic building blocks for a scenic graph, are stored in a memory 23. Objects consist of geometry, graphical state, transformation hierarchy and audio information. Scenes in VRML format are transmitted to an API-like interface, which calls 25 different engines to modify the scenic graph. A parser contributes to this, to allow VRML files to be run on any computer. The API interface is structured as a collection of hierarchical classes, representing appearance, material, texture, text transformation, geometry, color, coordinates, sound, shape. The composition engines used are: a 29 geometric morphology engine, an interpolation engine and a writing engine. among the primitives in the geometric set, are included: set of points, set of lines, set of polygons, set of coordinates, 31 set of colors, set of texture coordinates, set of integration indices, primitives of cone and cylinder type . 33

The scenic graph is represented as an acyclic graph of nodes. The class hierarchy also includes a group of type nodes: transform node, switch node and a background for defining 35 light and fog.

The technical problem, which the invention solves, consists in the production of graphics on 37 computers, by accessing an object model of elements, in a way that allows to permanently interface with a data structure of the scenic graph. 39

The system for processing graphic information and other video information, for display on computer systems, comprises: 41

- a higher level composition and animation engine and a lower level engine, the higher level engine being instantiated on a per-application basis, and the lower level motor 43 serving requests from several applications;

- a marker language, this comprising graphic instructions, comprising a string format 45 and an object notation, the object notation comprising graphic elements from a class of graphic elements; 47

RO 123609 Β1

- a graphic object model, comprising:

a. a basic class visual object, which is a container for graphic content, which provides basic functionality, for other visual types and from which other visual types derive;

b. a container-type visual object, which is a container for visual elements and may contain other container-type visual objects;

c. a drawing object that is a container for graphic content, and

d. a class of graphic elements, the element class comprising a shape class, an image class, a video class and a Canavas class, and the element class being integrated with a general property system:

- a type converter, which is configured to convert a graphical instruction in string format to a visual object programming interface (API) object;

- a parser / translator, which is configured to:

a. interpret graphic instructions, which include direct code calls, object model code calls, and graphic instructions written using marker language,

b. access the type converter, which is configured to convert a graphic instruction in string format into a visual API object, and

c. interpret the marker code and, when interpreting the marker code, add elements from the graphic element class to a tree element;

d. a presentation system, which is configured to translate the graphic elements trees into calls to a visual API; a visual API, the visual API being configured to:

a. interface with the presentation system, interface with the parser-translator and interface with the direct code calls from the programming languages, and

b. in response to the requests of the presentation system, the translator parser creates scene objects within a scenic graph; and

c. an operable display interface to facilitate the display of graphic objects within the scenic graph.

The system according to the invention has the elements of the object model of elements correlated with the objects of the object model of the scenic graph.

In the system according to the invention, the marker includes the in-line text, which includes a string that defines a property of the element, and the translator communicates with a type converter, to convert the string into a property of the object.

In the system according to the invention, the marker includes the inline text containing the property syntax, the property syntax specifying multiple attributes of vector graphic objects.

The system according to the invention is characterized in that the inline text is identified with a reference that refers to another location in the marker.

The system according to the invention is characterized in that the inline text is identified with a reference that refers to a file.

The system according to the invention is characterized in that the in-line text is identified with a reference corresponding to a file that can be downloaded from a remote location on a network.

In the system according to the invention, the marker includes the inline text comprising the complex property syntax, corresponding to a graphical resource.

The system according to the invention is characterized in that the graphic resource describes a visual brush object, the parser / translator providing the resource level data for direct communication with the visual API layer, to create a visual paint object, which corresponds to the element described by the complex property syntax.

In the system according to the invention, the resource level data is identified by a reference that refers to another location in the marker.

RO 123609 Β1

Also, the resource level data is identified with a reference that refers to 1 file.

In the system according to the invention, the resource level data is identified by a reference which 3 refers to a file that can be downloaded from a remote location, on a network.

The system according to the invention is characterized in that one of the elements 5 of the graphic object model comprises an image element.

The system according to the invention is characterized in that one of the graphic elements 7 comprises a poly element. Also, one of the graphic elements comprises a polygon element or a trajectory element, or a line element or an ellipse element or a circle element 9.

The system according to the invention is characterized in that one of the graphic elements 11 includes at least data on the filling property and / or data on the movement property of the brush and / or data on the cutting property and / or data on the transformation property 13 and / or or effect data and / or opacity data and / or merge mode data. 15 In the system according to the invention, the translator requests the instantiation of at least one constructor, in order to create graphic objects. 17

The advantages arising from the application of the invention are mentioned below. So:

The vector graphics system can thus program at an elementary level, at which 19 each of the drawing conformations is represented as an element at the same level as the rest of the programmable elements on a page / screen, allowing interaction with the system of 21 presenters, with events and properties.

The vector graphics system also provides a mechanism for programming 23 at a resource level, whereby scenic designers can basically short-circuit the element tree and the presenter system, and program directly to the API layer of the visual, which 25 interfaces. with the data structure of the scenic graph. It provides a more efficient and easier way to get the right object, although some of the element level programmability is lost. In an implementation, if a visual brush type fill is programmed, the grammar analyzer can directly call the API layer with the resource level data, to create a corresponding visual paint object (which is also a correlation between the element object model and the object model. scenic graph). In this bistratified system, element-level vector graphics are grammatically analyzed in the created elements, which require further translation into objects, while resource-level vector graphics is grammatically analyzed and stored 33 directly, effectively. at the same time, the data of the resource level or the objects created from it can be completed by the elements and part of the element tree. For this purpose, the elements including paint elements for the visual can be called. The stage designer thus has the ability to efficiently appreciate the programmability as much as necessary. 37

Other advantages and advantages of the invention will become apparent from the following detailed description, if the drawing is linked, wherein:

FIG. 1 is a block diagram, representing a typical computer system in which the present invention may be incorporated;

FIG. 2 is a block diagram, which represents, in general, a graphics-level architecture, in which the present invention can be incorporated;

FIG. 3 is a representation of a scenic graph of visuals, as well as the associated components, for the processing of the scenic graph, such as drawing through the decoration of the graphic, to provide the graphic commands, as well as other data, according to an aspect of the present invention ; 47

RO 123609 Β1

FIG. 4 is a representation of a scenic graph of validation visuals, drawing visuals and associated drawing primitives, created in accordance with an aspect of the present invention;

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

FIG. 6 is a representation of other objects of the object model, according to an aspect of the present invention;

FIG. 7 is a diagram representing the transformation of some data of the visual, according to an aspect of the present invention;

FIG. 8A and 8B are representations of the transformations of some data of the visual on a geometric scale and, respectively, on a non-uniform scale, according to an aspect of the present invention;

FIG. 9A ... 9C are block diagrams of surface visual objects, as well as other visuals and components, according to one aspect of the present invention;

FIG. 10A and 10B are diagrams representing HWnd visual objects according to one aspect of the present invention;

FIG. 11 is a diagram, which represents a stratified visual object, in accordance with an aspect of the present invention;

FIG. 12 is a representation of the geometry classes of the object model, according to one aspect of the present invention;

FIG. 13 is a representation of a path geometry structure (PathGeometry), in accordance with an aspect of the present invention;

FIG. 14 is a representation of a scenic graph of visuals and drawing primitives, showing a graph, for example, produced by primitives, in accordance with an aspect of the present invention;

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

FIG. 16 is a representation of the given graph, which results from the data of a linear gradient brush object, in accordance with an aspect of the present invention;

FIG. 17 is a representation of the given graph, which results from the data of a brush object with radial gradient, according to an aspect of the present invention;

FIG. 18 is a representation of the given graph, which results from having various extension values, according to one aspect of the present invention;

FIG. 19 is a representation of the rendered graph, which results from having various values ​​of the plate (tile), according to one aspect of the present invention;

FIG. 20 is a flow chart which generally represents the logic for interpreting a visual, including a brush object, to generate graphics, in accordance with an aspect of the present invention;

FIG. 21 is a representation of a transformed grid and grid, which results from the data in a brush object of the visual, in accordance with an aspect of the present invention;

FIG. 22 is a representation of a transformed grid and grid, together with the rendered graph, which is drawn from a visual, in accordance with an aspect of the present invention;

FIG. 23 is a representation of a given brush object, with nine grids, according to an aspect of the present invention;

FIG. 24 is a representation of the transformed classes, of the object model, according to one aspect of the present invention.

FIG. 25 is a representation of the element classes in the element object model, in accordance with an aspect of the present invention;

RO 123609 Β1

FIG. 26 is a representation of the components, for determining the marking language code 1 to interface with the visual API layer, in accordance with an aspect of the present invention; 3

FIG. 27 is a representation of the cutting by a geometric path, in accordance with an aspect of the present invention. 5

Fig. 1 illustrates an example of a suitable computer system environment 100, on which the invention can be implemented. The environment 100 of the computing system is only an example of a suitable computing environment 7 and it is not intended to suggest any limitations, as to the purpose of use or to the functionality of the invention. No computing environment, 100, will be interpreted as having any dependency or requirement on any component or any combination of components illustrated in the typical operating environment, 100. 11

The invention is functional, together with numerous other means or configurations of general purpose or special purpose computing systems. Examples of well-known computing systems, media and / or configurations, which may be suitable for use in conjunction with the invention, include, but are not limited to, personal computers, server computers, hand-held devices or laptops, devices tablet type, multiprocessor systems, microprocessor based systems, set top boxes, electronic products, programmable, consumer, network PCs, minicomputers, mainframe computers, distributed computing media, which include any of the above systems or devices, as well as 19 or so.

The invention may be described in the general context of computer executable instructions, such as program modules that are executed by a computer. Generally, the program modules include routines, programs, objects, components, data structures, and so on, 23 that execute certain sets of instructions (tasks) or that implement certain abstract types of data. The invention can also be practiced in distributed computing environments, 25 where the works are performed by means of remote processing devices, which are linked through a communications network. In a distributed computing environment, the program modules can be located on both local and remote computer storage media, including memory storage devices. 29 in connection with FIG. 1, a typical system for implementing the invention includes a general purpose computing device, in the form of a computer 110. The components of the computer 31 110 may include, but are not limited to, a processing unit 120, a system memory 130, such as and a system bus 121, which connects various components of the system 33 including system memory, to the processing unit 120. System bus 121 can be any of the various types of bus structures that include a 35 memory bus or a memory controller, a peripheral bus, as well as a local bus that uses any of the variety of bus architectures. For example, and not as a limitation, 37 such architectures include the ISA (Industry Standard Architecture) bus, the MCA (Micro Channel Architecture) bus, 39 the EISA (Enhanced ISA - ISA) bus. , the local VESA (Video Electronics Standards Association) local bus, AGP 41 (Accelerated Graphics Port - Accelerated Graphics Port) bus, as well as the PCI (Peripheral Component Interconnect) bus, also known as the 43 Mezzanine bus.

Computer 110 typically includes a variety of readable media using the computer 45. Computer-readable media can be any available media, which can be accessed by computer 110, and include both volatile and non-volatile environments, as well as movable and removable media 47. By way of example and not limitation, readable media with help

RO 123609 Β1 of the computer may contain computer storage media and communication media. Computer storage media include both volatile and non-volatile media, as well as mobile and removable media, implemented in any method or technology for storing information, such as computer-readable instructions, data structures, program modules, or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technologies, CD-ROMs, DVDs (Digital Versatile Digital Diskdisc versatile) or other optical disk storage, cassettes magnetic tape, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to store desired information and can be accessed by computer 110. The media typically includes computer-readable instructions, data structures, program modules, or other data from a modulated data signal, such as a carrier wave or other transport mechanism, and includes any media. information delivery. The term modulated data signal means a signal that has one or more of its characteristics, set or modified in such a manner as to encode the information in the signal. By way of example and not limitation, communication media includes wired environments, such as a wired or wired connection, as well as wireless (wireless) environments, such as acoustic, RF, infrared, and other wireless environments. . The combinations of any of the above must also be included in the scope of computer-readable environments.

System memory 130 includes computer storage media, in the form of volatile memory and / or non-volatile memory, such as ROM 131 (Read Only Memory) and RAM 132 (Random Access Memory). with random access). A BIOS (Basic Input / Output System) 133, containing basic routines that help transfer information between the elements inside the computer 110, such as the ones during start-up, is in a characteristic mode stored in ROM 131. RAM 132 typically contains data and / or program modules that are immediately and / or necessarily accessible, being functional at processing unit 120. By way of example and no limitation, fig. 1 illustrates operating system 134, application programs 135, other program modules 136 and program data 137.

Computer 110 may also include other movable / removable, volatile / non-volatile storage media in the computer. Only by way of example, fig. 1 illustrates a hard disk drive 141, which reads or writes on removable, non-volatile magnetic media, a magnetic disk drive 151, which reads or writes to a movable, non-volatile magnetic disk 152, as well as an optical disk drive 155, which reads or write to a movable, non-volatile optical disk 156, such as a CD-ROM or other optical media. Other movable / removable, volatile / non-volatile computer storage media that can be used in the typical operating environment include, but are not limited to, magnetic tape cassettes, flash memory cards, versatile digital discs, digital video tape , Semiconductor RAM, semiconductor ROM, and the like. The hard disk drive 141 is typically connected to the system bus 121 through a removable memory interface, such as the interface 140, and the magnetic disk drive 151 and the optical disk drive 155 are typically connected. at system bus 121, via a mobile memory interface, such as interface 150.

The units and associated media, stored in the computer, discussed above and illustrated in fig. 1, ensures the storage of readable instructions using the computer, the data structures, the program modules, as well as other data for the computer 110. in fig. 1, for example, the hard disk drive 141 is illustrated as storing the operating system 144, the application programs 145, the other program modules 146, as well as the program data 147. It should be noted that

EN 123609 aceste1 these components may either be the same or different from the operating system 134, the 1 application programs 135, the other program modules 136 and the program data 137.

Operating system 144, application programs 145, other program modules 146, as well as 3 and program data 147, have indicated different numbers here, to illustrate that, at a minimum, they are different copies. A user can enter commands and information into the computer5

110, via input devices, such as a tablet (electronic digitizer) 164, a microphone 163, a keyboard 162 and a pointing device 161, commonly referred to as a mouse, 7 trackball or touch pad. Other input devices (not shown) may include a joystick, game pad, asymmetrical satellite dish reflector, scanner or the like. 9 These, as well as other input devices, are often connected to the processing unit 120, via a user input interface 160, which is coupled to the system bus, but 11 which can be connected by another interface or other bus structures. , such as a parallel port, gaming port, or universal serial bus (USB). A monitor 191 or another 13 type of display devices is also connected to the system bus 121, via an interface, such as a video interface 190. The monitor 191 may also be integrated, 15 together with a touch-screen panel 193 or something similar, which can introduce a digitized input, such as handwriting, into the computer system 110, via an interface, such as 17, such as the touch-screen interface 192. It should be noted that the monitor and / or the touch-screen panel may be physically coupled to a housing in which the computing device 110 is incorporated, such as in a personal tablet computer, to which the touch screen panel 193 serves, in essence, as the tablet 164. In addition, computers such as calculating device 21, 110 may also include other peripheral output devices, such as speakers 195 and printer 196, which may be connected, via an interface 194, by peripherals. of 23 outputs or the like.

Computer 110 can operate in a network environment, using logical connections, 25 to one or more remote computers, such as computer 180, remote. The remote computer 180 may be a personal computer, a server, a router, a network PC 27, a peer device or other common network nodes, and typically includes many or all of the elements described above. , referring to computer 110, although, only 29 a memory storage device 181 has been illustrated in FIG. 1. The logical connections, represented in fig. 1, include a LAN (Local Area Network) 171 and a WAN 31 (Wide Area Network - 173), but may also include other networks.

Such network connection environments are common in offices, on computer networks on large area 33 of enterprises, on intranets and on the Internet.

When used in a LAN network environment, computer 110 is connected to LAN 171 through a network interface or adapter 170. When used in a WAN network environment, computer 110 typically includes 37 a modem 172 or other means for establishing communications over WAN 173, such as the Internet. The modem 172, which can be internal or external, can be connected, at the bus of 39 system 121, through the user input interface 160 or by another suitable mechanism. In a networked connection environment, the described program modules, relating to the computer 110 or 41 portions thereof, can be stored in a remote storage device in memory. By way of example and not limitation, FIG. 1 illustrates remote application programs 185, 43 as residents on the memory device 181. It will be appreciated that the respective network connections shown are typical, and other means of establishing communication link 45 between computers may be used.

RO 123609 Β1

One aspect of the present invention is generally directed to enable the program code, such as an application or component of the operating system, to communicate the drawing instructions as well as other information (for example, image bitmaps). ) to the graphics components, to deliver the graphic output on the system display. For this purpose, the present invention provides a marking language, together with a set of conformational elements, as well as other elements, provides a grouping and composition system, and integration with a general property system of an object model. , to allow programs to populate a scenic graph with data structures, drawing primitives (commands), and other graph data. When processed, the scenic graph results in graphic displayed on the screen.

Fig. 2 represents a general architecture, stratified 200, in which the present invention can be implemented. As shown in FIG. 2, program code 202 (for example, an application program or an operating system component or the like) can be developed to produce graphical data on one or more different paths, including by forming image 204, through the elements of vector graphics 206, and / or by function calls / methods placed directly at a layer 212, of the visual application programming interface (API). The direct interaction with the API layer is described further, in the dependent patent application, mentioned above, entitled Visual and scenic graphical interfaces.

In general, image training 204 provides program code 202 with a mechanism for uploading, editing and saving images, such as 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 an aspect of the present invention, the vector graphics elements 206 provide another way of drawing graphics, compatible with the rest of the object model (as described below). Vector graphics elements 206 can be created through a markup language, which processes a system 208, of elements / properties, and a presentation system 210 to make specific calls to the visual API layer, 212. As described below , in connection with FIG. 26, in general, the elements 206 of vector graphics are analyzed, grammatically, in objects of the object model from which a scenic graph is drawn, which can be provided to the decoration graph through a level of elements, through the system 208 of elements / properties and through the presentation system 210, or can be provided in a more efficient way at a resource level, as also described below.

In one implementation, the architecture 200, of the graphics layer, includes a high-level 214 composition and animation engine, which includes or is associated, on the other hand, with a hidden memory data structure 216. The 216 hidden memory data structure contains a scenic graph, comprising hierarchically arranged objects, which are managed according to a defined object model, as described below. In general, the API layer 212 of the visuals provides program code 202 (as well as the presentation system 210) with an interface for structure 216, of hidden memory data, including the ability to create objects, open and close objects, for provide them with data, and so on. In other words, the top-level composition and animation engine 214 displays a unified media API layer, 212, through which developers can express their intentions regarding graphics and environments, to display graphics information, and provide a fundamental platform with enough information, so the platform can optimize the use of hardware for program code. For example, the fundamental platform will be responsible for hidden memory, resource negotiation and media integration.

In an implementation, the top-level composition and animation engine 214 passes 1 a set of instructions and possible other data (for example, bitmap pointers), to a composition and animation engine 218. fast, lower level. As used herein, 3 terms of upper and lower level are similar to those used in other computing scenarios, where, in general, the lower the software component compared to the 5 components. The higher the level, the closer that component to the hardware is. Thus, for example, the graphics information, sent from the higher level composition and animation engine 214, can be received to the lower level composition, animation and 218 engine, where the information is used to send the graphic data. in the graphics subsystem, 9 including hardware 222.

The higher level composition and animation engine 214, together with 11 program code 202, constructs a decoration graph, to represent a graphic decoration, provided by program code 202. For example, each element that is drawn can be loaded, 13 together with the drawing instructions, which the system can hide in the data structure 216, of the scenic graph. As will be described below, there are a number of different paths, 15 for specifying this data structure 216, as well as what is drawn. In addition, the higher-level composition and animation engine 214 integrates, with systems 220, timing and animation, to ensure declarative (or other) control of the animation (for example, animation intervals), as well as control. timing. It should be noted that the 19 animation system allows animated values, to be passed, essentially, anywhere in the system, being included, for example, at the properties level of the elements, 208, inside the layer 212, API, of the 21 visuals, as well. and any other resources. The timing system is exposed to the levels of elements and visuals. 2. 3

The lower level composition and animation 218 engine manages the composition, animation and remitting of the scene, which is then provided in subsystem 222, for graphics. The lower level 25 218 engine makes up the remittances for multiple application scenes, and together with the remit components, implements the actual remittance, of the graphics, on the screen. It should be noted, however, that, from time to time, it may be necessary and / or advantageous for some of the remittances to be made at higher levels. For example, while the service of the lower layers requires multiple applications, the upper layers are instantiated on a per-application basis, through which it is possible, through the mechanisms 204, to form images (imaging), to carry out remittances. consummate time-outs or application-specific remittances, at higher levels, and pass references to a bitmap, at lower levels. 33

As described below, the remittance model is divided between elements 206, high-level, command-based vector graphics, and low-level objects, created by 35 through the visual API layer, 212, used in structure 216, by data, of the scenic graph. This ensures a significant value of the correlation between the high-level elements of the present invention, and the low-level objects. The following describes an implementation of the object model of the scenic graph. 39

Fig. 3 and 4 present model scenic graphs, 300, and 400, respectively, which include a basic object mentioned as a visual. Generally, a visual contains an object that represents a 41 virtual surface to the user and has a visual representation on the display. As shown in FIG. 5, a basic class visual provides the basic functionality, for other types of visual 43, that is, the visual class 500, is an abstract basic class, from which the types of the visual are derived (for example, 501-506). 45

RO 123609 Β1

As shown in FIG. 3, a visual 302, peak (or root) level, is connected to an object 304, visual manager, which also has a relationship (for example, on a convenient pretext) with a window (HWnd) 306 or a similar unit, to which the graph data is extracted for the program code. The visual manager (VisualManager) 304 manages the drawing of the top level visual (as well as the children of this visual) at this window 306. Fig. 6 presents the VisualManager as one of a set of other 620 objects, from the object model of the graphics system described herein.

In order to draw, the visual manager, 304, processes (for example, scans or transmits) the scenic graph, as planned by a dispatcher 308, and provides graphical instructions, as well as other data, at component 218, level low (fig. 2), for its corresponding window, 306, as generally described in patent applications US 2003/0076328, US 2003/0132937 and US 2003/0076329. The processing of the scenic graph will usually be planned by the dispatcher 308, at a rate that is relatively lower than the refresh rate of component 218, lower level and / or subsystem 222, of the graph. Fig. 3 shows a number of visual children 310-315, arranged hierarchically below visual 302, at the peak (root) level, some of which are represented as populated by drawing contexts 316 and 317 (presented as boxes with dashed lines) , to represent their temporary nature) with lists of associated instructions, 318, and 319, respectively, containing, for example, drawing primitives, as well as other visuals. The visuals may also contain other property information, as shown in the following visual example class:

public abstract class Visual: VisualComponent {

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 HitTestResult HitTest (Point point); public bool IsDescendant (Visual visual);

public static Point TransformToDescendant (

Visual reference,

Descending visual, Point point);

public static Point TransformFromDescendant (Visual reference,

Descending visual, Point point);

public Rect CalculateBounds (); // Loose bounds public Rect CalculateTightBounds (); // public bool HitTestable {get; set; } public bool HitTestlgnoreChildren {get; set; } public bool HitTestFinal {get; set; }}

RO 123609 Β1

A transformation set by the property of the transform defines the 1-coordinate system for the subgroup of a visual. The coordinate system, before the transformation, is called the pre-transformation coordinate system, the one after the transformation is called 3 post-transformation coordinate system, that is, a visual with a transformation is equivalent to a visual with a transformation node, as a parent. . Fig. 7 it generally provides for an example of transformation, which identifies the systems of pre-transformation and post-transformation coordinates, regarding a visual. To obtain or set the transformation of a visual, 7 the Transform property can be used.

It should be noted that the coordinate transforms can be applied, evenly, to any, 9 even if they were in a bitmap. Note that this does not mean that transformations are always used in bitmaps, but what is remitted is equally affected by the transforms. 11 For example, if the user draws a circle with a round shooter, which is one inch wide (inch) and then applies a graduated scale on the X direction in the two directions, to this 13 circle, the shooter will be two width inch left and right, and only one inch wide up and down. This is sometimes referred to as a composition or bitmap transform (as opposed to a skeleton or geometry scale that only affects geometry). Fig. 8A is a representation of the scaling transformation, with an untransformed image 800, which appears on the left, 17 as well as a transformed image 802, with a non-uniform scale, which appears on the right. Fig. 8B is a representation of the scaling transformation, with the untransformed image 800, which appears on the left 19, as well as a transformed image 804, with a geometric scaling that appears on the right.

Considering the coordinate transformation of a visual, TransformToDescendant 21 (transforms to descendant) transforms a point from the reference visual to a descending visual. The point is transformed from the post-transformation coordinate space of the reference visual 23, into the post-transformation coordinate space of the descending visual. TransformFromDescendant (transform from descendant) transforms a point in the descending visual 25, starting with the parent chain, into the reference visual. The point is transformed from the post-transformation coordinate space of the descending visual, into the coordinate space 27 of the post-transformation of the reference visual. The CalculateBounds method returns the box for delimiting the contents of the Visual from the 29 post-transformation coordinate space. It should be noted that there may be an alternative version of the API, where more specific specifications are allowed, about how the transform from a visual is inter- preted during a coordinate transformation. For example, the transformed from the reference and descending visuals may or may not be taken into consideration. In this alternative, there are 33 thus four alternatives, for example, the coordinates can be transformed from pre-transformation space into pre-transformation space, from pre-transformation space to post-transformation space, from post-transformation space to pre-transformation space , and from post-transformation space to post-transformation space. The same concept applies to target hit testing, for example, target hit testing can be started at the coordinate space of the pre-transformation or post-transform transforms, and the results of the target hit test might be in space. of pre-transformation or post-transformation coordinates. 41

Cutting property sets (and obtains) the crop region of a visual. Any geometry (geometry class is described below, in connection with fig. 12) can be used as a cut region, and the cut region is applied in the post-transformation coordinate space. In one implementation, a reference setting for the 45-cut region is null, that is, without cut, which can be thought of as an infinite large cut-off rectangle, from (- °°, - °°) to (+ ° °, + °°). 47

RO 123609 Β1

The Opacity property obtains / sets the opacity value of a visual, so that the respective content of the visual is combined on the drawing surface, based on the opacity value and the selected merge mode. The property of BlendMode (merge mode) can be used to set (or obtain) the merge mode that is used. For example, an opacity (alpha) value can be set between 0.0 and 1.0, with the linear combination alpha set, as a setting, for example, Color = alpha * foreground color + (1.0-alpha) * background color) Other services, such as special effects properties, can be included in a visual, for example, stain, monochrome and so on.

Various services (including transform, opacity, clipping) can be introduced and removed from a drawing context, and the push / pop operations can be included as long as a pop-up call ) matches a push call. For example, PushTransform (...); PushOpacity (...); PopTransform (...); it is illegal, because before the PopTransform call, it must be called PopOpacity.

The PushTransform method introduces a transformation. The following drawing operations are performed, taking into account the transformation introduced. PopTransform removes the transformation introduced by the appropriate PushTransform call:

void PushTransform (Transform transform);

void PushTransform (Matrix matrix);

void PopTransform ();.

Similarly, the PushOpacity method introduces an opacity value. The following drawing operations are rendered on a temporary surface, together with the specified amount of opacity and then combined in decoration. PopOpacity extracts the opacity entered by the appropriate PushOpacity call void PushOpacity (float opacity);

void PushOpacity (NumberAnimationBase opacity);

void PopOpacity ();.

The PushClip method introduces a cutting geometry. The following drawing operations are cut to geometry. The cut is applied to the post transform space. PopCIip extracts the cut region introduced by the appropriate PushClip call:

void PushClip (clip geometry);

void PopCIip ();.

Note that the input operations can be arbitrarily included in each other, as long as the removal operations are combined with an introduction. For example, the following applies:

PushTransform (...);

DrawLine (...);

PushClip (...);

DrawLine (...);

PopCIip ();

PushTransform (...);

DrawRect (...);

PopTransform ();

PopTransform ();

RO 123609 Β1

Target touch testing is performed in the post-trans-1 coordinate space, and the return of an identity of each visually testable upon reaching the target, ie the target is reached, for example, when a shooter or mouse click is detected . An alternative 3 version of the interface can allow, for the target hit testing, the start at the post-transformation coordinate space, visually, where the target 5 hit test is started. The visuals that are targeted are returned in the first order, from right to left. Target touch testing can be controlled with various flags including 7 HitTestable, which determines whether the visual is testable from the target (the reference is true), and the HitTestFinal, which determines whether the hit test target 9 stops when the visual is targeted, that is, if a Visual is targeted, and the HitTestFinal property of the visual is true, the test upon reaching the target is interrupted and the results collected at this point are returned (the reference is false). Another indicator is HitTestlgnoreChildren, which determines whether the children of a visual should be considered, 13 when the target hit test is performed on a visual (the reference is false).

A ProxyVisual is a visual that can be added more than once to the stage graph. 15 Because any visual that is referred to by a ProxyVisual can be reached through multiple root paths, read services (TransformToDescendent, TransformFromDescendent and 17

HitTest) does not work with a ProxyVisual. In essence, there is a canonical path from any visual to the root of the visual tree, and this path does not include any ProxyVisual. 19

As shown in FIG. 5, the various types of visuals are defined in object mode, including container visuals (ContainerVisual) 501, drawing visuals 21 (DrawingVisual) 502, validation visuals (ValidationVisual) 503, surface visuals (SurfaceVisual) 504 and visuals Hwnd ( HwndVisual) 505. The following table describes 23 model methods of a visual drawing:

public class DrawingVisual: Visual {public DrawingVisual ();

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

}

A DrawingVisual is a container for graphic content (for example, lines, text, images and so on). Note that it is possible to add a Visual to a 33 DrawingVisual, but in some implementations, this is not allowed. DrawingVisual 502 includes an Open method, which returns an IdrawingContext that can be used to populate DrawingVisual, for example, with other visuals and drawing primitives, as described below. For an implementation, for various reasons, described, 37 below, a DrawingVisual can only be opened once, to populate its drawing context; in other words, such a DrawingVisual is invariable. 39

Once the DrawingVisual has been populated, it is closed, using a Close method, for example in the drawing context. It should be noted that an Open call 41 can delete any content (children) of a visual, however at an alternative implementation, an Append method is provided, to open a current visual, in a manner 43 which is attached to this visual. In other words, an OpenForAppend call (open for attachment) works the same as Open, except that DrawingVisual's current content 45 is not deleted at the time of opening.

RO 123609 Β1

The following is an example of how a drawing context is used to populate a visual:

ContainerVisual cv1 = new ContainerVisual ();

DrawingVisual dv1 = new DrawingVisual ();

// Opens a drawing context

Context II will be automatically closed when // exits the usage block.

It will also replace / / any content that might already be // in you1.

using (IDrawingContext dc = dv1.Open ()) {

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

} // Adds you to the cv1 cv1 child collection. Children. Add (dv1);

// Add another arbitrary visual to cv1 cv1. Children. Add (someOtherVisual);

// Creates another DrawingVisual

DrawingVisual dv2 = new DrawingVisual ();

using (IDrawingContext dc = dv2. Open ()) {

// This sets up a new coordinate system // where anything is twice as large as your PushTransform (new Scale (2.0, 2.0));

// This line is drawn in the new scaled // coordinate system.

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

// It returns to the original coordinate system.

your PopTransform ();

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

} // Adds you to the cv1 child collection;

CV1. Children. Add (dv2);

In general, a ValidationVisual (visual validation) 503 is conceptually similar to a DrawingVisual, except that ValidationVisual is populated when the system requires it to be completed, instead of the fact that the program code requires to populate it. For example, as described in U.S. Patent Application 2003/0076329, the high-level 214 composition and animation engine (Fig. 2) may

EN 123609 Β1 invalidates scenic graph data, because resources are needed, such as when a 1 part of the decoration graph is not visible. For example, if some portions are scrolled off the display, they are cut, and so on. If later, the 3 invalidated data of the scenic graph is required, the program code 202, called, will be recalled to redesign (validate) the invalidated portion of the scenic graph. In this sense, a typical usage scenario is 5 for a program code, to subclass ValidationVisual and to override the OnValidate method. When the system calls the OnValidate method, a drawing context is introduced, and the program using the drawing context repopulates the ValidationVisual. 9

The example below shows a way to implement a single validation visual (ValidationVisual), for example, one that draws a line with a certain color. The color of line 11 can be changed by calling SetColor (set the color). To force ValidationVisual update, SetColor calls Invalidate to force 13 graphics subsystem to revalidate ValidationVisual:

public class MyValidationVisual: ValidationVisual {

public override void Onvalidate (IDrawingContext dc) {

dc. DrawLine (m_color, ...),;

} public void SetColor (Color newColor) {

m_color = color;

Invalidate (); // Forces a redesign of a ValidationVisual // to reflect the color change.

} private Color m_color}

This example shows how to use ValidationVisual:

MyValidationVisual myVV = new MyValidationVisual ();

container. Children. Add (myVV);

myVV. SetColor (new Color (...));

Fig. 4 shows a scenic graph 400, as an example in which ContainerVisuals and 41 DrawingVisuals are specified in a scenic graph and have associated data in the form of drawing primitives, for example, according to the drawing contexts. 43 ContainerVisual is a container for Visuals, and ContainerVisuals can be included in one another. The children of a Visual Container can be handled with a VisualCollection (collection of 45 visuals), returned from a Children property of the VisualContainer. The order

RO 123609 Β1

The visuals in the VisualCollection determine in what order the visuals are delivered, that is, the visuals are delivered from the lowest index to the highest index, back to front (painting order). For example, with the help of specific parameters, along with three drawing visuals representing red, green and blue rectangles, hierarchically below a container view, the following code would result from drawing the three rectangles (right and down translation), a red rectangle in the back, a green rectangle in the middle and a blue rectangle in the front:

VisualCollection vc = m_cv. Children;

vc. Add (new vc. Add (new vc. Add {new

DrawingVisual (

DrawingVisual (

DrawingVisual (for (int i = 0; i <vc. Count; i ++)

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

v.Transform = Transform.CreateTranslation (i IDrawingContext dc = v.Open (); dc.DrawRectangle (new Brush (colors [i]), null, new Point2D (0, 0), new Point2D (100.0f, 100.0f) )

v. Close (dc);

20.Of, i * 20f);

As shown in FIG. 5, another type of visual object is a SurfaceVisual 504. generally, as shown in FIG. 3, an object 315 of the SurfaceVisual completes a surface of the memory (bitmap) 322, which the program code 202 (fig. 2) can access. The client's program code 202 may supply its own surface memory or it may require that the memory be allocated by the surface object.

Program code 202 has the option to open a SurfaceVisual and get a drawing context 323, in which program code 202 can write data 324 pixels or something similar and directly place these pixels on the surface. This is shown in FIG. 3, by the dashed line between the surface object 322, the drawing context 323 (presented as a box with dashed lines, to represent its temporary nature) and the pixel data 324.

Program code 202 also has an option to create an administrator 330, of the visual surface and to associate a subgraph 332, of the visual, with the SurfaceVisual 315. This option is represented in fig. 3, through the dashed line between the surface object 322 and the manager 330, of the surface visual. It should be noted that the subgraph 332, of the visual, may also fit other surface visuals, as also shown in FIG. 3. The manager 330, of the visual surface (also presented as a type of other objects in the set 620, of the figure 6), goes through subgroup 332, of the visual, to update the bitmap 322 of the SurfaceVisual. Next, it should be noted that this scroll

RO 123609 Β1 is planned by dispatcher 308, and for efficiency, it can be stopped to control how often this bitmap 32 is updated. Manager 330, of the visual surface, does not have to go through subgroup 322, of the visual, of each given and / or at the same speed with which 3 manager 302, of the top level visuals, goes through the rest of the scenic graph.

Considering surfaces, as described below, in relation to 5 fig. 9A - 9C, in general, the graphics model allows, in this way, the combination of a set of visuals on a surface allows the immediate and immediate remittance of vector and bitmap primitives 7 on a surface, allows to combine a surface on desktop or another surface, and allows surface control, from a list of surfaces, which is used to combine 9 or draw inside it. A list of surfaces is defined as a collection of one or more physical memory (system or video) frames (or frames / buffers), 11 used to store combinations of visuals or graphics, or both. One of the surfaces in the surface list can be set as a current 13-back buffer, where drawing and / or combining is performed, and one of the surfaces in the surface list is set as a current primary buffer or as a front buffer. , which is used for 15 to combine with another submission target.

Surfaces can be used in several ways. By way of example, FIG. 9A shows the cornering of a surface. in FIG. 9A, an object 900, of the surface visual manager, connects a list 902, of surfaces, as a referral target for a 904 tree, of visuals. For the duration of each combination cycle, the visuals are combined on the surface of the surface list, which currently serves as an active back buffer for the surface list. The surface, 21 which is combined with these, may include a surface owned by the client / engine 214, of high level combination (fig. 2), for the combination scenarios during the process, may 23 include a surface owned by the low-level 218 engine, for the scenarios where the client does not need bits, but the low-level 218 engine has 25 need these, to combine the surface from another remit target or from a cross process surface, for scenarios where the client needs access to 27 surface bits, but the low level combination 218 engine, it also needs the surface for another combination unit. 29

The combination is controlled by a timer service, which is attached to VisualManager (the visual manager). An example timer service is a manual 31 mode, which should be used as in the example below:

// create a manual timer service and attach a visual manager TimingService timingService = new ManualTimingService (visualManager);

// combines the visual tree with the current back buffer of the VisualManager surface. Render ();

foreach (Tick tick in timingService) {

// advances the buffer back to the next surfaceList frame. NextFrame ();

// advances the duration of the timingService visual tree. Tick ​​(tick);

// combines the visual tree with the current back buffer of the VisualManager surface. Render ();

}

RO 123609 Β1

Another way to use a surface is to immediately refer to a surface through a context. Attaching a list of surfaces to a visual (a visual of the surface) allows to immediately refer to the surface in the surface list, which currently serves as an active back buffer, for the surface list. This remittance is performed by obtaining a drawing context from the surface visual and by executing the drawing commands on this context, as described above. It should be noted that obtaining a drawing context blocks the surface, so that other combining operations cannot be performed on it. Each drawing command is executed immediately, and vectors and other surfaces can be drawn (mixed) on the surface. However, other visuals cannot be drawn on the surface, but instead, they can be combined on the surface by associating it with a visual manager, as described previously (for example, in Fig. 9A).

// attaches a list of surfaces to a visual

SurfaceVisual surfaceVisual = new SurfaceVisual (surfaceList);

// validates the mode-immediate (and blocks) remittance to the back buffer surface

BaseDrawingContext dc = surfaceVisual. Open ();

// draws a line (immediately) to the current back buffer of the dc surface. DrawLine (pen, startPoint, endPoint);

// unlock the surface - I did it with the immediate-way surfaceVisual remit. Close (dc);

Another use for surfaces is when a surface is combined with another remit target. In this sense, once the surface list is attached to a surface visual, then the surface can be attached to the visual tree, as a node, and the surface from the surface list, which currently serves as a primary or front buffer, can be combined with another surface or desktop. This is illustrated in FIG. 9B and in the example below:

// attaches a list of surfaces to a visual SurfaceVisual surfaceVisual = new SurfaceVisual (surfaceList);

// Adds surfaceVisual to a visual tree, to be combined with another rootVisual remit target. Add (surfaceVisual);

The direct composition at / from a surface is represented in fig. 9C, where the possibilities described above are combined so that, respectively, the combination at the back buffer surface, a surface list, and the combination from the front buffer surface, a surface list (for example, at the desktop ) is happening simultaneously. It should be noted that in order to eliminate the unwanted video effect, known as tearing, the list of surfaces must have at least two surfaces, one surface of the front buffer and one of the back buffer. A surface used as in FIG. 9C is owned as it seems by the low-level 218 engine, or is a cross-process area, to make the low-218 engine combination, respectively, perform better.

RO 123609 Β1

The surfaces are constructed as independent objects, as shown by 1 examples below of the builders:

public class Surface {

// creates and allocates an empty surface without initial public data Surface (int width, int height, int dpi,

PixelFormat pixelFormat,

SurfaceFlags flags // creates a surface, using the publicly available memory Surface (int width, int height, int dpi,

PixelFormat pixelFormat,

IntPtr pixels, // surface managed memory

Int stride // // create from a source (ie Clone - clone) public Surface (Surface sourceSurface, SurfaceFlags flags) // Create (Create) from File or from public URL Surface (String filename,

SurfaceFlags flags // // Creates from public Stream (chain) Surface (System. IO. Stream stream, SurfaceFlags flags) // Creates from HBITMAP (which cannot be selected in an HDC) public Surface (HBITMAP hbitmap, HPALETTE hPalette) / / Create from HICON public Surface (HICON hicon) // read-only properties public Int Width {get; } public Int Height {get; } public Int Dpi {get; } public PixelFormat Format {get; } public int Stride {get; } public IntPtr Buffer {get; }}

RO 123609 Β1 public class SurfaceList {

// Creates a list of blank surfaces (no initial data).

public SurfaceList (int width, int height, int dpi,

PixelFormat pixelFormat, you're numSurfaces,

SurfaceFlags flags // Creates a SurfaceList (list of surfaces) that uses the // specified // All surfaces must have identical properties (w, h, // dpi, etc.).

public SurfaceList (Surface [] surfaces) // modifies the front buffer with the first row back buffer public Flip () // advances the buffer back to the next surface public Next () public int FrontBufferlndex {get; set;} public int BackBufferlndex {get; set;} public Surface GetFrontBuffer () public Surface GetBackBuffer () public Surface GetSurface (int surfacelndex)

J

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

// Creates a public surface visual SurfaceDrawingVisual (Surface surface) public SurfaceDrawingVisual (SurfaceList SurfaceList) // Creates a visual manager along with a public surface delivery target VisualManager (Surface Surface) public VisualManager (SurfaceList SurfaceList) in addition, one surface it can get data from a decoder and / or send its data to a encoder, for writing a specific file format. Surfaces can also receive / send data from / to effect interfaces. A surface can be constructed for any pixel format, from the complete set of types supported by

RO 123609 Β1 surface. However, some adjustments can be made to the specified pixel format, for example, if 1 pixel-specified format is less than 32 bits per pixel, then the format will be advanced to bits per pixel. Whenever the bits are requested from a surface of the original format, the upper 3 will be copied to a buffer of the required pixel format, which uses a format conversion filter. 5 turning to FIG. 5, already another visual is a HwndVisual 505, which places a child HWnd from Win 32, in the scenic graph. In a more particular way, the programs left 7 inheritance will still work through the WM_PAINT (or similar) method, which draws on a child HWnd (or something similar), based on previous graphics technology. To support 9 such programs in the new graphics processing model, HwndVisual allows the Hwnd to be contained in a scenic graph and to be moved as soon as the parent visual is repositioned 11, as shown in fig. 10A. As a result of limitations with existing Hwnds, however, when they are submitted, a child Hwnd can only be on the top 13 of other windows and cannot be rotated or scaled like other visuals described above. Cutting is possible, as shown in FIG. 10B, where the dashed line indicates the displayed rectangle of the HWnd 15, which is cut during the relative motion, taking into account its parent visual. 17

Other types of visuals 506 are also achievable, and the present object model is extensible, to allow others to be developed. For example, as shown in FIG. 11, a stratified visual 1110 allows an application developer to separately control information from a visual, through multiple data strings, ensuring a finer granularity of 21 commands, regarding visuals having a single data string. It should be noted that the similar granularity of the command can be achieved by having separate child-type visuals (eg, tree) 23 under a single parent visual, however this requires that the program code works with multiple visuals, respectively, which is more complicated than working with a simple layered visual, 25 which has indexes at multiple layers.

By way of example, in FIG. 11, the background data, the content data, as well as the border data 27 are contained in a single layered view, but are separated from each other, as indexed, by a layer value, for example, 0, 1, or respectively 29 2. The layers can be inserted, including attached at each end, and / or deleted, together with the stratification command (for example, from left to right, as shown), defining a 31 default command, Z, for display. It should be noted that, for security, the child's content as well as other data from a stratified visual cannot be listed. 33

Other types of visuals include container visuals and redirected visuals HWnd child, in which the content is drawn to a bitmap and embedded in a surface visual. Three-dimensional visuals allow a connection between two-dimensional and three-dimensional worlds, for example, a visualization as in a video camera is possible through a two-dimensional visual, which has a view of 37 in a three-dimensional world.

Many resource objects are invariably created once, that is, once they are created, they cannot be modified by various methods, including simplifying elements of penetration, preventing forgery by others, and simplifying interaction with elements and 41 with APIs. It should be noted that this generally simplifies the system. It should be noted, however, that it is possible to have a system where such objects are changeable, but, for example, 43 would require the administration of a subordination graph. For example, while it is possible to have a system where such objects are changeable, if the program code changed the clip setting to a Visual 45, the visual would need to be re-rendered, thus requiring a notification / recording mechanism, for example, if a new clip is 47 assigned to a video, the video itself records the clip for notifications (such as a clip modification notification). Thus in an implementation, for the sake of simplification, the resource objects 49 are invariable.

RO 123609 Β1

These resource objects can be defined, together with a constructor, which is a direct, generic way to create an object or to use an accompanying creative object, as described below. For example, to create a SolidColorBrush (brush for uniform colors), (brush objects are described below), a constructor can be used:

Brush MyBrush = new SolidColorBrush (Colors. Red);

The user can also use static brush class members to obtain a predefined set of colors.

Because invariable objects cannot be modified, to actually modify an object, the user needs to create a new object and replace the old object with it. To this end, many of the resource objects in the system can use the creator sequence, in which invariable objects are created together with a creator class, which is an accompanying class, which is changeable. The user creates an unchangeable object, to mirror the parameter set on the builder (creator), creates a new builder for that object and initializes it from the invariable object. The user then modifies the builder as needed. Once this is done, the user can build a new object, by modifying the builder and reusing it to create another invariable object. It should be noted that it is desirable to have invariable objects, along with the setting properties, and these unchangeable objects cannot be modified, but only replaced by running an event with property modification.

Thus, instead of using a constructor, to create a SolidColorBrush, as described above, a SolidColorBrushBuilder (creator of uniform color brushes) can be used:

SolidColorBrushBuilder MyBuilder = new

SolidColorBrushBuilder ();

MyBuilder. Color = Colors. Red;

Brush MyBrush = MyBuilder. ToBrush ();

Most objects that take static values ​​can also take animation objects. For example, on DrawingContext, there is a fix to DrawCircle, which takes a PointAnimationBase (indicates the animation base), for the center of the circle. In this regard, the user can specify rich animation information, at the primitive level. For resource objects, there is a collection of animation, apart from the base value. These are combined, where, if the user wants to animate the example above, the user could specify the following example line, before the brush is created:

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

It should be noted that an object with animation parameters is still invariable, because its animation parameters are static. However, when the stage graph is processed (for example, path), the significance of the animation parameters changes over time, giving the impression of non-static animated data.

As described above, visuals can be determined by popularizing their drawing contexts with various drawing primitives, including geometry (Geometry), image data (ImageData) and video data (VideoData). In addition, there is a set of resources and classes that are distributed throughout this stack. This includes Drawers, Brushes, Geometry, Transforms and Effects. The IDrawingContext context displays a set of drawing operations, which can be used to populate a DrawingVisual (visual drawing), a ValidationVisual (visual validation). ISurfaceDrawingContext context, a basic interface for drawing Idrawing,

RO 123609 Β1 of the context, can be used to populate a SurfaceVisual (visual surface). In other words, the drawing context exposes a set of drawing operations; for each drawing operation there are two methods, one that takes the constants as arguments and one that takes 3 animators as arguments.

The DrawLine method draws a line with the specific shooter, from start point 5 to end point.

public void DrawLine (Pen pen, Point start, Point end); public void DrawLine (

Bread,

PointAnimationBase start,

PointAnimationBase end);

public void DrawRoundedRectangle (

Brush brush,

Bread,

TopLeft point,

Size size, float radius);

public void DrawRoundedRectangle (

Brush brush,

Bread,

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

Brush brush,

Bread,

TopLeft point,

Point bottomRight, float rx, float ry);

public void DrawRoundedRectangle (

Brush brush,

Bread,

PointAnimationBase topLeft,

PointAnimationBase bottomRight, NumberAnimationBase radiusX, NumberAnimationBase radiusY)

The DrawRoundedRectangle method (draws a rectangle with rounded corners) draws a rectangle with rounded corners, with the specified brush and pen; brush and pen can be zero. 15

The DrawGeometry method draws a trajectory using the specified brush and pen; brush and pen can be zero. 45 public void DrawGeometry (Brush brush, Pen pen, Geometry geometry);

RO 123609 Β1

The DrawRectangle method draws a rectangle using the specified brush and pen; brush and pen can be zero.

public void DrawRectangle (Brush brush, Pen pen, Point topLeft, Size size);

public void DrawRectangle (

Brush brush,

Bread,

Point AnimationBase topLeft, SizeAnimationBase size);

The DrawSurface method draws a surface.

public void DrawSurface (Surface area, 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 graphic skeleton, without moving the count or without filling. Each geometry object is of a simple shape (LineGeometrygeometry of the line, EllipseGeometry- the geometry of the ellipse, RectangleGeometry - the geometry of the rectangle), with a single complex form (PathGeometry - the geometry of the trajectory), or with a list of GeometryList (such a list of geometries). geometrical, specified, together with a combining operation (eg, meeting, intersecting, and so on). These objects form a class hierarchy, as shown in fig. 12.

As shown in FIG. 13, PathGeometry is a collection of figure objects. Each of the figure objects is composed, in turn, of one or more Segment objects, which in fact defines the shape of the figure. A figure (figures) is a subsection of a geometry (Geometry) that defines a collection of segments. This collection of segments is a single connected series of two-dimensional objects of Segment, figures can either be of a closed form with a defined area, or only a connected series of segments (Segments) that define a curve, but do not have a closed surface. .

The surface filled in PathGeometry is defined by taking the figures, which have their Filling property set to true and applying a FilIMode (fill mode), to determine the closed area. It should be noted that the enumeration in FilIMode specifies how the intersecting surfaces of the figure (figure) objects contained in a geometry are combined to form the resulting area of ​​geometry. An alternate type rule determines whether

EN 123609 Β1 a point is inside the tarp, by drawing, in a conceptual way, a radius from that 1 point to infinity, in any direction, and then, by examining the places where a segment of the conformation crosses the radius. By starting with a count from zero and adding a 3 at each time a Segment crosses the radius from left to right and decreasing by one, each time, when a segment of the trajectory crosses the radius from right 5 to left, after counting the crossings, if the result is zero, then the point is off the trajectory. Otherwise, it is inside the trajectory. A twisted rule determines if a 7 point on the roof is in and works by drawing, conceptually, a radius, from this point to infinity, in any direction, and by counting the number of segments 9 (Segments) of the path, from the given conformation that the ray crosses. If this number is odd, the point is inside, if it is even, the point is outside. 11

As shown in FIG. 14, if the geometry is drawn (for example, a rectangle), a brush or a drawer, as described below, may be specified. in addition, the firing object also has a brush object. A brush object defines how to graphically fill a plan, and there is a class hierarchy of brush objects. It is shown in FIG. 14, through the full rectangle, 1402, which results when the visual is processed which includes the instructions and parameters for the rectangle and the brush. 17

As described below, some types of brushes (brushes, such as gradients and nine-line grids) themselves are sized. When used, size 19 for these brushes is obtained from a bounding box, for example, if GradientUnits / DestinationUnits for the brush is 21 set to ObjectBoundingBox (bounding box). object), the bounding box of the primitive is used which is drawn. If these properties are set to UserSpaceOnUse 23 (user space in use), then the coordinate space is used.

A Pen object draws a Brush along with the 25 properties for Width, LineJoin, LineCap, MiterLimit, DashArray (hatching network) and DashOffset (27 hatching deviation), as represented in the example below:

public enum System. Windows. Mediate. PenLineCap {

Butt, Round, Square}

public enum System. Windows. Mediate. PenLineJoin {

Miter, Round, Bevel}

public class System. Windows. Mediate. Pen {

// Builders public Pen (Color color, float width); public Pen (Brush brush, float width);

// public float properties [] DashArray {get; }

RO 123609 Β1 public float DashOffset {get; } public FloatAnimationCollection DashOffsetAnimations {get; } public PenLineCap LineCap {get; } public PenLineJoin LineJoin {get; } public float MiterLimit {get; } public FloatAnimationCollection MiterLimitAnimations {get; } public float Opacity {get; } public FloatAnimationCollection OpacityAnimations {get; } public Brush Brush {get; } public float Width {get; } public FloatAnimationCollection WidthAnimations {get; }}

public sealed class System. Windows. Mediate. PenBuilder: Builder {// Fields // Public Builders PenBuilder ();

public PenBuilder (Color color);

public PenBuilder (Brush brush);

public PenBuilder (Pen pen);

// public float properties [] DashArray {get; set; } public float DashOffset {get; set; } public FloatAnimationCollectionBuilder DashOffsetAnimations {get; } public PenLineCap LineCap {get; set; } public PenLineJoin LineJoin {get; set; } public float MiterLimit {get; set; } public FloatAnimationCollectionBuilder MiterLimitAnimations {get; } public float Opacity {get; set; } public FloatAnimationCollectionBuilder OpacityAnimations {get; }

RO 123609 Β1 public Brush Brush {get; set; } public float Width {get; set; } public FloatAnimationCollectionBuilder WidthAnimations {get; } // public method Pen ToPen ();

}

As mentioned above, the object model of the graph of the present invention includes a brush object model (brush), which is generally directed to the concept of covering a pixel plane. Examples of brush types are represented in the hierarchy of fig. 15, and under a basic Brush class, include SolidColorBrush 13 (unifor m brush ), GradientBrush (Image gradient brush), ImageBrush (Image brush), VisualBrush (Visual brush) (which can be assigned as a Visual (visual), such as 15 and NineGridBrush (nine-line grid brush). GradientBrush includes the objects of LinearGradient (linear gradient) and RadialGradient (radial gradient). As described above, Brush objects are invariable.

public abstract class System. Windows. Mediate. Brush {float Opacity {get; }

FloatAnimationCollection OpacityAnimations {get; }}

The following presents an example brushBuilder class: 25 public abstract class System. Windows. Mediate. BrushBuilder: Builder {public virtual Brush ToBrush ();

public override seled object Createinstance ();

{return ToBrush ();

} float Opacity {get; set; }

FloatAnimationCollectionBuilder OpacityAnimations {get; }}

It should be noted that Brush-type objects can recognize how they relate to the coordinate system, when used, and / or how they relate to the bounding box of the form they use. In general, information, such as size, can be deduced from the object the brush draws. More particularly, many types of brushes use a coordinate system to specify some of their parameters. This coordinate system can either be defined as 43

RO 123609 Β1 relative to the simple box delimiting the shape to which the brush is applied, or it may be relative to the coordinate space that is active at the time the brush is used. These are known as ObjectBoundingBox (object bounding box) and UserSpaceOnUse (user space user space) respectively.

public enum System. Windows. Mediate. BrushMappingMode {

ObjectBoundingBox,

UserSpaceOnUse,}

An SolidColorBrush object (uniform color brush) fills the identified plane with a uniform color. If there is an alpha component of the color, it is combined in a multiplicative way, together with the corresponding opacity attribute, from the base class Brush. The following shows an example object of SolidColorBrush (uniform color brush):

public sealed class System. Windows. Mediate. SolidColorBrush: Brush {

// SolidColorBrush () public builders; // initialize SolidColorBrush (Color color) on public black;

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

// public properties Color Color {get; } public lEnumerator ColorAnimations {get; }}

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

// Constructors public SolidColorBrushBuilder ();

public SolidColorBrushBuilder (Color color);

public SolidColorBrushBuilder (SolidColorBrush scp);

// public properties Color Color {get; set; } public AnimationList ColorAnimations {get; } // Method public virtual Brush ToBrush ();

}

RO 123609 Β1

GradientBrush objects or simple gradients provide 1 gradient filling and are drawn by specifying a set of gradient stops, which specify colors along several types of progress. The gradient is drawn by performing 3 linear interpolations between the ends of the gradient in an RGB color space with the contrast factor of 2.2; interpolation by other contrast factors or other color spaces (HSB, CMYK and so on) is also a viable alternative. Two types of objects in the gradient include linear and radial gradients. 7 In general, gradients are composed of a list of gradient ends. Each of these gradient ends contains a color (along with the included alpha value) and an offset 9 (color deviation). If no end of the gradient is specified, the brush is drawn as something black, evenly transparent, because no 11 brush has been specified. If only one end of the gradient is specified, the brush is drawn in a uniform color, having one of the specified colors. As with other resource classes, the 13 class with gradient ends (the example in the table below) is invariable.

public class System. Windows. Mediate. GradientStop {

public GradientStop (Color color, float offset);

public Color Color {get; } public AnimationEnumerator ColorAnimations {get; } public float Offset {get; } public AnimationEnumerator OffsetAnimations {get; }}

public class System. Windows. Mediate. GradientStopBuilder: Builder {public GradientStopBuilder ();

public GradientStopBuilder (Color color, float offset);

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

}

There is also a collection class, as started from the following example: 39 public class System. Windows. Mediate. GradientStopCollection: ICollection {public GradientStopCollection (); // clears the public list GradientStopCollection (GradientStop [] GradientStops);

public GradientStopCollection (ICollection c);

RO 123609 Β1 // lEnumerable public lEnumerator 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; } // Additional functions public GradientStop this [int index] {get; } public bool Contains (GradientStop value);

public int IndexOf (GradientStop value); // return the first public int IndexOf (GradientStop value, int startlndex);

public int IndexOf (GradientStop value, int startlndex, int count); public int LastlndexOf (GradientStop value);

public int LastlndexOf (GradientStop value, int startlndex);

public int LastlndexOf (GradientStop value, int startlndex, int count); public GradientStopCollection GetRange (int index, int count);

} public class System. Windows. Mediate. GradientStopCollectionBuilder: Builder, list {

public GradientStopCollectionBuilder ();

public GradientStopCollectionBuilder (GradientStop [] GradientStops); public GradientStopCollectionBuilder (ICollection c);

public GradientStopCollectionBuilder (GradientStopCollection GradientStops);

// lEnumerable public lEnumerator 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 list bool IsFixedSize {get {return false; }} public bool IsReadOnly {get {return false; }} public object list. this [int index] {get; set; } public int list. Add (object value);

public void Clear ();

public bool list. Contains (object value);

public int list. IndexOf (object value); // returns the first one

RO 123609 Β1 public void list. Insert (int index, object value);

public void list. Remove (object value); // transfer it to the first public void RemoveAt (int index);

// additional functions public public public public public public public public public public public public public public public public GradientStopCollectionBuilder GetRange (int index, int count);

GradientStop this [int index] {get; set; } int Add (GradientStop value); bool Contains (GradientStop value); int int int int int int void void void void void void

IndexOf (GradientStop value); // re spins on the first IndexOf (GradientStop value, int startlndex);

IndexOf (GradientStop value, int startlndex, int count); LastlndexOf (GradientStop value);

LastlndexOf (GradientStop value, int startlndex);

LastlndexOf (GradientStop value, int startlndex, int count); Insert (int index, GradientStop value);

Remove (GradientStop value); // transfer it to the first AddRange (ICollection c);

InsertRange (int index, ICollection c); RemoveRange (int index, int count); SetRange (int index, ICollection c);

// Capacity is a suggestion. An exception will be thrown if it is set to a value lower than the Count.

public int Capacity {get; set; }

As shown in the table below, the GradientSpreadMethod method 37 (gradient distribution method) specifies how the gradient should be drawn outside the specified vector or space. There are three values, including the pad (padding), where 39 edge colors (first and last) are used to fill the remaining space, to mirror, in which of the ends are repeatedly reproduced in reverse order, to fill space 41 and to repeat, in which of the ends, they are repeated in order until the space is filled:

// Overloads Builder (creator) public override object Build (); public override void ResetBuilder ();

public override void SetBuilder (Object example);

public GradientStopCollection ToGradientStopCollection (); } public enum System. Windows. Mediate. GradientSpreadMethod {

pad,

reflect,

Repeat}

RO 123609 Β1

Fig. 16 shows examples of the GradientSpreadMethod method. Each conformation has a linear gradient, going from white to gray. The uniform line represents the gradient vector.

LinearGradient (linear gradient) specifies a linear gradient brush along a vector. Individual ends specify color ends along this vector. An example is shown in the table below:

public class System. Windows. Mediate. LinearGradient: GradientBrush {

// Put a two-color gradient as well as a gradient vector // specify to fill the object the gradient is used for.

// This means ObjectBoundingBox (object bounding box) for the property of public GradientUnits (gradient units) LinearGradient (Color colors, Color color2, float angles);

public BrushMappingMode GradientUnits {get; } public Transform GradientTransform {get; } public GradientSpreadMethod SpreadMethod {get; } // PointVectorStart public gradient vector {get; } public PointAnimationCollection VectorStartAnimations {get; } public Point VectorEnd {get; } public PointAnimationCollection VectorEndAnimations {get; } // Public Gradient Ends GradientStopCollection GradientStops {get; }}

public class System. Windows. Mediate. LinearGradientBuilder:

GradientBrushBuilder {

public LinearGradientBuilder ();

public LinearGradientBuilder (Color color, Color color2, float angle); public LinearGradientBuilder (LinearGradient Ig);

// GradientUnits: The reference is the ObjectBoundingBox public BrushMappingMode GradientUnits {get; set; } // GadientTransform (gradient transform); The reference is the public identity Transform GradientTransform {get; set; } // SpreadMethod (distribution method): The reference is public Pad GradientSpreadMethod SpreadMethod {get; set; } // Gradient vector // The reference vector is (0,0) - (1,0) public Point VectorStart {get; set; } public PointAnimationCollectionBuilder VectorStartAnimations {get;

set; }

RO 123609 Β1 public PointVectorEnd {get; set; } public PointAnimationCollectionBuilder VectorEndAnimations {get; set; } // Ends public gradient void AddStop (Color color, float offset);

public GradientStopCollectionBuilder GradientStops {get; set; }}

RadialGradient (radial gradient) is similar to the linear gradient programming model. However, considering that the linear gradient has a starting point and an end point of 11, to define the gradient vector, the radial gradient has a circle, together with a focal point, to define the gradient behavior. The circle defines the end point of the gradient, 13 that is, one end of the gradient at 1.0 defines the color of the circle. The focal point defines the center of the gradient. One end of the gradient at 0.0 defines the color at the focal point. 15

Fig. 17 shows a radial gradient, which is from white to gray. The outer circle represents the gradient circle, while the point denotes the focal point. This example 17 gradient has the SpreadMethod (distribution method) set to Pad:

public class System. Windows. Mediate. RadialGradient: GradientBrush {/ / Sets a two-color gradient.

// This means ObjectBoundingBox for the // GradientUnits property with a center at (0.5, 0.5)

II a radius of the circle of 0.5 and a focal point at (0.5, 0.5) public RadialGradient (Color colors, Color color2);

public BrushMappingMode GradientUnits {get; } public Transform GradientTransform {get; } public GradientSpreadMethod SpreadMethod {get; } // Define public gradient Point CircleCenter {get; } public PointAnimationCollection CircleCenterAnimations {get; } public float CircleRadius {get; } public FloatAnimationCollection CircleRadiusAnimations {get; } public Point Focus {get; } public PointAnimationCollection FocusAnimations {get; } // Public Gradient Ends GradientStopCollection GradientStops {get; }}

public class System. Windows. Mediate. RadialGradientBuilder:

GradientBrushBuilder {

public RadialGradientBuilder ();

RO 123609 Β1 public RadialGradient (Color color, Color color2);

public RadialGradientBuilder (RadialGradient rg);

// GradientUnits: The reference is public ObjectBoundingBox BrushMappingMode GradientUnits {get; set; } // GradientTransform: The reference is the public identity Transform GradientTransform {get; set; } // SpreadMethod: The reference is public Pad GradientSpreadMethod SpreadMethod {get; set; } // Define public gradient Point CircleCenter {get; set; } // Reference: (0.5,0.5) public PointAnimationCollectionBuilder CircleCenterAnimations {get; set; } public float CircleRadius {get; set; } // Reference: 0.5 public FloatAnimationCollectionBuilder CircleRadiusAnimations {get; set; } public Point Focus {get; set; } // Reference: (0.5,0.5) public PointAnimationCollectionBuilder FocusAnimations {get; set; } // Ends public gradient void AddStop (Color color, float offset);

public GradientStopCollectionBuilder GradientStops {get; set; }}

Another brush object, represented in FIG. 15, is a Visual Brush object. Conceptually, VisuaIBrush provides a way to have a visual drawn in a repeated fashion, wrapped like tiles, as a fill. Visual painting objects also provide a mechanism for markup language to work directly with the API layer at a resource level, as described below. An example of such filling is shown in FIG. 14, by the visual brush, which completes a visual (as well as any child visual), which specifies a single circular conformation 1420, with this circular conformation filling a rectangle 1422. Thus, the VisuaIBrush object can complete a visual, to define the way how to draw this brush, which introduces a type of multiple uses, for the visual. In this way, a program can use an arbitrary metaphorical graph, to fill a surface, with a brush or a shooter. Because this is a compressed form, for storing and using arbitrary graphics, it serves a graph resource. The following shows an example object of VisuaIBrush (visual brush):

public class System. Windows. Mediate. VisuaIBrush: Brush {public VisuaIBrush (Visual v);

public BrushMappingMode DestinationUnits {get; } public BrushMappingMode ContentUnits {get; } public Transform Transform {get; }

RO 123609 Β1 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 SizeAnimationCollection SizeAnimations {get; } // Visual (the visual) public Visual Visual {get; }}

public class System. Windows. Mediate. VisuaIBrushBuilder: BrushBuilder {

public VisuaIBrushBuilder ();

public VisuaIBrushBuilder (Visual v);

public VisuaIBrushBuilder (VisuaIBrush vb);

// DestinationUnits (target units): The reference is the ObjectBoundingBox public BrushMappingMode DestinationUnits {get; set; } // ContentUnits (units of content): The reference is ObjectBoundingBox public BrushMappingMode ContentUnits {get; set; } // Transform: The reference is public Identity Transform transform {get; set; } // ViewBox: The reference is (0, 0, 0, 0) - unset and publicly ignored Rect ViewBox {get; set; } // Stretch: The reference is None - and is ignored // because the ViewBox is not publicly set Stretch Stretch {get; set; } // HorizontalAlign: The reference is Center and / / is ignored publicly HorizontalAlign HorizontalAlign {get; set; } // VerticalAlign: The reference is Center and is ignored VerticalAlign VerticalAlign {get; set; } // Origin: The reference is (0, 0) public Point Origin {get; set; } public PointAnimationCollectionBuilder OriginAnimations {get; set; } // Size: The reference is (1, 1) public Size Size {get; set; } public SizeAnimationCollectionBuilder SizeAnimations {get; set; } // Visual (reference): The reference is zero - nothing is drawn public Visual Visual {get; set; }}

RO 123609 Β1

The content of VisualBrush has no intrinsic separation surface and, indeed, describes an infinite plane. This content exists in its own coordinate space, and the space, which is filled by VisuaIBrush, is the local coordinate space at the time of application. The content space is mapped to the local space, based on the properties of ViewBox (view box), ViewPort (view port), Alignments (alignment) and Stretch (extension). The ViewBox is specified in the content space, and this rectangle is mapped to the ViewPort rectangle (as specified by the Origin and Size properties).

The ViewPort defines the location where the content will eventually be drawn, creating the basic tile cover for this Brush. If the value of DestinationUnits is UserSpaceOnUse, the Origin and Size properties are considered to be in the local space at the time of application. If, instead of DestinationUnits, is ObjectBoundingBox, then an Origin and Size are considered to be in the coordinate space, where 0.0 is the top / left corner of the object bounding box that is drawn. with the brush, and 1.1 is the bottom / right corner of the same box. For example, let's consider a filled rectangle geometry, which is drawn from 100,100 to 200,200. In such an example, if DestinationUnits is UserSpaceOnUse, an Origin of 100, 100, and a Size of 100, 100 would describe the entire surface of the content. If DestinationUnits is an ObjectBoundingBox, an Origin of 0, 0, and a Size of 1, 1 would describe the entire content surface. If Size is empty, this Brush does not return anything.

ViewBox is specified in the content space. This rectangle is transformed, to fit inside the ViewPort, as determined by the Alignment properties and the Stretch property. If there is nothing in Stretch, then no content scaling is applied. If Stretch is Filled, then the ViewBox is scaled independently on both X and Y, to be the same size as the ViewPort. If Stretch is Uniform or UniformToFill, the logic is similar, but the X and Y dimensions are evenly scaled, keeping the content aspect ratio. If Stretch is Uniform, the ViewBox is scaled to have a more compressed size equal to the size of the ViewPort. If Stretch is UniformToFill, the ViewBox is scaled to have a less compressed size equal to the size of the ViewPort. In other words, both Uniform and UniformToFill keep track of issues, but Uniform guarantees that the entire ViewBox is inside the ViewPort (the virtual part of leaving the ViewPort not covered by ViewBox), and UniformToFill guarantees that the whole ViewPort it is filled by the ViewBox (virtual parts that cause the ViewBox to be outside the ViewPort). If the ViewBox is empty, then the Stretch will not be used. It should be noted that the alignment will still appear, and it will position the ViewBox point.

Fig. 18 provides representations of a single 1800 plate, graphically, remitted, along with various extension settings, including an 800 plate, when the expansion is set to none. Plate 1802 is a representation when extension is set to Uniform, plate 1804, when extension is set to UniformToFill, and plate 1806 when extension is set to Sons.

Once the ViewPort is determined (based on DestinationUnits) and the size of the ViewBox is determined (based on Stretch), the ViewBox needs to be positioned inside the ViewPort. If the ViewBox is the same size as the ViewPort (if Stretch is the Sons or if it just happens to appear with one of Stretch's other three values), then the ViewBox is set to Origin so that it is identical. with

RO 123609 Β1

Viewport. Otherwise, Horizontal Alignment (Horizontal Alignment) and 1 Vertical Alignment (Vertical Alignment) are considered. Based on these properties, the ViewBox is aligned to both X and Y. If Horizontal Alignment is Left, then the left 3 edge of the ViewBox will be positioned to the Left (left) edge of the ViewPort. If this is Center, then the center of ViewBox will be positioned at the center of 5 ViewPort, and if it is Right, then the right edges will meet. The process is repeated for size Y. 7

If the ViewBox is (0, 0, 0, 0), it is considered unset, as ContentUnits (units of content) are taken into account. If ContentUnits are 9 UserSpaceOnUse, no scaling or lag occurs, and the content is drawn in ViewPort, without any transformation. If ContentUnits are ObjectBoundingBox, then the content line is aligned, along with ViewPort Origin, and the content is scaled by the width and height of the object bounding box. 13

When a space is filled with a VisualBrush, the content is mapped into ViewPort, as above, and cropped to ViewPort. It forms the motherboard for 15 fillings, and what remains of the space is filled based on Brush's TileMode (tile coating mode). In conclusion, if set, Brush's transform is applied - 17 it appears after all other mappings, scalars, offsets, etc.

The listing in TileMode (tile type mode) is used to describe if 19 and how a space is filled by its Brush. A Brush, which can be covered with plates, has defined a rectangle type plate, and this plate has a base location inside the space 21 which is filled. The rest of the space is filled based on the value of TileMode. Fig. 19 provides an example graph representation, along with various TileMode settings, including None 23 1900, Tile 1092, FlipX 1904, FlipY 1906, and FlipXY 1908. The top-left board of the various example graphics contains the motherboard. 25

Fig. 20 is a process for generating pixels for this brush. It should be noted that the logic described in FIG. 20 is only one possible way to implement the logic, and this should be understood by the fact that the other paths, including more efficient paths, are achievable. For example, there are probably more efficient ways of processing data, for example, 29 so that the content is not drawn for each repetition, with the tile (plate) drawn and stored hidden. However, FIG. 20 provides a direct presentation. 31 In general, each time the content of the sequence is drawn, a new coordinate system is created. The origin and lag of each repetition is specified by the 33 Origin and Size properties, as filtered through the properties of DestinationUnits and Transform. 35

A coordinate reference is set based on the property of DestinationUnits. For this purpose, if in step 2000, the property of DestinationUnits is UserSpaceOnUse, the current coordinate reference 37, since the brush was used, is the starting coordinate reference, through step 2002. If, on the other hand, in step 2004, the property is 39

ObjectBoundingBox, uses the geometry delimitation box to which this brush is applied, as represented by step 2004, to set a new 41 coordinate landmark, so that the upper left corner of the delimitation box is set to (0, 0 ), and the lower left corner of the bounding box is positioned on (1,1). In each case, 43 at step 2006, the Transform property is applied to this coordinate landmark, which basically defines a grid.45

Fig. 21 represents a Grid of VisualBrush, which is defined for the tiles of a VisualBrush. The first circle is a simple grid, and the second has a Transform47 (transformed) with a Skew (oblique) in the x direction, 47.

RO 123609 Β1

At step 2008, the visual is drawn in each cell of the grid, as shown in fig. 22, where the visual draws the specific data. If, in step 2010, a ViewBox is specified, the Visual is inserted into the grid cell, as specified by the attributes of ViewBox, Stretch, HorizontalAlign, and VerticalAlign, through step 2012. The DestinationUnits and Transform properties are used to apply the correct transform, so that the visual fits into the grid box.

If no ViewBox is specified, then a new coordinate system is established for drawing content from step 2014.

The coordinate landmark is set so that its origin is at the point of Origin, for this particular cell of the grid that is drawn.

At step 2018, a clip (cut) is applied, based on the Size property, so that this tile will not be drawn outside the cell boundaries. Origin and Size are modified appropriately, based on the property of DestinationUnits.

The coordinate system is then modified, based on the property of SourceUnits (source units). For this purpose, if at Source 2020, the property of SourceUnits is ObjectBoundingBox, the specific scalar transform is applied at step 2026, otherwise it is UserSpaceOnUse and no new transform is applied. Transform's property is applied at step 2024, and the content is drawn at step 2026.

It should be noted that if any part of the size is zero, nothing is drawn, and if Stretch is None, the transform for the ViewBox is fixed, so that one unit in the new coordinate reference is equal to one unit in the old coordinate reference. The transform becomes essentially an offset, based on the alignment attributes and the size of the ViewBox. As described above, in steps 2010 and 2012, the Stretch and alignment properties apply only if a ViewBox is specified. The ViewBox specifies a new coordinate system for the content, and the Stretch helps to specify how this content is displayed in the ViewBox. The alignment options align the ViewBox, not the content. So, for example, if the viewbox is set to 0 0 10 10 and something is drawn to -10, -10 and aligned to the top left corner, this will be off.

turning to FIG. 15, the picture brush can be thought of as a special case of VisualBrush. Even if a program can create a visual, put an image in it, and attach it to Visual Brush, the API to do so would be uncomfortable. Since there is no indispensable reference coordinate for the content, the elements of the ViewBox and ContentUnits properties no longer apply.

public class System. Windows. Mediate. ImageBrush: 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; }

RO 123609 Β1 public PointAnimationCollection OriginAnimations {get; } public Size Size {get; } public SizeAnimationCollection SizeAnimations {get; } public ImageData ImageData {get; }}

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

public ImageBrushBuilder ();

public ImageBrushBuilder (ImageData image);

public ImageBrushBuilder (ImageBrush ib);

// DestinationUnits: The reference is public ObjectBoundingBox BrushMappingMode DestinationUnits {get; set; } // Transform: The reference is the public identity Transform Transform {get; set; } // Stretch: The reference is None public Stretch Stretch {get; set; } // HorizontalAlign: The reference is public center HorizontalAlign HorizontalAlign {get; set; } // VerticalAlign: Reference is public center VerticalAlign VerticalAlign {get; set; } // Origin: The reference is (0, 0) public Point Origin {get; set; } public PointAnimationCollectionBuilder OriginAnimations {get; set; } // Size: The reference is (1,1) public Size Size {get; set; } public SizeAnimationCollectionBuilder SizeAnimations {get; set; } // ImageData (image data): Reference is zero - nothing is drawn public ImageData ImageData {get; set; }}

NineGridBrush (brush with nine grids) is very similar to lmageBrush 39 (brush for images), except that the image is deformed in size. Essentially, NineGridBrush can be thought of as a Stretch client type, to which certain parts of the 41 images expand, while others (for example, borders) do not expand. In this way, depending on what the Image Size in the ImageBrush will determine a simple scale, 43

NineGridBrush will produce an uneven scale to the desired size. Units for non-scaled areas are user units, when the brush is applied, which means 45 that ContentsUnits (if any exists for NineGridBrush) would have been set to UserUnitsOnUse. Brush's Transform property can be effectively used 47. It should be noted that the border elements are at the edge of the image.

RO 123609 Β1 for example, fig. 23 represents an image with nine grids, which is enlarged from the first moment, 2302, to the second moment, 2304, with four types of zones. As shown in FIG. 23, to maintain the same border, the areas marked with a extend horizontally, the areas marked with b extend vertically, the areas marked with c extend horizontally and vertically, and the areas marked with d do not change in size.

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

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

public BrushMappingMode DestinationUnits {get; } public Transform Transform {get; } public Point Origin {get; } public PointAnimationCollection OriginAnimations {get; } public Size Size {get; } public SizeAnimationCollection SizeAnimations {get; } public int LeftBorder {get; } public int RightBorder {get; } public int TopBorder {get; } public int BottomBorder {get; } public ImageData ImageData {get; }}

public class System. Windows. Mediate. NineGridBrushBuilder: BrushBuilder {public NineGridBrushBuilder ();

public NineGridBrushBuilder (ImageData image, int LeftBorder, int RightBorder, int TopBorder, int BottomBorder);

public NineGridBrushBuilder (NineGridBrush ngb);

// DestinationUnits: The reference is public ObjectBoundingBox BrushMappingMode DestinationUnits {get; set; } // Transform: The reference is the public identity Transform Transform {get; set; } // Origin: The reference is (0, 0) public Point Origin {get; set; } public PointAnimationCollectionBuilder OriginAnimations {get;

set; }

RO 123609 Β1 // Size: The reference is (1,1) public Size Size {get; set; } public SizeAnimationCollectionBuilder SizeAnimations {get; set; } // public public public public * Border: reference to 0 int int int int

LeftBorder {get; set; } RightBorder {get; set; } TopBorder {get; set; } BottomBorder {get; set; } // ImageData: Reference is zero - nothing is drawn public ImageData ImageData {get; set; }}

As generally described, the graphic object model of the present invention includes a Transform object model, which includes the types of transforms represented in the hierarchy of FIG. 24, under a basic Transform class. These different types of components, which complete a transform, can include TransformList, TransformTransform, RotateTransform, RotateTransform, ScaleTransform, SkewTransform, and MatrixTransform ( matrix transform). Individual properties can be animated, for example, a program developer can animate the Angle (angle) property of a RotateTransform.

Matrices for 2D calculations are represented as a 3x3 matrix. For the required transforms, only six values ​​are needed instead of a complete 3x3 matrix. These are named and defined as follows.

mOO m10 m20 mO1 m11 m21

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

mOO m01 0 [XnewCoordSys ynew CoordSys 1]. m10 m11 0 = [XoldCoordSys yold CoordSys 1] m20 m21 1

Transformers can be included in each other at any level. Whenever a new transform is applied, it is the same as its post-multiplication to the current matrix of the transform:

m002 m012 0 m001 m011 [XnewCoordSyS ynew CoordSys1] .m102 m112 0. m101 CoordSys 1] m 111 0 = [XoldCoordSys yold m202 m212 1 m201 m211

RO 123609 Β1

Most places in the API do not directly take a Matrix, but instead use the Transform class, which supports animation.

public struct System. Windows. Mediate. Matrix {// Build and set public Matrix (); // references to public identity Matrix (double mOO, double m01, double m10, double m11, double m20, double m21;

// Identity (public identity) public static readonly Matrix Identity; public void Setldentity ();

public bool Isldentity {get; } public static Matrix operator * (Matrix matrixl, Matrix matrix2); public static Point operator * (Matrix matrix, Point point);

// These functions reset the current matrix with the / / specified transform matrix.

public public public public public public public public public public public void void void void void void void void void void void void void

SetTranslation (double right, double double); SetTranslation (Size offset);

SetRotation (double angle); // grade

SetRotation (double angle, Point center); // grade SetRotationRadians (double angle);

SetRotationRadians (double angle, Point center); SetScaling (double SetScaling (double SetSkewX (double SetSkewY (double

SetSkewXRadians (double angle); SetSkewYRadians (double English);

sx, double sx, double angle); // English); // sy);

sy, Point center); degrees degrees // These functions post-multiply the current matrix

II with the specified transform public void AppIyTranslation (double dx, double dy);

public void AppIyTranslation (Size offAply);

public void AppIyRotation (double angle); // grade public void AppIyRotation (double angle, Point center); // grade public void AppIyRotationRadian (double angle);

public void AppIyRotationRadian (double angle, Point center);

public void AppIyScaling (double sx, double sy);

RO 123609 Β1 public public public public public public void void void void void void void

AppIyScaling (double left, double sy, Point center); AppIySkewX (double English); // grade AppIySkewY (double English); // grade AppIySkewXRadians (double English); AppIySkewYRadians (double English);

AppIyMatrix (Matrix matrix);

// Public investment material double Determinant {get; } public bool Islnvertible {get; } public void Invert (); // Throws ArgumentException if invertible (! Islnvertable) public static Matrix Invert (Matrix matrix);

// Individual elements public public public public public public

<td>double</td><td>M00</td><td> {</td><td>get;</td><td>set;</td>

<td>double</td><td>M01</td><td> {</td><td>get;</td><td>set;</td>

<td>double</td><td>M10</td><td> {</td><td>get;</td><td>set;</td>

<td>double</td><td>M11</td><td> {</td><td>get;</td><td>set;</td>

<td>double</td><td>M20</td><td> {</td><td>get;</td><td>set;</td>

<td>double</td><td>M21</td><td> {</td><td>get;</td><td>set;</td>

} } }

} }

} };

According to one aspect of the present invention, there is provided a markup language and an object model of the elements, to allow user programs, as well as 25 tools, to interact with the data structure 216, of the scenic graph, without requiring knowledge specific details of API 212 layer (fig. 2). Generally, a marking language for vector graphics is provided, which includes an interchange format, together with a simple format of authorization based on markers, for expressing vector graphics 29 through an object model of the elements. With this language, markup (eg HTML or XML content) can be programmed. Thereafter, to construct a scenic graph, the marking is analyzed grammatically and translated into specific objects of the visual API layer, which have been described above. At this higher level of operation, a 33-element tree, a system of properties and a system of presenters are provided to handle much of the complexity, making it accessible to scene designers, to design 35 possible complex scenes. .

In general, the vector graphics system typically provides a set of 37 conformational elements, as well as other elements, provides for integration with a general system of properties, provides a grouping and composition system, and a bistratified approximation ( element 39 and resource level), so that the user can program in a way that corresponds to the needs of flexibility and performance. In accordance with one aspect of the present invention, the model object 41 of the elements having to do with vector graphics, is in correlation with the model object of the scenic graph. In other words, the vector graphics system and the API layer of Visual 43 share a set of resources at the element object model level, for example, the Brush object is used when drawing in the Visual API, and this is, also 45 type of fill property on Shape (conformation). Thus, besides having elements that are in correlation with the objects of the scenic graph, the markup language shares a number of 47 resources of the primitives (for example, brushes, transformed, and so on), with the Visual API layer. The vector graphics system also exposes and extends the 49 animation capabilities of the Visual API layer, which is largely split between levels.

In addition, as described below, the vector graphics system can be programmed at different profiles or levels, which include an element level and a resource level. At the element level, each of the drawing conformations is represented as an element, at the same level as the rest of the programmable elements on a page / screen. This means that the respective conformations interact entirely with the presentation system, the events and the properties. At the resource level, the vector graphics system works in a pure format of resources, similar to a metafile (meta-file) of traditional graphics.

The resource level is efficient, but it has some limited support for cascading properties, for programmable events and fine-grained ones. The stage designer thus has the ability to compare efficiency with programmability as needed.

According to one aspect of the present invention, the vector graphics system, at the resource level, is also in correlation with the API layer of the visual, in which the resource level marker, from an implementation, is expressed as a Visual Brush (visual brush). If the resource marker is grammatically analyzed, a visual object is created. The visual object is set to a VisualBrush that can be used by conformations, commands, and other elements, at the element level.

Fig. 25 is a representation of a hierarchy 2500, of the class of elements. The classes of the object model of the marking language, of the present invention, are represented by shaded boxes, and include a class 2502, conformations, a class 2504, images, a video class 2506 and a class 2508, tarpaulins. The elements of the conformation class include rectangle 2510, polyline 2512, polygon 2514, path 2516, line 2518 and ellipse 2520. Note that in some implementations, a circle element cannot be present as indicated by box 2522, with dashed lines, from fig. 25, however, for the purposes of the various examples herein, the circle element 2522. will be described. Each element may include or may be associated with the filling data (property), with the movement data of the brush, with the cutting data, with the transformed data, with filter effect data as well as masking data.

As described below, the conformations correspond to the geometry that is drawn with inherited presentation properties and connected in cascade. The presentation properties are used to build the shooter and brush needed to draw the figures. In one embodiment, the figures are complete presenters, as are other control elements. However, for other implementations, a class 2508, of sheets, can be provided as a container for figures, and the figures can only be drawn if they are in a covering element. For example, to keep the figures easy, they are not allowed to have presenters attached. instead, the tarp has a presenter attached and draws the figures. The tarp elements are described below, with more details.

As also described below, the image class is more specific than a conformation and, for example, may include delimitation data, which can be complex. For example, a border may be specified as a color on the top, as a different color on the sides, with the possibility of specifying different thicknesses and setting other properties. The position, shape rotation, and scaling can be set for an image or a similar item, enclosed in a box, such as text or video. It should be noted that the image and video elements can exist and can be presented outside a cover element, and can also happen from BoxedElement (closed element in a box), for example, to get the background, borders, etc. and the filling support from this element.

RO 123609 Β1

The video element allows the video image (or similar multimedia) to be played inside a displayed element. In this way, the vector graphics system provides a markup interface to the API layer, which is undoubtedly consistent within the multimedia framework, including 3 text, 2D graphics, 3D graphics, animation, video, still images, and audio. This allows designers to learn how to work with one media, to more easily integrate another 5 media into applications and documents. The vector graphics system also gives the possibility of animating multimedia in the same way as other elements, again giving designers the ability to use multimedia, like other elements, without sacrificing yet another intrinsic uniqueness of memory, to each individual type in the media. For example, a designer can use the same 9 naming scheme for rotation, scaling, animation, drawing, composition, and other effects, from one side to the other of different media types, through which designers can easily create 11 very rich applications. , just as well allowing a very efficient remittance and composition implementation to be built below. 13

Fig. 26 is an implementation in which the marking code 2602 is interpreted by a grammatical analyzer / translator 2604. In general, the grammatical analyzer / translator 2604 15 adds elements to a tree of elements / system properties 208 (also represented in FIG. 2) and attach presenters to these elements. The presentation system 210 then takes 17 the element tree 210, together with the attached presenters, and translates the data into objects and calls the visual API layer, 212. It should be noted that not all elements need to be translated, but only those with attached presenters.

In general, an element is an object from the layer of elements that participates in the system of properties 21, in the system of events, as well as in the positioning / presentation. The grammar parser finds the tags (tags) and decides whether these tags help define a 23 element or resource object. In the special case of a VisuaIBrush, the same labels can be interpreted as elements or can also be interpreted as resource objects, depending on the context in which these labels appear, for example, depending on whether or not they appear in the complex syntax of properties. 27 according to one aspect of the present invention, the marking language provides distinct paths for describing a resource, including a single string format or complex object notation 29. For a simple string format, the grammar analyzer / translator 2604 uses a type converter, 2608, to convert a sequence into an API object, specific to the visual 31. For example, on the next line of the marker, the value of the Sons property (fill) can be converted to a brush object, using the type converter, 2608: 33 <Circle CenterX = 10 CenterY = 10 Radius = 5 Fill = Red / >

____________________________________________________________________________________ 37

As can be readily appreciated, the conversion of such a line, in line with the label-based marker 39, is done together with simple sequence of parameters, is made directly to the brush object and provides a simple way for a stage designer to add 41 conformation, as well as its features, to a scene.

However, there are times when the fill attribute is too complex to fit 43 in a single sequence. In such a situation, the complex property syntax, which can be inline within the marker, is used to set this property. For example, 45

EN 123609 Β1 the following complex property syntax fills a circle with a gradient rather than a uniform color, specifying the colors of the different ends of the gradient (which may be in the range 0 to 1):

«Circle CenterX = 10

CenterY = 10

Radius = 5>

<Circle. Fill>

<LinearGradient>

&lt;GradientStop &lt;GradientStop

Color = Red Offset = 0 />

Color-'Blue Offset = 0.33 />

«GradientStop Color-'Green Offset = 0.66 />

«GradientStop Color = Red Offset = 1.0 />

</ LinearGradient>

«/ Circle. Fill>

</ Circle>

In addition, when being present in the line within the marker, an example resource may be located elsewhere (such as in the marker or in a file, which may be local or on a remote network and which it is properly downloaded), and can be referred to by a name (for example, a text name, reference identifier, or other suitable one). In this way, a scene designer can reuse an element from the element tree, from one end to the other of a scene, including the elements described by the complex property syntax.

The grammar analyzer handles the marker in the complex property syntax, by accessing, as necessary, the type converter, 2608, and also by combining the specific parameters to the object properties, thereby handling the complexity for the scene designer. Thus, the grammar analyzer not only sets the objects, but also sets the attributes on the objects. It should be noted that the grammar analyzer actually initiates a constructor immediately to create the objects, because the objects are invariable.

Because the same remittance model is divided between the element level and the API level, many of the objects are essentially the same. This makes grammatical analysis / translation much more efficient and also allows different types of programming languages ​​(such as C # -like languages) the ability to more easily convert from a markup into its own syntax and vice versa. It should be noted that, as shown in FIG. 26, another such programming language, 2610, may add elements to the element tree 208 or may interface directly with the API layer of the visual, 212.

As shown in FIG. 26, as well as in accordance with one aspect of the present invention, the same marker 2602 can be used to program at an elementary level and at a resource level. As described above, the element level gives the decor designer complete programmability, a use of the property system that ensures succession (for example, paper-like features), and an event run (e.g. , whereby an element can have a code attached, to change its appearance, position, and so on, in response to a user input event). However, the present invention also provides a resource level mechanism, whereby scenic designers can basically short-circuit the element tree and the presentation system, and can program directly to the API layer of the visual. For many types of static figures, images and the like, where no element-level features are required, this ensures

RO 123609 Β1 a more efficient and easier way to extract the right object. For this purpose, the grammatical analyzer 1 recognizes if a visual brush type filling is present and directly calls the API layer 212, together with the resource level data 2612, to create the 3 object. In other words, as shown in FIG. 22, the element-level vector graphics obtains the grammatical analysis of the created elements, which need further translation into objects, while the resource-level vector graphics efficiently obtains the grammatical analysis and direct storage. 7

For example, the following markup is directly derived from the object model for the LinearGradient object (linear gradient) and fills an outer circle with a Visual Brush. 9 The content of this Visual Brush is defined by the internal marking. It should be noted that this syntax is commonly used to express different brushes, transformed and 11 animations:

<Circle CenterX = 10 CenterY = 10 Radius = 5> <Circle. Fill>

&lt;VisualBrush xmlns- '..

&lt;Circle &lt;Circle &lt;Circle &lt;Circle

Fill = LemonChiffon /> </VisualBrush>

</ Circle. Fill>

</ Circle>

CenterX = 0.5

CenterX = 0.6

CenterX = 0.7

CenterX = 0.8>

CenterY = 0.5

CenterY = 0.6

CenterY = 0.7

CenterY = 0.8

Radius = 0.25

Radius = 0.25

Radius = 0.25

Radius = 0.25

Fill = Blue />

Fill = Green /> Fill = Red />

It should be noted that while these objects filled with the visual brush are stored 27 effectively, the resource level data (or the objects created by it) can be supplemented with elements and a portion of the element tree, 208, as is shown in general mode 29 in FIG. 26. To this end, these visual brush resources can be named (for example, with a suitable name, reference, or other identifier) ​​and supplemented as well as 31 other resources described using complex property syntax.

Returning to an explanation of the tarp, as mentioned above in an alternative implementation, the conformations can be easily maintained, and thus can be claimed to be contained in a tarp. At this alternative implementation, if the content is delivered, it is delivered to an infinite tarpaulin, independent of the device, which has an associated coordinate system. The covering element can thus position the content in accordance with the absolute coordinates. The tarp element can optionally define a viewport, which specifies the crop, a transform, a preferred aspect ratio 39, and a mapping of the viewporf in a domain parent. If no viewport is set, the tarp element can specify only a grouping of 41 drawing primitives and can set a transform, an opacity, and other compositional attributes.

The following is an example of a marker for a sample tarp: 43 <Canvas Background = black Top = 100 Left = 100 Height = 600 Width = 800> <Rectangle Top = 600 Left = 100 Width = 100 Height = 50 Fill = red Stroke -'blue StrokeWidth = 10 />

<Line x1 = 100 y1 = 300 x2 = 300 y2 = 100 Stroke = green StrokeWidth = 5 />

</ Canvas>

RO 123609 Β1

Note that in an implementation, if the coordinates are specified without units of measure, then they are considered as logical pixels, having a 96-inch part, and in the example above, the line will be 200 pixels long. In addition to coordinates, other properties include width, horizontal and vertical height alignment, and ViewBox (rectangular straight type; reference is not fixed or is (0, 0, 0, 0), meaning that it is not no adjustment is made, and the extension and alignment properties are ignored). As described in the general mode above, with reference to FIG. 18 ... 20, other properties include the extension, which, when not specified, retains the original size, or may:

- specify a fill at which the aspect ratio is not kept, and the content is scaled, to fill the separation surfaces set by the top / left / width / height,

- specify the uniform, which scales the size evenly, until the image matches the separation surfaces set by the top / left / width / height, or

- Specify UniformToFill, which scales the size evenly, to fill the separation surfaces set by the top / left / width / height, as well as the clips as needed.

To be further correlated with the low level object model, the transform property sets a new coordinate reference for the element's children, while the cut property limits the region to which the content can be drawn on the tarp, with the predetermined trajectory of cutting, defined as a bounding box. The Zlndex property can be used to specify the remittance command for the tarp elements, included in each other, from within a panel.

The viewbox specifies a new coordinate system for the content, for example, by redefining the extent and origin of the viewport. The extension helps to specify how this content is positioned in the viewport. The value of the viewBox attribute is a list of four numbers without units of measure, <min-x>, <min-y>, <width> and <height> (height), for example separated by white and / or areas by comma, and is of type Rect (rectangular). Viewbox's rectum specifies the rectangle in the user space that is positioned on the bounding box. It works the same as inserting a scaleX and a scaleY. The extension property (if the option is other than none) provides the additional command, to keep the aspect ratio in the graph. An additional transformation is applied to the descendants of a given element to achieve the specified effect.

In the example above, the actual result of the rectangle in the marking sample above, at each extension rule, would be:

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

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

Uniform - from (100,?) To (900,?) - the new height will be

400, and will be centered based on HorizontalAlign (horizontal alignment) and VerticalAlign (vertical alignment).

UniformToFill - from (?, 100) to (?, 700) - The new width is

1200, and will again be centered on HorizontalAlign and VerticalAlign.

RO 123609 Β1

If there is a transform on the tarp, it is basically applied above (for example, to the tree) positioning in the Viewbox. It should be noted that this positioning will extend any element of a tarp, for example, boxes, text and so on, not only the formations. In addition, it is worth noting that if a viewbox is specified, the tarp no longer matches its content, but rather has a specific size. If y-width (y-width 5) and y-height (y-height) are also specified, then the extension / alignment properties are used to intersperse the viewbox to the specified width and height. 7

The elements in the object model may each have a Clip attribute applied. In some elements, particularly conformations, it is directly exposed, as a common property of 9 language running times, while in others (for example, most commands), this property is set by a DynamicProperty (dynamic property). ). 11 generally, the cutting path narrows the region to which the content can be drawn, as represented in the general way in fig. 27, in which a button from a cone 13 is shown 2702, uncut, as well as from a configuration 2704, in which a cut path is specified (where the dashed line represents the cut path). Conceptually, any part 15 of a drawing that extends outside the region bounded by the active, current clipping path is not drawn. A clipping path can be thought of as a mask, in which those pixels 17 outside the clipping path are black, along 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-19 otherwise denomination along the edge of the figure).

A clipping path is defined by an object in geometry, either in 21 lines or in a characteristic way in a section of the resource. A clipping path is used and / or completed, using the Clip property on an element, as shown in 23 following example:

<def: Resources> <Geometry def: ID = MyClip>

<Path Data -'... />

<Rectangle ... />

</ Geometry>

</ def: Resources>

<Element Clip =% resource; MyClip ... />

Note that animating a clip is similar to animating transforms: 35 <Element>

<Element. video>

<Circle ... />

<Rectangle ...>

<FloatAnimation ... />

</Rectangle> </ Element. Clip> ... children ...

</ Element>

RO 123609 Β1

A path is drawn by specifying geometry data and referral properties, such as Sons (Fill), Stroke (brush movement), and StrokeWidth (brush width of brush) on the Path element. An example marker for a path is specified as follows:

<Path Data = M 100 100 L 300 100 L 200 300 z Fill = red Stroke = blue StrokeWidth = 3 />

The 'Date' string of the path is of type Geometry. A more complete and multi-word way to specify a drawn path is through the complex property syntax, as described above. The marker (such as the one in the following example) is inserted directly into the builder's geometry classes described above:

<Path>

<Path. Date> <CircleGeometry ... /> <RectangleGeometry ... /> <PathGeometry ... />

</ Path. Data>

<Path. Fiii value = red />

<Path. Stroke value-'blue /> </Path>

The path data string is also described, using the following notation to describe the grammar for a trajectory data string:

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

(): grouping

I: separates the double alternatives with quotation marks around the letters

The following shows the information in the path data string, described with this notation (note that in an implementation, FilIMode can be specified here, instead of a property at the element level):

wvg-path:

wsp * moveto-drawto-command-groups? wsp * moveto-drawto-command-groups:

MoveTo-drawto-command-group

I moveto-drawto-command-group wsp * moveto-drawto-commandgroups

RO 123609 Β1 moveto-drawto-command-group:

moveto wsp * drawto-commands?

drawto-commands: drawto-command I drawto-command wsp * drawto-commands drawto-command:

closepath horizontal linear-vertical linear-curvature smooth smooth-quadratic-bezier-curved smooth-quadratic-bezier-elliptical-curved arc ι ι

I

I

I

I

I

I moveto:

(Μ I m) wsp * moveto-argument-sequence moveto-argument-sequence: coordinate-pair

The coordinate-pair comma-wsp? lineto-argument-sequence closepath:

(ZI z) line:

(LII) wsp * lineto-argument-sequence lineto-argument-sequence:

coordinate-pair

The coordinate-pair comma-wsp? line-argument-sequence horizontal-line:

(Η I h) wsp * horizontal-line-argument-sequence horizontal-line-argument-sequence: coordinate

The comma-wsp coordinates? horizontal-line-argumentsequence vertical-line:

(VI v) wsp * vertical-line-argument-sequence vertical-line-argument-sequence: coordinate

RO 123609 Β1

The comma-wsp coordinates? vertical-line-argument-sequence curve:

(CI c) wsp * curveto-argument-sequence curveto-argument-sequence:

curveto-argument

The curveto-argument comma-wsp? curve-argument-sequence curve-argument:

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

(IF s) wsp * smooth-curveto-argument-sequence smooth-curveto-argument-sequence:

smooth-curveto-argument

Smooth-curveto-argument comma-wsp? smooth-curveto-argument-sequence smooth-curveto-argument:

coordinate-pair comma-wsp? coordinate-pair quadratic-bezier-curve:

(Qi q) wsp * quadratic-bezier-curveto-argumentsequence quadratic-bezier-curveto-argument-sequence: quadratic-bezier-curveto-argument

I 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:

(TI t) wsp * smooth-quadratic-bezier-curvetoargument-sequence smooth-quadratic-bezier-curveto-argument-sequence: coordinate-pair

The coordinate-pair comma-wsp? smooth-quadratic-beziercurveto-argument-sequence elliptical-arc:

(AI a) wsp * elliptical-arc-argument-sequence

RO 123609 Β1 elliptical-arc-argument-sequence:

elliptical-arc-argument

And elliptical-arc-argument comma-wsp? elliptical-arcargument-sequence elliptical-arc-argument:

nonnegative-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 I floating-point-constant number: sign? Integer-constant I sign? floating-point-constant flag:

II / ΛΙΙ I II A II comma-wsp:

(wsp + comma? wsp *) I (comma wsp *) comma:

II II integer-constant: digit-sequence floating-point-constant: fractional-constant exponent? The digit-sequence exponent fractional-constant: digit-sequence? digit-sequence I digit-sequence exponent:

(and IE) sign? digit-sequence

RO 123609 Β1 sign:

ΙΙψΙΙ | II II digit-sequence:

digit

I digit digit-sequence digit:

OI

I 2 I

<img file="RO123609B1_D0001.tif" />

WSP:

(# x20 I # x9 I #xD I #xA)

The image element (fig. 25) indicates that the respective content of a complete file is about to be delivered in a given rectangle, within the user's current coordinate system. The image (indicated by the image mark) can refer to image trace files, such as PNG or JPEG, or to files of type ΜΙΜΕ in image / wvg, as it starts in the following example:

&lt;lmage Top = 200 Left = 200 Width = 100px Height = 100px

Source-'myimage. png>

</ Lmage>

The following table provides image information, with a few example properties:

Table

<td colspan="2">Type Name</td><td>R / RW</td><td colspan="3">Value Standard description</td>

<td>Top</td><td colspan="2">Boxun</td><td></td><td></td><td>Coordinates for the top of lmage (image)</td>

<td>left</td><td colspan="2">Boxun</td><td></td><td></td><td>Coordinates for the left side of Image</td>

<td>width</td><td colspan="2">Boxun</td><td></td><td></td><td>Image's width</td>

<td>height</td><td colspan="2">Boxun</td><td></td><td></td><td>the height of Image</td>

<td>source</td><td colspan="2">imaged</td><td></td><td></td><td>Image's source</td>

<td>dpi</td><td colspan="2">float</td><td></td><td> 96 (?)</td><td>DPI target for use in sizing</td>

<td>HorizontalAlign</td><td colspan="2">enum {Left (?), Center (?), Right (?) }</td><td></td><td>Center</td><td></td>

<td>VerticalAlign</td><td colspan="2">enum {Top (?), Middle (?), Bottom (?)}</td><td></td><td>Middle</td><td></td>

Table (continued)

RO 123609 Β1

<td colspan="5">Name Type R / RW Value Description standard</td>

<td>stretch</td><td>enum Stretch { none, sons Uniform, UniformToFill, }</td><td></td><td>none</td><td>None: Retains the original shape Sons: The aspect ratio is not kept, and the content is scaled, to fill the borders set by tlbh Uniform: Uniform scaling, until the image matches the edges set by tlwh. UniformToFill: Scaling form to evenly fill edges set by tlbh, and cut</td>

<td>readyState</td><td>enum {MetaDataReady, Loading, Loaded LoadError }</td><td></td><td></td><td></td>

<td>LoadCounter</td><td>Int</td><td>Read</td><td>null</td><td>The count that increases when ReadyState is loaded (Loading)</td>

<td>Name</td><td>String</td><td></td><td></td><td>Alternate text for Image</td>

As described above, the conformations correspond to the geometry drawn using the inherited and cascaded presentation properties. The following tables start from the properties of the figure examples, for the basic elements of the figures described above (Rectangle - rectangle, Ellipse - ellipse, Line - line, Polyline - polyline, Polygon polygon). It is worth noting that these basic figures can have brush movement properties, filling properties, and can be used as cutting paths, have succession characteristics and apply to both element and Resource levels:

Table 39

<td>Name</td><td>Type</td><td>R / RW</td><td>Standard value</td><td>Description</td>

<td>sons</td><td>Brush</td><td>RW</td><td>null</td><td>Coordinates for the upper part of the rectum</td>

<td>FilIOpacity</td><td>float</td><td>RW</td><td> 1.0</td><td>Coordinates for the left side of rect</td>

<td>Stroke</td><td>Brush</td><td>RW</td><td>null</td><td>The width of his rectum</td>

<td>StrokeOpacity</td><td>float</td><td>RW</td><td> 1.0</td><td>Height of rectum</td>

<td>StrokeWidth</td><td>Boxun</td><td>RW</td><td>IPX</td><td>Width of brush movement. Ipx = 1/96 of an inch</td>

<td>FilIRule</td><td>enum {EvenOdd, NonZero,}</td><td>RW</td><td>EvenOdd</td><td>FilIRule indicates the algorithm to be used to determine which parts of the tarp are included within the figure.</td>

Table (continued)

RO 123609 Β1

<td>Name</td><td>Type</td><td>R / RW</td><td>Standard value</td><td>Description</td>

<td>StrokeLineCap</td><td>enum {Butt, Round, Square, Diamond}</td><td>RW</td><td>Butt</td><td>StrokeLineCap specifies the figure to use at the end of the sub-path opening, when they are moved with the brush.</td>

<td>StrokeLineJoint</td><td>enum {Miter, Round, Bevel }</td><td>RW</td><td>Miter</td><td>StrokeLineJoint specifies the figure that is used at the corners of the paths (or other vector conformations) that are moved with the brush, when they are moved with the brush.</td>

<td>StrokeMiterLimit</td><td>float</td><td>RW</td><td> 4.0</td><td>Limit the ratio between MiterLength and StrokeWidth. The value should be&gt; = 1</td>

<td>StrokeDashArray</td><td>PointList</td><td>RW</td><td>null</td><td>StrokeDashArray controls the sequence of paused lines and pauses used in brush strokes. &lt;dasharray&gt; contains a list of &lt;numbers&gt; (&lt;number&gt; s) separated by spaces and commas, specifying the lengths of dotted lines and alternate breaks in user units. If an odd number of values ​​is provided, then the list of values ​​is repeated to produce an even number of values. Thus, the network of dotted lines of brush movement: 5 3 2 is equivalent to the network of dotted lines of brush movement: 5 3 2 5 3 2.</td>

<td>StrokeDashOff set</td><td>Point</td><td>RW</td><td></td><td>StrokeDashOffset specifies the distance from the dotted line sequence at the beginning of the dotted lines.</td>

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

<td>video</td><td>Geometry</td><td>RW</td><td>null</td><td>The clip limits the region to which the paint can be applied on the tarp. The standard cutting path is defined as a bounding box.</td>

RO 123609 Β1

The following is an example markup 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 in the object model (note that the rectangles are read / written, have default values ​​equal to zero, support the sequence and apply to both levels of elements and resources):

Table

<td>Name</td><td>Type</td><td>Description</td>

<td>Top</td><td>Boxun</td><td>Coordinates for the upper part of the rectum</td>

<td>left</td><td>Boxun</td><td>Coordinates for the left side of rect</td>

<td>width</td><td>Boxun</td><td>The width of his rectum</td>

<td>height</td><td>Boxun</td><td>the height of his rectum</td>

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

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

The following is an example markup syntax for a circle:

<Circle CenterX = 600 CenterY = 100 Fill = red Stroke-'blue StrokeWidth = 10 />

A circle has the following properties in the object model (it should be noted that the circles are read / written, have default values ​​equal to zero, support the sequence and apply to both levels of elements and resources):

Table

<td>Name</td><td>Type</td><td>Description</td>

<td>CenterX</td><td>Boxun</td><td>The X coordinate of the center of the circle</td>

<td>CenterY</td><td>Boxun</td><td>The Y coordinate of the center of the circle</td>

<td>Radius</td><td>Boxun</td><td>Circle's radius</td>

The following is an example markup syntax for an ellipse:

<Ellipse CenterX = 600 CenterY = 100 Fill = red Stroke-'blue StrokeWidth = 10 />

RO 123609 Β1

An ellipse has the following properties in the object model (note that the ellipses are read / written, have default values ​​equal to zero, support the sequence and apply to both levels of elements and resources):

Table

<td>Name</td><td>Type</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>Coordinate Y of the center of the ellipse</td>

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

<td>RadiusY</td><td>Length</td><td>Race on the Y axis of the ellipse. If a radius is specified on the negative Y axis, the absolute radius value will be used.</td>

The following is an example markup syntax for a line:

<Line x1 = 100 y1 = 300 x2 = 300 y2 = 100 StrokeWidth = 5 />

A line has the following properties in the object model (note that the lines are read / written, have default values ​​equal to zero, support the sequence and apply to both levels of elements and resources):

Table

<td>Name</td><td>Type</td><td>Description</td>

<td>X1</td><td>Boxun</td><td>Coordinate on the X axis of the beginning of the line. The default value is 0.</td>

<td>Y1</td><td>Boxun</td><td>Coordinate on the Y axis of the beginning of the line. The default value is 0.</td>

<td>X2</td><td>Boxun</td><td>Coordinate on the X axis of the end of the line. The default value is 0.</td>

<td>Y2</td><td>Boxun</td><td>Coordinate on the Y axis of the end of the line. The default value is 0.</td>

'Polyline' defines a set of straight line segments connected together. Typically, a polyline defines an open conformation.

The following is an example markup syntax for a polyline:

&lt;Polyline Fill = None Stroke = Blue StrokeWidth = 10 cm

Points = 50.375

150.375 150,325

350.375 350,250

550.375 550,175

750.375 750,100

250,325 250,375

450,250 450,375

650,175 650,375

850,100 850,375

950,375 950,25 1050,25 1050,375

1150,375 />

RO 123609 Β1

A polyline has the following properties in the object model (note that the lines are read / written, have default values ​​equal to zero, support the sequence and apply to both levels of elements and resources):

Table

<td>Name</td><td>Type</td><td>Description</td>

<td>Points</td><td>PointCollection</td><td>The points that make up the polyline. The coordinate values ​​are in the user coordinate system.</td>

The Polygon element defines a closed conformation, comprising a set of segments of straight lines, connected together. The following is an example markup 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 />

A polygon has the following properties in the object model (note that the lines are read / written, have default values ​​equal to zero, support the sequence and apply to both levels of elements and resources):

Table

<td>Name</td><td>Type</td><td>Description</td>

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

The grammar for the point-of-order specifications the elements of polyline and polygon is described, together with the following notation:

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

(): grouping

I: separate the double quotes with the double quotes around the literals

The following describes the point specifications of the elements of 'Polyline' and 'Polygon', using the above notation:

RO 123609 Β1 list-of-points:

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

<td>coordinate</td><td>comma-wsp coordinates</td>

coordinate: number number:

sign? Integer-constant

I sign? floating-point-constant comma-wsp:

(wsp + comma? wsp *) I (comma wsp *) comma:

II II integer-constant: digit-sequence floating-point-constant: fractional-constant exponent? The digit-sequence exponent fractional-constant: digit-sequence? digit-sequence I digit-sequence exponent:

(and IE) sign? digit-sequence sign:

ΙΙψΙΙ | II II digit-sequence:

digit

I digit digit-sequence digit:

WSP:

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

RO 123609 Β1

As can be seen from the previous, detailed description, there is provided a 1 system, a method and an element / object model, which provides, to the program code, various mechanisms, to interface with a scenic graph. The system, the method, as well as the object model are 3 used directly, they are still powerful, flexible and extensible.

While the invention is susceptible to various modifications and alternative constructions, 5 certain embodiments illustrated by it are presented in the drawings and have been described above in detail. It should, however, be understood that there is no intention to limit the invention 7 to the specific forms presented, but on the contrary, the intention is to cover all modifications, alternative constructions, and other equivalent ones, entering the spirit and scope of the invention. 9