diff --git a/pom.xml b/pom.xml
index 3469411..8a3457e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -35,27 +35,32 @@
       <artifactId>autocomplete</artifactId>
       <version>3.2.0</version>
     </dependency>
-    <dependency>
+    <!-- <dependency>
+      <groupId>com.googlecode.lanterna</groupId>
+      <artifactId>lanterna</artifactId>
+      <version>3.1.1</version>
+  </dependency> -->
+    <!-- <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>3.8.1</version>
       <scope>test</scope>
-    </dependency>
+    </dependency> -->
   </dependencies>
 
   <build>
-      <resources>
-          <resource>
-              <directory>src/main/res</directory>
-          </resource>
-      </resources>
+    <resources>
+      <resource>
+        <directory>src/main/res</directory>
+      </resource>
+    </resources>
     <plugins>
       <plugin>
         <groupId>org.codehaus.mojo</groupId>
         <artifactId>exec-maven-plugin</artifactId>
         <version>3.0.0</version>
         <configuration>
-          <mainClass>istlab.TestRSyntaxTA.App</mainClass>
+          <mainClass>istlab.KisoJikken.App</mainClass>
           <!-- <additionalClasspathElements>
             <additionalClasspathElement>${pom.basedir}/jar/piccolo2d-core-3.1-SNAPSHOT.jar</additionalClasspathElement>
             <additionalClasspathElement>${pom.basedir}/jar/piccolo2d-examples-3.1-SNAPSHOT.jar</additionalClasspathElement>
@@ -80,7 +85,7 @@
 
           <archive>
             <manifest>
-              <mainClass>istlab.TestRSyntaxTA.App</mainClass>
+              <mainClass>istlab.KisoJikken.App</mainClass>
             </manifest>
             <manifestEntries>
               <Permissions>all-permissions</Permissions>
diff --git a/src/main/java/istlab/KisoJikken/App.java b/src/main/java/istlab/KisoJikken/App.java
new file mode 100644
index 0000000..11be12a
--- /dev/null
+++ b/src/main/java/istlab/KisoJikken/App.java
@@ -0,0 +1,38 @@
+package istlab.KisoJikken;
+
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+
+/**
+ * Hello world!
+ *
+ */
+public class App {
+    public static void main(String[] args) {
+        // SwingUtilities.invokeLater(() -> {
+		// 	String laf = UIManager.getSystemLookAndFeelClassName();
+		// 	//laf = "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel";
+		// 	try {
+		// 		UIManager.setLookAndFeel(laf);
+		// 	} catch (Exception e) {
+		// 		e.printStackTrace();
+		// 	}
+		// 	AutoCompleteDemoApp frame = new AutoCompleteDemoApp();
+		// 	frame.getToolkit().setDynamicLayout(true);
+		// 	frame.setVisible(true);
+		// });
+
+
+        // System.out.println("Hello World!");
+        // Instantiate GUI on the EDT.
+        SwingUtilities.invokeLater(() -> {
+            try {
+                String laf = UIManager.getSystemLookAndFeelClassName();
+                UIManager.setLookAndFeel(laf);
+            } catch (Exception e) {
+                /* Never happens */ }
+            new Launcher(args).setVisible(true);
+        });
+
+    }
+}
diff --git a/src/main/java/istlab/KisoJikken/AutoCompleteDemo.java b/src/main/java/istlab/KisoJikken/AutoCompleteDemo.java
new file mode 100644
index 0000000..04c0968
--- /dev/null
+++ b/src/main/java/istlab/KisoJikken/AutoCompleteDemo.java
@@ -0,0 +1,167 @@
+package istlab.KisoJikken;
+
+import java.awt.BorderLayout;
+import java.awt.Font;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.plaf.FontUIResource;
+
+import org.fife.ui.autocomplete.AutoCompletion;
+import org.fife.ui.autocomplete.BasicCompletion;
+import org.fife.ui.autocomplete.CompletionProvider;
+import org.fife.ui.autocomplete.DefaultCompletionProvider;
+import org.fife.ui.autocomplete.ShorthandCompletion;
+import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;
+import org.fife.ui.rsyntaxtextarea.SyntaxConstants;
+import org.fife.ui.rtextarea.RTextScrollPane;
+import org.mdkt.compiler.InMemoryJavaCompiler;
+
+public class AutoCompleteDemo extends JFrame {
+
+   RSyntaxTextArea textArea;
+
+   public AutoCompleteDemo() {
+
+      JPanel contentPane = new JPanel(new BorderLayout());
+      textArea = new RSyntaxTextArea(20, 60);
+      textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA);
+      textArea.setCodeFoldingEnabled(true);
+      textArea.setFont(new FontUIResource("sansserif", Font.PLAIN, 20));
+      contentPane.add(new RTextScrollPane(textArea));
+
+      // A CompletionProvider is what knows of all possible completions, and
+      // analyzes the contents of the text area at the caret position to
+      // determine what completion choices should be presented. Most instances
+      // of CompletionProvider (such as DefaultCompletionProvider) are designed
+      // so that they can be shared among multiple text components.
+      CompletionProvider provider = createCompletionProvider();
+
+      // An AutoCompletion acts as a "middle-man" between a text component
+      // and a CompletionProvider. It manages any options associated with
+      // the auto-completion (the popup trigger key, whether to display a
+      // documentation window along with completion choices, etc.). Unlike
+      // CompletionProviders, instances of AutoCompletion cannot be shared
+      // among multiple text components.
+      AutoCompletion ac = new AutoCompletion(provider);
+      ac.install(textArea);
+
+      setContentPane(contentPane);
+      setTitle("AutoComplete Demo");
+      setDefaultCloseOperation(EXIT_ON_CLOSE);
+
+      JPanel north = new JPanel();
+      JButton loadB = new JButton("Load");
+      loadB.addActionListener(new ActionListener() {
+         @Override
+         public void actionPerformed(ActionEvent e) {
+            InputStream is = getClass().getResourceAsStream("/Hello.java");
+            BufferedReader br = new BufferedReader(new InputStreamReader(is));
+            StringBuilder sb = new StringBuilder();
+            String line;
+            try {
+               while((line=br.readLine())!=null){
+                  sb.append(line+"\n");
+               }
+            } catch (IOException e1) {
+               e1.printStackTrace();
+            }
+            textArea.setText(sb.toString());
+
+         }
+      });
+      north.add(loadB);
+
+      JButton saveB = new JButton("Save");
+      saveB.addActionListener(new ActionListener() {
+         @Override
+         public void actionPerformed(ActionEvent e) {
+            System.out.println(textArea.getText());
+         }
+      });
+      north.add(saveB);
+
+      JButton execB = new JButton("Exec");
+      execB.addActionListener(new ActionListener() {
+         @Override
+         public void actionPerformed(ActionEvent e) {
+            Class<?> helloClass;
+            try {
+               helloClass = InMemoryJavaCompiler.newInstance().compile("Hello", textArea.getText());
+               System.out.println(helloClass.getClass().getName());
+
+               System.out.println(helloClass.getDeclaredConstructor().newInstance().toString());
+            } catch (Exception e1) {
+               e1.printStackTrace();
+            }
+
+         }
+      });
+      north.add(execB);
+      // JOptionPane.showMessageDialog(null, "test");
+
+      add(north, BorderLayout.NORTH);
+      pack();
+      setLocationRelativeTo(null);
+
+
+   }
+
+   /**
+    * Create a simple provider that adds some Java-related completions.
+    */
+   private CompletionProvider createCompletionProvider() {
+
+      // A DefaultCompletionProvider is the simplest concrete implementation
+      // of CompletionProvider. This provider has no understanding of
+      // language semantics. It simply checks the text entered up to the
+      // caret position for a match against known completions. This is all
+      // that is needed in the majority of cases.
+      DefaultCompletionProvider provider = new DefaultCompletionProvider();
+
+      // Add completions for all Java keywords. A BasicCompletion is just
+      // a straightforward word completion.
+      provider.addCompletion(new BasicCompletion(provider, "abstract"));
+      provider.addCompletion(new BasicCompletion(provider, "assert"));
+      provider.addCompletion(new BasicCompletion(provider, "break"));
+      provider.addCompletion(new BasicCompletion(provider, "case"));
+      // ... etc ...
+      provider.addCompletion(new BasicCompletion(provider, "transient"));
+      provider.addCompletion(new BasicCompletion(provider, "try"));
+      provider.addCompletion(new BasicCompletion(provider, "void"));
+      provider.addCompletion(new BasicCompletion(provider, "volatile"));
+      provider.addCompletion(new BasicCompletion(provider, "while"));
+
+      // Add a couple of "shorthand" completions. These completions don't
+      // require the input text to be the same thing as the replacement text.
+      provider.addCompletion(new ShorthandCompletion(provider, "sysout",
+            "System.out.println(", "System.out.println("));
+      provider.addCompletion(new ShorthandCompletion(provider, "syserr",
+            "System.err.println(", "System.err.println("));
+
+      return provider;
+
+   }
+
+   public static void main(String[] args) {
+      // Instantiate GUI on the EDT.
+      SwingUtilities.invokeLater(() -> {
+         try {
+            String laf = UIManager.getSystemLookAndFeelClassName();
+            UIManager.setLookAndFeel(laf);
+         } catch (Exception e) {
+            /* Never happens */ }
+         new AutoCompleteDemo().setVisible(true);
+      });
+   }
+
+}
\ No newline at end of file
diff --git a/src/main/java/istlab/KisoJikken/CCellRenderer.java b/src/main/java/istlab/KisoJikken/CCellRenderer.java
new file mode 100644
index 0000000..a5e2f02
--- /dev/null
+++ b/src/main/java/istlab/KisoJikken/CCellRenderer.java
@@ -0,0 +1,78 @@
+/*
+ * 01/07/2009
+ *
+ * CCellRenderer.java - A cell renderer for C completions.
+ *
+ * This library is distributed under a modified BSD license.  See the included
+ * LICENSE.md file for details.
+ */
+package istlab.KisoJikken;
+
+import javax.swing.Icon;
+import javax.swing.JList;
+
+import org.fife.ui.autocomplete.Completion;
+import org.fife.ui.autocomplete.CompletionCellRenderer;
+import org.fife.ui.autocomplete.FunctionCompletion;
+import org.fife.ui.autocomplete.VariableCompletion;
+
+
+/**
+ * The cell renderer used for the C programming language.
+ *
+ * @author Robert Futrell
+ * @version 1.0
+ */
+class CCellRenderer extends CompletionCellRenderer {
+
+	private Icon variableIcon;
+	private Icon functionIcon;
+
+
+	/**
+	 * Constructor.
+	 */
+	CCellRenderer() {
+		variableIcon = getIcon("img/var.png");
+		functionIcon = getIcon("img/function.png");
+	}
+
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	protected void prepareForOtherCompletion(JList list,
+			Completion c, int index, boolean selected, boolean hasFocus) {
+		super.prepareForOtherCompletion(list, c, index, selected, hasFocus);
+		setIcon(getEmptyIcon());
+	}
+
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	protected void prepareForVariableCompletion(JList list,
+			VariableCompletion vc, int index, boolean selected,
+			boolean hasFocus) {
+		super.prepareForVariableCompletion(list, vc, index, selected,
+										hasFocus);
+		setIcon(variableIcon);
+	}
+
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
+	protected void prepareForFunctionCompletion(JList list,
+			FunctionCompletion fc, int index, boolean selected,
+			boolean hasFocus) {
+		super.prepareForFunctionCompletion(list, fc, index, selected,
+										hasFocus);
+		setIcon(functionIcon);
+	}
+
+
+}
diff --git a/src/main/java/istlab/KisoJikken/DemoRootPane.java b/src/main/java/istlab/KisoJikken/DemoRootPane.java
new file mode 100644
index 0000000..14a33b5
--- /dev/null
+++ b/src/main/java/istlab/KisoJikken/DemoRootPane.java
@@ -0,0 +1,473 @@
+/*
+ * 01/13/2009
+ *
+ * DemoRootPane.java - Root pane for the demo applet and standalone application.
+ *
+ * This library is distributed under a modified BSD license.  See the included
+ * LICENSE.md file for details.
+ */
+package istlab.KisoJikken;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Font;
+import java.awt.event.ActionEvent;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringReader;
+import java.util.Arrays;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.BorderFactory;
+import javax.swing.ButtonGroup;
+import javax.swing.JCheckBoxMenuItem;
+import javax.swing.JEditorPane;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JRadioButtonMenuItem;
+import javax.swing.JRootPane;
+import javax.swing.SwingUtilities;
+import javax.swing.ToolTipManager;
+import javax.swing.UIManager;
+import javax.swing.text.TextAction;
+
+import org.fife.ui.autocomplete.AutoCompletion;
+import org.fife.ui.autocomplete.BasicCompletion;
+import org.fife.ui.autocomplete.CompletionCellRenderer;
+import org.fife.ui.autocomplete.CompletionProvider;
+import org.fife.ui.autocomplete.DefaultCompletionProvider;
+import org.fife.ui.autocomplete.FunctionCompletion;
+import org.fife.ui.autocomplete.LanguageAwareCompletionProvider;
+import org.fife.ui.autocomplete.ParameterizedCompletion;
+import org.fife.ui.autocomplete.ShorthandCompletion;
+import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;
+import org.fife.ui.rsyntaxtextarea.SyntaxConstants;
+import org.fife.ui.rtextarea.RTextScrollPane;
+import org.fife.ui.rtextarea.ToolTipSupplier;
+
+import istlab.KisoJikken.demo.AutoCompleteDemoApp;
+
+
+/**
+ * The root pane for the demo application.  This is all code shared between
+ * the applet and standalone versions of the demo.
+ *
+ * @author Robert Futrell
+ * @version 1.0
+ */
+class DemoRootPane extends JRootPane {
+
+	private RSyntaxTextArea textArea;
+	private AutoCompletion ac;
+	private JCheckBoxMenuItem cellRenderingItem;
+	private JCheckBoxMenuItem alternateRowColorsItem;
+	private JCheckBoxMenuItem showDescWindowItem;
+	private JCheckBoxMenuItem paramAssistanceItem;
+	private JEditorPane ep;
+
+	private static final Color ALT_BG_COLOR = new Color(0xf0f0f0);
+
+
+	/**
+	 * Constructor.
+	 */
+	DemoRootPane() {
+		this(null);
+	}
+
+
+	/**
+	 * Constructor.
+	 *
+	 * @param provider The completion provider for the editor to use.
+	 */
+	DemoRootPane(CompletionProvider provider) {
+
+		JPanel contentPane = new JPanel(new BorderLayout());
+
+		ep = new JEditorPane("text/html", null);
+		updateEditorPane(); // Nimbus doesn't always clean up after itself.
+		contentPane.add(ep, BorderLayout.NORTH);
+
+		textArea = new RSyntaxTextArea(25, 40);
+		textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_C);
+
+		if (provider==null) {
+			provider = createCompletionProvider();
+		}
+
+		// Install auto-completion onto our text area.
+		ac = new AutoCompletion(provider);
+		ac.setListCellRenderer(new CCellRenderer());
+		ac.setShowDescWindow(true);
+		ac.setParameterAssistanceEnabled(true);
+
+		ac.setAutoCompleteEnabled(true);
+		ac.setAutoActivationEnabled(true);
+		ac.setAutoCompleteSingleChoices(true);
+		ac.setAutoActivationDelay(800);
+
+		ac.install(textArea);
+		contentPane.add(new RTextScrollPane(textArea, true));
+
+		try {
+			textArea.read(new StringReader("int main() {\n  printf(\"Hello world\\n\");\n}\n"), null);
+		} catch (IOException ioe) {
+			ioe.printStackTrace();
+		}
+
+		textArea.setToolTipSupplier((ToolTipSupplier)provider);
+		ToolTipManager.sharedInstance().registerComponent(textArea);
+
+		setJMenuBar(createMenuBar());
+
+		// Get ready to go.
+		setContentPane(contentPane);
+
+		// Put the focus into the text area, not the "label" JEditorPane.
+		SwingUtilities.invokeLater(() -> textArea.requestFocusInWindow());
+
+	}
+
+
+	/**
+	 * Returns the provider to use when editing code.
+	 *
+	 * @return The provider.
+	 * @see #createCommentCompletionProvider()
+	 * @see #createStringCompletionProvider()
+	 */
+	private CompletionProvider createCodeCompletionProvider() {
+
+		// Add completions for the C standard library.
+		DefaultCompletionProvider cp = new DefaultCompletionProvider();
+
+		cp.setAutoActivationRules(true, ".");
+
+		// First try loading resource (running from demo jar), then try
+		// accessing file (debugging in Eclipse).
+		ClassLoader cl = getClass().getClassLoader();
+		InputStream in = cl.getResourceAsStream("c.xml");
+		try {
+			if (in!=null) {
+				cp.loadFromXML(in);
+				in.close();
+			}
+			else {
+				cp.loadFromXML(new File("c.xml"));
+			}
+		} catch (IOException ioe) {
+			ioe.printStackTrace();
+		}
+
+		// Add some handy shorthand completions.
+		cp.addCompletion(new ShorthandCompletion(cp, "main",
+							"int main(int argc, char **argv)"));
+
+		// Add a parameterized completion with a ton of parameters (see #67)
+		FunctionCompletion functionCompletionWithLotsOfParameters = new FunctionCompletion(cp, "long", "int");
+		functionCompletionWithLotsOfParameters.setParams(Arrays.asList(
+			new ParameterizedCompletion.Parameter("int", "intVal"),
+			new ParameterizedCompletion.Parameter("float", "floatVal"),
+			new ParameterizedCompletion.Parameter("string", "stringVal"),
+			new ParameterizedCompletion.Parameter("int", "otherVal1"),
+			new ParameterizedCompletion.Parameter("int", "otherVal2"),
+			new ParameterizedCompletion.Parameter("int", "otherVal3"),
+			new ParameterizedCompletion.Parameter("int", "otherVal4"),
+			new ParameterizedCompletion.Parameter("int", "otherVal5"),
+			new ParameterizedCompletion.Parameter("int", "otherVal6"),
+			new ParameterizedCompletion.Parameter("int", "otherVal7"),
+			new ParameterizedCompletion.Parameter("int", "otherVal8"),
+			new ParameterizedCompletion.Parameter("int", "otherVal9"),
+			new ParameterizedCompletion.Parameter("int", "otherVal9"),
+			new ParameterizedCompletion.Parameter("int", "otherVal10"),
+			new ParameterizedCompletion.Parameter("int", "otherVal11"),
+			new ParameterizedCompletion.Parameter("int", "otherVal12"),
+			new ParameterizedCompletion.Parameter("int", "otherVal13"),
+			new ParameterizedCompletion.Parameter("int", "otherVal14"),
+			new ParameterizedCompletion.Parameter("int", "otherVal15"),
+			new ParameterizedCompletion.Parameter("int", "otherVal16"),
+			new ParameterizedCompletion.Parameter("int", "otherVal17"),
+			new ParameterizedCompletion.Parameter("int", "otherVal18"),
+			new ParameterizedCompletion.Parameter("int", "otherVal19"),
+			new ParameterizedCompletion.Parameter("int", "otherVal20")
+		));
+		cp.addCompletion(functionCompletionWithLotsOfParameters);
+		return cp;
+
+	}
+
+
+	/**
+	 * Returns the provider to use when in a comment.
+	 *
+	 * @return The provider.
+	 * @see #createCodeCompletionProvider()
+	 * @see #createStringCompletionProvider()
+	 */
+	private CompletionProvider createCommentCompletionProvider() {
+		DefaultCompletionProvider cp = new DefaultCompletionProvider();
+		cp.addCompletion(new BasicCompletion(cp, "TODO:", "A to-do reminder"));
+		cp.addCompletion(new BasicCompletion(cp, "FIXME:", "A bug that needs to be fixed"));
+		return cp;
+	}
+
+
+	/**
+	 * Creates the completion provider for a C editor.  This provider can be
+	 * shared among multiple editors.
+	 *
+	 * @return The provider.
+	 */
+	private CompletionProvider createCompletionProvider() {
+
+		// Create the provider used when typing code.
+		CompletionProvider codeCP = createCodeCompletionProvider();
+
+		// The provider used when typing a string.
+		CompletionProvider stringCP = createStringCompletionProvider();
+
+		// The provider used when typing a comment.
+		CompletionProvider commentCP = createCommentCompletionProvider();
+
+		// Create the "parent" completion provider.
+		LanguageAwareCompletionProvider provider = new
+								LanguageAwareCompletionProvider(codeCP);
+		provider.setStringCompletionProvider(stringCP);
+		provider.setCommentCompletionProvider(commentCP);
+
+		return provider;
+
+	}
+
+
+	/**
+	 * Returns the menu bar for the demo application.
+	 *
+	 * @return The menu bar.
+	 */
+	private JMenuBar createMenuBar() {
+
+		JMenuBar mb = new JMenuBar();
+
+		JMenu menu = new JMenu("File");
+		Action newAction = new TextAction("New") {
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				AutoCompleteDemoApp app2 = new AutoCompleteDemoApp(
+												ac.getCompletionProvider());
+				app2.setVisible(true);
+			}
+		};
+		JMenuItem item = new JMenuItem(newAction);
+		menu.add(item);
+		mb.add(menu);
+
+		menu = new JMenu("View");
+		Action renderAction = new FancyCellRenderingAction();
+		cellRenderingItem = new JCheckBoxMenuItem(renderAction);
+		cellRenderingItem.setSelected(true);
+		menu.add(cellRenderingItem);
+		Action alternateRowColorsAction = new AlternateRowColorsAction();
+		alternateRowColorsItem = new JCheckBoxMenuItem(alternateRowColorsAction);
+		menu.add(alternateRowColorsItem);
+		Action descWindowAction = new ShowDescWindowAction();
+		showDescWindowItem = new JCheckBoxMenuItem(descWindowAction);
+		showDescWindowItem.setSelected(true);
+		menu.add(showDescWindowItem);
+		Action paramAssistanceAction = new ParameterAssistanceAction();
+		paramAssistanceItem = new JCheckBoxMenuItem(paramAssistanceAction);
+		paramAssistanceItem.setSelected(true);
+		menu.add(paramAssistanceItem);
+		mb.add(menu);
+
+		ButtonGroup bg = new ButtonGroup();
+		menu = new JMenu("LookAndFeel");
+		Action lafAction = new LafAction("System", UIManager.getSystemLookAndFeelClassName());
+		JRadioButtonMenuItem rbmi = new JRadioButtonMenuItem(lafAction);
+		rbmi.setSelected(true);
+		menu.add(rbmi);
+		bg.add(rbmi);
+		lafAction = new LafAction("Motif", "com.sun.java.swing.plaf.motif.MotifLookAndFeel");
+		rbmi = new JRadioButtonMenuItem(lafAction);
+		menu.add(rbmi);
+		bg.add(rbmi);
+		lafAction = new LafAction("Ocean", "javax.swing.plaf.metal.MetalLookAndFeel");
+		rbmi = new JRadioButtonMenuItem(lafAction);
+		menu.add(rbmi);
+		bg.add(rbmi);
+		lafAction = new LafAction("Nimbus", "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
+		rbmi = new JRadioButtonMenuItem(lafAction);
+		menu.add(rbmi);
+		bg.add(rbmi);
+		mb.add(menu);
+
+		return mb;
+
+	}
+
+
+	/**
+	 * Returns the completion provider to use when the caret is in a string.
+	 *
+	 * @return The provider.
+	 * @see #createCodeCompletionProvider()
+	 * @see #createCommentCompletionProvider()
+	 */
+	private CompletionProvider createStringCompletionProvider() {
+		DefaultCompletionProvider cp = new DefaultCompletionProvider();
+		cp.addCompletion(new BasicCompletion(cp, "%c", "char", "Prints a character"));
+		cp.addCompletion(new BasicCompletion(cp, "%i", "signed int", "Prints a signed integer"));
+		cp.addCompletion(new BasicCompletion(cp, "%f", "float", "Prints a float"));
+		cp.addCompletion(new BasicCompletion(cp, "%s", "string", "Prints a string"));
+		cp.addCompletion(new BasicCompletion(cp, "%u", "unsigned int", "Prints an unsigned integer"));
+		cp.addCompletion(new BasicCompletion(cp, "\\n", "Newline", "Prints a newline"));
+		return cp;
+	}
+
+
+	/**
+	 * Focuses the text area.
+	 */
+	public void focusEditor() {
+		textArea.requestFocusInWindow();
+	}
+
+
+	/**
+	 * Updates the font used in the HTML, as well as the background color, of
+	 * the "label" editor pane.  The font would always have to be done (since
+	 * HTMLEditorKit doesn't use the editor pane's font by default), but the
+	 * background only has to be modified because Nimbus doesn't clean up the
+	 * colors it installs after itself.
+	 */
+	private void updateEditorPane() {
+		Font f = UIManager.getFont("Label.font");
+		String fontTag = "<body style=\"font-family: " + f.getFamily() +
+					"; font-size: " + f.getSize() + "pt; \">";
+		String text = "<html>" + fontTag + "" +
+			"The text area below provides simple code completion for the C " +
+			"programming language as you type. Simply type <b>Ctrl+Space</b> " +
+			"at any time to see a list of completion choices (function names, "+
+			"for example). If there is only one possible completion, it will " +
+			"be automatically inserted.<p>" +
+			"Also, completions are context-sensitive.  If you type " +
+			"Ctrl+Space in a comment or in the middle of a string, you will " +
+			"get different completion choices than if you are in code.";
+		ep.setText(text);
+		ep.setBorder(BorderFactory.createEmptyBorder(5,5,10,5));
+		ep.setEditable(false);
+		ep.setBackground(UIManager.getColor("Panel.background"));
+	}
+
+
+	/**
+	 * Toggles whether row backgrounds use alternate colors.
+	 */
+	private class AlternateRowColorsAction extends AbstractAction {
+
+		AlternateRowColorsAction() {
+			putValue(NAME, "Alternate Row Colors in completion list");
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			boolean alternate = alternateRowColorsItem.isSelected();
+			CompletionCellRenderer.setAlternateBackground(
+					alternate ? ALT_BG_COLOR: null);
+		}
+
+	}
+
+
+	/**
+	 * Toggles whether the completion window uses "fancy" rendering.
+	 */
+	private class FancyCellRenderingAction extends AbstractAction {
+
+		FancyCellRenderingAction() {
+			putValue(NAME, "Fancy Cell Rendering");
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			boolean fancy = cellRenderingItem.isSelected();
+			ac.setListCellRenderer(fancy ? new CCellRenderer() : null);
+		}
+
+	}
+
+
+	/**
+	 * Sets a new look and feel.
+	 */
+	private class LafAction extends AbstractAction {
+
+		private String laf;
+
+		LafAction(String name, String laf) {
+			putValue(NAME, name);
+			this.laf = laf;
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			try {
+				UIManager.setLookAndFeel(laf);
+			} catch (Exception ex) {
+				JOptionPane.showMessageDialog(DemoRootPane.this,
+					"Error setting LookAndFeel", "Error",
+					JOptionPane.ERROR_MESSAGE);
+				return;
+			}
+			Component parent = SwingUtilities.getRoot(DemoRootPane.this);
+			SwingUtilities.updateComponentTreeUI(parent);
+			updateEditorPane();
+		}
+
+	}
+
+
+	/**
+	 * Toggles whether parameter assistance is enabled.
+	 */
+	private class ParameterAssistanceAction extends AbstractAction {
+
+		ParameterAssistanceAction() {
+			putValue(NAME, "Function Parameter Assistance");
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			boolean enabled = paramAssistanceItem.isSelected();
+			ac.setParameterAssistanceEnabled(enabled);
+		}
+
+	}
+
+
+	/**
+	 * Toggles whether the description window is visible.
+	 */
+	private class ShowDescWindowAction extends AbstractAction {
+
+		ShowDescWindowAction() {
+			putValue(NAME, "Show Description Window");
+		}
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			boolean show = showDescWindowItem.isSelected();
+			ac.setShowDescWindow(show);
+		}
+
+	}
+
+
+}
diff --git a/src/main/java/istlab/KisoJikken/Editor.java b/src/main/java/istlab/KisoJikken/Editor.java
new file mode 100644
index 0000000..e68339f
--- /dev/null
+++ b/src/main/java/istlab/KisoJikken/Editor.java
@@ -0,0 +1,123 @@
+package istlab.KisoJikken;
+
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.WindowConstants;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.plaf.FontUIResource;
+
+import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;
+import org.fife.ui.rsyntaxtextarea.SyntaxConstants;
+import org.fife.ui.rtextarea.RTextScrollPane;
+
+public class Editor extends JFrame implements ActionListener {
+    File file;
+    RSyntaxTextArea textArea;
+    JPanel topP;
+    JSlider fontSizeJS;
+
+    public Editor(File f) {
+        file = f;
+
+        // JPanel contentPane = new JPanel(new BorderLayout());
+        textArea = new RSyntaxTextArea(20, 40);
+        textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA);
+        textArea.setCodeFoldingEnabled(true);
+        textArea.setFont(new FontUIResource("sansserif", Font.PLAIN, 16));
+        getContentPane().add(new RTextScrollPane(textArea));
+
+        try {
+            setTitle(file.getCanonicalPath());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        setSize(new Dimension(800, 400));// pack();
+        setLocationRelativeTo(Launcher.theapp);
+        setLocation(Launcher.theapp.getWidth(), Launcher.theapp.file2editor.size() * 40);
+        setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);
+        load();
+
+        topP = new JPanel();
+        topP.add(new JLabel("size:"));
+        fontSizeJS = new JSlider(10, 50, 16);
+        topP.add(fontSizeJS);
+        fontSizeJS.addChangeListener(new ChangeListener() {
+            public void stateChanged(ChangeEvent e) {
+                int size = fontSizeJS.getValue();
+                textArea.setFont(new FontUIResource("sansserif", Font.PLAIN, size));
+
+            }
+        });
+        JButton saveB = new JButton("Save");
+        saveB.addActionListener(this);
+        topP.add(saveB);
+
+        JButton loadB = new JButton("Reload");
+        loadB.addActionListener(this);
+        topP.add(loadB);
+
+        getContentPane().add(topP, BorderLayout.NORTH);
+
+        setVisible(true);
+    }
+
+    public void load() {
+        InputStream is = null;
+        try {
+            is = new FileInputStream(file);
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+        BufferedReader br = new BufferedReader(new InputStreamReader(is));
+        StringBuilder sb = new StringBuilder();
+        String line;
+        try {
+            while ((line = br.readLine()) != null) {
+                sb.append(line + "\n");
+            }
+        } catch (IOException e1) {
+            e1.printStackTrace();
+        }
+        textArea.setText(sb.toString());
+    }
+
+    public void save(){
+        String src = textArea.getText();
+        System.out.println(src);
+        try {
+            PrintWriter out = new PrintWriter(file.getAbsolutePath());
+            out.println(src);
+            out.flush();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        if (e.getActionCommand().equals("Save")){
+            save();
+        } else if (e.getActionCommand().equals("Reload")){
+            load();
+        }
+        
+    }
+}
diff --git a/src/main/java/istlab/KisoJikken/Launcher.java b/src/main/java/istlab/KisoJikken/Launcher.java
new file mode 100644
index 0000000..f934d9b
--- /dev/null
+++ b/src/main/java/istlab/KisoJikken/Launcher.java
@@ -0,0 +1,183 @@
+package istlab.KisoJikken;
+
+import java.awt.BorderLayout;
+import java.awt.event.MouseEvent;
+import java.io.File;
+import java.util.Arrays;
+import java.util.Hashtable;
+
+import javax.swing.JFrame;
+import javax.swing.JScrollPane;
+import javax.swing.JTree;
+import javax.swing.event.MouseInputListener;
+import javax.swing.event.TreeModelListener;
+import javax.swing.tree.TreeModel;
+import javax.swing.tree.TreePath;
+
+public class Launcher extends JFrame implements MouseInputListener {
+
+    public static Launcher theapp;
+    // JPanel mainP;
+    JTree tree;
+    Hashtable<File, Editor> file2editor;
+
+    public Launcher(String[] args) {
+        super("Kiso NWP Launcher");
+        setDefaultCloseOperation(EXIT_ON_CLOSE);
+        // mainP = new JPanel();
+        file2editor = new Hashtable<File,Editor>();
+        theapp = this;
+
+        File root;
+        if (args.length > 0)
+            root = new File(args[0]);
+        else
+            root = new File(System.getProperty("user.home") + "/NWP/src");
+
+        // Create a TreeModel object to represent our tree of files
+        FileTreeModel model = new FileTreeModel(root);
+
+        // Create a JTree and tell it to display our model
+        tree = new JTree();
+        tree.setModel(model);
+        tree.addMouseListener(this);
+
+        // The JTree can get big, so allow it to scroll.
+        JScrollPane scrollpane = new JScrollPane(tree);
+        // mainP.setLayout(new BoxLayout(mainP, BoxLayout.PAGE_AXIS));
+        // for (int i = 1; i < 8; i++) {
+        // JButton b = new JButton("j" + i);
+        // mainP.add(b);
+        // }
+        // ShellScriptPanel run11 = new ShellScriptPanel("run1-1.sh");
+        getContentPane().add(scrollpane, BorderLayout.CENTER);
+
+        // getContentPane().add(mainP, BorderLayout.WEST);
+        setSize(400, 600);
+    }
+
+    @Override
+    public void mouseClicked(MouseEvent e) {
+        if (e.getClickCount() == 2) {
+            TreePath tp = tree.getSelectionModel().getSelectionPath();
+            File node = (File) tp.getLastPathComponent();
+            Editor ed = file2editor.get(node);
+            if (ed==null) {
+                ed = new Editor(node);
+                file2editor.put(node,ed);
+            } else {
+                ed.setVisible(true);
+                ed.toFront();
+            }
+            System.out.println(node.toString());
+        }
+
+    }
+
+    @Override
+    public void mousePressed(MouseEvent e) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void mouseReleased(MouseEvent e) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void mouseEntered(MouseEvent e) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void mouseExited(MouseEvent e) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void mouseDragged(MouseEvent e) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public void mouseMoved(MouseEvent e) {
+        // TODO Auto-generated method stub
+
+    }
+
+}
+
+/**
+ * The methods in this class allow the JTree component to traverse
+ * the file system tree, and display the files and directories.
+ **/
+class FileTreeModel implements TreeModel {
+
+    // We specify the root directory when we create the model.
+    protected File root;
+
+    public FileTreeModel(File root) {
+        this.root = root;
+    }
+
+    // The model knows how to return the root object of the tree
+    public Object getRoot() {
+        return root;
+    }
+
+    // Tell JTree whether an object in the tree is a leaf or not
+    public boolean isLeaf(Object node) {
+        return ((File) node).isFile();
+    }
+
+    // Tell JTree how many children a node has
+    public int getChildCount(Object parent) {
+        String[] children = ((File) parent).list();
+        if (children == null)
+            return 0;
+        return children.length;
+    }
+
+    // Fetch any numbered child of a node for the JTree.
+    // Our model returns File objects for all nodes in the tree. The
+    // JTree displays these by calling the File.toString() method.
+    public Object getChild(Object parent, int index) {
+        String[] children = ((File) parent).list();
+        Arrays.sort(children);
+        if ((children == null) || (index >= children.length)) return null;
+        return new File((File) parent, children[index]);
+    }
+
+    // Figure out a child's position in its parent node.
+    public int getIndexOfChild(Object parent, Object child) {
+        String[] children = ((File) parent).list();
+        Arrays.sort(children);
+        if (children == null) return -1;
+        String childname = ((File) child).getName();
+        // if (childname.startsWith(".")) return -1;
+        for (int i = 0; i < children.length; i++) {
+            if (childname.equals(children[i]))
+                return i;
+        }
+        return -1;
+    }
+
+    // This method is only invoked by the JTree for editable trees.
+    // This TreeModel does not allow editing, so we do not implement
+    // this method. The JTree editable property is false by default.
+    public void valueForPathChanged(TreePath path, Object newvalue) {
+    }
+
+    // Since this is not an editable tree model, we never fire any events,
+    // so we don't actually have to keep track of interested listeners.
+    public void addTreeModelListener(TreeModelListener l) {
+    }
+
+    public void removeTreeModelListener(TreeModelListener l) {
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/istlab/KisoJikken/ShellScriptPanel.java b/src/main/java/istlab/KisoJikken/ShellScriptPanel.java
new file mode 100644
index 0000000..0c6518d
--- /dev/null
+++ b/src/main/java/istlab/KisoJikken/ShellScriptPanel.java
@@ -0,0 +1,82 @@
+package istlab.KisoJikken;
+
+import java.awt.BorderLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+
+public class ShellScriptPanel extends JPanel implements ActionListener, Runnable {
+    JTextArea jta;
+    JScrollPane jsp;
+    JLabel lbl;
+    String script;
+    JButton execB;
+    Thread thread;
+    Process process;
+
+    // private Thread stdOutReader;
+    // private Thread stdErrReader;
+    // private boolean stopThreads;
+    // private final PipedInputStream stdOutPin = new PipedInputStream();
+    // private final PipedInputStream stdErrPin = new PipedInputStream();
+
+    public ShellScriptPanel(String script) {
+        setLayout(new BorderLayout());
+        this.script = script;
+        jta = new JTextArea();
+        jta.setEditable(false);
+        jsp = new JScrollPane(jta);
+        add(jsp);
+        lbl = new JLabel(script);
+        add(lbl, BorderLayout.NORTH);
+
+        execB = new JButton("Run / Stop");
+        execB.addActionListener(this);
+        add(execB, BorderLayout.SOUTH);
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        if (thread == null) {
+            thread = new Thread(this);
+            thread.start();
+        } else {
+            process.destroy();
+            thread = null;
+        }
+    }
+
+    @Override
+    public void run() {
+        // Run script
+        String userHomeDir = System.getProperty("user.home");
+        System.out.println(userHomeDir + "/NWP/src/" + script);
+        ProcessBuilder processBuilder = new ProcessBuilder("bash", userHomeDir + "/NWP/src/" + script);
+        // ProcessBuilder processBuilder = new ProcessBuilder("pwd");
+        processBuilder.directory(new File(userHomeDir+"/NWP/src"));
+        processBuilder.inheritIO();
+        try {
+            process = processBuilder.start();
+            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
+            String line;
+            while ((line = reader.readLine()) != null) {
+                jta.append(line);
+            }
+            process.waitFor();
+        } catch (IOException | InterruptedException e1) {
+            e1.printStackTrace();
+        }
+        System.out.println("Exit");
+        thread = null;
+    }
+
+}
diff --git a/src/main/java/istlab/KisoJikken/Tutorial01.java b/src/main/java/istlab/KisoJikken/Tutorial01.java
new file mode 100644
index 0000000..38b539d
--- /dev/null
+++ b/src/main/java/istlab/KisoJikken/Tutorial01.java
@@ -0,0 +1,189 @@
+package istlab.KisoJikken;
+
+import java.io.IOException;
+
+import com.googlecode.lanterna.SGR;
+import com.googlecode.lanterna.TerminalPosition;
+import com.googlecode.lanterna.TextColor;
+import com.googlecode.lanterna.terminal.DefaultTerminalFactory;
+import com.googlecode.lanterna.terminal.Terminal;
+
+public class Tutorial01 {
+    public static void main(String[] args) throws InterruptedException {
+        /*
+        This is the first tutorial and entrypoint for learning more about how to use lanterna. We will use the lower
+        layer in this tutorial to demonstrate how to move around the cursor and how to output text in different
+        styles and color.
+        */
+
+        /*
+        First of all, we need to get hold of a Terminal object. This will be our main way of interacting with the
+        terminal itself. There are a couple of implementation available and it's important you pick the correct one:
+         * UnixTerminal - Uses ANSI escape codes through standard input/output to carry out the operations
+         * SwingTerminal - Creates a Swing JComponent extending surface that is implementing a terminal emulator
+         * SwingTerminalFrame - Creates a Swing JFrame containing a surface that is implementing a terminal emulator
+         * AWTTerminal - Creates an AWT Component extending surface that is implementing a terminal emulator
+         * AWTTerminalFrame - Creates an AWT Frame containing a surface that is implementing a terminal emulator
+         * TelnetTerminal - Through TelnetTerminalServer, this allows you control the output to the client through the Terminal interface
+         * VirtualTerminal - Complete in-memory implementation
+        If you intend to write a program that runs in a standard console, like for example on a remote server you're
+        connecting to through some terminal emulator and ssh, what you want is UnixTerminal. However, when developing
+        the program in your IDE, you might have issues as the IDE's console probably doesn't implement the ANSI escape
+        codes correctly and the output is complete garbage. Because of this, you might want to use one of the graphical
+        terminal emulators (Swing or AWT), which will open a new window when you run the program instead of writing to
+        standard output, and then switch to UnixTerminal when the application is ready. In order to simplify this,
+        lanterna provides a TerminalFactory with a DefaultTerminalFactory implementation that tries to figure out which
+        implementation to use. It's mainly checking for if the runtime system has a graphical frontend or not (i.e. if
+        Java considers the system headless) and if Java is detecting a semi-standard terminal or not (checking if
+        System.console() returns something), giving you either a terminal emulator or a UnixTerminal.
+        */
+
+        DefaultTerminalFactory defaultTerminalFactory = new DefaultTerminalFactory();
+        /*
+        The DefaultTerminalFactory can be further tweaked, but we'll leave it with default settings in this tutorial.
+         */
+
+        Terminal terminal = null;
+        try {
+            /*
+            Let the factory do its magic and figure out which implementation to use by calling createTerminal()
+             */
+            terminal = defaultTerminalFactory.createTerminal();
+
+            /*
+            If we got a terminal emulator (probably Swing) then we are currently looking at an empty terminal emulator
+            window at this point. If the code ran in another terminal emulator (putty, gnome-terminal, konsole, etc) by
+            invoking java manually, there is yet no changes to the content.
+             */
+
+            /*
+            Let's print some text, this has the same as calling System.out.println("Hello");
+             */
+            terminal.putCharacter('H');
+            terminal.putCharacter('e');
+            terminal.putCharacter('l');
+            terminal.putCharacter('l');
+            terminal.putCharacter('o');
+            terminal.putCharacter('\n');
+            terminal.flush();
+            /*
+            Notice the flush() call above; it is necessary to finish off terminal output operations with a call to
+            flush() both in the case of native terminal and the bundled terminal emulators. Lanterna's Unix terminal
+            doesn't buffer the output by itself but one can assume the underlying I/O layer does. In the case of the
+            terminal emulators bundled in lanterna, the flush call will signal a repaint to the underlying UI component.
+             */
+            Thread.sleep(2000);
+
+            /*
+            At this point the cursor should be on start of the next line, immediately after the Hello that was just
+            printed. Let's move the cursor to a new position, relative to the current position. Notice we still need to
+            call flush() to ensure the change is immediately visible (i.e. the user can see the text cursor moved to the
+            new position).
+            One thing to notice here is that if you are running this in a 'proper' terminal and the cursor position is
+            at the bottom line, it won't actually move the text up. Attempts at setting the cursor position outside the
+            terminal bounds are usually rounded to the first/last column/row. If you run into this, please clear the
+            terminal content so the cursor is at the top again before running this code.
+             */
+            TerminalPosition startPosition = terminal.getCursorPosition();
+            terminal.setCursorPosition(startPosition.withRelativeColumn(3).withRelativeRow(2));
+            terminal.flush();
+            Thread.sleep(2000);
+
+            /*
+            Let's continue by changing the color of the text printed. This doesn't change any currently existing text,
+            it will only take effect on whatever we print after this.
+             */
+            terminal.setBackgroundColor(TextColor.ANSI.BLUE);
+            terminal.setForegroundColor(TextColor.ANSI.YELLOW);
+
+            /*
+            Now print text with these new colors
+             */
+            terminal.putCharacter('Y');
+            terminal.putCharacter('e');
+            terminal.putCharacter('l');
+            terminal.putCharacter('l');
+            terminal.putCharacter('o');
+            terminal.putCharacter('w');
+            terminal.putCharacter(' ');
+            terminal.putCharacter('o');
+            terminal.putCharacter('n');
+            terminal.putCharacter(' ');
+            terminal.putCharacter('b');
+            terminal.putCharacter('l');
+            terminal.putCharacter('u');
+            terminal.putCharacter('e');
+            terminal.flush();
+            Thread.sleep(2000);
+
+            /*
+            In addition to colors, most terminals supports some sort of style that can be selectively enabled. The most
+            common one is bold mode, which on many terminal implementations (emulators and otherwise) is not actually
+            using bold text at all but rather shifts the tint of the foreground color so it stands out a bit. Let's
+            print the same text as above in bold mode to compare.
+            Notice that startPosition has the same value as when we retrieved it with getTerminalSize(), the
+            TerminalPosition class is immutable and calling the with* methods will return a copy. So the following
+            setCursorPosition(..) call will put us exactly one row below the previous row.
+             */
+            terminal.setCursorPosition(startPosition.withRelativeColumn(3).withRelativeRow(3));
+            terminal.flush();
+            Thread.sleep(2000);
+            terminal.enableSGR(SGR.BOLD);
+            terminal.putCharacter('Y');
+            terminal.putCharacter('e');
+            terminal.putCharacter('l');
+            terminal.putCharacter('l');
+            terminal.putCharacter('o');
+            terminal.putCharacter('w');
+            terminal.putCharacter(' ');
+            terminal.putCharacter('o');
+            terminal.putCharacter('n');
+            terminal.putCharacter(' ');
+            terminal.putCharacter('b');
+            terminal.putCharacter('l');
+            terminal.putCharacter('u');
+            terminal.putCharacter('e');
+            terminal.flush();
+            Thread.sleep(2000);
+
+            /*
+            Ok, that's enough for now. Let's reset colors and SGR modifiers and move down one more line
+             */
+            terminal.resetColorAndSGR();
+            terminal.setCursorPosition(terminal.getCursorPosition().withColumn(0).withRelativeRow(1));
+            terminal.putCharacter('D');
+            terminal.putCharacter('o');
+            terminal.putCharacter('n');
+            terminal.putCharacter('e');
+            terminal.putCharacter('\n');
+            terminal.flush();
+
+            Thread.sleep(2000);
+
+            /*
+            Beep and exit
+             */
+            terminal.bell();
+            terminal.flush();
+            Thread.sleep(200);
+        }
+        catch(IOException e) {
+            e.printStackTrace();
+        }
+        finally {
+            if(terminal != null) {
+                try {
+                    /*
+                    Closing the terminal doesn't always do something, but if you run the Swing or AWT bundled terminal
+                    emulators for example, it will close the window and allow this application to terminate. Calling it
+                    on a UnixTerminal will not have any affect.
+                     */
+                    terminal.close();
+                }
+                catch(IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/java/istlab/TestRSyntaxTA/App.java b/src/main/java/istlab/TestRSyntaxTA/App.java
deleted file mode 100644
index 6342910..0000000
--- a/src/main/java/istlab/TestRSyntaxTA/App.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package istlab.TestRSyntaxTA;
-
-import javax.swing.SwingUtilities;
-import javax.swing.UIManager;
-
-/**
- * Hello world!
- *
- */
-public class App {
-    public static void main(String[] args) {
-        // SwingUtilities.invokeLater(() -> {
-		// 	String laf = UIManager.getSystemLookAndFeelClassName();
-		// 	//laf = "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel";
-		// 	try {
-		// 		UIManager.setLookAndFeel(laf);
-		// 	} catch (Exception e) {
-		// 		e.printStackTrace();
-		// 	}
-		// 	AutoCompleteDemoApp frame = new AutoCompleteDemoApp();
-		// 	frame.getToolkit().setDynamicLayout(true);
-		// 	frame.setVisible(true);
-		// });
-
-
-        // System.out.println("Hello World!");
-        // Instantiate GUI on the EDT.
-        SwingUtilities.invokeLater(() -> {
-            try {
-                String laf = UIManager.getSystemLookAndFeelClassName();
-                UIManager.setLookAndFeel(laf);
-            } catch (Exception e) {
-                /* Never happens */ }
-            new AutoCompleteDemo().setVisible(true);
-        });
-
-    }
-}
diff --git a/src/main/java/istlab/TestRSyntaxTA/AutoCompleteDemo.java b/src/main/java/istlab/TestRSyntaxTA/AutoCompleteDemo.java
deleted file mode 100644
index a2234ea..0000000
--- a/src/main/java/istlab/TestRSyntaxTA/AutoCompleteDemo.java
+++ /dev/null
@@ -1,167 +0,0 @@
-package istlab.TestRSyntaxTA;
-
-import java.awt.BorderLayout;
-import java.awt.Font;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-
-import javax.swing.JButton;
-import javax.swing.JFrame;
-import javax.swing.JPanel;
-import javax.swing.SwingUtilities;
-import javax.swing.UIManager;
-import javax.swing.plaf.FontUIResource;
-
-import org.fife.ui.autocomplete.AutoCompletion;
-import org.fife.ui.autocomplete.BasicCompletion;
-import org.fife.ui.autocomplete.CompletionProvider;
-import org.fife.ui.autocomplete.DefaultCompletionProvider;
-import org.fife.ui.autocomplete.ShorthandCompletion;
-import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;
-import org.fife.ui.rsyntaxtextarea.SyntaxConstants;
-import org.fife.ui.rtextarea.RTextScrollPane;
-import org.mdkt.compiler.InMemoryJavaCompiler;
-
-public class AutoCompleteDemo extends JFrame {
-
-   RSyntaxTextArea textArea;
-
-   public AutoCompleteDemo() {
-
-      JPanel contentPane = new JPanel(new BorderLayout());
-      textArea = new RSyntaxTextArea(20, 60);
-      textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA);
-      textArea.setCodeFoldingEnabled(true);
-      textArea.setFont(new FontUIResource("sansserif", Font.PLAIN, 20));
-      contentPane.add(new RTextScrollPane(textArea));
-
-      // A CompletionProvider is what knows of all possible completions, and
-      // analyzes the contents of the text area at the caret position to
-      // determine what completion choices should be presented. Most instances
-      // of CompletionProvider (such as DefaultCompletionProvider) are designed
-      // so that they can be shared among multiple text components.
-      CompletionProvider provider = createCompletionProvider();
-
-      // An AutoCompletion acts as a "middle-man" between a text component
-      // and a CompletionProvider. It manages any options associated with
-      // the auto-completion (the popup trigger key, whether to display a
-      // documentation window along with completion choices, etc.). Unlike
-      // CompletionProviders, instances of AutoCompletion cannot be shared
-      // among multiple text components.
-      AutoCompletion ac = new AutoCompletion(provider);
-      ac.install(textArea);
-
-      setContentPane(contentPane);
-      setTitle("AutoComplete Demo");
-      setDefaultCloseOperation(EXIT_ON_CLOSE);
-
-      JPanel north = new JPanel();
-      JButton loadB = new JButton("Load");
-      loadB.addActionListener(new ActionListener() {
-         @Override
-         public void actionPerformed(ActionEvent e) {
-            InputStream is = getClass().getResourceAsStream("/Hello.java");
-            BufferedReader br = new BufferedReader(new InputStreamReader(is));
-            StringBuilder sb = new StringBuilder();
-            String line;
-            try {
-               while((line=br.readLine())!=null){
-                  sb.append(line+"\n");
-               }
-            } catch (IOException e1) {
-               e1.printStackTrace();
-            }
-            textArea.setText(sb.toString());
-
-         }
-      });
-      north.add(loadB);
-
-      JButton saveB = new JButton("Save");
-      saveB.addActionListener(new ActionListener() {
-         @Override
-         public void actionPerformed(ActionEvent e) {
-            System.out.println(textArea.getText());
-         }
-      });
-      north.add(saveB);
-
-      JButton execB = new JButton("Exec");
-      execB.addActionListener(new ActionListener() {
-         @Override
-         public void actionPerformed(ActionEvent e) {
-            Class<?> helloClass;
-            try {
-               helloClass = InMemoryJavaCompiler.newInstance().compile("Hello", textArea.getText());
-               System.out.println(helloClass.getClass().getName());
-
-               System.out.println(helloClass.getDeclaredConstructor().newInstance().toString());
-            } catch (Exception e1) {
-               e1.printStackTrace();
-            }
-
-         }
-      });
-      north.add(execB);
-      // JOptionPane.showMessageDialog(null, "test");
-
-      add(north, BorderLayout.NORTH);
-      pack();
-      setLocationRelativeTo(null);
-
-
-   }
-
-   /**
-    * Create a simple provider that adds some Java-related completions.
-    */
-   private CompletionProvider createCompletionProvider() {
-
-      // A DefaultCompletionProvider is the simplest concrete implementation
-      // of CompletionProvider. This provider has no understanding of
-      // language semantics. It simply checks the text entered up to the
-      // caret position for a match against known completions. This is all
-      // that is needed in the majority of cases.
-      DefaultCompletionProvider provider = new DefaultCompletionProvider();
-
-      // Add completions for all Java keywords. A BasicCompletion is just
-      // a straightforward word completion.
-      provider.addCompletion(new BasicCompletion(provider, "abstract"));
-      provider.addCompletion(new BasicCompletion(provider, "assert"));
-      provider.addCompletion(new BasicCompletion(provider, "break"));
-      provider.addCompletion(new BasicCompletion(provider, "case"));
-      // ... etc ...
-      provider.addCompletion(new BasicCompletion(provider, "transient"));
-      provider.addCompletion(new BasicCompletion(provider, "try"));
-      provider.addCompletion(new BasicCompletion(provider, "void"));
-      provider.addCompletion(new BasicCompletion(provider, "volatile"));
-      provider.addCompletion(new BasicCompletion(provider, "while"));
-
-      // Add a couple of "shorthand" completions. These completions don't
-      // require the input text to be the same thing as the replacement text.
-      provider.addCompletion(new ShorthandCompletion(provider, "sysout",
-            "System.out.println(", "System.out.println("));
-      provider.addCompletion(new ShorthandCompletion(provider, "syserr",
-            "System.err.println(", "System.err.println("));
-
-      return provider;
-
-   }
-
-   public static void main(String[] args) {
-      // Instantiate GUI on the EDT.
-      SwingUtilities.invokeLater(() -> {
-         try {
-            String laf = UIManager.getSystemLookAndFeelClassName();
-            UIManager.setLookAndFeel(laf);
-         } catch (Exception e) {
-            /* Never happens */ }
-         new AutoCompleteDemo().setVisible(true);
-      });
-   }
-
-}
\ No newline at end of file
diff --git a/src/main/java/istlab/TestRSyntaxTA/demo/AutoCompleteDemoApp.java b/src/main/java/istlab/TestRSyntaxTA/demo/AutoCompleteDemoApp.java
deleted file mode 100644
index e2ba144..0000000
--- a/src/main/java/istlab/TestRSyntaxTA/demo/AutoCompleteDemoApp.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * 12/21/2008
- *
- * AutoCompleteDemoApp.java - A demo program for the auto-completion library.
- *
- * This library is distributed under a modified BSD license.  See the included
- * LICENSE.md file for details.
- */
-package istlab.TestRSyntaxTA.demo;
-
-import java.awt.Dimension;
-
-import javax.swing.JFrame;
-import javax.swing.SwingUtilities;
-import javax.swing.UIManager;
-import javax.swing.WindowConstants;
-
-import org.fife.ui.autocomplete.CompletionProvider;
-
-
-/**
- * A program that demonstrates use of auto-completion.  It creates a simple
- * C source editor with context sensitive auto-completion.
- *
- * @author Robert Futrell
- * @version 1.0
- */
-public class AutoCompleteDemoApp extends JFrame {
-
-
-	/**
-	 * Constructor.
-	 */
-	public AutoCompleteDemoApp() {
-		this(null);
-	}
-
-
-	/**
-	 * Constructor.
-	 *
-	 * @param provider The completion provider for the editor to use.
-	 */
-	public AutoCompleteDemoApp(CompletionProvider provider) {
-		setRootPane(new DemoRootPane(provider));
-		setTitle("AutoCompletion Demo");
-		setSize(new Dimension(500,600));//pack();
-		setLocationRelativeTo(null);
-		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
-	}
-
-
-	/**
-	 * Program entry point.
-	 *
-	 * @param args Command line arguments.
-	 */
-	public static void main(String[] args) {
-
-		SwingUtilities.invokeLater(() -> {
-			String laf = UIManager.getSystemLookAndFeelClassName();
-			//laf = "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel";
-			try {
-				UIManager.setLookAndFeel(laf);
-			} catch (Exception e) {
-				e.printStackTrace();
-			}
-			AutoCompleteDemoApp frame = new AutoCompleteDemoApp();
-			frame.getToolkit().setDynamicLayout(true);
-			frame.setVisible(true);
-		});
-
-	}
-
-
-}
diff --git a/src/main/java/istlab/TestRSyntaxTA/demo/CCellRenderer.java b/src/main/java/istlab/TestRSyntaxTA/demo/CCellRenderer.java
deleted file mode 100644
index f129208..0000000
--- a/src/main/java/istlab/TestRSyntaxTA/demo/CCellRenderer.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * 01/07/2009
- *
- * CCellRenderer.java - A cell renderer for C completions.
- *
- * This library is distributed under a modified BSD license.  See the included
- * LICENSE.md file for details.
- */
-package istlab.TestRSyntaxTA.demo;
-
-import javax.swing.Icon;
-import javax.swing.JList;
-
-import org.fife.ui.autocomplete.Completion;
-import org.fife.ui.autocomplete.CompletionCellRenderer;
-import org.fife.ui.autocomplete.FunctionCompletion;
-import org.fife.ui.autocomplete.VariableCompletion;
-
-
-/**
- * The cell renderer used for the C programming language.
- *
- * @author Robert Futrell
- * @version 1.0
- */
-class CCellRenderer extends CompletionCellRenderer {
-
-	private Icon variableIcon;
-	private Icon functionIcon;
-
-
-	/**
-	 * Constructor.
-	 */
-	CCellRenderer() {
-		variableIcon = getIcon("img/var.png");
-		functionIcon = getIcon("img/function.png");
-	}
-
-
-	/**
-	 * {@inheritDoc}
-	 */
-	@Override
-	protected void prepareForOtherCompletion(JList list,
-			Completion c, int index, boolean selected, boolean hasFocus) {
-		super.prepareForOtherCompletion(list, c, index, selected, hasFocus);
-		setIcon(getEmptyIcon());
-	}
-
-
-	/**
-	 * {@inheritDoc}
-	 */
-	@Override
-	protected void prepareForVariableCompletion(JList list,
-			VariableCompletion vc, int index, boolean selected,
-			boolean hasFocus) {
-		super.prepareForVariableCompletion(list, vc, index, selected,
-										hasFocus);
-		setIcon(variableIcon);
-	}
-
-
-	/**
-	 * {@inheritDoc}
-	 */
-	@Override
-	protected void prepareForFunctionCompletion(JList list,
-			FunctionCompletion fc, int index, boolean selected,
-			boolean hasFocus) {
-		super.prepareForFunctionCompletion(list, fc, index, selected,
-										hasFocus);
-		setIcon(functionIcon);
-	}
-
-
-}
diff --git a/src/main/java/istlab/TestRSyntaxTA/demo/DemoRootPane.java b/src/main/java/istlab/TestRSyntaxTA/demo/DemoRootPane.java
deleted file mode 100644
index 4e29539..0000000
--- a/src/main/java/istlab/TestRSyntaxTA/demo/DemoRootPane.java
+++ /dev/null
@@ -1,471 +0,0 @@
-/*
- * 01/13/2009
- *
- * DemoRootPane.java - Root pane for the demo applet and standalone application.
- *
- * This library is distributed under a modified BSD license.  See the included
- * LICENSE.md file for details.
- */
-package istlab.TestRSyntaxTA.demo;
-
-import java.awt.BorderLayout;
-import java.awt.Color;
-import java.awt.Component;
-import java.awt.Font;
-import java.awt.event.ActionEvent;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.StringReader;
-import java.util.Arrays;
-
-import javax.swing.AbstractAction;
-import javax.swing.Action;
-import javax.swing.BorderFactory;
-import javax.swing.ButtonGroup;
-import javax.swing.JCheckBoxMenuItem;
-import javax.swing.JEditorPane;
-import javax.swing.JMenu;
-import javax.swing.JMenuBar;
-import javax.swing.JMenuItem;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JRadioButtonMenuItem;
-import javax.swing.JRootPane;
-import javax.swing.SwingUtilities;
-import javax.swing.ToolTipManager;
-import javax.swing.UIManager;
-import javax.swing.text.TextAction;
-
-import org.fife.ui.autocomplete.AutoCompletion;
-import org.fife.ui.autocomplete.BasicCompletion;
-import org.fife.ui.autocomplete.CompletionCellRenderer;
-import org.fife.ui.autocomplete.CompletionProvider;
-import org.fife.ui.autocomplete.DefaultCompletionProvider;
-import org.fife.ui.autocomplete.FunctionCompletion;
-import org.fife.ui.autocomplete.LanguageAwareCompletionProvider;
-import org.fife.ui.autocomplete.ParameterizedCompletion;
-import org.fife.ui.autocomplete.ShorthandCompletion;
-import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;
-import org.fife.ui.rsyntaxtextarea.SyntaxConstants;
-import org.fife.ui.rtextarea.RTextScrollPane;
-import org.fife.ui.rtextarea.ToolTipSupplier;
-
-
-/**
- * The root pane for the demo application.  This is all code shared between
- * the applet and standalone versions of the demo.
- *
- * @author Robert Futrell
- * @version 1.0
- */
-class DemoRootPane extends JRootPane {
-
-	private RSyntaxTextArea textArea;
-	private AutoCompletion ac;
-	private JCheckBoxMenuItem cellRenderingItem;
-	private JCheckBoxMenuItem alternateRowColorsItem;
-	private JCheckBoxMenuItem showDescWindowItem;
-	private JCheckBoxMenuItem paramAssistanceItem;
-	private JEditorPane ep;
-
-	private static final Color ALT_BG_COLOR = new Color(0xf0f0f0);
-
-
-	/**
-	 * Constructor.
-	 */
-	DemoRootPane() {
-		this(null);
-	}
-
-
-	/**
-	 * Constructor.
-	 *
-	 * @param provider The completion provider for the editor to use.
-	 */
-	DemoRootPane(CompletionProvider provider) {
-
-		JPanel contentPane = new JPanel(new BorderLayout());
-
-		ep = new JEditorPane("text/html", null);
-		updateEditorPane(); // Nimbus doesn't always clean up after itself.
-		contentPane.add(ep, BorderLayout.NORTH);
-
-		textArea = new RSyntaxTextArea(25, 40);
-		textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_C);
-
-		if (provider==null) {
-			provider = createCompletionProvider();
-		}
-
-		// Install auto-completion onto our text area.
-		ac = new AutoCompletion(provider);
-		ac.setListCellRenderer(new CCellRenderer());
-		ac.setShowDescWindow(true);
-		ac.setParameterAssistanceEnabled(true);
-
-		ac.setAutoCompleteEnabled(true);
-		ac.setAutoActivationEnabled(true);
-		ac.setAutoCompleteSingleChoices(true);
-		ac.setAutoActivationDelay(800);
-
-		ac.install(textArea);
-		contentPane.add(new RTextScrollPane(textArea, true));
-
-		try {
-			textArea.read(new StringReader("int main() {\n  printf(\"Hello world\\n\");\n}\n"), null);
-		} catch (IOException ioe) {
-			ioe.printStackTrace();
-		}
-
-		textArea.setToolTipSupplier((ToolTipSupplier)provider);
-		ToolTipManager.sharedInstance().registerComponent(textArea);
-
-		setJMenuBar(createMenuBar());
-
-		// Get ready to go.
-		setContentPane(contentPane);
-
-		// Put the focus into the text area, not the "label" JEditorPane.
-		SwingUtilities.invokeLater(() -> textArea.requestFocusInWindow());
-
-	}
-
-
-	/**
-	 * Returns the provider to use when editing code.
-	 *
-	 * @return The provider.
-	 * @see #createCommentCompletionProvider()
-	 * @see #createStringCompletionProvider()
-	 */
-	private CompletionProvider createCodeCompletionProvider() {
-
-		// Add completions for the C standard library.
-		DefaultCompletionProvider cp = new DefaultCompletionProvider();
-
-		cp.setAutoActivationRules(true, ".");
-
-		// First try loading resource (running from demo jar), then try
-		// accessing file (debugging in Eclipse).
-		ClassLoader cl = getClass().getClassLoader();
-		InputStream in = cl.getResourceAsStream("c.xml");
-		try {
-			if (in!=null) {
-				cp.loadFromXML(in);
-				in.close();
-			}
-			else {
-				cp.loadFromXML(new File("c.xml"));
-			}
-		} catch (IOException ioe) {
-			ioe.printStackTrace();
-		}
-
-		// Add some handy shorthand completions.
-		cp.addCompletion(new ShorthandCompletion(cp, "main",
-							"int main(int argc, char **argv)"));
-
-		// Add a parameterized completion with a ton of parameters (see #67)
-		FunctionCompletion functionCompletionWithLotsOfParameters = new FunctionCompletion(cp, "long", "int");
-		functionCompletionWithLotsOfParameters.setParams(Arrays.asList(
-			new ParameterizedCompletion.Parameter("int", "intVal"),
-			new ParameterizedCompletion.Parameter("float", "floatVal"),
-			new ParameterizedCompletion.Parameter("string", "stringVal"),
-			new ParameterizedCompletion.Parameter("int", "otherVal1"),
-			new ParameterizedCompletion.Parameter("int", "otherVal2"),
-			new ParameterizedCompletion.Parameter("int", "otherVal3"),
-			new ParameterizedCompletion.Parameter("int", "otherVal4"),
-			new ParameterizedCompletion.Parameter("int", "otherVal5"),
-			new ParameterizedCompletion.Parameter("int", "otherVal6"),
-			new ParameterizedCompletion.Parameter("int", "otherVal7"),
-			new ParameterizedCompletion.Parameter("int", "otherVal8"),
-			new ParameterizedCompletion.Parameter("int", "otherVal9"),
-			new ParameterizedCompletion.Parameter("int", "otherVal9"),
-			new ParameterizedCompletion.Parameter("int", "otherVal10"),
-			new ParameterizedCompletion.Parameter("int", "otherVal11"),
-			new ParameterizedCompletion.Parameter("int", "otherVal12"),
-			new ParameterizedCompletion.Parameter("int", "otherVal13"),
-			new ParameterizedCompletion.Parameter("int", "otherVal14"),
-			new ParameterizedCompletion.Parameter("int", "otherVal15"),
-			new ParameterizedCompletion.Parameter("int", "otherVal16"),
-			new ParameterizedCompletion.Parameter("int", "otherVal17"),
-			new ParameterizedCompletion.Parameter("int", "otherVal18"),
-			new ParameterizedCompletion.Parameter("int", "otherVal19"),
-			new ParameterizedCompletion.Parameter("int", "otherVal20")
-		));
-		cp.addCompletion(functionCompletionWithLotsOfParameters);
-		return cp;
-
-	}
-
-
-	/**
-	 * Returns the provider to use when in a comment.
-	 *
-	 * @return The provider.
-	 * @see #createCodeCompletionProvider()
-	 * @see #createStringCompletionProvider()
-	 */
-	private CompletionProvider createCommentCompletionProvider() {
-		DefaultCompletionProvider cp = new DefaultCompletionProvider();
-		cp.addCompletion(new BasicCompletion(cp, "TODO:", "A to-do reminder"));
-		cp.addCompletion(new BasicCompletion(cp, "FIXME:", "A bug that needs to be fixed"));
-		return cp;
-	}
-
-
-	/**
-	 * Creates the completion provider for a C editor.  This provider can be
-	 * shared among multiple editors.
-	 *
-	 * @return The provider.
-	 */
-	private CompletionProvider createCompletionProvider() {
-
-		// Create the provider used when typing code.
-		CompletionProvider codeCP = createCodeCompletionProvider();
-
-		// The provider used when typing a string.
-		CompletionProvider stringCP = createStringCompletionProvider();
-
-		// The provider used when typing a comment.
-		CompletionProvider commentCP = createCommentCompletionProvider();
-
-		// Create the "parent" completion provider.
-		LanguageAwareCompletionProvider provider = new
-								LanguageAwareCompletionProvider(codeCP);
-		provider.setStringCompletionProvider(stringCP);
-		provider.setCommentCompletionProvider(commentCP);
-
-		return provider;
-
-	}
-
-
-	/**
-	 * Returns the menu bar for the demo application.
-	 *
-	 * @return The menu bar.
-	 */
-	private JMenuBar createMenuBar() {
-
-		JMenuBar mb = new JMenuBar();
-
-		JMenu menu = new JMenu("File");
-		Action newAction = new TextAction("New") {
-			@Override
-			public void actionPerformed(ActionEvent e) {
-				AutoCompleteDemoApp app2 = new AutoCompleteDemoApp(
-												ac.getCompletionProvider());
-				app2.setVisible(true);
-			}
-		};
-		JMenuItem item = new JMenuItem(newAction);
-		menu.add(item);
-		mb.add(menu);
-
-		menu = new JMenu("View");
-		Action renderAction = new FancyCellRenderingAction();
-		cellRenderingItem = new JCheckBoxMenuItem(renderAction);
-		cellRenderingItem.setSelected(true);
-		menu.add(cellRenderingItem);
-		Action alternateRowColorsAction = new AlternateRowColorsAction();
-		alternateRowColorsItem = new JCheckBoxMenuItem(alternateRowColorsAction);
-		menu.add(alternateRowColorsItem);
-		Action descWindowAction = new ShowDescWindowAction();
-		showDescWindowItem = new JCheckBoxMenuItem(descWindowAction);
-		showDescWindowItem.setSelected(true);
-		menu.add(showDescWindowItem);
-		Action paramAssistanceAction = new ParameterAssistanceAction();
-		paramAssistanceItem = new JCheckBoxMenuItem(paramAssistanceAction);
-		paramAssistanceItem.setSelected(true);
-		menu.add(paramAssistanceItem);
-		mb.add(menu);
-
-		ButtonGroup bg = new ButtonGroup();
-		menu = new JMenu("LookAndFeel");
-		Action lafAction = new LafAction("System", UIManager.getSystemLookAndFeelClassName());
-		JRadioButtonMenuItem rbmi = new JRadioButtonMenuItem(lafAction);
-		rbmi.setSelected(true);
-		menu.add(rbmi);
-		bg.add(rbmi);
-		lafAction = new LafAction("Motif", "com.sun.java.swing.plaf.motif.MotifLookAndFeel");
-		rbmi = new JRadioButtonMenuItem(lafAction);
-		menu.add(rbmi);
-		bg.add(rbmi);
-		lafAction = new LafAction("Ocean", "javax.swing.plaf.metal.MetalLookAndFeel");
-		rbmi = new JRadioButtonMenuItem(lafAction);
-		menu.add(rbmi);
-		bg.add(rbmi);
-		lafAction = new LafAction("Nimbus", "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
-		rbmi = new JRadioButtonMenuItem(lafAction);
-		menu.add(rbmi);
-		bg.add(rbmi);
-		mb.add(menu);
-
-		return mb;
-
-	}
-
-
-	/**
-	 * Returns the completion provider to use when the caret is in a string.
-	 *
-	 * @return The provider.
-	 * @see #createCodeCompletionProvider()
-	 * @see #createCommentCompletionProvider()
-	 */
-	private CompletionProvider createStringCompletionProvider() {
-		DefaultCompletionProvider cp = new DefaultCompletionProvider();
-		cp.addCompletion(new BasicCompletion(cp, "%c", "char", "Prints a character"));
-		cp.addCompletion(new BasicCompletion(cp, "%i", "signed int", "Prints a signed integer"));
-		cp.addCompletion(new BasicCompletion(cp, "%f", "float", "Prints a float"));
-		cp.addCompletion(new BasicCompletion(cp, "%s", "string", "Prints a string"));
-		cp.addCompletion(new BasicCompletion(cp, "%u", "unsigned int", "Prints an unsigned integer"));
-		cp.addCompletion(new BasicCompletion(cp, "\\n", "Newline", "Prints a newline"));
-		return cp;
-	}
-
-
-	/**
-	 * Focuses the text area.
-	 */
-	public void focusEditor() {
-		textArea.requestFocusInWindow();
-	}
-
-
-	/**
-	 * Updates the font used in the HTML, as well as the background color, of
-	 * the "label" editor pane.  The font would always have to be done (since
-	 * HTMLEditorKit doesn't use the editor pane's font by default), but the
-	 * background only has to be modified because Nimbus doesn't clean up the
-	 * colors it installs after itself.
-	 */
-	private void updateEditorPane() {
-		Font f = UIManager.getFont("Label.font");
-		String fontTag = "<body style=\"font-family: " + f.getFamily() +
-					"; font-size: " + f.getSize() + "pt; \">";
-		String text = "<html>" + fontTag + "" +
-			"The text area below provides simple code completion for the C " +
-			"programming language as you type. Simply type <b>Ctrl+Space</b> " +
-			"at any time to see a list of completion choices (function names, "+
-			"for example). If there is only one possible completion, it will " +
-			"be automatically inserted.<p>" +
-			"Also, completions are context-sensitive.  If you type " +
-			"Ctrl+Space in a comment or in the middle of a string, you will " +
-			"get different completion choices than if you are in code.";
-		ep.setText(text);
-		ep.setBorder(BorderFactory.createEmptyBorder(5,5,10,5));
-		ep.setEditable(false);
-		ep.setBackground(UIManager.getColor("Panel.background"));
-	}
-
-
-	/**
-	 * Toggles whether row backgrounds use alternate colors.
-	 */
-	private class AlternateRowColorsAction extends AbstractAction {
-
-		AlternateRowColorsAction() {
-			putValue(NAME, "Alternate Row Colors in completion list");
-		}
-
-		@Override
-		public void actionPerformed(ActionEvent e) {
-			boolean alternate = alternateRowColorsItem.isSelected();
-			CompletionCellRenderer.setAlternateBackground(
-					alternate ? ALT_BG_COLOR: null);
-		}
-
-	}
-
-
-	/**
-	 * Toggles whether the completion window uses "fancy" rendering.
-	 */
-	private class FancyCellRenderingAction extends AbstractAction {
-
-		FancyCellRenderingAction() {
-			putValue(NAME, "Fancy Cell Rendering");
-		}
-
-		@Override
-		public void actionPerformed(ActionEvent e) {
-			boolean fancy = cellRenderingItem.isSelected();
-			ac.setListCellRenderer(fancy ? new CCellRenderer() : null);
-		}
-
-	}
-
-
-	/**
-	 * Sets a new look and feel.
-	 */
-	private class LafAction extends AbstractAction {
-
-		private String laf;
-
-		LafAction(String name, String laf) {
-			putValue(NAME, name);
-			this.laf = laf;
-		}
-
-		@Override
-		public void actionPerformed(ActionEvent e) {
-			try {
-				UIManager.setLookAndFeel(laf);
-			} catch (Exception ex) {
-				JOptionPane.showMessageDialog(DemoRootPane.this,
-					"Error setting LookAndFeel", "Error",
-					JOptionPane.ERROR_MESSAGE);
-				return;
-			}
-			Component parent = SwingUtilities.getRoot(DemoRootPane.this);
-			SwingUtilities.updateComponentTreeUI(parent);
-			updateEditorPane();
-		}
-
-	}
-
-
-	/**
-	 * Toggles whether parameter assistance is enabled.
-	 */
-	private class ParameterAssistanceAction extends AbstractAction {
-
-		ParameterAssistanceAction() {
-			putValue(NAME, "Function Parameter Assistance");
-		}
-
-		@Override
-		public void actionPerformed(ActionEvent e) {
-			boolean enabled = paramAssistanceItem.isSelected();
-			ac.setParameterAssistanceEnabled(enabled);
-		}
-
-	}
-
-
-	/**
-	 * Toggles whether the description window is visible.
-	 */
-	private class ShowDescWindowAction extends AbstractAction {
-
-		ShowDescWindowAction() {
-			putValue(NAME, "Show Description Window");
-		}
-
-		@Override
-		public void actionPerformed(ActionEvent e) {
-			boolean show = showDescWindowItem.isSelected();
-			ac.setShowDescWindow(show);
-		}
-
-	}
-
-
-}
diff --git a/src/main/java/istlab/TestRSyntaxTA/demo/package-info.java b/src/main/java/istlab/TestRSyntaxTA/demo/package-info.java
deleted file mode 100644
index 9badafc..0000000
--- a/src/main/java/istlab/TestRSyntaxTA/demo/package-info.java
+++ /dev/null
@@ -1,4 +0,0 @@
-/**
- * A package that demonstrates features of the AutoComplete library.
- */
-package istlab.TestRSyntaxTA.demo;