P:/GCC/docs/wxMask/MaskTextCtrl.cpp

Go to the documentation of this file.

#ifndef __MaskTextCtrl_CPP
#define __MaskTextCtrl_CPP

#include <wxMask/MaskTextCtrl.h>

MaskTextCtrl::MaskTextCtrl(wxWindow* parent,
                 wxWindowID id,
                 const wxString &value ,
                 const wxPoint &pos ,
                 const wxSize &size ,
                 long style ,
                 const wxValidator &validator ,
                 const wxString &name )
{
    wxTextCtrl::Create(parent,id,value,pos, size,style,validator,name);
    Connect(wxEVT_CHAR, wxKeyEventHandler(MaskTextCtrl::MaskOnChar ));
        Connect(wxEVT_KEY_DOWN, wxKeyEventHandler( MaskTextCtrl::MaskEvtEnter ));

#ifdef __WXMSW__
  wxAcceleratorEntry MaskEntry[1];
  MaskEntry[0].Set(wxACCEL_CTRL,  WXK_RETURN , WXK_RETURN );
  wxAcceleratorTable Mask_WXK(1, MaskEntry);
  SetAcceleratorTable(Mask_WXK);
#endif
}


MaskTextCtrl::~MaskTextCtrl()
{
        // Disconnect Events
    Disconnect(wxEVT_CHAR, wxKeyEventHandler(MaskTextCtrl::MaskOnChar ));
}


bool MaskTextCtrl::MaskIsUDigit(const int Mskkey)
{
    wxChar val = wxT(Mskkey);

  wxRegEx re(wxT("[0-9]"), wxRE_DEFAULT );
if (re.Matches(val)) return true ;
    return false;
}
bool MaskTextCtrl::MaskIsDigit(const int Mskkey)
{
    wxChar val = wxT(Mskkey);

  wxRegEx re(wxT("[0-9]|\\-|\\+"),wxRE_DEFAULT  );
if (re.Matches(val)) return true ;
    return false;
}

bool MaskTextCtrl::MaskIsUDecimal(const int Mskkey)
{
    wxChar val =wxT(Mskkey);

  wxRegEx re(wxT("[0-9]|\\."),wxRE_DEFAULT  );
if (re.Matches(val)) return true ;
    return false;
}
bool MaskTextCtrl::MaskIsDecimal(const int Mskkey)
{
    wxChar val = wxT(Mskkey);

  wxRegEx re(wxT("[0-9]|\\-|\\.|\\+"),wxRE_DEFAULT  );
if (re.Matches(val)) return true ;
    return false;
}
bool MaskTextCtrl::MaskIsAlphaNumeric(const int Mskkey)
{
    wxChar val = wxT(Mskkey);


  wxRegEx re(wxT("[A-Za-z0-9]|[:space :]|\\-|\\.|\\+"),wxRE_DEFAULT );
if (re.Matches(val)) return true ;
    return false;
}
bool MaskTextCtrl::MaskIsAlpha(const int Mskkey)
{
     const wxChar val = wxT(Mskkey);

  wxRegEx re(wxT("[A-Za-z]|[:space :]|\\-|\\.|\\+"),wxRE_DEFAULT  );

if (re.Matches(val) ) return true;
return false ;
}

bool MaskTextCtrl::MaskIsNumeric(const int Mskkey)
{
    wxChar val = wxT(Mskkey);

  wxRegEx re(wxT("[0-9]|[:space :]"), wxRE_DEFAULT );
if (re.Matches(val)) return true ;
    return false;
}

void MaskTextCtrl::MaskEditWord(unsigned int MskFILTER, wxString MskEdtWord)
{
    MaskFILTER = MskFILTER ;
    MaskEdtWord = MskEdtWord ;
    this->SetMaxLength( MaskEdtWord.Len());
    MaskNextField = true;
}


wxString MaskTextCtrl::MaskGetValue()
{   wxString MskValue ;
    MaskValue = this->GetValue();


// delete  '_'  and  mask ex: ( / or - etc...
   if (MaskEdtWord.Len() > 0) {
    if(MaskValue.Len() >0)
    for (size_t i =0 ; i <=MaskValue.Len() ; i++  ) {

           switch(MaskFILTER) {
    case Mask_UDECIMAL:
    case Mask_DECIMAL:
   if ( (MaskValue[i] != '_' && MaskEdtWord[i] =='#') || (MaskEdtWord[i] =='.')) MskValue.Append(MaskValue[i]); break;
    default :
    if ( MaskValue[i] != '_' && MaskEdtWord[i] =='#' ) MskValue.Append(MaskValue[i]); break;
           }


    }
   } else MskValue=MaskValue;
// formatage value DECIMAL

       MskValue = MaskCodeEdit(MskValue);

return MskValue;
}


wxString MaskTextCtrl::MaskGetText()
{   wxString MskValue ;
    MaskValue = this->GetValue();


// delete  '_'  and  mask ex: ( / or - etc...
    for (size_t i =0 ; i <=MaskValue.Len() ; i++  ) {


   if ( (MaskValue[i] == '_')) MskValue.Append(' ');
   else MskValue.Append(MaskValue[i]);
    }
return MskValue;
}



void MaskTextCtrl::MaskClear()
{  this->Clear();
MaskSetValue(MaskGetValue());
}


wxString MaskTextCtrl::MaskCodeEdit(wxString MskValue)
{
       unsigned int Decimal = 0;
        wxString  edt , buf;
       double Dval ;


          switch(MaskFILTER) {
    case Mask_UDECIMAL:
        MskValue.ToDouble(&Dval);

    for (size_t i = MaskEdtWord.Len() ; i >0 && MaskEdtWord[i] !='.' ; i-- ) {
        if (MaskEdtWord[i] =='#' ) Decimal ++;
    }

        edt  =_T("%#." + wxString::Format("%d",Decimal)+"f");

        buf=  wxString::Format(edt,Dval);
            break;

    case Mask_DECIMAL:
    MskValue.ToDouble(&Dval);

    for (size_t i = MaskEdtWord.Len() ; i >0 && MaskEdtWord[i] !='.' ; i-- ) {
        if (MaskEdtWord[i] =='#' ) Decimal ++;
    }

        edt  =_T("%+#." + wxString::Format("%d",Decimal)+"f");

        buf=  wxString::Format(edt,Dval);
            break;

    default:
    return MskValue;
          }
return buf;
}
void MaskTextCtrl::MaskSetValue(wxString MskValue)
{
                 MaskValue  =MskValue;

                wxString EditWord ;

            if (MaskEdtWord.Len() > 0)
            for (size_t i =0 ; i<=MaskEdtWord.Len() ; i++) {
                if(MaskEdtWord[i] == '#')  EditWord.Append('_');
                 else EditWord.Append(wxString::wxString::Format("%c",MaskEdtWord[i])) ;
            }

          switch(MaskFILTER) {
 // cadrage Left
    case Mask_ALPHANUMERIC:
    case Mask_ALPHA:
    case Mask_NUMERIC:

            if (MaskEdtWord.Len() > 0)
            for (size_t i =0,u=0 ; i< MaskEdtWord.Len() ; i++) {
                if(MaskEdtWord[i] == '#' ) {
                    if( MaskValue.Len() >0 &&  u<MaskValue.Len()) {
                         EditWord[i]=MaskValue[u];
                    }
                    u++;
                }
            } else  EditWord= MaskValue;
            break;
// cadrage right
    case Mask_UDIGIT:
    case Mask_DIGIT:
    case Mask_UDECIMAL:
    case Mask_DECIMAL:

            MaskValue = MaskCodeEdit(MaskValue);
            if (MaskEdtWord.Len() > 0) {
            for (int i =MaskEdtWord.Len() , u = MaskValue.Len()  ; u >0 ; i--) {
                if( (MaskEdtWord[i] == '#' && MaskValue.Len() >  0 ) ||
                    (MaskEdtWord[i] == '.' && MaskValue.Len() >  0 ) ) {
                  if ( u >= 0) {
                  if (MaskValue[u-1] == '-' || MaskValue[u-1] == '+' )
                                EditWord[0] =MaskValue[u-1];
                  else EditWord[i] =MaskValue[u-1];
                  }
                u-- ;
                }
            }
            } else  EditWord.Append(MaskValue);


             break;


    default: EditWord.Append(MaskValue) ; break ;
    } // case FILTER
    this->SetValue(EditWord);
}

// define Last trt value enter
void MaskTextCtrl::MaskLast(bool MskLast ) { MaskNextField = MskLast ;};


void MaskTextCtrl::MaskEvtEnter(wxKeyEvent &event)
{
//wxMessageBox(wxString::Format("%i", event.GetKeyCode()));

// recadrage passe à la zone suivante
if (((wxKeyEvent&)event).GetKeyCode()== WXK_RETURN  )  {
      MaskSetValue(MaskGetValue());
      event.Skip();
      if (MaskNextField == true) Navigate(true );
      return ;
      }
      event.Skip();
}


void MaskTextCtrl::MaskOnChar(wxKeyEvent &event)
{
    bool MaskOK = false;
    size_t pos;

    wxChar val = wxT(event.GetKeyCode());

  switch( ((wxKeyEvent&)event).GetKeyCode()) {

    case WXK_LEFT:
    case WXK_NUMPAD_LEFT:
                    if ( GetInsertionPoint()>0) this->SetInsertionPoint(GetInsertionPoint()-1);
                    break;

    case WXK_RIGHT:
    case WXK_NUMPAD_RIGHT:
                    if ( GetInsertionPoint()< this->GetLastPosition()) this->SetInsertionPoint(GetInsertionPoint()+1);
                    break;

 // suppression de caractere ('_')
    case WXK_BACK:
                     pos = this->GetInsertionPoint();
                     if(MaskEdtWord.length() ==0) {
                     this->Remove(this->GetInsertionPoint()-1, this->GetInsertionPoint());
                     this->SetInsertionPoint(pos-1);
                     }
                     else    if(MaskEdtWord[pos-1] =='#') {
                    this->Replace(this->GetInsertionPoint()-1, this->GetInsertionPoint(),wxT("_"));
                    this->SetInsertionPoint(pos-1);
                     }
                    this->SetInsertionPoint(pos-1);
                    break;
  // suppression de caractere ('_')
    case WXK_TAB:
                     pos = this->GetInsertionPoint();
                     if(MaskEdtWord.length() ==0) {
                     this->Remove(this->GetInsertionPoint(), this->GetInsertionPoint()+1);
                     this->SetInsertionPoint(pos);
                     }
                     else  if(MaskEdtWord[pos] =='#') {
                    this->Replace(this->GetInsertionPoint(), this->GetInsertionPoint()+1,wxT("_"));
                    this->SetInsertionPoint(pos+1);
                     } else  this->SetInsertionPoint(pos+1);
                    break;

  // suppression de caractere clear field
    case WXK_DELETE:
    case WXK_NUMPAD_DELETE:
                    this->Remove(0,this->GetLastPosition());
                    MaskSetValue(this->GetValue());

                    break;
    case WXK_END:
    case WXK_NUMPAD_END:
                    MaskSetValue(MaskGetValue());
                    this->SetInsertionPoint(this->GetLastPosition());
                    break;
    case WXK_HOME:
    case WXK_NUMPAD_HOME:
                    this->SetInsertionPoint(0);
                    break;

    case WXK_ESCAPE:   //this->EmulateKeyPress(WXK_RETURN); No test!!!
                     break;
    case WXK_RETURN:   //this->EmulateKeyPress(WXK_RETURN); No test!!!
                     break;

// pas de traitement des Keycode > 300
    default :
     if (((wxKeyEvent&)event).GetKeyCode()>= WXK_START )  break;

        switch(MaskFILTER) {

    case Mask_UDIGIT:
                MaskOK = MaskIsUDigit(event.GetKeyCode());
                break;
    case Mask_DIGIT:
                MaskOK = MaskIsDigit(event.GetKeyCode());
                break;
    case Mask_UDECIMAL:
                MaskOK = MaskIsUDecimal(event.GetKeyCode());
                break;
    case Mask_DECIMAL:
                MaskOK = MaskIsDecimal(event.GetKeyCode());
                break;
    case Mask_NUMERIC:
                MaskOK = MaskIsNumeric(event.GetKeyCode());
                break;
    case Mask_ALPHANUMERIC:
                MaskOK = MaskIsAlphaNumeric(event.GetKeyCode());
                break;
    case Mask_ALPHA:
                MaskOK = MaskIsAlpha(event.GetKeyCode());
                break;
  // tout cracatère autorisés
    case Mask_NONE:
                MaskOK = true;


      default:
        event.Skip(); break;
   } 
      if (MaskOK== true ) MaskWriteChar(val);
  }  
     event.Skip(false);

}

// particularité traitement char --> txtctrl
void MaskTextCtrl::MaskWriteChar(wxChar val)
{ int pos = this->GetInsertionPoint();
           if(MaskEdtWord.length() ==0) WriteText(val);
    else {
        switch(MaskFILTER) {
    case Mask_DIGIT:
    case Mask_DECIMAL:
                if ( val =='-' || val =='+') {  this->Replace(0,1,val); break;}
                if    (MaskEdtWord[pos] !='#') this->SetInsertionPoint(pos+1);
                else  this->Replace(this->GetInsertionPoint(), this->GetInsertionPoint()+1,val);
                break;
    default:
            if    (MaskEdtWord[pos] !='#') this->SetInsertionPoint(pos+1);
            else  this->Replace(this->GetInsertionPoint(), this->GetInsertionPoint()+1,val);
            break;
        }

        }
}

 char * MaskTextCtrl::ToChar()

{

  wxString inchar = MaskGetValue();

  char * outchar ;



  inchar.Trim(); inchar.Trim(true);

   outchar = (char*) malloc( inchar.Length() );

   strcpy(outchar,inchar.c_str());



  return outchar;

}
#endif

---