gtk3-node 1.0.0 → 1.1.0

package/binding.gyp

@@ -0,0 +1,56 @@
+{
+  "targets": [
+    {
+      "target_name": "gtk3_node",
+      "sources": [
+        "src/gtk3_node.cpp",
+        "src/button.cpp",
+        "widgets/label/label.cpp",
+        "widgets/box/box.cpp",
+        "widgets/scroll/scroll.cpp"
+      ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")",
+        "/usr/include/gtk-3.0",
+        "/usr/include/glib-2.0",
+        "/usr/lib/x86_64-linux-gnu/glib-2.0/include",
+        "/usr/include/pango-1.0",
+        "/usr/include/harfbuzz",
+        "/usr/include/freetype2",
+        "/usr/include/libpng16",
+        "/usr/include/libmount",
+        "/usr/include/blkid",
+        "/usr/include/fribidi",
+        "/usr/include/cairo",
+        "/usr/include/pixman-1",
+        "/usr/include/gdk-pixbuf-2.0",
+        "/usr/include/x86_64-linux-gnu",
+        "/usr/include/gio-unix-2.0",
+        "/usr/include/atk-1.0",
+        "/usr/include/at-spi2-atk/2.0",
+        "/usr/include/at-spi-2.0",
+        "/usr/include/dbus-1.0",
+        "/usr/lib/x86_64-linux-gnu/dbus-1.0/include"
+      ],
+      "libraries": [
+        "-lgtk-3",
+        "-lgobject-2.0",
+        "-lglib-2.0",
+        "-lgdk-3",
+        "-lpango-1.0",
+        "-lcairo",
+        "-lgdk_pixbuf-2.0",
+        "-latk-1.0"
+      ],
+      "cflags": [
+        "-std=c++17"
+      ],
+      "cflags_cc": [
+        "-std=c++17"
+      ],
+      "defines": [
+        "NAPI_DISABLE_CPP_EXCEPTIONS"
+      ]
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtk3-node",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Native Node.js extension for creating GTK3 widgets",
   "main": "index.js",
   "scripts": {
@@ -48,6 +48,10 @@
   ],
   "author": "Usuario",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/bytedogssyndicate1/nodetk3.git"
+  },
   "dependencies": {
     "node-addon-api": "^7.0.0"
   },

package/src/button.cpp

@@ -0,0 +1,146 @@
+#include <napi.h>
+#include <gtk/gtk.h>
+
+// Estructura para almacenar datos del botón
+struct ButtonData {
+  GtkWidget* button;
+  Napi::FunctionReference callback;
+  Napi::Env env;
+  
+  ButtonData(Napi::Env e) : button(nullptr), env(e) {}
+};
+
+// Callback para el evento de clic en GTK
+static void button_click_callback(GtkWidget *widget, gpointer data) {
+  ButtonData* btn_data = static_cast<ButtonData*>(data);
+  
+  if (!btn_data->callback.IsEmpty()) {
+    Napi::HandleScope scope(btn_data->env);
+    btn_data->callback.Call({});
+  }
+}
+
+// Constructor de botón
+Napi::Value CreateButton(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  std::string label = "Button";
+  if (info.Length() > 0 && info[0].IsString()) {
+    label = info[0].As<Napi::String>().Utf8Value();
+  }
+  
+  GtkWidget* button = gtk_button_new_with_label(label.c_str());
+  
+  // Crear estructura de datos para el botón
+  ButtonData* btn_data = new ButtonData(env);
+  btn_data->button = button;
+  
+  // Guardar la estructura en los datos del widget
+  g_object_set_data_full(G_OBJECT(button), "button_data", btn_data, 
+    GDestroyNotify([](gpointer data) {
+      ButtonData* btn_data = static_cast<ButtonData*>(data);
+      if (!btn_data->callback.IsEmpty()) {
+        btn_data->callback.Reset();
+      }
+      delete btn_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, button));
+  
+  return obj;
+}
+
+// Función para conectar el callback de clic
+Napi::Value ConnectClick(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* button = widgetExt.Data();
+  
+  // Obtener la estructura de datos del botón
+  ButtonData* btn_data = static_cast<ButtonData*>(g_object_get_data(G_OBJECT(button), "button_data"));
+  if (!btn_data) {
+    Napi::TypeError::New(env, "Datos del botón no encontrados").ThrowAsJavaScriptException();
+    return Napi::Boolean::New(env, false);
+  }
+  
+  // Almacenar el nuevo callback
+  btn_data->callback.Reset(callback, 1);
+  
+  // Conectar el callback de GTK
+  g_signal_connect(button, "clicked", G_CALLBACK(button_click_callback), btn_data);
+  
+  return Napi::Boolean::New(env, true);
+}
+
+// Función para cambiar el texto del botón
+Napi::Value SetButtonText(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsString()) {
+    Napi::TypeError::New(env, "Se requiere un objeto widget y un texto").ThrowAsJavaScriptException();
+    return Napi::Boolean::New(env, false);
+  }
+  
+  Napi::Object widgetObj = info[0].As<Napi::Object>();
+  std::string newText = info[1].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* button = widgetExt.Data();
+  
+  gtk_button_set_label(GTK_BUTTON(button), newText.c_str());
+  
+  return Napi::Boolean::New(env, true);
+}
+
+// Función para obtener el texto del botón
+Napi::Value GetButtonText(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::String::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::String::New(env, "");
+  }
+  
+  Napi::External<GtkWidget> widgetExt = widgetObj.Get("widget").As<Napi::External<GtkWidget>>();
+  GtkWidget* button = widgetExt.Data();
+  
+  const gchar* text = gtk_button_get_label(GTK_BUTTON(button));
+  return Napi::String::New(env, text ? text : "");
+}
+
+Napi::Object InitButton(Napi::Env env, Napi::Object exports) {
+  exports.Set("createButton", Napi::Function::New(env, CreateButton));
+  exports.Set("connectClick", Napi::Function::New(env, ConnectClick));
+  exports.Set("setButtonText", Napi::Function::New(env, SetButtonText));
+  exports.Set("getButtonText", Napi::Function::New(env, GetButtonText));
+  
+  return exports;
+}

package/src/gtk3_node.cpp

@@ -0,0 +1,150 @@
+#include <napi.h>
+#include <gtk/gtk.h>
+
+// Función para inicializar GTK
+Napi::Value InitGtk(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  static bool initialized = false;
+  if (!initialized) {
+    gtk_init(0, NULL);
+    initialized = true;
+  }
+  
+  return Napi::Boolean::New(env, true);
+}
+
+// Función para ejecutar el loop de eventos de GTK
+Napi::Value RunGtk(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  gtk_main();
+  
+  return Napi::Boolean::New(env, true);
+}
+
+// Función para salir del loop de eventos de GTK
+Napi::Value QuitGtk(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  gtk_main_quit();
+  
+  return Napi::Boolean::New(env, true);
+}
+
+// Función para crear una ventana
+Napi::Value CreateWindow(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  std::string title = "Ventana";
+  gint width = 400;
+  gint height = 300;
+  
+  if (info.Length() > 0 && info[0].IsString()) {
+    title = info[0].As<Napi::String>().Utf8Value();
+  }
+  if (info.Length() > 1 && info[1].IsNumber()) {
+    width = info[1].As<Napi::Number>().Int32Value();
+  }
+  if (info.Length() > 2 && info[2].IsNumber()) {
+    height = info[2].As<Napi::Number>().Int32Value();
+  }
+  
+  GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title(GTK_WINDOW(window), title.c_str());
+  gtk_window_set_default_size(GTK_WINDOW(window), width, height);
+  
+  // Conectar el evento destroy para salir del programa
+  g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
+  
+  // Convertir el widget a External para pasarlo a JavaScript
+  Napi::Object obj = Napi::Object::New(env);
+  obj.Set("widget", Napi::External<GtkWidget>::New(env, window));
+  
+  return obj;
+}
+
+// Función para mostrar todos los widgets en una ventana
+Napi::Value ShowAll(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::Boolean::New(env, false);
+  }
+  
+  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::Boolean::New(env, false);
+  }
+  
+  Napi::External<GtkWidget> widgetExt = widgetObj.Get("widget").As<Napi::External<GtkWidget>>();
+  GtkWidget* window = widgetExt.Data();
+  
+  gtk_widget_show_all(window);
+  
+  return Napi::Boolean::New(env, true);
+}
+
+// Función para agregar un widget a una ventana
+Napi::Value AddToWindow(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 windowObj = info[0].As<Napi::Object>();
+  Napi::Object widgetObj = info[1].As<Napi::Object>();
+  
+  if (!windowObj.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> windowExt = windowObj.Get("widget").As<Napi::External<GtkWidget>>();
+  Napi::External<GtkWidget> widgetExt = widgetObj.Get("widget").As<Napi::External<GtkWidget>>();
+  
+  GtkWidget* window = windowExt.Data();
+  GtkWidget* widget = widgetExt.Data();
+  
+  gtk_container_add(GTK_CONTAINER(window), widget);
+  
+  return Napi::Boolean::New(env, true);
+}
+
+// Función principal que define el módulo
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  // Inicializar GTK
+  exports.Set("init", Napi::Function::New(env, InitGtk));
+  exports.Set("run", Napi::Function::New(env, RunGtk));
+  exports.Set("quit", Napi::Function::New(env, QuitGtk));
+  
+  // Funciones de ventana
+  exports.Set("createWindow", Napi::Function::New(env, CreateWindow));
+  exports.Set("showAll", Napi::Function::New(env, ShowAll));
+  exports.Set("addToWindow", Napi::Function::New(env, AddToWindow));
+  
+  // Inicializar las clases
+  extern Napi::Object InitButton(Napi::Env env, Napi::Object exports);
+  InitButton(env, exports);
+  
+  // Inicializar el widget Label
+  extern Napi::Object InitLabel(Napi::Env env, Napi::Object exports);
+  InitLabel(env, exports);
+  
+  // Inicializar el widget Box
+  extern Napi::Object InitBox(Napi::Env env, Napi::Object exports);
+  InitBox(env, exports);
+  
+  // Inicializar el widget Scroll
+  extern Napi::Object InitScroll(Napi::Env env, Napi::Object exports);
+  InitScroll(env, exports);
+  
+  return exports;
+}
+
+NODE_API_MODULE(gtk3_node, Init)

package/widgets/box/README.md

@@ -0,0 +1,42 @@
+# Widget Box
+
+El widget Box es parte de la colección de widgets para la extensión GTK3 para Node.js. Proporciona contenedores lineales (horizontales o verticales) para organizar otros widgets.
+
+## Características
+
+- Contenedor lineal horizontal o vertical
+- Soporta adición de múltiples widgets
+- Compatible con el principio DRY
+- Fácil integración con otros widgets
+
+## API
+
+### Constructor
+- `new Box(orientacion)` - Crea un nuevo contenedor con la orientación especificada ('horizontal' o 'vertical')
+
+### Métodos
+- `add(widget)` - Agrega un widget al contenedor
+
+## Ejemplo de Uso
+
+```javascript
+const { Box, Label, Window, init, run } = require('../../index.js');
+
+init();
+const window = new Window('Ejemplo Box', 400, 300);
+
+const box = new Box('vertical');
+const label1 = new Label('Etiqueta 1');
+const label2 = new Label('Etiqueta 2');
+
+box.add(label1);
+box.add(label2);
+window.add(box);
+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/box/box.cpp

@@ -0,0 +1,77 @@
+#include <napi.h>
+#include <gtk/gtk.h>
+
+// Estructura para almacenar datos del box
+struct BoxData {
+  GtkWidget* box;
+  Napi::Env env;
+  
+  BoxData(Napi::Env e) : box(nullptr), env(e) {}
+};
+
+// Constructor de box
+Napi::Value CreateBox(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  GtkOrientation orientation_enum = GTK_ORIENTATION_HORIZONTAL; // Por defecto horizontal
+  if (info.Length() > 0 && info[0].IsString()) {
+    std::string orientation = info[0].As<Napi::String>().Utf8Value();
+    if (orientation == "vertical" || orientation == "VERTICAL") {
+      orientation_enum = GTK_ORIENTATION_VERTICAL;
+    }
+  }
+  
+  GtkWidget* box = gtk_box_new(orientation_enum, 5); // 5 pixels de espaciado
+  
+  // Crear estructura de datos para el box
+  BoxData* box_data = new BoxData(env);
+  box_data->box = box;
+  
+  // Guardar la estructura en los datos del widget
+  g_object_set_data_full(G_OBJECT(box), "box_data", box_data, 
+    GDestroyNotify([](gpointer data) {
+      BoxData* box_data = static_cast<BoxData*>(data);
+      delete box_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, box));
+  
+  return obj;
+}
+
+// Función para agregar un widget al box
+Napi::Value AddToBox(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_box_pack_start(GTK_BOX(container), widget, FALSE, FALSE, 0);
+  
+  return Napi::Boolean::New(env, true);
+}
+
+Napi::Object InitBox(Napi::Env env, Napi::Object exports) {
+  exports.Set("createBox", Napi::Function::New(env, CreateBox));
+  exports.Set("addToBox", Napi::Function::New(env, AddToBox));
+  
+  return exports;
+}

package/widgets/box/box.h

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

package/widgets/label/README.md

@@ -0,0 +1,41 @@
+# Widget Label
+
+El widget Label es parte de la colección de widgets para la extensión GTK3 para Node.js. Proporciona una forma sencilla de mostrar texto estático en la interfaz de usuario.
+
+## Características
+
+- Muestra texto estático en la interfaz
+- Soporta texto multilínea
+- Compatible con el principio DRY
+- Fácil integración con otros widgets
+
+## API
+
+### Constructor
+- `new Label(texto)` - Crea una nueva etiqueta con el texto especificado
+
+### Propiedades
+- `text` - El texto mostrado en la etiqueta (getter/setter)
+
+### Métodos
+- `setText(texto)` - Establece el texto de la etiqueta
+- `getText()` - Obtiene el texto actual de la etiqueta
+
+## Ejemplo de Uso
+
+```javascript
+const { Label, Window, init, run } = require('../../index.js');
+
+init();
+const window = new Window('Ejemplo Label', 300, 200);
+
+const label = new Label('Hola Mundo!');
+window.add(label);
+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/label/label.cpp

@@ -0,0 +1,95 @@
+#include <napi.h>
+#include <gtk/gtk.h>
+
+// Estructura para almacenar datos del label
+struct LabelData {
+  GtkWidget* label;
+  Napi::Env env;
+  
+  LabelData(Napi::Env e) : label(nullptr), env(e) {}
+};
+
+// Constructor de label
+Napi::Value CreateLabel(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  std::string text = "";
+  if (info.Length() > 0 && info[0].IsString()) {
+    text = info[0].As<Napi::String>().Utf8Value();
+  }
+  
+  GtkWidget* label = gtk_label_new(text.c_str());
+  
+  // Crear estructura de datos para el label
+  LabelData* lbl_data = new LabelData(env);
+  lbl_data->label = label;
+  
+  // Guardar la estructura en los datos del widget
+  g_object_set_data_full(G_OBJECT(label), "label_data", lbl_data, 
+    GDestroyNotify([](gpointer data) {
+      LabelData* lbl_data = static_cast<LabelData*>(data);
+      delete lbl_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, label));
+  
+  return obj;
+}
+
+// Función para establecer el texto del label
+Napi::Value SetLabelText(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsString()) {
+    Napi::TypeError::New(env, "Se requiere un objeto widget y un texto").ThrowAsJavaScriptException();
+    return Napi::Boolean::New(env, false);
+  }
+  
+  Napi::Object widgetObj = info[0].As<Napi::Object>();
+  std::string newText = info[1].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* label = widgetExt.Data();
+  
+  gtk_label_set_text(GTK_LABEL(label), newText.c_str());
+  
+  return Napi::Boolean::New(env, true);
+}
+
+// Función para obtener el texto del label
+Napi::Value GetLabelText(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::String::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::String::New(env, "");
+  }
+  
+  Napi::External<GtkWidget> widgetExt = widgetObj.Get("widget").As<Napi::External<GtkWidget>>();
+  GtkWidget* label = widgetExt.Data();
+  
+  const gchar* text = gtk_label_get_text(GTK_LABEL(label));
+  return Napi::String::New(env, text ? text : "");
+}
+
+Napi::Object InitLabel(Napi::Env env, Napi::Object exports) {
+  exports.Set("createLabel", Napi::Function::New(env, CreateLabel));
+  exports.Set("setLabelText", Napi::Function::New(env, SetLabelText));
+  exports.Set("getLabelText", Napi::Function::New(env, GetLabelText));
+  
+  return exports;
+}

package/widgets/label/label.h

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

package/widgets/scroll/README.md

@@ -0,0 +1,40 @@
+# Widget Scroll
+
+El widget Scroll es parte de la colección de widgets para la extensión GTK3 para Node.js. Proporciona contenedores con barras de desplazamiento para manejar contenido que excede el área visible.
+
+## Características
+
+- Contenedor con barras de desplazamiento vertical y horizontal
+- Soporta adición de widgets hijos
+- Compatible con el principio DRY
+- Fácil integración con otros widgets
+
+## API
+
+### Constructor
+- `new Scroll()` - Crea un nuevo contenedor con scroll
+
+### Métodos
+- `add(widget)` - Agrega un widget al contenedor con scroll
+
+## Ejemplo de Uso
+
+```javascript
+const { Scroll, Label, Window, init, run } = require('../../index.js');
+
+init();
+const window = new Window('Ejemplo Scroll', 300, 200);
+
+const scroll = new Scroll();
+const label = new Label('Contenido largo...');
+
+scroll.add(label);
+window.add(scroll);
+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/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