src/common/valtext.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/valtext.cpp
   3 // Purpose:     wxTextValidator
   4 // Author:      Julian Smart
   5 // Modified by: Francesco Montorsi
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16   #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_VALIDATORS && (wxUSE_TEXTCTRL || wxUSE_COMBOBOX)
  20
  21 #include "wx/valtext.h"
  22
  23 #ifndef WX_PRECOMP
  24   #include <stdio.h>
  25   #include "wx/textctrl.h"
  26   #include "wx/combobox.h"
  27   #include "wx/utils.h"
  28   #include "wx/msgdlg.h"
  29   #include "wx/intl.h"
  30 #endif
  31
  32 #include <ctype.h>
  33 #include <string.h>
  34 #include <stdlib.h>
  35
  36 // ----------------------------------------------------------------------------
  37 // global helpers
  38 // ----------------------------------------------------------------------------
  39
  40 static bool wxIsNumeric(const wxString& val)
  41 {
  42     for ( wxString::const_iterator i = val.begin(); i != val.end(); ++i )
  43     {
  44         // Allow for "," (French) as well as "." -- in future we should
  45         // use wxSystemSettings or other to do better localisation
  46         if ((!wxIsdigit(*i)) &&
  47             (*i != wxS('.')) && (*i != wxS(',')) && (*i != wxS('e')) &&
  48             (*i != wxS('E')) && (*i != wxS('+')) && (*i != wxS('-')))
  49             return false;
  50     }
  51     return true;
  52 }
  53
  54 // ----------------------------------------------------------------------------
  55 // wxTextValidator
  56 // ----------------------------------------------------------------------------
  57
  58 IMPLEMENT_DYNAMIC_CLASS(wxTextValidator, wxValidator)
  59 BEGIN_EVENT_TABLE(wxTextValidator, wxValidator)
  60     EVT_CHAR(wxTextValidator::OnChar)
  61 END_EVENT_TABLE()
  62
  63 wxTextValidator::wxTextValidator(long style, wxString *val)
  64 {
  65     m_stringValue = val;
  66     SetStyle(style);
  67 }
  68
  69 wxTextValidator::wxTextValidator(const wxTextValidator& val)
  70     : wxValidator()
  71 {
  72     Copy(val);
  73 }
  74
  75 void wxTextValidator::SetStyle(long style)
  76 {
  77     m_validatorStyle = style;
  78
  79 #if wxDEBUG_LEVEL
  80     int check;
  81     check = (int)HasFlag(wxFILTER_ALPHA) + (int)HasFlag(wxFILTER_ALPHANUMERIC) +
  82             (int)HasFlag(wxFILTER_DIGITS) + (int)HasFlag(wxFILTER_NUMERIC);
  83     wxASSERT_MSG(check <= 1,
  84         "It makes sense to use only one of the wxFILTER_ALPHA/wxFILTER_ALPHANUMERIC/"
  85         "wxFILTER_SIMPLE_NUMBER/wxFILTER_NUMERIC styles");
  86
  87     wxASSERT_MSG(((int)HasFlag(wxFILTER_INCLUDE_LIST) + (int)HasFlag(wxFILTER_INCLUDE_CHAR_LIST) <= 1) &&
  88                  ((int)HasFlag(wxFILTER_EXCLUDE_LIST) + (int)HasFlag(wxFILTER_EXCLUDE_CHAR_LIST) <= 1),
  89         "Using both wxFILTER_[IN|EX]CLUDE_LIST _and_ wxFILTER_[IN|EX]CLUDE_CHAR_LIST "
  90         "doesn't work since wxTextValidator internally uses the same array for both");
  91
  92     check = (int)HasFlag(wxFILTER_INCLUDE_LIST) + (int)HasFlag(wxFILTER_INCLUDE_CHAR_LIST) +
  93             (int)HasFlag(wxFILTER_EXCLUDE_LIST) + (int)HasFlag(wxFILTER_EXCLUDE_CHAR_LIST);
  94     wxASSERT_MSG(check <= 1,
  95         "Using both an include/exclude list may lead to unexpected results");
  96 #endif // wxDEBUG_LEVEL
  97 }
  98
  99 bool wxTextValidator::Copy(const wxTextValidator& val)
 100 {
 101     wxValidator::Copy(val);
 102
 103     m_validatorStyle = val.m_validatorStyle;
 104     m_stringValue = val.m_stringValue;
 105
 106     m_includes    = val.m_includes;
 107     m_excludes    = val.m_excludes;
 108
 109     return true;
 110 }
 111
 112 wxTextEntry *wxTextValidator::GetTextEntry()
 113 {
 114 #if wxUSE_TEXTCTRL
 115     if (m_validatorWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
 116     {
 117         return (wxTextCtrl*)m_validatorWindow;
 118     }
 119 #endif
 120
 121 #if wxUSE_COMBOBOX
 122     if (m_validatorWindow->IsKindOf(CLASSINFO(wxComboBox)))
 123     {
 124         return (wxComboBox*)m_validatorWindow;
 125     }
 126 #endif
 127
 128     wxFAIL_MSG(
 129         wxT("wxTextValidator can only be used with wxTextCtrl or wxComboBox")
 130     );
 131
 132     return NULL;
 133 }
 134
 135 // Called when the value in the window must be validated.
 136 // This function can pop up an error message.
 137 bool wxTextValidator::Validate(wxWindow *parent)
 138 {
 139     // If window is disabled, simply return
 140     if ( !m_validatorWindow->IsEnabled() )
 141         return true;
 142
 143     wxTextEntry * const text = GetTextEntry();
 144     if ( !text )
 145         return false;
 146
 147     wxString val(text->GetValue());
 148
 149     wxString errormsg;
 150     if ( HasFlag(wxFILTER_EMPTY) && val.empty() )
 151     {
 152         errormsg = _("Required information entry is empty.");
 153     }
 154     else if ( !(errormsg = IsValid(val)).empty() )
 155     {
 156         // NB: this format string should always contain exactly one '%s'
 157         wxString buf;
 158         buf.Printf(errormsg, val.c_str());
 159         errormsg = buf;
 160     }
 161
 162     if ( !errormsg.empty() )
 163     {
 164         m_validatorWindow->SetFocus();
 165         wxMessageBox(errormsg, _("Validation conflict"),
 166                      wxOK | wxICON_EXCLAMATION, parent);
 167
 168         return false;
 169     }
 170
 171     return true;
 172 }
 173
 174 // Called to transfer data to the window
 175 bool wxTextValidator::TransferToWindow()
 176 {
 177     if ( m_stringValue )
 178     {
 179         wxTextEntry * const text = GetTextEntry();
 180         if ( !text )
 181             return false;
 182
 183         text->SetValue(*m_stringValue);
 184     }
 185
 186     return true;
 187 }
 188
 189 // Called to transfer data to the window
 190 bool wxTextValidator::TransferFromWindow()
 191 {
 192     if ( m_stringValue )
 193     {
 194         wxTextEntry * const text = GetTextEntry();
 195         if ( !text )
 196             return false;
 197
 198         *m_stringValue = text->GetValue();
 199     }
 200
 201     return true;
 202 }
 203
 204 // IRIX mipsPro refuses to compile wxStringCheck<func>() if func is inline so
 205 // let's work around this by using this non-template function instead of
 206 // wxStringCheck(). And while this might be fractionally less efficient because
 207 // the function call won't be inlined like this, we don't care enough about
 208 // this to add extra #ifs for non-IRIX case.
 209 namespace
 210 {
 211
 212 bool CheckString(bool (*func)(const wxUniChar&), const wxString& str)
 213 {
 214     for ( wxString::const_iterator i = str.begin(); i != str.end(); ++i )
 215     {
 216         if ( !func(*i) )
 217             return false;
 218     }
 219
 220     return true;
 221 }
 222
 223 } // anonymous namespace
 224
 225 wxString wxTextValidator::IsValid(const wxString& val) const
 226 {
 227     // wxFILTER_EMPTY is checked for in wxTextValidator::Validate
 228
 229     if ( HasFlag(wxFILTER_ASCII) && !val.IsAscii() )
 230         return _("'%s' should only contain ASCII characters.");
 231     if ( HasFlag(wxFILTER_ALPHA) && !CheckString(wxIsalpha, val) )
 232         return _("'%s' should only contain alphabetic characters.");
 233     if ( HasFlag(wxFILTER_ALPHANUMERIC) && !CheckString(wxIsalnum, val) )
 234         return _("'%s' should only contain alphabetic or numeric characters.");
 235     if ( HasFlag(wxFILTER_DIGITS) && CheckString(wxIsdigit, val) )
 236         return _("'%s' should only contain digits.");
 237     if ( HasFlag(wxFILTER_NUMERIC) && !wxIsNumeric(val) )
 238         return _("'%s' should be numeric.");
 239     if ( HasFlag(wxFILTER_INCLUDE_LIST) && m_includes.Index(val) == wxNOT_FOUND )
 240         return _("'%s' is invalid");
 241     if ( HasFlag(wxFILTER_INCLUDE_CHAR_LIST) && !ContainsOnlyIncludedCharacters(val) )
 242         return _("'%s' is invalid");
 243     if ( HasFlag(wxFILTER_EXCLUDE_LIST) && m_excludes.Index(val) != wxNOT_FOUND )
 244         return _("'%s' is invalid");
 245     if ( HasFlag(wxFILTER_EXCLUDE_CHAR_LIST) && ContainsExcludedCharacters(val) )
 246         return _("'%s' is invalid");
 247
 248     return wxEmptyString;
 249 }
 250
 251 bool wxTextValidator::ContainsOnlyIncludedCharacters(const wxString& val) const
 252 {
 253     for ( wxString::const_iterator i = val.begin(); i != val.end(); ++i )
 254         if (m_includes.Index((wxString) *i) == wxNOT_FOUND)
 255             // one character of 'val' is NOT present in m_includes...
 256             return false;
 257
 258     // all characters of 'val' are present in m_includes
 259     return true;
 260 }
 261
 262 bool wxTextValidator::ContainsExcludedCharacters(const wxString& val) const
 263 {
 264     for ( wxString::const_iterator i = val.begin(); i != val.end(); ++i )
 265         if (m_excludes.Index((wxString) *i) != wxNOT_FOUND)
 266             // one character of 'val' is present in m_excludes...
 267             return true;
 268
 269     // all characters of 'val' are NOT present in m_excludes
 270     return false;
 271 }
 272
 273 void wxTextValidator::SetCharIncludes(const wxString& chars)
 274 {
 275     wxArrayString arr;
 276
 277     for ( wxString::const_iterator i = chars.begin(); i != chars.end(); ++i )
 278         arr.Add(*i);
 279
 280     SetIncludes(arr);
 281 }
 282
 283 void wxTextValidator::SetCharExcludes(const wxString& chars)
 284 {
 285     wxArrayString arr;
 286
 287     for ( wxString::const_iterator i = chars.begin(); i != chars.end(); ++i )
 288         arr.Add(*i);
 289
 290     SetExcludes(arr);
 291 }
 292
 293 void wxTextValidator::OnChar(wxKeyEvent& event)
 294 {
 295     if (!m_validatorWindow)
 296     {
 297         event.Skip();
 298         return;
 299     }
 300
 301     int keyCode = event.GetKeyCode();
 302
 303     // we don't filter special keys and delete
 304     if (keyCode < WXK_SPACE || keyCode == WXK_DELETE || keyCode >= WXK_START)
 305     {
 306         event.Skip();
 307         return;
 308     }
 309
 310     wxString str((wxUniChar)keyCode, 1);
 311     if (!IsValid(str).empty())
 312     {
 313         if ( !wxValidator::IsSilent() )
 314             wxBell();
 315
 316         // eat message
 317         return;
 318     }
 319     else
 320         event.Skip();
 321 }
 322
 323
 324 #endif
 325   // wxUSE_VALIDATORS && (wxUSE_TEXTCTRL || wxUSE_COMBOBOX)