Query in QtSQL

Ho appena perso un paio di giorni cercando di effettuare una semplice query su un database utilizzando le ottime librerie Qt, nello specifico il modulo QtSQL. Il codice in questione è il seguente:


QSqlQuery query;
query.prepare("SELECT id FROM ':tableName' WHERE name=':recordName'");
query.bindValue(":tableName", tableName);
query.bindValue(":recordName", recordName);
query.exec();

Simpaticamente la query ritornava sempre lo stesso errore:

query error:  Parameter count mismatch 

In sintesi, NON è possibile effettuare il bindValue del nome della table su cui vogliamo effettuare la query.

A questo punto le soluzioni sono due, possiamo arrenderci e scolpire il nome della table nella stringa:

query.prepare("SELECT id FROM nations WHERE name=':recordName'");

oppure raggirare il prepare inserendo il nome della tabella come QString ed effettuare il bind solo del parametro che ci interessa:

query.prepare("SELECT id FROM '"+tableName+"' WHERE name=':recordName'");

Read more...

Sviluppare per Android

Ho iniziato a sviluppare per android da diverso tempo, prima mi sono avvicinato ad AndEngine ma poi per caratteristiche e performance ho deciso di spostarmi su libGDX il vantaggi principali sono la possibilità di realizzare l'applicazione in versione desktop nativa e poi con pochissime modifiche portare il progetto direttamente sul cellulare, cosa che riduce notevolmente i tempi morti dello sviluppo nell'attesa che l'app venga installata sul cellulare ad ogni avvio. Poi c'è il miglior wrapper per box2d (libreria per la simulazione della fisica in 2d) realizzata su android, al punto che quasi tutti gli altri engine utilizzato il wrapper di libGDX! Ottima documentazione, esempi e community, che dire, correte a provarla!

Read more...

Netbeans in KDE

Installando Netbeans in KDE, noterete che il look-and-feel dell'applicazione risulta essere quella di default per le applicazioni Java sotto linux, ovvero Metal, a mio giudizio un pò bruttino.
Per migliorare la situazione possiamo invocare il look-and-feel delle GTK in questo modo:

• Individuiamo la directory in cui è stato installato netbeans
• Apriamo il file netbeans.conf posto nella sotto-directory "/etc" della dir di cui sopra
• Aggiungiamo la stringa "--laf GTK" alla fine della variabile “netbeans_default_options” salviamo il file e riapriamo Netbeans

al posto di GTK potremo provare anche Metal e Nimbus

Read more...

Input multipiattaforma con OIS - 3a parte

Nella precedente parte abbiamo trattato la crezione dei dispositivi necessari per la lettura degli input, compresa la tastiera, ora vedremo come leggere lo stato di quest'ultima.

Nell'update dell'applicazione dovremo eseguire questo comando:

oisKeyboard->capture();

fatto ciò potremo controllare lo stato di ogni singolo tasto con:

oisKeyboard->isKeyDown(OIS::KC_F1)   // ritorna true se F1 è premuto

ovviamente potremo anche sfruttare un listener per ottenere l'input bufferizzato della tastiera, per fare ciò ci basterà derivare la classe OIS::KeyListener così:

class MyKeyListener : public OIS::KeyListener
    {
    public:
    bool keyPressed(const KeyEvent &arg)
        {
        printf("premuto tasto %i\n", arg.key);
        }
    bool keyReleased(const KeyEvent &arg)
        {
        printf("rilasciato tasto %i\n", arg.key);
        }
    };

dopo potremo impostare il nostro listener con il seguente comando:

oisKeyboard->setEventCallback(new MyKeyListener);

Read more...

Input multipiattaforma con OIS - 2a parte

Nella seconda parte di questo tutorial vedremo come creare i dispositivi necessari alla lettura dei vari input e come appunto ottenere queste informazioni. L'ultimo passaggio della parte precedente è stata la creazione dell'istanza dell'InputManager, ora con quest'ultimo potremo procedere alla crezione dei devices:

OIS::Keyboard *oisKeyboard = static_cast(oisInputManager->createInputObject(OIS::OISKeyboard, false));
OIS::Mouse *oisMouse = static_cast(oisInputManager->createInputObject(OIS::OISMouse, false));
OIS::JoyStick *oisJoystick = NULL;
try
{
    oisJoystick = static_cast  (oisInputManager->createInputObject(OIS::OISJoyStick, false));
}
catch(...)
{
    oisJoystick = NULL;
}

La creazione del device del joystick è stata inserita in un blocco try&catch perchè altimenti la libreria solleverebbe un eccezione nel caso in cui non vi fosse collegato un joystick alla macchina. In realtà noi diamo per scontato che tastiera e mouse lo siano... altrimenti sarebbe necessario inserire anche le due precedenti righe in altrettanti blocchi try&catch.

Il passo successivo è definire l'area di clipping iniziale delle coordinate del mouse, larghezza e altezza di solito saranno quelle relative alla finestra della nostra applicazione. Quest'operazione dovrà essere ripetuta anche in caso di resize della finestra.

if(oisMouse != NULL)
{
    const OIS::MouseState &ms = oisMouse->getMouseState();
    ms.width = width;
    ms.height = height;
}

Ora che abbiamo completato l'inizializzazione di OIS, vediamo come leggere i devices nel ciclo di update dell'applicazione, iniziamo dal mouse:

const OIS::MouseState &ms = this->oisMouse->getMouseState();

Nella variabile ms potremo leggere le coordinate del mouse assolute e relative rispettivamente con ms.X.abs e ms.X.rel, questo vale anche per Y e Z. Per leggere lo stato dei pulsanti invece useremo ms.buttons con un and con la costante del tasto che ci interessa verificare (es. ms.buttons & OIS::MB_Right), ecco una tabella riassuntiva:

OIS::MB_Left      // tasti sinistro, centrale e destro

OIS::MB_Middle

OIS::MB_Right

OIS::MB_Button3   // eventuali bottoni aggiuntivi da 3 a 7

[...]

OIS::MB_Button7

To be continued...

Read more...

Input multipiattaforma con OIS - 1a parte

Oggi parliamo di OIS una libreria per l'input multipiattaforma (più precisamente Linux, Window e MacOS anche se quest'ultimo solo parzialmente supportato), gestisce svariate periferiche (tastiera, mouse, joystick, wiimote, etc.) e dispositivi dotati di forcefeedback, è scritta in c++ ed è orientata ad oggetti.

Nota: negli esempi tratto la compilazione e/o utilizzo per Linux, ma non ci sono sostanziali differenze dall'utilizzo su Windows, in ogni caso nel pacchetto dei sorgenti di OIS è presente il file "readme.txt" con tutte le informazioni necessarie.

L'utilizzo neanche a dirlo è semplicissimo, iniziamo con lo scaricare i sorgenti da qui:

http://sourceforge.net/projects/wgois/files/

una volta scompattato l'archivio in una directory a scelta, eseguiremo la compilazione con:

./bootstrap
./configure
./make && make install

ovviamente, per eseguire il make install dovremo avere il privilegi di root.

Per utilizzare OIS nel nostro programma dovremo includere il suo header:

#include "OIS/OIS.h"

Creare una lista di parametri con le nostre preferenze da utilizzare per la creazione dell'inputManahger, e cosa molto importante dovremo passare ad OIS l'id di una finestra già aperta su cui agganciare l'input (nel caso di Window un HWND):

char windowIdStr[40];
sprintf(windowIdStr, "%u", windowId);

OIS::ParamList pl;
pl.insert(std::make_pair(std::string("WINDOW"), std::string(windowIdStr)));

#if defined OIS_WIN32_PLATFORM    
pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND" )));
pl.insert(std::make_pair(std::string("w32_mouse"), std::string( hideMouse ? "DISCL_EXCLUSIVE" : "DISCL_NONEXCLUSIVE" )));
pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
#elif defined OIS_LINUX_PLATFORM
pl.insert(std::make_pair(std::string("x11_mouse_grab"), std::string( grabInput ? "true" : "false" )));
pl.insert(std::make_pair(std::string("x11_mouse_hide"), std::string( hideMouse ? "true" : "false" )));
pl.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string( grabInput ? "true" : "false" )));
pl.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
#endif
 

OIS::InputManager* oisInputManager = OIS::InputManager::createInputSystem( pl );

In sostanza i vari paramentri sono sia per la versione Win32 che per linux e servono per specificare se effettuare il grab della tastiera e del mouse e se nascondere il puntatore del mouse.


To be continued...

Read more...

OpenGL context sharing

Ovvero, come condividere un context OpenGL tra diverse finestre o addirittura tra applicazioni differenti.
Se state utilizzando Windows, dovrete utilizzare la funzione wglShareLists(). Altrimenti se come nel mio caso utilizzate GLX, ci servirà il parametro share della funzione glXCreateContext().

GLXContext ctx1 = glXCreateContext(display, vi, 0, true);
GLXContext ctx2 = glXCreateContext(display, vi, ctx1, true);

Nel momento in cui creeremo il secondo context, entrambi avranno visibilità sulle risorse già create fino a quel momento e su quelle che verranno create in seguito.
Condividere il context ci permetterà non solo di poter utilizzare le stesse risorse (textures, shaders, etc.), ma anche come nel mio caso di poter effettuare il renderToTexture da un applicazione e renderizzare poi quella texture da un'altra applicazione.

Vi rimando comunque alla documentazione ufficiale.

Read more...

Profiling in linux

In questi giorni ho avuto la necessità di realizzare il profiling di un'applicazione che sto realizzando, e ho utilizzato l'accoppiata Valgrind + KCachegrind.
Il primo è uno strumento potentissimo, che effettua il debug di problemi di memoria, ricerca dei memory leak ed il profiling del software. KCachegrind è una gui per la visualizzazione grafica dei dati del profiling prodotti da Valgrind.

Per generare i dati di profiling basta eseguire da shell:

valgrind --tool=callgrind nome_applicazione

il risultato sarà un file tipo: callgrind.out.un_numero, ora lanciando KCachegrind potremo visualizzare i dati raccolti e analizzare così la velocità delle nostre funzioni.

Read more...