Qt tips (in English)

Qt Tips (memo)

What is Qt?
Compiling with tmk
Flushing a image tip.
Qt4's moc bug patch.
I do not know well, but something about Qt4.
Layout tips. setMinimumSize() does not change the layout->minimulSize()
Reading source code tips.

What is Qt?

Qt is a trolltech's software products. It is the multi-platform, C++ Graphical User Interfaces toolkit. Supported platforms are:

MS Windows 95/98/Me, NT4, 2000 and XP
Linux, Solaris, HP-UX, IRIX, AIX, FreeBSD, and many other Unix variants.
Apple Mac OS X.
(Embedded Qt for some PDA machines. ex. Sharp Zaurus)

Compiling with tmk.

tmk is a make program with programming ability by Tcl language. There is qt compiling module which is aware of qt moc compiler and qt environment.

Single thread : use qt module. Add the next line in your TMakefile:
- Qt3
  module { qt }
- Qt4
  module { qt4 qt4qtcore }
  And other Qt4 modules.
(Obsolete in Qt4) Multithread enable : use qt::mt module instead of qt module. Add the next line in your TMakefile:
- module { qt::mt }
If using qt module for your multithreading code, you can not compile your code due to some types are not defined. ex. QWaitCondition

Flushing a image tip.

When you calculate a heavy stuff, and you want to visualize it on a 2D image, this tip may help you.

Basic idea
- Make separate two threads for the computation and the Qt main loop.
- Using the immediately update widget method, repaint().
  (Notice: If you call many repaint()s in a very short time, you do not need repaint(). In that case, the method update() will work better. In X environment, too many repaint() in short time makes an async server error.)
- Flush the buffered drawing operations of QPaint.
Multi-threading
There are some documents for multi-threading in Qt in the Qt Reference documentation. Please start with ``Thread Support in Qt'' in the document and see also the QThread class documentation.
Updating Widget
QWidget::repaint() immidiately schadule the QWidget::paintEvent(). You should use this when you need immidiately update your widget.

QWidget::update() will be update a widget but not immediately for performance optimization.

Both above methods will try to update your widget, but not the image buffer (QPainter). Then next tips is needed.
Updating QPainter
QPainter::flush() will flushes any buffered drawing operations.
Misc
- There are also some flush functions like QApplication::flushX(), QApplication::syncX().
- Qpainter::drawPoint uses XDrawPoint for its implementation. Other some methods also use X functions in the same way. Then if you call these functions too much and successive, you will get ``Xlib: unexpected async reply''.
  In such a case, you should call XFlush(dpy) with some adequate interval, or use QImage class. This problem can not be avoided using QPainter, since QPainter with QPixmap calls some X async requests. However, you can use QImage (at least Qt 3.0 implementation of QImage). Since QImage is independent from devices these async will not be called. Then you can get QPixmap from QImage with convertFromImage. The disadvantage of this is low performance. But if you make too many requests, I think once you made a QImage (with many requests) and convert to QPixmap is not a bad idea. At least in my case, it works well without too performance degradation.
  Too much and successive means somehow in between 60,000 to 70,000 times for 1.7G Pentium Linux machine. This depends on your environment.

Qt4's moc bug patch. 2006-12-16(Sat)

Trolltech has answered this isuue to me and was fixed 2006-12-18's snapshot. So, if you can upgrade it, it should be no problem. (I currently has not time to check that.)

The new Qt4's moc uses static_cast, reinterpret_cast, and const_cast instead of C style cast by Qt3's moc. I think this is an improvement. However, the code src/tools/moc/generater.cpp did not consider the C++ Digraph, which is (I believe) a pitfall to mock the C++ users. Therefore, the moc is mocked by this ISO/IEC 9899-1999, Programming Languages - C standard.

Tested environment

Qt version: Qt 4.2.2
OS: SuSE Linux 10.1
Compiler: Both gcc 4.1.0 and gcc 3.4.6.

Descriptions

A sample code from which moc generates wrong code.

#include <QObject>
namespace AAA {
  /** \class BaseA 
      This is almost nothing, but in the namesapace AAA.
   */ 
  class BaseA {
  public:
    BaseA(){}
    virtual ~BaseA(){}
  };
} // namesapace AAA

namespace BBB {
/** \class DerivedB 
    Qt4's moc automatically generates a function called
    qt_metacast(). In this function, there is a static_cast, (The
    former mocs generates a C type cast. I see this change is an
    improvement.) However, global namespece identifier gives a
    digraph, then, '<:' is translated to '[' because of C++ standard
    rule.
*/
class DerivedB : public QObject, public ::AAA::BaseA {
  Q_OBJECT
public:
  DerivedB() : QObject(0), BaseA() {}
  virtual ~DerivedB() {}
public slots:
signals:
private:
};
} //namespace BBB

C99 standard has Digraph. It seems a new pitfall in introduced after Trigraph becomes a famous pitfall. This is avoided by inserting space. So, I greped the qt-x11-opensource-src-4.2.2/src/tools/moc/generator.cpp file, with cast<[^ ] line and updated.
Example and patch for qt-x11-opensource-src-4.2.2

You can apply the patch at one up of qt-x11-opensource-src-4.2.2 directory like next.

% ls
qt-x11-opensource-src-4.2.2
% patch -p0 < qt-x11-opensource-src-4.2.2_src_tools_moc_generator_20061216_hitoshi.patch

I do not know well, but something about Qt4.

Does QGridLayout need filled up cell all?
- It seems if you did not filled up some part of the grid cells, the column and row related the empty cell will not show up.
- I made a 3x3 grid layout. I filled up like next by widget A, B, C, D, E. I did not fill the cell ().
```
	  +----+----+----+
	  |    |    | C  |
	  + A  + B  +----+
	  |    |    | D  |    
	  +----+----+----+
	  | () |    E    |
	  +----+----+----+
	  
```
  Then, I have next result.
```
	  +----+----+
	  |    | C  |
	  + B  +----+
	  |    | D  |    
	  +----+----+
	  
```
  ()'s column and row did not show up. Then I added a QLabel("") at the position (), I got what I wanted.
- I encountered this with next environment.
  - Qt4.2.2, gcc 3.4.6, gcc 4.1.0, SuSE Linux 10.1
  - Qt4.2.2, gcc 3.3.5, Debian 1:3.3.5-13
  - 2006-12-10(Sun)
  I am not sure this is the reason since I do not have a minimal test code.

Layout tips. setMinimumSize() does not change the layout->minimulSize()

A layout manager uses minimumSize() (depends on which mode, but I think this is most of the case) for layout. If you made a new widget, but your widget has a layout manager, then, your widget's minimumSize() is usually ignored. This is a bit hard part, but in the documentation, ``Layout Classes'' explain that.
But the problem is that: OK, we know the widget's minimumSize does not matter, but then how you can tell the layouted widget's minimumSize()? Since there is not setMinimumSize() of Layout classes. Usually, next results are not the same (hbox is the layout of this.)
```
     cerr << "this min size = " << this->minimumSize().width() << ", " 
           << this->minimumSize().height() << endl;
     cerr << "hbox min size = " << hbox->minimumSize().width() << ", " 
          << hbox->minimumSize().height()  << endl;
     
```
I think this did not explained well, but see the source code, BoxLayout's minimumSize() collecting the children's size. So, you should set the minimumSize() to the children in case of you use some layout manager. Not via the this->setMinimumSize().
Other things you should care is each level of layout manager is independent. So, one level is wrong, you could see something wrong. I recommend to decide one policy of layout management (e.g., QLayout::SetMinimumSize) for at least each dialog, then apply that all. And give all the widget minimulSize() (e.g., widget->setMinimulSize(widget->sizeHint()) to avoid (0,0) minimulSize.

Reading source code tips.

Even though the quality of Qt's document is high, sometimes I need to read Qt's source code. I found some part of the code is hard to read. For example, you can check the following:
- The most important member variable of a class is usually `d'. A member variable is almost a global variable in the class. Especially a large complex class, it is hard to search single character global variable `d'? I hardly believe that the trolltech internal code has such member variable `d'.
- A member local variable also has a short name. It is OK for a loop counter, but some variable are just a or b, and they are sometimes live more then two blocks. (For example, see qlayout.cpp::minimumSize() Qt4.2.2's `a' is so important. Why this is not childWidgets/(chw is still better), items or something like that? This is just one example and easy to find more.
I think these are on purpose. Since I found most of the code is nice. But some part like above is unnaturally hard to read. I see there are large influence from Java, such part I can easily read. But if so, why this hard-to-read part exists? ... Maybe this does not matter since most of the hard part is inside of the implementation, in this case private members only anyway. But it matters sometimes you have only chance to understand the system with source code. That's the nice thing of source code available. So, I would like to put some tips here for the developers of Qt who need to go deep in the Qt.
You can easy to find the single character member `d' or `q' in the source code. This is usually the following macro, defined at src/corelib/global/qglobal.h.
- #define Q_D(Class) Class##Private * const d = d_func()
- #define Q_Q(Class) Class * const q = q_func()
This is the instance of the private implementation of the class. So if you see the code like this:
```
     Q_D(const QBoxLayout);
     d->minSize = d->minSize + QSize(2 * m, 2 * m);
     
```
This means there is a QBoxLayoutPrivate class, which you can get by d_func(). Same as Q_Q, but const. This is actually an easy case. But there is no guarantee the a `d' is this `d'. So first you should make it sure.
Only the bottom base class's virtual function has keyword virtual. This makes hard to read, but there is a documentation and it tells you. In C++, a method is once virtual, then always virtual. (Rachel Green told Ross, her mother said, once cheater, always cheater.)