void testMessagePattern() {

    QString QT_MESSAGE_PATTERN=

            "[%{if-debug}D%{endif}%{if-warning}W%{endif}%{if-critical}C%{endif}%{if-fatal}F%{endif}]"

            ": %{file}:%{line} - %{message}";

    qSetMessagePattern(QT_MESSAGE_PATTERN);

    qDebug() << "Hello Pattern";

    qDebug() << QString("黄彪").toUtf8().toHex();

}

[D]: /Users/Biao/Dropbox/workspace/Qt/Test/main.cpp:26 - Hello Pattern 
[D]: /Users/Biao/Dropbox/workspace/Qt/Test/main.cpp:28 - "e9bb84e5bdaa" 

void qSetMessagePattern(const QString & pattern)
Changes the output of the default message handler.
Allows to tweak the output of qDebug(), qWarning(), qCritical() and qFatal().
Following placeholders are supported:

    

        

            
Placeholder
Description
        
    
    

        

            
%{appname}
            
QCoreApplication::applicationName()
        
        

            
%{file}
            
Path to source file
        
        

            
%{function}
            
Function
        
        

            
%{line}
            
Line in source file
        
        

            
%{message}
            
The actual message
        
        

            
%{pid}
            
QCoreApplication::applicationPid()
        
        

            
%{threadid}
            
ID of current thread
        
        

            
%{type}
            
"debug", "warning", "critical" or "fatal"
        
    

You can also use conditionals on the type of the message using %{if-debug}, %{if-warning}, %{if-critical} or %{if-fatal} followed by an %{endif}. What is inside the%{if-*} and %{endif} will only be printed if the type matches.
Example:
QT_MESSAGE_PATTERN="[%{if-debug}D%{endif}%{if-warning}W%{endif}%{if-critical}C%{endif}%{if-fatal}F%{endif}] %{file}:%{line} - %{message}"
The default pattern is "%{message}".
The pattern can also be changed at runtime by setting the QT_MESSAGE_PATTERN environment variable; if both qSetMessagePattern() is called and QT_MESSAGE_PATTERN is set, the environment variable takes precedence.
qSetMessagePattern() has no effect if a custom message handler is installed.
This function was introduced in QtCore 5.0.
See also qInstallMessageHandler() and Debugging Techniques.

Adding a Q_DECLARE_METATYPE() makes the type known to all template based functions, including QVariant.

Note that if you intend to use the type in queued signal and slot connections or in QObject's property system,

you also have to call qRegisterMetaType() since the names are resolved at runtime.

class BH {

public:

    BH() {

        value = 10;

    }

    int value;

};

Q_DECLARE_METATYPE(BH)

QVariant var = QVariant::fromValue(bh);

qDebug() << var.canConvert<BH>();

BH bh2 = var.value<BH>();

qDebug() << bh2.value;

• Channels
• Buffers
• Selectors

• 容量（Capacity） 缓冲区能够容纳的数据元素的最大数量。这一容量在缓冲区创建时被设定，并且永远不能被改变。
• 上界（Limit） 缓冲区的第一个不能被读或写的元素。或者说，缓冲区中现存元素的计数。
• 位置（Position） 下一个要被读或写的元素的索引。位置会自动由相应的get( )和put( )函数更新。
• 标记（Mark） 一个备忘位置。调用mark( )来设定mark = postion。调用reset( )设定position = mark。标记在设定前是未定义的(undefined)。

• 一旦读完Buffer中的数据，需要让Buffer准备好再次被写入。可以通过clear()或compact()方法来完成。
• 如果调用的是clear()方法，position将被设回0，limit被设置成 capacity的值。换句话说，Buffer 被清空了。但这个时候Buffer中的数据并未清除，只是这些标记告诉我们可以从哪里开始往Buffer里写数据。

Java代码  

1. public static void main(String[] argv) throws Exception {  
2.         CharBuffer buffer = CharBuffer.allocate(20);  
3.         System.out.println("初始化时候：position="+buffer.position()+" limit="+buffer.limit());  
4.         fillBuffer(buffer,"hello");  
5.         System.out.println("填入hello以后：position="+buffer.position()+" limit="+buffer.limit());  
6.         buffer.put(0,'M').put('w');  
7.         System.out.println("修改成Mellow后：position="+buffer.position()+" limit="+buffer.limit());  
8.         buffer.flip();  
9.         System.out.println("翻转后：position="+buffer.position()+" limit="+buffer.limit());  
10.         buffer.clear();  
11.         System.out.println("clear后：position="+buffer.position()+" limit="+buffer.limit());  
12.         buffer.position(0);  
13.         while (buffer.hasRemaining()) {  
14.             System.out.println(buffer.get());  
15.         }  
16.     }private static void fillBuffer(CharBuffer buffer) {  
17.         String string = "MY TEST BUFFER";  
18.         for (int i = 0; i < string.length(); i++) {  
19.             buffer.put(string.charAt(i));  
20.         }  
21.     }  
22.   
23. 结果：  
24. 初始化时候：position=0 limit=20  
25. 填入hello以后：position=5 limit=20  
26. 修改成Mellow后：position=6 limit=20  
27. 翻转后：position=0 limit=6  
28. clear后：position=0 limit=20  
29. M  
30. e  
31. l  
32. l  
33. o  
34. w  

Java代码  

1. public static void compactTest(){  
2.         CharBuffer buffer = CharBuffer.allocate(11);  
3.         fillBuffer(buffer,"hello world");  
4.         buffer.position(6);  
5.         buffer.compact();  
6.         buffer.put("j");  
7.         buffer.put("a");  
8.         buffer.put("v");  
9.         buffer.put("a");  
10.         buffer.flip();  
11.         while (buffer.hasRemaining()) {  
12.             System.out.print(buffer.get());  
13.         }  
14.     }  
15. 打印结果为worldjava  

// [[1]] 使用typedef定义函数指针为一个类型，更喜欢这种方式

typedef int (*MYFUN)(int, int);

MYFUN funcs[10];

// [[2]] 使用typedef定义函数指针数组为一个类型，不是很直观

typedef int (*MYFUN2[10])(int, int);

MYFUN2 funcs2;

int main(int argc, char *argv[]) {

    funcs[0] = add;

    qDebug() << (*funcs[0])(2, 3); // 也可以用 funcs[0](2, 3).

    funcs2[0] = add;

    qDebug() << (*funcs2[0])(2, 3);

    return 0;

}

最近做项目遇到的问题，总结下。

有时候我们觉得系统的标题栏和按钮太丑太呆板，想做自己的标题栏以及最大化、最小化、关闭，菜单按钮，我们就需要 

有两种方案处理这种情况：

1.自己对mouseMoveEvent,mousePressEvent,mouseReleaseEvent 等事件进行处理。

2.Qt可以处理windows的消息。大家重新实现bool winEvent(MSG *message, long *result);(在此又一次感觉Qt的NB)

我刚开始使用第一种方法去实现的。移动窗口很容易做，大家可以去看看这个大大写的，比网上其他版本问题少些。

http://blog.csdn.net/aqtata/article/details/8902889

在窗口边缘按下鼠标拖动改变窗口大小就比较麻烦了。

我是这样做的：

在mousePressEvent 按下设置m_bPressed为真。

在mouseMoveEvent中m_bPressed为真且event->x() 在窗口边缘 及处理算出鼠标移动的增量 然后不断resize窗口。

至于如何为边缘的断定，就自己设定一个 差值 假如 在窗口边缘 ±4个px 就算在在该边缘就处理该resize。

这样做缺点很多，1.拖快了不行，很容易超过该差值 ， 2.窗口抖动的厉害，一直在resize，3.要处理太多情况

鉴于上诉缺点于是乎就到处问人百度google。有了第二种方法：

第二种方法很好用，效果和有标题边框程序一样~~~

Qt居然可以处理windows消息。。

这里我们要重新实现winEvent ( MSG * message, long * result ) 

该虚函数在QWidget和QWizard以及QSizeGrip以及他们的子类中都可以实现。

如果你想停止Qt处理消息就返回true，并且设置result到你想要保存的值返回给window处理。否者的话返回false。

这里我们主要想处理WM_NCHITTEST消息。

The WM_NCHITTEST message is sent to a window in order to determine what part of the window corresponds to a particular screen coordinate. This can happen, for example, when the cursor moves, when a mouse button is pressed or released, or in response to a call to a function such as WindowFromPoint. If the mouse is not captured, the message is sent to the window beneath the cursor. Otherwise, the message is sent to the window that has captured the mouse.

A window receives this message through its WindowProc function. 

知道这个就好了，我们还是要判断下鼠标的位置，然后通过该位置保存到result给window处理。

其实就是我们的程序没有边框不能发送这些消息，我们把它告诉windows，然后windows帮我们处理拖动，改变大小等效果。所以效果和有边框有标题程序效果一样的。

头文件申明：

把各种边界情况保存到result给windows处理，我们就省去很多事情，我想windows肯定比我们自己实现的效果要好多了。

因为

我做了边框阴影。阴影边框设定为20px所以在

Using a third-party library with Qt is a simple process. Suppose you know of a cross-platform library that accepts audio samples of a cat's meows and translates them into English words. This library is named CatWhisperer, and has several files that it provides as part of its library. Your project, MyQtApp, stores these files in a folder named 3rdparty:

• MyQtApp/
  • MyQtApp.pro
  • src/
    • main.cpp
  • 3rdparty/
    • CatWhisperer
      • include/
        • CatWhisperer.h
      • lib/
        • libCatWhisperer.so
        • CatWhisperer.lib
      • bin/
        • CatWhisperer.dll

To use the CatWhisperer library in MyQtApp, qmake requires the location and names of the CatWhisperer libraries. Optionally, you can also:

• Provide the location of the CatWhisperer source code so that you don't have to type out the full path to each file when you include them in your own code.
• Choose the destination in which the MyQtApp executable will be created.

The information above is provided in the .pro file, so that qmake can parse it and produce makefiles. Makefiles contain all the information needed by your compiler and linker to produce output, whether it is an executable, another library file, etc. The next sections explain the syntax with which qmakeexpects you to provide this information.

Source code

To be able to write

#include <CatWhisperer.h>

instead of

#include <3rdparty/CatWhisperer/include/CatWhisperer.h>

you can provide the path to the CatWhisperer include directory, using the INCLUDEPATH variable:

INCLUDEPATH += 3rdparty/CatWhisperer/include

Library files

To let qmake know where to find the CatWhisperer library files, use the LIBS variable:

LIBS += -L"3rdparty/CatWhisperer/lib" -lCatWhisperer

The first part of the expression lets the linker know in which directory it should look for the library files. The double quotes are only necessary when the path contains spaces, so we could have omitted them in this example.

The second part tells the linker which libraries to link against. We have two different library files for UNIX platforms and Windows, respectively:libCatWhisperer.so and CatWhisperer.lib. It is not necessary to specify the .lib extension, nor the lib prefix (on UNIX platforms).

Destination directory

By default, qmake creates the executable in the same directory as the .pro file. We can choose our own directory using the DESTDIR variable:

DESTDIR = bin

That's it! You can now use the CatWhisperer library in your project. The final .pro file looks like this:

TARGET = MyQtApp
TEMPLATE = app
INCLUDEPATH += 3rdparty/CatWhisperer/include
SOURCES += src/main.cpp
LIBS += -L"3rdparty/CatWhisperer/lib" -lCatWhisperer

See also qmake Manual and Adding Libraries to Projects.

QFontDatabase的构造函数中会调用createDatabase （里面调用了initializeDb), initializeDb里调用了privateDb(),一个这个时候是第一次调用， 会生成QFontDatabasePrivate对象

QFontDatabasePrivate中的QDataStream *stream成员才是真正处理qte的字体

创建一个QT的库项目,删除自动生成的.h和.cpp文件,添加一个接口定义.h文件和一个接口实现类(一个.h一个.cpp).代码如下:

1.接口文件源码

#ifndef PLUGININTERFACE_H
#define PLUGININTERFACE_H

#include <QString>

class EchoInterface
{
public:
 virtual ~EchoInterface() {}
 virtual QString echo(const QString &message) = 0;
};

QT_BEGIN_NAMESPACE
Q_DECLARE_INTERFACE(EchoInterface, "com.hollysys.plugin.EchoIntrface/1.0");
QT_END_NAMESPACE

#endif

2.接口实现类头文件

#ifndef PLUGIN_H
#define PLUGIN_H

//#include "plugin_global.h"
#include <QObject>
#include "plugininterface.h"

class Plugin : public QObject, EchoInterface
{
 Q_OBJECT
 Q_INTERFACES(EchoInterface)
public:
 Plugin();
 ~Plugin();
public:
 QString echo(const QString &message);

};

#endif // PLUGIN_H

3.接口实现类cpp文件

#include "plugin.h"
#include <QtGui>

Plugin::Plugin()
{

}

Plugin::~Plugin()
{

}

QString Plugin::echo(const QString &message)
{
 return message;
}

Q_EXPORT_PLUGIN2("echoPlugin", Plugin);

编译生成dll格式的插件.这里可能会遇到LNK2001错误,因为插件接口定义依赖于QT的元数据,而在代码中手动添加Q_OBJECT宏后,编译器不会自动为我们生成moc_XXXX.cpp文件,因此需要使用命令行生成moc元数据文件:cmd-->cd 源码所在命令 -->moc -o moc_XXXX.cpp XXXX.h.这样就可以手动创建出moc元数据文件,解决LNK2001编译错误.

建立一个GUI测试项目,代码如下:

#include "test.h"
#include <QtGui>
#include <QMessageBox>
#include <QDir>

Test::Test(QWidget *parent, Qt::WFlags flags)
 : QMainWindow(parent, flags)
{
 ui.setupUi(this);
 QObject::connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(ButtonClicked()));
 loadPlugin();
}

Test::~Test()
{

}

bool Test::loadPlugin()
{
 QDir pluginsDir(qApp->applicationDirPath());
 foreach (QString filename, pluginsDir.entryList(QDir::Files))
 {
  QPluginLoader pluginLoader(pluginsDir.absoluteFilePath(filename));
  QObject *plugin = pluginLoader.instance();
  if(plugin)
  {
   echoInterface = qobject_cast<EchoInterface *>(plugin);//echoInterface是成员变量
   if(echoInterface)
    return true;
  }
 }
}

void Test::ButtonClicked()
{
 QString plugin = ui.lineEdit->text();
 QMessageBox::information(NULL, "", echoInterface->echo(plugin));
}

分析代码可见,这里对所有与exe文件同目录的文件尝试加载插件,如果加载成功则返回.代码实现非常简洁.在正式开发中可将已加载的插件接口存放在列表中,在需要的时候依次调用即可.

另外如果想获取插件中类定义的元数据,可以使插件接口类从QObject继承,并使用Q_CLASSINFO宏添加键值对,如Q_CLASSINFO("Author**", "Henreash**").并从主程序中使用插件对象元数据获取这些键值对:

 const QMetaObject *mo = echoInterface->metaObject();
 for(int i = 0; i < mo->classInfoCount(); i++)
 {
  qDebug() << mo->classInfo(i).name() << mo->classInfo(i).value();
 }

使用这个机制可以在定义插件类的时候向主程序传递一些特殊信息.

测试发现,如果在插件接口类中定义一个静态变量,那么这个静态变量在插件中的地址和在主程序中的地址是不相同的.

在C++编程语言中，单例模式应用的例子如下述代码所示（这里仅仅提供一个示例，这个例子对多线程的情况并不是安全的）：

// ...
class lock
{
public:
lock();
lock(lock const & l);
~lock();
lock & operator =(lock const & l);
void request();
void release();
// ...
};
lock::lock()
{
// ...
}
// ...
lock::~lock()
{
// ...
}
// ...
void lock::request()
{
// ...
}
void lock::release()
{
// ...
}
// ...
// assumes _DATA_TYPE_ has a default constructor
template<typename _DATA_TYPE_>
class singleton
{
public:
static _DATA_TYPE_ * request();
static void release();
private:
singleton();
singleton(singleton<_DATA_TYPE_> const & s);
~singleton();
singleton<_DATA_TYPE_> & operator =(singleton<_DATA_TYPE_> const & s);
static _DATA_TYPE_ * pointer;
static lock mutex;
// ...
};
template<typename _DATA_TYPE_>
_DATA_TYPE_ * singleton<_DATA_TYPE_>::pointer = 0;
template<typename _DATA_TYPE_>
lock singleton<_DATA_TYPE_>::mutex;
template<typename _DATA_TYPE_>
_DATA_TYPE_ * singleton<_DATA_TYPE_>::request()
{
if(singleton<_DATA_TYPE_>::pointer == 0)
{
singleton<_DATA_TYPE_>::mutex.request();
if(singleton<_DATA_TYPE_>::pointer == 0)
{
singleton<_DATA_TYPE_>::pointer = new _DATA_TYPE_;
}
singleton<_DATA_TYPE_>::mutex.release();
}
return singleton<_DATA_TYPE_>::pointer;
}
template<typename _DATA_TYPE_>
void singleton<_DATA_TYPE_>::release()
{
if(singleton<_DATA_TYPE_>::pointer != 0)
{
singleton<_DATA_TYPE_>::mutex.request();
if(singleton<_DATA_TYPE_>::pointer != 0)
{
delete singleton<_DATA_TYPE_>::pointer;
singleton<_DATA_TYPE_>::pointer = 0;
}
singleton<_DATA_TYPE_>::mutex.release();
}
}
template<typename _DATA_TYPE_>
singleton<_DATA_TYPE_>::singleton()
{
// ...
}
// ...
int main()
{
int * s;
s = singleton<int>::request();
// ...
singleton<int>::release();
return 0;
}