tyler.durden/notepad-plus-plus
1
0
Fork 0
mirror of https://github.com/notepad-plus-plus/notepad-plus-plus.git synced 2025-04-08 17:15:37 +02:00
Code Issues Packages Projects Releases Wiki Activity

Add the UTF8 character ability for Run & Macro menu

Browse Source 
Ref: https://github.com/notepad-plus-plus/notepad-plus-plus/issues/13221#issuecomment-1457325172

Fix #12670, fix #13221, fix #13488, close #13538
This commit is contained in:
Don Ho 2023-04-16 00:46:58 +02:00
parent ac5657d826
commit fff5f9b24c
13 changed files with 369 additions and 476 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
PowerEditor/src/MISC/PluginsManager/PluginsManager.cpp
View File

@ -597,23 +597,23 @@ void PluginsManager::addInMenuFromPMIndex(int i)
int cmdID = ID_PLUGINS_CMD + static_cast<int32_t>(_pluginsCommands.size() - 1); int cmdID = ID_PLUGINS_CMD + static_cast<int32_t>(_pluginsCommands.size() - 1);
_pluginInfos[i]->_funcItems[j]._cmdID = cmdID; _pluginInfos[i]->_funcItems[j]._cmdID = cmdID;
generic_string itemName = _pluginInfos[i]->_funcItems[j]._itemName; string itemName = wstring2string(_pluginInfos[i]->_funcItems[j]._itemName, CP_UTF8);
if (_pluginInfos[i]->_funcItems[j]._pShKey) if (_pluginInfos[i]->_funcItems[j]._pShKey)
{ {
ShortcutKey & sKey = *(_pluginInfos[i]->_funcItems[j]._pShKey); ShortcutKey & sKey = *(_pluginInfos[i]->_funcItems[j]._pShKey);
PluginCmdShortcut pcs(Shortcut(itemName.c_str(), sKey._isCtrl, sKey._isAlt, sKey._isShift, sKey._key), cmdID, _pluginInfos[i]->_moduleName.c_str(), j); PluginCmdShortcut pcs(Shortcut(itemName.c_str(), sKey._isCtrl, sKey._isAlt, sKey._isShift, sKey._key), cmdID, wstring2string(_pluginInfos[i]->_moduleName, CP_UTF8).c_str(), j);
pluginCmdSCList.push_back(pcs); pluginCmdSCList.push_back(pcs);
itemName += TEXT("\t"); itemName += "\t";
itemName += pcs.toString(); itemName += pcs.toString();
} }
else else
{ //no ShortcutKey is provided, add an disabled shortcut (so it can still be mapped, Paramaters class can still index any changes and the toolbar wont funk out { //no ShortcutKey is provided, add an disabled shortcut (so it can still be mapped, Paramaters class can still index any changes and the toolbar wont funk out
Shortcut sc(itemName.c_str(), false, false, false, 0x00); Shortcut sc(itemName.c_str(), false, false, false, 0x00);
PluginCmdShortcut pcs(sc, cmdID, _pluginInfos[i]->_moduleName.c_str(), j); //VK_NULL and everything disabled, the menu name is left alone PluginCmdShortcut pcs(sc, cmdID, wstring2string(_pluginInfos[i]->_moduleName, CP_UTF8).c_str(), j); //VK_NULL and everything disabled, the menu name is left alone
pluginCmdSCList.push_back(pcs); pluginCmdSCList.push_back(pcs);
} }
::InsertMenu(_pluginInfos[i]->_pluginMenu, j, MF_BYPOSITION, cmdID, itemName.c_str()); ::InsertMenu(_pluginInfos[i]->_pluginMenu, j, MF_BYPOSITION, cmdID, string2wstring(itemName, CP_UTF8).c_str());
if (_pluginInfos[i]->_funcItems[j]._init2Check) if (_pluginInfos[i]->_funcItems[j]._init2Check)
::CheckMenuItem(_hPluginsMenu, cmdID, MF_BYCOMMAND | MF_CHECKED); ::CheckMenuItem(_hPluginsMenu, cmdID, MF_BYCOMMAND | MF_CHECKED);

6
PowerEditor/src/Notepad_plus.cpp
View File

@ -5346,8 +5346,8 @@ bool Notepad_plus::addCurrentMacro()
::InsertMenu(hMacroMenu, posBase + nbTopLevelItem + 2, MF_BYCOMMAND, IDM_SETTING_SHORTCUT_MAPPER_MACRO, nativeLangShortcutMapperMacro.c_str()); ::InsertMenu(hMacroMenu, posBase + nbTopLevelItem + 2, MF_BYCOMMAND, IDM_SETTING_SHORTCUT_MAPPER_MACRO, nativeLangShortcutMapperMacro.c_str());
} }
theMacros.push_back(ms); theMacros.push_back(ms);
macroMenu.push_back(MenuItemUnit(cmdID, ms.getName())); macroMenu.push_back(MenuItemUnit(cmdID, string2wstring(ms.getName(), CP_UTF8)));
::InsertMenu(hMacroMenu, static_cast<UINT>(posBase + nbTopLevelItem), MF_BYPOSITION, cmdID, ms.toMenuItemString().c_str()); ::InsertMenu(hMacroMenu, static_cast<UINT>(posBase + nbTopLevelItem), MF_BYPOSITION, cmdID, string2wstring(ms.toMenuItemString(), CP_UTF8).c_str());
_accelerator.updateShortcuts(); _accelerator.updateShortcuts();
nppParams.setShortcutDirty(); nppParams.setShortcutDirty();
return true; return true;
@ -8515,7 +8515,7 @@ void Notepad_plus::updateCommandShortcuts()
shortcutName = menuName; shortcutName = menuName;
} }
csc.setName(menuName.c_str(), shortcutName.c_str()); csc.setName(wstring2string(menuName, CP_UTF8).c_str(), wstring2string(shortcutName, CP_UTF8).c_str());
} }
} }

2
PowerEditor/src/NppBigSwitch.cpp
View File

@ -1455,7 +1455,7 @@ LRESULT Notepad_plus::process(HWND hwnd, UINT message, WPARAM wParam, LPARAM lPa
case WM_FRSAVE_STR: case WM_FRSAVE_STR:
{ {
_macro.push_back(recordedMacroStep(static_cast<int32_t>(wParam), 0, 0, reinterpret_cast<const TCHAR *>(lParam), recordedMacroStep::mtSavedSnR)); _macro.push_back(recordedMacroStep(static_cast<int32_t>(wParam), 0, 0, reinterpret_cast<const char *>(lParam), recordedMacroStep::mtSavedSnR));
break; break;
} }

4
PowerEditor/src/NppCommands.cpp
View File

@ -48,7 +48,7 @@ void Notepad_plus::macroPlayback(Macro macro)
if (step->isScintillaMacro()) if (step->isScintillaMacro())
step->PlayBack(_pPublicInterface, _pEditView); step->PlayBack(_pPublicInterface, _pEditView);
else else
_findReplaceDlg.execSavedCommand(step->_message, step->_lParameter, step->_sParameter); _findReplaceDlg.execSavedCommand(step->_message, step->_lParameter, string2wstring(step->_sParameter, CP_UTF8));
} }
_pEditView->execute(SCI_ENDUNDOACTION); _pEditView->execute(SCI_ENDUNDOACTION);
@ -3964,7 +3964,7 @@ void Notepad_plus::command(int id)
vector<UserCommand> & theUserCommands = (NppParameters::getInstance()).getUserCommandList(); vector<UserCommand> & theUserCommands = (NppParameters::getInstance()).getUserCommandList();
UserCommand ucmd = theUserCommands[i]; UserCommand ucmd = theUserCommands[i];
Command cmd(ucmd.getCmd()); Command cmd(string2wstring(ucmd.getCmd(), CP_UTF8));
cmd.run(_pPublicInterface->getHSelf()); cmd.run(_pPublicInterface->getHSelf());
} }
else if ((id >= ID_PLUGINS_CMD) && (id < ID_PLUGINS_CMD_LIMIT)) else if ((id >= ID_PLUGINS_CMD) && (id < ID_PLUGINS_CMD_LIMIT))

3
PowerEditor/src/NppNotification.cpp
View File

@ -1025,8 +1025,7 @@ BOOL Notepad_plus::notify(SCNotification *notification)
recordedMacroStep( recordedMacroStep(
notification->message, notification->message,
notification->wParam, notification->wParam,
notification->lParam, notification->lParam
static_cast<int32_t>(_pEditView->execute(SCI_GETCODEPAGE))
) )
); );
break; break;

404
PowerEditor/src/Parameters.cpp
View File

@ -1471,12 +1471,12 @@ bool NppParameters::load()
::CopyFile(srcShortcutsPath.c_str(), _shortcutsPath.c_str(), TRUE); ::CopyFile(srcShortcutsPath.c_str(), _shortcutsPath.c_str(), TRUE);
} }
_pXmlShortcutDoc = new TiXmlDocument(_shortcutsPath); _pXmlShortcutDocA = new TiXmlDocumentA();
loadOkay = _pXmlShortcutDoc->LoadFile(); loadOkay = _pXmlShortcutDocA->LoadUnicodeFilePath(_shortcutsPath.c_str());
if (!loadOkay) if (!loadOkay)
{ {
delete _pXmlShortcutDoc; delete _pXmlShortcutDocA;
_pXmlShortcutDoc = nullptr; _pXmlShortcutDocA = nullptr;
isAllLaoded = false; isAllLaoded = false;
} }
else else
@ -1613,10 +1613,9 @@ void NppParameters::destroyInstance()
delete _pXmlNativeLangDocA; delete _pXmlNativeLangDocA;
delete _pXmlToolIconsDoc; delete _pXmlToolIconsDoc;
delete _pXmlShortcutDoc; delete _pXmlShortcutDocA;
delete _pXmlContextMenuDocA; delete _pXmlContextMenuDocA;
delete _pXmlTabContextMenuDocA; delete _pXmlTabContextMenuDocA;
delete _pXmlBlacklistDoc;
delete getInstancePointer(); delete getInstancePointer();
} }
@ -1903,10 +1902,10 @@ std::pair<unsigned char, unsigned char> NppParameters::addUserDefineLangsFromXml
bool NppParameters::getShortcutsFromXmlTree() bool NppParameters::getShortcutsFromXmlTree()
{ {
if (!_pXmlShortcutDoc) if (!_pXmlShortcutDocA)
return false; return false;
TiXmlNode *root = _pXmlShortcutDoc->FirstChild(TEXT("NotepadPlus")); TiXmlNodeA *root = _pXmlShortcutDocA->FirstChild("NotepadPlus");
if (!root) if (!root)
return false; return false;
@ -1917,10 +1916,10 @@ bool NppParameters::getShortcutsFromXmlTree()
bool NppParameters::getMacrosFromXmlTree() bool NppParameters::getMacrosFromXmlTree()
{ {
if (!_pXmlShortcutDoc) if (!_pXmlShortcutDocA)
return false; return false;
TiXmlNode *root = _pXmlShortcutDoc->FirstChild(TEXT("NotepadPlus")); TiXmlNodeA *root = _pXmlShortcutDocA->FirstChild("NotepadPlus");
if (!root) if (!root)
return false; return false;
@ -1931,10 +1930,10 @@ bool NppParameters::getMacrosFromXmlTree()
bool NppParameters::getUserCmdsFromXmlTree() bool NppParameters::getUserCmdsFromXmlTree()
{ {
if (!_pXmlShortcutDoc) if (!_pXmlShortcutDocA)
return false; return false;
TiXmlNode *root = _pXmlShortcutDoc->FirstChild(TEXT("NotepadPlus")); TiXmlNodeA *root = _pXmlShortcutDocA->FirstChild("NotepadPlus");
if (!root) if (!root)
return false; return false;
@ -1945,10 +1944,10 @@ bool NppParameters::getUserCmdsFromXmlTree()
bool NppParameters::getPluginCmdsFromXmlTree() bool NppParameters::getPluginCmdsFromXmlTree()
{ {
if (!_pXmlShortcutDoc) if (!_pXmlShortcutDocA)
return false; return false;
TiXmlNode *root = _pXmlShortcutDoc->FirstChild(TEXT("NotepadPlus")); TiXmlNodeA *root = _pXmlShortcutDocA->FirstChild("NotepadPlus");
if (!root) if (!root)
return false; return false;
@ -1959,10 +1958,10 @@ bool NppParameters::getPluginCmdsFromXmlTree()
bool NppParameters::getScintKeysFromXmlTree() bool NppParameters::getScintKeysFromXmlTree()
{ {
if (!_pXmlShortcutDoc) if (!_pXmlShortcutDocA)
return false; return false;
TiXmlNode *root = _pXmlShortcutDoc->FirstChild(TEXT("NotepadPlus")); TiXmlNodeA *root = _pXmlShortcutDocA->FirstChild("NotepadPlus");
if (!root) if (!root)
return false; return false;
@ -1970,18 +1969,6 @@ bool NppParameters::getScintKeysFromXmlTree()
return true; return true;
} }
bool NppParameters::getBlackListFromXmlTree()
{
if (!_pXmlBlacklistDoc)
return false;
TiXmlNode *root = _pXmlBlacklistDoc->FirstChild(TEXT("NotepadPlus"));
if (!root)
return false;
return feedBlacklist(root);
}
void NppParameters::initMenuKeys() void NppParameters::initMenuKeys()
{ {
int nbCommands = sizeof(winKeyDefs)/sizeof(WinMenuKeyDefinition); int nbCommands = sizeof(winKeyDefs)/sizeof(WinMenuKeyDefinition);
@ -1989,7 +1976,7 @@ void NppParameters::initMenuKeys()
for (int i = 0; i < nbCommands; ++i) for (int i = 0; i < nbCommands; ++i)
{ {
wkd = winKeyDefs[i]; wkd = winKeyDefs[i];
Shortcut sc((wkd.specialName ? wkd.specialName : TEXT("")), wkd.isCtrl, wkd.isAlt, wkd.isShift, static_cast<unsigned char>(wkd.vKey)); Shortcut sc((wkd.specialName ? wstring2string(wkd.specialName, CP_UTF8).c_str() : ""), wkd.isCtrl, wkd.isAlt, wkd.isShift, static_cast<unsigned char>(wkd.vKey));
_shortcuts.push_back( CommandShortcut(sc, wkd.functionId) ); _shortcuts.push_back( CommandShortcut(sc, wkd.functionId) );
} }
} }
@ -2016,7 +2003,7 @@ void NppParameters::initScintillaKeys()
} }
else else
{ {
Shortcut s = Shortcut(skd.name, skd.isCtrl, skd.isAlt, skd.isShift, static_cast<unsigned char>(skd.vKey)); Shortcut s = Shortcut(wstring2string(skd.name, CP_UTF8).c_str(), skd.isCtrl, skd.isAlt, skd.isShift, static_cast<unsigned char>(skd.vKey));
ScintillaKeyMap sm = ScintillaKeyMap(s, skd.functionId, skd.redirFunctionId); ScintillaKeyMap sm = ScintillaKeyMap(s, skd.functionId, skd.redirFunctionId);
_scintillaKeyCommands.push_back(sm); _scintillaKeyCommands.push_back(sm);
++prevIndex; ++prevIndex;
@ -2712,17 +2699,17 @@ void NppParameters::feedFindHistoryParameters(TiXmlNode *node)
_findHistory._isPurge = (lstrcmp(TEXT("yes"), boolStr) == 0); _findHistory._isPurge = (lstrcmp(TEXT("yes"), boolStr) == 0);
} }
void NppParameters::feedShortcut(TiXmlNode *node) void NppParameters::feedShortcut(TiXmlNodeA *node)
{ {
TiXmlNode *shortcutsRoot = node->FirstChildElement(TEXT("InternalCommands")); TiXmlNodeA *shortcutsRoot = node->FirstChildElement("InternalCommands");
if (!shortcutsRoot) return; if (!shortcutsRoot) return;
for (TiXmlNode *childNode = shortcutsRoot->FirstChildElement(TEXT("Shortcut")); for (TiXmlNodeA *childNode = shortcutsRoot->FirstChildElement("Shortcut");
childNode ; childNode ;
childNode = childNode->NextSibling(TEXT("Shortcut")) ) childNode = childNode->NextSibling("Shortcut"))
{ {
int id; int id;
const TCHAR *idStr = (childNode->ToElement())->Attribute(TEXT("id"), &id); const char* idStr = (childNode->ToElement())->Attribute("id", &id);
if (idStr) if (idStr)
{ {
//find the commandid that matches this Shortcut sc and alter it, push back its index in the modified list, if not present //find the commandid that matches this Shortcut sc and alter it, push back its index in the modified list, if not present
@ -2739,73 +2726,52 @@ void NppParameters::feedShortcut(TiXmlNode *node)
} }
} }
void NppParameters::feedMacros(TiXmlNode *node) void NppParameters::feedMacros(TiXmlNodeA *node)
{ {
TiXmlNode *macrosRoot = node->FirstChildElement(TEXT("Macros")); TiXmlNodeA *macrosRoot = node->FirstChildElement("Macros");
if (!macrosRoot) return; if (!macrosRoot) return;
for (TiXmlNode *childNode = macrosRoot->FirstChildElement(TEXT("Macro")); for (TiXmlNodeA *childNode = macrosRoot->FirstChildElement("Macro");
childNode ; childNode ;
childNode = childNode->NextSibling(TEXT("Macro")) ) childNode = childNode->NextSibling("Macro"))
{ {
Shortcut sc; Shortcut sc;
generic_string fdnm; string fdnm;
if (getShortcuts(childNode, sc, &fdnm)) if (getShortcuts(childNode, sc, &fdnm))
{ {
Macro macro; Macro macro;
getActions(childNode, macro); getActions(childNode, macro);
int cmdID = ID_MACRO + static_cast<int32_t>(_macros.size()); int cmdID = ID_MACRO + static_cast<int32_t>(_macros.size());
_macros.push_back(MacroShortcut(sc, macro, cmdID)); _macros.push_back(MacroShortcut(sc, macro, cmdID));
_macroMenuItems.push_back(MenuItemUnit(cmdID, string2wstring(sc.getName(), CP_UTF8), string2wstring(fdnm, CP_UTF8)));
// User could add folder name in his/her native language,
// so let's make non-western languages displayable here.
if (!fdnm.empty())
{
// The function WideCharToMultiByte with CP_ACP doesn't work.
// So we use our way to convert to char from wchar_t:
size_t len = fdnm.size();
const wchar_t* fdnmW = fdnm.c_str();
char* fdnmA = new char[len+1];
for (size_t i = 0; i < len; ++i)
{
fdnmA[i] = (char)fdnmW[i];
}
fdnmA[len] = '\0';
WcharMbcsConvertor& wmc = WcharMbcsConvertor::getInstance();
fdnm = wmc.char2wchar(fdnmA, SC_CP_UTF8);
delete[] fdnmA;
}
_macroMenuItems.push_back(MenuItemUnit(cmdID, sc.getName(), fdnm));
} }
} }
} }
void NppParameters::getActions(TiXmlNode *node, Macro & macro) void NppParameters::getActions(TiXmlNodeA *node, Macro & macro)
{ {
for (TiXmlNode *childNode = node->FirstChildElement(TEXT("Action")); for (TiXmlNodeA *childNode = node->FirstChildElement("Action");
childNode ; childNode ;
childNode = childNode->NextSibling(TEXT("Action")) ) childNode = childNode->NextSibling("Action") )
{ {
int type; int type;
const TCHAR *typeStr = (childNode->ToElement())->Attribute(TEXT("type"), &type); const char *typeStr = (childNode->ToElement())->Attribute("type", &type);
if ((!typeStr) || (type > 3)) if ((!typeStr) || (type > 3))
continue; continue;
int msg = 0; int msg = 0;
(childNode->ToElement())->Attribute(TEXT("message"), &msg); (childNode->ToElement())->Attribute("message", &msg);
int wParam = 0; int wParam = 0;
(childNode->ToElement())->Attribute(TEXT("wParam"), &wParam); (childNode->ToElement())->Attribute("wParam", &wParam);
int lParam = 0; int lParam = 0;
(childNode->ToElement())->Attribute(TEXT("lParam"), &lParam); (childNode->ToElement())->Attribute("lParam", &lParam);
const TCHAR *sParam = (childNode->ToElement())->Attribute(TEXT("sParam")); const char *sParam = (childNode->ToElement())->Attribute("sParam");
if (!sParam) if (!sParam)
sParam = TEXT(""); sParam = "";
recordedMacroStep step(msg, wParam, lParam, sParam, type); recordedMacroStep step(msg, wParam, lParam, sParam, type);
if (step.isValid()) if (step.isValid())
macro.push_back(step); macro.push_back(step);
@ -2813,71 +2779,49 @@ void NppParameters::getActions(TiXmlNode *node, Macro & macro)
} }
} }
void NppParameters::feedUserCmds(TiXmlNode *node) void NppParameters::feedUserCmds(TiXmlNodeA *node)
{ {
TiXmlNode *userCmdsRoot = node->FirstChildElement(TEXT("UserDefinedCommands")); TiXmlNodeA *userCmdsRoot = node->FirstChildElement("UserDefinedCommands");
if (!userCmdsRoot) return; if (!userCmdsRoot) return;
for (TiXmlNode *childNode = userCmdsRoot->FirstChildElement(TEXT("Command")); for (TiXmlNodeA *childNode = userCmdsRoot->FirstChildElement("Command");
childNode ; childNode ;
childNode = childNode->NextSibling(TEXT("Command")) ) childNode = childNode->NextSibling("Command") )
{ {
Shortcut sc; Shortcut sc;
generic_string fdnm; string fdnm;
if (getShortcuts(childNode, sc, &fdnm)) if (getShortcuts(childNode, sc, &fdnm))
{ {
TiXmlNode *aNode = childNode->FirstChild(); TiXmlNodeA *aNode = childNode->FirstChild();
if (aNode) if (aNode)
{ {
const TCHAR *cmdStr = aNode->Value(); const char* cmdStr = aNode->Value();
if (cmdStr) if (cmdStr)
{ {
int cmdID = ID_USER_CMD + static_cast<int32_t>(_userCommands.size()); int cmdID = ID_USER_CMD + static_cast<int32_t>(_userCommands.size());
_userCommands.push_back(UserCommand(sc, cmdStr, cmdID)); _userCommands.push_back(UserCommand(sc, cmdStr, cmdID));
_runMenuItems.push_back(MenuItemUnit(cmdID, string2wstring(sc.getName(), CP_UTF8), string2wstring(fdnm, CP_UTF8)));
// User could add folder name in his/her native language,
// so let's make non-western languages displayable here.
if (!fdnm.empty())
{
// The function WideCharToMultiByte with CP_ACP doesn't work.
// So we use our way to convert to char from wchar_t:
size_t len = fdnm.size();
const wchar_t* fdnmW = fdnm.c_str();
char* fdnmA = new char[len + 1];
for (size_t i = 0; i < len; ++i)
{
fdnmA[i] = (char)fdnmW[i];
}
fdnmA[len] = '\0';
WcharMbcsConvertor& wmc = WcharMbcsConvertor::getInstance();
fdnm = wmc.char2wchar(fdnmA, SC_CP_UTF8);
delete[] fdnmA;
}
_runMenuItems.push_back(MenuItemUnit(cmdID, sc.getName(), fdnm));
} }
} }
} }
} }
} }
void NppParameters::feedPluginCustomizedCmds(TiXmlNode *node) void NppParameters::feedPluginCustomizedCmds(TiXmlNodeA *node)
{ {
TiXmlNode *pluginCustomizedCmdsRoot = node->FirstChildElement(TEXT("PluginCommands")); TiXmlNodeA *pluginCustomizedCmdsRoot = node->FirstChildElement("PluginCommands");
if (!pluginCustomizedCmdsRoot) return; if (!pluginCustomizedCmdsRoot) return;
for (TiXmlNode *childNode = pluginCustomizedCmdsRoot->FirstChildElement(TEXT("PluginCommand")); for (TiXmlNodeA *childNode = pluginCustomizedCmdsRoot->FirstChildElement("PluginCommand");
childNode ; childNode ;
childNode = childNode->NextSibling(TEXT("PluginCommand")) ) childNode = childNode->NextSibling("PluginCommand") )
{ {
const TCHAR *moduleName = (childNode->ToElement())->Attribute(TEXT("moduleName")); const char *moduleName = (childNode->ToElement())->Attribute("moduleName");
if (!moduleName) if (!moduleName)
continue; continue;
int internalID = -1; int internalID = -1;
const TCHAR *internalIDStr = (childNode->ToElement())->Attribute(TEXT("internalID"), &internalID); const char *internalIDStr = (childNode->ToElement())->Attribute("internalID", &internalID);
if (!internalIDStr) if (!internalIDStr)
continue; continue;
@ -2887,7 +2831,7 @@ void NppParameters::feedPluginCustomizedCmds(TiXmlNode *node)
for (size_t i = 0; i < len; ++i) for (size_t i = 0; i < len; ++i)
{ {
PluginCmdShortcut & pscOrig = _pluginCommands[i]; PluginCmdShortcut & pscOrig = _pluginCommands[i];
if (!wcsnicmp(pscOrig.getModuleName(), moduleName, lstrlen(moduleName)) && pscOrig.getInternalID() == internalID) if (!strnicmp(pscOrig.getModuleName(), moduleName, strlen(moduleName)) && pscOrig.getInternalID() == internalID)
{ {
//Found matching command //Found matching command
getShortcuts(childNode, _pluginCommands[i]); getShortcuts(childNode, _pluginCommands[i]);
@ -2898,22 +2842,22 @@ void NppParameters::feedPluginCustomizedCmds(TiXmlNode *node)
} }
} }
void NppParameters::feedScintKeys(TiXmlNode *node) void NppParameters::feedScintKeys(TiXmlNodeA *node)
{ {
TiXmlNode *scintKeysRoot = node->FirstChildElement(TEXT("ScintillaKeys")); TiXmlNodeA *scintKeysRoot = node->FirstChildElement("ScintillaKeys");
if (!scintKeysRoot) return; if (!scintKeysRoot) return;
for (TiXmlNode *childNode = scintKeysRoot->FirstChildElement(TEXT("ScintKey")); for (TiXmlNodeA *childNode = scintKeysRoot->FirstChildElement("ScintKey");
childNode ; childNode ;
childNode = childNode->NextSibling(TEXT("ScintKey")) ) childNode = childNode->NextSibling("ScintKey") )
{ {
int scintKey; int scintKey;
const TCHAR *keyStr = (childNode->ToElement())->Attribute(TEXT("ScintID"), &scintKey); const char *keyStr = (childNode->ToElement())->Attribute("ScintID", &scintKey);
if (!keyStr) if (!keyStr)
continue; continue;
int menuID; int menuID;
keyStr = (childNode->ToElement())->Attribute(TEXT("menuCmdID"), &menuID); keyStr = (childNode->ToElement())->Attribute("menuCmdID", &menuID);
if (!keyStr) if (!keyStr)
continue; continue;
@ -2930,27 +2874,27 @@ void NppParameters::feedScintKeys(TiXmlNode *node)
_scintillaKeyCommands[i].setKeyComboByIndex(0, _scintillaKeyCommands[i].getKeyCombo()); _scintillaKeyCommands[i].setKeyComboByIndex(0, _scintillaKeyCommands[i].getKeyCombo());
addScintillaModifiedIndex(i); addScintillaModifiedIndex(i);
KeyCombo kc; KeyCombo kc;
for (TiXmlNode *nextNode = childNode->FirstChildElement(TEXT("NextKey")); for (TiXmlNodeA *nextNode = childNode->FirstChildElement("NextKey");
nextNode ; nextNode ;
nextNode = nextNode->NextSibling(TEXT("NextKey"))) nextNode = nextNode->NextSibling("NextKey"))
{ {
const TCHAR *str = (nextNode->ToElement())->Attribute(TEXT("Ctrl")); const char *str = (nextNode->ToElement())->Attribute("Ctrl");
if (!str) if (!str)
continue; continue;
kc._isCtrl = (lstrcmp(TEXT("yes"), str) == 0); kc._isCtrl = (strcmp("yes", str) == 0);
str = (nextNode->ToElement())->Attribute(TEXT("Alt")); str = (nextNode->ToElement())->Attribute("Alt");
if (!str) if (!str)
continue; continue;
kc._isAlt = (lstrcmp(TEXT("yes"), str) == 0); kc._isAlt = (strcmp("yes", str) == 0);
str = (nextNode->ToElement())->Attribute(TEXT("Shift")); str = (nextNode->ToElement())->Attribute("Shift");
if (!str) if (!str)
continue; continue;
kc._isShift = (lstrcmp(TEXT("yes"), str) == 0); kc._isShift = (strcmp("yes", str) == 0);
int key; int key;
str = (nextNode->ToElement())->Attribute(TEXT("Key"), &key); str = (nextNode->ToElement())->Attribute("Key", &key);
if (!str) if (!str)
continue; continue;
kc._key = static_cast<unsigned char>(key); kc._key = static_cast<unsigned char>(key);
@ -2962,56 +2906,38 @@ void NppParameters::feedScintKeys(TiXmlNode *node)
} }
} }
bool NppParameters::feedBlacklist(TiXmlNode *node) bool NppParameters::getShortcuts(TiXmlNodeA *node, Shortcut & sc, string* folderName)
{
TiXmlNode *blackListRoot = node->FirstChildElement(TEXT("PluginBlackList"));
if (!blackListRoot) return false;
for (TiXmlNode *childNode = blackListRoot->FirstChildElement(TEXT("Plugin"));
childNode ;
childNode = childNode->NextSibling(TEXT("Plugin")) )
{
const TCHAR *name = (childNode->ToElement())->Attribute(TEXT("name"));
if (name)
{
_blacklist.push_back(name);
}
}
return true;
}
bool NppParameters::getShortcuts(TiXmlNode *node, Shortcut & sc, generic_string* folderName)
{ {
if (!node) return false; if (!node) return false;
const TCHAR *name = (node->ToElement())->Attribute(TEXT("name")); const char* name = (node->ToElement())->Attribute("name");
if (!name) if (!name)
name = TEXT(""); name = "";
bool isCtrl = false; bool isCtrl = false;
const TCHAR *isCtrlStr = (node->ToElement())->Attribute(TEXT("Ctrl")); const char* isCtrlStr = (node->ToElement())->Attribute("Ctrl");
if (isCtrlStr) if (isCtrlStr)
isCtrl = (lstrcmp(TEXT("yes"), isCtrlStr) == 0); isCtrl = (strcmp("yes", isCtrlStr) == 0);
bool isAlt = false; bool isAlt = false;
const TCHAR *isAltStr = (node->ToElement())->Attribute(TEXT("Alt")); const char* isAltStr = (node->ToElement())->Attribute("Alt");
if (isAltStr) if (isAltStr)
isAlt = (lstrcmp(TEXT("yes"), isAltStr) == 0); isAlt = (strcmp("yes", isAltStr) == 0);
bool isShift = false; bool isShift = false;
const TCHAR *isShiftStr = (node->ToElement())->Attribute(TEXT("Shift")); const char* isShiftStr = (node->ToElement())->Attribute("Shift");
if (isShiftStr) if (isShiftStr)
isShift = (lstrcmp(TEXT("yes"), isShiftStr) == 0); isShift = (strcmp("yes", isShiftStr) == 0);
int key; int key;
const TCHAR *keyStr = (node->ToElement())->Attribute(TEXT("Key"), &key); const char* keyStr = (node->ToElement())->Attribute("Key", &key);
if (!keyStr) if (!keyStr)
return false; return false;
if (folderName) if (folderName)
{ {
const TCHAR* fn = (node->ToElement())->Attribute(TEXT("FolderName")); const char* fn = (node->ToElement())->Attribute("FolderName");
*folderName = fn ? fn : L""; *folderName = fn ? fn : "";
} }
sc = Shortcut(name, isCtrl, isAlt, isShift, static_cast<unsigned char>(key)); sc = Shortcut(name, isCtrl, isAlt, isShift, static_cast<unsigned char>(key));
@ -3261,9 +3187,9 @@ bool NppParameters::writeSettingsFilesOnCloudForThe1stTime(const generic_string
// shortcuts.xml // shortcuts.xml
generic_string cloudShortcutsPath = cloudSettingsPath; generic_string cloudShortcutsPath = cloudSettingsPath;
pathAppend(cloudShortcutsPath, TEXT("shortcuts.xml")); pathAppend(cloudShortcutsPath, TEXT("shortcuts.xml"));
if (!::PathFileExists(cloudShortcutsPath.c_str()) && _pXmlShortcutDoc) if (!::PathFileExists(cloudShortcutsPath.c_str()) && _pXmlShortcutDocA)
{ {
isOK = _pXmlShortcutDoc->SaveFile(cloudShortcutsPath.c_str()); isOK = _pXmlShortcutDocA->SaveUnicodeFilePath(cloudShortcutsPath.c_str());
if (!isOK) if (!isOK)
return false; return false;
} }
@ -3398,115 +3324,87 @@ void NppParameters::writeNeed2SaveUDL()
} }
void NppParameters::insertCmd(TiXmlNode *shortcutsRoot, const CommandShortcut & cmd) void NppParameters::insertCmd(TiXmlNodeA *shortcutsRoot, const CommandShortcut & cmd)
{ {
const KeyCombo & key = cmd.getKeyCombo(); const KeyCombo & key = cmd.getKeyCombo();
TiXmlNode *sc = shortcutsRoot->InsertEndChild(TiXmlElement(TEXT("Shortcut"))); TiXmlNodeA *sc = shortcutsRoot->InsertEndChild(TiXmlElementA("Shortcut"));
sc->ToElement()->SetAttribute(TEXT("id"), cmd.getID()); sc->ToElement()->SetAttribute("id", cmd.getID());
sc->ToElement()->SetAttribute(TEXT("Ctrl"), key._isCtrl?TEXT("yes"):TEXT("no")); sc->ToElement()->SetAttribute("Ctrl", key._isCtrl?"yes":"no");
sc->ToElement()->SetAttribute(TEXT("Alt"), key._isAlt?TEXT("yes"):TEXT("no")); sc->ToElement()->SetAttribute("Alt", key._isAlt?"yes":"no");
sc->ToElement()->SetAttribute(TEXT("Shift"), key._isShift?TEXT("yes"):TEXT("no")); sc->ToElement()->SetAttribute("Shift", key._isShift?"yes":"no");
sc->ToElement()->SetAttribute(TEXT("Key"), key._key); sc->ToElement()->SetAttribute("Key", key._key);
} }
void NppParameters::insertMacro(TiXmlNode *macrosRoot, const MacroShortcut & macro, const generic_string& folderName) void NppParameters::insertMacro(TiXmlNodeA *macrosRoot, const MacroShortcut & macro, const string& folderName)
{ {
const KeyCombo & key = macro.getKeyCombo(); const KeyCombo & key = macro.getKeyCombo();
TiXmlNode *macroRoot = macrosRoot->InsertEndChild(TiXmlElement(TEXT("Macro"))); TiXmlNodeA *macroRoot = macrosRoot->InsertEndChild(TiXmlElementA("Macro"));
macroRoot->ToElement()->SetAttribute(TEXT("name"), macro.getMenuName()); macroRoot->ToElement()->SetAttribute("name", macro.getMenuName());
macroRoot->ToElement()->SetAttribute(TEXT("Ctrl"), key._isCtrl?TEXT("yes"):TEXT("no")); macroRoot->ToElement()->SetAttribute("Ctrl", key._isCtrl?"yes":"no");
macroRoot->ToElement()->SetAttribute(TEXT("Alt"), key._isAlt?TEXT("yes"):TEXT("no")); macroRoot->ToElement()->SetAttribute("Alt", key._isAlt?"yes":"no");
macroRoot->ToElement()->SetAttribute(TEXT("Shift"), key._isShift?TEXT("yes"):TEXT("no")); macroRoot->ToElement()->SetAttribute("Shift", key._isShift?"yes":"no");
macroRoot->ToElement()->SetAttribute(TEXT("Key"), key._key); macroRoot->ToElement()->SetAttribute("Key", key._key);
if (!folderName.empty()) if (!folderName.empty())
{ {
// W -> A -> W macroRoot->ToElement()->SetAttribute("FolderName", folderName);
WcharMbcsConvertor& wmc = WcharMbcsConvertor::getInstance();
const char* folderNameA = wmc.wchar2char(folderName.c_str(), SC_CP_UTF8);
size_t len = strlen(folderNameA);
wchar_t* folderNameW = new wchar_t[len+1];
for (size_t i = 0; i < len; ++i)
{
folderNameW[i] = folderNameA[i];
}
folderNameW[len] = '\0';
macroRoot->ToElement()->SetAttribute(TEXT("FolderName"), folderNameW);
delete[] folderNameW;
} }
for (size_t i = 0, len = macro._macro.size(); i < len ; ++i) for (size_t i = 0, len = macro._macro.size(); i < len ; ++i)
{ {
TiXmlNode *actionNode = macroRoot->InsertEndChild(TiXmlElement(TEXT("Action"))); TiXmlNodeA *actionNode = macroRoot->InsertEndChild(TiXmlElementA("Action"));
const recordedMacroStep & action = macro._macro[i]; const recordedMacroStep & action = macro._macro[i];
actionNode->ToElement()->SetAttribute(TEXT("type"), action._macroType); actionNode->ToElement()->SetAttribute("type", action._macroType);
actionNode->ToElement()->SetAttribute(TEXT("message"), action._message); actionNode->ToElement()->SetAttribute("message", action._message);
actionNode->ToElement()->SetAttribute(TEXT("wParam"), static_cast<int>(action._wParameter)); actionNode->ToElement()->SetAttribute("wParam", static_cast<int>(action._wParameter));
actionNode->ToElement()->SetAttribute(TEXT("lParam"), static_cast<int>(action._lParameter)); actionNode->ToElement()->SetAttribute("lParam", static_cast<int>(action._lParameter));
actionNode->ToElement()->SetAttribute(TEXT("sParam"), action._sParameter.c_str()); actionNode->ToElement()->SetAttribute("sParam", action._sParameter.c_str());
} }
} }
void NppParameters::insertUserCmd(TiXmlNode *userCmdRoot, const UserCommand & userCmd, const generic_string& folderName) void NppParameters::insertUserCmd(TiXmlNodeA *userCmdRoot, const UserCommand & userCmd, const string& folderName)
{ {
const KeyCombo & key = userCmd.getKeyCombo(); const KeyCombo & key = userCmd.getKeyCombo();
TiXmlNode *cmdRoot = userCmdRoot->InsertEndChild(TiXmlElement(TEXT("Command"))); TiXmlNodeA *cmdRoot = userCmdRoot->InsertEndChild(TiXmlElementA("Command"));
cmdRoot->ToElement()->SetAttribute(TEXT("name"), userCmd.getMenuName()); cmdRoot->ToElement()->SetAttribute("name", userCmd.getMenuName());
cmdRoot->ToElement()->SetAttribute(TEXT("Ctrl"), key._isCtrl?TEXT("yes"):TEXT("no")); cmdRoot->ToElement()->SetAttribute("Ctrl", key._isCtrl?"yes":"no");
cmdRoot->ToElement()->SetAttribute(TEXT("Alt"), key._isAlt?TEXT("yes"):TEXT("no")); cmdRoot->ToElement()->SetAttribute("Alt", key._isAlt?"yes":"no");
cmdRoot->ToElement()->SetAttribute(TEXT("Shift"), key._isShift?TEXT("yes"):TEXT("no")); cmdRoot->ToElement()->SetAttribute("Shift", key._isShift?"yes":"no");
cmdRoot->ToElement()->SetAttribute(TEXT("Key"), key._key); cmdRoot->ToElement()->SetAttribute("Key", key._key);
cmdRoot->InsertEndChild(TiXmlText(userCmd._cmd.c_str())); cmdRoot->InsertEndChild(TiXmlTextA(userCmd._cmd.c_str()));
if (!folderName.empty()) if (!folderName.empty())
{ {
// W -> A -> W cmdRoot->ToElement()->SetAttribute("FolderName", folderName);
WcharMbcsConvertor& wmc = WcharMbcsConvertor::getInstance();
const char* folderNameA = wmc.wchar2char(folderName.c_str(), SC_CP_UTF8);
size_t len = strlen(folderNameA);
wchar_t* folderNameW = new wchar_t[len + 1];
for (size_t i = 0; i < len; ++i)
{
folderNameW[i] = folderNameA[i];
}
folderNameW[len] = '\0';
cmdRoot->ToElement()->SetAttribute(TEXT("FolderName"), folderNameW);
delete[] folderNameW;
} }
} }
void NppParameters::insertPluginCmd(TiXmlNode *pluginCmdRoot, const PluginCmdShortcut & pluginCmd) void NppParameters::insertPluginCmd(TiXmlNodeA *pluginCmdRoot, const PluginCmdShortcut & pluginCmd)
{ {
const KeyCombo & key = pluginCmd.getKeyCombo(); const KeyCombo & key = pluginCmd.getKeyCombo();
TiXmlNode *pluginCmdNode = pluginCmdRoot->InsertEndChild(TiXmlElement(TEXT("PluginCommand"))); TiXmlNodeA *pluginCmdNode = pluginCmdRoot->InsertEndChild(TiXmlElementA("PluginCommand"));
pluginCmdNode->ToElement()->SetAttribute(TEXT("moduleName"), pluginCmd.getModuleName()); pluginCmdNode->ToElement()->SetAttribute("moduleName", pluginCmd.getModuleName());
pluginCmdNode->ToElement()->SetAttribute(TEXT("internalID"), pluginCmd.getInternalID()); pluginCmdNode->ToElement()->SetAttribute("internalID", pluginCmd.getInternalID());
pluginCmdNode->ToElement()->SetAttribute(TEXT("Ctrl"), key._isCtrl?TEXT("yes"):TEXT("no")); pluginCmdNode->ToElement()->SetAttribute("Ctrl", key._isCtrl?"yes":"no");
pluginCmdNode->ToElement()->SetAttribute(TEXT("Alt"), key._isAlt?TEXT("yes"):TEXT("no")); pluginCmdNode->ToElement()->SetAttribute("Alt", key._isAlt?"yes":"no");
pluginCmdNode->ToElement()->SetAttribute(TEXT("Shift"), key._isShift?TEXT("yes"):TEXT("no")); pluginCmdNode->ToElement()->SetAttribute("Shift", key._isShift?"yes":"no");
pluginCmdNode->ToElement()->SetAttribute(TEXT("Key"), key._key); pluginCmdNode->ToElement()->SetAttribute("Key", key._key);
} }
void NppParameters::insertScintKey(TiXmlNode *scintKeyRoot, const ScintillaKeyMap & scintKeyMap) void NppParameters::insertScintKey(TiXmlNodeA *scintKeyRoot, const ScintillaKeyMap & scintKeyMap)
{ {
TiXmlNode *keyRoot = scintKeyRoot->InsertEndChild(TiXmlElement(TEXT("ScintKey"))); TiXmlNodeA *keyRoot = scintKeyRoot->InsertEndChild(TiXmlElementA("ScintKey"));
keyRoot->ToElement()->SetAttribute(TEXT("ScintID"), scintKeyMap.getScintillaKeyID()); keyRoot->ToElement()->SetAttribute("ScintID", scintKeyMap.getScintillaKeyID());
keyRoot->ToElement()->SetAttribute(TEXT("menuCmdID"), scintKeyMap.getMenuCmdID()); keyRoot->ToElement()->SetAttribute("menuCmdID", scintKeyMap.getMenuCmdID());
//Add main shortcut //Add main shortcut
KeyCombo key = scintKeyMap.getKeyComboByIndex(0); KeyCombo key = scintKeyMap.getKeyComboByIndex(0);
keyRoot->ToElement()->SetAttribute(TEXT("Ctrl"), key._isCtrl?TEXT("yes"):TEXT("no")); keyRoot->ToElement()->SetAttribute("Ctrl", key._isCtrl?"yes":"no");
keyRoot->ToElement()->SetAttribute(TEXT("Alt"), key._isAlt?TEXT("yes"):TEXT("no")); keyRoot->ToElement()->SetAttribute("Alt", key._isAlt?"yes":"no");
keyRoot->ToElement()->SetAttribute(TEXT("Shift"), key._isShift?TEXT("yes"):TEXT("no")); keyRoot->ToElement()->SetAttribute("Shift", key._isShift?"yes":"no");
keyRoot->ToElement()->SetAttribute(TEXT("Key"), key._key); keyRoot->ToElement()->SetAttribute("Key", key._key);
//Add additional shortcuts //Add additional shortcuts
size_t size = scintKeyMap.getSize(); size_t size = scintKeyMap.getSize();
@ -3514,12 +3412,12 @@ void NppParameters::insertScintKey(TiXmlNode *scintKeyRoot, const ScintillaKeyMa
{ {
for (size_t i = 1; i < size; ++i) for (size_t i = 1; i < size; ++i)
{ {
TiXmlNode *keyNext = keyRoot->InsertEndChild(TiXmlElement(TEXT("NextKey"))); TiXmlNodeA *keyNext = keyRoot->InsertEndChild(TiXmlElementA("NextKey"));
key = scintKeyMap.getKeyComboByIndex(i); key = scintKeyMap.getKeyComboByIndex(i);
keyNext->ToElement()->SetAttribute(TEXT("Ctrl"), key._isCtrl?TEXT("yes"):TEXT("no")); keyNext->ToElement()->SetAttribute("Ctrl", key._isCtrl?"yes":"no");
keyNext->ToElement()->SetAttribute(TEXT("Alt"), key._isAlt?TEXT("yes"):TEXT("no")); keyNext->ToElement()->SetAttribute("Alt", key._isAlt?"yes":"no");
keyNext->ToElement()->SetAttribute(TEXT("Shift"), key._isShift?TEXT("yes"):TEXT("no")); keyNext->ToElement()->SetAttribute("Shift", key._isShift?"yes":"no");
keyNext->ToElement()->SetAttribute(TEXT("Key"), key._key); keyNext->ToElement()->SetAttribute("Key", key._key);
} }
} }
} }
@ -3633,25 +3531,25 @@ void NppParameters::writeShortcuts()
{ {
if (!_isAnyShortcutModified) return; if (!_isAnyShortcutModified) return;
if (!_pXmlShortcutDoc) if (!_pXmlShortcutDocA)
{ {
//do the treatment //do the treatment
_pXmlShortcutDoc = new TiXmlDocument(_shortcutsPath); _pXmlShortcutDocA = new TiXmlDocumentA();
TiXmlDeclaration* decl = new TiXmlDeclaration(TEXT("1.0"), TEXT("UTF-8"), TEXT("")); TiXmlDeclarationA* decl = new TiXmlDeclarationA("1.0", "UTF-8", "");
_pXmlShortcutDoc->LinkEndChild(decl); _pXmlShortcutDocA->LinkEndChild(decl);
} }
TiXmlNode *root = _pXmlShortcutDoc->FirstChild(TEXT("NotepadPlus")); TiXmlNodeA *root = _pXmlShortcutDocA->FirstChild("NotepadPlus");
if (!root) if (!root)
{ {
root = _pXmlShortcutDoc->InsertEndChild(TiXmlElement(TEXT("NotepadPlus"))); root = _pXmlShortcutDocA->InsertEndChild(TiXmlElementA("NotepadPlus"));
} }
TiXmlNode *cmdRoot = root->FirstChild(TEXT("InternalCommands")); TiXmlNodeA *cmdRoot = root->FirstChild("InternalCommands");
if (cmdRoot) if (cmdRoot)
root->RemoveChild(cmdRoot); root->RemoveChild(cmdRoot);
cmdRoot = root->InsertEndChild(TiXmlElement(TEXT("InternalCommands"))); cmdRoot = root->InsertEndChild(TiXmlElementA("InternalCommands"));
for (size_t i = 0, len = _customizedShortcuts.size(); i < len ; ++i) for (size_t i = 0, len = _customizedShortcuts.size(); i < len ; ++i)
{ {
size_t index = _customizedShortcuts[i]; size_t index = _customizedShortcuts[i];
@ -3659,48 +3557,48 @@ void NppParameters::writeShortcuts()
insertCmd(cmdRoot, csc); insertCmd(cmdRoot, csc);
} }
TiXmlNode *macrosRoot = root->FirstChild(TEXT("Macros")); TiXmlNodeA *macrosRoot = root->FirstChild("Macros");
if (macrosRoot) if (macrosRoot)
root->RemoveChild(macrosRoot); root->RemoveChild(macrosRoot);
macrosRoot = root->InsertEndChild(TiXmlElement(TEXT("Macros"))); macrosRoot = root->InsertEndChild(TiXmlElementA("Macros"));
for (size_t i = 0, len = _macros.size(); i < len ; ++i) for (size_t i = 0, len = _macros.size(); i < len ; ++i)
{ {
insertMacro(macrosRoot, _macros[i], _macroMenuItems.getItemFromIndex(i)._parentFolderName); insertMacro(macrosRoot, _macros[i], wstring2string(_macroMenuItems.getItemFromIndex(i)._parentFolderName, CP_UTF8));
} }
TiXmlNode *userCmdRoot = root->FirstChild(TEXT("UserDefinedCommands")); TiXmlNodeA *userCmdRoot = root->FirstChild("UserDefinedCommands");
if (userCmdRoot) if (userCmdRoot)
root->RemoveChild(userCmdRoot); root->RemoveChild(userCmdRoot);
userCmdRoot = root->InsertEndChild(TiXmlElement(TEXT("UserDefinedCommands"))); userCmdRoot = root->InsertEndChild(TiXmlElementA("UserDefinedCommands"));
for (size_t i = 0, len = _userCommands.size(); i < len ; ++i) for (size_t i = 0, len = _userCommands.size(); i < len ; ++i)
{ {
insertUserCmd(userCmdRoot, _userCommands[i], _runMenuItems.getItemFromIndex(i)._parentFolderName); insertUserCmd(userCmdRoot, _userCommands[i], wstring2string(_runMenuItems.getItemFromIndex(i)._parentFolderName, CP_UTF8));
} }
TiXmlNode *pluginCmdRoot = root->FirstChild(TEXT("PluginCommands")); TiXmlNodeA *pluginCmdRoot = root->FirstChild("PluginCommands");
if (pluginCmdRoot) if (pluginCmdRoot)
root->RemoveChild(pluginCmdRoot); root->RemoveChild(pluginCmdRoot);
pluginCmdRoot = root->InsertEndChild(TiXmlElement(TEXT("PluginCommands"))); pluginCmdRoot = root->InsertEndChild(TiXmlElementA("PluginCommands"));
for (size_t i = 0, len = _pluginCustomizedCmds.size(); i < len ; ++i) for (size_t i = 0, len = _pluginCustomizedCmds.size(); i < len ; ++i)
{ {
insertPluginCmd(pluginCmdRoot, _pluginCommands[_pluginCustomizedCmds[i]]); insertPluginCmd(pluginCmdRoot, _pluginCommands[_pluginCustomizedCmds[i]]);
} }
TiXmlNode *scitillaKeyRoot = root->FirstChild(TEXT("ScintillaKeys")); TiXmlNodeA *scitillaKeyRoot = root->FirstChild("ScintillaKeys");
if (scitillaKeyRoot) if (scitillaKeyRoot)
root->RemoveChild(scitillaKeyRoot); root->RemoveChild(scitillaKeyRoot);
scitillaKeyRoot = root->InsertEndChild(TiXmlElement(TEXT("ScintillaKeys"))); scitillaKeyRoot = root->InsertEndChild(TiXmlElementA("ScintillaKeys"));
for (size_t i = 0, len = _scintillaModifiedKeyIndices.size(); i < len ; ++i) for (size_t i = 0, len = _scintillaModifiedKeyIndices.size(); i < len ; ++i)
{ {
insertScintKey(scitillaKeyRoot, _scintillaKeyCommands[_scintillaModifiedKeyIndices[i]]); insertScintKey(scitillaKeyRoot, _scintillaKeyCommands[_scintillaModifiedKeyIndices[i]]);
} }
_pXmlShortcutDoc->SaveFile(); _pXmlShortcutDocA->SaveUnicodeFilePath(_shortcutsPath.c_str());
} }

30
PowerEditor/src/Parameters.h
View File

@ -1814,8 +1814,8 @@ private:
TiXmlDocument *_pXmlUserLangDoc = nullptr; // userDefineLang.xml TiXmlDocument *_pXmlUserLangDoc = nullptr; // userDefineLang.xml
std::vector<UdlXmlFileState> _pXmlUserLangsDoc; // userDefineLang customized XMLs std::vector<UdlXmlFileState> _pXmlUserLangsDoc; // userDefineLang customized XMLs
TiXmlDocument *_pXmlToolIconsDoc = nullptr; // toolbarIcons.xml TiXmlDocument *_pXmlToolIconsDoc = nullptr; // toolbarIcons.xml
TiXmlDocument *_pXmlShortcutDoc = nullptr; // shortcuts.xml
TiXmlDocument *_pXmlBlacklistDoc = nullptr; // not implemented TiXmlDocumentA *_pXmlShortcutDocA = nullptr; // shortcuts.xml
TiXmlDocumentA *_pXmlNativeLangDocA = nullptr; // nativeLang.xml TiXmlDocumentA *_pXmlNativeLangDocA = nullptr; // nativeLang.xml
TiXmlDocumentA *_pXmlContextMenuDocA = nullptr; // contextMenu.xml TiXmlDocumentA *_pXmlContextMenuDocA = nullptr; // contextMenu.xml
@ -1976,7 +1976,6 @@ private:
bool getPluginCmdsFromXmlTree(); bool getPluginCmdsFromXmlTree();
bool getScintKeysFromXmlTree(); bool getScintKeysFromXmlTree();
bool getSessionFromXmlTree(TiXmlDocument *pSessionDoc, Session& session); bool getSessionFromXmlTree(TiXmlDocument *pSessionDoc, Session& session);
bool getBlackListFromXmlTree();
void feedGUIParameters(TiXmlNode *node); void feedGUIParameters(TiXmlNode *node);
void feedKeyWordsParameters(TiXmlNode *node); void feedKeyWordsParameters(TiXmlNode *node);
@ -1993,23 +1992,22 @@ private:
void feedUserStyles(TiXmlNode *node); void feedUserStyles(TiXmlNode *node);
void feedUserKeywordList(TiXmlNode *node); void feedUserKeywordList(TiXmlNode *node);
void feedUserSettings(TiXmlNode *node); void feedUserSettings(TiXmlNode *node);
void feedShortcut(TiXmlNode *node); void feedShortcut(TiXmlNodeA *node);
void feedMacros(TiXmlNode *node); void feedMacros(TiXmlNodeA *node);
void feedUserCmds(TiXmlNode *node); void feedUserCmds(TiXmlNodeA *node);
void feedPluginCustomizedCmds(TiXmlNode *node); void feedPluginCustomizedCmds(TiXmlNodeA *node);
void feedScintKeys(TiXmlNode *node); void feedScintKeys(TiXmlNodeA *node);
bool feedBlacklist(TiXmlNode *node);
void getActions(TiXmlNode *node, Macro & macro); void getActions(TiXmlNodeA *node, Macro & macro);
bool getShortcuts(TiXmlNode *node, Shortcut & sc, generic_string* folderName = nullptr); bool getShortcuts(TiXmlNodeA *node, Shortcut & sc, std::string* folderName = nullptr);
void writeStyle2Element(const Style & style2Write, Style & style2Sync, TiXmlElement *element); void writeStyle2Element(const Style & style2Write, Style & style2Sync, TiXmlElement *element);
void insertUserLang2Tree(TiXmlNode *node, UserLangContainer *userLang); void insertUserLang2Tree(TiXmlNode *node, UserLangContainer *userLang);
void insertCmd(TiXmlNode *cmdRoot, const CommandShortcut & cmd); void insertCmd(TiXmlNodeA *cmdRoot, const CommandShortcut & cmd);
void insertMacro(TiXmlNode *macrosRoot, const MacroShortcut & macro, const generic_string& folderName); void insertMacro(TiXmlNodeA *macrosRoot, const MacroShortcut & macro, const std::string& folderName);
void insertUserCmd(TiXmlNode *userCmdRoot, const UserCommand & userCmd, const generic_string& folderName); void insertUserCmd(TiXmlNodeA *userCmdRoot, const UserCommand & userCmd, const std::string& folderName);
void insertScintKey(TiXmlNode *scintKeyRoot, const ScintillaKeyMap & scintKeyMap); void insertScintKey(TiXmlNodeA *scintKeyRoot, const ScintillaKeyMap & scintKeyMap);
void insertPluginCmd(TiXmlNode *pluginCmdRoot, const PluginCmdShortcut & pluginCmd); void insertPluginCmd(TiXmlNodeA *pluginCmdRoot, const PluginCmdShortcut & pluginCmd);
TiXmlElement * insertGUIConfigBoolNode(TiXmlNode *r2w, const TCHAR *name, bool bVal); TiXmlElement * insertGUIConfigBoolNode(TiXmlNode *r2w, const TCHAR *name, bool bVal);
void insertDockingParamNode(TiXmlNode *GUIRoot); void insertDockingParamNode(TiXmlNode *GUIRoot);
void writeExcludedLangList(TiXmlElement *element); void writeExcludedLangList(TiXmlElement *element);

3
PowerEditor/src/TinyXml/tinyXmlA/tinyxmlA.cpp
View File

@ -87,6 +87,8 @@ void TiXmlBaseA::PutString( const TIXMLA_STRING& str, TIXMLA_STRING* outString )
outString->append( entity[4].str, entity[4].strLength ); outString->append( entity[4].str, entity[4].strLength );
++i; ++i;
} }
// Remove the following code for that attribute value can be human readable if it contains Unicode characters
/*
else if ( c < 32 || c > 126 ) else if ( c < 32 || c > 126 )
{ {
// Easy pass at non-alpha/numeric/symbol // Easy pass at non-alpha/numeric/symbol
@ -96,6 +98,7 @@ void TiXmlBaseA::PutString( const TIXMLA_STRING& str, TIXMLA_STRING* outString )
outString->append( buf, strlen( buf ) ); outString->append( buf, strlen( buf ) );
++i; ++i;
} }
*/
else else
{ {
char realc = static_cast<char>(c); char realc = static_cast<char>(c);

48
PowerEditor/src/WinControls/Grid/ShortcutMapper.cpp
View File

@ -197,8 +197,8 @@ bool ShortcutMapper::isFilterValid(Shortcut sc)
if (_shortcutFilter.empty()) if (_shortcutFilter.empty())
return true; return true;
generic_string shortcut_name = stringToLower(generic_string(sc.getName())); wstring shortcut_name = stringToLower(string2wstring(sc.getName(), CP_UTF8));
generic_string shortcut_value = stringToLower(sc.toString()); wstring shortcut_value = stringToLower(string2wstring(sc.toString(), CP_UTF8));
// test the filter on the shortcut name and value // test the filter on the shortcut name and value
return (shortcut_name.find(_shortcutFilter) != std::string::npos) || return (shortcut_name.find(_shortcutFilter) != std::string::npos) ||
@ -210,7 +210,7 @@ bool ShortcutMapper::isFilterValid(PluginCmdShortcut sc)
// Do like a classic search on shortcut name, then search on the plugin name. // Do like a classic search on shortcut name, then search on the plugin name.
Shortcut shortcut = sc; Shortcut shortcut = sc;
bool match = false; bool match = false;
generic_string module_name = stringToLower(generic_string(sc.getModuleName())); wstring module_name = stringToLower(string2wstring(sc.getModuleName(), CP_UTF8));
if (isFilterValid(shortcut)){ if (isFilterValid(shortcut)){
return true; return true;
} }
@ -296,9 +296,9 @@ void ShortcutMapper::fillOutBabyGrid()
if (findKeyConflicts(nullptr, cshortcuts[i].getKeyCombo(), i)) if (findKeyConflicts(nullptr, cshortcuts[i].getKeyCombo(), i))
isMarker = _babygrid.setMarker(true); isMarker = _babygrid.setMarker(true);
_babygrid.setText(cs_index, 1, cshortcuts[i].getName()); _babygrid.setText(cs_index, 1, string2wstring(cshortcuts[i].getName(), CP_UTF8).c_str());
if (cshortcuts[i].isEnabled()) //avoid empty strings for better performance if (cshortcuts[i].isEnabled()) //avoid empty strings for better performance
_babygrid.setText(cs_index, 2, cshortcuts[i].toString().c_str()); _babygrid.setText(cs_index, 2, string2wstring(cshortcuts[i].toString(), CP_UTF8).c_str());
const TCHAR* category = cshortcuts[i].getCategory(); const TCHAR* category = cshortcuts[i].getCategory();
generic_string categoryStr = nativeLangSpeaker->getShortcutMapperLangStr((std::string(wstring2string(category, CP_UTF8)) + "Category").c_str(), category); generic_string categoryStr = nativeLangSpeaker->getShortcutMapperLangStr((std::string(wstring2string(category, CP_UTF8)) + "Category").c_str(), category);
@ -328,9 +328,9 @@ void ShortcutMapper::fillOutBabyGrid()
if (findKeyConflicts(nullptr, cshortcuts[i].getKeyCombo(), i)) if (findKeyConflicts(nullptr, cshortcuts[i].getKeyCombo(), i))
isMarker = _babygrid.setMarker(true); isMarker = _babygrid.setMarker(true);
_babygrid.setText(cs_index, 1, cshortcuts[i].getName()); _babygrid.setText(cs_index, 1, string2wstring(cshortcuts[i].getName(), CP_UTF8).c_str());
if (cshortcuts[i].isEnabled()) //avoid empty strings for better performance if (cshortcuts[i].isEnabled()) //avoid empty strings for better performance
_babygrid.setText(cs_index, 2, cshortcuts[i].toString().c_str()); _babygrid.setText(cs_index, 2, string2wstring(cshortcuts[i].toString(), CP_UTF8).c_str());
if (isMarker) if (isMarker)
isMarker = _babygrid.setMarker(false); isMarker = _babygrid.setMarker(false);
@ -357,9 +357,9 @@ void ShortcutMapper::fillOutBabyGrid()
if (findKeyConflicts(nullptr, cshortcuts[i].getKeyCombo(), i)) if (findKeyConflicts(nullptr, cshortcuts[i].getKeyCombo(), i))
isMarker = _babygrid.setMarker(true); isMarker = _babygrid.setMarker(true);
_babygrid.setText(cs_index, 1, cshortcuts[i].getName()); _babygrid.setText(cs_index, 1, string2wstring(cshortcuts[i].getName(), CP_UTF8).c_str());
if (cshortcuts[i].isEnabled()) //avoid empty strings for better performance if (cshortcuts[i].isEnabled()) //avoid empty strings for better performance
_babygrid.setText(cs_index, 2, cshortcuts[i].toString().c_str()); _babygrid.setText(cs_index, 2, string2wstring(cshortcuts[i].toString(), CP_UTF8).c_str());
if (isMarker) if (isMarker)
isMarker = _babygrid.setMarker(false); isMarker = _babygrid.setMarker(false);
@ -387,10 +387,10 @@ void ShortcutMapper::fillOutBabyGrid()
if (findKeyConflicts(nullptr, cshortcuts[i].getKeyCombo(), i)) if (findKeyConflicts(nullptr, cshortcuts[i].getKeyCombo(), i))
isMarker = _babygrid.setMarker(true); isMarker = _babygrid.setMarker(true);
_babygrid.setText(cs_index, 1, cshortcuts[i].getName()); _babygrid.setText(cs_index, 1, string2wstring(cshortcuts[i].getName(), CP_UTF8).c_str());
if (cshortcuts[i].isEnabled()) //avoid empty strings for better performance if (cshortcuts[i].isEnabled()) //avoid empty strings for better performance
_babygrid.setText(cs_index, 2, cshortcuts[i].toString().c_str()); _babygrid.setText(cs_index, 2, string2wstring(cshortcuts[i].toString(), CP_UTF8).c_str());
_babygrid.setText(cs_index, 3, cshortcuts[i].getModuleName()); _babygrid.setText(cs_index, 3, string2wstring(cshortcuts[i].getModuleName(), CP_UTF8).c_str());
if (isMarker) if (isMarker)
isMarker = _babygrid.setMarker(false); isMarker = _babygrid.setMarker(false);
@ -427,9 +427,9 @@ void ShortcutMapper::fillOutBabyGrid()
} }
} }
_babygrid.setText(cs_index, 1, cshortcuts[i].getName()); _babygrid.setText(cs_index, 1, string2wstring(cshortcuts[i].getName(), CP_UTF8).c_str());
if (cshortcuts[i].isEnabled()) //avoid empty strings for better performance if (cshortcuts[i].isEnabled()) //avoid empty strings for better performance
_babygrid.setText(cs_index, 2, cshortcuts[i].toString().c_str()); _babygrid.setText(cs_index, 2, string2wstring(cshortcuts[i].toString(), CP_UTF8).c_str());
if (isMarker) if (isMarker)
isMarker = _babygrid.setMarker(false); isMarker = _babygrid.setMarker(false);
@ -1285,9 +1285,9 @@ bool ShortcutMapper::findKeyConflicts(__inout_opt generic_string * const keyConf
*keyConflictLocation += TEXT(" | "); *keyConflictLocation += TEXT(" | ");
*keyConflictLocation += std::to_wstring(itemIndex + 1); *keyConflictLocation += std::to_wstring(itemIndex + 1);
*keyConflictLocation += TEXT(" "); *keyConflictLocation += TEXT(" ");
*keyConflictLocation += vShortcuts[itemIndex].getName(); *keyConflictLocation += string2wstring(vShortcuts[itemIndex].getName(), CP_UTF8);
*keyConflictLocation += TEXT(" ( "); *keyConflictLocation += TEXT(" ( ");
*keyConflictLocation += vShortcuts[itemIndex].toString(); *keyConflictLocation += string2wstring(vShortcuts[itemIndex].toString(), CP_UTF8);
*keyConflictLocation += TEXT(" )"); *keyConflictLocation += TEXT(" )");
} }
} }
@ -1319,9 +1319,9 @@ bool ShortcutMapper::findKeyConflicts(__inout_opt generic_string * const keyConf
*keyConflictLocation += TEXT(" | "); *keyConflictLocation += TEXT(" | ");
*keyConflictLocation += std::to_wstring(itemIndex + 1); *keyConflictLocation += std::to_wstring(itemIndex + 1);
*keyConflictLocation += TEXT(" "); *keyConflictLocation += TEXT(" ");
*keyConflictLocation += vShortcuts[itemIndex].getName(); *keyConflictLocation += string2wstring(vShortcuts[itemIndex].getName(), CP_UTF8);
*keyConflictLocation += TEXT(" ( "); *keyConflictLocation += TEXT(" ( ");
*keyConflictLocation += vShortcuts[itemIndex].toString(); *keyConflictLocation += string2wstring(vShortcuts[itemIndex].toString(), CP_UTF8);
*keyConflictLocation += TEXT(" )"); *keyConflictLocation += TEXT(" )");
} }
} }
@ -1353,9 +1353,9 @@ bool ShortcutMapper::findKeyConflicts(__inout_opt generic_string * const keyConf
*keyConflictLocation += TEXT(" | "); *keyConflictLocation += TEXT(" | ");
*keyConflictLocation += std::to_wstring(itemIndex + 1); *keyConflictLocation += std::to_wstring(itemIndex + 1);
*keyConflictLocation += TEXT(" "); *keyConflictLocation += TEXT(" ");
*keyConflictLocation += vShortcuts[itemIndex].getName(); *keyConflictLocation += string2wstring(vShortcuts[itemIndex].getName(), CP_UTF8);
*keyConflictLocation += TEXT(" ( "); *keyConflictLocation += TEXT(" ( ");
*keyConflictLocation += vShortcuts[itemIndex].toString(); *keyConflictLocation += string2wstring(vShortcuts[itemIndex].toString(), CP_UTF8);
*keyConflictLocation += TEXT(" )"); *keyConflictLocation += TEXT(" )");
} }
} }
@ -1387,9 +1387,9 @@ bool ShortcutMapper::findKeyConflicts(__inout_opt generic_string * const keyConf
*keyConflictLocation += TEXT(" | "); *keyConflictLocation += TEXT(" | ");
*keyConflictLocation += std::to_wstring(itemIndex + 1); *keyConflictLocation += std::to_wstring(itemIndex + 1);
*keyConflictLocation += TEXT(" "); *keyConflictLocation += TEXT(" ");
*keyConflictLocation += vShortcuts[itemIndex].getName(); *keyConflictLocation += string2wstring(vShortcuts[itemIndex].getName(), CP_UTF8);;
*keyConflictLocation += TEXT(" ( "); *keyConflictLocation += TEXT(" ( ");
*keyConflictLocation += vShortcuts[itemIndex].toString(); *keyConflictLocation += string2wstring(vShortcuts[itemIndex].toString(), CP_UTF8);
*keyConflictLocation += TEXT(" )"); *keyConflictLocation += TEXT(" )");
} }
} }
@ -1427,9 +1427,9 @@ bool ShortcutMapper::findKeyConflicts(__inout_opt generic_string * const keyConf
*keyConflictLocation += TEXT("* "); *keyConflictLocation += TEXT("* ");
else else
*keyConflictLocation += TEXT(" "); *keyConflictLocation += TEXT(" ");
*keyConflictLocation += vShortcuts[itemIndex].getName(); *keyConflictLocation += string2wstring(vShortcuts[itemIndex].getName(), CP_UTF8);
*keyConflictLocation += TEXT(" ( "); *keyConflictLocation += TEXT(" ( ");
*keyConflictLocation += vShortcuts[itemIndex].toString(sciIndex); *keyConflictLocation += string2wstring(vShortcuts[itemIndex].toString(sciIndex), CP_UTF8);
*keyConflictLocation += TEXT(" )"); *keyConflictLocation += TEXT(" )");
} }
} }

6
PowerEditor/src/WinControls/StaticDialog/RunDlg/RunDlg.cpp
View File

@ -338,7 +338,7 @@ intptr_t CALLBACK RunDlg::run_dlgProc(UINT message, WPARAM wParam, LPARAM lParam
TCHAR cmd[MAX_PATH]; TCHAR cmd[MAX_PATH];
::GetDlgItemText(_hSelf, IDC_COMBO_RUN_PATH, cmd, MAX_PATH); ::GetDlgItemText(_hSelf, IDC_COMBO_RUN_PATH, cmd, MAX_PATH);
UserCommand uc(Shortcut(), cmd, cmdID); UserCommand uc(Shortcut(), wstring2string(cmd, CP_UTF8).c_str(), cmdID);
uc.init(_hInst, _hSelf); uc.init(_hInst, _hSelf);
if (uc.doDialog() != -1) if (uc.doDialog() != -1)
@ -351,8 +351,8 @@ intptr_t CALLBACK RunDlg::run_dlgProc(UINT message, WPARAM wParam, LPARAM lParam
::InsertMenu(hRunMenu, posBase - 1, MF_BYPOSITION, static_cast<unsigned int>(-1), 0); ::InsertMenu(hRunMenu, posBase - 1, MF_BYPOSITION, static_cast<unsigned int>(-1), 0);
theUserCmds.push_back(uc); theUserCmds.push_back(uc);
runMenu.push_back(MenuItemUnit(cmdID, uc.getName())); runMenu.push_back(MenuItemUnit(cmdID, string2wstring(uc.getName(), CP_UTF8)));
::InsertMenu(hRunMenu, posBase + nbTopLevelItem, MF_BYPOSITION, cmdID, uc.toMenuItemString().c_str()); ::InsertMenu(hRunMenu, posBase + nbTopLevelItem, MF_BYPOSITION, cmdID, string2wstring(uc.toMenuItemString(), CP_UTF8).c_str());
NppParameters& nppParams = NppParameters::getInstance(); NppParameters& nppParams = NppParameters::getInstance();
if (nbTopLevelItem == 0) if (nbTopLevelItem == 0)

264
PowerEditor/src/WinControls/shortcut/shortcut.cpp
View File

@ -28,137 +28,137 @@
using namespace std; using namespace std;
struct KeyIDNAME { struct KeyIDNAME {
const TCHAR * name = nullptr; const char * name = nullptr;
UCHAR id = 0; UCHAR id = 0;
}; };
KeyIDNAME namedKeyArray[] = { KeyIDNAME namedKeyArray[] = {
{TEXT("None"), VK_NULL}, {"None", VK_NULL},
{TEXT("Backspace"), VK_BACK}, {"Backspace", VK_BACK},
{TEXT("Tab"), VK_TAB}, {"Tab", VK_TAB},
{TEXT("Enter"), VK_RETURN}, {"Enter", VK_RETURN},
{TEXT("Esc"), VK_ESCAPE}, {"Esc", VK_ESCAPE},
{TEXT("Spacebar"), VK_SPACE}, {"Spacebar", VK_SPACE},
{TEXT("Page up"), VK_PRIOR}, {"Page up", VK_PRIOR},
{TEXT("Page down"), VK_NEXT}, {"Page down", VK_NEXT},
{TEXT("End"), VK_END}, {"End", VK_END},
{TEXT("Home"), VK_HOME}, {"Home", VK_HOME},
{TEXT("Left"), VK_LEFT}, {"Left", VK_LEFT},
{TEXT("Up"), VK_UP}, {"Up", VK_UP},
{TEXT("Right"), VK_RIGHT}, {"Right", VK_RIGHT},
{TEXT("Down"), VK_DOWN}, {"Down", VK_DOWN},
{TEXT("INS"), VK_INSERT}, {"INS", VK_INSERT},
{TEXT("DEL"), VK_DELETE}, {"DEL", VK_DELETE},
{TEXT("0"), VK_0}, {"0", VK_0},
{TEXT("1"), VK_1}, {"1", VK_1},
{TEXT("2"), VK_2}, {"2", VK_2},
{TEXT("3"), VK_3}, {"3", VK_3},
{TEXT("4"), VK_4}, {"4", VK_4},
{TEXT("5"), VK_5}, {"5", VK_5},
{TEXT("6"), VK_6}, {"6", VK_6},
{TEXT("7"), VK_7}, {"7", VK_7},
{TEXT("8"), VK_8}, {"8", VK_8},
{TEXT("9"), VK_9}, {"9", VK_9},
{TEXT("A"), VK_A}, {"A", VK_A},
{TEXT("B"), VK_B}, {"B", VK_B},
{TEXT("C"), VK_C}, {"C", VK_C},
{TEXT("D"), VK_D}, {"D", VK_D},
{TEXT("E"), VK_E}, {"E", VK_E},
{TEXT("F"), VK_F}, {"F", VK_F},
{TEXT("G"), VK_G}, {"G", VK_G},
{TEXT("H"), VK_H}, {"H", VK_H},
{TEXT("I"), VK_I}, {"I", VK_I},
{TEXT("J"), VK_J}, {"J", VK_J},
{TEXT("K"), VK_K}, {"K", VK_K},
{TEXT("L"), VK_L}, {"L", VK_L},
{TEXT("M"), VK_M}, {"M", VK_M},
{TEXT("N"), VK_N}, {"N", VK_N},
{TEXT("O"), VK_O}, {"O", VK_O},
{TEXT("P"), VK_P}, {"P", VK_P},
{TEXT("Q"), VK_Q}, {"Q", VK_Q},
{TEXT("R"), VK_R}, {"R", VK_R},
{TEXT("S"), VK_S}, {"S", VK_S},
{TEXT("T"), VK_T}, {"T", VK_T},
{TEXT("U"), VK_U}, {"U", VK_U},
{TEXT("V"), VK_V}, {"V", VK_V},
{TEXT("W"), VK_W}, {"W", VK_W},
{TEXT("X"), VK_X}, {"X", VK_X},
{TEXT("Y"), VK_Y}, {"Y", VK_Y},
{TEXT("Z"), VK_Z}, {"Z", VK_Z},
{TEXT("Numpad 0"), VK_NUMPAD0}, {"Numpad 0", VK_NUMPAD0},
{TEXT("Numpad 1"), VK_NUMPAD1}, {"Numpad 1", VK_NUMPAD1},
{TEXT("Numpad 2"), VK_NUMPAD2}, {"Numpad 2", VK_NUMPAD2},
{TEXT("Numpad 3"), VK_NUMPAD3}, {"Numpad 3", VK_NUMPAD3},
{TEXT("Numpad 4"), VK_NUMPAD4}, {"Numpad 4", VK_NUMPAD4},
{TEXT("Numpad 5"), VK_NUMPAD5}, {"Numpad 5", VK_NUMPAD5},
{TEXT("Numpad 6"), VK_NUMPAD6}, {"Numpad 6", VK_NUMPAD6},
{TEXT("Numpad 7"), VK_NUMPAD7}, {"Numpad 7", VK_NUMPAD7},
{TEXT("Numpad 8"), VK_NUMPAD8}, {"Numpad 8", VK_NUMPAD8},
{TEXT("Numpad 9"), VK_NUMPAD9}, {"Numpad 9", VK_NUMPAD9},
{TEXT("Num *"), VK_MULTIPLY}, {"Num *", VK_MULTIPLY},
{TEXT("Num +"), VK_ADD}, {"Num +", VK_ADD},
//{TEXT("Num Enter"), VK_SEPARATOR}, //this one doesnt seem to work // {"Num Enter"), VK_SEPARATOR}, //this one doesnt seem to work
{TEXT("Num -"), VK_SUBTRACT}, {"Num -", VK_SUBTRACT},
{TEXT("Num ."), VK_DECIMAL}, {"Num .", VK_DECIMAL},
{TEXT("Num /"), VK_DIVIDE}, {"Num /", VK_DIVIDE},
{TEXT("F1"), VK_F1}, {"F1", VK_F1},
{TEXT("F2"), VK_F2}, {"F2", VK_F2},
{TEXT("F3"), VK_F3}, {"F3", VK_F3},
{TEXT("F4"), VK_F4}, {"F4", VK_F4},
{TEXT("F5"), VK_F5}, {"F5", VK_F5},
{TEXT("F6"), VK_F6}, {"F6", VK_F6},
{TEXT("F7"), VK_F7}, {"F7", VK_F7},
{TEXT("F8"), VK_F8}, {"F8", VK_F8},
{TEXT("F9"), VK_F9}, {"F9", VK_F9},
{TEXT("F10"), VK_F10}, {"F10", VK_F10},
{TEXT("F11"), VK_F11}, {"F11", VK_F11},
{TEXT("F12"), VK_F12}, {"F12", VK_F12},
{TEXT("~"), VK_OEM_3}, {"~", VK_OEM_3},
{TEXT("-"), VK_OEM_MINUS}, {"-", VK_OEM_MINUS},
{TEXT("="), VK_OEM_PLUS}, {"=", VK_OEM_PLUS},
{TEXT("["), VK_OEM_4}, {"[", VK_OEM_4},
{TEXT("]"), VK_OEM_6}, {"]", VK_OEM_6},
{TEXT(";"), VK_OEM_1}, {";", VK_OEM_1},
{TEXT("'"), VK_OEM_7}, {"'", VK_OEM_7},
{TEXT("\\"), VK_OEM_5}, {"\\", VK_OEM_5},
{TEXT(","), VK_OEM_COMMA}, {",", VK_OEM_COMMA},
{TEXT("."), VK_OEM_PERIOD}, {".", VK_OEM_PERIOD},
{TEXT("/"), VK_OEM_2}, {"/", VK_OEM_2},
{TEXT("<>"), VK_OEM_102}, {"<>", VK_OEM_102},
}; };
#define nbKeys sizeof(namedKeyArray)/sizeof(KeyIDNAME) #define nbKeys sizeof(namedKeyArray)/sizeof(KeyIDNAME)
generic_string Shortcut::toString() const string Shortcut::toString() const
{ {
generic_string sc = TEXT(""); string sc;
if (!isEnabled()) if (!isEnabled())
return sc; return sc;
if (_keyCombo._isCtrl) if (_keyCombo._isCtrl)
sc += TEXT("Ctrl+"); sc += "Ctrl+";
if (_keyCombo._isAlt) if (_keyCombo._isAlt)
sc += TEXT("Alt+"); sc += "Alt+";
if (_keyCombo._isShift) if (_keyCombo._isShift)
sc += TEXT("Shift+"); sc += "Shift+";
generic_string keyString; string keyString;
getKeyStrFromVal(_keyCombo._key, keyString); getKeyStrFromVal(_keyCombo._key, keyString);
sc += keyString; sc += keyString;
return sc; return sc;
} }
void Shortcut::setName(const TCHAR * menuName, const TCHAR * shortcutName) void Shortcut::setName(const char* menuName, const char* shortcutName)
{ {
lstrcpyn(_menuName, menuName, nameLenMax); lstrcpynA(_menuName, menuName, nameLenMax);
TCHAR const * name = shortcutName ? shortcutName : menuName; char const * name = shortcutName ? shortcutName : menuName;
size_t i = 0, j = 0; size_t i = 0, j = 0;
while (name[j] != 0 && i < (nameLenMax - 1)) while (name[j] != 0 && i < (nameLenMax - 1))
{ {
@ -181,34 +181,34 @@ void Shortcut::setName(const TCHAR * menuName, const TCHAR * shortcutName)
_name[i] = 0; _name[i] = 0;
} }
generic_string ScintillaKeyMap::toString() const string ScintillaKeyMap::toString() const
{ {
generic_string sc = TEXT(""); string sc;
size_t nbCombos = getSize(); size_t nbCombos = getSize();
for (size_t combo = 0; combo < nbCombos; ++combo) for (size_t combo = 0; combo < nbCombos; ++combo)
{ {
sc += toString(combo); sc += toString(combo);
if (combo < nbCombos - 1) if (combo < nbCombos - 1)
sc += TEXT(" or "); sc += " or ";
} }
return sc; return sc;
} }
generic_string ScintillaKeyMap::toString(size_t index) const string ScintillaKeyMap::toString(size_t index) const
{ {
generic_string sc = TEXT(""); string sc = "";
if (!isEnabled()) if (!isEnabled())
return sc; return sc;
KeyCombo kc = _keyCombos[index]; KeyCombo kc = _keyCombos[index];
if (kc._isCtrl) if (kc._isCtrl)
sc += TEXT("Ctrl+"); sc += "Ctrl+";
if (kc._isAlt) if (kc._isAlt)
sc += TEXT("Alt+"); sc += "Alt+";
if (kc._isShift) if (kc._isShift)
sc += TEXT("Shift+"); sc += "Shift+";
generic_string keyString; string keyString;
getKeyStrFromVal(kc._key, keyString); getKeyStrFromVal(kc._key, keyString);
sc += keyString; sc += keyString;
return sc; return sc;
@ -268,9 +268,9 @@ size_t ScintillaKeyMap::getSize() const
return _size; return _size;
} }
void getKeyStrFromVal(UCHAR keyVal, generic_string & str) void getKeyStrFromVal(UCHAR keyVal, string & str)
{ {
str = TEXT(""); str = "";
bool found = false; bool found = false;
size_t i; size_t i;
for (i = 0; i < nbKeys; ++i) for (i = 0; i < nbKeys; ++i)
@ -284,22 +284,22 @@ void getKeyStrFromVal(UCHAR keyVal, generic_string & str)
if (found) if (found)
str = namedKeyArray[i].name; str = namedKeyArray[i].name;
else else
str = TEXT("Unlisted"); str = "Unlisted";
} }
void getNameStrFromCmd(DWORD cmd, generic_string & str) void getNameStrFromCmd(DWORD cmd, wstring & str)
{ {
if ((cmd >= ID_MACRO) && (cmd < ID_MACRO_LIMIT)) if ((cmd >= ID_MACRO) && (cmd < ID_MACRO_LIMIT))
{ {
vector<MacroShortcut> & theMacros = (NppParameters::getInstance()).getMacroList(); vector<MacroShortcut> & theMacros = (NppParameters::getInstance()).getMacroList();
int i = cmd - ID_MACRO; int i = cmd - ID_MACRO;
str = theMacros[i].getName(); str = string2wstring(theMacros[i].getName(), CP_UTF8);
} }
else if ((cmd >= ID_USER_CMD) && (cmd < ID_USER_CMD_LIMIT)) else if ((cmd >= ID_USER_CMD) && (cmd < ID_USER_CMD_LIMIT))
{ {
vector<UserCommand> & userCommands = (NppParameters::getInstance()).getUserCommandList(); vector<UserCommand> & userCommands = (NppParameters::getInstance()).getUserCommandList();
int i = cmd - ID_USER_CMD; int i = cmd - ID_USER_CMD;
str = userCommands[i].getName(); str = string2wstring(userCommands[i].getName(), CP_UTF8);
} }
else if ((cmd >= ID_PLUGINS_CMD) && (cmd < ID_PLUGINS_CMD_LIMIT)) else if ((cmd >= ID_PLUGINS_CMD) && (cmd < ID_PLUGINS_CMD_LIMIT))
{ {
@ -313,7 +313,7 @@ void getNameStrFromCmd(DWORD cmd, generic_string & str)
break; break;
} }
} }
str = pluginCmds[i].getName(); str = string2wstring(pluginCmds[i].getName(), CP_UTF8);
} }
else else
{ {
@ -375,7 +375,7 @@ intptr_t CALLBACK Shortcut::run_dlgProc(UINT Message, WPARAM wParam, LPARAM lPar
{ {
NppDarkMode::autoSubclassAndThemeChildControls(_hSelf); NppDarkMode::autoSubclassAndThemeChildControls(_hSelf);
::SetDlgItemText(_hSelf, IDC_NAME_EDIT, _canModifyName ? getMenuName() : getName()); //display the menu name, with ampersands, for macros ::SetDlgItemText(_hSelf, IDC_NAME_EDIT, _canModifyName ? string2wstring(getMenuName(), CP_UTF8).c_str() : string2wstring(getName(), CP_UTF8).c_str()); //display the menu name, with ampersands, for macros
if (!_canModifyName) if (!_canModifyName)
::SendDlgItemMessage(_hSelf, IDC_NAME_EDIT, EM_SETREADONLY, TRUE, 0); ::SendDlgItemMessage(_hSelf, IDC_NAME_EDIT, EM_SETREADONLY, TRUE, 0);
auto textlen = ::SendDlgItemMessage(_hSelf, IDC_NAME_EDIT, WM_GETTEXTLENGTH, 0, 0); auto textlen = ::SendDlgItemMessage(_hSelf, IDC_NAME_EDIT, WM_GETTEXTLENGTH, 0, 0);
@ -387,7 +387,7 @@ intptr_t CALLBACK Shortcut::run_dlgProc(UINT Message, WPARAM wParam, LPARAM lPar
int iFound = -1; int iFound = -1;
for (size_t i = 0 ; i < nbKeys ; ++i) for (size_t i = 0 ; i < nbKeys ; ++i)
{ {
::SendDlgItemMessage(_hSelf, IDC_KEY_COMBO, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>(namedKeyArray[i].name)); ::SendDlgItemMessage(_hSelf, IDC_KEY_COMBO, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>(string2wstring(namedKeyArray[i].name, CP_UTF8).c_str()));
if (_keyCombo._key == namedKeyArray[i].id) if (_keyCombo._key == namedKeyArray[i].id)
iFound = static_cast<int32_t>(i); iFound = static_cast<int32_t>(i);
@ -485,9 +485,9 @@ intptr_t CALLBACK Shortcut::run_dlgProc(UINT Message, WPARAM wParam, LPARAM lPar
if (_canModifyName) if (_canModifyName)
{ {
TCHAR editName[nameLenMax]; TCHAR editName[nameLenMax]{};
::SendDlgItemMessage(_hSelf, IDC_NAME_EDIT, WM_GETTEXT, nameLenMax, reinterpret_cast<LPARAM>(editName)); ::SendDlgItemMessage(_hSelf, IDC_NAME_EDIT, WM_GETTEXT, nameLenMax, reinterpret_cast<LPARAM>(editName));
setName(editName); setName(wstring2string(editName, CP_UTF8).c_str());
} }
::EndDialog(_hSelf, 0); ::EndDialog(_hSelf, 0);
updateConflictState(true); updateConflictState(true);
@ -683,10 +683,10 @@ void Accelerator::updateMenuItemByCommand(const CommandShortcut& csc)
// Ensure that the menu item state is also maintained // Ensure that the menu item state is also maintained
UINT cmdFlags = GetMenuState(_hAccelMenu, cmdID, MF_BYCOMMAND ); UINT cmdFlags = GetMenuState(_hAccelMenu, cmdID, MF_BYCOMMAND );
cmdFlags = MF_BYCOMMAND | ((cmdFlags&MF_CHECKED) ? MF_CHECKED : MF_UNCHECKED) | ((cmdFlags&MF_DISABLED) ? MF_DISABLED : MF_ENABLED); cmdFlags = MF_BYCOMMAND | ((cmdFlags&MF_CHECKED) ? MF_CHECKED : MF_UNCHECKED) | ((cmdFlags&MF_DISABLED) ? MF_DISABLED : MF_ENABLED);
::ModifyMenu(_hAccelMenu, cmdID, cmdFlags, cmdID, csc.toMenuItemString().c_str()); ::ModifyMenu(_hAccelMenu, cmdID, cmdFlags, cmdID, string2wstring(csc.toMenuItemString(), CP_UTF8).c_str());
} }
recordedMacroStep::recordedMacroStep(int iMessage, uptr_t wParam, uptr_t lParam, int codepage) recordedMacroStep::recordedMacroStep(int iMessage, uptr_t wParam, uptr_t lParam)
: _message(iMessage), _wParameter(wParam), _lParameter(lParam), _macroType(mtUseLParameter) : _message(iMessage), _wParameter(wParam), _lParameter(lParam), _macroType(mtUseLParameter)
{ {
if (_lParameter) if (_lParameter)
@ -715,9 +715,7 @@ recordedMacroStep::recordedMacroStep(int iMessage, uptr_t wParam, uptr_t lParam,
case IDD_FINDINFILES_FILTERS_COMBO: case IDD_FINDINFILES_FILTERS_COMBO:
{ {
char *ch = reinterpret_cast<char *>(_lParameter); char *ch = reinterpret_cast<char *>(_lParameter);
TCHAR tch[2]; _sParameter = *ch;
::MultiByteToWideChar(codepage, 0, ch, -1, tch, 2);
_sParameter = *tch;
_macroType = mtUseSParameter; _macroType = mtUseSParameter;
_lParameter = 0; _lParameter = 0;
} }
@ -881,11 +879,14 @@ void recordedMacroStep::PlayBack(Window* pNotepad, ScintillaEditView *pEditView)
if (_macroType == mtUseSParameter) if (_macroType == mtUseSParameter)
{ {
/*
int byteBufferLength = ::WideCharToMultiByte(static_cast<UINT>(pEditView->execute(SCI_GETCODEPAGE)), 0, _sParameter.c_str(), -1, NULL, 0, NULL, NULL); int byteBufferLength = ::WideCharToMultiByte(static_cast<UINT>(pEditView->execute(SCI_GETCODEPAGE)), 0, _sParameter.c_str(), -1, NULL, 0, NULL, NULL);
auto byteBuffer = std::make_unique< char[] >(byteBufferLength); auto byteBuffer = std::make_unique< char[] >(byteBufferLength);
::WideCharToMultiByte(static_cast<UINT>(pEditView->execute(SCI_GETCODEPAGE)), 0, _sParameter.c_str(), -1, byteBuffer.get(), byteBufferLength, NULL, NULL); ::WideCharToMultiByte(static_cast<UINT>(pEditView->execute(SCI_GETCODEPAGE)), 0, _sParameter.c_str(), -1, byteBuffer.get(), byteBufferLength, NULL, NULL);
auto lParam = reinterpret_cast<LPARAM>(byteBuffer.get()); auto lParam = reinterpret_cast<LPARAM>(byteBuffer.get());
pEditView->execute(_message, _wParameter, lParam); pEditView->execute(_message, _wParameter, lParam);
*/
pEditView->execute(_message, _wParameter, (LPARAM)_sParameter.c_str());
} }
else else
{ {
@ -974,8 +975,7 @@ void ScintillaAccelerator::updateMenuItemByID(const ScintillaKeyMap& skm, int id
if (skm.isEnabled()) if (skm.isEnabled())
{ {
menuItem += TEXT("\t"); menuItem += TEXT("\t");
//menuItem += TEXT("Sc:"); //sc: scintilla shortcut menuItem += string2wstring(skm.toString(), CP_UTF8);
menuItem += skm.toString();
} }
::ModifyMenu(_hAccelMenu, id, MF_BYCOMMAND, id, menuItem.c_str()); ::ModifyMenu(_hAccelMenu, id, MF_BYCOMMAND, id, menuItem.c_str());
::DrawMenuBar(_hMenuParent); ::DrawMenuBar(_hMenuParent);
@ -1049,12 +1049,12 @@ intptr_t CALLBACK ScintillaKeyMap::run_dlgProc(UINT Message, WPARAM wParam, LPAR
{ {
NppDarkMode::autoSubclassAndThemeChildControls(_hSelf); NppDarkMode::autoSubclassAndThemeChildControls(_hSelf);
::SetDlgItemText(_hSelf, IDC_NAME_EDIT, _name); ::SetDlgItemText(_hSelf, IDC_NAME_EDIT, string2wstring(_name, CP_UTF8).c_str());
_keyCombo = _keyCombos[0]; _keyCombo = _keyCombos[0];
for (size_t i = 0 ; i < nbKeys ; ++i) for (size_t i = 0 ; i < nbKeys ; ++i)
{ {
::SendDlgItemMessage(_hSelf, IDC_KEY_COMBO, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>(namedKeyArray[i].name)); ::SendDlgItemMessage(_hSelf, IDC_KEY_COMBO, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>(string2wstring(namedKeyArray[i].name, CP_UTF8).c_str()));
} }
for (size_t i = 0; i < _size; ++i) for (size_t i = 0; i < _size; ++i)
@ -1228,7 +1228,7 @@ intptr_t CALLBACK ScintillaKeyMap::run_dlgProc(UINT Message, WPARAM wParam, LPAR
CommandShortcut::CommandShortcut(const Shortcut& sc, long id) : Shortcut(sc), _id(id) CommandShortcut::CommandShortcut(const Shortcut& sc, long id) : Shortcut(sc), _id(id)
{ {
_shortcutName = sc.getName(); _shortcutName = string2wstring(sc.getName(), CP_UTF8);
if ( _id >= IDM_WINDOW_SORT_FN_ASC and _id <= IDM_WINDOW_SORT_FS_DSC) if ( _id >= IDM_WINDOW_SORT_FN_ASC and _id <= IDM_WINDOW_SORT_FS_DSC)
_category = TEXT("Window"); _category = TEXT("Window");
else if ( _id < IDM_EDIT) else if ( _id < IDM_EDIT)

56
PowerEditor/src/WinControls/shortcut/shortcut.h
View File

@ -27,8 +27,8 @@ const size_t nameLenMax = 64;
class NppParameters; class NppParameters;
void getKeyStrFromVal(UCHAR keyVal, generic_string & str); void getKeyStrFromVal(UCHAR keyVal, std::string & str);
void getNameStrFromCmd(DWORD cmd, generic_string & str); void getNameStrFromCmd(DWORD cmd, std::wstring & str);
static size_t keyTranslate(size_t keyIn) { static size_t keyTranslate(size_t keyIn) {
switch (keyIn) { switch (keyIn) {
case VK_DOWN: return SCK_DOWN; case VK_DOWN: return SCK_DOWN;
@ -64,22 +64,22 @@ struct KeyCombo {
UCHAR _key = 0; UCHAR _key = 0;
}; };
class Shortcut : public StaticDialog { class Shortcut : public StaticDialog {
public: public:
Shortcut(): _canModifyName(false) { Shortcut(): _canModifyName(false) {
setName(TEXT("")); setName("");
_keyCombo._isCtrl = false; _keyCombo._isCtrl = false;
_keyCombo._isAlt = false; _keyCombo._isAlt = false;
_keyCombo._isShift = false; _keyCombo._isShift = false;
_keyCombo._key = 0; _keyCombo._key = 0;
}; };
Shortcut(const TCHAR *name, bool isCtrl, bool isAlt, bool isShift, UCHAR key) : _canModifyName(false) { Shortcut(const char* name, bool isCtrl, bool isAlt, bool isShift, UCHAR key) : _canModifyName(false) {
_name[0] = '\0'; _name[0] = '\0';
if (name) { if (name) {
setName(name); setName(name);
} else { } else {
setName(TEXT("")); setName("");
} }
_keyCombo._isCtrl = isCtrl; _keyCombo._isCtrl = isCtrl;
_keyCombo._isAlt = isAlt; _keyCombo._isAlt = isAlt;
@ -108,7 +108,7 @@ public:
return *this; return *this;
} }
friend inline bool operator==(const Shortcut & a, const Shortcut & b) { friend inline bool operator==(const Shortcut & a, const Shortcut & b) {
return ((lstrcmp(a.getMenuName(), b.getMenuName()) == 0) && return ((strcmp(a.getMenuName(), b.getMenuName()) == 0) &&
(a._keyCombo._isCtrl == b._keyCombo._isCtrl) && (a._keyCombo._isCtrl == b._keyCombo._isCtrl) &&
(a._keyCombo._isAlt == b._keyCombo._isAlt) && (a._keyCombo._isAlt == b._keyCombo._isAlt) &&
(a._keyCombo._isShift == b._keyCombo._isShift) && (a._keyCombo._isShift == b._keyCombo._isShift) &&
@ -140,12 +140,12 @@ public:
return (_keyCombo._key != 0); return (_keyCombo._key != 0);
}; };
virtual generic_string toString() const; //the hotkey part virtual std::string toString() const; //the hotkey part
generic_string toMenuItemString() const { //generic_string suitable for menu std::string toMenuItemString() const { //generic_string suitable for menu
generic_string str = _menuName; std::string str = _menuName;
if (isEnabled()) if (isEnabled())
{ {
str += TEXT("\t"); str += "\t";
str += toString(); str += toString();
} }
return str; return str;
@ -154,15 +154,15 @@ public:
return _keyCombo; return _keyCombo;
}; };
const TCHAR * getName() const { const char* getName() const {
return _name; return _name;
}; };
const TCHAR * getMenuName() const { const char* getMenuName() const {
return _menuName; return _menuName;
} }
void setName(const TCHAR * menuName, const TCHAR * shortcutName = NULL); void setName(const char* menuName, const char* shortcutName = NULL);
void clear(){ void clear(){
_keyCombo._isCtrl = false; _keyCombo._isCtrl = false;
@ -176,8 +176,8 @@ protected :
KeyCombo _keyCombo; KeyCombo _keyCombo;
virtual intptr_t CALLBACK run_dlgProc(UINT Message, WPARAM wParam, LPARAM lParam); virtual intptr_t CALLBACK run_dlgProc(UINT Message, WPARAM wParam, LPARAM lParam);
bool _canModifyName = false; bool _canModifyName = false;
TCHAR _name[nameLenMax] = {'\0'}; //normal name is plain text (for display purposes) char _name[nameLenMax] = {'\0'}; //normal name is plain text (for display purposes)
TCHAR _menuName[nameLenMax] = { '\0' }; //menu name has ampersands for quick keys char _menuName[nameLenMax] = { '\0' }; //menu name has ampersands for quick keys
void updateConflictState(const bool endSession = false) const; void updateConflictState(const bool endSession = false) const;
}; };
@ -224,8 +224,8 @@ public:
bool isEnabled() const; bool isEnabled() const;
size_t getSize() const; size_t getSize() const;
generic_string toString() const; std::string toString() const;
generic_string toString(size_t index) const; std::string toString(size_t index) const;
intptr_t doDialog() intptr_t doDialog()
{ {
@ -277,15 +277,15 @@ struct recordedMacroStep {
int _message = 0; int _message = 0;
uptr_t _wParameter = 0; uptr_t _wParameter = 0;
uptr_t _lParameter = 0; uptr_t _lParameter = 0;
generic_string _sParameter; std::string _sParameter;
MacroTypeIndex _macroType = mtMenuCommand; MacroTypeIndex _macroType = mtMenuCommand;
recordedMacroStep(int iMessage, uptr_t wParam, uptr_t lParam, int codepage); recordedMacroStep(int iMessage, uptr_t wParam, uptr_t lParam);
explicit recordedMacroStep(int iCommandID): _wParameter(iCommandID) {}; explicit recordedMacroStep(int iCommandID): _wParameter(iCommandID) {};
recordedMacroStep(int iMessage, uptr_t wParam, uptr_t lParam, const TCHAR *sParam, int type) recordedMacroStep(int iMessage, uptr_t wParam, uptr_t lParam, const char *sParam, int type)
: _message(iMessage), _wParameter(wParam), _lParameter(lParam), _macroType(MacroTypeIndex(type)){ : _message(iMessage), _wParameter(wParam), _lParameter(lParam), _macroType(MacroTypeIndex(type)){
_sParameter = (sParam)?generic_string(sParam):TEXT(""); _sParameter = (sParam) ? std::string(sParam) : "";
}; };
bool isValid() const { bool isValid() const {
@ -312,16 +312,16 @@ private:
class UserCommand : public CommandShortcut { class UserCommand : public CommandShortcut {
friend class NppParameters; friend class NppParameters;
public: public:
UserCommand(const Shortcut& sc, const TCHAR *cmd, int id) : CommandShortcut(sc, id), _cmd(cmd) {_canModifyName = true;}; UserCommand(const Shortcut& sc, const char *cmd, int id) : CommandShortcut(sc, id), _cmd(cmd) {_canModifyName = true;};
const TCHAR* getCmd() const {return _cmd.c_str();}; const char* getCmd() const {return _cmd.c_str();};
private: private:
generic_string _cmd; std::string _cmd;
}; };
class PluginCmdShortcut : public CommandShortcut { class PluginCmdShortcut : public CommandShortcut {
//friend class NppParameters; //friend class NppParameters;
public: public:
PluginCmdShortcut(const Shortcut& sc, int id, const TCHAR *moduleName, unsigned short internalID) :\ PluginCmdShortcut(const Shortcut& sc, int id, const char*moduleName, unsigned short internalID) :\
CommandShortcut(sc, id), _id(id), _moduleName(moduleName), _internalID(internalID) {}; CommandShortcut(sc, id), _id(id), _moduleName(moduleName), _internalID(internalID) {};
bool isValid() const { bool isValid() const {
if (!Shortcut::isValid()) if (!Shortcut::isValid())
@ -330,13 +330,13 @@ public:
return false; return false;
return true; return true;
} }
const TCHAR * getModuleName() const {return _moduleName.c_str();}; const char* getModuleName() const {return _moduleName.c_str();};
int getInternalID() const {return _internalID;}; int getInternalID() const {return _internalID;};
unsigned long getID() const {return _id;}; unsigned long getID() const {return _id;};
private : private :
unsigned long _id; unsigned long _id;
generic_string _moduleName; std::string _moduleName;
int _internalID; int _internalID;
}; };

9
PowerEditor/src/localization.cpp
View File

@ -1043,9 +1043,7 @@ void NativeLangSpeaker::changeShortcutLang()
CommandShortcut & csc = mainshortcuts[index]; CommandShortcut & csc = mainshortcuts[index];
if (csc.getID() == (unsigned long)id) if (csc.getID() == (unsigned long)id)
{ {
WcharMbcsConvertor& wmc = WcharMbcsConvertor::getInstance(); csc.setName(name);
const wchar_t * nameW = wmc.char2wchar(name, _nativeLangEncoding);
csc.setName(nameW);
} }
} }
} }
@ -1073,10 +1071,7 @@ void NativeLangSpeaker::changeShortcutLang()
{ {
const char *name = element->Attribute("name"); const char *name = element->Attribute("name");
ScintillaKeyMap & skm = scinshortcuts[index]; ScintillaKeyMap & skm = scinshortcuts[index];
skm.setName(name);
WcharMbcsConvertor& wmc = WcharMbcsConvertor::getInstance();
const wchar_t * nameW = wmc.char2wchar(name, _nativeLangEncoding);
skm.setName(nameW);
} }
} }
} }