rectangle: The bounds of the rectangle.

...: Any normal Shape construction arguments may be passed, including option initializers, transformations, or child Shapes. See Shape.default for details.

The values stored into RectangleShape.rectangle may be different from those in the rectangle passed in. In particular, if the rectangle is inverted such that, for instance, -rectangle.lextent is greater than rectangle.rextent, the inverted dimensions will be swapped. The rectangle passed in will not itself be modified, however.

All shape objects have this option, either inherited or set directly on the object.

Some shape objects do not make use of this property directly. A ShapeGroup for example, does not use this property. It may nevertheless useful to set properties such as this one on a ShapeGroup object, since all of the shape children of the object will inherit those properties by default.

Please see LineStyle for more information.

This is a local option, and applies only to the current object; in other words, it functions similarly to Graphic.border-width.

Legal types of values are:

• number: int, double, etc.
• distance: Distance and FloatDistance.
• pixel distance: PixelDistance and FloatPixelDistance

The default value is 0pt, which means that no border is drawn. Examples of legal values include:

• 2cm
• 1.5in
• 36pt
• 3px
• 36 (which is the same as 36pt)

Note that using a width that evaluates to one pixel results in a performance boost which may be substantial. (This is because the border may be rendered using line-based primitives, rather than solid-filled primitives.) The easiest way to cause this is to use 1pixel (or 1px). However, you must take the Shape's transformation into account. If it has had a scale factor of 2, 2 applied, then a border-width of 1pixel will in fact cover two device pixels, and thus will be slower. The appropriate value in this case would be 0.5px.

Please see Shape.quantize-line-thickness for a more detailed explanation of how values are converted and quantized to pixels.

If you do not desire a filled shape, this option may be set to FillPattern.transparent. Note that this will not generally affect the results of Shape.self-contains-point? or the mouse events delivered to the shape.

All shape objects have this option, either inherited or set directly on the object.

Some shape objects do not make use of this property directly. A ShapeGroup for example, does not use this property. It may nevertheless useful to set properties such as this one on a ShapeGroup object, since all of the shape children of the object will inherit those properties by default.

This option is used for communication purposes within the Curl graphics system. It should not be casually set or unset by user code. It should also not usually be read directly by user code: if you want the current DisplayContext, you should fetch it by calling Visual.get-display-context.

Every graphic hierarchy that can be displayed, whether in a window on the screen or on a printed page, must have at its root an object that sets the display-context option to a DisplayContext object that is suitable for the display medium by means of which the graphic hierarchy will be seen. Thus, an object can tell that it has been attached to a displayable graphic hierarchy by watching for the display-context option's value to change from null to a non-null DisplayContext object. Accordingly, subclasses of Visual that need to take specific actions when they become connected to a displayable graphic hierarchy monitor the display-context option by including an option declaration such as

{nonlocal-option public display-context:#DisplayContext
change handler}

where the code in change handler looks at the current value of the display-context option (available within the change handler as the value of the variable display-context), watching for changes between null and non-null values, and takes any actions that are needed.

Programmers using this programming idiom should be aware, however, that it is fairly common when rearranging graphical displays to detach graphical objects temporarily from a graphic hierarchy and then reattach them to the same hierarchy, which will cause the detached objects to temporarily see the display-context object become null and then become non-null again. Code that monitors changes in the display-context option should take this possibility into account and avoid taking undesired actions in this case.

Do not modify the contents of this GRect. Instead, assign a new value to RectangleShape.rectangle.

Note that the object passed in to the setter (as well as the rectangle argument in the constructor) is copied, not stored by reference, so you do not need to worry about modifying it later or reusing it for other purposes.

The values stored into RectangleShape.rectangle may be different from those in the rectangle passed in. In particular, if the rectangle is inverted such that, for instance, -rectangle.lextent is greater than rectangle.rextent, the inverted dimensions will be swapped. The rectangle passed in will not itself be modified, however.

This implementation returns the value of Visual._style-element but is normally overridden to return a constant value.

If a subclass of Visual should be stylable separately from other types of objects, this getter should be overridden to return an appropriate string. By convention, this string is the name of the class or the name of the markup that produces the object.

An override must return self._style-element if it is not the empty string.

Introduced in: version 6.0

renderer2d: The Renderer2d that this object should use to draw itself.

When subclassing Shape, this method must be overridden.

dest: An optional GRect object to be used to return the data.

A GRect object containing the bounds. This will always be the same object as dest. This GRect must be well-formed; that is, the following must be true: -dest.lextent <= dest.rextent and -dest.ascent <= dest.descent

The bounds returned should cover all pixels that will be painted by this object but do not include all of the children of this object.

Rendering bounds (get-own-bounds) and layout bounds (get-own-layout-bounds) are typically similar, but may differ. In particular, the rendering bounds may be generously inclusive, but the layout bounds must describe the Shape precisely in order for adjacent items to abut properly.

When subclassing Shape, this method must be overridden. The dest parameter must be used to return the data.

lc: The LayoutContext in effect for this layout negotiation.

width-first?: For GraphicShapes, indicates whether the bounds should be calculated using using width-first layout negotation. This parameter is not typically used by other subclasses.

dest: An optional GRect object to be used to return the data.

A GRect object containing the bounds. This will always be the same object as dest. This GRect must be well-formed; that is, the following must be true: -dest.lextent <= dest.rextent and -dest.ascent <= dest.descent

The bounds returned are those that best describe the object for layout purposes but do not include all of the children of this object.

Rendering bounds (get-own-bounds) and layout bounds (get-own-layout-bounds) are typically similar, but may differ. In particular, the rendering bounds may be generously inclusive, but the layout bounds must describe the Shape precisely in order for adjacent items to abut properly.

The default implementation merely calls get-own-bounds. The dest parameter must be used to return the data.

x: The X coordinate of the point.

y: The Y coordinate of the point.

true if this Shape contains (x, y).

The point is in this object's local coordinate system. This method does not consider its children.

When subclassing Shape, this method must be overridden. This method determines when mouse events (such as PointerMotion) will be delivered to this object, among other things.

Generally, you should implement this method to determine whether or not the point lies within any of the rendered primitives of the shape, not simply whether or not it is within the bounds of the shape. However, you are free to implement it using whatever metric you desire.

polygon: An object containing set of points that describe a polygon in this shape's local coordinate space. It is guaranteed that this polygon will be convex and will use a counter-clockwise winding order.

This method is very similar to Shape.self-contains-point?, except that it deals with an area rather than a point. It is primarily used to support area-based selection, but it may also be directly called.

When subclassing Shape, this method must be overridden. It need not consider children.

Generally, you should implement this method to determine whether or not the area intersects with any of the rendered primitives of the shape, not simply whether or not it is within the bounds of the shape. However, you are free to implement it using whatever metric you desire. Users will experience strange results when selecting this object if the implementation of this method disagrees with Shape.self-contains-point?.

If you are not using any selection features, this method can be implemented to simply return false.

Important note: Any overriding implementation of this method should include a call to the superclass implementation in order to ensure that the new area of the object is invalidated.