Object subclass:#Menu

	instanceVariableNames:'items groupSizes receiver'

	classVariableNames:''

	poolDictionaries:''

	category:'Views-Support'

!

!Menu class methodsFor:'documentation'!

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 == nil or:[linesArray isEmpty]) 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"

!

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"

! !

!Menu methodsFor:'ST-80 compatibility'!

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"

!

menuItems

    ^ items

!

menuItems:aCollectionOfMenuItems menuItemGroups:sizes values:values

    |n|

    items := aCollectionOfMenuItems.

    groupSizes := sizes.

    sizes size > 0 ifTrue:[

        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"

!

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]

    "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

    "

    aResourceContainerOrApplication notNil ifTrue:[

	items notNil ifTrue:[

	    items do:[:anItem| anItem findGuiResourcesIn:aResourceContainerOrApplication ]

	]

    ]

! !

!Menu methodsFor:'adding & removing'!

addItem:aMenuItem

    items isNil ifTrue:[

	items := OrderedCollection new

    ].

    items add:aMenuItem.

!

addItem:aMenuItem beforeIndex:anIndex

    items isNil ifTrue:[

        items := OrderedCollection new

    ].

    items add:aMenuItem beforeIndex:anIndex.

!

addItem:aMenuItem value:aValue

    aMenuItem value:aValue.

    self addItem:aMenuItem.

!

addItemGroup:aCollectionOfItems

    groupSizes isNil ifTrue:[

	groupSizes := OrderedCollection new

    ].

    groupSizes add:aCollectionOfItems size.

    aCollectionOfItems do:[:item |

	self addItem:item

    ].

    "Created: / 27.10.1997 / 15:02:15 / cg"

!

addItemGroup:aGroup values:values

    groupSizes isNil ifTrue:[

	groupSizes := OrderedCollection new

    ].

    groupSizes add:items size.

    aGroup with:values do:[:item :value |

	self addItem:item value:value

    ].

!

addItemGroupLabels:labels values:values

    |items|

    items := labels with:values

		collect:[:label :value |

			    |item|

			    item := MenuItem new.

			    item label:label.

			    item value:value.

			].

    self addItemGroup:items

    "Created: / 27.10.1997 / 19:49:27 / cg"

!

addItemLabel:label value:value

    |item|

    item := MenuItem new.

    item label:label.

    item value:value.

    self addItem:item

    "Created: / 27.10.1997 / 19:47:12 / cg"

!

removeItem:aMenuItem

    "remove an item from the menu"

    |idx|

    items notNil ifTrue:[

        idx := items identityIndexOf:aMenuItem.

        idx ~~ 0 ifTrue:[

            items removeAtIndex:idx

        ]

    ].

    "Created: / 13.9.1997 / 10:27:31 / cg"

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

!

removeItemAt:anIndex

    "remove item at an index

    "

    anIndex <= items size ifTrue:[

        ^ items removeAtIndex:anIndex

    ].

    ^ nil

! !

!Menu methodsFor:'converting'!

fromLiteralArrayEncoding:aLiteralEncodedArray

    "read my contents from a aLiteralEncodedArray"

    |items groups values|

    items := (aLiteralEncodedArray at:2) collect:[:item | item decodeAsLiteralArray].

    groups := aLiteralEncodedArray at:3.

    values := aLiteralEncodedArray at:4.

    self menuItems:items menuItemGroups:groups values:values.

    "extract from PD folder.st:

     #(#Menu #(

		#(#MenuItem 

			#rawLabel: 'left' 

			#value: #left ) 

		#(#MenuItem 

			#rawLabel: 'center' 

			#value: #center ) 

		#(#MenuItem 

			#rawLabel: 'right' 

			#value: #right ) 

	      ) 

	     #(3 )