How do you allow for mouseY to still change the height of an ellipse when inside a keyReleased?

AVRG

//I'm currently trying to create a typeface which will change when using a weighing scale. Right now, I've created the basis for what I believe will work and I'm using mouseY to simulate the use of a weighing scale. But of course, when it's in KeyReleased it doesn't change as key release practically snapshots it. What is the method for getting around this? Many thanks!

void setup(){
  size(600,650);

}

void draw(){
  fill(0,0,0);

} 
void keyReleased(){


//LETTERS

    if(key == 'a' || key == 'A'){

      //X1
      ellipse(200,200,mouseY,mouseY);

      }else{
        //nothing
  }
}

KevinWorkman

Can you please post a shorter example? All you really need is a single ellipse to show what you're having trouble with, right?

AVRG

void setup(){
  size(600,650);

}

void draw(){
  fill(0,0,0);

} 
void keyReleased(){


//LETTERS

    if(key == 'a' || key == 'A'){

      //X1
      ellipse(200,200,mouseY,mouseY);

      }else{
        //nothing
  }
}

AVRG

Apologies,

Above is the more basic example of the code. I'd like the mouseY to still work once the keys been pressed.

Thank you!

KevinWorkman

Please edit your post to fix your formatting by highlighting your code and pressing the code button.

What do you mean when you want the mouseY to still work? What exactly do you expect this code to do? What does it do instead?

AVRG

I'd like the ellipse to be able to grow and shrink using the mouseY value in real time. I'm hoping this will lead me to eventually linking a load cell and an Arduino instead.

Heavier the weight, heavier the typeface.

thank you so much for your patients. I only began learning code two weeks ago.

cheers again,

KevinWorkman

Why do you need the keyReleased() function at all here?

Create a small sketch that just shows a single ellipse whose size changes based on the mouse position.

AVRG

Yeah, i've done that. Thats my backup.

The reason for using keyReleased is so the user can type their own words. I understand it's complex but it's something i'd love to try.

Is there not a simple way to allow the ellipse pasted during the keyReleased to continue to change size according to mouseY?

KevinWorkman

Yeah, split your logic up. Don't put drawing code inside the keyReleased() function. Instead, use the keyReleased() function to modify some sketch-level variables that you then use inside the draw() function.

Chrisir

All that’s necessary here has been said already.

Your architecture is wrong.

Draw everything in draw (). Use mouseY here to define S or whatever.

In keyPressed (or keyReleased) just store the key that has been pressed in a variable and use this variable in draw().

I also hope you can use all letters not only a.

I am on a journey and can’t do the sketch here for you.

Chrisir

Essentially move the content from keyReleased into draw

AVRG

Really struggling to get my head around this as a beginner. If any reader could create an example I'll be very grateful!

Which functions should I research?

Thank you

Chrisir

??

Do what we told you and post your entire example so that we can correct it

AVRG

Apologies I'm having an off day and struggling with this. Below I've moved the content to draw with ellipses in two different locations for testing, the mouseY works! The issue is when a second key is pressed it erases the previous.

Thank you for being patient with me,

void setup(){
      size(600,650);

    }

    void draw(){
      fill(0,0,0);
      background(60,60,60);


          if(key == 'a' || key == 'A'){

          ellipse(200,200,mouseY,mouseY);

          }

          if(key == 'b' || key == 'B'){


          ellipse(300,200,mouseY,mouseY);

     }
    }

Chrisir

So you wish no erasing, right?

Then you want to display a word or sentence?

Say wordMy = wordMy+key; in the function (!) keyPressed

Before setup say String wordMy="";

In draw() use a for loop to loop over wordMy, like text(wordMy.charAt(i), i*72, 120);

or do the ellipses here instead

read tutorials about string etc.

KevinWorkman

It looks like you might be unfamiliar with the concept of creating variables. You can create a variable outside of your functions so that they're shared between the functions. Modify the variable inside the keyReleased() function, and use that variable inside your draw() function.

You should also try to be more specific about exactly what you're trying to do. Break your problem down into smaller steps and take those steps on one at a time. Write down exactly what you want to happen, step-by-step, in English. When you have those steps written out, then you can think about implementing some code.

Chrisir

Instead of key (all of it) in your lines above use variable letter

In first line of draw()

char letter=key;

Chrisir

here is a new version that can receive and store multiple keys (a word) and display it - based on your last code above. It can do only a and b (one ellipse or two).

String word="aba"; 
boolean cursorOn=false;

void setup() {
  size(1200, 650);
}

void draw() {
  background(60, 60, 60); // clear screen

  fill(0, 0, 0);
  noStroke(); 

  float xpos=-10;

  for (int i = 0; i < word.length(); i++) {
    // text(word.charAt(i), i*100, 120);

    char letter = word.charAt(i);
    xpos = i * 100 + 66; 

    if (letter == 'a' || letter == 'A') {
      ellipse(xpos, 200, mouseY, mouseY);
    } else if (letter == 'b' || letter == 'B') {
      ellipse(xpos, 200, mouseY, mouseY);
      ellipse(xpos, 240, mouseY, mouseY);
    }// else if
  } // for

  // The curosor Image (the vertical red line | )
  manageCursorImage(xpos);

  // help text 
  fill(255);
  text("Type a and b and test with mouseY. ", 18, 18);
}//func 

void keyPressed() {
  word = word + key;
}

void manageCursorImage( float xpos ) {

  if (cursorOn) {
    xpos+=100;
    stroke(255, 0, 0); // red  
    line(xpos, 170, xpos, 280);
  }
  if (frameCount%19==0) {
    cursorOn=!cursorOn;
  }
}

Chrisir

here is a new version that shows the letters of the entire alphabet if you type them

the ellipses of the letter change their size with mouseY

it's based on my first sketch in your other discussion

https://forum.processing.org/two/discussion/26229/typeface-which-changes-with-a-kitchen-scale-issues

// https : // forum.processing.org/two/discussion/comment/79932/#Comment_79932

ArrayList<PVector[]> list = new ArrayList(); 
PGraphics pg=new PGraphics();
PFont f;

String word = "aba";
boolean cursorOn=false;

void setup() {

  size(1960, 1000);
  background(0);

  f = createFont("Arial", 300); // "AR BERKLEY", 300 ) ; // 
  textFont(f);
  fill(0);

  pg = createGraphics(400, 400);
  pg.noSmooth();

  for (int i='A'; i<='Z'; i++) {

    makeLetter(char(i));

    PVector[] pv= new PVector[0]; 

    for (int x=0; x < pg.width; x+=2) {
      for (int y=0; y < pg.height; y+=3) {
        if (pg.get(x, y) < color(1)) 
          //point(x, y) ;
          pv=(PVector[])append(pv, new PVector(x, y));
      }//for
    }//for

    list.add(pv);
  }//for
  //
}//func

void draw() {
  //
  background(60, 60, 60); // clear screen
  fill(0, 0, 0);
  noStroke(); 
  float xpos=-10;

  // for loop over word 
  for (int i = 0; i < word.length(); i++) {
    char letter = word.charAt(i);
    xpos = i * 210 + 66;
    showOneLetter(letter, xpos, 210);
  }//for 

  // increase for cursor
  xpos += 140;

  // The curosor Image (the vertical red line | )
  manageCursorImage(xpos);

  // help text 
  fill(255); // white
  textSize(20);
  text("Type any key and test with mouseY. ", 18, 18);
}//func

// -----------------------------------------------------------------

void showOneLetter(char letter, float x, float y) {

  letter=str(letter).toUpperCase().charAt(0); 

  PVector[] pvector_Array = list.get(letter-65);

  pushMatrix();
  translate(x, y);
  for (PVector pv : pvector_Array) {
    // point(pv.x, pv.y) ;
    noStroke(); 
    fill(0, 255, 0);
    ellipse(pv.x, pv.y, mouseY/16, mouseY/16);
  }
  popMatrix();
}//func

void makeLetter (char letter) {
  // for init
  pg.beginDraw();
  pg.background(255);
  pg.textFont(f);
  pg.fill(0);
  pg.text(letter, 4, 223);//"D"
  //pg.text(letter, 3, .5);//"D"
  pg.endDraw();
}

void keyPressed() {
  word = word + key;
}

void manageCursorImage( float xpos ) {
  // The curosor Image (the vertical red line | )  
  if (cursorOn) {
    xpos+=100;
    stroke(255, 0, 0); // red  
    line(xpos, 170, xpos, 450);
  }

  if (frameCount%3==0) {
    cursorOn=!cursorOn;
  }
}
// 

Chrisir

This version is based on the textual star "*" images of each letter in the sketch below.

It is based on my sketch on github, see link in your other discussion:

https://forum.processing.org/two/discussion/26229/typeface-which-changes-with-a-kitchen-scale-issues

// shows a sentence / word
// code from the forum not by me
// https : // forum.processing.org/two/discussion/26229/typeface-which-changes-with-a-kitchen-scale-issues#latest
// https : // forum.processing.org/two/discussion/comment/79932/#Comment_79932

// variables =============================================

int bufferWritePosition = 0;

String[] buffer = new String[1256];

String word = "aba";
boolean cursorOn=false;

void setup() {
  size(1960, 1000);
  background(0);
}//func

void draw() {
  //
  background(60, 60, 60); // clear screen
  fill(0, 0, 0);
  noStroke(); 
  float xpos=-10;

  // for loop over word 
  for (int i = 0; i < word.length(); i++) {
    char letter = word.charAt(i);
    xpos = i * 111 + 166;
    showOneLetter(letter, xpos, 210);
  }//for 

  // increase for cursor
  xpos += 33;

  // The curosor Image (the vertical red line | )
  manageCursorImage(xpos);

  // help text 
  fill(255); // white
  textSize(20);
  text("Type any key and test with mouseY. ", 18, 18);
}//func

// ------------------------------------------------------------------------------------

void showOneLetter(char letter, float x, float y) {

  float factorBetweenLetters=x; 
  float factorBetweenEllipses=12; 

  // letter=str(letter).toUpperCase().charAt(0); 

  //  PVector[] pvector_Array = list.get(letter-65);

  // set buffer now
  keyPaintHelper(letter);

  int EllipseCount=0; 

  for (int j = 0; j < bufferWritePosition; j++) {
    for (int k = 0; k < buffer[j].length(); k++) {

      if (buffer[j].charAt(k) == '*') {
        // has a * 
        PVector newPVector = new PVector( 
          x + j*factorBetweenEllipses, 
          300-(k*factorBetweenEllipses)+100 );

        fill(0);
        float sizeEllipse=map(mouseY, 
          0, height, 
          1, 111); 

        ellipse(newPVector.x, newPVector.y, 
          sizeEllipse, sizeEllipse);
      } // if
    } // for
  } // for
}//func

void keyPressed() {
  word = word + key;
  println (word);
}

void manageCursorImage( float xpos ) {
  // The curosor Image (the vertical red line | )  
  if (cursorOn) {
    xpos+=100;
    stroke(255, 0, 0); // red  
    line(xpos, 170, xpos, 450);
  }

  if (frameCount%13==0) {
    cursorOn=!cursorOn;
  }
}

// --------------------------------------------------------------

void keyPaintHelper(char InputKeyOfFunction) {

  // Building letters from sets of stars (*).

  char k = Character.toUpperCase(InputKeyOfFunction);
  //letterSpacing=0;

  // Init complete letter with 
  bufferWritePosition=0; 
  buffer[bufferWritePosition + 0] = "         ";
  buffer[bufferWritePosition + 1] = "         ";
  buffer[bufferWritePosition + 2] = "         ";
  buffer[bufferWritePosition + 3] = "         ";
  buffer[bufferWritePosition + 4] = "         ";
  buffer[bufferWritePosition + 5] = "         ";
  buffer[bufferWritePosition + 6] = "         ";


  switch(k) {
  case 'A':
    buffer[bufferWritePosition + 0] = " ******  ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = "   *   * ";
    buffer[bufferWritePosition + 3] = "   *   * ";
    buffer[bufferWritePosition + 4] = " ******* ";
    buffer[bufferWritePosition + 5] = " ******  ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'B':
    buffer[bufferWritePosition + 0] = " ******* ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = " *  *  * ";
    buffer[bufferWritePosition + 3] = " *  *  * ";
    buffer[bufferWritePosition + 4] = " ******* ";
    buffer[bufferWritePosition + 5] = "  ** **  ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'C':
    buffer[bufferWritePosition + 0] = "  *****  ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = " *     * ";
    buffer[bufferWritePosition + 3] = " *     * ";
    buffer[bufferWritePosition + 4] = " *     * ";
    buffer[bufferWritePosition + 5] = "  *   *  ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'D':
    buffer[bufferWritePosition + 0] = " ******* ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = " *     * ";
    buffer[bufferWritePosition + 3] = " **   ** ";
    buffer[bufferWritePosition + 4] = "  *****  ";
    buffer[bufferWritePosition + 5] = "   ***   ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'E':
    buffer[bufferWritePosition + 0] = " ******* ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = " *  *  * ";
    buffer[bufferWritePosition + 3] = " *  *  * ";
    buffer[bufferWritePosition + 4] = " *  *  * ";
    buffer[bufferWritePosition + 5] = " *     * ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'F':
    buffer[bufferWritePosition + 0] = " ******* ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = "    *  * ";
    buffer[bufferWritePosition + 3] = "    *  * ";
    buffer[bufferWritePosition + 4] = "    *  * ";
    buffer[bufferWritePosition + 5] = "       * ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'G':
    buffer[bufferWritePosition + 0] = "  *****  ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = " ** *  * ";
    buffer[bufferWritePosition + 3] = " ** *  * ";
    buffer[bufferWritePosition + 4] = " **** ** ";
    buffer[bufferWritePosition + 5] = " **** *  ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'H':
    buffer[bufferWritePosition + 0] = " ******* ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = "    *    ";
    buffer[bufferWritePosition + 3] = "    *    ";
    buffer[bufferWritePosition + 4] = " ******* ";
    buffer[bufferWritePosition + 5] = " ******* ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;

  case 'I':
    buffer[bufferWritePosition + 0] = "         ";
    buffer[bufferWritePosition + 1] = " *     * ";
    buffer[bufferWritePosition + 2] = " ******* ";
    buffer[bufferWritePosition + 3] = " ******* ";
    buffer[bufferWritePosition + 4] = " *     * ";
    buffer[bufferWritePosition + 5] = "         ";
    bufferWritePosition += 6;
    break;
  case 'J':
    buffer[bufferWritePosition + 0] = "  **     ";
    buffer[bufferWritePosition + 1] = " ***     ";
    buffer[bufferWritePosition + 2] = " *     * ";
    buffer[bufferWritePosition + 3] = " ******* ";
    buffer[bufferWritePosition + 4] = "  ****** ";
    buffer[bufferWritePosition + 5] = "       * ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'K':
    buffer[bufferWritePosition + 0] = " ******* ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = "   ***   ";
    buffer[bufferWritePosition + 3] = "  ** **  ";
    buffer[bufferWritePosition + 4] = " **   ** ";
    buffer[bufferWritePosition + 5] = " *     * ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'L':
    buffer[bufferWritePosition + 0] = "         ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = " ******* ";
    buffer[bufferWritePosition + 3] = " *       ";
    buffer[bufferWritePosition + 4] = " *       ";
    buffer[bufferWritePosition + 5] = " *       ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'M':
    buffer[bufferWritePosition + 0] = " ******  ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = "    **** ";
    buffer[bufferWritePosition + 3] = "  ****   ";
    buffer[bufferWritePosition + 4] = "  ****   ";
    buffer[bufferWritePosition + 5] = "    **** ";
    buffer[bufferWritePosition + 6] = " ******* ";
    buffer[bufferWritePosition + 7] = " ******  ";
    buffer[bufferWritePosition + 8] = "         ";
    bufferWritePosition += 9;
    break;
  case 'N':
    buffer[bufferWritePosition + 0] = " ******* ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = "    **   ";
    buffer[bufferWritePosition + 3] = "   **    ";
    buffer[bufferWritePosition + 4] = " ******* ";
    buffer[bufferWritePosition + 5] = " ******* ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'O':
    buffer[bufferWritePosition + 0] = "  *****  ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = " *     * ";
    buffer[bufferWritePosition + 3] = " *     * ";
    buffer[bufferWritePosition + 4] = " ******* ";
    buffer[bufferWritePosition + 5] = "  *****  ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;

  case 'P':
    buffer[bufferWritePosition + 0] = " ******* ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = "    *  * ";
    buffer[bufferWritePosition + 3] = "    *  * ";
    buffer[bufferWritePosition + 4] = "    **** ";
    buffer[bufferWritePosition + 5] = "     **  ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;

  case 'Q':
    buffer[bufferWritePosition + 0] = "  *****  ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = " **    * ";
    buffer[bufferWritePosition + 3] = " **    * ";
    buffer[bufferWritePosition + 4] = "******** ";
    buffer[bufferWritePosition + 5] = "* *****  ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;

    break;
  case 'R':
    buffer[bufferWritePosition + 0] = " ******* ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = "   **  * ";
    buffer[bufferWritePosition + 3] = "  ***  * ";
    buffer[bufferWritePosition + 4] = " ** **** ";
    buffer[bufferWritePosition + 5] = " *   **  ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;

    break;
  case 'S':
    buffer[bufferWritePosition + 0] = "  ** **  ";
    buffer[bufferWritePosition + 1] = " ** **** ";
    buffer[bufferWritePosition + 2] = " *  *  * ";
    buffer[bufferWritePosition + 3] = " *  *  * ";
    buffer[bufferWritePosition + 4] = " **** ** ";
    buffer[bufferWritePosition + 5] = "  ** **  ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;

  case 'T':
    buffer[bufferWritePosition + 0] = "       * ";
    buffer[bufferWritePosition + 1] = "       * ";
    buffer[bufferWritePosition + 2] = " ******* ";
    buffer[bufferWritePosition + 3] = " ******* ";
    buffer[bufferWritePosition + 4] = "       * ";
    buffer[bufferWritePosition + 5] = "       * ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'U':
    buffer[bufferWritePosition + 0] = "  ****** ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = " *       ";
    buffer[bufferWritePosition + 3] = " *       ";
    buffer[bufferWritePosition + 4] = " ******* ";
    buffer[bufferWritePosition + 5] = "  ****** ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'V':
    buffer[bufferWritePosition + 0] = "   ***** ";
    buffer[bufferWritePosition + 1] = "  ****** ";
    buffer[bufferWritePosition + 2] = " **      ";
    buffer[bufferWritePosition + 3] = " **      ";
    buffer[bufferWritePosition + 4] = "  ****** ";
    buffer[bufferWritePosition + 5] = "   ***** ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'W':
    // letterSpacing=-6 ; // -6 for 'W'
    buffer[bufferWritePosition + 0] = "  ****** ";
    buffer[bufferWritePosition + 1] = " ******* ";
    buffer[bufferWritePosition + 2] = " **      ";
    buffer[bufferWritePosition + 3] = "  ****   ";
    buffer[bufferWritePosition + 4] = "  ****   ";
    buffer[bufferWritePosition + 5] = " **      ";
    buffer[bufferWritePosition + 6] = " ******* ";
    buffer[bufferWritePosition + 7] = "  ****** ";
    buffer[bufferWritePosition + 8] = "         ";
    bufferWritePosition += 9;
    break;
  case 'X':
    buffer[bufferWritePosition + 0] = " **   ** ";
    buffer[bufferWritePosition + 1] = " *** *** ";
    buffer[bufferWritePosition + 2] = "   ***   ";
    buffer[bufferWritePosition + 3] = "   ***   ";
    buffer[bufferWritePosition + 4] = " *** *** ";
    buffer[bufferWritePosition + 5] = " **   ** ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'Y':
    buffer[bufferWritePosition + 0] = "     *** ";
    buffer[bufferWritePosition + 1] = "    **** ";
    buffer[bufferWritePosition + 2] = " ****    ";
    buffer[bufferWritePosition + 3] = " ****    ";
    buffer[bufferWritePosition + 4] = "    **** ";
    buffer[bufferWritePosition + 5] = "     *** ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case 'Z':
    buffer[bufferWritePosition + 0] = " **    * ";
    buffer[bufferWritePosition + 1] = " ***   * ";
    buffer[bufferWritePosition + 2] = " * **  * ";
    buffer[bufferWritePosition + 3] = " *  ** * ";
    buffer[bufferWritePosition + 4] = " *   *** ";
    buffer[bufferWritePosition + 5] = " *    ** ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case '.':
    buffer[bufferWritePosition + 0] = " **      ";
    buffer[bufferWritePosition + 1] = " **      ";
    buffer[bufferWritePosition + 2] = "         ";
    bufferWritePosition += 3;
    break;
  case ',':
    buffer[bufferWritePosition + 0] = "*        ";
    buffer[bufferWritePosition + 1] = "***      ";
    buffer[bufferWritePosition + 2] = " **      ";
    buffer[bufferWritePosition + 3] = "         ";
    bufferWritePosition += 4;
    break;
  case '\'':
    buffer[bufferWritePosition + 0] = "     *** ";
    buffer[bufferWritePosition + 1] = "     *** ";
    buffer[bufferWritePosition + 2] = "         ";
    bufferWritePosition += 3;
    break;
  case '?':
    buffer[bufferWritePosition + 0] = "      *  ";
    buffer[bufferWritePosition + 1] = "      ** ";
    buffer[bufferWritePosition + 2] = " * *   * ";
    buffer[bufferWritePosition + 3] = " * **  * ";
    buffer[bufferWritePosition + 4] = "    **** ";
    buffer[bufferWritePosition + 5] = "     **  ";
    buffer[bufferWritePosition + 6] = "         ";
    bufferWritePosition += 7;
    break;
  case '!':
    buffer[bufferWritePosition + 0] = "         ";
    buffer[bufferWritePosition + 1] = " * ***** ";
    buffer[bufferWritePosition + 2] = " * ***** ";
    buffer[bufferWritePosition + 3] = "         ";
    bufferWritePosition += 4;
    break;
  case '-':
    buffer[bufferWritePosition + 0] = "   **    ";
    buffer[bufferWritePosition + 1] = "   **    ";
    buffer[bufferWritePosition + 2] = "   **    ";
    buffer[bufferWritePosition + 3] = "         ";
    bufferWritePosition += 4;
    break;
  case ' ':
    buffer[bufferWritePosition + 0] = "         ";
    buffer[bufferWritePosition + 1] = "         ";
    buffer[bufferWritePosition + 2] = "         ";
    buffer[bufferWritePosition + 3] = "         ";
    bufferWritePosition += 4;
    break;

  default:
    // Error
    println ("Error 416 ");
    exit();
    break;
    //
  }//switch 
  //
}// func 
//

AVRG

Wow, just looked back at this. Thank you so much Chrisir. Great work.

Chrisir

Sure!

AVRG

So, thanks to you Chrisir I have more or less completed my project. I have now attached the typeface to an Arduino and a kitchen scale, it works great! (so instead of the mouseY its the weight placed on the scale).

I added code so it drops down a line when it reaches the edge of the page and starts at the top again when it reaches the bottom. Thank you so much for your help. (I didn't use the buffer because I felt the need to use my own longer technique for grade reasons(hence the partial alphabet on here)) I'll continue to play around but I'm ever so grateful.

    import processing.serial.*;

    String word=""; //where the data of which keys were pressed reside

    void setup() {
      fullScreen();
     cursor(CROSS);
    }

    void draw() {
      background(200); // clear screen
      fill(0, 0, 0, 90);
      //fill( random(255), random(255), random(255), random(255)); 
      noStroke(); 

      textSize(20);
      text(mouseY, 100, 70);  


          float x= -85;
          float y=150;
          float start= 100; //start of line
          float S = width/150; //spacing between dots
          float SIZE = mouseY/15;//size of the ellipses
          float YP = (S*25); // Y placing
          float moon = S*15;//spacing between letters

          for (int i = 0; i < word.length(); i++) {
            // text(word.charAt(i), i*100, 120);

            char letter = word.charAt(i);
            //x = i * moon + start; //placing of the letter // i = the size

            x += moon;


            //------change the line 
            if (x >(width - 200 )) { 

              x = start;
              y+= YP;
            }

            //------ENTER 
            if (key == ENTER) {

              x = start;
              y += YP;
            }

            //-------go back to the start 
            if (y >(height - 200 )) { 

              x = start;
              y = 150;
              background(200);
              word = "";
            }


            //-------LETTERS 

            if (letter == 'a' || letter == 'A') {
              ellipse(x+(S*1), y+(S*1 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*2 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*3 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*4 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*5 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*6 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*7 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*8 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*9 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*10), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*11), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*12), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*13), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*14), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*15), SIZE, SIZE);
              //X2
              ellipse(x+(S*2), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*2), y+(S*8), SIZE, SIZE);
              //X3
              ellipse(x+(S*3), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*3), y+(S*8), SIZE, SIZE);
              //X4
              ellipse(x+(S*4), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*4), y+(S*8), SIZE, SIZE);
              //X5
              ellipse(x+(S*5), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*5), y+(S*8), SIZE, SIZE);
              //X6
              ellipse(x+(S*6), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*6), y+(S*8), SIZE, SIZE);
              //X7
              ellipse(x+(S*7), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*7), y+(S*8), SIZE, SIZE);
              //X8
              ellipse(x+(S*8), y+(S*2), SIZE, SIZE);
              ellipse(x+(S*8), y+(S*8), SIZE, SIZE);
              //X9
              //ellipse(x+(S*9),y+(S*1 ),SIZE,SIZE);
              //ellipse(x+(S*9),y+(S*2 ),SIZE,SIZE);
              ellipse(x+(S*9), y+(S*3 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*4 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*5 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*6 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*7 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*8 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*9 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*10), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*11), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*12), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*13), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*14), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*15), SIZE, SIZE);

            } else if (letter == 'b' || letter == 'B') {

              //X1
              ellipse(x+(S*1), y+(S*1 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*2 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*3 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*4 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*5 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*6 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*7 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*8 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*9 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*10), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*11), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*12), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*13), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*14), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*15), SIZE, SIZE);
              //X2
              ellipse(x+(S*2), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*2), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*2), y+(S*15), SIZE, SIZE);
              //X3
              ellipse(x+(S*3), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*3), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*3), y+(S*15), SIZE, SIZE);
              //X4
              ellipse(x+(S*4), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*4), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*4), y+(S*15), SIZE, SIZE);
              //X5
              ellipse(x+(S*5), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*5), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*5), y+(S*15), SIZE, SIZE);
              //X6
              ellipse(x+(S*6), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*6), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*6), y+(S*15), SIZE, SIZE);
              //X7
              ellipse(x+(S*7), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*7), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*7), y+(S*15), SIZE, SIZE);
              //X8
              ellipse(x+(S*8), y+(S*2), SIZE, SIZE);
              ellipse(x+(S*8), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*8), y+(S*14), SIZE, SIZE);
              //X9
              ellipse(x+(S*9), y+(S*3 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*4 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*5 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*6 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*7 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*9 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*10), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*11), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*12), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*13), SIZE, SIZE);

            } else if (letter == 'c' || letter == 'C') {
              //X1
              ellipse(x+(S*1), y+(S*4 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*5 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*6 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*7 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*8 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*9 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*10), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*11), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*12), SIZE, SIZE);
              //X2
              ellipse(x+(S*2), y+(S*2), SIZE, SIZE);
              ellipse(x+(S*2), y+(S*3), SIZE, SIZE);
              ellipse(x+(S*2), y+(S*13), SIZE, SIZE);
              ellipse(x+(S*2), y+(S*14), SIZE, SIZE);
              //X3
              ellipse(x+(S*3), y+(S*2), SIZE, SIZE);
              ellipse(x+(S*3), y+(S*14), SIZE, SIZE);
              //X4
              ellipse(x+(S*4), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*4), y+(S*15), SIZE, SIZE);
              //X5
              ellipse(x+(S*5), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*5), y+(S*15), SIZE, SIZE);
              //X6
              ellipse(x+(S*6), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*6), y+(S*15), SIZE, SIZE);
              //X7
              ellipse(x+(S*7), y+(S*2), SIZE, SIZE);
              ellipse(x+(S*7), y+(S*14), SIZE, SIZE);
              //X8
              ellipse(x+(S*8), y+(S*2), SIZE, SIZE);
              ellipse(x+(S*8), y+(S*3), SIZE, SIZE);
              ellipse(x+(S*8), y+(S*13), SIZE, SIZE);
              ellipse(x+(S*8), y+(S*14), SIZE, SIZE);
              //X9
              ellipse(x+(S*9), y+(S*4 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*5 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*11), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*12), SIZE, SIZE);

            } else if (letter == 'd' || letter == 'D') {
              //X1
              ellipse(x+(S*1), y+(S*1 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*2 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*3 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*4 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*5 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*6 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*7 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*8 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*9 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*10), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*11), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*12), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*13), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*14), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*15), SIZE, SIZE);
              //X2
              ellipse(x+(S*2), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*2), y+(S*15), SIZE, SIZE);
              //X3
              ellipse(x+(S*3), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*3), y+(S*15), SIZE, SIZE);
              //X4
              ellipse(x+(S*4), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*4), y+(S*15), SIZE, SIZE);
              //X5
              ellipse(x+(S*5), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*5), y+(S*15), SIZE, SIZE);
              //X6
              ellipse(x+(S*6), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*6), y+(S*15), SIZE, SIZE);
              //X7
              ellipse(x+(S*7), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*7), y+(S*15), SIZE, SIZE);
              //X8
              ellipse(x+(S*8), y+(S*2), SIZE, SIZE);
              ellipse(x+(S*8), y+(S*14), SIZE, SIZE);
              //X9
              ellipse(x+(S*9), y+(S*3 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*4 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*5 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*6 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*7 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*8 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*9 ), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*10), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*11), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*12), SIZE, SIZE);
              ellipse(x+(S*9), y+(S*13), SIZE, SIZE);

            } else if (letter == 'e' || letter == 'E') {
              //X1
              ellipse(x+(S*1), y+(S*1 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*2 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*3 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*4 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*5 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*6 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*7 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*8 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*9 ), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*10), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*11), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*12), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*13), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*14), SIZE, SIZE);
              ellipse(x+(S*1), y+(S*15), SIZE, SIZE);
              //X2
              ellipse(x+(S*2), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*2), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*2), y+(S*15), SIZE, SIZE);
              //X3
              ellipse(x+(S*3), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*3), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*3), y+(S*15), SIZE, SIZE);
              //X4
              ellipse(x+(S*4), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*4), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*4), y+(S*15), SIZE, SIZE);
              //X5
              ellipse(x+(S*5), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*5), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*5), y+(S*15), SIZE, SIZE);
              //X6
              ellipse(x+(S*6), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*6), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*6), y+(S*15), SIZE, SIZE);
              //X7
              ellipse(x+(S*7), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*7), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*7), y+(S*15), SIZE, SIZE);
              //X8
              ellipse(x+(S*8), y+(S*1), SIZE, SIZE);
              ellipse(x+(S*8), y+(S*8), SIZE, SIZE);
              ellipse(x+(S*8), y+(S*15), SIZE, SIZE);
              //X9
              ellipse(x+(S*9),y+(S*1 ),SIZE,SIZE);
              ellipse(x+(S*9),y+(S*15),SIZE,SIZE);



            }// else if
          } // for
        }//func




    void keyPressed() {
      word = word + key;
    }

Chrisir

Thanks for sharing!

Did you do all letters of the alphabet or just a few (the ones you posted) ?

From a programming point of view: you would make an array to hold x,y pairs (PVector) of all points to represent letters and then use a for loop over it.

Maybe I can make an example of what I mean

AVRG

Yeah, I've designed and coded all the letters, but it went over the number of characters I could post on here so I cut the code down.

Now I'm just trying to track down how to remove keys such as SHIFT from the string so they aren't recognised as a key pressed.

Then I'll make it aesthetic like any good graphic design student.

Chrisir

IN keyPressed()

switch(key) {

    case SHIFT:
         // ignore
         break;

    case BACKSPACE:
        // go back one letter of word (delete last letter)
        break; 

    default:
       word+=key;
       break;

}

kfrajer

@AVRG Check the reference for the keywords key and keyCode. They documented how to do that.

Kf

Chrisir

In my switch section: you should make all keys to upper case since you don’t distinguish anyway

Then in the default section in switch you can use if(int(key)>65 && int(key)<100) or whatever to accept only the letters you want

Chrisir

here is an example for A and B - I also made a function ellipse / ellipse2 which is over shadowing the real ellipse to one time use to convert letters to data

I did that for A and B - see data at the end of the sketch. This gets read in.

that can be further improved when you use the input A B as an index for a bigger array containing all single data (instead of aTable for A and bTable for B and so on)

• I also implemented a new way of handling ENTER (in the main if...else if... section) and handling SHIFT and BACKSPACE.

Chrisir ;-)

// import processing.serial.*;

String word=""; //where the data of which keys were pressed reside

float S; //spacing between dots

void setup() {
  fullScreen();
  cursor(CROSS);
  S = width/150; //spacing between dots
}

void ellipse2(float a, float b, float c, float d) {
  // rename me to ellipse to use me as a converter; together with 4 lines below 
  // (type letter to convert and then copy from println window into code).
  // delete function when done. 
  print ( "{"
    +int(a)
    +","
    +int(b)
    +"},");
}

void draw() {
  background(200); // clear screen
  fill(0, 0, 0, 90);
  //fill( random(255), random(255), random(255), random(255)); 
  noStroke(); 

  textSize(20);
  text(mouseY, 100, 70);  

  showWord();
}//func

// -------------------------------------------------------------------------

void showWord() {

  float x= -85;
  float y= 150;
  float start= 100;  // start of line
  float YP = (S*25); // Y placing
  float moon = S*15; // spacing between letters

  word=word.toUpperCase();

  for (int i = 0; i < word.length(); i++) {
    // text(word.charAt(i), i*100, 120);

    char letter = word.charAt(i);
    //x = i * moon + start; //placing of the letter // i = the size

    x += moon;

    //------change the line 
    if (x >(width - 200 )) { 

      x = start;
      y+= YP;
    }

    //-------go back to the start 
    if (y >(height - 200 )) { 

      x = start;
      y = 150;
      background(200);
      word = "";
    }

    //-------LETTERS 

    // comment in when using as a converter with ellipse2 !!!!!!!!!!!!!!!!!!!!!!!!
    //  noLoop();
    //  x=0; 
    //  y=0;
    //  S=1; 

    if (letter == 'a' || letter == 'A') {
      readTable(aTable, x, y);
    }// else if
    else if (letter == 'b' || letter == 'B') {
      readTable(bTable, x, y);
    } // else if
    else if (letter == ENTER || letter == RETURN) {
      x = start;
      y += YP;
    }// else if
  } // for
}// func 

void readTable( int[][] localTable, float x, float y  ) {

  float SIZE = mouseY/15;//size of the ellipses

  for (int i2 = 0; i2<localTable.length; i2++) { 
    ellipse(x+ S*localTable[i2][0], y+ S*localTable[i2][1], 
      SIZE, SIZE);
  }
}

void keyPressed() {
  switch(keyCode) {

  case SHIFT:
    // ignore
    break;

  case BACKSPACE:
    // BACKSPACE
    // go back one letter of word (delete last letter)
    if (word.length()>0) {
      word=word.substring(0, word.length()-1);
    }
    break;

  default:
    if (int(key)>65 && int(key)<100) {
      word+=key;
    }
    break;
  }//switch
}//func 

// --------------------------------------------------------------------------
// data 


int[][] aTable = { {1, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, {1, 7}, {1, 8}, {1, 9}, {1, 10}, {1, 11}, {1, 12}, {1, 13}, {1, 14}, {1, 15}, {2, 1}, {2, 8}, {3, 1}, {3, 8}, 
  {4, 1}, {4, 8}, {5, 1}, {5, 8}, {6, 1}, {6, 8}, {7, 1}, {7, 8}, {8, 2}, {8, 8}, {9, 3}, {9, 4}, {9, 5}, {9, 6}, {9, 7}, {9, 8}, {9, 9}, {9, 10}, {9, 11}, {9, 12}, {9, 13}, 
  {9, 14}, {9, 15} };


int[][] bTable = {  {1, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, {1, 7}, {1, 8}, {1, 9}, {1, 10}, {1, 11}, {1, 12}, {1, 13}, {1, 14}, {1, 15}, {2, 1}, {2, 8}, {2, 15}, {3, 1}, 
  {3, 8}, {3, 15}, {4, 1}, {4, 8}, {4, 15}, 
  {5, 1}, {5, 8}, {5, 15}, {6, 1}, {6, 8}, {6, 15}, {7, 1}, {7, 8}, {7, 15}, {8, 2}, {8, 8}, {8, 14}, {9, 3}, {9, 4}, {9, 5}, {9, 6}, {9, 7}, {9, 9}, {9, 10}, {9, 11}, 
  {9, 12}, {9, 13} };
//

Chrisir

Not sure if ENTER works correctly in my code

Chrisir

Hello,

I made a new version with replacing aTable, bTable... with one huge table named table for all letters of the alphabet.

In turn, the whole if...else if...-block for each letter can now be reduced very much, since we use the ascii value of each letter as the index for table:

    if (letter >='A' && letter <='Z') { 
      readTable(table, int(letter)-65, x, y);
    } // if

Of course you could save and load the data which are now in table in data file on the hard drive. You could also write an font editor to design load and save your letters graphically.

regarding ENTER: I modified it, but you did something strange with your x-position x of a new line: Initially it was -85 but then it was 100 because you said x = start;.

Chrisir

// import processing.serial.*;

String word=""; //where the data of which keys were pressed reside

float S; //spacing between dots

void setup() {
  //  fullScreen();
  size(1000, 1200);
  cursor(CROSS);
  S = width/150; //spacing between dots
}

void ellipse2(float a, float b, float c, float d) {
  // rename me to ellipse to use me as a converter; together with 4 lines below 
  // (type letter to convert and then copy from println window into code).
  // delete function when done. 
  print ( "{"
    +int(a)
    +","
    +int(b)
    +"},");
}

void draw() {
  background(200); // clear screen
  fill(0, 0, 0, 90);
  //fill( random(255), random(255), random(255), random(255)); 
  noStroke(); 

  textSize(20);
  text(mouseY, 100, 70);  

  showWord();
}//func

// -------------------------------------------------------------------------

void showWord() {

  float x=0; //  -85; ///????
  float y= 150;
  float start= 100;  // start of line
  float YP = (S*25); // Y placing
  float moon = S*15; // spacing between letters

  x = start;

  word=word.toUpperCase();

  for (int i = 0; i < word.length(); i++) {
    // text(word.charAt(i), i*100, 120);

    char letter = word.charAt(i);
    //x = i * moon + start; //placing of the letter // i = the size

    x += moon;

    //------change the line 
    if (x >(width - 200 )) { 

      x = start;
      y+= YP;
    }

    //-------go back to the start 
    if (y >(height - 200 )) { 

      x = start;
      y = 150;
      background(200);
      word = "";
    }

    //-------LETTERS 

    // comment in when using as a converter with ellipse2 !!!!!!!!!!!!!!!!!!!!!!!!
    //  noLoop();
    //  x=0; 
    //  y=0;
    //  S=1; 

    if (letter >='A' && letter <='Z') { 
      readTable(table, int(letter)-65, x, y);
    } // if
    else if (letter == '\n') { // new line 
      x = start;
      y += YP;
    }// else if
  } // for
}// func 

void readTable( int[][][] localTable, int indexLetter, 
  float x, float y  ) {

  float SIZE = mouseY/15;//size of the ellipses

  for (int i2 = 0; i2<localTable[indexLetter].length; i2++) { 
    ellipse(x+ S*localTable[indexLetter][i2][0], y+ S*localTable[indexLetter][i2][1], 
      SIZE, SIZE);
  }//for
}//func 

void keyPressed() {
  switch(keyCode) {

  case SHIFT:
    // ignore
    break;

  case BACKSPACE:
    // BACKSPACE
    // go back one letter of word (delete last letter)
    if (word.length()>0) {
      word=word.substring(0, word.length()-1);
    }
    break;

  case ENTER:
  case RETURN:
    word+="\n"; // new line
    break; 

  default:
    String s1=key+"";
    s1=s1.toUpperCase();
    char keyU=s1.charAt(0);
    if (int(keyU)>=65 && int(keyU)<=100) {
      word+=key;
      println(word);
    }
    break;
  }//switch
  //
}//func 

// --------------------------------------------------------------------------
// data 

int[][][] table = {

  // A

  { {1, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, {1, 7}, {1, 8}, {1, 9}, {1, 10}, {1, 11}, {1, 12}, {1, 13}, {1, 14}, {1, 15}, {2, 1}, {2, 8}, {3, 1}, {3, 8}, 
    {4, 1}, {4, 8}, {5, 1}, {5, 8}, {6, 1}, {6, 8}, {7, 1}, {7, 8}, {8, 2}, {8, 8}, {9, 3}, {9, 4}, {9, 5}, {9, 6}, {9, 7}, {9, 8}, {9, 9}, {9, 10}, {9, 11}, {9, 12}, {9, 13}, 
  {9, 14}, {9, 15} }, 

  // B 

  { {1, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, {1, 7}, {1, 8}, {1, 9}, {1, 10}, {1, 11}, {1, 12}, {1, 13}, {1, 14}, {1, 15}, {2, 1}, {2, 8}, {2, 15}, {3, 1}, 
    {3, 8}, {3, 15}, {4, 1}, {4, 8}, {4, 15}, {5, 1}, {5, 8}, {5, 15}, {6, 1}, {6, 8}, {6, 15}, {7, 1}, {7, 8}, {7, 15}, {8, 2}, {8, 8}, {8, 14}, {9, 3}, {9, 4}, {9, 5}, {9, 6}, {9, 7}, {9, 9}, {9, 10}, {9, 11}, 
  {9, 12}, {9, 13}  }

};
//

AVRG

Having backspace is awesome, I was trying to get my head around how to do it. I managed to create the ENTER myself and works perfectly.

Thank you so much for all your help. I'll soon upload images of the final working piece with the scale etc. My deadline is tomorrow