myitem.h

#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

mywindow.h

#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

mywindow.cpp

#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();
}