MenuBuilder.h

#pragma once
#include "AL/maya/Common.h"

#include "maya/MStatus.h"
#include "maya/MString.h"
#include "maya/MGlobal.h"

#include <sstream>
#include <string>
#include <vector>
#include <set>

namespace AL {
namespace maya {
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class MenuBuilder
{
public:

  struct MenuItem
  {
    std::string label; 
    std::string command; 
    std::string optionBox; 
    bool checkBox; 
    bool checkBoxValue; 
  };

  #ifndef AL_GENERATING_DOCS
  struct Menu
  {
    friend class MenuBuilder;

    ~Menu()
    {
      m_name.clear();
      m_childMenus.clear();
      m_menuItems.clear();
    }

    inline bool operator < (const Menu& menu) const
      { return m_name < menu.m_name; }

    inline bool operator == (const Menu& menu) const
      { return m_name == menu.m_name; }

    inline void print_indent(std::ostream& os, int indent) const
      { for(int i = 0; i <= indent; ++i) os << "  "; }

    void generate(std::ostringstream& os, std::ostringstream& kill, const char* prefix, int indent = 0) const;

    const std::string& name() const { return m_name; }
    const std::set<Menu>& childMenus() const { return m_childMenus; }
    const std::vector<MenuItem>& menuItems() const { return m_menuItems; }

  private:
    std::string m_name;
    mutable std::set<Menu> m_childMenus;
    mutable std::vector<MenuItem> m_menuItems;
  };

  // for unit testing ONLY!!
  static const std::set<Menu>& rootMenus()
    { return m_menus; }

  // for unit testing ONLY!!
  static void clearRootMenus()
    { m_menus.clear(); }
  #endif

  static MenuItem* addEntry(const char* menuItemPath, const char* command, bool hasCheckbox = false, bool defaultCheckBoxValue = false);

  static bool addEntry(const char* menuItemPath, const char* command, const char* optionBoxCommand);

  template<typename FnPlugin>
  static MStatus generatePluginUI(FnPlugin& fnPlugin, const MString& prefix, const MString& extraOnInit = "", const MString& extraOnExit = "")
  {
    if(m_menus.empty())
      return MS::kSuccess;
    MString ui_init = prefix + "_initGUI";
    MString ui_exit = prefix + "_exitGUI";

    // set up init script
    std::ostringstream initGUI;
    initGUI << "global proc " << ui_init.asChar() << "()\n{\n  global string $gMainWindow;\n";

    if(extraOnInit.length())
      initGUI << "  " << extraOnInit.asChar() << std::endl;

    // set up exit script
    std::ostringstream exitGUI;
    exitGUI << "global proc " << ui_exit.asChar() << "()\n{\n";
    if(extraOnExit.length())
      exitGUI << "  " << extraOnExit.asChar() << std::endl;
    exitGUI << "  deleteUI ";

    // now construct all of the menu related gubbins.
    for(auto it = m_menus.begin(); it != m_menus.end(); ++it)
    {
      it->generate(initGUI, exitGUI, prefix.asChar());
    }
    m_menus.clear();

    // finish off

    initGUI << "}\n\n";
    exitGUI << ";\n}\n\n";

    MGlobal::executeCommand(initGUI.str().c_str());
    MGlobal::executeCommand(exitGUI.str().c_str());

    #if AL_USD_PRINT_UI_CODE
    std::cout << initGUI.str() << std::endl;
    std::cout << exitGUI.str() << std::endl;
    #endif

    return fnPlugin.registerUI(ui_init, ui_exit);
  }

private:
  static std::set<Menu> m_menus;
};

//----------------------------------------------------------------------------------------------------------------------
} // usdmaya
} // AL
//----------------------------------------------------------------------------------------------------------------------