gtk3-node 1.0.0 → 1.2.0

package/widgets/scroll/scroll.cpp

@@ -0,0 +1,72 @@
+#include <napi.h>
+#include <gtk/gtk.h>
+
+// Estructura para almacenar datos del scroll
+struct ScrollData {
+  GtkWidget* scroll;
+  Napi::Env env;
+  
+  ScrollData(Napi::Env e) : scroll(nullptr), env(e) {}
+};
+
+// Constructor de scroll
+Napi::Value CreateScroll(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  GtkWidget* scroll = gtk_scrolled_window_new(NULL, NULL);
+  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), 
+                                 GTK_POLICY_AUTOMATIC, 
+                                 GTK_POLICY_AUTOMATIC);
+  
+  // Crear estructura de datos para el scroll
+  ScrollData* scroll_data = new ScrollData(env);
+  scroll_data->scroll = scroll;
+  
+  // Guardar la estructura en los datos del widget
+  g_object_set_data_full(G_OBJECT(scroll), "scroll_data", scroll_data, 
+    GDestroyNotify([](gpointer data) {
+      ScrollData* scroll_data = static_cast<ScrollData*>(data);
+      delete scroll_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, scroll));
+  
+  return obj;
+}
+
+// Función para agregar un widget al scroll
+Napi::Value AddToScroll(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+    Napi::TypeError::New(env, "Se requieren dos objetos widget").ThrowAsJavaScriptException();
+    return Napi::Boolean::New(env, false);
+  }
+  
+  Napi::Object containerObj = info[0].As<Napi::Object>();
+  Napi::Object widgetObj = info[1].As<Napi::Object>();
+  
+  if (!containerObj.HasOwnProperty("widget") || !widgetObj.HasOwnProperty("widget")) {
+    Napi::TypeError::New(env, "Ambos objetos deben contener widgets válidos").ThrowAsJavaScriptException();
+    return Napi::Boolean::New(env, false);
+  }
+  
+  Napi::External<GtkWidget> containerExt = containerObj.Get("widget").As<Napi::External<GtkWidget>>();
+  Napi::External<GtkWidget> widgetExt = widgetObj.Get("widget").As<Napi::External<GtkWidget>>();
+  
+  GtkWidget* container = containerExt.Data();
+  GtkWidget* widget = widgetExt.Data();
+  
+  gtk_container_add(GTK_CONTAINER(container), widget);
+  
+  return Napi::Boolean::New(env, true);
+}
+
+Napi::Object InitScroll(Napi::Env env, Napi::Object exports) {
+  exports.Set("createScroll", Napi::Function::New(env, CreateScroll));
+  exports.Set("addToScroll", Napi::Function::New(env, AddToScroll));
+  
+  return exports;
+}

package/widgets/scroll/scroll.h

@@ -0,0 +1,10 @@
+#ifndef SCROLL_H
+#define SCROLL_H
+
+#include <napi.h>
+#include <gtk/gtk.h>
+
+// Función para inicializar el widget Scroll
+Napi::Object InitScroll(Napi::Env env, Napi::Object exports);
+
+#endif // SCROLL_H

package/widgets/stringgrid/README.md

@@ -0,0 +1,46 @@
+# Widget StringGrid
+
+El widget StringGrid es parte de la colección de widgets para la extensión GTK3 para Node.js. Proporciona una tabla bidimensional para mostrar y editar datos en formato fila-columna.
+
+## Características
+
+- Tabla bidimensional de filas y columnas
+- Soporte para edición de celdas
+- Compatible con el principio DRY
+- Fácil integración con otros widgets
+
+## API
+
+### Constructor
+- `new StringGrid(rows, cols)` - Crea una nueva tabla con el número especificado de filas y columnas
+
+### Métodos
+- `setCellValue(row, col, value)` - Establece el valor de una celda
+- `getCell(row, col)` - Obtiene el valor de una celda
+- `setHeader(headers)` - Establece los encabezados de columna
+- `addRow(data)` - Agrega una fila con los datos especificados
+
+## Ejemplo de Uso
+
+```javascript
+const { StringGrid, Window, init, run } = require('../../index.js');
+
+init();
+const window = new Window('Ejemplo StringGrid', 600, 400);
+
+const grid = new StringGrid(10, 5); // 10 filas, 5 columnas
+grid.setHeader(['Nombre', 'Edad', 'Ciudad', 'País', 'Activo']);
+
+// Agregar algunas filas de ejemplo
+grid.addRow(['Juan Pérez', '30', 'Madrid', 'España', 'Sí']);
+grid.addRow(['Ana García', '25', 'Barcelona', 'España', 'No']);
+
+window.add(grid);
+window.show();
+
+run();
+```
+
+## Principio DRY
+
+Este widget sigue el principio DRY (Don't Repeat Yourself) al reutilizar patrones comunes de implementación de widgets en la extensión GTK3 para Node.js.

package/widgets/stringgrid/stringgrid.cpp

@@ -0,0 +1,496 @@
+#include <napi.h>
+#include <gtk/gtk.h>
+
+// Estructura para almacenar datos del stringgrid
+struct StringGridData {
+  GtkWidget* treeview;
+  GtkListStore* store;
+  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);
+          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
+    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
+    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);
+  }
+  
+  // Guardar la estructura en los datos del widget
+  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()) {
+        grid_data->cell_edit_callback.Reset();
+      }
+      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() || 
+      !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 {
+    // Si la fila no existe, crearla
+    gtk_list_store_append(grid_data->store, &iter);
+    // Rellenar las columnas anteriores con cadenas vacías si es necesario
+    for (int i = 0; i < col; i++) {
+      gtk_list_store_set(grid_data->store, &iter, i, "", -1);
+    }
+    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() || 
+      !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);
+    const gchar* cell_value = g_value_get_string(&value);
+    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
+      }
+      
+      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);
+}
+
+// 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
+  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;
+      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_list_free(renderers);
+    }
+  }
+  
+  return Napi::Boolean::New(env, true);
+}
+
+Napi::Object InitStringGrid(Napi::Env env, Napi::Object exports) {
+  exports.Set("createStringGrid", Napi::Function::New(env, CreateStringGrid));
+  exports.Set("setGridCellValue", Napi::Function::New(env, SetGridCellValue));
+  exports.Set("getGridCell", Napi::Function::New(env, GetGridCell));
+  exports.Set("setGridHeader", Napi::Function::New(env, SetGridHeader));
+  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;
+}

package/widgets/stringgrid/stringgrid.h

@@ -0,0 +1,10 @@
+#ifndef STRINGGRID_H
+#define STRINGGRID_H
+
+#include <napi.h>
+#include <gtk/gtk.h>
+
+// Función para inicializar el widget StringGrid
+Napi::Object InitStringGrid(Napi::Env env, Napi::Object exports);
+
+#endif // STRINGGRID_H

package/widgets/textview/README.md

@@ -0,0 +1,48 @@
+# Widget TextView
+
+El widget TextView es parte de la colección de widgets para la extensión GTK3 para Node.js. Proporciona un área de texto multilinea para entrada y visualización de grandes cantidades de texto.
+
+## Características
+
+- Área de texto multilinea para entrada de texto largo
+- Soporta desplazamiento para contenido extenso
+- Compatible con el principio DRY
+- Fácil integración con otros widgets
+
+## API
+
+### Constructor
+- `new TextView(textoInicial)` - Crea un nuevo área de texto con texto opcional inicial
+
+### Propiedades
+- `text` - El texto actual en el área de texto (getter/setter)
+
+### Métodos
+- `setText(texto)` - Establece el texto en el área de texto
+- `getText()` - Obtiene el texto actual del área de texto
+- `appendText(texto)` - Añade texto al final del contenido existente
+- `insertText(posición, texto)` - Inserta texto en una posición específica
+
+## Ejemplo de Uso
+
+```javascript
+const { TextView, Window, init, run } = require('../../index.js');
+
+init();
+const window = new Window('Ejemplo TextView', 400, 300);
+
+const textView = new TextView('Texto inicial\\ncon múltiples\\nlíneas');
+window.add(textView);
+window.show();
+
+// Leer el valor del textView
+setTimeout(() => {
+  console.log('Contenido del TextView:', textView.text);
+}, 2000);
+
+run();
+```
+
+## Principio DRY
+
+Este widget sigue el principio DRY (Don't Repeat Yourself) al reutilizar patrones comunes de implementación de widgets en la extensión GTK3 para Node.js.