TfpgColor is always in RRGGBB (Red, Green, Blue) format, no matter the operating system.

The fpg_base unit also contains definitions of many useful color constants. It defines the standard predefined Delphi colors (like clRed, clMagenta etc.), the 140 web safe colors using the defacto standard names as used by Netscape and Internet Explorer web browsers. As well as some internal color constants used by many GUI components (like clText, clWindowBackground etc.).

Note that this structure is not a class, so static allocations are allowed. This makes it much easier to use in Widgets and in fpGUI internal messages.

Think of the pixel screen/grid like the grid of a spreadsheet (or as a magnified look of the top corner of your screen).

.
     0   1
   +---+---+---
0  | x |   |
   +---+---+---
1  |   |   |
   +---+---+---
2  |   |   |
   +---+---+---
   |   |   |

x is at (0,0). A pixel is always 1x1, you don't get smaller (we are not using sub-pixels like on LCD screens, because they don't apply to all screens).

So with that example, Width = 1 pixel and Height = 1 pixel. In the case of Classes.Bounds() the Right and Bottom values are (1,1) which looking at the above image will be wrong, the pixel only covers one block, so in a screen/pixel environment, Right, Bottom is also (0,0), the same as Top/Left. This is what TfpgRect.Right and TfpgRect.Bottom will report.

.
     0   1
   +---+---+---
0  | x | x |
   +---+---+---
1  | x | x |
   +---+---+---
2  |   |   |
   +---+---+---
   |   |   |

In this example we have a rectangle. Top/Left = (0,0) and Bottom/Right = (1,1). This means Width = 2 pixels and Height = 2 pixels. Clearly visible in the image above.

But if we call Classes.Bounds(0,0,2,2) it reports Bottom/Right as (2,2) which is wrong (again looking at the image above as reference). This is my point. Bounds() cannot be used in this case in a graphical environment.

The reason I don't use a grid layout as shown below, is because if the mouse is over the rectangle containing x, the OS (graphics system) reports its position as (0,0). You don't have to have the mouse pointer over the intersecting lines at (0,0) as indicated in the image below. The whole square containing the x is referenced as (0,0), hence the grid layout as show in the images above, and what fpGUI uses. The same grid layout as used in TfpgStringGrid or any Spreadsheet program etc.

.
   0   1   2
0  +---+---+---
   | x |   |
1  +---+---+---
   |   |   |
2  +---+---+---
   |   |   |
3  +---+---+---
   |   |   |

fpGUI implements what is called "delayed resource allocation". It delays some action until everything is ready to go. This delayed action applies to setting Widget or Form size and position. Why? Imagine you have a complex form with lots of anchors, alignments and OnResize event handlers. Now somewhere in there you change the size or position of a component.

If fpGUI acted immediately, as every property is set, it means it would have to recalculate all those widget boundaries, and fire all OnResize event handlers of the whole form four times. Once for each property - as you set them. Not very efficient! To reduce such redundant calculations, fpGUI allows you to set all the properties, then act on it once you call UpdateWindowPosition. In most cases fpGUI can even reduce the API calls needed, because it could pass for example Width and Height via one API call. In the case of X11, it can actually do all four values in a single API call. Thus improving efficiency and reduces resize calculations and screen redraws.

. Use the Left property to determine where the left side of the control begins or to reposition the left side of the control.

. Use the Top property to determine where the top side of the control begins or to reposition the top side of the control.

. Use the Width property to read or change the width of the control. For TfpgTabSheet controls of for controls that have their Align property set to alTop, alBottom or alClient, changing this property at runtime has no effect.

. Use the Height property to read or change the height of the control. For TfpgTabSheet controls of for controls that have their Align property set to alLeft, alRight or alClient, changing this property at runtime has no effect.

. This procedure clips a line to the AClipRect boundaries and then calls the DrawLine procedure with the clipped coordinates. If the line lies completely outside of the clip boundary, then the Line routine is not called. This procedure uses the well known Cohen-Sutherland line clipping algorithm to clip each coordinate.

Use this if you do not want to change the Canvas.ClipRegion for some reason. For a detailed explanation see: http://www.nondot.org/~sabre/graphpro/line6.html

. This structure is used inside the fpGUI framework, and includes some extra methods like calculating lengths between to points etc.

Returns the sum of the absolute values of X and Y, traditionally known as the "Manhattan length" of the vector from the origin to the point. For example:

Accuracy is traded for speed. This is a useful, and quick to calculate, approximation to the true length:

The tradition of "Manhattan length" arises because such distances apply to travelers who can only travel on a rectangular grid, like the streets of Manhattan.

For a further explanation of "Manhattan length" see the Wikipedia article on Taxicab geometry.