Programación para Haiku: Hola Mundo

Original :  https://hoelz.ro/blog/programming-for-haiku-hello-world

Si eres como yo, has estado siguiendo el proyecto Haiku por un tiempo y probablemente estés muy entusiasmado con el reciente lanzamiento alfa. ¿Esperar lo? ¿No has oído hablar del Haiku? Bueno, Haiku es una recreación cercana de código abierto de BeOS, que fue un sistema operativo revolucionario para su época. Como no me interesaba la informática en ese entonces, no puedo justificar describir Haiku y BeOS aquí, así que aquí hay algunos enlaces para informarle:

Preguntas frecuentes sobre Haiku Haiku en Wikipedia BeOS en Wikipedia

Primeros pasos en Haiku

Bien, ahora que sabe qué son Haiku y BeOS, puede estar interesado en contribuir al proyecto Haiku si es un desarrollador. Mucha gente ha venido al canal Haiku en Freenode últimamente (#haiku) pidiendo una aplicación de inicio simple, por lo que esta publicación le dará el código para una aplicación simple "Hello, World" que imprime "¡Hola, Haiku!" a la consola cada vez que haga clic en un botón. Aquí hay una captura de pantalla del producto terminado:

El código de aplicación completo

Pensé que comenzaría con el código completo de la aplicación, para que pueda hacerse una idea de la estructura del código antes de entrar en cada sección en detalle.

#include <Application.h>
#include <Button.h>
#include <Window.h>
#include <stdio.h>

const int32 HELLO_HAIKU = 'HELO';

class HelloWindow : public BWindow
{
    public:
    HelloWindow(BRect frame) : BWindow(frame, "Hello Window", B_TITLED_WINDOW, 0)
    {
    BView *view = new BView(Bounds(), NULL, B_FOLLOW_ALL_SIDES, B_WILL_DRAW);
    AddChild(view);
    BButton *button = new BButton(view->Bounds(), NULL, "Hello", new BMessage(HELLO_HAIKU));
    view->AddChild(button);
    }

    bool QuitRequested()
    {
    be_app_messenger.SendMessage(B_QUIT_REQUESTED);
    return BWindow::QuitRequested();
    }

    void MessageReceived(BMessage *msg)
    {
    switch(msg->what) {
        case HELLO_HAIKU:
        printf("Hello, Haiku!\n");
        break;
        default:
        BWindow::MessageReceived(msg);
    }
    }
};

class HelloHaiku : public BApplication
{
    public:
    HelloHaiku() : BApplication("application/hello-haiku")
    {
    }

    void ReadyToRun()
    {
    BWindow *win = new HelloWindow(BRect(100, 100, 300, 200));
    win->Show();
    }
};

int main(void)
{
    HelloHaiku app;

    app.Run();

    return 0;
}

Construyendo el código

Para compilar este código, por supuesto, debe ejecutar Haiku. Descarga una imagen y ejecútala con QEMU o VirtualBox (¡es realmente fácil de configurar!) o toma un LiveCD de su sitio aquí , ejecútalo, abre una Terminal y usa esto para compilar el código:

g++ -o hello-haiku hello-haiku.cpp -lbe

Si no está familiarizado con las opciones del compilador de GCC, -oespecifique el archivo de salida y -lbedígale a GCC que se vincule a la biblioteca be, que contiene todo el código objeto para este ejemplo.

Descripción general del código

Muy bien, repasemos juntos cada sección del código. Supongo que tiene al menos una familiaridad pasajera con C ++ mientras realiza esto, por lo que esta primera parte debería parecerle bastante familiar:

#include <Application.h>
#include <Button.h>
#include <Window.h>
#include <stdio.h>

Estas incluyen directivas para incluir los encabezados del kit de aplicación (que incluye la clase BApplication), las clases BButton y BWindow (que se encuentran en el kit de interfaz) y la biblioteca de E/S estándar para C. Esta charla sobre kits puede ser extraño para usted, así que déjeme aclarar: las bibliotecas de software para BeOS (y, por lo tanto, Haiku) están organizadas en kits . Cada kit tiene un propósito específico; por ejemplo, el kit de aplicación se usa para comunicarse con el servidor de aplicaciones de Haiku, mientras que el kit de interfaz se usa para crear GUI. Hay muchos más kits disponibles, pero solo los mencionaré, ya que esos son todos los que se usan en este tutorial.

const int32 HELLO_HAIKU = 'HELO';

Esta línea define una constante de comando para usar en nuestra aplicación. Las aplicaciones Haiku utilizan el paso de mensajes para comunicarse con otras aplicaciones y también para comunicarse entre diferentes componentes de una aplicación. Cada mensaje se identifica mediante una constante de comando. Hay muchas constantes de comando definidas por el sistema; por ejemplo B_QUIT_REQUESTED y B_MOUSE_DOWN. En esta aplicación, queremos que se envíe un mensaje personalizado a nuestra ventana principal cuando se haga clic en el botón "Hola", por lo que definimos nuestra propia constante de comando HELLO_HAIKU.

class HelloWindow : public BWindow

Este código define una subclase de ventana especializada. Repasaremos cada uno de los métodos anulados en detalle.

HelloWindow(BRect frame) : BWindow(frame, "Hello Window", B_TITLED_WINDOW, 0)
{
    BView *view = new BView(Bounds(), NULL, B_FOLLOW_ALL_SIDES, B_WILL_DRAW);
    AddChild(view);
    BButton *button = new BButton(view->Bounds(), NULL, "Hello", new BMessage(HELLO_HAIKU));
    view->AddChild(button);
}

Este código define un constructor para nuestra nueva clase de Ventana. Toma un BRect como argumento, que define su tamaño y posición en la pantalla. Proporciona esta y alguna otra información al constructor de BWindow; puede leer sobre los detalles de ese constructor en la documentación al final de esta publicación. A continuación, crea un BView, que puede considerar como un contenedor de widgets. Agrega la vista a su lista de elementos secundarios y agrega un botón a la lista de elementos secundarios de la vista. Los argumentos para el botón son un poco más importantes para este tutorial, así que los explicaré en detalle.

• El primer argumento especifica el tamaño y la posición del botón. view->Bounds()devuelve un rectángulo que hará que el botón ocupe toda la vista.
• El segundo argumento especifica el nombre del botón. Puedes darle al botón el nombre que quieras, o NULL si no quieres darle un nombre.
• El tercer argumento especifica el texto del botón.
• El cuarto argumento especificó el mensaje que se enviará cuando se haga clic en el botón. En este caso, el botón enviará un mensaje utilizando nuestra constante de comando personalizada.

Notarás que tiramos muchos consejos aquí y no limpiamos después de nosotros mismos. Esto se debe a que el mensaje se destruye cuando se destruye nuestro botón, y nuestro botón y vista se destruyen cuando se destruye la ventana.

bool QuitRequested() {
    be_app_messenger.SendMessage(B_QUIT_REQUESTED);
    // or be_app->PostMessage(B_QUIT_REQUESTED);
    return BWindow::QuitRequested();
}

Este método anula BWindow::QuitRequested, que se llama cuando se hace clic en el botón de cerrar (el botón en el lado izquierdo de la pestaña de título de la ventana). Este código:

be_app_messenger.SendMessage(B_QUIT_REQUESTED);

envía un mensaje B_QUIT_REQUESTED a la aplicación, solicitando que se cierre. Notarás que también presenté una alternativa:

be_app->PostMessage(B_QUIT_REQUESTED);

Este código hace algo similar al código anterior, excepto que PostMessage no espera un mensaje de respuesta. Además, notará que PostMessage usa be_app, no be_app_messenger. be_app es un puntero global a nuestro objeto de aplicación, y be_app_messenger es un objeto BMessenger global que puede enviar mensajes a be_app. Si desea obtener más información sobre BMessengers, consulte la documentación.

Luego devolvemos el resultado de la versión del método de la superclase, lo cual es verdadero. Devolver verdadero desde QuitRequested significa que está bien que se cierre esta ventana.

void MessageReceived(BMessage *msg) {
    switch(msg->what) {
        case HELLO_HAIKU:
            printf("Hello, Haiku!\n");
            break;
        default:
            BWindow::MessageReceived(msg);
    }
}

Se llama al método MessageReceived cuando se recibe un mensaje (Nota: algunos mensajes especiales, por ejemplo B_QUIT_REQUESTED, tienen sus propios ganchos (como QuitRequested) y no pasan por MessageReceived. Consulte la documentación para obtener detalles). Aquí imprimimos "¡Hola, Haiku!" cada vez que recibimos nuestro mensaje personalizado del botón, y llamamos a la versión de la superclase en otros casos.

class HelloHaiku : public BApplication
{
    public:
    HelloHaiku() : BApplication("application/hello-haiku")
    {
    }

    void ReadyToRun() {
        BWindow *win = new HelloWindow(BRect(100, 100, 300, 200));
        win->Show();
    }
};

Nuestra subclase BApplication es bastante simple, así que la repasaré en una sección. En el constructor, pasamos la firma de nuestra aplicación al constructor de la superclase. Esto permite que otras aplicaciones se comuniquen con nosotros si así lo desean. El método ReadyToRun se llama cuando el servidor de aplicaciones está preparado para ejecutar nuestra aplicación, por lo que configuramos nuestra GUI y la mostramos. Si lo desea, también puede configurar su GUI en el constructor de la clase de aplicación. Como antes, notará que no limpiamos el objeto ventana; todas las ventanas de una aplicación se destruyen automáticamente cuando se cierra la aplicación que las creó.

int main(void) {
    HelloHaiku app;

    app.Run();

    return 0;
}

Esta parte debes reconocerla; es el punto de entrada para el programa. Todo lo que hace es crear una instancia de nuestra aplicación y ejecutarla.