public void enter() {
    Blackboard Identificadores = app.getBlackboard();
    ID_Inmueble = Integer.parseInt(Identificadores.get("IdInmueble").toString());

    // Mostramos los datos para el inmueble
    PatrimonioPostgre General = new PatrimonioPostgre();
    ArrayList Datos = General.DatosRegistro(ID_Inmueble);
    if (Datos == null) return;
    Iterator alIt = Datos.iterator();
    Iterator itControles = Registro.iterator();
    while (itControles.hasNext()) {
      try {
        JComponent comp = (JComponent) itControles.next();
        Object obj = alIt.next();
        if (comp instanceof JTextField)
          ((JTextField) comp).setText((obj != null) ? obj.toString() : "");
        if (comp instanceof JCheckBox) {
          String check = (obj != null) ? obj.toString() : "";
          if (check == "TRUE") {
            ((JCheckBox) comp).setSelected(true);
          } else {
            ((JCheckBox) comp).setSelected(false);
          }
        }
        if (comp instanceof JComboBox)
          ((JComboBox) comp).setSelectedItem((obj != null) ? obj.toString() : "");
      } catch (Exception A) {
        A.printStackTrace();
      }
    }
  }
  public boolean execute(PlugInContext context) throws Exception {
    if (context.getLayerViewPanel() == null) {
      return false;
    }
    try {
      if (app.getBlackboard().get("temporalincidents") != null)
        app.getBlackboard().put("temporalincidents", new ArrayList<IdEdgeNetworkBean>());

      // JOptionPane.showMessageDialog(app.getMainFrame(),I18N.get("temporalIncidents","routeengine.temporalincidents.remove.removed"));
    } catch (Exception e) {
      context
          .getLayerViewPanel()
          .getContext()
          .warnUser(I18N.get("temporalIncidents", "routeengine.temporalincidents.remove.error"));
      return false;
    }
    JOptionPane.showMessageDialog(
        context.getWorkbenchFrame(),
        I18N.get("temporalIncidents", "routeengine.temporalincidents.remove.removed"));
    context
        .getLayerViewPanel()
        .getContext()
        .setStatusMessage(
            I18N.get("temporalIncidents", "routeengine.temporalincidents.remove.removed"));
    return true;
  }
  public void initialize(FeatureDialogHome fd) {
    GeopistaSchema esquema = (GeopistaSchema) fd.getFeature().getSchema();

    AppContext.getApplicationContext().getBlackboard().put("featureDialog", fd);

    Object obj = fd.getFeature().getAttribute(esquema.getAttributeByColumn("id"));
    if (obj != null
        && !obj.equals("")
        && ((esquema.getGeopistalayer() != null
                && !esquema.getGeopistalayer().isExtracted()
                && !esquema.getGeopistalayer().isLocal())
            || (esquema.getGeopistalayer() == null)
                && fd.getFeature() instanceof GeopistaFeature
                && !((GeopistaFeature) fd.getFeature()).getLayer().isExtracted())) {

      String codprov = null;
      if (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codprov")) != null) {
        codprov =
            (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codprov"))).toString();
      }

      String codmunic = null;
      if (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codmunic")) != null) {
        codmunic =
            (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codmunic"))).toString();
      }

      String entidad = null;
      if (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codentidad")) != null) {
        entidad =
            (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codentidad"))).toString();
      }

      String nucleo = null;
      if (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codpoblamiento")) != null) {
        nucleo =
            (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codpoblamiento")))
                .toString();
      }

      AppContext app = (AppContext) AppContext.getApplicationContext();
      Blackboard Identificadores = app.getBlackboard();
      EdicionOperations operations = new EdicionOperations();
      Identificadores.put(
          "propiedadesnucleosencuestados1_panel",
          operations.getPanelNucleosEncuestados1EIEL(codprov, codmunic, entidad, nucleo));
      Encuestados1Panel encuestados1Panel = new Encuestados1Panel();
      encuestados1Panel.loadDataIdentificacion(codprov, codmunic, entidad, nucleo);
      encuestados1Panel.loadData();
      this.encuestados1Panel = encuestados1Panel;
      fd.addPanel(encuestados1Panel);
    }
  }
  public void initialize(FeatureDialogHome fd) {

    GeopistaSchema esquema = (GeopistaSchema) fd.getFeature().getSchema();

    Object obj = fd.getFeature().getAttribute(esquema.getAttributeByColumn("id"));
    if (obj != null
        && !obj.equals("")
        && ((esquema.getGeopistalayer() != null
                && !esquema.getGeopistalayer().isExtracted()
                && !esquema.getGeopistalayer().isLocal())
            || (esquema.getGeopistalayer() == null)
                && fd.getFeature() instanceof GeopistaFeature
                && !((GeopistaFeature) fd.getFeature()).getLayer().isExtracted())) {
      String clave = null;
      if (fd.getFeature().getAttribute(esquema.getAttributeByColumn("clave")) != null) {
        clave = (fd.getFeature().getAttribute(esquema.getAttributeByColumn("clave"))).toString();
      }

      String codprov = null;
      if (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codprov")) != null) {
        codprov =
            (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codprov"))).toString();
      }

      String codmunic = null;
      if (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codmunic")) != null) {
        codmunic =
            (fd.getFeature().getAttribute(esquema.getAttributeByColumn("codmunic"))).toString();
      }

      String orden_ca = null;
      if (fd.getFeature().getAttribute(esquema.getAttributeByColumn("orden_ca")) != null) {
        orden_ca =
            (fd.getFeature().getAttribute(esquema.getAttributeByColumn("orden_ca"))).toString();
      }

      int ID =
          Integer.parseInt(
              fd.getFeature().getAttribute(esquema.getAttributeByColumn("id")).toString());
      AppContext app = (AppContext) AppContext.getApplicationContext();
      Blackboard Identificadores = app.getBlackboard();
      Identificadores.put("ID_Captacion", ID);

      EdicionOperations operations = new EdicionOperations();
      Identificadores.put("captacion", operations.getCaptacionEIEL(ID));
      CaptacionesPanel captaciones = new CaptacionesPanel();
      captaciones.loadDataIdentificacion(clave, codprov, codmunic, orden_ca);
      captaciones.loadData();
      this.captacionesPanel = captaciones;
      fd.addPanel(captaciones);
    }
  }
  public boolean execute(PlugInContext context) throws Exception {

    JSplitPane splitpane =
        (JSplitPane) appContext.getBlackboard().get(ConstantesGestorFIP.OPEN_GESTORFIP);

    if (splitpane.getDividerLocation() <= 1) {
      splitpane.setDividerLocation(400);
    } else {
      splitpane.setDividerLocation(0);
    }

    return true;
  }
  public String getNombreNucleo(String codentidad, String codnucleo) {

    String nombreNucleo = codentidad;
    aplicacion = (AppContext) AppContext.getApplicationContext();

    HashMap map = (HashMap) aplicacion.getBlackboard().get("HASH_NUCLEOS_MUNICIPIO");

    String claveBusqueda = codentidad + "_" + codnucleo;

    LCGNucleoEIEL nucleoEIEL = (LCGNucleoEIEL) map.get(claveBusqueda);
    if (nucleoEIEL != null) {
      nombreNucleo = "(" + claveBusqueda + ") " + nucleoEIEL.getDenominacion();
    }

    return nombreNucleo;
  }
  public void enter() {
    // Recuperamos el ID_Parcela y el ID_UnidadConstruccion
    AppContext app = (AppContext) AppContext.getApplicationContext();
    Blackboard Identificadores = app.getBlackboard();
    ID_Parcela = Integer.parseInt(Identificadores.get("ID_Parcela").toString());
    // ID_Unidad= Integer.parseInt(Identificadores.get("ID_Unidad").toString());

    // Rellenamos el Listbox
    lstCons.clear();
    try {
      CatastroActualizarPostgre Cons = new CatastroActualizarPostgre();
      ArrayList Datos = Cons.Cons(ID_Parcela);
      Iterator alIt = Datos.iterator();
      while (alIt.hasNext()) {
        lstCons.addElement(alIt.next());
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
 public void exit() {
   AppContext app = (AppContext) AppContext.getApplicationContext();
   Blackboard Identificadores = app.getBlackboard();
   Identificadores.put("ID_Construccion", ID_Construccion);
 }
/** Clase que mostrará la información general que se incluirá en el informe */
public class GeopistaGeneradorListadosDatosGenerales extends JPanel implements WizardPanel {

  AppContext aplicacion = (AppContext) AppContext.getApplicationContext();
  private DefaultListModel modeloList = new DefaultListModel();
  private JList lstCapas = new JList(modeloList);
  private Blackboard blackboardInformes = aplicacion.getBlackboard();
  private JPanel jPanel1 = new JPanel();
  private JLabel lblDatosGenerales = new JLabel();
  private JLabel lblModulo = new JLabel();
  private JComboBox cmbModulos = new JComboBox();
  private JLabel lblCapa = new JLabel();

  private ListSelectionModel listSelectionModel1 = new DefaultListSelectionModel();
  private JSeparator jSeparator1 = new JSeparator();
  private JLabel lblNombreFichero = new JLabel();
  private JTextField txtNombreFichero = new JTextField();
  private JLabel lblOrientacion = new JLabel();
  private JLabel lblDescripcion = new JLabel();
  private JTextField txtDescripcion = new JTextField();
  private JLabel lblTitulo = new JLabel();
  private JTextField txtTituloInforme = new JTextField();

  public Connection con = null;

  public GeopistaGeneradorListadosDatosGenerales() {
    try {

      jbInit();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  private void jbInit() throws Exception {
    // Leemos la conexion

    //
    //    con = getDBConnection();
    GeopistaGeneradorListadosConexionBD geopistaListados =
        new GeopistaGeneradorListadosConexionBD();

    this.setLayout(null);
    this.setSize(new Dimension(854, 500));
    jPanel1.setLayout(null);
    jPanel1.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.RAISED));
    lblDatosGenerales.setText(aplicacion.getI18nString("generador.app.reports.datos.generales"));
    lblModulo.setText(aplicacion.getI18nString("generador.app.reports.modulo"));
    lblCapa.setText(aplicacion.getI18nString("generador.app.reports.capa"));

    // Cargamos la lista de capas
    ArrayList capas = geopistaListados.capasGeopista();

    Iterator i = capas.iterator();
    lblDatosGenerales.setBounds(new Rectangle(135, 5, 185, 20));
    lblModulo.setBounds(new Rectangle(135, 23, 60, 25));
    lblCapa.setBounds(new Rectangle(135, 50, 45, 30));
    jPanel1.setBounds(new Rectangle(10, 15, 750, 500));
    jSeparator1.setBounds(new Rectangle(0, 135, 735, 5));
    while (i.hasNext()) {
      modeloList.addElement(i.next());
    }

    // Creamos la lista con el modelo anteriormente definido

    // --    jPanel1.setSize(new Dimension(750, 600));
    cmbModulos.setBackground(new Color(254, 255, 255));
    cmbModulos.setBounds(new Rectangle(215, 25, 520, 20));

    lstCapas.setSelectionModel(listSelectionModel1);

    lblTitulo.setText(aplicacion.getI18nString("informe.datos.seleccion.titulo.fichero"));
    lblTitulo.setBounds(new Rectangle(140, 215, 95, 15));
    txtTituloInforme.setBounds(new Rectangle(140, 230, 595, 20));

    lstCapas.addKeyListener(
        new java.awt.event.KeyAdapter() {
          public void keyReleased(java.awt.event.KeyEvent e) {
            String cadena = (String) lstCapas.getSelectedValue();
            lstCapas.ensureIndexIsVisible(lstCapas.getSelectedIndex());
            lstCapas.setSelectedValue((String) cadena, true);
          }
        });
    lstCapas.addMouseListener(
        new MouseListener() {
          public void mouseClicked(MouseEvent e) {
            wizardContext.inputChanged();
          }

          public void mousePressed(MouseEvent e) {}

          public void mouseReleased(MouseEvent e) {}

          public void mouseEntered(MouseEvent e) {}

          {
          }

          public void mouseExited(MouseEvent e) {}
        });

    lblDescripcion.setText(aplicacion.getI18nString("generador.app.reports.descripcion.informe"));
    lblDescripcion.setBounds(new Rectangle(140, 255, 95, 20));
    txtDescripcion.setBounds(new Rectangle(140, 280, 595, 95));
    lblOrientacion.setText(aplicacion.getI18nString("generador.app.reports.orientacion.informe"));
    lblOrientacion.setBounds(new Rectangle(135, 178, 85, 25));
    lblNombreFichero.setText(aplicacion.getI18nString("generador.app.reports.nombre.fichero"));
    lblNombreFichero.setBounds(new Rectangle(135, 145, 120, 30));
    txtNombreFichero.setBounds(new Rectangle(215, 150, 520, 20));

    //    hb.enableHelpKey(this,"encabezado",hs);
    // Ponemos a mano los Módulos , prueba
    cmbModulos.addItem(
        (String) aplicacion.getI18nString("generador.app.reports.modulo.planeamiento"));
    cmbModulos.addItem(aplicacion.getI18nString("generador.app.reports.modulo.catastro"));
    cmbModulos.addItem(aplicacion.getI18nString("generador.app.reports.modulo.informacion"));
    cmbModulos.addItem(aplicacion.getI18nString("generador.app.reports.modulo.patrimonio"));
    cmbModulos.addItem(aplicacion.getI18nString("generador.app.reports.modulo.infraestructuras"));
    // Ponemos las explicaciones de las secciones
    /*  lblExplicacionDatosInformes.setText(aplicacion.getI18nString("informe.datos.generales.explicacion.comentarios"));
    txtTituloInforme.setToolTipText(aplicacion.getI18nString("informe.datos.generales.explicacion.titulo.fichero"));
    txtDescripcion.setToolTipText(aplicacion.getI18nString("informe.datos.generales.explicacion.detalle"));
    txtNombreFichero.setToolTipText(aplicacion.getI18nString("informe.datos.generales.explicacion.nombre.fichero"));
    lblUbicacion.setText(aplicacion.getI18nString("informe.datos.generales.explicacion.ubicacion"));*/

    // Ponemos a mano la horientacion
    optVertical.setText(aplicacion.getI18nString("generador.app.reports.orientacion.vertical"));
    optHorizontal.setText(aplicacion.getI18nString("generador.app.reports.orientacion.horizontal"));

    // Nuevo Listener para ver cuando cambia la caja de texto
    txtTituloInforme.addKeyListener(
        new KeyListener() {
          public void keyTyped(KeyEvent e) {}

          public void keyPressed(KeyEvent e) {
            wizardContext.inputChanged();
          }

          public void keyReleased(KeyEvent e) {}
        });
    optVertical.setText(aplicacion.getI18nString("generador.app.reports.orientacion.vertical"));
    optVertical.setSelected(true);
    optVertical.setBounds(new Rectangle(215, 180, 125, 20));
    optVertical.addActionListener(
        new ActionListener() {
          public void actionPerformed(ActionEvent e) {
            optVertical_actionPerformed(e);
          }
        });
    optHorizontal.setText(aplicacion.getI18nString("generador.app.reports.orientacion.horizontal"));
    optHorizontal.setBounds(new Rectangle(360, 180, 135, 20));
    optHorizontal.addActionListener(
        new ActionListener() {
          public void actionPerformed(ActionEvent e) {
            optHorizontal_actionPerformed(e);
          }
        });
    jScrollPane1.setBounds(new Rectangle(215, 60, 520, 70));
    jSeparator2.setBounds(new Rectangle(5, 205, 730, 5));
    lblImagen.setBounds(new Rectangle(15, 20, 110, 490));
    lblImagen.setIcon(IconLoader.icon((String) blackboardInformes.get("tipoBanner")));
    lblImagen.setBounds(new Rectangle(15, 20, 110, 490));
    lblImagen.setBorder(BorderFactory.createLineBorder(Color.black, 1));
    lblImagen.setBorder(BorderFactory.createLineBorder(Color.black, 1));

    txtNombreFichero.addKeyListener(
        new KeyListener() {
          public void keyTyped(KeyEvent e) {}

          public void keyPressed(KeyEvent e) {
            wizardContext.inputChanged();
          }

          public void keyReleased(KeyEvent e) {}
        });

    jScrollPane1.getViewport().add(lstCapas, null);
    jPanel1.add(jSeparator2, null);
    jPanel1.add(jScrollPane1, null);
    jPanel1.add(optHorizontal, null);
    jPanel1.add(optVertical, null);
    jPanel1.add(txtTituloInforme, null);
    jPanel1.add(lblTitulo, null);
    jPanel1.add(txtDescripcion, null);
    jPanel1.add(lblDescripcion, null);
    jPanel1.add(lblOrientacion, null);
    jPanel1.add(txtNombreFichero, null);
    jPanel1.add(lblNombreFichero, null);
    jPanel1.add(jSeparator1, null);
    jPanel1.add(lblCapa, null);
    jPanel1.add(cmbModulos, null);
    jPanel1.add(lblModulo, null);
    jPanel1.add(lblDatosGenerales, null);
    this.add(lblImagen, null);
    this.add(jPanel1, null);

    // Cargamos las capas en la lista

  }

  public void enteredFromLeft(Map dataMap) {
    try {
      // HelpSet de Ayuda
      String helpHS = "ayuda.hs";
      HelpSet hs = com.geopista.app.help.HelpLoader.getHelpSet(helpHS);
      HelpBroker hb = hs.createHelpBroker();
      hb.enableHelpKey(this, "generadorInformeDatosGenerales", hs);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /** Called when the user presses Next on this panel */
  public void exitingToRight() throws Exception {
    // ponemos en un objeto listaTablas las capas qeu se utilizan

    // DefaultListModel recuperar = (DefaultListModel) lstCapas.getModel();

    java.util.List listaTablasInformes = null;
    GeopistaObjetoInformeDatosGenerales objetoDatosGenerales =
        new GeopistaObjetoInformeDatosGenerales();
    listaTablasInformes = Arrays.asList(lstCapas.getSelectedValues());

    // Pasamos los datos al objeto
    objetoDatosGenerales.setCapas(listaTablasInformes);
    objetoDatosGenerales.setModulo((String) cmbModulos.getSelectedItem());
    objetoDatosGenerales.setTitulo(txtTituloInforme.getText());
    if (optVertical.isSelected()) {
      objetoDatosGenerales.setOrientacion(optVertical.getText());
    } else {
      objetoDatosGenerales.setOrientacion(optHorizontal.getText());
    }

    objetoDatosGenerales.setNombreFichero(txtNombreFichero.getText());
    objetoDatosGenerales.setDescripcion(txtDescripcion.getText());

    blackboardInformes.put("datosGenerales", objetoDatosGenerales);
  }

  /**
   * Tip: Delegate to an InputChangedFirer.
   *
   * @param listener a party to notify when the input changes (usually the WizardDialog, which needs
   *     to know when to update the enabled state of the buttons.
   */
  public void add(InputChangedListener listener) {}

  public void remove(InputChangedListener listener) {}

  public String getTitle() {
    return " ";
  }

  public String getID() {
    return "2";
  }

  private WizardContext wizardContext;
  private JRadioButton optVertical = new JRadioButton();
  private JRadioButton optHorizontal = new JRadioButton();
  private JScrollPane jScrollPane1 = new JScrollPane();
  private JSeparator jSeparator2 = new JSeparator();

  public void setWizardContext(WizardContext wd) {

    wizardContext = wd;
  }

  public String getInstructions() {
    return " ";
  }

  public boolean isInputValid() {

    if (txtNombreFichero.getText().equals("")) {

      return false;
    } else {

      // Comprobar que hay capas selecionadas

      if (lstCapas.getSelectedIndices().length == 0) {
        return false;
      } else {
        if (txtTituloInforme.getText().equals("")) {
          return false;
        } else {
          return true;
        }
      }
    }
  }

  private String nextID = "3";
  private JLabel lblImagen = new JLabel();

  public void setNextID(String nextID) {
    this.nextID = nextID;
  }
  /** @return null to turn the Next button into a Finish button */
  public String getNextID() {
    return nextID;
  }

  private void cmbOrientacion_actionPerformed(ActionEvent e) {}

  /**
   * Devuevle la conexion para acceso a la base de datos
   *
   * @return conexion para acceder a la base de datos
   */
  public static Connection getDBConnection() throws SQLException {
    GeopistaInformesPostgresCon geoConex = new GeopistaInformesPostgresCon();
    Connection conn = null;
    try {
      conn = geoConex.abrirConexion();
      conn.setAutoCommit(false);
    } catch (Exception e) {
      return null;
    }

    return conn;
  }

  private void optVertical_actionPerformed(ActionEvent e) {
    optHorizontal.setSelected(false);
  }

  private void optHorizontal_actionPerformed(ActionEvent e) {
    optVertical.setSelected(false);
  }

  /* (non-Javadoc)
   * @see com.geopista.ui.wizard.WizardPanel#exiting()
   */
  public void exiting() {
    // TODO Auto-generated method stub

  }
}
Beispiel #10
0
public class ImportarUtils {
  public static final String HTML_ROJO = "<p><font face=SansSerif size=3 color=#ff0000><b>";
  public static final String HTML_VERDE = "<p><font face=SansSerif size=3 color=#009900><b>";
  public static final String HTML_NUEVO_PARRAFO = "<p><font face=SansSerif size=3>";
  public static final String HTML_FIN_PARRAFO = "</b></font></p>";
  public static final String HTML_SALTO = "<BR>";
  public static final boolean BORDERS_OFF = false;
  public static final boolean BORDERS_ON = true;

  public static final String LAST_IMPORT_DIRECTORY = "lastImportDirectory";
  public static final String LAST_IMPORT_DIRECTORY_IMAGENES = "lastImportDirectoryImagenes";
  public static final String FILE_TO_IMPORT = "fileToImport";
  public static final String FILE_TYPE = "fileType";
  public static final String FILE_TXT_MULTILINE = "txtMultiline";
  public static final String LISTA_PARCELAS = "listaParcelas";
  public static final String LISTA_IMAGENES = "listaImagenes";

  private AppContext application = (AppContext) AppContext.getApplicationContext();
  private Blackboard blackboard = application.getBlackboard();

  public static Boolean res = null;

  /**
   * Formatea una cadena en HTML en forma "clave: valor", con la clave en negrita
   *
   * @param field Texto a resaltar en negrita (nombre del campo)
   * @param value Valor a mostrar
   * @return String con la cadena HTML
   */
  public static String getStringHtmlFormattedText(String field, String value) {
    return getStringHtmlFormattedText(field, value).toString();
  }

  /**
   * Formatea una cadena en HTML en forma "clave: valor", con la clave en negrita
   *
   * @param field Texto a resaltar en negrita (nombre del campo)
   * @param value Valor a mostrar
   * @return StringBuffer con la cadena HTML
   */
  public static StringBuffer getStringBufferHtmlFormattedText(String field, String value) {
    StringBuffer sb = new StringBuffer();
    sb.append("<p><b>").append(field).append(": </b>").append(value).append("</p>");
    return sb;
  }

  /**
   * Formatea una cadena en HTML en forma "clave: valor", con la clave en negrita
   *
   * @param field Texto a resaltar en negrita (nombre del campo)
   * @param value int con el valor a mostrar
   * @return StringBuffer con la cadena HTML
   */
  public static StringBuffer getStringBufferHtmlFormattedText(String field, int value) {
    return getStringBufferHtmlFormattedText(field, new Integer(value).toString());
  }

  /**
   * Formatea una cadena en HTML en forma "clave: valor", con la clave en negrita
   *
   * @param field Texto a resaltar en negrita (nombre del campo)
   * @param value long con el valor a mostrar
   * @return StringBuffer con la cadena HTML
   */
  public static StringBuffer getStringBufferHtmlFormattedText(String field, long value) {
    return getStringBufferHtmlFormattedText(field, new Long(value).toString());
  }
  /**
   * Recupera la fecha actual
   *
   * @param frm Patrón de generación de la fecha
   * @return Fecha actual en formato String
   */
  public static String getDate(String frm) {
    return (String) new SimpleDateFormat(frm).format(new Date());
  }
  /**
   * Recupera la fecha actual con patrón "dd-MMM-yyyy HH:mm:ss"
   *
   * @return Fecha actual en formato String
   */
  public static String getDate() {
    return getDate("dd-MMM-yyyy HH:mm:ss");
  }

  /**
   * Resalta un texto, creando un nuevo párrafo en negrita y verde, formateado en HTML
   *
   * @param text Texto a resaltar
   * @return String con el texto resaltado en HTML
   */
  public static String getEnhancedInformationMessage(String text) {
    StringBuffer sb = new StringBuffer();
    sb.append(HTML_SALTO).append(HTML_VERDE).append(text).append(HTML_FIN_PARRAFO);

    return sb.toString();
  }

  /**
   * Método para determinar si un fichero de texto tiene el tamaño esperado
   *
   * @param String path Ruta del fichero a comprobar que sea correcto
   * @param int size Tamaño esperado de cada registro del fichero
   * @return boolean true si es correcto, false en caso contrario
   */
  public static boolean testFileSize(String path, int size) {
    boolean hasExpectedLength = true;
    try {
      BufferedReader reader = new BufferedReader(new FileReader(path));
      String str = null;
      while ((str = reader.readLine()) != null) {
        if (str.length() != size) {
          hasExpectedLength = false;
          break;
        }
      }
      reader.close();
    } catch (Exception e) {
      e.printStackTrace();
      return hasExpectedLength;
    }
    return hasExpectedLength;
  }

  /**
   * Devuelve una lista de filas erroneas dentro de un fichero de tipo texto
   *
   * @param path Ruta donde se encuentra el fichero a comprobar
   * @param lstTypes Lista con los posibles comienzos de registro
   * @param
   * @return ArrayList con la lista de índices de los registros erroneos
   */
  public static ArrayList getErroneousRows(
      String path, ArrayList lstTypes, boolean includeBorders) {
    ArrayList lst = new ArrayList();
    try {
      BufferedReader reader = new BufferedReader(new FileReader(path));
      String str = null;
      int rowIndex = 0;
      while ((str = reader.readLine()) != null) {
        rowIndex++;

        if (!lstTypes.contains(str.substring(0, 2))) {
          lst.add(new Integer(rowIndex));
        }
      }

      // Si en la lista de tipos no se han incluido los tipos de la cabecera y de la cola, se
      // eliminan de la lista de erroneos
      if (!includeBorders) {
        lst.remove(new Integer(rowIndex));
        lst.remove(new Integer(1));
      }

      reader.close();

    } catch (Exception e) {
      e.printStackTrace();
    }

    return lst;
  }

  /**
   * Comprueba si un fichero de texto tiene cabecera válida
   *
   * @param path Fichero a comprobar
   * @param headerType Cadena de inicio del registro de cabecera
   * @return True si el fichero tiene cabecera válida
   */
  public static boolean testHeader(String path, String headerType) {
    boolean hasHeader = false;
    try {
      BufferedReader reader = new BufferedReader(new FileReader(path));
      String str = null;

      if ((str = reader.readLine()) != null) {
        if (str.startsWith(headerType)) {
          hasHeader = true;
        }
      }
      reader.close();

    } catch (Exception e) {
      e.printStackTrace();
    }

    return hasHeader;
  }

  /**
   * Comprueba si un fichero de texto tiene cola válida
   *
   * @param path Fichero a comprobar
   * @param tailType Cadena de inicio del registro de cola
   * @return True si el fichero tiene cola válida
   */
  public static boolean testTail(String path, String tailType) {
    boolean hasTail = false;
    try {
      BufferedReader reader = new BufferedReader(new FileReader(path));
      String str = null;

      // al recorrer todo el fichero, hasTail tomará el resultado de la comprobación
      // para el último registro
      while ((str = reader.readLine()) != null) {
        if (str.startsWith(tailType)) {
          hasTail = true;
        }
      }
      reader.close();

    } catch (Exception e) {
      e.printStackTrace();
    }

    return hasTail;
  }

  public static String doubleToStringWithFactor(double d, int factor) {
    NumberFormat form = new DecimalFormat("##");

    String s = form.format(d * factor);
    if (s.contains(".")) {
      s = s.substring(0, s.indexOf("."));
    }
    return s;
  }

  public static String floatToStringWithFactor(float f, int factor) {
    NumberFormat form = new DecimalFormat("##");

    String s = form.format(f * factor);
    // String s = String.valueOf(f*factor);

    s = s.substring(0, s.indexOf("."));

    return s;
  }

  public static double strToDouble(String value) {
    double d = 0;
    if (value.length() != 0) d = Double.parseDouble(value);

    return d;
  }

  public static float strToFloat(String value) {
    float f = 0;
    if (value.length() != 0) f = Float.parseFloat(value);

    return f;
  }

  /**
   * Convierte un InputStream en String
   *
   * @param is
   * @return
   */
  public String parseISToString(java.io.InputStream is) {
    java.io.DataInputStream din = new java.io.DataInputStream(is);
    StringBuffer sb = new StringBuffer();
    try {
      String line = null;
      while ((line = din.readLine()) != null) {
        sb.append(line + "\n");
      }
    } catch (Exception ex) {
      ex.getMessage();
    } finally {
      try {
        is.close();
      } catch (Exception ex) {
      }
    }
    return sb.toString();
  }

  /**
   * Convierte un String en in InputStream
   *
   * @param xml
   * @return
   */
  public static java.io.InputStream parseStringToIS(String xml) {
    if (xml == null) return null;
    xml = xml.trim();
    java.io.InputStream in = null;
    try {
      in = new java.io.ByteArrayInputStream(xml.getBytes("UTF-8"));
    } catch (Exception ex) {
    }
    return in;
  }

  /**
   * Transforma de base64 a cadena de caracteres ASCII
   *
   * @param base64 Cadena en base 64 binario
   * @return Cadena de caracteres ASCII equivalente a la cadena en base 64
   */
  public static String base64ToAscii(String base64) {
    String ascii = null;
    byte[] bytes;
    try {
      bytes = new sun.misc.BASE64Decoder().decodeBuffer(base64);
      ascii = new String(bytes);
    } catch (IOException e) {
      e.printStackTrace();
    }
    return ascii;
  }

  /**
   * Transforma una cadena ascii a base 64
   *
   * @param ascii Cadena en ASCII a transformar
   * @return Cadena de caracteres en base 64 equivalente a la cadena ASCII
   */
  public static String asciiToBase64(String ascii) {
    return new sun.misc.BASE64Encoder().encode(ascii.getBytes());
  }

  public InputSource resolveEntity(String arg0, String arg1) throws SAXException, IOException {
    // TODO Auto-generated method stub
    return null;
  }

  public String getImagenCatastroXML(ArrayList lstImagenes) {

    String lstImagenesXML = "<limg>";
    for (Iterator itImagenes = lstImagenes.iterator(); itImagenes.hasNext(); ) {

      ImagenCatastro imagen = (ImagenCatastro) itImagenes.next();
      lstImagenesXML = lstImagenesXML + "<img>";

      lstImagenesXML = lstImagenesXML + "<nom>" + imagen.getNombre() + "</nom>";
      lstImagenesXML = lstImagenesXML + "<frmt>" + imagen.getExtension() + "</frmt>";
      lstImagenesXML = lstImagenesXML + "<tdo>" + imagen.getTipoDocumento() + "</tdo>";
      lstImagenesXML = lstImagenesXML + "<foto>" + imagen.getFoto() + "</foto>";

      lstImagenesXML = lstImagenesXML + "</img>";
    }
    lstImagenesXML = lstImagenesXML + "</limg>";

    return lstImagenesXML;
  }

  public static void reportExceptions(
      ArrayList exceptions, DataSourceQuery dataSourceQuery, WorkbenchContext context) {
    context
        .getIWorkbench()
        .getFrame()
        .getOutputFrame()
        .addHeader(
            1,
            exceptions.size()
                + " problem"
                + StringUtil.s(exceptions.size())
                + " loading "
                + dataSourceQuery.toString()
                + "."
                + ((exceptions.size() > 10) ? " First and last five:" : ""));
    context.getIWorkbench().getFrame().getOutputFrame().addText("See View / Log for stack traces");
    context.getIWorkbench().getFrame().getOutputFrame().append("<ul>");

    Collection exceptionsToReport =
        exceptions.size() <= 10
            ? exceptions
            : CollectionUtil.concatenate(
                Arrays.asList(
                    new Collection[] {
                      exceptions.subList(0, 5),
                      exceptions.subList(exceptions.size() - 5, exceptions.size())
                    }));
    for (Iterator j = exceptionsToReport.iterator(); j.hasNext(); ) {
      Exception exception = (Exception) j.next();
      context.getIWorkbench().getGuiComponent().log(StringUtil.stackTrace(exception));
      context.getIWorkbench().getFrame().getOutputFrame().append("<li>");
      context
          .getIWorkbench()
          .getFrame()
          .getOutputFrame()
          .append(GUIUtil.escapeHTML(WorkbenchFrameImpl.toMessage(exception), true, true));
      context.getIWorkbench().getFrame().getOutputFrame().append("</li>");
    }
    context.getIWorkbench().getFrame().getOutputFrame().append("</ul>");
  }

  public static String[] extensions(Class readerWriterDataSourceClass) {
    try {
      return ((StandardReaderWriterFileDataSource) readerWriterDataSourceClass.newInstance())
          .getExtensions();
    } catch (Exception e) {
      Assert.shouldNeverReachHere(e.toString());
      return null;
    }
  }

  public static Geometry obtenerGeometriaParcela(String dxf) {
    return obtenerGeometriaParcela(dxf, null);
  }

  public static Geometry obtenerGeometriaParcela(String dxf, WorkbenchContext context) {

    Geometry geometryParcela = null;

    GeopistaLoadDxfQueryChooser dxfLoad =
        new GeopistaLoadDxfQueryChooser(Dxf.class, "GEOPISTA dxf", extensions(Dxf.class), context);

    InputStream fileDXF = ImportarUtils_LCGIII.parseStringToIS(dxf);

    try {
      Assert.isTrue(!dxfLoad.getDataSourceQueries(fileDXF).isEmpty());
    } catch (AssertionFailedException e) {
      throw new AssertionFailedException(I18N.get("FileEmpty"));
    }

    fileDXF = ImportarUtils_LCGIII.parseStringToIS(dxf);

    boolean exceptionsEncountered = false;
    for (Iterator i = dxfLoad.getDataSourceQueries(fileDXF).iterator(); i.hasNext(); ) {
      DataSourceQuery dataSourceQuery = (DataSourceQuery) i.next();

      ArrayList exceptions = new ArrayList();
      Assert.isTrue(dataSourceQuery.getDataSource().isReadable());

      Connection connection = dataSourceQuery.getDataSource().getConnection();
      try {
        FeatureCollection dataset =
            dataSourceQuery
                .getDataSource()
                .installCoordinateSystem(
                    connection.executeQuery(dataSourceQuery.getQuery(), exceptions, null), null);
        if (dataset != null) {

          String layerName = dataSourceQuery.toString();
          Geometry geometriaInicial = null;
          GeopistaFeature featureInicial = null;

          if (layerName.startsWith("PG-LP")) {
            // Obtener el borde con las features de la capa
            ArrayList lstFeatures = new ArrayList();
            for (Iterator features = dataset.getFeatures().iterator(); features.hasNext(); ) {
              GeopistaFeature feature = (GeopistaFeature) features.next();
              lstFeatures.add(feature);
            }
            ArrayList coordenadas = new ArrayList();

            if (lstFeatures != null && lstFeatures.size() > 0) {

              featureInicial = (GeopistaFeature) lstFeatures.iterator().next();
              lstFeatures.remove(featureInicial);
              geometriaInicial = featureInicial.getGeometry();
              for (int indice = 0; indice < geometriaInicial.getCoordinates().length; indice++)
                coordenadas.add(geometriaInicial.getCoordinates()[indice]);

              if (geometriaInicial instanceof LineString) {

                Point puntoFinal = ((LineString) geometriaInicial).getEndPoint();
                GeopistaFeature feature = null;
                Geometry geometria = null;
                int indice;

                while (lstFeatures.size() > 0) {
                  boolean encontrado = false;
                  Iterator features = lstFeatures.iterator();
                  while (features.hasNext() && !encontrado) {

                    feature = (GeopistaFeature) features.next();
                    geometria = feature.getGeometry();
                    if (geometria instanceof LineString) {

                      if (puntoFinal.distance(((LineString) geometria).getStartPoint()) == 0) {

                        for (indice = 1; indice < geometria.getCoordinates().length; indice++)
                          coordenadas.add(geometria.getCoordinates()[indice]);
                        puntoFinal = ((LineString) geometria).getEndPoint();
                        encontrado = true;

                      } else if (puntoFinal.distance(((LineString) geometria).getEndPoint()) == 0) {
                        for (indice = geometria.getCoordinates().length - 2; indice >= 0; indice--)
                          coordenadas.add(geometria.getCoordinates()[indice]);

                        puntoFinal = ((LineString) geometria).getStartPoint();
                        encontrado = true;
                      }
                    }
                  }
                  if (encontrado) {
                    lstFeatures.remove(feature);
                  }
                }
                Coordinate[] coordenadasParcela = new Coordinate[coordenadas.size()];
                indice = 0;
                for (Iterator coordenada = coordenadas.iterator(); coordenada.hasNext(); ) {
                  coordenadasParcela[indice] = (Coordinate) coordenada.next();
                  indice++;
                }

                if (coordenadasParcela[0].equals3D(
                    coordenadasParcela[coordenadasParcela.length - 1])) {
                  LinearRing lineaParcela =
                      geometriaInicial.getFactory().createLinearRing(coordenadasParcela);
                  Polygon poligonoParcela = null;
                  poligonoParcela = geometriaInicial.getFactory().createPolygon(lineaParcela, null);
                  geometryParcela = poligonoParcela;
                }
              }
            }
          }
        }
      } finally {
        connection.close();
      }
      if (!exceptions.isEmpty()) {
        if (!exceptionsEncountered) {
          context.getIWorkbench().getFrame().getOutputFrame().createNewDocument();
          exceptionsEncountered = true;
        }
        reportExceptions(exceptions, dataSourceQuery, context);
      }
    }
    if (exceptionsEncountered) {
      context
          .getIWorkbench()
          .getGuiComponent()
          .warnUser("Problems were encountered. See Output Window for details.");
    }

    return geometryParcela;
  }
}
public class TablesDomainsPanel extends JPanel
    implements FeatureExtendedPanel, TreeSelectionListener {

  private JPanelTables jPanelTablas;
  private JPanelDominios jPanelDominios;
  private JPanel jPanelLevel = new JPanel();

  private JLabel lblLevel = new JLabel();
  private JTextField txtLevel = new JTextField();

  private JButton jButtonSalir = new JButton();;
  private JButton jButtonAsociar = new JButton();
  private JButton jButtonDesasociar = new JButton();
  private JPanel templateJPanel = new JPanel();
  private JScrollPane templateJScrollPane = new JScrollPane();

  private ResourceBundle messages;

  private JTree treeDominios = new JTree();
  private JTree treeDominiosParticular = new JTree();
  private JTree treeTablas = new JTree();

  boolean nodoParticular = false;
  boolean nodoGeneral = false;
  boolean nodoTablas = false;

  private com.geopista.protocol.administrador.dominios.Domain auxDomain =
      new com.geopista.protocol.administrador.dominios.Domain();
  private Column auxColumn = new Column();
  private static AppContext aplicacion = (AppContext) AppContext.getApplicationContext();
  private Blackboard Identificadores = aplicacion.getBlackboard();

  boolean levelActivado = false;
  int idMunicipio = 0;

  /** Constructor de la clase */
  public TablesDomainsPanel() {
    // Operaciones para añadir el panel de tablas
    try {
      UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
      initComponents();
    } catch (Exception e) {
      e.printStackTrace();
      System.err.println("Couldn't use system look and feel.");
    }
  }

  /** Inicialización de los componentes */
  private void initComponents() {

    this.setBounds(new Rectangle(10, 10, 1000, 830));
    this.setBorder(BorderFactory.createLineBorder(Color.black, 1));
    this.setLayout(null);

    // Operaciones para añadir el panel de dominios
    try {

      // aplicacion.login();
      com.geopista.app.administrador.init.Constantes.url =
          aplicacion.getString("geopista.conexion.servidorurl")
              + WebAppConstants.ADMINISTRACION_WEBAPP_NAME;
      //
      // com.geopista.app.administrador.init.Constantes.idMunicipio=Integer.parseInt(AppContext.getApplicationContext().getString("geopista.DefaultCityId"));
      com.geopista.app.administrador.init.Constantes.idEntidad = aplicacion.getIdEntidad();
      // com.geopista.security.SecurityManager.setHeartBeatTime(100000);
      com.geopista.security.SecurityManager.setHeartBeatTime(10000);
      com.geopista.security.SecurityManager.setsUrl(
          com.geopista.app.administrador.init.Constantes.url);
      com.geopista.app.administrador.init.Constantes.Locale =
          aplicacion.getUserPreference(
              AppContext.GEOPISTA_LOCALE_KEY, GestorCapas.DEFAULT_LOCALE, false);

      /*Municipio municipio =
          (new OperacionesAdministrador(com.geopista.app.administrador.init.Constantes.url))
          .getMunicipio(new Integer(com.geopista.app.administrador.init.Constantes.idMunicipio).toString());
      if (municipio!=null)
      {
          com.geopista.app.administrador.init.Constantes.Municipio = municipio.getNombre();
          com.geopista.app.administrador.init.Constantes.Provincia= municipio.getProvincia();
      }*/
      Entidad entidad =
          (new OperacionesAdministrador(com.geopista.app.administrador.init.Constantes.url))
              .getEntidad(
                  new Integer(com.geopista.app.administrador.init.Constantes.idEntidad).toString());
      if (entidad != null) {
        com.geopista.app.administrador.init.Constantes.Entidad = entidad.getNombre();
        // com.geopista.app.administrador.init.Constantes.Provincia= municipio.getProvincia();
      }

      try {
        messages =
            ResourceBundle.getBundle(
                "config.administrador",
                new Locale(
                    aplicacion.getUserPreference(
                        AppContext.GEOPISTA_LOCALE_KEY, GestorCapas.DEFAULT_LOCALE, false)));
      } catch (Exception e) {
        messages =
            ResourceBundle.getBundle(
                "config.administrador", new Locale(GestorCapas.DEFAULT_LOCALE));
      }

      jPanelDominios = new JPanelDominios(messages, aplicacion.getMainFrame());
      jPanelDominios.hideLeyenda();

    } catch (Exception e) {

      e.printStackTrace();
    }

    templateJScrollPane = new JScrollPane();
    templateJPanel = new JPanel();
    templateJPanel.setLayout(new BorderLayout());

    // jButtonSalir.setBounds(new Rectangle(350, 555, 100, 25));
    jButtonSalir.setBounds(new Rectangle(875, 555, 100, 25));

    jButtonSalir.setMaximumSize(new java.awt.Dimension(100, 25));
    jButtonSalir.setPreferredSize(new java.awt.Dimension(75, 25));
    jButtonSalir.addActionListener(
        new java.awt.event.ActionListener() {
          public void actionPerformed(java.awt.event.ActionEvent evt) {
            jButtonSalirActionPerformed();
          }
        });

    // aplicacion.loadI18NResource("GestorCapasi18n");
    jButtonSalir.setText(I18N.get("GestorCapas", "general.boton.salir"));

    templateJScrollPane.setViewportView(templateJPanel);

    jPanelDominios.setBounds(new Rectangle(260, 5, 740, 550));

    jPanelLevel.setBounds(new java.awt.Rectangle(15, 490, 200, 25));
    lblLevel.setText(I18N.get("GestorCapas", "tablas.level.dominio"));
    txtLevel.setText("0 ");
    txtLevel.setBounds(new Rectangle(50, 5, 40, 15));
    txtLevel.setEnabled(false);
    lblLevel.setBackground(Color.GRAY);
    jPanelLevel.add(lblLevel, null);
    jPanelLevel.add(txtLevel, null);

    jButtonAsociar.setBounds(new java.awt.Rectangle(35, 525, 180, 25));
    jButtonAsociar.setEnabled(false);
    jButtonAsociar.addActionListener(
        new java.awt.event.ActionListener() {
          public void actionPerformed(java.awt.event.ActionEvent evt) {
            jButtonAsociarActionPerformed();
          }
        });
    jButtonAsociar.setText(I18N.get("GestorCapas", "tablas.boton.asociar"));

    jButtonDesasociar.setBounds(new java.awt.Rectangle(35, 555, 180, 25));
    jButtonDesasociar.setEnabled(false);
    jButtonDesasociar.addActionListener(
        new java.awt.event.ActionListener() {
          public void actionPerformed(java.awt.event.ActionEvent evt) {
            jButtonDesasociarActionPerformed();
          }
        });
    jButtonDesasociar.setText(I18N.get("GestorCapas", "tablas.boton.desasociar"));

    jPanelTablas = new JPanelTables(TreeSelectionModel.SINGLE_TREE_SELECTION);
    jPanelTablas.setBorder(
        BorderFactory.createTitledBorder(I18N.get("GestorCapas", "tablas.arbol.titulo")));
    jPanelTablas.setBounds(new java.awt.Rectangle(5, 5, 250, 481));

    jPanelDominios.changeScreenLang(messages);

    treeDominios = jPanelDominios.getJTreeArbol();
    treeDominios.addTreeSelectionListener(this);

    treeDominiosParticular = jPanelDominios.getJTreeArbolParticular();
    treeDominiosParticular.addTreeSelectionListener(this);

    treeTablas = jPanelTablas.getTree();
    treeTablas.addTreeSelectionListener(this);

    this.add(jPanelDominios, null);
    this.add(jButtonSalir, null);
    this.add(jPanelTablas, null);
    this.add(jButtonAsociar, null);
    this.add(jButtonDesasociar, null);
    this.add(jPanelLevel, null);
  }

  /** Acción realizada al pulsar el botón de salir de la aplicación */
  private void jButtonSalirActionPerformed() {
    String string1 = I18N.get("GestorCapas", "general.si");
    String string2 = I18N.get("GestorCapas", "general.no");
    Object[] options = {string1, string2};

    int n =
        JOptionPane.showOptionDialog(
            this,
            I18N.get("GestorCapas", "general.salir.mensaje"),
            "",
            JOptionPane.YES_NO_OPTION,
            JOptionPane.QUESTION_MESSAGE,
            null,
            options,
            options[1]);
    if (n == JOptionPane.NO_OPTION) return;

    aplicacion.getMainFrame().dispose();
    System.exit(0);
  }

  /** Acción realizada al pulsar el botón de asociar de la aplicación */
  private void jButtonAsociarActionPerformed() {
    try {
      // Convierte com.geopista.protocol.administrador.dominios.Domain
      // en com.geopista.features.Domain

      int idDomain = Integer.parseInt(auxDomain.getIdDomain());
      String nombreDominio = auxDomain.getName();
      LayerOperations operaciones = new LayerOperations();
      Domain dominio = operaciones.obtenerDominioTipo(idDomain, nombreDominio);

      // asocia el dominio a la columna
      int iRes =
          operaciones.actualizarDominioColumna(
              auxColumn, dominio, Integer.parseInt(txtLevel.getText()));
      // auxColumn.setDomain(dominio);

      if (iRes > 0) {
        JOptionPane optionPane =
            new JOptionPane(
                I18N.get("GestorCapas", "general.mensaje.fin.operacion"),
                JOptionPane.INFORMATION_MESSAGE);
        JDialog dialog = optionPane.createDialog(this, "");
        dialog.show();

        Identificadores.put("DomainsModificados", true);
        jButtonDesasociar.setEnabled(true);
      } else {
        JOptionPane optionPane =
            new JOptionPane(
                I18N.get("GestorCapas", "general.mensaje.error.operacion"),
                JOptionPane.ERROR_MESSAGE);
        JDialog dialog = optionPane.createDialog(this, "");
        dialog.show();
      }

      repaint();

    } catch (DataException de) {
      de.printStackTrace();
    }
  }

  /** Acción realizada al pulsar el botón desasociar de la aplicación */
  private void jButtonDesasociarActionPerformed() {
    try {
      LayerOperations operaciones = new LayerOperations();

      // desasocia el dominio de la columna
      int iDeleted = operaciones.desasociarColumna(auxColumn);

      if (iDeleted > 0) {
        JOptionPane optionPane =
            new JOptionPane(
                I18N.get("GestorCapas", "general.mensaje.fin.operacion"),
                JOptionPane.INFORMATION_MESSAGE);
        JDialog dialog = optionPane.createDialog(this, "");
        dialog.show();
        Identificadores.put("DomainsModificados", true);
        jButtonAsociar.setEnabled(true);
        jButtonDesasociar.setEnabled(false);
      } else {
        JOptionPane optionPane =
            new JOptionPane(
                I18N.get("GestorCapas", "general.mensaje.error.operacion"),
                JOptionPane.ERROR_MESSAGE);
        JDialog dialog = optionPane.createDialog(this, "");
        dialog.show();
      }
      ;

      repaint();

    } catch (DataException de) {
      de.printStackTrace();
    }
  }

  /**
   * Escucha los posibles cambios producidos en la selección de elementos del árbol de tables y
   * columns de GeoPISTA
   */
  public void valueChanged(TreeSelectionEvent e) {

    if (e == null || !(e.getSource() instanceof JTree)) return;
    JTree arbol = (JTree) e.getSource();
    DefaultMutableTreeNode node = (DefaultMutableTreeNode) arbol.getLastSelectedPathComponent();
    if (node == null) return;
    Object nodeInfo = node.getUserObject();

    if (arbol.getName().indexOf("Particular") >= 0) {
      levelActivado = false;
      idMunicipio =
          Integer.parseInt(AppContext.getApplicationContext().getString("geopista.DefaultCityId"));

      if (nodeInfo instanceof com.geopista.protocol.administrador.dominios.Domain) {
        nodoParticular = true;
      } else {
        nodoParticular = false;
      }
      nodoGeneral = false;
    } else if (arbol.getName().indexOf("General") >= 0) {
      levelActivado = false;
      idMunicipio = 0;

      if (nodeInfo instanceof com.geopista.protocol.administrador.dominios.Domain) {
        nodoGeneral = true;
      } else {
        nodoGeneral = false;
      }
      nodoParticular = false;
    } else if (arbol.getName().indexOf("Tablas") >= 0) {
      // comprobar q es una columna lo seleccionado
      if (nodeInfo instanceof Column) {
        nodoTablas = true;
      } else {
        nodoTablas = false;
      }
    }

    if (nodeInfo instanceof Column) {
      jButtonDesasociar.setEnabled(true);

      auxColumn = (Column) nodeInfo;

      if (auxColumn.getDomain() == null) jButtonDesasociar.setEnabled(false);
      else jButtonDesasociar.setEnabled(true);

      if (nodoParticular || nodoGeneral) {
        // System.out.println ("tengo dominio y detecto columna");
        jButtonAsociar.setEnabled(true);
        return;
      }
    }

    if (nodeInfo instanceof Table) {
      jButtonAsociar.setEnabled(false);
      jButtonDesasociar.setEnabled(false);
    }

    if (nodeInfo instanceof com.geopista.protocol.administrador.dominios.Domain) {
      levelActivado = false;
      auxDomain = (com.geopista.protocol.administrador.dominios.Domain) nodeInfo;
      if (nodoTablas) {
        // System.out.println ("tengo columna y detecto dominio");
        jButtonAsociar.setEnabled(true);
      }

      LayerOperations operaciones = new LayerOperations();

      try {
        if (operaciones.obtenerTipoDominio(auxDomain, idMunicipio) == Domain.TREE)
          levelActivado = true;
      } catch (DataException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
      }

      if (arbol.getName().indexOf("General") >= 0
          && auxDomain.getListaNodes().getFirst() != null
          && auxDomain.getListaNodes().getFirst().getType() == Domain.TREE) {
        levelActivado = true;

      } else if (arbol.getName().indexOf("Particular") >= 0) {
        levelActivado = true;
      }
    } else {
      jButtonAsociar.setEnabled(false);
    }

    if (levelActivado) {
      // Se activa la caja de edicion de level
      txtLevel.setEnabled(true);
      lblLevel.setBackground(Color.BLACK);
      txtLevel.setText("0");
    } else {
      txtLevel.setEnabled(false);
      txtLevel.setText("0");
      lblLevel.setBackground(Color.GRAY);
    }
  }

  /** Acciones realizas al entrar en la pantalla */
  public void enter() {
    if (((Boolean) Identificadores.get("TablasModificadas")).booleanValue()
        && !((Boolean) Identificadores.get("TablasDominiosActualizada")).booleanValue()) {
      // Cada vez que se entra, se actualiza el arbol de tablas del sistema con
      // los posibles cambios realizados
      Identificadores.put("Tablas", null);
      Identificadores.put("Columnas", null);

      this.remove(jPanelTablas);
      jPanelTablas = new JPanelTables(TreeSelectionModel.SINGLE_TREE_SELECTION);
      jPanelTablas.setBorder(
          BorderFactory.createTitledBorder(I18N.get("GestorCapas", "tablas.arbol.titulo")));
      jPanelTablas.setBounds(new java.awt.Rectangle(5, 5, 250, 481));
      this.add(jPanelTablas);
      treeTablas = jPanelTablas.getTree();
      treeTablas.addTreeSelectionListener(this);

      // Si se modifica algo en la pantalla de tablas de base de datos, habrá
      // que actualizar la información tanto en el panel de tablasdominios como
      // en el de layers.
      Identificadores.put("TablasDominiosActualizada", true);
      if (((Boolean) Identificadores.get("LayersActualizada")).booleanValue()) {
        Identificadores.put("TablasModificadas", false);
        Identificadores.put("TablasDominiosActualizada", false);
        Identificadores.put("LayersActualizada", false);
      }
    }

    try {
      // Iniciamos la ayuda
      String helpHS = "help/catastro/gestordecapas/GestorCapasHelp_es.hs";
      ClassLoader c1 = this.getClass().getClassLoader();
      URL hsURL = HelpSet.findHelpSet(c1, helpHS);
      HelpSet hs = new HelpSet(null, hsURL);
      HelpBroker hb = hs.createHelpBroker();
      // fin de la ayuda
      hb.enableHelpKey(this, "Pestania2Dominios", hs);
    } catch (Exception excp) {
      excp.printStackTrace();
    }
  }

  /** Acciones realizadas al salir de la pantalla */
  public void exit() {}
}