2013-11-29 18:29:41 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
2019-06-18 15:18:09 +00:00
|
|
|
* Copyright (C) 2013 Wayne Stambaugh <stambaughw@gmail.com>
|
2019-05-10 12:21:08 +00:00
|
|
|
* Copyright (C) 2004-2019 KiCad Developers, see change_log.txt for contributors.
|
2019-03-11 21:32:05 +00:00
|
|
|
* Copyright (C) 2018 CERN
|
2013-11-29 18:29:41 +00:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @file validators.cpp
|
|
|
|
* @brief Custom text control validator implementations.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <kicad_string.h>
|
2019-03-11 21:32:05 +00:00
|
|
|
#include <confirm.h>
|
2013-11-29 18:29:41 +00:00
|
|
|
#include <validators.h>
|
|
|
|
|
2018-03-07 12:48:08 +00:00
|
|
|
#include <wx/grid.h>
|
|
|
|
#include <wx/textctrl.h>
|
2015-08-17 00:30:29 +00:00
|
|
|
#include <wx/textentry.h>
|
|
|
|
#include <wx/log.h>
|
2020-06-08 18:36:25 +00:00
|
|
|
#include <wx/combo.h>
|
2013-11-29 18:29:41 +00:00
|
|
|
|
2018-03-07 12:48:08 +00:00
|
|
|
GRID_CELL_TEXT_EDITOR::GRID_CELL_TEXT_EDITOR() : wxGridCellTextEditor()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-07-21 20:23:13 +00:00
|
|
|
void GRID_CELL_TEXT_EDITOR::SetValidator( const wxValidator& validator )
|
2018-03-07 12:48:08 +00:00
|
|
|
{
|
|
|
|
// keep our own copy because wxGridCellTextEditor's is annoyingly private
|
|
|
|
m_validator.reset( static_cast<wxValidator*>( validator.Clone() ) );
|
|
|
|
|
2018-07-21 20:23:13 +00:00
|
|
|
wxGridCellTextEditor::SetValidator( *m_validator );
|
2018-03-07 12:48:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void GRID_CELL_TEXT_EDITOR::StartingKey( wxKeyEvent& event )
|
|
|
|
{
|
|
|
|
if( m_validator )
|
|
|
|
{
|
|
|
|
m_validator.get()->SetWindow( Text() );
|
|
|
|
m_validator.get()->ProcessEvent( event );
|
|
|
|
}
|
|
|
|
|
2018-07-21 20:23:13 +00:00
|
|
|
if( event.GetSkipped() )
|
|
|
|
{
|
2018-03-07 12:48:08 +00:00
|
|
|
wxGridCellTextEditor::StartingKey( event );
|
2018-07-21 20:23:13 +00:00
|
|
|
event.Skip( false );
|
|
|
|
}
|
2018-03-07 12:48:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-11-10 21:20:03 +00:00
|
|
|
FOOTPRINT_NAME_VALIDATOR::FOOTPRINT_NAME_VALIDATOR( wxString* aValue ) :
|
2013-11-29 18:29:41 +00:00
|
|
|
wxTextValidator( wxFILTER_EXCLUDE_CHAR_LIST, aValue )
|
|
|
|
{
|
2020-11-13 11:17:15 +00:00
|
|
|
// This list of characters follows the string from footprint.cpp which, in turn mimics the
|
|
|
|
// strings from lib_id.cpp
|
2019-06-29 20:31:11 +00:00
|
|
|
// TODO: Unify forbidden character lists
|
|
|
|
wxString illegalChars = "%$<>\t\n\r\"\\/:";
|
|
|
|
SetCharExcludes( illegalChars );
|
2014-12-11 12:00:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
FILE_NAME_WITH_PATH_CHAR_VALIDATOR::FILE_NAME_WITH_PATH_CHAR_VALIDATOR( wxString* aValue ) :
|
2015-08-17 00:30:29 +00:00
|
|
|
wxTextValidator( wxFILTER_EXCLUDE_CHAR_LIST | wxFILTER_EMPTY, aValue )
|
2014-12-11 12:00:59 +00:00
|
|
|
{
|
|
|
|
// The Windows (DOS) file system forbidden characters already include the forbidden
|
|
|
|
// file name characters for both Posix and OSX systems. The characters *?|"<> are
|
|
|
|
// illegal and filtered by the validator, but /\: are valid (\ and : only on Windows.
|
2015-08-17 00:30:29 +00:00
|
|
|
wxString illegalChars = wxFileName::GetForbiddenChars( wxPATH_DOS );
|
2014-12-11 12:00:59 +00:00
|
|
|
wxTextValidator nameValidator( wxFILTER_EXCLUDE_CHAR_LIST );
|
|
|
|
wxArrayString illegalCharList;
|
|
|
|
|
|
|
|
for( unsigned i = 0; i < illegalChars.size(); i++ )
|
|
|
|
{
|
|
|
|
if( illegalChars[i] == '/' )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
#if defined (__WINDOWS__)
|
|
|
|
if( illegalChars[i] == '\\' || illegalChars[i] == ':' )
|
|
|
|
continue;
|
|
|
|
#endif
|
|
|
|
illegalCharList.Add( wxString( illegalChars[i] ) );
|
|
|
|
}
|
|
|
|
|
2013-11-29 18:29:41 +00:00
|
|
|
SetExcludes( illegalCharList );
|
|
|
|
}
|
2015-03-29 21:22:53 +00:00
|
|
|
|
|
|
|
|
2018-03-07 12:48:08 +00:00
|
|
|
ENV_VAR_NAME_VALIDATOR::ENV_VAR_NAME_VALIDATOR( wxString* aValue ) :
|
|
|
|
wxTextValidator()
|
2015-03-29 21:22:53 +00:00
|
|
|
{
|
2018-03-07 12:48:08 +00:00
|
|
|
Connect( wxEVT_CHAR, wxKeyEventHandler( ENV_VAR_NAME_VALIDATOR::OnChar ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ENV_VAR_NAME_VALIDATOR::ENV_VAR_NAME_VALIDATOR( const ENV_VAR_NAME_VALIDATOR& val )
|
|
|
|
: wxTextValidator()
|
|
|
|
{
|
|
|
|
wxValidator::Copy( val );
|
|
|
|
|
|
|
|
Connect( wxEVT_CHAR, wxKeyEventHandler( ENV_VAR_NAME_VALIDATOR::OnChar ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ENV_VAR_NAME_VALIDATOR::~ENV_VAR_NAME_VALIDATOR()
|
|
|
|
{
|
|
|
|
Disconnect( wxEVT_CHAR, wxKeyEventHandler( ENV_VAR_NAME_VALIDATOR::OnChar ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void ENV_VAR_NAME_VALIDATOR::OnChar( wxKeyEvent& aEvent )
|
|
|
|
{
|
2019-05-10 12:21:08 +00:00
|
|
|
if( !m_validatorWindow )
|
2018-03-07 12:48:08 +00:00
|
|
|
{
|
|
|
|
aEvent.Skip();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int keyCode = aEvent.GetKeyCode();
|
|
|
|
|
|
|
|
// we don't filter special keys and delete
|
2019-05-10 12:21:08 +00:00
|
|
|
if( keyCode < WXK_SPACE || keyCode == WXK_DELETE || keyCode >= WXK_START )
|
2018-03-07 12:48:08 +00:00
|
|
|
{
|
|
|
|
aEvent.Skip();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
wxUniChar c = (wxUChar) keyCode;
|
|
|
|
|
|
|
|
if( c == wxT( '_' ) )
|
|
|
|
{
|
|
|
|
// OK anywhere
|
|
|
|
aEvent.Skip();
|
|
|
|
}
|
|
|
|
else if( wxIsdigit( c ) )
|
|
|
|
{
|
|
|
|
// not as first character
|
|
|
|
long from, to;
|
|
|
|
GetTextEntry()->GetSelection( &from, &to );
|
2019-05-10 12:21:08 +00:00
|
|
|
|
2018-03-07 12:48:08 +00:00
|
|
|
if( from < 1 )
|
|
|
|
wxBell();
|
|
|
|
else
|
|
|
|
aEvent.Skip();
|
|
|
|
}
|
|
|
|
else if( wxIsalpha( c ) )
|
|
|
|
{
|
|
|
|
// Capitals only.
|
2018-10-22 13:03:55 +00:00
|
|
|
|
|
|
|
if( wxIslower( c ) )
|
|
|
|
{
|
|
|
|
// You may wonder why this scope is so twisted, so make yourself comfortable and read:
|
|
|
|
// 1. Changing the keyCode and/or uniChar in the event and passing it on
|
|
|
|
// doesn't work. Some platforms look at the original copy as long as the event
|
|
|
|
// isn't vetoed.
|
|
|
|
// 2. Inserting characters by hand does not move the cursor, meaning either you insert
|
|
|
|
// text backwards (lp:#1798869) or always append, no matter where is the cursor.
|
|
|
|
// wxTextEntry::{Get/Set}InsertionPoint() do not work at all here.
|
|
|
|
// 3. There is wxTextEntry::ForceUpper(), but it is not yet available in common
|
|
|
|
// wxWidgets packages.
|
|
|
|
//
|
|
|
|
// So here we are, with a command event handler that converts
|
|
|
|
// the text to upper case upon every change.
|
|
|
|
wxTextCtrl* textCtrl = dynamic_cast<wxTextCtrl*>( GetTextEntry() );
|
|
|
|
|
|
|
|
if( textCtrl )
|
|
|
|
{
|
|
|
|
textCtrl->Connect( textCtrl->GetId(), wxEVT_COMMAND_TEXT_UPDATED,
|
2020-01-09 18:01:54 +00:00
|
|
|
wxCommandEventHandler( ENV_VAR_NAME_VALIDATOR::OnTextChanged ) );
|
2018-10-22 13:03:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
aEvent.Skip();
|
2018-03-07 12:48:08 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
wxBell();
|
|
|
|
}
|
2015-03-29 21:22:53 +00:00
|
|
|
}
|
2018-10-22 13:03:55 +00:00
|
|
|
|
|
|
|
|
|
|
|
void ENV_VAR_NAME_VALIDATOR::OnTextChanged( wxCommandEvent& event )
|
|
|
|
{
|
|
|
|
wxTextCtrl* textCtrl = dynamic_cast<wxTextCtrl*>( event.GetEventObject() );
|
|
|
|
|
|
|
|
if( textCtrl )
|
|
|
|
{
|
|
|
|
if( !textCtrl->IsModified() )
|
|
|
|
return;
|
|
|
|
|
|
|
|
long insertionPoint = textCtrl->GetInsertionPoint();
|
|
|
|
textCtrl->ChangeValue( textCtrl->GetValue().Upper() );
|
|
|
|
textCtrl->SetInsertionPoint( insertionPoint );
|
|
|
|
textCtrl->Disconnect( textCtrl->GetId(), wxEVT_COMMAND_TEXT_UPDATED );
|
|
|
|
}
|
|
|
|
|
|
|
|
event.Skip();
|
|
|
|
}
|
2019-03-07 16:21:49 +00:00
|
|
|
|
|
|
|
|
2019-03-11 21:32:05 +00:00
|
|
|
bool REGEX_VALIDATOR::Validate( wxWindow* aParent )
|
|
|
|
{
|
|
|
|
// If window is disabled, simply return
|
|
|
|
if( !m_validatorWindow->IsEnabled() )
|
|
|
|
return true;
|
|
|
|
|
|
|
|
wxTextEntry* const textEntry = GetTextEntry();
|
|
|
|
|
|
|
|
if( !textEntry )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
bool valid = true;
|
|
|
|
const wxString& value = textEntry->GetValue();
|
|
|
|
|
|
|
|
if( m_regEx.Matches( value ) )
|
|
|
|
{
|
|
|
|
size_t start, len;
|
|
|
|
m_regEx.GetMatch( &start, &len );
|
|
|
|
|
|
|
|
if( start != 0 || len != value.Length() ) // whole string must match
|
|
|
|
valid = false;
|
|
|
|
}
|
|
|
|
else // no match at all
|
|
|
|
{
|
|
|
|
valid = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( !valid )
|
|
|
|
{
|
|
|
|
m_validatorWindow->SetFocus();
|
|
|
|
DisplayError( aParent, wxString::Format( _( "Incorrect value: %s" ), value ) );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void REGEX_VALIDATOR::compileRegEx( const wxString& aRegEx, int aFlags )
|
|
|
|
{
|
|
|
|
if( !m_regEx.Compile( aRegEx, aFlags ) )
|
|
|
|
{
|
|
|
|
throw std::runtime_error( "REGEX_VALIDATOR: Invalid regular expression: "
|
|
|
|
+ aRegEx.ToStdString() );
|
|
|
|
}
|
|
|
|
|
|
|
|
m_regExString = aRegEx;
|
|
|
|
m_regExFlags = aFlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-10 12:21:08 +00:00
|
|
|
bool LIB_ID_VALIDATOR::Validate( wxWindow *aParent )
|
|
|
|
{
|
|
|
|
LIB_ID dummy;
|
|
|
|
|
|
|
|
// If window is disabled, simply return
|
|
|
|
if( !m_validatorWindow->IsEnabled() )
|
|
|
|
return true;
|
|
|
|
|
|
|
|
wxTextEntry* const text = GetTextEntry();
|
|
|
|
|
|
|
|
if( !text )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
wxString msg;
|
|
|
|
wxString val( text->GetValue() );
|
|
|
|
wxString tmp = val.Clone(); // For trailing and leading white space tests.
|
|
|
|
|
2019-06-18 15:18:09 +00:00
|
|
|
// Allow empty string if empty filter not set to allow clearing the LIB_ID.
|
|
|
|
if( !(GetStyle() & wxFILTER_EMPTY) && val.IsEmpty() )
|
|
|
|
return true;
|
|
|
|
|
2019-05-10 12:21:08 +00:00
|
|
|
if( tmp.Trim() != val ) // Trailing white space.
|
|
|
|
{
|
|
|
|
msg = _( "Entry contains trailing white space." );
|
|
|
|
}
|
|
|
|
else if( tmp.Trim( false ) != val ) // Leading white space.
|
|
|
|
{
|
|
|
|
msg = _( "Entry contains leading white space." );
|
|
|
|
}
|
2020-12-17 23:32:23 +00:00
|
|
|
else if( dummy.Parse( val ) != -1 || !dummy.IsValid() ) // Is valid LIB_ID.
|
2019-05-10 12:21:08 +00:00
|
|
|
{
|
2021-06-27 23:26:54 +00:00
|
|
|
msg.Printf( _( "'%s' is not a valid library identifier format." ), val );
|
2019-05-10 12:21:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if( !msg.empty() )
|
|
|
|
{
|
|
|
|
m_validatorWindow->SetFocus();
|
|
|
|
|
|
|
|
wxMessageBox( msg, _( "Library Identifier Validation Error" ),
|
|
|
|
wxOK | wxICON_EXCLAMATION, aParent );
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-08 18:36:25 +00:00
|
|
|
NETNAME_VALIDATOR::NETNAME_VALIDATOR( wxString *aVal ) :
|
2020-11-08 00:33:15 +00:00
|
|
|
wxTextValidator(),
|
|
|
|
m_allowSpaces( false )
|
2020-06-08 18:36:25 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NETNAME_VALIDATOR::NETNAME_VALIDATOR( const NETNAME_VALIDATOR& aValidator ) :
|
2020-11-08 00:33:15 +00:00
|
|
|
wxTextValidator( aValidator ),
|
|
|
|
m_allowSpaces( aValidator.m_allowSpaces )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NETNAME_VALIDATOR::NETNAME_VALIDATOR( bool aAllowSpaces ) :
|
|
|
|
wxTextValidator(),
|
|
|
|
m_allowSpaces( aAllowSpaces )
|
2020-06-08 18:36:25 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool NETNAME_VALIDATOR::Validate( wxWindow *aParent )
|
|
|
|
{
|
|
|
|
// If window is disabled, simply return
|
|
|
|
if ( !m_validatorWindow->IsEnabled() )
|
|
|
|
return true;
|
|
|
|
|
|
|
|
wxTextEntry * const text = GetTextEntry();
|
|
|
|
|
|
|
|
if ( !text )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
const wxString& errormsg = IsValid( text->GetValue() );
|
|
|
|
|
|
|
|
if( !errormsg.empty() )
|
|
|
|
{
|
|
|
|
m_validatorWindow->SetFocus();
|
|
|
|
wxMessageBox( errormsg, _( "Invalid signal name" ), wxOK | wxICON_EXCLAMATION, aParent );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
wxString NETNAME_VALIDATOR::IsValid( const wxString& str ) const
|
|
|
|
{
|
|
|
|
if( str.Contains( '\r' ) || str.Contains( '\n' ) )
|
|
|
|
return _( "Signal names cannot contain CR or LF characters" );
|
|
|
|
|
2020-11-08 00:33:15 +00:00
|
|
|
if( !m_allowSpaces && ( str.Contains( ' ' ) || str.Contains( '\t' ) ) )
|
2020-06-08 18:36:25 +00:00
|
|
|
return _( "Signal names cannot contain spaces" );
|
|
|
|
|
|
|
|
return wxString();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-03-07 16:21:49 +00:00
|
|
|
void KIUI::ValidatorTransferToWindowWithoutEvents( wxValidator& aValidator )
|
|
|
|
{
|
|
|
|
wxWindow* ctrl = aValidator.GetWindow();
|
|
|
|
|
|
|
|
wxCHECK_RET( ctrl != nullptr, "Transferring validator data without a control" );
|
|
|
|
|
|
|
|
wxEventBlocker orient_update_blocker( ctrl, wxEVT_ANY );
|
|
|
|
aValidator.TransferToWindow();
|
2019-03-11 21:32:05 +00:00
|
|
|
}
|