///
/// Browse the complete list of shortcuts and ensure that a key only triggers
/// one of them.
void Remove_duplicate_shortcuts(void)
{
int action_1;
// This algorithm favors shortcuts that are last in the list.
// The idea is that we, coders, append new shortcuts at the end with default
// values; they take priority as they are new functions.
for (action_1=NB_SHORTCUTS-1; action_1>0; action_1--)
{
int n;
word *shortcut_1 = Shortcut(Ordering[action_1]);
for (n=0; n<2; n++)
{
int action_2;
for (action_2=0; action_2<action_1; action_2++)
{
if (shortcut_1[n]!=0)
{
int i;
for(i=0; i<NB_SHORTCUTS; i++)
{
word *shortcut_2 = Shortcut(Ordering[action_2]);
if (shortcut_2[0]==shortcut_1[n])
shortcut_2[0]=0;
if (shortcut_2[1]==shortcut_1[n])
shortcut_2[1]=0;
}
}
}
}
}
}
///
/// Browse the complete list of shortcuts and ensure that a key only triggers
/// one of them.
void Remove_duplicate_shortcuts(void)
{
int action_1;
// This algorithm favors shortcuts that are first in the list.
// The idea is that we, coders, append new shortcuts at the end with default
// values; they should be discarded if user has chosen the key first.
for (action_1=0; action_1<NB_SHORTCUTS-1; action_1++)
{
int n;
word *shortcut_1 = Shortcut(Ordering[action_1]);
for (n=0; n<2; n++)
{
int action_2;
for (action_2=action_1+1; action_2<NB_SHORTCUTS; action_2++)
{
if (shortcut_1[n]!=0)
{
int i;
for(i=0; i<NB_SHORTCUTS; i++)
{
word *shortcut_2 = Shortcut(Ordering[action_2]);
if (shortcut_2[0]==shortcut_1[n])
shortcut_2[0]=0;
if (shortcut_2[1]==shortcut_1[n])
shortcut_2[1]=0;
}
}
}
}
}
}
ShortcutManager::ShortcutManager(QSettings *settings) :
_shortcutSettings(new QSettings)
{
_shortcutSettings = settings;
for (int i = Config::shortcutFullScreen; i <= Config::shortcutClose; ++i)
_listShortcuts << Shortcut();
}
const Configuration::Shortcut Configuration::getShortcut(const QString key_id) const
{
if(Shortcuts.contains(key_id))
return Shortcuts.constFind(key_id).value();
QMessageBox msg(QMessageBox::Warning, "NOT FOUND IN CONFIG!", key_id);
msg.setWindowIcon(QIcon(":/icons/images/compile-warning.png"));
msg.setWindowFlags(msg.windowFlags() & (~Qt::WindowContextHelpButtonHint));
msg.exec();
return Shortcut();
}
ShortcutManager::ShortcutManager(QSettings *settings) :
shortcutSettings(new QSettings)
{
shortcutSettings = settings;
// TODO -- make 2 different lists to shortcut storage
for(int i = Config::shortcutFullScreen; i <= Config::shortcutHelp; ++i)
{
listShortcuts << Shortcut();
}
}
void PluginsManager::addInMenuFromPMIndex(int i)
{
std::vector<PluginCmdShortcut> & pluginCmdSCList = (NppParameters::getInstance())->getPluginCommandList();
::InsertMenu(_hPluginsMenu, i, MF_BYPOSITION | MF_POPUP, (UINT_PTR)_pluginInfos[i]->_pluginMenu, _pluginInfos[i]->_pFuncGetName());
unsigned short j = 0;
for ( ; j < _pluginInfos[i]->_nbFuncItem ; j++)
{
if (_pluginInfos[i]->_funcItems[j]._pFunc == NULL)
{
::InsertMenu(_pluginInfos[i]->_pluginMenu, j, MF_BYPOSITION | MF_SEPARATOR, 0, TEXT(""));
continue;
}
_pluginsCommands.push_back(PluginCommand(_pluginInfos[i]->_moduleName.c_str(), j, _pluginInfos[i]->_funcItems[j]._pFunc));
int cmdID = ID_PLUGINS_CMD + (_pluginsCommands.size() - 1);
_pluginInfos[i]->_funcItems[j]._cmdID = cmdID;
generic_string itemName = _pluginInfos[i]->_funcItems[j]._itemName;
if (_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);
pluginCmdSCList.push_back(pcs);
itemName += TEXT("\t");
itemName += pcs.toString();
}
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
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
pluginCmdSCList.push_back(pcs);
}
::InsertMenu(_pluginInfos[i]->_pluginMenu, j, MF_BYPOSITION, cmdID, itemName.c_str());
if (_pluginInfos[i]->_funcItems[j]._init2Check)
::CheckMenuItem(_hPluginsMenu, cmdID, MF_BYCOMMAND | MF_CHECKED);
}
/*UNLOAD
::InsertMenu(_pluginInfos[i]->_pluginMenu, j++, MF_BYPOSITION | MF_SEPARATOR, 0, TEXT(""));
::InsertMenu(_pluginInfos[i]->_pluginMenu, j, MF_BYPOSITION, ID_PLUGINS_REMOVING + i, TEXT("Remove this plugin"));
*/
}
// Nom de la touche actuallement assignée à un raccourci d'après son numéro
// de type 0x100+BOUTON_* ou SPECIAL_*
const char * Keyboard_shortcut_value(word shortcut_number)
{
static char shortcuts_name[80];
word * pointer = Shortcut(shortcut_number);
if (pointer == NULL)
return "(Problem)";
else
{
if (pointer[0] == 0 && pointer[1] == 0)
return "None";
if (pointer[0] != 0 && pointer[1] == 0)
return Key_name(pointer[0]);
if (pointer[0] == 0 && pointer[1] != 0)
return Key_name(pointer[1]);
strcpy(shortcuts_name, Key_name(pointer[0]));
strcat(shortcuts_name, " or ");
strcat(shortcuts_name, Key_name(pointer[1]));
return shortcuts_name;
}
}
void
gfxSkipChars::BuildShortcuts()
{
if (!mList || mCharCount < SHORTCUT_FREQUENCY)
return;
mShortcuts = new Shortcut[mCharCount/SHORTCUT_FREQUENCY];
if (!mShortcuts)
return;
PRUint32 i;
PRUint32 nextShortcutIndex = 0;
PRUint32 originalCharOffset = 0;
PRUint32 skippedCharOffset = 0;
for (i = 0; i < mListLength; ++i) {
PRUint8 len = mList[i];
// We use >= here to ensure that when mCharCount is a multiple of
// SHORTCUT_FREQUENCY, we fill in the final shortcut with a reference
// to the last element of mList. This means that in general when a list
// element ends on an offset that's a multiple of SHORTCUT_FREQUENCY,
// that list element is the shortcut for that offset, which is
// slightly suboptimal (the *next* element is the one we really want),
// but it's all correct and simpler this way.
while (originalCharOffset + len >= (nextShortcutIndex + 1)*SHORTCUT_FREQUENCY) {
mShortcuts[nextShortcutIndex] =
Shortcut(i, originalCharOffset, skippedCharOffset);
++nextShortcutIndex;
}
originalCharOffset += len;
if (IsKeepEntry(i)) {
skippedCharOffset += len;
}
}
}
BOOL CALLBACK RunDlg::run_dlgProc(UINT message, WPARAM wParam, LPARAM)
{
switch (message)
{
case WM_COMMAND :
{
switch (wParam)
{
case IDCANCEL :
display(false);
return TRUE;
case IDOK :
{
TCHAR cmd[MAX_PATH];
::GetDlgItemText(_hSelf, IDC_COMBO_RUN_PATH, cmd, MAX_PATH);
_cmdLine = cmd;
HINSTANCE hInst = run(_hParent);
if (int(hInst) > 32)
{
addTextToCombo(_cmdLine.c_str());
display(false);
}
else
{
removeTextFromCombo(_cmdLine.c_str());
}
return TRUE;
}
case IDC_BUTTON_SAVE :
{
std::vector<UserCommand> & theUserCmds = (NppParameters::getInstance())->getUserCommandList();
int nbCmd = theUserCmds.size();
int cmdID = ID_USER_CMD + nbCmd;
TCHAR cmd[MAX_PATH];
::GetDlgItemText(_hSelf, IDC_COMBO_RUN_PATH, cmd, MAX_PATH);
UserCommand uc(Shortcut(), cmd, cmdID);
uc.init(_hInst, _hSelf);
if (uc.doDialog() != -1)
{
HMENU hRunMenu = ::GetSubMenu((HMENU)::SendMessage(_hParent, NPPM_INTERNAL_GETMENU, 0, 0), MENUINDEX_RUN);
int const posBase = 2;
if (nbCmd == 0)
::InsertMenu(hRunMenu, posBase - 1, MF_BYPOSITION, (unsigned int)-1, 0);
theUserCmds.push_back(uc);
::InsertMenu(hRunMenu, posBase + nbCmd, MF_BYPOSITION, cmdID, uc.toMenuItemString().c_str());
if (nbCmd == 0)
{
// Insert the separator and modify/delete command
::InsertMenu(hRunMenu, posBase + nbCmd + 1, MF_BYPOSITION, (unsigned int)-1, 0);
const char * nativeLangShortcutMapperRun = (NppParameters::getInstance())->getNativeLangMenuStringA(IDM_SETTING_SHORTCUT_MAPPER_RUN);
const char * shortcutMapperRunStr = nativeLangShortcutMapperRun?nativeLangShortcutMapperRun:"Modify Shortcut/Delete Command...";
#ifdef UNICODE
WcharMbcsConvertor *wmc = WcharMbcsConvertor::getInstance();
const wchar_t * shortcutMapperRunStrW = wmc->char2wchar(shortcutMapperRunStr, ::SendMessage(_hParent, NPPM_GETCURRENTNATIVELANGENCODING, 0, 0));
::InsertMenu(hRunMenu, posBase + nbCmd + 2, MF_BYCOMMAND, IDM_SETTING_SHORTCUT_MAPPER_RUN, shortcutMapperRunStrW);
#else
::InsertMenu(hRunMenu, posBase + nbCmd + 2, MF_BYCOMMAND, IDM_SETTING_SHORTCUT_MAPPER_RUN, shortcutMapperRunStr);
#endif
}
(NppParameters::getInstance())->getAccelerator()->updateShortcuts();
}
return TRUE;
}
case IDC_BUTTON_FILE_BROWSER :
{
FileDialog fd(_hSelf, _hInst);
fd.setExtFilter(TEXT("Executable file : "), TEXT(".exe"), TEXT(".com"), TEXT(".cmd"), TEXT(".bat"), NULL);
fd.setExtFilter(TEXT("All files : "), TEXT(".*"), NULL);
if (const TCHAR *fn = fd.doOpenSingleFileDlg())
addTextToCombo(fn);
return TRUE;
}
default :
break;
}
}
}
return FALSE;
}
Shortcut ShortcutWidget::shortcut(){
if (lock)
return pShortcut;
else
return Shortcut();
}
BOOL CALLBACK RunDlg::run_dlgProc(UINT message, WPARAM wParam, LPARAM)
{
switch (message)
{
case WM_COMMAND :
{
switch (wParam)
{
case IDCANCEL :
display(false);
return TRUE;
case IDOK :
{
TCHAR cmd[MAX_PATH];
::GetDlgItemText(_hSelf, IDC_COMBO_RUN_PATH, cmd, MAX_PATH);
_cmdLine = cmd;
HINSTANCE hInst = run(_hParent);
if (int(hInst) > 32)
{
addTextToCombo(_cmdLine.c_str());
display(false);
}
else
{
removeTextFromCombo(_cmdLine.c_str());
}
return TRUE;
}
case IDC_BUTTON_SAVE :
{
std::vector<UserCommand> & theUserCmds = (NppParameters::getInstance())->getUserCommandList();
int nbCmd = theUserCmds.size();
int cmdID = ID_USER_CMD + nbCmd;
TCHAR cmd[MAX_PATH];
::GetDlgItemText(_hSelf, IDC_COMBO_RUN_PATH, cmd, MAX_PATH);
UserCommand uc(Shortcut(), cmd, cmdID);
uc.init(_hInst, _hSelf);
if (uc.doDialog() != -1)
{
HMENU hRunMenu = ::GetSubMenu((HMENU)::SendMessage(_hParent, NPPM_INTERNAL_GETMENU, 0, 0), MENUINDEX_RUN);
int const posBase = 2;
if (nbCmd == 0)
::InsertMenu(hRunMenu, posBase - 1, MF_BYPOSITION, (unsigned int)-1, 0);
theUserCmds.push_back(uc);
::InsertMenu(hRunMenu, posBase + nbCmd, MF_BYPOSITION, cmdID, uc.toMenuItemString().c_str());
if (nbCmd == 0)
{
// Insert the separator and modify/delete command
::InsertMenu(hRunMenu, posBase + nbCmd + 1, MF_BYPOSITION, (unsigned int)-1, 0);
NativeLangSpeaker *pNativeLangSpeaker = (NppParameters::getInstance())->getNativeLangSpeaker();
generic_string nativeLangShortcutMapperMacro = pNativeLangSpeaker->getNativeLangMenuString(IDM_SETTING_SHORTCUT_MAPPER_MACRO);
if (nativeLangShortcutMapperMacro == TEXT(""))
nativeLangShortcutMapperMacro = TEXT("Modify Shortcut/Delete Command...");
::InsertMenu(hRunMenu, posBase + nbCmd + 2, MF_BYCOMMAND, IDM_SETTING_SHORTCUT_MAPPER_RUN, nativeLangShortcutMapperMacro.c_str());
}
(NppParameters::getInstance())->getAccelerator()->updateShortcuts();
}
return TRUE;
}
case IDC_BUTTON_FILE_BROWSER :
{
FileDialog fd(_hSelf, _hInst);
fd.setExtFilter(TEXT("Executable file : "), TEXT(".exe"), TEXT(".com"), TEXT(".cmd"), TEXT(".bat"), NULL);
fd.setExtFilter(TEXT("All files : "), TEXT(".*"), NULL);
if (const TCHAR *fn = fd.doOpenSingleFileDlg())
{
if(wcschr(fn, ' ') != NULL)
{
generic_string fn_quotes(fn);
fn_quotes = TEXT("\"") + fn_quotes + TEXT("\"");
addTextToCombo(fn_quotes.c_str());
}
else
{
addTextToCombo(fn);
}
}
return TRUE;
}
default :
break;
}
}
}
return FALSE;
}
void Window_set_shortcut(int action_id)
{
short clicked_button;
short order_index;
short config_index;
short redraw_controls=1;
word * shortcut_ptr=NULL;
word backup_shortcut[2];
shortcut_ptr=Shortcut(action_id);
backup_shortcut[0]=shortcut_ptr[0];
backup_shortcut[1]=shortcut_ptr[1];
// Recherche dans hotkeys
order_index=0;
while (Ordering[order_index]!=action_id)
{
order_index++;
if (order_index>=NB_SHORTCUTS)
{
Error(0);
return;
}
}
/*
config_index=0;
while (ConfigKey[config_index].Number!=order_index)
{
config_index++;
if (config_index>=NB_SHORTCUTS)
{
Error(0);
return;
}
}
*/
config_index=order_index; // Comprends pas... ça devrait pas marcher
Open_window(302,131,"Keyboard shortcut");
Window_set_normal_button(181,111,55,14,"Cancel",0,1,KEY_ESC); // 1
Window_set_normal_button(241,111,55,14,"OK",0,1,SDLK_RETURN); // 2
Window_set_normal_button(6,111,111,14,"Reset default",0,1,KEY_NONE); // 3
// Titre
Block(Window_pos_X+(Menu_factor_X*5),
Window_pos_Y+(Menu_factor_Y*16),
Menu_factor_X*292,Menu_factor_Y*11,MC_Black);
Print_in_window(7,18,ConfigKey[config_index].Label,MC_White,MC_Black);
// Zone de description
Window_display_frame_in(5,68,292,37);
Print_in_window(8,70,ConfigKey[config_index].Explanation1,MC_Black,MC_Light);
Print_in_window(8,78,ConfigKey[config_index].Explanation2,MC_Black,MC_Light);
Print_in_window(8,86,ConfigKey[config_index].Explanation3,MC_Black,MC_Light);
// Shortcut 0
Window_set_normal_button(27,30,177,14,"",0,1,KEY_NONE); // 4
Window_set_normal_button(209,30,56,14,"Remove",0,1,KEY_NONE); // 5
// Shortcut 1
Window_set_normal_button(27,49,177,14,"",0,1,KEY_NONE); // 6
Window_set_normal_button(209,49,56,14,"Remove",0,1,KEY_NONE); // 7
Display_cursor();
do
{
if (redraw_controls)
{
Hide_cursor();
Block(Window_pos_X+(Menu_factor_X*32),
Window_pos_Y+(Menu_factor_Y*33),
Menu_factor_X*21*8,Menu_factor_Y*8,MC_Light);
Print_in_window_limited(32,33,Key_name(shortcut_ptr[0]),21,MC_Black,MC_Light);
Block(Window_pos_X+(Menu_factor_X*32),
Window_pos_Y+(Menu_factor_Y*52),
Menu_factor_X*21*8,Menu_factor_Y*8,MC_Light);
Print_in_window_limited(32,52,Key_name(shortcut_ptr[1]),21,MC_Black,MC_Light);
Update_rect(Window_pos_X,Window_pos_Y,302*Menu_factor_X,131*Menu_factor_Y);
Display_cursor();
redraw_controls=0;
}
clicked_button=Window_clicked_button();
switch (clicked_button)
{
case -1:
case 0:
break;
case 4: // Change 0
Redefine_control(&shortcut_ptr[0], 32, 33);
redraw_controls=1;
break;
case 6: // Change 1
Redefine_control(&shortcut_ptr[1], 32, 52);
redraw_controls=1;
break;
case 5: // Remove 0
shortcut_ptr[0]=0;
redraw_controls=1;
break;
case 7: // Remove 1
shortcut_ptr[1]=0;
redraw_controls=1;
break;
case 3: // Defaults
shortcut_ptr[0]=ConfigKey[config_index].Key;
shortcut_ptr[1]=ConfigKey[config_index].Key2;
redraw_controls=1;
break;
case 1: // Cancel
shortcut_ptr[0]=backup_shortcut[0];
shortcut_ptr[1]=backup_shortcut[1];
case 2: // OK
// Replace twice by single
if (shortcut_ptr[0]==shortcut_ptr[1])
shortcut_ptr[1]=0;
// Remove all other shortcuts that use same keys
if (!Config.Allow_multi_shortcuts)
{
int n;
for (n=0; n<2; n++)
{
if (shortcut_ptr[n]!=0)
{
int i;
for(i=0; i<NB_SHORTCUTS; i++)
{
word * other_shortcut_ptr;
if (Ordering[i]==action_id)
continue;
other_shortcut_ptr=Shortcut(Ordering[i]);
if (other_shortcut_ptr[0]==shortcut_ptr[n])
other_shortcut_ptr[0]=0;
if (other_shortcut_ptr[1]==shortcut_ptr[n])
other_shortcut_ptr[1]=0;
}
}
}
}
default:
break;
}
}
while ((clicked_button!=1) && (clicked_button!=2) && (Key!=SDLK_RETURN));
Key=0;
Close_window();
Display_cursor();
}
Configuration::Configuration() : QObject()
{
//setup default color map
defaultColors.clear();
defaultColors.insert("AbstractTableViewSeparatorColor", QColor("#808080"));
defaultColors.insert("AbstractTableViewBackgroundColor", QColor("#FFF8F0"));
defaultColors.insert("AbstractTableViewTextColor", QColor("#000000"));
defaultColors.insert("AbstractTableViewHeaderTextColor", QColor("#000000"));
defaultColors.insert("AbstractTableViewSelectionColor", QColor("#C0C0C0"));
defaultColors.insert("DisassemblyCipColor", QColor("#FFFFFF"));
defaultColors.insert("DisassemblyCipBackgroundColor", QColor("#000000"));
defaultColors.insert("DisassemblyBreakpointColor", QColor("#000000"));
defaultColors.insert("DisassemblyBreakpointBackgroundColor", QColor("#FF0000"));
defaultColors.insert("DisassemblyHardwareBreakpointColor", QColor("#000000"));
defaultColors.insert("DisassemblyHardwareBreakpointBackgroundColor", Qt::transparent);
defaultColors.insert("DisassemblyBookmarkColor", QColor("#000000"));
defaultColors.insert("DisassemblyBookmarkBackgroundColor", QColor("#FEE970"));
defaultColors.insert("DisassemblyLabelColor", QColor("#FF0000"));
defaultColors.insert("DisassemblyLabelBackgroundColor", Qt::transparent);
defaultColors.insert("DisassemblyBackgroundColor", QColor("#FFF8F0"));
defaultColors.insert("DisassemblySelectionColor", QColor("#C0C0C0"));
defaultColors.insert("DisassemblyAddressColor", QColor("#808080"));
defaultColors.insert("DisassemblyAddressBackgroundColor", Qt::transparent);
defaultColors.insert("DisassemblySelectedAddressColor", QColor("#000000"));
defaultColors.insert("DisassemblySelectedAddressBackgroundColor", Qt::transparent);
defaultColors.insert("DisassemblyConditionalJumpLineTrueColor", QColor("#FF0000"));
defaultColors.insert("DisassemblyConditionalJumpLineFalseColor", QColor("#808080"));
defaultColors.insert("DisassemblyUnconditionalJumpLineColor", QColor("#FF0000"));
defaultColors.insert("DisassemblyBytesColor", QColor("#000000"));
defaultColors.insert("DisassemblyModifiedBytesColor", QColor("#FF0000"));
defaultColors.insert("DisassemblyCommentColor", QColor("#000000"));
defaultColors.insert("DisassemblyCommentBackgroundColor", Qt::transparent);
defaultColors.insert("DisassemblyAutoCommentColor", QColor("#808080"));
defaultColors.insert("DisassemblyAutoCommentBackgroundColor", Qt::transparent);
defaultColors.insert("SideBarCipLabelColor", QColor("#FFFFFF"));
defaultColors.insert("SideBarCipLabelBackgroundColor", QColor("#4040FF"));
defaultColors.insert("SideBarBackgroundColor", QColor("#FFF8F0"));
defaultColors.insert("SideBarConditionalJumpLineTrueColor", QColor("#FF0000"));
defaultColors.insert("SideBarConditionalJumpLineFalseColor", QColor("#808080"));
defaultColors.insert("SideBarUnconditionalJumpLineTrueColor", QColor("#FF0000"));
defaultColors.insert("SideBarUnconditionalJumpLineFalseColor", QColor("#808080"));
defaultColors.insert("SideBarBulletColor", QColor("#808080"));
defaultColors.insert("SideBarBulletBreakpointColor", QColor("#FF0000"));
defaultColors.insert("SideBarBulletDisabledBreakpointColor", QColor("#00AA00"));
defaultColors.insert("SideBarBulletBookmarkColor", QColor("#FEE970"));
defaultColors.insert("RegistersBackgroundColor", QColor("#FFF8F0"));
defaultColors.insert("RegistersColor", QColor("#000000"));
defaultColors.insert("RegistersModifiedColor", QColor("#FF0000"));
defaultColors.insert("RegistersSelectionColor", QColor("#EEEEEE"));
defaultColors.insert("RegistersLabelColor", QColor("#000000"));
defaultColors.insert("RegistersExtraInfoColor", QColor("#000000"));
defaultColors.insert("InstructionHighlightColor", QColor("#FF0000"));
defaultColors.insert("InstructionCommaColor", QColor("#000000"));
defaultColors.insert("InstructionCommaBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionPrefixColor", QColor("#000000"));
defaultColors.insert("InstructionPrefixBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionUncategorizedColor", QColor("#000000"));
defaultColors.insert("InstructionUncategorizedBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionAddressColor", QColor("#000000"));
defaultColors.insert("InstructionAddressBackgroundColor", QColor("#FFFF00"));
defaultColors.insert("InstructionValueColor", QColor("#828200"));
defaultColors.insert("InstructionValueBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionMnemonicColor", QColor("#000000"));
defaultColors.insert("InstructionMnemonicBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionPushPopColor", QColor("#0000FF"));
defaultColors.insert("InstructionPushPopBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionCallColor", QColor("#000000"));
defaultColors.insert("InstructionCallBackgroundColor", QColor("#00FFFF"));
defaultColors.insert("InstructionRetColor", QColor("#000000"));
defaultColors.insert("InstructionRetBackgroundColor", QColor("#00FFFF"));
defaultColors.insert("InstructionConditionalJumpColor", QColor("#FF0000"));
defaultColors.insert("InstructionConditionalJumpBackgroundColor", QColor("#FFFF00"));
defaultColors.insert("InstructionUnconditionalJumpColor", QColor("#000000"));
defaultColors.insert("InstructionUnconditionalJumpBackgroundColor", QColor("#FFFF00"));
defaultColors.insert("InstructionNopColor", QColor("#808080"));
defaultColors.insert("InstructionNopBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionFarColor", QColor("#000000"));
defaultColors.insert("InstructionFarBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionInt3Color", QColor("#000000"));
defaultColors.insert("InstructionInt3BackgroundColor", Qt::transparent);
defaultColors.insert("InstructionMemorySizeColor", QColor("#000080"));
defaultColors.insert("InstructionMemorySizeBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionMemorySegmentColor", QColor("#FF00FF"));
defaultColors.insert("InstructionMemorySegmentBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionMemoryBracketsColor", QColor("#000000"));
defaultColors.insert("InstructionMemoryBracketsBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionMemoryStackBracketsColor", QColor("#000000"));
defaultColors.insert("InstructionMemoryStackBracketsBackgroundColor", QColor("#00FFFF"));
defaultColors.insert("InstructionMemoryBaseRegisterColor", QColor("#B03434"));
defaultColors.insert("InstructionMemoryBaseRegisterBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionMemoryIndexRegisterColor", QColor("#3838BC"));
defaultColors.insert("InstructionMemoryIndexRegisterBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionMemoryScaleColor", QColor("#B30059"));
defaultColors.insert("InstructionMemoryScaleBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionMemoryOperatorColor", QColor("#F27711"));
defaultColors.insert("InstructionMemoryOperatorBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionGeneralRegisterColor", QColor("#008300"));
defaultColors.insert("InstructionGeneralRegisterBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionFpuRegisterColor", QColor("#000080"));
defaultColors.insert("InstructionFpuRegisterBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionMmxRegisterColor", QColor("#000080"));
defaultColors.insert("InstructionMmxRegisterBackgroundColor", Qt::transparent);
defaultColors.insert("InstructionSseRegisterColor", QColor("#000080"));
defaultColors.insert("InstructionSseRegisterBackgroundColor", Qt::transparent);
defaultColors.insert("HexDumpTextColor", QColor("#000000"));
defaultColors.insert("HexDumpModifiedBytesColor", QColor("#FF0000"));
defaultColors.insert("HexDumpBackgroundColor", QColor("#FFF8F0"));
defaultColors.insert("HexDumpSelectionColor", QColor("#C0C0C0"));
defaultColors.insert("HexDumpAddressColor", QColor("#000000"));
defaultColors.insert("HexDumpAddressBackgroundColor", Qt::transparent);
defaultColors.insert("HexDumpLabelColor", QColor("#FF0000"));
defaultColors.insert("HexDumpLabelBackgroundColor", Qt::transparent);
defaultColors.insert("StackTextColor", QColor("#000000"));
defaultColors.insert("StackInactiveTextColor", QColor("#808080"));
defaultColors.insert("StackBackgroundColor", QColor("#FFF8F0"));
defaultColors.insert("StackSelectionColor", QColor("#C0C0C0"));
defaultColors.insert("StackCspColor", QColor("#FFFFFF"));
defaultColors.insert("StackCspBackgroundColor", QColor("#000000"));
defaultColors.insert("StackAddressColor", QColor("#808080"));
defaultColors.insert("StackAddressBackgroundColor", Qt::transparent);
defaultColors.insert("StackSelectedAddressColor", QColor("#000000"));
defaultColors.insert("StackSelectedAddressBackgroundColor", Qt::transparent);
defaultColors.insert("StackLabelColor", QColor("#FF0000"));
defaultColors.insert("StackLabelBackgroundColor", Qt::transparent);
defaultColors.insert("HexEditTextColor", QColor("#000000"));
defaultColors.insert("HexEditWildcardColor", QColor("#FF0000"));
defaultColors.insert("HexEditBackgroundColor", QColor("#FFF8F0"));
defaultColors.insert("HexEditSelectionColor", QColor("#C0C0C0"));
defaultColors.insert("ThreadCurrentColor", QColor("#FFFFFF"));
defaultColors.insert("ThreadCurrentBackgroundColor", QColor("#000000"));
defaultColors.insert("MemoryMapBreakpointColor", QColor("#FFFBF0"));
defaultColors.insert("MemoryMapBreakpointBackgroundColor", QColor("#FF0000"));
defaultColors.insert("MemoryMapSectionTextColor", QColor("#8B671F"));
defaultColors.insert("SearchListViewHighlightColor", QColor("#FF0000"));
//bool settings
QMap<QString, bool> disassemblyBool;
disassemblyBool.insert("ArgumentSpaces", false);
disassemblyBool.insert("MemorySpaces", false);
disassemblyBool.insert("FillNOPs", false);
disassemblyBool.insert("Uppercase", false);
disassemblyBool.insert("FindCommandEntireBlock", false);
disassemblyBool.insert("OnlyCipAutoComments", false);
defaultBools.insert("Disassembler", disassemblyBool);
//uint settings
QMap<QString, uint_t> hexdumpUint;
hexdumpUint.insert("DefaultView", 0);
defaultUints.insert("HexDump", hexdumpUint);
//font settings
QFont font("Lucida Console", 8, QFont::Normal, false);
defaultFonts.insert("AbstractTableView", font);
defaultFonts.insert("Disassembly", font);
defaultFonts.insert("HexDump", font);
defaultFonts.insert("Stack", font);
defaultFonts.insert("Registers", font);
defaultFonts.insert("HexEdit", font);
defaultFonts.insert("Application", QApplication::font());
// hotkeys settings
defaultShortcuts.insert("FileOpen", Shortcut(tr("File -> Open"), "F3", true));
defaultShortcuts.insert("FileAttach", Shortcut(tr("File -> Attach"), "Alt+A", true));
defaultShortcuts.insert("FileDetach", Shortcut(tr("File -> Detach"), "Ctrl+Alt+F2", true));
defaultShortcuts.insert("FileExit", Shortcut(tr("File -> Exit"), "Alt+X", true));
defaultShortcuts.insert("ViewCpu", Shortcut(tr("View -> CPU"), "Alt+C", true));
defaultShortcuts.insert("ViewLog", Shortcut(tr("View -> Log"), "Alt+L", true));
defaultShortcuts.insert("ViewBreakpoints", Shortcut(tr("View -> Breakpoints"), "Alt+B", true));
defaultShortcuts.insert("ViewMemoryMap", Shortcut(tr("View -> Memory Map"), "Alt+M", true));
defaultShortcuts.insert("ViewCallStack", Shortcut(tr("View -> Call Stack"), "Alt+K", true));
defaultShortcuts.insert("ViewScript", Shortcut(tr("View -> Script"), "Alt+S", true));
defaultShortcuts.insert("ViewSymbolInfo", Shortcut(tr("View -> Symbol Info"), "Ctrl+Alt+S", true));
defaultShortcuts.insert("ViewSource", Shortcut(tr("View -> Source"), "Ctrl+Shift+S", true));
defaultShortcuts.insert("ViewReferences", Shortcut(tr("View -> References"), "Alt+R", true));
defaultShortcuts.insert("ViewThreads", Shortcut(tr("View -> Threads"), "Alt+T", true));
defaultShortcuts.insert("ViewPatches", Shortcut(tr("View -> Patches"), "Ctrl+P", true));
defaultShortcuts.insert("ViewComments", Shortcut(tr("View -> Comments"), "Ctrl+Alt+C", true));
defaultShortcuts.insert("ViewLabels", Shortcut(tr("View -> Labels"), "Ctrl+Alt+L", true));
defaultShortcuts.insert("ViewBookmarks", Shortcut(tr("View -> Bookmarks"), "Ctrl+Alt+B", true));
defaultShortcuts.insert("ViewFunctions", Shortcut(tr("View -> Functions"), "Alt+F", true));
defaultShortcuts.insert("DebugRun", Shortcut(tr("Debug -> Run"), "F9", true));
defaultShortcuts.insert("DebugeRun", Shortcut(tr("Debug -> Run (skip exceptions)"), "Shift+F9", true));
defaultShortcuts.insert("DebugRunSelection", Shortcut(tr("Debug -> Run until selection"), "F4", true));
defaultShortcuts.insert("DebugPause", Shortcut(tr("Debug -> Pause"), "F12", true));
defaultShortcuts.insert("DebugRestart", Shortcut(tr("Debug -> Restart"), "Ctrl+F2", true));
defaultShortcuts.insert("DebugClose", Shortcut(tr("Debug -> Close"), "Alt+F2", true));
defaultShortcuts.insert("DebugStepInto", Shortcut(tr("Debug -> Step into"), "F7", true));
defaultShortcuts.insert("DebugeStepInfo", Shortcut(tr("Debug -> Step into (skip execptions)"), "Shift+F7", true));
defaultShortcuts.insert("DebugStepOver", Shortcut(tr("Debug -> Step over"), "F8", true));
defaultShortcuts.insert("DebugeStepOver", Shortcut(tr("Debug -> Step over (skip execptions)"), "Shift+F8", true));
defaultShortcuts.insert("DebugRtr", Shortcut(tr("Debug -> Execute till return"), "Ctrl+F9", true));
defaultShortcuts.insert("DebugeRtr", Shortcut(tr("Debug -> Execute till return (skip exceptions)"), "Ctrl+Shift+F9", true));
defaultShortcuts.insert("DebugSkipNextInstruction", Shortcut(tr("Debug -> Skip next instruction"), "Ctrl+F8", true));
defaultShortcuts.insert("DebugCommand", Shortcut(tr("Debug -> Command"), "Ctrl+Return", true));
defaultShortcuts.insert("PluginsScylla", Shortcut(tr("Plugins -> Scylla"), "Ctrl+I", true));
defaultShortcuts.insert("OptionsPreferences", Shortcut(tr("Options -> Preferences"), "", true));
defaultShortcuts.insert("OptionsAppearance", Shortcut(tr("Options -> Appearance"), "", true));
defaultShortcuts.insert("OptionsShortcuts", Shortcut(tr("Options -> Shortcuts"), "", true));
defaultShortcuts.insert("OptionsTopmost", Shortcut(tr("Options -> Topmost"), "Ctrl+F5", true));
defaultShortcuts.insert("HelpAbout", Shortcut(tr("Help -> About"), "", true));
defaultShortcuts.insert("HelpDonate", Shortcut(tr("Help -> Donate"), "", true));
defaultShortcuts.insert("HelpCheckForUpdates", Shortcut(tr("Help -> Check for Updates"), "", true));
defaultShortcuts.insert("HelpCalculator", Shortcut(tr("Help -> Calculator"), "?"));
defaultShortcuts.insert("HelpReportBug", Shortcut(tr("Help -> Report Bug"), "", true));
defaultShortcuts.insert("ActionFindStrings", Shortcut(tr("Actions -> Find Strings"), "", true));
defaultShortcuts.insert("ActionFindIntermodularCalls", Shortcut(tr("Actions -> Find Intermodular Calls"), "", true));
defaultShortcuts.insert("ActionToggleBreakpoint", Shortcut(tr("Actions -> Toggle Breakpoint"), "F2"));
defaultShortcuts.insert("ActionToggleBookmark", Shortcut(tr("Actions -> Toggle Bookmark"), "Ctrl+D"));
defaultShortcuts.insert("ActionDeleteBreakpoint", Shortcut(tr("Actions -> Delete Breakpoint"), "Delete"));
defaultShortcuts.insert("ActionEnableDisableBreakpoint", Shortcut(tr("Actions -> Enable/Disable Breakpoint"), "Space"));
defaultShortcuts.insert("ActionBinaryEdit", Shortcut(tr("Actions -> Binary Edit"), "Ctrl+E"));
defaultShortcuts.insert("ActionBinaryFill", Shortcut(tr("Actions -> Binary Fill"), "F"));
defaultShortcuts.insert("ActionBinaryFillNops", Shortcut(tr("Actions -> Binary Fill NOPs"), "Ctrl+9"));
defaultShortcuts.insert("ActionBinaryCopy", Shortcut(tr("Actions -> Binary Copy"), "Shift+C"));
defaultShortcuts.insert("ActionBinaryPaste", Shortcut(tr("Actions -> Binary Paste"), "Shift+V"));
defaultShortcuts.insert("ActionBinaryPasteIgnoreSize", Shortcut(tr("Actions -> Binary Paste (Ignore Size)"), "Ctrl+Shift+V"));
defaultShortcuts.insert("ActionUndoSelection", Shortcut(tr("Actions -> Undo Selection"), "Ctrl+Backspace"));
defaultShortcuts.insert("ActionSetLabel", Shortcut(tr("Actions -> Set Label"), ":"));
defaultShortcuts.insert("ActionSetComment", Shortcut(tr("Actions -> Set Comment"), ";"));
defaultShortcuts.insert("ActionToggleFunction", Shortcut(tr("Actions -> Toggle Function"), "Shift+F"));
defaultShortcuts.insert("ActionAssemble", Shortcut(tr("Actions -> Assemble"), "Space"));
defaultShortcuts.insert("ActionYara", Shortcut(tr("Actions -> Yara"), "Ctrl+Y"));
defaultShortcuts.insert("ActionSetNewOriginHere", Shortcut(tr("Actions -> Set New Origin Here"), "Ctrl+*"));
defaultShortcuts.insert("ActionGotoOrigin", Shortcut(tr("Actions -> Goto Origin"), "*"));
defaultShortcuts.insert("ActionGotoPrevious", Shortcut(tr("Actions -> Goto Previous"), "-"));
defaultShortcuts.insert("ActionGotoNext", Shortcut(tr("Actions -> Goto Next"), "+"));
defaultShortcuts.insert("ActionGotoExpression", Shortcut(tr("Actions -> Goto Expression"), "Ctrl+G"));
defaultShortcuts.insert("ActionFindReferencesToSelectedAddress", Shortcut(tr("Actions -> Find References to Selected Address"), "Ctrl+R"));
defaultShortcuts.insert("ActionFindPattern", Shortcut(tr("Actions -> Find Pattern"), "Ctrl+B"));
defaultShortcuts.insert("ActionFindReferences", Shortcut(tr("Actions -> Find References"), "Ctrl+R"));
defaultShortcuts.insert("ActionHighlightingMode", Shortcut(tr("Actions -> Highlighting Mode"), "Ctrl+H"));
defaultShortcuts.insert("ActionFind", Shortcut(tr("Actions -> Find"), "Ctrl+F"));
defaultShortcuts.insert("ActionIncreaseRegister", Shortcut(tr("Actions -> Increase Register"), "+"));
defaultShortcuts.insert("ActionDecreaseRegister", Shortcut(tr("Actions -> Decrease Register"), "-"));
defaultShortcuts.insert("ActionZeroRegister", Shortcut(tr("Actions -> Zero Register"), "0"));
defaultShortcuts.insert("ActionSetOneRegister", Shortcut(tr("Actions -> Set Register to One"), "1"));
defaultShortcuts.insert("ActionToggleRegisterValue", Shortcut(tr("Actions -> Toggle Register Value"), "Space"));
defaultShortcuts.insert("ActionCopy", Shortcut(tr("Actions -> Copy"), "Ctrl+C"));
defaultShortcuts.insert("ActionCopyAddress", Shortcut(tr("Actions -> Copy Address"), "Alt+INS"));
defaultShortcuts.insert("ActionCopySymbol", Shortcut(tr("Actions -> Copy Symbol"), "Ctrl+S"));
defaultShortcuts.insert("ActionLoadScript", Shortcut(tr("Actions -> Load Script"), "Ctrl+O"));
defaultShortcuts.insert("ActionReloadScript", Shortcut(tr("Actions -> Reload Script"), "Ctrl+R"));
defaultShortcuts.insert("ActionUnloadScript", Shortcut(tr("Actions -> Unload Script"), "Ctrl+U"));
defaultShortcuts.insert("ActionRunScript", Shortcut(tr("Actions -> Run Script"), "Space"));
defaultShortcuts.insert("ActionToggleBreakpointScript", Shortcut(tr("Actions -> Toggle Script Breakpoint"), "F2"));
defaultShortcuts.insert("ActionRunToCursorScript", Shortcut(tr("Actions -> Run Script to Cursor"), "Shift+F4"));
defaultShortcuts.insert("ActionStepScript", Shortcut(tr("Actions -> Step Script"), "Tab"));
defaultShortcuts.insert("ActionAbortScript", Shortcut(tr("Actions -> Abort Script"), "Esc"));
defaultShortcuts.insert("ActionExecuteCommandScript", Shortcut(tr("Actions -> Execute Script Command"), "X"));
Shortcuts = defaultShortcuts;
load();
mPtr = this;
}
namespace Ms {
#ifdef OMR
extern Score::FileError importPdf(Score*, const QString&);
#endif
extern Score::FileError importBB(Score*, const QString&);
extern Score::FileError importCapella(Score*, const QString&);
extern Score::FileError importCapXml(Score*, const QString&);
extern Score::FileError importCompressedMusicXml(Score*, const QString&);
extern Score::FileError importMusicXml(Score*, const QString&);
extern Score::FileError importGTP(Score*, const QString&);
extern bool saveXml(Score*, const QString&);
bool debugMode = false;
QString revision;
bool enableTestMode;
Score* score;
MuseScoreCore* mscoreCore;
MasterSynthesizer* synti;
QString dataPath;
QIcon* icons[0];
Shortcut Shortcut::sc[1] = { Shortcut() };
//---------------------------------------------------------
// Preferences
//---------------------------------------------------------
Preferences preferences;
Preferences::Preferences()
{
}
//---------------------------------------------------------
// writeReadElement
// writes and element and reads it back
//---------------------------------------------------------
Element* MTest::writeReadElement(Element* element)
{
//
// write element
//
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
Xml xml(&buffer);
xml.header();
element->write(xml);
buffer.close();
//
// read element
//
// printf("===read <%s>===\n", element->name());
// printf("%s\n", buffer.buffer().data());
XmlReader e(buffer.buffer());
e.readNextStartElement();
QString tag(e.name().toString());
// printf("read tag %s\n", qPrintable(tag));
element = Element::name2Element(e.name(), score);
element->read(e);
return element;
}
//---------------------------------------------------------
// MTest
//---------------------------------------------------------
MTest::MTest()
{
MScore::testMode = true;
}
//---------------------------------------------------------
// readScore
//---------------------------------------------------------
Score* MTest::readScore(const QString& name)
{
QString path = root + "/" + name;
return readCreatedScore(path);
}
//---------------------------------------------------------
// readCreatedScore
//---------------------------------------------------------
Score* MTest::readCreatedScore(const QString& name)
{
Score* score = new Score(mscore->baseStyle());
score->setName(name);
// MScore::testMode = true;
QString csl = score->fileInfo()->suffix().toLower();
Score::FileError rv;
if (csl == "cap")
rv = importCapella(score, name);
else if (csl == "capx")
rv = importCapXml(score, name);
else if (csl == "sgu")
rv = importBB(score, name);
else if (csl == "mscz" || csl == "mscx")
rv = score->loadMsc(name, false);
else if (csl == "mxl")
rv = importCompressedMusicXml(score, name);
#ifdef OMR
else if (csl == "pdf")
rv = importPdf(score, name);
#endif
else if (csl == "xml")
rv = importMusicXml(score, name);
else if (csl == "gp3" || csl == "gp4" || csl == "gp5")
rv = importGTP(score, name);
else
rv = Score::FileError::FILE_UNKNOWN_TYPE;
if (rv != Score::FileError::FILE_NO_ERROR) {
QWARN(qPrintable(QString("readScore: cannot load <%1> type <%2>\n").arg(name).arg(csl)));
delete score;
return 0;
}
score->updateNotes();
for (Excerpt* e : score->excerpts())
e->score()->updateNotes();
return score;
}
//---------------------------------------------------------
// saveScore
//---------------------------------------------------------
bool MTest::saveScore(Score* score, const QString& name)
{
QFileInfo fi(name);
// MScore::testMode = true;
return score->saveFile(fi);
}
//---------------------------------------------------------
// compareFiles
//---------------------------------------------------------
bool MTest::compareFiles(const QString& saveName, const QString& compareWith)
{
QString cmd = "diff";
QStringList args;
args.append("-u");
args.append(saveName);
args.append(root + "/" + compareWith);
QProcess p;
p.start(cmd, args);
if (!p.waitForFinished())
return false;
if (p.exitCode()) {
QByteArray ba = p.readAll();
qDebug("%s", qPrintable(ba));
qDebug(" <diff -u %s %s failed", qPrintable(saveName),
qPrintable(QString(root + "/" + compareWith)));
return false;
}
return true;
}
//---------------------------------------------------------
// saveCompareScore
//---------------------------------------------------------
bool MTest::saveCompareScore(Score* score, const QString& saveName, const QString& compareWith)
{
saveScore(score, saveName);
return compareFiles(saveName, compareWith);
}
//---------------------------------------------------------
// saveCompareMusicXMLScore
//---------------------------------------------------------
bool MTest::saveCompareMusicXmlScore(Score* score, const QString& saveName, const QString& compareWith)
{
saveMusicXml(score, saveName);
return compareFiles(saveName, compareWith);
}
//---------------------------------------------------------
// savePdf
//---------------------------------------------------------
bool MTest::savePdf(Score* cs, const QString& saveName)
{
QPrinter printerDev(QPrinter::HighResolution);
const PageFormat* pf = cs->pageFormat();
printerDev.setPaperSize(pf->size(), QPrinter::Inch);
printerDev.setCreator("MuseScore Version: " VERSION);
printerDev.setFullPage(true);
printerDev.setColorMode(QPrinter::Color);
printerDev.setDocName(cs->name());
printerDev.setDoubleSidedPrinting(pf->twosided());
printerDev.setOutputFormat(QPrinter::PdfFormat);
printerDev.setOutputFileName(saveName);
QPainter p(&printerDev);
p.setRenderHint(QPainter::Antialiasing, true);
p.setRenderHint(QPainter::TextAntialiasing, true);
double mag = printerDev.logicalDpiX() / MScore::DPI;
p.scale(mag, mag);
const QList<Page*> pl = cs->pages();
int pages = pl.size();
int offset = cs->pageNumberOffset();
int fromPage = printerDev.fromPage() - 1 - offset;
int toPage = printerDev.toPage() - 1 - offset;
if (fromPage < 0)
fromPage = 0;
if ((toPage < 0) || (toPage >= pages))
toPage = pages - 1;
for (int copy = 0; copy < printerDev.numCopies(); ++copy) {
bool firstPage = true;
for (int n = fromPage; n <= toPage; ++n) {
if (!firstPage)
printerDev.newPage();
firstPage = false;
cs->print(&p, n);
if ((copy + 1) < printerDev.numCopies())
printerDev.newPage();
}
}
p.end();
return true;
}
//---------------------------------------------------------
// saveMusicXml
//---------------------------------------------------------
bool MTest::saveMusicXml(Score* score, const QString& saveName)
{
return saveXml(score, saveName);
}
//---------------------------------------------------------
// initMTest
//---------------------------------------------------------
void MTest::initMTest()
{
MScore::DPI = 120;
MScore::PDPI = 120;
MScore::DPMM = MScore::DPI / INCH;
MScore::noGui = true;
synti = new MasterSynthesizer();
mscore = new MScore;
mscore->init();
preferences.shortestNote = MScore::division / 4; // midi quantization: 1/16
root = TESTROOT "/mtest";
loadInstrumentTemplates(":/instruments.xml");
score = readScore("/test.mscx");
}
}
