"

 COPYRIGHT (c) 1997 by 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:libview2' }"

Object subclass:#Menu

	instanceVariableNames:'items groupSizes receiver'

	classVariableNames:''

	poolDictionaries:''

	category:'Views-Support'

!

!Menu class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1997 by 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

"

    not yet finished Menu class - this will eventually replace

    most of the MenuView and PopUpMenu stuff.

    (and hopefully be ST-80 compatible ...)

    For now, only a subset of the full protocol is implemented.

    [author:]

	Claus Gittinger

    [see also:]

	MenuItem

	PopUpMenu

"

! !

!Menu class methodsFor:'instance creation'!

labelArray:arrayOfString lines:linesArray values:valueArrayOrNil

    "return a menu with menu items built with labels from arrayOfString (not Symbols).  

     The linesArray describes which menu items are the last menu item in their group. 

     The valueArray contains value objects for each menu item 

     (or is nil if no value objects are specified)."

    |nLabel valueArray menuItems groupLengths|

    nLabel := arrayOfString size.

    valueArrayOrNil isNil ifTrue:[

        (valueArray := arrayOfString isEmpty) ifTrue: [

            valueArray := #()

        ] ifFalse:[

            valueArray := (1 to:nLabel)

        ]

    ] ifFalse:[

        valueArray := valueArrayOrNil

    ].

    nLabel ~~ valueArray size ifTrue: [

        ^ self error: 'illegal menu combination'

    ].

    menuItems := Array new:nLabel.

    1 to:nLabel do:[:i |

        |mi v|

        mi := MenuItem labeled:(arrayOfString at:i) asString.

        v := valueArray at:i.

        (v isKindOf:Menu) ifTrue:[mi submenu:v].

        menuItems at:i put:mi

    ].

    (linesArray size == 0) ifTrue:[

        groupLengths := (menuItems isEmpty)

                            ifTrue: [Array new:0]

                            ifFalse: [Array with:menuItems size]

    ] ifFalse:[

        groupLengths := Array new:(linesArray size + 1).

        groupLengths at:1 put:linesArray first.

        2 to:linesArray size do: [:i | 

            groupLengths at:i put:((linesArray at:i) - (linesArray at:i - 1))

        ].

        groupLengths at:groupLengths size put:(menuItems size - linesArray last).

    ].

    ^ self new 

        menuItems:menuItems 

        menuItemGroups:groupLengths 

        values:valueArray

    "Modified: / 19.4.1998 / 11:30:18 / cg"

!

labelArray:arrayOfString values:valueArrayOrNil

    "return a menu with menu items built with labels from arrayOfString (not Symbols).  

     The valueArray contains value objects for each menu item 

     (or is nil if no value objects are specified)."

    ^ self 

        labelArray:arrayOfString 

        lines:nil 

        values: valueArrayOrNil

!

labelList:arrayOfGroupStrings values:valueArrayOrNil

    |labels lines|

    lines := arrayOfGroupStrings collect:[:each | each size].

    labels := OrderedCollection new.

    arrayOfGroupStrings do:[:group | labels addAll:group].

    ^ self labelArray:labels lines:lines values:valueArrayOrNil

    "Modified: 20.6.1997 / 10:46:45 / cg"

    "Created: 13.9.1997 / 10:35:46 / cg"

!

labels:aString lines:linesArray values:valueArrayOrNil

    ^ self 

	labelArray:(aString asCollectionOfLines)

	lines:linesArray

	values:valueArrayOrNil

    "Created: / 31.10.1997 / 03:12:20 / cg"

    "Modified: / 31.10.1997 / 03:23:42 / cg"

!

labels:aString values:valueArrayOrNil

    ^ self 

        labelArray:(aString asCollectionOfLines)

        lines:#()

        values:valueArrayOrNil

    "Modified: / 31.10.1997 / 03:23:42 / cg"

    "Created: / 12.11.2001 / 16:06:36 / cg"

! !

indexOfMenuItem:anItem

    ^ items indexOf:anItem

    "Created: / 27.10.1997 / 16:34:19 / cg"

!

menuButtons

    "ST-80 seems to use a special menuButton class here.

     Here, kludge a collection of menuItems."

    ^ items

    "Created: / 27.10.1997 / 16:33:35 / cg"

! !

!Menu methodsFor:'accessing'!

atNameKey:aNameKey

    "return the menuItem for the given nameKey; nil if no such item is in the menu.

     Searches in allItems (i.e. also in subMenus)"

    self allItemsDo:[:anItem|

	anItem nameKey == aNameKey ifTrue:[^ anItem]

    ].

    ^ nil

    "Modified: / 27.10.1997 / 15:12:00 / cg"

!

groupSizes

    "return the value of the instance variable 'groupSizes' (automatically generated)"

    ^ groupSizes

!

groupSizes:something

    "set the value of the instance variable 'groupSizes' (automatically generated)"

    groupSizes := something.

!

labelAt:anIndex

    "gets the label of the menu item at the given index or nil

    "

    |item|

    (item := self menuItemAt:anIndex) notNil ifTrue:[

        ^ item label

    ].

    ^ nil

    "Modified: / 2.2.1998 / 13:28:32 / cg"

!

labelAtValue:aValue

    "gets the label of the menu item assigned to value

    "

    |item|

    item := self menuAndSubmenusDetectItem:[:anItem | anItem value == aValue ].

    item notNil ifTrue:[

        ^ item label

    ].

    ^ nil

    "Modified: / 2.2.1998 / 13:28:28 / cg"

!

labels

    "return a collection of labels from my items"

    items isNil ifTrue:[^ #()].

    ^ items collect:[:anItem | anItem label]

    "Created: / 25.2.1997 / 19:47:53 / cg"

    "Modified: / 19.6.1998 / 02:36:22 / cg"

!

lastItem

    "returns last item

    "

    ^ items notNil ifTrue:[items last] ifFalse:[nil]

!

lines

    "return the indexes of the menu items that are the last menu item in their group (except the very last)."

    |lines groupSz|

    (groupSz := groupSizes size) <= 1 ifTrue: [^ Array new].

    lines := Array new:(groupSz - 1).

    lines at:1 put:groupSizes first.

    2 to:(groupSz-1) do:[:i |

        lines at:i put:(lines at:(i - 1)) + (groupSizes at:i)

    ].

    ^ lines

    "Modified: / 2.2.1998 / 13:28:19 / cg"

!

menuItemAt:index

    "gets the menu item at the given index. When the index is out of bounds

     nil is returned

    "

    (index > 0 and:[index <= items size]) ifTrue:[

	^ items at:index

    ].

  ^ nil

!

menuItemLabeled:anItemLabel

    "return the menuItem for the given nameKey; nil if no such item is in the menu.

     Searches all items (i.e. also submenu items)"

    self allItemsDo:[:anItem|

		|l|

		((l := anItem label) sameAs: anItemLabel) ifTrue:[

		    ^ anItem

		].

		(l includes:$&) ifTrue:[

		    ((l copyWithout:$&) sameAs: anItemLabel) ifTrue:[

			^ anItem

		    ]

		]

	     ].

    ^ nil

    "Created: / 13.9.1997 / 10:25:16 / cg"

    "Modified: / 27.10.1997 / 15:23:33 / cg"

!

menuItemWithValue:aValue

    "return the menuItem for the given value; nil if no such item is in the menu.

     Searches all items (i.e. also submenu items)"

    self allItemsDo:[:anItem|

                |l|

                (anItem value == aValue) ifTrue:[

                    ^ anItem

                ].

             ].

    ^ nil

    "Created: / 13.9.1997 / 10:25:16 / cg"

    "Modified: / 27.10.1997 / 15:23:33 / cg"

!

menuItems

    ^ items ? #()

!

menuItems:aCollectionOfMenuItems menuItemGroups:sizes values:values

    |n|

    items := groupSizes := nil.

    aCollectionOfMenuItems size == 0 ifTrue:[ ^ self ].

    items := aCollectionOfMenuItems.

    sizes size > 0 ifTrue:[

        groupSizes := sizes.

        n := sizes inject:0 into:[:sumSoFar :this | sumSoFar + this].

        n = items size ifTrue:[

            groupSizes := sizes copyWithoutLast:1

        ]

    ].

    values notNil ifTrue:[

        items with:values do:[:anItem :aValue |anItem value:aValue]

    ].

    "Modified: / 19.4.1998 / 11:47:34 / cg"

!

menuPerformer:something

    "set the receiver of the menu messages"

    receiver := something.

    "Modified: / 2.2.1998 / 13:26:29 / cg"

!

numberOfItems

    "return the number of items in this menu"

    ^ items size

    "Created: / 6.3.1997 / 15:15:53 / cg"

    "Modified: / 2.2.1998 / 13:26:40 / cg"

!

receiver

    "return the receiver of the menu messages"

    ^ receiver

    "Modified: / 2.2.1998 / 13:26:20 / cg"

!

receiver:something

    "set the receiver of the menu messages"

    receiver := something.

    "Modified: / 2.2.1998 / 13:26:29 / cg"

!

valueAt:index

    "return a collection of values from my items"

    ^ (items at:index) value

    "Created: 25.2.1997 / 19:49:41 / cg"

!

valueAt:anIndex put:aValue

    "put value an an index"

    (items at:anIndex) value:aValue

    "Created: 6.3.1997 / 15:15:48 / cg"

!

values

    "return a collection of values from my items"

    ^ items collect:[:anItem | anItem value]

    "Created: 25.2.1997 / 19:49:29 / cg"

!

values:aCollectionOfValues

    "return a collection of values from my items"

    |s|

    s := aCollectionOfValues readStream.

    self itemsDo:[:item |

        |val|

        val := s next.

        item value:val

    ].

    s atEnd ifFalse:[

        self halt:'not enough elements in value collection'

    ]

    "Created: / 27.10.1997 / 15:15:47 / cg"

!

visibleMenuItemGroups

    |itemGroups visibleItemGroups nextItem|

    itemGroups := OrderedCollection new.

    nextItem := 1.

    groupSizes do:[:groupSize |

        itemGroups addLast: (items copyFrom:nextItem to:nextItem + groupSize - 1).

        nextItem := nextItem + groupSize

    ].

    self hasHiddenItems ifFalse:[^ itemGroups].

    "Remove the hidden items."

    visibleItemGroups := OrderedCollection new.

    itemGroups do:[:eachItemGroup |

        |visibleItemGroup|

        visibleItemGroup := eachItemGroup reject:[:eachMenuItem | eachMenuItem hidden].

        visibleItemGroup isEmpty ifFalse:[

            visibleItemGroups addLast: visibleItemGroup

        ]

    ].

    ^ visibleItemGroups

    "Created: / 27.10.1997 / 15:07:50 / cg"

    "Modified: / 2.2.1998 / 13:25:52 / cg"

! !

!Menu methodsFor:'accessing-resource'!

findGuiResourcesIn:aResourceContainerOrApplication

    "setup a resource owner

    "

    ^ self 

        findGuiResourcesIn:aResourceContainerOrApplication 

        rememberResourcesIn:(ValueHolder new)

!

findGuiResourcesIn:aResourceContainerOrApplication rememberResourcesIn:aValueHolderOrNil

    "setup a resource owner

    "

    aResourceContainerOrApplication notNil ifTrue:[

        receiver isNil ifTrue:[

            receiver := aResourceContainerOrApplication

        ].

        items notNil ifTrue:[

            items do:[:anItem | 

                anItem 

                    findGuiResourcesIn:aResourceContainerOrApplication 

                    rememberResourcesIn:aValueHolderOrNil

            ]

        ]

    ]

! !

!Menu methodsFor:'adding & removing'!

addItem:aMenuItem

    "add a menuItem at the end;

     useful to build a menu programmatically (or, to add more items dynamically)"

    items isNil ifTrue:[

        items := OrderedCollection new

    ] ifFalse:[

        items := items asOrderedCollection

    ].

    items add:aMenuItem.

    "Modified: / 4.8.1998 / 17:31:13 / cg"

!