Class: LayoutFrame

• Inheritance
• Description
• Class protocol
  • instance creation
• Instance protocol
  • accessing
  • comparing
  • computing
  • converting
  • initialization
  • printing & storing
  • queries
• Examples

Inheritance:

   Object
   |
   +--Layout
      |
      +--LayoutOrigin
         |
         +--LayoutFrame
            |
            +--ConstrainedLayoutFrame

Package:

stx:libview2

Category:

Graphics-Geometry

Version:

rev: 1.51 date: 2022/07/19 08:56:03

user: stefan

file: LayoutFrame.st directory: libview2

module: stx stc-classLibrary: libview2

Description:

This class is provided to make porting of existing ST-80/Squeak applications
easier. Instances can be used to control the geometry of a subview, within
its superview. Like a layoutOrigin, it controls the origin of a component
by given fraction and offset dimensions; in addition, the bottom-right
corner is also controlled by corresponding values. 
Therefore, the component's preferredExtent is ignored.

Notice: 
    this class was implemented using protocol information
    from alpha testers - it may not be complete or compatible to
    the corresponding ST-80 class. 
    If you encounter any incompatibilities, please forward a note 
    describing the incompatibility verbal (i.e. no code) to the ST/X team.

copyright
COPYRIGHT (c) 1995 by Claus Gittinger
             All Rights Reserved

This software is furnished under a license and may be used
only in accordance with the terms of that license and with the
inclusion of the above copyright notice.   This software may not
be provided or otherwise made available to, or used by, any
other person.  No title to or ownership of the software is
hereby transferred.

Class protocol:

 bottomFrame: pixels

create a new layoutFrame which makes the child take a fixed frame at the bottom

 bottomInset: pixels

create a new layoutFrame which insets the child at the bottom by some pixels

 fractions: fractionRectangle offsets: offsetRectangle

create a new layoutFrame given a rectangle of fractions and a rectangle of offsets

Usage example(s):

LayoutFrame fractions:(0 @ 0 corner:1.0 @ 1.0) offsets:(0 @ 0 corner:0 @ 0)

 inset: pixels

create a new layoutFrame which insets the child by some pixels

 leftFraction: lF offset: lO rightFraction: rF offset: rO topFraction: tF offset: tO bottomFraction: bF offset: bO

create a new layoutFrame

 leftFraction: lF rightFraction: rF topFraction: tF bottomFraction: bF

create a new layoutFrame

 leftFrame: pixels

create a new layoutFrame which makes the child take a fixed frame at the left

 leftOffset: lO rightOffset: rO topOffset: tO bottomOffset: bO

create a new layoutFrame

 leftOffset: lO topOffset: tO rightOffset: rO bottomOffset: bO

create a new layoutFrame

 origin: origin corner: corner

create a new layoutFrame from an oldStyle origin-corner rectangle.
Added to make migration from Rectangles to LayoutFrames easier.

 rightFrame: pixels

create a new layoutFrame which makes the child take a fixed frame at the right

 topFrame: pixels

create a new layoutFrame which makes the child take a fixed frame at the top

 topInset: pixels

create a new layoutFrame which insets the child at the top by some pixels

Instance protocol:

 bottomFraction

Return the y-coordinate of the bottom of the relative rectangle as a percentage of the height of the reference rectangle.

 bottomFraction: aFraction

Set the y-coordinate of the bottom of the relative rectangle to be a fraction of the height of the reference rectangle.

 bottomFraction: aFraction offset: o

set both bottomFraction (0..1) and offset

 bottomInset: pixels

set bottomOffset for an inset at the bottom

 bottomOffset

return bottomOffset

 bottomOffset: something

set bottomOffset

 fractions: fractionRectangle offsets: offsetRectangle

LayoutFrame fractions:(0 @ 0 corner:1.0 @ 1.0) offsets:(0 @ 0 corner:0 @ 0)

 horizontalInset: aNumber

setup the offsets for insetting horizontally the frame aNumber pixels at all sides

 inset: aNumber

setup the offsets for insetting the frame aNumber pixels at all sides

 leftFraction: lF offset: lO rightFraction: rF offset: rO topFraction: tF offset: tO bottomFraction: bF offset: bO

set all fields

 leftFraction: lF rightFraction: rF

 leftFraction: lF rightFraction: rF topFraction: tF bottomFraction: bF

 leftOffset: lO rightOffset: rO

set the horizontal offset fields

 leftOffset: lO rightOffset: rO topOffset: tO bottomOffset: bO

set all offset fields

 rightFraction

return rightFraction

 rightFraction: aFraction

set rightFraction (0..1)

 rightFraction: rF bottomFraction: bF

 rightFraction: aFraction offset: o

set rightFraction (0..1) and offset

 rightInset: pixels

set rightOffset for an inset at the right

 rightOffset

return rightOffset

 rightOffset: something

set rightOffset

 topFraction: tF bottomFraction: bF

 topOffset: newTopOffset bottomOffset: newBottomOffset

 verticalInset: aNumber

setup the offsets for insetting vertically the frame aNumber pixels
at all sides

 = anObject

 hash

 rectangleRelativeTo: superRectangle preferred: prefRectHolder

compute the rectangle represented by the receiver,
given the superView's rectangle and the view's preferredExtent.

Usage example(s):

|superRect lF| superRect := 0@0 corner:99@99. lF := (LayoutFrame new). lF leftFraction:0.25; topFraction:0.25; rightFraction:0.75; bottomFraction:0.75. lF rectangleRelativeTo:superRect preferred:(0@0 corner:30@30)

 fromLiteralArrayEncoding: encoding

read my values from an encoding.
The encoding is supposed to be of the form:
(LayoutFrame orgOffsX relOrgX orgOffsY relOrgY cornOffsX relCornX cornOffsY relCornY)
This is the reverse to literalArrayEncoding.

Usage example(s):

LayoutFrame new fromLiteralArrayEncoding:#(#LayoutFrame 70 0 2 0 0 1 25 0 ) #(#LayoutFrame 70 0 2 0 0 1 25 0 ) decodeAsLiteralArray

 literalArrayEncoding

encode myself as an array, from which a copy of the receiver
can be reconstructed with #decodeAsLiteralArray.
The encoding is:
(#LayoutFrame orgOffsX relOrgX orgOffsY relOrgY cornOffsX relCornX cornOffsY relCornY)

 initialize

bottomFraction := rightFraction := 1.

 displayOn: aGCOrStream

return a printed representation of the receiver for displaying

 corner

 isLayoutFrame

return true, if this is a layoutFrame

Examples:

    |top button|

    top := StandardSystemView new.
    top extent:300@300.

    button := Button label:'component'.
    top add:button in:(LayoutFrame new
                            leftFraction:0.25;
                            topFraction:0.25;
                            rightFraction:0.75;
                            bottomFraction:0.75).

    top open

    |top button|

    top := StandardSystemView new.
    top extent:300@300.

    button := Button label:'component'.
    top add:button in:(LayoutFrame new
                            leftFraction:0.25; leftOffset:10;
                            topFraction:0.25;  topOffset:-20;
                            rightFraction:0.75;
                            bottomFraction:0.75).

    top open

    |top button|

    top := StandardSystemView new.
    top extent:300@300.

    button := Button label:'component'.
    top add:button in:(LayoutFrame new
                            leftFraction:0.0; leftOffset:10;
                            topFraction:0.0;  topOffset:10;
                            rightFraction:1.0; rightOffset:-10;
                            bottomFraction:1.0; bottomOffset:-10).

    top open