QObject类

Qt 3.0.5

previous page next page
主页 | 所有的类 | 主要的类 | 注释的类 | 分组的类 | 函数

QObject类参考

QObject类是所有Qt对象的基类。 详情请见……

#include <qobject.h>

继承了Qt。

被QAccel、QAccessibleObject、QAction、QApplication、QDataPump、QWidget、QCanvas、QStyle、QClipboard、QCopChannel、QDns、QLayout、QDragObject、QEditorFactory、QFileIconProvider、QNetworkProtocol、QServerSocket、QWSKeyboardHandler、QNetworkOperation、QNPInstance、QObjectCleanupHandler、QProcess、QSessionManager、QSignal、QSignalMapper、QSocket、QSocketNotifier、QSound、QSqlDatabase、QSqlDriver、QSqlForm、QStyleSheet、QTimer、QToolTipGroup、QTranslator、QUrlOperator、QValidator和QWSMouseHandler继承。

所有成员函数的列表。

公有成员

  • QObject ( QObject * parent = 0, const char * name = 0 )
  • virtual ~QObject ()
  • const char * className () const
  • QString tr ( const char * sourceText, const char * comment ) const
  • QString trUtf8 ( const char * sourceText, const char * comment ) const
  • QMetaObject * metaObject () const
  • virtual bool event ( QEvent * e )
  • virtual bool eventFilter ( QObject * watched, QEvent * e )
  • bool isA ( const char * clname ) const
  • bool inherits ( const char * clname ) const
  • const char * name () const
  • const char * name ( const char * defaultName ) const
  • virtual void setName ( const char * name )
  • bool isWidgetType () const
  • bool highPriority () const
  • bool signalsBlocked () const
  • void blockSignals ( bool block )
  • int startTimer ( int interval )
  • void killTimer ( int id )
  • void killTimers ()
  • QObject * child ( const char * objName, const char * inheritsClass = 0, bool recursiveSearch = TRUE )
  • const QObjectList * children () const
  • QObjectList * queryList ( const char * inheritsClass = 0, const char * objName = 0, bool regexpMatch = TRUE, bool recursiveSearch = TRUE ) const
  • virtual void insertChild ( QObject * obj )
  • virtual void removeChild ( QObject * obj )
  • void installEventFilter ( const QObject * obj )
  • void removeEventFilter ( const QObject * obj )
  • bool connect ( const QObject * sender, const char * signal, const char * member ) const
  • bool disconnect ( const char * signal = 0, const QObject * receiver = 0, const char * member = 0 )
  • bool disconnect ( const QObject * receiver, const char * member = 0 )
  • void dumpObjectTree ()
  • void dumpObjectInfo ()
  • virtual bool setProperty ( const char * name, const QVariant & value )
  • virtual QVariant property ( const char * name ) const
  • QObject * parent () const

公有槽

信号

静态公有成员

  • const QObjectList * objectTrees ()
  • bool connect ( const QObject * sender, const char * signal, const QObject * receiver, const char * member )
  • bool disconnect ( const QObject * sender, const char * signal, const QObject * receiver, const char * member )

属性

  • QCString name - 这个对象的名称

保护成员

静态保护成员

相关函数

  • void * qt_find_obj_child ( QObject * parent, const char * type, const char * name )

详细描述

QObject类是所有Qt对象的基类。

QObject是Qt对象模型的中心。这个模型的中心特征就是一种用于无缝对象通讯的被叫做信号和槽的非常强大的机制。你能够使用connect()把信号和槽连接起来并且可以用disconnect()来破坏这种连接。为了避免从不结束的通知循环，你可以调用blockSignals()临时地阻塞信号。保护函数connectNotify()和disconnectNotify()使跟踪连接成为可能。

QObject把它们自己组织在对象树中。当你创建一个QObject作为其它对象的父对象，这个对象会在父对象中自动调用insertChild()并且可以在父对象的children()列表中显示出来。父对象拥有这个对象，比如，它将在它的析构函数中自动删除它的孩子。你可以使用child()或者queryList()通过名称和任意的类型来查找一个对象，并且使用objectTrees()来获得树根的列表。

每个对象都有一个对象名称（name()），能够报告它的类名（className()）并且它在QObject继承层次中是否继承了另一个类（inherits()）。

当对象被删除时，它发射destroyed()信号。你可以捕获这个信号来避免对QObject的摇摆引用。QGuardedPtr类提供了一种文雅的方式来使用这个机制。

QObject可以通过event()接收事件并且过滤其它对象的事件。详细情况请参考installEventFilter()和eventFilter()。一个方便的处理者，childEvent()，能够被重新实现来捕获子对象事件。

最后但不是最不重要的一点，QObject提供了Qt中最基本的定时器，关于定时器的高级支持请参考QTimer。

注意Q_OBJECT宏对于任何实现信号、槽和属性的对象都是强制的。你也需要对源文件运行moc程序（元对象编译器）。我们强烈建议在QObject的所有子类中使用这个宏，而不管它是不是实际使用了信号、槽和属性，因为不这样做也许会导致普通函数会出现为定义的问题。

所有的Qt窗口部件继承了QObject。方便的函数isWidgetType()返回这个对象实际上是不是一个窗口部件。它比inherits( "QWidget" )快得多。

一些QObject函数，比如children()、objectTrees()和queryList()返回一个QObjectList。QObjectList是QObject的QPtrList。QObjectLists支持像QPtrLists同样的操作并且又一个迭代器类QObjectListIt。

也可以参考对象模型。

成员函数文档

QObject::QObject ( QObject * parent = 0, const char * name = 0 )

构造一个父对象为parent，叫做name的对象。

对象的父对象也许可以看做这个对象的所有者。例如，一个对话框是它包含的“OK”和“Cancel”按钮的父对象。

父对象的析构函数销毁所有的子对象。

设置parent为0时，构造一个没有父对象的对象。如果一个对象是窗口部件，它将会成为一个顶级窗口。

对象名称就是可以用来识别一个QObject的一些文本。它在和Qt设计器联合使用的时候特别有用。你可以使用child()来通过名称（和类型）找到一个对象。使用queryList()可以找到几个对象。

也可以参考parent()、name、child()和queryList()。

QObject::~QObject () [虚]

销毁这个对象，删除它的所有子对象。

到这个对象的信号和从这个对象发出的信号被自动地取消连接。

警告：所有子对象被删除。如果这些对象中的任何一个在栈中或者是全局的，迟早或稍后你的程序将会崩溃。我们不建议在父对象的外面保存值对象的指针。如果你要这么做，当对象销毁时，QObject::destroyed()信号会给你一个机会来进行检测。

void QObject::blockSignals ( bool block )

如果block为真，阻塞信号，或者如果block为假，取消信号阻塞。

如果信号被阻塞，被发射的信号消失在超空间。

实例：rot13/rot13.cpp。

bool QObject::checkConnectArgs ( const char * signal, const QObject * receiver, const char * member ) [虚 保护]

如果signal和member参数是协调的，返回真，否则返回假。（receiver参数通常被忽略。）

警告：我们建议你使用默认实现不要再重新实现这个函数。

QObject * QObject::child ( const char * objName, const char * inheritsClass = 0, bool recursiveSearch = TRUE )

搜索这个对象的子对象和任意的孙子对象，并且返回继承inheritsClass的被叫做objName的子对象。如果inheritsClass为0（默认），任何类都可以匹配。

如果recursiveSearch为真（默认），child()执行的是一个对于对象的子孙深度优先的搜索。

如果没有这样的对象，这个函数返回0。如果超过一个，所找到的第一个被返回，如果你需要它们的全部，使用queryList()。

void QObject::childEvent ( QChildEvent * ) [虚 保护]

这个事件处理器在子类中可以被重新实现来接收子对象事件。

当子对象被插入或移除，子对象事件被发送给对象。

注意事件类型（QEvent::type()）为QEvent::ChildInserted的事件被传递（通过QApplication::postEvent()）确认了子对象的构造函数在这个函数被调用之前已经完成。

如果子对象在被插入之后立即被移除，ChildInserted事件也许被抑制，但是ChildRemoved事件总是被发送。在这种情况下，一个ChildRemoved事件没有一个相对应的ChildInserted事件是可能的。

如果你基于ChildInserted事件改变状态，调用QWidget::constPolish()，或者在基于这种状态的函数中执行 

        QApplication::sendPostedEvents( this, QEvent::ChildInserted );
一个著名的实例就是QWidget::sizeHint()。

也可以参考event()和QChildEvent。

在QMainWindow和QSplitter中被重新实现。

const QObjectList * QObject::children () const

返回子对象的列表，或者如果这个对象没有子对象返回0。

QObjectList类在qobjectlist.h头文件中被定义。

第一个子对象被添加为这个列表的第一个对象并且最后一个子对象被添加为这个列表的最后一个对象，比如，新的子对象被添加到列表的最后。

注意当QWidget子对象被升起或下降，列表的顺序会改变。一个被升起的窗口部件变为这个列表中的最后一个对象，并且一个被下降的窗口部件变为这个列表中的第一个对象。

也可以参考child()、queryList()、parent()、insertChild()和removeChild()。

const char * QObject::className () const

返回这个对象的类名。

这个函数是由元对象编译器生成的。

警告：如果类定义中缺少Q_OBJECT宏，这个函数就会返回错误的名称。

也可以参考name、inherits()、isA()和isWidgetType()。

实例：sql/overview/custom1/main.cpp。

bool QObject::connect ( const QObject * sender, const char * signal, const QObject * receiver, const char * member ) [静态]

把从sender对象发送的signal和receiver对象中的member连接起来，并且如果连接成功返回真，否则返回假。

你必须在说明signal和member的时候使用SIGNAL()和SLOT()两个宏，例如： 

    QLabel     *label  = new QLabel;
    QScrollBar *scroll = new QScrollBar;
    QObject::connect( scroll, SIGNAL(valueChanged(int)),
                      label,  SLOT(setNum(int)) );

这个实例确保了label总显示当前滚动条的值。

一个信号也可以被连接到另一个信号上： 

    class MyWidget : public QWidget
    {
        Q_OBJECT
    public:
        MyWidget();

    signals:
        void myUsefulSignal();

    private:
        QPushButton *aButton;
    };

    MyWidget::MyWidget()
    {
        aButton = new QPushButton( this );
        connect( aButton, SIGNAL(clicked()), SIGNAL(myUsefulSignal()) );
    }

在这个实例中，MyWidget的构造函数传递一个来自私有成员变量的信号，并且使它在MyWidget的一个相关名称下可用。

一个信号可以被连接到多个槽和信号上。多个信号可以被连接到一个槽上。

如果一个信号被连接到几个槽上，当信号被发射的时候，槽被激活的顺序是任意的。

如果信号和槽被成功连接，返回真。如果它不能创建连接，返回假，例如，如果QObject不能检验signal或member的存在，或者如果它们的标签不协调。

也可以参考disconnect()。

实例：action/actiongroup/editor.cpp、action/main.cpp、addressbook/main.cpp、application/main.cpp、iconview/main.cpp、mdi/main.cpp和t2/main.cpp。

bool QObject::connect ( const QObject * sender, const char * signal, const char * member ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

把从sender对象发送的signal和这个对象的member连接起来。

等于：QObject::connect(sender, signal, this, member)。

也可以参考disconnect()。

void QObject::connectNotify ( const char * signal ) [虚 保护]

当某个东西被连接到这个对象的signal时，这个虚函数被调用。

警告：这个函数违反了模块的面向对象的原则。不管如何，当你需要在某个东西连接到一个信号时执行昂贵的初始化时，这也许很有用。

也可以参考connect() and disconnectNotify().

void QObject::customEvent ( QCustomEvent * ) [虚 保护]

这个事件处理器可以在子类中重新实现来接收自定义事件。自定义事件就是至少类型值为QEvent::Type枚举变量中的“User”项的用户定义的事件，并且通常为QCustomEvent或QCustomEvent的子类。

也可以参考event()和QCustomEvent。

void QObject::deleteLater () [槽]

执行这个对象的延期删除。

不是立即删除，这个函数当Qt返回主事件循环时延期执行删除事件的处理。

void QObject::destroyed () [信号]

在对象被销毁之前，这个信号被立即发射。

在这个信号被发射之后，所有这个对象的子对象都被销毁。

void QObject::destroyed ( QObject * obj ) [信号]

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

在obj对象被销毁之前，这个信号被立即发射。

在这个信号被发射之后，所有这个对象的子对象都被销毁。

bool QObject::disconnect ( const QObject * sender, const char * signal, const QObject * receiver, const char * member ) [静态]

取消从sender对象发送的signal和对象receiver中的member的连接。

当这两个有关对象中的一个被销毁时，这个信号——槽连接就被移除了。

disconnect()通常被用在三种方式下，正如下面的例子所描述的。

  1. 取消连接到一个对象的信号的任何事物： 
           disconnect( myObject, 0, 0, 0 );
    等于非静态重载函数 
           myObject->disconnect();
  2. 取消连接到一个特定信号的任何事物： 
           disconnect( myObject, SIGNAL(mySignal()), 0, 0 );
    等于非静态重载函数 
           myObject->disconnect( SIGNAL(mySignal()) );
  3. 取消一个特定接收者的所有连接： 
           disconnect( myObject, 0, myReceiver, 0 );
    等于非静态重载函数 
           myObject->disconnect(  myReceiver );

0可以用做一个通配符，意义可能分别为“任何信号”、“任何接受对象”或者“一个接受对象中的任何槽”。

sender不能为0。（你不能在一个调用中取消来自多于一个对象的信号的连接。）

如果signal为0，它取消所有和这个对象的信号连接的receiver和member。如果不是，只由特定信号被取消联接。

如果receiver为0，它取消连接到signal的任何事物。如果不是，只有receiver中的槽被取消连接。

如果member为0，它取消连接到receiver的任何事物。如果不是，只有名为member的槽被取消联接并且其它所有槽被保留。如果receiver被省去，member必须为0，所以你不能取消所有对象中同一特定名称槽的连接。

也可以参考connect()。

bool QObject::disconnect ( const char * signal = 0, const QObject * receiver = 0, const char * member = 0 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

取消和receiver中member连接的signal。

当这两个有关对象中的一个被销毁时，这个信号——槽连接就被移除了。

bool QObject::disconnect ( const QObject * receiver, const char * member = 0 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

取消和receiver中member连接的这个信号中的所有信号。

当这两个有关对象中的一个被销毁时，这个信号——槽连接就被移除了。

void QObject::disconnectNotify ( const char * signal ) [虚 保护]

当和这个对象的signal连接的某个事物已经被取消联接时，这个虚函数被调用。

警告：这个函数违反了模块的面向对象的原则。不管如何，在对昂贵的资源访问进行最优化时，这个也许很有用处。

也可以参考disconnect() and connectNotify().

void QObject::dumpObjectInfo ()

调试输出这个对象的关于信号连接的消息等等。

在调试的时候这个函数很有用，但是如果库是在发布模式下（例如，没有任何调试信息）被编译的，它就不会做任何事情。

void QObject::dumpObjectTree ()

调试输出子对象树。

在调试的时候这个函数很有用，但是如果库是在发布模式下（例如，没有任何调试信息）被编译的，它就不会做任何事情。

bool QObject::event ( QEvent * e ) [虚]

这个虚函数会接收到一个对象的事件并且应该在e事件被识别和处理时返回真。

event()可以被重新实现来定义一个对象的行为。

也可以参考installEventFilter()、timerEvent()、QApplication::sendEvent()、QApplication::postEvent()和QWidget::event()。

在QWidget中被重新实现。

bool QObject::eventFilter ( QObject * watched, QEvent * e ) [虚]

如果这个对象已经被安装为watched对象的一个事件过滤器，就过滤事件。

在这个函数你的重新实现中，如果你想过滤出e事件，比如，停止它的进一步处理，返回真，否则返回假。

警告：如果你在这个函数中删除接收对象，请确认返回真。否则，Qt会把这个事件转给被删除的对象并且程序也许会崩溃。

也可以参考installEventFilter()。

在QAccel、QScrollView和QSpinBox中被重新实现。

bool QObject::highPriority () const

如果对象是一个高优先权的对象，返回真，或者如果它是一个标准优先权的对象，返回假。

高优先权对象被放置到QObject的子对象列表的开始，假设它们将被更频繁地引用。

bool QObject::inherits ( const char * clname ) const

如果这个对象是继承clname的类的实例，并且clname继承QObject，那么返回真，否则返回假。

一个类可以被认为继承了它自己。

实例： 

        QTimer *t = new QTimer;         // QTimer继承QObject
        t->inherits( "QTimer" );        // 返回TRUE
        t->inherits( "QObject" );       // 返回TRUE
        t->inherits( "QButton" );       // 返回FALSE

        // QScrollBar继承QWidget和QRangeControl
        QScrollBar *s = new QScrollBar( 0 );
        s->inherits( "QWidget" );       // 返回TRUE
        s->inherits( "QRangeControl" ); // 返回FALSE

（QRangeControl不是一个QObject。）

也可以参考isA()和metaObject()。

实例：table/statistics/statistics.cpp、themes/metal.cpp和themes/wood.cpp。

void QObject::insertChild ( QObject * obj ) [虚]

插入对象obj到子对象列表中。

警告：这个函数不能被用来把一个窗口部件变为另一个窗口部件的子窗口部件。子窗口部件只能通过在构造函数中的父窗口部件参数设置来被创建或者通过调用QWidget::reparent()。

也可以参考removeChild()和QWidget::reparent()。

void QObject::installEventFilter ( const QObject * obj )

安装事件过滤器obj到这个对象。

事件过滤器就是接收所有被发送到这个对象的事件的对象。这个过滤器可以停止事件或者把它再转给这个对象。事件过滤器obj通过它的eventFilter()函数来接收事件。如果事件被过滤了（比如，停止了），eventFilter()函数必须返回真，否则它必须返回假。

如果有多个事件过滤器被安装到同一个对象上，最后一个被安装的事件过滤器将先被激活。

实例： 

    #include <qwidget.h>

    class MyWidget : public QWidget
    {
        Q_OBJECT
    public:
        MyWidget( QWidget *parent = 0, const char *name = 0 );

    protected:
        bool eventFilter( QObject *, QEvent * );
    };

    MyWidget::MyWidget( QWidget *parent, const char *name )
        : QWidget( parent, name )
    {
        // 为父对象（如果有的话）安装一个过滤器
        if ( parent )
            parent->installEventFilter( this );
    }

    bool MyWidget::eventFilter( QObject *o, QEvent *e )
    {
        if ( e->type() == QEvent::KeyPress ) {
            // 对于键被按下进行特殊处理
            QKeyEvent *k = (QKeyEvent *)e;
            qDebug( "Ate key press %d", k->key() );
            return TRUE; // 吃掉了这个事件
        } else {
            // 标准事件处理
            return QWidget::eventFilter( o, e );
        }
    }

例如，QAccel类使用这种技术来截取快捷键被按下。

警告：如果在你的eventFilter()函数中你删除了接收对象，请确认返回真。否则，Qt会把这个事件转给被删除的对象并且程序也许会崩溃。

也可以参考removeEventFilter()、eventFilter()和event()。

bool QObject::isA ( const char * clname ) const

如果这个对象是clname类的实例，返回真，否则返回假。

实例： 

    QTimer *t = new QTimer; // QTimer继承QObject
    t->isA( "QTimer" );     // 返回TRUE
    t->isA( "QObject" );    // 返回FALSE

也可以参考inherits()和metaObject()。

bool QObject::isWidgetType () const

如果这个对象是一个窗口部件，返回真，否则返回假。

调用这个函数等于调用inherits("QWidget")，但这个函数要快很多。

void QObject::killTimer ( int id )

通过定时器标识符id删除定时器。

当一个定时器事件开始时，定时器标识符由startTimer()返回。

也可以参考timerEvent()、startTimer()和killTimers()。

void QObject::killTimers ()

删除这个对象中已经开始的所有定时器。

警告：使用这个函数可能导致很难找到的bug：它会删除你在子类和超类中开始的定时器，这通常不是你所想要的。我们建议使用QTimer或者killTimer()。

也可以参考timerEvent()、startTimer()和killTimer()。

QMetaObject * QObject::metaObject () const

返回这个对象的元对象的指针。

元对象包含关于一个继承QObject的类的一些信息，比如，类名称、超类名称、属性、信号和槽。每个包含Q_OBJECT宏的类也都会有一个元对象。

在信号/槽连接机制和属性系统中需要元对象信息。函数isA()和inherits()也使用元对象。

const char * QObject::name () const

返回这个对象的名称。详细情况请参考“name”属性。

const char * QObject::name ( const char * defaultName ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

返回这个对象的名称，或者如果这个对象没有名称返回defaultName。

QCString QObject::normalizeSignalSlot ( const char * signalSlot ) [静态 保护]

通过删除不是必需的控制符号来普通化信号或槽定义signalSlot。

const QObjectList * QObject::objectTrees () [静态]

返回所有对象树的列表的指针（它们的根对象），或者如果没有对象返回0。

QObjectList类在qobjectlist.h头文件中被定义。

最近的根对象被创建为列表中的第一个对象并且第一个根对象被添加为列表的最后一个对象。

也可以参考children()、parent()、insertChild()和removeChild()。

QObject * QObject::parent () const

返回父对象的指针。

也可以参考children()。

QVariant QObject::property ( const char * name ) const [虚]

返回对象的name属性的值。

如果没有这样一个属性存在，返回变量是无效的。

关于所有可用属性的信息通过metaObject()提供。

也可以参考setProperty()、QVariant::isValid()、metaObject()、QMetaObject::propertyNames()和QMetaObject::property()。

QObjectList * QObject::queryList ( const char * inheritsClass = 0, const char * objName = 0, bool regexpMatch = TRUE, bool recursiveSearch = TRUE ) const

搜索这个对象的子对象和任意的子孙对象，并且返回继承inheritsClass的名称为objName的对象的列表。如果inheritsClass为0（默认），任何类都可以匹配。如果objName为0（默认），所有的对象名称都可以匹配。

如果regexpMatch为真（默认），objName是一个对象名称必须匹配的正则表达式。语法规则就是QRegExp。如果regexpMatch为假，objName就是对象名称必须正确匹配的字符串。

注意inheritsClass使用从QObject的单继承，方式和inherits()中的一样。根据inherits()，QMenuBar继承了QWidget，而不是QMenuData。这样也许和真是情况不太一致，但是这是使Qt能够支持更多种类编译器的最好方法。

最后，如果recursiveSearch为真（默认），queryList()就像第一代子对象那样搜索n代子孙对象。

如果所有这些看起来都比你需要的要复杂，更简单的函数child()也许是你想要的。

这里是一个人为的实例来使这个窗口中的所有按钮失效： 

    QObjectList *l = topLevelWidget()->queryList( "QButton" );
    QObjectListIt it( *l ); // 遍历按钮
    QObject *obj;

    while ( (obj = it.current()) != 0 ) {
        // 对于每一个找到的对象……
        ++it;
        ((QButton*)obj)->setEnabled( FALSE );
    }
    delete l; // 删除这个列表，而不是对象

QObjectList类在qobjectlist.h头文件中被定义。

警告：你使用这个列表完成之后，就删除它。这个列表中包含的指针也许会在任何你不注意的时候失效（例如，一旦用户关闭一个窗口，你也许就得到了一个摇摆的指针）。

也可以参考child()、children()、parent()、inherits()、name和QRegExp。

void QObject::removeChild ( QObject * obj ) [虚]

从子对象列表中移除obj对象。

警告：这个函数将不会从屏幕上移除一个子窗口部件。它仅仅是从父窗口部件的子对象列表中移除它。

也可以参考insertChild()和QWidget::reparent()。

void QObject::removeEventFilter ( const QObject * obj )

从这个对象中移除事件过滤器对象obj。如果事件过滤器没有被安装，这个要求将被忽略。

当这个对象被销毁时，这个对象的所有事件过滤器都会自动地被移除。

移除事件过滤器总是安全的，甚至在事件过滤器被激活期间（比如，从eventFilter()函数中）。

也可以参考installEventFilter()、eventFilter()和event()。

const QObject * QObject::sender () [保护]

如果在任何函数调用或信号发射之前在槽中调用的话，返回发送消息的对象的指针。在所有其它情况下，返回未定义的值。

警告：在其它一些情况下，这个函数也会返回一些显然正确的东西。无论如何，在任何函数调用期间，它的值可能发生变化，取决于这次调用中什么信号—槽连接被激活。在Qt 3.0中这个值的变化要比2.x下多得多。

警告：这个函数违反了模块的面相对象的原则。不管如何，当许多信号连接到一个单一的槽上的时候，获得访问的发送者也许很有用处。如果槽是被做为普通C++函数调用的话，发送者是未定义的。

void QObject::setName ( const char * name ) [虚]

设置对象的名称为name。

bool QObject::setProperty ( const char * name, const QVariant & value ) [虚]

设置对象的name属性值为value。

如果操作成功，返回真，否则返回假。

关于所有可用属性的信息通过metaObject()提供。

也可以参考property()、metaObject()、QMetaObject::propertyNames()和QMetaObject::property()。

bool QObject::signalsBlocked () const

如果信号被阻塞，返回真，否则返回假。

默认情况下，信号不被阻塞。

也可以参考blockSignals()。

int QObject::startTimer ( int interval )

定时器开始计时并且返回一个定时器标识符，或者如果不能开始计时，返回0。

每interval毫秒出现一个定时器事件直到killTimer()或killTimers()被调用。如果interval为0，那么定时器事件将在每次没有窗口系统事件要处理的情况下出现。

当定时器事件发生时，虚函数timerEvent()被调用为QTimerEvent事件参数类。重新实现这个函数可以获得定时器事件。

如果多个定时器在运行，QTimerEvent::timerId()可以用来找到那个定时器被激活。

实例： 

    class MyObject : public QObject
    {
        Q_OBJECT
    public:
        MyObject( QObject *parent = 0, const char *name = 0 );

    protected:
        void timerEvent( QTimerEvent * );
    };

    MyObject::MyObject( QObject *parent, const char *name )
        : QObject( parent, name )
    {
        startTimer( 50 );    // 50微妙定时器
        startTimer( 1000 );  // 1秒定时器
        startTimer( 60000 ); // 1分钟定时器
    }

    void MyObject::timerEvent( QTimerEvent *e )
    {
        qDebug( "timer event, id %d", e->timerId() );
    }

实际上没有间隔值的上限（超过1年也可以）。注意QTimer的精确度依赖与底下的操作系统和硬件。绝大多数平台都支持20毫秒的精确度，一些平台可以提供更精确的。如果Qt不能发送定时器滴答所要求的数量，它将会默默地丢弃一些。

QTimer类提供了单触发定时器和替代事件的定时器信号的高级编程接口。

也可以参考timerEvent()、killTimer()和killTimers()。

void QObject::timerEvent ( QTimerEvent * ) [虚 保护]

这个信号处理者可以在子类中重新实现而接收对象的定时器事件。

QTimer提供了定时器功能的高级接口，并且提供了关于定时器的更多说明。

也可以参考startTimer()、killTimer()、killTimers()和event()。

实例：biff/biff.cpp、dclock/dclock.cpp、forever/forever.cpp、grapher/grapher.cpp、qmag/qmag.cpp和xform/xform.cpp。

QString QObject::tr ( const char * sourceText, const char * comment ) const

返回sourceText的翻译版本，或者如果没有合适的版本返回sourceText它自己。翻译上下文是comment的QObject（默认为空）。所有使用Q_OBJECT宏的QObject对象有这个函数的重新实现，把子类名作为上下文。

也可以参考trUtf8()、QApplication::translate()和Qt中的国际化。

实例：network/networkprotocol/view.cpp。

QString QObject::trUtf8 ( const char * sourceText, const char * comment ) const

返回sourceText的翻译版本，或者如果没有合适的版本返回QString::fromUtf8(sourceText)。它是另一种tr(sourceText, comment)。

也可以参考tr()和QApplication::translate()。

属性文档

QCString name

这个属性保存的是这个对象的名称。

你可以通过名称（和类型）使用child()来找到一个对象。你可以通过queryList()来找到一系列对象。

对象名称可以通过构造函数或者setName()函数设置。对象名称在当前版本的Qt中不是非常有用，但是将在未来变得越来越重要。

如果对象没有名称，name()函数返回“unnamed”，所以printf()（在qDebug()中被使用）将不会被请求输出一个空指针。如果你希望没有名称的对象返回空指针，你可以调用name( 0 )。 

        qDebug( "MyClass::setPrecision(): (%s) invalid precision %f",
                name(), newPrecision );

也可以参考className()、child()和queryList()。

通过setName()可以设置属性值并且通过name()来获得属性值。

相关函数

void * qt_find_obj_child ( QObject * parent, const char * type, const char * name )

返回一个继承了parent对象类型为type的名为name的对象的指针。

如果没有这样的对象，返回0。 

        QListBox *c = (QListBox *) qt_find_obj_child( myWidget, "QListBox",
                                                      "my list box" );
        if ( c )
            c->insertItem( "another string" );

这个文件是Qt工具包一部分。 版权所有 © 1995-2002 Trolltech。保留所有权利。

Copyright © 2002 Trolltech Trademarks 译者:Cavendish
Qt 3.0.5版

previous page start next page