{% extends "base.html" %}

{% block title %}Login{% endblock title %}
{% block page_title %}Login{% endblock page_title %}

{% block content %}

{% if form.errors %}

          <div class="alert alert-error">
          <a href="#" class="close" data-dismiss="alert">&times;</a>
          Your username and password did not match. Please try again.
          </div>
{% endif %}

<form method="post" action="{% url 'login' %}">
{% csrf_token %}
<table>
<tr>
    <td>{{ form.username.label_tag }}</td>
    <td>{{ form.username }}</td>
</tr>
<tr>
    <td>{{ form.password.label_tag }}</td>
    <td>{{ form.password }}</td>
</tr>
</table>

<input type="submit" value="login" />
<input type="hidden" name="next" value="{{ next|escape }}" />
</form>

{% endblock %}

/*
 * Author: Alex R Gronseth
 * 
 * Date: 12/05/2012
 * 
 * Course: Comp 2247 Spring 2013
 * 
 * Assignment: Program 1
 * 
 * Description: A GUI application that takes an input string, tokenizes each
 * word within the string, and uses a stack to reverse the word. Punctuation at
 * the end of words is not reversed.
 */

package reverseit;

//Make needed imports
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;

/**
 * Creates the GUI used for the application.
 * @author Alex
 * @version 2/20/2013
 */
public class ReverseIt extends JFrame
{
   //Create all the J Components
   private JTextField inputField;
   private JTextField outputField;
   
   private JTextArea inputTA;
   private JTextArea outputTA;
   
   private JButton reverseB;
   private JButton clearB;
   private JButton exitB;
   
   //Create the button handlers
   private Reverser strReverser;
   private ClearButtonHandler cbHandler;
   private ExitButtonHandler ebHandler;
   
   //Create constants
   private static final int WIDTH = 600;
   private static final int HEIGHT = 400;
   private static final String NO_REV_YET = "Notice: You have not yet reversed "
                                          + "any text.";
   private static final String EMPTY_INPUT = "ERROR! You did not enter anything"
                               + " to be reversed. Press the \"Clear\" "
                               + "button and try again.";
   private static final String INTRODUCTION = "This program will take an input "
           + "sentence and reverse each word in the sentence. If a word to be "
           + "reversed ends with one of the 6 punctuation characters within the"
           + " following parenthesis: <b>(. , ; : ! ?)</b> the punctuation will"
           + " not be reversed. Multiple space characters will be folded to a "
           + "single space. Press the enter key or the button titled \"Reverse "
           + "it!\" to reverse your input. To reverse a new sentence, press the"
           + " button labeled \"Clear\" and start over."
            + "<p><center><b>See: this example!</b> will become <b>eeS: siht "
            + "elpmaxe!</b></center></p>";

private ReverseIt()
{
    //Create the intro and id areas
    JEditorPane introPane = new JEditorPane("text/html", "");
    introPane.setText(INTRODUCTION);
    inputField = new JTextField ("Input sentence: ");
    outputField = new JTextField ("Words reversed: ");
    
    //Set appearance of the intro and id areas
    introPane.setEditable(false);
    introPane.setBackground(Color.YELLOW);
    introPane.setBorder(BorderFactory.createLineBorder(Color.BLACK));
    inputField.setEditable(false);
    inputField.setBackground(Color.CYAN);
    inputField.setHorizontalAlignment(JTextField.RIGHT);
    inputField.setBorder(BorderFactory.createLineBorder(Color.BLACK));
    outputField.setEditable(false);
    outputField.setBackground(Color.CYAN);
    outputField.setHorizontalAlignment(JTextField.RIGHT);
    outputField.setBorder(BorderFactory.createLineBorder(Color.BLACK));
    //outputField.setVisible(false);
    
    //Create the input and output areas
    inputTA = new JTextArea();
    outputTA = new JTextArea();
    
    //Set the appearance of the input and output areas
    inputTA.setLineWrap(true);
    inputTA.setWrapStyleWord(true);
    inputTA.setBackground(Color.WHITE);
    inputTA.setBorder(BorderFactory.createLineBorder(Color.BLACK));
    outputTA.setLineWrap(true);
    outputTA.setWrapStyleWord(true);
    outputTA.setBackground(Color.LIGHT_GRAY);
    outputTA.setBorder(BorderFactory.createLineBorder(Color.BLACK));    
    outputTA.setEditable(false);
    //outputTA.setVisible(false);
    outputTA.setText(NO_REV_YET);
    
    //Create reverse button
    reverseB = new JButton("Reverse it!");
    reverseB.setHorizontalAlignment(SwingConstants.CENTER);
    strReverser = new Reverser();
    reverseB.addActionListener(strReverser);
    
    //Create enter key listener that makes enter key reverse the input
    inputTA.addKeyListener(new KeyAdapter()
    {
        @Override
        public void keyPressed(KeyEvent e)
        {
            if (e.getKeyCode() == KeyEvent.VK_ENTER)
            {
                e.consume();
                strReverser.performReverse();
            }
        }
    });    
    
    //Create clear button
    clearB = new JButton("Clear");
    cbHandler = new ClearButtonHandler();
    clearB.addActionListener(cbHandler);
    
    //Create exit button
    exitB = new JButton("Exit");
    ebHandler = new ExitButtonHandler();
    exitB.addActionListener(ebHandler);
    
    //Set the title
    setTitle("Reverse It!");
    
    //Set the intro explanation
    JPanel introPanel = new JPanel();
    introPanel.setLayout(new BoxLayout(introPanel, BoxLayout.X_AXIS));
    introPanel.add(introPane);
    
    //Set the id components
    JPanel titlePanel = new JPanel();
    titlePanel.setLayout(new BoxLayout(titlePanel, BoxLayout.Y_AXIS));
    titlePanel.add(inputField);
    titlePanel.add(outputField);
    
    //Set the input/output components
    JPanel inOutPanel = new JPanel();
    inOutPanel.setLayout(new BoxLayout(inOutPanel, BoxLayout.Y_AXIS));
    inOutPanel.add(inputTA);
    inOutPanel.add(outputTA);
    
    //Set the buttons horizontally across bottom of gui
    JPanel horPanel = new JPanel();
    horPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
    horPanel.add(reverseB);
    horPanel.add(clearB);
    horPanel.add(exitB);
    horPanel.setBorder(BorderFactory.createLineBorder(Color.BLACK));
    
    //Get and set the container
    Container c = getContentPane();
    c.add(introPanel, BorderLayout.PAGE_START);
    c.add(titlePanel, BorderLayout.LINE_START);
    c.add(inOutPanel, BorderLayout.CENTER);
    c.add(horPanel, BorderLayout.PAGE_END);
    
    //Display window in center of screen with desired size and focus in the
    //input text area
    setMinimumSize(new Dimension (WIDTH, HEIGHT));
    setLocationRelativeTo(null);
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setVisible(true);
    inputTA.requestFocusInWindow();
}


private class Reverser implements ActionListener
{
    @Override
    public void actionPerformed(ActionEvent e)
    {
        performReverse();
    }
    
    private void performReverse()
    {
        //Get input string and tokenize it
        String inputStr = inputTA.getText();
        String outputStr = "";
        StringTokenizer st = new StringTokenizer(inputStr);
        
        //Create strings to aid in reversing
        String temp;
        String reversed;
        
        //Go through process of properly reversing tokens
        //First check to see if input in empty
        if (inputStr.trim().equals(""))
        {
            outputStr = EMPTY_INPUT;
            inputTA.requestFocusInWindow();
        }
        //Not empty, work on reversing it
        else
        {
            while (st.hasMoreElements())
            {
                temp = st.nextToken();
                //Check if word ends with one of the 6 punctuation characters
                //if it does then remove the character before reversing
                if (isPunctuation(temp))
                {
                    char punctuation = temp.charAt(temp.length()-1);
                    temp = temp.substring(0, temp.length()-1);
                    reversed = reverse(temp);
                    outputStr += (reversed + punctuation + " ");
                
                }
                //Does not end in punctuation, go ahead and reverse it
                else
                {
                    reversed = reverse(temp);
                    outputStr += (reversed + " ");               
                }
            }
        }
        //Send the new string or error message to the GUI
        outputTA.setText(outputStr);
        outputTA.setVisible(true);
        outputField.setVisible(true);
        outputTA.requestFocusInWindow();
        inputTA.setEditable(false);
    }
    
    private boolean isPunctuation(String s)
    {
        return (s.endsWith(".")||s.endsWith(",")||s.endsWith(";")
                ||s.endsWith(":")||s.endsWith("!")||s.endsWith("?"));    
    }
    
    private String reverse (String s)
    {
        //SB builds reversed word, arraystack reverses word using a stack
        StringBuilder sb = new StringBuilder("");
        ArrayStack<Character> stack = new ArrayStack();
        int length = s.length();
        
        //Push all the char from word onto stack
        for (int i=0; i < length; i++)
        {
            stack.push(s.charAt(i));
        }
        //Now pop them off the stack onto the SB, reversing the word
        for (int i=0; i < length; i++)
        {
            sb.append(stack.pop());
        }
        
        return sb.toString();
    }    
}

//Set actions taken when Clear button is used
private class ClearButtonHandler implements ActionListener
{
    @Override
    public void actionPerformed(ActionEvent e)
    {
        //Set everything back to original
        inputTA.setText("");
        inputTA.setEditable(true);
        outputTA.setText(NO_REV_YET);
        //outputField.setVisible(false);
        //outputTA.setVisible(false);        
        inputTA.requestFocusInWindow();    
    }
}

//Set actions taken when Exit button is used
private class ExitButtonHandler implements ActionListener
{
    @Override
    public void actionPerformed(ActionEvent e)
    {
        System.exit(0);
    } 
}

/**
 * Instantiates a ReverseIt object, which starts the GUI app.
 * @param args
 */
public static void main(String[] args)
{
    new ReverseIt();
}
}

/**
 *  @author Lewis and Chase
 *
 *  Defines the interface to a stack data structure.
 */
package reverseit;

public interface StackADT<T>
{
  /**  Adds one element to the top of this stack. 
   *   @param element element to be pushed onto stack
   */
  public void push (T element);
  
  /**  Removes and returns the top element from this stack. 
   *   @return T element removed from the top of the stack
   */
  public T pop();

  /**  Returns without removing the top element of this stack. 
   *   @return T element on top of the stack
   */
  public T peek();
  
  /**  Returns true if this stack contains no elements. 
   *   @return boolean whether or not this stack is empty
   */
  public boolean isEmpty();

  /**  Returns the number of elements in this stack. 
   *   @return int number of elements in this stack
   */
  public int size();

  /**  Returns a string representation of this stack. 
   *   @return String representation of this stack
   */
  public String toString();
}

/**
 *  @author Lewis and Chase
 *
 *  Represents an array implementation of a stack.
 */
package reverseit;
//import reverseit.exceptions.*;


public class ArrayStack<T> implements StackADT<T>
{
  /**
   * constant to represent the default capacity of the array
   */
  private final int DEFAULT_CAPACITY = 100;

  /**
   * int that represents both the number of elements and the next
   * available position in the array
   */
  private int top;  

  /**
   * array of generic elements to represent the stack
   */
  private T[] stack;
  
  /**
   * Creates an empty stack using the default capacity.
   */
  public ArrayStack()
  {
    top = 0;
    stack = (T[])(new Object[DEFAULT_CAPACITY]);
  }

  /**
   * Creates an empty stack using the specified capacity.
   * @param initialCapacity represents the specified capacity 
   */
  public ArrayStack (int initialCapacity)
  {
    top = 0;
    stack = (T[])(new Object[initialCapacity]);
  }

  /**
   * Adds the specified element to the top of this stack, expanding
   * the capacity of the stack array if necessary.
   * @param element generic element to be pushed onto stack
   */
  public void push (T element)
  {
    if (size() == stack.length) 
      expandCapacity();

    stack[top] = element;
    top++;
  }

  /**
   * Removes the element at the top of this stack and returns a
   * reference to it. Throws an EmptyCollectionException if the stack
   * is empty.
   * @return T element removed from top of stack
   * @throws EmptyCollectionException if a pop is attempted on empty stack
   */
  public T pop() throws EmptyCollectionException
  {
    if (isEmpty())
      throw new EmptyCollectionException("Stack");

    top--;
    T result = stack[top];
    stack[top] = null; 

    return result;
  }
   
  /**
   * Returns a reference to the element at the top of this stack.
   * The element is not removed from the stack.  Throws an
   * EmptyCollectionException if the stack is empty.  
   * @return T element on top of stack
   * @throws EmptyCollectionException if a peek is attempted on empty stack
   */
  public T peek() throws EmptyCollectionException
  {
    if (isEmpty())
      throw new EmptyCollectionException("Stack");

    return stack[top-1];
  }

  /**
   * Returns true if this stack is empty and false otherwise. 
   * @return boolean true if this stack is empty, false otherwise
   */
  public boolean isEmpty()
  {
    return (top == 0);
  }
 
  /**
   * Returns the number of elements in this stack.
   * @return int the number of elements in this stack
   */
  public int size()
  {
    return top;
  }

  /**
   * Returns a string representation of this stack. 
   * @return String representation of this stack
   */
  public String toString()
  {
    String result = "";

    for (int scan=0; scan < top; scan++)
      result = result + stack[scan].toString() + "\n";

    return result;
  }

  /**
   * Creates a new array to store the contents of this stack with
   * twice the capacity of the old one.
   */
  private void expandCapacity()
  {
    T[] larger = (T[])(new Object[stack.length*2]);
    
    for (int index=0; index < stack.length; index++)
      larger[index] = stack[index];
    
    stack = larger;
  }
}

~$ python
>>> import antigravity