src/common/valtext.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/valtext.cpp
   3 // Purpose:     wxTextValidator
   4 // Author:      Julian Smart
   5 // Modified by:
   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 wxIsAlpha(const wxString& val)
  41 {
  42     int i;
  43     for ( i = 0; i < (int)val.length(); i++)
  44     {
  45         if (!wxIsalpha(val[i]))
  46             return false;
  47     }
  48     return true;
  49 }
  50
  51 static bool wxIsAlphaNumeric(const wxString& val)
  52 {
  53     int i;
  54     for ( i = 0; i < (int)val.length(); i++)
  55     {
  56         if (!wxIsalnum(val[i]))
  57             return false;
  58     }
  59     return true;
  60 }
  61
  62 static bool wxIsNumeric(const wxString& val)
  63 {
  64     int i;
  65     for ( i = 0; i < (int)val.length(); i++)
  66     {
  67         // Allow for "," (French) as well as "." -- in future we should
  68         // use wxSystemSettings or other to do better localisation
  69         if ((!wxIsdigit(val[i])) && (val[i] != wxT('.')) && (val[i] != wxT(',')) && (val[i] != wxT('e')) &&
  70             (val[i] != wxT('E')) && (val[i] != wxT('+')) && (val[i] != wxT('-')))
  71             return false;
  72     }
  73     return true;
  74 }
  75
  76
  77 // ----------------------------------------------------------------------------
  78 // wxTextValidator
  79 // ----------------------------------------------------------------------------
  80
  81 IMPLEMENT_DYNAMIC_CLASS(wxTextValidator, wxValidator)
  82 BEGIN_EVENT_TABLE(wxTextValidator, wxValidator)
  83     EVT_CHAR(wxTextValidator::OnChar)
  84 END_EVENT_TABLE()
  85
  86
  87 #if WXWIN_COMPATIBILITY_2_8
  88 wxTextValidator::wxTextValidator(long style, wxString *val)
  89 {
  90     m_validatorStyle = (wxTextValidatorStyle)style;
  91     m_stringValue = val;
  92 }
  93
  94 void wxTextValidator::SetStyle(long style)
  95 {
  96     SetStyle((wxTextValidatorStyle)style);
  97 }
  98 #endif
  99
 100 wxTextValidator::wxTextValidator(wxTextValidatorStyle style, wxString *val)
 101 {
 102     m_validatorStyle = style;
 103     m_stringValue = val;
 104 /*
 105     m_refData = new wxVTextRefData;
 106
 107     M_VTEXTDATA->m_validatorStyle = style;
 108     M_VTEXTDATA->m_stringValue = val;
 109 */
 110 }
 111
 112 wxTextValidator::wxTextValidator(const wxTextValidator& val)
 113     : wxValidator()
 114 {
 115     Copy(val);
 116 }
 117
 118 bool wxTextValidator::Copy(const wxTextValidator& val)
 119 {
 120     wxValidator::Copy(val);
 121
 122     m_validatorStyle = val.m_validatorStyle;
 123     m_stringValue = val.m_stringValue;
 124
 125     m_includes    = val.m_includes;
 126     m_excludes    = val.m_excludes;
 127
 128     return true;
 129 }
 130
 131 wxTextEntry *wxTextValidator::GetTextEntry()
 132 {
 133 #if wxUSE_TEXTCTRL
 134     if (m_validatorWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
 135     {
 136         return (wxTextCtrl*)m_validatorWindow;
 137     }
 138 #endif
 139
 140 #if wxUSE_COMBOBOX
 141     if (m_validatorWindow->IsKindOf(CLASSINFO(wxComboBox)))
 142     {
 143         return (wxComboBox*)m_validatorWindow;
 144     }
 145 #endif
 146
 147     wxFAIL_MSG(
 148         _T("wxTextValidator can only be used with wxTextCtrl or wxComboBox")
 149     );
 150
 151     return NULL;
 152 }
 153
 154 // Called when the value in the window must be validated.
 155 // This function can pop up an error message.
 156 bool wxTextValidator::Validate(wxWindow *parent)
 157 {
 158     // If window is disabled, simply return
 159     if ( !m_validatorWindow->IsEnabled() )
 160         return true;
 161
 162     wxTextEntry * const text = GetTextEntry();
 163     if ( !text )
 164         return false;
 165
 166     wxString val(text->GetValue());
 167
 168     // NB: this format string should always contain exactly one '%s'
 169     wxString errormsg;
 170
 171     switch (m_validatorStyle)
 172     {
 173     case wxFILTER_NONE:
 174         // nothing to do...
 175         break;
 176
 177     case wxFILTER_INCLUDE_LIST:
 178         if ( m_includes.Index(val) == wxNOT_FOUND )
 179             errormsg = _("'%s' is invalid");
 180         break;
 181
 182     case wxFILTER_EXCLUDE_LIST:
 183         if ( m_excludes.Index(val) != wxNOT_FOUND )
 184             errormsg = _("'%s' is invalid");
 185         break;
 186
 187     case wxFILTER_ASCII:
 188         if ( !val.IsAscii() )
 189             errormsg = _("'%s' should only contain ASCII characters.");
 190         break;
 191
 192     case wxFILTER_ALPHA:
 193         if ( !wxIsAlpha(val) )
 194             errormsg = _("'%s' should only contain alphabetic characters.");
 195         break;
 196
 197     case wxFILTER_ALPHANUMERIC:
 198         if ( !wxIsAlphaNumeric(val) )
 199             errormsg = _("'%s' should only contain alphabetic or numeric characters.");
 200         break;
 201
 202     case wxFILTER_NUMERIC:
 203         if ( !wxIsNumeric(val) )
 204             errormsg = _("'%s' should be numeric.");
 205         break;
 206
 207     case wxFILTER_INCLUDE_CHAR_LIST:
 208         if ( !IsInCharIncludes(val) )
 209             errormsg = _("'%s' is invalid");
 210         break;
 211
 212     case wxFILTER_EXCLUDE_CHAR_LIST:
 213         if ( !IsNotInCharExcludes(val) )
 214             errormsg = _("'%s' is invalid");
 215         break;
 216
 217     default:
 218         wxFAIL_MSG("invalid text validator style");
 219     }
 220
 221     if ( !errormsg.empty() )
 222     {
 223         m_validatorWindow->SetFocus();
 224
 225         wxString buf;
 226         buf.Printf(errormsg, val.c_str());
 227
 228         wxMessageBox(buf, _("Validation conflict"),
 229                      wxOK | wxICON_EXCLAMATION, parent);
 230
 231         return false;
 232     }
 233
 234     return true;
 235 }
 236
 237 // Called to transfer data to the window
 238 bool wxTextValidator::TransferToWindow(void)
 239 {
 240     if ( m_stringValue )
 241     {
 242         wxTextEntry * const text = GetTextEntry();
 243         if ( !text )
 244             return false;
 245
 246         text->SetValue(*m_stringValue);
 247     }
 248
 249     return true;
 250 }
 251
 252 // Called to transfer data to the window
 253 bool wxTextValidator::TransferFromWindow(void)
 254 {
 255     if ( m_stringValue )
 256     {
 257         wxTextEntry * const text = GetTextEntry();
 258         if ( !text )
 259             return false;
 260
 261         *m_stringValue = text->GetValue();
 262     }
 263
 264     return true;
 265 }
 266
 267 bool wxTextValidator::IsInCharIncludes(const wxString& val)
 268 {
 269     size_t i;
 270     for ( i = 0; i < val.length(); i++)
 271     {
 272         if (m_includes.Index((wxString) val[i]) == wxNOT_FOUND)
 273             return false;
 274     }
 275     return true;
 276 }
 277
 278 bool wxTextValidator::IsNotInCharExcludes(const wxString& val)
 279 {
 280     size_t i;
 281     for ( i = 0; i < val.length(); i++)
 282     {
 283        if (m_excludes.Index((wxString) val[i]) != wxNOT_FOUND)
 284             return false;
 285     }
 286     return true;
 287 }
 288
 289 void wxTextValidator::OnChar(wxKeyEvent& event)
 290 {
 291 /*
 292     if ( !M_VTEXTDATA )
 293         return;
 294 */
 295
 296     if ( m_validatorWindow )
 297     {
 298         int keyCode = event.GetKeyCode();
 299
 300         // we don't filter special keys and Delete
 301         if (
 302              !(keyCode < WXK_SPACE || keyCode == WXK_DELETE || keyCode > WXK_START) &&
 303              (
 304               ((m_validatorStyle == wxFILTER_INCLUDE_CHAR_LIST) && !IsInCharIncludes(wxString((wxChar) keyCode, 1))) ||
 305               ((m_validatorStyle == wxFILTER_EXCLUDE_CHAR_LIST) && !IsNotInCharExcludes(wxString((wxChar) keyCode, 1))) ||
 306               ((m_validatorStyle == wxFILTER_ASCII) && !isascii(keyCode)) ||
 307               ((m_validatorStyle == wxFILTER_ALPHA) && !wxIsalpha(keyCode)) ||
 308               ((m_validatorStyle == wxFILTER_ALPHANUMERIC) && !wxIsalnum(keyCode)) ||
 309               ((m_validatorStyle == wxFILTER_NUMERIC) && !wxIsdigit(keyCode)
 310                                 && keyCode != wxT('.') && keyCode != wxT(',') && keyCode != wxT('-') && keyCode != wxT('+')
 311                                 && keyCode != wxT('e') && keyCode != wxT('E'))
 312              )
 313            )
 314         {
 315             if ( !wxValidator::IsSilent() )
 316                 wxBell();
 317
 318             // eat message
 319             return;
 320         }
 321     }
 322
 323     event.Skip();
 324 }
 325
 326
 327 #endif
 328   // wxUSE_VALIDATORS && (wxUSE_TEXTCTRL || wxUSE_COMBOBOX)