DaoQt: A Binding to Qt Application and GUI Framework

Hello world Revised Signal/Slot model QString QList and QVector QTextStream and QFile

The official documentation of Qt4.5 can be found here: Qt Reference Documentation .

With DaoQt module, it is possible to access most of the functionalities of the excellent Qt application and GUI framework. Most of the Qt classes and functions are wrapped as they are, with the same class inheritance relationships and similar function prototypes. However due to the limit of the autobind tool used to generate the bindings, there are several issues one needs to know. These issues will be explained bellow. (This module is released under LGPL!)

1 Hello world

Top

2 Revised Signal/Slot model

Top

Signal/Slot Issues

Using DaoQt, the signals and slots can be connected freely between native Qt objects and objects of derived classes in Dao.

1. Native Qt object => native Qt object:
   QObject::connect(  sender,  'signal name',  receiver,  'slot name'  );
   For example,
   win  =  QMainWindow();
   bar  =  win.addToolBar(  'ToolBar'  );
   action  =  bar.addAction(  'Close'  );
   QObject::connect(  action,  'triggered()',  win,  'close()'  );
2. Native Qt object => Dao object:
   QObject::connect(  sender,  'signal name',  receiver,  slot_function  );
   For example,
   class  MyWindow  :  QMainWindow
   {
        routine  MyClose(  a  =  1  ){  self.close();  }
   }
   win  =  MyWindow();
   bar  =  win.addToolBar(  'ToolBar'  );
   action  =  bar.addAction(  'Close'  );
   QObject::connect(  action,  'triggered(bool)',  win,  win.MyClose  );
3. Dao object => native Qt object:
   QObject::connect(  sender,  signal_function,  receiver,  'slot name'  );
   In this case, the signal can actually be anything except string.
4. Dao object => Dao object:
   QObject::connect(  sender,  signal_function,  receiver,  slot_function  );
   class  MyObject  :  QObject
   {
        routine  MySlot(  message  ){
             stdio.println(  'hello:',  message  );
        }
   }
   
   o  =  MyObject();
   
   o.connect(  o,  1,  o,  o.MySlot  );
   o.emit(  1,  'DaoQt4.5'  );
   
   o.connect(  o,  o.MySlot,  o,  o.MySlot  );
   o.emit(  o.MySlot,  'DaoQt4.5'  );

2.1 Signal/Slot Issues

Top

1. In the QObject::connect() function, a string signal/slot always identify a native Qt signal/slot. In other cases, any other objects/data can be used as signal, and only Dao functions can be used as slots;
2. When connecting native signals or slots with user signals or slots defined in Dao, the native signal and slot names must be complete. Namely, parameter types of the parameter with default values should also be included. For example,
   connect(button,  'clicked()',  daowidget,  daowidget.showMessage  );
   is not valid, because the "clicked" signal of QPushButton has a default parameter. The correct way is,
   connect(button,  'clicked(bool)',  daowidget,  daowidget.showMessage  ).
3. When connecting a native signal to a Dao slot, the Dao slot must be a function with parameter types matching to that of the signal. If not matched, the slot will not be invoked.

3 QString

Top

In most cases, if QString is used as parameter or returned value in a function, it is automatically converted to Dao string type when wrapping this function. But if it is used as a pointer, it will not be convered automatically. So for a Qt function with the following prototype: It will be wrapped as,
To use the functionalities of QString, a QString object must be constructed explicitly by calling its constructor, e.g.
For the methods of the QString class, if the returned value is QString, it is not converted automatically. For example, will be wrapped as, So it will still allow user to write codes like
To convert from QString to Dao string, one can use toLocal8Bit()

Similarly, in DaoQt, QChar is converted to int, and QByteArray is converted to Dao string.

4 QList and QVector

Top

Most of the QList<X>, QList<X*>, QVector<X>, and QVector<X*> are converted to list<X>, when they are used as parameters or returned values.

5 QTextStream and QFile

Top

The operators of QTextStream are not wrapped, but several methods are added for writing data to the stream.
The QFile.close() must be called when it is done.