summaryrefslogtreecommitdiff
path: root/indra/llui/llmenugl.h
blob: 72e041672a081f5064b851c192bf2bfc0ac2b71e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
/**
 * @file llmenugl.h
 * @brief Declaration of the opengl based menu system.
 *
 * $LicenseInfo:firstyear=2001&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#ifndef LL_LLMENUGL_H
#define LL_LLMENUGL_H

#include <list>

#include "llstring.h"
#include "v4color.h"
#include "llframetimer.h"

#include "llkeyboard.h"
#include "llfloater.h"
#include "lluistring.h"
#include "llview.h"
#include <boost/function.hpp>

extern S32 MENU_BAR_HEIGHT;
extern S32 MENU_BAR_WIDTH;

class LLMenuKeyboardBinding
{
public:
    KEY             mKey;
    MASK            mMask;
};

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Class LLMenuItemGL
//
// The LLMenuItemGL represents a single menu item in a menu.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class LLMenuItemGL: public LLUICtrl, public ll::ui::SearchableControl
{
public:
    struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
    {
        Optional<std::string>   shortcut;
        Optional<KEY>           jump_key;
        Optional<bool>          use_mac_ctrl,
                                allow_key_repeat;

        Ignored                 rect,
                                left,
                                top,
                                right,
                                bottom,
                                width,
                                height,
                                bottom_delta,
                                left_delta;

        Optional<LLUIColor>     enabled_color,
                                disabled_color,
                                highlight_bg_color,
                                highlight_fg_color;


        Params();
    };

protected:
    LLMenuItemGL(const Params&);
    friend class LLUICtrlFactory;
public:
    // LLView overrides
    /*virtual*/ void onVisibilityChange(BOOL new_visibility);
    /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
    /*virtual*/ BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
    /*virtual*/ BOOL handleRightMouseUp(S32 x, S32 y, MASK mask);

    // LLUICtrl overrides
    /*virtual*/ void setValue(const LLSD& value);
    /*virtual*/ LLSD getValue() const;

    virtual bool hasAccelerator(const KEY &key, const MASK &mask) const;
    virtual BOOL handleAcceleratorKey(KEY key, MASK mask);

    LLColor4 getHighlightBgColor() { return mHighlightBackground.get(); }

    void setJumpKey(KEY key);
    KEY getJumpKey() const { return mJumpKey; }

    // set the font used by this item.
    void setFont(const LLFontGL* font) { mFont = font; }
    const LLFontGL* getFont() const { return mFont; }

    // returns the height in pixels for the current font.
    virtual U32 getNominalHeight( void ) const;

    // Marks item as not needing space for check marks or accelerator keys
    virtual void setBriefItem(BOOL brief);
    virtual BOOL isBriefItem() const;

    virtual BOOL addToAcceleratorList(std::list<LLMenuKeyboardBinding*> *listp);
    void setAllowKeyRepeat(BOOL allow) { mAllowKeyRepeat = allow; }
    BOOL getAllowKeyRepeat() const { return mAllowKeyRepeat; }

    // change the label
    void setLabel( const LLStringExplicit& label ) { mLabel = label; }
    std::string getLabel( void ) const { return mLabel.getString(); }
    virtual BOOL setLabelArg( const std::string& key, const LLStringExplicit& text );

    // Get the parent menu for this item
    virtual class LLMenuGL* getMenu() const;

    // returns the normal width of this control in pixels - this is
    // used for calculating the widest item, as well as for horizontal
    // arrangement.
    virtual U32 getNominalWidth( void ) const;

    // buildDrawLabel() - constructs the string used during the draw()
    // function. This reduces the overall string manipulation, but can
    // lead to visual errors if the state of the object changes
    // without the knowledge of the menu item. For example, if a
    // boolean being watched is changed outside of the menu item's
    // onCommit() function, the draw buffer will not be updated and will
    // reflect the wrong value. If this ever becomes an issue, there
    // are ways to fix this.
    // Returns the enabled state of the item.
    virtual void buildDrawLabel( void );

    // for branching menu items, bring sub menus up to root level of menu hierarchy
    virtual void updateBranchParent( LLView* parentp ){};

    virtual void onCommit( void );

    virtual void setHighlight( BOOL highlight );
    virtual BOOL getHighlight() const { return mHighlight; }

    // determine if this represents an active sub-menu
    virtual BOOL isActive( void ) const { return FALSE; }

    // determine if this represents an open sub-menu
    virtual BOOL isOpen( void ) const { return FALSE; }

    virtual void setEnabledSubMenus(BOOL enable){};

    // LLView Functionality
    virtual BOOL handleKeyHere( KEY key, MASK mask );
    virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
    virtual BOOL handleMouseUp( S32 x, S32 y, MASK mask );
    virtual BOOL handleScrollWheel( S32 x, S32 y, S32 clicks );

    virtual void    onMouseEnter(S32 x, S32 y, MASK mask);
    virtual void    onMouseLeave(S32 x, S32 y, MASK mask);

    virtual void draw( void );

    BOOL getHover() const { return mGotHover; }

    void setDrawTextDisabled(BOOL disabled) { mDrawTextDisabled = disabled; }
    BOOL getDrawTextDisabled() const { return mDrawTextDisabled; }

protected:
    void setHover(BOOL hover) { mGotHover = hover; }

    // This function appends the character string representation of
    // the current accelerator key and mask to the provided string.
    void appendAcceleratorString( std::string& st ) const;

    virtual std::string _getSearchText() const
    {
        return mLabel.getString();
    }

protected:
    KEY mAcceleratorKey;
    MASK mAcceleratorMask;
    // mLabel contains the actual label specified by the user.
    LLUIString mLabel;

    // The draw labels contain some of the labels that we draw during
    // the draw() routine. This optimizes away some of the string
    // manipulation.
    LLUIString mDrawBoolLabel;
    LLUIString mDrawAccelLabel;
    LLUIString mDrawBranchLabel;

    LLUIColor mEnabledColor;
    LLUIColor mDisabledColor;
    LLUIColor mHighlightBackground;
    LLUIColor mHighlightForeground;

    BOOL mHighlight;
private:
    // Keyboard and mouse variables
    BOOL mAllowKeyRepeat;
    BOOL mGotHover;

    // If true, suppress normal space for check marks on the left and accelerator
    // keys on the right.
    BOOL mBriefItem;

    // Font for this item
    const LLFontGL* mFont;
    BOOL mDrawTextDisabled;

    KEY mJumpKey;
};

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Class LLMenuItemSeparatorGL
//
// This class represents a separator.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class LLMenuItemSeparatorGL : public LLMenuItemGL
{
public:
    struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
    {
        Optional<EnableCallbackParam > on_visible;
        Params();
    };

    LLMenuItemSeparatorGL(const LLMenuItemSeparatorGL::Params& p = LLMenuItemSeparatorGL::Params());

    /*virtual*/ void draw( void );
    /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
    /*virtual*/ BOOL handleMouseUp(S32 x, S32 y, MASK mask);
    /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);

    virtual void buildDrawLabel();

    /*virtual*/ U32 getNominalHeight( void ) const;

private:
    enable_signal_t mVisibleSignal;
};

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Class LLMenuItemCallGL
//
// The LLMenuItemCallerGL represents a single menu item in a menu that
// calls a user defined callback.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class LLMenuItemCallGL : public LLMenuItemGL
{
public:
    struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
    {
        Optional<EnableCallbackParam > on_enable;
        Optional<CommitCallbackParam > on_click;
        Optional<EnableCallbackParam > on_visible;
        Params()
            : on_enable("on_enable"),
              on_click("on_click"),
              on_visible("on_visible")
        {}
    };
protected:
    LLMenuItemCallGL(const Params&);
    friend class LLUICtrlFactory;
    void updateEnabled( void );
    void updateVisible( void );

public:
    void initFromParams(const Params& p);

    // called to rebuild the draw label
    virtual void buildDrawLabel( void );

    virtual void onCommit( void );

    virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
    virtual BOOL handleKeyHere(KEY key, MASK mask);

    //virtual void draw();

    boost::signals2::connection setClickCallback( const commit_signal_t::slot_type& cb )
    {
        return setCommitCallback(cb);
    }

    boost::signals2::connection setEnableCallback( const enable_signal_t::slot_type& cb )
    {
        return mEnableSignal.connect(cb);
    }

private:
    enable_signal_t mEnableSignal;
    enable_signal_t mVisibleSignal;
};

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Class LLMenuItemCheckGL
//
// The LLMenuItemCheckGL is an extension of the LLMenuItemCallGL
// class, by allowing another method to be specified which determines
// if the menu item should consider itself checked as true or not.  Be
// careful that the provided callback is fast - it needs to be VERY
// EFFICIENT because it may need to be checked a lot.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class LLMenuItemCheckGL
:   public LLMenuItemCallGL
{
public:
    struct Params : public LLInitParam::Block<Params, LLMenuItemCallGL::Params>
    {
        Optional<EnableCallbackParam > on_check;
        Params()
        :   on_check("on_check")
        {}
    };

protected:
    LLMenuItemCheckGL(const Params&);
    friend class LLUICtrlFactory;
public:

    void initFromParams(const Params& p);

    virtual void onCommit( void );

    virtual void setValue(const LLSD& value);
    virtual LLSD getValue() const;

    // called to rebuild the draw label
    virtual void buildDrawLabel( void );

    boost::signals2::connection setCheckCallback( const enable_signal_t::slot_type& cb )
    {
        return mCheckSignal.connect(cb);
    }

private:
    enable_signal_t mCheckSignal;
};

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Class LLMenuGL
//
// The Menu class represents a normal rectangular menu somewhere on
// screen. A Menu can have menu items (described above) or sub-menus
// attached to it. Sub-menus are implemented via a specialized
// menu-item type known as a branch. Since it's easy to do wrong, I've
// taken the branch functionality out of public view, and encapsulate
// it in the appendMenu() method.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// child widget registry
struct MenuRegistry : public LLChildRegistry<MenuRegistry>
{
    LLSINGLETON_EMPTY_CTOR(MenuRegistry);
};


class LLMenuGL
:   public LLUICtrl
{
public:
    struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
    {
        Optional<KEY>                   jump_key;
        Optional<bool>                  horizontal_layout,
                                        can_tear_off,
                                        drop_shadow,
                                        bg_visible,
                                        create_jump_keys,
                                        keep_fixed_size,
                                        scrollable;
        Optional<U32>                   max_scrollable_items;
        Optional<U32>                   preferred_width;
        Optional<LLUIColor>             bg_color;
        Optional<S32>                   shortcut_pad;

        Params()
        :   jump_key("jump_key", KEY_NONE),
            horizontal_layout("horizontal_layout"),
            can_tear_off("tear_off", false),
            drop_shadow("drop_shadow", true),
            bg_visible("bg_visible", true),
            create_jump_keys("create_jump_keys", false),
            keep_fixed_size("keep_fixed_size", false),
            bg_color("bg_color",  LLUIColorTable::instance().getColor( "MenuDefaultBgColor" )),
            scrollable("scrollable", false),
            max_scrollable_items("max_scrollable_items", U32_MAX),
            preferred_width("preferred_width", U32_MAX),
            shortcut_pad("shortcut_pad")
        {
            addSynonym(bg_visible, "opaque");
            addSynonym(bg_color, "color");
            addSynonym(can_tear_off, "can_tear_off");
        }
    };

    // my valid children are contained in MenuRegistry
    typedef MenuRegistry child_registry_t;

    void initFromParams(const Params&);

    // textual artwork which menugl-imitators may want to match
    static const std::string BOOLEAN_TRUE_PREFIX;
    static const std::string BRANCH_SUFFIX;
    static const std::string ARROW_UP;
    static const std::string ARROW_DOWN;

    // for scrollable menus
    typedef enum e_scrolling_direction
    {
        SD_UP = 0,
        SD_DOWN = 1,
        SD_BEGIN = 2,
        SD_END = 3
    } EScrollingDirection;

protected:
    LLMenuGL(const LLMenuGL::Params& p);
    friend class LLUICtrlFactory;
    // let branching menu items use my protected traversal methods
    friend class LLMenuItemBranchGL;
public:
    virtual ~LLMenuGL( void );

    void parseChildXML(LLXMLNodePtr child, LLView* parent);

    // LLView Functionality
    /*virtual*/ BOOL handleUnicodeCharHere( llwchar uni_char );
    /*virtual*/ BOOL handleHover( S32 x, S32 y, MASK mask );
    /*virtual*/ BOOL handleScrollWheel( S32 x, S32 y, S32 clicks );
    /*virtual*/ void draw( void );
    /*virtual*/ void drawBackground(LLMenuItemGL* itemp, F32 alpha);
    /*virtual*/ void setVisible(BOOL visible);
    /*virtual*/ bool addChild(LLView* view, S32 tab_group = 0);
    /*virtual*/ void deleteAllChildren();
    /*virtual*/ void removeChild( LLView* ctrl);
    /*virtual*/ BOOL postBuild();

    virtual bool hasAccelerator(const KEY &key, const MASK &mask) const;
    virtual BOOL handleAcceleratorKey(KEY key, MASK mask);

    LLMenuGL* findChildMenuByName(const std::string& name, BOOL recurse) const;

    BOOL clearHoverItem();

    // return the name label
    const std::string& getLabel( void ) const { return mLabel.getString(); }
    void setLabel(const LLStringExplicit& label) { mLabel = label; }

    // background colors
    void setBackgroundColor( const LLUIColor& color ) { mBackgroundColor = color; }
    const LLUIColor& getBackgroundColor() const { return mBackgroundColor; }
    void setBackgroundVisible( BOOL b ) { mBgVisible = b; }
    void setCanTearOff(BOOL tear_off);

    // add a separator to this menu
    virtual BOOL addSeparator();

    // for branching menu items, bring sub menus up to root level of menu hierarchy
    virtual void updateParent( LLView* parentp );

    // setItemEnabled() - pass the name and the enable flag for a
    // menu item. TRUE will make sure it's enabled, FALSE will disable
    // it.
    void setItemEnabled( const std::string& name, BOOL enable );

    // propagate message to submenus
    void setEnabledSubMenus(BOOL enable);

    void setItemVisible( const std::string& name, BOOL visible);

    void setItemLabel(const std::string &name, const std::string &label);

    // sets the left,bottom corner of menu, useful for popups
    void setLeftAndBottom(S32 left, S32 bottom);

    virtual BOOL handleJumpKey(KEY key);

    virtual BOOL jumpKeysActive();

    virtual BOOL isOpen();

    void needsArrange() { mNeedsArrange = TRUE; }
    // Shape this menu to fit the current state of the children, and
    // adjust the child rects to fit. This is called automatically
    // when you add items. *FIX: We may need to deal with visibility
    // arrangement.
    virtual void arrange( void );
    void arrangeAndClear( void );

    // remove all items on the menu
    void empty( void );

    // erase group of items from menu
    void erase( S32 begin, S32 end, bool arrange = true );

    // add new item at position
    void insert( S32 begin, LLView * ctrl, bool arrange = true );

    void            setItemLastSelected(LLMenuItemGL* item);    // must be in menu
    U32             getItemCount();             // number of menu items
    LLMenuItemGL*   getItem(S32 number);        // 0 = first item
    LLMenuItemGL*   getItem(std::string name);
    LLMenuItemGL*   getHighlightedItem();

    LLMenuItemGL*   highlightNextItem(LLMenuItemGL* cur_item, BOOL skip_disabled = TRUE);
    LLMenuItemGL*   highlightPrevItem(LLMenuItemGL* cur_item, BOOL skip_disabled = TRUE);

    void buildDrawLabels();
    void createJumpKeys();

    // Show popup at a specific location, in the spawn_view's coordinate frame
    static void showPopup(LLView* spawning_view, LLMenuGL* menu, S32 x, S32 y, S32 mouse_x = 0, S32 mouse_y = 0);

    // Whether to drop shadow menu bar
    void setDropShadowed( const BOOL shadowed );

    void setParentMenuItem( LLMenuItemGL* parent_menu_item ) { mParentMenuItem = parent_menu_item->getHandle(); }
    LLMenuItemGL* getParentMenuItem() const { return dynamic_cast<LLMenuItemGL*>(mParentMenuItem.get()); }

    void setTornOff(BOOL torn_off);
    BOOL getTornOff() { return mTornOff; }

    BOOL getCanTearOff() { return mTearOffItem != NULL; }

    KEY getJumpKey() const { return mJumpKey; }
    void setJumpKey(KEY key) { mJumpKey = key; }

    static void setKeyboardMode(BOOL mode) { sKeyboardMode = mode; }
    static BOOL getKeyboardMode() { return sKeyboardMode; }

    S32 getShortcutPad() { return mShortcutPad; }

    bool scrollItems(EScrollingDirection direction);
    BOOL isScrollable() const { return mScrollable; }

    static class LLMenuHolderGL* sMenuContainer;

    void resetScrollPositionOnShow(bool reset_scroll_pos) { mResetScrollPositionOnShow = reset_scroll_pos; }
    bool isScrollPositionOnShowReset() { return mResetScrollPositionOnShow; }

    void setAlwaysShowMenu(BOOL show) { mAlwaysShowMenu = show; }
    BOOL getAlwaysShowMenu() { return mAlwaysShowMenu; }

    // add a context menu branch
    BOOL appendContextSubMenu(LLMenuGL *menu);

    const LLFontGL *getFont() const { return mFont; }

  protected:
    void createSpilloverBranch();
    void cleanupSpilloverBranch();
    // Add the menu item to this menu.
    virtual BOOL append( LLMenuItemGL* item );

    // add a menu - this will create a cascading menu
    virtual BOOL appendMenu( LLMenuGL* menu );

    // Used in LLContextMenu and in LLTogleableMenu
    // to add an item of context menu branch
    bool addContextChild(LLView* view, S32 tab_group);

    // TODO: create accessor methods for these?
    typedef std::list< LLMenuItemGL* > item_list_t;
    item_list_t mItems;
    LLMenuItemGL*mFirstVisibleItem;
    LLMenuItemGL *mArrowUpItem, *mArrowDownItem;

    typedef std::map<KEY, LLMenuItemGL*> navigation_key_map_t;
    navigation_key_map_t mJumpKeys;
    S32             mLastMouseX;
    S32             mLastMouseY;
    S32             mMouseVelX;
    S32             mMouseVelY;
    U32             mMaxScrollableItems;
    U32             mPreferredWidth;
    BOOL            mHorizontalLayout;
    BOOL            mScrollable;
    BOOL            mKeepFixedSize;
    BOOL            mNeedsArrange;

    // Font for top menu items only
    const LLFontGL* mFont;

private:


    static LLColor4 sDefaultBackgroundColor;
    static BOOL     sKeyboardMode;

    BOOL            mAlwaysShowMenu;

    LLUIColor       mBackgroundColor;
    BOOL            mBgVisible;
    LLHandle<LLView> mParentMenuItem;
    LLUIString      mLabel;
    BOOL mDropShadowed;     //  Whether to drop shadow
    bool            mHasSelection;
    LLFrameTimer    mFadeTimer;
    LLTimer         mScrollItemsTimer;
    BOOL            mTornOff;
    class LLMenuItemTearOffGL* mTearOffItem;
    class LLMenuItemBranchGL* mSpilloverBranch;
    LLMenuGL*       mSpilloverMenu;
    KEY             mJumpKey;
    BOOL            mCreateJumpKeys;
    S32             mShortcutPad;
    bool            mResetScrollPositionOnShow;
}; // end class LLMenuGL



//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Class LLMenuItemBranchGL
//
// The LLMenuItemBranchGL represents a menu item that has a
// sub-menu. This is used to make cascading menus.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class LLMenuItemBranchGL : public LLMenuItemGL
{
public:
    struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
    {
        Optional<LLMenuGL*> branch;
    };

protected:
    LLMenuItemBranchGL(const Params&);
    friend class LLUICtrlFactory;
public:
    virtual ~LLMenuItemBranchGL();

    virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);

    virtual bool hasAccelerator(const KEY &key, const MASK &mask) const;
    virtual BOOL handleAcceleratorKey(KEY key, MASK mask);

    // check if we've used these accelerators already
    virtual BOOL addToAcceleratorList(std::list <LLMenuKeyboardBinding*> *listp);

    // called to rebuild the draw label
    virtual void buildDrawLabel( void );

    virtual void onCommit( void );

    virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
    virtual BOOL handleUnicodeChar(llwchar uni_char, BOOL called_from_parent);

    // set the hover status (called by it's menu) and if the object is
    // active. This is used for behavior transfer.
    virtual void setHighlight( BOOL highlight );

    virtual BOOL handleKeyHere(KEY key, MASK mask);

    virtual BOOL isActive() const;

    virtual BOOL isOpen() const;

    LLMenuGL* getBranch() const { return (LLMenuGL*)mBranchHandle.get(); }

    virtual void updateBranchParent( LLView* parentp );

    // LLView Functionality
    virtual void onVisibilityChange( BOOL curVisibilityIn );

    virtual void draw();

    virtual void setEnabledSubMenus(BOOL enabled) { if (getBranch()) getBranch()->setEnabledSubMenus(enabled); }

    virtual void openMenu();

    virtual LLView* getChildView(const std::string& name, BOOL recurse = TRUE) const;
    virtual LLView* findChildView(const std::string& name, BOOL recurse = TRUE) const;

private:
    LLHandle<LLView> mBranchHandle;
}; // end class LLMenuItemBranchGL


//-----------------------------------------------------------------------------
// class LLContextMenu
// A context menu
//-----------------------------------------------------------------------------

class LLContextMenu
: public LLMenuGL
{
public:
    struct Params : public LLInitParam::Block<Params, LLMenuGL::Params>
    {
        Params()
        {
            changeDefault(visible, false);
        }
    };

protected:
    LLContextMenu(const Params& p);
    friend class LLUICtrlFactory;

public:
    virtual ~LLContextMenu() {}

    // LLView Functionality
    // can't set visibility directly, must call show or hide
    virtual void    setVisible          (BOOL visible);

    virtual void    show                (S32 x, S32 y, LLView* spawning_view = NULL);
    virtual void    hide                ();

    virtual BOOL    handleHover         ( S32 x, S32 y, MASK mask );
    virtual BOOL    handleRightMouseDown( S32 x, S32 y, MASK mask );
    virtual BOOL    handleRightMouseUp  ( S32 x, S32 y, MASK mask );

    virtual bool    addChild            (LLView* view, S32 tab_group = 0);

            LLHandle<LLContextMenu> getHandle() { return getDerivedHandle<LLContextMenu>(); }

            LLView* getSpawningView() const     { return mSpawningViewHandle.get(); }
            void    setSpawningView(LLHandle<LLView> spawning_view) { mSpawningViewHandle = spawning_view; }

protected:
    BOOL                        mHoveredAnyItem;
    LLMenuItemGL*               mHoverItem;
    LLRootHandle<LLContextMenu> mHandle;
    LLHandle<LLView>            mSpawningViewHandle;
};

//-----------------------------------------------------------------------------
// class LLContextMenuBranch
// A branch to another context menu
//-----------------------------------------------------------------------------
class LLContextMenuBranch : public LLMenuItemGL
{
public:
    struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
    {
        Mandatory<LLContextMenu*> branch;
    };

    LLContextMenuBranch(const Params&);

    virtual ~LLContextMenuBranch();

    // called to rebuild the draw label
    virtual void    buildDrawLabel( void );

    // onCommit() - do the primary funcationality of the menu item.
    virtual void    onCommit( void );

    LLContextMenu*  getBranch() { return mBranch.get(); }
    void            setHighlight( BOOL highlight );

protected:
    void    showSubMenu();

    LLHandle<LLContextMenu> mBranch;
};


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Class LLMenuBarGL
//
// A menu bar displays menus horizontally.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class LLMenuBarGL : public LLMenuGL
{
public:
    struct Params : public LLInitParam::Block<Params, LLMenuGL::Params>
    {};
    LLMenuBarGL( const Params& p );
    virtual ~LLMenuBarGL();

    /*virtual*/ BOOL handleAcceleratorKey(KEY key, MASK mask);
    /*virtual*/ BOOL handleKeyHere(KEY key, MASK mask);
    /*virtual*/ BOOL handleJumpKey(KEY key);
    /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
    /*virtual*/ BOOL handleDoubleClick(S32 x, S32 y, MASK mask);

    /*virtual*/ void draw();
    /*virtual*/ BOOL jumpKeysActive();

    // add a vertical separator to this menu
    virtual BOOL addSeparator();

    // LLView Functionality
    virtual BOOL handleHover( S32 x, S32 y, MASK mask );

    // Returns x position of rightmost child, usually Help menu
    S32 getRightmostMenuEdge();

    void resetMenuTrigger() { mAltKeyTrigger = FALSE; }

private:
    // add a menu - this will create a drop down menu.
    virtual BOOL appendMenu( LLMenuGL* menu );
    // rearrange the child rects so they fit the shape of the menu
    // bar.
    virtual void arrange( void );

    void checkMenuTrigger();

    std::list <LLMenuKeyboardBinding*>  mAccelerators;
    BOOL                        mAltKeyTrigger;
};

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Class LLMenuHolderGL
//
// High level view that serves as parent for all menus
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class LLMenuHolderGL : public LLPanel
{
public:
    struct Params : public LLInitParam::Block<Params, LLPanel::Params>
    {};
    LLMenuHolderGL(const Params& p);
    virtual ~LLMenuHolderGL() {}

    virtual BOOL hideMenus();
    void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
    void setCanHide(BOOL can_hide) { mCanHide = can_hide; }

    // LLView functionality
    virtual void draw();
    virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
    virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );

    // Close context menus on right mouse up not handled by menus.
    /*virtual*/ BOOL handleRightMouseUp( S32 x, S32 y, MASK mask );

    virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
    virtual const LLRect getMenuRect() const { return getLocalRect(); }
    LLView*const getVisibleMenu() const;
    virtual BOOL hasVisibleMenu() const {return getVisibleMenu() != NULL;}

    static void setActivatedItem(LLMenuItemGL* item);

    // Need to detect if mouse-up after context menu spawn has moved.
    // If not, need to keep the menu up.
    static LLCoordGL sContextMenuSpawnPos;

private:
    static LLHandle<LLView> sItemLastSelectedHandle;
    static LLFrameTimer sItemActivationTimer;

    BOOL mCanHide;
};

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Class LLTearOffMenu
//
// Floater that hosts a menu
// https://wiki.lindenlab.com/mediawiki/index.php?title=LLTearOffMenu&oldid=81344
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class LLTearOffMenu : public LLFloater
{
public:
    static LLTearOffMenu* create(LLMenuGL* menup);
    virtual ~LLTearOffMenu();

    virtual void draw(void);
    virtual void onFocusReceived();
    virtual void onFocusLost();
    virtual BOOL handleUnicodeChar(llwchar uni_char, BOOL called_from_parent);
    virtual BOOL handleKeyHere(KEY key, MASK mask);
    virtual void translate(S32 x, S32 y);

    void updateSize();

private:
    LLTearOffMenu(LLMenuGL* menup);

    void closeTearOff();

    LLView*     mOldParent;
    LLMenuGL*   mMenu;
    S32         mTargetHeight;
    bool        mQuitRequested;
};

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Class LLMenuItemTearOffGL
//
// This class represents a separator.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class LLMenuItemTearOffGL : public LLMenuItemGL
{
public:
    struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
    {};

    LLMenuItemTearOffGL( const Params& );

    virtual void onCommit(void);
    virtual void draw(void);
    virtual U32 getNominalHeight() const;

    LLFloater* getParentFloater();
};


// *TODO: this is currently working, so finish implementation
class LLEditMenuHandlerMgr
{
public:
    LLEditMenuHandlerMgr& getInstance() {
        static LLEditMenuHandlerMgr instance;
        return instance;
    }
    virtual ~LLEditMenuHandlerMgr() {}
private:
    LLEditMenuHandlerMgr() {};
};


// *TODO: Eliminate
// For backwards compatability only; generally just use boost::bind
class view_listener_t : public boost::signals2::trackable
{
public:
    virtual bool handleEvent(const LLSD& userdata) = 0;
    view_listener_t() { sListeners.insert(this); }
    virtual ~view_listener_t() { sListeners.erase(this); }

    static void addEnable(view_listener_t* listener, const std::string& name)
    {
        LLUICtrl::EnableCallbackRegistry::currentRegistrar().add(name, boost::bind(&view_listener_t::handleEvent, listener, _2));
    }

    static void addCommit(view_listener_t* listener, const std::string& name)
    {
        LLUICtrl::CommitCallbackRegistry::currentRegistrar().add(name, boost::bind(&view_listener_t::handleEvent, listener, _2));
    }

    static void addMenu(view_listener_t* listener, const std::string& name)
    {
        // For now, add to both click and enable registries
        addEnable(listener, name);
        addCommit(listener, name);
    }

    static void cleanup()
    {
        listener_vector_t listeners(sListeners.begin(), sListeners.end());
        sListeners.clear();

        std::for_each(listeners.begin(), listeners.end(), DeletePointer());
        listeners.clear();
    }

private:
    typedef std::set<view_listener_t*> listener_map_t;
    typedef std::vector<view_listener_t*> listener_vector_t;
    static listener_map_t sListeners;
};

#endif // LL_LLMENUGL_H