Haiku C++ Tutorial - Helloworld grafico in c++

System: Haiku

Le classi principali di Haiku (e BeOS) per la creazione di un'applicazione grafica sono:

BApplication, si tratta della classe che incorpora effettivamente l'applicazione stessa, il suo compito è quello di creare una finestra, possono essere eseguite numerose operazioni su di essa e infine ma non meno importante, tramite questa classe si definisce il MIME type dell'applicazione.

BWindow, come ci suggerisce il nome non fa altro che creare la finestra su cui poi noi potremo attaccare le varie BView successivamente create.

BView, è un pò come un poster, possiamo attaccarci sopra qualunque oggetto definito dall'API (BTextControl, BButton..), nascondere, mostrare e poi staccare il "poster" dal muro (la finestra).

BRect, è sostanzialmente un modo per orientarsi nello schermo, ormai non si usa più grazie ai layout ma è comunque bene conoscerlo visto che è necessario per impostare le dimensioni base di una finestra, anche usando i layout.

In questi anni alle originali BeAPI (di BeOS) sono state affiancate nuove classi, come i cosiddetti layout, perchè nascono? a cosa servono?

Nascono essenzialmente per facilitare la vita al programmatore, per rendere il codice più snello ed elegante, per fornire strumenti ormai propri delle GUI più avanzate, permettendo di ridimensionare e impostare delle regole di visualizzazione, sensibilità dei font e tanto altro.

La classe che ci interessa in questa sede è BGroupLayout, utilizzando questa classe le BView contenute vengono raggruppate a seconda di quello che scegliamo tramite il costruttore in orizzontale o in verticale.
La classe quando è usata in combinazione (vari BGroupLayout orizzontali contenuti in un BGroupLayout verticali per esempio) può essere la più flessibile delle classi che compongono l'api dei layout.

Rimando a questa pagina per trovare altra documentazione (in inglese), ricordate comunque che il BeBook e l' HaikuBook sono sempre l'handbook indispensabile per un programmatore BeOS/Haiku che si rispetti.

In particolare è importante segnalare la pagina dell'interface kit di Haiku, è disponibile una pagina analoga (più dettagliata ma meno aggiornata) nel BeBook.

Come potrete vedere anche nei sorgenti, l'API di Haiku è estremamente semplice ed elegante, per approfondire i layout è disponibile anche un articolo sul sito ufficiale di Haiku.

Helloworld grafico in c++

//
// Hello World
//
// Copyright 1998, Be Incorporated
//
// Written by: Eric Shepherd
//
// Modified by Barrett

#include // per la classe BApplication
#include // header per BGroupLayout
#include // header per la classe BWindow
#include // per la classe BView

//
// la classe HelloView
//
// Questa classe definisce la view dove il messaggio "Hello World"
// verrà stampato
//

class HelloView : public BView
{
    public:
        HelloView();
    virtual void Draw(BRect updateRect);
};

//
// HelloView::HelloView
//
// Costruttore della View dove noi disegneremo ciò che ci occorre.
// Come puoi vedere non fa molti compiti.
//

HelloView::HelloView()
    : BView("HelloView", B_WILL_DRAW, 0)
{

// qui puoi infatti ad esempio mettere un BTextControl
// o qualunque altro oggetto disponibile nell'API
}

//
// HelloView::Draw
//
// Questa funzione è chiamata ovunque la nostra View
// ha bisogno di essere ridisegnata. Questo soltanto perchè
// abbiamo specificato B_WILL_DRAW nei flags quando
// abbiamo creato la view (guarda il costruttore).
//
// l'attributo updateRect è il rettangolo che ha bisogno
// di essere ridisegnato. Noi ignoreremo in realtà questo metodo
// ma puoi usarlo per velocizzare i refresh
// in un programma più complicato.
//

void HelloView::Draw(BRect updateRect)
{
    MovePenTo(BPoint(20,75)); // Move pen
    DrawString("Hello, world!");
}

//
// classe HelloWindow
//
// Questa classe definisce la finestra.
//

class HelloWindow : public BWindow
{
    public:
            HelloWindow(BRect frame);
        virtual bool QuitRequested();
    private:
        HelloView* fHelloView;
};

//
// HelloWindow::HelloWindow
//
// Costruttore dove noi attaccheremo la BView precedentemente
// creata.
//

HelloWindow::HelloWindow(BRect frame)

        : BWindow(frame, "Hello World", B_TITLED_WINDOW, B_NOT_RESIZABLE
        | B_NOT_ZOOMABLE | B_AUTO_UPDATE_SIZE_LIMITS)
{

    SetLayout(new BGroupLayout(B_HORIZONTAL)); // settiamo il layout
    fHelloView = new HelloView(); // creiamo la BView
    GetLayout()->AddView(fHelloView); // aggiungiamo la BView al layout
    Show(); // stampiamo la finestra e tutto ciò che contiene
}

//
// HelloWindow::QuitRequested
//
// Quando la finestra viene chiusa (cioè quando l'user clicka
// sul box per chiudere il programma o quando il programma viene chiuso
// dal sistema), questo metodo viene chiamato. Puoi ad esempio
// aggiungere il codice per dare l'opportunità all'utente di salvare,
// il proprio documento o qualunque altra operazione.
//
// In questo semplice programma diamo semplicemente l'ok per chiudere
// la finestra.
//

bool HelloWindow::QuitRequested()
{
    be_app->PostMessage(B_QUIT_REQUESTED); // questo metodo serve per mandare messaggi
    return true;
}

//
// classe HelloApp
//
// Questa classe derivata da BApplication, definisce
// l'applicazione stessa.
//
class HelloApp : public BApplication
{
    public:
        HelloApp();
    private:
        HelloWindow *fWindow;
};

//
// HelloApp::HelloApp
//
// Il costruttore per la classe HelloApp.
// Semplicemente crea la nostra finestra.
//

HelloApp::HelloApp()
    : BApplication("application/x-vnd.Be-HelloWorld")
{
    BRect windowRect; // creiamo un BRect
    windowRect.Set(50,50,200,200); // definiamo la grandezza della finestra
    fWindow = new HelloWindow(windowRect); // creiamo la finestra
}

//
// main
//
// Il lavoro della funzione main() in Haiku è quello di creare
// un oggetto BApplication,
// lo avvia, e lo cancella quando il programma termina.
//

int main(void)
{
    HelloApp *theApp; // Puntatore al nostro BApplication
    theApp = new(HelloApp); // creiamo l'applicazione
    theApp->Run(); // la facciamo partire
    delete theApp; // al termine puliamo tutto
}


Download del codice Sorgente di Esempio

E' possibile scaricare il file di esempio a questo link, l'archivio contiene il sorgente, il file binario compilato e il progetto Paladin.

Per chi non volesse utiizzare Paladin è possibile comunque compilarlo con il comando:

g++ helloworldhaiku.cpp -o helloworld -lbe


Adesso non resta che scaricare il sorgente, e buon divertimento!


Tutorial by Dario Casalinuovo (Barrett) - Submitted 2013
Made available by BeSly, the Haiku, BeOS and Zeta knowledge base.