JP2003506768A - Graphic object with minimum and desired size - Google Patents

Abstract

To process the layout of graphical objects, elastics data structures are established for the graphical objects to define minimum and preferred sizes, stretch properties and compression properties. Composite graphical objects include elastics properties computed from their components through add and max operations which are dependent on relative elasticities of the components. The positions of origins within graphical objects are defined by pairs of elastics in each of two dimensions. One application of elastics is with respect to text blocks where preferred width and compressibility of each text block is a function of the amount of text in the text block. The elastics and dimensions of graphical objects are processed in a three pass layout negotiation. In the first pass, preferred sizes and elasticities of the graphical objects are computed along a first dimension. In a second pass, size values of the graphical objects along the first dimension are computed from the preferred sizes and elasticities, and preferred sizes and elasticities of the graphical objects along a second dimension are computed based on the size values of the graphical objects along the first dimension. In a final pass, size values of the graphical objects along the second dimension are computed from the preferred sizes and elasticities.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION

In recent years, the number of users who use the Internet has increased exponentially. As this popularity has increased, so has the demand for tools that enhance "online use." To meet this need, new object-oriented computer programming languages, such as Java, have been developed. Although these languages have advanced through the prior art, there is room for improvement. In particular, there is room for improvement in the ability to efficiently change the layout of complex structures of graphic objects in variable size windows. Using these languages,
Achieving high quality, real-time graphics on a website is difficult.

With Java, a minimum and maximum size can be specified for a graphic object, and if the difference between these minimum and maximum sizes is large, these values can be used to make the object more elastic.

A language specifically developed for Internet use is the MIT Curl Language, which is described by M. Hostetter et al., "Curl: A Gentle Slope Language for the
Web, "WorldwideWeb Journal, Vol 2, Issue 2, O'Reilly & Associates, Spling
It is described in 1997. Embodiments of the present invention extend the Curl language (the language of the embodiments of the present invention is called "Curl" to distinguish it from the former "MIT Curl" language). MIT Curl is a three pass layout negotiation method (three pass
layout negotiation) was used, and the object was able to describe the size preference with respect to the minimum size and expansion factor.

TeX is a text format program and is widely used. This program is based on Donald E. Knuth's The TeXBook, Addison-Wesley, Reading,
Developed by MA, 1984. TeX utilizes a concept known as "glue" to represent dimensional preferences for fill objects and incorporates different stretch and compression orders, which are used to create different types of fill Can describe objects. As the overall layout changes, the dimensions of the individual fill objects change depending on the desired size and stretch of these objects.

A graphics tool developed by Robert Haistead called Stk
The kit incorporates the concept of elasticity known as "glue", which is the minimum size, expansion factor, and
And the function of extension order. This kit formulates horizontal and vertical box layout calculations for graphic objects in terms of elastic add, maximize and split operations. Stk is not generally known or used. Stk's layout mechanism is built into Swat.
Swat is a graphics tool developed at the MIT by Harold Abelson, James Miller and Natalya Cohen.

[0006]

[Outline of the Invention]

According to the present invention, there is provided a system, method and data structure for laying out graphic objects. A minimum and desired size is determined for each of the plurality of graphic objects. Elasticity is also determined for each of the plurality of graphic objects. The minimum size is specified individually for the desired size and elasticity of the graphic object. Processing graphic objects and embedding multiple graphic objects,
Determine the minimum and desired size of larger graphic objects.

Preferred data structures for graphic objects include minimum size, desired size and elasticity. The elasticity of each graphic object can be determined by separate stretch and compression factors.

The process can include an add operation in which each of the minimum and desired size of the add result is a plurality of graphic
The sum of the minimum size and the desired size, respectively, of the object.

The process can include a maximum operation, where the maximum result includes a minimum size that is greater than a minimum size of the plurality of graphic objects. The maximum result also includes the desired size, which is the preferred size of the graphic object with the least elasticity relative to other sizes.

The process can include a split operation, where
Divide the size into multiple graphic objects. The split operation splits the size proportionally to the minimum size of the graphic object if the size to be split is less than the sum of the minimum sizes. If the size to be divided is larger than the sum of the minimum sizes, the surplus or deficit for the desired size sum is calculated. The size is based on the required change from the desired size,
It is divided according to the elasticity of each graphic object. The resulting elasticity is
The compression and decompression orders (in this case, the orders are equal) and the different decompression and compression factors can be used as a reference.

In one preferred embodiment, a method of canceling elasticity of an original layout of a graphic object comprises receiving a new layout elasticity of the graphic object's dimensions. At this time, this new layout elasticity is stored. The obtained layout elasticity is determined from the new layout elasticity and the original layout elasticity. Finally, the layout elasticity obtained is returned.

The foregoing and other objects, features and advantages of the present invention will become apparent in the following detailed description of the preferred embodiments of the invention illustrated in the accompanying drawings. In the drawings, the same reference numerals refer to the same parts in different drawings. The drawings are not necessarily to scale and emphasis is placed on illustrating the principles of the invention.

[0013]

DETAILED DESCRIPTION OF THE INVENTION

One of the jobs required of a 2D graphics system is to calculate the layout (position and size) of the displayed objects. The configuration of the graphic representation of the Curl programming language consists of "leaf graphics (leaf g
raphics) "into a large assembly and put them in a graphic container known as a Box. Boxes can be placed inside other Boxes one after the other, which allows you to arbitrarily compose complex graphic displays. it can.

Leaf graphics can include several types of graphic objects. 1. Simple geometries, such as rectangles and ellipses, can either have their size specified within the Curl program, or calculated at layout time, as specified by the program. Simple strings such as labels also fall into this category. 2． Images and other graphics can be scaled, but the aspect ratio (width to height ratio) must be maintained. 3． Formatted text blocks, whose width and height can be scaled, but they need to be approximately inversely related to each other (reduced width increases height).

FIG. 1 shows a typical Curl window containing a large number of graphic objects, including both leaf graphics and Box. 2 is shown in FIG.
Figure 3 shows the composition of the graphic object shown in Figure 2 and is shown in a partially expanded outline form. Each graphic object is a Box
In either case of leaf graphics or leaf graphics, "{VBox
74} "is shown on a single line with a name such as {VBox 74}
Indicates the type of object (VBox) and also contains a unique number (74) that specifies the particular object associated with this line of the diagram. Each Box is shown on a line containing a triangle icon to the left of the Box name, while each leaf graphic is shown by a square icon next to the Graphic Name. {VBox 74
} Or {HBox 63}, the triangle icon corresponding to the Box is connected to the bottom of the triangle, which links the triangle to the icon of each object directly contained as a child of the Box. Lines show the graphics contained within that Box on subsequent lines. {CdeButton 64} or {
If a Box triangle points to the right, as in HBox 70}, the Box can have child objects (not shown for simplicity). However, in reality, not all Boxes indicated by a right-pointing triangle have child objects. For example, {CastTextFlowBox 60} has no child objects.

The diagram of FIG. 2 showing the top-level objects of FIG. 1 is {CdePan
eView 1}, with {VBox 70} as a single graphic child below it. The {VBox 70} has several child objects below it, each of which fills its compartment horizontally and is arranged from top to bottom. {MenuBar 75} is a menu bar object that defines the menu bar 75 of FIG. 1 and contains the words "File", "Edit", etc. {HBox 72} is a toolbar object,
Right below these words. Figure 2 shows this expanded HBox with "Print
A separate CdeButtu that supports tool buttons named "," Window ", etc.
m Indicates an object. {CdeButton 62} is the "Print" tool button, expanded below it to contain the Frame object {Frame 61}. {Frame 61} includes {VBox 59} below it. Finally, {VBox 59} is the printer icon {Pict
ure 44} and the word "Print" contained within {CastTextFlowBox 60} is an entity. The other objects shown in FIG. 1 are similarly grouped. In particular, {PageViewPane 77} corresponds to the word "Welcome to Curl" and a large area containing related text and graphics, while {Stretchy
TextDisplay 78} corresponds to the blank status section at the bottom of the screen and occasionally displays a message indicating which application program is running.

Since Curl supports all of these types of graphics, and further allows all of their combinations to be put together in a Box, Curl provides the following basics provided by the layout system: Need a solution to a social problem.

1. Simple leaf graphics or composite graphics (ie Box)
Display size preferences for graphic objects, which are either:
This display should allow the Box to query its component graphics for their size preferences and combine the results into the Box's own size preference display. The display should be able to code size preferences for both rigid objects such as many simple graphics and elastic objects such as images and formatted text. In Curl, this role is denoted by "elastics". Elasticity values are determined for the height and width of individual graphic objects, as described in more detail below. Elastic values for composite graphic objects are calculated from the elastic values of their components. 2． Compute the graphic layout in a manner that takes into account size preferences for both rigid and elastic objects. The presence of stretchable objects that adhere to height-width relationships, such as both constant aspect ratio images and formatted text, further complicate this problem.

In Curl, this role is called wide-first and height-first.
) Is displayed by a three-pass layout negotiation algorithm having two methods. The breadth-first algorithm collects the width preference for the first pass through the graphic object tree, calculates the width allocation, and
Collect the pass height preferences and calculate the height assignment for the third pass. The height-first algorithm is similar, but the roles of height and width alternate. By collecting height preferences after the width allocation has been determined (or vice versa for height-first layouts), the algorithm accommodates objects whose height and width preferences are not independent of each other.

Graphic objects within the elastic general concept layout can have desirable dimensions. For example, in FIG. 3, two side-by-side graphic objects A and B may have the desired widths PA and PB. However, when the user enlarges or shrinks the window containing the graphic objects A and B, the widths of A and B are changed in order to match the hardware display size or the window size of the display, and the space is changed. It must be filled or the peripheral edge of the field of view must be avoided. For example, if two objects A and B fill a width W1, the two objects can grow proportionally to the resulting widths WA and WB shown in FIG. 3B. The results in Figure 3B assume that the two graphic objects have the same elasticity (ie, the same elasticity) for magnification. However, by determining the elasticity for each graphic object, one object can be stretched preferentially over the other. For example, if object B is determined to have greater extensibility relative to object A, then object A will stay at the desired width PA and the total expansion will depend on the total width W1 generated by object B, as shown in FIG. 3C. Be brought. Similarly, if the composite object needs to be reduced to the reduced width W2, the two objects will be proportionally compressed, as shown in FIG. 3D. On the other hand, as shown in FIG. 3E, object A can be determined to have a large compressibility so that object A causes a large distribution of compression.

Elastic indications behave like mechanical springs. Like springs, elastic bodies have a "desired size", which is their length when no deforming force acts. Like a spring, when an elastic is compressed to a size less than the desired length, it is believed that the elastic exerts a force opposite that of compression. This force increases with increasing degree of compression, but unlike simple mechanical springs, elastic bodies generally exhibit a discontinuous change in force magnitude or rate of change of force with respect to the magnitude of elastic deformation.

If instead of compression, the elastic is stretched longer than desired, it is believed that the elastic counters its elongation with a force that increases with the amount of deformation, as well as a compressive force.

As with springs, different elastic bodies can have different rates of extension and compression. The maximum proportion of stretch and compression is related to the elasticity, which represents the minimum force against a given deformation.

Unlike mechanical springs, elastic bodies can also have different "orders" of extension and compression. An elastic body having a large extension (or compression) order can be infinitely extended (or compressed) as compared with an elastic body having a small extension (or compression) order. When two elastics with different stretch orders are placed in series and the assembly is stretched, the elastic with the smaller stretch order stays at its desired size, and all the extra distance is the elastic with the larger stretch order. Occupied by stretching.

However, if the two elastics in the above state have the same stretch order, they are both stretched. Each elastic body is stretched to a length such that the forces opposing the stretching of the two elastic bodies are equal. In fact, this means that if one of the elastics is stretched N times more than the other, the amount by which it stretches beyond its desired size is N times the amount of stretching distributed to the other elastic. Means to grow to.

If, instead of stretching, the assembly of two elastics is compressed below its desired size, the behavior is similar to that described above, except that stretching replaces compression.

In order to perform the graphic layout, elasticity is used to represent the height and width preferences of the graphic object. Therefore, it is necessary to be able to:

1. The elasticity (body) that represents the graphics in the Box is combined to create the elasticity (body) that represents the basic settings for the height and width of the Box itself. 2． As a whole, assume a height or width assignment for a Box, and the height or width elasticity (body) of the graphics in that Box, and assign a height or width assignment for each of those graphics. calculate.

In order to support these requirements, elastics need to support certain basic operations. 1. The "add" operation is equivalent to placing two elastic bodies in series. For example, this operation can be used to calculate the width elasticity of a Box that contains two or more graphics arranged horizontally and as in FIG. 2． The "maximum" operation is equivalent to arranging two elastic bodies in parallel. For example, this operation can be used to calculate the height elasticity (body) of a Box containing some graphics arranged horizontally and horizontally. 3． The "split" operation applies to two elasticity and length. This operation calculates the portion of the length assigned to each elastic when the two elastics are placed in series and the assembly is stretched or compressed to a particular length. For example, this operation can be used to calculate a width allocation for each graph by a Box that contains two graphics arranged horizontally and horizontally as in Figure 3, assuming a particular width allocation for that Box. As will be described below, this operation can be used in conjunction with an add operation to distribute a particular width or height to any number of objects arranged in sequence along the dimension of interest. In addition to these basic operations, there are a few other operations that account for the use of elastic Curl.

4. The "scale" operation multiplies an elastic body by N (> 0). If N is an integer, the result is the same as that obtained by copying the elastic body in series N times using an add operation. If N is not an integer, the result is interpolated midway between the results corresponding to the two integers closest to N. Five . The "equal" operation of two elastic bodies returns to their original shape when the two elastic bodies exert the same force at all sizes. 6． The "size equality" operation applies to two elasticity and specific lengths. This operation is established when the same force is applied when the two elastic bodies deform to a predetermined length.

[0031]   You can also imagine other operations like "subtract".

Elasticity of Curl Language Although the general concept of elasticity described above is based on improving layout calculation,
The most common form of implementation is expensive. In addition, Curl performs an approximation to the general elasticity concept described above. The Curl approximation has the following properties. 1. It is possible to display elasticity in which the degree of extension (and extension order) is different from the degree of compression (and compression order). 2. It incorporates the concept of "minimum size". Curl elasticity is extremely difficult to compress to a size smaller than the minimum size. 3. There is a limit as to the ability to magnify the representation of elasticity when the aforementioned addition, maximal, and other operations are performed. Representations of elasticity with this property may not yield accurate results for all possible elasticity operations. Therefore,
Curl derives approximate results for add, max, and other operations when it is necessary to not grow the size of the result. 4. There is a compact display function for some of the common elastic value generations. For example, elasticity with the same degree of extension and compression can be displayed more compactly than general elasticity in which this identity is not maintained.

[0033]   In summary, the standard Curl elasticity has 6 fields. 1. Minimum size (floating point number) 2． Desired size (float) 3． Compressibility factor (floating point number) Four . Compression order (integer) Five . Expansion coefficient (floating point number) 6． Extension order (integer)

A Curl object representing elasticity has a type code (same for all Curl objects) and a field containing the above-mentioned values. A special example elastic compact representation has different type codes and a subset of the fields. The associated value of the missing field is calculated with reference to the type code and the field applied in the compact representation. For example, type code Stretc
hyElastic is associated with the object containing fields (1)-(4) from the list above. When values corresponding to fields (5) or (6) are required, they are applied by providing values from fields (3) and (4) respectively.

Another example of a compact elastic display is RigidElastic, which has only the desired size field. When you need the corresponding values for the other fields, calculate those values so that the minimum size is equal to the desired size, and the field (3)
− Let (6) have values associated with standard “stiffness” objects.

Performing Basic Elasticity Operations in Curl The execution of basic elastic operations in Curl can be described by the following six standard elasticity fields.

The add operation produces a result with the following fields: 1. The minimum size is the sum of the minimum sizes of its operands. 2． The desired size is the sum of the desired sizes of its operands. 3． The compressibility factor is the sum of the compressibility factors of the operands when both operands have the same compression order. Otherwise, the resulting compressibility factor will be equal to the compressibility factor of the operand with the greater compression order. Four . The compression order will be equal to the greater of the compression orders of its operands. Five . If both operands have the same extension order, then the extension factor is the sum of the extension factors for that operand. Otherwise, the resulting stretch factor is equal to the stretch factor of the operand with the higher stretch order. 6． The extension order is equal to the greater extension order of its operands.

The elastic body created according to this rule may only be an approximation of the ideal result of the addition operation. For example, if an elastic body A with a small desired size and a large compression order is added to an elastic body B with a large desired size and a small compression order, the resulting elastic body C will have a compression order equal to A,
The desired size of C is the sum of those desired sizes of A and B. Therefore, C becomes an elastic body that can be easily compressed, and maintains a state in which it can be easily compressed even after the size becomes smaller than the desired size of B alone. This behavior differs from that of the mechanical system of the spring. For mechanical systems, highly compressible elastic body A
Is compressed to zero length, no further compression of A is possible, where B
Corresponding to the compression order of, the elastic body C becomes extremely difficult to compress.

Although the addition operation described here is only an approximation, it has the advantage that the result can be displayed in a fixed amount of space. All methods of creating an ideal result from an elastic add operation require an increased amount of space, as the result of one add operation itself is provided as an operand to another add operation, and need to be balanced with improved fidelity of the result. There is an increase in space and time costs. The above approximation can be calculated efficiently and gives good results in practice.

The maximum operation of two elastics A and B produces a result with the following fields: 1. The minimum size is the larger of the minimum sizes of its operands. 2． The desired size is close to the desired size of elasticity (body), which is the minimum elasticity (body) relative to other desired sizes. The elasticity is first ordered. If the orders are equal, compare the coefficients. Since it is necessary to stretch one elastic body to match the other and simultaneously compress the other to match the first elastic body, the elasticity value comparison is a comparison between the extension degree and the compression degree. Specifically, the desired size is equal to the desired size of A in the following cases (a) or (b). (A) The desired size of A is larger than that of B, and either:
(I) the compression order of A is smaller than the expansion order of B, or (ii) the compression order of A is equal to the expansion order of B, and the compression factor of A is B
Is less than or equal to the coefficient of elasticity. (B) The desired size of A is smaller than that of B, and either:
(I) the expansion / contraction order of A is smaller than the compression order of B, or (ii) the expansion / contraction order of A is equal to the compression order of B, and the expansion coefficient of A is B
Is less than the compression factor of. Otherwise, the desired size of the result is equal to the desired size of B.

3. The compressibility factor is the elasticity (body) compressibility factor of the desired size selected for the value of the desired size field (2). If both operands have the same desired size, and the operands have different compression orders, then the compression factor associated with the smaller compression order is used, otherwise the smaller of the two compression factors is used. Four . The compression order is the compression order associated with the compression factor selected for field (3). Five . The modulus of elasticity is the modulus of elasticity of the desired size of elasticity selected for the value of field (2). If both operands have the same desired size,
If the operands have different expansion orders, then the expansion coefficient associated with the smaller expansion order is used, otherwise the smaller of the two expansion coefficients is used. 6． The stretch order is the stretch order associated with the stretch factor selected for field (5).

Similar to performing the addition described above, this performing of the maximum operation only produces an approximate result in some states. For example, assume that elastic A has a small desired size and a small compression order, while elastic B has a large desired size and a large compression order. When the expansion order of A and B is larger than the compression order of B, the desirable size of elastic body C, which is the larger of A and B, is B
Equals the desired size of. Similarly, the compression degree and compression order of C are equal to those of B, in which case C can be easily compressed. Similar to mechanical springs, C is presumed to be more difficult to compress once the desired size of A is achieved. However, when the elastic body C is calculated according to the outline described above, such a state does not occur.

As with the add operation, the overall fidelity of the maximum operation is subject to the unlimited space and time required to compute the result. The approximation described above is used because it allows efficient computations and gives good results in practice. The split operation on the two elastic bodies A and B and the length x is described as split (A, B, x) and produces the length of the object having the elastic body A. The split operation is executed as follows.

1. If x is less than the minimum size of two elastic (body) lengths, the length x is elastic (
The body is divided in proportion to the minimum size. Therefore, the result of the split operation is: (X * A. Minimum size) / (A. Top size + B. Minimum size) 2. On the other hand, the surplus (or deficit) e is calculated by subtracting the sum of the two desired sizes from x. e is distributed to two elasticity bodies as follows. a. If e is a surplus and the two elastic bodies have the same extension order, e
Is divided in proportion to the elastic modulus of the two elastic bodies. Therefore, the elastic body A
The surplus allocated to is as follows. (E * A. Stretch degree) / (A. Stretch degree + B. Stretch degree) b. If e is insufficient and the two elastic bodies have the same compression order, e
Divides in proportion to the compressibility coefficient of the two elastic bodies. c. If e is a surplus and the two elasticity (body) have different extension orders, all e are allocated to the elasticity (body) having the larger extension order. d. If e is insufficient and the two elastics (bodies) have different compression orders, all e are distributed to the elastics (bodies) with the larger compression orders.

The result of the split operation is then the sum of the desired size of A and the portion of e allocated to A. However, unless this result is adjusted, as necessary, to avoid assigning either A or B a size smaller than its minimum size.

The scale operation applies a scale factor (magnification) f to the elastic body A. The elastic parameter obtained is calculated from the scale factor of A as follows. 1. The minimum size is f times the minimum size of A. 2． The desired size is f times the desired size of A. 3． The compression factor is f times the compression factor of A. Four . The compression order is equal to the compression order of A. Five . The expansion coefficient is f times the expansion coefficient of A. 6. The extension order is equal to the extension order of A. Other elastic operations are performed in a similar manner.

Graphic Origin and Dimensions As before, Curl uses elasticity to describe size preferences for graphic objects. Each such object has a width and height, and has an "origin" somewhere within the object. The origin is, for example, an effective method for displaying the position of the baseline of a line of text protruding vertically from the baseline. Also, the origin is effective for vertical alignment, for example, if a number falls within the text string and the origin of the text string is at the decimal point position of the digit, the decimal point of the number in one column is set to the origin point. It can be easily aligned by aligning with.

Considering the origin, there are four size preferences described using elasticity, as shown in FIG. 1. The distance between the origin of the object and its top ("upper part" of the object) 2. The distance between the origin of the object and its bottom ("lower part" of the object) 3． Distance from the origin of the object to its left edge ("left range" of the object) Distance between the origin of the object and its right edge ("right range" of the object)

It is advantageous to bundle the elastics describing the size settings together for the upper and lower parts into a single unit describing the size settings for the vertical dimension. Similarly, it is advantageous to bundle elastic bodies together that describe the basic settings for the left and right range of the object. Therefore, the Curl implementation provides a class OriginalErastic that contains a pair of elastic objects that describe size preferences on either side of the origin.

For simple graphics such as graphics and rectangles, the appropriate elastics are simply composited and their size settings are described based on internal parameters such as the number of pixels in the graphics. Graphic containers, on the other hand, use the elastic operations described above to combine the elastic bodies of their component graphics to create elastic bodies.

Using Elasticity with HBox and Vbox For example, Curl has a container, known as an HBox, that has a collection of graphics arranged in a horizontal row. The HBox has several options that allow you to specify that the components of the HBox should be aligned with their origin, bottom, top, or center. Aligned to the origin of the component
When considering the HBox, the origin of the HBox itself is located at the origin of the first (leftmost) object in the HBox, and the origins of all other components in the HBox are aligned with the origin of the HBox itself. To be done.

FIG. 5 shows three objects, CastTextGFlowBox and Rectangle.
, And another CastTextGFlowBox. FIG. 6 shows the graphic hierarchy of the HBox. This particular HBox is aligned to the vertical origin of the component object. Rectangle produces an elastic body that requires the origin to be the lower left corner of the rectangle, while text produces an elastic body that requires the origin to be the left edge of the text, thus these When the three objects are displayed within this HBox, the bottom of the Rectangle is aligned with the baseline of the text, which is generally the desired array. Even if the bottom of each text block is below the text block's baseline (as indicated by the position of the lower letters "y" and "g" in the text block), this array is used by the origin. Will be possible.

FIG. 7 contains several objects located at the horizontal origin of the objects
Indicates VBox. Aligning the decimal points to one column of numbers, as shown, is useful for aligning the horizontal origin. FIG. 8 shows the graphics hierarchy corresponding to FIG. 7, with all the objects appearing in FIG. 7 fully expanded as clearly shown in FIG. Curl allows you to create a graphic object that contains the text placed to the immediate left of the decimal point for all text strings whose origin represents the decimal point. However, since such an object is not embedded in Cirl, each string of numbers is constructed as an HBox containing two text blocks. That is, the first block contains a number to the left of the decimal point and the second block contains a decimal point and, if present, the number to the right. Each HBox is configured to place the rightmost origin of the first text block. The Rule object is "
It has a function to display a horizontal line just under 33.333 ". Rule object is 1/72
Has a fixed height of inch (0.35mm) but can be stretched in width, which makes it wider
Automatically matches the width of.

In the case of FIG. 5, the elasticity of the left area of the HBox is simply the elasticity of the left area of the first component. The right range elasticity of the HBox is calculated using the elastic add operation, which combines the right range elasticity of the first component with the left and right range elasticity of all remaining components. The HBox's Upper Elasticity is calculated using the Elastic Maximum operation and combines all the upper elastics of the HBox component. The lower side elasticity of the HBox is similarly calculated using the elastic maximum operation,
Joins all the underside elasticity of the HBox component.

The above description describes a method of calculating the elasticity describing the HBox's size preferences from the elasticity describing the HBox's graphic child object's size preferences. The other part of FIG. 5 is a method of making a layout decision using these elasticity. In width-first layout negotiation, the HBox calculates its width elasticity and then
The graphic's parent object finally determines the numbers in the left and right range of the HBox,
Communicate these values to HBox. The HBox uses this information to calculate the left-right range and horizontal origin position for each of the HBox's graphic children in combination with the width elasticity previously obtained from the HBox's graphic children.

The left extent of the HBox's first child object is easily calculated because it is equal to the left extent of the HBox itself. However, calculating the left and right bounds of the HBox child objects is a complex task. As shown in FIG. 9, three graphic children A, B
, C. The origin of each object is marked with "*".

The left ranges of A, B, and C are represented by al, bl, and cl, and the right ranges of A, B, and C are
Represented by ar, br, and cr, respectively. The symbols AL, AR, etc. refer to the corresponding elasticity delineating the basic settings of A, B, C used to calculate the range.

As described above, al is equal to the left range of HBox as a whole, but sum ar + bl + cl + cr
Must be equal to the right range of HBox. There are several ways to calculate these values. A simple method is to apply elastic splitting operations sequentially, proceeding from right to left. The first such split operation computes the following equation: cr = divide (CR, AR + BL + BR + CL, r) where r is the right range of HBox, and AR + BL + BR + CL are four elastic bodies AR, BL,
It is the elastic sum of BR and CL. The second split operation computes the following formula: cl = divide (CL, AR + BL + BR, r-cr) The third division operation calculates the following equation. br = divide (BR, AR + BL, r-cr-cl) Proceed with the calculation by this method, and continue until the calculation of all necessary range is completed. This procedure is a generalization for an HBox with approximately three graphic children.

The alternative method differs from this method but leads to the same result. An alternative method is to first calculate cl + cr as follows. cl + cr = divide (CL + CR, AR + BL + BR + CL, r) Next, this result is decomposed into components cl and cr as follows. cl = divide (CL, CR, cl + cr) cr = (cl + cr) -cl

The same method is further repeated to calculate bl + br calculated from bl and br. As we will see later, this method is based on the relatively rigid graphics contained within the HBox.
It slightly simplifies the calculation when the HBox calculates the amount of padding that is inserted around the object as needed.

Still another procedure of calculation is possible. For example, the flow chart of Figure 18 illustrates a method of calculating a range from left to right.

Curl also has a container known as a VBox. The VBox works exactly like the HBox, but with horizontal and vertical dimensions swapped.

Why HBox and VBox Elasticity Calculations Work Correctly The purpose of determining elastic add and split operations can be derived from the aforementioned policy for calculating the horizontal extent of component objects within an HBox. For one example, consider a case where the five elastic bodies AR, BL, BR, CR in the above example are equal. At this time, it is intuitively understood that it is desirable that all five of the ranges ar, bl, cl and cr are equal. For this to work, the following operations on the value of r
It is necessary to derive a result that is 1/5. cr = divide (CR, AR + BL + BR + CL, r) Furthermore, similarly, the following operation needs to lead to a result that is 2/5 of the value of r. cl + cr = divide (CL + CR, AR + BL + BR, r) In fact, these desired values are obtained by the addition and division decisions given above, due to the three main properties of elasticity obtained from the addition operation.

1. The desired size of the result is the sum of the desired sizes of the operands. 2. When the expansion orders of the operands are equal, the resulting expansion coefficient is equal to the sum of the expansion coefficients of the operands. 3. When the compactness orders of the operands are equal, the resulting compactness factor is equal to the sum of the compactness factors of the operands.

Thus, for N equal sums of elasticity, the desired size of the summation, the stretch coefficient, and the compressibility coefficient are each N times the value of the corresponding characteristic of the elasticity of the operands. If the value r of the divide operation's divide (A, B, r) is greater than the sum of the desired size of A and B, and the stretch order of A and B is equal, the split operation is the surplus s between A and B. Distribute -r proportionally to their stretch factors. Similar distributions are maintained even when the split operation distributes the lack of space between two elastics with equal compression orders. These allocation characteristics of split operations are
The addition operation, combined with the method of calculating the desired size, stretch factor, and compressibility factor, ensures that the above calculations produce the desired results that are certainly intuitive. These results cannot be generated if the elasticity (body) does not have a stretch or compression factor. This is because there is no general way for a split operation to recognize that the summation AR + BL + BR + CL contains four units that require space allocation between them, whereas the summation AR + BL + BR contains only three units. .

As another example, consider the case where all of the elastic bodies in question are equal (except that CL has a larger stretch order than all others). Furthermore, assuming that the distance r in this example is larger than the desired size of AR + BL + BR + CL + CR, there is extra space to allocate. As is intuitive, it is desirable that all of the surplus space be allocated to CL. This is because CL has a greater stretch than all other elastic bodies. In this case, all elastic bodies including CL (eg CL-
It can be seen from the definition of the elastic add operation that the sum of CR or AR + BL + BR + CL) has the same stretch order as CL and has a stretch factor equal to CL. On the other hand, the sum of elasticity without CL (such as AR + BL + BR) has a small extension order and an extension coefficient proportional to the added elasticity, as described above. In this case, cr is equal to the desired size of CR, because the following division operation, cr = divide (CR, AR + BL + BR + CL, r), which includes CL in the right operand, allocates all excess space to the right operand. However, the following division operation cl = divide (CL, AR + BL + BR, r-cr) that includes CL in the left operand allocates all the surplus space to the left operand, so cl is the desired size of CR and allocation. Equal to the amount of surplus space allocated. Finally, the following split operation br = divide (BR, AR + BL, r-cr-cl), where neither operand contains CL, works as described above. The intuition of allocating all of the extra space for CL, regardless of the order of the division operations used to allocate the distance between the elasticity to be added, is that the functions of the addition and division operations work simultaneously due to the following logic: The desired result is obtained. For example, if the first step is either cr = divide (CR, AR + BL + BR + CL, r) or cl + cr = divide (CL-CR, AR + BL + BR, r), the desired result is obtained.

[0067]   The same conclusions are drawn from many other examples of this property.

Grids and Tables Complex graphic layouts can be created by nesting HBoxes and VBoxes inside each other. Curl also has grit and table containers that can be used to create a layout like that of FIG. In this case in FIG. 10, the vertical arrangement of A and C (and B and D) and the horizontal arrangement of A and B (and C and D) need to be maintained. Layouts like this are HBox and VBox
Cannot be created simply by nesting the. Grid and table are HBox and
It brings more geometric constraints than VBox, but the basic elastic operations can be applied sequentially to compute many of their geometries.

Fill Object It is extremely effective to use a fill object (a stretchable object) in creating a graphic layout. This fill object does not perform drawing operations, but has basic height and width settings and also takes up space. Rigid fill objects can be used inside HBoxes and VBoxes to place padding and / or indentation around other graphic objects. You can use the stretch fill object to align and center. For example, one request is supported, and the following table of contents is created. Midsummer Night's Dream 5 Tempest 89 Two gentlemen of Verona 173

In Curl, this layout can be specified as a VBox containing one object for each line of the table of contents. In contrast, each line is an HBox, which has three objects: a text object that contains the title, a fill object whose width preference has a greater stretch order than the text object, and a page. And a text object containing a number. The VBox allocates the same width to all of its child objects, whereas each HBox aligns the title to the left and the page number to the right, and allocates all the extra width to the fill object. The reason for this is that the expansion order of the width basic setting is larger than the width expansion order of all the child objects of the HBox graphic.

Stretch fill objects can be used to center graphic objects in larger graphic containers than centered graphic objects. In this case, one decompression object is the following Curl
Is placed on each side of the centered object, as in the display. {HBox {Fill}, object, {Fill}}

Since fill objects have a larger stretch order than other objects, all extra width is allocated to fill objects. If two fill objects have the same stretch order and stretch factor, the extra width is assigned to them equally. As a result, each fill object has the same width and the graphic objects are centered within the space occupied by the HBox. Two
If two fill objects have the same stretch factor but not the same stretch factor, the extra space is allocated proportionally to their stretch factor and the space allocated to the left of the object is allocated to its right. Form another possible layout, such as being half the width of the available space.

The fact that Curl elasticity has an extensional order and an extensibility coefficient is extremely important for the successful outcome of the above-mentioned method. If there is no stretch order, there is no way to assign all the extra widths to fill objects, and necessarily a portion of the extra widths will be assigned to centered or justified objects, at least for them. Gives a slight deformation.

Padding Elastic The intuitive idea that a particular object is "rigid" means that it will not stretch or compress unless it is placed in the most harsh environment. For example, Figure 11 shows three rectangles of different height contained within the HBox. The height of the HBox is equal to the height of the tallest rectangle, but this situation occurs when it is not desirable to stretch other rectangles to match the height of the HBox. This is because the rectangle is usually considered a rigid object. On the other hand, Phil
If elastic objects, such as objects, are contained within the same HBox, it is desirable that the elastic objects extend the full height of the HBox.

These objectives are achieved within Curl by using padding elasticity to fill areas where rigid objects are not stretched. For example, padding elasticity is
Used above each rectangle in FIG.

The padding elasticity has an extension order whose value is known as the "padding threshold extension order". Therefore, any object whose stretch order is less than the "padding threshold stretch order" is considered rigid. This is because padding takes precedence over decompression and decompresses that object. Therefore, the HBox's width and height preferences accurately represent the preferences of the HBox's child objects, and the padding elasticity is not used to calculate the HBox's width and height preferences. However, if the specified width and height of the HBox are assigned between the child objects of the HBox, use padding elasticity as a device to avoid stretching rigid objects.

In the example of FIG. 11, the object is bottom aligned. Therefore, padding elasticity is needed only above the object. In another example, such as in FIG. 12, the objects are centered and padding is required both above and below each object.

A similar padding method is used by VBoxes and other containers that have the potential to stretch rigid objects. Some Curl graphic containers have the option to disable the use of padding in certain situations where you want to stretch rigid objects but use padding by default.

Using Elasticity with TextFlowBoxes Curl's TextFlowBox container is a type of vehicle that displays a paragraph of formatted text on a line of a given length. A TextFl containing a single paragraph, although a single TextFlowBox can contain multiple paragraphs of text.
The owBox is an important specific case. This is because many graphic displays, such as tables, contain blocks of text that can be treated as a single paragraph. Elasticity (body) used to draw the basic settings for the width and height of the TextFlowBox
By selecting, the following three objects are achieved.

1. In the absence of other constraints, the TextFlowBox needs to be expanded horizontally enough so that each paragraph can be represented on a single line. 2. If some TextFlowBoxes are contained in an HBox or similar container (such as a table row) and there is not enough available space to represent them all as in (1), then the available space is their space. TextFl by the method of making height almost the same
Must be distributed among owBox. 3. Some TextFlowBoxes are contained in a VBox or similar container (such as table columns), and the VBox's width preference is managed by the TextFlowBox so that it has the maximum width when expressed as in (1) above. Need to

A VBox contains two TextFlowBoxes, one containing a long paragraph and the other one.
Suppose one contains a very short paragraph (such as two words). This principle states that, in the absence of other constraints, short paragraphs do not "pull" the horizontal extent of a VBox in a way that causes long paragraphs to be represented as a few lines of text.

The purpose of these functions is achieved by calculating the width elasticity (body) of the TextFlowBox as follows. (The TextFlowBox width preference requires the origin of the TextFlowBox to be at its left edge, which causes the elastic body in the left range of the TextFlowBox to have a highly rigid elastic body with a desired size of zero. Therefore,
The width elasticity described below is the elasticity corresponding to the right range of the TextFlowBox. ) 1. The minimum size is the width of the longest indivisible text element (typically one word of text). 2. The desired size is the width needed to allow the longest paragraph in the TextFlowBox to be laid out as a single line of text, thereby achieving objective (1). 3. The compression factor is proportional to the total amount of text in the longest paragraph of the TextFlowBox. In other words, it is proportional to the length of the longest paragraph that does not include any fixed left or right margins or other indentation of interest. 4. The compression order is a standard value known as the "text flow compression order". 5. The extension factor is equal to the compression factor. 6. Stretch order is a standard value known as "text flow stretch order". What is important is that the "text flow decompression order" is greater than the "text flow compression order" and less than the "padding threshold decompression order".

The purpose (3) is achieved by the fact that the "text flow decompression order" is greater than the "text flow compression order". Consider the case where two or more differently sized TextFlowBoxes are contained in a VBox or similarly container, as specified in the purpose (3) description. Elastic maximum operation is these Text
It is executed on the width elasticity (body) of the FlowBox. The degree of expansion of each TextFlowBox is TextFlow
The rule for elastic max operations is that the result is the largest desired size (including the longest paragraph) because it is much larger than any degree of compression of the Boxes (because their stretch order is larger than their compression order). Text
(Equal to the width elasticity of the FlowBox size).

The fact that the “TextFlowBox stretch order” is smaller than the “padding threshold stretch order” means that the TextFlowBox acts as a rigid object in the sense of the padding elasticity description above. Therefore, TextFlowBox is
If more space is available than the desired width of the xtFlowBox, then this TextFlowBox will not be stretched horizontally unless the use of padding is disabled. This method is in line with the usual notion of how to handle text, however, this method uses a "padding threshold stretch order" for the TextFlowBox if necessary.
It can be modified by giving width elasticity with greater stretch.

The compressibility coefficient of the width elasticity of the TextFlowBox is a parameter that can satisfy the above-mentioned purpose (2). A particular case where the user selects an object is where each TextFlowBox in use consists of a single paragraph of text. This case is targeted because it is the most frequent case in actual situations where it is desirable for adjacent TextFlowBoxes to have the same height, especially when such TextFlowBoxes appear as components of a table.

The compression factor is such that a given block of text occupies a certain area on the display (in other words, as width decreases, height increases (or vice versa)). It is derived based on the assumption that the product is almost constant). There are several reasons why the text does not exactly follow this model, but it is a fairly informative approximation. Consider two text blocks P and Q that follow this model. In this case, the desired width of P is p and the desired width of Q is q. In addition, these 2
Consider that one text block needs to be laid out horizontally within a space of full width W (where W <p + q). The deficit d = (p + q) needs to be distributed between P and Q such that the heights of P and Q are equal. When the desired width of P and Q is proportional to their area-this occurs in the case where we consider each case of P and Q containing a single paragraph of text-this desired allocation is Is assigned between P and Q in proportion to their area. For example, if the area of P is greater than Q, then a proportionally larger allocation of deficiency d is distributed to P.

The degree of satisfaction of the objective (2) by the current Curl execution is shown in FIGS.
These figures show the display state of a graphical hierarchy having the structure shown in FIG. 13, when the hierarchy is constrained for each of three different widths. As shown in Figure 13, the structure shown in Figures 14-16 is an HBox containing three TextFlowBoxes, each one of which has a single paragraph of different length. When laid out with the desired width, the resulting representation is as shown in FIG. Each TextFlowBox is given exactly the space needed to represent it on a single line, which is the preferred representation of a TextFlowBox containing a single paragraph. As the available width decreases, the decrease is proportional among the constituent TextFlowBoxes, proportional to their compression factor (ie,
It is distributed (in proportion to the length of the text contained in them). FIG. 15 represents the resulting state when the width reductions are adjusted and shows that this distribution of width reductions for each TextFlowBox achieves the desired layout and that all three Boxes have equal height. Figure 16 shows the result when the width reduction is even larger, TextFlowBox
It shows again how to allocate reductions to keep the heights of the equal.

This method does not always make the heights of the TextFlowBox exactly the same, as the length of the words changes and line splitting only occurs between words (or at particular positions of hyphenated words). This method often results in a margin condition where one TextFlowBox expands slightly to the additional line of text, while the other TextFlowBox does not. Also, if the width of the TextFlowBox is reduced below the width of its longest word (or other indivisible object), there will be more deviation from ideal behavior. Nevertheless, over a wide range of conditions, the width elasticity of the TextFlowBox described here helps to keep the height of the TextFlowBox equal.

In the width-first layout negotiation, setting a desired height of the TextFlowBox, that is, expressing the height basic setting, is a clear method. This is because the width of the text is already known before calculating the height preference. As a result, the TextFlowBox's height preference is both a minimum and a desired size, a stiffness elasticity equal to the height actually needed to display the full text.

Objective (2) above is difficult to achieve with satisfactory results when using height-first layout negotiation. Therefore, in this case, assume that the calculation of the TextFlowBox's size preference is just a rigid object with the dimensions needed to lay out the text that contains the object, as described in Objective (1) above. And calculated.

The simple rigid object TextFlowBox is one example of a graphic object whose width and height are approximately inversely proportional to each other, but simpler graphic objects such as polygons and ellipses.
Objects exist, they simply have a certain natural size and are usually not transformed. The basic width and height settings of these rigid objects are represented by the elasticity of the following properties. 1. The minimum size is the object's natural size (width or height, as appropriate). 2. The desired size is equal to the minimum size. 3. The compression factor is a standard value such as 1. 4. The compression order is a standard value known as the "minimized extension order", which is less than the "text flow compression order" and the total elasticity (body ) Used as a compression order. In practice, it does not matter how much compression order or compression factor is used for such elasticity (body). This is because the elastic division operation simply allocates the elasticity (body) to a space smaller than its minimum size in the maximum condition, and the size of the compression order or the compression factor does not matter. 5. The stretch factor is a standard value such as 1. 6. The decompression order is equal to the "text flow decompression order".

The main characteristics of this elasticity (body) are as follows. 1. Compressing at the natural size of an object is extremely difficult. 2. The stretch order is less than the "padding threshold stretch order", so when placed in a container such as an HBox or VBox that uses padding elasticity, it does not stretch beyond its natural size. 3. In a VBox if the VBox contains a particular combination of TextFlowBox and a rigid object, because the rigid object's expanded order is greater than the TextFlowBox's compressed order (and similarly, the TextFlowBox's expanded order is greater than the rigid object's compressed order). Does not cause any of the objects contained in to compress all other objects in the VBox below the desired width.

Assuming that a width has been assigned to the TextFlowBox during width-first layout negotiation, the TextFlowBox's height preference is such that the natural size has the height required for the layout of the text contained within the TextFlowBox. Compressed as rigid elasticity.

Objects of Constant Aspect Ratio The third set of objects includes image-like graphics. Such graphics are of different sizes, but for good display, they are represented by a particular "aspect ratio" (height-to-width ratio). Such objects can be treated the same as rigid objects if the desired height and width are known.
However, in some cases it is convenient to have variable heights and widths to allow the object size to fit around it. This is done by providing stretch elasticity during the first layout negotiation pass (ie by providing stretch elasticity as a width preference during width-first layout negotiation).
Achievable with the Curl layout system. This stretch elasticity makes it possible to obtain a desired level that matches the surrounding graphics regardless of the parameters. During the second layout negotiation pass, the size allocated during the first layout negotiation pass (ie the width in the case of width-first layout negotiation) is known. Therefore, the size preference returned during the second layout negotiation pass is stiffness elasticity, which has its natural size between the aspect ratio of the object and the first layout negotiation pass. Calculated using the allocated size and.

Elastic Overrides In some cases, it may be beneficial to override (update or overwrite) the default width or height preferences for graphic objects. The updated new value can be used when the graphic object reports its own preferences to the parent object, thereby communicating the graphic relationships created by the override to the parent graphic object. . Cu
Override rl with "width" and "height" options as follows:
It's easy to do. {Fill width = 2cm, height = 1cm}

The values specified with these options may be either linear measurements such as "2 cm" in the above example or other elasticity values. If the supplied width or height value is an OriginElastic, use it directly as an alternative value, otherwise as the width or height preference provided by the graphic object. However, if the supplied value is not an OriginElastic, use the supplied value as a guide in modifying the OriginElastic returned by the object and use it for layout purposes by the graphic's parent object (for example, an HBox container). It is necessary to calculate the actual used OriginElastic override.

If the width and height supplied are linear measurements, such as 2 cm, then the values are such that the stiffness elasticity is equal to the linear measurements (as described in the section "Simple Rigid Objects" above). To)). Therefore, there are only two cases when determining the override OriginElastic for a graphic object. 1. In the previous case where the override width or height value is supplied as an OriginElastic. 2. If the supplied value is elastic.

In the former case, the graphic object is the supplied override Orig.
It stores the inElastic and simply returns it when the OriginElastic is requested.

In the latter case, it is desirable to calculate the override OriginElastic with the following two characteristics. 1. Override OriginElastic's two component elastic sum (using the elastic add operation) equals the supplied width or height value. 2. Subject to constraint (1), the relationship between the two component elasticity of the override OriginElastic should be as close as possible to the relationship between the two component elasticity of the original OriginElastic supplied by the object representing the basic settings for width and height. .

FIG. 23 shows the horizontal alignment of two text boxes and their corresponding elasticity. Two text boxes X and Y are contained within the graphic object HBox. For the purposes of this example, the composition of the text boxes (X and Y) is HBox
Suppose that the origin of is configured to be on the line separating the two text boxes (X and Y). The original OriginElastic returned is represented by the line containing A and B. The original OriginElastic is returned when the width value is cancelled. T represents the state when the width value is canceled. As mentioned above, the override value is an optional value (often expressed as rigidity elasticity).
Or Origin Elastic. If the override value is OriginElastic, you do not need to perform a calculation to return the override OriginElastic, and the supplied
It just puts the OriginElastic back in. If no override value is provided, the override OriginElastic needs to be calculated.

In particular, because property (2) is a somewhat subjective measure, there are several different ways to calculate the Override OriginElastic that is said to have these properties. The method outlined below is the method actually used in Curl execution and has been proven to calculate reasonable values for practical use. In the explanation below,
A and B (FIG. 23) represent the "first" and "last" components of OriginElastic. T represents the elasticity supplied as a width option value. AA and BB represent the first and last components of the resulting override OriginElastic. This method is described using the Curl programming notation. The code uses two procedures (subroutines): decompression distribution to components and decompression distribution to the first. Lines beginning with a vertical bar of "|" include comments.

[0102]

[Equation 1]

[0103]

[Equation 2]

[0104]

[Equation 3]

[0105]

[Equation 4]

[0106]

[Equation 5]

[0107]

[Equation 6]

[0108]

[Equation 7]

[0109]

[Equation 8]

[0110]

[Equation 9]

FIG. 24 shows the hierarchy of the graphic objects shown in FIG. Graphic Container Object HBox 150 is Graphic Object X and Y
It is the root of the hierarchy that contains 156. Each graphic object has an associated layout object 154, which describes the position and size of the displayed object. Override 152 is Elastic or Orig
Stored in the graphic hierarchy with either inalElastic.

FIG. 25 shows a flowchart of a method for providing an override to a graphic object defined (determined) using elasticity. This process is step 16
Starts with 0. First, the original OriginalElastic is determined from the graphic object (step 162). The original OriginalElastic is calculated for the composite graphic object and then simply stored for the graphic object. If the override is not associated with a graphic object (step 164), the original OriginalElastic is simply copied to the originalElastic obtained by the override (step 166).
If an override is present, a new overridden OriginalElastic is calculated from the original OriginalElastic and the stored override elasticity (see the method described using the Curl programming notation above) (step 168). Then the new OriginalElastic (steps 166-168) is added to step 17
Returned at 0. The process ends at step 172.

Overriding elasticity is an effective mechanism for changing the display characteristics of a graphic object while preserving certain display relationships. In particular, the relationship between the two component elasticity in the overridden new OriginalElastic is close to the relationship between the two component elasticity in the original OriginalElastic.

Curl's Three-Pass Layout Negotiation Algorithm As previously described, Cuel supports two negotiation instructions, breadth-first and height-first. For this application, the text is first formatted into horizontal lines (for example, when using Western European languages), and width-first negotiation generally yields good results, as shown above in the width preference for TextFlowBox. Derive. The following description describes breadth-first layout negotiation. The details of the height-first negotiation are completely similar, except that the width and height are swapped.

The width-first layout negotiation with the object g is started when the parent of the object calls the get-width-preference method of g. This method serves to return the elasticity of the pair (or information that can be transformed into the elasticity of the pair) and describes the basic setting of g for the amount of space allocated to the left and right ranges. If G is a Box, this information is generally derived by invoking the width preference get method of each of the graphic's child objects of g and combining the results in the proper manner.

Width-First Layout Negotiation with g The following steps occur when the constrained width method of g is invoked. This method takes as argument the left and right range values calculated for g and serves to return the elasticity of the pair (or information that can be converted into elasticity of the pair), the amount of space allocated to the upper and lower parts. Describe the basic settings of g for. If g is a Box, this method generally computes the left-right bounds for each graphic child of g and then calls the constraint-width method on each child object to set the height preference for each child. obtain. Then combine these height preferences in the proper way to derive a height preference for g.

The final step of layout negotiation occurs when the set size method of g is invoked. This method takes as arguments the left and right bounds assigned to g and a description of the upper and lower parts. g makes a description of this information for future reference. If g is a Box, it is expected to call the set size method on each of the graphic's children with the proper arguments.

This layout negotiation method does not need information about the height preferences until a width decision is made, so objects such as text blocks and graphics can be created until their width allocation is known. Provides an opportunity to postpone determining the height preferences. This way, word wrap (word wra
Both paragraphs with p) and figures with constant aspect ratio can be formatted to a higher degree.

17, 18 and 19 represent flow charts illustrating how an exemplary graphic container HBox handles layout. Each flow chart illustrates the function of the HBox in one of the three paths of the three path width first layout negotiation. The functions in height-first layout negotiation are similar, but the detailed sequence of operations is different.

The method of calling the HBox during three phase layout negotiation is as follows. First pass: {HBox, get-width-preference} Second pass: {HBox, constrain-width lextent: float, rextent: float} Third pass: {HBox, set-size bounds: GRect}

The HBox.get-width-preference method (origin width acquisition method) returns OriginElastic representing the width basic setting of the HBox, and HBox.constrain-width (width constraint method) OriginElastic representing the height basic setting of the HBox. Bring back. The lextent and rextent arguments to HBox. Constrain-width give the left and right bounds assumed for the purpose of calculating the HBox's height preference. The GRect object supplied as an argument to HBox.set-size contains the left and right bounds that represent the rectangular area allocated for the HBox and four floating point numbers that represent the top and bottom values. .

Next, the flowcharts 17, 18, and 19 will be described. The graphic layout is a complex tree, where each object can be a parent object with many child components, which can themselves be parents to their children, thus I'll grow tired. 17 to 1
Each of the nine flow charts represents a process in a child component when the corresponding routine is called by its parent. Within each routine, the child makes the same call to each of its children. In this way, the call passes from the root of the tree to the leaves and returns their respective results through the tree root.

A case where the flow chart is restricted is when the HBox is aligned with the origin of the objects it contains and does not contain the logic necessary to align the bottom, top, or center. By specifying the logic for the HBox that has these additional functions, clear execution becomes possible. The flow chart is described with respect to the simple example of FIG. 9, where a call is made to the HBox, which in turn makes a call to its three children A, B, C.

Calculations are described using some variables that are understood exclusively in HBox. This includes: A, D, R: Elasticity used for internal calculation. P: elasticity used for padding. C: A pointer to the child graphic object currently targeted. i: integer index variable. CWE: An array of OriginElastics that stores the width preferences received from the child objects. CHE: OriginElastics that stores the height preferences received from the child objects
Array of. RR: An array of elastics used to accumulate the width preference of the HBox. letent, rextent, ascent, descent, casc, cdese, cp, after, cspace: Numbers used to allocate size and position for graphic objects. CLEX and CREX: An array for each of the left and right extents calculated on the child objects. XPOS: An array of x coordinates of the origin of the child objects. CBOUNDS: GRect object.

When the parent of the HBox calls get-width-preference (width basic setting acquisition) (FIG. 17), the HBox in this example returns the width elasticity WE composed of left and right elasticity (body) L and R. . The left elasticity of the HBox is the left elasticity of the object A, and the right elasticity is the sum of the remaining elasticity AR, BL, CL, CR shown in FIG. Finally, the HBox itself executes a get-width-preference (get width width main setting) call for each of its children A, B, C to obtain the respective left and right elasticity. Specifically, at 102, the left and right resilience of the HBox is initially set to zero and the number of HBox children i is set to three. 104, i is 3 first
, And thus greater than zero, so that the system continues at 106. In 106, HBox gets-width-preference (get basic width setting) for its child C (i = 3)
Make a call and receive CL and CR. The right elasticity stays at zero and is stored in R [3] for reference in subsequent methods. The overall width preference of child C is also stored in CWE [3] for reference in subsequent methods. The right component CR of the child C is added to the value R and the HBox
Serves as an accumulation of the right elasticity of. (In the flow chart, the terms final component / first component refer to right range / left range and lower / upper part, respectively, depending on whether a breadth-first or height-first process is performed. In this example, Last / first matches right / left).

In order to further process the child C, i = 3 in 108 and the left component CL of the child C is set.
Add 110 to the right component R of the HBox. The index i is reduced at 112 and compared to zero at 104. In the next loop, BR and BL are 106 and 110 as well.
It is added to R and the value RR [2] is stored. Specifically, RR [2] is the sum of left and right elasticity of the child C.

In the final loop of this example, child A is processed. The value RR [1] is the sum of the left and right elasticity of the children B and C. The right elasticity AR adds to the right elasticity R of the HBox at 106, but at 108 the system progresses to 114. Therefore, the left elasticity AL of the final child A becomes the left elasticity of HBox. Finally, using i reduced to zero at 112, the left and right elasticity L and R are Origin
Form alElastic WE. OriginalElastic for HBox is returned to its parent.
Its value goes through the parent's get-width-preference routine for the root of the tree and back into the tree.

Next, the width constraint is passed through the constraint-width call (FIG. 18) to the tree below, and the HBox is composed of the calculated upper and lower parts of the Original.
Return to Elastic HE.

Upon receiving the constrain-width call, the HBox performs the method of FIG. Based on the left-right elasticity calculated by the method of FIG. 17 and the padding elasticity for the HBox, at 118, the padding is divided through the lextent and rextent
Remove from (left and right range included in parent call). The upper and lower parts are initialized to zero, like the value cp at the cursor position. The constrain-width process processes the children from left to right to determine the left edge of the adjacent region where cp is allocated,
Count right from the origin of the HBox. The child index i is set to 1 for left-to-right processing. The value "after" is the distance split between children, initially set to rextent (Fig. 21A).

At 120, i is less than three HBox children, and the system continues at 122. At 122, the left and right elasticity h of the child A is stored in L and R. At 124, i =
1 and the system progresses to 126. In 126, HBox is lextent CLEX [1] and re
xtent CREX [1] is calculated and sent to child A in a constraint-width call. The lextent sent to the first child A is the lextent received by the HBox. CL
Increase cp with lextent, using the lextent assigned to EX [1]. The rextent sent to the child A is a value excluding the value calculated in the split operation. Figure 21
As shown in A, the "after" distance is equal to the rextent received at this point in the method, and the right elasticity R of child A and the accumulated child B and C in the first pass. It needs to be split between the width basic setting RR [1]. Assigned to elasticity R
The "after" part is the value cspace.

The value cspace is then sent to child A as a constrained rexent. , The child height OrigonalElastic, which determines the upper and lower elasticity A and D, is returned from the child A. The value XPOS [1] that sets the distance to the origin of the child relative to the origin of the HBox sets child A to zero. The reason for this is that the origin of the HBox is defined to be the same as the origin of the leftmost child.

At 128, the cursor pointer cp is incremented by cspace to the left edge of A and the child index is incremented by 1. The distance "after" in the allocated state is allocated between the left and right ranges of B and C, as shown in FIG. 21B by subtracting cspace of FIG. 21A from "after" of FIG. 21A. Calculated by providing the distance.

From 120, the method returns to 122 to process the second child. The elasticity of the left and right sides of the child B calculated by the method of FIG. 17 determines L and R (FIG. 21B). This method processes from 124 to 130 because the first child has already been processed. The cspace allocated is then calculated by dividing the distance "after" between L + R and RR [2]. Next, the value cspace is divided according to the elasticity L and R on the left and right of the child B, CLEX [2] is determined, and cs
The difference between pace and CLEX [2] determines CREX [2]. The origin position of child BXPOS [2] is CL
Determined by adding EX [2] to the left edge of child B determined by cp. The HBox also provides a constraint-width call to child B to compute child B CLEX.
Constrain to [2] and CREX [2], and receive the elasticity of its upper and lower parts from child B. Next, the elasticity A, D of the upper side and the lower side with respect to the HBox is the current values A, D of the upper side and the lower side of the HBox and the values of the upper side and the lower side returned from the child B. Is determined through the maximum operations applied to.

In the next loop, the method processes the third child in steps 122 and 130 similarly. The HBox then returns its height, OriginElastic, which is the maximum upper and lower sides for the three children A, B, and C.

FIG. 19 illustrates a set-size method whereby an HBox is provided with its left range, right range, upper and lower parts, and the HBox assigns appropriate values to each of its children. Pass through. At 134, the proper padding for the HBox is stored at P. The upper and lower parts are taken from the component provided in the call from the parent and the child index is set to 1. For the first child, the method goes through decision processes 136-138. At 138, the upper and lower resiliences A and D for the child A are determined by the corresponding components of the child's height elasticity (body), which deviates from the calculation of FIG. Next, the casc and cdesc of the upper and lower parts of the child are
Calculated by a split operation that splits the upper, lower, and upper and lower bounds according to padding elasticity (FIG. 22). Then the boundary of the child
It is determined for the child from the range previously constrained by the constraint-width method (FIG. 18) and the upper and lower sides calculated here. Then these boundaries are se
It is provided to the child through a t-size call and the child index is incremented by 1. Once the boundaries of each child have been determined, the method returns from decision 136 to the parent.

While the present invention has been illustrated and described in detail in terms of preferred embodiments, those skilled in the art can make changes in shape or detail without departing from the spirit and scope of the invention as defined in the appended claims. It will be appreciated that various modifications can be made.

[Brief description of drawings]

FIG. 1 shows an example of a display window containing a number of graphic objects illustrating the use of the present invention.

FIG. 2 is a partial view of the hierarchy of graphic objects displayed in the window of FIG.

FIG. 3 illustrates the concept of elasticity, in which the size of two graphic objects has changed to fill a variable window width.

FIG. 4 shows the left and right extents of the graphic object relative to the original, the upper and lower parts.

FIG. 5 is a diagram of using a vertical origin to align a graphic object with a baseline of a line of text.

[Figure 6]   6 illustrates a hierarchy of graphic objects displayed in FIG.

FIG. 7 is a diagram of using a horizontal origin to align a graphic object with a sequence of numbers.

[Figure 8]   8 shows a hierarchy of graphic objects displayed in FIG. 7.

FIG. 9 shows the left and right ranges of three graphic objects of the Hbox and the corresponding elastic bodies.

[Figure 10]   A grid of four graphic objects is shown.

FIG. 11   Shows the use of HBox padding containing three rectangles of different height.

[Fig. 12]   Demonstrates the use of HBox padding that centers rectangles of different heights.

[Fig. 13]   3 illustrates a horizontally arranged graphic hierarchy of three text boxes.

FIG. 14 shows the horizontal placement of the three text boxes of FIG. 13 given the desired width.

FIG. 15 shows the horizontal alignment of the three text boxes of FIG. 14 given a width that is somewhat narrower than desired.

FIG. 16 shows the horizontal alignment of the three text boxes of FIGS. 14 and 15 when given a width much narrower than desired.

FIG. 17 is a flow chart showing the first pass of the three pass method for the HBox process.

FIG. 18 is a flow chart showing the second pass of the three pass method for the HBox process.

FIG. 19 is a flowchart showing the third pass of the three pass method for the HBox process.

FIG. 20 shows three graphical objects used to describe the method of FIG.
Indicates HBox.

FIG. 21A   An example of the method of FIG. 18 is shown.

FIG. 21B   18 shows another example of the method of FIG.

FIG. 22   The method of FIG. 19 is shown.

FIG. 23 shows the horizontal alignment of two text boxes and their corresponding elasticity values including overrides.

FIG. 24   FIG. 24 shows a hierarchy of graphic objects displayed in FIG.

FIG. 25   6 is a flow chart illustrating a method of providing elastic override.

─────────────────────────────────────────────────── ─── Continued front page    (81) Designated countries EP (AT, BE, CH, CY, DE, DK, ES, FI, FR, GB, GR, IE, I T, LU, MC, NL, PT, SE), OA (BF, BJ , CF, CG, CI, CM, GA, GN, GW, ML, MR, NE, SN, TD, TG), AP (GH, GM, K E, LS, MW, MZ, SD, SL, SZ, TZ, UG , ZW), EA (AM, AZ, BY, KG, KZ, MD, RU, TJ, TM), AE, AG, AL, AM, AT, AU, AZ, BA, BB, BG, BR, BY, BZ, C A, CH, CN, CR, CU, CZ, DE, DK, DM , DZ, EE, ES, FI, GB, GD, GE, GH, GM, HR, HU, ID, IL, IN, IS, JP, K E, KG, KP, KR, KZ, LC, LK, LR, LS , LT, LU, LV, MA, MD, MG, MK, MN, MW, MX, MZ, NO, NZ, PL, PT, RO, R U, SD, SE, SG, SI, SK, SL, TJ, TM , TR, TT, TZ, UA, UG, UZ, VN, YU, ZA, ZW F-term (reference) 5B009 NC07 NG02 NG05                 5E501 AA01 AC15 FA14 FB04

Claims (22)

[Claims] 1. A graphic object is processed and its graphic
A method of laying out objects, the method comprising: determining a desired size for each of a plurality of graphic objects; determining a desired elasticity for each of the plurality of graphic objects; Determining, for each of the plurality of graphic objects identified in, a minimum size of the object, a large graphic processing the plurality of graphic objects and incorporating the plurality of graphic objects. Determining a minimum size and a desired size for the object. 2. The method of claim 1, wherein the processing step performs an addition operation in which each of the minimum size and the desired size of the addition result is the sum of the minimum and desired sizes of a plurality of graphic objects. A method including steps. 3. The method of claim 1, wherein the processing step comprises performing a maximum operation that includes a minimum size and a desired size whose maximum result is greater than a minimum size of the plurality of graphic objects. Performing a maximum operation such that is the desired size of the graphic object that has the least elasticity to other sizes. 4. The method according to claim 3, wherein the elasticity of each graphic object is determined by a separate expansion coefficient and compression coefficient. 5. The method according to claim 1, wherein the processing step includes a dividing operation for dividing a size between a plurality of graphic objects, wherein the divided size is smaller than the minimum size. A method, wherein a split operation splits the size proportionally to a minimum size of the plurality of graphic objects. 6. The method of claim 1, wherein the processing step comprises a split operation, wherein if the split size is greater than the minimum size sum, a surplus or deficiency for the desired size sum is calculated. , A method of dividing its size according to the elasticity of each object based on the required change from the desired size. 7. The method of claim 6, wherein elasticity is determined by separate stretch and compressibility characteristics. 8. The method of claim 7, wherein elasticity is based on stretch and compression orders and, when the orders are equal, on separate stretch and compression factors. 9. The method of claim 1, wherein elasticity is based on stretch and compression orders and, when the orders are equal, on separate stretch and compression factors. 10. A data structure of a data processing system for determining elasticity for a layout of a graphic object, the data structure being specified independently of a desired size, elasticity, and the desired size and elasticity of the graphic object. A data structure that contains a minimum size and. 11. The data structure of claim 10, wherein the elasticity includes compressibility and extensibility properties. 12. The data structure of claim 11, wherein the compressibility and decompression characteristics include compression and decompression factors and compression and decompression orders. 13. The data structure according to claim 10, wherein the elasticity includes a modulus of elasticity and an elasticity order. 14. A data processing system comprising: means for determining a desired size of each of the plurality of graphic objects; means for determining elasticity of each of the plurality of graphic objects; Means for determining a minimum size of each of the objects, which is specified independently of said desired size and elasticity, and a large graphic object processing said plurality of graphic objects and incorporating said plurality of graphic objects. A system for determining a minimum size and a desired size for the system. 15. The method according to claim 14, wherein the processing step performs an addition operation in which each of the minimum size and the desired size of an addition result is the sum of the minimum and desired sizes of a plurality of graphic objects. A system that includes steps. 16. The method of claim 14, wherein the processing step is a maximum operation including a minimum size and a desired size whose maximum result is greater than a minimum size of the plurality of graphic objects, the desired size being another. A system comprising performing a maximum operation that results in a desired size of the graphic object that has minimal elasticity to size. 17. The system according to claim 16, wherein the elasticity of each graphic object is determined by separate stretch and compression factors. 18. The method according to claim 14, wherein the means for processing the plurality of graphic objects processes a division operation for dividing a size among the plurality of graphic objects, and the size of the division target is the minimum. A system, wherein the dividing operation divides the size in proportion to each minimum size of the plurality of graphic objects if the size is less than the sum of the sizes. 19. The method according to claim 14, wherein the processing means includes means for processing a division operation, and when the size of the division target is larger than the sum of the minimum sizes, a surplus or a shortage with respect to the sum of the desired sizes. And dividing the size according to the elasticity of each object based on the required change from the desired size. 20. The system of claim 19, wherein elasticity is determined by separate stretch and compressibility characteristics. 21. The system of claim 20, wherein elasticity is based on stretch and compression orders, and when the orders are equal, separate stretch and compression factors. 22. The system of claim 14, wherein elasticity is based on stretch and compression orders and, when the orders are equal, on separate stretch and compression factors.