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