"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 1998 by Andreas Vogel / eXept Software AG

              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.

"

"{ Package: 'stx:libwidg2' }"

"{ NameSpace: Smalltalk }"

PanelView subclass:#GridBagLayoutView

	instanceVariableNames:'columnWidths rowHeights columnWeights rowWeights layoutInfo'

	classVariableNames:''

	poolDictionaries:''

	category:'Views-Layout'

!

!GridBagLayoutView class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1998 by Andreas Vogel / eXept Software AG

              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.

"

!

documentation

"

GridBagLayout is a flexible layout manager that aligns components vertically and horizontally,

without requiring that the components be the same size. Each GridBagLayout uses a dynamic rectangular 

grid of cells, with each component occupying one or more cells (called its display area).

Each component managed by a GridBagLayout is associated with a GridBagConstraints instance that 

specifies how the component is laid out within its display area. How a GridBagLayout places a set of 

components depends on each component's GridBagConstraints and minimum size, as well as the preferred 

size of the components' container.

To use a GridBagLayout effectively, you must customize one or more of its components' GridBagConstraints.

You customize a GridBagConstraints object by setting one or more of its instance variables:

    gridX

    gridY

		Specifies the cell at the upper left of the component's display area, where the 

		upper-left-most cell has address gridX=0, gridY=0. Use #RELATIVE (the default value)

		to specify that the component be just placed just to the right of (for gridX)

		or just below (for gridY) the component that was added to the container just before 

		this component was added.

    gridWidth

    gridHeight

		Specifies the number of cells in a row (for gridWidth) or column (for gridHeight)

		in the component's display area. The default value is 1. Use #REMAINDER to specify

		that the component be the last one in its row (for gridWidth) or column (for gridHeight).

		Use #RELATIVE to specify that the component be the next to last one in its row 

		(for gridWidth) or column (for gridHeight).

    fill

		Used when the component's display area is larger than the component's requested size

		to determine whether (and how) to resize the component.

		Valid values are

		    #NONE

			(the default),

		    #HORIZONTAL

			(make the component wide enough to fill its display area

			horizontally, but don't change its height),

		    #VERTICAL

			(make the component tall enough to fill its display area

			vertically, but don't change its width), and

		    #BOTH       

			(make the component fill its display area entirely).

    ipadX

    ipadY

		Specifies the internal padding: how much to add to the minimum size of the component.

		The width of the component will be at least its minimum width plus ipadX*2 pixels

		(since the padding applies to both sides of the component). Similarly, the height of 

		the component will be at least the minimum height plus ipadY*2 pixels.

    insets

		Specifies the external padding of the component -- the minimum amount of space between 

		the component and the edges of its display area.

    anchor

		Used when the component is smaller than its display area to determine where (within the area) 

		to place the component.

		Valid values are

			#CENTER (the default),

			#NORTH,

			#NORTHEAST,

			#EAST,

			#SOUTHEAST,

			#SOUTH,

			#SOUTHWEST,

			#WEST, 

			#NORTHWEST.

    weightX

    weightY

		Used to determine how to distribute space; this is important for specifying resizing 

		behavior. Unless you specify a weight for at least one component in a row (weightX)

		and column (weightY), all the components clump together in the center of their container.

		This is because when the weight is zero (the default), the GridBagLayout puts any extra 

		space between its grid of cells and the edges of the container.

    [see also:]

	GridBagConstraints

	GridBagLayoutInfo

	Insets

    [author:]

	Andreas Vogel

"

!

examples

"

    This example is taken from the java source and should produce the same layout. Check the file

    Grid*.gif in the java distribution.

									[exBegin]

	| v p c |

	c := #(

	    #( fill: #BOTH weightX: 1.0 )                         

	    #( fill: #BOTH weightX: 1.0 )                         

	    #( fill: #BOTH weightX: 1.0 )                         

	    #( fill: #BOTH weightX: 1.0 gridWidth: #REMAINDER ) 

	    #( fill: #BOTH gridWidth: #REMAINDER )                

	    #( fill: #BOTH gridWidth: #RELATIVE )                 

	    #( fill: #BOTH gridWidth: #REMAINDER )                

	    #( fill: #BOTH weightY: 1.0 gridHeight: 2 )

	    #( fill: #BOTH gridWidth: #REMAINDER )                

	    #( fill: #BOTH gridWidth: #REMAINDER )                

	).           

	v := StandardSystemView new. v label:'GridBagLayoutView: Example 1'.

	p := GridBagLayoutView in:v. p origin:(0.0 @ 0.0) corner:(1.0 @ 1.0).

	1 to: c size do:[ :i | | b |

	    b := Button label:('Button ',(i displayString)) in:p. 

	    b objectAttributeAt:#GridBagConstraints put:((#(GridBagConstraints) , (c at:i)) decodeAsLiteralArray). 

	].

	v extent:(p preferredExtent). v open.

									[exEnd]

									[exBegin]

	| v p c |

	c := #(

	    #( insets: #(Insets 2 2 2 2) fill: #BOTH weightX: 1.0 )                         

	    #( insets: #(Insets 2 2 2 2) fill: #BOTH weightX: 1.0 )                         

	    #( insets: #(Insets 2 2 2 2) fill: #BOTH weightX: 1.0 )                         

	    #( insets: #(Insets 2 2 2 2) fill: #BOTH weightX: 1.0 gridWidth: #REMAINDER ) 

	    #( insets: #(Insets 2 2 2 2) fill: #BOTH gridWidth: #REMAINDER )                

	    #( insets: #(Insets 2 2 2 2) fill: #BOTH gridWidth: #RELATIVE )                 

	    #( insets: #(Insets 2 2 2 2) fill: #BOTH gridWidth: #REMAINDER )                

	    #( insets: #(Insets 2 2 2 2) fill: #BOTH weightY: 1.0 gridHeight: 2 )

	    #( insets: #(Insets 2 2 2 2) fill: #BOTH gridWidth: #REMAINDER )                

	    #( insets: #(Insets 2 2 2 2) fill: #BOTH gridWidth: #REMAINDER )                

	).           

	v := StandardSystemView new. v label:'GridBagLayoutView: Example 2'.

	p := GridBagLayoutView in:v. p origin:(0.0 @ 0.0) corner:(1.0 @ 1.0).

	1 to: c size do:[ :i | | b |

	    b := Button label:('Button ',(i displayString)) in:p. 

	    b objectAttributeAt:#GridBagConstraints put:((#(GridBagConstraints) , (c at:i)) decodeAsLiteralArray). 

	].

	v extent:(p preferredExtent). v open.

									[exEnd]

"

! !

!GridBagLayoutView class methodsFor:'instance creation'!

new

    "Create a new instance of my class and do explizit initialization of it."

    ^ self basicNew initialize

    "Created: / 19.1.1998 / 13:53:11 / av"

    "Modified: / 1.2.1998 / 13:02:59 / av"

! !

!GridBagLayoutView methodsFor:'initialization'!

initialize

    "Initialize the instance. Mainly set our instance variables to required values."

    super initialize.

    columnWidths  := IdentityDictionaryWithDefault newWithDefaultValue:0.

    rowHeights    := IdentityDictionaryWithDefault newWithDefaultValue:0.

    columnWeights := IdentityDictionaryWithDefault newWithDefaultValue:0.0.

    rowWeights    := IdentityDictionaryWithDefault newWithDefaultValue:0.0.

    layoutInfo    := nil.

    "Created: / 19.1.1998 / 13:53:59 / av"

    "Modified: / 1.2.1998 / 12:57:05 / av"

! !

!GridBagLayoutView methodsFor:'layout'!

setChildPositions

    "(re)compute position of every child whenever children are added or my size has changed"

    self arrangeGrid.

    "Modified: / 01-02-1998 / 12:52:22 / av"

    "Modified (comment): / 09-11-2017 / 10:43:16 / mawalch"

! !

!GridBagLayoutView methodsFor:'private'!

adjustForGravity:c in:r

    |insets fill anchor diffx diffy add |

    insets := c insets.

    fill := c fill.

    anchor := c anchor.

    r setLeft: ((r left)   + (insets left)).

    r width:   ((r width)  - ((insets left) + (insets right))).

    r setTop:  ((r top)    + (insets top)).

    r height:  ((r height) - ((insets top) + (insets bottom))).

    diffx := 0.

    (fill ~~ #HORIZONTAL and:[(fill ~~ #BOTH) and:[(r width) > (add := (c minWidth) + (c ipadX))]]) ifTrue:[

        diffx := (r width) - add.

        r width:add.

    ].

    diffy := 0.

    (fill ~~ #VERTICAL and:[(fill ~~ #BOTH) and:[(r height) > (add := (c minHeight) + (c ipadY))]]) ifTrue:[

        diffy := (r height) - add.

        r height:add.

    ].

    (anchor == #CENTER) ifTrue:[

        r setLeft:((r left) + (diffx / 2)).

        r setTop:((r top) + (diffy / 2)).

    ].

    (anchor == #NORTH) ifTrue:[

        r setLeft:((r left) + (diffx / 2)).

    ].

    (anchor == #NORTHEAST) ifTrue:[

        r setLeft:((r left) + diffx).

    ].

    (anchor == #EAST) ifTrue:[

        r setLeft:((r left) + diffx).

        r setTop:((r top) + (diffy / 2)).

    ].

    (anchor == #SOUTHEAST) ifTrue:[

        r setLeft:((r left) + diffx).

        r setTop:((r top) + diffy).

    ].

    (anchor == #SOUTH) ifTrue:[

        r setLeft:((r left) + (diffx / 2)).

        r setTop:((r top) + diffy).

    ].

    (anchor == #SOUTHWEST) ifTrue:[

        r setTop:((r top) + diffy).

    ].

    (anchor == #WEST) ifTrue:[

        r setTop:((r top) + (diffy / 2)).

    ].

    (anchor == #NORTHWEST) ifTrue:[

    ].

    r setLeft: ((r left)   asInteger).

    r setTop:  ((r top)    asInteger).

    r width:   ((r width)  asInteger).

    r height:  ((r height) asInteger).

    ^ r

    "Modified: / 22.1.1998 / 09:50:01 / av"

!

arrangeGrid

    " Lay out the grid."

    | insets subViews info ext d r c diffw diffh weight |

    insets := Insets new.

    "/ If the parent has no slaves anymore, then don't do anything

    "/ at all:  just leave the parent's size as-is.

    (((subViews := self subViews) size) == 0) ifTrue:[^ self].

"/    self extentChangedFlag ifTrue:[

"/        ext    := self computeExtent.

"/        width  := ext x.

"/        height := ext y.

"/    ].

    "/ Pass #1: scan all the slaves to figure out the total amount

    "/ of space needed.

    info := self getLayoutInfo:#PREFERRED_SIZE.    

    d := self getMinSize:info.

    ((width < (d width)) or:[(height < (d height))]) ifTrue:[

        info := self getLayoutInfo:#MINIMUM_SIZE.    

        d := self getMinSize:info.

    ].

    layoutInfo := info.

    r := Rectangle origin:0@0 extent:((d width) @ (d height)).

    "/ If the current dimensions of the window don't match the desired

    "/ dimensions, then adjust the minWidth and minHeight arrays

    "/ according to the weights.

    diffw := width - (r width).

    (diffw ~~ 0) ifTrue:[

        weight := 0.0.

        0 to:((info width) - 1) do:[ :i |

            weight := weight + ((info weightX) at:(i + 1)).

        ].

        (weight > 0.0) ifTrue:[

            0 to:((info width) - 1) do:[ :i |    

                | dx |

                dx := ((diffw * ((info weightX) at:(i + 1))) / weight) asInteger.

                (info minWidth) at:(i + 1) put:(((info minWidth) at:(i + 1)) + dx).

                r width:((r width) + dx).

                (((info minWidth) at:(i + 1)) < 0) ifTrue:[

                    r width:((r width) - ((info minWidth) at:(i + 1))).

                    (info minWidth) at:(i + 1) put:0.

                ].

            ].

        ].

        diffw := width - (r width).

    ] ifFalse:[

        diffw := 0.

    ].

    diffh := height - (r height).

    (diffh ~~ 0) ifTrue:[

        weight := 0.0.

        0 to:((info height) - 1) do:[ :i |

            weight := weight + ((info weightY) at:(i + 1)).

        ].

        (weight > 0.0) ifTrue:[

            0 to:((info height) - 1) do:[ :i |    

                | dy |

                dy := ((diffh * ((info weightY) at:(i + 1))) / weight) asInteger.

                (info minHeight) at:(i + 1) put:(((info minHeight) at:(i + 1)) + dy).

                r height:((r height) + dy).

                (((info minHeight) at:(i + 1)) < 0) ifTrue:[

                    r height:((r height) - ((info minHeight) at:(i + 1))).

                    (info minHeight) at:(i + 1) put:0.

                ].

            ].

        ].

        diffh := height - (r height).

    ] ifFalse:[

        diffh := 0.

    ].

    "/ Now do the actual layout of the slaves using the layout information

    "/ that has been collected.

    info startX:(((diffw / 2) + (insets left)) asInteger).

    info startY:(((diffh / 2) + (insets top)) asInteger).

    subViews do:[ :child |

        |rW rH minWidth minHeight|

        c := self constraints:child.

        minWidth := info minWidth.

        minHeight := info minHeight.

        r setLeft:(info startX).

        0 to:((c tempX) - 1) do:[ :i | r setLeft:((r left) + (minWidth at:(i + 1))). ].

        r setTop:(info startY).

        0 to:((c tempY) - 1) do:[ :i | r setTop:((r top) + (minHeight at:(i + 1))). ].

        r width:0.

        (c tempX) to:((c tempX) + (c tempWidth) - 1) do:[ :i |

            r width:((r width) + (minWidth at:(i + 1))).

        ].

        r height:0.

        (c tempY) to:((c tempY) + (c tempHeight) - 1) do:[ :i |

            r height:((r height) + (minHeight at:(i + 1))).

        ].

        self adjustForGravity:c in:r.

        "/ If the window is too small to be interesting then

        "/ unmap it.  Otherwise configure it and then make sure

        "/ its mapped.

        rW := r width.

        rH := r height.

        ((rW <= 0) or:[rH <= 0]) ifTrue:[

            child origin:(0@0) ; width:0 height:0.

        ] ifFalse:[

            child origin:((r left) @ (r top)).

            child width:rW.

            child height:rH.

        ].

    ].

    "Modified: / 1.2.1998 / 12:53:37 / av"

!

constraints:anObject 

    " Get the GridBag constraints for an object. As a fallback create new constraints for objects

      which don't have any constraints yet."

    | c |

    c := anObject objectAttributeAt:#GridBagConstraints.

    c isNil ifTrue:[

	anObject objectAttributeAt:#GridBagConstraints put:(c := GridBagConstraints new)

    ].

    ^ c.

    "Created: / 21.1.1998 / 00:24:34 / av"

    "Modified: / 1.2.1998 / 12:55:23 / av"

!

getLayoutInfo:which

    "return a good extent, one that makes subviews fit"

    | 

        MAX_INT_VAL subViews 

        r i k px py pixelsDiff weightDiff weight nextSize c 

        curX curY curWidth curHeight curRow curCol xMax yMax

    |

    MAX_INT_VAL := 9999999999.

    subViews := (self subViews).

    r := GridBagLayoutInfo new.

    r width:0.

    r height:0.

    xMax := IdentityDictionaryWithDefault newWithDefaultValue:0.

    yMax := IdentityDictionaryWithDefault newWithDefaultValue:0.

    curRow := curCol := -1.

    "/ Pass #1

    "/

    "/ Figure out the dimensions of the layout grid (use a value of 1 for

    "/ zero or negative widths and heights).

    subViews do:[ :child |

        c := self constraints:child.

        curX := c gridX.

        curY := c gridY.

        ((curWidth  := c gridWidth)  <= 0) ifTrue:[ curWidth  := 1. ].

        ((curHeight := c gridHeight) <= 0) ifTrue:[ curHeight := 1. ].

        "/ If x or y is negative, then use relative positioning:

        ((curX < 0) and:[ curY < 0 ]) 

            ifTrue:[

                (curRow >= 0) 

                    ifTrue: [ curY := curRow. ]

                    ifFalse:[ (curCol >= 0) ifTrue:[ curX := curCol. ] ifFalse: [ curY := 0. ]].

            ].

        (curX < 0) 

            ifTrue:[

                px := 0.

                curY to:(curY + curHeight - 1) do: [ :i |

                    px := px max:(xMax at:(i + 1)).

                ].

                ((curX := px - curX - 1) < 0) ifTrue:[ curX := 0. ].

            ]

            ifFalse:[

                (curY < 0) ifTrue:[

                    py := 0.

                    curX to: (curX + curWidth - 1) do: [ :i |

                        py := py max: (yMax at:(i + 1)).

                    ].

                    ((curY := py - curY - 1) < 0) ifTrue:[ curY := 0. ].

                ].

            ].

        "/ Adjust the grid width and height

        px := curX + curWidth.  [ (r width)  < px ] whileTrue:[ r width:((r width) + 1). ].

        py := curY + curHeight. [ (r height) < py ] whileTrue:[ r height:((r height) + 1). ].

        "/ Adjust the xMax and yMax arrays

        curX to:(curX + curWidth  - 1) do:[ :i | yMax at:(i + 1) put:py. ].

        curY to:(curY + curHeight - 1) do:[ :i | xMax at:(i + 1) put:px. ].