// -------------------------------------------------------------------------------------
// xsEasyCpp
// Demo de Objeto ArbolOpciones
// g++ -g ArbolOpciones.cpp -lxseasycpp -LC:/msys64/mingw64/lib -lgtk-3 -lgdk-3 -lz -lgdi32 -limm32 -lshell32 -lole32 -Wl,-luuid -lwinmm -ldwmapi -lsetupapi -lcfgmgr32 -lpangowin32-1.0 -lpangocairo-1.0 -lpango-1.0 -latk-1.0 -lcairo-gobject -lcairo -lgdk_pixbuf-2.0 -lgio-2.0 -lgobject-2.0 -lintl -lglib-2.0 -o ArbolOpciones.exe
// g++ -g ArbolOpciones.cpp %PKG-XSEASYCPP% -o ArbolOpciones.exe
// -------------------------------------------------------------------------------------

// Incluye las librería de xsEasyCpp
#include "include/xsEasyCpp.hpp"

// Para la Imagen que se usa en el árbol
xsImagen imgFolder;

// Variable para entrada de datos
xsEntrada oEntrada;

// Función para controlar la Salida de una Ventana
Estatica Vacio fnSalida(xsObjetoGUI* ventana, xsApuntador datos);


// Función para controlar el Cierre de una Ventana
Estatica Entero fnCierre(xsObjetoGUI* ventana, xsEvento* evento);

// Función para controlar la acción de Selección del Opcion
Vacio fnArbolMensajesOnOff(xsObjetoGUI* objeto, xsApuntador Opcion);

// Función para controlar la accción de Selección del Opcion
Estatica Vacio fnClickEnArbol(xsObjetoGUI*            objeto,
                              xsArbolRuta*            ruta,
                              xsArbolVistaColumna*    columna,                              
                              xsApuntador             opcion);


// Crea el Modelo de Datos para el árbol
xsModeloArbol* fnCrearModeloDatos(Vacio);

// Insertar 
Estatica Vacio fnInsertar (xsApuntador      boton, 
                           xsArbolVista*    arbol);

// Insertar en Raíz
Estatica Vacio fnInsertarRaiz (xsApuntador      boton, 
                               xsArbolVista*    arbol);

// Insertar En
Estatica Vacio fnInsertarEn(xsApuntador     boton, 
                            xsArbolVista*   arbol);

// Seleccionar un Elemento
Estatica Vacio fnSeleccionar(xsApuntador    boton, 
                             xsArbolVista*  arbol);

// Modificar el renglón seleccionado
Estatica Vacio fnModificarSeleccionado(xsApuntador    boton, 
                                       xsArbolVista*  arbol);

// Modificar un Elemento específico
Estatica Vacio fnModificarElemento(xsApuntador    boton, 
                                   xsArbolVista*  arbol);

// Eliminae el renglón seleccionado
Estatica Vacio fnEliminarSeleccionado(xsApuntador     boton, 
                                      xsArbolVista*   arbol);

// Eliminar un Elemento específico
Estatica Vacio fnEliminarElemento(xsApuntador    boton, 
                                  xsArbolVista*  arbol);

// Eliminar todos los Elementos del Árbol
Estatica Vacio fnEliminarTodos(xsApuntador    boton, 
                               xsArbolVista*  arbol);

// Colapsar un Elemento Árbol
Estatica Vacio fnColapsarElemento(xsApuntador    boton, 
                                  xsArbolVista*  arbol);

// Colapsar el Árbol
Estatica Vacio fnColapsarTodos(xsApuntador    boton, 
                               xsArbolVista*  arbol);

// Expander un Elemento Árbol
Estatica Vacio fnExpanderElemento(xsApuntador    boton, 
                                  xsArbolVista*  arbol);

// Expander el Árbol
Estatica Vacio fnExpanderTodos(xsApuntador    boton, 
                               xsArbolVista*  arbol);

// Función para eliminar todos
Vacio fnDesplegarTodos(xsObjetoGUI *boton, xsApuntador lista);

// Función para Desplegar por Elemento
Vacio fnDesplegarPorElemento(xsApuntador lista, xsCadena elemento);


// Función principal de xsEasyWindow
xsPrincipal
{
  // Iniciamos xsEasyWindows
  xsAppInicia;

  // Definimos un objeto de la Clase xsVentana
  xsVentana oVentana(XS_CON_CONTENEDOR);

  // Estableciendo un tamaño para la Ventana                                  
  oVentana.colocarDimensiones(400,700);

  // Centrar la Ventana
  oVentana.centrar();

  // Establece el borde de la Ventana
  oVentana.colocarBordeVentana(10);

  // Mostramos la Ventana
  oVentana.mostrar();

  // Coloca el Título
  oVentana.colocarTitulo("xsEasyCpp Demo Árbol de Opciones");

  // Establece el Icono
  oVentana.colocarIcono("img/js.ico");
    
  // Establece la función de Salida
  oVentana.colocarFuncionSalida(XS_FUNCION_RETORNO (fnSalida));

  // Establece la función de Cierre
  oVentana.colocarFuncionCierre(XS_FUNCION_RETORNO (fnCierre));
  
  // Imagen del folder
  imgFolder.crear("img/folder.png");

  // Declaramos un modelo para los datos del Árbol
  xsModeloArbol* modelo;

  // crea el modelo del arbol
  modelo = fnCrearModeloDatos();

  //Creamos un Árbol de Opciones
  xsArbolOpciones oArbolMensajes;
  oArbolMensajes.crear();

  // Define un vector de datos para la Columnas
  vector<xsArbolOpciones::columnaArbolOpciones> arrDatos;

  // Defino un dato para establecer la columna
  xsArbolOpciones::columnaArbolOpciones columna;

  // Establezco las caracteristicas de la columna
  columna.tipo = xsArbolOpciones::tipoColumna::PixBuf;
  columna.posicion=0;

  // Agrego las columnas al Vector
  arrDatos.push_back(columna);
  
  // Establezco las caracteristicas de la columna
  columna.tipo = xsArbolOpciones::tipoColumna::Texto;
  columna.posicion=1;

  // Agrega las columnas al Vector
  arrDatos.push_back(columna);  

  // Agrega Columna al árbol
  oArbolMensajes.agregarColumna(arrDatos,"Titulo Columna");

  // Limpia el Arreglo
  arrDatos.clear();

  // Defino un dato para establecer la columna
  xsArbolOpciones::columnaArbolOpciones columna2;

  // Establezco las caracteristicas de la columna
  columna2.tipo = xsArbolOpciones::tipoColumna::PixBuf;
  columna2.posicion=0;

  // Agrego las columnas al Vector
  arrDatos.push_back(columna2);
  
  // Establezco las caracteristicas de la columna
  columna2.tipo = xsArbolOpciones::tipoColumna::Texto;
  columna2.posicion=1;

  // Agrega las columnas al Vector
  arrDatos.push_back(columna2);  

  // Agrega Columna al árbol
  oArbolMensajes.agregarColumna(arrDatos,"Titulo Columna2");

  // Coloca el Model
  oArbolMensajes.colocarModelo(modelo);
  xsObjeto_desreferenciar(XS_OBJETO(modelo));

  // Define un vector de datos para agrega un Renglon
  vector<xsArbolOpciones::renglonArbolOpciones> arrRenglon;

  // Defino un dato para establecer el renglon
  xsArbolOpciones::renglonArbolOpciones renglon;

  // Establezco lo que tendrá el renglón
  renglon.tipo = xsArbolOpciones::tipoColumna::PixBuf;
  renglon.posicion = 0;
  renglon.imagen = imgFolder.obtenerBufferPixeles();
  
  // Agrega el dato al arreglo
  arrRenglon.push_back(renglon);

  // Establezco lo que tendrá el renglon
  renglon.tipo = xsArbolOpciones::tipoColumna::Texto;
  renglon.posicion = 1;
  renglon.texto ="Raiz";

  // Agrega el dato al arreglo
  arrRenglon.push_back(renglon);
  
  // Agrega renglon al árbol
  oArbolMensajes.insertar(arrRenglon, FALSO);

  // Crea una Ventana de Desplazamiento (scroll)
  xsVentanaDesplazamiento scroll(NULO,NULO);
	
  // Agrega el Árbol a el Scroll
  scroll.agregarEn(oArbolMensajes.obtenerManejador());
  scroll.colocarDimensiones(100,200);

  // Crea la Entrada
  oEntrada.crear();

  // Colocar el PlaceHolder
  oEntrada.colocarPlaceHolderTexto("Capture Dato Insertar-Modificar");

  // Crea los botones	
  xsBoton btnInsertar("Insertar",NO XS_CON_MNEMONICO);
  xsBoton btnInsertarRaiz("Insertar Raiz",NO XS_CON_MNEMONICO);
  xsBoton btnInsertarEn("Insertar En",NO XS_CON_MNEMONICO);
  xsBoton btnSeleccionar("Seleccionar",NO XS_CON_MNEMONICO);
  xsBoton btnModificarSeleccionado("Modificar Seleccionado",NO XS_CON_MNEMONICO);
  xsBoton btnModificarElemento("Modificar Elemento",NO XS_CON_MNEMONICO);
  xsBoton btnEliminarSeleccionado("Eliminar Seleccionado",NO XS_CON_MNEMONICO);
  xsBoton btnEliminarElemento("Eliminar Elemento",NO XS_CON_MNEMONICO);
  xsBoton btnEliminarTodos("Eliminar Todos",NO XS_CON_MNEMONICO);
  xsBoton btnColapsarElemento("Colapsar Elemento",NO XS_CON_MNEMONICO);
  xsBoton btnColapsarTodos("Colapsar Todos",NO XS_CON_MNEMONICO);
  xsBoton btnExpanderElemento("Expander Elemento",NO XS_CON_MNEMONICO);
  xsBoton btnExpanderTodos("Expander Todos",NO XS_CON_MNEMONICO);
  xsBoton btnDesplegarTodos("Desplegar Todos",NO XS_CON_MNEMONICO);

  // Agrega el Scroll y los Botones a la Ventana
  oVentana.agregarAlContenedor(scroll.obtenerManejador());  
  oVentana.agregarAlContenedor(oEntrada.obtenerManejador());  
  oVentana.agregarAlContenedor(btnInsertar.obtenerManejador());
  oVentana.agregarAlContenedor(btnInsertarRaiz.obtenerManejador());
  oVentana.agregarAlContenedor(btnInsertarEn.obtenerManejador());
  oVentana.agregarAlContenedor(btnSeleccionar.obtenerManejador());
  oVentana.agregarAlContenedor(btnModificarSeleccionado.obtenerManejador());
  oVentana.agregarAlContenedor(btnModificarElemento.obtenerManejador());
  oVentana.agregarAlContenedor(btnEliminarSeleccionado.obtenerManejador());
  oVentana.agregarAlContenedor(btnEliminarElemento.obtenerManejador());
  oVentana.agregarAlContenedor(btnEliminarTodos.obtenerManejador());
  oVentana.agregarAlContenedor(btnColapsarElemento.obtenerManejador());
  oVentana.agregarAlContenedor(btnColapsarTodos.obtenerManejador());
  oVentana.agregarAlContenedor(btnExpanderElemento.obtenerManejador());
  oVentana.agregarAlContenedor(btnExpanderTodos.obtenerManejador());
  oVentana.agregarAlContenedor(btnDesplegarTodos.obtenerManejador());

  // Conectando Señales
  oVentana.conectarSenal("destroy",xsFuncionSalida, NULO);
  oArbolMensajes.conectarSenal("row-activated",XS_FUNCION_RETORNO(fnClickEnArbol), oArbolMensajes.obtenerManejador());
  btnInsertar.conectarSenal("clicked",XS_FUNCION_RETORNO(fnInsertar), oArbolMensajes.obtenerManejador());
  btnInsertarRaiz.conectarSenal("clicked",XS_FUNCION_RETORNO(fnInsertarRaiz), oArbolMensajes.obtenerManejador());
  btnInsertarEn.conectarSenal("clicked",XS_FUNCION_RETORNO(fnInsertarEn), oArbolMensajes.obtenerManejador());
  btnSeleccionar.conectarSenal("clicked",XS_FUNCION_RETORNO(fnSeleccionar), oArbolMensajes.obtenerManejador());
  btnModificarSeleccionado.conectarSenal("clicked",XS_FUNCION_RETORNO(fnModificarSeleccionado), oArbolMensajes.obtenerManejador());
  btnModificarElemento.conectarSenal("clicked",XS_FUNCION_RETORNO(fnModificarElemento), oArbolMensajes.obtenerManejador());  
  btnEliminarSeleccionado.conectarSenal("clicked",XS_FUNCION_RETORNO(fnEliminarSeleccionado), oArbolMensajes.obtenerManejador());  
  btnEliminarElemento.conectarSenal("clicked",XS_FUNCION_RETORNO(fnEliminarElemento), oArbolMensajes.obtenerManejador());  
  btnEliminarTodos.conectarSenal("clicked",XS_FUNCION_RETORNO(fnEliminarTodos), oArbolMensajes.obtenerManejador());
  btnColapsarElemento.conectarSenal("clicked",XS_FUNCION_RETORNO(fnColapsarElemento), oArbolMensajes.obtenerManejador());
  btnColapsarTodos.conectarSenal("clicked",XS_FUNCION_RETORNO(fnColapsarTodos), oArbolMensajes.obtenerManejador());
  btnExpanderElemento.conectarSenal("clicked",XS_FUNCION_RETORNO(fnExpanderElemento), oArbolMensajes.obtenerManejador());
  btnExpanderTodos.conectarSenal("clicked",XS_FUNCION_RETORNO(fnExpanderTodos), oArbolMensajes.obtenerManejador());
  btnDesplegarTodos.conectarSenal("clicked",XS_FUNCION_RETORNO(fnDesplegarTodos), oArbolMensajes.obtenerManejador());

  // Muestra todos los objetos
  oVentana.mostrarTodo();

  // Ciclo
  xsAppCiclo;

  // Finaliza retornando 0
  retorna 0;

}


// Detiene el Ciclo Principal iniciado por gtk_main cuando la ventana es destruida
Estatica Vacio fnSalida(xsObjetoGUI* ventana, xsApuntador datos)
{
    // Llama a la función de la Librería que sale del Ciclo Main  
    xsAppSalida;
}

// Función para controlar el Cierre de una Ventana
Estatica Entero fnCierre(xsObjetoGUI* ventana, xsEvento* evento)
{
    // Para que se cierre, lo contrario para que no se cierre
    retorna Falso; 
}

// Función para detectar click
Estatica Vacio fnClickEnArbol(xsObjetoGUI*            objeto,
                              xsArbolRuta*            ruta,
                              xsArbolVistaColumna*    columna,                              
                              xsApuntador             Opcion)
{
  // Declara una variable lista para los hijos del Objeto
  xsLista*        hijos;
  xsModeloArbol*  modeloArbol;
  xsArbolIterador iterador;
  xsArbolOpcionSeleccionada* seleccionado;

  // Define variable
  xsArbolOpciones tmpArbol;

  // Asigna el Manejador
  tmpArbol.asignarManejador(XS_OBJETOGUI(objeto));
  seleccionado = tmpArbol.obtenerSeleccionado();

  // Verifica si está seleccionado
  xsObjeto_ArbolOpciones_verifica_seleccionado (seleccionado, &modeloArbol, &iterador); 

  // Define e Inicializa variable G
  xsValorG texto =XS_VALOR_G_INICIAL;

  // Obtiene el valor
  xsObjeto_Arbol_obtener_valor (modeloArbol,&iterador,1,&texto);
  
  // Coloca el Texto en la entrada
  oEntrada.colocarTexto(xsValorG_obten_cadena (&texto));  
}

// Crea el modelo de datos
xsModeloArbol* fnCrearModeloDatos(Vacio)
{
   // Crea arbol datos
	xsArbolDatos* datosArbol;
	
	// Crea el modelo con 2 tipos de columnas: imagen y texto 
	datosArbol = xsObjeto_Arbol_crear(2, XS_COLUMNA_TIPO_BUFFER_PIXELES, XS_COLUMNA_TIPO_CADENA);
	
   // Retorna el Modelo
	return XS_ARBOL_MODELO(datosArbol);
}


// Agrega una Fila al Árbol
Estatica Vacio fnInsertar (xsApuntador    boton, 
                           xsArbolVista*  arbol)
{ 
   // Define variable
   xsArbolOpciones arbolTemporal;

   // Asigna el Manejador
   arbolTemporal.asignarManejador(XS_OBJETOGUI(arbol));

   // Define un vector de datos para agrega un Renglon
   vector<xsArbolOpciones::renglonArbolOpciones> arrRenglon;

   // Defino un dato para establecer el renglon
   xsArbolOpciones::renglonArbolOpciones renglon;

   // Establezco lo que tendrá el renglón
   renglon.tipo = xsArbolOpciones::tipoColumna::PixBuf;
   renglon.posicion = 0;
   renglon.imagen = imgFolder.obtenerBufferPixeles();
  
   // Agrega el dato al arreglo
   arrRenglon.push_back(renglon);

   // Establezco lo que tendrá el renglon
   renglon.tipo     = xsArbolOpciones::tipoColumna::Texto;
   renglon.posicion = 1;
   renglon.texto    = oEntrada.obtenerTexto();

   // Agrega el dato al arreglo
   arrRenglon.push_back(renglon);

   // Verifico si hay algo en la entrada
   si (oEntrada.obtenerLongitudTexto()>0)
      // Agrega renglon al árbol
      arbolTemporal.insertar(arrRenglon, FALSO);      
   deOtroModo
   {
      // Mensaje
      xsVentana::mensajeInformacion("xsEasyCpp Demo Árbol de Opciones","Capture el Dato a Insertar");
      // Coloca el foco
      oEntrada.colocarFoco();
   }
}

// Agrega una Fila al Árbol en Raiz
Estatica Vacio fnInsertarRaiz (xsApuntador    boton, 
                               xsArbolVista*  arbol)
{ 
   // Define variable
   xsArbolOpciones arbolTemporal;

   // Asigna el Manejador
   arbolTemporal.asignarManejador(XS_OBJETOGUI(arbol));

   // Define un vector de datos para agrega un Renglon
   vector<xsArbolOpciones::renglonArbolOpciones> arrRenglon;

   // Defino un dato para establecer el renglon
   xsArbolOpciones::renglonArbolOpciones renglon;

   // Establezco lo que tendrá el renglón
   renglon.tipo = xsArbolOpciones::tipoColumna::PixBuf;
   renglon.posicion = 0;
   renglon.imagen = imgFolder.obtenerBufferPixeles();
  
   // Agrega el dato al arreglo
   arrRenglon.push_back(renglon);

   // Establezco lo que tendrá el renglon
   renglon.tipo     = xsArbolOpciones::tipoColumna::Texto;
   renglon.posicion = 1;
   renglon.texto    = oEntrada.obtenerTexto();

   // Agrega el dato al arreglo
   arrRenglon.push_back(renglon);

   // Verifico si hay algo en la entrada
   si (oEntrada.obtenerLongitudTexto()>0)
      // Agrega renglon al árbol en raiz
      arbolTemporal.insertar(arrRenglon, VERDAD);
   deOtroModo
   {
      // Mensaje
      xsVentana::mensajeInformacion("xsEasyCpp Demo Árbol de Opciones","Capture el Dato a Insertar");
      // Coloca el foco
      oEntrada.colocarFoco();
   }
}

// Inserta un renglon en un lugar especifico
Estatica Vacio fnInsertarEn(xsApuntador    boton, 
                            xsArbolVista* arbol)
{ 
   // Define variable
   xsArbolOpciones arbolTemporal;

   // Asigna el Manejador
   arbolTemporal.asignarManejador(XS_OBJETOGUI(arbol));

   // Define un vector de datos para agrega un Renglon
   vector<xsArbolOpciones::renglonArbolOpciones> arrRenglon;

   // Defino un dato para establecer el renglon
   xsArbolOpciones::renglonArbolOpciones renglon;

   // Establezco lo que tendrá el renglón
   renglon.tipo = xsArbolOpciones::tipoColumna::PixBuf;
   renglon.posicion = 0;
   renglon.imagen = imgFolder.obtenerBufferPixeles();
  
   // Agrega el dato al arreglo
   arrRenglon.push_back(renglon);

   // Establezco lo que tendrá el renglon
   renglon.tipo     = xsArbolOpciones::tipoColumna::Texto;
   renglon.posicion = 1;
   renglon.texto    = "Insertado";

   // Agrega el dato al arreglo
   arrRenglon.push_back(renglon);

   // Verifico si hay algo en la entrada
   si (oEntrada.obtenerLongitudTexto()>0)
      // Agrega renglon al árbol en raiz
      arbolTemporal.insertar(arrRenglon, oEntrada.obtenerTexto());
   deOtroModo
   {
      // Mensaje
      xsVentana::mensajeInformacion("xsEasyCpp Demo Árbol de Opciones","Capture el Dato a Insertar");
      // Coloca el foco
      oEntrada.colocarFoco();
   }
}

// Seleccionar
Estatica Vacio fnSeleccionar(xsApuntador    boton, 
                             xsArbolVista* arbol)
{
	// Define variable
  xsArbolOpciones tmpArbolOpciones;

  // Asigna el Manejador
  tmpArbolOpciones.asignarManejador(XS_OBJETOGUI(arbol));

  // Verifica si hay dato capturado
  si (oEntrada.obtenerLongitudTexto()>0)
     // DesSeleccionar
     tmpArbolOpciones.seleccionar(oEntrada.obtenerTexto());
  deOtroModo
  {
     // Mensaje
     xsVentana::mensajeInformacion("xsEasyCpp Demo Árbol de Opciones","Capture el Dato a Seleccionar");

     // Coloca el foco
     oEntrada.colocarFoco();   
  }
}

// Modificando un Renglón
Estatica Vacio fnModificarSeleccionado(xsApuntador    boton, 
                                       xsArbolVista* arbol)
{
  // Cargamos una imagen diferente
  xsImagen logo("img/js16x16.jpg");

	// Define variable
  xsArbolOpciones tmpArbol;

  // Asigna el Manejador
  tmpArbol.asignarManejador(XS_OBJETOGUI(arbol));

  // Define un vector de datos para agrega un Renglon
  vector<xsArbolOpciones::renglonArbolOpciones> arrRenglon;

  // Defino un dato para establecer el renglon
  xsArbolOpciones::renglonArbolOpciones renglon;

  // Establezco lo que tendrá el renglón
  renglon.tipo = xsArbolOpciones::tipoColumna::PixBuf;
  renglon.posicion = 0;
  renglon.imagen = logo.obtenerBufferPixeles();
  
  // Agrega el dato al arreglo
  arrRenglon.push_back(renglon);

  // Establezco lo que tendrá el renglon
  renglon.tipo = xsArbolOpciones::tipoColumna::Texto;
  renglon.posicion = 1;
  renglon.texto = oEntrada.obtenerTexto();

  // Agrega el dato al arreglo
  arrRenglon.push_back(renglon);

  // Verifica si hay dato capturado
  si (oEntrada.obtenerLongitudTexto()>0)
     // Agrega renglon al árbol
     tmpArbol.modificarRenglonSeleccionado(arrRenglon);		
  deOtroModo
  {
     // Mensaje
     xsVentana::mensajeInformacion("xsEasyCpp Demo Árbol de Opciones","Capture el Dato a Seleccionar");

     // Coloca el foco
     oEntrada.colocarFoco();   
  }    
}

// Modificar un Elemento
Estatica Vacio fnModificarElemento(xsApuntador    boton, 
                                   xsArbolVista* arbol)
{
  // Cargamos una imagen diferente
  xsImagen logo("img/js16x16.jpg");

	// Define variable
  xsArbolOpciones tmpArbol;

  // Asigna el Manejador
  tmpArbol.asignarManejador(XS_OBJETOGUI(arbol));

  // Define un vector de datos para agrega un Renglon
  vector<xsArbolOpciones::renglonArbolOpciones> arrRenglon;

  // Defino un dato para establecer el renglon
  xsArbolOpciones::renglonArbolOpciones renglon;

  // Establezco lo que tendrá el renglón
  renglon.tipo = xsArbolOpciones::tipoColumna::PixBuf;
  renglon.posicion = 0;
  renglon.imagen = logo.obtenerBufferPixeles();
  
  // Agrega el dato al arreglo
  arrRenglon.push_back(renglon);

  // Establezco lo que tendrá el renglon
  renglon.tipo = xsArbolOpciones::tipoColumna::Texto;
  renglon.posicion = 1;
  renglon.texto = "Modificado";

  // Agrega el dato al arreglo
  arrRenglon.push_back(renglon);

  // Verifica si hay dato capturado
  si (oEntrada.obtenerLongitudTexto()>0)
     // Modifica el Elemento
     tmpArbol.modificarElemento(arrRenglon,oEntrada.obtenerTexto());		
  deOtroModo
  {
     // Mensaje
     xsVentana::mensajeInformacion("xsEasyCpp Demo Árbol de Opciones","Capture el Elemento a Modificar");

     // Coloca el foco
     oEntrada.colocarFoco();   
  }    
}


// Función para Eliminar un Renglón 
Estatica Vacio fnEliminarSeleccionado(xsApuntador    boton, 
                                      xsArbolVista* arbol)
{
	// Define variable
  xsArbolOpciones tmpArbol;

  // Asigna el Manejador
  tmpArbol.asignarManejador(XS_OBJETOGUI(arbol));

  // Llama a función de eliminacion
  tmpArbol.eliminarRenglonSeleccionado();
}

// Eliminar un Elemento
Estatica Vacio fnEliminarElemento(xsApuntador    boton, 
                                  xsArbolVista* arbol)
{  
	// Define variable
  xsArbolOpciones tmpArbol;

  // Asigna el Manejador
  tmpArbol.asignarManejador(XS_OBJETOGUI(arbol));

  // Verifica si hay dato capturado
  si (oEntrada.obtenerLongitudTexto()>0)
     // Modifica el Elemento
     tmpArbol.eliminar(oEntrada.obtenerTexto());		
  deOtroModo
  {
     // Mensaje
     xsVentana::mensajeInformacion("xsEasyCpp Demo Árbol de Opciones","Capture el Elemento a Modificar");

     // Coloca el foco
     oEntrada.colocarFoco();   
  }    
}

// Función para Eliminar Todos
Estatica Vacio fnEliminarTodos(xsApuntador    boton, 
                               xsArbolVista* arbol)
{
	// Define variable
  xsArbolOpciones tmpArbol;

  // Asigna el Manejador
  tmpArbol.asignarManejador(XS_OBJETOGUI(arbol));

  // Llama a función de eliminacion
  tmpArbol.limpiar();
}


// Función para Colapasar Elemento
Estatica Vacio fnColapsarElemento(xsApuntador    boton, 
                                  xsArbolVista* arbol)
{
	// Define variable
  xsArbolOpciones tmpArbol;

  // Asigna el Manejador
  tmpArbol.asignarManejador(XS_OBJETOGUI(arbol));

  // Verifica si hay dato capturado
  si (oEntrada.obtenerLongitudTexto()>0)
     // Modifica el Elemento
     tmpArbol.colapsar(oEntrada.obtenerTexto());		
  deOtroModo
  {
     // Mensaje
     xsVentana::mensajeInformacion("xsEasyCpp Demo Árbol de Opciones","Capture el Elemento a Colapsar");

     // Coloca el foco
     oEntrada.colocarFoco();   
  } 
}

// Función para Colapsar Todos
Estatica Vacio fnColapsarTodos(xsApuntador    boton, 
                               xsArbolVista* arbol)
{
  // Define variable
  xsArbolOpciones tmpArbol;

  // Asigna el Manejador
  tmpArbol.asignarManejador(XS_OBJETOGUI(arbol));

  // Modifica el Elemento
  tmpArbol.colapsar();		
}

// Función para Expander Elemento
Estatica Vacio fnExpanderElemento(xsApuntador    boton, 
                                  xsArbolVista* arbol)
{
  // Define variable
  xsArbolOpciones tmpArbol;

  // Asigna el Manejador
  tmpArbol.asignarManejador(XS_OBJETOGUI(arbol));

  // Verifica si hay dato capturado
  si (oEntrada.obtenerLongitudTexto()>0)
     // Modifica el Elemento
     tmpArbol.expander(oEntrada.obtenerTexto());		
  deOtroModo
  {
     // Mensaje
     xsVentana::mensajeInformacion("xsEasyCpp Demo Árbol de Opciones","Capture el Elemento a Expander");

     // Coloca el foco
     oEntrada.colocarFoco();   
  } 
}

// Función para Expander Todos
Estatica Vacio fnExpanderTodos(xsApuntador    boton, 
                               xsArbolVista* arbol)
{
  // Define variable
  xsArbolOpciones tmpArbol;

  // Asigna el Manejador
  tmpArbol.asignarManejador(XS_OBJETOGUI(arbol));

  // Llama a función de eliminacion
  tmpArbol.expander();
}

// Función para Desplegar Todos
Vacio fnDesplegarTodos(xsObjetoGUI* boton, xsApuntador lista)
{
   // Llama a la Función que busca por elemento
   fnDesplegarPorElemento(lista,"");   
}

// Función para desplegar los Elementos de un Nodo
Vacio fnDesplegarPorElemento(xsApuntador lista, xsCadena elemento)
{
   // Para obtener el texto
   Caracter* texto;

	// Variable para la ruta (indice)
	xsCadena ruta;

	// Variable para el Indice
	Entero indice;

	// Variable para el Modelo
	xsModeloArbol*  modelo;

    // Variable para el Iterador
	xsArbolIterador iterador;

	// Verifica si es un elemento
	si (elemento.size()>0)
	   // Le agrega los ":"
	   elemento=elemento+":";

   // Lista Temporal
   xsListaArbolOpciones lstTemporal;

   // Asignamos los manejadores
   lstTemporal.asignarManejador(XS_OBJETOGUI(lista));

	// Obtiene el Modelo
   modelo = xsObjeto_ArbolOpciones_obtener_modelo(XS_ARBOL_VISTA(lstTemporal.obtenerManejador()));
		
	// Ciclo para verificar cada dato
	for (indice=0;VERDAD;indice++)
	{
		// Obtiene la ruta por el indice
		ruta = elemento+to_string(indice);	
	
   	// Verifica que NO obtuvo algo
		si (NO xsObjeto_Arbol_obtener_iterador_cadena (modelo, &iterador,ruta.c_str()))
		{
			// Sale del Ciclo
		    salirCiclo;
		}
      deOtroModo
      {
         xsObjeto_Arbol_obtener_modelo(modelo, &iterador, 1, &texto,  -1);
         xsVentana::mensajeInformacion("xsEasyCpp Demo ListaArbolOpciones",texto);
      }
		
        // Verifica si tiene hijos
	    si (xsObjeto_Arbol_obtener_iterador_cadena (modelo, &iterador,(ruta+":0").c_str()))
		    // Se ejecuta recursividad
		    fnDesplegarPorElemento(lista,ruta.c_str());
	}	

	// Devuelve el Contador de Elementos
	retorna;
}
