[Resolvido]Utilizando scripts para desenhar

/**
 * Arquivo onde é armazenado o interpretador de scripts do programa
 */
package br.ericware.programa;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;

/** Classe responsável por executar todo e qualquer script necessário para execução do programa
 * @author elisson
 *
 */
public class Interpretador implements ActionListener{

	/**
	 * Armazena o módulo 2D
	 */
	private Mod2D mod2D;

	/**
	 * Armazena o desenhista, por onde os desenhos são feitos
	 */
	private Desenhista desenhista;

	/**
	 * Cria a conexão com o interpretador Python
	 */
	private ScriptEngine engine = new ScriptEngineManager().getEngineByName("python");;

	/**
	 * Construtor que recebe como parâmetro o móludo de desenho e o desenhista
	 * @param m2d o módulo2D de onde virão os scripts
	 * @param ds o desenhista do módulo em questão
	 */
	public Interpretador(Mod2D m2d, Desenhista ds) {
		this.mod2D = m2d;
		this.desenhista = ds;
		try {
			engine.eval("from " + Executor.class.getPackage().getName() + " import "+ Executor.class.getSimpleName());

			Set<Class> classes = new HashSet<Class>();

			for (Method metodo : Executor.class.getMethods()) {
				if(Modifier.isPublic( metodo.getModifiers())){
					if(metodo.getName() != "brincar"){
						classes.addAll(Arrays.asList(metodo.getParameterTypes()));
						classes.add(metodo.getReturnType());
						StringBuffer sb =  new StringBuffer("def "+ metodo.getName()+"(");
						for(int i = 0; i < metodo.getParameterTypes().length;i++){
							if(i > 0)
								sb.append(",");
							sb.append("param" + i);

						}
						sb.append("):");
						StringBuffer chamada = new StringBuffer("return "+Executor.class.getSimpleName()+"."+metodo.getName()+"(");
						for(int i = 0; i < metodo.getParameterTypes().length;i++){
							if(i > 0)
								chamada.append(",");
							chamada.append("param" + i);
						}
						chamada.append(")");
						engine.eval(sb.toString()+"\n   "+chamada.toString());
					}else{
						StringBuffer jogo = new StringBuffer("from time import time" +
								"\nvezes = 0" +
								"\ndef brincar():" +
								"\n   global vezes"+
								"\n   comeco = time()" +
								"\n   while(vezes< 6000):" +
								"\n      if((comeco - time()/1000)> 1.5):" +
								"\n         deslocaPista()" +
								"\n         comeco = time()" +
								"\ndef deslocaPista():"+
								"\n   global vezes"+
								"\n   soma = ((vezes%4)*30)" +
								"\n   alterarCorPrimaria(Color.black)" +
								"\n   desenharRetangulo(Point(0,0),Point(400,400))" +
								"\n   alterarCorPrimaria(Color.white)" +
								"\n   desenharRetangulo(Point(185,(-130)+soma),Point(215,(-40)+soma))" +
								"\n   desenharRetangulo(Point(185,0+soma),Point(215,90+soma))" +
								"\n   desenharRetangulo(Point(185,110+soma),Point(215,200+soma))" +
								"\n   desenharRetangulo(Point(185,220+soma),Point(215,310+soma))" +
						"\n   vezes= vezes+1" );
						engine.eval(jogo.toString());
					}
				}
			}
			for(Class classe :classes){
				if(!classe.isPrimitive()){
					engine.eval("from " + classe.getPackage().getName() + " import "+ classe.getSimpleName());
				}
			}
		} catch (ScriptException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub

		JTextField linhaComando =  (JTextField) e.getSource();
		try {
			engine.eval(linhaComando.getText());
		} catch (ScriptException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		linhaComando.setText("");
	}

}

/**
 * Armazena classe responsável pela execução de comandos para o programa 
 */
package br.ericware.programa;

import java.awt.Color;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Enumeration;

import javax.swing.AbstractButton;
import javax.swing.ButtonModel;

import org.python.antlr.base.mod;

import br.ericware.desenhos.Elipse;
import br.ericware.desenhos.Linha;
import br.ericware.desenhos.Poligono;
import br.ericware.desenhos.Retangulo;
import br.ericware.desenhos.Texto;
import br.ericware.programa.Desenhista.EstadoSelecao;
import br.ericware.programa.Mod2D.NaoSalvouException;


/**Classe responsável por executar os comandos repassados ao programa, não importando a origem
 * 
 * @author elisson
 *
 */
public class Executor {
	
	/**
	 * Armazena a instância única do mod2d para realizar as operações
	 */
	private static Mod2D mod2d;

	/**
	 * Armazena a instância desenhista ligada a instancia de Mod2D armazenada
	 */
	private static Desenhista ds;
	
	/**
	 * Determina qual instância será usada para as operações
	 * @param m2 a instância que será usada para as operações
	 */
	static void setMod2D(Mod2D m2){
		Executor.mod2d = m2;
	}
	
	/**Determina a instância de Desenhista ligado a instância de mod2d armazenada
	 * @param ds o desenhista que deseja-se armazenar
	 */
	static void setDs(Desenhista ds) {
		Executor.ds = ds;
	}
	
	/**
	 * Abre uma imagem a partir do arquivo indicado
	 * @param arquivo caminho do arquivo para abrir a imagem
	 */
	public static void abrirImagem(String arquivo){
		mod2d.giGerenciador.abreImagem(arquivo);
	}
	
	/**
	 * Abre uma imagem a partir do caminho indicado pelo objeto
	 * @param arquivo a instância que apontar para o local onde o caminho está
	 */
	public static void abrirImagem(File arquivo) {
		mod2d.giGerenciador.abreImagem(arquivo);
	}
	
	/**
	 * Cria uma nova imagem nas dimensões padrões
	 */
	public static void criarImagem() {
		mod2d.giGerenciador.novaImagem();
	}
	
	/**
	 * Fecha a imagem indicada
	 * @param img a imagem que se deseja para de editar
	 */
	public static void fecharImagem(Imagem img) {
		mudarImagemEmFoco(img);
		mod2d.giGerenciador.fechaImagemAtual();
	}
	
	/**
	 * Fecha a imagem atual
	 */
	public static void fecharImagemAtual() {
		mod2d.giGerenciador.fechaImagemAtual();
	}
	
	/**
	 * Altera a imagem em foco para imagem indicada
	 * @param novaImagem a imagem que se desejar focar
	 */
	public static void mudarImagemEmFoco(Imagem novaImagem) {		
		mod2d.giGerenciador.modificaImagemFocada(mod2d.giGerenciador.getLsImagens().indexOf(novaImagem));
		
	}
	
	/**
	 * Altera a resolução da imagem atual para a indicada
	 * @param novaAltura a nova altura da imagem
	 * @param novaLargura a nova largura da imagem
	 */
	public static void alterarResolucao(int novaAltura,int novaLargura){
		mod2d.giGerenciador.getImagemAtual().getDesfazerRefazer().addEdit(new AcaoImagem(mod2d.giGerenciador,ds,mod2d.giGerenciador.getImagemAtual(), novaLargura/(float)mod2d.giGerenciador.getImagemAtual().getTamanho().width, novaAltura/(float)mod2d.giGerenciador.getImagemAtual().getTamanho().height));
		mod2d.giGerenciador.getImagemAtual().setTamanho(novaLargura, novaAltura);
		mod2d.giGerenciador.atualizaTitulo();
		ds.invalidar();
		
	}
	
	/**
	 * Altera o nome da imagem atual
	 * @param nome o novo nome que se deseja dar a imagem atual
	 */
	public static void alterarNome(String nome){
		mod2d.giGerenciador.getImagemAtual().setNome(nome);
		mod2d.giGerenciador.atualizaTitulo();
	}
	
	/**
	 * Salva a iamgem indicada
	 * @param img a imagem que se deseja salvar
	 */
	public static void salvarImagem(Imagem img){
		mod2d.giGerenciador.modificaImagemFocada(mod2d.giGerenciador.getLsImagens().indexOf(img));
		try {
			mod2d.giGerenciador.salvarImagemAtual();
		} catch (IOException ioe) {
			// TODO Auto-generated catch block
			ioe.printStackTrace();
		} catch (NaoSalvouException nse) {
			nse.printStackTrace();
		}
	}
	
	/**
	 * Salva a imagem indicada com o nome indicado
	 * @param img a imagem que se deseja salvar
	 * @param arquivo o caminho para o arquivo onde deseja-se salvar a imagem
	 */
	public static void salvarImagem(Imagem img, String arquivo){
		mod2d.giGerenciador.modificaImagemFocada(mod2d.giGerenciador.getLsImagens().indexOf(img));
		try {
			mod2d.giGerenciador.salvarImagemAtual(new File(arquivo));
		} catch (IOException ioe) {
			// TODO Auto-generated catch block
			ioe.printStackTrace();
		} catch (NaoSalvouException nse) {
			nse.printStackTrace();
		}
	}
	
	/**
	 * Retorna a imagem atual
	 * @return a imagem atual
	 */
	public static Imagem retornarImagemAtual(){
		return mod2d.giGerenciador.getImagemAtual();
	}
	
	/**
	 * Fecha o programa
	 */
	public static void fecharPrograma(){
		try {
			mod2d.fecha();
		} catch (NaoSalvouException nse) {
			// TODO Auto-generated catch block
			nse.printStackTrace();
		}
	}
	
	/**
	 * Copia a parte da imagem indicada pelo retangulo
	 * @param retangulo o retangulo da onde a imagem será copiada
	 */
	public static void copiar(Rectangle retangulo){
		Executor.criarSelecao(retangulo);
		mod2d.transfer.copiar(ds);
	}
	
	/**
	 * Colar uma imagem da área de transferencia na área indicada
	 * @param retangulo o retangulo onde a imagem será colada
	 * @param img a imagem que será colada na área indicada
	 */
	public static void colar(Rectangle retangulo, Image	img){
		Executor.criarSelecao(retangulo);
		try {
			mod2d.transfer.colar(ds);
		} catch (UnsupportedFlavorException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * Extrai uma imagem da área indicada
	 * @param retangulo a área da onde a imagem será extraída
	 */
	public static void recortar(Rectangle retangulo){
		Executor.criarSelecao(retangulo);
		mod2d.transfer.recortar(ds);
	}
	
	/**
	 * Altera a cor primária atual para a cor indicada
	 * @param novaCor a nova cor que será aplicada
	 */
	public static void alterarCorPrimaria(Color novaCor){
		mod2d.setCorPrimaria(novaCor);
	}
	
	/**
	 * Altera a cor secundária atual para a cor indicada
	 * @param novaCor a nova cor que será aplicada
	 */
	public static void alterarCorSecundaria(Color novaCor){
		mod2d.setCorSecundaria(novaCor);
	}
	
	/**
	 * Desenha uma linha entre os pontos indicados
	 * @param origem ponto de origem da linha
	 * @param fim ponto de fim da linha
	 */
	public static void desenharLinha(Point origem, Point fim){
		Linha linha = new Linha(origem.x, origem.y, ds.getCorPrimaria());
		linha.setFimX(fim.x).setFimY(fim.y);
		linha.setEspessuraLinha((float) mod2d.getEspessuraAtual());
		mod2d.giGerenciador.getImagemAtual().getLsDesenhosPendentes().add(linha);
		ds.finalizaUltimoDesenho();
		ds.repaint();
	}
	
	/**
	 * Desenha a elipse tendo como limites os pontos indicados
	 * @param origem um dos pontos que marcará o limite da elipse
	 * @param fim outro ponto que marcará o limite da elipse
	 */
	public static void desenharElipse(Point origem, Point fim){
		Elipse elipse = new Elipse(origem.x, origem.y,fim.x,fim.y, ds.getCorPrimaria());
		elipse.setEspessuraLinha((float) mod2d.getEspessuraAtual());
		mod2d.giGerenciador.getImagemAtual().getLsDesenhosPendentes().add(elipse);
		ds.finalizaUltimoDesenho();
		ds.repaint();
	}
	
	/**
	 * Cria um circulo a partir do seu centro e raio
	 * @param centro ponto que ser o centro do círculo
	 * @param raio distancia do centro até a borda do circulo
	 */
	public static void desenharCirculo(Point centro, int raio){
		Elipse circulo = new Elipse(centro.x -raio, centro.y - raio,centro.x+raio,centro.y+raio, ds.getCorPrimaria());
		circulo.setEspessuraLinha((float) mod2d.getEspessuraAtual());
		mod2d.giGerenciador.getImagemAtual().getLsDesenhosPendentes().add(circulo);
		ds.finalizaUltimoDesenho();
		ds.repaint();
	}
	
	/**
	 * Desenha um retangulo limitado pelos pontos indicados
	 * @param origem um ponto que limitará o retângulo
	 * @param fim outro ponto que limitará o retângulo
	 */
	public static void desenharRetangulo(Point origem, Point fim){
		Retangulo retangulo = new Retangulo(origem.x, origem.y,fim.x,fim.y, ds.getCorPrimaria());
		retangulo.setEspessuraLinha((float) mod2d.getEspessuraAtual());
		mod2d.giGerenciador.getImagemAtual().getLsDesenhosPendentes().add(retangulo);
		ds.finalizaUltimoDesenho();
		ds.repaint();
	}
	
	/**
	 * Cria um texto a partir do ponto indicado
	 * @param origem o ponto que será o canto inferior esquerdo do texto
	 */
	public static void inserirTexto(Point origem){
		Texto texto = new Texto(origem.x, origem.y, mod2d.clCorPrimaria, mod2d.jfJanela, ds);
		mod2d.giGerenciador.getImagemAtual().getLsDesenhosPendentes().add(texto);
	}
	
	/**
	 * Cria um texto a partir do texto e ponto indicados
	 * @param origem o ponto onde o texto iniciará
	 * @param texto o texto que será impresso
	 */
	public static void inserirTexto(Point origem, String texto){
		Texto textoImpresso = new Texto(origem.x, origem.y, mod2d.clCorPrimaria, mod2d.jfJanela, ds,texto);
		mod2d.giGerenciador.getImagemAtual().getLsDesenhosPendentes().add(textoImpresso);
		ds.finalizaUltimoDesenho();
	}
	
	/**
	 * Indica uma área que será preenchida pela cor de fundo
	 * @param retanguloApagado o retangulo que será pagado
	 */
	public static void apagarArea(Rectangle retanguloApagado){
		Retangulo retangulo = new Retangulo(retanguloApagado.x, retanguloApagado.y,retanguloApagado.x+retanguloApagado.width,retanguloApagado.y+retanguloApagado.height, mod2d.clCorSecundaria);
		retangulo.setEspessuraLinha((float) mod2d.getEspessuraAtual());
		mod2d.giGerenciador.getImagemAtual().getLsDesenhosPendentes().add(retangulo);
		ds.finalizaUltimoDesenho();
		ds.repaint();
	}
	
	/**
	 * Aplica a ferramenta lata de tinta no ponto indicado
	 * @param ponto o ponto que se deseja preencher os arredores
	 */
	public static void preencherPonto(Point ponto){
		Poligono preenchimento = ds.geraPoligonoPreenchido(ponto.x,ponto.y,ds.getImagem());
		mod2d.giGerenciador.getImagemAtual().getLsDesenhosPendentes().add(preenchimento);
		ds.finalizaUltimoDesenho();
		ds.repaint();
	}
	
	/**
	 * Cria um novo polígono a partir do ponto indicado
	 * @param origem o ponto que será a origem do polígono
	 */
	public static void iniciarPoligono(Point origem){
	ds.verificaInicioPoligono(origem.x, origem.y);	
	}
	
	/**
	 * Continua a traçar o polígono até o ponto indicado
	 * @param destino o ponto da onde será traçado uma linha que alcançará o atual fim do poligono
	 */
	public static void extenderPoligono(Point destino){
		ds.verificaInicioPoligono(destino.x, destino.y);	
	}
	
	/**
	 * Finaliza o poligno no ponto indicado
	 * @param destino o ultimo ponto do poligono que se deseja traçar
	 */
	public static void finalizarPoligono(Point destino){
		ds.verificaInicioPoligono(destino.x, destino.y);
		finalizarPoligono();
	}
	
	/**
	 * Finaliza o poligono que está sendo desenhado
	 */
	public static void finalizarPoligono(){
		ds.finalizaUltimoDesenho();
		ds.repaint();
	}
	
	/**
	 * Amostra a cor no ponto indicado
	 * @param ponto o ponto da onde se deseja tirar a cor primária
	 */
	public static void amostrarCor(Point ponto){
		ds.amostraCor((int)(ponto.x*mod2d.giGerenciador.getImagemAtual().getZoom()),(int)(ponto.y*mod2d.giGerenciador.getImagemAtual().getZoom()));
	}
	
	/**
	 * Aumenta o zoom
	 */
	public static void aumentarZoom(){
		ds.aumentaZoom();
	}
	
	/**
	 * Diminui o zoom
	 */
	public static void diminuirZoom(){
		ds.diminuiZoom();
	}
	
	/**
	 * Determina o zoom
	 * @param zoom O valor em porcentagem qeu se deseja para o novo zoom
	 */
	public static void aplicarZoom(int zoom){
		ds.setZoom(((double)(zoom))/100.0);
	}
	
	/**
	 * Altera a espessura da ferramenta atual
	 * @param espessura a nova espessura desejada
	 */
	public static void alterarExpessura(double espessura){
		mod2d.setEspessuraAtual(espessura);
	}
	
	/**
	 * Troca a ferramenta atualmente usada pela indicada por seu nome
	 * @param ferramenta o nome da ferramenta desejada
	 */
	public static void trocarFerramenta(String ferramenta){
		Enumeration<AbstractButton> botoes = mod2d.bgFerramentas.getElements();
		while(botoes.hasMoreElements()){
			AbstractButton botao = botoes.nextElement();
			if(botao.getName() == ferramenta){
				ButtonModel modelo = botao.getModel();
				mod2d.bgFerramentas.setSelected(modelo, true);
			}
		}
	}
	
	/**
	 * Inicia um joguinho de corrida :)
	 */
	public static void brincar(){
		
	}
	
	/**
	 * Rotaciona a imagem no sentido horário
	 */
	public static void rotacionar(){
		mod2d.giGerenciador.getImagemAtual().rotacionar();
	}
	
	/**
	 * Desfaz a última ação realizada na imagem atual
	 */
	public static void desfazer(){
		if(mod2d.giGerenciador.getImagemAtual().getDesfazerRefazer().canUndo())
			mod2d.giGerenciador.getImagemAtual().getDesfazerRefazer().undo();
	}
	
	/**
	 * Refaz a última ação desfeita na imagem
	 */
	public static void refazer(){
		if(mod2d.giGerenciador.getImagemAtual().getDesfazerRefazer().canRedo()){
			mod2d.giGerenciador.getImagemAtual().getDesfazerRefazer().redo();
		}
	}
	
	/**
	 * Cria uma seleção na área do retangulo indicado. Entretano, a seleção só será exibida se a ferramenta seleciona for seleção
	 * @param area o retangulo onde ficará a seleção
	 */
	public static void criarSelecao(Rectangle area){
		mod2d.setSelecao(area);
	}
}