handle-gesture ( gesture gadget -- ? )
Factor handbook » UI framework » Implementing new gadgets » UI gestures

Prev:	set-gestures ( class hash -- )
Next:	gesture>string ( gesture -- string/f )

Vocabulary
ui.gestures

Inputs

gesture	a gesture
gadget	the receiver of the gesture

Outputs

?

a boolean

Generic word contract
Handles a gesture sent to a gadget.

Outputs f if the gesture was handled, and t if the gesture should be passed on to the gadget's parent.

The default implementation looks at the "gestures" word property of each superclass of the gadget's class.

Notes
Methods should be defined on this word if you desire to handle an arbitrary set of gestures. To define handlers for a fixed set, it is easier to use set-gestures. If you define a method on handle-gesture, you should also override handles-gesture?.

See also
propagate-gesture, handles-gesture?, set-gestures

Definition

IN: ui.gestures

GENERIC: handle-gesture ( gesture gadget -- ? )

Methods

USING: accessors assocs combinators gamelib.ui kernel
ui.gestures ;

M: board-gadget handle-gesture
    swap over gests>> ?at
    [ 2dup ( gadget -- ) call-effect ] when 2drop f ;


USING: accessors combinators combinators.short-circuit generic
kernel ui.gadgets.glass ui.gestures ui.tools.browser ;

M: browser-gadget handle-gesture
    {
        {
            [ over key-gesture? not ]
            [
                M\ browser-gadget handle-gesture
                (call-next-method)
            ]
        }
        {
            [ dup popup>> ]
            [
                {
                    [ pass-to-popup ]
                    [
                        M\ browser-gadget handle-gesture
                        (call-next-method)
                    ]
                } 2&&
            ]
        }
        [ M\ browser-gadget handle-gesture (call-next-method) ]
    } cond ;


USING: accessors generic kernel ui.gadgets ui.gadgets.comboboxes
ui.gadgets.glass ui.gadgets.tables ui.gestures ;

M: combo-table handle-gesture
    [ M\ combo-table handle-gesture (call-next-method) drop ]
    2keep swap T{ button-down } = [
        [ spawner>> ] [
            selected-row
            [ disp-string swap set-control-value ] [ 2drop ] if
        ] [ hide-glass ] tri
    ] [ drop ] if t ;


USING: accessors gesture-logger io kernel prettyprint ui.gadgets
ui.gestures ;

M: gesture-logger handle-gesture
    over T{ button-down } = [ dup request-focus ] when stream>>
    [ . ] with-output-stream* t ;


USING: accessors circular combinators.short-circuit generic
kernel minesweeper sequences ui.gestures ;

M: grid-gadget handle-gesture
    over
    { [ key-down? ] [ sym>> length 1 = ] [ sym>> " " = not ] }
    1&&
    [ 2dup [ sym>> first ] [ hint?>> ] bi* circular-push ] when
    M\ grid-gadget handle-gesture (call-next-method) ;


USING: accessors combinators combinators.short-circuit generic
kernel ui.gadgets.glass ui.gestures ui.tools.listener
ui.tools.listener.completion ;

M: interactor handle-gesture
    {
        {
            [ over key-gesture? not ]
            [ M\ interactor handle-gesture (call-next-method) ]
        }
        {
            [ dup popup>> ]
            [
                ?check-popup {
                    [ pass-to-popup ]
                    [
                        M\ interactor handle-gesture
                        (call-next-method)
                    ]
                } 2&&
            ]
        }
        {
            [ dup token-model>> value>> ]
            [
                {
                    [ interactor-operation ]
                    [
                        M\ interactor handle-gesture
                        (call-next-method)
                    ]
                } 2&&
            ]
        }
        [ M\ interactor handle-gesture (call-next-method) ]
    } cond ;


USING: game.input.demos.key-caps kernel ui.gestures ;

M: key-caps-gadget handle-gesture
    drop [ key-down? ] [ key-up? ] bi or not ;


USING: accessors assocs combinators kernel key-handlers
ui.gestures ;

M: key-handler handle-gesture
    [ handlers>> at ] 1check
    [ ( gadget -- ) call-effect f ] [ drop t ] if* ;


USING: generic kernel maze ui.gadgets ui.gestures ;

M: maze handle-gesture
    over T{ button-down { # 1 } } =
    [ nip relayout f ]
    [ M\ maze handle-gesture (call-next-method) ] if ;


USING: combinators generic kernel ui.gadgets.menus
ui.gadgets.menus.private ui.gestures ;

M: menu-button handle-gesture
    [
        {
            { [ over mouse-enter? ] [ nip activate-item ] }
            { [ over mouse-leave? ] [ nip inactivate-item ] }
            [ 2drop ]
        } cond
    ] 2keep M\ menu-button handle-gesture (call-next-method) ;


USING: combinators kernel ui.gestures ;

M: object handle-gesture
    [ nip ] [ get-gesture-handler ] 2bi dup
    [ ( gadget -- ) call-effect f ] [ 2drop t ] if ;


USING: combinators.short-circuit generic kernel
ui.gadgets.search-tables ui.gestures ;

M: search-field handle-gesture
    over key-gesture? [
        {
            [ pass-to-table ]
            [
                M\ search-field handle-gesture
                (call-next-method)
            ]
        } 2&&
    ] [ M\ search-field handle-gesture (call-next-method) ] if ;


USING: accessors combinators combinators.short-circuit kernel
snake-game.ui ui ui.gestures ;

M: snake-gadget handle-gesture
    swap [ key-down? ] 1check [
        sym>> {
            { [ dup quit-key? ] [ drop close-window ] }
            { [ dup pause-key? ] [ drop toggle-game-pause ] }
            { [ dup new-game-key? ] [ drop start-new-game ] }
            [
                key-dir [
                    swap snake-game>> dup
                    { ~quotation~ ~quotation~ } 1&&
                    [ next-turn-dir<< ] [ 2drop ] if
                ] [ drop ] if*
            ]
        } cond
    ] [ 2drop ] if f ;


USING: combinators generic kernel ui.gadgets.worlds ui.gestures
;

M: world handle-gesture
    2dup M\ world handle-gesture (call-next-method) [
        {
            {
                [ over specific-button-up? ]
                [ drop generalize-gesture f ]
            }
            {
                [ over specific-button-down? ]
                [ drop generalize-gesture f ]
            }
            {
                [ over specific-drag? ]
                [ drop generalize-gesture f ]
            }
            [ 2drop t ]
        } cond
    ] [ 2drop f ] if ;