479 lines
16 KiB
C++
479 lines
16 KiB
C++
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2018 Jean-Pierre Charras, jp.charras at wanadoo.fr
|
|
* Copyright (C) 2010 Wayne Stambaugh <stambaughw@gmail.com>
|
|
* Copyright (C) 1992-2021 KiCad Developers, see AUTHORS.txt for contributors.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, you may find one here:
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <kiface_base.h>
|
|
#include <hotkeys_basic.h>
|
|
#include <id.h>
|
|
#include <string_utils.h>
|
|
#include <eda_base_frame.h>
|
|
#include <eda_draw_frame.h>
|
|
#include <wildcards_and_files_ext.h>
|
|
#include <settings/settings_manager.h>
|
|
|
|
#include <tool/tool_manager.h>
|
|
#include "dialogs/dialog_hotkey_list.h"
|
|
#include <wx/apptrait.h>
|
|
#include <wx/stdpaths.h>
|
|
#include <wx/tokenzr.h>
|
|
#include <wx/txtstrm.h>
|
|
#include <wx/wfstream.h>
|
|
#include <tool/tool_action.h>
|
|
|
|
|
|
/*
|
|
* class to handle the printable name and the keycode
|
|
*/
|
|
struct hotkey_name_descr
|
|
{
|
|
const wxChar* m_Name;
|
|
int m_KeyCode;
|
|
};
|
|
|
|
|
|
/* table giving the hotkey name from the hotkey code, for special keys
|
|
* Note : when modifiers (ATL, SHIFT, CTRL) do not modify
|
|
* the code of the key, do need to enter the modified key code
|
|
* For instance wxT( "F1" ), WXK_F1 handle F1, AltF1, CtrlF1 ...
|
|
* Key names are:
|
|
* "Space","Ctrl+Space","Alt+Space" or
|
|
* "Alt+A","Ctrl+F1", ...
|
|
*/
|
|
#define KEY_NON_FOUND -1
|
|
static struct hotkey_name_descr hotkeyNameList[] =
|
|
{
|
|
{ wxT( "F1" ), WXK_F1 },
|
|
{ wxT( "F2" ), WXK_F2 },
|
|
{ wxT( "F3" ), WXK_F3 },
|
|
{ wxT( "F4" ), WXK_F4 },
|
|
{ wxT( "F5" ), WXK_F5 },
|
|
{ wxT( "F6" ), WXK_F6 },
|
|
{ wxT( "F7" ), WXK_F7 },
|
|
{ wxT( "F8" ), WXK_F8 },
|
|
{ wxT( "F9" ), WXK_F9 },
|
|
{ wxT( "F10" ), WXK_F10 },
|
|
{ wxT( "F11" ), WXK_F11 },
|
|
{ wxT( "F12" ), WXK_F12 },
|
|
|
|
{ wxT( "Esc" ), WXK_ESCAPE },
|
|
{ wxT( "Del" ), WXK_DELETE },
|
|
{ wxT( "Tab" ), WXK_TAB },
|
|
{ wxT( "Back" ), WXK_BACK },
|
|
{ wxT( "Ins" ), WXK_INSERT },
|
|
|
|
{ wxT( "Home" ), WXK_HOME },
|
|
{ wxT( "End" ), WXK_END },
|
|
{ wxT( "PgUp" ), WXK_PAGEUP },
|
|
{ wxT( "PgDn" ), WXK_PAGEDOWN },
|
|
|
|
{ wxT( "Up" ), WXK_UP },
|
|
{ wxT( "Down" ), WXK_DOWN },
|
|
{ wxT( "Left" ), WXK_LEFT },
|
|
{ wxT( "Right" ), WXK_RIGHT },
|
|
|
|
{ wxT( "Return" ), WXK_RETURN },
|
|
|
|
{ wxT( "Space" ), WXK_SPACE },
|
|
|
|
{ wxT( "Num Pad 0" ), WXK_NUMPAD0 },
|
|
{ wxT( "Num Pad 1" ), WXK_NUMPAD1 },
|
|
{ wxT( "Num Pad 2" ), WXK_NUMPAD2 },
|
|
{ wxT( "Num Pad 3" ), WXK_NUMPAD3 },
|
|
{ wxT( "Num Pad 4" ), WXK_NUMPAD4 },
|
|
{ wxT( "Num Pad 5" ), WXK_NUMPAD5 },
|
|
{ wxT( "Num Pad 6" ), WXK_NUMPAD6 },
|
|
{ wxT( "Num Pad 7" ), WXK_NUMPAD7 },
|
|
{ wxT( "Num Pad 8" ), WXK_NUMPAD8 },
|
|
{ wxT( "Num Pad 9" ), WXK_NUMPAD9 },
|
|
{ wxT( "Num Pad +" ), WXK_NUMPAD_ADD },
|
|
{ wxT( "Num Pad -" ), WXK_NUMPAD_SUBTRACT },
|
|
{ wxT( "Num Pad *" ), WXK_NUMPAD_MULTIPLY },
|
|
{ wxT( "Num Pad /" ), WXK_NUMPAD_DIVIDE },
|
|
{ wxT( "Num Pad ." ), WXK_NUMPAD_SEPARATOR },
|
|
|
|
{ wxEmptyString, 0 },
|
|
|
|
{ wxT( "Click" ), PSEUDO_WXK_CLICK },
|
|
{ wxT( "DblClick" ), PSEUDO_WXK_DBLCLICK },
|
|
{ wxT( "Wheel" ), PSEUDO_WXK_WHEEL },
|
|
|
|
// Do not change this line: end of list
|
|
{ wxEmptyString, KEY_NON_FOUND }
|
|
};
|
|
|
|
|
|
// name of modifier keys.
|
|
// Note: the Ctrl key is Cmd key on Mac OS X.
|
|
// However, in wxWidgets defs, the key WXK_CONTROL is the Cmd key,
|
|
// so the code using WXK_CONTROL should be ok on any system.
|
|
// (on Mac OS X the actual Ctrl key code is WXK_RAW_CONTROL)
|
|
#ifdef __WXMAC__
|
|
#define USING_MAC_CMD
|
|
#endif
|
|
|
|
#ifdef USING_MAC_CMD
|
|
#define MODIFIER_CTRL wxT( "Cmd+" )
|
|
#define MODIFIER_ALT wxT( "Option+" )
|
|
#else
|
|
#define MODIFIER_CTRL wxT( "Ctrl+" )
|
|
#define MODIFIER_ALT wxT( "Alt+" )
|
|
#endif
|
|
#define MODIFIER_CMD_MAC wxT( "Cmd+" )
|
|
#define MODIFIER_CTRL_BASE wxT( "Ctrl+" )
|
|
#define MODIFIER_SHIFT wxT( "Shift+" )
|
|
|
|
|
|
/**
|
|
* Return the key name from the key code.
|
|
*
|
|
* Only some wxWidgets key values are handled for function key ( see hotkeyNameList[] )
|
|
*
|
|
* @param aKeycode key code (ASCII value, or wxWidgets value for function keys).
|
|
* @param aIsFound a pointer to a bool to return true if found, or false. an be nullptr default).
|
|
* @return the key name in a wxString.
|
|
*/
|
|
wxString KeyNameFromKeyCode( int aKeycode, bool* aIsFound )
|
|
{
|
|
wxString keyname, modifier, fullkeyname;
|
|
int ii;
|
|
bool found = false;
|
|
|
|
// Assume keycode of 0 is "unassigned"
|
|
if( (aKeycode & MD_CTRL) != 0 )
|
|
modifier << MODIFIER_CTRL;
|
|
|
|
if( (aKeycode & MD_ALT) != 0 )
|
|
modifier << MODIFIER_ALT;
|
|
|
|
if( (aKeycode & MD_SHIFT) != 0 )
|
|
modifier << MODIFIER_SHIFT;
|
|
|
|
aKeycode &= ~( MD_CTRL | MD_ALT | MD_SHIFT );
|
|
|
|
if( (aKeycode > ' ') && (aKeycode < 0x7F ) )
|
|
{
|
|
found = true;
|
|
keyname.Append( (wxChar)aKeycode );
|
|
}
|
|
else
|
|
{
|
|
for( ii = 0; ; ii++ )
|
|
{
|
|
if( hotkeyNameList[ii].m_KeyCode == KEY_NON_FOUND ) // End of list
|
|
{
|
|
keyname = wxT( "<unknown>" );
|
|
break;
|
|
}
|
|
|
|
if( hotkeyNameList[ii].m_KeyCode == aKeycode )
|
|
{
|
|
keyname = hotkeyNameList[ii].m_Name;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( aIsFound )
|
|
*aIsFound = found;
|
|
|
|
fullkeyname = modifier + keyname;
|
|
return fullkeyname;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param aText the base text on which to append the hotkey.
|
|
* @param aHotKey the hotkey keycode.
|
|
* @param aStyle IS_HOTKEY to add <tab><keyname> (shortcuts in menus, same as hotkeys).
|
|
* IS_COMMENT to add <spaces><(keyname)> mainly in tool tips.
|
|
*/
|
|
wxString AddHotkeyName( const wxString& aText, int aHotKey, HOTKEY_ACTION_TYPE aStyle )
|
|
{
|
|
wxString msg = aText;
|
|
wxString keyname = KeyNameFromKeyCode( aHotKey );
|
|
|
|
if( !keyname.IsEmpty() )
|
|
{
|
|
switch( aStyle )
|
|
{
|
|
case IS_HOTKEY:
|
|
{
|
|
// Don't add a suffix for unassigned hotkeys:
|
|
// WX spews debug from wxAcceleratorEntry::ParseAccel if it doesn't
|
|
// recognize the keyname, which is the case for <unassigned>.
|
|
if( aHotKey != 0 )
|
|
{
|
|
msg << wxT( "\t" ) << keyname;
|
|
}
|
|
break;
|
|
}
|
|
case IS_COMMENT:
|
|
{
|
|
msg << wxT( " (" ) << keyname << wxT( ")" );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef USING_MAC_CMD
|
|
// On OSX, the modifier equivalent to the Ctrl key of PCs
|
|
// is the Cmd key, but in code we should use Ctrl as prefix in menus
|
|
msg.Replace( MODIFIER_CMD_MAC, MODIFIER_CTRL_BASE );
|
|
#endif
|
|
|
|
return msg;
|
|
}
|
|
|
|
|
|
/**
|
|
* Return the key code from its user-friendly key name (ie: "Ctrl+M").
|
|
*/
|
|
int KeyCodeFromKeyName( const wxString& keyname )
|
|
{
|
|
int ii, keycode = KEY_NON_FOUND;
|
|
|
|
// Search for modifiers: Ctrl+ Alt+ and Shift+
|
|
// Note: on Mac OSX, the Cmd key is equiv here to Ctrl
|
|
wxString key = keyname;
|
|
wxString prefix;
|
|
int modifier = 0;
|
|
|
|
while( true )
|
|
{
|
|
prefix.Empty();
|
|
|
|
if( key.StartsWith( MODIFIER_CTRL_BASE ) )
|
|
{
|
|
modifier |= MD_CTRL;
|
|
prefix = MODIFIER_CTRL_BASE;
|
|
}
|
|
else if( key.StartsWith( MODIFIER_CMD_MAC ) )
|
|
{
|
|
modifier |= MD_CTRL;
|
|
prefix = MODIFIER_CMD_MAC;
|
|
}
|
|
else if( key.StartsWith( MODIFIER_ALT ) )
|
|
{
|
|
modifier |= MD_ALT;
|
|
prefix = MODIFIER_ALT;
|
|
}
|
|
else if( key.StartsWith( MODIFIER_SHIFT ) )
|
|
{
|
|
modifier |= MD_SHIFT;
|
|
prefix = MODIFIER_SHIFT;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( !prefix.IsEmpty() )
|
|
key.Remove( 0, prefix.Len() );
|
|
}
|
|
|
|
if( (key.length() == 1) && (key[0] > ' ') && (key[0] < 0x7F) )
|
|
{
|
|
keycode = key[0];
|
|
keycode += modifier;
|
|
return keycode;
|
|
}
|
|
|
|
for( ii = 0; hotkeyNameList[ii].m_KeyCode != KEY_NON_FOUND; ii++ )
|
|
{
|
|
if( key.CmpNoCase( hotkeyNameList[ii].m_Name ) == 0 )
|
|
{
|
|
keycode = hotkeyNameList[ii].m_KeyCode + modifier;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return keycode;
|
|
}
|
|
|
|
|
|
/*
|
|
* Displays the hotkeys registered with the given tool manager.
|
|
*/
|
|
void DisplayHotkeyList( EDA_BASE_FRAME* aParent, TOOL_MANAGER* aToolManager )
|
|
{
|
|
DIALOG_LIST_HOTKEYS dlg( aParent, aToolManager );
|
|
dlg.ShowModal();
|
|
}
|
|
|
|
|
|
void ReadHotKeyConfig( const wxString& aFileName, std::map<std::string, int>& aHotKeys )
|
|
{
|
|
wxString fileName = aFileName;
|
|
|
|
if( fileName.IsEmpty() )
|
|
{
|
|
wxFileName fn( wxT( "user" ) );
|
|
fn.SetExt( HotkeyFileExtension );
|
|
fn.SetPath( SETTINGS_MANAGER::GetUserSettingsPath() );
|
|
fileName = fn.GetFullPath();
|
|
}
|
|
|
|
if( !wxFile::Exists( fileName ) )
|
|
return;
|
|
|
|
wxFFile file( fileName, wxT( "rb" ) );
|
|
|
|
if( !file.IsOpened() ) // There is a problem to open file
|
|
return;
|
|
|
|
wxString input;
|
|
file.ReadAll( &input );
|
|
input.Replace( wxT( "\r\n" ), wxT( "\n" ) ); // Convert Windows files to Unix line-ends
|
|
wxStringTokenizer fileTokenizer( input, wxT( "\n" ), wxTOKEN_STRTOK );
|
|
|
|
while( fileTokenizer.HasMoreTokens() )
|
|
{
|
|
wxStringTokenizer lineTokenizer( fileTokenizer.GetNextToken(), wxT( "\t" ) );
|
|
|
|
wxString cmdName = lineTokenizer.GetNextToken();
|
|
wxString keyName = lineTokenizer.GetNextToken();
|
|
|
|
if( !cmdName.IsEmpty() )
|
|
aHotKeys[ cmdName.ToStdString() ] = KeyCodeFromKeyName( keyName );
|
|
}
|
|
}
|
|
|
|
|
|
int WriteHotKeyConfig( const std::map<std::string, TOOL_ACTION*>& aActionMap )
|
|
{
|
|
std::map<std::string, int> hotkeys;
|
|
wxFileName fn( wxT( "user" ) );
|
|
|
|
fn.SetExt( HotkeyFileExtension );
|
|
fn.SetPath( SETTINGS_MANAGER::GetUserSettingsPath() );
|
|
|
|
// Read the existing config (all hotkeys)
|
|
ReadHotKeyConfig( fn.GetFullPath(), hotkeys );
|
|
|
|
// Overlay the current app's hotkey definitions onto the map
|
|
for( const auto& ii : aActionMap )
|
|
hotkeys[ ii.first ] = ii.second->GetHotKey();
|
|
|
|
// Write entire hotkey set
|
|
wxFFileOutputStream outStream( fn.GetFullPath() );
|
|
wxTextOutputStream txtStream( outStream, wxEOL_UNIX );
|
|
|
|
for( const auto& ii : hotkeys )
|
|
txtStream << wxString::Format( "%s\t%s", ii.first,
|
|
KeyNameFromKeyCode( ii.second ) ) << endl;
|
|
|
|
txtStream.Flush();
|
|
outStream.Close();
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
int ReadLegacyHotkeyConfig( const wxString& aAppname, std::map<std::string, int>& aMap )
|
|
{
|
|
// For Eeschema and Pcbnew frames, we read the new combined file.
|
|
// For other kifaces, we read the frame-based file
|
|
if( aAppname == LIB_EDIT_FRAME_NAME || aAppname == SCH_EDIT_FRAME_NAME )
|
|
{
|
|
return ReadLegacyHotkeyConfigFile( EESCHEMA_HOTKEY_NAME, aMap );
|
|
}
|
|
else if( aAppname == PCB_EDIT_FRAME_NAME || aAppname == FOOTPRINT_EDIT_FRAME_NAME )
|
|
{
|
|
return ReadLegacyHotkeyConfigFile( PCBNEW_HOTKEY_NAME, aMap );
|
|
}
|
|
|
|
return ReadLegacyHotkeyConfigFile( aAppname, aMap );
|
|
}
|
|
|
|
|
|
int ReadLegacyHotkeyConfigFile( const wxString& aFilename, std::map<std::string, int>& aMap )
|
|
{
|
|
wxFileName fn( aFilename );
|
|
|
|
fn.SetExt( HotkeyFileExtension );
|
|
fn.SetPath( SETTINGS_MANAGER::GetUserSettingsPath() );
|
|
|
|
if( !wxFile::Exists( fn.GetFullPath() ) )
|
|
return 0;
|
|
|
|
wxFFile cfgfile( fn.GetFullPath(), wxT( "rb" ) );
|
|
|
|
if( !cfgfile.IsOpened() ) // There is a problem to open file
|
|
return 0;
|
|
|
|
// get length
|
|
wxFileOffset size = cfgfile.Length();
|
|
|
|
// read data
|
|
std::vector<char> buffer( size );
|
|
cfgfile.Read( buffer.data(), size );
|
|
wxString data( buffer.data(), wxConvUTF8, size );
|
|
|
|
// Is this the wxConfig format? If so, remove "Keys=" and parse the newlines.
|
|
if( data.StartsWith( wxT("Keys="), &data ) )
|
|
data.Replace( wxT( "\\n" ), wxT( "\n" ), true );
|
|
|
|
// parse
|
|
wxStringTokenizer tokenizer( data, L"\r\n", wxTOKEN_STRTOK );
|
|
|
|
while( tokenizer.HasMoreTokens() )
|
|
{
|
|
wxString line = tokenizer.GetNextToken();
|
|
wxStringTokenizer lineTokenizer( line );
|
|
|
|
wxString line_type = lineTokenizer.GetNextToken();
|
|
|
|
if( line_type[0] == '#' ) // comment
|
|
continue;
|
|
|
|
if( line_type[0] == '[' ) // tags ignored reading legacy hotkeys
|
|
continue;
|
|
|
|
if( line_type == wxT( "$Endlist" ) )
|
|
break;
|
|
|
|
if( line_type != wxT( "shortcut" ) )
|
|
continue;
|
|
|
|
// Get the key name
|
|
lineTokenizer.SetString( lineTokenizer.GetString(), L"\"\r\n\t ", wxTOKEN_STRTOK );
|
|
wxString keyname = lineTokenizer.GetNextToken();
|
|
|
|
wxString remainder = lineTokenizer.GetString();
|
|
|
|
// Get the command name
|
|
wxString fctname = remainder.AfterFirst( '\"' ).BeforeFirst( '\"' );
|
|
|
|
// Add the pair to the map
|
|
aMap[ fctname.ToStdString() ] = KeyCodeFromKeyName( keyname );
|
|
}
|
|
|
|
// cleanup
|
|
cfgfile.Close();
|
|
return 1;
|
|
}
|
|
|
|
|