myitem.h
<code C++>
#ifndef MYITEM_H
#define MYITEM_H

#include <QTreeWidget>
#include <QMetaMethod>

class MyItem : public QTreeWidgetItem
{
};

class ObjectItem : public MyItem
{
public:
    ObjectItem () : obj (nullptr) { }
private:
    QObject * obj;
public:
    QObject * getObject () { return obj; }
    void setObject (QObject * p) { obj = p; }
};

class MethodItem : public ObjectItem
{
public:
    MethodItem () { }
private:
    QMetaMethod meth;
public:
    QMetaMethod getMethod () { return meth; }
    void setMethod (QMetaMethod p) { meth = p; }
};

#endif // MYITEM_H

</code>

mywindow.h
<code C++>
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QTableWidget>
#include <QTreeWidget>
#include <QMetaProperty>
#include "myitem.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private slots:
    void on_treeWidget_itemActivated(QTreeWidgetItem *item, int column);

private:
    Ui::MainWindow *ui;
    int line_count;
    void displayTree(QTreeWidgetItem *target, QObject *obj);
    void displayDetail(QTreeWidgetItem *target, QObject *obj);
    QTableWidgetItem * displayLine (QString name, QString value, QColor color = QColor () );
    void displayProperty (const QObject * obj, QMetaProperty prop);
    void displayObject (QObject * obj);
    void displayMethod (QObject * obj, QMetaMethod meth);
};

#endif // MAINWINDOW_H

</code>

mywindow.cpp
<code C++>
#include "mainwindow.h"
#include "ui_mainwindow.h"

#include <QApplication>

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi (this);
    displayTree (ui->treeWidget->invisibleRootItem(), this);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::displayTree (QTreeWidgetItem * target, QObject * obj)
{
    auto node = new ObjectItem;
    const QMetaObject * type = obj->metaObject();
    QString s = obj->objectName() + " : " + type->className();
    node->setText (0, s);
    node->setObject (obj);
    node->setForeground(0, QColor ("blue"));
    target->addChild (node);
    displayDetail (node, obj);

    const QObjectList & list = obj->children();
    for (QObject * t : list)
        displayTree (node, t);
}

void MainWindow::displayDetail (QTreeWidgetItem * target, QObject * obj)
{
    const QMetaObject * type = obj->metaObject();

    QTreeWidgetItem * branch = new QTreeWidgetItem ();
    branch->setText(0, "methods");
    branch->setForeground(0, QColor ("lime"));
    target->addChild (branch);

    int cnt = type->methodCount();
    for (int i = 0; i < cnt; i++)
    {
       QMetaMethod meth = type->method(i);
       MethodItem * item = new MethodItem;
       item->setObject (obj);
       item->setMethod (meth);
       item->setForeground(0, QColor ("lime"));
       item->setText(0, meth.name());
       QString t = QString (meth.typeName()) + " " + meth.methodSignature();
       item->setToolTip(0, t);
       branch->addChild (item);
    }
}

void MainWindow::on_treeWidget_itemActivated (QTreeWidgetItem *item, int column)
{
    if ( MethodItem * meth_item = dynamic_cast <MethodItem *> (item) )
       displayMethod (meth_item->getObject(), meth_item->getMethod());
    else if ( ObjectItem * obj_item = dynamic_cast <ObjectItem *> (item) )
       displayObject (obj_item->getObject());
}

void MainWindow::displayMethod (QObject * obj, QMetaMethod meth)
{
    line_count = 0;
    ui->tableWidget->setColumnCount(2);
    ui->tableWidget->setRowCount(0);

    displayLine ("type name", meth.typeName (), QColor ("yellow"));
    displayLine ("object name", objectName (), QColor ("orange"));
    displayLine ("method name", meth.name (), QColor ("red"));

    QList<QByteArray> names = meth.parameterNames();
    QList<QByteArray> types = meth.parameterTypes();

    int n = meth.parameterCount();
    for (int i = 0; i < n; i++)
    {
        QString s = names[i] + " : " + types[i];
        displayLine (s, "", QColor ("green"));
    }
}


QTableWidgetItem * MainWindow::displayLine (QString name, QString value, QColor color)
{
    int line = line_count;
    line_count ++;
    if (ui->tableWidget->rowCount() < line_count)
        ui->tableWidget->setRowCount (line_count);

    QTableWidgetItem * item = new QTableWidgetItem;
    item->setText (name);
    if (color.isValid ())
       item->setForeground(color);
    ui->tableWidget->setItem (line, 0, item);

    item = new QTableWidgetItem;
    item->setText (value);
    if (color.isValid ())
       item->setForeground(color);
    ui->tableWidget->setItem (line, 1, item);

    return item;
}

void MainWindow::displayProperty (const QObject * obj, QMetaProperty prop)
{
    QString name = prop.name ();
    QVariant value = prop.read (obj);
    QTableWidgetItem * item = displayLine (name, value.toString());

    QVariant::Type t = value.type();
    if (t == QVariant::Bool)
    {
       bool b = value.toBool ();
       item->setData (Qt::CheckStateRole, b ? Qt::Checked : Qt::Unchecked);
    }
    if (t == QVariant::Color)
    {
        QColor c = value.value <QColor> ();
        item->setData (Qt::DecorationRole, c);
    }
    if (t == QVariant::Palette)
    {
        QPalette p = value.value <QPalette> ();
        QColor c = p.background().color();
        item->setData (Qt::DecorationRole, c);
    }
    if (t == QVariant::Icon)
    {
        QIcon i = value.value <QIcon> ();
        item->setData (Qt::DecorationRole, i);
    }
    if (t == QVariant::Image)
    {
        QImage i = value.value <QImage> ();
        item->setData (Qt::DecorationRole, i);
    }
    // if (t == QVariant::Color)
}

void MainWindow::displayObject (QObject * obj)
{
    line_count = 0;
    ui->tableWidget->setColumnCount(2);
    ui->tableWidget->setRowCount(0);

    QStringList list;
    list << "Name" << "Value";
    ui->tableWidget->setHorizontalHeaderLabels (list);

    const QMetaObject * type = obj->metaObject ();
    displayLine("className", type->className(), QColor ("blue"));

    int cnt = type->propertyCount();
    for (int inx = 0; inx < cnt; inx++)
    {
        // #include <QMetaProperty>
        QMetaProperty prop = type->property (inx);
        displayProperty (obj, prop);
    }
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();

    return a.exec();
}


</code>