CWE-ou-minkata/Sources/Tools/MaxMain/plMaxMenu.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "HeadSpin.h"
#include "max.h"
#include "iMenuMan.h"

#include "plMaxMenu.h"
#include "plActionTableMgr.h"
#include "resource.h"
#include "plSaveSelected.h"
#include "plComponentDlg.h"
#include "plMaxCFGFile.h"
#include "plResCollector.h"
#include "plAgeDescInterface.h"
#include "../MaxSceneViewer/SceneViewer.h"
#include "plNodeLock.h"
#include "plResetXform.h"
#include "plTextureSearch.h"
#include "../MaxExport/plExportDlg.h"

//  ************************* action table
//

// random id to identify an action table and context
const ActionTableId kActionId = 0x54162b7c;


enum
{
    kActionSaveSel,
    kActionMerge,
    kActionComponent,
    kActionResCollect,
    kActionAgeDesc,
    kActionCompCopy,
    kActionSceneViewer,
    kActionLock,
    kActionUnlock,
    kActionTexSearch,
    kActionReset,
    kActionSelectNonRenderables,
    kActionExport,
};

static ActionDescription spActions[] = 
{
    {
        kActionSaveSel,         // ActionId identifies action for callback execution (within table)
        IDS_ACT1_DESC,          // Action description for display in ui customization
        IDS_ACT1_NAME,          // Action name for display on menu
        IDS_ACT_CAT             // Action category for ui customization
    },
    {
        kActionMerge,
        IDS_ACT2_DESC,
        IDS_ACT2_NAME,
        IDS_ACT_CAT
    },
    {
        kActionComponent,
        IDS_ACT3_NAME,
        IDS_ACT3_NAME,
        IDS_ACT_CAT
    },
    {
        kActionResCollect,
        IDS_ACT4_NAME,
        IDS_ACT4_NAME,
        IDS_ACT_CAT
    },
    {
        kActionAgeDesc,
        IDS_ACT5_NAME,
        IDS_ACT5_NAME,
        IDS_ACT_CAT
    },
    {
        kActionCompCopy,
        IDS_ACT6_NAME,
        IDS_ACT6_NAME,
        IDS_ACT_CAT
    },
    {
        kActionSceneViewer,
        IDS_ACT7_NAME,
        IDS_ACT7_NAME,
        IDS_ACT_CAT
    },
    {
        kActionLock,
        IDS_ACT8_DESC,
        IDS_ACT8_NAME,
        IDS_ACT_CAT
    },
    {
        kActionUnlock,
        IDS_ACT9_DESC,
        IDS_ACT9_NAME,
        IDS_ACT_CAT
    },
    {
        kActionTexSearch,
        IDS_ACT10_NAME,
        IDS_ACT10_NAME,
        IDS_ACT_CAT
    },
    {
        kActionReset,
        IDS_ACT11_DESC,
        IDS_ACT11_NAME,
        IDS_ACT_CAT
    },
    {
        kActionSelectNonRenderables,
        IDS_ACT12_DESC,
        IDS_ACT12_NAME,
        IDS_ACT_CAT
    },
    {
        kActionExport,
        IDS_PLASMA_EXPORT,
        IDS_PLASMA_EXPORT,
        IDS_ACT_CAT
    }
};

// callback for action exection
bool DoAction(int id)
{
    switch(id)
    {
    case kActionSaveSel:
        plSaveSelected();
        return true;

    case kActionMerge:
        plMerge();
        return true;

    case kActionComponent:
        plComponentDlg::Instance().Open();
        return true;

    case kActionResCollect:
        plResCollector::Collect();
        return true;

    case kActionAgeDesc:
        plAgeDescInterface::Instance().Open();
        return true;

    case kActionCompCopy:
        CopyComponents();
        return true;

    case kActionSceneViewer:
        SceneViewer::Instance().Show();
        return true;

    case kActionLock:
        plNodeLock().Lock();
        return true;

    case kActionUnlock:
        plNodeLock().Unlock();
        return true;

    case kActionTexSearch:
        plTextureSearch::Instance().Toggle();
        return true;

    case kActionReset:
        plResetXform().ResetSelected();
        return true;

    case kActionSelectNonRenderables:
        plSelectNonRenderables().SelectNonRenderables();
        return true;

    case kActionExport:
        plExportDlg::Instance().Show();
        return true;
    }

    return false;
}

static ActionTableInfo actionInfo(kActionId, "Plasma", spActions, sizeof(spActions) / sizeof(ActionDescription));

// static or global declaration of action table manager
plActionTableMgr theActionTableMgr(actionInfo, DoAction);


//
//  ************************* end action table

//////////////////////////////////////////////////////////////////////////////
// Menu Creation Junk

MenuContextId kMyMenuContextId=0xcff95f6c;  //<random number>
static char *kMenuName = "Plasma";
static int kMenuVersion = 10;   // Increment this number if you add an entry to the menu

extern TCHAR *GetString(int id);

void AddPlasmaExportMenu()
{
    IMenuManager* pMenuMan = GetCOREInterface()->GetMenuManager();
    IMenu* fileMenu = pMenuMan->FindMenu("&File");

    int i;

    bool plasmaExportFound = false;

    // Make sure our action isn't already in the menu
    TSTR ourName = GetString(IDS_PLASMA_EXPORT);
    for (i = 0; i < fileMenu->NumItems(); i++)
    {
        IMenuItem* fileMenuItem = fileMenu->GetItem(i);
        const TSTR& title = fileMenuItem->GetTitle();
        if (title == ourName)
            plasmaExportFound = true;

        // KLUDGE - MaxAss didn't define the file submenu with an accelerator.
        // This fixes it.
        if (title == "MAX File Operations")
        {
            fileMenuItem->SetUseCustomTitle(true);
            bool custom = fileMenuItem->GetUseCustomTitle();
            fileMenuItem->SetTitle("MAX File Opera&tions");

            pMenuMan->UpdateMenuBar();
        }
    }

    if (!plasmaExportFound)
    {
        // Menu item isn't there, add it
        for (i = 0; i < fileMenu->NumItems(); i++)
        {
            IMenuItem* fileMenuItem = fileMenu->GetItem(i);
            const TSTR& title = fileMenuItem->GetTitle();
            // We want to add it after the "Export Selected" menu item
            if (title == "Export Selected...")
            {
                ActionTable* pActionTable = GetCOREInterface()->GetActionManager()->FindTable(kActionId);
                if (!pActionTable)
                {
                    hsAssert(0, "Action table not found");
                    return;
                }

                IMenuItem* menuItem = GetIMenuItem();
                menuItem->SetActionItem(pActionTable->GetAction(kActionExport));
                fileMenu->AddItem(menuItem, i+1);

                pMenuMan->UpdateMenuBar();

                return;
            }
        }
    }
}

void plCreateMenu()
{
    AddPlasmaExportMenu();

    IMenuManager* pMenuMan = GetCOREInterface()->GetMenuManager();
    bool newlyRegistered = pMenuMan->RegisterMenuBarContext(kMyMenuContextId, kMenuName);

    // Is the Max menu version the most recent?
    bool wrongVersion = GetPrivateProfileInt("Menu", "Version", 0, plMaxConfig::GetPluginIni()) < kMenuVersion;
    if (wrongVersion)
    {
        // Delete the old version of the menu
        IMenu *oldMenu = pMenuMan->FindMenu(kMenuName);
        if (oldMenu)
            pMenuMan->UnRegisterMenu(oldMenu);

        // Update the menu version
        char buf[30];
        WritePrivateProfileString("Menu", "Version", itoa(kMenuVersion, buf, 10), plMaxConfig::GetPluginIni());
    }
    
    if (wrongVersion || newlyRegistered)
    {
        IMenu *pMainMenu = pMenuMan->GetMainMenuBar();
        if (!pMainMenu)
        {
            hsAssert(0, "Main menu not found");
            return;
        }

        // Get our action table
        ActionTable* pActionTable = GetCOREInterface()->GetActionManager()->FindTable(kActionId);
        if (!pActionTable)
        {
            hsAssert(0, "Action table not found");
            return;
        }

        // Create the Plasma menu
        IMenu* pPlasmaMenu = GetIMenu();
        pPlasmaMenu->SetTitle(kMenuName);

        // Register the new menu with the system
        pMenuMan->RegisterMenu(pPlasmaMenu, 0);

        /////////////////////////////////////////////////
        // Add the menu items
        //

        // Add the save selected action to the menu
        IMenuItem* pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionSaveSel));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the merge action to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionMerge));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the component copy action to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionCompCopy));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add a separator
        pMenuItem = GetIMenuItem();
        pMenuItem->ActAsSeparator();
        pPlasmaMenu->AddItem(pMenuItem);
    
        // Add the component manager to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionComponent));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the resource collector to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionResCollect));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the texture search to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionTexSearch));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the age description to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionAgeDesc));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add a separator
        pMenuItem = GetIMenuItem();
        pMenuItem->ActAsSeparator();
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the SceneViewer to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionSceneViewer));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add a separator
        pMenuItem = GetIMenuItem();
        pMenuItem->ActAsSeparator();
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the Lock Selected to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionLock));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the Unlock Selected to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionUnlock));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the Reset Selected to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionReset));
        pPlasmaMenu->AddItem(pMenuItem);

        // Add the SelectNonRenderables to the menu
        pMenuItem = GetIMenuItem();
        pMenuItem->SetActionItem(pActionTable->GetAction(kActionSelectNonRenderables));
        pPlasmaMenu->AddItem(pMenuItem);

        // Create a new menu item to hold the sub-menu
        IMenuItem* pSubMenuItem1 = GetIMenuItem();   //menu in menu bar...
        pSubMenuItem1->SetSubMenu(pPlasmaMenu);
        pMainMenu->AddItem(pSubMenuItem1);

        pMenuMan->UpdateMenuBar();

        // Save the dang menu, in case Max crashes
        const char *uiDir = GetCOREInterface()->GetDir(APP_UI_DIR);
        char path[MAX_PATH];
        sprintf(path, "%s\\%s", uiDir, "MaxMenus.mnu");
        
        pMenuMan->SaveMenuFile(path);
    }

}

// End Menu Creation Junk
//////////////////////////////////////////////////////////////////////////////