gtk3-node 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -1,6 +1,61 @@
 # CHANGELOG - Extensión GTK3 para Node.js
 
-## [Versión 1.0.0] - 2026-02-14
+## [Versión 1.3.0] - 2026-02-15
+
+
+### Características
+- Integración nativa con GTK3
+- Sistema de eventos con callbacks
+- Soporte para interfaces gráficas completas
+- Estructura modular y extensible
+- Temporización con funcionalidad similar a TTimer de Delphi
+
+### Documentación
+- README principal
+- Documentación para cada widget
+- Ejemplos básicos, intermedios y avanzados
+- Guía de compilación (HOWTO-COMPILE.md)
+
+### Notas Técnicas
+- Basado en N-API para compatibilidad con múltiples versiones de Node.js
+- Compilación con node-gyp
+- Integración con GTK3 3.x
+- Soporte para Linux (actualmente)
+
+## [Versión 1.2.0] - 2026-02-15
+
+### Añadido
+- Widget Button con soporte para eventos y callbacks
+- Widget Window para contenedores de interfaz
+- Widget Label para mostrar texto estático
+- Widget Box para layouts horizontales y verticales
+- Widget Scroll para contenedores con barras de desplazamiento
+- Widget Entry para entrada de texto simple
+- Widget StringGrid para tablas bidimensionales de datos
+- Widget TextView para áreas de texto multilinea
+- Estructura modular para futuras expansiones
+- Ejemplos organizados por niveles de complejidad
+- Principio DRY aplicado en la arquitectura
+
+### Características
+- Integración nativa con GTK3
+- Sistema de eventos con callbacks
+- Soporte para interfaces gráficas completas
+- Estructura modular y extensible
+
+### Documentación
+- README principal
+- Documentación para cada widget
+- Ejemplos básicos, intermedios y avanzados
+- Guía de compilación (HOWTO-COMPILE.md)
+
+### Notas Técnicas
+- Basado en N-API para compatibilidad con múltiples versiones de Node.js
+- Compilación con node-gyp
+- Integración con GTK3 3.x
+- Soporte para Linux (actualmente)
+
+## [Versión 1.1.0] - 2026-02-14
 
 ### Añadido
 - Implementación inicial de la extensión GTK3 para Node.js
@@ -32,4 +87,20 @@
 - Basado en N-API para compatibilidad con múltiples versiones de Node.js
 - Compilación con node-gyp
 - Integración con GTK3 3.x
-- Soporte para Linux (actualmente)
+- Soporte para Linux (actualmente)
+
+## [Versión 1.0.0] - 2026-02-14
+
+### Añadido
+- Implementación inicial de la extensión GTK3 para Node.js
+- Soporte para creación de interfaces gráficas con GTK3
+- Widget Button con soporte para eventos y callbacks
+- Widget Window para contenedores de interfaz
+- Widget Label para mostrar texto estático
+- Widget Box para layouts horizontales y verticales
+- Widget Scroll para contenedores con barras de desplazamiento
+- Widget Entry para entrada de texto simple
+- Widget StringGrid para tablas bidimensionales de datos
+- Estructura modular para futuras expansiones
+- Ejemplos organizados por niveles de complejidad
+- Principio DRY aplicado en la arquitectura

package/CHANGELOG.md.backup

@@ -0,0 +1,115 @@
+# CHANGELOG - Extensión GTK3 para Node.js
+
+## [Versión 1.3.0] - 2026-02-15
+
+### Añadido
+- Widget TextView para áreas de texto multilinea
+- Widget Timer para funcionalidad de temporización similar a TTimer de Delphi
+- Soporte completo para eventos y callbacks en todos los widgets
+- Mejoras en la arquitectura para evitar duplicación de código
+- Correcciones de errores en la implementación de StringGrid
+- Ejemplos funcionales completos que demuestran la creación de interfaces gráficas
+- Soporte para creación de ventanas con botones interactivos
+- Implementación de bucles de eventos no bloqueantes
+
+### Características
+- Integración nativa con GTK3
+- Sistema de eventos con callbacks
+- Soporte para interfaces gráficas completas
+- Estructura modular y extensible
+- Temporización con funcionalidad similar a TTimer de Delphi
+
+### Documentación
+- README principal
+- Documentación para cada widget
+- Ejemplos básicos, intermedios y avanzados
+- Guía de compilación (HOWTO-COMPILE.md)
+
+### Notas Técnicas
+- Basado en N-API para compatibilidad con múltiples versiones de Node.js
+- Compilación con node-gyp
+- Integración con GTK3 3.x
+- Soporte para Linux (actualmente)
+
+## [Versión 1.2.0] - 2026-02-15
+
+### Añadido
+- Widget Button con soporte para eventos y callbacks
+- Widget Window para contenedores de interfaz
+- Widget Label para mostrar texto estático
+- Widget Box para layouts horizontales y verticales
+- Widget Scroll para contenedores con barras de desplazamiento
+- Widget Entry para entrada de texto simple
+- Widget StringGrid para tablas bidimensionales de datos
+- Widget TextView para áreas de texto multilinea
+- Estructura modular para futuras expansiones
+- Ejemplos organizados por niveles de complejidad
+- Principio DRY aplicado en la arquitectura
+
+### Características
+- Integración nativa con GTK3
+- Sistema de eventos con callbacks
+- Soporte para interfaces gráficas completas
+- Estructura modular y extensible
+
+### Documentación
+- README principal
+- Documentación para cada widget
+- Ejemplos básicos, intermedios y avanzados
+- Guía de compilación (HOWTO-COMPILE.md)
+
+### Notas Técnicas
+- Basado en N-API para compatibilidad con múltiples versiones de Node.js
+- Compilación con node-gyp
+- Integración con GTK3 3.x
+- Soporte para Linux (actualmente)
+
+## [Versión 1.1.0] - 2026-02-14
+
+### Añadido
+- Implementación inicial de la extensión GTK3 para Node.js
+- Soporte para creación de interfaces gráficas con GTK3
+- Widget Button con soporte para eventos y callbacks
+- Widget Window para contenedores de interfaz
+- Widget Label para mostrar texto estático
+- Widget Box para layouts horizontales y verticales
+- Widget Scroll para contenedores con barras de desplazamiento
+- Widget Entry para entrada de texto simple
+- Widget StringGrid para tablas bidimensionales de datos
+- Estructura modular para futuras expansiones
+- Ejemplos organizados por niveles de complejidad
+- Principio DRY aplicado en la arquitectura
+
+### Características
+- Integración nativa con GTK3
+- Sistema de eventos con callbacks
+- Soporte para interfaces gráficas completas
+- Estructura modular y extensible
+
+### Documentación
+- README principal
+- Documentación para cada widget
+- Ejemplos básicos, intermedios y avanzados
+- Guía de compilación (HOWTO-COMPILE.md)
+
+### Notas Técnicas
+- Basado en N-API para compatibilidad con múltiples versiones de Node.js
+- Compilación con node-gyp
+- Integración con GTK3 3.x
+- Soporte para Linux (actualmente)
+
+## [Versión 1.0.0] - 2026-02-14
+
+### Añadido
+- Implementación inicial de la extensión GTK3 para Node.js
+- Soporte para creación de interfaces gráficas con GTK3
+- Widget Button con soporte para eventos y callbacks
+- Widget Window para contenedores de interfaz
+- Widget Label para mostrar texto estático
+- Widget Box para layouts horizontales y verticales
+- Widget Scroll para contenedores con barras de desplazamiento
+- Widget Entry para entrada de texto simple
+- Widget StringGrid para tablas bidimensionales de datos
+- Estructura modular para futuras expansiones
+- Ejemplos organizados por niveles de complejidad
+- Principio DRY aplicado en la arquitectura

package/ejemplo_funcional.js

@@ -0,0 +1,29 @@
+// ejemplo_funcional.js - Ejemplo funcional con ventana y botón visibles
+
+const { init, run } = require('./index.js');
+
+// Inicializar GTK
+init();
+
+// Crear una ventana usando directamente las funciones nativas
+const window = gtk3_native.createWindow('Ejemplo Funcional', 400, 300);
+
+// Crear un botón usando directamente las funciones nativas
+const button = gtk3_native.createButton('Haz clic aquí');
+
+// Conectar un callback al botón
+gtk3_native.connectClick(button, () => {
+  console.log('¡Botón presionado!');
+  gtk3_native.setButtonText(button, '¡Gracias por hacer clic!');
+});
+
+// Agregar el botón a la ventana
+gtk3_native.addToWindow(window, button);
+
+// Mostrar todos los widgets
+gtk3_native.showAll(window);
+
+console.log('Interfaz gráfica lista. Abriendo ventana con botón...');
+
+// Iniciar el loop de eventos GTK para mostrar la interfaz
+run();

package/ejemplo_funcional_corregido.js

@@ -0,0 +1,29 @@
+// ejemplo_funcional_corregido.js - Ejemplo funcional con ventana y botón visibles
+
+const { Button, Window, init, run } = require('./index.js');
+
+// Inicializar GTK
+init();
+
+// Crear una ventana
+const window = new Window('Ejemplo Funcional', 400, 300);
+
+// Crear un botón
+const button = new Button('Haz clic aquí');
+
+// Agregar un manejador de eventos al botón
+button.onClick(() => {
+  console.log('¡Botón presionado!');
+  button.label = '¡Gracias por hacer clic!';
+});
+
+// Agregar el botón a la ventana
+window.add(button);
+
+// Mostrar la ventana y todos sus contenidos
+window.show();
+
+console.log('Interfaz gráfica lista. Abriendo ventana con botón...');
+
+// Iniciar el loop de eventos GTK para mostrar la interfaz
+run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtk3-node",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Native Node.js extension for creating GTK3 widgets",
   "main": "index.js",
   "scripts": {

package/widgets/stringgrid/stringgrid.cpp

@@ -1,5 +1,7 @@
 #include <napi.h>
 #include <gtk/gtk.h>
+#include <vector>
+#include <string>
 
 // Estructura para almacenar datos del stringgrid
 struct StringGridData {
@@ -8,109 +10,123 @@ struct StringGridData {
   std::vector<std::string> headers;
   Napi::Env env;
   Napi::FunctionReference cell_edit_callback;
-  
+
   StringGridData(Napi::Env e) : treeview(nullptr), store(nullptr), env(e) {}
 };
 
 // Callback para cuando se edita una celda
 static void cell_edited_callback(GtkCellRendererText *renderer, gchar *path_string, gchar *new_text, gpointer user_data) {
   StringGridData* grid_data = static_cast<StringGridData*>(user_data);
-  
+
   // Convertir la cadena de ruta a un GtkTreePath
   GtkTreePath* path = gtk_tree_path_new_from_string(path_string);
-  
+
   // Obtener el iterador para la fila
   GtkTreeIter iter;
   if (gtk_tree_model_get_iter(GTK_TREE_MODEL(grid_data->store), &iter, path)) {
     // Determinar qué columna fue editada
-    GtkTreeViewColumn* column = gtk_tree_view_get_column(GTK_TREE_VIEW(grid_data->treeview), 0); // Necesitamos identificar la columna
-    
-    // Buscar cuál columna es la que se está editando
     gint n_columns = gtk_tree_view_get_n_columns(GTK_TREE_VIEW(grid_data->treeview));
     for (gint i = 0; i < n_columns; i++) {
       GtkTreeViewColumn* col = gtk_tree_view_get_column(GTK_TREE_VIEW(grid_data->treeview), i);
       GList* renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(col));
-      
+
       if (renderers) {
         GtkCellRenderer* renderer_in_col = (GtkCellRenderer*)renderers->data;
         if (renderer_in_col == (GtkCellRenderer*)renderer) {
           // Actualizar el valor en la tienda
           gtk_list_store_set(grid_data->store, &iter, i, new_text, -1);
+
+          // Si hay un callback registrado, llamarlo
+          if (!grid_data->cell_edit_callback.IsEmpty()) {
+            Napi::HandleScope scope(grid_data->env);
+
+            // Crear objeto con información de la edición
+            Napi::Object editInfo = Napi::Object::New(grid_data->env);
+            gint row_index = gtk_tree_path_get_indices(path)[0];
+            editInfo.Set("row", Napi::Number::New(grid_data->env, row_index));
+            editInfo.Set("col", Napi::Number::New(grid_data->env, i));
+            editInfo.Set("newValue", Napi::String::New(grid_data->env, new_text));
+
+            grid_data->cell_edit_callback.Call({editInfo});
+          }
+          g_list_free(renderers);
           break;
         }
         g_list_free(renderers);
       }
     }
   }
-  
+
   gtk_tree_path_free(path);
 }
 
 // Constructor de stringgrid
 Napi::Value CreateStringGrid(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-  
+
   int rows = 10; // Valor por defecto
   int cols = 5; // Valor por defecto
-  
+
   if (info.Length() > 0 && info[0].IsNumber()) {
     rows = info[0].As<Napi::Number>().Int32Value();
   }
   if (info.Length() > 1 && info[1].IsNumber()) {
     cols = info[1].As<Napi::Number>().Int32Value();
   }
-  
+
   // Crear modelo para el TreeView
   GType* types = new GType[cols];
   for (int i = 0; i < cols; i++) {
     types[i] = G_TYPE_STRING;
   }
-  
+
   GtkListStore* store = gtk_list_store_newv(cols, types);
   GtkWidget* treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
-  
+
   // Crear columnas con edición
   for (int i = 0; i < cols; i++) {
     GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
-    
+
     // Permitir edición
     g_object_set(renderer, "editable", TRUE, NULL);
-    
-    // Conectar el callback de edición
+
+    // Conectar el callback de edición con la estructura de datos
     g_signal_connect(renderer, "edited", G_CALLBACK(cell_edited_callback), NULL);
-    
+
     GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
       ("Col " + std::to_string(i)).c_str(), renderer, "text", i, NULL);
-    
+
     gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
   }
-  
+
   // Permitir selección
   GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
   gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
-  
+
   delete[] types;
-  
+
   // Crear estructura de datos para el stringgrid
   StringGridData* grid_data = new StringGridData(env);
   grid_data->treeview = treeview;
   grid_data->store = store;
-  
-  // Conectar el callback de edición a la estructura de datos
-  for (int i = 0; i < cols; i++) {
-    GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
-    g_object_set(renderer, "editable", TRUE, NULL);
-    g_signal_connect(renderer, "edited", G_CALLBACK(cell_edited_callback), grid_data);
-    
-    // Actualizar el renderer en la columna existente
+
+  // Conectar el callback de edición a la estructura de datos para todas las columnas
+  gint n_columns = gtk_tree_view_get_n_columns(GTK_TREE_VIEW(treeview));
+  for (gint i = 0; i < n_columns; i++) {
     GtkTreeViewColumn* column = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), i);
-    gtk_tree_view_column_clear(column);
-    gtk_tree_view_column_pack_start(column, renderer, TRUE);
-    gtk_tree_view_column_add_attribute(column, renderer, "text", i);
+    GList* renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
+    
+    if (renderers) {
+      GtkCellRenderer* renderer = (GtkCellRenderer*)renderers->data;
+      // Reconectar el callback con la estructura de datos correcta
+      g_signal_handlers_disconnect_by_func(renderer, (gpointer)cell_edited_callback, NULL);
+      g_signal_connect(renderer, "edited", G_CALLBACK(cell_edited_callback), grid_data);
+      g_list_free(renderers);
+    }
   }
-  
+
   // Guardar la estructura en los datos del widget
-  g_object_set_data_full(G_OBJECT(treeview), "stringgrid_data", grid_data, 
+  g_object_set_data_full(G_OBJECT(treeview), "stringgrid_data", grid_data,
     GDestroyNotify([](gpointer data) {
       StringGridData* grid_data = static_cast<StringGridData*>(data);
       if (!grid_data->cell_edit_callback.IsEmpty()) {
@@ -118,55 +134,55 @@ Napi::Value CreateStringGrid(const Napi::CallbackInfo& info) {
       }
       delete grid_data;
     }));
-  
+
   // Convertir el widget a External para pasarlo a JavaScript
   Napi::Object obj = Napi::Object::New(env);
   obj.Set("widget", Napi::External<GtkWidget>::New(env, treeview));
-  
+
   return obj;
 }
 
 // Función para establecer el valor de una celda
 Napi::Value SetGridCellValue(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-  
-  if (info.Length() < 4 || !info[0].IsObject() || !info[1].IsNumber() || 
+
+  if (info.Length() < 4 || !info[0].IsObject() || !info[1].IsNumber() ||
       !info[2].IsNumber() || !info[3].IsString()) {
     Napi::TypeError::New(env, "Se requiere un objeto widget, fila, columna y valor").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   Napi::Object widgetObj = info[0].As<Napi::Object>();
   int row = info[1].As<Napi::Number>().Int32Value();
   int col = info[2].As<Napi::Number>().Int32Value();
   std::string value = info[3].As<Napi::String>().Utf8Value();
-  
+
   if (!widgetObj.HasOwnProperty("widget")) {
     Napi::TypeError::New(env, "El objeto no contiene un widget válido").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   Napi::External<GtkWidget> widgetExt = widgetObj.Get("widget").As<Napi::External<GtkWidget>>();
   GtkWidget* treeview = widgetExt.Data();
-  
+
   StringGridData* grid_data = static_cast<StringGridData*>(
     g_object_get_data(G_OBJECT(treeview), "stringgrid_data"));
-  
+
   if (!grid_data || !grid_data->store) {
     Napi::TypeError::New(env, "Datos del grid no encontrados").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   // Buscar la fila específica
   GtkTreeIter iter;
   gboolean valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(grid_data->store), &iter);
   int current_row = 0;
-  
+
   while (valid && current_row < row) {
     valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(grid_data->store), &iter);
     current_row++;
   }
-  
+
   if (valid && current_row == row) {
     gtk_list_store_set(grid_data->store, &iter, col, value.c_str(), -1);
   } else {
@@ -178,50 +194,50 @@ Napi::Value SetGridCellValue(const Napi::CallbackInfo& info) {
     }
     gtk_list_store_set(grid_data->store, &iter, col, value.c_str(), -1);
   }
-  
+
   return Napi::Boolean::New(env, true);
 }
 
 // Función para obtener el valor de una celda
 Napi::Value GetGridCell(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-  
-  if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsNumber() || 
+
+  if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsNumber() ||
       !info[2].IsNumber()) {
     Napi::TypeError::New(env, "Se requiere un objeto widget, fila y columna").ThrowAsJavaScriptException();
     return Napi::String::New(env, "");
   }
-  
+
   Napi::Object widgetObj = info[0].As<Napi::Object>();
   int row = info[1].As<Napi::Number>().Int32Value();
   int col = info[2].As<Napi::Number>().Int32Value();
-  
+
   if (!widgetObj.HasOwnProperty("widget")) {
     Napi::TypeError::New(env, "El objeto no contiene un widget válido").ThrowAsJavaScriptException();
     return Napi::String::New(env, "");
   }
-  
+
   Napi::External<GtkWidget> widgetExt = widgetObj.Get("widget").As<Napi::External<GtkWidget>>();
   GtkWidget* treeview = widgetExt.Data();
-  
+
   StringGridData* grid_data = static_cast<StringGridData*>(
     g_object_get_data(G_OBJECT(treeview), "stringgrid_data"));
-  
+
   if (!grid_data || !grid_data->store) {
     Napi::TypeError::New(env, "Datos del grid no encontrados").ThrowAsJavaScriptException();
     return Napi::String::New(env, "");
   }
-  
+
   // Buscar la fila específica
   GtkTreeIter iter;
   gboolean valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(grid_data->store), &iter);
   int current_row = 0;
-  
+
   while (valid && current_row < row) {
     valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(grid_data->store), &iter);
     current_row++;
   }
-  
+
   if (valid && current_row == row) {
     GValue value = {0};
     gtk_tree_model_get_value(GTK_TREE_MODEL(grid_data->store), &iter, col, &value);
@@ -229,257 +245,209 @@ Napi::Value GetGridCell(const Napi::CallbackInfo& info) {
     g_value_unset(&value);
     return Napi::String::New(env, cell_value ? cell_value : "");
   }
-  
+
   return Napi::String::New(env, "");
 }
 
 // Función para establecer encabezados
 Napi::Value SetGridHeader(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-  
+
   if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsArray()) {
     Napi::TypeError::New(env, "Se requiere un objeto widget y un array de encabezados").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   Napi::Object widgetObj = info[0].As<Napi::Object>();
   Napi::Array headersArray = info[1].As<Napi::Array>();
-  
+
   if (!widgetObj.HasOwnProperty("widget")) {
     Napi::TypeError::New(env, "El objeto no contiene un widget válido").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   Napi::External<GtkWidget> widgetExt = widgetObj.Get("widget").As<Napi::External<GtkWidget>>();
   GtkWidget* treeview = widgetExt.Data();
-  
+
   StringGridData* grid_data = static_cast<StringGridData*>(
     g_object_get_data(G_OBJECT(treeview), "stringgrid_data"));
-  
+
   if (!grid_data) {
     Napi::TypeError::New(env, "Datos del grid no encontrados").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   // Actualizar los encabezados
   guint n_columns = gtk_tree_view_get_n_columns(GTK_TREE_VIEW(treeview));
   guint array_length = headersArray.Length();
-  
+
   for (guint i = 0; i < n_columns && i < array_length; i++) {
     Napi::Value headerValue = headersArray.Get(i);
     std::string header = headerValue.As<Napi::String>().Utf8Value();
-    
+
     GtkTreeViewColumn* column = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), i);
     if (column) {
       gtk_tree_view_column_set_title(column, header.c_str());
     }
   }
-  
+
   return Napi::Boolean::New(env, true);
 }
 
 // Función para agregar una fila
 Napi::Value AddGridRow(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-  
+
   if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsArray()) {
     Napi::TypeError::New(env, "Se requiere un objeto widget y un array de datos").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   Napi::Object widgetObj = info[0].As<Napi::Object>();
   Napi::Array dataArray = info[1].As<Napi::Array>();
-  
+
   if (!widgetObj.HasOwnProperty("widget")) {
     Napi::TypeError::New(env, "El objeto no contiene un widget válido").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   Napi::External<GtkWidget> widgetExt = widgetObj.Get("widget").As<Napi::External<GtkWidget>>();
   GtkWidget* treeview = widgetExt.Data();
-  
+
   StringGridData* grid_data = static_cast<StringGridData*>(
     g_object_get_data(G_OBJECT(treeview), "stringgrid_data"));
-  
+
   if (!grid_data || !grid_data->store) {
     Napi::TypeError::New(env, "Datos del grid no encontrados").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   // Crear una nueva fila
   GtkTreeIter iter;
   gtk_list_store_append(grid_data->store, &iter);
-  
+
   // Establecer los valores para cada columna
   guint array_length = dataArray.Length();
   guint n_cols = gtk_tree_model_get_n_columns(GTK_TREE_MODEL(grid_data->store));
-  
+
   for (guint i = 0; i < n_cols && i < array_length; i++) {
     Napi::Value cellValue = dataArray.Get(i);
     std::string cellStr = cellValue.As<Napi::String>().Utf8Value();
     gtk_list_store_set(grid_data->store, &iter, i, cellStr.c_str(), -1);
   }
-  
+
   return Napi::Boolean::New(env, true);
 }
 
 // Función para obtener la fila/columna seleccionada
 Napi::Value GetSelectedCell(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-  
+
   if (info.Length() < 1 || !info[0].IsObject()) {
     Napi::TypeError::New(env, "Se requiere un objeto widget").ThrowAsJavaScriptException();
     return Napi::Object::New(env);
   }
-  
+
   Napi::Object widgetObj = info[0].As<Napi::Object>();
-  
+
   if (!widgetObj.HasOwnProperty("widget")) {
     Napi::TypeError::New(env, "El objeto no contiene un widget válido").ThrowAsJavaScriptException();
     return Napi::Object::New(env);
   }
-  
+
   Napi::External<GtkWidget> widgetExt = widgetObj.Get("widget").As<Napi::External<GtkWidget>>();
   GtkWidget* treeview = widgetExt.Data();
-  
+
   StringGridData* grid_data = static_cast<StringGridData*>(
     g_object_get_data(G_OBJECT(treeview), "stringgrid_data"));
-  
+
   if (!grid_data) {
     Napi::TypeError::New(env, "Datos del grid no encontrados").ThrowAsJavaScriptException();
     return Napi::Object::New(env);
   }
-  
+
   // Obtener la selección
   GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
-  
+
   if (gtk_tree_selection_get_selected(selection, NULL, NULL)) {
     GtkTreeModel* model;
     GtkTreeIter iter;
-    
+
     if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
       // Para encontrar el índice de la fila, usaremos gtk_tree_model_get_path
       GtkTreePath* path = gtk_tree_model_get_path(model, &iter);
-      gint* indices = gtk_tree_path_get_indices(path);
-      gint row_index = -1;
-      
-      if (indices != NULL) {
-        row_index = indices[0]; // El primer índice es el número de fila
-      }
-      
+      gint row_index = gtk_tree_path_get_indices(path)[0];
+
       gtk_tree_path_free(path);
-      
+
       // Crear un objeto con la información de la selección
       Napi::Object result = Napi::Object::New(env);
       result.Set("row", Napi::Number::New(env, row_index));
       result.Set("col", Napi::Number::New(env, -1)); // GTK TreeView no proporciona fácilmente la columna seleccionada
-      
+
       return result;
     }
   }
-  
+
   // Si no hay selección, retornar un objeto vacío
   Napi::Object result = Napi::Object::New(env);
   result.Set("row", Napi::Number::New(env, -1));
   result.Set("col", Napi::Number::New(env, -1));
-  
-  return result;
-}
 
-// Función para conectar un callback cuando se edita una celda
-static void cell_edited_callback_with_context(GtkCellRendererText *renderer, gchar *path_string, gchar *new_text, gpointer user_data) {
-  StringGridData* grid_data = static_cast<StringGridData*>(user_data);
-  
-  // Convertir la cadena de ruta a un GtkTreePath
-  GtkTreePath* path = gtk_tree_path_new_from_string(path_string);
-  
-  // Obtener el iterador para la fila
-  GtkTreeIter iter;
-  if (gtk_tree_model_get_iter(GTK_TREE_MODEL(grid_data->store), &iter, path)) {
-    // Determinar qué columna fue editada
-    gint n_columns = gtk_tree_view_get_n_columns(GTK_TREE_VIEW(grid_data->treeview));
-    for (gint i = 0; i < n_columns; i++) {
-      GtkTreeViewColumn* col = gtk_tree_view_get_column(GTK_TREE_VIEW(grid_data->treeview), i);
-      GList* renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(col));
-      
-      if (renderers) {
-        GtkCellRenderer* renderer_in_col = (GtkCellRenderer*)renderers->data;
-        if (renderer_in_col == (GtkCellRenderer*)renderer) {
-          // Actualizar el valor en la tienda
-          gtk_list_store_set(grid_data->store, &iter, i, new_text, -1);
-          
-          // Si hay un callback registrado, llamarlo
-          if (!grid_data->cell_edit_callback.IsEmpty()) {
-            Napi::HandleScope scope(grid_data->env);
-            
-            // Crear objeto con información de la edición
-            Napi::Object editInfo = Napi::Object::New(grid_data->env);
-            editInfo.Set("row", Napi::Number::New(grid_data->env, gtk_tree_path_get_indices(path)[0]));
-            editInfo.Set("col", Napi::Number::New(grid_data->env, i));
-            editInfo.Set("newValue", Napi::String::New(grid_data->env, new_text));
-            
-            grid_data->cell_edit_callback.Call({editInfo});
-          }
-          break;
-        }
-        g_list_free(renderers);
-      }
-    }
-  }
-  
-  gtk_tree_path_free(path);
+  return result;
 }
 
 // Función para registrar un callback de edición de celda
 Napi::Value RegisterCellEditCallback(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-  
+
   if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsFunction()) {
     Napi::TypeError::New(env, "Se requiere un objeto widget y una función callback").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   Napi::Object widgetObj = info[0].As<Napi::Object>();
   Napi::Function callback = info[1].As<Napi::Function>();
-  
+
   if (!widgetObj.HasOwnProperty("widget")) {
     Napi::TypeError::New(env, "El objeto no contiene un widget válido").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   Napi::External<GtkWidget> widgetExt = widgetObj.Get("widget").As<Napi::External<GtkWidget>>();
   GtkWidget* treeview = widgetExt.Data();
-  
+
   StringGridData* grid_data = static_cast<StringGridData*>(
     g_object_get_data(G_OBJECT(treeview), "stringgrid_data"));
-  
+
   if (!grid_data) {
     Napi::TypeError::New(env, "Datos del grid no encontrados").ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
-  
+
   // Limpiar callback anterior si existe
   if (!grid_data->cell_edit_callback.IsEmpty()) {
     grid_data->cell_edit_callback.Reset();
   }
-  
+
   // Almacenar el nuevo callback
   grid_data->cell_edit_callback = Napi::Persistent(callback);
-  
-  // Conectar el callback de edición a todos los renderers
+
+  // Conectar el callback de edición a todas las columnas
   gint n_columns = gtk_tree_view_get_n_columns(GTK_TREE_VIEW(treeview));
   for (gint i = 0; i < n_columns; i++) {
     GtkTreeViewColumn* col = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), i);
     GList* renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(col));
-    
+
     if (renderers) {
       GtkCellRenderer* renderer = (GtkCellRenderer*)renderers->data;
+      // Reconectar el callback con la estructura de datos correcta
       g_signal_handlers_disconnect_by_func(renderer, (gpointer)cell_edited_callback, NULL);
-      g_signal_connect(renderer, "edited", G_CALLBACK(cell_edited_callback_with_context), grid_data);
+      g_signal_connect(renderer, "edited", G_CALLBACK(cell_edited_callback), grid_data);
       g_list_free(renderers);
     }
   }
-  
+
   return Napi::Boolean::New(env, true);
 }
 
@@ -491,6 +459,6 @@ Napi::Object InitStringGrid(Napi::Env env, Napi::Object exports) {
   exports.Set("addGridRow", Napi::Function::New(env, AddGridRow));
   exports.Set("getSelectedCell", Napi::Function::New(env, GetSelectedCell));
   exports.Set("registerCellEditCallback", Napi::Function::New(env, RegisterCellEditCallback));
-  
+
   return exports;
 }