menuhandler.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        N. Hemstra
 Date:          May 2003
________________________________________________________________________

-*/

#include "generalmod.h"
#include "refcount.h"
#include "position.h"
#include "notify.h"
#include "bufstring.h"
#include "uistring.h"

class BufferStringSet;
class MenuItem;
class MenuHandler;

mExpClass(General) MenuItemHolder : public CallBacker
{
public:
                                MenuItemHolder();
    virtual                     ~MenuItemHolder();
    Notifier<MenuItemHolder>    removal;
    virtual void                addItem(MenuItem*,bool manage=false);
    void                        removeItems();
    int                         nrItems() const;

    const MenuItem*             getItem(int idx) const;
    MenuItem*                   getItem(int idx);
    int                         itemIndex(const MenuItem*) const;
    int                         itemIndex(int id) const;
    MenuItem*                   findItem(int id);
    const MenuItem*             findItem(int id) const;
    MenuItem*                   findItem(const char*);
    const MenuItem*             findItem(const char*) const;

    const ObjectSet<MenuItem>&  getItems() const;

protected:
    friend                      class MenuHandler;
    void                        itemIsDeletedCB(CallBacker*);
    virtual void                assignItemID(MenuItem&);
    MenuItemHolder*             parent_;

private:
    ObjectSet<MenuItem>         items_;
    BoolTypeSet                 manageitems_;
};

mExpClass(General) MenuItem : public MenuItemHolder
{
public:
                                MenuItem(const uiString&
                                             text=uiString::emptyString(),
                                         int placement=-1);
                                MenuItem(const uiString& text,
                                         CallBack cb,int placement=-1);
                                MenuItem(const uiString& text,
                                         const char* iconnm,
                                         const uiString& tooltip,
                                         CallBack cb=CallBack(),
                                         int placement=-1);
    void                        createItems(const BufferStringSet&);
    void                        createItems(const uiStringSet&);

    uiString                    text;
                                /*< The text that should be on the item. */
    int                         placement;
    int                         id;
    bool                        checkable;
    bool                        checked;
    bool                        enabled;
    BufferString                iconfnm;
                                //*!< Icon identifier
    uiString                    tooltip;
                                //*!< Tooltip if item is used in toolbar
    CallBack                    cb;
                                //*!< Callback function to be called
};


mExpClass(General) SeparatorItem : public MenuItem
{ mODTextTranslationClass(SeparatorItem);
public:
                                SeparatorItem(int plmnt=-1)
                                    : MenuItem(tr("Separator"),plmnt)   {}
};


mExpClass(General) MenuHandler  : public RefCount::Referenced
                                , public MenuItemHolder
{
public:
                                MenuHandler( int id );

    virtual bool                executeMenu()                           = 0;

    int                         menuID() const { return id_; }
                                /*<Each menu has an unique id where the
                                   that identifies it. */
    void                        setMenuID( int newid ) { id_=newid; }

    Notifier<MenuHandler>       initnotifier;
    Notifier<MenuHandler>       createnotifier;
    CNotifier<MenuHandler,int>  handlenotifier;
    bool                        isHandled() const;
    void                        setIsHandled(bool);
    int                         queueID() const { return queueid_; }
protected:
                                ~MenuHandler();
    void                        assignItemID(MenuItem&);
    void                        executeQueue();

    int                         id_;
    bool                        ishandled_;
    int                         queueid_;
};


mExpClass(General) MenuItemHandler : public CallBacker
{
public:
                        MenuItemHandler(MenuHandler&,const uiString& nm,
                                        const CallBack&,const char* parenttxt=0,
                                        int placement=-1);
                        ~MenuItemHandler();
    bool                doadd_;
    bool                isenabled_;
    bool                ischecked_;
    void                setIcon(const char* fnm);

protected:

    virtual void        createMenuCB(CallBacker*);
    virtual void        handleMenuCB(CallBacker*);

    virtual bool        shouldAddMenu() const                   { return true; }
    virtual bool        shouldBeEnabled() const                 { return true;}
    virtual bool        shouldBeChecked() const                 { return false;}

    MenuItem            menuitem_;
    MenuHandler&        menuhandler_;
    CallBack            cb_;
    BufferString        parenttext_;
};



#define mResetMenuItem( item ) \
{ \
    (item)->enabled = true; \
    (item)->checked = false; \
    (item)->id = -1; \
    (item)->removeItems(); \
}

#define mAddMenuItemWithManageFlag( parent, item, manage, enab, check ) \
{ \
    MenuItem* _item = item; \
    MenuItemHolder* _parent = parent; \
    if ( _parent && (_parent)->itemIndex(_item)==-1 ) \
        (_parent)->addItem( _item ); \
   \
    (_item)->enabled = (enab); \
    (_item)->checked = (check); \
}

#define mAddMenuItem( parent, item, enab, check ) \
mAddMenuItemWithManageFlag( parent, item, false, enab, check )


#define mAddManagedMenuItem( parent, item, enab, check ) \
mAddMenuItemWithManageFlag( parent, item, true, enab, check )


#define mAddMenuItemCond( menu, item, enab, check, cond ) { \
    if ( menu && cond ) \
        mAddMenuItem( menu, item, enab, check ) \
    else \
        mResetMenuItem( item ) } \

//Macro that can poplulate both a toolbar and a menu.
#define mAddMenuOrTBItem( istoolbar, tbparent, popupparent, item, enab, check )\
    mAddMenuItem( \
        istoolbar?(MenuItemHolder*)(tbparent):(MenuItemHolder*)(popupparent), \
            item, enab, check )