Results 1 to 7 of 7

Thread: QCoreApplication::postEvent: Unexpected null receiver while running application

  1. #1
    Join Date
    Sep 2015
    Posts
    6
    Qt products
    Qt5
    Platforms
    Unix/X11

    Default QCoreApplication::postEvent: Unexpected null receiver while running application

    Hi all,

    Upon running my QT application, I am seeing the following Unexpected null receiver error. What is this error?

    QCoreApplication:ostEvent: Unexpected null receiver
    file:///home/andy/Qt/5.3/gcc_64/qml/QtQuick/Controls/ApplicationWindow.qml: Conflicting properties 'visible' and 'visibility' for Window 'root'

    The error also mentions something about conflicting 'visible' and 'visibility' properties in ApplicationWindow.qml

    Can someone please explain what could be going on?

    Thanks.

  2. #2
    Join Date
    Jan 2006
    Location
    Graz, Austria
    Posts
    8,419
    Thanks
    37
    Thanked 1,546 Times in 1,496 Posts
    Qt products
    Qt3 Qt4 Qt5
    Platforms
    Unix/X11 Windows

    Default Re: QCoreApplication::postEvent: Unexpected null receiver while running application

    Looks like you accidentally forgot to post the code of your ApplicationWindow using QML file.

    Cheers,
    _

  3. #3
    Join Date
    Sep 2015
    Posts
    6
    Qt products
    Qt5
    Platforms
    Unix/X11

    Default Re: QCoreApplication::postEvent: Unexpected null receiver while running application

    Sorry about that. Here is the code from ApplicationWindow.qml.

    /************************************************** **************************
    .....
    **
    ** $QT_END_LICENSE$
    **
    ************************************************** **************************/

    import QtQuick.Window 2.1
    import QtQuick 2.2
    import QtQuick.Controls 1.2
    import QtQuick.Layouts 1.0
    import QtQuick.Controls.Private 1.0

    /*!
    \qmltype ApplicationWindow
    \since 5.1
    \inqmlmodule QtQuick.Controls
    \ingroup applicationwindow
    \brief Provides a top-level application window.

    \image applicationwindow.png

    ApplicationWindow is a \l Window that adds convenience for positioning items,
    such as \l MenuBar, \l ToolBar, and \l StatusBar in a platform independent
    manner.

    \code
    ApplicationWindow {
    id: window
    visible: true

    menuBar: MenuBar {
    Menu { MenuItem {...} }
    Menu { MenuItem {...} }
    }

    toolBar: ToolBar {
    RowLayout {
    anchors.fill: parent
    ToolButton {...}
    }
    }

    TabView {
    id: myContent
    anchors.fill: parent
    ...
    }
    }
    \endcode

    \note By default, an ApplicationWindow is not visible.

    The \l{Qt Quick Controls - Gallery} example is a good starting
    point to explore this type.
    */

    Window {
    id: root

    /*!
    \qmlproperty MenuBar ApplicationWindow::menuBar

    This property holds the \l MenuBar.

    By default, this value is not set.
    */
    property MenuBar menuBar: null

    /*!
    \qmlproperty Item ApplicationWindow::toolBar

    This property holds the toolbar \l Item.

    It can be set to any Item type, but is generally used with \l ToolBar.

    By default, this value is not set. When you set the toolbar item, it will
    be anchored automatically into the application window.
    */
    property Item toolBar

    /*!
    \qmlproperty Item ApplicationWindow::statusBar

    This property holds the status bar \l Item.

    It can be set to any Item type, but is generally used with \l StatusBar.

    By default, this value is not set. When you set the status bar item, it
    will be anchored automatically into the application window.
    */
    property Item statusBar

    // The below documentation was supposed to be written as a grouped property, but qdoc would
    // not render it correctly due to a bug (https://bugreports.qt-project.org/browse/QTBUG-34206)
    /*!
    \qmlproperty ContentItem ApplicationWindow::contentItem

    This group holds the size constraints of the content item. This is the area between the
    \l ToolBar and the \l StatusBar.
    The \l ApplicationWindow will use this as input when calculating the effective size
    constraints of the actual window.
    It holds these 6 properties for describing the minimum, implicit and maximum sizes:
    \table
    \header \li Grouped property \li Description
    \row \li contentItem.minimumWidth \li The minimum width of the content item.
    \row \li contentItem.minimumHeight \li The minimum height of the content item.
    \row \li contentItem.implicitWidth \li The implicit width of the content item.
    \row \li contentItem.implicitHeight \li The implicit height of the content item.
    \row \li contentItem.maximumWidth \li The maximum width of the content item.
    \row \li contentItem.maximumHeight \li The maximum height of the content item.
    \endtable
    */
    property alias contentItem : contentArea

    /*! \internal */
    property real __topBottomMargins: contentArea.y + statusBarArea.height
    /*! \internal
    There is a similar macro QWINDOWSIZE_MAX in qwindow_p.h that is used to limit the
    range of QWindow::maximum{Width,Height}
    However, in case we have a very big number (> 2^31) conversion will fail, and it will be
    converted to 0, resulting in that we will call setMaximumWidth(0)....
    We therefore need to enforce the limit at a level where we are still operating on
    floating point values.
    */
    readonly property real __qwindowsize_max: (1 << 24) - 1

    /*! \internal */
    property real __width: 0
    Binding {
    target: root
    property: "__width"
    when: root.minimumWidth <= root.maximumWidth
    value: Math.max(Math.min(root.maximumWidth, contentArea.implicitWidth), root.minimumWidth)
    }
    /*! \internal */
    property real __height: 0
    Binding {
    target: root
    property: "__height"
    when: root.minimumHeight <= root.maximumHeight
    value: Math.max(Math.min(root.maximumHeight, contentArea.implicitHeight), root.minimumHeight)
    }
    width: contentArea.__noImplicitWidthGiven ? 0 : __width
    height: contentArea.__noImplicitHeightGiven ? 0 : __height

    minimumWidth: contentArea.__noMinimumWidthGiven ? 0 : contentArea.minimumWidth
    minimumHeight: contentArea.__noMinimumHeightGiven ? 0 : (contentArea.minimumHeight + __topBottomMargins)

    maximumWidth: Math.min(__qwindowsize_max, contentArea.maximumWidth)
    maximumHeight: Math.min(__qwindowsize_max, contentArea.maximumHeight + __topBottomMargins)
    onToolBarChanged: { if (toolBar) { toolBar.parent = toolBarArea } }

    onStatusBarChanged: { if (statusBar) { statusBar.parent = statusBarArea } }

    onVisibleChanged: { if (visible && menuBar) { menuBar.__parentWindow = root } }

    /*! \internal */
    default property alias data: contentArea.data

    color: SystemPaletteSingleton.window(true)

    flags: Qt.Window | Qt.WindowFullscreenButtonHint |
    Qt.WindowTitleHint | Qt.WindowSystemMenuHint | Qt.WindowMinMaxButtonsHint |
    Qt.WindowCloseButtonHint | Qt.WindowFullscreenButtonHint
    // QTBUG-35049: Windows is removing features we didn't ask for, even though Qt::CustomizeWindowHint is not set
    // Otherwise Qt.Window | Qt.WindowFullscreenButtonHint would be enough

    Item {
    id: backgroundItem
    anchors.fill: parent

    Keys.forwardTo: menuBar ? [menuBar.__contentItem] : []

    ContentItem {
    id: contentArea
    anchors.top: toolBarArea.bottom
    anchors.left: parent.left
    anchors.right: parent.right
    anchors.bottom: statusBarArea.top
    }

    Item {
    id: toolBarArea
    anchors.top: parent.top
    anchors.left: parent.left
    anchors.right: parent.right
    implicitHeight: childrenRect.height
    height: visibleChildren.length > 0 ? implicitHeight: 0
    }

    Item {
    id: statusBarArea
    anchors.bottom: parent.bottom
    anchors.left: parent.left
    anchors.right: parent.right
    implicitHeight: childrenRect.height
    height: visibleChildren.length > 0 ? implicitHeight: 0
    }

    onVisibleChanged: if (visible && menuBar) menuBar.__parentWindow = root

    states: State {
    name: "hasMenuBar"
    when: menuBar && !menuBar.__isNative

    ParentChange {
    target: menuBar.__contentItem
    parent: backgroundItem
    }

    PropertyChanges {
    target: menuBar.__contentItem
    x: 0
    y: 0
    width: backgroundItem.width
    }

    AnchorChanges {
    target: toolBarArea
    anchors.top: menuBar.__contentItem.bottom
    }
    }
    }
    }


    Added after 8 minutes:


    I also wanted to include the code from qquickwindowmodule.cpp which contains reference to the error message

    /************************************************** **************************
    **...........
    ** $QT_END_LICENSE$
    **
    ************************************************** **************************/

    #include "qquickwindowmodule_p.h"
    #include "qquickscreen_p.h"
    #include "qquickview_p.h"
    #include <QtQuick/QQuickWindow>
    #include <QtCore/QCoreApplication>
    #include <QtQml/QQmlEngine>

    #include <private/qguiapplication_p.h>
    #include <private/qqmlengine_p.h>
    #include <qpa/qplatformintegration.h>

    QT_BEGIN_NAMESPACE

    class QQuickWindowQmlImpl : public QQuickWindow, public QQmlParserStatus
    {
    Q_INTERFACES(QQmlParserStatus)
    Q_OBJECT

    Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
    Q_PROPERTY(Visibility visibility READ visibility WRITE setVisibility NOTIFY visibilityChanged)

    public:
    QQuickWindowQmlImpl(QWindow *parent = 0)
    : QQuickWindow(parent)
    , m_complete(false)
    , m_visible(isVisible())
    , m_visibility(AutomaticVisibility)
    {
    connect(this, &QWindow::visibleChanged, this, &QQuickWindowQmlImpl::visibleChanged);
    connect(this, &QWindow::visibilityChanged, this, &QQuickWindowQmlImpl::visibilityChanged);
    }

    void setVisible(bool visible) {
    if (!m_complete)
    m_visible = visible;
    else if (!transientParent() || transientParent()->isVisible())
    QQuickWindow::setVisible(visible);
    }

    void setVisibility(Visibility visibility)
    {
    if (!m_complete)
    m_visibility = visibility;
    else
    QQuickWindow::setVisibility(visibility);
    }

    Q_SIGNALS:
    void visibleChanged(bool arg);
    void visibilityChanged(QWindow::Visibility visibility);

    protected:
    void classBegin() {
    QQmlEngine* e = qmlEngine(this);
    //Give QQuickView behavior when created from QML with QQmlApplicationEngine
    if (QCoreApplication::instance()->property("__qml_using_qqmlapplicationengine") == QVariant(true)) {
    if (e && !e->incubationController())
    e->setIncubationController(incubationController()) ;
    }
    Q_ASSERT(e);
    {
    QV4::ExecutionEngine *v4 = QQmlEnginePrivate::getV4Engine(e);
    QV4::Scope scope(v4);
    QV4::ScopedObject v(scope, new (v4->memoryManager) QQuickRootItemMarker(e, this));
    rootItemMarker = v;
    }
    }

    void componentComplete() {
    m_complete = true;
    if (transientParent() && !transientParent()->isVisible()) {
    connect(transientParent(), &QQuickWindow::visibleChanged, this,
    &QQuickWindowQmlImpl::setWindowVisibility, Qt::QueuedConnection);
    } else {
    setWindowVisibility();
    }
    }

    private Q_SLOTS:
    void setWindowVisibility()
    {
    if (transientParent() && !transientParent()->isVisible())
    return;

    if (sender()) {
    disconnect(transientParent(), &QWindow::visibleChanged, this,
    &QQuickWindowQmlImpl::setWindowVisibility);
    }

    // We have deferred window creation until we have the full picture of what
    // the user wanted in terms of window state, geometry, visibility, etc.

    if ((m_visibility == Hidden && m_visible) || (m_visibility > AutomaticVisibility && !m_visible)) {
    QQmlData *data = QQmlData::get(this);
    Q_ASSERT(data && data->context);

    QQmlError error;
    error.setObject(this);

    const QQmlContextData* urlContext = data->context;
    while (urlContext && urlContext->url.isEmpty())
    urlContext = urlContext->parent;
    error.setUrl(urlContext ? urlContext->url : QUrl());

    QString objectId = data->context->findObjectId(this);
    if (!objectId.isEmpty())
    error.setDescription(QCoreApplication::translate(" QQuickWindowQmlImpl",
    "Conflicting properties 'visible' and 'visibility' for Window '%1'").arg(objectId));
    else
    error.setDescription(QCoreApplication::translate(" QQuickWindowQmlImpl",
    "Conflicting properties 'visible' and 'visibility'"));

    QQmlEnginePrivate::get(data->context->engine)->warning(error);
    }

    if (m_visibility == AutomaticVisibility) {
    setWindowState(QGuiApplicationPrivate::platformInt egration()->defaultWindowState(flags()));
    setVisible(m_visible);
    } else {
    setVisibility(m_visibility);
    }
    }

    private:
    bool m_complete;
    bool m_visible;
    Visibility m_visibility;
    QV4::PersistentValue rootItemMarker;
    };

    void QQuickWindowModule::defineModule()
    {
    const char uri[] = "QtQuick.Window";

    qmlRegisterType<QQuickWindow>(uri, 2, 0, "Window");
    qmlRegisterRevision<QWindow,1>(uri, 2, 1);
    qmlRegisterRevision<QWindow,2>(uri, 2, 2);
    qmlRegisterRevision<QQuickWindow,1>(uri, 2, 1);//Type moved to a subclass, but also has new members
    qmlRegisterRevision<QQuickWindow,2>(uri, 2, 2);
    qmlRegisterType<QQuickWindowQmlImpl>(uri, 2, 1, "Window");
    qmlRegisterUncreatableType<QQuickScreen>(uri, 2, 0, "Screen", QStringLiteral("Screen can only be used via the attached property."));
    }

    #include "qquickwindowmodule.moc"

    QT_END_NAMESPACE
    Last edited by karpt; 28th September 2015 at 17:24.

  4. #4
    Join Date
    Jan 2006
    Location
    Graz, Austria
    Posts
    8,419
    Thanks
    37
    Thanked 1,546 Times in 1,496 Posts
    Qt products
    Qt3 Qt4 Qt5
    Platforms
    Unix/X11 Windows

    Default Re: QCoreApplication::postEvent: Unexpected null receiver while running application

    And what of that is your code?
    That looks like code shipped with Qt.

    Cheers,
    _

  5. #5
    Join Date
    Sep 2015
    Posts
    6
    Qt products
    Qt5
    Platforms
    Unix/X11

    Default Re: QCoreApplication::postEvent: Unexpected null receiver while running application

    Thanks anda_skoa for your response. I was able to partially fix the error/warning. In my MainWindow.qml, the attribute "visible: true" was missing. As the default value of the visible attribute is false, this caused a conflict between visible: false and visibility: Maximum attributes. I added the attribute "visible: true" and the error regarding
    "Conflicting properties 'visible' and 'visibility' for Window 'root'" disappeared. However, I still have the QCoreApplication:postEvent: Unexpected null receiver error which shows up as soon as the application launches. Unfortunately, the entire code is too huge to be included here and I am not sure which part of the code is triggering the postEvent() function. Any tips on how to go about finding the issue?


    MainWindow.qml
    --------
    import QtQuick 2.2
    import QtQuick.Controls 1.1
    import QtQuick.Layouts 1.1
    import QtQuick.Dialogs 1.2
    import "."

    ApplicationWindow {
    id: mainWindow
    visibility: "Maximized"
    visible: true
    width: 800
    height: 600

    title: "Main Window"
    color: "whitesmoke"

    property int msgBarHeight: 30

    SplashScreen {
    id: splash
    visible: true
    }
    ....

  6. #6
    Join Date
    Jan 2006
    Location
    Graz, Austria
    Posts
    8,419
    Thanks
    37
    Thanked 1,546 Times in 1,496 Posts
    Qt products
    Qt3 Qt4 Qt5
    Platforms
    Unix/X11 Windows

    Default Re: QCoreApplication::postEvent: Unexpected null receiver while running application

    Does that other error happen if you don't load the UI?

    If it only appears when you load the UI, have you tried if it occurs when you minimize your main QML file?

    In any case you can likely just ignore it.

    Cheers,
    _

  7. #7
    Join Date
    Sep 2015
    Posts
    6
    Qt products
    Qt5
    Platforms
    Unix/X11

    Default Re: QCoreApplication::postEvent: Unexpected null receiver while running application

    The problem is fixed now. What was happening was that as soon as the application loaded, deleteLater() was being called on an object which was NULL initially. Upon placing the dleeteLater call inside a simple conditional, the error vanished.

    Thanks a lot for your help anda_skoa.

Similar Threads

  1. Replies: 0
    Last Post: 14th April 2011, 16:10
  2. QCoreApplication::postEvent: Unexpected null receiver
    By mortoray in forum Qt Programming
    Replies: 3
    Last Post: 14th November 2010, 23:14
  3. QCoreApplication::postEvent();
    By chrisdsimpson in forum Newbie
    Replies: 6
    Last Post: 1st April 2008, 22:23
  4. QCoreApplication::postEvent: Unexpected null receiver
    By merlvingian in forum Qt Programming
    Replies: 6
    Last Post: 13th March 2007, 21:25
  5. postEvent() to a non-existing receiver
    By Artschi in forum Qt Programming
    Replies: 7
    Last Post: 1st June 2006, 15:44

Tags for this Thread

Bookmarks

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  
Digia, Qt and their respective logos are trademarks of Digia Plc in Finland and/or other countries worldwide.