package modelo;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
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;

/**
 * Clase Documento Req, Clase que crea un documento de requisito
 * @author MW3 Software
 */

// <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>
    /**
     * Lista de Caso de Uso que tiene el Documento de Requisitos
     */
    private ArrayList<CasodeUso> mCasodeUso = new ArrayList();
    /**
     * Lista de Requisitos Funcionales que tiene el Documento de Requisitos
     */
    private ArrayList<ReqFuncional> mReqFunc = new ArrayList();
    /**
     * Lista de Requisitos no funcionales que tiene el Documento de Requisitos
     */
    private ArrayList<ReqNoFuncional> mReqNoFunc = new ArrayList();
    /**
     * Lista de Requisitos de Informacion que tiene el Documento de Requisitos 
     */
    private ArrayList<ReqInformacion> mReqInfo = new ArrayList();
    /**
     * Lista de Requsitos de Restriccion que tiene el Documento de Requisitos 
     */
    private ArrayList<ReqRestriccion> mReqRest = new ArrayList();
    /**
     * Lista de Participantes que tiene el Documento de Requisitos
     */
    private ArrayList<Participante> mParticipante = new ArrayList();
    /**
     * Lista de Objetivos que tiene el Documento de Requisitos
     */
    private ArrayList<Objetivos> mObjetivos = new ArrayList();
    /**
     * Lista de Reunion que tiene el Documento de Requisitos
     */
    private ArrayList<Reunion> mReunion = new ArrayList();
    /**
     * Lista de Secciones que tiene el Documento de Requisitos
     */
    private ArrayList<Seccion> mSeccion = new ArrayList();
    /**
     * Lista de Parrafos que tiene el Documento de Requisitos
     */
    private ArrayList<Parrafo> mParrafo = new ArrayList();
    /**
     * Lista de Ficheros Graficos que tiene el Documento de Requisitos
     */
    private ArrayList<FicheroGrafico> mFicheroGrafico = new ArrayList();
    /**
     * Lista de Matriz de Rastreabilidad que tiene el Documento de Requisitos
     */
    private ArrayList<Rastreabilidad> mRastreabilidad = new ArrayList();
    /**
     * Lista de Organizaciones que tiene el Documento de Requisitos 
     */
    private ArrayList<Organizacion> mOrganizacion = 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>


    /**
     * metodo que crea un Caso de Uso
     * @param nombreCU
     * @param esAbstracto
     * @param eventoActivacion
     * @param frecuencia
     * @param unidadFrecuencia
     * @param precondicion
     * @param postcondicion
     * @param importancia
     * @param urgencia
     * @param estadodeDesarrollo
     * @param estabilidad
     * @param Rastreable
     * @return devuelve el caso de uso creado
     */
    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, ArrayList<String> Rastreable) {

        //// 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);
        auxCU.setDestinoRastreable(Rastreable);
        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getCasodeUso().add(auxCU);
        //Guardamos el CU en la base de datos
        guardar(auxCU);
        //Notificamos que ha habido un cambio
        this.setChanged();
         this.notifyObservers();
        return auxCU;
    }
   
    /**
     * metodo que crea un requisito funcional
     * @param nombre
     * @param autores
     * @param Fuentes
     * @param comentarios
     * @param importancia
     * @param urgencia
     * @param estadoDes
     * @param estabilidad
     * @param descripcion
     * @param Rastreable
     * @return devuelve el requisito funcional creado
     */
    public ReqFuncional nuevoReqFunc(String nombre,
                           String autores,
                           String Fuentes,
                           String comentarios,
                           String importancia,
                           String urgencia,
                           String estadoDes,
                           String estabilidad,
                           String descripcion, ArrayList<String> Rastreable)
    {
        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);
        aux.setDestinoRastreable(Rastreable);
        this.getmReqFunc().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }

    /**
     * metodo que crea un requisito no funcuonal
     * @param nombre
     * @param autores
     * @param Fuentes
     * @param comentarios
     * @param importancia
     * @param urgencia
     * @param estadoDes
     * @param estabilidad
     * @param descripcion
     * @param Rastreable
     * @return devuelve el requisito no funcional creado
     */
    public ReqNoFuncional nuevoReqNoFunc(String nombre,
                           String autores,
                           String Fuentes,
                           String comentarios,
                           String importancia,
                           String urgencia,
                           String estadoDes,
                           String estabilidad,
                           String descripcion, ArrayList<String> Rastreable)
    {
        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);
        aux.setDestinoRastreable(Rastreable);
        this.getmReqNoFunc().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }

    /**
     * Metodo que crea n requisito de Restriccion
     * @param nombre
     * @param autores
     * @param Fuentes
     * @param comentarios
     * @param importancia
     * @param urgencia
     * @param estadoDes
     * @param estabilidad
     * @param descripcion
     * @param Rastreable
     * @return devuelve el requisitos de restriccion creado
     */
    public ReqRestriccion nuevoReqRest(String nombre,
                           String autores,
                           String Fuentes,
                           String comentarios,
                           String importancia,
                           String urgencia,
                           String estadoDes,
                           String estabilidad,
                           String descripcion, ArrayList<String> Rastreable)
    {
        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);
        aux.setDestinoRastreable(Rastreable);
        this.getmReqRest().add(aux);
        //Notificamos que ha habido un cambio
         this.setChanged();
         this.notifyObservers();
        return aux;
    }

    /**
     * Metodo que crea un requisito de informacion
     * @param nombre
     * @param autores
     * @param Fuentes
     * @param importancia
     * @param urgencia
     * @param estadoDes
     * @param estabilidad
     * @param comentarios
     * @param conceptoRelevante
     * @param tiempoMax
     * @param tiempoMed
     * @param unifreqmax
     * @param unifreqmed
     * @param numOcurrencias
     * @param numMedio
     * @param Rastreable
     * @return devuelve el Requisito de informacion creado
     */
    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, ArrayList<String> Rastreable)
    {
        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);
        aux.setDestinoRastreable(Rastreable);
        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();
    }

    /**
     * Metodo que crea los elementos necesarios para que el fichero XSL muestre los datos
     */
    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
                  List<PasoCU> pasos = mCasodeUso.get(i).getPasoCU();
                  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);

                      List<ExcepcionCU> excepciones = mCasodeUso.get(i).getPasoCU().get(j).getExcepcionCU();
                      for(int k=0;k<excepciones.size();k++)
                      {
                          Element Excepcion = document.createElement("Excepcion");

                          Element numExc=document.createElement("numero");
                          //String numExcstring=String.valueOf(excepciones.get(k).getNumeroExcep());
                          String numExcstring=String.valueOf(excepciones.get(k).getPaso());
                          Text tnumeroexc=document.createTextNode(numExcstring);
                          numExc.appendChild(tnumeroexc);
                          Excepcion.appendChild(numExc);

                          Element descripExc=document.createElement("descripcion");
                          Text tdescripcionExc=document.createTextNode(excepciones.get(k).getDescripcionExcep());
                          descripExc.appendChild(tdescripcionExc);
                          Excepcion.appendChild(descripExc);

                          Paso.appendChild(Excepcion);

                      }
                      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


            //ORGANIZACION

            int numOrg = this.mOrganizacion.size();

               for (int i=0;i<numOrg;i++)
               {
                  Element Organizacion = document.createElement("Object");

                  Element nombre,autores,fuentes,direccion,telefono,fax,comentarios,type;
                  Text tnombre,tautores,tfuentes,tdireccion,ttelefono,tfax,tcomentarios,ttype;

                  //creamos cada atributo con su nombre
                  nombre=document.createElement("nombre");
                  autores=document.createElement("autores");
                  direccion=document.createElement("direccion");
                  telefono=document.createElement("telefono");
                  fax=document.createElement("fax");
                  comentarios=document.createElement("comentarios");
                  fuentes=document.createElement("fuentes");
                  type=document.createElement("type");

                  //Introducimos el text

                  tnombre=document.createTextNode(mOrganizacion.get(i).getNombre());
                  tfuentes=document.createTextNode(mOrganizacion.get(i).getFuentes());
                  tautores=document.createTextNode(mOrganizacion.get(i).getAutores());
                  tdireccion=document.createTextNode(mOrganizacion.get(i).getDireccion());
                  ttelefono=document.createTextNode(String.valueOf(mOrganizacion.get(i).getTelefono()));
                  tfax=document.createTextNode(String.valueOf(mOrganizacion.get(i).getFax()));
                  tcomentarios=document.createTextNode(mOrganizacion.get(i).getComentarios());
                  ttype=document.createTextNode("organizacion");

                  //enlazamos cada texto con su atributo
                  nombre.appendChild(tnombre);
                  fuentes.appendChild(tfuentes);
                  autores.appendChild(tautores);
                  direccion.appendChild(tdireccion);
                  telefono.appendChild(ttelefono);
                  fax.appendChild(tfax);
                  comentarios.appendChild(tcomentarios);
                  type.appendChild(ttype);

                  //enlazamos cada atributo a su caso de uso
                  Organizacion.appendChild(nombre);
                  Organizacion.appendChild(fuentes);
                  Organizacion.appendChild(autores);
                  Organizacion.appendChild(direccion);
                  Organizacion.appendChild(telefono);
                  Organizacion.appendChild(fax);
                  Organizacion.appendChild(comentarios);
                  Organizacion.appendChild(type);

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

               }

            //FIN ORGANIZACION


            //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);
                  
                  //PASOS
                  ArrayList<Objetivos> subObjetivos = mObjetivos.get(i).getmSubObjetivos();
                  for(int j=0;j<subObjetivos.size();j++)
                  {
                      Element SubObjetivo = document.createElement("subObjetivo");
                      
                      Element nombreSO=document.createElement("nombreSO");
                      Text tnombreSO=document.createTextNode(subObjetivos.get(j).getNombre());
                      
                      Element descripcionSO=document.createElement("descripcionSO");
                      Text tdescripcionSO=document.createTextNode(subObjetivos.get(j).getDescripcion());

                      nombreSO.appendChild(tnombreSO);
                      descripcionSO.appendChild(tdescripcionSO);

                      SubObjetivo.appendChild(nombreSO);
                      SubObjetivo.appendChild(descripcionSO);

                      Objetivo.appendChild(SubObjetivo);
                      
                  }
                  

                  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 PARRAFOS
            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

               }
            //FIN DE FICHERO GRAFICO

            //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 Fila = document.createElement("fila");
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaCU.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);
                              
                              //Creamos un elemento Destino Rastreable por cada elemento del array destinoRastreable de cada fila
                              //y se lo incluimos
                              ArrayList <String>aRastrFilaCU=new ArrayList();
                              aRastrFilaCU=aFilaCU.get(k).getdestinoRastreable();
                              for (int R=0;R<aRastrFilaCU.size();R++)
                              {
                                  Element DestRastr=document.createElement("destRastr");
                                  Element nomDestRastr=document.createElement("nomDestRastr");
                                  Text tnomDestRastr=document.createTextNode(aRastrFilaCU.get(R));
                                  nomDestRastr.appendChild(tnomDestRastr);
                                  DestRastr.appendChild(nomDestRastr);
                                  Fila.appendChild(DestRastr);
                              }
                              
                              
                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Fichero Grafico"))
                      {
                          aFilaFG=this.getmFicheroGrafico();
                          for(int k=0;k<aFilaFG.size();k++)
                          {
                              Element Fila = document.createElement("fila");
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaFG.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);

                              //Creamos un elemento Destino Rastreable por cada elemento del array destinoRastreable de cada fila
                              //y se lo incluimos
                              ArrayList <String>aRastrFilaFG=new ArrayList();
                              aRastrFilaFG=aFilaFG.get(k).getDestinoRastreable();
                              for (int R=0;R<aRastrFilaFG.size();R++)
                              {
                                  Element DestRastr=document.createElement("destRastr");
                                  Element nomDestRastr=document.createElement("nomDestRastr");
                                  Text tnomDestRastr=document.createTextNode(aRastrFilaFG.get(R));
                                  nomDestRastr.appendChild(tnomDestRastr);
                                  DestRastr.appendChild(nomDestRastr);
                                  Fila.appendChild(DestRastr);
                              }

                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Objetivo"))
                      {
                          aFilaO=this.getmObjetivos();
                          for(int k=0;k<aFilaO.size();k++)
                          {
                              Element Fila = document.createElement("fila");
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaO.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);

                              //Creamos un elemento Destino Rastreable por cada elemento del array destinoRastreable de cada fila
                              //y se lo incluimos
                              ArrayList <String>aRastrFilaO=new ArrayList();
                              aRastrFilaO=aFilaO.get(k).getDestinoRastreable();
                              for (int R=0;R<aRastrFilaO.size();R++)
                              {
                                  Element DestRastr=document.createElement("destRastr");
                                  Element nomDestRastr=document.createElement("nomDestRastr");
                                  Text tnomDestRastr=document.createTextNode(aRastrFilaO.get(R));
                                  nomDestRastr.appendChild(tnomDestRastr);
                                  DestRastr.appendChild(nomDestRastr);
                                  Fila.appendChild(DestRastr);
                              }

                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Parrafo"))
                      {
                          aFilaP=this.getmParrafo();
                          for(int k=0;k<aFilaP.size();k++)
                          {
                              Element Fila = document.createElement("fila");
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaP.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);

                              //Creamos un elemento Destino Rastreable por cada elemento del array destinoRastreable de cada fila
                              //y se lo incluimos
                              ArrayList <String>aRastrFilaP=new ArrayList();
                              aRastrFilaP=aFilaP.get(k).getDestinoRastreable();
                              for (int R=0;R<aRastrFilaP.size();R++)
                              {
                                  Element DestRastr=document.createElement("destRastr");
                                  Element nomDestRastr=document.createElement("nomDestRastr");
                                  Text tnomDestRastr=document.createTextNode(aRastrFilaP.get(R));
                                  nomDestRastr.appendChild(tnomDestRastr);
                                  DestRastr.appendChild(nomDestRastr);
                                  Fila.appendChild(DestRastr);
                              }

                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Requisito de Informacion"))
                      {
                          aFilaRI=this.getmReqInfo();
                          for(int k=0;k<aFilaRI.size();k++)
                          {
                              Element Fila = document.createElement("fila");
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaRI.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);

                              //Creamos un elemento Destino Rastreable por cada elemento del array destinoRastreable de cada fila
                              //y se lo incluimos
                              ArrayList <String>aRastrFilaRI=new ArrayList();
                              aRastrFilaRI=aFilaRI.get(k).getDestinoRastreable();
                              for (int R=0;R<aRastrFilaRI.size();R++)
                              {
                                  Element DestRastr=document.createElement("destRastr");
                                  Element nomDestRastr=document.createElement("nomDestRastr");
                                  Text tnomDestRastr=document.createTextNode(aRastrFilaRI.get(R));
                                  nomDestRastr.appendChild(tnomDestRastr);
                                  DestRastr.appendChild(nomDestRastr);
                                  Fila.appendChild(DestRastr);
                              }

                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Requisito Funcional"))
                      {

                          aFilaRF=this.getmReqFunc();
                          for(int k=0;k<aFilaRF.size();k++)
                          {
                              Element Fila = document.createElement("fila");
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaRF.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);

                              //Creamos un elemento Destino Rastreable por cada elemento del array destinoRastreable de cada fila
                              //y se lo incluimos
                              ArrayList <String>aRastrFilaRF=new ArrayList();
                              aRastrFilaRF=aFilaRF.get(k).getDestinoRastreable();
                              for (int R=0;R<aRastrFilaRF.size();R++)
                              {
                                  Element DestRastr=document.createElement("destRastr");
                                  Element nomDestRastr=document.createElement("nomDestRastr");
                                  Text tnomDestRastr=document.createTextNode(aRastrFilaRF.get(R));
                                  nomDestRastr.appendChild(tnomDestRastr);
                                  DestRastr.appendChild(nomDestRastr);
                                  Fila.appendChild(DestRastr);
                              }

                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Requisito no Funcional"))
                      {
                          aFilaRNF=this.getmReqNoFunc();
                          for(int k=0;k<aFilaRNF.size();k++)
                          {
                              Element Fila = document.createElement("fila");
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaRNF.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);

                              //Creamos un elemento Destino Rastreable por cada elemento del array destinoRastreable de cada fila
                              //y se lo incluimos
                              ArrayList <String>aRastrFilaRNF=new ArrayList();
                              aRastrFilaRNF=aFilaRNF.get(k).getDestinoRastreable();
                              for (int R=0;R<aRastrFilaRNF.size();R++)
                              {
                                  Element DestRastr=document.createElement("destRastr");
                                  Element nomDestRastr=document.createElement("nomDestRastr");
                                  Text tnomDestRastr=document.createTextNode(aRastrFilaRNF.get(R));
                                  nomDestRastr.appendChild(tnomDestRastr);
                                  DestRastr.appendChild(nomDestRastr);
                                  Fila.appendChild(DestRastr);
                              }
                              Matriz.appendChild(Fila);
                          }
                      }
                      if(nomFila.equals("Requisito Restriccional"))
                      {
                          aFilaRR=this.getmReqRest();
                          for(int k=0;k<aFilaRR.size();k++)
                          {
                              Element Fila = document.createElement("fila");
                              Element nombreFila=document.createElement("nombreFila");
                              Text tnombreFila=document.createTextNode(aFilaRR.get(k).getNombre());
                              nombreFila.appendChild(tnombreFila);
                              Fila.appendChild(nombreFila);

                              //Creamos un elemento Destino Rastreable por cada elemento del array destinoRastreable de cada fila
                              //y se lo incluimos
                              ArrayList <String>aRastrFilaRR=new ArrayList();
                              aRastrFilaRR=aFilaRR.get(k).getDestinoRastreable();
                              for (int R=0;R<aRastrFilaRR.size();R++)
                              {
                                  Element DestRastr=document.createElement("destRastr");
                                  Element nomDestRastr=document.createElement("nomDestRastr");
                                  Text tnomDestRastr=document.createTextNode(aRastrFilaRR.get(R));
                                  nomDestRastr.appendChild(tnomDestRastr);
                                  DestRastr.appendChild(nomDestRastr);
                                  Fila.appendChild(DestRastr);
                              }

                              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 Columna = document.createElement("columna");
                              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 Columna = document.createElement("columna");
                              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 Columna = document.createElement("columna");
                              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 Columna = document.createElement("columna");
                              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 Columna = document.createElement("columna");
                              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 Columna = document.createElement("columna");
                              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 Columna = document.createElement("columna");
                              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 Columna = document.createElement("columna");
                              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);
        }

    }


    /**
     * Muestra un mensaje por un panel
     * @param mensaje Mensaje a mostrar
     */
    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();
    }


    /**
     * metodo que crea un participante
     * @param nombre
     * @param esUsuario
     * @param esCliente
     * @param esDesarrollador
     * @param rol
     * @param organizacion
     * @param autores
     * @param fuentes
     * @return devuelve el participante creado
     */
    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();
    }

    /**
     * Metodo que crea un objetivo
     * @param nombre
     * @param autores
     * @param Fuentes
     * @param descripcion
     * @param comentarios
     * @param importancia
     * @param urgencia
     * @param estadoDes
     * @param estabilidad
     * @param Rastreable
     * @return devuelve el objetivo creado
     */
    public Objetivos nuevoObjetivo(String nombre,
                                       String autores,
                                       String Fuentes,
                                       String descripcion,
                                       String comentarios,
                                       String importancia,
                                       String urgencia,
                                       String estadoDes,
                                       String estabilidad, ArrayList<String> Rastreable)
    {
        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);
        aux.setDestinoRastreable(Rastreable);
        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();
    }

    /**
     * Metodo que crea una reunion
     * @param nombre
     * @param autores
     * @param Fuentes
     * @param resultados
     * @param lugar
     * @param comentario
     * @param asistentes
     * @return devuelve la reunion creada
     */
    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();
    }

   /**
    * Metodo que crea una Seccion
    * @param nombre
    * @param autores
    * @param fuentes
    * @param tipo
    * @param orden
    * @param comentarios
    * @return devuelve la seccion Creada
    */
    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;
    }

    /**
     * Metodo que Crea un parrafo
     * @param nombre
     * @param autores
     * @param fuentes
     * @param texto
     * @param esElementoGlosario
     * @param comentarios
     * @param Rastreable
     * @return Devuelve el parrafo creado
     */
    public Parrafo nuevoParrafo (String nombre, String autores, String fuentes, String texto, boolean esElementoGlosario, String comentarios, ArrayList<String> Rastreable) {
        //// 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);
        auxParrafo.setDestinoRastreable(Rastreable);
        //// 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;
    }

    /**
     * metodo que crea un fichero grafico
     * @param nombre
     * @param autores
     * @param fuentes
     * @param fichero
     * @param comentarios
     * @param Rastreable
     * @return devuelve el fichero grafico creado
     */
    public FicheroGrafico nuevoFicheroGrafico (String nombre, String autores, String fuentes, File fichero, String comentarios, ArrayList<String> Rastreable) {
        //// 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);
        auxFicheroGrafico.setDestinoRastreable(Rastreable);
        //// 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();
    }

    /**
     * Metodo que crea una matriz de rastreabilidad
     * @param Nom
     * @param Aut
     * @param Fuent
     * @param Comment
     * @param fi
     * @param col
     * @return devuelve la matriz creada
     */
    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;
    }

    /**
     * Muestra un Panel con un mensaje
     * @param mensaje Mensaje a Mostrar
     */
    private void mostrarmensaje(int mensaje) {
         JOptionPane.showMessageDialog(null,mensaje);
    }

    /**
     * @return the mOrganizacion
     */
    public ArrayList<Organizacion> getmOrganizacion() {
        return mOrganizacion;
    }

    /**
     * @param mOrganizacion the mOrganizacion to set
     */
    public void setmOrganizacion(ArrayList<Organizacion> mOrganizacion) {
        this.mOrganizacion = mOrganizacion;
    }

    /**
     * metodo que crea una Organizacion
     * @param nombreOrg
     * @param Autores
     * @param Fuentes
     * @param direccion
     * @param telefono
     * @param fax
     * @param comentario
     * @return devuelve la organizacion creada
     */
    public Organizacion nuevaOrganizacion (String nombreOrg, String Autores, String Fuentes, String direccion, int telefono, int fax, String comentario) {

        //// Creo la instancia
        Organizacion auxOrg=new Organizacion();
        //// Asigno los valores a los atributos
        auxOrg.setNombre(nombreOrg);
        auxOrg.setAutores(Autores);
        auxOrg.setFuentes(Fuentes);
        auxOrg.setDireccion(direccion);
        auxOrg.setTelefono(telefono);
        auxOrg.setFax(fax);
        auxOrg.setComentarios(comentario);

        //// Enlazo el CasodeUso a la lista de CU que tiene el documento
        this.getmOrganizacion().add(auxOrg);
        //Notificamos que ha habido un cambio
        this.setChanged();
        this.notifyObservers();
        return auxOrg;
    }

    /**
     * Almacena un objeto(CU) en la bae de datos
     * @param Objeto a guardad en la BD
     */
    public void guardar(Object object) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("ProyectoISG2PU");
        EntityManager em = emf.createEntityManager();
        em.getTransaction().begin();
        try {
            em.persist(object);
            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }
}

    

