package br.mia.test.controler;

 import java.awt.datatransfer.UnsupportedFlavorException;

 import java.awt.geom.Point2D;

 import java.io.IOException;

 import java.sql.SQLException;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.List;

 import javax.swing.JTextField;

 import javax.swing.SwingConstants;

 import org.jgraph.JGraph;

 import org.jgraph.graph.DefaultEdge;

 import org.jgraph.graph.DefaultGraphCell;

 import org.jgraph.graph.GraphConstants;

 import br.mia.test.model.CasoUso;

 import br.mia.test.model.Filtro;

 import br.mia.test.model.Fluxo;

 import br.mia.test.model.Link;

 import br.mia.test.model.RegraNegocio;

 import br.mia.test.model.Step;

 import br.mia.test.model.TestDataValor;

 import br.mia.test.model.dao.DAOFiltro;

 import br.mia.test.model.dao.DAOStep;

 import br.mia.test.testcase.DadosTeste;

 import br.mia.test.view.factory.BotaoFactory;

 import br.mia.test.view.graph.BotaoCell;

 import br.mia.test.view.graph.CodeGrafoPane;

 import br.mia.test.view.graph.CondicionalCell;

 import br.mia.test.view.graph.DadoEdge;

 import br.mia.test.view.graph.DataCell;

 import br.mia.test.view.graph.FiltroEdge;

 import br.mia.test.view.graph.FlowCell;

 import br.mia.test.view.graph.GrafoPane;

 import br.mia.test.view.graph.LinkEdge;

 import br.mia.test.view.graph.LinkPort;

 import br.mia.test.view.graph.RuleCell;

 import br.mia.test.view.graph.RuleEdge;

 import br.mia.test.view.graph.StateFlowCell;

 import br.mia.test.view.graph.StepCell;

 import br.mia.test.view.graph.Util;

 import br.mia.test.view.graph.ValorCell;

 import br.mia.test.view.graph.ValorEdge;

 import br.mia.test.view.graph.observer.ObserverCodeGraphPane;

 import br.mia.test.view.graph.observer.ObserverComponent;

 import br.mia.test.view.graph.observer.ObserverComponentCodigo;

 import br.mia.test.view.graph.observer.ObserverGraphPane;

 /***

  * Controlador para gera��o do modelo gr�fico

  *

  * @author 74397176353

  *

  */

 public class ControladorGraph extends AbstractControlerPane

 {

     /***

      * Cola passos no modelo grafico

      *

      * @param flowCell

      * @param stepCell

      * @param fluxo

      * @param useCase

      * @param objetos

      * @param passosCobertos

      * @throws UnsupportedFlavorException

      * @throws IOException

      */

     public void colarPassos(FlowCell flowCell, StepCell stepCell, Fluxo fluxo,

             CasoUso useCase, ArrayList<Object> objetos,

             ArrayList<Object> passosCobertos)

             throws UnsupportedFlavorException, IOException {

         String conteudo = br.mia.test.util.Util.getClipboardContents();

         String[] linhas = conteudo.split("\n");

         StepCell auxiliar = stepCell;

         int x = 20;

         int y = 20;

         if (stepCell != null) {

             x = stepCell.getX();

             y = stepCell.getY() + 20;

         }

         if (flowCell != null) {

             x = flowCell.getX();

             y = flowCell.getY() + 20;

         }

         DAOStep dao = new DAOStep();

         for (int i = 0; i <= linhas.length - 1; i++) {

             String descricaoAux = linhas[i].toString();

             if (descricaoAux.replaceAll(" ", "").length() > 0) {

                 Step step = new Step();

                 step.setDescricao(linhas[i]);

                 try {

                     step = (Step) dao.insert(step, fluxo);

                     fluxo.getSteps().add(step);

                     StepCell novoStepCell = Util.criaPasso(fluxo, step,

                             useCase, x, y, passosCobertos);

                     objetos.add(novoStepCell);

                     if (auxiliar != null) {

                         Util.criaLinkPasso(auxiliar, novoStepCell, objetos);

                     }

                     y = y + 40;

                     auxiliar = novoStepCell;

                 } catch (Exception e1) {

                     ControladorErro.trata(e1, this);

                 }

             }

         }

     }

     public void criaCodigo(CasoUso useCase, ArrayList<Object> passosCobertos,

             JGraph graph, ArrayList<Object> celulas,

             ObserverCodeGraphPane observer) throws IOException {

         HashMap<Object, Object> mapa = new HashMap<Object, Object>();

         HashMap<Object, Object> mapaStep = new HashMap<Object, Object>();

         int x = 0;

         HashMap<Object, Object> flows = new HashMap<Object, Object>();

         for (Object object : useCase.getFlows()) {

             Fluxo flow = (Fluxo) object;

             FlowCell cell = new FlowCell(flow.getName(), flow, x, 0);

             mapa.put(flow.getName(), cell);

             celulas.add(cell);

             int y = 40;

             int contador = 0;

             StepCell cellAnterior = null;

             if (!(flows.containsKey(flow.getName()))) {

                 flows.put(flow.getName(), new ArrayList<StepCell>());

             }

             if (!(flow.isMinimizado())) {

                 this.criaFlowCodigo(flow, useCase, x, y, passosCobertos, flows,

                         mapaStep, contador, celulas, cellAnterior);

             } else {

                 this.criaFlowResumido(flow, useCase, x, y, passosCobertos,

                         flows, mapaStep, contador, celulas, cellAnterior);

             }

             x = x + 150;

         }

         for (Object object : useCase.getFlows()) {

             Fluxo flow = (Fluxo) object;

             int contador = 0;

             if (!(flow.isMinimizado())) {

                 this.criaLinkNaoResumido(flow, mapaStep, contador, celulas);

             } else {

                 this.criaLinkResumido(flow, mapaStep, celulas, contador);

             }

         }

         if (!(observer.getMapas().contains(flows))) {

             observer.getMapas().add(flows);

         }

         CodeGrafoPane grafoPane = observer.getGrafoPane();

         if (grafoPane != null) {

             grafoPane.setCelulas(celulas);

         }

         graph.getGraphLayoutCache().insert(celulas.toArray());

         ObserverComponentCodigo observerComponent = new ObserverComponentCodigo(

                 grafoPane);

         observerComponent.getGraph().add(graph);

         observerComponent.getObjetos().add(useCase);

         graph.addGraphSelectionListener(observerComponent);

         graph.addKeyListener(observerComponent);

     }

     public void cria(CasoUso useCase, ArrayList<Object> passosCobertos,

             JGraph graph, List<Object> list, ObserverGraphPane observer) {

         HashMap<Object, Object> mapa = new HashMap<Object, Object>();

         HashMap<Object, Object> mapaStep = new HashMap<Object, Object>();

         int x = 0;

         HashMap<Object, Object> flows = new HashMap<Object, Object>();

         for (Object object : useCase.getFlows()) {

             Fluxo flow = (Fluxo) object;

             FlowCell cell = new FlowCell(flow.getName(), flow, x, 0);

             mapa.put(flow.getName(), cell);

             list.add(cell);

             int y = 40;

             int contador = 0;

             StepCell cellAnterior = null;

             if (!(flows.containsKey(flow.getName()))) {

                 flows.put(flow.getName(), new ArrayList<StepCell>());

             }

             if (!(flow.isMinimizado())) {

                 this.criaFlow(flow, useCase, x, y, passosCobertos, flows,

                         mapaStep, contador, list, cellAnterior);

             } else {

                 this.criaFlowResumido(flow, useCase, x, y, passosCobertos,

                         flows, mapaStep, contador, list, cellAnterior);

             }

             x = x + 150;

         }

         for (Object object : useCase.getFlows()) {

             Fluxo flow = (Fluxo) object;

             int contador = 0;

             if (!(flow.isMinimizado())) {

                 this.criaLinkNaoResumido(flow, mapaStep, contador, list);

             } else {

                 this.criaLinkResumido(flow, mapaStep, list, contador);

             }

         }

         if (!(observer.getMapas().contains(flows))) {

             observer.getMapas().add(flows);

         }

         GrafoPane grafoPane = observer.getGrafoPane();

         if (grafoPane != null) {

             grafoPane.setCelulas(list);

         }

         graph.getGraphLayoutCache().insert(list.toArray());

         ObserverComponent observerComponent = new ObserverComponent(grafoPane);

         observerComponent.getGraph().add(graph);

         observerComponent.getObjetos().add(useCase);

         graph.addGraphSelectionListener(observerComponent);

         graph.addKeyListener(observerComponent);

     }

     @SuppressWarnings("unchecked")

     public void criaFlow(Fluxo flow, CasoUso useCase, int x, int y,

             ArrayList<Object> passosCobertos, HashMap<Object, Object> flows,

             HashMap<Object, Object> mapaStep, int contador, List<Object> list,

             StepCell cellAnterior) {

         for (Object object1 : flow.getSteps()) {

             Step step = (Step) object1;

             StepCell cell1 = Util.criaPasso(flow, step, useCase, x, y,

                     passosCobertos);

             ArrayList<StepCell> steps = (ArrayList<StepCell>) flows.get(flow

                     .getName());

             steps.add(cell1);

             y = y + 40;

             mapaStep.put(flow.getName() + contador, cell1);

             if (!(list.contains(cell1))) {

                 list.add(cell1);

             }

             contador++;

             for (Filtro filtro : step.getFiltros()) {

                 y = y + 40;

                 CondicionalCell condicao = Util.criaCondicao(filtro, 40 + x, y,

                         step, flow, useCase);

                 FiltroEdge edge = Util.criaLinkCondicao(condicao, cell1);

                 list.add(condicao);

                 if (!(list.contains(edge))) {

                     list.add(edge);

                 }

             }

             if (cellAnterior != null) {

                 Util.criaLinkPasso(cellAnterior, cell1, list);

             }

             cellAnterior = cell1;

             for (Object object2 : step.getDatas()) {

                 DadosTeste data = (DadosTeste) object2;

                 x = x + 40;

                 DataCell cell2 = Util.criaDado(data, x, y, step);

                 x = x - 40;

                 y = y + 40;

                 mapaStep.put(flow.getName() + contador + data.getName(), cell2);

                 if (!(list.contains(cell2))) {

                     list.add(cell2);

                 }

                 DadoEdge edge1 = Util.criaLinkDado(cell1, cell2);

                 if (!(list.contains(edge1))) {

                     list.add(edge1);

                 }

             }

             for (Object object2 : step.getRegras()) {

                 RegraNegocio rule = (RegraNegocio) object2;

                 x = x - 40;

                 RuleCell cell2 = Util.criaRule(rule, x, y, step);

                 x = x + 40;

                 y = y + 40;

                 mapaStep.put(flow.getName() + contador + rule.getName(), cell2);

                 if (!(list.contains(cell2))) {

                     list.add(cell2);

                 }

                 RuleEdge edge1 = Util.criaLinkRule(cell1, cell2);

                 if (!(list.contains(edge1))) {

                     list.add(edge1);

                 }

             }

         }

     }

     @SuppressWarnings("unchecked")

     public void criaFlowCodigo(Fluxo flow, CasoUso useCase, int x, int y,

             ArrayList<Object> passosCobertos, HashMap<Object, Object> flows,

             HashMap<Object, Object> mapaStep, int contador,

             ArrayList<Object> celulas, StepCell cellAnterior)

             throws IOException {

         for (Object object1 : flow.getSteps()) {

             Step step = (Step) object1;

             StepCell cell1;

             if (step.getTipoObjeto() != null) {

                 if (step.getTipoObjeto().equals("Bot�o")) {

                     cell1 = new BotaoCell(step.getPalavraChave(), useCase,

                             step, flow, flow.getSteps().indexOf(step), 20 + x,

                             20 + y, passosCobertos);

                     GraphConstants.setIcon(cell1.getAttributes(), BotaoFactory

                             .createIcon("button"));

                     GraphConstants.setVerticalTextPosition(cell1

                             .getAttributes(), SwingConstants.BOTTOM);

                 } else {

                     cell1 = new StepCell(step.getPalavraChave(), useCase, step,

                             flow, flow.getSteps().indexOf(step), 20 + x,

                             20 + y, passosCobertos);

                 }

             } else {

                 cell1 = new StepCell(step.getPalavraChave(), useCase, step,

                         flow, flow.getSteps().indexOf(step), 20 + x, 20 + y,

                         passosCobertos);

             }

             ArrayList<StepCell> steps = (ArrayList<StepCell>) flows.get(flow

                     .getName());

             steps.add(cell1);

             y = y + 40;

             mapaStep.put(flow.getName() + contador, cell1);

             if (!(celulas.contains(cell1))) {

                 celulas.add(cell1);

             }

             contador++;

             for (Filtro filtro : step.getFiltros()) {

                 CondicionalCell condicao = Util.criaCondicao(filtro, 40 + x,

                         40 + y, step, flow, useCase);

                 FiltroEdge edge = Util.criaLinkCondicao(condicao, cell1);

                 celulas.add(condicao);

                 if (!(celulas.contains(edge))) {

                     celulas.add(edge);

                 }

             }

             if (cellAnterior != null) {

                 DefaultEdge edge = new DefaultEdge();

                 int arrow = GraphConstants.ARROW_CLASSIC;

                 GraphConstants.setLineEnd(edge.getAttributes(), arrow);

                 GraphConstants.setEndFill(edge.getAttributes(), true);

                 edge.setSource(cellAnterior.getChildAt(0));

                 edge.setTarget(cell1.getChildAt(0));

                 cell1.setSetaAnterior(edge);

                 if (!(celulas.contains(edge))) {

                     celulas.add(edge);

                 }

             }

             cellAnterior = cell1;

             for (Object object2 : step.getDatas()) {

                 DadosTeste data = (DadosTeste) object2;

                 x = x + 40;

                 DataCell cell2 = Util.criaDado(data, x, y, step);

                 x = x - 40;

                 y = y + 40;

                 mapaStep.put(flow.getName() + contador + data.getName(), cell2);

                 if (!(celulas.contains(cell2))) {

                     celulas.add(cell2);

                 }

                 DadoEdge edge1 = Util.criaLinkDado(cell1, cell2);

                 if (!(celulas.contains(edge1))) {

                     celulas.add(edge1);

                 }

             }

             for (Object object2 : step.getRegras()) {

                 RegraNegocio rule = (RegraNegocio) object2;

                 x = x - 40;

                 RuleCell cell2 = Util.criaRule(rule, x, y, step);

                 x = x + 40;

                 y = y + 40;

                 mapaStep.put(flow.getName() + contador + rule.getName(), cell2);

                 if (!(celulas.contains(cell2))) {

                     celulas.add(cell2);

                 }

                 RuleEdge edge1 = Util.criaLinkRule(cell1, cell2);

                 if (!(celulas.contains(edge1))) {

                     celulas.add(edge1);

                 }

             }

         }

     }

     public void criaLinkNaoResumido(Fluxo flow,

             HashMap<Object, Object> mapaStep, int contador, List<Object> list) {

         if (flow.isShowLink()) {

             for (Object object1 : flow.getSteps()) {

                 Step step = (Step) object1;

                 for (Object object2 : step.getLinks()) {

                     Link link = (Link) object2;

                     Fluxo flowLink = link.getFlow();

                     StepCell cellOrigem = (StepCell) mapaStep.get(flow

                             .getName()

                             + contador);

                     if (flowLink != null) {

                         if (!(Util.getFlows().contains(flowLink.getName()))) {

                             StepCell cellDestino = (StepCell) mapaStep

                                     .get(flowLink.getName()

                                             + link.getStepNumber());

                             if (cellDestino != null) {

                                 DefaultEdge edge = Util.criaLink(cellOrigem,

                                         cellDestino, link);

                                 if (!(list.contains(edge))) {

                                     list.add(edge);

                                 }

                             }

                         } else {

                             StateFlowCell cellDestino = (StateFlowCell) mapaStep

                                     .get(flowLink.getName());

                             DefaultEdge edge = Util.criaLink(cellOrigem,

                                     cellDestino, link);

                             if (!(list.contains(edge))) {

                                 list.add(edge);

                             }

                         }

                     }

                 }

                 contador++;

             }

         }

     }

     /***

      * Cria link para fluxos no modeo escondido

      *

      * @param flow

      * @param mapaStep

      * @param list

      * @param contador

      */

     public void criaLinkResumido(Fluxo flow, HashMap<Object, Object> mapaStep,

             List<Object> list, int contador) {

         for (Object object1 : flow.getSteps()) {

             Step step = (Step) object1;

             for (Object object2 : step.getLinks()) {

                 Link link = (Link) object2;

                 Fluxo flowLink = link.getFlow();

                 try {

                     StateFlowCell cellOrigem = (StateFlowCell) mapaStep

                             .get(flow.getName());

                     if (!(Util.getFlows().contains(flowLink.getName()))) {

                         StepCell cellDestino = (StepCell) mapaStep.get(flowLink

                                 .getName()

                                 + link.getStepNumber());

                         if (cellDestino != null) {

                             DefaultEdge edge = Util.criaLink(cellOrigem,

                                     cellDestino, link);

                             if (!(list.contains(edge))) {

                                 list.add(edge);

                             }

                         }

                     } else {

                         StateFlowCell cellDestino = (StateFlowCell) mapaStep

                                 .get(flowLink.getName());

                         DefaultEdge edge = Util.criaLink(cellOrigem,

                                 cellDestino, link);

                         if (!(list.contains(edge))) {

                             list.add(edge);

                         }

                     }

                 } catch (Exception e) {

                     ControladorErro.trata(e, this);

                 }

             }

             contador++;

         }

     }

     @SuppressWarnings("unchecked")

     public void criaFlowResumido(Fluxo flow, CasoUso useCase, int x, int y,

             ArrayList passosCobertos, HashMap<Object, Object> flows,

             HashMap<Object, Object> mapaStep, int contador, List<Object> list,

             StepCell cellAnterior) {

         StateFlowCell flowCell = new StateFlowCell(flow.getName(), flow,

                 20 + x, 20 + y);

         if (!(list.contains(flowCell))) {

             list.add(flowCell);

         }

         mapaStep.put(flow.getName(), flowCell);

         for (Object object1 : flow.getSteps()) {

             Step step = (Step) object1;

             StepCell cell1 = new StepCell(step.getDescricao(), useCase, step,

                     flow, flow.getSteps().indexOf(step), 20 + x, 20 + y,

                     passosCobertos);

             ArrayList<Object> steps = (ArrayList<Object>) flows.get(flow

                     .getName());

             steps.add(cell1);

             y = y + 40;

             mapaStep.put(flow.getName() + contador, cell1);

             contador++;

         }

     }

     @Override

     public void deletarEspecifico(Object[] selecionados, CasoUso useCase,

             List<DefaultGraphCell> remocao) throws InstantiationException,

             IllegalAccessException, ClassNotFoundException, SQLException,

             IOException {

         StepCell primeiro = null;

         for (int i = 0; i <= selecionados.length - 1; i++) {

             primeiro = (StepCell) selecionados[i];

             ControladorStep controlador = new ControladorStep();

             controlador.deletarStep(primeiro.getStep(), useCase, primeiro

                     .getFlow());

             remocao.add(primeiro);

         }

     }

     @Override

     public void ligarValorEspecifico(Object[] celulas,

             List<DefaultGraphCell> adicao) throws InstantiationException,

             IllegalAccessException, ClassNotFoundException, SQLException,

             IOException {

         DataCell primeiro1 = null;

         for (int i = 0; i <= selecionados.length - 1; i++) {

             Object celula = selecionados[i];

             if (celula instanceof DataCell) {

                 primeiro1 = (DataCell) celula;

             }

             if (celula instanceof ValorCell) {

                 ValorCell valorCell = (ValorCell) celula;

                 TestDataValor valor = valorCell.getValor();

                 DadosTeste data = primeiro1.getData();

                 ValorEdge seta = Util.criaLinkValor(primeiro1, valorCell);

                 adicao.add(seta);

                 FlowController controlador = new FlowController();

                 controlador.inserirValor(data, valor);

             }

         }

     }

     @Override

     public void ligarRegraEspecifico(Object[] celulas,

             List<DefaultGraphCell> adicao) {

         StepCell primeiro3 = null;

         for (int i = 0; i <= selecionados.length - 1; i++) {

             Object celula = selecionados[i];

             if (celula instanceof StepCell) {

                 primeiro3 = (StepCell) celula;

             }

             if (celula instanceof RuleCell) {

                 RuleCell data = (RuleCell) celula;

                 data.setStep(primeiro3.getStep());

                 RuleEdge seta = Util.criaLinkRule(primeiro3, data);

                 adicao.add(seta);

                 FlowController controlador = new FlowController();

                 controlador.inserirRegra(primeiro3.getStep(), primeiro3

                         .getFlow(), data.getRule());

             }

         }

     }

     @Override

     public void ligarDadoEspecifico(Object[] celulas,

             List<DefaultGraphCell> adicao) {

         StepCell primeiro1 = null;

         for (int i = 0; i <= celulas.length - 1; i++) {

             Object celula = celulas[i];

             if (celula instanceof StepCell) {

                 primeiro1 = (StepCell) celula;

             }

             if (celula instanceof DataCell) {

                 DataCell data = (DataCell) celula;

                 DadoEdge seta = Util.criaLinkDado(primeiro1, data);

                 adicao.add(seta);

                 FlowController controlador = new FlowController();

                 controlador.inserirDados(primeiro1.getStep(), primeiro1

                         .getFlow(), data.getData());

             }

         }

     }

     @Override

     public void atualizarStepEspecifico(Object[] celulas2) {

         StepCell primeiro = null;

         for (int i = 0; i <= celulas2.length - 1; i++) {

             Object celula = celulas2[i];

             if (celula instanceof StepCell) {

                 primeiro = (StepCell) celula;

                 FlowController controlador = new FlowController();

                 String descricao = primeiro.toString();

                 controlador.renomear(primeiro.getStep(), primeiro.getFlow(),

                         descricao, primeiro.getUseCase());

             }

         }

     }

     @Override

     public void criarLinkEspecifico(Object[] celulas,

             List<DefaultGraphCell> adicao) {

         StepCell primeiro = null;

         for (int i = 0; i <= celulas.length - 1; i++) {

             Object celula = celulas[i];

             if (celula instanceof StepCell) {

                 if (primeiro != null) {

                     StepCell segundo = (StepCell) celula;

                     DefaultEdge seta = Util.criaLink(primeiro, segundo,

                             new Link());

                     adicao.add(seta);

                     FlowController controlador = new FlowController();

                     controlador.inserirLink(primeiro.getStep(), segundo

                             .getFlow(), segundo.getStepNumber(), primeiro

                             .getUseCase());

                     primeiro = (StepCell) celula;

                 } else {

                     primeiro = (StepCell) celula;

                 }

             }

         }

     }

     @Override

     public void definirProbabilidadeEspecifico(Object[] celulas,

             CasoUso useCase, List<DefaultGraphCell> adicao) {

         for (int i = 0; i <= celulas.length - 1; i++) {

             Object celula = celulas[i];

             if (celula instanceof LinkEdge) {

                 LinkEdge edge = (LinkEdge) celula;

                 LinkPort porta = (LinkPort) edge.getSource();

                 Step step = porta.getStep();

                 double probabilidade = Double.parseDouble(edge.toString());

                 Link link = edge.getLink();

                 link.setProbabilidade(probabilidade);

                 FlowController controlador = new FlowController();

                 controlador.atualizaLink(link, step, link.getFlow(), useCase);

             }

         }

     }

     @Override

     public void aplicarFiltroValidoEspecifico(Object[] celulas,

             CasoUso useCase, List<DefaultGraphCell> adicao, JGraph graph)

             throws SQLException, InstantiationException,

             IllegalAccessException, ClassNotFoundException, IOException {

         for (int i = 0; i <= celulas.length - 1; i++) {

             Object celula = celulas[i];

             if (celula instanceof StepCell) {

                 StepCell stepCell = (StepCell) celula;

                 Step step = stepCell.getStep();

                 Filtro filtro = new Filtro();

                 filtro.setTipoCondicional(0);

                 filtro.setStep(step);

                 DAOFiltro daoFiltro = new DAOFiltro();

                 filtro = daoFiltro.insere(step, filtro);

                 step.getFiltros().add(filtro);

                 Point2D point = graph.getCenterPoint();

                 CondicionalCell condicao = Util.criaCondicao(filtro,

                         (int) point.getX(), (int) point.getY(), step, stepCell

                                 .getFlow(), useCase);

                 adicao.add(condicao);

                 FiltroEdge seta = Util.criaLinkCondicao(condicao, stepCell);

                 adicao.add(seta);

             }

         }

     }

     @Override

     public void retiraFiltrosEspecifico(Object[] celulas,

             List<DefaultGraphCell> adicao) throws SQLException,

             InstantiationException, IllegalAccessException,

             ClassNotFoundException, IOException {

         for (int i = 0; i <= celulas.length - 1; i++) {

             Object celula = celulas[i];

             if (celula instanceof CondicionalCell) {

                 CondicionalCell condicionalCell = (CondicionalCell) celula;

                 Step step = condicionalCell.getStep();

                 Filtro filtro = condicionalCell.getFiltro();

                 DAOFiltro daoFiltro = new DAOFiltro();

                 daoFiltro.delete(step, filtro);

                 step.getFiltros().remove(filtro);

                 adicao.add(condicionalCell);

                 adicao.add(condicionalCell.getFiltroEdge());

             }

         }

     }

     @Override

     public void inserirValorEspecifico(List<JTextField> fields,

             List<DefaultGraphCell> adicao) {

         TestDataValor valor = new TestDataValor();

         String valorString = fields.get(2).getText();

         valor.setValor(valorString);

         ValorCell valorCell = Util.criaValor(valor, 100, 100);

         adicao.add(valorCell);

     }

 }