C++博客-天下-随笔分类-QT

QT生成在Windows下有图标的exe文件(IDE=QT Creator)

天下 — Mon, 30 May 2016 05:51:00 GMT

QT生成在Windows下有图标的exe文件(IDE=QT Creator)
我个人十分喜爱QT Creator的IDE界面与操作，但是也许是尚未完全成熟或者是为了代码跨平台，有些功能并没有直接提供。

比如Windows下做软件，至少作为主程序或启动程序的exe文件一般都应该有自己的图标，QT Creator虽然可以轻松地设置窗口的小图标，但并没有提供设置exe文件图标的功能。

其实做起来并不难。
·首先当然要准备一个.ico图标文件（假定为myIcon.ico），将其复制到工程目录当中（.pro文件所在的目录）。
·然后在QT Creator中Ctrl+N或 File - New File or Project
选择General中的Text File
名称填写为.rc文件（如myRc.rc）
在里面只用写一行:
IDI_ICON1 ICON DISCARDABLE "myIcon.ico"
·编辑.pro文件，里面应该有：
OTHER_FILES+= \
apprc.rc
在其下再添加一行（如果没有上面的内容也没事）:
RC_FILE = \
myRc.rc
·最后编译一下就好了，新生成的exe文件的图标就会变成myIcon.ico的样子

天下 2016-05-30 13:51 发表评论

QWidget与HWND的互相转换

天下 — Mon, 30 May 2016 05:51:00 GMT

QWidget与HWND的互相转换

在编写Windows的应用程序时，我们有时不可避免地要与Windows平台固有的Win32 API打交道，但是Win32 API里面常常用到的HWND等诸多句柄QT并没有。QT作为一款优秀的跨平台GUI库，不可能未作考虑，那么需要互相转换的时候该如何做呢？

HWND转QWidget
QWidget *myWidget;
HWND hwnd;
myWidget=QWidget::find(hwnd);

QWidget转HWND
QWidget *myWidget;
HWND hwnd;
hwnd=(HWND)myWidget->winId();
QPixmap与HBITMAP、HICON互转

使用QPixmap::toWinHICON();QPixmap::toWinHBITMAP();
QPixmap::fromWinHICON();QPixmap::fromWinHBITMAP();函数用法一目了然
QPixmap与QIcon、QImage可以轻松互转，这里不多说了

天下 2016-05-30 13:51 发表评论

SetAutoFont

天下 — Thu, 28 Nov 2013 07:56:00 GMT

void SetAutoFont(QLabel* pLabel)
{
    int w = pLabel->width();
    QFont font = pLabel->font();
    int nFontMax = 60;
    int nFontMin = 12;
    int nNewWidth;
    QString strText = pLabel->text();
    for (int nFontSize=nFontMax;nFontSize>=nFontMin;nFontSize-=2)
    {
        font.setPointSize(nFontSize);
        QFontMetrics fm(font);
        nNewWidth = fm.width(strText);
        if (nNewWidth < w)
        {
            pLabel->setFont(font);
            break;
        }
    }
}

天下 2013-11-28 15:56 发表评论

Qt将资源放在外部调用

天下 — Tue, 26 Nov 2013 09:42:00 GMT

编译资源文件：
rcc -binary resource/0/app.qrc -o resource/0.rcc
rcc -binary resource/1/app.qrc -o resource/1.rcc

调用：
bool bRet = QResource::registerResource(strResourceFileName);

释放：
bool bRet = QResource::unregisterResource(strResourceFileName);

天下 2013-11-26 17:42 发表评论

键盘事件的传递

天下 — Thu, 04 Jul 2013 04:02:00 GMT

class Q_GUI_EXPORT QWidget : public QObject, public QPaintDevice
{
protected:
    QWidget(QWidgetPrivate &d, QWidget* parent, Qt::WindowFlags f);
}

/*!
\internal
*/
QWidget::QWidget(QWidgetPrivate &dd, QWidget* parent, Qt::WindowFlags f)
    : QObject(dd, 0), QPaintDevice()
{
    Q_D(QWidget);
    QT_TRY {
        d->init(parent, f);
    } QT_CATCH() {
        QWidgetExceptionCleaner::cleanup(this, d_func());
        QT_RETHROW;
    }
}

//键盘事件的传递
extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        case WM_CHAR: {
            MSG msg1;
            bool anyMsg = PeekMessage(&msg1, msg.hwnd, 0, 0, PM_NOREMOVE);
            if (anyMsg && msg1.message == WM_DEADCHAR) {
                result = true; // consume event since there is a dead char next
                break;
            }
            QWidget *g = QWidget::keyboardGrabber();
            if (g && qt_get_tablet_widget() && hwnd == qt_get_tablet_widget()->winId()) {
                // if we get an event for the internal tablet widget,
                // then don't send it to the keyboard grabber, but
                // send it to the widget itself (we don't use it right
                // now, just in case).
                g = 0;
            }
            if (g)
                widget = (QETWidget*)g;
            else if (QApplication::activePopupWidget())
                widget = (QETWidget*)QApplication::activePopupWidget()->focusWidget()
                       ? (QETWidget*)QApplication::activePopupWidget()->focusWidget()
                       : (QETWidget*)QApplication::activePopupWidget();
            else if (QApplication::focusWidget())  //这里条件为真
                widget = (QETWidget*)QApplication::focusWidget();  //得到具有输入焦点的widget
            else if (!widget || widget->internalWinId() == GetFocus()) // We faked the message to go to exactly that widget.
                widget = (QETWidget*)widget->window();
            if (widget->isEnabled())
                result = sm_blockUserInput
                            ? true
                            : qt_keymapper_private()->translateKeyEvent(widget, msg, g != 0);
            break;
        }
    //..
}

extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    if (qt_is_translatable_mouse_event(message)) {
        if (QApplication::activePopupWidget() != 0) { // in popup mode
            POINT curPos = msg.pt;
            QWidget* w = QApplication::widgetAt(curPos.x, curPos.y);
            if (w)
                widget = (QETWidget*)w;
        }

    if (!qt_tabletChokeMouse) {
        result = widget->translateMouseEvent(msg);
    }
    }
}

天下 2013-07-04 12:02 发表评论

[转]浅议Qt的事件处理机制二

天下 — Thu, 04 Jul 2013 04:00:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->浅议Qt的事件处理机制二我们在上文中，介绍了Qt框架的事件处理机制：事件的产生、分发、接受和处理，并以视窗系统鼠标点击QWidget为例，对代码进行了剖析，向大家分析了Qt框架如何通过Event ... 阅读全文

天下 2013-07-04 12:00 发表评论

[转]浅议Qt的事件处理机制一

天下 — Thu, 04 Jul 2013 03:59:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->浅议Qt的事件处理机制一 . 深入了解事件处理系统对于每个学习Qt人来说非常重要，可以说，Qt是以事件驱动的UI工具集。大家... 阅读全文

天下 2013-07-04 11:59 发表评论

[原]Qt事件处理机制浅析

天下 — Thu, 27 Jun 2013 03:10:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->[原]Qt事件处理机制浅析事件处理机制浅析是通过WM_ACTIVATE消息来分析的//调用堆栈WinMainCRTStartup()&nbs... 阅读全文

天下 2013-06-27 11:10 发表评论

Qt模态对话框

天下 — Wed, 24 Apr 2013 01:38:00 GMT

Qt模态对话框

1、模态对话框定

模态对话框（Modal Dialog）与非模态对话框（Modeless Dialog）的概念不是Qt所独有的，在各种不同的平台下都存在。又有叫法是称为模式对话框，无模式对话框等。

所谓模态对话框就是在其没有被关闭之前，用户不能与同一个应用程序的其他窗口进行交互，直到该对话框关闭。对于非模态对话框，当被打开时，用户既可选择和该对话框进行交互，也可以选择同应用程序的其他窗口交互。

2、显示模态对话框的方式

在Qt中，显示一个对话框一般有两种方式，一种是使用exec()方法，它总是以模态来显示对话框；另一种是使用show()方法，它使得对话框既可以模态显示，也可以非模态显示，决定它是模态还是非模态的是对话框的modal属性。

在Qt中，Qt的模态与非模态对话框选择是通过其属性modal来确定的。我们来看看modal属性，其定义如下：modal : bool默认情况下，对话框的该属性值是false。

这时通过show()方法显示的对话框就是非模态的。而如果将该属性值设置为true，就设置成了模态对话框，其作用于把QWidget::windowModality属性设置为Qt::ApplicationModal。

而使用exec()方法显示对话框的话，将忽略modal属性值的设置并把对话框设置为模态对话框。

一般使用setModal()方法来设置对话框的modal属性。

3、具体函数

我们总结一下设置对话框为模态的方法。

如果要设置为模态对话框，最简单的就是使用exec()方法，示例代码如下：

MyDialog myDlg; myDlg.exec();

也可以使用show()方法，示例代码如下：

MyDialog myDlg; myDlg.setModal(true); myDlg.show();

如果要设置为非模态对话框，必须使用show()方法，示例代码如下：

MyDialog myDlg; myDlg.setModal(false);

//或者

myDlg.setModal();

myDlg.show();

再次强调，目前有的朋友对于模态对话框和非模态对话框的认识有误解，认为使用show()方法显示的就是非模态对话框，这是不正确的。

4、窗口置前

小贴士：有时候，我们需要一个对话框以非模态的形式显示，但又需要它总在所有窗口的最前面，这时可以通过如下代码设置：

MyDialog myDlg; myDlg.setModal(false);

//或者

mDlg.setModal(); myDlg.show();

//关键是下面这行

myDlg.setWindowFlags(Qt::WindowStaysOnTopHint);

转自：http://blog.163.com/qimo601@126/blog/static/1582209320130119254624/

天下 2013-04-24 09:38 发表评论

win32下使用getopt,从qt中弄了个getop.c

天下 — Tue, 16 Apr 2013 07:24:00 GMT

//getopt.h
#pragma once
#ifdef __cplusplus
extern "C" {
#endif

extern int opterr;        /* if error message should be printed */
extern int optind;        /* index into parent argv vector */
extern int optopt;            /* character checked for validity */
extern int optreset;        /* reset getopt */
extern char    *optarg;        /* argument associated with option */
int getopt(int argc, char * const argv[], const char *optstring);

#ifdef __cplusplus
}
#endif

getopt.c 从qt中弄的,一行都没改

//getopt.c 从qt中弄的,一行都没改

/* $Id: getopt.c,v 1.2 2005/07/07 16:34:06 dron Exp $ */

/*
* Copyright (c) 1987, 1993, 1994
*    The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#if 0
static char sccsid[] = "@(#)getopt.c    8.3 (Berkeley) 4/27/95";
__RCSID("$NetBSD: getopt.c,v 1.26 2003/08/07 16:43:40 agc Exp $");
#endif

#include
#include <string.h>

int    opterr = 1,        /* if error message should be printed */
    optind = 1,        /* index into parent argv vector */
    optopt,            /* character checked for validity */
    optreset;        /* reset getopt */
char    *optarg;        /* argument associated with option */

#define    BADCH    (int)'?'
#define    BADARG    (int)':'
#define    EMSG    ""

/*
* getopt --
*    Parse argc/argv argument vector.
*/
int getopt(int argc, char * const argv[], const char *optstring)
{
    static char *place = EMSG;        /* option letter processing */
    char *oli;                /* option letter list index */

    if (optreset || *place == 0) {        /* update scanning pointer */
        optreset = 0;
        place = argv[optind];
        if (optind >= argc || *place++ != '-') {
            /* Argument is absent or is not an option */
            place = EMSG;
            return (-1);
        }
        optopt = *place++;
        if (optopt == '-' && *place == 0) {
            /* "--" => end of options */
            ++optind;
            place = EMSG;
            return (-1);
        }
        if (optopt == 0) {
            /* Solitary '-', treat as a '-' option
               if the program (eg su) is looking for it. */
            place = EMSG;
            if (strchr(optstring, '-') == NULL)
                return -1;
            optopt = '-';
        }
    } else
        optopt = *place++;

    /* See if option letter is one the caller wanted */
    if (optopt == ':' || (oli = strchr(optstring, optopt)) == NULL) {
        if (*place == 0)
            ++optind;
        if (opterr && *optstring != ':')
            (void)fprintf(stderr,
                                      "unknown option -- %c\n", optopt);
        return (BADCH);
    }

    /* Does this option need an argument? */
    if (oli[1] != ':') {
        /* don't need argument */
        optarg = NULL;
        if (*place == 0)
            ++optind;
    } else {
        /* Option-argument is either the rest of this argument or the
           entire next argument. */
        if (*place)
            optarg = place;
        else if (argc > ++optind)
            optarg = argv[optind];
        else {
            /* option-argument absent */
            place = EMSG;
            if (*optstring == ':')
                return (BADARG);
            if (opterr)
                (void)fprintf(stderr,
                                        "option requires an argument -- %c\n",
                                        optopt);
            return (BADCH);
        }
        place = EMSG;
        ++optind;
    }
    return (optopt);            /* return option letter */
}

gnu getopt的使用:

//main.c
#include
#ifdef WIN32
    #include "getopt.h"
#else
    #include
#endif

int main(int argc,char **argv)
{
    int ch;
    opterr = 1;
    while((ch = getopt(argc,argv,"a:bcde"))!= -1)
    {
        switch(ch)
        {
            case 'a': printf("option a:'%s'\n",optarg); break;
            case 'b': printf("option b :b\n"); break;
            default:  printf("other option :%c\n",ch);
        }
    }

    printf("optopt +%c\n",optopt);
    //system("pause");
    return 0;

}

天下 2013-04-16 15:24 发表评论

QLCDNumber

天下 — Fri, 19 Oct 2012 03:18:00 GMT

//DigitalClock.h
#pragma once
#include <QtGui>
#include <QLCDNumber>

class DigitalClock : public QLCDNumber
{
public:
    DigitalClock(QWidget *parent=0);

protected:
    void timerEvent(QTimerEvent *);
private:
    bool isColon;
};

//DigitalClock.cpp
#include "DigitalClock.h"
#include <QDateTime>

DigitalClock::DigitalClock(QWidget *parent) : QLCDNumber(parent)
{
    this->isColon = false;
    this->setFrameStyle(QFrame::Panel | QFrame::Raised);
    this->setNumDigits(11);

    //QPalette pe;
    //pe.setColor(QPalette::WindowText,Qt::blue);
    //setPalette(pe);
    startTimer(500);

    setStyleSheet("color:#0000ff;");
    //setStyleSheet("color:blue;");
}

void DigitalClock::timerEvent(QTimerEvent *e) {
    isColon = !isColon;

    QString timeString = QTime::currentTime().toString().left(5);

    QDate date = QDate::currentDate();
    QString dateString;
    dateString.sprintf( " %2d-%2d", date.month(), date.day());

    QString displayString = timeString;

    if (!isColon) {
        displayString[2] = ' ';
    }
    display(displayString);
}

//main.cpp
#include "DigitalClock.h"
#include <QApplication>

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

    DigitalClock *digitalClock = new DigitalClock;

    digitalClock->resize(300,80);
    digitalClock->setWindowTitle("QTimer");

    digitalClock->show();

    return app.exec();
}

天下 2012-10-19 11:18 发表评论

QT设置QLabel中字体的颜色

天下 — Fri, 19 Oct 2012 03:14:00 GMT

QT设置QLabel中字体的颜色

其实，这是一个比较常见的问题。大致有几种做法：一是使用setPalette()方法；二是使用样式表；三是可以使用QStyle；四是可以在其中使用一些简单的HTML样式。
下面就具体说一下，也算是个总结吧。

第一种，使用setPalette()方法如下：
QLabel *label = new QLabel(tr("Hello Qt!"));
QPalette pe;
pe.setColor(QPalette::WindowText,Qt::white);
label->setPalette(pe);

第二种，使用样式表如下：
setStyleSheet("color:red;");
//setStyleSheet("color:#ff6600;");

第三种，使用QStyle，在Qt Demo中有一个很好的讲解QStyle的例子，可以参考学习。

第四种，使用一些简单的HTML格式：
QLabel *label = new QLabel("

HelloQt!

");

天下 2012-10-19 11:14 发表评论

用标准C++实现信号与槽机制

天下 — Wed, 17 Oct 2012 08:11:00 GMT

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

template<typename tParam>
class SlotBase
{
public:
    virtual void Exec(tParam param) = 0;
};

template<class T, class tParam>
class SlotImpl : public SlotBase<tParam>
{
public:
    SlotImpl(T* pObj, void (T::*func)(tParam) )
    {
        m_pObj = pObj;
        m_Func = func;
    }

    void Exec( tParam param)
    {
        (m_pObj->*m_Func)(param);
    }

private:
    T* m_pObj;
    void (T::*m_Func)(tParam);
};

template<class tParam>
class Slot
{
public:
    template<class T>
    Slot(T* pObj, void (T::*func)(tParam))
    {
        m_pSlotBase = new SlotImpl<T,tParam>(pObj, func);
    }

    ~Slot()
    {
        delete m_pSlotBase;
    }

    void Exec(tParam param1)
    {
        m_pSlotBase->Exec(param1);
    }

private:
    SlotBase<tParam>* m_pSlotBase;
};

template<typename tParam>
class Signal
{
public:
    template<class T>
    void Bind(T* pObj, void (T::*func)(tParam))
    {
        m_pSlotSet.push_back( new Slot<tParam>(pObj,func) );
    }

    ~Signal()
    {
        for(int i=0;i<(int)m_pSlotSet.size();i++)
        {
            delete m_pSlotSet[i];
        }
    }

    void operator()(tParam param1)
    {
        for(int i=0;i<(int)m_pSlotSet.size();i++)
        {
            m_pSlotSet[i]->Exec(param1);
        }
    }

private:
    vector< Slot<tParam>* > m_pSlotSet;
};

#define Connect( sender, signal, receiver, method) ( (sender)->signal.Bind(receiver, method) )

class A
{
public:
    void FuncOfA(int param)
    {
        printf("A::FuncOfA(%d)\n", param);
    }
};

class B
{
public:
    void FuncOfB(int param)
    {
        printf("B::FuncOfB(%d)\n", param);
    }
};

class C
{
public:
    void SetValue(int value)
    {
        ValueChanged(value);
    }

public:
    Signal<int> ValueChanged;

};

int main()
{
    A* pA = new A;
    B* pB = new B;
    C* pC = new C;

    Connect(pC, ValueChanged, pA, &A::FuncOfA);
    //Connect(pC, ValueChanged, pB, &B::FuncOfB);

    //pC->ValueChanged(10);
    pC->SetValue(10);
    //pC->SetValue(5);
    //pC->SetValue(5);

    delete pC;
    delete pB;
    delete pA;

    system("pause");
    return 0;
}

转自:http://www.cnitblog.com/luckydmz/archive/2010/11/15/71336.html

天下 2012-10-17 16:11 发表评论

QT资源文件

天下 — Wed, 17 Oct 2012 03:03:00 GMT

QT资源文件

Qt资源体系采用平台独立机制来存储应用程序执行时的二进制文件。这种机制在应用程序需要一些确定的文件(图标、翻译文件等等)而且又不想冒丢失文件的风险时是有用的。

资源体系依赖于 qmake, rcc (Qt's resource compiler), 和 QFile 的紧密协作。Qt 3 的 qembed 工具和 image collection 机制被废除。

Resource Collection Files (.qrc)
与应用程序关联的应用程序由 .qrc 文件来指定，它用XML记录硬盘上的文件和对应的随意指定的资源名称，应用程序通过资源名称来访问资源。

一个.qrc 文件的例子：

DOCTYPE RCC>
<RCC version="1.0">
    <qresource>
    <file>images/copy.pngfile>
    <file>images/cut.pngfile>
    <file>images/paste.pngfile>
    <file>images/save.pngfile>
    qresource>
RCC>
.qrc 文件中列出的资源文件是程序的源码树的一部分。指定的路径是 .qrc 文件所在目录的相对路径。注意，列出的资源文件必须位于 .qrc 文件所在目录或者其子目录下。

资源数据也能被编译进二进制文件中，因此应用程序代码可以立即访问；也可以创建一个二进制资源，稍后在程序中登记了资源体系的代码中指定。

缺省时，程序可以用资源在源码树中的名称加一个 :/ 前缀来访问它。例如，在程序的源码树中是 images/cut.png 的文件可以通过 :/images/cut.png 来访问。但也可以用 file 标签中的 alias 属性来指定：

<file alias="cut-img.png">images/cut.pngfile>
这时该文件可以通过 :/cut-img.png 来访问。也可以在 .qrc 文件中用 qresource 标签的 prefix 属性：它可以为 .qrc 文件中所有文件指定一个前缀：

<qresource prefix="/myresources">
    <file alias="cut-img.png">images/cut.pngfile>
qresource>
这时该文件可以用 :/myresources/cut-img.png 访问。

有些资源，像翻译文件和图标，需要随着用户的本地配置而变化。这可以在 qresource 标签的 lang 属性中指定一个合适的本地化字串来实现。例如：

<qresource>
    <file>cut.jpgfile>
qresource>

<qresource lang="fr">
    <file alias="cut.jpg">cut_fr.jpgfile>
qresource>
如果用户的本地化设置是 French (也就是说，QLocale::system().name() returns "fr_FR")，:/cut.jpg 就会引用 cut_fr.jpg 图像。对于其他本地化设置，仍然用 cut.jpg 。

本地化字串的使用格式参见 QLocale 文档。

使用外部二进制资源
为创建一个外部二进制资源，需要通过向 rcc 传递 -binary 开关来生成资源数据(一般是.rcc扩展名)。然后可以用 QResource API 来注册资源。
例如，一个 .qrc 文件指定的资源数据集可以用下面方法编译：
rcc -binary myresource.qrc -o myresource.rcc
应用程序中，用下面的代码注册资源： QResource::registerResource("/path/to/myresource.rcc");

Compiled-In Resources
必须在应用程序的 .pro 文件中指定.qrc 文件， qmake 才能知道并将资源编译进二进制文件。例如：

RESOURCES  +  = application.qrc
qmake 将产生make规则来生成一个叫做 qrc_application.cpp 的文件并把它链接到应用程序中。该文件中，图像和其他资源的所有数据被以压缩二进制数据存进静态C++数组中。 .qrc 文件被改变或者它引用的文件中的某一个被改变时， qrc_application.cpp 自动重新生成。若你没有使用 .pro 文件，你也可以手动调用 rcc 或者在你的编译系统中添加创建规则。

通常，Qt直接将数据存储在可执行文件中，甚至在Windows和Mac OS X这些提供资源本地支持的操作系统中也是这样。这可能会在未来的Qt版本中改变。

Using Resources in the Application

应用程序中，绝大多数地方都可以用资源路径代替原始文件系统路径。尤其是在 QIcon, QImage, or QPixmap 构造器中可以传递资源路径来代替文件名称：

cutAct = new QAction(QIcon(":/images/cut.png"), tr("Cu&t"), this);

在内存中，资源被用资源对象树来描述。该树在启动时自动构建并用QFile来解析资源路径。可以用":/" 初始化的 QDir 来从资源树的根部开始浏览。

Qt资源支持搜索路径列表概念。若用 ":"代替":/"做前缀来引用一个资源，资源将被用搜索路径列表查询。启动时搜索路径列表是空的，调用 QDir::addResourceSearchPath() 可以添加路径。

If you have resources in a static library，必须用.qrc 文件的base name作参数调用 Q_INIT_RESOURCE() 来强制初始化资源。例如：

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    Q_INIT_RESOURCE(graphlib);
    //
    return app.exec();
}
同样地，若你需要显式卸载一个资源集(因插件被卸载或资源失效)，需要用与前面相同的base name为参数调用Q_CLEANUP_RESOURCE() 来强制移除资源

天下 2012-10-17 11:03 发表评论

QT学习笔记（9）：堆栈窗口

天下 — Wed, 17 Oct 2012 02:21:00 GMT

//StackDlg.h
#pragma once
#include <QtGui>
class StackDlg : public QDialog
{
    Q_OBJECT
public:
    StackDlg(QWidget *parent = 0, Qt::WindowFlags f1 = 0);

    QLabel *label1;
    QLabel *label2;
    QLabel *label3;
    QListWidget *listwidget;
    QStackedWidget *stackwidget;
};

//StackDlg.cpp
#include "stack.h"

StackDlg::StackDlg(QWidget *parent, Qt::WindowFlags f1) : QDialog(parent,f1)
{
    setWindowTitle(tr("Stacked Widgets"));

    listwidget = new QListWidget(this);
    listwidget->insertItem(0,tr("Window 1"));
    listwidget->insertItem(1,tr("Window 2"));
    listwidget->insertItem(2,tr("Window 3"));

    label1 = new QLabel(tr("This is Window 1 !"));
    label2 = new QLabel(tr("This is Window 2 !"));
    label3 = new QLabel(tr("This is Window 3 !"));

    stackwidget = new QStackedWidget(this);
    stackwidget->addWidget(label1);
    stackwidget->addWidget(label2);
    stackwidget->addWidget(label3);

    QHBoxLayout *mainLayout = new QHBoxLayout(this);
    mainLayout->setMargin(0);
    mainLayout->setSpacing(0);

    mainLayout->addWidget(listwidget,1);    //延伸因子为1

    mainLayout->addWidget(stackwidget,3,Qt::AlignLeft); //延伸因子为3

    //mainLayout->setStretchFactor(list,1);    //设置延伸因子为1
    //mainLayout->setStretchFactor(stackwidget,4); //设置延伸因子为4
    connect(listwidget,SIGNAL(currentRowChanged(int)),stackwidget,SLOT(setCurrentIndex(int)));
}

//main.cpp
#include <QApplication>
#include "StackDlg.h"

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

    StackDlg stack;
    stack.show();
    return a.exec();
}

天下 2012-10-17 10:21 发表评论

QT学习笔记（8）：可停靠的窗口

天下 — Wed, 17 Oct 2012 01:36:00 GMT

//dockwindows.h
#pragma once
#include <QtGui>

class DockWindows : public QMainWindow
{
    Q_OBJECT
public:
    DockWindows();
    ~DockWindows();
};

//dockwindows.cpp
#include "dockwindows.h"

DockWindows::DockWindows(): QMainWindow()

{
    setWindowTitle( tr( "DockWindows" ) );

    QTextEdit *te = new QTextEdit( this );
    te->setText(tr("Main Window"));
    te->setAlignment(Qt::AlignCenter);
    //te->setMinimumWidth(640);
    //this->resize(800,600);
    setCentralWidget( te );

    //  停靠窗口 1
    QDockWidget *dock = new QDockWidget(tr("DockWindow 1"), this );

    dock->setFeatures(QDockWidget::DockWidgetFeature::AllDockWidgetFeatures);
    //same as dock->setFeatures(QDockWidget::AllDockWidgetFeatures);

    dock->setAllowedAreas(Qt::DockWidgetArea::AllDockWidgetAreas);
    //same as dock->setAllowedAreas(Qt::AllDockWidgetAreas);
    QTextEdit *te1 = new QTextEdit();
    te1->setText(tr("Window 1"));
    dock->setWidget( te1 );

    addDockWidget( Qt::RightDockWidgetArea, dock );

    //  停靠窗口 2
    dock = new QDockWidget( tr("DockWindow 2"), this );
    //dock->setFeatures( QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetClosable);
    QTextEdit *te2 = new QTextEdit();
    te2->setText(tr("Window 2"));
    dock->setWidget( te2 );
    addDockWidget( Qt::RightDockWidgetArea, dock);

    //  停靠窗口 3
    dock = new QDockWidget( tr("DockWindow 3"),this );
    dock->setFeatures( QDockWidget::AllDockWidgetFeatures );
    QTextEdit *te3 = new QTextEdit();
    te3->setText(tr("Window 3"));
    dock->setWidget( te3 );
    addDockWidget( Qt::BottomDockWidgetArea, dock);
}

DockWindows::~DockWindows()
{
}

//main.cpp
#include "dockwindows.h"
#include <QApplication>

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

    QApplication a( argc, argv );
    QTranslator translator(0);
    translator.load("dockwindows_zh",".");
    a.installTranslator(&translator);

    DockWindows *dockwindows = new DockWindows();
    dockwindows->show();
    return a.exec();
}

天下 2012-10-17 09:36 发表评论

QCheckBoxEx

天下 — Tue, 09 Oct 2012 05:56:00 GMT

//QCheckBoxEx.h
#include <QtGui/QtGui>
class QCheckBoxEx : public QAbstractButton
{
public:
    QCheckBoxEx(QWidget* parent);
    bool init(QString yes,QString no);
private:
    QPixmap m_pixmap[2];
protected:
    void paintEvent(QPaintEvent *event);
};

//QCheckBoxEx.cpp
#include "QCheckBoxEx.h"
QCheckBoxEx::QCheckBoxEx(QWidget* parent)
{
    setParent(parent);
    setCheckable(true);
}

bool QCheckBoxEx::init(QString yes,QString no)
{
    m_pixmap[0].load(no);
    m_pixmap[1].load(yes);

    int w = m_pixmap[0].width();
    int h = m_pixmap[0].height();

    if (w && h && w== m_pixmap[1].width() && h==m_pixmap[1].height())
    {
        resize(w,h);
        return true;
    }
    return false;
}
void QCheckBoxEx::paintEvent(QPaintEvent *event)
{
    QPainter p(this);
    if (isChecked())
    {
        p.drawPixmap(0,0,m_pixmap[1]);
    }
    else{
        p.drawPixmap(0,0,m_pixmap[0]);
    }
}

//使用
    m_check = new QCheckBoxEx(this);
    m_check->init("d:\\1.jpg","d:\\0.jpg");
    //m_check->setChecked(true);

天下 2012-10-09 13:56 发表评论

QT学习笔记（7）：线程

天下 — Fri, 31 Aug 2012 07:29:00 GMT

//QT线程
#include <QtGui/QtGui>

QMutex mutex;
int count = 0;
class MyThread : public QThread
{
public:
        virtual void run();
};
void MyThread::run()
{
    int i=10000;
    while(i--)
    {
        mutex.lock();
        count++;
        qDebug( "at %p count:%d",this,count );
        //msleep(100);
        mutex.unlock();
    }
}

int main()
{
    MyThread a;
    MyThread b;
    a.start();
    b.start();
    a.wait();
    b.wait();

    //如果不加锁,得到的count可能不正确.
    qDebug( "count:%d",count );
    return 0;
}

天下 2012-08-31 15:29 发表评论

Qt的内存管理

天下 — Fri, 31 Aug 2012 07:28:00 GMT

Qt的内存管理

刚学Qt时，发现代码里到处都是new，而基本上见不到delete，百度得知，Qt中内存管理机制：当new一个对象指定父亲时，父亲被销毁时，会一并把自对象销毁。

在QT的程序中经常会看到只有new而不delete的情况，其实是因为QT有一套回收内存的机制，主要的规则如下：

1.所有继承自QOBJECT类的类，如果在new的时候指定了父亲，那么它的清理时在父亲被delete的时候delete的，所以如果一个程序中，所有的QOBJECT类都指定了父亲，那么他们是会一级级的在最上面的父亲清理时被清理，而不用自己清理；

2.程序通常最上层会有一个根的QOBJECT，就是放在setCentralWidget（）中的那个QOBJECT，这个QOBJECT在new的时候不必指定它的父亲，因为这个语句将设定它的父亲为总的QAPPLICATION，当整个QAPPLICATION没有时它就自动清理，所以也无需清理。9这里QT4和QT3有不同，QT3中用的是setmainwidget函数，但是这个函数不作为里面QOBJECT的父亲，所以QT3中这个顶层的QOBJECT要自行销毁）。

3.这是有人可能会问那如果我自行delete掉这些QT接管负责销毁的指针了会出现什么情况呢，如果时这样的话，正常情况下QT的拥有这个对象的那个父亲会知道这件事情，它会直到它的儿子被你直接DELETE了，这样它会将这个儿子移出它的列表，并且重新构建显示内容，但是直接这样做时有风险的！也就是要说的下一条

4.当一个QOBJECT正在接受事件队列时如果中途被你DELETE掉了，就是出现问题了，所以QT中建议大家不要直接DELETE掉一个QOBJECT，如果一定要这样做，要使用QOBJECT的deleteLater()函数，它会让所有事件都发送完一切处理好后马上清除这片内存，而且就算调用多次的deletelater也不会有问题。

5.QT不建议在一个QOBJECT 的父亲的范围之外持有对这个QOBJECT的指针，因为如果这样外面的指针很可能不会察觉这个QOBJECT被释放，会出现错误，如果一定要这样，就要记住你在哪这样做了，然后抓住那个被你违规使用的QOBJECT的destroyed（）信号，当它没有时赶快置零你的外部指针。当然我认为这样做是及其麻烦也不符合高效率编程规范的，所以如果要这样在外部持有QOBJECT的指针，建议使用引用或者用智能指针，如QT就提供了智能指针针对这些情况，见最后一条。

6.QT中的智能指针封装为QPointer类，所有QOBJECT的子类都可以用这个智能指针来包装，很多用法与普通指针一样，可以详见QT assistant

转自:http://blog.csdn.net/leonwei/article/details/3703598

天下 2012-08-31 15:28 发表评论

QFileSystemModel+QTableView

天下 — Thu, 30 Aug 2012 03:13:00 GMT

//main.cpp
#include <QtGui/QtGui>
#include <QtGui/QDirModel>
#include <QtGui/QListView>
#include <QtGui/QTableView>
#include <QtGui/QTreeView>

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

    QFileSystemModel model; //如果用QDirModel model; 展开树时,太慢

    //QListView list;
    QTreeView tree;
    QTableView table;
    QSplitter* spliter = new QSplitter;

    //model.setRootPath("");
    model.setRootPath("");
    //model.setRootIndex();
    tree.setModel(&model);
    //list.setModel(&model);
    table.setModel(&model);

    //tree.setSelectionMode(QAbstractItemView::MultiSelection);
    tree.setSelectionMode(QAbstractItemView::SingleSelection);
    //list.setSelectionMode(tree.selectionMode());
    table.setSelectionMode(tree.selectionMode());

    //QObject::connect(&tree,SIGNAL(doubleClicked(QModelIndex)),&list,
    //    SLOT(setRootIndex(QModelIndex)));
    QObject::connect(&tree,SIGNAL(clicked(QModelIndex)),&table,
        SLOT(setRootIndex(QModelIndex)));

    spliter->addWidget(&tree);
    //spliter->addWidget(&list);
    spliter->addWidget(&table);
    spliter->show();

    return app.exec();
}

天下 2012-08-30 11:13 发表评论

QT学习笔记（6）：QUiLoader使用

天下 — Tue, 28 Aug 2012 01:46:00 GMT

//QUiLoader使用
//main.cpp
#include <QtGui/Qtgui>
#include <QtGui/QLabel>
#include <QtUiTools/QUiLoader>

int main( int argc, char **argv )
{
    QApplication a( argc, argv );
    QUiLoader uiLoader;
    QFile file("MyDialog.ui");

    QWidget* pWidget = uiLoader.load(&file);

    if (pWidget==NULL)
    {
        QMessageBox::warning(NULL,"error","load MyDialog.ui error",QMessageBox::Ok);
        return 0;
    }
    //void QWidget::showNormal () [slot]
    QPushButton* pBtnOk = pWidget->findChild<QPushButton*>("okButton");
    if (pBtnOk!=NULL)
    {
        QMessageBox::information(NULL,"Hint","Find okButton Success",QMessageBox::Ok);
    }
    pWidget->showNormal();

    //pWidget->show();
    return a.exec();
}

天下 2012-08-28 09:46 发表评论

QT学习笔记（4）：QTableview使用

天下 — Mon, 27 Aug 2012 02:57:00 GMT

//QTableview使用笔记
//main.cpp
#include <QtGui/QApplication>
#include <QtGui/QLabel>
#include <QtGui/QMainWindow>
#include <QtGui/QVBoxLayout>
#include <QtGui/QPushButton>
#include <QProgressDialog>
#include <QDebug>
#include <QStringListModel>
#include <QtGui/QListView>
#include <QtGui/QListWidget>
#include <QtGui/QLabel>
#include <QStandardItem>
#include <QTableView>
#include <QStandardItemModel>
#include <QHeaderView>

//#include "MyDialog.h"

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

    QStandardItemModel *model = new QStandardItemModel;

    QTableView* pTableView = new QTableView;
    model->setColumnCount(2);    // 设置列数

    //设置列标题
    model->setHeaderData(0,Qt::Horizontal,"ID");
    model->setHeaderData(1,Qt::Horizontal,"NAME");
    //for (int i = 0; i < 2; i++)
    //{
    //    model->setItem(i,0,new QStandardItem(QString("%1").arg(i+1)) );
    //    model->setItem(i,1,new QStandardItem(QString("Aaron%1").arg(i)));
    //}


    /*
    //相同效果
    QStandardItem *item;
    QList items;
    for (int i = 0; i < 2; i++)
    {
        items.clear();
        item = new QStandardItem("Aaron");
        //item->setCheckable(true);
        items.push_back(item);
        item = new QStandardItem("12.21");
        items.push_back(item);
        model->appendRow(items);
    }
    */

    pTableView->setModel(model);

    //隐藏左边那列
    pTableView->verticalHeader()->hide();

    //设置某列隐藏
    //pTableView->setColumnHidden(0,true);

    //列宽
    pTableView->setColumnWidth(0,60);

    //整行选择
    pTableView->setSelectionBehavior(QAbstractItemView::SelectRows);

    pTableView->show();

    return app.exec();

}

天下 2012-08-27 10:57 发表评论

QT学习笔记（3）：Qt Designer设计ui及对话框使用

天下 — Sun, 26 Aug 2012 02:11:00 GMT

1）在qt工程中的Form Files，添加MyDialog.ui，对话框的对象名为MyDialog。
2）添加1个pushButton，在Qt Designer添加信号clicked()及槽slot1()
这时，我们可以看到Qt Designer会帮我们生成 ui_MyDialog.h
//在ui_MyDialog.h文件中，注意这里，这是Qt Designer生成的代码
QObject::connect(pushButton, SIGNAL(clicked()), MyDialog, SLOT(slot1()));

3.添加对应的类，并实现槽slot1()
详见附件：
/Files/aaxron/qt_deom05.rar

也可以这样:
使用Qt设计师利用布局来设置好界面，生成.ui文件，然后使用uic -o XXX.h XXX.ui  来生成.h 文件，然后包含这个.h 文件，自定义一个类，继承这个.h中的类，并且继承QObject 的子类，公共继承可以使用ui中的所有的界面元素

//自定义类文件
#ifndef CellDialog_H_
#define CellDialog_H_

#include "ui_CellDialog.h"
#include <QtGui/QtGui>

class GoToCellDialog :public QDialog , Ui::GoToCellDialog
{
    Q_OBJECT
public:
    GoToCellDialog(QWidget *parent = 0);
private slots:
    void on_lineEdit_textChanged();
};

#endif

天下 2012-08-26 10:11 发表评论

QT学习笔记（2）:标准对话框的使用

天下 — Sun, 26 Aug 2012 02:10:00 GMT

QT学习笔记（2）:标准对话框的使用详见附件:
/Files/aaxron/qtdemo02.zip

天下 2012-08-26 10:10 发表评论

QT 的信号与槽机制(3)

天下 — Sat, 25 Aug 2012 02:52:00 GMT

QT 的信号与槽机制(3)
　　信号和槽是一种高级接口，应用于对象之间的通信，它是 QT 的核心特性。要正确的处理信号和槽，必须借助一个称为 moc（Meta Object Compiler）的 QT 工具，该工具是一个 C++ 预处理程序，它为高层次的事件处理自动生成所需要的附加代码。信号和槽能携带任意数量和任意类型的参数。我们可以将很多信号与单个的槽进行连接，也可以将单个的信号与很多的槽进行连接，（当这个信号被发射时，这些槽将会一个接一个地执行，但是它们执行的顺序将会是随机的、不确定的，我们不能人为地指定哪个先执行、哪个后执行。）甚至于将一个信号与另外一个信号相连接，这时无论第一个信号什么时候发射系统都将立刻发射第二个信号。总之，信号与槽构造了一个强大的部件编程机制。

信号（signals）

信号只需要在头文件中做声明，不需要在cpp中实现。放在QT自定义关键字signals下，在此之前一定要加上Q_OBJECT宏！

在编程中，一般使用的是控件内部定义好的信号。
如：QTreeWidget类下的 signals：
void    currentItemChanged ( QTreeWidgetItem * current, QTreeWidgetItem * previous )
void    itemActivated ( QTreeWidgetItem * item, int column )
void    itemChanged ( QTreeWidgetItem * item, int column )
void    itemClicked ( QTreeWidgetItem * item, int column )
void    itemCollapsed ( QTreeWidgetItem * item )
void    itemDoubleClicked ( QTreeWidgetItem * item, int column )
void    itemEntered ( QTreeWidgetItem * item, int column )
void    itemExpanded ( QTreeWidgetItem * item )
void    itemPressed ( QTreeWidgetItem * item, int column )
void    itemSelectionChanged ()

也可以自定义信号，并通过emit在代码中发射信号。

// ------------ sender.h -----------
class sender : public QObject
{
    Q_OBJECT

     public:
        void doSend();
    signals:
        void send(int);
};

// ------------ sender.cpp -----------
#include "sender.h"
void sender :: doSend()
{
    emit send(40);
}

槽（slots）

　　槽和普通的C++成员函数几乎是一样的（可以是虚函数，可以被重载，可以是public slots、protected slots、private slots，可以被其他C++成员函数直接调用；唯一不同的是：槽还可以和信号连接在一起，在这种情况下，信号被发射时，会自动调用这个槽。）槽不需要信号传过来的参数时，可以不要参数；但槽一旦要参数，其参数个数，类型，顺序必须要和对应的信号保持一致。另外，槽的参数不能有缺省值。

// ------------ receiver.h -----------
class receiver : public QObject
{
    Q_OBJECT

    public slots:
        void recv(int);
};

// ------------ Receiver.cpp -----------
void receiver :: recv(int n)
{
    qDebug()<<"recv number: "<<n<<endl;
}

关联信号和槽（connect）
可以使用QObject类的静态成员函数connect来建立信号的槽的关联

QObject::connect是静态函数,返回值bool类型.
static  bool QObject::connect ( const QObject * sender, const char * signal,const QObject * receiver, const char * member );

具体的调用为：connect(sender, SIGNAL(signal), receiver, SLOT(slot));   其中sender和receiver为QObject类对象的指针； SIGNAL宏和SLOT宏将信号的槽转换成字符串。

sender s;
receiver r;
QObject::connect(&s, SIGNAL(send(int)), &r, SLOT(recv(int)));

注：在connect函数中信号函数和槽函数若有参数，只能写出参数类型，而不能也将变量名写出；否则，连接会失败！

断开信号和槽（disconnect）

当信号和槽没有必要继续保持连接时，可以通过调用disconnect来断开它们。

static bool QObject::disconnect (const QObject * sender, const char * signal,  const Object * receiver, const char * slot)

有三种情况必须使用 disconnect() 函数：
（1）断开与某个对象相关联的任何对象。
    disconnect(sender, 0, 0, 0) ;
    //或者
    sender->disconnect();

（2）断开与某个特定信号的任何关联。
    disconnect(sender, SIGNAL(signal()), 0, 0);
    //或者
    sender->disconnect(SIGNAL(signal()));

（3）断开两个对象之间的关联。
    disconnect(sender, 0, receiver, 0);
    //或者
    sender->disconnect(receiver);

转自:

天下 2012-08-25 10:52 发表评论

QT 的信号与槽机制(2)

天下 — Sat, 25 Aug 2012 02:41:00 GMT

转自:http://www.cppblog.com/lovecpp666/articles/169108.html

Signals and Slots in Depth

(1) 信号和槽是Qt编程的一个重要部分。这个机制可以在对象之间彼此并不了解的情况下将它们的行为联系起来。

槽和普通的c++成员函数很像。它们可以是虚函数（virtual），也可被重载（overload），

可以是公有的（public），保护的（protective），也可是私有的（private），它们可以像任何c++成员函数

一样被调用，可以传递任何类型的参数。不同在于一个槽函数能和一个信号相连接，只要信号发出了，这个槽函

数就会自动被调用。

(2)connect函数语法如下：
connect(sender, SIGNAL(signal), receiver, SLOT(slot));
sender和receiver是QObject对象指针，

signal和slot是不带参数的函数原型。

SIGNALE()和SLOT()宏的作用是把他们转换成字符串。

(3)信号和槽实际使用中要考虑的一些规则：
1、一个信号可以连接到多个槽：
connect(slider, SIGNAL(valueChanged(int)),spinBox, SLOT(setValue(int)));
connect(slider, SIGNAL(valueChanged(int)),this, SLOT(updateStatusBarIndicator(int)));
当信号发出后，槽函数都会被调用，但是调用的顺序是随机的，不确定的。

2、多个信号可以连接到一个槽
connect(lcd, SIGNAL(overflow()), this, SLOT(handleMathError()));
connect(calculator, SIGNAL(divisionByZero()),this, SLOT(handleMathError()));
任何一个信号发出，槽函数都会执行。

3、一个信号可以和另一个信号相连
connect(lineEdit, SIGNAL(textChanged(const QString &)),
this, SIGNAL(updateRecord(const QString &)))；
第一个信号发出后，第二个信号也同时发送。除此之外，信号与信号连接上和信号和槽连接相同。

4、连接可以被删除
disconnect(lcd, SIGNAL(overflow()),this, SLOT(handleMathError()));
这个函数很少使用，一个对象删除后，Qt自动删除这个对象的所有连接。

(4)信号和槽函数必须有着相同的参数类型，这样信号和槽函数才能成功连接：
connect(ftp, SIGNAL(rawCommandReply(int, const QString &)),this, SLOT(processReply(int, const QString &)));

(5)如果信号里的参数个数多于槽函数的参数，多余的参数被忽略：
connect(ftp, SIGNAL(rawCommandReply(int, const QString &)),this, SLOT(checkErrorCode(int)));
如果参速类型不匹配，或者信号和槽不存在，在debug状态时，Qt会在运行期间给出警告。

如果信号和槽连接时包含了参数的名字，Qt将会给出警告。

(6)不仅有控件的信号和槽，信号和槽机制可以实现在任何从QObject继承的子类中。

1 class Employee : public QObject
2 {
3     Q_OBJECT
4 public:
5     Employee() { mySalary = 0; }
6     int salary() const { return mySalary; }
7 public slots:
8     void setSalary(int newSalary);
9 signals:
10     void salaryChanged(int newSalary);
11 private:
12     int mySalary;
13 };
14 void Employee::setSalary(int newSalary)
15 {
16     if (newSalary != mySalary) {
17         mySalary = newSalary;
18         emit salaryChanged(mySalary);
19     }
20 }
21

注意，只有newSalary != mySalary时才发出salary-Changed()信号，这样避免了死循环的出现。

天下 2012-08-25 10:41 发表评论

QT学习笔记（5）：进度条对话框

天下 — Fri, 24 Aug 2012 08:31:00 GMT

//MyWidget.h
#pragma once
#include <QWidget>
#include <QPushButton>

class MyWidget:public QWidget
{
    Q_OBJECT
public:
    MyWidget();
public:
    QPushButton m_btnQuit;
    QPushButton m_btnTest;

public slots:
    void runTestDialog();
};

//MyDialog.cpp
#include "MyDialog.h"

MyDialog::MyDialog(QWidget* parent,Qt::WindowFlags f)
    :QDialog(parent,f)
{
    m_pLayout    = new QGridLayout(this);
    this->setWindowTitle(tr("run Test Dialog"));
    //this->setFixedHeight(200);
    this->setFixedWidth(640);

    m_pbtnQuit = new QPushButton("Quit");
    m_pbtnTestQFileDialog = new QPushButton("Test QFileDialog");
    m_pbtnTestQFileDialog->setFixedWidth(150);

    m_pbtnTestQColorDialog = new QPushButton("Test QColorDialog");
    m_pbtnTestQFontDialog = new QPushButton("Test QFontDialog");

    m_pFrameColor = new QFrame;
    m_pFrameColor->setFrameShape(QFrame::Box);
    m_pFrameColor->setAutoFillBackground(true);

    m_pEditFile = new QLineEdit;
    //m_pEditFile->resize(200,20);


    m_pEditFont = new QLineEdit;
    m_pEditFont->setText( trUtf8("\xE5\xAD\x97\xE4\xBD\x93\xE6\xB5\x8B\xE8\xAF\x95 Font Test"));
    //m_pEditFont->setMinimumHeight(40);

    m_pLayout->addWidget(m_pbtnTestQFileDialog,0,0);
    m_pLayout->addWidget(m_pEditFile,0,1);

    m_pLayout->addWidget(m_pbtnTestQColorDialog,1,0);
    m_pLayout->addWidget(m_pFrameColor,1,1);

    m_pLayout->addWidget(m_pbtnTestQFontDialog,2,0);
    m_pLayout->addWidget(m_pEditFont,2,1);
    m_pLayout->addWidget(m_pbtnQuit,5,0);

    m_pLayout->setMargin(15);
    m_pLayout->setSpacing(10);

    connect(m_pbtnQuit,SIGNAL(clicked()),qApp,SLOT(quit()) );

    connect(m_pbtnTestQFileDialog,SIGNAL(clicked()),SLOT(TestQFileDialog()) );
    connect(m_pbtnTestQColorDialog,SIGNAL(clicked()),SLOT(TestQColorDialog()) );
    connect(m_pbtnTestQFontDialog,SIGNAL(clicked()),SLOT(TestQFontDialog()) );

}

void MyDialog::TestQFileDialog()
{
    QProgressDialog*  pDlg = new QProgressDialog(this);
    int nMax = 100001;
    pDlg->setLabelText("Test QProgressDialog");
    pDlg->setRange(0,nMax-1);
    //pDlg->setModal(false);
    pDlg->setAutoClose(true);
    pDlg->show();
    //pDlg->exec();

    for (int i=0;i<nMax;i++)
    {
        if (pDlg->wasCanceled())
        {
            qDebug() << pDlg->wasCanceled();
            break;
        }
        pDlg->setValue(i);
        qApp->processEvents();
        //if (i==50000)
        //{
        //    pDlg->close();
        //    break;
        //}
    }
    delete pDlg;
    //QString hello = tr("Hello");
    //QString world = tr("World");

    //QMessageBox::information(this,hello,world);

    //QString filename = QFileDialog::getOpenFileName(this,"Test QFileDialog","/","C++ files(*.cpp)");
    //m_pEditFile->setText(filename);
}

void MyDialog::TestQColorDialog()
{
    QColor color  = QColorDialog::getColor();
    if (color.isValid())
    {
        m_pFrameColor->setPalette(color);
    }
}
void MyDialog::TestQFontDialog()
{
    bool ok;
    QFont font = QFontDialog::getFont(&ok);
    if (ok)
    {
        //font.setPointSize(24);
        m_pEditFont->setFont(font);
    }
}

天下 2012-08-24 16:31 发表评论

QT 的信号与槽机制(1)

天下 — Fri, 24 Aug 2012 07:41:00 GMT

QT 的信号与槽机制(1)
信号
当某个信号对其客户或所有者发生的内部状态发生改变，信号被一个对象发射。只有定义过这个信号的类及其派生类能够发射这个信号。当一个信号被发射时，与其相关联的槽将被立刻执行，就象一个正常的函数调用一样。信号 - 槽机制完全独立于任何 GUI 事件循环。只有当所有的槽返回以后发射函数（emit）才返回。如果存在多个槽与某个信号相关联，那么，当这个信号被发射时，这些槽将会一个接一个地执行，但是它们执行的顺序将会是随机的、不确定的，我们不能人为地指定哪个先执行、哪个后执行。
信号的声明是在头文件中进行的，QT 的 signals 关键字指出进入了信号声明区，随后即可声明自己的信号。例如，下面定义了三个信号：
signals:
void mySignal();
void mySignal(int x);
void mySignalParam(int x,int y);

在上面的定义中，signals 是 QT 的关键字，而非 C/C++ 的。
接下来的一行 void mySignal() 定义了信号 mySignal，这个信号没有携带参数；
接下来的一行 void mySignal(int x) 定义了重名信号 mySignal，但是它携带一个整形参数，这有点类似于 C++ 中的虚函数。
从形式上讲信号的声明与普通的 C++ 函数是一样的，但是信号却没有函数体定义，另外，信号的返回类型都是 void，不要指望能从信号返回什么有用信息。
信号由 moc 自动产生，它们不应该在 .cpp 文件中实现。

槽
槽是普通的 C++ 成员函数，可以被正常调用，它们唯一的特殊性就是很多信号可以与其相关联。当与其关联的信号被发射时，这个槽就会被调用。槽可以有参数，但槽的参数不能有缺省值。
既然槽是普通的成员函数，因此与其它的函数一样，它们也有存取权限。槽的存取权限决定了谁能够与其相关联。同普通的 C++ 成员函数一样，槽函数也分为三种类型，即 public slots、private slots 和 protected slots。
public slots：在这个区内声明的槽意味着任何对象都可将信号与之相连接。这对于组件编程非常有用，你可以创建彼此互不了解的对象，将它们的信号与槽进行连接以便信息能够正确的传递。
protected slots：在这个区内声明的槽意味着当前类及其子类可以将信号与之相连接。这适用于那些槽，它们是类实现的一部分，但是其界面接口却面向外部。
private slots：在这个区内声明的槽意味着只有类自己可以将信号与之相连接。这适用于联系非常紧密的类。
槽也能够声明为虚函数，这也是非常有用的。
槽的声明也是在头文件中进行的。例如，下面声明了三个槽：
public slots:
    void mySlot();
    void mySlot(int x);
    void mySignalParam(int x,int y);


信号与槽的关联
通过调用 QObject 对象的 connect 函数来将某个对象的信号与另外一个对象的槽函数相关联，这样当发射者发射信号时，接收者的槽函数将被调用。该函数的定义如下：
static bool QObject::connect(const QObject *sender, const char *signal,const QObject *receiver, const char *method,Qt::ConnectionType type)


用信号signals和槽slots需注意的基本问题是：
在所有包含signal与slot的类的声明中:
1)在类class声明中必须加入Q_OBJECT
2)类的声明文件必须成单独保存一个到.h文件

天下 2012-08-24 15:41 发表评论

qt学习笔记（1）：重要点

天下 — Fri, 24 Aug 2012 07:39:00 GMT

qt学习笔记(1)

0.
C++中explicit关键字只对构造函数起作用，用来抑制隐式转换。

1.
改变整个应用程序的默认字体使用QApplication::setFont()

2.
用信号signals和槽slots需注意的基本问题是：
在所有包含signal与slot的类的声明中:
1)在类class声明中必须加入Q_OBJECT
2)类的声明文件必须成单独保存一个到.h文件

3.
QObject::connect是静态函数,返回值bool类型.
static bool QObject::connect ( const QObject * sender, const char * signal,const QObject * receiver, const char * member );

3.QT4中QWidget的构造函数:
explicit QWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);

4.Multiple Inheritance Requires QObject to Be First（多重继承QObject一定要放在前面）

5.moc不扩展宏，所以信号和槽的定义不能使用宏，包括connect的时候也不能用宏做信号和槽的名字以及参数
tr也不支持使用宏。

天下 2012-08-24 15:39 发表评论

qt对话框+线程小试

天下 — Thu, 22 Sep 2011 02:24:00 GMT

//thread.h
#pragma once
#define QT3_SUPPORT
#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <Qt/qapplication.h>
#include <Qt/qpushbutton.h>
#include <qmessagebox.h>
#include <Qt/qdialog.h>
#include <Qt/qthread.h>
#include <QString>

template<typename T>
class Thread : public QThread
{
public:
    Thread();
    ~Thread();
    void run();
    void setTObj(T* pobj);
public:
    int flag;
    unsigned int pos;
    T* pTObj;
};

template<typename T>
Thread<T>::Thread()
{
    flag = 1;
    pos =0;
}

template<typename T>
Thread<T>::~Thread()
{

}

template<typename T>
void Thread<T>::run()
{
    //QMessageBox::information( NULL, "Application name","Started.\n");
    QString strText;
    while(flag)
    {
        strText.sprintf("flag:%d",pos);
        pTObj->setWindowTitle(strText);
        pos++;
        QThread::msleep(500);
    }
}

template<typename T>
void Thread<T>::setTObj(T* pobj)
{
    pTObj = pobj;
}

//ProcessDialog.h
#pragma once
#define QT3_SUPPORT

#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <Qt/qapplication.h>
#include <Qt/qpushbutton.h>
#include <qmessagebox.h>
#include <Qt/qdialog.h>
#include <Qt/qthread.h>
#include <QString>
#include "Thread.h"

class ProcessDialog :public QDialog
{
    Q_OBJECT
public:
    ProcessDialog(QWidget* parent=0)
        :btnStop("Stop",this)
        ,btnWork("Work",this)
    {
        btnStop.setGeometry( 62, 40, 75, 30 );
        btnWork.setGeometry( 162,140, 75, 30 );

        threadA.setTObj(this);

        connect(&btnWork,SIGNAL( clicked()),this,SLOT(start()) );
        connect(&btnStop,SIGNAL( clicked()),this,SLOT(stop()) );
    }

public:
    QPushButton btnStop;
    QPushButton btnWork;
    private slots:
        void start()
        {
            btnWork.setText("Working");
            threadA.start();
            threadA.flag = 1;
        }
        void stop()
        {
            btnWork.setText("Work");
            threadA.flag = 0;
            //threadA.pos  = 0;
        }

private:
    Thread<ProcessDialog> threadA;
};

//main.cpp
#define QT3_SUPPORT
#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <Qt/qapplication.h>
#include <Qt/qpushbutton.h>
#include <qmessagebox.h>
#include <Qt/qdialog.h>
#include <Qt/qthread.h>
#include <QString>
#include "Thread.h"
#include "ProcessDialog.h"

int main( int argc, char **argv )
{
    QApplication app( argc, argv );
    ProcessDialog dlg;
    app.setMainWidget( &dlg );
    dlg.resize(640,480);
    dlg.setModal(true);
    dlg.exec();
    return app.exec();
}

天下 2011-09-22 10:24 发表评论