Docs / Primeros Pasos / Arquitectura

Arquitectura

HarbourBuilder utiliza una arquitectura en capas que separa limpiamente la logica de la aplicacion del codigo nativo especifico de la plataforma. Este disenio permite que una unica base de codigo .prg produzca aplicaciones nativas en Windows macOS Linux.

Arquitectura de 5 Capas

Cada aplicacion HarbourBuilder fluye a traves de cinco capas, desde la sintaxis xBase de alto nivel hasta las llamadas a la API nativa de la plataforma:

graph TB A["1. Application Code
.prg source files"] --> B["2. xBase Commands
#xcommand / #translate (compile-time)"] B --> C["3. Harbour OOP Layer
TForm, TControl, TToolBar, ..."] C --> D["4. HB_FUNC Bridge
UI_FormNew, UI_SetProp, UI_OnEvent"] D --> E1["5a. Win32 API
C++ · CreateWindowEx"] D --> E2["5b. Cocoa / AppKit
Objective-C · NSView"] D --> E3["5c. GTK3
C · GtkWidget"] D --> E4["5d. Android
JNI · android.widget.*"] D --> E5["5e. iOS / UIKit
Objective-C · UIView"] style A fill:#58a6ff,stroke:#388bfd,color:#0d1117 style B fill:#8b5cf6,stroke:#7c3aed,color:#fff style C fill:#f59e0b,stroke:#d97706,color:#0d1117 style D fill:#3fb950,stroke:#2ea043,color:#0d1117 style E1 fill:#0078d4,stroke:#005a9e,color:#fff style E2 fill:#555,stroke:#333,color:#fff style E3 fill:#e95420,stroke:#c34113,color:#fff style E4 fill:#34c759,stroke:#1a8d4d,color:#0d1117 style E5 fill:#007aff,stroke:#005ec4,color:#fff

¿Por que cinco capas? La capa de comandos xBase permite a los desarrolladores escribir la sintaxis familiar de estilo Clipper. La capa OOP proporciona un modelo de objeto consistente. El puente HB_FUNC es el punto unico donde Harbour se encuentra con C/C++/Obj-C, lo que facilita anadir nuevos backends sin tocar el codigo de la aplicacion.

Backends de Plataforma

Cada capa se asigna a una tecnologia nativa diferente segun la plataforma objetivo:

Capa	Windows	macOS	Linux	Android	iOS
Codigo de Aplicacion	Harbour .prg	Harbour .prg	Harbour .prg	Harbour .prg	Harbour .prg
Comandos xBase	hbbuilder.ch	hbbuilder.ch	hbbuilder.ch	UI_* directo (re-emitido por el IDE)	UI_* directo (re-emitido por el IDE)
Capa OOP	TForm, TControl	TForm, TControl	TForm, TControl	UI_* plano (iter 1, TForm pronto)	UI_* plano (iter 1, TForm pronto)
Puente HB_FUNC	C++ (MSVC/MinGW)	Objective-C (Clang)	C (GCC)	C + JNI (NDK Clang)	Objective-C (Xcode Clang)
Backend Nativo	Win32 API / GDI+	Cocoa / AppKit	GTK3 / Cairo	android.widget.*	UIKit / UIView
Creacion de Ventanas	CreateWindowEx()	[NSWindow alloc]	gtk_window_new()	FrameLayout en MainActivity	UIView en UIViewController
Bucle de Eventos	GetMessage / WndProc	[NSApp run]	gtk_main()	Ciclo de vida de la Activity	UIApplicationMain (controlado por el SO)
Dibujo	GDI / GDI+	Core Graphics	Cairo / Pango	Canvas / Skia	Core Graphics (iOS)

Android e iOS son objetivos de cross-compile, no hosts. El IDE sigue ejecutandose en Windows/macOS/Linux; lo que produce es un APK o .app que corre en el dispositivo o simulador. Ver la guia de la plataforma Android y la guia de la plataforma iOS para los pipelines completos y los Setup Wizards que instalan los toolchains automaticamente.

Sistema de Tipos de Control

Cada componente visual en HarbourBuilder se identifica mediante una constante numerica CT_ definida en hbide.h. Estas constantes (que van de 0 a 86) determinan como el IDE serializa los controles, como el disenador los renderiza y que widget nativo crea el backend en tiempo de ejecucion.

¿Por que IDs numericos? Un tipo entero simple permite despachar rapidamente la creacion de controles a traves del puente C y mantiene el formato binario compacto. Los mismos IDs son utilizados por el disenador, el generador de codigo y el runtime.

Pestania de Paleta	Rango CT_	Controles
Estandar	0 – 11	CT_FORM (0), CT_LABEL (1), CT_EDIT (2), CT_BUTTON (3), CT_CHECKBOX (4), CT_COMBOBOX (5), CT_GROUPBOX (6), CT_LISTBOX (7), CT_RADIO (8), CT_TOOLBAR (9), CT_TABCONTROL (10), CT_STATUSBAR (11)
Adicionales	12 – 32	CT_BITBTN (12), CT_SPEEDBTN (13), CT_IMAGE (14), CT_SHAPE (15), CT_BEVEL (16), CT_SCROLLBOX (17), CT_MASKEDIT (18), CT_STRINGGRID (19), CT_MEMO (24), CT_PANEL (25), CT_SCROLLBAR (26), CT_STATICTEXT (31), CT_LABELEDEDIT (32)
Nativo	20 – 37	CT_TREEVIEW (20), CT_LISTVIEW (21), CT_PROGRESSBAR (22), CT_RICHEDIT (23), CT_TRACKBAR (34), CT_UPDOWN (35), CT_DATETIMEPICKER (36), CT_MONTHCALENDAR (37)
Sistema	38 – 39	CT_TIMER (38), CT_PAINTBOX (39)
Dialogos	40 – 45	CT_OPENDIALOG (40), CT_SAVEDIALOG (41), CT_FONTDIALOG (42), CT_COLORDIALOG (43), CT_FINDDIALOG (44), CT_REPLACEDIALOG (45)
IA	46 – 52	CT_OPENAI (46), CT_GEMINI (47), CT_CLAUDE (48), CT_DEEPSEEK (49), CT_GROK (50), CT_OLLAMA (51), CT_TRANSFORMER (52)
Acceso a Datos	53 – 61	CT_DBFTABLE (53), CT_MYSQL (54), CT_MARIADB (55), CT_POSTGRESQL (56), CT_SQLITE (57), CT_FIREBIRD (58), CT_SQLSERVER (59), CT_ORACLE (60), CT_MONGODB (61)
Internet	62, 71 – 78	CT_WEBVIEW (62), CT_WEBSERVER (71), CT_WEBSOCKET (72), CT_HTTPCLIENT (73), CT_FTPCLIENT (74), CT_SMTPCLIENT (75), CT_TCPSERVER (76), CT_TCPCLIENT (77), CT_UDPSOCKET (78)
Hilos	63 – 70	CT_THREAD (63), CT_MUTEX (64), CT_SEMAPHORE (65), CT_CRITICALSECTION (66), CT_THREADPOOL (67), CT_ATOMICINT (68), CT_CONDVAR (69), CT_CHANNEL (70)
Conscientes de Datos	79 – 86	CT_BROWSE (79), CT_DBGRID (80), CT_DBNAVIGATOR (81), CT_DBTEXT (82), CT_DBEDIT (83), CT_DBCOMBOBOX (84), CT_DBCHECKBOX (85), CT_DBIMAGE (86)

Estructura de Archivos

El proyecto HarbourBuilder esta organizado en directorios claramente separados:

HarbourBuilder/
├── backends/
│   ├── cocoa/          // Backend Objective-C para macOS
│   ├── gtk3/           // Backend GTK3/C para Linux
│   ├── win32/          // Backend C++ para Windows
│   ├── android/        // Backend JNI + Java para Android
│   ├── ios/            // Backend UIKit + Objective-C para iOS
│   ├── console/        // Backend TUI de consola
│   └── web/            // Backend Web/HTML
├── core/               // Clases OOP de Harbour (TForm, TControl, ...)
├── cpp/
│   ├── include/        // Cabeceras C/C++ (hbide.h con defines CT_)
│   └── src/            // Fuentes C++ del IDE (disenador, inspector, editor)
├── docs/
│   ├── assets/         // CSS, JS, imagenes para documentacion
│   ├── en/             // Documentacion en ingles
│   ├── es/             // Documentacion en espaniol
│   └── pt/             // Documentacion en portugues
├── harbour/            // Compilador Harbour y runtime
├── images/             // Iconos y mapas de bits del IDE
├── include/            // Cabeceras Harbour (hbide.ch)
├── resources/
│   └── icons/          // Iconos de la paleta de componentes
└── samples/
    └── projects/       // Proyectos de ejemplo

Sistema de Eventos

HarbourBuilder enruta los eventos nativos del sistema operativo a traves de una canalizacion unificada que termina en bloques de codigo Harbour definidos por el usuario. El mismo flujo de eventos se aplica en todas las plataformas; solo difiere el punto de entrada (WndProc en Windows, NSResponder en macOS, g_signal en GTK3, UIEvent en iOS).

sequenceDiagram participant User participant OS as Native OS participant WndProc as WndProc / NSResponder / g_signal / UIResponder participant Fire as FireEvent() participant Block as Harbour Code Block participant Code as User Code User->>OS: Click button OS->>WndProc: WM_COMMAND / action / clicked / touchUpInside WndProc->>Fire: FireEvent( hWnd, nMsg, CT_BUTTON ) Fire->>Block: Eval( oBtn:OnClick ) Block->>Code: { || MsgInfo("Hello!") } Code-->>User: Message box displayed

Vinculacion de eventos Los eventos se vinculan asignando un bloque de codigo a una propiedad del control: oBtn:OnClick := { || DoSomething() }. El generador de codigo escribe estas asignaciones automaticamente cuando se hace doble clic en un control en el disenador de formularios.

Herramientas Bidireccionales

HarbourBuilder mantiene una sincronizacion perfecta entre el disenador visual y el codigo fuente. Los cambios en cualquier direccion se reflejan instantaneamente, y las implementaciones METHOD escritas por el usuario nunca se sobrescriben durante la regeneracion de codigo.

flowchart LR A["Form Designer
(visual)"] -- "drop control /
move / resize" --> B["Code Generator"] B -- "writes .prg" --> C["Source Code
(.prg file)"] C -- "parse changes" --> D["Code Parser"] D -- "updates objects" --> A B -. "preserves METHOD
implementations" .-> C D -. "detects new controls
and properties" .-> A style A fill:#58a6ff,stroke:#388bfd,color:#0d1117 style C fill:#3fb950,stroke:#2ea043,color:#0d1117 style B fill:#f59e0b,stroke:#d97706,color:#0d1117 style D fill:#f59e0b,stroke:#d97706,color:#0d1117

Direccion	Disparador	Accion
Disenador → Codigo	Soltar, mover, redimensionar o cambiar una propiedad en el inspector	El generador de codigo reescribe los comandos DEFINE FORM / @, preservando todos los bloques METHOD
Codigo → Disenador	Editar el fuente .prg en el editor de codigo y guardar	El analizador de codigo detecta controles nuevos o modificados y actualiza el lienzo del disenador en tiempo real

Canalizacion de Compilacion

El proceso de compilacion transforma el codigo fuente Harbour en ejecutables nativos a traves de una canalizacion de multiples etapas:

graph LR A[".prg
Harbour source"] --> B["Harbour Compiler
(harbour.exe)"] B --> C[".c
Generated C code"] C --> D["C Compiler
(MSVC / Clang / GCC)"] D --> E[".obj / .o
Object files"] E --> F["Linker
(link / ld)"] G["Native Backend
(Win32 / Cocoa / GTK3 / Android JNI / iOS UIKit)"] --> F H["Harbour Runtime
(libharbour)"] --> F F --> I[".exe / app / ELF / APK / .app
Native binary"] style A fill:#58a6ff,stroke:#388bfd,color:#0d1117 style B fill:#8b5cf6,stroke:#7c3aed,color:#fff style C fill:#f59e0b,stroke:#d97706,color:#0d1117 style D fill:#8b5cf6,stroke:#7c3aed,color:#fff style E fill:#f59e0b,stroke:#d97706,color:#0d1117 style F fill:#3fb950,stroke:#2ea043,color:#0d1117 style G fill:#e95420,stroke:#c34113,color:#fff style H fill:#555,stroke:#333,color:#fff style I fill:#3fb950,stroke:#2ea043,color:#0d1117

Etapa	Windows	macOS	Linux	Android	iOS
Compilador Harbour	harbour.exe	harbour	harbour	harbour (NDK cross)	harbour (Xcode cross)
Compilador C	cl.exe (MSVC) / gcc (MinGW)	clang (Xcode)	gcc / g++	clang (NDK)	clang (Xcode)
Enlazador	link.exe / ld	ld (via clang)	ld (via gcc)	ld (NDK)	ld (via clang)
Etapas Extra	—	—	—	aapt2 → javac → d8 → zipalign → apksigner	asset catalog → Info.plist → .app bundle
Salida	.exe	Paquete .app	Binario ELF	.apk	Paquete .app

Compilacion con un clic Presione F9 en el IDE para compilar, enlazar y ejecutar su proyecto. HarbourBuilder detecta la plataforma actual y selecciona la cadena de herramientas del compilador apropiada automaticamente.

En Esta Página

Primeros Pasos Paleta de Componentes Funciones del IDE Tutoriales Referencia Plataformas Arquitectura de 5 Capas Backends de Plataforma Sistema de Tipos de Control Estructura de Archivos Sistema de Eventos Herramientas Bidireccionales Canalizacion de Compilacion