source: src/UIElements/Menu/Qt4/QtMenu.hpp@ 91c409

/*
 * QtMenu.hpp
 *
 *  Created on: Nov 5, 2010
 *      Author: heber
 */

#ifndef MENUINTERFACEQT_HPP_
#define MENUINTERFACEQT_HPP_

// include config.h
#include <cstddef>
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif


#include <Qt/qaction.h>
#include <Qt/qpoint.h>

#include "Menu/Qt4/QMenu_tooltip.hpp"

#include <iostream>
#include <list>
#include <map>
#include <string>

#include "Menu/Menu.hpp"
#include "Menu/MenuInterface.hpp"
#include "Menu/Qt4/QtMenuPipe.hpp"

/** QtMenu is a specialization of MenuInterface to Qt-like menus.
 * I.e. with this interface we can access QMenu and QMenuBar.
 * (The latter is the reason why we have to add this additional wrapping layer).
 */
template <class T>
class QtMenu : virtual public MenuInterface, public Menu
{
public:
  explicit QtMenu(const std::string &_token) :
    MenuInterface(_token),
    Menu(_token),
    MenuInstance(new T(QString(getNameWithAccelerator(_token).c_str()))),
    deleteMenu(true)
  {}

  QtMenu(T *_Menu, const std::string &_token) :
    MenuInterface(_token),
    Menu(_token),
    MenuInstance(_Menu),
    deleteMenu(false)
  {}

  virtual ~QtMenu()
  {
    // delete all plumbed actions
    for(std::list<QtMenuPipe*>::iterator it=plumbing.begin(); it != plumbing.end(); it++)
      delete (*it);

    // delete all submenus
    for(SubMenus_t::iterator iter = submenus.begin(); iter != submenus.end(); ++iter)
      delete(*iter);

    // delete the wrapped instance if we took over ownership
    if (deleteMenu)
      delete MenuInstance;
  }

  T * const getMenuInstance()
  {
    return MenuInstance;
  }

protected:
  // We need to have a reference of the Menu, as Qt returns reference to added menu as well
  T *MenuInstance;

  /** Puts Qt's token, the ampersand, in front of the accelerator char in the menu name.
   * \param ActionName Action of menu
   * \return name with ampersand added at the right place
   */
  std::string getNameWithAccelerator(const std::string &ActionName)
  {
    std::string newname;
    bool Inserted = false;
    std::pair < MenuShortcutMap::iterator, bool > Inserter;
    for (std::string::const_iterator CharRunner = ActionName.begin();
        CharRunner != ActionName.end();
        ++CharRunner) {
//      std::cout << "Current char is " << *CharRunner << std::endl;
      if (!Inserted) {
        Inserter = ShortcutMap.insert(
            std::pair<char, std::string > (*CharRunner, ActionName)
            );
        if (Inserter.second) {
//          std::cout << "Accelerator is " << *CharRunner << std::endl;
          newname += '&';
          Inserted = true;
        }
      }
      newname += *CharRunner;
    }
    return newname;
  }

private:
  bool deleteMenu;
  std::list<QtMenuPipe*> plumbing;

  typedef std::map <char, std::string> MenuShortcutMap;
  MenuShortcutMap ShortcutMap;

  typedef std::list< QtMenu<QMenu_tooltip>* > SubMenus_t;
  SubMenus_t submenus;

  virtual void addActionItem(const std::string &token, const std::string &description)
  {
    QAction *action = MenuInstance->addAction(QString(getNameWithAccelerator(token).c_str()));
    action->setToolTip(QString(description.c_str()));
    action->setWhatsThis(QString(description.c_str()));
    QtMenuPipe *pipe = new QtMenuPipe(token,action);
    QObject::connect(action, SIGNAL(triggered()),pipe,SLOT(called()));
    plumbing.push_back(pipe);
  }

  virtual void addSeparatorItem()
  {
    MenuInstance->addSeparator();
  }

  virtual void addSubmenuItem(const std::string &token, const std::string &description)
  {
    QMenu_tooltip *Menu = new QMenu_tooltip(QString(token.c_str()));
    MenuInstance->addMenu(Menu);
    QtMenu<QMenu_tooltip> *NewMenu = new QtMenu<QMenu_tooltip>(Menu, token);
    submenus.push_back(NewMenu);
    NewMenu->init();
  }

public:
  QtMenu<QMenu_tooltip>* findSubmenu(const std::string &token) {
    for (SubMenus_t::iterator iter = submenus.begin(); iter != submenus.end(); ++iter) {
      QtMenu<QMenu_tooltip>* submenu = *(iter);
      if (submenu->getName() == token)
        return submenu;
      else {
        QtMenu<QMenu_tooltip>* found_submenu = submenu->findSubmenu(token);
        if (found_submenu != NULL)
        return found_submenu;
      }
    }
    return NULL;
  }

  void popup(const QPoint &pos) {
    MenuInstance->popup(pos);
  }
};

#endif /* MENUINTERFACEQT_HPP_ */