IMPLEMENTACIÓN EN EL LENGUAJE JAVA DE UNA HERRAMIENTA DE EDICIÓN PARA XML SCHEMA CÓDIGO

Transcripción

1 IMPLEMENTACIÓN EN EL LENGUAJE JAVA DE UNA HERRAMIENTA DE EDICIÓN PARA XML SCHEMA CÓDIGO Departamento de Ingeniería de Sistemas y Automática. Área de Ingeniería Telemática. Escuela Superior de Ingenieros. Universidad de Sevilla PROYECTO FIN DE CARRERA REALIZADO POR: María del Pilar Jiménez Guijarro DIRIGIDO POR: D. Antonio J. Sierra Collado Sevilla, Febrero 2007

2

3 Annotation.java import java.awt.borderlayout; import java.awt.dimension; import java.awt.event.windowadapter; import java.awt.event.windowevent; import javax.swing.boxlayout; import javax.swing.buttongroup; import javax.swing.jdialog; import javax.swing.jlabel; import javax.swing.joptionpane; import javax.swing.jpanel; import javax.swing.jradiobutton; import javax.swing.jsplitpane; import javax.swing.jtextfield; import javax.swing.border.emptyborder; /** Clase encargada de la creación de un cuadro de * diálogo para la inserción de un elemento Annotation. Mª del Pilar Jiménez Guijarro. 1.0 */ public class Annotation extends JDialog { /* Esta clase crea el diálogo, pero no realiza la llamada a setvisible(true). * Esto es debido a que, si la llamada se hace desde dentro de esta clase * (ver linea de código comentada más adelante), y al utilizar setmodal(true), * al pulsar los botones del diálogo, no se detectan los eventos que deberían * producirse. Para evitar esto, hay que crear el objeto y llamar a * setvisible(true) en el punto de creación del objeto. */ JRadioButton doc; JRadioButton app; ButtonGroup group; JTextField jtf; JTextField lenguaje ; boolean cerrado = false; /** Constructor de la clase. */ Annotation(){ settitle("wizard: Annotation."); - 3 -

4 setmodal(true); inicializar(); /** Método encargado de la creación de los elementos * que forman el cuadro de diálogo. */ public void inicializar(){ /* Clase anonima para que la aplicacion se cierre al * pulsar la X (boton esquina superior derecha). */ this.addwindowlistener(new WindowAdapter(){ public void windowclosing(windowevent e){ cerrado = true; ); /* Creación de los elementos JPanel. */ JSplitPane sp = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT); JPanel pan1 = new JPanel(); JPanel pan2 = new JPanel(); BorderLayout bl1 = new BorderLayout(); pan1.setlayout(bl1); BoxLayout bl2 = new BoxLayout(pan2,BoxLayout.Y_AXIS); pan2.setlayout(bl2); pan2.setborder(new EmptyBorder(10, 30, 20, 10)); /* Creación de los Radio Button y del grupo de botones. */ String docstring = "documentation"; doc = new JRadioButton(docString); doc.setmnemonic('d'); doc.setactioncommand(docstring); doc.setselected(true); String appstring = "appinfo"; app = new JRadioButton(appString); app.setactioncommand(appstring); app.setmnemonic('a'); /* Creación de la etiqueta y el campo de texto para el lenguaje. */ JLabel jl = new JLabel(" xml:lang = "); lenguaje = new JTextField (2); lenguaje.setpreferredsize(new Dimension(10,5)); group = new ButtonGroup(); group.add(doc); - 4 -

5 group.add(app); AnnotationRL mylistener = new AnnotationRL(lenguaje); doc.addactionlistener(mylistener); app.addactionlistener(mylistener); /* Añadimos los elementos al panel. */ pan1.add(new JLabel(" Select one of the following elements:")); pan1.add(doc, BorderLayout.NORTH); pan1.add(jl, BorderLayout.WEST); pan1.add(lenguaje, BorderLayout.CENTER); pan1.add(app, BorderLayout.SOUTH); /* Campo de texto y etiqueta para el texto del elemento Annotation. */ jtf = new JTextField(); jtf.setpreferredsize(new Dimension(150,50)); JLabel lab = new JLabel("Insert your annotation s text: "); /* Añadimos los elementos al panel. */ pan2.add(lab); pan2.add(jtf); /* Introducimos los dos JPanel en el JSplitPane. */ sp.setleftcomponent(pan1); sp.setrightcomponent(pan2); sp.setdividerlocation(200); /* Se crea el array de objetos con el texto * introductorio y el splitpane anterior. */ JLabel intro = new JLabel("Fill in the following fields, please."); Object[] array = {intro, sp; /* Se crea el JOptionPane y se establece como * contenido del cuadro de diálogo. */ final String btnstring1 = "Enter"; final String btnstring2 = "Cancel"; Object[] options = {btnstring1, btnstring2; JOptionPane jop = new JOptionPane(array, JOptionPane. PLAIN_MESSAGE,JOptionPane.YES_NO_OPTION, null, options, options[0]); setcontentpane(jop); setdefaultcloseoperation(dispose_on_close); pack(); setsize(450, 200); - 5 -

6 setlocation(525,375); /* NO PONER setvisible(true); AQUI!!! Si se pone aquí en vez de desde * donde creamos el objeto, cuando se pone setmodal(true) se produce * un error: no reconoce las pulsaciones de botón.*/ /* Listeners para eventos Action y PropertyChange. */ TextFieldAL tfal = new TextFieldAL(jop); jtf.addactionlistener(tfal); lenguaje.addactionlistener(tfal); AnnotationPCL pcl = new AnnotationPCL(this, jop, jtf, lenguaje); jop.addpropertychangelistener(pcl); - 6 -

7 AnnotationPCL.java import java.beans.propertychangeevent; import java.beans.propertychangelistener; import javax.swing.jdialog; import javax.swing.joptionpane; import javax.swing.jtextfield; /** Clase que escucha cambios en las propiedades del cuadro * de diálogo creado por la clase Annotation. Mª del Pilar Jiménez Guijarro. 1.0 */ public class AnnotationPCL implements PropertyChangeListener { JDialog d; JOptionPane jop; JTextField jtf; JTextField lenguaje; final String btnstring1 = "Enter"; final String btnstring2 = "Cancel"; String typedtext = null; String typedtext2 = null; /** Constructor de la clase. */ AnnotationPCL(JDialog dialogo, JOptionPane option, JTextField textfield, JTextField lang){ d = dialogo; jop = option; jtf = textfield; lenguaje = lang; /* Se ejecuta si se produce un evento PropertyChange. * Hereda comentario de documentación. */ public void propertychange(propertychangeevent e) { String prop = e.getpropertyname(); - 7 -

8 if (d.isvisible() && (e.getsource() == jop) && (prop.equals(joptionpane.value_property) prop. equals(joptionpane.input_value_property))) { Object value = jop.getvalue(); if (value == JOptionPane.UNINITIALIZED_VALUE) { return; if (value.equals(btnstring1)) { typedtext = jtf.gettext(); typedtext2 = lenguaje.gettext(); else { /* Miramos si el campo de texto de lenguaje está activado * y si tiene texto, así como si el otro campo de texto * no esta vacio. Si se cumple, quitamos el diálogo de * pantalla. */ if (!typedtext.equals("") && lenguaje.isenabled() &&!typedtext2.equals("")) { d.setvisible(false); /* Si el campo de lenguaje no está activado, miramos * que el segundo campo de texto no esté vacío. */ else if (!typedtext.equals("") &&!lenguaje.isenabled()){ d.setvisible(false); else { /* Falta algún elemento de texto de los necesarios*/ JOptionPane.showMessageDialog(d," There"+ " is some text missing. \n Fill in " + "all the fields, please.","error", JOptionPane.ERROR_MESSAGE); /* Reseteamos el valor del JOptionPane. */ jop.setvalue(joptionpane. UNINITIALIZED_VALUE); /*Si cancelamos, no hacemos nada*/ jtf.settext(""); d.setvisible(false); - 8 -

9 AnnotationRL.java import java.awt.event.actionevent; import java.awt.event.actionlistener; import javax.swing.jtextfield; /** Clase que escucha las acciones realizadas sobre los * botones de radio de la clase Attribute. Mª del Pilar Jiménez Guijarro. 1.0 */ public class AnnotationRL implements ActionListener { String docstring = "documentation"; JTextField jtf; /** Constructor de la clase. */ AnnotationRL(JTextField lenguaje){ jtf=lenguaje; /** Activa o desactiva el campo de texto correspondiente * al lenguaje, asociado a la opción documentation de la * clase Attribute. */ public void actionperformed(actionevent e) { if (e.getactioncommand().equals(docstring)){ jtf.setenabled(true); else jtf.setenabled(false); - 9 -

10 Attribute.java import java.awt.gridlayout; import java.awt.event.windowadapter; import java.awt.event.windowevent; import javax.swing.jcheckbox; import javax.swing.jdialog; import javax.swing.jlabel; import javax.swing.joptionpane; import javax.swing.jpanel; import javax.swing.jtextfield; /** Clase encargada de la creación de un cuadro de * diálogo para la inserción de un elemento Attribute. Mª del Pilar Jiménez Guijarro. 1.0 */ public class Attribute extends JDialog { JTextField jtf1; JTextField jtf2; JTextField jtf3; JTextField jtf4; JTextField jtf5; JLabel jl1; JLabel jl2; JLabel jl3; JLabel jl4; JLabel jl5; JTextField lenguaje; boolean annotation; boolean cancelado = false; boolean cerrado = false; /** Constructor de la clase. */ Attribute(){ settitle("wizard: Attribute."); setmodal(true); inicializar();

11 /** Método encargada de la creación de los elementos * que forman el cuadro de diálogo. */ public void inicializar(){ /* Clase anonima para que la aplicacion se cierre al * pulsar la X (boton esquina superior derecha). */ this.addwindowlistener(new WindowAdapter(){ public void windowclosing(windowevent e){ cerrado = true; ); /* Se crean los elementos y se añaden al panel. */ JPanel pan1 =new JPanel(); GridLayout gl = new GridLayout(7,2); pan1.setlayout(gl); jl1 = new JLabel("name : "); jl2 = new JLabel("type : "); jl3 = new JLabel("id? : "); jl4 = new JLabel("use? : "); jl5 = new JLabel("value? : "); jtf1 = new JTextField(); jtf2 = new JTextField(); jtf3 = new JTextField(); jtf4 = new JTextField(); jtf5 = new JTextField(); pan1.add(jl1); pan1.add(jtf1); pan1.add(jl2); pan1.add(jtf2); pan1.add(jl3); pan1.add(jtf3); pan1.add(jl4); pan1.add(jtf4); pan1.add(jl5); pan1.add(jtf5); pan1.add(new JLabel ("")); pan1.add(new JLabel ("")); JCheckBox jcb = new JCheckBox("Add Annotation"); pan1.add(jcb); /* Se crea el array de objetos con el texto * introductorio y el panel anterior. */

12 JLabel intro = new JLabel("Fill in the following" + " fields, please. (? = optional )"); Object[] array = {intro, pan1; /* Se crea el JOptionPane y se establece como * contenido del cuadro de diálogo. */ final String btnstring1 = "Enter"; final String btnstring2 = "Cancel"; Object[] options = {btnstring1, btnstring2; JOptionPane jop = new JOptionPane(array, JOptionPane. PLAIN_MESSAGE,JOptionPane.YES_NO_OPTION, null, options, options[0]); setcontentpane(jop); setdefaultcloseoperation(dispose_on_close); pack(); setsize(260, 270); setlocation(525,375); /* Listeners para eventos Action y PropertyChange. */ TextFieldAL tfal = new TextFieldAL(jop); jtf1.addactionlistener(tfal); jtf2.addactionlistener(tfal); jtf3.addactionlistener(tfal); jtf4.addactionlistener(tfal); jtf5.addactionlistener(tfal); AttributePCL pcl = new AttributePCL(this, jop, jtf1, jtf2, jcb); jop.addpropertychangelistener(pcl);

13 AttributeGroup.java import java.awt.gridlayout; import java.awt.event.windowadapter; import java.awt.event.windowevent; import javax.swing.jcheckbox; import javax.swing.jdialog; import javax.swing.jlabel; import javax.swing.joptionpane; import javax.swing.jpanel; import javax.swing.jtextfield; /** Clase encargada de la creación de un cuadro de diálogo * para la inserción de un elemento AttributeGroup. Mª del Pilar Jiménez Guijarro. 1.0 */ public class AttributeGroup extends JDialog { JTextField jtf1; JTextField jtf2; JLabel jl1; JLabel jl2; boolean annotation; boolean cancelado = false; boolean cerrado = false; /** Constructor de la clase. */ AttributeGroup(){ settitle("wizard: AttributeGroup."); setmodal(true); inicializar(); /** Método encargado de la creación de los elementos * que forman el cuadro de diálogo. */ public void inicializar(){

14 /* Clase anonima para que la aplicacion se cierre al * pulsar la X (boton esquina superior derecha). */ this.addwindowlistener(new WindowAdapter(){ public void windowclosing(windowevent e){ cerrado = true; ); /* Se crean los elementos y se añaden al panel. */ JPanel pan1 =new JPanel(); GridLayout gl = new GridLayout(4,2); pan1.setlayout(gl); JLabel jl1 = new JLabel("Group s name : "); JLabel jl2 = new JLabel("Number of attributes : "); jtf1 = new JTextField(); jtf2 = new JTextField(); pan1.add(jl1); pan1.add(jtf1); pan1.add(jl2); pan1.add(jtf2); pan1.add(new JLabel ("")); pan1.add(new JLabel ("")); JCheckBox jcb = new JCheckBox("Add Annotation"); pan1.add(jcb); /* Se crea el array de objetos con el texto * introductorio y el panel anterior. */ JLabel intro = new JLabel("Fill in the following " + "fields, please. (? = optional )"); Object[] array = {intro, pan1; final String btnstring1 = "Enter"; final String btnstring2 = "Cancel"; Object[] options = {btnstring1, btnstring2; /* Se crea el JOptionPane y se establece como * contenido del cuadro de diálogo. */ JOptionPane jop = new JOptionPane(array, JOptionPane. PLAIN_MESSAGE,JOptionPane.YES_NO_OPTION, null, options, options[0]); setcontentpane(jop); setdefaultcloseoperation(dispose_on_close); pack();

15 setsize(270, 190); setlocation(525,375); /* Listeners para eventos Action y PropertyChange. */ TextFieldAL tfal = new TextFieldAL(jop); jtf1.addactionlistener(tfal); jtf2.addactionlistener(tfal); AttributeGroupPCL pcl = new AttributeGroupPCL( this, jop, jtf1, jtf2, jcb); jop.addpropertychangelistener(pcl);

16 AttributeGroupPCL.java import java.beans.propertychangeevent; import java.beans.propertychangelistener; import javax.swing.jcheckbox; import javax.swing.joptionpane; import javax.swing.jtextfield; /** Clase que escucha cambios en las propiedades del cuadro * de diálogo creado por la clase AttributeGroup. Mª del Pilar Jiménez Guijarro. 1.0 */ public class AttributeGroupPCL implements PropertyChangeListener { AttributeGroup d; JOptionPane jop; JTextField name; JTextField number; JCheckBox jcb; final String btnstring1 = "Enter"; final String btnstring2 = "Cancel"; String typedtext = null; String typedtext2 = null; /** Constructor de la clase. */ AttributeGroupPCL(AttributeGroup dialogo, JOptionPane option, JTextField nombre, JTextField num_att, JCheckBox box){ d = dialogo; jop = option; name = nombre; number = num_att; jcb = box; /* Se ejecuta si se produce un evento PropertyChange. * Hereda comentario de documentación.*/ public void propertychange(propertychangeevent e) {

17 String prop = e.getpropertyname(); if (d.isvisible() && (e.getsource() == jop)&& (prop.equals(joptionpane.value_property) prop. equals(joptionpane.input_value_property))) { Object value = jop.getvalue(); if (value == JOptionPane.UNINITIALIZED_VALUE) { return; if (value.equals(btnstring1)) { typedtext = name.gettext(); typedtext2 = number.gettext(); else { /* Miramos si los campos obligatorios contienen texto. */ if (!typedtext.equals("") &&!typedtext2.equals("")) { if(jcb.isselected()) d.annotation = true; d.setvisible(false); else { /* Falta algún elemento de texto de los necesarios*/ JOptionPane.showMessageDialog(d," There"+ " is some text missing. \n Fill in " + "all the fields, please.","error", JOptionPane.ERROR_MESSAGE); jop.setvalue(joptionpane. UNINITIALIZED_VALUE); /*Si cancelamos, no hacemos nada*/ d.cancelado = true; d.setvisible(false);

18 AttributePCL.java import java.beans.propertychangeevent; import java.beans.propertychangelistener; import javax.swing.jcheckbox; import javax.swing.joptionpane; import javax.swing.jtextfield; /** Clase que escucha cambios en las propiedades del cuadro * de diálogo creado por la clase Attribute. Mª del Pilar Jiménez Guijarro. 1.0 */ public class AttributePCL implements PropertyChangeListener { Attribute d; JOptionPane jop; JTextField name; JTextField type; JCheckBox jcb; final String btnstring1 = "Enter"; final String btnstring2 = "Cancel"; String typedtext = null; String typedtext2 = null; /** Constructor de la clase. */ AttributePCL(Attribute dialogo, JOptionPane option, JTextField nombre, JTextField tipo, JCheckBox box){ d = dialogo; jop = option; name = nombre; type = tipo; jcb = box; /* Se ejecuta si se produce un evento PropertyChange. * Hereda comentario de documentación. */ public void propertychange(propertychangeevent e) {

19 String prop = e.getpropertyname(); if (d.isvisible() && (e.getsource() == jop) && (prop.equals(joptionpane.value_property) prop. equals(joptionpane.input_value_property))) { Object value = jop.getvalue(); if (value == JOptionPane.UNINITIALIZED_VALUE) { return; if (value.equals(btnstring1)) { typedtext = name.gettext(); typedtext2 = type.gettext(); else { /* Miramos si los campos obligatorios contienen texto. */ if (!typedtext.equals("") &&!typedtext2.equals("")) { if(jcb.isselected()) d.annotation = true; d.setvisible(false); else { /* Falta algún elemento de texto de los necesarios*/ JOptionPane.showMessageDialog(d," There"+ " is some text missing. \n Fill in " + "all the fields, please.","error", JOptionPane.ERROR_MESSAGE); jop.setvalue(joptionpane. UNINITIALIZED_VALUE); /*Si cancelamos, no hacemos nada*/ d.cancelado = true; d.setvisible(false);

20 CodeDocument.java import java.util.*; import javax.swing.text.attributeset; import javax.swing.text.badlocationexception; import javax.swing.text.defaultstyleddocument; import javax.swing.text.element; /** Clase encargada del tratamiento del texto * que se inserta en un panel de edición. Mª del Pilar Jiménez Guijarro. 1.0 */ public class CodeDocument extends DefaultStyledDocument{ /* Almacena el valor del prefijo asignado al * espacio de nombres de XML Schema.*/ String prefijo; MyJEditorPane jep; /* Variable booleana para saber si estamos leyendo de un archivo, en cuyo * caso usaremos el insertstring de la clase padre, sin hacer ningún tipo * de comparación y con el AttributeSet que nos pasan como parametro. Si * no estamos leyendo de un archivo sino insertando caracteres por teclado * sí haremos las comprobaciones. */ boolean leer = false; /* Para almacenar las palabras clave a insertar. */ private String word = ""; /* Posición actual de inserción de texto. */ private int currentpos = 0; /* Vector que contiene las palabras clave de XML Schema. */ private Vector keywords = new Vector(); /* Modos en los que podemos encontrarnos al tratar el texto y variable * (mode) que almacena el modo en que estamos en cada instante.*/ public static int STRING_MODE = 10; public static int TEXT_MODE = 11; public static int PI_MODE = 12; public static int COMMENT_MODE = 13; private int mode = TEXT_MODE;

21 boolean insertando_varios = false; /* Se utiliza para, al poner un signo ">", no poner la etiqueta de * cierre salvo si lo que tenemos previamente es una palabra clave. */ boolean palabra_clave = false; /* Variables para almacenar el punto en que se encuentra el Caret y * ver si ha sido desplazado a un punto no contiguo a donde estaba.*/ int posicion_previa = 0; int posicion_aux; /* Variable para indicar que es el caracter ">", para que cuando sea cierre de * comentario o PI y vengamos de otro renglón NO LO PONGA EN ROJO. */ boolean cierre = false; boolean cierre_com = false; boolean cierre_pi = false; /* Cuentan el número de etiquetas de apertura y cierre de PI o comentario. */ int abre_comment = 0; int cierra_comment = 0; int abre_pi = 0; int cierra_pi = 0; /* ****************************************************** */ /* ****************** CONSTRUCTOR ******************* */ /* ****************************************************** */ /** Constructor de la clase. */ public CodeDocument(MyJEditorPane j) { jep = j; /* ****************************************************** */ /* **************** INSERCIÓN DE TEXTO **************** */ /* ****************************************************** */ /** Método sobrescrito:acepta cualquier longitud de * cadena y realiza el procesamiento de caracteres. */ public void insertstring(int offs, String str, AttributeSet a) throws BadLocationException{ posicion_previa = currentpos; if(!leer){

22 super.insertstring(offs, str, jep.normal); else int strlen = str.length(); if(strlen > 1) insertando_varios = true; int endpos = offs + strlen; int strpos; for (int i=offs;i<endpos;i++){ currentpos = i; strpos = i - offs; processchar(str.charat(strpos)); currentpos = offs; insertando_varios= false; super.insertstring(offs, str, a); /* ****************************************************** */ /* ********* PROCESAMIENTO DE CARACTERES ********** */ /* ****************************************************** */ /** Método que convierte el char que se le pasa como parámetro * a String y llama a proccesschar(string str). */ public void processchar(char strchar){ char[] chrstr = new char[1]; chrstr[0] = strchar; String str = new String(chrstr); processchar(str); /** Método que procesa cada caracter para ver en qué modo estamos, * a qué modo hay que pasar y cuales son las acciones a realizar. */ public void processchar(string str){ char strchar = str.charat(0); posicion_aux=posicion_previa + 1; /* CUIDADO: Lo que viene ahora se encarga de buscar comentarios * o PIs si hemos cambiado la posición del cursor. Estas * comprobaciones no las haremos cuando estamos insertando

23 * varios elementos a la vez, es decir, un string completo * (mediante un copy-paste por ejemplo), ya que insertstring * se encarga, en este caso, de que se compruebe si hay PI * o comentario al insertar así. */ if(!insertando_varios){ if(posicion_aux!= currentpos){ /* Reinicializamos estas variables antes de hacer * el tratamiento. */ cierre = false; cierre_com = false; cierre_pi = false; if (strchar == '>') cierre = true; /* Sólo válido para que, en el caso de tener "<!-" e * introducir "-", se retire lo anterior y se ponga * todo "<!--" de color verde. */ if (strchar == '-') checkforcomment(); buscar_comment(); if (mode == TEXT_MODE) buscar_pi(); else{ /* Si el caracter es ">", saldremos de la función * buscar_comment()en modo comentario. En ese * caso, si no se hace lo que sigue, escribiriamos * en verde (comentario). Con las lineas siguientes * se consigue que pasemos a ver si ese cierre * pertenece al cierre de un PI (?>), o si sólo * forma parte de un comentario o de un PI. */ if(!cierre_com && cierre_pi) buscar_pi(); if(mode == COMMENT_MODE){ switch (strchar){ case('>'):{ /* Ponemos ya a false la variable cierre. */ cierre = false; /*Para ver cuando cambiar el modo comentario. */ checkforcomment(); /* Si después de esta función seguimos en modo

24 * comentario es porque no era cierre, entonces * hay que escribir el ">" en color verde. Como * en el método insertstring ya ha sido insertado * el elemento, lo sustituimos en color verde * mediante insertcommentstring(). */ if(mode==comment_mode){ insertcommentstring(str, this.currentpos); break; default: insertcommentstring(str, this.currentpos); else if(mode == PI_MODE){ switch (strchar){ case('>'):{ /* Ponemos ya a false la variable cierre. */ cierre = false; /*Para ver cuando cambiar el modo PI*/ checkforpi(); else{ /* Si después de esta función seguimos en modo PI es * porque no era cierre, entonces hay que escribir el ">" en * color celeste. Como en el método insertstring ya ha sido * insertado el elemento, lo sustituimos en color celeste. */ if(mode==pi_mode){ insertpistring(str, this.currentpos); break; default: insertpistring(str, this.currentpos); switch (strchar){ case('<'):case('/'):{ char[] chrstr = new char[1]; chrstr[0] = strchar; insertopensign(new String(chrstr),currentPos); break; case (' '): case('\n'):case('>'):{ checkforkeyword();

25 if(strchar == '>'){ char[] chrstr = new char[1]; chrstr[0] = strchar; insertclosesign(new String(chrstr),currentPos); if (mode == STRING_MODE && strchar == '\n'){ mode = TEXT_MODE; break; case ('-'):{ checkforcomment(); break; case ('?'):{ checkforpi(); break; case ('"'):case('\''):{ inserttextstring(str, currentpos); checkforstring(); break; default: break; if (mode == TEXT_MODE){ checkforstring(); if (mode == STRING_MODE){ inserttextstring(str, this.currentpos); /* ****************************************************** */ /* ************** FUNCIONES DE BÚSQUEDA ************* */ /* ****************************************************** */ /** Método que cuenta el número de comillas simples o dobles en la línea

26 * en que nos encontramos y activa el modo String si es necesario.*/ public void checkforstring(){ int offs = currentpos; Element element = this.getparagraphelement(offs); String elementtext = ""; try{ /* Esta es la forma de obtener el texto que nos * interesa (una línea) desde el elemento párrafo. */ elementtext = this.gettext(element.getstartoffset(), element.getendoffset() - element.getstartoffset()); catch(exception ex){ System.err.println("no text"); int strlen = elementtext.length(); if (strlen == 0) return; int i = 0; if (element.getstartoffset() > 0){ /* Traducimos hacia atrás si es necesario: sólo comprobaremos * de donde empieza el elemento hasta el punto de inserción.*/ offs = offs - element.getstartoffset(); int quotecount = 0; int aposcount = 0; if ((offs >= 0) && (offs <= strlen-1)){ i = offs; while (i >0){ /* El bucle chile camina hacia atrás hasta y mientras * vamos contando las comillas simples y dobles. */ char charat = elementtext.charat(i); if ((charat == '"')){ quotecount ++; if ((charat == '\'')){ aposcount ++; i--; int rem = quotecount % 2; int rem2 = aposcount % 2; mode = (rem == 0 && rem2==0)? TEXT_MODE: STRING_MODE;

27 /** Método que busca si hay palabras clave en la línea y * la escribe en color azul en caso de encontrar alguna.*/ public void checkforkeyword(){ if (mode!= TEXT_MODE) { return; int offs = currentpos; Element element = this.getparagraphelement(offs); String elementtext = ""; try{ /* Esta es la forma de obtener el texto que nos * interesa (una línea) desde el elemento párrafo. */ elementtext = this.gettext(element.getstartoffset(), element.getendoffset() - element.getstartoffset()); catch(exception ex){ System.err.println("no text"); int strlen = elementtext.length(); if (strlen == 0) return; int i = 0; if (element.getstartoffset() > 0){ /* Traducimos hacia atrás si es necesario: sólo comprobaremos * de donde empieza el elemento hasta el punto de inserción.*/ offs = offs - element.getstartoffset(); if ((offs >= 0) && (offs <= strlen-1)){ i = offs; while (i >0){ /* El bucle chile camina hacia atrás hasta hasta que se * encuentre un elemento de los que buscamos. */ i--; char charat = elementtext.charat(i); if ((charat==' ') (i==0) charat=='<' charat==('/')){ if ((charat==' ') charat=='<' charat==('/')){ /* Para no coger el caracter limite: i++. */ i++; word = elementtext.substring(i, offs); String s = word.trim(); /* Aquí es donde realmente se compara con las * palabras clave almacenadas en el vector. */

28 if (keywords.contains(s)){ palabra_clave = true; insertkeyword(word, currentpos); break; /** Método que cambia a modo comentario o modo texto si es necesario, y * sustituye cierto texto en color verde mediante insertcommentstring(). */ public void checkforcomment(){ int offs = currentpos; Element element = this.getparagraphelement(offs); String elementtext = ""; try{ /* Esta es la forma de obtener el texto que nos * interesa (una línea) desde el elemento párrafo. */ elementtext = this.gettext(element.getstartoffset(), element.getendoffset() - element.getstartoffset()); catch(exception ex){ System.err.println("no text"); int strlen = elementtext.length(); if (strlen == 0) return; int i = 0; if (element.getstartoffset() > 0){ /* Traducimos hacia atrás si es necesario: sólo comprobaremos * de donde empieza el elemento hasta el punto de inserción.*/ offs = offs - element.getstartoffset(); /* Offset mayor o igual que tres para no tener elementos * negativos al tomar los elementos commentstartchar.*/ if ((offs >= 3) && (offs <= strlen-1)){ i = offs; char commentstartchar1 = elementtext.charat(i-3); char commentstartchar2 = elementtext.charat(i-2); char commentstartchar3 = elementtext.charat(i-1); char commentstartchar4 = elementtext.charat(i); if (commentstartchar1 == '<' && commentstartchar2 == '!' && commentstartchar3 == '-' && commentstartchar4 == '-'){

29 mode = COMMENT_MODE; insertcommentstring("<!--", currentpos-3); else if (commentstartchar2 == '-' && commentstartchar3 == '-' && commentstartchar4 == '>'){ mode = TEXT_MODE; insertcommentstring("-->", currentpos-2); /** Método que cambia a modo PI o modo texto si es necesario, y * sustituye cierto texto en color rojo mediante insertpistring(). */ public void checkforpi(){ int offs = currentpos; Element element = this.getparagraphelement(offs); String elementtext = ""; try{ /* Esta es la forma de obtener el texto que nos * interesa (una línea) desde el elemento párrafo. */ elementtext = this.gettext(element.getstartoffset(), element.getendoffset() - element.getstartoffset()); catch(exception ex){ ex.printstacktrace(); int strlen = elementtext.length(); if (strlen == 0) return; int i = 0; if (element.getstartoffset() > 0){ /* Traducimos hacia atrás si es necesario: sólo comprobaremos * de donde empieza el elemento hasta el punto de inserción.*/ offs = offs - element.getstartoffset(); /* Offset mayor o igual que uno para no tener elementos * negativos al tomar los elementos PIStartChar.*/ if ((offs >= 1) && (offs <= strlen-1)){ i = offs; char PIStartChar1 = elementtext.charat(i-1); char PIStartChar2 = elementtext.charat(i); if (PIStartChar1 == '<' && PIStartChar2 == '?'){ mode = PI_MODE;

30 this.insertpistring("<?", currentpos-1); else if (PIStartChar1 == '?' && PIStartChar2 == '>'){ mode = TEXT_MODE; this.insertpistring(">", currentpos); /** Método que busca comentario. Se utiliza en el caso * en que hayamos cambiado el cursor de posición.*/ public void buscar_comment(){ abre_comment = 0; cierra_comment = 0; int offs = currentpos; Element element = this.getparagraphelement(offs); String elementtext = ""; try{ elementtext = this.gettext(element.getstartoffset(), element.getendoffset() - element.getstartoffset()); catch(exception ex){ System.err.println("no text"); int strlen = elementtext.length(); if (strlen == 0) return; int i = 0; if (element.getstartoffset() > 0){ offs = offs - element.getstartoffset(); /*Offset mayor o igual que tres para no tener elementos negativos al * almacenar los elementos commentstartchar.*/ if ((offs >= 3) && (offs <= strlen-1)){ i = offs; while (i>=3){ char commentstartchar1 = elementtext.charat(i-3); char commentstartchar2 = elementtext.charat(i-2); char commentstartchar3 = elementtext.charat(i-1); char commentstartchar4 = elementtext.charat(i); if (commentstartchar1 == '<' && commentstartchar2-30 -

31 == '!' && commentstartchar3 == '-' && commentstartchar4 == '-'){ abre_comment ++; else if (commentstartchar2 == '-' && commentstartchar3 == '-' && commentstartchar4 == '>'){ cierra_comment ++; i--; if(cierre){ /* Retomo el texto, para ver si el cierre pertenece a la * etiqueta de cierre de un PI, a la de un comentario o * forma parte de alguno del PI o el comentario. Para ello * utilizaré dos variables, cierre_com y cierre_pi.*/ i = offs; char c1 = elementtext.charat(i-2); char c2 = elementtext.charat(i-1); char c3 = elementtext.charat(i); if (c1 == '-' && c2 == '-' && c3 == '>'){ cierre_com = true; cierre_pi = false; else if(c2 == '?' && c3 == '>'){ cierre_pi = true; cierre_com = false; else{ /* Caso en que el simbolo de cierre forma parte * de la PI o del comentario, pero no cierra * ninguno de esos elementos. */ cierre_com = false; cierre_pi = false; if ((abre_comment == cierra_comment) &&!cierre) mode = TEXT_MODE; else{ /* En el caso de que sea cierre, pero no cierre de * comentario, por ejemplo, insertar una etiqueta * de cierre a un elemento que hubiésemos olvidado * cerrar, no estaremos en modo comentario sino en * modo texto para cerrar la etiqueta en rojo y * añadir la etiqueta de cierre. (Ver buscar_pi(), * que realiza una comprobación más concreta. */ if(cierre &&!cierre_com) mode = TEXT_MODE; else

32 else mode = TEXT_MODE; mode = COMMENT_MODE; /** Método que busca PIs. Se utiliza en el caso * en que hayamos cambiado el cursor de posición.*/ public void buscar_pi(){ abre_pi = 0; cierra_pi = 0; int offs = currentpos; Element element = this.getparagraphelement(offs); String elementtext = ""; try{ elementtext = this.gettext(element.getstartoffset(), element.getendoffset() - element.getstartoffset()); catch(exception ex){ System.err.println("no text"); int strlen = elementtext.length(); if (strlen == 0) return; int i = 0; if (element.getstartoffset() > 0){ offs = offs - element.getstartoffset(); /* Offset mayor o igual que uno para no tener elementos * negativos al almacenar los elementos PIStartChar.*/ if ((offs >= 1) && (offs <= strlen-1)){ i = offs; while(i>=1){ char PIStartChar1 = elementtext.charat(i-1); char PIStartChar2 = elementtext.charat(i); if (PIStartChar1 == '<' && PIStartChar2 == '?'){ abre_pi++; else if (PIStartChar1 == '?' && PIStartChar2 == '>'){ cierra_pi ++;

33 i--; else if ((abre_pi == cierra_pi) &&!cierre) mode = TEXT_MODE; else{ if(cierre &&!cierre_pi &&!cierre_com){ /* Tenemos el elemento ">", pero no cierra * ni un comentario ni un PI. Entonces:*/ if(abre_pi!= cierra_pi) /* Estamos dentro de un PI*/ mode = PI_MODE; else if(abre_comment!= cierra_comment) /* Estamos dentro de un comentario!*/ mode = COMMENT_MODE; else /* Lo insertaremos en rojo. */ mode = TEXT_MODE; else if(cierre &&!cierre_pi) mode = TEXT_MODE; else mode = PI_MODE; mode = TEXT_MODE; /* ****************************************************** */ /* ************* FUNCIONES DE INSERCIÓN ************* */ /* ****************************************************** */ /** Método para insertar palabras clave en color azul. */ public void insertkeyword(string str, int pos){ try{ /* Eliminamos la palabra antigua y formateamos */ this.remove(pos - str.length(), str.length()); /* Reemplazamos con la misma palabra, pero con nuevo formato. * Debemos llamar al método de la superclase insertstring aqui, * de otro modo acabaríamos en un bucle infinito!*/ super.insertstring(pos - str.length(), str, jep.etiqueta); catch (Exception ex){

34 ex.printstacktrace(); /** Método para insertar texto entrecomillado en color rosa. */ public void inserttextstring(string str, int pos){ try{ this.remove(pos,str.length()); super.insertstring(pos, str, jep.valoratributo); catch (Exception ex){ ex.printstacktrace(); /** Método para insertar comentarios en color verde. */ public void insertcommentstring(string str, int pos){ try{ this.remove(pos,str.length()); super.insertstring(pos, str, jep.comentario); catch (Exception ex){ ex.printstacktrace(); /** Método para insertar PIs en color rojo. */ public void insertpistring(string st, int pos){ try{ this.remove(pos,st.length()); super.insertstring(pos, st, jep.declaracion_pi); catch (Exception ex){ ex.printstacktrace(); /** Método para insertar el símbolo de apertura de etiqueta en color rojo. */ public void insertopensign(string str, int pos){ try{ this.remove(pos,str.length());

35 super.insertstring(pos, str, jep.apertura); catch (Exception ex){ ex.printstacktrace(); /** Método para insertar el símbolo de cierre de etiqueta en color rojo. */ public void insertclosesign(string str, int pos){ try{ this.remove(pos,str.length()); super.insertstring(pos, str, jep.apertura); /* Si estoy insertando varios caracteres a la vez (paste), * no quiero que, si se trata de una etiqueta correcta, * se inserte el elemento de cierre de dicha etiqueta. */ if(!insertando_varios && palabra_clave){ etiqueta_cierre(); palabra_clave = false; mode = TEXT_MODE; catch (Exception ex){ ex.printstacktrace(); /** Método para insertar la etiqueta de cierre * para una etiqueta de apertura (si procede). */ public void etiqueta_cierre(){ /* Realizamos la búsqueda del texto que forma la etiqueta * (obviando todos los atributos que pueda haber). */ String st = ""; int offs = this.currentpos; Element element = this.getparagraphelement(offs); String elementtext = ""; try{ elementtext = this.gettext(element.getstartoffset(), element.getendoffset() - element.getstartoffset()); catch(exception ex){ ex.printstacktrace(); int strlen = elementtext.length(); if (strlen == 0) return;

36 int i = 0; if (element.getstartoffset() > 0){ offs = offs - element.getstartoffset(); if ((offs >= 0) && (offs <= strlen-1)){ i = offs; while (i >0){ i--; char charat = elementtext.charat(i); if(charat == '/') break; if(charat == ' ') /* Cuando encuentro un espacio, modifico la * variable offs que es el punto máximo del * elemento que tomaré en st para añadir * dentro de la etiqueta de cierre */ offs = i; if (charat == '<'){ i++; st = elementtext.substring(i, offs); try{ offs = this.currentpos+1; String apert = "</"; String cierre = ">"; super.insertstring(offs,apert, jep.apertura); offs += apert.length(); super.insertstring(offs, st, jep.etiqueta); offs += st.length(); super.insertstring(offs, cierre, jep.apertura); catch (Exception ex){ ex.printstacktrace(); break; /* ****************************************************** */ /* ***************** OTRAS FUNCIONES ***************** */ /* ****************************************************** */ /** Método que asigna el vector pasado como * parámetro a la variable keywords. */

37 public void setkeywords(vector akeywordlist){ if (akeywordlist!= null){ this.keywords = akeywordlist;

38 EventHandler.java import java.awt.event.actionevent; import java.awt.event.actionlistener; import javax.swing.joptionpane; /** Clase que escucha las acciones que el usuario realiza en la GUI. Mª del Pilar Jiménez Guijarro. 1.0 */ public class EventHandler implements ActionListener { Inicial i; /** Constructor de la clase. */ EventHandler(Inicial application) { i = application; /* Se ejecuta cuando se produce algún evento Action por las * acciones del usuario. Hereda comentario de documentación. */ public void actionperformed(actionevent e) { /* Salir. */ if (e.getsource() == i.exitmenu) { i.exit(); /* Abrir fichero (tanto en menú File como botón del toolbar). */ else if (e.getsource() == i.openmenu e.getsource() == i.openbutton) { i.openfile(false, null); /* Abrir fichero nuevo (tanto en menú File como botón del toolbar). */ else if (e.getsource() == i.newmenu e.getsource() == i.newbutton) { i.newfile(); /* Salvar. */ else if (e.getsource() == i.savemenu e.getsource() == i.savebutton) {

39 i.savefile(); /* Salvar Como. */ else if (e.getsource() == i.saveasmenu) { i.savefileas(); /* Cerrar un fichero. */ else if (e.getsource() == i.closemenu e.getsource() == i.closep) { i.closefile(); /* Cerrar todos. */ else if (e.getsource() == i.closeallmenu e.getsource() == i.closeallp){ i.closeallfiles(); /* Cerrar todos menos éste. */ else if (e.getsource() == i.closeallexceptmenu e.getsource() == i.closeallexceptp) { i.closeallexceptthis(); /* Refrescar. */ else if (e.getsource() == i.refreshtabmenu e.getsource() == i.refreshbutton) { i.refresh(); /* Refrescar y Salvar. */ else if (e.getsource() == i.refreshandsavemenu) { i.refreshandsave(); /* Si queremos ver el about del editor. */ else if (e.getsource() == i.abouteditormenu) { JOptionPane.showMessageDialog(i, " Lyon Editor 1.0\n" + "Realizado por Pilar Jiménez Guijarro", "About Lyon Editor", JOptionPane.INFORMATION_MESSAGE); /* Código añadido para "abrir reciente" */ else if (e.getsource() == i.jmi1) { i.openrecentfile(i.jmi1.gettext()); else if (e.getsource() == i.jmi2) { i.openrecentfile(i.jmi2.gettext());

40 else if (e.getsource() == i.jmi3) { i.openrecentfile(i.jmi3.gettext()); else if (e.getsource() == i.jmi4) { i.openrecentfile(i.jmi4.gettext()); /* Código añadido para la inserción de elementos. */ else if (e.getsource() == i.annotationmenu e.getsource() == i.annotationbutton) { i.annotation(); else if (e.getsource() == i.attributemenu e.getsource() == i.attributebutton) { i.attribute(); else if (e.getsource() == i.attributegroupmenu e.getsource() == i.attributegroupbutton) { i.attributegroup(); else if (e.getsource() == i.importmenu e.getsource() == i.importbutton) { i.importar(); else if (e.getsource() == i.includemenu e.getsource() == i.includebutton) { i.include();

41 Import.java import java.awt.dimension; import java.awt.gridlayout; import java.awt.event.windowadapter; import java.awt.event.windowevent; import javax.swing.jcheckbox; import javax.swing.jdialog; import javax.swing.jlabel; import javax.swing.joptionpane; import javax.swing.jpanel; import javax.swing.jsplitpane; import javax.swing.jtextfield; /** Clase encargada de la creación de un cuadro de * diálogo para la inserción de un elemento Import. Mª del Pilar Jiménez Guijarro. 1.0 */ public class Import extends JDialog { JTextField jtf1; JTextField jtf2; JTextField jtf3; boolean annotation; boolean cancelado = false; boolean cerrado = false; /* Constructor de la clase. */ Import(){ settitle("wizard: Import."); setmodal(true); inicializar(); /** Método encargado de la creación de los elementos * que forman el cuadro de diálogo. */ public void inicializar(){

42 /* Clase anonima para que la aplicacion se cierre al * pulsar la X (boton esquina superior derecha). */ this.addwindowlistener(new WindowAdapter(){ public void windowclosing(windowevent e){ cerrado = true; ); /* Creamos un JSplitPane, pues tendremos dos partes diferenciadas. */ JSplitPane sp = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT); sp.setpreferredsize(new Dimension(450,150)); /* Creamos los paneles y añadimos los elementos. */ JPanel pan1 =new JPanel(); JPanel pan2 =new JPanel(); GridLayout gl = new GridLayout(3,2); pan1.setlayout(gl); JLabel jl1 = new JLabel("id? : "); JLabel jl2 = new JLabel("namespace? : "); JLabel jl3 = new JLabel("schemaLocation? : "); jtf1 = new JTextField(); jtf2 = new JTextField(); jtf3 = new JTextField(); pan1.add(jl1); pan1.add(jtf1); pan1.add(jl2); pan1.add(jtf2); pan1.add(jl3); pan1.add(jtf3); JCheckBox jcb = new JCheckBox("Add Annotation"); pan2.add(jcb); /* Añadimos los paneles al JSplitPane. */ sp.setleftcomponent(pan1); sp.setrightcomponent(pan2); sp.setdividerlocation(250); /* Se crea el array de objetos con el texto * introductorio y el splitpane anterior. */ JLabel intro = new JLabel("Fill in the following " + "fields, please. (? = optional )"); Object[] array = {intro, sp; /* Se crea el JOptionPane y se establece como

43 * contenido del cuadro de diálogo. */ final String btnstring1 = "Enter"; final String btnstring2 = "Cancel"; Object[] options = {btnstring1, btnstring2; JOptionPane jop = new JOptionPane(array, JOptionPane. PLAIN_MESSAGE,JOptionPane.YES_NO_OPTION, null, options, options[0]); setcontentpane(jop); setdefaultcloseoperation(dispose_on_close); pack(); setsize(450, 200); setlocation(525,375); /* Listeners para eventos Action y PropertyChange. */ TextFieldAL tfal = new TextFieldAL(jop); jtf1.addactionlistener(tfal); jtf2.addactionlistener(tfal); jtf3.addactionlistener(tfal); ImportPCL pcl = new ImportPCL(this, jop, jcb); jop.addpropertychangelistener(pcl);

44 ImportPCL.java import java.beans.propertychangeevent; import java.beans.propertychangelistener; import javax.swing.jcheckbox; import javax.swing.joptionpane; /** Clase que escucha cambios en las propiedades del cuadro * de diálogo creado por la clase Import. Mª del Pilar Jiménez Guijarro. 1.0 */ public class ImportPCL implements PropertyChangeListener { String id; String namespace; String schemaloc; Import d; JOptionPane jop; final String btnstring1 = "Enter"; final String btnstring2 = "Cancel"; JCheckBox jcb; /* Constructor de la clase. */ ImportPCL(Import dialogo, JOptionPane option, JCheckBox box){ d = dialogo; jop = option; jcb = box; /* Se ejecuta si se produce un evento PropertyChange. * Hereda comentario de documentación. */ public void propertychange(propertychangeevent e) { String prop = e.getpropertyname(); if (d.isvisible() && (e.getsource() == jop) && (prop.equals(joptionpane.value_property) prop. equals(joptionpane.input_value_property))) {

45 Object value = jop.getvalue(); if (value == JOptionPane.UNINITIALIZED_VALUE) { return; if (value.equals(btnstring1)) { if(jcb.isselected()){ d.annotation = true; /* d.cancelado vale false -> * realizaremos las acciones! */ d.setvisible(false); else { /*Si cancelamos, no hacemos nada*/ d.annotation = false; d.cancelado = true; d.setvisible(false);

46 Include.java import java.awt.dimension; import java.awt.gridlayout; import java.awt.event.windowadapter; import java.awt.event.windowevent; import javax.swing.jcheckbox; import javax.swing.jdialog; import javax.swing.jlabel; import javax.swing.joptionpane; import javax.swing.jpanel; import javax.swing.jsplitpane; import javax.swing.jtextfield; /** Clase encargada de la creación de un cuadro de * diálogo para la inserción de un elemento Include. Mª del Pilar Jiménez Guijarro. 1.0 */ public class Include extends JDialog { JTextField jtf1; JTextField jtf2; boolean annotation; boolean cancelado = false; boolean cerrado = false; /** Constructor de la clase. */ Include(){ settitle("wizard: Include."); setmodal(true); inicializar(); /** Método encargado de la creación de los elementos * que forman el cuadro de diálogo. */ public void inicializar(){

47 /* Clase anonima para que la aplicacion se cierre al * pulsar la X (boton esquina superior derecha). */ this.addwindowlistener(new WindowAdapter(){ public void windowclosing(windowevent e){ cerrado = true; ); /* Creamos un JSplitPane, pues tendremos dos partes diferenciadas. */ JSplitPane sp = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT); sp.setpreferredsize(new Dimension(450,150)); /* Creamos los paneles y añadimos los elementos. */ JPanel pan1 =new JPanel(); JPanel pan2 =new JPanel(); GridLayout gl = new GridLayout(2,2); pan1.setlayout(gl); JLabel jl1 = new JLabel("id? : "); JLabel jl2 = new JLabel("schemaLocation : "); jtf1 = new JTextField(); jtf2 = new JTextField(); pan1.add(jl1); pan1.add(jtf1); pan1.add(jl2); pan1.add(jtf2); JCheckBox jcb = new JCheckBox("Add Annotation"); pan2.add(jcb); /* Añadimos los paneles al JSplitPane. */ sp.setleftcomponent(pan1); sp.setrightcomponent(pan2); sp.setdividerlocation(250); /* Se crea el array de objetos con el texto * introductorio y el splitpane anterior. */ JLabel intro = new JLabel("Fill in the following" + " fields, please. (? = optional )"); Object[] array = {intro, sp; /* Se crea el JOptionPane y se establece como * contenido del cuadro de diálogo. */ final String btnstring1 = "Enter"; final String btnstring2 = "Cancel"; Object[] options = {btnstring1, btnstring2;

48 JOptionPane jop = new JOptionPane(array, JOptionPane. PLAIN_MESSAGE,JOptionPane.YES_NO_OPTION, null, options, options[0]); setcontentpane(jop); setdefaultcloseoperation(dispose_on_close); pack(); setsize(450, 150); setlocation(525,375); /* Listeners para eventos Action y PropertyChange. */ TextFieldAL tfal = new TextFieldAL(jop); jtf1.addactionlistener(tfal); jtf2.addactionlistener(tfal); IncludePCL pcl = new IncludePCL(this, jop, jcb, jtf2); jop.addpropertychangelistener(pcl);

49 IncludePCL.java import java.beans.propertychangeevent; import java.beans.propertychangelistener; import javax.swing.jcheckbox; import javax.swing.joptionpane; import javax.swing.jtextfield; /** Clase que escucha cambios en las propiedades del cuadro * de diálogo creado por la clase Include. Mª del Pilar Jiménez Guijarro. 1.0 */ public class IncludePCL implements PropertyChangeListener { String id; String schemaloc; Include d; JOptionPane jop; JTextField jtf; String text; final String btnstring1 = "Enter"; final String btnstring2 = "Cancel"; JCheckBox jcb; /** Constructor de la clase. */ IncludePCL(Include dialogo, JOptionPane option, JCheckBox box, JTextField jtf_schema){ d = dialogo; jop = option; jcb = box; jtf = jtf_schema; /* Se ejecuta si se produce un evento PropertyChange. * Hereda comentario de documentación. */ public void propertychange(propertychangeevent e) { String prop = e.getpropertyname();

50 if (d.isvisible() && (e.getsource() == jop) && (prop.equals(joptionpane.value_property) prop. equals(joptionpane.input_value_property))) { Object value = jop.getvalue(); if (value == JOptionPane.UNINITIALIZED_VALUE) { return; if (value.equals(btnstring1)) { /* Sólo compruebo el texto de schemalocation. */ text = jtf.gettext(); else { /* En este caso, si el campo de texto correspondiente al * schemalocation está vacío, mostraremos un diálogo de * error ya que es un campo obligatorio. */ if (!text.equals("")) { if(jcb.isselected()){ d.annotation = true; /* d.cancelado vale false -> * realizaremos las acciones! */ d.setvisible(false); else { /* Falta el elemento de texto de schemalocation*/ JOptionPane.showMessageDialog(d," The field " + "schemalocation is REQUIRED. \n " + "Fill in at least this field, please.", "ERROR", JOptionPane.ERROR_MESSAGE); jop.setvalue(joptionpane. UNINITIALIZED_VALUE); /*Si cancelamos, no hacemos nada*/ d.annotation = false; d.cancelado = true; d.setvisible(false);

51 Inicial.java import javax.swing.action; import javax.swing.box; import javax.swing.imageicon; import javax.swing.jbutton; import javax.swing.jfilechooser; import javax.swing.jframe; import javax.swing.jmenu; import javax.swing.jmenubar; import javax.swing.jmenuitem; import javax.swing.joptionpane; import javax.swing.jpanel; import javax.swing.jpopupmenu; import javax.swing.jscrollpane; import javax.swing.jsplitpane; import javax.swing.jtabbedpane; import javax.swing.jtoolbar; import javax.swing.keystroke; import javax.swing.swingutilities; import javax.swing.uimanager; import javax.swing.text.defaulteditorkit; import javax.swing.text.document; import javax.swing.text.jtextcomponent; import javax.swing.undo.undomanager; import java.awt.borderlayout; import java.awt.container; import java.awt.cursor; import java.awt.insets; import java.awt.toolkit; import java.awt.event.actionlistener; import java.awt.event.keyevent; import java.awt.event.mouselistener; import java.awt.event.windowadapter; import java.awt.event.windowevent; import java.io.bufferedreader; import java.io.bufferedwriter; import java.io.file; import java.io.filereader; import java.io.filewriter; import java.util.hashtable;

52 /** Clase que inicializa la GUI, y se encarga de la realización de * acciones de apertura, cierre, salvaguarda, etc. de ficheros. Mª del Pilar Jiménez Guijarro. 1.0 */ public class Inicial extends JFrame{ static Inicial application; /* Diálogo de elección de archivos y Barra de Menu.*/ JFileChooser filechooser = null; JMenuBar menubar; /* Menus e Items de Menus para el Menu Inicial.*/ JMenu filemenu; JMenu aboutmenu; JMenuItem newmenu; JMenuItem openmenu; JMenu openrecentmenu; JMenuItem exitmenu; JMenuItem abouteditormenu; /* Menu e items para completar el menu inicial. ATENCIÓN!!! No se * inicializan aqui; aqui se definen para poderlos usar a lo largo de * todo el programa.*/ JMenuItem closemenu; JMenuItem closeallmenu; JMenuItem closeallexceptmenu; JMenuItem savemenu; JMenuItem saveasmenu; /* Lo mismo que lo anterior, pero para refresh.*/ JMenu refreshmenu; JMenuItem refreshtabmenu; JMenuItem refreshandsavemenu; JButton refreshbutton; /* Similar pero para Insert. */ JMenu insertmenu; JMenuItem annotationmenu; JMenuItem attributemenu; JMenuItem attributegroupmenu; JMenuItem complextypemenu; JMenuItem elementmenu; JMenuItem groupmenu; JMenuItem importmenu; JMenuItem includemenu; JMenuItem notationmenu; JMenuItem redefinemenu;