Recursos y fundamentos de SWT

SWT (Standard Widget Toolkit) es un framwork de Java que utiliza JNI para interactuar con las APIs nativas del sistema operativo, ofreciendo una apariencia nativa y un rendimiento eficiente. Esto contrasta con frameworks como Swing que dibujan sus propios componentes. Para comenzar, se puede acceder a la documentación oficial y ejemplos en el sitio de Eclipse SWT.

Para obtener el código fuente, se puede clonar el repositorio oficial:

git clone --depth=1 git://git.eclipse.org/gitroot/platform/eclipse.platform.swt.git

Dentro del repositroio, el directorio org.eclipse.swt.snippets contiene fragmentos de código útiles para principiantes, mientras que el directorio examples incluye demostraciones completas.

Configuración de SWT en Eclipse con WindowBuilder

Para desarrollar aplicaciones SWT visualmente en Eclipse, se recomienda instalar el plugin WindowBuilder. Este proceso puede resolver errores comunes como "Unknown GUI toolkit" o problemas al importar paquetes SWT.

1. Instale el plugin WindowBuilder desde el mercado de Eclipse, seleccionando la versión estable disponible.
2. Al crear un nuevo proyecto, asegúrese de configurar correctamente el paquete. En lugar de seguir pasos genéricos, cree un paquete con src -> new -> Packages, marcando la opción para generar package-info.java. Luego, desde other -> WindowBuilder -> SWT -> Application Window, complete la creación.
3. Si la vista de diseño muestra errores como "Unknown GUI toolkit", cambie a la vista de código y elimine las importaciones problemáticas. Agregue la dependencia de SWT al archivo module-info.java mediante requires org.eclipse.swt.win32.win32.x86_64;, eliminando cualquier línea redundante como requires swt;.
4. Descargue el archivo swt.jar correspondiente a su plataforma y extráigalo en un directorio. En Eclipse, agregue este directorio como una carpeta de clases en la ruta de classpath del proyecto.
5. Para soporte de bibliotecas nativas (DLL), localice el archivo JAR de SWT en el directorio plugins de Eclipse (por ejemplo, org.eclipse.swt.win32.win32.x86_64_*.jar), extraiga los archivos DLL y impórtelos al proyecto usando File -> Import -> General -> File System.

Una vez configurado, el entorno debería funcionar sin errores, permitiendo el diseño visual de interfaces SWT.

Configuración de SWT en entornos no Eclipse, como VSCode

Para configurar SWT fuera de Eclipse, como en VSCode, siga estos pasos:

1. Descarga de SWT

Visite el sitio oficial de Eclipse SWT y descargue el archivo ZIP correspondiente a su versión de Eclipse y plataforma (por ejemplo, swt-<versi>-win32-win32-x86_64.zip</versi>). Extraiga el contenido para obtener swt.jar.

2. Ejemplo básico de aplicación SWT

Coloque el archivo swt.jar en una carpeta lib y cree un archivo Java con la siguiente estructura modificada:

package com.demo.swt;

import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.SWT;

public class VentanaSWT {
    public static void main(String[] args) {
        Display displayObj = new Display();
        Shell ventanaPrincipal = new Shell(displayObj, SWT.CLOSE | SWT.MIN);
        ventanaPrincipal.setBounds(150, 150, 350, 250);
        ventanaPrincipal.setText("Aplicación SWT");
        ventanaPrincipal.open();

        while (!ventanaPrincipal.isDisposed()) {
            if (!displayObj.readAndDispatch()) {
                displayObj.sleep();
            }
        }
        displayObj.dispose();
    }
}

Compile el código con el classpath apuntando a swt.jar:

javac -classpath "../lib/swt.jar" com/demo/swt/VentanaSWT.java

3. Configuración en VSCode

Para gestionar dependencias en VSCode, se recomienda usar Maven. Cree un proyecto Maven y agregue el repositorio de SWT en el archivo pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" ...>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>app-swt</artifactId>
    <version>1.0</version>

    <repositories>
        <repository>
            <id>eclipse-swt</id>
            <url>http://maven-eclipse.github.io/maven</url>
        </repository>
    </repositories>

    <properties>
        <swt.version>4.924</swt.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.eclipse.swt</groupId>
            <artifactId>org.eclipse.swt.win32.win32.x86_64</artifactId>
            <version>${swt.version}</version>
        </dependency>
    </dependencies>
</project>

Asegúrese de configurar Maven para usar una fuente espejo, como Alibaba, para mejorar la velocidad de descarga. Edite el archivo settings.xml de Maven en ~/.m2/:

<settings>
    <mirrors>
        <mirror>
            <id>aliyun</id>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <mirrorOf>central</mirrorOf>
        </mirror>
    </mirrors>
</settings>

Si se encuentran errores como UnsatisfiedLinkError, verifique que las bibliotecas nativas (DLL) coincidan con la arquitectura del JDK (32-bit o 64-bit).

Introducción a JavaFX

JavaFX es una alternativa moderna para interfaces gráficas en Java, inspirada en SWT para integración nativa pero con soporte oficial y características avanzadas. A partir de JDK 9, JavaFX se distribuye por separado.

Configuración de JavaFX con Maven

Para configurar un proyecto JavaFX, use Maven con las siguientes dependencias y plugin:

<project xmlns="http://maven.apache.org/POM/4.0.0" ...>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.demo</groupId>
    <artifactId>aplicacion-javafx</artifactId>
    <version>1.0</version>

    <properties>
        <javafx.version>17</javafx.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-controls</artifactId>
            <version>${javafx.version}</version>
        </dependency>
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-fxml</artifactId>
            <version>${javafx.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.openjfx</groupId>
                <artifactId>javafx-maven-plugin</artifactId>
                <version>0.0.8</version>
                <configuration>
                    <mainClass>com.demo.AppLauncher</mainClass>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.4.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals><goal>shade</goal></goals>
                    </execution>
                </executions>
                <configuration>
                    <transformers>
                        <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                            <mainClass>com.demo.AppLauncher</mainClass>
                        </transformer>
                    </transformers>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Para ejecutar la aplicación, use el comando mvn javafx:run. Para empaquetar, ejecute mvn package shade:shade para crear un JAR con todas las dependencias.

Al configurar el IDE, como IntelliJ IDEA, añada la opción de ejecución Maven con el parámetro javafx:run. Para versiones de JDK 11 y superiores, asegúrese de incluir módulos JavaFX en la configuración, por ejemplo:

--module-path "/ruta/a/javafx-sdk/lib" --add-modules=javafx.controls,javafx.fxml

Para verificar la versión de JavaFX en tiempo de ejecución, se puede incluir código de diagnóstico en el método start():

System.out.println("Versión Java: " + System.getProperty("java.version"));
System.out.println("Versión JavaFX: " + System.getProperty("javafx.version"));