package modelo;

import java.io.File;
import java.util.ArrayList;
import java.util.Observable;
import javax.swing.JOptionPane;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;


// <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
// #[regen=yes,id=DCE.6152FD4C-6D23-B415-B6AA-5E3083D32571]
// </editor-fold> 
public class DocumentoReq extends Observable{

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.CCA1F4F7-57C3-AD84-BE75-1BB551CFC3E5]
    // </editor-fold> 
    private ArrayList<CasodeUso> mCasodeUso = new ArrayList();
    private ArrayList<ReqFuncional> mReqFunc = new ArrayList();
    private ArrayList<ReqNoFuncional> mReqNoFunc = new ArrayList();
    private ArrayList<ReqInformacion> mReqInfo = new ArrayList();
    private ArrayList<ReqRestriccion> mReqRest = new ArrayList();
    private ArrayList<Participante> mParticipante = new ArrayList();
    private ArrayList<Objetivos> mObjetivos = new ArrayList();
    private ArrayList<Reunion> mReunion = new ArrayList();
    private ArrayList<Seccion> mSeccion = new ArrayList();
    private ArrayList<Parrafo> mParrafo = new ArrayList();
    private ArrayList<FicheroGrafico> mFicheroGrafico = new ArrayList();
    private ArrayList<Rastreabilidad> mRastreabilidad = new ArrayList();

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.1D51ABF1-2DD9-82E3-126D-173DEB5FADBA]
    // </editor-fold> 
    public DocumentoReq () {
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.A9A64C79-62B1-D6C4-FB8A-BCD4EF81E5C4]
    // </editor-fold> 
    public ArrayList<CasodeUso> getCasodeUso () {
        return mCasodeUso;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.53D39B7F-03CC-D44E-1C6A-CB6F6C02538E]
    // </editor-fold> 
    public void setCasodeUso (ArrayList<CasodeUso> val) {
         this.mCasodeUso=val;
         //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.3DF3139E-17FC-1508-86A3-908C60405553]
    // </editor-fold> 
    public CasodeUso nuevoCU (String nombreCU, boolean esAbstracto, String eventoActivacion, int frecuencia, String unidadFrecuencia, String precondicion, String postcondicion, String importancia, String urgencia, String estadodeDesarrollo, String estabilidad) {

        //// Creo la instancia
        CasodeUso auxCU=new CasodeUso();
        //// Asigno los valores a los atributos
        auxCU.setNombre(nombreCU);
        auxCU.setEsAbstracto(esAbstracto);
        auxCU.setEventoActivacion(eventoActivacion);
        auxCU.setFrecuencia(frecuencia);
        auxCU.setUnidadFrecuencia(unidadFrecuencia);
        auxCU.setPrecondicion(precondicion);
        auxCU.setPostcondicion(postcondicion);
        auxCU.setImportancia(importancia);
        auxCU.setUrgencia(urgencia);
        auxCU.setEstadodeDesarrollo(estadodeDesarrollo);
        auxCU.setEstabilidad(estabilidad);
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getCasodeUso().add(auxCU);
        //Notificamos que ha habido un cambio
        this.setChanged();
         this.notifyObservers();
        return auxCU;
    }
    public ReqFuncional nuevoReqFunc(String nombre,
                           String autores,
                           String Fuentes,
                           String comentarios,
                           String importancia,
                           String urgencia,
                           String estadoDes,
                           String estabilidad,
                           String descripcion)
    {
        ReqFuncional aux = new ReqFuncional();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setComentarios(comentarios);
        aux.setImportancia(importancia);
        aux.setUrgencia(urgencia);
        aux.setEstadoDes(estadoDes);
        aux.setEstabilidad(estabilidad);
        aux.setDescripcion(descripcion);
        this.getmReqFunc().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }
    public ReqNoFuncional nuevoReqNoFunc(String nombre,
                           String autores,
                           String Fuentes,
                           String comentarios,
                           String importancia,
                           String urgencia,
                           String estadoDes,
                           String estabilidad,
                           String descripcion)
    {
        ReqNoFuncional aux = new ReqNoFuncional();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setComentarios(comentarios);
        aux.setImportancia(importancia);
        aux.setUrgencia(urgencia);
        aux.setEstadoDes(estadoDes);
        aux.setEstabilidad(estabilidad);
        aux.setDescripcion(descripcion);
        this.getmReqNoFunc().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }
    public ReqRestriccion nuevoReqRest(String nombre,
                           String autores,
                           String Fuentes,
                           String comentarios,
                           String importancia,
                           String urgencia,
                           String estadoDes,
                           String estabilidad,
                           String descripcion)
    {
        ReqRestriccion aux = new ReqRestriccion();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setComentarios(comentarios);
        aux.setImportancia(importancia);
        aux.setUrgencia(urgencia);
        aux.setEstadoDes(estadoDes);
        aux.setEstabilidad(estabilidad);
        aux.setDescripcion(descripcion);
        this.getmReqRest().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }
    public ReqInformacion nuevoReqInfo(String nombre,
                                       String autores,
                                       String Fuentes,
                                       String importancia,
                                       String urgencia,
                                       String estadoDes,
                                       String estabilidad,
                                       String comentarios,
                                       String conceptoRelevante,
                                       int tiempoMax,
                                       int tiempoMed,
                                       String unifreqmax,
                                       String unifreqmed,
                                       int numOcurrencias,
                                       int numMedio)
    {
        ReqInformacion aux = new ReqInformacion();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setComentarios(comentarios);
        aux.setImportancia(importancia);
        aux.setUrgencia(urgencia);
        aux.setEstadoDes(estadoDes);
        aux.setEstabilidad(estabilidad);
        aux.setConceptoRelevante(conceptoRelevante);
        aux.setTiempoMaxVida(tiempoMax);
        aux.setTiempoMedVida(tiempoMed);
        aux.setUnidadFreqMax(unifreqmax);
        aux.setUnidadFreqMed(unifreqmed);
        aux.setNumOcurrencias(numOcurrencias);
        aux.setNumMedio(numMedio);
        this.getmReqInfo().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }

    public ArrayList<ReqFuncional> getmReqFunc() {
        return mReqFunc;
    }

    /**
     * @param mReqFunc the mReqFunc to set
     */
    public void setmReqFunc(ArrayList<ReqFuncional> mReqFunc) {
        this.mReqFunc = mReqFunc;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }

    /**
     * @return the mReqNoFunc
     */
    public ArrayList<ReqNoFuncional> getmReqNoFunc() {
        return mReqNoFunc;
    }

    /**
     * @param mReqNoFunc the mReqNoFunc to set
     */
    public void setmReqNoFunc(ArrayList<ReqNoFuncional> mReqNoFunc) {
        this.mReqNoFunc = mReqNoFunc;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }

    /**
     * @return the mReqInfo
     */
    public ArrayList<ReqInformacion> getmReqInfo() {
        return mReqInfo;
    }

    public void setmReqInfo(ArrayList<ReqInformacion> mReqInfo) {
        this.mReqInfo = mReqInfo;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }

    /**
     * @return the mReqRest
     */
    public ArrayList<ReqRestriccion> getmReqRest() {
        return mReqRest;
    }

    /**
     * @param mReqRest the mReqRest to set
     */
    public void setmReqRest(ArrayList<ReqRestriccion> mReqRest) {
        this.mReqRest = mReqRest;
        //Notificamos que ha habido un cambio
        this.setChanged();
        this.notifyObservers();
    }

    public void toXML(){
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        try{
            DocumentBuilder builder = factory.newDocumentBuilder();
            DOMImplementation implementation = builder.getDOMImplementation();
            Document document = implementation.createDocument(null, "xml", null);

            Element raiz = document.createElement("Documento"); // creamos el elemento raiz
            document.setXmlVersion("1.0"); // asignamos la version de nuestro XML
            document.getDocumentElement().appendChild(raiz); //pegamos la raiz al documento

            //A PARTIR DE AQUI SE VA MANEJANDO CADA ELEMENTO (CU,REQUISITO FUNCIONAL...)

            //CASOS DE USO
            int numCasosUso = this.mCasodeUso.size();

            for (int i=0;i<numCasosUso;i++)
               { 
                  //Element CasoU = document.createElement("CasodeUso");
                  Element CasoU = document.createElement("Object");

                  Element nombre,esAbstracto,eventoActivacion,frecuencia,unidadFrecuencia,precondicion,postcondicion,importancia,urgencia,estadodeDesarrollo,estabilidad,type;
                  Text tnombre,tesAbstracto,teventoActivacion,tfrecuencia,tunidadFrecuencia,tprecondicion,tpostcondicion,timportancia,turgencia,testadodeDesarrollo,testabilidad,ttype;
               

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  esAbstracto=document.createElement("esAbstracto");
                  eventoActivacion=document.createElement("eventoActivacion");
                  frecuencia=document.createElement("frecuencia");
                  unidadFrecuencia=document.createElement("unidadFrecuencia");
                  precondicion=document.createElement("precondicion");
                  postcondicion=document.createElement("postcondicion");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadodeDesarrollo=document.createElement("estadodeDesarrollo");
                  estabilidad=document.createElement("estabilidad");
                  type=document.createElement("type");

                  //Introducimos el text
                  if(mCasodeUso.get(i).getEsAbstracto() == true)
                  {
                     tesAbstracto = document.createTextNode("SI"); //Ingresamos la info
                  }
                  else
                  {
                      tesAbstracto = document.createTextNode("NO"); //Ingresamos la info
                  }

                  String frecuencia1=String.valueOf(mCasodeUso.get(i).getFrecuencia());
                  tnombre=document.createTextNode(mCasodeUso.get(i).getNombre());
                  teventoActivacion=document.createTextNode(mCasodeUso.get(i).getEventoActivacion());
                  tfrecuencia=document.createTextNode(frecuencia1);
                  tunidadFrecuencia=document.createTextNode(mCasodeUso.get(i).getUnidadFrecuencia());
                  tprecondicion=document.createTextNode(mCasodeUso.get(i).getPrecondicion());
                  tpostcondicion=document.createTextNode(mCasodeUso.get(i).getPostcondicion());
                  timportancia=document.createTextNode(mCasodeUso.get(i).getImportancia());
                  turgencia=document.createTextNode(mCasodeUso.get(i).getUrgencia());
                  testadodeDesarrollo=document.createTextNode(mCasodeUso.get(i).getEstadodeDesarrollo());
                  testabilidad=document.createTextNode(mCasodeUso.get(i).getEstabilidad());
                  ttype=document.createTextNode("CasodeUso");

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  esAbstracto.appendChild(tesAbstracto);
                  eventoActivacion.appendChild(teventoActivacion);
                  frecuencia.appendChild(tfrecuencia);
                  unidadFrecuencia.appendChild(tunidadFrecuencia);
                  precondicion.appendChild(tprecondicion);
                  postcondicion.appendChild(tpostcondicion);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadodeDesarrollo.appendChild(testadodeDesarrollo);
                  estabilidad.appendChild(testabilidad);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  CasoU.appendChild(nombre);
                  CasoU.appendChild(esAbstracto);
                  CasoU.appendChild(eventoActivacion);
                  CasoU.appendChild(frecuencia);
                  CasoU.appendChild(unidadFrecuencia);
                  CasoU.appendChild(precondicion);
                  CasoU.appendChild(postcondicion);
                  CasoU.appendChild(importancia);
                  CasoU.appendChild(urgencia);
                  CasoU.appendChild(estadodeDesarrollo);
                  CasoU.appendChild(estabilidad);
                  CasoU.appendChild(type);

                  
                  //PASOS
                  ArrayList<PasoCU> pasos = mCasodeUso.get(i).getPasoCU();
                  //mostrarmensaje(mCasodeUso.get(i).getPasoCU().size());
                  for(int j=0;j<pasos.size();j++)
                  {
                      Element Paso = document.createElement("Paso");
                      
                      Element numero=document.createElement("numero");
                      String numPaso=String.valueOf(pasos.get(j).getNumeroPaso());
                      Text tnumero=document.createTextNode(numPaso);
                      numero.appendChild(tnumero);
                      Paso.appendChild(numero);
                      
                      Element descripcion=document.createElement("descripcion");
                      Text tdescripcion=document.createTextNode(pasos.get(j).getDescripcionPas());
                      descripcion.appendChild(tdescripcion);
                      Paso.appendChild(descripcion);
                      
                      CasoU.appendChild(Paso);
                   }
                   //FIN DE PASOS

                   raiz.appendChild(CasoU); //pegamos el elemento hijo a la raiz
               }
             //FIN CASOS DE USO

            //REQUISITOS FUNCIONALES
            int numRF = this.mReqFunc.size();

            for (int i=0;i<numRF;i++)
            {
                  // Element ReqFunc = document.createElement("ReqFun");
                    Element ReqFunc = document.createElement("Object");

                   Element nombre,autores,fuentes,comentarios,importancia,urgencia,estadoDes,estabilidad,descripcion,type;
                   Text tnombre,tautores,tfuentes,tcomentarios,timportancia,turgencia,testadoDes,testabilidad,tdescripcion,ttype;

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadoDes=document.createElement("estadoDes");
                  estabilidad=document.createElement("estabilidad");
                  descripcion=document.createElement("descripcion");
                  type=document.createElement("type");

                  //Introducimos el text

                  tnombre=document.createTextNode(mReqFunc.get(i).getNombre());
                  tautores=document.createTextNode(mReqFunc.get(i).getAutores());
                  tfuentes=document.createTextNode(mReqFunc.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mReqFunc.get(i).getComentarios());
                  timportancia=document.createTextNode(mReqFunc.get(i).getImportancia());
                  turgencia=document.createTextNode(mReqFunc.get(i).getUrgencia());
                  testadoDes=document.createTextNode(mReqFunc.get(i).getEstadoDes());
                  testabilidad=document.createTextNode(mReqFunc.get(i).getEstabilidad());
                  tdescripcion=document.createTextNode(mReqFunc.get(i).getDescripcion());
                  ttype=document.createTextNode("ReqFun");
                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadoDes.appendChild(testadoDes);
                  estabilidad.appendChild(testabilidad);
                  descripcion.appendChild(tdescripcion);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  ReqFunc.appendChild(nombre);
                  ReqFunc.appendChild(autores);
                  ReqFunc.appendChild(fuentes);
                  ReqFunc.appendChild(comentarios);
                  ReqFunc.appendChild(importancia);
                  ReqFunc.appendChild(urgencia);
                  ReqFunc.appendChild(estadoDes);
                  ReqFunc.appendChild(estabilidad);
                  ReqFunc.appendChild(descripcion);
                  ReqFunc.appendChild(type);

                  raiz.appendChild(ReqFunc); //pegamos el elemento hijo a la raiz
             }

            //FIN REQUISITOS FUNCIONALES

            //REQUISITOS NO FUNCIONALES

            int numRNF = this.mReqNoFunc.size();
            
                   //CREAMOS LOS DISTINTOS ELEMENTOS Y TEXT
               for (int i=0;i<numRNF;i++)
               {
                   //Element ReqNoFunc = document.createElement("ReqNoFun");
                   Element ReqNoFunc = document.createElement("Object");
                   Element nombre,autores,fuentes,comentarios,importancia,urgencia,estadoDes,estabilidad,descripcion,type;
                   Text tnombre,tautores,tfuentes,tcomentarios,timportancia,turgencia,testadoDes,testabilidad,tdescripcion,ttype;


                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadoDes=document.createElement("estadoDes");
                  estabilidad=document.createElement("estabilidad");
                  descripcion=document.createElement("descripcion");
                  type=document.createElement("type");

                  //Introducimos el text

                  tnombre=document.createTextNode(mReqNoFunc.get(i).getNombre());
                  tautores=document.createTextNode(mReqNoFunc.get(i).getAutores());
                  tfuentes=document.createTextNode(mReqNoFunc.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mReqNoFunc.get(i).getComentarios());
                  timportancia=document.createTextNode(mReqNoFunc.get(i).getImportancia());
                  turgencia=document.createTextNode(mReqNoFunc.get(i).getUrgencia());
                  testadoDes=document.createTextNode(mReqNoFunc.get(i).getEstadoDes());
                  testabilidad=document.createTextNode(mReqNoFunc.get(i).getEstabilidad());
                  tdescripcion=document.createTextNode(mReqNoFunc.get(i).getDescripcion());
                  ttype=document.createTextNode("ReqNoFun");

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadoDes.appendChild(testadoDes);
                  estabilidad.appendChild(testabilidad);
                  descripcion.appendChild(tdescripcion);
                  type.appendChild(ttype);
                  //enlazamos cada atributo a su caso de uso
                  ReqNoFunc.appendChild(nombre);
                  ReqNoFunc.appendChild(autores);
                  ReqNoFunc.appendChild(fuentes);
                  ReqNoFunc.appendChild(comentarios);
                  ReqNoFunc.appendChild(importancia);
                  ReqNoFunc.appendChild(urgencia);
                  ReqNoFunc.appendChild(estadoDes);
                  ReqNoFunc.appendChild(estabilidad);
                  ReqNoFunc.appendChild(descripcion);
                  ReqNoFunc.appendChild(type);

                  raiz.appendChild(ReqNoFunc); //pegamos el elemento hijo a la raiz
             }

            //FIN REQUISITO NO FUNCIONAL

            //REQUISITO DE INFORMACION

            int numRInfo = this.mReqInfo.size();
               //CREAMOS LOS DISTINTOS ELEMENTOS Y TEXT
               for (int i=0;i<numRInfo;i++)
               {
                   //Element ReqInfo = document.createElement("ReqInf");
                   Element ReqInfo = document.createElement("Object");

                   Element nombre,autores,fuentes,comentarios,importancia,urgencia,estadoDes,estabilidad,conceptoRelevante,tiempoMaxVida,tiempoMedVida,unidadFreqMax,unidadFreqMed,numOcurrencias,numMedio,type;
                   Text tnombre,tautores,tfuentes,tcomentarios,timportancia,turgencia,testadoDes,testabilidad,tconceptoRelevante,ttiempoMaxVida,ttiempoMedVida,tunidadFreqMax,tunidadFreqMed,tnumOcurrencias,tnumMedio,ttype;


                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadoDes=document.createElement("estadoDes");
                  estabilidad=document.createElement("estabilidad");
                  conceptoRelevante=document.createElement("conceptoRelevante");
                  tiempoMaxVida=document.createElement("tiempoMaxVida");
                  tiempoMedVida=document.createElement("tiempoMedVida");
                  unidadFreqMax=document.createElement("unidadFreqMax");
                  unidadFreqMed=document.createElement("unidadFreqMed");
                  numOcurrencias=document.createElement("numOcurrencias");
                  numMedio=document.createElement("numMedio");
                  type=document.createElement("type");
                  //Introducimos el text

                  String tiempoMaxVida1=String.valueOf(mReqInfo.get(i).getTiempoMaxVida());
                  String tiempoMedVida1=String.valueOf(mReqInfo.get(i).getTiempoMedVida());
                  String numOcurrencias1=String.valueOf(mReqInfo.get(i).getNumOcurrencias());
                  String numMedio1=String.valueOf(mReqInfo.get(i).getNumMedio());
                  tnombre=document.createTextNode(mReqInfo.get(i).getNombre());
                  tautores=document.createTextNode(mReqInfo.get(i).getAutores());
                  tfuentes=document.createTextNode(mReqInfo.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mReqInfo.get(i).getComentarios());
                  timportancia=document.createTextNode(mReqInfo.get(i).getImportancia());
                  turgencia=document.createTextNode(mReqInfo.get(i).getUrgencia());
                  testadoDes=document.createTextNode(mReqInfo.get(i).getEstadoDes());
                  testabilidad=document.createTextNode(mReqInfo.get(i).getEstabilidad());
                  tconceptoRelevante=document.createTextNode(mReqInfo.get(i).getConceptoRelevante());
                  ttiempoMaxVida=document.createTextNode(tiempoMaxVida1);
                  ttiempoMedVida=document.createTextNode(tiempoMedVida1);
                  tunidadFreqMax=document.createTextNode(mReqInfo.get(i).getUnidadFreqMax());
                  tunidadFreqMed=document.createTextNode(mReqInfo.get(i).getUnidadFreqMed());
                  tnumOcurrencias=document.createTextNode(numOcurrencias1);
                  tnumMedio=document.createTextNode(numMedio1);
                  ttype=document.createTextNode("ReqInf");


                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadoDes.appendChild(testadoDes);
                  estabilidad.appendChild(testabilidad);
                  conceptoRelevante.appendChild(tconceptoRelevante);
                  tiempoMaxVida.appendChild(ttiempoMaxVida);
                  tiempoMedVida.appendChild(ttiempoMedVida);
                  unidadFreqMax.appendChild(tunidadFreqMax);
                  unidadFreqMed.appendChild(tunidadFreqMed);
                  numOcurrencias.appendChild(tnumOcurrencias);
                  numMedio.appendChild(tnumMedio);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  ReqInfo.appendChild(nombre);
                  ReqInfo.appendChild(autores);
                  ReqInfo.appendChild(fuentes);
                  ReqInfo.appendChild(comentarios);
                  ReqInfo.appendChild(importancia);
                  ReqInfo.appendChild(urgencia);
                  ReqInfo.appendChild(estadoDes);
                  ReqInfo.appendChild(estabilidad);
                  ReqInfo.appendChild(conceptoRelevante);
                  ReqInfo.appendChild(tiempoMaxVida);
                  ReqInfo.appendChild(tiempoMedVida);
                  ReqInfo.appendChild(unidadFreqMax);
                  ReqInfo.appendChild(unidadFreqMed);
                  ReqInfo.appendChild(numOcurrencias);
                  ReqInfo.appendChild(numMedio);
                  ReqInfo.appendChild(type);

                  raiz.appendChild(ReqInfo); //pegamos el elemento hijo a la raiz
             }

            //FUN REQUISITO DE INFORMACION

            //REQUISITO DE RESTRICCION

           int numRest = this.mReqRest.size();

           for (int i=0;i<numRest;i++)
               {

                  //Element ReqRest = document.createElement("ReqRestri");
                  Element ReqRest = document.createElement("Object");

                  Element nombre,autores,fuentes,comentarios,importancia,urgencia,estadoDes,estabilidad,descripcion,type;
                  Text tnombre,tautores,tfuentes,tcomentarios,timportancia,turgencia,testadoDes,testabilidad,tdescripcion,ttype;

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadoDes=document.createElement("estadoDes");
                  estabilidad=document.createElement("estabilidad");
                  descripcion=document.createElement("descripcion");
                  type=document.createElement("type");

                  //Introducimos el text

                  tnombre=document.createTextNode(mReqRest.get(i).getNombre());
                  tautores=document.createTextNode(mReqRest.get(i).getAutores());
                  tfuentes=document.createTextNode(mReqRest.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mReqRest.get(i).getComentarios());
                  timportancia=document.createTextNode(mReqRest.get(i).getImportancia());
                  turgencia=document.createTextNode(mReqRest.get(i).getUrgencia());
                  testadoDes=document.createTextNode(mReqRest.get(i).getEstadoDes());
                  testabilidad=document.createTextNode(mReqRest.get(i).getEstabilidad());
                  tdescripcion=document.createTextNode(mReqRest.get(i).getDescripcion());
                  ttype=document.createTextNode("ReqRest");

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadoDes.appendChild(testadoDes);
                  estabilidad.appendChild(testabilidad);
                  descripcion.appendChild(tdescripcion);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  ReqRest.appendChild(nombre);
                  ReqRest.appendChild(autores);
                  ReqRest.appendChild(fuentes);
                  ReqRest.appendChild(comentarios);
                  ReqRest.appendChild(importancia);
                  ReqRest.appendChild(urgencia);
                  ReqRest.appendChild(estadoDes);
                  ReqRest.appendChild(estabilidad);
                  ReqRest.appendChild(descripcion);
                  ReqRest.appendChild(type);

                  raiz.appendChild(ReqRest); //pegamos el elemento hijo a la raiz
                }

            //FUN REQUISITO DE RESTRICCION

            //PARTICIPANTES

            int numPart = this.mParticipante.size();
            
               for (int i=0;i<numPart;i++)
               {
                  //Element Participante = document.createElement("participante");
                   Element Participante = document.createElement("Object");

                  Element nombre,esUsuario,esCliente,esDesarrollador,rol,organizacion,autores,fuentes,type;
                  Text tnombre,tesUsuario,tesCliente,tesDesarrollador,trol,torganizacion,tautores,tfuentes,ttype;

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  esUsuario=document.createElement("esUsuario");
                  esCliente=document.createElement("esCliente");
                  esDesarrollador=document.createElement("esDesarrollador");
                  rol=document.createElement("rol");
                  organizacion=document.createElement("organizacion");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  type=document.createElement("type");

                  //Introducimos el text

                  tnombre=document.createTextNode(mParticipante.get(i).getNombre());
                  if(mParticipante.get(i).getEsUsuario()==true)
                  {
                    tesUsuario=document.createTextNode("SI");
                  }
                  else
                  {
                      tesUsuario=document.createTextNode("NO");
                  }
                  if(mParticipante.get(i).getEsCliente()==true)
                  {
                    tesCliente=document.createTextNode("SI");
                  }
                  else
                  {
                      tesCliente=document.createTextNode("NO");
                  }
                  if(mParticipante.get(i).getEsDesarrollador()==true)
                  {
                    tesDesarrollador=document.createTextNode("SI");
                  }
                  else
                  {
                      tesDesarrollador=document.createTextNode("NO");
                  }
                  trol=document.createTextNode(mParticipante.get(i).getRol());
                  torganizacion=document.createTextNode(mParticipante.get(i).getOrganizacion());
                  tfuentes=document.createTextNode(mParticipante.get(i).getFuentes());
                  tautores=document.createTextNode(mParticipante.get(i).getAutores());
                  ttype=document.createTextNode("participante");
                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  esUsuario.appendChild(tesUsuario);
                  esCliente.appendChild(tesCliente);
                  esDesarrollador.appendChild(tesDesarrollador);
                  rol.appendChild(trol);
                  organizacion.appendChild(torganizacion);
                  fuentes.appendChild(tfuentes);
                  autores.appendChild(tautores);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  Participante.appendChild(nombre);
                  Participante.appendChild(esUsuario);
                  Participante.appendChild(esCliente);
                  Participante.appendChild(esDesarrollador);
                  Participante.appendChild(rol);
                  Participante.appendChild(organizacion);
                  Participante.appendChild(fuentes);
                  Participante.appendChild(autores);
                  Participante.appendChild(type);

                  raiz.appendChild(Participante); //pegamos el elemento hijo a la raiZ

               }

            //FIN PARTICIPANTES

            //OBJETIVOS

            int numObj = this.mObjetivos.size();

               for (int i=0;i<numObj;i++)
               {
                  //Element Objetivo = document.createElement("objetivo");
                   Element Objetivo = document.createElement("Object");

                  Element nombre,autores,fuentes,comentarios,importancia,urgencia,estadoDes,estabilidad,descripcion,type;
                  Text tnombre,tautores,tfuentes,tcomentarios,timportancia,turgencia,testadoDes,testabilidad,tdescripcion,ttype;

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  importancia=document.createElement("importancia");
                  urgencia=document.createElement("urgencia");
                  estadoDes=document.createElement("estadoDes");
                  estabilidad=document.createElement("estabilidad");
                  descripcion=document.createElement("descripcion");
                  type=document.createElement("type");

                  //Introducimos el text

                  tnombre=document.createTextNode(mObjetivos.get(i).getNombre());
                  tautores=document.createTextNode(mObjetivos.get(i).getAutores());
                  tfuentes=document.createTextNode(mObjetivos.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mObjetivos.get(i).getComentarios());
                  timportancia=document.createTextNode(mObjetivos.get(i).getImportancia());
                  turgencia=document.createTextNode(mObjetivos.get(i).getUrgencia());
                  testadoDes=document.createTextNode(mObjetivos.get(i).getEstadoDes());
                  testabilidad=document.createTextNode(mObjetivos.get(i).getEstabilidad());
                  tdescripcion=document.createTextNode(mObjetivos.get(i).getDescripcion());
                  ttype=document.createTextNode("objetivo");

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  importancia.appendChild(timportancia);
                  urgencia.appendChild(turgencia);
                  estadoDes.appendChild(testadoDes);
                  estabilidad.appendChild(testabilidad);
                  descripcion.appendChild(tdescripcion);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  Objetivo.appendChild(nombre);
                  Objetivo.appendChild(autores);
                  Objetivo.appendChild(fuentes);
                  Objetivo.appendChild(comentarios);
                  Objetivo.appendChild(importancia);
                  Objetivo.appendChild(urgencia);
                  Objetivo.appendChild(estadoDes);
                  Objetivo.appendChild(estabilidad);
                  Objetivo.appendChild(descripcion);
                  Objetivo.appendChild(type);

                  raiz.appendChild(Objetivo); //pegamos el elemento hijo a la raiz

               }

            //FIN OBJETIVOS


            //REUNION
            
            int numReu = this.mReunion.size();
            
               for (int i=0;i<numReu;i++)
               {
                  //Element Reunion = document.createElement("reunion");
                   Element Reunion = document.createElement("Object");

                  Element nombre,autores,fuentes,comentarios,resultado,lugar,asistentes,type;
                  Text tnombre,tautores,tfuentes,tcomentarios,tresultado,tlugar,tasistentes,ttype;

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  comentarios=document.createElement("comentarios");
                  resultado=document.createElement("resultado");
                  lugar=document.createElement("lugar");
                  asistentes=document.createElement("asistentes");
                  type=document.createElement("type");

                  //Introducimos el text

                  tnombre=document.createTextNode(mReunion.get(i).getNombre());
                  tautores=document.createTextNode(mReunion.get(i).getAutores());
                  tfuentes=document.createTextNode(mReunion.get(i).getFuentes());
                  tcomentarios=document.createTextNode(mReunion.get(i).getComentario());
                  tresultado=document.createTextNode(mReunion.get(i).getResultados());
                  tlugar=document.createTextNode(mReunion.get(i).getLugar());
                  tasistentes=document.createTextNode(mReunion.get(i).getAsistentes());
                  ttype=document.createTextNode("reunion");

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  comentarios.appendChild(tcomentarios);
                  resultado.appendChild(tresultado);
                  lugar.appendChild(tlugar);
                  asistentes.appendChild(tasistentes);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  Reunion.appendChild(nombre);
                  Reunion.appendChild(autores);
                  Reunion.appendChild(fuentes);
                  Reunion.appendChild(comentarios);
                  Reunion.appendChild(resultado);
                  Reunion.appendChild(lugar);
                  Reunion.appendChild(asistentes);
                  Reunion.appendChild(type);

                  raiz.appendChild(Reunion); //pegamos el elemento hijo a la raiz

               }
            //FIN REUNION
            
            //INICIO SECCIONES
            int numSecc = this.mSeccion.size();

               for (int i=0;i<numSecc;i++)
               {
                  //Element Seccion = document.createElement("seccion");
                   Element Seccion = document.createElement("Object");

                  Element nombre,autores,fuentes,tipo,orden,comentarios,type;
                  Text tnombre,tautores,tfuentes,ttipo,torden,tcomentarios,ttype;

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  fuentes=document.createElement("fuentes");
                  tipo=document.createElement("tipo");
                  orden=document.createElement("orden");
                  comentarios=document.createElement("comentarios");
                  type=document.createElement("type");


                  //Introducimos el text

                  tnombre=document.createTextNode(mSeccion.get(i).getNombre());
                  tautores=document.createTextNode(mSeccion.get(i).getAutores());
                  tfuentes=document.createTextNode(mSeccion.get(i).getFuentes());
                  ttipo=document.createTextNode(mSeccion.get(i).getTipo());
                  if(mSeccion.get(i).getOrden()==true)
                  {
                    torden=document.createTextNode("SI");
                  }
                  else
                  {
                      torden=document.createTextNode("NO");
                  }
                  tcomentarios=document.createTextNode(mSeccion.get(i).getComentarios());
                  ttype=document.createTextNode("seccion");

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  autores.appendChild(tautores);
                  fuentes.appendChild(tfuentes);
                  tipo.appendChild(ttipo);
                  orden.appendChild(torden);
                  comentarios.appendChild(tcomentarios);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  Seccion.appendChild(nombre);
                  Seccion.appendChild(autores);
                  Seccion.appendChild(fuentes);
                  Seccion.appendChild(tipo);
                  Seccion.appendChild(orden);
                  Seccion.appendChild(comentarios);
                  Seccion.appendChild(type);

                  raiz.appendChild(Seccion); //pegamos el elemento hijo a la raiz

               }
            //FIN SECCIONES

            //INICIO PARAFOS
            int numParr = this.mParrafo.size();

               for (int i=0;i<numParr;i++)
               {
                  //Element Parrafo = document.createElement("parrafo");
                  Element Parrafo = document.createElement("Object");

                  Element texto,type;
                  Text ttexto,ttype;

                  //creamos cada atributo con su nombre
                  texto=document.createElement("texto");
                  type=document.createElement("type");

                  //Introducimos el text

                  ttexto=document.createTextNode(mParrafo.get(i).getTexto());
                  ttype=document.createTextNode("parrafo");

                  //enlazamos cada texto con su atributo
                  texto.appendChild(ttexto);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  Parrafo.appendChild(texto);
                  Parrafo.appendChild(type);

                  raiz.appendChild(Parrafo); //pegamos el elemento hijo a la raiz

               }
            //FIN PARRAFOS

            //FICHERO GRAFICO
            int numFG = this.mFicheroGrafico.size();

               for (int i=0;i<numFG;i++)
               {
                  //Element FicheroGrafico = document.createElement("FicheroGrafico");
                   Element FicheroGrafico = document.createElement("Object");

                  Element nombre,ruta,type;
                  Text tnombre,truta,ttype;

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  ruta=document.createElement("ruta");
                 type=document.createElement("type");
                  
                  //Introducimos el text

                  tnombre=document.createTextNode(mFicheroGrafico.get(i).getNombre());
                  truta=document.createTextNode(mFicheroGrafico.get(i).getFichero().getPath());
                  ttype=document.createTextNode("FicheroGrafico");
                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  ruta.appendChild(truta);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  FicheroGrafico.appendChild(nombre);
                  FicheroGrafico.appendChild(ruta);
                  FicheroGrafico.appendChild(type);

                  raiz.appendChild(FicheroGrafico); //pegamos el elemento hijo a la raiz

               }

            //MATRIZ
            int numMat = this.mRastreabilidad.size();

               for (int i=0;i<numMat;i++)
               {
                  //Element FicheroGrafico = document.createElement("FicheroGrafico");
                   Element Matriz = document.createElement("Object");

                  Element nombre,autores,type;
                  Text tnombre,tautores,ttype;

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  type=document.createElement("type");

                  //Introducimos el text

                  tnombre=document.createTextNode(mRastreabilidad.get(i).getNombre());
                  ttype=document.createTextNode("Matriz");
                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  Matriz.appendChild(nombre);
                  Matriz.appendChild(type);

                  ArrayList<String> fila=mRastreabilidad.get(i).getFilas();
                  ArrayList<String> columna=mRastreabilidad.get(i).getColumnas();

                  for(int j=0;j<fila.size();j++)
                  {
                      String nomFila=fila.get(j);
                      String nombreA;

                      Element Fila = document.createElement("fila");
                      ArrayList <CasodeUso>aFilaCU=new ArrayList();
                      ArrayList <FicheroGrafico>aFilaFG=new ArrayList();
                      ArrayList <Objetivos>aFilaO=new ArrayList();
                      ArrayList <Parrafo>aFilaP=new ArrayList();
                      ArrayList <ReqInformacion>aFilaRI=new ArrayList();
                      ArrayList <ReqFuncional>aFilaRF=new ArrayList();
                      ArrayList <ReqNoFuncional>aFilaRNF=new ArrayList();
                      ArrayList <ReqRestriccion>aFilaRR=new ArrayList();
                      if(nomFila.equals("Casos de Uso"))
                      {
                          aFilaCU=this.getCasodeUso();
                          for(int k=0;k<aFilaCU.size();k++)
                          {
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaCU.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);
                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Fichero Grafico"))
                      {
                          aFilaFG=this.getmFicheroGrafico();
                          for(int k=0;k<aFilaFG.size();k++)
                          {
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaFG.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);
                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Objetivo"))
                      {
                          aFilaO=this.getmObjetivos();
                          for(int k=0;k<aFilaO.size();k++)
                          {
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaO.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);
                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Parrafo"))
                      {
                          aFilaP=this.getmParrafo();
                          for(int k=0;k<aFilaP.size();k++)
                          {
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaP.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);
                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Requisito de Informacion"))
                      {
                          aFilaRI=this.getmReqInfo();
                          for(int k=0;k<aFilaRI.size();k++)
                          {
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaRI.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);
                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Requisito Funcional"))
                      {
                          aFilaRF=this.getmReqFunc();
                          for(int k=0;k<aFilaRF.size();k++)
                          {
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaRF.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);
                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Requisito no Funcional"))
                      {
                          aFilaRNF=this.getmReqNoFunc();
                          for(int k=0;k<aFilaRNF.size();k++)
                          {
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaRNF.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);
                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Requisito Restriccional"))
                      {
                          aFilaRR=this.getmReqRest();
                          for(int k=0;k<aFilaRR.size();k++)
                          {
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaRR.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);
                              Matriz.appendChild(Fila);
                          }
                      }
                      
//                      
                  }
                  for(int j=0;j<columna.size();j++)
                  {
                      String nomColum=columna.get(j);

                      Element Columna = document.createElement("columna");
                      ArrayList <CasodeUso>aColumCU=new ArrayList();
                      ArrayList <FicheroGrafico>aColumFG=new ArrayList();
                      ArrayList <Objetivos>aColumO=new ArrayList();
                      ArrayList <Parrafo>aColumP=new ArrayList();
                      ArrayList <ReqInformacion>aColumRI=new ArrayList();
                      ArrayList <ReqFuncional>aColumRF=new ArrayList();
                      ArrayList <ReqNoFuncional>aColumRNF=new ArrayList();
                      ArrayList <ReqRestriccion>aColumRR=new ArrayList();
                      if(nomColum.equals("Casos de Uso"))
                      {
                          aColumCU=this.getCasodeUso();
                          for(int k=0;k<aColumCU.size();k++)
                          {
                              Element nombreColum=document.createElement("nombreColum");
                              Text tnombreColum=document.createTextNode(aColumCU.get(k).getNombre());
                              nombreColum.appendChild(tnombreColum);
                              Columna.appendChild(nombreColum);
                              Matriz.appendChild(Columna);
                          }
                      }
                      if(nomColum.equals("Fichero Grafico"))
                      {
                          aColumFG=this.getmFicheroGrafico();
                          for(int k=0;k<aColumFG.size();k++)
                          {
                              Element nombreColum=document.createElement("nombreColum");
                              Text tnombreColum=document.createTextNode(aColumFG.get(k).getNombre());
                              nombreColum.appendChild(tnombreColum);
                              Columna.appendChild(nombreColum);
                              Matriz.appendChild(Columna);
                          }
                      }
                      if(nomColum.equals("Objetivo"))
                      {
                          aColumO=this.getmObjetivos();
                          for(int k=0;k<aColumO.size();k++)
                          {
                              Element nombreColum=document.createElement("nombreColum");
                              Text tnombreColum=document.createTextNode(aColumO.get(k).getNombre());
                              nombreColum.appendChild(tnombreColum);
                              Columna.appendChild(nombreColum);
                              Matriz.appendChild(Columna);
                          }
                      }
                      if(nomColum.equals("Parrafo"))
                      {
                          aColumP=this.getmParrafo();
                          for(int k=0;k<aColumP.size();k++)
                          {
                              Element nombreColum=document.createElement("nombreColum");
                              Text tnombreColum=document.createTextNode(aColumP.get(k).getNombre());
                              nombreColum.appendChild(tnombreColum);
                              Columna.appendChild(nombreColum);
                              Matriz.appendChild(Columna);
                          }
                      }
                      if(nomColum.equals("Requisito de Informacion"))
                      {
                          aColumRI=this.getmReqInfo();
                          for(int k=0;k<aColumRI.size();k++)
                          {
                              Element nombreColum=document.createElement("nombreColum");
                              Text tnombreColum=document.createTextNode(aColumRI.get(k).getNombre());
                              nombreColum.appendChild(tnombreColum);
                              Columna.appendChild(nombreColum);
                              Matriz.appendChild(Columna);;
                          }
                      }
                      if(nomColum.equals("Requisito Funcional"))
                      {
                          aColumRF=this.getmReqFunc();
                          for(int k=0;k<aColumRF.size();k++)
                          {
                              Element nombreColum=document.createElement("nombreColum");
                              Text tnombreColum=document.createTextNode(aColumRF.get(k).getNombre());
                              nombreColum.appendChild(tnombreColum);
                              Columna.appendChild(nombreColum);
                              Matriz.appendChild(Columna);
                          }
                      }
                      if(nomColum.equals("Requisito no Funcional"))
                      {
                          aColumRNF=this.getmReqNoFunc();
                          for(int k=0;k<aColumRNF.size();k++)
                          {
                              Element nombreColum=document.createElement("nombreColum");
                              Text tnombreColum=document.createTextNode(aColumRNF.get(k).getNombre());
                              nombreColum.appendChild(tnombreColum);
                              Columna.appendChild(nombreColum);
                              Matriz.appendChild(Columna);
                          }
                      }
                      if(nomColum.equals("Requisito Restriccional"))
                      {
                          aColumRR=this.getmReqRest();
                          for(int k=0;k<aColumRR.size();k++)
                          {
                              Element nombreColum=document.createElement("nombreColum");
                              Text tnombreColum=document.createTextNode(aColumRR.get(k).getNombre());
                              nombreColum.appendChild(tnombreColum);
                              Columna.appendChild(nombreColum);
                              Matriz.appendChild(Columna);
                          }
                      }
                  }
                  raiz.appendChild(Matriz); //pegamos el elemento hijo a la raiz

               }
                       

            //guardamos en resultado.xml
            Source source = new DOMSource(document);
            Result result = new StreamResult(new java.io.File("resultado.xml")); //nombre del archivo
            Result console= new StreamResult(System.out);
            Transformer transformer = TransformerFactory.newInstance().newTransformer();
            transformer.transform(source, result);
            transformer.transform(source, console);
        }
        catch(Exception e){
            System.err.println("Error: "+e);
        }

    }


    private void mostrarMensaje(String mensaje) {
                JOptionPane.showMessageDialog(null, mensaje);
        }

        public ArrayList<Participante> getmParticipante() {
        return mParticipante;
    }

    /**
     * @param mParticipante the mParticipante to set
     */
    public void setmParticipante(ArrayList<Participante> mParticipante) {
        this.mParticipante = mParticipante;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }

    public Participante nuevoParticipante(String nombre,
                           boolean esUsuario,
                           boolean esCliente,
                           boolean esDesarrollador,
                           String rol,
                           String organizacion,
                           String autores,
                           String fuentes)
    {
        Participante aux = new Participante();
        aux.setNombre(nombre);
        aux.setEsUsuario(esUsuario);
        aux.setEsCliente(esCliente);
        aux.setEsDesarrollador(esDesarrollador);
        aux.setRol(rol);
        aux.setOrganizacion(organizacion);
        aux.setAutores(autores);
        aux.setFuentes(fuentes);
        this.getmParticipante().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }

    /**
     * @return the mObjetivos
     */
    public ArrayList<Objetivos> getmObjetivos() {
        return mObjetivos;
    }

    /**
     * @param mObjetivos the mObjetivos to set
     */
    public void setmObjetivos(ArrayList<Objetivos> mObjetivos) {
        this.mObjetivos = mObjetivos;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }

    public Objetivos nuevoObjetivo(String nombre,
                                       String autores,
                                       String Fuentes,
                                       String descripcion,
                                       String comentarios,
                                       String importancia,
                                       String urgencia,
                                       String estadoDes,
                                       String estabilidad)
    {
        Objetivos aux = new Objetivos();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setDescripcion(descripcion);
        aux.setComentarios(comentarios);
        aux.setImportancia(importancia);
        aux.setUrgencia(urgencia);
        aux.setEstadoDes(estadoDes);
        aux.setEstabilidad(estabilidad);
        this.getmObjetivos().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }

    /**
     * @return the mReunion
     */
    public ArrayList<Reunion> getmReunion() {
        return mReunion;
    }

    /**
     * @param mReunion the mReunion to set
     */
    public void setmReunion(ArrayList<Reunion> mReunion) {
        this.mReunion = mReunion;
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
    }


    public Reunion nuevoReunion(String nombre,
                                       String autores,
                                       String Fuentes,
                                       String resultados,
                                       String lugar,
                                       String comentario,
                                       String asistentes)
    {
        Reunion aux = new Reunion();
        aux.setNombre(nombre);
        aux.setAutores(autores);
        aux.setFuentes(Fuentes);
        aux.setResultados(resultados);
        aux.setLugar(lugar);
        aux.setComentario(comentario);
        aux.setAsistentes(asistentes);
        this.getmReunion().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }

    
    
    ////////////       SECCION
    public ArrayList<Seccion> getmSeccion() {
        return mSeccion;
    }

    public void setmSeccion(ArrayList<Seccion> mSeccion) {
        this.mSeccion = mSeccion;
        this.setChanged();
        this.notifyObservers();
    }
    public Seccion nuevaSeccion (String nombre, String autores, String fuentes, String tipo, boolean orden, String comentarios) {
        //// Creo la instancia
        Seccion auxSeccion=new Seccion();
        //// Asigno los valores a los atributos
        auxSeccion.setNombre(nombre);
        auxSeccion.setAutores(autores);
        auxSeccion.setFuentes(fuentes);
        auxSeccion.setTipo(tipo);
        auxSeccion.setOrden(orden);
        auxSeccion.setComentarios(comentarios);
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmSeccion().add(auxSeccion);
        //Notificamos que ha habido un cambio
        this.setChanged();
        this.notifyObservers();

        return auxSeccion;
    }
    //////      FIN DE SECCION
    
    public ArrayList<Parrafo> getmParrafo() {
        return mParrafo;
    }

    
    public void setmParrafo(ArrayList<Parrafo> mParrafo) {
        this.mParrafo = mParrafo;
    }
    public Parrafo nuevoParrafo (String nombre, String autores, String fuentes, String texto, boolean esElementoGlosario, String comentarios) {
        //// Creo la instancia
        Parrafo auxParrafo=new Parrafo();
        //// Asigno los valores a los atributos
        auxParrafo.setNombre(nombre);
        auxParrafo.setAutores(autores);
        auxParrafo.setFuentes(fuentes);
        auxParrafo.setTexto(texto);
        auxParrafo.setEsElementoGlosario(esElementoGlosario);
        auxParrafo.setComentarios(comentarios);
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmParrafo().add(auxParrafo);
        //Notificamos que ha habido un cambio
        this.setChanged();
        this.notifyObservers();

        return auxParrafo;
    }

    /////     FICHERO GRAFICO
    public ArrayList<FicheroGrafico> getmFicheroGrafico() {
        return mFicheroGrafico;
    }

    public void setmFicheroGrafico(ArrayList<FicheroGrafico> mFicheroGrafico) {
        this.mFicheroGrafico = mFicheroGrafico;
    }
    public FicheroGrafico nuevoFicheroGrafico (String nombre, String autores, String fuentes, File fichero, String comentarios) {
        //// Creo la instancia
        FicheroGrafico auxFicheroGrafico=new FicheroGrafico();
        //// Asigno los valores a los atributos
        auxFicheroGrafico.setNombre(nombre);
        auxFicheroGrafico.setAutores(autores);
        auxFicheroGrafico.setFuentes(fuentes);
        auxFicheroGrafico.setFichero(fichero);
        auxFicheroGrafico.setComentarios(comentarios);
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmFicheroGrafico().add(auxFicheroGrafico);
        //Notificamos que ha habido un cambio
        this.setChanged();
        this.notifyObservers();

        return auxFicheroGrafico;
    }

    public ArrayList<Rastreabilidad> getmRastreabilidad() {
        return mRastreabilidad;
    }

    /**
     * @param mRastreabilidad the mRastreabilidad to set
     */
    public void setmRastreabilidad(ArrayList<Rastreabilidad> mRastreabilidad) {
        this.mRastreabilidad = mRastreabilidad;
        //Notificamos que ha habido un cambio
        this.setChanged();
        this.notifyObservers();
    }
    public Rastreabilidad nuevoRastreabilidad(String Nom, String Aut, String Fuent, String Comment, ArrayList<String> fi, ArrayList<String> col)
    {
        Rastreabilidad aux = new Rastreabilidad();
        aux.setNombre(Nom);
        aux.setAutores(Aut);
        aux.setFuentes(Fuent);
        aux.setComentario(Comment);
        aux.setFilas(fi);
        aux.setColumnas(col);
        this.getmRastreabilidad().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }

    private void mostrarmensaje(int mensaje) {
         JOptionPane.showMessageDialog(null,mensaje);
    }
}

    

