Com\’è dura la professione!

25 luglio 2011

QXmlEdit 0.5.0: YAXV (Yet Another XSD Viewer)

Filed under: Open Source,QT,qxmledit,xml — lbell @ 20:24

If it is true that a complex idea can be examined under different prospectives, then a XML Schema viewer can be useful. XML Schema concepts can be modeled with a plain text editor, but QXmlEdit in the 0.5 version can help with a new graphical plugin.

What’s really difficult in such a program is to establish a mapping between the images that the program provides and the concepts that the user has in mind when interacting with them. This mapping is even more difficult if the viewer will be transformed in an editor in some future.

The program needs a cut, it is important to determine which are the main concepts to show and what needs to be removed from the scene. If all the objects defined by the language have the same importance, the scene will be filled with a lot of informations, hiding the basic concepts that the user is trying to model, making the visual editor almost useless compared to a text-based editor.

To achieve this goal, some information, especially those relating to the elements and the types must be automatically and silently changed as the user decides to change the relationship graphically.

A small change in terms of visual representation, such as adding an attribute to an element, has great implications in terms of XSD syntax. When the user decides that an element can have an attribute, the semantic change is very small, but for the scheme it may involve the transformation of a simple type in a complex one.

To access the XSD Viewer in QXmlEdit, load a XSD Schema file in the editor, then use the Tools > Plugins > XSD Viewer menu.

11 aprile 2011

Delegate a delegate in a Qt View

Filed under: QT — lbell @ 20:59

The data presentation in a Qt Item View like a TreeView or a TableView is made by means of components that implement a QAbstractItemDelegate interface.

Write a custom delegate to gain full control on how the data are rendered forces us to face all the subtle details and intricacy of the measuring and styling of graphics items with the risk of producing a component that does not fit well with the style used in the host system. Moreover, speaking in a C++ term, we don’t know what is the base class that a particular view is using, so we can’t subclassing it to alter its behavior.

If our needs are limited, for example, to display a decoration over a read only standard item, a simple solution can be to use the existing view delegate to do the hard work, then render the decoration over the painted surface.

We can create a delegate deriving from QAbstractItemDelegate class, inquire the view that we want to manipulate about its actual delegate and store it as an internal variable of the new delegate. Our class can act as a bridge, implementing all the interface functions and the slots of a delegate and redirect incoming calls to the old delegate.

Our class will look like this (some code omitted for clarity)

class ElementItemDelegate : public QAbstractItemDelegate
    QAbstractItemDelegate *baseDelegate;
    explicit ElementItemDelegate(QAbstractItemDelegate *newBaseDelegate, QObject *parent = 0);
    virtual ~ElementItemDelegate();
    virtual QWidget * createEditor () const;
    virtual bool editorEvent ( );
    virtual void paint ( ... ) const;

At the window creation we can retrieve the actual delegate from e. g. a tree widget and pass it to our delegate:

void MainWindow::setUpDelegates()
    QAbstractItemDelegate *oldDelegate = treeWidget->itemDelegate();
    ElementItemDelegate *newDelegate = new ElementItemDelegate( oldDelegate, this );
    treeWidget->setItemDelegateForColumn(0, newDelegate);

Each incoming call to our delegate is then redirected to the existing delegate.
The only method we are interested about is the paint() one. We let the old delegate do the hard work, then we paint:

void ElementItemDelegate::paint ( QPainter *painter, const QStyleOptionViewItem & option, 
   const QModelIndex & index ) const
    QStyleOptionViewItemV4 option4(option);
    // call the default delegate
    baseDelegate->paint(painter, option, index );
    Element * element = Element::fromModelIndex(index);
    if( NULL != element ) {
        QRect markRect = option.rect;
        if( option4.viewItemPosition == QStyleOptionViewItemV4::Beginning ) {
        if( element->saved() ) {
            painter->fillRect(markRect, savedBrush);
        } else if ( element->edited() ) {
            painter->fillRect(markRect, editedBrush);
        } else {
            painter->fillRect(markRect, normalBrush);

13 marzo 2011

In difesa della scuola pubblica italiana

Filed under: Uncategorized — lbell @ 22:00

Un politico influente, attualmente in crisi, ha cercato di ingraziarsi i propri sostenitori attaccando la scuola pubblica italiana.

Non si può tacere di fronte ad una cosa del genere; la convinzione che la scuola pubblica appartenga ad una parte politica e come tale vada combattuta, è preoccupante.

Per fortuna sabato si è tenuta una manifestazione in favore della scuola pubblica in diverse città italiane

Alla manifestazione cui ho assistito ho visto solo presone che sembravano appartenere alla categoria dei docenti e mi sono chiesto dove fossero gli altri e perché la cosa non interessasse tutti.

La vista dei professori che indossavano sulle spalle la bandiera italiana mi ha fatto ricordare di quando da piccolo vedevo i lavoratori vestire nello stesso modo la bandiera rossa, ed ho realizzato quanto abbiamo perso in questi anni se la bandiera nazionale è diventata solo uno stendardo di parte.

Ma solo ai docenti deve interessare questo argomento?

Fra i primi danneggiati da una scuola elitaria ci sono gli imprenditori che vedranno ridotto, ad esempio, il numero di ingegneri bravi e motivati tra cui reclutare i nuovi assunti dato che si restringerà la base di chi può permettersi di frequentare l’università. Saranno costretti a reclutare gli ingegneri all’estero, in Paesi (Cina, …) in cui comunque la formazione è delegata alla scuola pubblica.

L’idea della scuola pubblica sopravvisse perfino alla restaurazione sopraggiunta alla fine del periodo napoleonico, perché ci si accorse che è un valore.

La scuola pubblica è una conquista e non un danno per il Paese.

22 dicembre 2010

Explore a XML file structure with QXmlEdit

Filed under: Open Source,QT,qxmledit,xml — lbell @ 22:08
Tags: , ,

One of QXmlEdit peculiar characteristics is the possibility to change the quantity and the type of informations shown on a XML file to examine it from various prospectives.

If the XML file is very large and complex it happens to focus on some details missing the big picture. Let us take for example a Qt user interface file, we can face the following situation:


it is very difficult, at least for me, to follow the widgets’s structure or differentiate between them. As a first help we can activate a display style that can list in the space reserved to element tag name, the value of one or more attributes that can characterize the element itself. The predefined style provided with QXmlEdit installer displays near to the element tag, the value of ‘name’, ‘id’ or ‘build’ attributes, if any. The styles can be created and installed by the end users; they can be applied using the ‘paint can’ icon button at the bottom right of the data tree.

The style makes the visualization more intuitive and the data structure stand out very quickly.


To solve the problem of seeing the element text together with his tag, we can activate the compact view visualization as shown in the following screenshot. The text, if present and if no attributes exist, appears in the column reserved to the attributes with a different color.


We can have an overview of the XML file while maintaining the desired level of detail.

24 settembre 2010

Generate Flex Code from Balsamiq Mockup Sources

Filed under: Flex,Open Source,QT — lbell @ 22:07

Having the need to generate an application skeleton after having created the mockup using Balsamiq (, and to poke into its file format, as explained in the page, I wrote a plugin for my Open Source project QXmlEdit.

It is very easy to use, but you should remember that it is a very simple tool and not a full fledged IDE.

The plugin can be activated via ‘Tools’ menu, as in the following screenshot:

The plugin window is divided in two: the upper part is dedicated to the Balsamiq sources to translate, the bottom one contains the destination directory where a MXML Application file is generated for each selected source file.

The translation is done by transforming the source using templates that can refer original attributes or calculated fields.

Data bound controls are supported by generating data sources as mx:Array containing mx:Object in a global section.

Not all Balsamiq controls are supported, only a subset of most commonly used ones, controls not supported are converted to mx:Label

List of supported controls:

  • Button

  • Label

  • LinkBar

  • DataGrid

  • List

  • TabBar

  • VRule

  • HRule

  • TextInput

  • ComboBox

  • TextArea

  • Paragraph

  • CheckBox

  • RadioButton

  • Tree

16 novembre 2009

Sfruttare il system tray per controllare i job di KDE

Filed under: kde4,Open Source,Programmazione — lbell @ 22:07

Una delle funzionalità offerte da KDE4 a sviluppatori ed utenti è quella di gestire i lavori a lungo termine delle applicazioni mediante un componente del vassoio di sistema. L’infrastruttura mette a disposizione dell’utente un unica locazione dalla quale può controllare l’andamento delle operazioni, opzionalmente sospenderle, sbloccarle o controllarne l’esito anche dopo il loro termine. Si evita così che ogni applicazione che intende avvalersi di questa funzionalità debba implementare una interfaccia di controllo. Dal punto di vista del programmatore, la fatica di imparare una nuova serie di API è ripagato dal fatto che è l’ambiente a prendersi in carico il compito di interagire con l’utilizzatore, sia per quello che riguarda l’aspetto funzionale, sia per l’interfaccia utente. Ovviamente i soli lavori di cui dovrà essere notificato lo stato di avanzamento mediante questa caratteristica sono solo quelli a lungo termine, per evitare di confondere l’utente con una miriade di messaggi irrilevanti.

Vediamo ora come si può sfruttare questa funzionalità:

Le applicazioni che intendono sfruttare il sistema di notifica devono incapsulare direttamente o indirettamente l’attività in una struttura KIO::Job, ad esempio derivando da essa la nostra classe di esempio KJobTest.

	#include <kjob.h>
	class KJobTest : public KIO::Job

Se si desidera che l’utente, una volta comparsa la notifica, possa mettere i lavori in pausa, riprenderli o annullarli occorre, nella nostra classe, chiamare la funzione


cui va passato come argomento un insieme di flag che ne determinano il comportamento. Con il valori Kjob::Suspendable si concede all’utente la possibilità di sospendere un lavoro, con KJob::Killable anche di terminarlo. Per abilitare entrambe le funzionalità, scriveremo:


Quando si è pronti per presentare il job all’utente, lo si deve registrare presso una struttura globale:


Da questo punto in poi il job è visibile all’utente. Emettendo il segnale ‘infoMessage‘ si può forzare il pannello a mostrare la descrizione desiderata per indicare il proprio job.

Il job può essere attivato in modalità sincrona o asincrona. Nel primo caso tutto quello che dovrà fare l’applicazione per gestire il job sarà richiamarne il metodo ‘exec‘, definito nella classe base, che restituirà l’esito mediante un valore booleano. Dietro le quinte verrà attivato un loop di messaggi nascosto. Riporto l’esempio di utilizzo definito nella documentazione KDE:

void SomeClass::methodWithSynchronousJobCall()
   KJob *job = someoperation( some parameters );
   if ( !job->exec() )
       // An error occurred
       // Do something

Nel caso si intenda utilizzare il job in modo asincrono, metodo preferito per la gestione di operazioni a lungo termine, occorre attivare il job attraverso il metodo start(), richiamato in modo nascosto anche nel caso sincrono, e mettersi in attesa dei risultati collegando il segnale ‘result‘ ad uno slot. Ecco l’esempio relativo, sempre tratto dalla documentazione KDE:

 void SomeClass::methodWithAsynchronousJobCall()
   KJob * job = someoperation( some parameters );
   connect( job, SIGNAL(result(KJob*)), this, SLOT(handleResult(KJob*)) );
 void SomeClass::handleResult( KJob *job )
   if ( job->error() )

Nel metodo start(), da reimplementare nella nostra classe derivata da KJob, occorre utilizzare un meccanismo asincrono, come ad esempio un timer di tipo oneShot, per innescare il job, per evitare che un’attivazione direttamente nella funzione start() provochi un malfunzionamento della gestione sincrona del job attraverso la funzione exec(), per motivi derivanti dall’implementazione della funzione exec stessa. Se abbiamo deciso di non utilizzare mai l’interfaccia sincrona potrebbe sembrare una precauzione inutile, ma scrivendo codice che si deve integrare in un ambiente, occorre sempre rispettarne i dettami.

Quando l’utente decide di intervenire nella vita del job cambiandone lo stato, il pannello del vassoio di sistema richiamerà metodi doSuspend(), doResume() e doKill() del nostro job, mediante i quali si potranno realizzare le dovute azioni.

Durante il suo ciclo di vita, il job può inviare al pannello segnali riguardo il proprio stato o la percentuale di avanzamento.

Emettendo il seguente segnale:

emit infoMessage(job, messageText, messageRichText );

si può provocare la comparsa della scritta relativa allo stato puntuale del job. Allo stesso modo è possibile inviare informazioni relative alla velocità attuale ed alla unità di misura utilizzata, nel caso sia compresa tra quelle dell’enumeratore ‘Unit’ di KJob.

Come esempio di utilizzo possiamo utilizzare un semplice programma, jobsample, mediante il quale è possibile provare le tecniche esposte, configurare i parametri principali a disposizione di un job ed osservare i risultati.

I sorgenti di jobsample sono disponibili a questo indirizzo:

Finestra principale di jobsample:

job sample in esecuzione:

26 ottobre 2009

Compilare KDE 4.4 con Qt4.6 e kdesvn-build

Filed under: kde4,Open Source,QT — lbell @ 21:55

Con il passaggio del trunk di KDE a Qt4.6 avvenuto il 10 ottobre non è più possibile utilizzare il sistema di build basato su kdesvn-build 1.9.1, dato che i sorgenti delle librerie Qt sono affidati a git e kdesvn-build si interfaccia con Subversion, occorrerebbe gestire manualmente il modulo qt-copy. Occorrerebbe, perché è appena stata rilasciata la versione 1.10, che è in grado di gestire git per il solo modulo qt-copy. E’ disponibile nel sito ufficiale da un paio di giorni e nel repository svn di KDE in branches/work/kdesvn-build-1.10. Per usarlo, occorre modificare la sezione relativa al modulo qt-copy nel file .kdesvn-build.rc nel modo seguente nella sezione dedicata a git:

module qt-copy
	#opzioni di compilazione
	configure-flags -system-zlib -qt-gif -system-libjpeg -system-libpng \
			-no-exceptions -fast -debug -dbus \
	            -no-phonon # Phonon built separately
	make-options -j2

	# opzioni di gestione git
	branch 4.6-stable-patched
end module

Sito di kdesvn-build:

19 ottobre 2009

Ma cosa fa funzionare veramente il computer?

Filed under: cosi' va il mondo,Programmazione — lbell @ 21:17

L’Apple II, il primo personal computer ad avere una diffusione ed un successo mondiali, quando nel 1977 vide la luce sembrò un miracolo di tecnologia; permetteva ad un prezzo accessibile di svolgere una quantità e varietà di compiti concreti come monitorare impianti industriali o di organizzare magazzini o di controllare le scadenze delle assicurazioni. Diciamo che gli utenti si accontentavano delle prestazioni e delle possibilità offerte, cercando di vincere le limitazioni del sistema (velocità e spazio di memoria in primis) con molta pazienza e con molto ingegno, inserendo nei programmi una serie di trucchi che oggi appaiono senza senso. Il sistema aveva 48K RAM e poteva supportarne in modo lineare al massimo 64KB.

Quando uscì il primo personal IBM la ram a disposizione era di 128 o 256KB con il codice di sistema caricato in parte di essa da disco; 640KB divennero uno standard poco dopo. All’avvento del Macintosh, il primo rivoluzionario PC con un’interfaccia grafica basata su finestre ed icone, precursore di tutti i sistemi che si usano oggi, che poteva pavoneggiarsi di una grafica di tipo interamente bitmap, si arrivò a 64K di ROM e 128K di RAM, ed in questo spazio non si trovava solo il codice per gestire la grafica, ma anche quello per permettere a tutti i programmi di terze parti di potersi adeguare ad una stessa metafora di comportamento mentre faceva timidamente la sua apparizione su sistemi di tale fascia il primo codice capace di gestire una rete.

E tutta questa meraviglia in soli 64K di ROM, più il software di sistema in un dischetto da 400K. La ram a disposizione dei programmi applicativi, al netto di quella necessaria al funzionamento del Macintosh stesso era di soli 90K (

E oggi? Se consideriamo le dimensioni del kernel di Linux rispetto ai tempi dell’Apple II troviamo non solo una crescita esponenziale del software di sistema ma la nascita di una nuovo filone, quasi sconosciuto al mondo visto in precedenza; il sottosistema di rete con relativa infrastruttura di sicurezza, che tramite protocolli di tutti i tipi si avvia a rappresentare una gran parte del codice di sistema. La directory del kernel Linux occupa, con varie versioni installate, da 120 a 475MB sul mio sistema e l’installazione complessiva del sistema e dei programmi applicativi più comuni quasi 10GB.

Questa crescita è avvenuta in in pochi decenni e ricalca la legge di Moore a proposito della crescita delle capacità dell’hardware ( Il fatto è che mentre l’hardware spesso è stato progettato in scala, il software di sistema in questione è stato scritto da zero, praticamente riga dopo riga. Ogni sistema operativo sul mercato ha proposto il proprio server web, il proprio stack di protocolli di rete, con tonnellate di sorgenti spesso inutilmente riscritti solo per esigenze commerciali. I computer non sono più solo strumenti nelle mani di artigiani, ma diventa sempre più difficile sapere cosa li fa effettivamente funzionare e quanto sono sicure le basi cui cui poggia il software applicativo.

grafico ram rom

7 giugno 2009

Il pittore ed il professore

Filed under: letture — lbell @ 19:53

Le Scienze sta pubblicando una interessante collana di DVD aventi come tema gli incontri avvenuti al festival della matematica di Roma dello scorso anno. In quello di questo mese vi si trova l‘intervento di Thomas Banchoff focalizzato su Salvator Dalí. Il relatore parla avendo alle spalle uno schermo gigantesco su cui sono mostrate le opere del pittore catalano mentre sono citate. La cosa strana è che, tanto più si parla di un’opera, tanto più il regista zooma sul relatore, stringendo l’inquadratura e non mostrando mai l’argomento del discorso.

Nel numero de ‘Le Scienze’ di questo mese viene svelato il mistero: ci sono problemi di licenza sul materiale video riguardante le opere.

Al di la dell’irritazione per l’assenza dei contenuti video principali in un DVD in vendita, è un po’ surreale che si parli per un’ora di qualcosa che non si può vedere, pure se si sa che esiste.

Una situazione perfettamente in tema con il surrealismo delle opere di Salvator Dalí.

8 aprile 2009

Activities are for humans

Filed under: kde4,Programmazione — lbell @ 21:48

Computers are very versatile tools, used in a variety of situations, to work, listen music, write documents, but it is very difficult to create a comfortable user environment for each task. When working to an important document, mail notifications are very annoying, but turning off completely notifications is not the ideal solution, mails related to the activity are welcomed. What is missing is the possibility that the computer adapts his environment to different activities.

Virtual desktops are the more advanced solution to implement activities today, but this is only a start.

There is a difference between a virtual desktop and an activity: virtual desktop is a collection of resources (windows mainly), an activity is a collection of related resources. You can work for a project, read documents, contact people, receive mails and so on and all these items can stay associated to the activity you are currently operating.

We can roughly consider an activity on top of a collections of virtual desktops.

A ‘recent document’ menu can contain a lot of unrelated documents, a personal letter written in a pause together with work documents and worst, it has a finite length, so new documents of unrelated activities are pushing into oblivion very important bookmarks.

Activities are useful to categorize and filter environment items, but it is not practical to manually label each resource that can reside in an activity, so the workspace should automatically collect informations, like the mylyn plugin in Eclipse world

When in an activity you can associate not only documents related to that activity, but also contacts, sites, and so on.

We work on different projects and we use the computer for personal activity each day. Computers are universal devices and can be used for different purposes.

As a further example, it is an annoyance to receive mail notifications from people not related to projects ( with obvious exception for emergencies ) in working hours. An activity can filter what that can distract, without hiding information, but focusing out of view not relevant factors.

It is important to have a simple ‘relations’ manager to handle what resources are related to an activity and move or copy them from a workspace to another (maybe using the KDE plasmoid zoom interface).

It is important to have multiple activity configurations, you can use same laptop at work and at home, even applications menu can change in different situations.

Activities attributes and resources should be shared between teams.

There are two types of applications: specialized ones (video, audio, graphics editor for instance ) and generics ones ( word processors, time tracker, etc) that should have different behavior. How horizontal applications like file browsers should behave? Why not filter activity related directories in ‘Open File’ dialogs? Currently this dialog supports only a simple filter that maps to file type (a word processor filter documents, a spreadsheet csv and so on)

How to save data in application specific format and not using specialized Desktop Environment routines? How to integrate, for example, Open Office? We should use the metadata we are using for browsers: the tags, but there is the problem to maintain metadata in sync with data when moving files, doing backups and so on. All the files that user opens or write should be logged, but the metainformations should be stored in the document or in the filesystem?

Even phones have different modes: mute, normal, meeting etc.

Tags and activities are separate concepts, tags are traversal and additive, activities are thematic.

Desktop Environment should leads the user how to enter and how to exit from an activity. We should decrease normal desktops visual clutter that confuses the user about his state.

Another problem is how to include external resources if the filter are restrictives, maybe by adding a button in each “Open File” dialog that let us choose to stay in the current activity environment or see all the resources.

Other open problems are how to integrate in this vision externals resources like network infrastructure, network, printers, etc.

Talking about concrete cases, like the recent documents menu, why not make it central for a desktop or expand it to order it for ( I often need this ) creation date, write date, access timestamp or access frequency, category?

Why not display this menu in a cloud representation? More, the vertical list used is a very short and useless representation. A timeline can be more useful.

Different activities can be created for different purposes even using same programs.

In a desktop system I can save programs state on disk passing from an activity to another one, but not on phone system for device limits.

Anyway each journey begins with a single step, and Plasma is a good one.

« Pagina precedentePagina successiva »

Blog su