"

 COPYRIGHT (c) 1989 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.

"

"{ Package: 'stx:libwidg' }"

"{ NameSpace: Smalltalk }"

PopUpView subclass:#PopUpMenu

	instanceVariableNames:'menuView lastSelection memorize hideOnLeave actionLabels

		actionLines actionValues hideOnRelease defaultHideOnRelease

		hideOnAnyKey hideOnKeyFilter'

	classVariableNames:''

	poolDictionaries:''

	category:'Views-Menus'

!

!PopUpMenu class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1989 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.

"

!

documentation

"

    Warning: this is a very old class which was written well before many improved

    successors and tools were added. A lot of stuff you find here is kept for backward

    compatibility.

    This class provides PopUpMenu functionality;

    -> Actually, this class only provides the popup and shadow functionality 

       and wraps ANOTHER view, which shows the actual menu-list 

       (usually an instance of MenuView, but in theory, other views could be wrapped as popup).

    PopUpMenus are usually created with a list of labels, selectors and a

    receiver. 

    Once activated, the specified receiver will be sent a 'selector'-message.

    PopupMenus may be either assigned statically to a view (via the #middleButtonMenu:

    message) or created dynamically as required.

    Static definition makes sense, if the menu stays constant and you want to

    assign it once for the lifetime of the view.

    Dynamic menus are easier to use, if the number of or look of the entries has to

    change according the internal state of some model. Also, this is the ST-80 way

    of using popupMenus. For dynamic popups, the view's model is asked for a menu

    via the #menuSelector each time a button press occurs.

    See examples section for more.

    [author:]

        Claus Gittinger

    [see also:]

        PullDownMenu MenuView

"

!

examples

"

  The ST-80 way of opening menus is to startUp a menu,

  and use the returned value:

                                                                        [exBegin]

    |p|

    p := PopUpMenu

            labels:#('foo' 'bar' 'baz').

    Transcript showCR:p startUp

                                                                        [exEnd]

  It returns the index of the selected item or 0 if nothing was selected.

  This opening is done by either the controller or the view (if it has

  a middleButtonMenu and/or a menuHolder).

  If the numeric index is inconvenient, alternative values may be specified

  as in (here, nil is returned if nothing was selected):

                                                                        [exBegin]

    |p|

    p := PopUpMenu

            labels:#('foo' 'bar' 'baz')

            values:#('hello foo' 'hello bar' 'hello baz').

    Transcript showCR:p startUp

                                                                        [exEnd]

  In ST/X, the above is actually done by a mimicri method (#startUp)

  and menus are typically created in one of the following ways:

  -> With a single actionBlock.

     This is convenient, if all actions shall perform a similar task, 

     but require different arguments.

  this is evaluated, passing the selections index or value as argument.

  The action block is NOT evaluated, if nothing was selected.

    With index:

                                                                        [exBegin]

    |p|

    p := PopUpMenu

            labels:#('foo' 'bar' 'baz').

    p action:[:item | Transcript showCR:item].

    p showAtPointer

                                                                        [exEnd]

    With individual arguments:

                                                                        [exBegin]

    |p|

    p := PopUpMenu

            labels:#('foo' 'bar' 'baz')

            args:#('hello foo' 'hello bar' 'hello baz').

    p action:[:item | Transcript showCR:item].

    p showAtPointer

                                                                        [exEnd]

  -> With an explicit receiver and different selectors.

     This is convenient, if you have to send per-item messages

     to some object (typically, the receiver is the view or a model)

                                                                        [exBegin]

    |p m|

    m := Plug new.

    m respondTo:#foo with:[Transcript showCR:'foo received'].

    m respondTo:#bar with:[Transcript showCR:'bar received'].

    m respondTo:#maz with:[Transcript showCR:'maz received'].

    p := PopUpMenu

            labels:#('foo' 'bar' 'baz')

            selectors:#(#foo #bar #baz)

            receiver:m.

    p showAtPointer

                                                                        [exEnd]

  More examples:

    dynamic with action instead of selector being sent:

                                                                        [exBegin]

        |p|

        p := PopUpMenu

                labels:(($a to: $d) collect:[:char | char asString])

                selectors:nil

                receiver:nil.

        p action:[:idx | Transcript showCR:'selected index is '; showCR:idx].

        p showAtPointer

                                                                        [exEnd]

    individual actions:

                                                                        [exBegin]

        |p|

        p := PopUpMenu

                labels:#('foo'

                         'bar'

                         'baz')

                selectors:#(

                            #foo

                            #bar

                            #baz).

        p actionAt:#foo put:[Transcript showCR:'foo'].

        p actionAt:#bar put:[Transcript showCR:'bar'].

        p actionAt:#baz put:[Transcript showCR:'baz'].

        p showAtPointer

                                                                        [exEnd]

    sometimes, you want to specify both selectors and some arguments

    to be sent; this is done by:

                                                                        [exBegin]

        |p|

        p := PopUpMenu

                labels:#('foo' 'bar' 'baz')

                selectors:#(#foo: #bar: #foo:)

                args:#(1 2 3)

                receiver:nil.

        p showAtPointer

                                                                        [exEnd]

    or, the same selector but different arguments:

                                                                        [exBegin]

        |p|

        p := PopUpMenu

                labels:#('foo' 'bar' 'baz')

                selectors:#foo:

                args:#(1 2 3)

                receiver:nil.

        p showAtPointer

                                                                        [exEnd]

    Normally, you do not show the menu explicitely, but install

    it as a either as middleButtonMenu of some view or return it from

    a model. 

    (Views/Controllers button-event handler will show it when the middle

    button is pressed ...)

    Static menu:

                                                                        [exBegin]

        |v m|

        v := View new.

        m := PopUpMenu

                labels:#('lower'

                         'raise'

                         '-'

                         'destroy')

                selectors:#(#lower #raise nil #destroy)

                receiver:v.

        v middleButtonMenu:m.

        v open

                                                                        [exEnd]

    Dynamic menu:

    (since we need some model which responds to a menu-message,

     we use a plug in the example below; normally, this would be your model)

                                                                        [exBegin]

        |v model|

        model := Plug new.

        model respondTo:#getMenu with:[PopUpMenu labels:#('foo' 'bar')

                                                 selectors:#(foo bar)].

        model respondTo:#foo with:[Transcript showCR:'models foo called'].

        model respondTo:#bar with:[Transcript showCR:'models bar called'].

        v := View new.

        v model:model; menu:#getMenu.

        v open

                                                                        [exEnd]

    Dynamic menus are the MVC-way (i.e. ST-80) way of doing things.

    They are usually easier to use, if the menu changes depending on the models

    state. (for example, see the systemBrowsers menus being different when

    things are selected ...)

    It is also possible, to add check-mark entries, with an entry string

    starting with the special sequence '\c' (for check-mark). The value

    passed will be the truth-state of the check-mark.

                                                                        [exBegin]

        |m v|

        v := View new.

        m := PopUpMenu

                labels:#('\c foo'

                         '\c bar')

                selectors:#(#value: #value:)

                receiver:[:v | Transcript show:'arg: '; showCR:v].

        v middleButtonMenu:m.

        v open

                                                                        [exEnd]

    The style of the checkmark can be: check (\c), box (\b) or thumbs (\t):

                                                                        [exBegin]

        |m v|

        v := View new.

        m := PopUpMenu

                labels:#('\c foo'

                         '\b bar'

                         '\t baz')

                selectors:#(#value: #value: #value:)

                receiver:[:v | Transcript show:'arg: '; showCR:v].

        v middleButtonMenu:m.

        v open

                                                                        [exEnd]

    or at the end (looks better with variable fonts):

                                                                        [exBegin]

        |m v|

        v := View new.

        m := PopUpMenu

                labels:#('foo \c'

                         'bar \b'

                         'baz \t')

                selectors:#(#value: #value: #value:)

                receiver:[:v | Transcript show:'arg: '; showCR:v].

        v middleButtonMenu:m.

        v open

                                                                        [exEnd]

    Finally, you can wrap other views into a popup menu (for example,

    to implement menus with icons or other components).

    The view should respond to some messages sent from here (for

    example: #hideSubmenus, #deselectWithoutRedraw and others).

    Currently there is only one class in the system, which can be used

    this way (PatternMenu in the DrawTool demo):

                                                                        [exBegin]

        |v p|

        v := View new.

        p := PatternMenu new.

        p patterns:(Array with:Color red

                          with:Color green

                          with:Color blue).

        v middleButtonMenu:(PopUpMenu forMenu:p).

        v open

                                                                        [exEnd]

    or try:

                                                                        [exBegin]

        |v p|

        v := View new.

        p := PatternMenu new.

        p patterns:(Array with:Color red

                          with:Color green

                          with:Color blue).

        p selectors:#value:.

        p receiver:[:val | v viewBackground:val. v clear].

        p args:(Array with:Color red

                      with:Color green

                      with:Color blue).

        v middleButtonMenu:(PopUpMenu forMenu:p).

        v open

                                                                        [exEnd]

    ST-80 style:

    The above menus all did some message send on selection; it is

    also possible, to use Smalltalk-80 style menus (which return some value

    from their startup method):

                                                                        [exBegin]

        |m selection|

        m := PopUpMenu

                labels:#('one' 'two' 'three').

        selection := m startUp.

        Transcript show:'the selection was: '; showCR:selection

                                                                        [exEnd]

    startUp will return the entries index, or 0 if there was no selection.

    You can also specify an array of values to be returned instead of the

    index:

                                                                        [exBegin]

        |m selection|

        m := PopUpMenu

                labels:#('one' 'two' 'three')

                values:#(10 20 30).

        selection := m startUp.

        Transcript show:'the value was: '; showCR:selection

                                                                        [exEnd]

    In ST/X style menus, separating lines between entries are created

    by a '-'-string as its label text (and corresponding nil-entries in the

    selectors- and args-arrays).

    In ST-80, you have to pass the indices of the lines in an extra array:

                                                                        [exBegin]

        |m selection|

        m := PopUpMenu

                labels:#('one' 'two' 'three' 'four' 'five')

                lines:#(2 4).

        selection := m startUp.

        Transcript show:'the value was: '; showCR:selection

                                                                        [exEnd]

    or:

                                                                        [exBegin]

        |m selection|

        m := PopUpMenu

                labels:#('one' 'two' 'three')

                lines:#(2)

                values:#(10 20 30).

        selection := m startUp.

        Transcript show:'the value was: '; showCR:selection

                                                                        [exEnd]

    Use whichever interface you prefer.

"

! !

!PopUpMenu class methodsFor:'instance creation'!

forMenu:aMenuView

    "this wraps an already existing menu - allowing to put any

     view (not just MenuViews) into popups (for example, menus

     with icons, or other components).

     Currently, there is only one example of different menus in

     the system (PatternMenu in the DrawTool) which could be used

     this way.

     The view should respond to some of the menuView messages

     (such as hideSubmenu, deselectWithoutRedraw etc.)"

    |newMenu|

    aMenuView isView ifFalse:[

        self error:'bad argument'

    ].

    newMenu := self onSameDeviceAs:aMenuView. 

    newMenu addSubView:aMenuView.

    newMenu menuView:aMenuView.

    ^ newMenu

!

itemList:itemList resources:resources

    "like labels:selectors:... messages, but expects a single collection,

     containing items row-wise (i.e. elements are themself arrays, consisting of

        label [selector [accelerator [arg]]]

     if resources are non-nil, labels are translated using the translations found there.

    "

    ^ self

        itemList:itemList resources:resources receiver:nil for:nil

    "the sometimes more convenient:

        |p|

        p := PopUpMenu

                itemList:#(('foo' doFoo CtrlF)

                           ('-')

                           ('bar' doBar CtrlB)

                           ('baz' doBaz CtrlZ))

                resources:nil.

        p showAtPointer

     does the same as:

        |p|

        p := PopUpMenu

                labels:#('foo' '-' 'bar' 'baz')

                selectors:#(doFoo nil doBar doBaz)

                accelerators:#(CtrlF nil CtrlB CtrlZ).

        p showAtPointer

    "

!

itemList:itemList resources:resources performer:menuPerformer

    "like labels:selectors:... messages, but expects a single collection,

     containing items row-wise (i.e. elements are themself arrays, consisting of

        label [selector [accelerator [arg]]]

     if resources are non-nil, labels are translated using the translations found there.

    "

    ^ self

        itemList:itemList resources:resources receiver:menuPerformer for:nil

    "Created: / 21.5.1998 / 15:31:42 / cg"

!

itemList:itemList resources:resources performer:menuPerformer for:aView

    "like labels:selectors:... messages, but expects a single collection,

     containing items row-wise (i.e. elements are themself arrays, consisting of

        label [selector [accelerator [arg]]]

     if resources are non-nil, labels are translated using the translations found there.

    "

    |n labels selectors accelerators args anyArg|

    n := itemList size.

    labels := Array new:n.

    selectors := Array new:n.

    accelerators := Array new:n.

    anyArg := false.

    itemList keysAndValuesDo:[:idx :item |

        |label selector accelerator arg|

        label := item at:1.

        labels at:idx put:label.

        item size > 1 ifTrue:[

            selector := item at:2.

            selectors at:idx put:selector.

            item size > 2 ifTrue:[

                accelerator := item at:3.

                accelerators at:idx put:accelerator.

                item size > 3 ifTrue:[

                    arg := item at:4.

                    anyArg ifFalse:[

                        anyArg := true.

                        args := Array new:n.

                    ].