Misc.pde

/**
  Polargraph controller
  Copyright Sandy Noble 2015.

  This file is part of Polargraph Controller.

  Polargraph Controller is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  Polargraph Controller is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with Polargraph Controller.  If not, see <http://www.gnu.org/licenses/>.
    
  Requires the excellent ControlP5 GUI library available from http://www.sojamo.de/libraries/controlP5/.
  Requires the excellent Geomerative library available from http://www.ricardmarxer.com/geomerative/.
  
  This is an application for controlling a polargraph machine, communicating using ASCII command language over a serial link.

  sandy.noble@gmail.com
  http://www.polargraph.co.uk/
  https://github.com/euphy/polargraphcontroller
*/

class Scaler
{
  public float scale = 1.0;
  public float mmPerStep = 1.0;
  
  public Scaler(float scale, float mmPerStep)
  {
    this.scale = scale;
    this.mmPerStep = mmPerStep;
  }
  public void setScale(float scale)
  {
    this.scale = scale;
  }
  
  public float scale(float in)
  {
    return in * mmPerStep * scale;
  }
}

class PreviewVector extends PVector
{
  public String command;
}
//
//
//import java.awt.Toolkit;
//import java.awt.BorderLayout;
//import java.awt.GraphicsEnvironment;
//
//public class Console extends WindowAdapter implements WindowListener, ActionListener, Runnable
//{
//  private JFrame frame;
//  private JTextArea textArea;
//  private Thread reader;
//  private Thread reader2;
//  private boolean quit;
//
//  private final PipedInputStream pin=new PipedInputStream(); 
//  private final PipedInputStream pin2=new PipedInputStream(); 
//
//  private PrintStream cOut = System.out;
//  private PrintStream cErr = System.err;
//
//  Thread errorThrower; // just for testing (Throws an Exception at this Console
//
//  public Console()
//  {
//    // create all components and add them
//    frame=new JFrame("Java Console");
//    Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
//    Dimension frameSize=new Dimension((int)(screenSize.width/2),(int)(screenSize.height/2));
//    int x=(int)(frameSize.width/2);
//    int y=(int)(frameSize.height/2);
//    frame.setBounds(x,y,frameSize.width,frameSize.height);
//
//    textArea=new JTextArea();
//    textArea.setEditable(false);
//    JButton button=new JButton("clear");
//
//    frame.getContentPane().setLayout(new BorderLayout());
//    frame.getContentPane().add(new JScrollPane(textArea),BorderLayout.CENTER);
//    frame.getContentPane().add(button,BorderLayout.SOUTH);
//    frame.setVisible(true);		
//
//    frame.addWindowListener(this);		
//    button.addActionListener(this);
//
//    try
//    {
//      this.cOut = System.out;
//      PipedOutputStream pout=new PipedOutputStream(this.pin);
//      System.setOut(new PrintStream(pout,true)); 
//    } 
//    catch (java.io.IOException io)
//    {
//      textArea.append("Couldn't redirect STDOUT to this console\n"+io.getMessage());
//    }
//    catch (SecurityException se)
//    {
//      textArea.append("Couldn't redirect STDOUT to this console\n"+se.getMessage());
//    } 
//
//    try 
//    {
//      this.cErr = System.err;
//      PipedOutputStream pout2=new PipedOutputStream(this.pin2);
//      System.setErr(new PrintStream(pout2,true));
//    } 
//    catch (java.io.IOException io)
//    {
//      textArea.append("Couldn't redirect STDERR to this console\n"+io.getMessage());
//    }
//    catch (SecurityException se)
//    {
//      textArea.append("Couldn't redirect STDERR to this console\n"+se.getMessage());
//    } 		
//
//    quit=false; // signals the Threads that they should exit
//
//    // Starting two seperate threads to read from the PipedInputStreams				
//    //
//    reader=new Thread(this);
//    reader.setDaemon(true);	
//    reader.start();	
//    //
//    reader2=new Thread(this);	
//    reader2.setDaemon(true);	
//    reader2.start();
//
////    // testing part
////    // you may omit this part for your application
////    // 
////    System.out.println("Hello World 2");
////    System.out.println("All fonts available to Graphic2D:\n");
////    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
////    String[] fontNames=ge.getAvailableFontFamilyNames();
////    for(int n=0;n<fontNames.length;n++)  System.out.println(fontNames[n]);		
////    // Testing part: simple an error thrown anywhere in this JVM will be printed on the Console
////    // We do it with a seperate Thread becasue we don't wan't to break a Thread used by the Console.
////    System.out.println("\nLets throw an error on this console");	
////    errorThrower=new Thread(this);
////    errorThrower.setDaemon(true);
////    errorThrower.start();					
//  }
//
//  public synchronized void windowClosed(WindowEvent evt)
//  {
//    quit=true;
//    this.notifyAll(); // stop all threads
//    try { 
//      reader.join(1000);
//      pin.close();
//      System.setOut(this.cOut);
//    } 
//    catch (Exception e){
//    }		
//    try { 
//      reader2.join(1000);
//      pin2.close(); 
//      System.setErr(this.cErr);
//    } 
//    catch (Exception e){
//    }
////    System.exit(0);
//  }		
//
//  public synchronized void windowClosing(WindowEvent evt)
//  {
//    frame.setVisible(false); // default behaviour of JFrame	
//    frame.dispose();
//  }
//
//  public synchronized void actionPerformed(ActionEvent evt)
//  {
//    textArea.setText("");
//  }
//
//  public synchronized void run()
//  {
//    try
//    {			
//      while (Thread.currentThread()==reader)
//      {
//        try { 
//          this.wait(100);
//        }
//        catch(InterruptedException ie) {
//        }
//        if (pin.available()!=0)
//        {
//          String input=this.readLine(pin);
//          textArea.append(input);
//          textArea.setCaretPosition(textArea.getDocument().getLength());
//
//        }
//        if (quit) return;
//      }
//
//      while (Thread.currentThread()==reader2)
//      {
//        try { 
//          this.wait(100);
//        }
//        catch(InterruptedException ie) {
//        }
//        if (pin2.available()!=0)
//        {
//          String input=this.readLine(pin2);
//          textArea.append(input);
//          textArea.setCaretPosition(textArea.getDocument().getLength());
//
//        }
//        if (quit) return;
//      }			
//    } 
//    catch (Exception e)
//    {
//      textArea.append("\nConsole reports an Internal error.");
//      textArea.append("The error is: "+e);			
//    }
//  }
//  
//  public void close()
//  {
//    this.windowClosing(null);
//  }
//
//  public synchronized String readLine(PipedInputStream in) throws IOException
//  {
//    String input="";
//    do
//    {
//      int available=in.available();
//      if (available==0) break;
//      byte b[]=new byte[available];
//      in.read(b);
//      input=input+new String(b,0,b.length);														
//    }
//    while( !input.endsWith("\n") &&  !input.endsWith("\r\n") && !quit);
//    return input;
//  }				
//}