Real-Time Text Input

Real-Time Text Input

Arthur Kalliokoski

Second in Command

February 2005

Thomas Fjellstrom said:

You'd be surprised.

Yep, right now I'd give ~~my right arm~~ a Pepsi Cola for some cut'n'paste code to disable resizable X windows. It's just a matter of the correct incantations.
(I did look at the A5 and SDL code, and my version doesn't work)

They all watch too much MSNBC... they get ideas.

Nazerith

Member #12,551

February 2011

~~I'm already building a class for this that I'll gladly post when I'm done. Should be later tonight, possibly tomorrow.~~

[EDIT]

Here is the first version of the class. I've not had a chance to test (or even compile it), so use at your own risk.

I'm assuming you know how to set up an event queue and capture events.

So assuming your variables are declared as follows:

ALLEGRO_EVENT ev;
ALLEGRO_EVENT_SOURCE* keyboard_source = al_get_keyboard_event_source();
TextField text;
bool success;

You should be able to capture and process keyboard actions with the following. It returns true if it succeeds, false if it fails (static field is full, can't delete due to cursor position, ect).

It should properly handle SHIFT key, and returns null if you hold CTRL/ALT or press a command key (function keys, pause, break, prtsc, sysrq, esc, ect). That way you can handle those cases separately if you want.

if(ev.source == keyboard_source)
  success = text.ProcessKey(ev);

The following will return the current string in the input field. It returns a character array, which should be easy to render with al_draw_text or similar.

str = text.CurrentString();

The class has lots of different helper functions. It support both dynamic and static string lengths. Obviously static is faster in some regards. Dynamic strings will grow automatically, but you can also use text.SetConserve(true) which will shrink the array if there is lots of dead space at the end (20+). By default the array doesn't shrink once its been expanded.

So without further ado, the TextField class:

#SelectExpand
   1class TextField
   2{
char * tf_string;      //current string
int tf_position;      //cursor position
int tf_size;        //size allocated for array
bool tf_isStatic;      //defaults to false (dynamic allocation)
bool tf_conserveMemory;    //if set dynamic arrays are shortened to conserve memory
   8
bool AddCharacter(char c);            //add character at current cursor position. (return true if success)
bool DeleteCharacter(bool reverse =  false);  //delete character at current position. (return true if success)
  11
  12public:
TextField(int maxLength=0);                      //initialize empty field
TextField(char * StartString, int StartPosition, int maxLength=0);  //initialize field with starting string and cursor position

char * GetString();      //returns current string
int GetPosition();      //returns current cursor position
int GetSize();        //returns current size of array
bool IsConserve();      //returns if dynamic arrays are resized to conserve memory
bool IsStatic();      //returns if field has static length
  21
bool SetPosition(int p);      //set cursor position
void SetConserve(bool conserve);  //set dynamic string memory conservation
  24
bool ProcessKey(ALLEGRO_EVENT ev);  //processes a key press (returns true if success, false if failure, null if ignored)
  26};
  27
  28TextField::TextField(int maxLength=0)
  29{
if(maxLength > 0) //if MaxLength was set greater than zero, array is Static length
{
  tf_size = maxLength;
  tf_isStatic = true;
}
else //set as dynamic with a starting 10 character storage
{
  tf_size = 10;
  tf_isStatic = false;
}
tf_string = new char[tf_size];
tf_position = 0;
tf_conserveMemory = false;
  43}
  44
  45TextField::TextField(char * StartString, int StartPosition, int MaxLength=0)
  46{
if(MaxLength > 0) //if MaxLength was set greater than zero, array is Static length
{
  tf_size = MaxLength;
  tf_string = new char[tf_size];
  tf_isStatic = true;
}
else //set as Dynamic length larger than starting string
{
  tf_size = strlen(StartString) + 10;
  tf_string = new char[tf_size];
  tf_isStatic = false;
}
  59
strcpy(tf_string,StartString);
tf_string[strlen(tf_string)] = '\0';
  62
tf_position = StartPosition;
tf_conserveMemory = false;
  65}
  66
  67char * TextField::GetString()
  68{
return tf_string;
  70}
  71
  72int TextField::GetPosition()
  73{
return tf_position;
  75}
  76
  77int TextField::GetSize()
  78{
return tf_size;
  80}
  81
  82bool TextField::IsConserve()
  83{
return tf_conserveMemory;
  85}
  86
  87bool TextField::IsStatic()
  88{
return tf_isStatic;
  90}
  91
  92bool TextField::SetPosition(int p)
  93{
if(p<0)
  return false;
else if (p > strlen(tf_string))
  return false;
else
  tf_position = p;

return true;
 102}
 103
 104void TextField::SetConserve(bool conserve)
 105{
tf_conserveMemory = conserve;
 107}
 108
 109bool TextField::AddCharacter(char c)
 110{
int currentLength = strlen(tf_string);
 112
if(tf_position>currentLength)    //catches error if position out of bounds
  tf_position=currentLength;
 115
if(tf_position<0)          //catches error if position out of bounds
  tf_position=0;
 118
if(tf_position==tf_size)    //if field is full
{
  if(tf_isStatic)    //cannot add any characters
    return false;
  else        //resize dynamic array (adds 10)
  {
    tf_size+=10;
    char* temp = new char [tf_size];
    strcpy(temp, tf_string);
    delete [] tf_string;
    tf_string=temp;
  }
}
 132
if(tf_position == strlen(tf_string)) //if position is at end of string
  strcat(tf_string, c);
else if(tf_position == 0)      //if position is beginning of string
{
  char * temp = new char [tf_size];
  temp[0] = c;
  strcpy(tf_string,strcat(temp, tf_string));
  delete [] temp;
}
else
{
  char * temp = new char [tf_size];
  strncpy(temp,tf_string,tf_position);
  temp[strlen(temp)] = c;
  for(int i=tf_position; i<strlen(tf_string);i++)
    temp[i+1]=tf_string[i];
  delete [] temp;
}
 151
tf_position++;
return true;
 154}
 155
 156bool TextField::DeleteCharacter(bool reverse=false)
 157{
int currentLength = strlen(tf_string);
 159
if(tf_position < 0)        //catches out of range error
  tf_position=0;
if(tf_position > currentLength)  //catches out of range error
  tf_position = currentLength;
 164
if(tf_position == 0)
{
  if(!reverse)  //cursor at start of field and backspace pressed
    return false;
  else      //delete character at start of field
  {
    char * temp = new char [tf_size];
    for(int i=1; i<currentLength; i++)
      temp[i-1]=tf_string[i];
    delete [] tf_string;
    tf_string = temp;
  }
}
else if(tf_position == currentLength)
{
  if(reverse)    //cursor at end of field and delete key pressed
    return false;
  else      //delete character at end of field
    strncpy(tf_string,tf_string,currentLength-1);
}
else
{
  char * temp = new char [tf_size];
  if(!reverse)  //delete character before cursor (BACKSPACE)
  {
    strncpy(temp,tf_string,tf_position-1);
    for(int i=tf_position;i<currentLength;i++)
      temp[i-1]=tf_string[i];
    tf_position--;
  }
  else      //delete character after cursor (DELETE)
  {
    strncpy(temp,tf_string,tf_position);
    for(int i=tf_position+1;i<currentLength;i++)
      temp[i-1]=tf_string[i];
  }
  delete [] tf_string;
  tf_string=temp;
}
 204
if(!tf_isStatic && tf_conserveMemory && tf_size>20 && currentLength+19<=tf_size) //resizes array to conserve memory (removes 10)
{
  tf_size-=10;
  char* temp = new char [tf_size];
  strcpy(temp, tf_string);
  delete [] tf_string;
  tf_string=temp;
}
 213
return true;
 215}
 216
 217bool TextField::ProcessKey(ALLEGRO_EVENT ev)
 218{
ALLEGRO_KEYBOARD_STATE *state;
al_get_keyboard_state(state);
 221
if(ev.type == ALLEGRO_EVENT_KEY_DOWN && !al_key_down(state, ALLEGRO_KEY_ALT) && !al_key_down(state, ALLEGRO_KEY_ALTGR) && !al_key_down(state, ALLEGRO_KEY_RCTRL) && !al_key_down(state, ALLEGRO_KEY_LCTRL))
{
  if(ev.keyboard.keycode >= ALLEGRO_KEY_A && ev.keyboard.keycode <= ALLEGRO_KEY_Z)
  {
    if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
      return AddCharacter('A'+ev.keyboard.keycode-ALLEGRO_KEY_A);
    else
      return AddCharacter('a'+ev.keyboard.keycode-ALLEGRO_KEY_A);
  }
  else if (ev.keyboard.keycode >= ALLEGRO_KEY_0 && ev.keyboard.keycode <= ALLEGRO_KEY_9)
  {
    if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
      return AddCharacter('A'+ev.keyboard.keycode-ALLEGRO_KEY_A);
    else
      return AddCharacter('a'+ev.keyboard.keycode-ALLEGRO_KEY_A);
  }
  else if (ev.keyboard.keycode >= ALLEGRO_KEY_PAD_0 && ev.keyboard.keycode <= ALLEGRO_KEY_PAD_9)
  {
    return AddCharacter('0'+ev.keyboard.keycode-ALLEGRO_KEY_PAD_0);
  }
  else
  {
    switch(ev.keyboard.keycode)
    {
      case ALLEGRO_KEY_TILDE :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter('~');
        else
          return AddCharacter('`');
      break;
      case ALLEGRO_KEY_MINUS :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter('_');
        else
          return AddCharacter('-');
      break;
      case ALLEGRO_KEY_EQUALS :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter('+');
        else
          return AddCharacter('=');
      break;
      case ALLEGRO_KEY_BACKSPACE :
        return DeleteCharacter();
      break;
      case ALLEGRO_KEY_OPENBRACE :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter('{');
        else
          return AddCharacter('[');
      break;
      case ALLEGRO_KEY_CLOSEBRACE :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter('}');
        else
          return AddCharacter(']');
      break;
      case ALLEGRO_KEY_SEMICOLON :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter(':');
        else
          return AddCharacter(';');
      break;
      case ALLEGRO_KEY_QUOTE :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter('\"');
        else
          return AddCharacter('\'');
      break;
      case ALLEGRO_KEY_BACKSLASH :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter('|');
        else
          return AddCharacter('\\');
      break;
      case ALLEGRO_KEY_BACKSLASH2 : /* DirectInput calls this DIK_OEM_102: "< > | on UK/Germany keyboards" */
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter('|');
        else
          return AddCharacter('\\');
      break; 
      case ALLEGRO_KEY_COMMA :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter('<');
        else
          return AddCharacter(',');
      break;
      case ALLEGRO_KEY_FULLSTOP :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter('>');
        else
          return AddCharacter('.');
      break;
      case ALLEGRO_KEY_SLASH :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter('?');
        else
          return AddCharacter('/');
      break;
      case ALLEGRO_KEY_SPACE :
        return AddCharacter(' ');
      break;
 324
      case ALLEGRO_KEY_LEFT :
        if(tf_position > 0)
          tf_position--;
      break;
      case ALLEGRO_KEY_RIGHT :
        if(tf_position < strlen(tf_string))
          tf_position++;
      break;
      case ALLEGRO_KEY_UP :
        //if you want to add a keyboard buffer of previous tf_strings
      break;
      case ALLEGRO_KEY_DOWN :
        //same as key up
      break;
 339
      case ALLEGRO_KEY_PAD_SLASH :
        return AddCharacter('/');
      break;
      case ALLEGRO_KEY_PAD_ASTERISK :
        return AddCharacter('*');
      break;
      case ALLEGRO_KEY_PAD_MINUS :
        return AddCharacter('-');
      break;
      case ALLEGRO_KEY_PAD_PLUS :
        return AddCharacter('+');
      break;
      case ALLEGRO_KEY_PAD_DELETE :
        return DeleteCharacter(true);
      break;
 355
      case ALLEGRO_KEY_COLON2 :
        return AddCharacter(':');
      break;
 359
      case ALLEGRO_KEY_PAD_EQUALS :
        return AddCharacter('=');
      break;
      case ALLEGRO_KEY_BACKQUOTE :
        return AddCharacter('\'');
      break;
      case ALLEGRO_KEY_SEMICOLON2 :
        if(al_key_down(state, ALLEGRO_KEY_LSHIFT) || al_key_down(state, ALLEGRO_KEY_RSHIFT))
          return AddCharacter(':');
        else
          return AddCharacter(';');
      break;
    }
  }
}
 375
return NULL;
 377}

Edgar Reynaldo

Major Reynaldo

May 2007

Nazerith said:

#SelectExpand
  1TextField::TextField(char* StartString, int StartPosition, int MaxLength=0)  2{  3if(MaxLength >0)//if MaxLength was set greater than zero, array is Static length  4{  5    tf_size = MaxLength;
  6    tf_string =newchar[tf_size];  7    tf_isStatic =true;  8}  9else//set as Dynamic length larger than starting string 10{ 11    tf_size =strlen(StartString)+10; 12    tf_string =newchar[tf_size]; 13    tf_isStatic =false; 14} 15 16  strcpy(tf_string,StartString);
 17  tf_string[strlen(tf_string)] = '\0';
 18 19  tf_position = StartPosition; 20  tf_conserveMemory =false; 21}

If MaxLength is less than or equal to the number of characters in StartString, then your strcpy call will overrun tf_string. Also, you overwrite the last character of the string with NULL when you use tf_string[strlen(tf_string)] = '\0'; Something else, strcpy writes a null character at the end of the string, so you don't need to do it manually.

Nazerith said:

#SelectExpand
  1bool TextField::AddCharacter(char c)  2{  3int currentLength =strlen(tf_string);  4  5if(tf_position>currentLength)//catches error if position out of bounds  6    tf_position=currentLength;  7  8if(tf_position<0)//catches error if position out of bounds  9    tf_position=0; 10 11/// Problem here, this checks the position, not the size 12
 13if(tf_position==tf_size)//if field is full 14{ 15if(tf_isStatic)//cannot add any characters 16returnfalse; 17else//resize dynamic array (adds 10) 18{ 19      tf_size+=10; 20char* temp =newchar[tf_size]; 21strcpy(temp, tf_string); 22delete[] tf_string; 23      tf_string=temp; 24} 25} 26 27if(tf_position ==strlen(tf_string))//if position is at end of string 28    strcat(tf_string, c);
 29elseif(tf_position ==0)//if position is beginning of string 30{ 31char* temp =newchar[tf_size]; 32    temp[0]= c; 33strcpy(tf_string,strcat(temp, tf_string)); 34delete[] temp; 35} 36else 37{ 38char* temp =newchar[tf_size]; 39strncpy(temp,tf_string,tf_position); 40    temp[strlen(temp)]= c; 41for(int i=tf_position; i<strlen(tf_string);i++) 42      temp[i+1]=tf_string[i]; 43delete[] temp; 44} 45 46  tf_position++; 47returntrue; 48}

c is a character - the second argument of strcat should be a const char*. You're also not checking the size of the string when you add a character to it, so you could overwrite it.

Nazerith said:

bool TextField::ProcessKey(ALLEGRO_EVENT ev){  ALLEGRO_KEYBOARD_STATE *state;
  al_get_keyboard_state(state);

You're asking allegro to store the keyboard state in an uninitialized pointer. It should be :

   ALLEGRO_KEYBOARD_STATE state;
   al_get_keyboard_state(&state);

You're using C++ - why don't you just use a std::string? It would make manipulation of the string easier, and would manage the memory for you. See also string::erase and string::insert.

Eagle and Allegro 5 binaries | Older Allegro 4 and 5 binaries | Allegro 5 compile guide
King Piccolo will make it so Then I could just flip it with some sweet, sweet matrix math. In either case, I’ll ride this wagon until the wheels fall off. Thanks to those that keep it running

Nazerith

Member #12,551

February 2011

Edgar Reynaldo said:

True, I was half awake when I wrote much of this. But I'm glad for the comments, makes it easier to find errors. I've already noticed a half dozen myself since posting, . (also, some helper functions to clear/set the string would be nice... )

Edgar Reynaldo said:

#SelectExpand
  1bool TextField::AddCharacter(char c)
  2{
int currentLength = strlen(tf_string);
  4
if(tf_position>currentLength)    //catches error if position out of bounds
  tf_position=currentLength;
  7
if(tf_position<0)          //catches error if position out of bounds
  tf_position=0;
 10
 11/// Problem here, this checks the position, not the size
if(tf_position==tf_size)    //if field is full
{
  if(tf_isStatic)    //cannot add any characters
    return false;
  else        //resize dynamic array (adds 10)
  {
    tf_size+=10;
    char* temp = new char [tf_size];
    strcpy(temp, tf_string);
    delete [] tf_string;
    tf_string=temp;
  }
}
 25
if(tf_position == strlen(tf_string)) //if position is at end of string
  strcat(tf_string, c);
else if(tf_position == 0)      //if position is beginning of string
{
  char * temp = new char [tf_size];
  temp[0] = c;
  strcpy(tf_string,strcat(temp, tf_string));
  delete [] temp;
}
else
{
  char * temp = new char [tf_size];
  strncpy(temp,tf_string,tf_position);
  temp[strlen(temp)] = c;
  for(int i=tf_position; i<strlen(tf_string);i++)
    temp[i+1]=tf_string[i];
  delete [] temp;
}
 44
tf_position++;
return true;
 47}

c is a character - the second argument of strcat should be a const char*.

oddly my compiler doesn't seem to mind this, easy enough to fix.

Edgar Reynaldo said:

You're also not checking the size of the string when you add a character to it, so you could overwrite it.

blarg. line 12 in the example should have been:

if(tf_size<=currentLength)

Less than should be impossible in theory, so I could get away with an == but nothing is really lost by making it <=.

Tomorrow after some sleep I'll throw a wrapper around this thing to render it and do some basic testing, work out the kinks. Too sleepy now. Nights.

[EDIT]

So insomnia got me once again, no sleep. sigh...

On the bright side, I build a wrapper to test everything. So here is the next version. I'll call this Alpha (why not?)

Changes:

Fixed compiler errors
Implemented keyboard state correctly
Made the number keys work (which didn't before due to a bad copy/paste)
Recoded the AddCharacter and DeleteCharacter functions. They are now much more compact and faster. (speed is why I'm not using std::String)
Added END and HOME functionality.
There are now SetString and Clear functions.
Added a destructor to deallocate the string when finished.
Removed nearly all of the strlen calls to tf_string. A new integer keeps tracks of the current string length (incremented/decremented as appropriate).

So here is TextField Alpha:

TextField.h

#SelectExpand
   1#ifndef TEXTFIELD
   2#define TEXTFIELD
   3
   4#include <string.h>
   5
   6#include <allegro5\allegro.h>
   7
   8class TextField
   9{
char * tf_string;      //current string
int tf_position;      //cursor position
int tf_array_size;      //size allocated for array
int tf_string_size;      //size of current string
bool tf_isStatic;      //defaults to false (dynamic allocation)
bool tf_conserveMemory;    //if set dynamic arrays are shortened to conserve memory
  16
bool AddCharacter(char c);            //add character at current cursor position. (return true if success)
bool DeleteCharacter(bool reverse =  false);  //delete character at current position. (return true if success)
  19
  20public:
TextField(int maxLength=0);                      //initialize empty field
TextField(char * StartString, int StartPosition, int maxLength=0);  //initialize field with starting string and cursor position

~TextField();        //destructor, deallocates tf_string;
  25
char * GetString();      //returns current string
int GetPosition();      //returns current cursor position
int GetSize();        //returns current size of string
int GetArraySize();      //returns current size of array
bool IsConserve();      //returns if dynamic arrays are resized to conserve memory
bool IsStatic();      //returns if field has static length
  32
bool SetPosition(int p);      //set cursor position
void SetConserve(bool conserve);  //set dynamic string memory conservation
bool SetString(const char* s);
  36
bool Clear();
  38
bool ProcessKey(ALLEGRO_EVENT ev);  //processes a key press (returns true if success, false if failure, null if ignored)
  40};
  41
  42TextField::TextField(int maxLength)
  43{
if(maxLength > 0) //if MaxLength was set greater than zero, array is Static length
{
  tf_array_size = maxLength;
  tf_isStatic = true;
}
else //set as dynamic with a starting 10 character storage
{
  tf_array_size = 10;
  tf_isStatic = false;
}
tf_string = new char[tf_array_size];
tf_string[0] = '\0';
tf_string_size = 0;
tf_position = 0;
tf_conserveMemory = false;
  59}
  60
  61TextField::TextField(char * StartString, int StartPosition, int MaxLength)
  62{
tf_string_size = strlen(StartString);
  64
if(MaxLength > 0) //if MaxLength was set greater than zero, array is Static length
{
  tf_array_size = MaxLength;
  tf_string = new char[tf_array_size];
  tf_isStatic = true;
  if(tf_string_size > tf_array_size)
  {
    tf_string_size = tf_array_size;
    strncpy(tf_string,StartString,tf_array_size);
  }
  else
    strcpy(tf_string,StartString);
}
else //set as Dynamic length larger than starting string
{
  tf_array_size = tf_string_size + 10;
  tf_string = new char[tf_array_size];
  tf_isStatic = false;
  strcpy(tf_string,StartString);
}

if(StartPosition<0)
  tf_position=0;
else if(StartPosition>tf_string_size)
  tf_position=tf_string_size;
else
  tf_position = StartPosition;
tf_conserveMemory = false;
  93}
  94
  95TextField::~TextField()
  96{
delete [] tf_string;
  98}
  99
 100char * TextField::GetString()
 101{
return tf_string;
 103}
 104
 105int TextField::GetPosition()
 106{
return tf_position;
 108}
 109
 110int TextField::GetSize()
 111{
return tf_string_size;
 113}
 114
 115int TextField::GetArraySize()
 116{
return tf_array_size;
 118}
 119
 120bool TextField::IsConserve()
 121{
return tf_conserveMemory;
 123}
 124
 125bool TextField::IsStatic()
 126{
return tf_isStatic;
 128}
 129
 130bool TextField::SetPosition(int p)
 131{
if(p<0)
  return false;
else if (p > tf_string_size)
  return false;
else
  tf_position = p;

return true;
 140}
 141
 142void TextField::SetConserve(bool conserve)
 143{
tf_conserveMemory = conserve;
 145}
 146
 147bool TextField::SetString(const char* NewString)
 148{
tf_string_size = strlen(NewString);
 150
if(tf_isStatic)
{
  if(tf_string_size > tf_array_size)
  {
    tf_string_size = tf_array_size;
    strncpy(tf_string,NewString,tf_array_size);
  }
  else
    strcpy(tf_string,NewString);
}
else //set as Dynamic length larger than starting string
{
  tf_array_size = tf_string_size + 10;
  delete [] tf_string;
  tf_string = new char[tf_array_size];
  strcpy(tf_string,NewString);
}

if(tf_position<0)
  tf_position=0;
else if(tf_position>tf_string_size)
  tf_position=tf_string_size;
 173
return(true);
 175}
 176
 177bool TextField::Clear()
 178{
 179
if(!tf_isStatic)
  tf_array_size = 10;

tf_string[0] = '\0';
tf_string_size = 0;
tf_position = 0;
 186
return(true);
 188}
 189
 190bool TextField::AddCharacter(char c)
 191{
if(tf_position>tf_string_size)    //catches error if position out of bounds
  tf_position=tf_string_size;
 194
if(tf_position<0)          //catches error if position out of bounds
  tf_position=0;
 197
if(tf_array_size<=tf_string_size+1)      //if field is full
{
  if(tf_isStatic)    //cannot add any characters
    return false;
  else        //resize dynamic array (adds 10)
  {
    tf_array_size+=10;
    char* temp = new char [tf_array_size];
    strcpy(temp, tf_string);
    delete [] tf_string;
    tf_string=temp;
  }
}

memmove(tf_string+tf_position+1, tf_string+tf_position, tf_string_size-tf_position+1);
tf_string[tf_position] = c;
tf_position++;
tf_string_size++;
 216
return true;
 218}
 219
 220bool TextField::DeleteCharacter(bool reverse)
 221{
if(tf_position < 0)          //catches out of range error
  tf_position=0;
if(tf_position > tf_string_size)  //catches out of range error
  tf_position = tf_string_size;
 226
if(reverse)
{
  if(tf_position==tf_string_size)
    return false;
  else
    memmove(tf_string+tf_position, tf_string+tf_position+1, tf_string_size-tf_position);
}
else
{
  if(tf_position==0)
    return false;
  else
  {
    memmove(tf_string+tf_position-1, tf_string+tf_position, tf_string_size-tf_position+1);
    tf_position--;
  }
}
 244
tf_string_size--;
 246
if(!tf_isStatic && tf_conserveMemory && tf_array_size>=20 && tf_string_size+19<=tf_array_size) //resizes array to conserve memory (removes 10)
{
  tf_array_size-=10;
  char* temp = new char [tf_array_size];
  strcpy(temp, tf_string);
  delete [] tf_string;
  tf_string=temp;
}
 255
return true;
 257}
 258
 259bool TextField::ProcessKey(ALLEGRO_EVENT ev)
 260{
ALLEGRO_KEYBOARD_STATE state;
bool shiftDown=false;
 263
al_get_keyboard_state(&state);
 265
if(ev.type != ALLEGRO_EVENT_KEY_DOWN || 
  al_key_down(&state, ALLEGRO_KEY_ALT) || al_key_down(&state, ALLEGRO_KEY_ALTGR) || 
  al_key_down(&state, ALLEGRO_KEY_RCTRL) || al_key_down(&state, ALLEGRO_KEY_LCTRL))
    return NULL;
else
{
  if(al_key_down(&state, ALLEGRO_KEY_LSHIFT) || al_key_down(&state, ALLEGRO_KEY_RSHIFT))
    shiftDown=true;
 274
  if(ev.keyboard.keycode >= ALLEGRO_KEY_A && ev.keyboard.keycode <= ALLEGRO_KEY_Z)
  {
    if(shiftDown)
      return AddCharacter('A'+ev.keyboard.keycode-ALLEGRO_KEY_A);
    else
      return AddCharacter('a'+ev.keyboard.keycode-ALLEGRO_KEY_A);
  }
  else if (ev.keyboard.keycode >= ALLEGRO_KEY_0 && ev.keyboard.keycode <= ALLEGRO_KEY_9)
  {
    if(shiftDown)
      switch(ev.keyboard.keycode)
      {
        case ALLEGRO_KEY_0 :
          AddCharacter(')');
        break;
        case ALLEGRO_KEY_1 :
          AddCharacter('!');
        break;
        case ALLEGRO_KEY_2 :
          AddCharacter('@');
        break;
        case ALLEGRO_KEY_3 :
          AddCharacter('#');
        break;
        case ALLEGRO_KEY_4 :
          AddCharacter('$');
        break;
        case ALLEGRO_KEY_5 :
          AddCharacter('%');
        break;
        case ALLEGRO_KEY_6 :
          AddCharacter('^');
        break;
        case ALLEGRO_KEY_7 :
          AddCharacter('&');
        break;
        case ALLEGRO_KEY_8 :
          AddCharacter('*');
        break;
        case ALLEGRO_KEY_9 :
          AddCharacter('(');
        break;
      }
    else
      return AddCharacter('0'+ev.keyboard.keycode-ALLEGRO_KEY_0);
  }
  else if (ev.keyboard.keycode >= ALLEGRO_KEY_PAD_0 && ev.keyboard.keycode <= ALLEGRO_KEY_PAD_9)
  {
    return AddCharacter('0'+ev.keyboard.keycode-ALLEGRO_KEY_PAD_0);
  }
  else
  {
    switch(ev.keyboard.keycode)
    {
      case ALLEGRO_KEY_TILDE :
        if(shiftDown)
          return AddCharacter('~');
        else
          return AddCharacter('`');
      break;
      case ALLEGRO_KEY_MINUS :
        if(shiftDown)
          return AddCharacter('_');
        else
          return AddCharacter('-');
      break;
      case ALLEGRO_KEY_EQUALS :
        if(shiftDown)
          return AddCharacter('+');
        else
          return AddCharacter('=');
      break;
      case ALLEGRO_KEY_BACKSPACE :
        return DeleteCharacter();
      break;
      case ALLEGRO_KEY_OPENBRACE :
        if(shiftDown)
          return AddCharacter('{');
        else
          return AddCharacter('[');
      break;
      case ALLEGRO_KEY_CLOSEBRACE :
        if(shiftDown)
          return AddCharacter('}');
        else
          return AddCharacter(']');
      break;
      case ALLEGRO_KEY_SEMICOLON :
        if(shiftDown)
          return AddCharacter(':');
        else
          return AddCharacter(';');
      break;
      case ALLEGRO_KEY_QUOTE :
        if(shiftDown)
          return AddCharacter('\"');
        else
          return AddCharacter('\'');
      break;
      case ALLEGRO_KEY_BACKSLASH :
        if(shiftDown)
          return AddCharacter('|');
        else
          return AddCharacter('\\');
      break;
      case ALLEGRO_KEY_BACKSLASH2 : /* DirectInput calls this DIK_OEM_102: "< > | on UK/Germany keyboards" */
        if(shiftDown)
          return AddCharacter('|');
        else
          return AddCharacter('\\');
      break; 
      case ALLEGRO_KEY_COMMA :
        if(shiftDown)
          return AddCharacter('<');
        else
          return AddCharacter(',');
      break;
      case ALLEGRO_KEY_FULLSTOP :
        if(shiftDown)
          return AddCharacter('>');
        else
          return AddCharacter('.');
      break;
      case ALLEGRO_KEY_SLASH :
        if(shiftDown)
          return AddCharacter('?');
        else
          return AddCharacter('/');
      break;
      case ALLEGRO_KEY_SPACE :
        return AddCharacter(' ');
      break;
 407
      case ALLEGRO_KEY_DELETE :
        return DeleteCharacter(true);
      break;
      case ALLEGRO_KEY_HOME :
        tf_position = 0;
      break;
      case ALLEGRO_KEY_END :
        tf_position = tf_string_size;
      break;
      case ALLEGRO_KEY_LEFT :
        if(tf_position > 0)
          tf_position--;
      break;
      case ALLEGRO_KEY_RIGHT :
        if(tf_position < tf_string_size)
          tf_position++;
      break;
      case ALLEGRO_KEY_UP :
        //if you want to add a keyboard buffer of previous tf_strings
      break;
      case ALLEGRO_KEY_DOWN :
        //same as key up
      break;
 431
      case ALLEGRO_KEY_PAD_SLASH :
        return AddCharacter('/');
      break;
      case ALLEGRO_KEY_PAD_ASTERISK :
        return AddCharacter('*');
      break;
      case ALLEGRO_KEY_PAD_MINUS :
        return AddCharacter('-');
      break;
      case ALLEGRO_KEY_PAD_PLUS :
        return AddCharacter('+');
      break;
      case ALLEGRO_KEY_PAD_DELETE :
        return DeleteCharacter(true);
      break;
 447
      case ALLEGRO_KEY_COLON2 :
        return AddCharacter(':');
      break;
 451
      case ALLEGRO_KEY_PAD_EQUALS :
        return AddCharacter('=');
      break;
      case ALLEGRO_KEY_BACKQUOTE :
        return AddCharacter('\'');
      break;
      case ALLEGRO_KEY_SEMICOLON2 :
        if(shiftDown)
          return AddCharacter(':');
        else
          return AddCharacter(';');
      break;
    }
  }
}
 467
return NULL;
 469}
 470
 471
 472#endif

Edgar Reynaldo

Major Reynaldo

May 2007

Nazerith said:

speed is why I'm not using std::String

This may be counter intuitive, but you'll probably save more time in development by using std::string. And also, the standard library has probably been optimized better than you could do with char* yourself. There's no way that at 60 updates per second that you will see any difference in speed of any kind by using char*'s manually instead of using std::string.

Nazerith said:

   tf_array_size = MaxLength;
//...
   strncpy(tf_string,StartString,tf_array_size);

tf_array_size should be MaxLength plus one, to account for the null terminator.
Also, if you copy X characters into an array with X elements, where will the null terminator go?

Peter Wang

Member #23

April 2000

Ugh.

bool TextField::ProcessKey(ALLEGRO_EVENT ev)
{
  ALLEGRO_KEYBOARD_STATE state;
  bool shiftDown=false;

  al_get_keyboard_state(&state);

  if(ev.type != ALLEGRO_EVENT_KEY_DOWN || 
    al_key_down(&state, ALLEGRO_KEY_ALT) || al_key_down(&state, ALLEGRO_KEY_ALTGR) || 
    al_key_down(&state, ALLEGRO_KEY_RCTRL) || al_key_down(&state, ALLEGRO_KEY_LCTRL))
      return NULL;
  else

ev.keyboard.modifiers already has this information.

    if(ev.keyboard.keycode >= ALLEGRO_KEY_A && ev.keyboard.keycode <= ALLEGRO_KEY_Z)
    {
      if(shiftDown)
        return AddCharacter('A'+ev.keyboard.keycode-ALLEGRO_KEY_A);
      else
        return AddCharacter('a'+ev.keyboard.keycode-ALLEGRO_KEY_A);
    }

The ev.keyboard.unichar field already has the information you need. Your code is needlessly verbose and will only "work" on US keyboard layouts.

If something is very repetitious, alarms should be sounding off in your head. Programmers hate repetition.

Nazerith

Member #12,551

February 2011

Edgar Reynaldo said:

Could I create a general purpose string library thats quicker than std:string. most likely not. But in the very specific usage I'm implementing here, its already faster than std:string for various reasons.

1) Every time you concatenate or lengthen a std:string, new memory is allocated. I'm only reallocating at a minimum of every ten concatenations.
2) Allocating new memory and using char * copy functions is faster than doing the same with std:string.

std:string has a bit of overhead that makes it very flexible. I don't need any of that flexibility, so I've sacrificed the the overhead. You can find some places on the internet where people have run comparison tests. Depending on the exact test, char* operates roughly 2x to 10x faster than std::string but you have to be willing to handle your own memory management.

I'm not worried about handling it 60 times a minute, but in a game there are frequently lots of events between frame renders. The less time it spends processing here, the more time it has to do other things. Since I'm working up these components for an online game, I expect lots of other things happening as well.

Edgar Reynaldo said:

tf_array_size = MaxLength;
//...
   strncpy(tf_string,StartString,tf_array_size);

tf_array_size should be MaxLength plus one, to account for the null terminator.
Also, if you copy X characters into an array with X elements, where will the null terminator go?

I've been testing dynamic strings mostly. Guess I'll need to make the array for fixed strings one larger. However on the strncpy I don't need to account for the null character in the length, since the function adds a null at the end anyways (as you pointed out previously).

Peter Wang said:

ev.keyboard.modifiers already has this information.

Yep. Originally I was using the Key Down event for my class, but have already switched to Key Char events. So in my next version I've eliminated the need to test state (which should get rid of any timing errors for rapid key presses), and it also lets me handle when someone holds down a key.

Peter Wang said:

The ev.keyboard.unichar field already has the information you need. Your code is needlessly verbose and will only "work" on US keyboard layouts.

If something is very repetitious, alarms should be sounding off in your head. Programmers hate repetition.

I'm still learning all the things in the Allegro library. I'll take a look at the unicode stuff and see about implementing it.

Thanks for the feedback guys. Til Laters.

Edgar Reynaldo

Major Reynaldo

May 2007

Nazerith said:

strcpy adds a null, if there is space for it, but I can't say for sure that strncpy does the same thing. And there's still the problem of using strncpy to copy X elements into an array that only has X elements. If it does add a trailing null, there will still be an overflow. If it does not, you still have a string that is not null terminated.

Nazerith

Member #12,551

February 2011

Agreed. Just to play it safe I'll make the array one larger.

jmasterx

Member #11,410

October 2009

Mine uses Unichar and uses UTF-8 and std::string, much cleaner & more effective imho.

Agui GUI API -> https://github.com/jmasterx/Agui
Agui 0.2 Release Thread -> https://www.allegro.cc/forums/thread/612830

Nazerith

Member #12,551

February 2011

Unicode does simply down the code, but now its too simplified.

Allegro API Docs said:

keyboard.unichar (int)
A Unicode code point (character). This may be zero or negative if the event was generated for a non-visible "character", such as an arrow key. In that case you can act upon the keycode field.

So a simple test of "ev.keyboard.unichar > 0" should do right? Well it does for arrow keys and delete, but not for esc, backspace and a number of other keys that are "non-visible". So now I have the opposite issue...I've got to test for every key that doesn't belong. While obviously easier in the long run (if you are shooting for international keyboards), its still a pain.

Urg.

For those out their who have messed with the unicode field before, you have a simple way to filter out the garbage?

jmasterx

Member #11,410

October 2009

#SelectExpand
  1void AguiTextBox::handleKeyboard( const AguiKeyEventArgs &keyArgs )
  2{
  3
forceShowCaret();
resetCaretBlinkTime();
if(keyArgs.getExtendedKey() == AGUI_EXT_KEY_UP)
{
  keyPositionCaret(getCaretColumn(),getCaretRow() - 1);
  return;
}
else if(keyArgs.getExtendedKey() == AGUI_EXT_KEY_DOWN)
{
  keyPositionCaret(getCaretColumn(),getCaretRow() + 1);
  return;
}
else if(keyArgs.getExtendedKey() == AGUI_EXT_KEY_LEFT)
{
  keyPositionCaret(getCaretColumn() - 1,getCaretRow());
  return;
}
else if(keyArgs.getExtendedKey() == AGUI_EXT_KEY_RIGHT)
{
  keyPositionCaret(getCaretColumn() + 1,getCaretRow());
  return;
}
else if(keyArgs.getKey() == AGUI_KEY_BACKSPACE)
{
  removeLastCharacter();
}
else if(keyArgs.getKey() == AGUI_KEY_DELETE)
{
  removeNextCharacter();
}
else if(keyArgs.getKey() == AGUI_KEY_ENTER)
{
  addToNextCharacter('\n');
}
else if(keyArgs.getUnichar() >= ' ')
{
  addToNextCharacter(keyArgs.getUnichar());
}
 42
 43
 44}

Agui GUI API -> https://github.com/jmasterx/Agui
Agui 0.2 Release Thread -> https://www.allegro.cc/forums/thread/612830

Tobias Dammers

Member #2,604

August 2002

Nazerith said:

Those are assumptions you're making, and they're both wrong.
1) A string is backed by a std::vector internally, which means that it only resizes when its capacity would otherwise be exceeded, and when it does, it grows exponentially (e.g., double its capacity on every overflow). You are growing every ten concatenations, which is O(n); std::string grows at O(log n).
2) Although std::string looks horribly complicated when you look at the source code, most of that complexity is executed at compile time, not at run time. The result is pretty efficient. Using things like strcat(), however, is horribly inefficient due to an inherent problem with null-terminated strings. Here's a bit of reading for you: http://en.wikipedia.org/wiki/Schlemiel_the_Painter%27s_algorithm (or might as well read the original article: http://www.joelonsoftware.com/articles/fog0000000319.html). In other words, a naive C-string implementation is almost certainly less efficient than a naive std::string implementation (std::string maintains a string length counter internally, so getting the length or finding the 'past-the-end' position is O(1)).

---
Me make music: Triofobie
---
"We need Tobias and his awesome trombone, too." - Johan Halmén

jmasterx

Member #11,410

October 2009

Since it uses a std::vector you should also be able to reserve x, that way if you know about how much you will need you can preallocate it.

Agui GUI API -> https://github.com/jmasterx/Agui
Agui 0.2 Release Thread -> https://www.allegro.cc/forums/thread/612830