wagic/projects/mtg/src/SimplePad.cpp

#include "PrecompiledHeader.h"

#include "SimplePad.h"
#include "JTypes.h"
#include "GameApp.h"
#include "Translate.h"


#define ALPHA_COLUMNS 8
#define ALPHA_ROWS 8

#define KPD_UP 0
#define KPD_DOWN 1
#define KPD_LEFT 2
#define KPD_RIGHT 3

SimpleKey::SimpleKey( string _ds, int _id){
  displayValue = _ds; id = _id; 
  for(int x=0;x<4;x++) 
    adjacency[x] = KPD_NOWHERE;
}

void SimplePad::linkKeys(int from, int to, int dir){

  if(keys[from] && keys[to]){
  keys[from]->adjacency[dir] = to;
  switch(dir){
    case KPD_UP:
    case KPD_LEFT:
      dir++;
      break;
    default:
      dir--;
  }
  keys[to]->adjacency[dir] = from;
  }
}

SimplePad::SimplePad(){
  nbitems = 0;
  bActive = false;
  selected = 0;
  priorKey = 0;
  cursor = 0;
  bShowCancel = false;
  bShowNumpad = false;
  bCapslock = true;
  char buf[2];
  buf[1] = '\0';
  SimpleKey * k;

  for(int x=0;x<KPD_MAX;x++)
    keys[x] = NULL;

  //Add the alphabet. We cheat a bit here.
  for(int x='a';x<='z';x++)
  {
    buf[0] = x;
    k=Add(buf,x);
    int idx = x-'a';

    if(idx > KPD_A)
      k->adjacency[KPD_LEFT] = idx-1;
    if(idx < KPD_Z)
      k->adjacency[KPD_RIGHT] = idx+1;
    if(idx > ALPHA_COLUMNS)
      k->adjacency[KPD_UP] = idx-1-ALPHA_COLUMNS;
    else 
      k->adjacency[KPD_UP] = KPD_INPUT;
    if(idx < 25-ALPHA_COLUMNS)
      k->adjacency[KPD_DOWN] = idx+1+ALPHA_COLUMNS;
  }

  Add(_("Spacebar"),KPD_SPACE);
  
  for(int x=25-ALPHA_COLUMNS;x<26;x++)
    keys[x]->adjacency[KPD_DOWN] = KPD_SPACE;

  k=Add(_("Confirm"),KPD_OK);
  keys[KPD_Z]->adjacency[KPD_RIGHT] = KPD_OK;
  k->adjacency[KPD_UP] = KPD_CAPS;
  k->adjacency[KPD_LEFT] = KPD_Z;
  k->adjacency[KPD_DOWN] = KPD_CANCEL;

  k=Add(_("Cancel"),KPD_CANCEL);
  k->adjacency[KPD_UP] = KPD_OK;
  k->adjacency[KPD_LEFT] = KPD_SPACE;

  k=Add(_("Del"),KPD_DEL);
  keys[KPD_I]->adjacency[KPD_RIGHT] = KPD_DEL;   
  k->adjacency[KPD_UP] = KPD_9;
  k->adjacency[KPD_DOWN] = KPD_CAPS;
  k->adjacency[KPD_LEFT] = KPD_I;
  
  k=Add(_("Caps"),KPD_CAPS);
  keys[KPD_R]->adjacency[KPD_RIGHT] = KPD_CAPS;
  keys[KPD_R]->adjacency[KPD_DOWN] = KPD_Z; 
  k->adjacency[KPD_UP] = KPD_DEL;
  k->adjacency[KPD_DOWN] = KPD_OK;
  k->adjacency[KPD_LEFT] = KPD_R;


  for(int x=0;x<10;x++){
    buf[0] = '0'+x;
    Add(buf,KPD_0+x);
    if(x < 8)
      linkKeys(KPD_0+x,KPD_A+x,KPD_DOWN);
    if(x > 0)
      linkKeys(KPD_0+x,KPD_0+x-1,KPD_LEFT);
  }

  keys[KPD_8]->adjacency[KPD_DOWN] = KPD_DEL;
  keys[KPD_9]->adjacency[KPD_DOWN] = KPD_DEL;

  keys[KPD_0]->adjacency[KPD_LEFT] = KPD_NOWHERE;   
  keys[KPD_A]->adjacency[KPD_LEFT] = KPD_NOWHERE;   
  keys[KPD_J]->adjacency[KPD_LEFT] = KPD_NOWHERE;   
  keys[KPD_S]->adjacency[KPD_LEFT] = KPD_NOWHERE;   

}

SimplePad::~SimplePad()
{
  for(int x=0;x<KPD_MAX;x++)
    SAFE_DELETE(keys[x]);
}


SimpleKey * SimplePad::Add(string display, unsigned char id){
  if(nbitems >= KPD_MAX)
    return NULL;

  keys[nbitems++] = NEW SimpleKey(display,id);
  return keys[nbitems-1];
}
void SimplePad::pressKey(unsigned char key){
  string input = "";

  if(isalpha(key))  {
    if(bCapslock)
      input += toupper(key);
    else
      input += key;
 
   if(cursor < buffer.size())
      cursor++;

    buffer.insert(cursor,input);

   //Auto swap capitalization
   if(bCapslock && buffer.size() == 1)
     bCapslock = !bCapslock;
  }
  else if(key == KPD_SPACE){  
    if(cursor < buffer.size())
      cursor++;
    buffer.insert(cursor," ");
  }
  else if(key == KPD_CAPS)
    bCapslock = !bCapslock;
  else if(key == KPD_DEL) {
    if(!buffer.size())
      return;

    if(cursor >= buffer.size()) {
      cursor = buffer.size();
      buffer = buffer.substr(0,cursor-1);
    }
    else
      buffer = buffer.substr(0,cursor) + buffer.substr(cursor+1);
    
    cursor--;
  }
  else if(key == KPD_OK) 
    Finish();
  else if(key == KPD_CANCEL) {
    bCanceled = true;
    Finish();
  }

}
void SimplePad::MoveSelection(unsigned char moveto)
{
  if(!bShowNumpad && moveto >= KPD_0 && moveto <= KPD_9 )
    moveto = KPD_INPUT;
  else if(!bShowCancel && moveto == KPD_CANCEL )
    moveto = KPD_SPACE;

  if (selected < KPD_MAX && selected >= 0)
    priorKey = selected;

  if (moveto < KPD_MAX)
    selected = moveto;
  else if (moveto == KPD_INPUT)
    selected = KPD_INPUT;
}

void SimplePad::Update(float dt){
  JGE * mEngine = JGE::GetInstance();
  JButton key = mEngine->ReadButton();

  //Start button changes capslock setting.
  if (key == JGE_BTN_MENU)
  {
    if (selected != KPD_OK)
      selected = KPD_OK;
    else
      Finish();
   }
  else if (key == JGE_BTN_CTRL)
    bCapslock = !bCapslock;

  if (selected == KPD_SPACE){
    if (bShowCancel && mEngine->GetButtonClick(JGE_BTN_RIGHT))
      selected = KPD_CANCEL;
    else if (key == JGE_BTN_LEFT || key == JGE_BTN_RIGHT
      || key == JGE_BTN_UP || key == JGE_BTN_DOWN)
      selected = priorKey;
  } //Moving within/from the text field.
  else if (selected == KPD_INPUT){
    if (key == JGE_BTN_DOWN )
      selected = priorKey;
    if (key == JGE_BTN_LEFT && cursor > 0) cursor--;
    else if (key == JGE_BTN_RIGHT && cursor < buffer.size()) cursor++;
  }
  else if (selected >= 0 && keys[selected]){
    if (key == JGE_BTN_LEFT)
      MoveSelection(keys[selected]->adjacency[KPD_LEFT]);
    else if (key == JGE_BTN_RIGHT)
      MoveSelection(keys[selected]->adjacency[KPD_RIGHT]);
    if (key == JGE_BTN_DOWN)
      MoveSelection(keys[selected]->adjacency[KPD_DOWN]);
    else if (key == JGE_BTN_UP)
      MoveSelection(keys[selected]->adjacency[KPD_UP]);
  }


  //These bits require a valid key...
  if (selected >= 0 && selected < nbitems && keys[selected])
    if (key == JGE_BTN_OK)
      pressKey(keys[selected]->id);
  if (buffer.size() > 0 && key == JGE_BTN_SEC)
    buffer = buffer.substr(0, buffer.size() - 1);
  if (buffer.size() && key == JGE_BTN_PREV) {
    if (cursor > 0) cursor--;
  }
  else if (key == JGE_BTN_NEXT) {
    if (cursor < buffer.size())
        cursor++;
    else {
      buffer += ' ';
      cursor = buffer.size();
    }
  }

  mX = 50;
  mY = 50;

  //Clear input buffer.
  mEngine->ResetInput();
}
void SimplePad::Start(string value, string * _dest) {
  bActive = true;
  bCanceled=false;
  buffer = value;
  original = buffer;
  dest = _dest;
  cursor = buffer.size();
  //Clear input buffer.
  JGE * mEngine = JGE::GetInstance();
  mEngine->ResetInput();
}

string SimplePad::Finish() {
  bActive = false;
  
  //Clear input buffer.
  JGE * mEngine = JGE::GetInstance();
  mEngine->ResetInput();

  //Return result.
  if(bCanceled){
    dest = NULL;
    return original;
  }else{ //Strip trailing spaces.
    string whitespaces (" \t\f\v\n\r");
    size_t found=buffer.find_last_not_of(whitespaces);
    if (found!=string::npos)
      buffer.erase(found+1);
    else
      buffer = "";
  }

  if(dest != NULL){
    dest->clear(); dest->insert(0,buffer);
    dest = NULL;
  }
  return buffer;
}

void SimplePad::Render(){
  //This could use some cleaning up to make margins more explicit
  WFont * mFont = resources.GetWFont(Fonts::MENU_FONT);

  float offX = 0, offY = 0;   
  float kH = mFont->GetHeight();
  float hSpacing = mFont->GetStringWidth("W");
  float rowLen = mFont->GetStringWidth("JKLMNOPQR") + 14*7; 
  float vSpacing = 0;
  float kW = hSpacing;
  
  JRenderer * renderer = JRenderer::GetInstance();

  
  vSpacing = kH+8;
 

  offY = vSpacing;
  if(bShowNumpad)
    offY += kH+14;
  //Draw Keypad Background.
  renderer->FillRoundRect(mX-kW,mY-kH,(kW+12)*13,(kH+14)*5+offY,2,ARGB(180,0,0,0));
  offY = vSpacing;
  //Draw text entry bubble
  renderer->FillRoundRect(mX-kW/2,mY+offY,(kW+12)*11+kW/2,kH,2,ARGB(255,255,255,255));

  //Draw text-entry title, if we've got one.
  if(title != ""){
    mFont->DrawString(_(title.c_str()),mX,mY);
  }
    mY+=kH+12;

  //Draw cursor.
  if(cursor < buffer.size())
  {
    kW = mFont->GetStringWidth(buffer.substr(cursor,1).c_str());
    renderer->FillRoundRect(mX+mFont->GetStringWidth(buffer.substr(0,cursor).c_str()),mY+kH-4,
      kW,4,2,ARGB(150,150,150,0));    
  }
  else
  {
    cursor = buffer.size();
    renderer->FillRoundRect(mX+mFont->GetStringWidth(buffer.substr(0,cursor).c_str()),mY+kH-4,
      kW,4,2,ARGB(150,150,150,0));    
  }
  
  mFont->SetColor(ARGB(255,0,0,0));
  mFont->DrawString(buffer.c_str(),mX,mY);
  offY += kH + 12;

  if(!bShowNumpad)
    vSpacing -= kH + 12;
    
  for(int x=0;x<nbitems;x++)
    if(keys[x]){   

      if((x == KPD_CANCEL && !bShowCancel) || (x >= KPD_0 && x <= KPD_9 && !bShowNumpad))
        continue;
      
      switch(x){
        case KPD_0:  
          offX = 0;
          offY = vSpacing;
          break;
        case KPD_A:  
          offX = 0;
          offY = vSpacing+(kH+12)*1;
          break;
        case KPD_J:
          offX = 0;
          offY = vSpacing+(kH+12)*2;
          break;
        case KPD_S:
          offX = 0;
          offY = vSpacing+(kH+12)*3;
          break;
        case KPD_SPACE:  
          offX = 0;
          offY = vSpacing+(kH+12)*4;
          break;
        case KPD_OK:
          offX = rowLen + hSpacing;
          offY = vSpacing+(kH+12)*3;
          break;
        case KPD_CANCEL:
          offX = rowLen + hSpacing;
          offY = vSpacing+(kH+12)*4;
          break;
        case KPD_DEL:
          offX = rowLen + hSpacing;
          offY = vSpacing+(kH+12)*1;
          break;
        case KPD_CAPS:
          offX = rowLen + hSpacing;
          offY = vSpacing+(kH+12)*2;
          break;
      }

      kW = mFont->GetStringWidth(keys[x]->displayValue.c_str());
      //Render a key.
      if(x != selected){
        renderer->FillRoundRect(mX+offX-4,mY+offY-4,kW+8,kH+4,2,ARGB(180,50,50,50));
        mFont->SetColor(ARGB(255,255,255,0));
      }
      else{
        renderer->FillRoundRect(mX+offX-4,mY+offY-4,kW+8,kH+4,2,ARGB(255,100,100,100));
        mFont->SetColor(ARGB(255,255,255,255));
      }

      char vkey[2];
      vkey[1] = '\0';
      vkey[0] = keys[x]->id;

      
      if(isalpha(vkey[0])) {
        if(bCapslock) vkey[0] = toupper(vkey[0]);
        mFont->DrawString(vkey,mX+offX,mY+offY);
      }
      else
        mFont->DrawString(keys[x]->displayValue.c_str(),mX+offX,mY+offY);
      offX += kW + 14;
    }
}

unsigned int SimplePad::cursorPos(){
  if(cursor > buffer.size())
    return buffer.size();

  return cursor;
}