aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-11-08 16:29:00 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/ryzom/client/src/interface_v3/macrocmd_key.cpp

1423 lines
50 KiB
C++
Raw Blame History

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
// Interface
#include "macrocmd_key.h"
#include "macrocmd_manager.h"
#include "interface_manager.h"
#include "action_handler.h"
#include "ctrl_button.h"
#include "group_editbox.h"
#include "group_list.h"
#include "dbgroup_combo_box.h"
#include "group_container.h"
#include "group_modal_get_key.h"
#include "interface_expr.h"
// tmp
#include "../r2/editor.h"
using namespace std;
using namespace NLMISC;
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// KEYS SHORTCUT KEYS SHORTCUT KEYS SHORTCUT KEYS SHORTCUT KEYS SHORTCUT KEYS
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// To display all keys
#define WIN_KEYS "ui:interface:keys"
#define WIN_KEYS_GAME "ui:interface:keys_"
#define WIN_KEYS_EDIT "ui:interface:keys_edit"
#define WIN_KEYS_EDIT_CONTENT "ui:interface:keys_edit:content"
#define TEMPLATE_KEYS_GROUP "tk_line"
#define TEMPLATE_KEYS_KEY_NAME "name"
#define TEMPLATE_KEYS_SHORTCUT_NAME "command"
// To edit a key already defined
/*
#define WIN_EDITKEY "ui:interface:editkey"
#define VIEW_EDITKEY_TEXT_CATEGORY "ui:interface:editkey:content:category"
#define VIEW_EDITKEY_TEXT_ACTION "ui:interface:editkey:content:action"
#define VIEW_EDITKEY_TEXT_FIRST_PARAM "ui:interface:editkey:content:param1"
#define VIEW_EDITKEY_TEXT_SECOND_PARAM "ui:interface:editkey:content:param2"
#define VIEW_EDITKEY_TEXT_FIRST_PARAM_NAME "ui:interface:editkey:content:param1_name"
#define VIEW_EDITKEY_TEXT_SECOND_PARAM_NAME "ui:interface:editkey:content:param2_name"
#define VIEW_EDITKEY_TEXT_KEY "ui:interface:editkey:content:txtkey"
*/
// To define a key
#define WIN_MODAL_GET_KEY "ui:interface:assign_key"
// ***************************************************************************
// Display all keys
// ***************************************************************************
// ***************************************************************************
// Add the template key to the parent
void addKeyLine (CGroupList *pParent, const ucstring &keyName, const ucstring &shortcutName, bool grayed)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
uint lineId= (uint)pMCM->NewKey->AllLines.size();
string templateId = pParent->getId() + ":k" + NLMISC::toString(lineId);
vector< pair<string, string> > vParams;
vParams.push_back(make_pair(string("id"), templateId));
vParams.push_back(make_pair(string("lineid"), toString(lineId)));
CInterfaceGroup *pKeysLine = NULL;
pKeysLine = pIM->createGroupInstance (TEMPLATE_KEYS_GROUP, pParent->getId(), vParams);
if (pKeysLine == NULL) return;
// Put name
CViewText *pViewKeyName = dynamic_cast<CViewText*>(pKeysLine->getView(TEMPLATE_KEYS_KEY_NAME));
if (pViewKeyName != NULL)
{
pViewKeyName->setText (keyName);
pViewKeyName->setColor(grayed?pIM->getSystemOption(CInterfaceManager::OptionCtrlTextGrayColor).getValColor():CRGBA::White);
}
CViewText *pViewShortcutName = dynamic_cast<CViewText*>(pKeysLine->getView(TEMPLATE_KEYS_SHORTCUT_NAME));
if (pViewShortcutName != NULL)
{
pViewShortcutName->setText (shortcutName);
pViewShortcutName->setColor(grayed?pIM->getSystemOption(CInterfaceManager::OptionCtrlTextGrayColor).getValColor():CRGBA::White);
}
pKeysLine->setParent (pParent);
pParent->addChild (pKeysLine);
}
// ***************************************************************************
struct CComboActionName
{
CCombo Combo; // KeyCount <=> action name unbound
CAction::CName ActionName;
};
void buildActionToComboMap(uint8 nAM, CGroupList * /* pList */, string catName, map<ucstring, CComboActionName> &remaped)
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
CActionsManager *pAM = pMCM->ActionManagers[nAM];
const CActionsManager::TComboActionMap &keyShortcut = pAM->getComboActionMap();
// *** Order Keys by actions
// parse the combo map
CActionsManager::TComboActionMap::const_iterator it = keyShortcut.begin();
while (it != keyShortcut.end())
{
const CAction::CName &rName = it->second;
// if match the current category parsed
const CCategory *pCat = pAM->getCategory(rName);
if (pCat != NULL)
if (pCat->Name == catName)
{
// see if action active in current context
if (pAM->isActionPresentInContext(it->second))
{
pair<ucstring, CComboActionName> value;
// Don't take any risk: avoid any bug if the localisation is buggy and give same text for 2 differents CAction::CName
// Use the localized text first, to have correct sort according to language
value.first= pAM->getActionLocalizedText(rName) + rName.Name + rName.Argu;
value.second.Combo= it->first;
value.second.ActionName= it->second;
remaped.insert(value);
}
}
it++;
}
// *** Add unbound "ForceDisplay" actions
const CActionsManager::TActionsForceDisplaySet &actionFD = pAM->getActionsForceDisplaySet();
CActionsManager::TActionsForceDisplaySet::const_iterator itFD= actionFD.begin();
for(;itFD!=actionFD.end();itFD++)
{
const CAction::CName &rName = *itFD;
// const CBaseAction *baseAction = pAM->getBaseAction(rName);
// if match the current category parsed
const CCategory *pCat = pAM->getCategory(rName);
if (pCat != NULL)
if (pCat->Name == catName)
{
// see if action active in current context
if (pAM->isActionPresentInContext(rName))
{
pair<ucstring, CComboActionName> value;
// Don't take any risk: avoid any bug if the localisation is buggy and give same text for 2 differents CAction::CName
// Use the localized text first, to have correct sort according to language
value.first= pAM->getActionLocalizedText(rName) + rName.Name + rName.Argu;
// if alredy added (ie combo bound)
if(remaped.find(value.first)!=remaped.end())
continue;
// Add this unbound action
value.second.Combo.Key= KeyCount;
value.second.Combo.KeyButtons= noKeyButton;
value.second.ActionName= rName;
remaped.insert(value);
}
}
}
}
// Get all the couple (combo,action) from the action manager nAM and insert them into pList (with the template)
void getAllComboAction(uint8 nAM, CGroupList *pList, const map<ucstring, CComboActionName> &remaped)
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
CActionsManager *pAM = pMCM->ActionManagers[nAM];
// *** Fill Actions
map<ucstring, CComboActionName>::const_iterator remapIT = remaped.begin();
while (remapIT != remaped.end())
{
ucstring keyName;
if(remapIT->second.Combo.Key==KeyCount)
keyName= CI18N::get("uiNotAssigned");
else
keyName= remapIT->second.Combo.toUCString();
const CBaseAction *baseAction = pAM->getBaseAction(remapIT->second.ActionName);
if (baseAction)
{
ucstring shortcutName = baseAction->getActionLocalizedText(remapIT->second.ActionName);
addKeyLine(pList, keyName, shortcutName, remapIT->second.Combo.Key==KeyCount);
CModalContainerEditCmd::CLine line;
line.ComboAM= nAM;
line.Combo= remapIT->second.Combo;
line.ActionName= remapIT->second.ActionName;
pMCM->NewKey->AllLines.push_back(line);
}
remapIT++;
}
}
// ***************************************************************************
// Called when we activate the keys container
class CHandlerKeysOpen: public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &/* Params */)
{
// Initialisation of category combo box
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
for (uint nAM = 0; nAM < pMCM->ActionManagers.size(); ++nAM)
{
CActionsManager *pAM = pMCM->ActionManagers[nAM];
const vector<CCategory> &rCats = pAM->getCategories();
CGroupContainer *pGC;
for (uint i = 0; i < rCats.size(); ++i)
{
string contName = string(WIN_KEYS_GAME)+rCats[i].Name;
pGC = dynamic_cast<CGroupContainer*>(pIM->getElementFromId(contName));
if(pGC != NULL)
{
pGC->setX(0);
pGC->setY(0);
}
}
}
// Ensure the Key edit is closed
pMCM->NewKey->deactivate();
pMCM->NewKey->CurAM = NULL;
pMCM->NewKey->AllLines.clear();
// Get the group to add all (keys,shortcut) couple
for (uint nAM = 0; nAM < pMCM->ActionManagers.size(); ++nAM)
{
CActionsManager *pAM = pMCM->ActionManagers[nAM];
const vector<CCategory> &rCats = pAM->getCategories();
for (uint i = 0; i < rCats.size(); ++i)
{
string contName = string(WIN_KEYS_GAME)+rCats[i].Name;
CInterfaceGroup *pCategory = dynamic_cast<CInterfaceGroup *>(pIM->getElementFromId(contName));
CGroupList *pList = dynamic_cast<CGroupList*>(pIM->getElementFromId(contName + ":content"));
if (pCategory != NULL && pList != NULL)
{
pList->clearGroups();
pList->setDynamicDisplaySize(true);
map<ucstring, CComboActionName> remaped;
buildActionToComboMap(nAM, pList, rCats[i].Name, remaped);
if (!remaped.empty())
{
getAllComboAction(nAM, pList, remaped);
pCategory->setActive(true);
}
else
{
pCategory->setActive(false);
}
}
}
}
}
};
REGISTER_ACTION_HANDLER( CHandlerKeysOpen, "keys_open");
// ***************************************************************************
// Called when we push the new button
class CHandlerKeysNew: public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &/* Params */)
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
pMCM->NewKey->CurrentEditCmdNb = -1;
pMCM->NewKey->activate();
}
};
REGISTER_ACTION_HANDLER( CHandlerKeysNew, "keys_new");
// ***************************************************************************
class CHandlerKeysAssign: public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
// Setup the editkey container from line
if (pCaller == NULL) return;
string sId = pCaller->getId();
sId = sId.substr(sId.rfind('k')+1,sId.size());
sint32 nLineNb;
fromString(sId, nLineNb);
if ((nLineNb < 0) || (nLineNb >= (sint32)pMCM->NewKey->AllLines.size())) return;
pMCM->NewKey->CurrentEditCmdLine = pMCM->NewKey->AllLines[nLineNb];
pMCM->NewKey->CurAM = pMCM->ActionManagers[pMCM->NewKey->AllLines[nLineNb].ComboAM];
CGroupModalGetKey*pGetKey = dynamic_cast<CGroupModalGetKey*>(pIM->getElementFromId(WIN_MODAL_GET_KEY));
pGetKey->Caller = "editkey";
pIM->enableModalWindow(pCaller, WIN_MODAL_GET_KEY);
}
};
REGISTER_ACTION_HANDLER( CHandlerKeysAssign, "keys_assign");
// ***************************************************************************
// Called when we right click on a shortcut line and choose edit from context menu
class CHandlerKeysEdit: public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
// Setup the editkey container from line
if (pCaller == NULL) return;
string sId = pCaller->getId();
sId = sId.substr(sId.rfind('k')+1,sId.size());
sint32 nLineNb;
fromString(sId, nLineNb);
if ((nLineNb < 0) || (nLineNb >= (sint32)pMCM->NewKey->AllLines.size())) return;
pMCM->NewKey->CurrentEditCmdLine = pMCM->NewKey->AllLines[nLineNb];
pMCM->NewKey->CurAM = pMCM->ActionManagers[pMCM->NewKey->AllLines[nLineNb].ComboAM];
// The key must exist, else cannot edit the action
CActionsManager::TComboActionMap::const_iterator it = pMCM->NewKey->CurAM->getComboActionMap().find(pMCM->NewKey->CurrentEditCmdLine.Combo);
if (it != pMCM->NewKey->CurAM->getComboActionMap().end())
{
pMCM->NewKey->activateFrom (it->second.Name, it->second.Argu, nLineNb);
}
}
};
REGISTER_ACTION_HANDLER( CHandlerKeysEdit, "keys_edit");
// ***************************************************************************
class CHandlerKeysDelete: public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
if (pCaller == NULL) return;
string sId = pCaller->getId();
sId = sId.substr(sId.rfind('k')+1,sId.size());
sint32 nLineNb;
fromString(sId, nLineNb);
if ((nLineNb < 0) || (nLineNb >= (sint32)pMCM->NewKey->AllLines.size())) return;
CActionsManager *pCurAM = pMCM->ActionManagers[pMCM->NewKey->AllLines[nLineNb].ComboAM];
// if key not bound, skip (ie: this is a N/A action that is "ForceDisplay")
if(pMCM->NewKey->AllLines[nLineNb].Combo.Key==NLMISC::KeyCount)
return;
// remove the combo
pCurAM->removeCombo(pMCM->NewKey->AllLines[nLineNb].Combo);
// reset display
pMCM->refreshAllKeyDisplays();
}
};
REGISTER_ACTION_HANDLER( CHandlerKeysDelete, "keys_delete");
// ***************************************************************************
// Edit Command (can be binded to a key)
// ***************************************************************************
// ***************************************************************************
CModalContainerEditCmd::CModalContainerEditCmd()
{
Win = NULL;
CurAM = NULL;
_AllowAllActions= true;
}
// ***************************************************************************
void CModalContainerEditCmd::create(const std::string &name, bool bDefKey, bool allowAllActions)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
string prefix = NLMISC::toUpper(name);
CanDefineKey = bDefKey;
_AllowAllActions = allowAllActions;
prefix = string(DB_EDITCMD_PREFIX) + string(":") + prefix + string(":");
DbComboSelCat = prefix + DB_EDITCMD_COMBO_SELECT_CATEGORY;
DbComboSelAct = prefix + DB_EDITCMD_COMBO_SELECT_ACTION;
DbComboSel1P = prefix + DB_EDITCMD_COMBO_SELECT_FIRST_PARAM;
DbComboSel2P = prefix + DB_EDITCMD_COMBO_SELECT_SECOND_PARAM;
DbComboDisp1P = prefix + DB_EDITCMD_COMBO_DISPLAY_FIRST_PARAM;
DbComboDisp2P = prefix + DB_EDITCMD_COMBO_DISPLAY_SECOND_PARAM;
// Create DB entry
pIM->getDbProp(DbComboSelCat);
pIM->getDbProp(DbComboSelAct);
pIM->getDbProp(DbComboSel1P);
pIM->getDbProp(DbComboSel2P);
pIM->getDbProp(DbComboDisp1P);
pIM->getDbProp(DbComboDisp2P);
vector< pair<string,string> > vArgs;
vArgs.push_back(pair<string,string>("id",name));
vArgs.push_back(pair<string,string>("db_sel_cat",DbComboSelCat));
vArgs.push_back(pair<string,string>("db_sel_act",DbComboSelAct));
vArgs.push_back(pair<string,string>("db_sel_1p",DbComboSel1P));
vArgs.push_back(pair<string,string>("db_sel_2p",DbComboSel2P));
vArgs.push_back(pair<string,string>("db_disp_1p",DbComboDisp1P));
vArgs.push_back(pair<string,string>("db_disp_2p",DbComboDisp2P));
Win = dynamic_cast<CGroupContainer*>(pIM->createGroupInstance(TEMPLATE_EDITCMD, "ui:interface", vArgs));
if (Win == NULL)
{
nlwarning ("cannot create %s", name.c_str());
return;
}
WinName = "ui:interface:" + name;
pIM->addWindowToMasterGroup("ui:interface", Win);
CInterfaceGroup *pRoot = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId("ui:interface"));
Win->setParent(pRoot);
pRoot->addGroup(Win);
CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId(WinName+CTRL_EDITCMD_KEY_GROUP));
if (pIG != NULL) pIG->setActive (CanDefineKey);
}
// ***************************************************************************
void CModalContainerEditCmd::setTitle(const std::string &uistr)
{
Win->setTitle(uistr);
}
// ***************************************************************************
void CModalContainerEditCmd::activate()
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
CurrentEditCmdLine.ActionName.Name = "";
CurrentEditCmdLine.ActionName.Argu = "";
CurrentEditCmdNb = -1;
Win->setActive(true);
Win->launch();
// Initialisation of category combo box
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CDBGroupComboBox *pCB= dynamic_cast<CDBGroupComboBox*>(pIM->getElementFromId( WinName+WIN_EDITCMD_COMBO_CATEGORY ));
if (pCB != NULL)
{
CurrentEditCmdCategories.clear();
pCB->resetTexts();
for (uint am=0; am < pMCM->ActionManagers.size(); am++)
{
const vector<CCategory> &rVCat = pMCM->ActionManagers[am]->getCategories();
for (uint i=0; i < rVCat.size();i++)
{
const CCategory &cat = rVCat[i];
// only macroisable categories (or if allow all)
if(_AllowAllActions || cat.Macroisable)
{
// category should have at least one action that is possible in currenyt
// context
bool found = false;
for (uint k = 0; k < cat.BaseActions.size(); ++k)
{
if (cat.BaseActions[k].isUsableInCurrentContext())
{
found = true;
break;
}
}
if (found)
{
pCB->addText( CI18N::get(rVCat[i].LocalizedName) );
CurrentEditCmdCategories.push_back(rVCat[i].Name);
}
}
}
}
}
// Clean up all actions
pCB= dynamic_cast<CDBGroupComboBox*>(pIM->getElementFromId( WinName+WIN_EDITCMD_COMBO_ACTION ));
if (pCB != NULL) pCB->resetTexts();
// Clean up
CurAM = NULL;
pIM->getDbProp( DbComboSelCat )->setValue32(-1);
pIM->getDbProp( DbComboSelAct )->setValue32(-1);
pIM->getDbProp( DbComboSel1P )->setValue32(-1);
pIM->getDbProp( DbComboSel2P )->setValue32(-1);
pIM->getDbProp( DbComboDisp1P )->setValue32(-1);
pIM->getDbProp( DbComboDisp2P )->setValue32(-1);
// reset name of params
CViewText *pViewParamName = dynamic_cast<CViewText*>(pIM->getElementFromId(WinName+VIEW_EDITCMD_FIRST_PARAM_NAME));
if (pViewParamName != NULL) pViewParamName->setText (string(""));
pViewParamName = dynamic_cast<CViewText*>(pIM->getElementFromId(WinName+VIEW_EDITCMD_SECOND_PARAM_NAME));
if (pViewParamName != NULL) pViewParamName->setText (string(""));
invalidCurrentCommand();
}
// ***************************************************************************
void CModalContainerEditCmd::deactivate()
{
if(Win) Win->setActive(false);
}
// ***************************************************************************
void CModalContainerEditCmd::activateFrom (const std::string &cmdName, const std::string &cmdParams, sint nRef)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
CurrentEditCmdNb = nRef;
Win->setActive(true);
Win->launch();
activate();
CurrentEditCmdLine.ActionName.Name = cmdName;
CurrentEditCmdLine.ActionName.Argu = cmdParams;
CurrentEditCmdNb = nRef;
// Get current action manager and interface category index from cmdName
uint i, j, k;
bool bFound = false;
const CBaseAction *pBA = NULL;
CActionsManager *pAM = NULL;
uint catCBIndex = 0;
uint actCBIndex = 0;
for (i=0; i < pMCM->ActionManagers.size(); ++i)
{
pAM = pMCM->ActionManagers[i];
const vector<CCategory> &rVCat = pAM->getCategories();
for (j=0; j < rVCat.size(); ++j)
{
// only macroisable category (or if allow all)
if(_AllowAllActions || rVCat[j].Macroisable)
{
const vector<CBaseAction> &rVBA = rVCat[j].BaseActions;
actCBIndex = 0;
for (k=0; k < rVBA.size(); ++k)
{
// only macrosiable actions (or if allow all)
if (_AllowAllActions || rVBA[k].Macroisable)
{
if(rVBA[k].Name == cmdName)
{
bFound = true;
CurAM = pMCM->ActionManagers[i];
pBA = &rVBA[k];
break;
}
// actCBIndex is index in combo box here
actCBIndex++;
}
}
if (bFound) break;
// catIndex is index in combo box here
catCBIndex++;
}
}
if (bFound) break;
}
if (!bFound) return;
// Here pAM and catIndex are valid
// Set category : Search the right category
CDBGroupComboBox *pCB;
pCB = dynamic_cast<CDBGroupComboBox*>(pIM->getElementFromId(WinName+WIN_EDITCMD_COMBO_CATEGORY));
pCB->setSelection(catCBIndex);
onChangeCategory();
CCDBNodeBranch::flushObserversCalls();
//pIM->runActionHandler("editcmd_change_category",NULL);
pCB = dynamic_cast<CDBGroupComboBox*>(pIM->getElementFromId(WinName+WIN_EDITCMD_COMBO_ACTION));
pCB->setSelection(actCBIndex);
onChangeAction();
CCDBNodeBranch::flushObserversCalls();
//pIM->runActionHandler("editcmd_change_action",NULL);
// Count number of displayed param
uint nbRealParam = 0;
for (i = 0; i < pBA->Parameters.size(); ++i)
{
const CBaseAction::CParameter &rP = pBA->Parameters[i];
if (rP.Type != CBaseAction::CParameter::Hidden)
nbRealParam++;
}
// Set params
uint noParam = 0;
string curStr = CurrentEditCmdLine.ActionName.Argu.substr();
for (i = 0; i < pBA->Parameters.size(); ++i)
{
const CBaseAction::CParameter &rP = pBA->Parameters[i];
string sTmp;
// Get ith param (params are nameOfParam=argumentOfAction strings separated by |)
// except for the last real param (which can then contains | chars) if it is the last param
string::size_type pos = curStr.find('|');
if ((pos == string::npos) ||
(((noParam == nbRealParam-1) && (rP.Type != CBaseAction::CParameter::Hidden)) && (i == (pBA->Parameters.size()-1))))
{
sTmp = curStr;
curStr = "";
}
else
{
sTmp = curStr.substr(0, pos);
curStr = curStr.substr(pos+1, curStr.size());
}
// Remove 'name='
if (sTmp.find('=') != string::npos)
sTmp = sTmp.substr(sTmp.find('=')+1,sTmp.size());
if (noParam >= 2) break; // NO MORE THAN 2 REAL PARAMS !
if (rP.Type == CBaseAction::CParameter::Hidden)
{
// Skip it
}
else if (rP.Type == CBaseAction::CParameter::Constant)
{
if (noParam == 0) pIM->getDbProp( DbComboDisp1P )->setValue32(0);
else pIM->getDbProp( DbComboDisp2P )->setValue32(0);
// Search the param value to get the position in combo box
bool bValFound = false;
uint nPinCB;
for(nPinCB = 0; nPinCB < rP.Values.size(); ++nPinCB)
{
if (rP.Values[nPinCB].Value == sTmp)
{
bValFound = true;
break;
}
}
if (bValFound)
{
string sCombo;
if (noParam == 0) sCombo = WinName+WIN_EDITCMD_COMBO_FIRST_PARAM_LIST;
else sCombo = WinName+WIN_EDITCMD_COMBO_SECOND_PARAM_LIST;
pCB = dynamic_cast<CDBGroupComboBox*>(pIM->getElementFromId(sCombo));
pCB->setSelection(nPinCB);
}
}
else if ((rP.Type == CBaseAction::CParameter::User) || (rP.Type == CBaseAction::CParameter::UserName))
{
if (noParam == 0) pIM->getDbProp( DbComboDisp1P )->setValue32(1);
else pIM->getDbProp( DbComboDisp2P )->setValue32(1);
string sEditBox;
if (noParam == 0) sEditBox = WinName+WIN_EDITCMD_COMBO_FIRST_PARAM_EDITBOX;
else sEditBox = WinName+WIN_EDITCMD_COMBO_SECOND_PARAM_EDITBOX;
CGroupEditBox *pEB = dynamic_cast<CGroupEditBox*>(pIM->getElementFromId(sEditBox));
// sTmp is utf8
pEB->setInputStringAsUtf8(sTmp);
}
// Setup the param name if any
if (rP.Type != CBaseAction::CParameter::Hidden)
{
string sText;
if (noParam == 0) sText = WinName+VIEW_EDITCMD_FIRST_PARAM_NAME;
else sText = WinName+VIEW_EDITCMD_SECOND_PARAM_NAME;
CViewText *pVT = dynamic_cast<CViewText*>(pIM->getElementFromId(sText));
if (pVT != NULL) pVT->setText(CI18N::get(pBA->Parameters[i].LocalizedName));
noParam++;
}
}
validCurrentCommand();
// Update the key name
const CActionsManager::TActionComboMap &actionCombo = pAM->getActionComboMap();
CActionsManager::TActionComboMap::const_iterator it = actionCombo.find(CurrentEditCmdLine.ActionName);
// Deactive the key definition (we are in edit key mode)
CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(pIM->getElementFromId(WinName+CTRL_EDITCMD_BUTTON_KEY));
if (pBut != NULL) pBut->setActive(false);
if (it != actionCombo.end())
{
CurrentEditCmdLine.Combo = it->second;
// Activate the key definer text
CViewText *pVT = dynamic_cast<CViewText*>(pIM->getElementFromId(WinName+VIEW_EDITCMD_TEXT_KEY));
if (pVT != NULL) pVT->setActive(true);
// setup the text of the key
pVT->setText(it->second.toUCString());
// There is already a shortcut so we can display ok button
pBut = dynamic_cast<CCtrlBaseButton*>(pIM->getElementFromId(WinName+CTRL_EDITCMD_BUTTON_OK));
if (pBut != NULL) pBut->setFrozen (false);
}
}
// ***************************************************************************
// Given the cat index in comboBox, find action manager and the real cat index depending on the AM / macrosiable categories
bool CModalContainerEditCmd::getCatIndexAndAM (sint32 nInCatIndex, sint32 &nOutCatIndex, CActionsManager*&nOutAM)
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
if (nInCatIndex >= (sint32)CurrentEditCmdCategories.size())
return false;
string catName = CurrentEditCmdCategories[nInCatIndex];
for (uint i=0; i < pMCM->ActionManagers.size(); ++i)
{
CActionsManager *pAM = pMCM->ActionManagers[i];
const vector<CCategory> &rVCat = pAM->getCategories();
for (uint j=0; j < rVCat.size(); ++j)
{
if (rVCat[j].Name == catName)
{
nOutCatIndex = j;
nOutAM = pAM;
return true;
}
}
}
return false;
}
// ***************************************************************************
// Give the action index in Combo box, find the action index in the category (skip not macroisable actions)
bool CModalContainerEditCmd::getBaseActionIndex(const CCategory &cat, sint32 nInActIndex, sint32 &nOutActIndex)
{
if(nInActIndex<0)
return false;
for(nOutActIndex=0; nOutActIndex<(sint32)cat.BaseActions.size();nOutActIndex++)
{
// only macroisable (or if allow all)
if(_AllowAllActions || cat.BaseActions[nOutActIndex].Macroisable)
{
// must be valid in current context
if (cat.BaseActions[nOutActIndex].isUsableInCurrentContext())
{
// ok, found?
if(nInActIndex==0) return true;
else nInActIndex--;
}
}
}
return false;
}
// ***************************************************************************
// The current command is not valid (so we cant drag it into a macro nor define a key for it)
void CModalContainerEditCmd::invalidCurrentCommand()
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CViewText *pVT;
if (CurrentEditCmdNb == -1)
{
// Dont display key shortcut if we are in creation mode
pVT= dynamic_cast<CViewText*>(pIM->getElementFromId( WinName+VIEW_EDITCMD_TEXT_KEY ));
if (pVT != NULL) pVT->setText(CI18N::get(VIEW_EDITCMD_TEXT_KEY_DEFAULT));
// Deactivate the key definer text
pVT = dynamic_cast<CViewText*>(pIM->getElementFromId(WinName+VIEW_EDITCMD_TEXT_KEY));
if (pVT != NULL) pVT->setActive(false);
}
// Deactivate the key definer button
CCtrlBaseButton *pCB = dynamic_cast<CCtrlBaseButton*>(pIM->getElementFromId(WinName+CTRL_EDITCMD_BUTTON_KEY));
if (pCB != NULL) pCB->setActive(false);
// Deactivate ok button
pCB = dynamic_cast<CCtrlBaseButton*>(pIM->getElementFromId(WinName+CTRL_EDITCMD_BUTTON_OK));
if (pCB != NULL) pCB->setFrozen (true);
}
// ***************************************************************************
// The current command becomes valid (display key shortcut if any)
void CModalContainerEditCmd::validCurrentCommand()
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
sint32 catIndex= pIM->getDbProp( DbComboSelCat )->getValue32();
if(catIndex < 0) return;
sint32 actIndex= pIM->getDbProp( DbComboSelAct )->getValue32();
if(actIndex < 0) return;
CActionsManager *pAM;
// From ComboBox to index in category/action
if (!getCatIndexAndAM(catIndex,catIndex,pAM)) return;
if (!getBaseActionIndex(pAM->getCategories()[catIndex], actIndex,actIndex)) return;
// get the action
const CBaseAction &rBA = pAM->getCategories()[catIndex].BaseActions[actIndex];
// Build couple (name,param) that define a command
CurrentEditCmdLine.ActionName.Name = rBA.Name;
CurrentEditCmdLine.ActionName.Argu = "";
uint noParam = 0;
for (uint i = 0; i < rBA.Parameters.size(); ++i)
{
const CBaseAction::CParameter &rP = rBA.Parameters[i];
if (noParam >= 2) break; // NO MORE THAN 2 REAL PARAMS !
if ((i >= 1) && (!CurrentEditCmdLine.ActionName.Argu.empty())) CurrentEditCmdLine.ActionName.Argu+= "|";
if (!rP.Name.empty())
CurrentEditCmdLine.ActionName.Argu += rP.Name + "=";
if (rP.Type == CBaseAction::CParameter::Hidden)
{
CurrentEditCmdLine.ActionName.Argu += rP.DefaultValue;
}
else if (rP.Type == CBaseAction::CParameter::Constant)
{
// If the param is constant get the string from the list
// cannot use index directly because some options may be disabled in current context
sint32 paramIndex;
const std::vector<CBaseAction::CParameter::CValue> &rVVal = rP.Values;
if (noParam == 0) paramIndex = pIM->getDbProp(DbComboSel1P)->getValue32();
else paramIndex = pIM->getDbProp(DbComboSel2P)->getValue32();
uint currIndex = 0;
for (uint k = 0; k < rVVal.size(); ++k)
{
const CBaseAction::CParameter::CValue &rVal = rVVal[k];
if (ActionsContext.matchContext(rVal.Contexts))
{
if (currIndex == (uint) paramIndex)
{
CurrentEditCmdLine.ActionName.Argu += rVal.Value;
noParam++;
}
currIndex ++;
}
}
}
else if ((rP.Type == CBaseAction::CParameter::User) || (rP.Type == CBaseAction::CParameter::UserName))
{
// If the param is user or username get the string from the edit box
string sWin;
if (noParam == 0) sWin = WinName+WIN_EDITCMD_COMBO_FIRST_PARAM_EDITBOX;
else sWin = WinName+WIN_EDITCMD_COMBO_SECOND_PARAM_EDITBOX;
CGroupEditBox *pEB= dynamic_cast<CGroupEditBox*>(pIM->getElementFromId( sWin ));
// convert to utf8
if (pEB != NULL)
CurrentEditCmdLine.ActionName.Argu += pEB->getInputStringAsUtf8();
noParam++;
}
}
// End of build
// If we are in mode new shortcut display the button to setup a key
if (WinName == "ui:interface:newkey")
{
if (CurrentEditCmdNb == -1)
{
// Activate the key definer button
CCtrlBaseButton *pCB = dynamic_cast<CCtrlBaseButton*>(pIM->getElementFromId(WinName+CTRL_EDITCMD_BUTTON_KEY));
if (pCB != NULL) pCB->setActive(true);
// Activate the key definer text
CViewText *pVT = dynamic_cast<CViewText*>(pIM->getElementFromId(WinName+VIEW_EDITCMD_TEXT_KEY));
if (pVT != NULL) pVT->setActive(true);
// Does the command already exists ?
const CActionsManager::TActionComboMap &actionCombo = pAM->getActionComboMap();
CActionsManager::TActionComboMap::const_iterator it = actionCombo.find(CurrentEditCmdLine.ActionName);
if (it != actionCombo.end())
{
CurrentEditCmdLine.Combo = it->second;
// Yes ok let setup the text of the key
pVT->setText(it->second.toUCString());
// There is already a shortcut so we can display ok button
CCtrlBaseButton *pCB = dynamic_cast<CCtrlBaseButton*>(pIM->getElementFromId(WinName+CTRL_EDITCMD_BUTTON_OK));
if (pCB != NULL) pCB->setFrozen (false);
}
else
{
CurrentEditCmdLine.Combo.Key = KeyCount;
CurrentEditCmdLine.Combo.KeyButtons = noKeyButton;
// Display not assigned text
pVT->setText(CI18N::get(VIEW_EDITCMD_TEXT_KEY_DEFAULT));
// Do not display the ok button
CCtrlBaseButton *pCB = dynamic_cast<CCtrlBaseButton*>(pIM->getElementFromId(WinName+CTRL_EDITCMD_BUTTON_OK));
if (pCB != NULL) pCB->setFrozen (true);
}
}
else
{
CCtrlBaseButton *pCB = dynamic_cast<CCtrlBaseButton*>(pIM->getElementFromId(WinName+CTRL_EDITCMD_BUTTON_OK));
if (pCB != NULL) pCB->setFrozen (false);
}
}
// If we are in mode new command (from macro) just turn on the ok button
if (WinName == "ui:interface:editcmd")
{
CCtrlBaseButton *pCB = dynamic_cast<CCtrlBaseButton*>(pIM->getElementFromId(WinName+CTRL_EDITCMD_BUTTON_OK));
if (pCB != NULL) pCB->setFrozen(false);
}
}
// ***************************************************************************
// Check if the param is valid depending on the type of the param
bool CModalContainerEditCmd::isParamValid (sint32 nParamIndex)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
sint32 paramType;
if (nParamIndex == 0) paramType = pIM->getDbProp(DbComboDisp1P)->getValue32();
else paramType = pIM->getDbProp(DbComboDisp2P)->getValue32();
if (paramType == 0) // combo box list
{
sint32 paramListIndex;
if (nParamIndex == 0) paramListIndex = pIM->getDbProp( DbComboSel1P )->getValue32();
else paramListIndex = pIM->getDbProp( DbComboSel2P )->getValue32();
if (paramListIndex < 0) return false;
else return true;
}
else if (paramType == 1)
{
CGroupEditBox *pEB;
if (nParamIndex == 0) pEB = dynamic_cast<CGroupEditBox*>(pIM->getElementFromId( WinName+WIN_EDITCMD_COMBO_FIRST_PARAM_EDITBOX ));
else pEB = dynamic_cast<CGroupEditBox*>(pIM->getElementFromId( WinName+WIN_EDITCMD_COMBO_SECOND_PARAM_EDITBOX ));
if (pEB == NULL) return false;
// no need to translate utf8 or not here
if (pEB->getInputStringRef().empty()) return false;
else return true;
}
return false;
}
// ***************************************************************************
void CModalContainerEditCmd::checkCurrentCommandValidity()
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
// Get the category selected
sint32 catIndex= pIM->getDbProp( DbComboSelCat )->getValue32();
if(catIndex < 0) return;
// Get the action index selected
sint32 actIndex= pIM->getDbProp( DbComboSelAct )->getValue32();
if(actIndex < 0) return;
CActionsManager *pAM;
// From ComboBox to index in category/action
if (!getCatIndexAndAM(catIndex,catIndex,pAM)) return;
if (!getBaseActionIndex(pAM->getCategories()[catIndex], actIndex,actIndex)) return;
// get action
const vector<CBaseAction> &rVBA = pAM->getCategories()[catIndex].BaseActions;
const vector<CBaseAction::CParameter> &rVParams = rVBA[actIndex].Parameters;
// Count nb real param
uint nbparam = 0;
for (uint i = 0; i < rVParams.size(); ++i)
if (rVParams[i].Type != CBaseAction::CParameter::Hidden)
nbparam ++;
if (nbparam == 0)
{
validCurrentCommand();
return;
}
// Check parameters
if (!isParamValid(0))
{
invalidCurrentCommand();
return;
}
// First param is valid
if (nbparam == 1) // If there is only one param requested so validate
{
validCurrentCommand();
}
else
{ // 2 params
nlassert(nbparam == 2);
if (isParamValid(1))
validCurrentCommand();
else
invalidCurrentCommand();
}
}
// ***************************************************************************
void CModalContainerEditCmd::onChangeCategory()
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
// Get the category selected
sint32 catIndex= pIM->getDbProp( DbComboSelCat )->getValue32();
if(catIndex < 0)
return;
// Update the combo box of actions
CDBGroupComboBox *pCB= dynamic_cast<CDBGroupComboBox*>(pIM->getElementFromId( WinName+WIN_EDITCMD_COMBO_ACTION ));
if( pCB )
{
pCB->resetTexts();
// From combo box index to real category index
if (!getCatIndexAndAM(catIndex,catIndex,CurAM)) return;
const vector<CBaseAction> &rVBA = CurAM->getCategories()[catIndex].BaseActions;
// add only macroisable actions (or if allow all)
for (uint i = 0; i < rVBA.size(); i++)
{
const CBaseAction &rBA = rVBA[i];
if(_AllowAllActions || rBA.Macroisable)
{
if (rBA.isUsableInCurrentContext())
{
pCB->addText( CI18N::get(rBA.LocalizedName) );
}
}
}
}
// reset the action and dont display params
pIM->getDbProp( DbComboSelAct )->setValue32(-1);
pIM->getDbProp( DbComboSel1P )->setValue32(-1);
pIM->getDbProp( DbComboSel2P )->setValue32(-1);
pIM->getDbProp( DbComboDisp1P )->setValue32(-1);
pIM->getDbProp( DbComboDisp2P )->setValue32(-1);
// reset name of params
CViewText *pViewParamName;
pViewParamName = dynamic_cast<CViewText*>(pIM->getElementFromId(WinName+VIEW_EDITCMD_FIRST_PARAM_NAME));
if (pViewParamName != NULL) pViewParamName->setText (string(""));
pViewParamName = dynamic_cast<CViewText*>(pIM->getElementFromId(WinName+VIEW_EDITCMD_SECOND_PARAM_NAME));
if (pViewParamName != NULL) pViewParamName->setText (string(""));
// Reset key
invalidCurrentCommand();
}
// ***************************************************************************
void CModalContainerEditCmd::onChangeAction()
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
// Get the category selected
sint32 catIndex= pIM->getDbProp( DbComboSelCat )->getValue32();
if(catIndex < 0)
return;
// Get the action index selected
sint32 actIndex= pIM->getDbProp( DbComboSelAct )->getValue32();
if(actIndex < 0)
return;
// From combo box index to cat/action index
if (!getCatIndexAndAM(catIndex,catIndex,CurAM)) return;
if (!getBaseActionIndex(CurAM->getCategories()[catIndex], actIndex,actIndex)) return;
// Check parameters
const vector<CBaseAction> &rVBA = CurAM->getCategories()[catIndex].BaseActions;
const vector<CBaseAction::CParameter> &rVParams = rVBA[actIndex].Parameters;
pIM->getDbProp( DbComboDisp1P )->setValue32(-1);
pIM->getDbProp( DbComboDisp2P )->setValue32(-1);
pIM->getDbProp( DbComboSel1P )->setValue32(-1);
pIM->getDbProp( DbComboSel2P )->setValue32(-1);
// reset name of params
CViewText *pViewParamName;
pViewParamName = dynamic_cast<CViewText*>(pIM->getElementFromId(WinName+VIEW_EDITCMD_FIRST_PARAM_NAME));
if (pViewParamName != NULL) pViewParamName->setText (string(""));
pViewParamName = dynamic_cast<CViewText*>(pIM->getElementFromId(WinName+VIEW_EDITCMD_SECOND_PARAM_NAME));
if (pViewParamName != NULL) pViewParamName->setText (string(""));
uint noParam = 0;
for (uint i = 0; i < rVParams.size(); ++i)
{
const CBaseAction::CParameter &rP = rVParams[i];
if (rP.Type == CBaseAction::CParameter::Hidden)
continue;
string sDB;
if (noParam >= 2) break; // NO MORE THAN 2 PARAMS !
if (noParam == 0)
sDB = DbComboDisp1P;
else
sDB = DbComboDisp2P;
// Set the parameter name
{
string sViewText;
if (noParam == 0) sViewText = WinName+VIEW_EDITCMD_FIRST_PARAM_NAME;
else sViewText = WinName+VIEW_EDITCMD_SECOND_PARAM_NAME;
pViewParamName = dynamic_cast<CViewText*>(pIM->getElementFromId(sViewText));
if (pViewParamName != NULL)
pViewParamName->setText (CI18N::get(rP.LocalizedName));
}
if (rP.Type == CBaseAction::CParameter::Constant)
{
string sWin;
if (noParam == 0) sWin = WinName+WIN_EDITCMD_COMBO_FIRST_PARAM_LIST;
else sWin = WinName+WIN_EDITCMD_COMBO_SECOND_PARAM_LIST;
CDBGroupComboBox *pCB= dynamic_cast<CDBGroupComboBox*>(pIM->getElementFromId( sWin ));
if( pCB )
{
pCB->resetTexts();
const std::vector<CBaseAction::CParameter::CValue> &rVVal = rP.Values;
for (uint j = 0; j < rVVal.size(); j++)
{
const CBaseAction::CParameter::CValue &rVal = rVVal[j];
if (ActionsContext.matchContext(rVal.Contexts))
{
if ((rVal.LocalizedValue.size() >= 2) &&
(rVal.LocalizedValue[0] == 'u') && (rVal.LocalizedValue[1] == 'i'))
pCB->addText(CI18N::get(rVal.LocalizedValue));
else
pCB->addText(ucstring(rVal.LocalizedValue));
}
}
}
pIM->getDbProp( sDB )->setValue32(0);
}
else if ((rP.Type == CBaseAction::CParameter::User) || (rP.Type == CBaseAction::CParameter::UserName))
{
string sWin;
if (noParam == 0) sWin = WinName+WIN_EDITCMD_COMBO_FIRST_PARAM_EDITBOX;
else sWin = WinName+WIN_EDITCMD_COMBO_SECOND_PARAM_EDITBOX;
CGroupEditBox *pEB= dynamic_cast<CGroupEditBox*>(pIM->getElementFromId( sWin ));
if( pEB )
{
pEB->setInputString(ucstring(""));
}
pIM->getDbProp( sDB )->setValue32(1);
}
noParam++;
}
// If action do not need any params validate the command
if (noParam == 0)
validCurrentCommand();
else
invalidCurrentCommand();
}
// ***************************************************************************
// Action handlers associated to the editcmd container
// ***************************************************************************
// ***************************************************************************
// Called at activate of macros container
class CHandlerEditCmdOpen: public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &Params)
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
// If we are in key shortcut mode
if (Params == "newkey")
{
CGroupContainer *pGC = pMCM->NewKey->Win;
//pMCM->NewKey->activate();
if (pGC != NULL) pGC->setModalParentList(WIN_KEYS);
if (pMCM->NewKey->CurrentEditCmdNb == -1)
pMCM->NewKey->setTitle(WIN_EDITCMD_TITLE_NEW_KEY);
else
pMCM->NewKey->setTitle(WIN_EDITCMD_TITLE_EDIT_KEY);
}
// If we are in macro mode
if (Params == "editcmd")
{
CGroupContainer *pGC = pMCM->EditCmd->Win;
//pMCM->EditCmd->activate();
if (pGC != NULL) pGC->setModalParentList(WIN_NEWMACRO);
// Set right title depending if we are in new command
if (pMCM->EditCmd->CurrentEditCmdNb == -1)
pGC->setTitle (WIN_EDITCMD_TITLE_NEW_CMD);
else // or not (edit cmd)
pGC->setTitle (WIN_EDITCMD_TITLE_EDIT_CMD);
}
}
};
REGISTER_ACTION_HANDLER( CHandlerEditCmdOpen, "editcmd_open");
// ***************************************************************************
// Called when we change category
class CHandlerEditCmdChangeCategory : public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &Params)
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
if (Params == "editcmd")
pMCM->EditCmd->onChangeCategory();
if (Params == "newkey")
pMCM->NewKey->onChangeCategory();
}
};
REGISTER_ACTION_HANDLER( CHandlerEditCmdChangeCategory, "editcmd_change_category");
// ***************************************************************************
// Called when we change action
class CHandlerEditCmdChangeAction : public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &Params)
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
if (Params == "editcmd")
pMCM->EditCmd->onChangeAction();
if (Params == "newkey")
pMCM->NewKey->onChangeAction();
}
};
REGISTER_ACTION_HANDLER( CHandlerEditCmdChangeAction, "editcmd_change_action");
// ***************************************************************************
// Called when we change the first param
class CHandlerEditCmdChangeFirstParam: public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &Params)
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
if (Params == "editcmd")
pMCM->EditCmd->checkCurrentCommandValidity();
if (Params == "newkey")
pMCM->NewKey->checkCurrentCommandValidity();
}
};
REGISTER_ACTION_HANDLER( CHandlerEditCmdChangeFirstParam, "editcmd_change_first_param");
// ***************************************************************************
// Called when we change the second param
class CHandlerEditCmdChangeSecondParam: public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &Params)
{
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
if (Params == "editcmd")
pMCM->EditCmd->checkCurrentCommandValidity();
if (Params == "newkey")
pMCM->NewKey->checkCurrentCommandValidity();
}
};
REGISTER_ACTION_HANDLER( CHandlerEditCmdChangeSecondParam, "editcmd_change_second_param");
// ***************************************************************************
// Called when we want to define a key for that command
class CHandlerEditCmdDefineKey: public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &Params)
{
//checkCurrentCommandValidity();
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CGroupModalGetKey*pGetKey = dynamic_cast<CGroupModalGetKey*>(pIM->getElementFromId(WIN_MODAL_GET_KEY));
pGetKey->Caller = Params;
pIM->enableModalWindow(pCaller, WIN_MODAL_GET_KEY);
}
};
REGISTER_ACTION_HANDLER( CHandlerEditCmdDefineKey, "editcmd_cmd_def_key");
// ***************************************************************************
// Called when we validate the command
class CHandlerEditCmdOK: public IActionHandler
{
public:
virtual void execute(CCtrlBase *pCaller, const string &Params)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
// If we are in key shortcut mode
if (Params == "newkey")
{
// Add the key !
pMCM->NewKey->CurAM->addCombo(pMCM->NewKey->CurrentEditCmdLine.ActionName,
pMCM->NewKey->CurrentEditCmdLine.Combo);
// Refresh key containers
pMCM->refreshAllKeyDisplays();
pMCM->NewKey->deactivate();
}
// If we are in new command from macro mode
if (Params == "editcmd")
{
if (pMCM->EditCmd->CurrentEditCmdNb != -1) // Edit mode ?
{
pMCM->CurrentEditMacro.delCommand(pMCM->EditCmd->CurrentEditCmdNb);
pMCM->CurrentEditMacro.addCommand (pMCM->EditCmd->CurrentEditCmdLine.ActionName.Name.c_str(),pMCM->EditCmd->CurrentEditCmdLine.ActionName.Argu.c_str(),
pMCM->EditCmd->CurrentEditCmdNb);
}
else
{
pMCM->CurrentEditMacro.addCommand(pMCM->EditCmd->CurrentEditCmdLine.ActionName.Name.c_str(),pMCM->EditCmd->CurrentEditCmdLine.ActionName.Argu.c_str());
}
pIM->runActionHandler("new_macro_open", pCaller);
pMCM->EditCmd->deactivate();
}
}
};
REGISTER_ACTION_HANDLER( CHandlerEditCmdOK, "editcmd_ok");
// ***************************************************************************
// Called when the key defined is validated (with ok button on the assign_key modal)
class CHandlerAssignKey: public IActionHandler
{
public:
virtual void execute(CCtrlBase * /* pCaller */, const string &/* Params */)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
pIM->disableModalWindow();
CGroupModalGetKey*pGetKey = dynamic_cast<CGroupModalGetKey*>(pIM->getElementFromId(WIN_MODAL_GET_KEY));
if (pGetKey == NULL)
return;
// If we are in key shortcut mode
if (pGetKey->Caller=="editkey")
{
pMCM->NewKey->CurrentEditCmdLine.Combo = pGetKey->Combo;
pMCM->NewKey->CurAM->addCombo(pMCM->NewKey->CurrentEditCmdLine.ActionName,
pMCM->NewKey->CurrentEditCmdLine.Combo);
// Refresh all keys
pMCM->refreshAllKeyDisplays();
}
// If we are in newkey mode
if (pGetKey->Caller=="newkey")
{
pMCM->NewKey->CurrentEditCmdLine.Combo = pGetKey->Combo;
CViewText *pVT = dynamic_cast<CViewText*>(pIM->getElementFromId(pMCM->NewKey->WinName+VIEW_EDITCMD_TEXT_KEY));
if (pVT != NULL) pVT->setText(pMCM->NewKey->CurrentEditCmdLine.Combo.toUCString());
CCtrlBaseButton *pCB = dynamic_cast<CCtrlBaseButton*>(pIM->getElementFromId(pMCM->NewKey->WinName+CTRL_EDITCMD_BUTTON_OK));
if (pCB != NULL) pCB->setFrozen (false);
}
// If we are in mode macro
if (pGetKey->Caller=="editcmd")
{
pMCM->EditCmd->CurrentEditCmdLine.Combo = pGetKey->Combo;
pMCM->CurrentEditMacro.Combo = pMCM->EditCmd->CurrentEditCmdLine.Combo;
CViewText *pVT = dynamic_cast<CViewText*>(pIM->getElementFromId(VIEW_NEWMACRO_KEY));
if (pVT != NULL) pVT->setText(pMCM->EditCmd->CurrentEditCmdLine.Combo.toUCString());
}
}
};
REGISTER_ACTION_HANDLER( CHandlerAssignKey, "ah_assign_key");
// ***************************************************************************
static DECLARE_INTERFACE_USER_FCT(canEditKey)
{
if(args.size()!=1)
{
nlwarning("<canEditKey> requires 1 arg");
return false;
}
// cand edit?
sint lineNb= (sint)args[0].getInteger();
CMacroCmdManager *pMCM= CMacroCmdManager::getInstance();
if(lineNb<0 || lineNb>=(sint)pMCM->NewKey->AllLines.size())
result.setBool(false);
else
{
CModalContainerEditCmd::CLine &line= pMCM->NewKey->AllLines[lineNb];
// get the action manager for this line
nlassert(line.ComboAM<pMCM->ActionManagers.size());
CActionsManager *pCurAM = pMCM->ActionManagers[line.ComboAM];
nlassert(pCurAM);
// can edit the action only if the action name is not "Force Display"
result.setBool(!pCurAM->isActionDisplayForced(line.ActionName));
}
return true;
}
REGISTER_INTERFACE_USER_FCT("canEditKey", canEditKey)
// ***************************************************************************
static DECLARE_INTERFACE_USER_FCT(canDeleteKey)
{
if(args.size()!=1)
{
nlwarning("<canDeleteKey> requires 1 arg");
return false;
}
// cand delete?
sint lineNb= (sint)args[0].getInteger();
CMacroCmdManager *pMCM= CMacroCmdManager::getInstance();
if(lineNb<0 || lineNb>=(sint)pMCM->NewKey->AllLines.size())
result.setBool(false);
else
{
CModalContainerEditCmd::CLine &line= pMCM->NewKey->AllLines[lineNb];
// get the action manager for this line
nlassert(line.ComboAM<pMCM->ActionManagers.size());
CActionsManager *pCurAM = pMCM->ActionManagers[line.ComboAM];
nlassert(pCurAM);
// cannot delete the action if the action name is "Force Display" AND NotAssigned (since already deleted)
result.setBool( !(pCurAM->isActionDisplayForced(line.ActionName) && line.Combo.Key==KeyCount) );
}
return true;
}
REGISTER_INTERFACE_USER_FCT("canDeleteKey", canDeleteKey)
Reference in a new issue View git blame Copy permalink