include/commonWgt/popupMenu.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2009 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: popupMenu.h,v $ $Revision: 1.42 $ $State: Exp $
*******************************************************************************/


#ifndef DTPOPUPMENU_H
#define DTPOPUPMENU_H

#include "commonWgt/commonWgtDefines.h"
#include "vrfGuiCore/menuItems.h"

#include <QtGui/QMenu>
#include <QtGui/QAction>
#include <QtCore/QList>
#include <QtCore/QHash>

class DtMenuWidget;
class DtFeatureActionManager;


class DT_DLL_commonWgt DtPopupMenuItem
{
public:
   DtPopupMenuItem() : myPos(-1), myIsSeparator(false), myAddSeparator(false), myIsToggle(false), myIsOn(false),
      myType(DtNoMenuItem), myGroup(DtNoMenuItem), myIsActionItem(false), myProcessed(false), myMenu(DtNoMenu) {};

   DtPopupMenuItem(const DtPopupMenuItem& orig) :
      myText(orig.myText),
      myToolTip(orig.myToolTip),
      myAccel(orig.myAccel),
      myName(orig.myName),
      myObjectName(orig.myObjectName),
      myPos(orig.myPos),
      myIsSeparator(orig.myIsSeparator),
      myAddSeparator(orig.myAddSeparator),
      myIsToggle(orig.myIsToggle),
      myIsOn(orig.myIsOn),
      myIsActionItem(orig.myIsActionItem),
      myType(orig.myType),
      myGroup(orig.myGroup),
      myMenu(orig.myMenu),
      myProcessed(false)
   {
   }

   bool operator==(const DtPopupMenuItem& orig) const
   {
      return ((myText == orig.myText) &&
         (myToolTip == orig.myToolTip) &&
         (myAccel == orig.myAccel) &&
         (myName == orig.myName) &&
         (myObjectName == orig.myObjectName) &&
         (myIsSeparator == orig.myIsSeparator) &&
         (myAddSeparator == orig.myAddSeparator) &&
         (myIsToggle == orig.myIsToggle) &&
         (myIsOn == orig.myIsOn) &&
         (myIsActionItem == orig.myIsActionItem) &&
         (myType == orig.myType) &&
         (myMenu == orig.myMenu) &&
         (myGroup == orig.myGroup));
   }

public:
   QString        myText;
   QString        myToolTip;
   QString        myAccel;
   QString        myName;
   QString        myObjectName;
   int            myPos;
   bool           myIsSeparator;
   bool           myAddSeparator;
   bool           myIsToggle;
   bool           myIsOn;
   bool           myIsActionItem;
   DtMenuItemType myType;
   DtMenuItemType myGroup;
   DtMainMenuType myMenu;
   bool           myProcessed;
};

class DT_DLL_commonWgt DtMenuItemValidator
{
public:
   DtMenuItemValidator(QObject* vc, const char* v) : myValidatorCall(vc), myValidator(v) {};
   DtMenuItemValidator(const DtMenuItemValidator& orig) :
      myValidatorCall(orig.myValidatorCall), myValidator(orig.myValidator) {}
   QObject* myValidatorCall;
   const char* myValidator;
};

class DT_DLL_commonWgt DtActionValidatorMap
{
public:
   DtActionValidatorMap() {  };
   DtActionValidatorMap(const DtActionValidatorMap& orig) :
      myActionCall(orig.myActionCall),
      myAction(orig.myAction),
      myValidators(orig.myValidators)
   {
   }

public:
   QObject* myActionCall;
   const char* myAction;
   QList<DtMenuItemValidator> myValidators;
};

class DT_DLL_commonWgt DtActionGroup : public QActionGroup
{
   Q_OBJECT

public:
   DtActionGroup(QMenu* parent);
   virtual ~DtActionGroup();

   void setUsesDropDown(bool b) { myUsesDropDown = b; };
   bool usesDropDown() const { return myUsesDropDown; };

   void setTitle(const QString& t);
   const QString& title() const { return myTitle; };

   void setTearOffEnabled(bool);

   QMenu* menu();
   QMenu* menuParent();

   QAction* addAction(QAction* action, QString addBefore = "");
   QAction* addAction(const QString& text, QString addBefore = "");
   QAction* addAction(const QIcon& icon, const QString& text, QString addBefore = "");

   virtual QMenu*   createMenu();

   void addActions(const QList<QAction*>&);

   void removeAttachment();
   void linkTo(DtActionGroup*, int);

   void attach();

   QAction* action(int);

   int numActions() const;

protected slots:
   virtual void actionDestroyed();

protected:
   virtual QAction* addActionInternal(QAction*, QString addBefore);

protected:
   QMenu*   myDropDownMenu;
   QMenu*   myMenuParent;
   bool     myUsesDropDown;
   QString  myTitle;
   DtActionGroup* myLinkTo;
   int      myInsertAtIndex;

   QList<QAction*>   myActions;
};

const int DtSeparatorType           = 0x80000000;
const int DtGroupAddType            = 0x40000000;

const int DtMapDoNotValidate        = 0x00000001;
const int DtMapCreateMenuItems      = 0x00000002;

class DT_DLL_commonWgt DtPopupMenu : public QMenu
{
   Q_OBJECT

public:
   DtPopupMenu ( QWidget * parent, bool display = true);
   virtual ~DtPopupMenu();

   virtual bool init(DtMainMenuType iType, DtMenuWidget* menu, QWidget* owner, int iPos = -1, int iID = -1);
   virtual void insertMenu(DtMenuWidget* menuWidget, int iPos = -1, int iID = -1);

   virtual bool setup(DtMenuWidget* menuWidget);

   virtual void preCreateMenuItems();

   virtual bool createMenuItems();

   virtual int id() const;

   virtual DtMenuItemType typeFromAction(QAction*);

   virtual DtMenuItemType typeFromName(const QString&);

   virtual QAction* menuItemForType(DtMenuItemType iType);

   virtual bool hasType(DtMenuItemType iType);

   virtual int positionOfMenuItem(const DtPopupMenuItem& item);
   virtual int positionOfMenuItem(DtMenuItemType iType);

   virtual int menuItemPositionOf(QAction* action);

   virtual DtActionGroup* getActionGroupForType(DtMenuItemType iType);

   virtual DtMainMenuType type() const;

   virtual void setOwner(QWidget* owner);
   virtual QWidget* owner() const;

   virtual void setEnableValidations(bool b);

   virtual void reconfigureMenu(QList<DtMenuItemType>& items, bool keep);

   virtual void updateMenuItems();

   virtual void seedActionGroups();

   virtual bool attachMenu(const QString& title, DtPopupMenu*, int iIndex = -1);

   bool initialized() const;

   DtFeatureActionManager* featureActionManager() const;
   virtual void setFeatureActionManager(DtFeatureActionManager*);

   void setAddFeatures(bool);
   bool addFeatures() const;

   virtual QString shortcutFor(const QString& feature) const;
   virtual void addShortcut(const QString& feature, const QString& shortcut);
   virtual void replaceShortcut(const QString& feature, const QString& shortcut);
   virtual bool hasShortcutOverride(const QString& feature) const;
   virtual bool hasShortcut(const QString& feature) const;

   virtual QString iconFor(const QString& feature, QIcon::Mode mode = QIcon::Normal, QIcon::State = QIcon::Off,
      bool useDefault = false);

   virtual QString menuTextForAction(QAction*);

public:
   virtual QHash<DtMenuItemType, QAction*>& actions();
   virtual QList<QAction*> menuActions();
   virtual const QList<DtPopupMenu*>& attachedMenus() const;

public:

   virtual DtPopupMenuItem* insertMenuItem(DtMenuItemType iPos, const QString& featureName, DtMenuItemType iType, QString text,
      QString toolTip = QString::null, QString accel = QString::null, bool addSeparator = false,
      bool toggle = false, bool isOn = false, const QString& objectName = "");

   virtual DtPopupMenuItem* insertMenuItem(DtMenuItemType iPos, DtMenuItemType iType, QString text,
      QString toolTip = QString::null, QString accel = QString::null, bool addSeparator = false,
      bool toggle = false, bool isOn = false, const QString& objectName = "");

   virtual DtPopupMenuItem* insertToggleMenuItem(DtMenuItemType iBefore, const QString& featureName, DtMenuItemType iType,
      QString text, QString toolTip = QString::null, QString accel = QString::null, bool addSeparator = false,
      bool isOn = false, const QString& objectName = "");

   virtual DtPopupMenuItem* insertToggleMenuItem(DtMenuItemType iBefore, DtMenuItemType iType,
      QString text, QString toolTip = QString::null, QString accel = QString::null, bool addSeparator = false,
      bool isOn = false, const QString& objectName = "");

   virtual void addMenuItemSeparator(DtMenuItemType iGroup);

   virtual void removeMenuItem(DtMenuItemType iType);

   virtual bool removeMenuGroup(const QString& gr);

   virtual void removeItemAtPosition(int iPos);

   virtual void addIcon(DtMenuItemType iType, QString icon, QIcon::Mode mode = QIcon::Normal, QIcon::State = QIcon::Off);

   virtual void removeIcon(DtMenuItemType iType, QIcon::Mode mode = (QIcon::Mode)-1, QIcon::State = QIcon::Off);

   virtual void addGroup(DtMenuItemType iToGroup, DtMenuItemType iGroup, int iPos, bool addSep = false);

   virtual void removeGroup(DtMenuItemType iGroup);

   virtual void addMenu(DtMainMenuType, int iPos, bool addSep);

   virtual void removeMenu(DtMainMenuType iGroup);

   virtual void mappingMenu(DtPopupMenu* menu, int iFlags = 0);

   virtual void mapMenuItem(DtMenuItemType iType, DtPopupMenu& popupMenu, int iPos = -1, bool addSeparator = false);

   virtual void setPosition(int iPos);

   virtual bool matchesName(QString name);

   virtual DtMenuItemType uniqueId() const;

   virtual QAction* addMenuItem(DtMenuItemType& retId,
      const QString& featureName, const QString& item, const QString& addToMenu,
      bool toggle = false, QObject* actionReceiver = NULL,
      const char* action = NULL, QObject* validationReceiver = NULL,
      const char* validation = NULL, const QString& tooltip = QString::null,
      const QString& accelerator = QString::null, bool addSep = false);

   virtual void appendMenuValidator(DtMenuItemType iType, QObject* vCall, const char* validator);
   virtual void appendMenuValidator(const QString& menu, QObject* vCall, const char* validator);

   virtual bool removeMenuItem(const QString& item);

   virtual void setupFrom(DtMainMenuType iType, DtPopupMenu*, QWidget*, DtMenuWidget* w);

public:
   virtual void renameMenuItem(DtMenuItemType iType, QString text = QString::null,
      QString toolTip = QString::null, QString accel = QString::null);

   virtual void positionBefore(DtMenuItemType iType, DtMenuItemType iBefore);
   virtual void positionAfter(DtMenuItemType iType, DtMenuItemType iAfter);

public:
   virtual QString menuName();

   virtual void addActionAndValidatorForType(DtMenuItemType iType, QObject* aCall, const char* action,
      QObject* vCall = NULL, const char* validator = NULL);
   virtual void addActionForType(DtMenuItemType iType, QObject* aCall, const char* action);
   virtual void addValidatorForType(DtMenuItemType iType, QObject* vCall, const char* validator);

   virtual void addGlobalActionAndValidatorForType(DtMenuItemType iType, QObject* aCall, const char* action,
      QObject* vCall = NULL, const char* validator = NULL);

   virtual DtActionGroup* actionGroupWithName(const QString&) const;
   virtual QAction* actionWithName(const QString&) const;

   virtual void clearMenuItems();

   virtual void removeFeatureActions();

signals:
   void validateItems();

public slots:
   virtual void validate();
   virtual void menuItemDestroyed(QAction*);
   virtual void actionGroupDestroyed(DtActionGroup*);
   virtual void featureActionManagerDestroyed();

protected slots:
   virtual void popupRemoved(QObject*);
   virtual void menuItemDestroyed();
   virtual void actionGroupDestroyed();

protected:
   virtual bool initMenuItems();

   virtual bool initActionGroups();

   virtual bool removeMenuItemAtPosition(int iPos);

   virtual void addNewMenuItem(DtPopupMenuItem& item, int iPos);

   virtual QAction* createMenuItem(const DtPopupMenuItem& item);

   virtual void attachMenuItems();

   virtual void attachMenuItem(const DtPopupMenuItem& item);

   virtual void addCompletedItemsToMenu();

   virtual void addAttachedMenus();

   virtual void setIcon(DtMenuItemType iType);

   virtual void attachValidators(bool b);

   virtual void initConnections();

   virtual DtPopupMenuItem* popupMenuItem(DtMenuItemType iType, bool actionable = false);

   virtual DtActionValidatorMap* actionValidatorMapEntry(DtMenuItemType iType);

   virtual void removeOrderedMenuItem(int iPos);

   virtual int addOrderedItem(const DtPopupMenuItem& item, int iPos);

   virtual void setMapMenuItemsTo(DtPopupMenu* menu);

   virtual void addActionGroup(DtActionGroup*);
   virtual bool matchesName(QString menu, QString name) const;

   virtual DtActionGroup* internalGetActionGroupForType(DtMenuItemType type);

   virtual QAction* addNewActionToActionGroup(const DtPopupMenuItem& item);

   virtual void addAllActionsFor(DtActionGroup*);

protected:
   QHash<DtMenuItemType, QAction*> myActions;
   QHash<DtMenuItemType, DtPopupMenuItem> myMenuItems;
   QHash<DtMenuItemType, DtActionValidatorMap> myActionValidators;
   QList<DtPopupMenuItem> myOrderedMenuItems;
   QHash<DtMenuItemType, QIcon> myIcons;
   int myId;
   bool myCreated;
   bool myInited;
   QWidget* myOwner;
   DtMainMenuType myType;
   bool myEnableValidations;
   DtMenuWidget* myMenuWidget;
   bool myDisplay;

   QHash<DtPopupMenu*, int> myMenuMappingList;

   DtPopupMenu* myMenuItemProxy;

   static QHash<DtMenuItemType, DtActionValidatorMap> myGlobalActionValidators;

   QList<DtActionGroup*> myActionGroups;

   QHash<DtMenuItemType, DtActionGroup*> myInternalGroupMappings;

   QList<DtPopupMenu*> myAttachedMenus;

   QList<DtActionGroup*> myPendingActionGroups;

   QVector<QString>     myRemovedActionGroups;

   DtFeatureActionManager* myFeatureActionManager;

   bool myAddFeatures;
};

typedef DtPopupMenu* (*DtPopupMenuCreatorFcn)(QWidget* parent, bool display);

inline bool DtPopupMenu::initialized() const
{
   return myInited;
}

inline DtFeatureActionManager* DtPopupMenu::featureActionManager() const
{
   return myFeatureActionManager;
}

inline void DtPopupMenu::setAddFeatures(bool b)
{
   myAddFeatures = b;
}

inline bool DtPopupMenu::addFeatures() const
{
   return myAddFeatures;
}

#endif