git.cworth.org Git - apitrace/blob - gui/argumentseditor.cpp

   1 #include "argumentseditor.h"
   2
   3 #include <QDebug>
   4 #include <QDoubleSpinBox>
   5 #include <QItemEditorFactory>
   6 #include <QSpinBox>
   7
   8 #include <limits.h>
   9 #include <float.h>
  10
  11 #include "apitracecall.h"
  12
  13 ArgumentsEditor::ArgumentsEditor(QWidget *parent)
  14     : QWidget(parent),
  15       m_model(new QStandardItemModel()),
  16       m_call(0)
  17 {
  18     init();
  19 }
  20
  21 ArgumentsEditor::~ArgumentsEditor()
  22 {
  23 }
  24
  25 void ArgumentsEditor::setCall(ApiTraceCall *call)
  26 {
  27     if (m_call != call) {
  28         m_call = call;
  29         setupCall();
  30     }
  31 }
  32
  33 ApiTraceCall * ArgumentsEditor::call() const
  34 {
  35     return m_call;
  36 }
  37
  38 void ArgumentsEditor::init()
  39 {
  40     m_ui.setupUi(this);
  41
  42     m_ui.argsTree->setModel(m_model);
  43     QItemEditorFactory *factory =
  44         new ArgumentsItemEditorFactory();
  45
  46     QItemEditorFactory::setDefaultFactory(factory);
  47 }
  48
  49 void ArgumentsEditor::setupCall()
  50 {
  51     m_model->clear();
  52
  53     QStringList headers;
  54     headers.append(tr("Argument"));
  55     headers.append(tr("Value"));
  56     m_model->setColumnCount(2);
  57     m_model->setHorizontalHeaderLabels(headers);
  58     m_ui.argsTabWidget->removeTab(
  59         m_ui.argsTabWidget->indexOf(m_ui.shaderTab));
  60
  61     if (!m_call)
  62         return;
  63
  64     m_ui.callLabel->setText(m_call->name);
  65     QStandardItem *rootItem = m_model->invisibleRootItem();
  66     for (int i = 0; i < m_call->argNames.count(); ++i) {
  67         QString argName = m_call->argNames[i];
  68         QVariant val = m_call->argValues[i];
  69         QStandardItem *nameItem = new QStandardItem(argName);
  70         nameItem->setFlags(nameItem->flags() ^ Qt::ItemIsEditable);
  71         QList<QStandardItem*> topRow;
  72         topRow.append(nameItem);
  73         qDebug()<<"arg "<<argName<<", val = "<<val;
  74
  75         if (val.canConvert<ApiArray>()) {
  76             ApiArray array = val.value<ApiArray>();
  77             QList<QVariant> vals = array.values();
  78             QVariant firstVal = vals.value(0);
  79
  80             if (firstVal.userType() == QVariant::String) {
  81                 m_ui.argsTabWidget->addTab(
  82                     m_ui.shaderTab, argName);
  83                 setupShaderEditor(vals);
  84                 delete nameItem;
  85                 continue;
  86             } else {
  87                 for (int i = 0; i < vals.count(); ++i) {
  88                     QList<QStandardItem*> row;
  89
  90                     QStandardItem *idx = new QStandardItem();
  91                     idx->setFlags(idx->flags() ^ Qt::ItemIsEditable);
  92                     idx->setText(tr("%1)").arg(i));
  93
  94                     QStandardItem *col = new QStandardItem();
  95                     col->setFlags(col->flags() | Qt::ItemIsEditable);
  96                     col->setData(vals[i], Qt::DisplayRole);
  97                     row.append(idx);
  98                     row.append(col);
  99                     nameItem->appendRow(row);
 100                 };
 101             }
 102             qDebug()<<"\tarray first = "<<vals[0];
 103         } else  if (val.canConvert<ApiPointer>()) {
 104             ApiPointer ptr = val.value<ApiPointer>();
 105             QStandardItem *item = new QStandardItem();
 106             item->setFlags(item->flags() ^ Qt::ItemIsEditable);
 107             item->setText(ptr.toString());
 108             QIcon icon(":/resources/emblem-locked.png");
 109             item->setIcon(icon);
 110             item->setToolTip(tr("Argument is read-only"));
 111             topRow.append(item);
 112         } else if (val.canConvert<ApiBitmask>()) {
 113             ApiBitmask mask = val.value<ApiBitmask>();
 114             QStandardItem *item = new QStandardItem();
 115             item->setFlags(item->flags() ^ Qt::ItemIsEditable);
 116             item->setText(mask.toString());
 117             QIcon icon(":/resources/emblem-locked.png");
 118             item->setIcon(icon);
 119             item->setToolTip(tr("Argument is read-only"));
 120             topRow.append(item);
 121         } else if (val.canConvert<ApiStruct>()) {
 122             ApiStruct str = val.value<ApiStruct>();
 123             QStandardItem *item = new QStandardItem();
 124             item->setFlags(item->flags() ^ Qt::ItemIsEditable);
 125             item->setText(str.toString());
 126             QIcon icon(":/resources/emblem-locked.png");
 127             item->setIcon(icon);
 128             item->setToolTip(tr("Argument is read-only"));
 129             topRow.append(item);
 130         } else if (val.userType() == QVariant::ByteArray) {
 131             QByteArray ba = val.value<QByteArray>();
 132             QStandardItem *item = new QStandardItem();
 133             item->setFlags(item->flags() ^ Qt::ItemIsEditable);
 134             item->setText(
 135                 tr("<binary data, size = %1 bytes>").arg(ba.size()));
 136             QIcon icon(":/resources/emblem-locked.png");
 137             item->setIcon(icon);
 138             item->setToolTip(tr("Argument is read-only"));
 139             topRow.append(item);
 140         } else {
 141             QStandardItem *item
 142                 = new QStandardItem();
 143             item->setFlags(item->flags() | Qt::ItemIsEditable);
 144             item->setData(val, Qt::DisplayRole);
 145             topRow.append(item);
 146         }
 147         rootItem->appendRow(topRow);
 148     }
 149 }
 150
 151 void ArgumentsEditor::setupShaderEditor(const QList<QVariant> &sources)
 152 {
 153 }
 154
 155 ArgumentsItemEditorFactory::ArgumentsItemEditorFactory()
 156     : QItemEditorFactory()
 157 {
 158 }
 159
 160 QWidget * ArgumentsItemEditorFactory::createEditor(QVariant::Type type,
 161                                                    QWidget *parent) const
 162 {
 163     switch (type) {
 164     case QVariant::Bool: {
 165         BooleanComboBox *cb = new BooleanComboBox(parent);
 166         cb->setFrame(false);
 167         return cb;
 168     }
 169     case QVariant::UInt: {
 170         QSpinBox *sb = new QSpinBox(parent);
 171         sb->setFrame(false);
 172         sb->setMaximum(INT_MAX);
 173         return sb; }
 174     case QVariant::Int: {
 175         QSpinBox *sb = new QSpinBox(parent);
 176         sb->setFrame(false);
 177         sb->setMinimum(INT_MIN);
 178         sb->setMaximum(INT_MAX);
 179         return sb;
 180     }
 181     case QVariant::ULongLong: {
 182         QSpinBox *sb = new QSpinBox(parent);
 183         sb->setFrame(false);
 184         sb->setMaximum(INT_MAX);
 185         return sb; }
 186     case QVariant::LongLong: {
 187         QSpinBox *sb = new QSpinBox(parent);
 188         sb->setFrame(false);
 189         sb->setMinimum(INT_MIN);
 190         sb->setMaximum(INT_MAX);
 191         return sb;
 192     }
 193     case QVariant::Pixmap:
 194         return new QLabel(parent);
 195     case QVariant::Double: {
 196         QDoubleSpinBox *sb = new QDoubleSpinBox(parent);
 197         sb->setFrame(false);
 198         sb->setMinimum(-DBL_MAX);
 199         sb->setMaximum(DBL_MAX);
 200         sb->setDecimals(10);
 201         return sb;
 202     }
 203     default:
 204         break;
 205     }
 206     return 0;
 207 }
 208
 209 QByteArray
 210 ArgumentsItemEditorFactory::valuePropertyName(QVariant::Type type) const
 211 {
 212     switch (type) {
 213     case QVariant::Bool:
 214         return "currentIndex";
 215     case QVariant::UInt:
 216     case QVariant::Int:
 217     case QVariant::LongLong:
 218     case QVariant::ULongLong:
 219     case QVariant::Double:
 220         return "value";
 221 #if 0
 222     case QVariant::String:
 223 #endif
 224     default:
 225         return "text";
 226     }
 227 }
 228
 229 BooleanComboBox::BooleanComboBox(QWidget *parent)
 230     : QComboBox(parent)
 231 {
 232     addItem(tr("False"));
 233     addItem(tr("True"));
 234 }
 235
 236 void BooleanComboBox::setValue(bool value)
 237 {
 238     setCurrentIndex(value ? 1 : 0);
 239 }
 240
 241 bool BooleanComboBox::value() const
 242 {
 243     return (currentIndex() == 1);
 244 }
 245
 246 #include "argumentseditor.moc"