small cleanups; documented the code

[chaz/vimcoder] / src / com / dogcows / VimCoder.java

package com.dogcows;

import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;
import com.topcoder.client.contestant.ProblemComponentModel;
import com.topcoder.shared.language.*;
import com.topcoder.shared.problem.*;
import com.topcoder.shared.problem.Renderer;

/**
 * @author Charles McGarvey
 * The TopCoder Arena editor plug-in providing support for Vim.
 * 
 * Distributable under the terms and conditions of the 2-clause BSD license;
 * see the file COPYING for a complete text of the license.
 */
public class VimCoder
{
    /**
     * The name and version of this plugin.
     */
    public final static String     version = "VimCoder 0.1";
    
    /**
     * The website of the plugin project.
     */
    public final static String     website = "http://www.dogcows.com/vimcoder";
    
    
    /**
     * The panel given to the Arena applet when it is requested.
     */
    private JPanel      panel;
    
    /**
     * The text widget where log messages are appended.
     */
    private JTextArea   logArea;
    
    /**
     * The current editor object (or null if there is none).
     */
    private Editor      editor;

   
    /**
     * Instantiate the entry point of the editor plugin.  Sets up the log widget
     * and panel.
     */
    public VimCoder()
    {
        logArea = new JTextArea();
        logArea.setForeground(Color.GREEN);
        logArea.setBackground(Color.BLACK);
        logArea.setEditable(false);
        Font font = new Font("Courier", Font.PLAIN, 12);
        if (font != null) logArea.setFont(font);
           
        panel = new JPanel(new BorderLayout());
        panel.add(new JScrollPane(logArea), BorderLayout.CENTER);
    }

    
    /**
     * Called by the Arena when the plugin is about to be used.
     */
    public void startUsing()
    {
        System.out.println("startUsing");
        Runnable task = new Runnable()
        {
            public void run()
            {
                logArea.setText("");
            }
        };
        if (SwingUtilities.isEventDispatchThread())
        {
            task.run();
        }
        else
        {
            SwingUtilities.invokeLater(task);
        }
    }
    
    /**
     * Called by the Arena when the plugin is no longer needed.
     */
    public void stopUsing()
    {
        System.out.println("stopUsing");
        editor = null;
    }
    
    /**
     * Called by the Arena to obtain the editor panel which we will use to show
     * log messages.
     * @return The editor panel.
     */
    public JPanel getEditorPanel()
    {
        System.out.println("getEditorPanel");
        return panel;
    }
   
    /**
     * Called by the Arena to obtain the current source.  This happens when the
     * user is saving, compiling, and/or submitting.
     * @return The current source code.
     * @throws Exception If the source file edited by Vim couldn't be read.
     */
    public String getSource() throws Exception
    {
        System.out.println("getSource");
        try
        {
            String source = editor.getSource();
            logInfo("Source code uploaded to server.");
            return source;
        }
        catch (Exception exception)
        {
            logError("Failed to get source code: " +
                     exception.getLocalizedMessage());
            throw exception;
        }
    }
    
    /**
     * Called by the Arena to pass the source it has.
     * @param source The source code.
     */
    public void setSource(String source)
    {
        System.out.println("setSource: " + source);
        try
        {
            editor.setSource(source);
            logInfo("Source code downloaded from server.");
        }
        catch (Exception exception)
        {
            logError("Failed to save the source given by the server: " +
                     exception.getLocalizedMessage());
            return;
        }
    }
    
    /**
     * Called by the Arena to pass along information about the current problem.
     * @param component A container for the particulars of the problem.
     * @param language The currently selected language.
     * @param renderer A helper object to help format the problem statement.
     */
    public void setProblemComponent(ProblemComponentModel component, 
                                    Language language,
                                    Renderer renderer)
    {
        System.out.println("setProblemComponent");
        try
        {
            editor = new Editor(component, language, renderer);
        }
        catch (Exception exception)
        {
            logError("An error occured while loading the problem: " +
                     exception.getLocalizedMessage());
        }
    }

    
    /**
     * A generic logging function, appends text to the text area.  A timestamp
     * is also prepended to the next text.
     * @param what The text to append.
     */
    private void log(final String what)
    {
        Runnable task = new Runnable()
        {
            public void run()
            {
                SimpleDateFormat format = new SimpleDateFormat("kk:mm:ss");
                logArea.append(format.format(new Date()) + ", " + what);
            }
        };
        if (SwingUtilities.isEventDispatchThread())
        {
            task.run();
        }
        else
        {
            SwingUtilities.invokeLater(task);
        }
    }
    
    /**
     * Output non-critical messages to the log.
     * @param what The text of the message.
     */
    private void logInfo(String what)
    {
        log(" INFO: " + what + System.getProperty("line.separator"));
    }
    
    /**
     * Output potentially important messages to the log.
     * @param what The text of the message.
     */
    private void logWarning(String what)
    {
        log(" WARN: " + what + System.getProperty("line.separator"));
    }
    
    /**
     * Output critical messages and errors to the log.
     * @param what The text of the message.
     */
    private void logError(String what)
    {
        log("ERROR: " + what + System.getProperty("line.separator"));
    }
}