diff options
Diffstat (limited to 'VMProtect/property_editor.cc')
| -rw-r--r-- | VMProtect/property_editor.cc | 2765 |
1 files changed, 2765 insertions, 0 deletions
diff --git a/VMProtect/property_editor.cc b/VMProtect/property_editor.cc new file mode 100644 index 0000000..01ec142 --- /dev/null +++ b/VMProtect/property_editor.cc @@ -0,0 +1,2765 @@ +#include "../runtime/common.h" +#include "../runtime/crypto.h" +#include "../core/objects.h" +#include "../core/osutils.h" +#include "../core/streams.h" +#include "../core/files.h" +#include "../core/lang.h" +#include "../core/core.h" +#include "../core/processors.h" +#include "widgets.h" +#include "models.h" +#include "property_editor.h" +#include "moc/moc_property_editor.cc" + +std::string formatBase64(const std::string &value) +{ + std::string res = value; + size_t len = res.size(); + for (size_t i = 0; i < len / 76; i++) { + res.insert(res.begin() + (i + 1) * 76 + i, '\n'); + } + return res; +} + +std::string formatVector(const std::vector<uint8_t> &value) +{ + std::string dst; + size_t dst_len = Base64EncodeGetRequiredLength(value.size()); + if (dst_len) { + dst.resize(dst_len); + Base64Encode(&value[0], value.size(), &dst[0], dst_len); + if (dst_len != dst.size()) + dst.resize(dst_len); + } + return formatBase64(dst); +} + +/** + * Property + */ + +Property::Property(Property *parent, const QString &name) + : parent_(NULL), name_(name), readOnly_(false) +{ + if (parent) + parent->addChild(this); +} + +Property::~Property() +{ + if (parent_) + parent_->removeChild(this); + clear(); + emit destroyed(this); +} + +void Property::clear() +{ + while (!children_.isEmpty()) { + QListIterator<Property *> it(children_); + Property *prop = it.next(); + delete prop; + } +} + +QWidget *Property::createEditor(QWidget * /*parent*/) +{ + return NULL; +} + +QString Property::valueText() const +{ + return QString(); +} + +void Property::setName(const QString &name) +{ + if (name_ == name) + return; + + name_ = name; + emit changed(this); +} + +void Property::setReadOnly(bool value) +{ + if (readOnly_ == value) + return; + + readOnly_ = value; + emit changed(this); +} + +void Property::addChild(Property *child) +{ + insertChild(childCount(), child); +} + +void Property::insertChild(int index, Property *child) +{ + if (child->parent()) + return; + + child->parent_ = this; + children_.insert(index, child); +} + +void Property::removeChild(Property *child) +{ + children_.removeOne(child); +} + +/** + * StringProperty + */ + +StringProperty::StringProperty(Property *parent, const QString &name, const QString &value) + : Property(parent, name), value_(value) +{ + +} + +QString StringProperty::valueText() const +{ + return value_; +} + +QWidget *StringProperty::createEditor(QWidget *parent) +{ + QLineEdit *editor = new LineEdit(parent); + editor->setFrame(false); + editor->setText(value_); + connect(editor, SIGNAL(textChanged(const QString &)), this, SLOT(editorChanged(const QString &))); + + return editor; +} + +void StringProperty::editorChanged(const QString &value) +{ + setValue(value); +} + +void StringProperty::setValue(const QString &value) +{ + if (value_ != value) { + value_ = value; + emit valueChanged(value); + emit changed(this); + } +} + +/** + * BoolProperty + */ + +BoolProperty::BoolProperty(Property *parent, const QString &name, bool value) + : Property(parent, name), value_(value) +{ + +} + +QString BoolProperty::valueText() const +{ + return value_ ? QString::fromUtf8(language[lsYes].c_str()) : QString::fromUtf8(language[lsNo].c_str()); +} + +QWidget *BoolProperty::createEditor(QWidget *parent) +{ + BoolEdit *editor = new BoolEdit(parent); + editor->setFrame(false); + editor->setChecked(value_); + + connect(editor, SIGNAL(toggled(bool)), this, SLOT(editorChanged(bool))); + + return editor; +} + +void BoolProperty::editorChanged(bool value) +{ + setValue(value); +} + +void BoolProperty::setValue(bool value) +{ + if (value_ != value) { + value_ = value; + emit valueChanged(value); + emit changed(this); + } +} + +/** + * DateProperty + */ + +DateProperty::DateProperty(Property *parent, const QString &name, const QDate &value) + : Property(parent, name), value_(value) +{ + +} + +QString DateProperty::valueText() const +{ + return value_.toString(Qt::SystemLocaleShortDate); +} + +QWidget *DateProperty::createEditor(QWidget *parent) +{ + QDateEdit *editor = new QDateEdit(parent); + editor->setFrame(false); + editor->setDate(value_); + connect(editor, SIGNAL(dateChanged(const QDate &)), this, SLOT(editorChanged(const QDate &))); + + return editor; +} + +void DateProperty::editorChanged(const QDate &value) +{ + setValue(value); +} + +void DateProperty::setValue(const QDate &value) +{ + if (value_ != value) { + value_ = value; + emit valueChanged(value); + emit changed(this); + } +} + +/** + * StringListProperty + */ + +StringListProperty::StringListProperty(Property *parent, const QString &name, const QString &value) + : StringProperty(parent, name, value) +{ + +} + +QWidget *StringListProperty::createEditor(QWidget *parent) +{ + StringListEdit *editor = new StringListEdit(parent); + editor->document()->setDocumentMargin(0); + editor->setFrameShape(QFrame::NoFrame); + editor->setPlainText(value()); + connect(editor, SIGNAL(textChanged(const QString &)), this, SLOT(editorChanged(const QString &))); + + return editor; +} + +/** + * HexProperty + */ + + /* +HexProperty::HexProperty(Property *parent, const QString &name, const QByteArray &value) + : Property(parent, name) +{ + edit_ = new QHexEdit(); + edit_->setFrameShape(QFrame::NoFrame); + edit_->setData(value); +} + +HexProperty::~HexProperty() +{ + delete edit_; +} + */ + +/** + * GroupProperty + */ + +GroupProperty::GroupProperty(Property *parent, const QString &name) + : Property(parent, name) +{ + +} + +/** + * CommandProperty + */ + +CommandProperty::CommandProperty(Property *parent, ICommand *value) + : Property(parent, QString::fromLatin1(value->display_address().c_str())), value_(value) +{ + text_ = QString::fromUtf8(value_->text().c_str()); +} + +QString CommandProperty::valueText() const +{ + return text_; +} + +bool CommandProperty::hasStaticText(int column) const +{ + if (!value_) + return false; + + if (column == 0) + return true; + + if (column == 1) + return (value_->comment().type > ttNone); + + return false; +} + +QString CommandProperty::staticText(int column) const +{ + if (!value_) + return QString(); + + if (column == 0) + return QString::fromLatin1(value_->dump_str().c_str()); + + if (column == 1) + return QString::fromUtf8(value_->comment().display_value().c_str()); + + return QString(); +} + +QColor CommandProperty::staticColor(int column) const +{ + if (!value_) + return QColor(); + + if (column == 0) + return Qt::gray; + + if (column == 1) { + switch (value_->comment().type) { + case ttFunction: case ttJmp: + return Qt::blue; + case ttImport: + return Qt::darkRed; + case ttExport: + return Qt::red; + case ttString: + return Qt::darkGreen; + case ttVariable: + return Qt::magenta; + case ttComment: + return Qt::gray; + } + } + return QColor(); +} + +/** + * EnumProperty + */ + +EnumProperty::EnumProperty(Property *parent, const QString &name, const QStringList &items, int value) + : Property(parent, name), items_(items), value_(value) +{ + +} + +void EnumProperty::setValue(int value) +{ + if (value_ != value) { + value_ = value; + emit valueChanged(value); + emit changed(this); + } +} + +void EnumProperty::editorChanged(int value) +{ + setValue(value); +} + +QString EnumProperty::valueText() const +{ + if (value_ >= 0 && value_ < items_.size()) + return items_[value_]; + return QString(); +} + +QWidget *EnumProperty::createEditor(QWidget *parent) +{ + EnumEdit *editor = new EnumEdit(parent, items_); + editor->setFrame(false); + editor->setCurrentIndex(value_); + + connect(editor, SIGNAL(currentIndexChanged(int)), this, SLOT(editorChanged(int))); + + return editor; +} + +/** + * CompilationTypeProperty + */ + +CompilationTypeProperty::CompilationTypeProperty(Property *parent, const QString &name, CompilationType value) + : Property(parent, name), value_(value), defaultValue_(ctNone) +{ + items_ << QString::fromUtf8(language[lsNone].c_str()); + items_ << QString::fromUtf8(language[lsVirtualization].c_str()); + items_ << QString::fromUtf8(language[lsMutation].c_str()); + items_ << QString("%1 (%2 + %3)").arg(QString::fromUtf8(language[lsUltra].c_str())).arg(QString::fromUtf8(language[lsMutation].c_str())).arg(QString::fromUtf8(language[lsVirtualization].c_str())); +} + +void CompilationTypeProperty::setValue(CompilationType value) +{ + if (value_ != value) { + value_ = value; + emit valueChanged(value); + emit changed(this); + } +} + +void CompilationTypeProperty::editorChanged(int value) +{ + CompilationType new_value = ctNone; + if (value > 0) { + if (defaultValue_ == ctNone) + new_value = static_cast<CompilationType>(value - 1); + else + new_value = (value == 1) ? defaultValue_ : ctNone; + } + + setValue(new_value); +} + +QString CompilationTypeProperty::valueText() const +{ + switch (value_) { + case ctNone: + return items_[0]; + case ctVirtualization: + return items_[1]; + case ctMutation: + return items_[2]; + case ctUltra: + return items_[3]; + } + + return QString(); +} + +QWidget *CompilationTypeProperty::createEditor(QWidget *parent) +{ + QStringList items; + items << items_[0]; + switch (defaultValue_) { + case ctNone: + items << items_[1]; + items << items_[2]; + items << items_[3]; + break; + case ctVirtualization: + items << items_[1]; + break; + case ctMutation: + items << items_[2]; + break; + case ctUltra: + items << items_[3]; + break; + } + + int index = 0; + if (defaultValue_ != ctNone) { + if (value_ == defaultValue_) + index = 1; + } else if (value_ != ctNone) { + index = value_ + 1; + } + + EnumEdit *editor = new EnumEdit(parent, items); + editor->setFrame(false); + editor->setCurrentIndex(index); + + connect(editor, SIGNAL(currentIndexChanged(int)), this, SLOT(editorChanged(int))); + + return editor; +} + +/** + * FileNameProperty + */ + +FileNameProperty::FileNameProperty(Property *parent, const QString &name, const QString &filter, const QString &value, bool saveMode) + : Property(parent, name), filter_(filter), value_(value), saveMode_(saveMode) +{ + +} + +QString FileNameProperty::valueText() const +{ + return value_; +} + +QWidget *FileNameProperty::createEditor(QWidget *parent) +{ + FileNameEdit *editor = new FileNameEdit(parent); + editor->setFrame(false); + editor->setFilter(filter_); + editor->setRelativePath(relativePath_); + editor->setText(value_); + editor->setSaveMode(saveMode_); + connect(editor, SIGNAL(textChanged(const QString &)), this, SLOT(editorChanged(const QString &))); + + return editor; +} + +void FileNameProperty::editorChanged(const QString &value) +{ + setValue(value); +} + +void FileNameProperty::setValue(const QString &value) +{ + if (value_ != value) { + value_ = value; + emit valueChanged(value); + emit changed(this); + } +} + +/** + * FileNameProperty + */ + +WatermarkProperty::WatermarkProperty(Property *parent, const QString &name, const QString &value) + : Property(parent, name), value_(value) +{ + +} + +QString WatermarkProperty::valueText() const +{ + return value_; +} + +QWidget *WatermarkProperty::createEditor(QWidget *parent) +{ + WatermarkEdit *editor = new WatermarkEdit(parent); + editor->setFrame(false); + editor->setText(value_); + connect(editor, SIGNAL(textChanged(const QString &)), this, SLOT(editorChanged(const QString &))); + + return editor; +} + +void WatermarkProperty::editorChanged(const QString &value) +{ + setValue(value); +} + +void WatermarkProperty::setValue(const QString &value) +{ + if (value_ != value) { + value_ = value; + emit valueChanged(value); + emit changed(this); + } +} + +/** + * PropertyManager + */ + +PropertyManager::PropertyManager(QObject *parent) + : QAbstractItemModel(parent) +{ + root_ = new GroupProperty(NULL, ""); +} + +PropertyManager::~PropertyManager() +{ + delete root_; +} + +QModelIndex PropertyManager::index(int row, int column, const QModelIndex &parent) const +{ + //if (parent.isValid() && parent.column() != 0) + // return QModelIndex(); + + Property *parentProp = indexToProperty(parent); + Property *childProp = parentProp->children().value(row); + if (!childProp) + return QModelIndex(); + + return createIndex(row, column, childProp); +} + +QModelIndex PropertyManager::parent(const QModelIndex &index) const +{ + if (!index.isValid()) + return QModelIndex(); + + Property *childProp = indexToProperty(index); + Property *parentProp = childProp->parent(); + if (parentProp == root_) + return QModelIndex(); + + return createIndex(parentProp->parent()->children().indexOf(parentProp), 0, parentProp); +} + +int PropertyManager::columnCount(const QModelIndex & /* parent */) const +{ + return 2; +} + +int PropertyManager::rowCount(const QModelIndex &parent) const +{ + Property *parentProp = indexToProperty(parent); + return parentProp->childCount(); +} + +QVariant PropertyManager::data(const QModelIndex &index, int role) const +{ + if (!index.isValid()) + return QVariant(); + + Property *prop = indexToProperty(index); + switch (role) { + case Qt::DisplayRole: + if (index.column() == 0) { + return prop->name(); + } else if (index.column() == 1) { + return prop->valueText(); + } + break; + case Qt::DecorationRole: + if (CommandProperty *c = qobject_cast<CommandProperty *>(prop)) { + if (index.column() == 0) { + ICommand *command = c->value(); + IFunction *func = command->owner(); + if (qobject_cast<CommandProperty *>(c->parent())) { + return QIcon(":/images/reference.png"); + } else if (func->ext_command_list()->GetCommandByAddress(command->address())) { + return QIcon(":/images/link.png"); + } else if (func->is_breaked_address(command->address())) { + return QIcon(":/images/disabled.png"); + } + QIcon res; + QPixmap pixmap(18, 1); + pixmap.fill(Qt::transparent); + res.addPixmap(pixmap); + return res; + } + } + break; + case Qt::TextColorRole: + if (prop->readOnly() && index.column() == 1) { + QPalette palette; + return palette.color(QPalette::Disabled, QPalette::Text); + } + break; + case Qt::FontRole: + if (!prop->readOnly() && index.column() == 1) { + QFont font; + font.setBold(true); + return font; + } + break; + case Qt::Vmp::StaticTextRole: + if (prop->hasStaticText(index.column())) + return prop->staticText(index.column()); + break; + case Qt::Vmp::StaticColorRole: + if (prop->hasStaticText(index.column())) + return prop->staticColor(index.column()); + break; + } + + return QVariant(); +} + +QVariant PropertyManager::headerData(int section, Qt::Orientation /*orientation*/, int role) const +{ + if (role == Qt::DisplayRole) { + if (section == 0) { + return QString::fromUtf8(language[lsName].c_str()); + } else { + return QString::fromUtf8(language[lsValue].c_str()); + } + } + return QVariant(); +} + +void PropertyManager::clear() +{ + root_->clear(); +} + +BoolProperty *PropertyManager::addBoolProperty(Property *parent, const QString &name, bool value) +{ + BoolProperty *prop = new BoolProperty(parent ? parent : root_, name, value); + addProperty(prop); + return prop; +} + +StringProperty *PropertyManager::addStringProperty(Property *parent, const QString &name, const QString &value) +{ + StringProperty *prop = new StringProperty(parent ? parent : root_, name, value); + addProperty(prop); + return prop; +} + +DateProperty *PropertyManager::addDateProperty(Property *parent, const QString &name, const QDate &value) +{ + DateProperty *prop = new DateProperty(parent ? parent : root_, name, value); + addProperty(prop); + return prop; +} + +StringListProperty *PropertyManager::addStringListProperty(Property *parent, const QString &name, const QString &value) +{ + StringListProperty *prop = new StringListProperty(parent ? parent : root_, name, value); + addProperty(prop); + return prop; +} + +GroupProperty *PropertyManager::addGroupProperty(Property *parent, const QString &name) +{ + GroupProperty *prop = new GroupProperty(parent ? parent : root_, name); + addProperty(prop); + return prop; +} + +EnumProperty *PropertyManager::addEnumProperty(Property *parent, const QString &name, const QStringList &items, int value) +{ + EnumProperty *prop = new EnumProperty(parent ? parent : root_, name, items, value); + addProperty(prop); + return prop; +} + +FileNameProperty *PropertyManager::addFileNameProperty(Property *parent, const QString &name, const QString &filter, const QString &value, bool saveMode) +{ + FileNameProperty *prop = new FileNameProperty(parent ? parent : root_, name, filter, value, saveMode); + addProperty(prop); + return prop; +} + +CommandProperty *PropertyManager::addCommandProperty(Property *parent, ICommand *value) +{ + CommandProperty *prop = new CommandProperty(parent ? parent : root_, value); + addProperty(prop); + return prop; +} + +WatermarkProperty *PropertyManager::addWatermarkProperty(Property *parent, const QString &name, const QString &value) +{ + WatermarkProperty *prop = new WatermarkProperty(parent ? parent : root_, name, value); + addProperty(prop); + return prop; +} + +CompilationTypeProperty *PropertyManager::addCompilationTypeProperty(Property *parent, const QString &name, CompilationType value) +{ + CompilationTypeProperty *prop = new CompilationTypeProperty(parent ? parent : root_, name, value); + addProperty(prop); + return prop; +} + +void PropertyManager::addProperty(Property *prop) +{ + if (!prop) + return; + + connect(prop, SIGNAL(destroyed(Property *)), this, SLOT(slotPropertyDestroyed(Property *))); + connect(prop, SIGNAL(changed(Property *)), this, SLOT(slotPropertyChanged(Property *))); +} + +Property *PropertyManager::indexToProperty(const QModelIndex &index) const +{ + if (index.isValid()) + return static_cast<Property *>(index.internalPointer()); + return root_; +} + +QModelIndex PropertyManager::propertyToIndex(Property *prop) const +{ + if (!prop) + return QModelIndex(); + + return createIndex(prop->parent()->children().indexOf(prop), 0, prop); +} + +void PropertyManager::slotPropertyChanged(Property *prop) +{ + QModelIndex index = propertyToIndex(prop); + emit dataChanged(index, index.sibling(index.row(), 1)); +} + +void PropertyManager::slotPropertyDestroyed(Property * /*prop*/) +{ + // +} + +Qt::ItemFlags PropertyManager::flags(const QModelIndex &index) const +{ + if (!index.isValid()) + return 0; + + Qt::ItemFlags res = Qt::ItemIsEnabled | Qt::ItemIsSelectable; + Property *prop = indexToProperty(index); + if (prop && prop->hasValue() && !prop->readOnly()) + res |= Qt::ItemIsEditable; + return res; +} + +/** + * PropertyEditorDelegate + */ + +PropertyEditorDelegate::PropertyEditorDelegate(QObject *parent) + : TreeViewItemDelegate(parent) +{ + +} + +Property *PropertyEditorDelegate::indexToProperty(const QModelIndex &index) const +{ + return static_cast<Property *>(index.internalPointer()); +} + +QWidget *PropertyEditorDelegate::createEditor(QWidget *parent, + const QStyleOptionViewItem &, const QModelIndex &index) const +{ + if (index.column() != 1) + return NULL; + + Property *prop = indexToProperty(index); + if (!prop) + return NULL; + + QWidget *editor = prop->createEditor(parent); + if (editor) { + QWidget *corrBearing = dynamic_cast<QLineEdit *>(editor); + editor->setObjectName("editor"); + editor->setAutoFillBackground(true); + QVariant value = index.data(Qt::FontRole); + if (value.isValid() && value.canConvert<QFont>()) + editor->setFont(qvariant_cast<QFont>(value)); + if (QComboBox *c = qobject_cast<QComboBox *>(editor)) { + c->lineEdit()->selectAll(); + corrBearing = c; + } else if (QPlainTextEdit *c = qobject_cast<QPlainTextEdit *>(editor)) { + c->selectAll(); + } + if(corrBearing) + { + corrBearing->setProperty("corrBearing", +#ifdef __APPLE__ + false +#else + true +#endif + ); + corrBearing->style()->unpolish(corrBearing); + corrBearing->style()->polish(corrBearing); + corrBearing->update(); + } + } + return editor; +} + +void PropertyEditorDelegate::setEditorData(QWidget * /*widget*/, const QModelIndex &) const +{ + //do nothing +} + +/** + * TreePropertyEditor + */ + +TreePropertyEditor::TreePropertyEditor(QWidget *parent) + : TreeView(parent) +{ + setObjectName("grid"); + setIconSize(QSize(18, 18)); + setFrameShape(QFrame::NoFrame); + setItemDelegate(new PropertyEditorDelegate(this)); +} + +Property *TreePropertyEditor::indexToProperty(const QModelIndex &index) const +{ + return static_cast<Property *>(index.internalPointer()); +} + +void TreePropertyEditor::keyPressEvent(QKeyEvent *event) +{ + switch (event->key()) { + case Qt::Key_Return: + case Qt::Key_Enter: + case Qt::Key_Space: // Trigger Edit + { + QModelIndex index = currentIndex(); + if ((index.flags() & (Qt::ItemIsEditable | Qt::ItemIsEnabled)) == (Qt::ItemIsEditable | Qt::ItemIsEnabled)) { + event->accept(); + // If the current position is at column 0, move to 1. + if (index.column() == 0) { + index = index.sibling(index.row(), 1); + setCurrentIndex(index); + } + edit(index); + return; + } + } + break; + default: + break; + } + + TreeView::keyPressEvent(event); +} + +void TreePropertyEditor::mousePressEvent(QMouseEvent *event) +{ + QTreeView::mousePressEvent(event); + QModelIndex index = indexAt(event->pos()); + + if (index.isValid()) { + Property *prop = indexToProperty(index); + if ((event->button() == Qt::LeftButton) && (index.column() == 1) && ((index.flags() & (Qt::ItemIsEditable | Qt::ItemIsEnabled)) == (Qt::ItemIsEditable | Qt::ItemIsEnabled))) { + edit(index); + } else if (!rootIsDecorated() && prop->childCount()) { + QRect rect = visualRect(index); + if (event->pos().x() >= rect.left() && event->pos().x() <= rect.left() + 20) + setExpanded(index, !isExpanded(index)); + } + } +} + +void TreePropertyEditor::dataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> &roles /*= QVector<int>()*/) +{ + QRect rect = visualRect(topLeft); + QTreeView::dataChanged(topLeft, bottomRight, roles); + if (topLeft.row() == bottomRight.row() && topLeft.isValid()) { + if (rect != visualRect(bottomRight)) + updateEditorGeometries(); + } +} + +/** + * LicensePropertyManager + */ + +LicensePropertyManager::LicensePropertyManager(QObject *parent) + : PropertyManager(parent), value_(NULL), lock_(false) +{ + details_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetails].c_str())); + licenseName_ = addStringProperty(details_, QString::fromUtf8(language[lsCustomerName].c_str()), QString()); + licenseEmail_ = addStringProperty(details_, QString::fromUtf8(language[lsEmail].c_str()), QString()); + licenseDate_ = addDateProperty(details_, QString::fromUtf8(language[lsDate].c_str()), QDate()); + licenseOrder_ = addStringProperty(details_, QString::fromUtf8(language[lsOrderRef].c_str()), QString()); + licenseComments_ = addStringListProperty(details_, QString::fromUtf8(language[lsComments].c_str()), QString()); + licenseBlocked_ = addBoolProperty(details_, QString::fromUtf8(language[lsBlocked].c_str()), false); + licenseSerialNumber_ = addStringProperty(details_, QString::fromUtf8(language[lsSerialNumber].c_str()), QString()); + licenseSerialNumber_->setReadOnly(true); + + contents_ = addGroupProperty(NULL, QString::fromUtf8(language[lsSerialNumberContents].c_str())); + serialName_ = addStringProperty(contents_, QString::fromUtf8(language[lsCustomerName].c_str()), QString()); + serialName_->setReadOnly(true); + serialEmail_ = addStringProperty(contents_, QString::fromUtf8(language[lsEmail].c_str()), QString()); + serialEmail_->setReadOnly(true); + serialHWID_ = addStringProperty(contents_, QString::fromUtf8(language[lsHardwareID].c_str()), QString()); + serialHWID_->setReadOnly(true); + serialExpirationDate_ = addDateProperty(contents_, QString::fromUtf8(language[lsExpirationDate].c_str()), QDate()); + serialExpirationDate_->setReadOnly(true); + serialTimeLimit_ = addStringProperty(contents_, QString::fromUtf8(language[lsRunningTimeLimit].c_str()), QString()); + serialTimeLimit_->setReadOnly(true); + serialMaxBuildDate_ = addDateProperty(contents_, QString::fromUtf8(language[lsMaxBuildDate].c_str()), QDate()); + serialMaxBuildDate_->setReadOnly(true); + serialUserData_ = addStringProperty(contents_, QString::fromUtf8(language[lsUserData].c_str()), QString()); + serialUserData_->setReadOnly(true); + + connect(licenseName_, SIGNAL(valueChanged(const QString &)), this, SLOT(nameChanged(const QString &))); + connect(licenseEmail_, SIGNAL(valueChanged(const QString &)), this, SLOT(emailChanged(const QString &))); + connect(licenseDate_, SIGNAL(valueChanged(const QDate &)), this, SLOT(dateChanged(const QDate &))); + connect(licenseOrder_, SIGNAL(valueChanged(const QString &)), this, SLOT(orderChanged(const QString &))); + connect(licenseComments_, SIGNAL(valueChanged(const QString &)), this, SLOT(commentsChanged(const QString &))); + connect(licenseBlocked_, SIGNAL(valueChanged(bool)), this, SLOT(blockedChanged(bool))); + + localize(); +} + +void LicensePropertyManager::localize() +{ + details_->setName(QString::fromUtf8(language[lsDetails].c_str())); + licenseName_->setName(QString::fromUtf8(language[lsCustomerName].c_str())); + licenseEmail_->setName(QString::fromUtf8(language[lsEmail].c_str())); + licenseDate_->setName(QString::fromUtf8(language[lsDate].c_str())); + licenseComments_->setName(QString::fromUtf8(language[lsComments].c_str())); + licenseOrder_->setName(QString::fromUtf8(language[lsOrderRef].c_str())); + licenseBlocked_->setName(QString::fromUtf8(language[lsBlocked].c_str())); + licenseSerialNumber_->setName(QString::fromUtf8(language[lsSerialNumber].c_str())); + + contents_->setName(QString::fromUtf8(language[lsSerialNumberContents].c_str())); + serialName_->setName(QString::fromUtf8(language[lsCustomerName].c_str())); + serialEmail_->setName(QString::fromUtf8(language[lsEmail].c_str())); + serialHWID_->setName(QString::fromUtf8(language[lsHardwareID].c_str())); + serialExpirationDate_->setName(QString::fromUtf8(language[lsExpirationDate].c_str())); + serialTimeLimit_->setName(QString::fromUtf8(language[lsRunningTimeLimit].c_str())); + serialMaxBuildDate_->setName(QString::fromUtf8(language[lsMaxBuildDate].c_str())); + serialUserData_->setName(QString::fromUtf8(language[lsUserData].c_str())); +} + +QVariant LicensePropertyManager::data(const QModelIndex &index, int role) const +{ + Property *prop = indexToProperty(index); + if (role == Qt::FontRole) { + if (index.column() == 1 && (prop == licenseSerialNumber_ || prop == serialUserData_)) + return QFont(MONOSPACE_FONT_FAMILY); + } + + return PropertyManager::data(index, role); +} + +void LicensePropertyManager::nameChanged(const QString &value) +{ + if (!value_ || lock_) + return; + +#ifdef ULTIMATE + value_->set_customer_name(value.toUtf8().constData()); +#endif +} + +void LicensePropertyManager::emailChanged(const QString &value) +{ + if (!value_ || lock_) + return; + +#ifdef ULTIMATE + value_->set_customer_email(value.toUtf8().constData()); +#endif +} + +void LicensePropertyManager::orderChanged(const QString &value) +{ + if (!value_ || lock_) + return; + +#ifdef ULTIMATE + value_->set_order_ref(value.toUtf8().constData()); +#endif +} + +void LicensePropertyManager::dateChanged(const QDate &value) +{ + if (!value_ || lock_) + return; + +#ifdef ULTIMATE + value_->set_date(LicenseDate(value.year(), value.month(), value.day())); +#endif +} + +void LicensePropertyManager::commentsChanged(const QString &value) +{ + if (!value_ || lock_) + return; + +#ifdef ULTIMATE + value_->set_comments(value.toUtf8().constData()); +#endif +} + +void LicensePropertyManager::blockedChanged(bool value) +{ + if (!value_ || lock_) + return; + +#ifdef ULTIMATE + value_->set_blocked(value); +#endif +} + +void LicensePropertyManager::setValue(License *value) +{ + value_ = value; + update(); +} + +void LicensePropertyManager::update() +{ +#ifdef ULTIMATE + lock_ = true; + + licenseName_->setValue(value_ ? QString::fromUtf8(value_->customer_name().c_str()) : QString()); + licenseEmail_->setValue(value_ ? QString::fromUtf8(value_->customer_email().c_str()) : QString()); + licenseDate_->setValue(value_ ? QDate(value_->date().Year, value_->date().Month, value_->date().Day) : QDate()); + licenseOrder_->setValue(value_ ? QString::fromUtf8(value_->order_ref().c_str()) : QString()); + licenseComments_->setValue(value_ ? QString::fromUtf8(value_->comments().c_str()) : QString()); + licenseBlocked_->setValue(value_ ? value_->blocked() : false); + licenseSerialNumber_->setValue(value_ ? QString::fromLatin1(formatBase64(value_->serial_number()).c_str()) : QString()); + + LicenseInfo *license_info = value_ ? value_->info() : NULL; + serialName_->setValue(license_info && (license_info->Flags & HAS_USER_NAME) ? QString::fromUtf8(license_info->CustomerName.c_str()) : QString()); + serialEmail_->setValue(license_info && (license_info->Flags & HAS_EMAIL) ? QString::fromUtf8(license_info->CustomerEmail.c_str()) : QString()); + serialHWID_->setValue(license_info && (license_info->Flags & HAS_HARDWARE_ID) ? QString::fromLatin1(license_info->HWID.c_str()) : QString()); + serialTimeLimit_->setValue(license_info && (license_info->Flags & HAS_TIME_LIMIT) ? QString::number(license_info->RunningTimeLimit) : QString()); + serialExpirationDate_->setValue(license_info && (license_info->Flags & HAS_EXP_DATE) ? QDate(license_info->ExpireDate.Year, license_info->ExpireDate.Month, license_info->ExpireDate.Day) : QDate()); + serialMaxBuildDate_->setValue(license_info && (license_info->Flags & HAS_MAX_BUILD_DATE) ? QDate(license_info->MaxBuildDate.Year, license_info->MaxBuildDate.Month, license_info->MaxBuildDate.Day) : QDate()); + QString userData; + if (license_info && license_info->Flags & HAS_USER_DATA) { + int bytes = 16; + for (size_t line = 0; line <= license_info->UserData.size() / bytes; line++) { + QString hex; + QString text; + for (int i = 0; i < bytes; i++) { + size_t pos = line * bytes + i; + if (pos < license_info->UserData.size()) { + uint8_t value = static_cast<uint8_t>(license_info->UserData[pos]); + hex.append(QString("%1 ").arg(value, 2, 16, QChar('0'))); + QChar qc(value); + if (qc.unicode() >= 127 || !qc.isPrint()) + qc = 0xB7; + text += qc; + } else { + if (i == 0) + break; + hex.append(" "); + text.append(" "); + } + } + if (!hex.isEmpty()) { + if (!userData.isEmpty()) + userData.append('\n'); + userData.append(QString("%1 ").arg(line * bytes, 4, 16, QChar('0'))).append(hex).append(text); + } + } + } + serialUserData_->setValue(userData); + + if (serialHWID_->childCount()) { + beginRemoveRows(propertyToIndex(serialHWID_), 0, serialHWID_->childCount()); + serialHWID_->clear(); + endRemoveRows(); + } + if (license_info && (license_info->Flags & HAS_HARDWARE_ID) && !license_info->HWID.empty()) { + size_t len = license_info->HWID.size(); + uint8_t *hwid = new uint8_t[len]; + Base64Decode(license_info->HWID.c_str(), license_info->HWID.size(), hwid, len); + beginInsertRows(propertyToIndex(serialHWID_), 0, (int)(len / 4)); + for (size_t i = 0; i < len; i += 4) { + uint32_t value = *reinterpret_cast<uint32_t *>(&hwid[i]); + QString name; + switch (value & 3) { + case 0: + name = QString::fromUtf8(language[lsCPU].c_str()); + break; + case 1: + name = QString::fromUtf8(language[lsHost].c_str()); + break; + case 2: + name = QString::fromUtf8(language[lsEthernet].c_str()); + break; + case 3: + name = QString::fromUtf8(language[lsHDD].c_str()); + break; + } + StringProperty *prop = addStringProperty(serialHWID_, name, QString("%1").arg(value & ~3, 8, 16, QChar('0')).toUpper()); + prop->setReadOnly(true); + } + delete [] hwid; + endInsertRows(); + } + + lock_ = false; +#endif +} + +/** + * FilePropertyManager + */ + +InternalFilePropertyManager::InternalFilePropertyManager(QObject *parent) + : PropertyManager(parent), value_(NULL), lock_(false) +{ + details_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetails].c_str())); + name_ = addStringProperty(details_, QString::fromUtf8(language[lsName].c_str()), QString()); + fileName_ = addFileNameProperty(details_, QString::fromUtf8(language[lsFileName].c_str()), QString( +#ifdef VMP_GNU + "%1 (*)" +#else + "%1 (*.*)" +#endif + ).arg(QString::fromUtf8(language[lsAllFiles].c_str())), QString()); + + action_ = addEnumProperty(details_, QString::fromUtf8(language[lsAction].c_str()), QStringList() << QString::fromUtf8(language[lsNo].c_str()) + << QString::fromUtf8(language[lsLoadAtStart].c_str()) << QString::fromUtf8(language[lsRegisterCOMServer].c_str()) << QString::fromUtf8(language[lsInstallCOMServer].c_str()), 0); + + connect(name_, SIGNAL(valueChanged(const QString &)), this, SLOT(nameChanged(const QString &))); + connect(fileName_, SIGNAL(valueChanged(const QString &)), this, SLOT(fileNameChanged(const QString &))); + connect(action_, SIGNAL(valueChanged(int)), this, SLOT(actionChanged(int))); +} + +void InternalFilePropertyManager::localize() +{ + details_->setName(QString::fromUtf8(language[lsDetails].c_str())); + name_->setName(QString::fromUtf8(language[lsName].c_str())); + fileName_->setName(QString::fromUtf8(language[lsFileName].c_str())); + fileName_->setFilter(QString( +#ifdef VMP_GNU + "%1 (*)" +#else + "%1 (*.*)" +#endif + ).arg(QString::fromUtf8(language[lsAllFiles].c_str()))); + action_->setName(QString::fromUtf8(language[lsAction].c_str())); + action_->setText(0, QString::fromUtf8(language[lsNo].c_str())); + action_->setText(1, QString::fromUtf8(language[lsLoadAtStart].c_str())); + action_->setText(2, QString::fromUtf8(language[lsRegisterCOMServer].c_str())); + action_->setText(3, QString::fromUtf8(language[lsInstallCOMServer].c_str())); +} + +void InternalFilePropertyManager::nameChanged(const QString &value) +{ + if (!value_ || lock_) + return; + +#ifdef ULTIMATE + value_->set_name(value.toUtf8().constData()); +#endif +} + +void InternalFilePropertyManager::fileNameChanged(const QString &value) +{ + if (!value_ || lock_) + return; + +#ifdef ULTIMATE + value_->set_file_name(value.toUtf8().constData()); +#endif +} + +void InternalFilePropertyManager::actionChanged(int value) +{ + if (!value_ || lock_) + return; + +#ifdef ULTIMATE + value_->set_action(static_cast<InternalFileAction>(value)); +#endif +} + +void InternalFilePropertyManager::setValue(InternalFile *value) +{ + value_ = value; + +#ifdef ULTIMATE + fileName_->setRelativePath(value_ ? QString::fromUtf8(value_->owner()->owner()->project_path().c_str()) : QString()); + update(); +#endif +} + +void InternalFilePropertyManager::update() +{ +#ifdef ULTIMATE + lock_ = true; + + name_->setValue(value_ ? QString::fromUtf8(value_->name().c_str()) : QString()); + fileName_->setValue(value_ ? QString::fromUtf8(value_->file_name().c_str()) : QString()); + int i = 0; + if (value_) { + switch (value_->action()) { + case faLoad: + i = 1; + break; + case faRegister: + i = 2; + break; + case faInstall: + i = 3; + break; + } + } + action_->setValue(value_ ? i : 0); + + lock_ = false; +#endif +} + +/** +* AssemblyPropertyManager +*/ + +AssemblyPropertyManager::AssemblyPropertyManager(QObject *parent) + : PropertyManager(parent), value_(NULL), lock_(false) +{ + details_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetails].c_str())); + name_ = addStringProperty(details_, QString::fromUtf8(language[lsName].c_str()), QString()); + fileName_ = addFileNameProperty(details_, QString::fromUtf8(language[lsFileName].c_str()), + QString("%1 (*.dll);;%2 (*.*)").arg(QString::fromUtf8(language[lsAssemblies].c_str())).arg(QString::fromUtf8(language[lsAllFiles].c_str())), QString()); + + connect(name_, SIGNAL(valueChanged(const QString &)), this, SLOT(nameChanged(const QString &))); + connect(fileName_, SIGNAL(valueChanged(const QString &)), this, SLOT(fileNameChanged(const QString &))); +} + +void AssemblyPropertyManager::localize() +{ + details_->setName(QString::fromUtf8(language[lsDetails].c_str())); + name_->setName(QString::fromUtf8(language[lsName].c_str())); + fileName_->setName(QString::fromUtf8(language[lsFileName].c_str())); + fileName_->setFilter(QString("%1 (*.dll);;%2 (*.*)").arg(QString::fromUtf8(language[lsAssemblies].c_str())).arg(QString::fromUtf8(language[lsAllFiles].c_str()))); +} + +void AssemblyPropertyManager::nameChanged(const QString &value) +{ + if (!value_ || lock_) + return; + +#ifdef ULTIMATE + value_->set_name(value.toUtf8().constData()); +#endif +} + +void AssemblyPropertyManager::fileNameChanged(const QString &value) +{ + if (!value_ || lock_) + return; + +#ifdef ULTIMATE + value_->set_file_name(value.toUtf8().constData()); +#endif +} + +void AssemblyPropertyManager::setValue(InternalFile *value) +{ + value_ = value; + +#ifdef ULTIMATE + fileName_->setRelativePath(value_ ? QString::fromUtf8(value_->owner()->owner()->project_path().c_str()) : QString()); + update(); +#endif +} + +void AssemblyPropertyManager::update() +{ +#ifdef ULTIMATE + lock_ = true; + + name_->setValue(value_ ? QString::fromUtf8(value_->name().c_str()) : QString()); + fileName_->setValue(value_ ? QString::fromUtf8(value_->file_name().c_str()) : QString()); + + lock_ = false; +#endif +} + +/** + * FunctionPropertyManager + */ + +FunctionPropertyManager::FunctionPropertyManager(QObject *parent) + : PropertyManager(parent), value_(NULL), lock_(false) +{ + protection_ = addGroupProperty(NULL, QString::fromUtf8(language[lsProtection].c_str())); + compilationType_ = addCompilationTypeProperty(protection_, QString::fromUtf8(language[lsCompilationType].c_str()), ctNone); + lockToKey_ = addBoolProperty(protection_, QString::fromUtf8(language[lsLockToSerialNumber].c_str()), false); + + details_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetails].c_str())); + type_ = addStringProperty(details_, QString::fromUtf8(language[lsType].c_str()), QString()); + type_->setReadOnly(true); + name_ = addStringProperty(details_, QString::fromUtf8(language[lsName].c_str()), QString()); + name_->setReadOnly(true); + address_ = addStringProperty(details_, QString::fromUtf8(language[lsAddress].c_str()), QString()); + address_->setReadOnly(true); + + connect(compilationType_, SIGNAL(valueChanged(CompilationType)), this, SLOT(compilationTypeChanged(CompilationType))); + connect(lockToKey_, SIGNAL(valueChanged(bool)), this, SLOT(lockToKeyChanged(bool))); +} + +void FunctionPropertyManager::localize() +{ + protection_->setName(QString::fromUtf8(language[lsProtection].c_str())); + compilationType_->setName(QString::fromUtf8(language[lsCompilationType].c_str())); + compilationType_->setText(0, QString::fromUtf8(language[lsNone].c_str())); + compilationType_->setText(1, QString::fromUtf8(language[lsVirtualization].c_str())); + compilationType_->setText(2, QString::fromUtf8(language[lsMutation].c_str())); + compilationType_->setText(3, QString("%1 (%2 + %3)").arg(QString::fromUtf8(language[lsUltra].c_str())).arg(QString::fromUtf8(language[lsMutation].c_str())).arg(QString::fromUtf8(language[lsVirtualization].c_str()))); + compilationType_->setToolTip(QString::fromUtf8(language[lsCompilationTypeHelp].c_str())); + + lockToKey_->setName(QString::fromUtf8(language[lsLockToSerialNumber].c_str())); + lockToKey_->setToolTip(QString::fromUtf8(language[lsLockToSerialNumberHelp].c_str())); + + details_->setName(QString::fromUtf8(language[lsDetails].c_str())); + type_->setName(QString::fromUtf8(language[lsType].c_str())); + name_->setName(QString::fromUtf8(language[lsName].c_str())); + address_->setName(QString::fromUtf8(language[lsAddress].c_str())); + + if (value_) { + for (QMap<IArchitecture *, ArchInfo>::const_iterator arch = map_.begin(); arch != map_.end(); arch++) { + QString str = QString::fromUtf8(language[lsCode].c_str()); + if (value_->show_arch_name()) + str.append(" ").append(QString::fromLatin1(arch.key()->name().c_str())); + arch.value().code->setName(str); + } + update(); + } +} + +QVariant FunctionPropertyManager::data(const QModelIndex &index, int role) const +{ + Property *prop = indexToProperty(index); + if (role == Qt::FontRole) { + if (qobject_cast<CommandProperty*>(prop)) + return QFont(MONOSPACE_FONT_FAMILY); + } + + return PropertyManager::data(index, role); +} + +void FunctionPropertyManager::setValue(FunctionBundle *value) +{ + if (value_ == value) + return; + + value_ = value; + + for (QMap<IArchitecture *, ArchInfo>::iterator arch = map_.begin(); arch != map_.end(); arch++) { + Property *code = arch.value().code; + if (code->childCount()) { + beginRemoveRows(propertyToIndex(code), 0, code->childCount()); + code->clear(); + endRemoveRows(); + } + arch.value().map.clear(); + } + + if (value_) { + for (size_t i = 0; i < value_->count(); i++) { + internalAddFunction(value_->item(i)->func()); + } + } else { + for (QMap<IArchitecture *, ArchInfo>::const_iterator arch = map_.begin(); arch != map_.end(); arch++) { + Property *code = arch.value().code; + int index = code->parent()->children().indexOf(code); + beginRemoveRows(propertyToIndex(code->parent()), index, index + 1); + delete code; + endRemoveRows(); + } + map_.clear(); + } + + update(); +} + +void FunctionPropertyManager::addFunction(IFunction *func) +{ + if (internalAddFunction(func)) + update(); +} + +void FunctionPropertyManager::createCommands(IFunction *func, Property *code) +{ + size_t i; + QMap<uint64_t, QList<ICommand*> > references; + + for (i = 0; i < func->link_list()->count(); i++) { + CommandLink *link = func->link_list()->item(i); + if (link->to_address()) { + QMap<uint64_t, QList<ICommand*> >::iterator it = references.find(link->to_address()); + if (it == references.end()) + it = references.insert(link->to_address(), QList<ICommand*>() << link->from_command()); + else + it.value().push_back(link->from_command()); + } + } + + beginInsertRows(propertyToIndex(code), 0, (int)func->count()); + for (i = 0; i < func->count(); i++) { + ICommand *command = func->item(i); + Property *prop = addCommandProperty(code, command); + prop->setReadOnly(true); + + QMap<uint64_t, QList<ICommand*> >::ConstIterator it = references.find(command->address()); + if (it != references.end()) { + for (int j = 0; j < it.value().size(); j++) { + Property *link_prop = addCommandProperty(prop, it.value().at(j)); + link_prop->setReadOnly(true); + } + } + } + endInsertRows(); +} + +bool FunctionPropertyManager::internalAddFunction(IFunction *func) +{ + if (!value_) + return false; + + FunctionArch *func_arch = value_->GetArchByFunction(func); + if (!func_arch) + return false; + + QMap<IArchitecture *, ArchInfo>::iterator arch = map_.find(func_arch->arch()); + if (arch == map_.end()) { + beginInsertRows(propertyToIndex(details_), details_->childCount(), details_->childCount() + 1); + QString str = QString::fromUtf8(language[lsCode].c_str()); + if (value_->show_arch_name()) + str.append(" ").append(QString::fromLatin1(func_arch->arch()->name().c_str())); + ArchInfo info; + info.code = addStringProperty(details_, str, QString()); + info.code->setReadOnly(true); + endInsertRows(); + arch = map_.insert(func_arch->arch(), info); + } + QMap<IFunction *, StringProperty *>::const_iterator it = arch.value().map.find(func); + if (it == arch.value().map.end()) { + StringProperty *code = arch.value().code; + if (!arch.value().map.empty()) { + if (arch.value().map.size() == 1) { + QMap<IFunction *, StringProperty *>::iterator tmp = arch.value().map.begin(); + if (tmp.value() == code) { + beginRemoveRows(propertyToIndex(code), 0, code->childCount()); + code->clear(); + endRemoveRows(); + + beginInsertRows(propertyToIndex(code), code->childCount(), code->childCount() + 1); + StringProperty *newCode = addStringProperty(code, QString::fromLatin1(tmp.key()->display_address("").c_str()), QString()); + newCode->setReadOnly(true); + endInsertRows(); + tmp.value() = newCode; + + createCommands(tmp.key(), newCode); + } + } + beginInsertRows(propertyToIndex(code), code->childCount(), code->childCount() + 1); + code = addStringProperty(code, QString::fromLatin1(func->display_address("").c_str()), QString()); + code->setReadOnly(true); + endInsertRows(); + } + it = arch.value().map.insert(func, code); + } + createCommands(func, it.value()); + + return true; +} + +void FunctionPropertyManager::updateFunction(IFunction *func) +{ + if (value_ && value_->GetArchByFunction(func)) + update(); +} + +bool FunctionPropertyManager::removeFunction(IFunction *func) +{ + if (internalRemoveFunction(func)) { + update(); + return true; + } + return false; +} + +bool FunctionPropertyManager::internalRemoveFunction(IFunction *func) +{ + if (!value_) + return false; + + FunctionArch *func_arch = value_->GetArchByFunction(func); + if (!func_arch) + return false; + + QMap<IArchitecture *, ArchInfo>::iterator arch = map_.find(func_arch->arch()); + if (arch != map_.end()) { + QMap<IFunction *, StringProperty *>::iterator it = arch.value().map.find(func); + if (it != arch.value().map.end()) { + StringProperty *code = it.value(); + if (code == arch.value().code) { + beginRemoveRows(propertyToIndex(code), 0, code->childCount()); + code->clear(); + endRemoveRows(); + } else { + int index = code->parent()->children().indexOf(code); + beginRemoveRows(propertyToIndex(code->parent()), index, index + 1); + delete code; + endRemoveRows(); + } + arch.value().map.erase(it); + } + } + + return true; +} + +void FunctionPropertyManager::update() +{ + lock_ = true; + + name_->setValue(value_ ? QString::fromUtf8(value_->display_name().c_str()) : QString()); + + QString str; + if (value_) { + switch (value_->type()) { + case otAPIMarker: + case otMarker: + str = QString::fromUtf8(language[lsMarker].c_str()); + break; + case otString: + str = QString::fromUtf8(language[lsString].c_str()); + break; + case otCode: + str = QString::fromUtf8(language[lsFunction].c_str()); + break; + case otExport: + str = QString::fromUtf8(language[lsExport].c_str()); + break; + default: + str = QString::fromUtf8(language[lsUnknown].c_str()); + break; + } + } else { + str = ""; + } + type_->setValue(str); + address_->setValue(value_ ? QString::fromUtf8(value_->display_address().c_str()) : QString()); + + compilationType_->setValue(value_ && value_->need_compile() ? value_->compilation_type() : ctNone); + compilationType_->setDefaultValue(value_ ? value_->default_compilation_type() : ctNone); + lockToKey_->setReadOnly(value_ && (!value_->need_compile() || value_->compilation_type() == ctMutation)); + lockToKey_->setValue((value_ && !lockToKey_->readOnly()) ? (value_->compilation_options() & coLockToKey) != 0 : false); + + for (QMap<IArchitecture *, ArchInfo>::const_iterator arch = map_.begin(); arch != map_.end(); arch++) { + ArchInfo info = arch.value(); + if (info.code->childCount()) + info.code->setValue(QString::number(info.code->childCount()) + " " + QString::fromUtf8(language[lsItems].c_str())); + else + info.code->setValue(QString()); + for (QMap<IFunction *, StringProperty *>::const_iterator it = info.map.begin(); it != info.map.end(); it++) { + IFunction *func = it.key(); + StringProperty *code = it.value(); + + str.clear(); + if (func->type() != otUnknown) { + str = QString::number(func->count()) + " " + QString::fromUtf8(language[lsItems].c_str()); + QString hint; + if (func->ext_command_list()->count()) { + if (!hint.isEmpty()) + hint.append(", "); + hint.append(QString::fromUtf8(language[lsExternalAddress].c_str())).append(": ").append(QString::number(func->ext_command_list()->count())); + } + if (func->break_address()) { + if (!hint.isEmpty()) + hint.append(", "); + hint.append(QString::fromUtf8(language[lsBreakAddress].c_str())); + } + if (!hint.isEmpty()) + str.append(" (").append(hint).append(")"); + } + code->setValue(str); + } + } + + lock_ = false; +} + +void FunctionPropertyManager::compilationTypeChanged(CompilationType value) +{ + if (!value_ || lock_) + return; + + if (value == ctNone) { + value_->set_need_compile(false); + } else { + value_->set_need_compile(true); + value_->set_compilation_type(value); + } +} + +void FunctionPropertyManager::lockToKeyChanged(bool value) +{ + if (!value_ || lock_) + return; + + uint32_t options = value_->compilation_options(); + if (value) { + options |= coLockToKey; + } else { + options &= ~coLockToKey; + } + value_->set_compilation_options(options); +} + +ICommand *FunctionPropertyManager::indexToCommand(const QModelIndex &index) const +{ + if (!index.isValid()) + return NULL; + + Property *prop = indexToProperty(index); + if (prop) { + if (CommandProperty *c = qobject_cast<CommandProperty*>(prop)) + return c->value(); + } + return NULL; +} + +IFunction *FunctionPropertyManager::indexToFunction(const QModelIndex &index) const +{ + if (!index.isValid()) + return NULL; + + Property *prop = indexToProperty(index); + if (prop) { + for (QMap<IArchitecture *, ArchInfo>::const_iterator arch = map_.begin(); arch != map_.end(); arch++) { + for (QMap<IFunction *, StringProperty *>::const_iterator it = arch.value().map.begin(); it != arch.value().map.end(); it++) { + if (it.value() == prop) + return it.key(); + } + } + } + return NULL; +} + +QModelIndex FunctionPropertyManager::commandToIndex(ICommand *command) const +{ + for (QMap<IArchitecture *, ArchInfo>::const_iterator arch = map_.begin(); arch != map_.end(); arch++) { + ArchInfo info = arch.value(); + for (QMap<IFunction *, StringProperty *>::const_iterator it = info.map.begin(); it != info.map.end(); it++) { + QList<Property *> propList = it.value()->children(); + for (int j = 0; j < propList.size(); j++) { + Property *prop = propList[j]; + if (reinterpret_cast<CommandProperty*>(prop)->value() == command) + return propertyToIndex(prop); + } + } + } + return QModelIndex(); +} + +/** + * SectionPropertyManager + */ + +SectionPropertyManager::SectionPropertyManager(QObject *parent) + : PropertyManager(parent), value_(NULL) +{ + details_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetails].c_str())); + + name_ = addStringProperty(details_, QString::fromUtf8(language[lsName].c_str()), QString()); + name_->setReadOnly(true); + address_ = addStringProperty(details_, QString::fromUtf8(language[lsAddress].c_str()), QString()); + address_->setReadOnly(true); + virtual_size_ = addStringProperty(details_, QString::fromUtf8(language[lsSize].c_str()), QString()); + virtual_size_->setReadOnly(true); + physical_offset_ = addStringProperty(details_, QString::fromUtf8(language[lsRawAddress].c_str()), QString()); + physical_offset_->setReadOnly(true); + physical_size_ = addStringProperty(details_, QString::fromUtf8(language[lsRawSize].c_str()), QString()); + physical_size_->setReadOnly(true); + flags_ = addStringProperty(details_, QString::fromUtf8(language[lsFlags].c_str()), QString()); + flags_->setReadOnly(true); +} + +void SectionPropertyManager::localize() +{ + details_->setName(QString::fromUtf8(language[lsDetails].c_str())); + name_->setName(QString::fromUtf8(language[lsName].c_str())); + address_->setName(QString::fromUtf8(language[lsAddress].c_str())); + virtual_size_->setName(QString::fromUtf8(language[lsSize].c_str())); + physical_offset_->setName(QString::fromUtf8(language[lsRawAddress].c_str())); + physical_size_->setName(QString::fromUtf8(language[lsRawSize].c_str())); + flags_->setName(QString::fromUtf8(language[lsFlags].c_str())); +} + +void SectionPropertyManager::setValue(ISection *value) +{ + value_ = value; + + update(); +} + +void SectionPropertyManager::update() +{ + name_->setValue(value_ ? QString::fromUtf8(value_->name().c_str()) : QString()); + address_->setValue(value_ ? QString::fromUtf8(DisplayValue(value_->address_size(), value_->address()).c_str()) : QString()); + virtual_size_->setValue(value_ ? QString::fromUtf8(DisplayValue(value_->address_size(), value_->size()).c_str()) : QString()); + physical_offset_->setValue(value_ ? QString::fromUtf8(DisplayValue(osDWord, value_->physical_offset()).c_str()) : QString()); + physical_size_->setValue(value_ ? QString::fromUtf8(DisplayValue(osDWord, value_->physical_size()).c_str()) : QString()); + flags_->setValue(value_ ? QString::fromLatin1(DisplayValue(osDWord, value_->flags()).c_str()) : QString()); +} + +/** + * SegmentPropertyManager + */ + +SegmentPropertyManager::SegmentPropertyManager(QObject *parent) + : PropertyManager(parent), value_(NULL), lock_(false) +{ + options_ = addGroupProperty(NULL, QString::fromUtf8(language[lsOptions].c_str())); + excluded_from_memory_protection_ = addBoolProperty(options_, QString::fromUtf8(language[lsExcludedFromMemoryProtection].c_str()), false); + excluded_from_packing_ = addBoolProperty(options_, QString::fromUtf8(language[lsExcludedFromPacking].c_str()), false); + + details_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetails].c_str())); + name_ = addStringProperty(details_, QString::fromUtf8(language[lsName].c_str()), QString()); + name_->setReadOnly(true); + address_ = addStringProperty(details_, QString::fromUtf8(language[lsAddress].c_str()), QString()); + address_->setReadOnly(true); + virtual_size_ = addStringProperty(details_, QString::fromUtf8(language[lsSize].c_str()), QString()); + virtual_size_->setReadOnly(true); + physical_offset_ = addStringProperty(details_, QString::fromUtf8(language[lsRawAddress].c_str()), QString()); + physical_offset_->setReadOnly(true); + physical_size_ = addStringProperty(details_, QString::fromUtf8(language[lsRawSize].c_str()), QString()); + physical_size_->setReadOnly(true); + flags_ = addStringProperty(details_, QString::fromUtf8(language[lsFlags].c_str()), QString()); + flags_->setReadOnly(true); + flag_readable_ = addBoolProperty(flags_, "Readable", false); + flag_readable_->setReadOnly(true); + flag_writable_ = addBoolProperty(flags_, "Writable", false); + flag_writable_->setReadOnly(true); + flag_executable_ = addBoolProperty(flags_, "Executable", false); + flag_executable_->setReadOnly(true); + flag_shared_ = addBoolProperty(flags_, "Shared", false); + flag_shared_->setReadOnly(true); + flag_discardable_ = addBoolProperty(flags_, "Discardable", false); + flag_discardable_->setReadOnly(true); + flag_notpaged_ = addBoolProperty(flags_, "NotPaged", false); + flag_notpaged_->setReadOnly(true); + + connect(excluded_from_packing_, SIGNAL(valueChanged(bool)), this, SLOT(excludedFromPackingChanged(bool))); + connect(excluded_from_memory_protection_, SIGNAL(valueChanged(bool)), this, SLOT(excludedFromMemoryProtectionChanged(bool))); +} + +void SegmentPropertyManager::localize() +{ + options_->setName(QString::fromUtf8(language[lsOptions].c_str())); + excluded_from_packing_->setName(QString::fromUtf8(language[lsExcludedFromPacking].c_str())); + excluded_from_memory_protection_->setName(QString::fromUtf8(language[lsExcludedFromMemoryProtection].c_str())); + + details_->setName(QString::fromUtf8(language[lsDetails].c_str())); + name_->setName(QString::fromUtf8(language[lsName].c_str())); + virtual_size_->setName(QString::fromUtf8(language[lsSize].c_str())); + address_->setName(QString::fromUtf8(language[lsAddress].c_str())); + physical_offset_->setName(QString::fromUtf8(language[lsRawAddress].c_str())); + physical_size_->setName(QString::fromUtf8(language[lsRawSize].c_str())); + flags_->setName(QString::fromUtf8(language[lsFlags].c_str())); +} + +void SegmentPropertyManager::setValue(ISection *value) +{ + value_ = value; + update(); +} + +void SegmentPropertyManager::update() +{ + lock_ = true; + + excluded_from_packing_->setValue(value_ ? value_->excluded_from_packing() : false); + excluded_from_memory_protection_->setValue(value_ ? value_->excluded_from_memory_protection() : false); + name_->setValue(value_ ? QString::fromUtf8(value_->name().c_str()) : QString()); + address_->setValue(value_ ? QString::fromUtf8(DisplayValue(value_->address_size(), value_->address()).c_str()) : QString()); + virtual_size_->setValue(value_ ? QString::fromUtf8(DisplayValue(value_->address_size(), value_->size()).c_str()) : QString()); + physical_offset_->setValue(value_ ? QString::fromUtf8(DisplayValue(osDWord, value_->physical_offset()).c_str()) : QString()); + physical_size_->setValue(value_ ? QString::fromUtf8(DisplayValue(osDWord, value_->physical_size()).c_str()) : QString()); + flags_->setValue(value_ ? QString::fromLatin1(DisplayValue(osDWord, value_->flags()).c_str()) : QString()); + uint32_t memoryType = value_ ? value_->memory_type() : mtNone; + flag_readable_->setValue(memoryType & mtReadable); + flag_writable_->setValue(memoryType & mtWritable); + flag_executable_->setValue(memoryType & mtExecutable); + flag_shared_->setValue(memoryType & mtShared); + flag_notpaged_->setValue(memoryType & mtNotPaged); + flag_discardable_->setValue(memoryType & mtDiscardable); + + lock_ = false; +} + +void SegmentPropertyManager::excludedFromPackingChanged(bool value) +{ + if (!value_ || lock_) + return; + + value_->set_excluded_from_packing(value); +} + +void SegmentPropertyManager::excludedFromMemoryProtectionChanged(bool value) +{ + if (!value_ || lock_) + return; + + value_->set_excluded_from_memory_protection(value); +} + +/** + * LoadCommandPropertyManager + */ + +LoadCommandPropertyManager::LoadCommandPropertyManager(QObject *parent) + : PropertyManager(parent), value_(NULL) +{ + details_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetails].c_str())); + + name_ = addStringProperty(details_, QString::fromUtf8(language[lsName].c_str()), QString()); + name_->setReadOnly(true); + address_ = addStringProperty(details_, QString::fromUtf8(language[lsAddress].c_str()), QString()); + address_->setReadOnly(true); + size_ = addStringProperty(details_, QString::fromUtf8(language[lsSize].c_str()), QString()); + size_->setReadOnly(true); + segment_ = addStringProperty(details_, QString::fromUtf8(language[lsSegment].c_str()), QString()); + segment_->setReadOnly(true); +} + +void LoadCommandPropertyManager::localize() +{ + details_->setName(QString::fromUtf8(language[lsDetails].c_str())); + name_->setName(QString::fromUtf8(language[lsName].c_str())); + address_->setName(QString::fromUtf8(language[lsAddress].c_str())); + size_->setName(QString::fromUtf8(language[lsSize].c_str())); + segment_->setName(QString::fromUtf8(language[lsSegment].c_str())); +} + +void LoadCommandPropertyManager::setValue(ILoadCommand *value) +{ + value_ = value; + + update(); +} + +void LoadCommandPropertyManager::update() +{ + name_->setValue(value_ ? QString::fromUtf8(value_->name().c_str()) : QString()); + address_->setValue(value_ ? QString::fromUtf8(DisplayValue(value_->address_size(), value_->address()).c_str()) : QString()); + size_->setValue(value_ ? QString::fromUtf8(DisplayValue(osDWord, value_->size()).c_str()) : QString()); + + ISection *segment = NULL; + if (value_) { + IArchitecture *file = value_->owner()->owner(); + segment = file->segment_list()->GetSectionByAddress(value_->address()); + if (file->owner()->format_name() == "ELF") { + switch (value_->type()) { + case DT_NEEDED: + case DT_PLTRELSZ: + case DT_RELASZ: + case DT_RELAENT: + case DT_STRSZ: + case DT_SYMENT: + case DT_SONAME: + case DT_RPATH: + case DT_RELSZ: + case DT_RELENT: + case DT_PLTREL: + case DT_DEBUG: + case DT_BIND_NOW: + case DT_INIT_ARRAYSZ: + case DT_FINI_ARRAYSZ: + case DT_RUNPATH: + case DT_FLAGS: + case DT_PREINIT_ARRAYSZ: + case DT_GNU_HASH: + case DT_RELACOUNT: + case DT_RELCOUNT: + case DT_FLAGS_1: + case DT_VERDEFNUM: + case DT_VERNEEDNUM: + segment = NULL; + break; + } + } + } + segment_->setValue(segment ? QString::fromUtf8(segment->name().c_str()) : QString()); +} + +/** + * ImportPropertyManager + */ + +ImportPropertyManager::ImportPropertyManager(QObject *parent) + : PropertyManager(parent), value_(NULL), func_(NULL) +{ + details_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetails].c_str())); + + name_ = addStringProperty(details_, QString::fromUtf8(language[lsName].c_str()), QString()); + name_->setReadOnly(true); + address_ = addStringProperty(details_, QString::fromUtf8(language[lsAddress].c_str()), QString()); + address_->setReadOnly(true); + references_ = addStringProperty(details_, QString::fromUtf8(language[lsReferences].c_str()), QString()); + references_->setReadOnly(true); +} + +ImportPropertyManager::~ImportPropertyManager() +{ + delete func_; +} + +void ImportPropertyManager::localize() +{ + details_->setName(QString::fromUtf8(language[lsDetails].c_str())); + name_->setName(QString::fromUtf8(language[lsName].c_str())); + address_->setName(QString::fromUtf8(language[lsAddress].c_str())); + references_->setName(QString::fromUtf8(language[lsReferences].c_str())); + references_->setValue(value_ ? QString::number(references_->childCount()) + " " + QString::fromUtf8(language[lsItems].c_str()) : QString()); +} + +QVariant ImportPropertyManager::data(const QModelIndex &index, int role) const +{ + Property *prop = indexToProperty(index); + if (role == Qt::FontRole) { + if (prop && prop->parent() == references_) + return QFont(MONOSPACE_FONT_FAMILY); + } + + return PropertyManager::data(index, role); +} + +void ImportPropertyManager::setValue(IImportFunction *value) +{ + value_ = value; + delete func_; + func_ = NULL; + + if (references_->childCount()) { + beginRemoveRows(propertyToIndex(references_), 0, references_->childCount()); + references_->clear(); + endRemoveRows(); + } + + if (value_) { + IArchitecture *file = value_->owner()->owner()->owner(); + func_ = file->function_list()->CreateFunction(); + ReferenceList *reference_list = value_->map_function()->reference_list(); + for (size_t i = 0; i < reference_list->count(); i++) { + Reference *reference = reference_list->item(i); + if (file->AddressSeek(reference->address())) + func_->ParseCommand(*file, reference->address()); + } + beginInsertRows(propertyToIndex(references_), 0, (int)reference_list->count()); + for (size_t i = 0; i < func_->count(); i++) { + Property *prop = addCommandProperty(references_, func_->item(i)); + prop->setReadOnly(true); + } + endInsertRows(); + } + + update(); +} + +void ImportPropertyManager::update() +{ + name_->setValue(value_ ? QString::fromUtf8(value_->name().c_str()) : QString()); + address_->setValue(value_ ? QString::fromUtf8(DisplayValue(value_->address_size(), value_->address()).c_str()) : QString()); + references_->setValue(value_ ? QString::number(references_->childCount()) + " " + QString::fromUtf8(language[lsItems].c_str()) : QString()); +} + +/** + * ExportPropertyManager + */ + +ExportPropertyManager::ExportPropertyManager(QObject *parent) + : PropertyManager(parent), value_(NULL) +{ + details_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetails].c_str())); + + name_ = addStringProperty(details_, QString::fromUtf8(language[lsName].c_str()), QString()); + name_->setReadOnly(true); + forwarded_ = addStringProperty(details_, "Forwarded", QString()); + forwarded_->setReadOnly(true); + address_ = addStringProperty(details_, QString::fromUtf8(language[lsAddress].c_str()), QString()); + address_->setReadOnly(true); +} + +void ExportPropertyManager::localize() +{ + details_->setName(QString::fromUtf8(language[lsDetails].c_str())); + name_->setName(QString::fromUtf8(language[lsName].c_str())); + address_->setName(QString::fromUtf8(language[lsAddress].c_str())); +} + +void ExportPropertyManager::setValue(IExport *value) +{ + value_ = value; + + update(); +} + +void ExportPropertyManager::update() +{ + name_->setValue(value_ ? QString::fromUtf8(value_->name().c_str()) : QString()); + forwarded_->setValue(value_ ? QString::fromUtf8(value_->forwarded_name().c_str()) : QString()); + address_->setValue(value_ ? QString::fromUtf8(DisplayValue(value_->address_size(), value_->address()).c_str()) : QString()); +} + +/** + * ResourcePropertyManager + */ + +ResourcePropertyManager::ResourcePropertyManager(QObject *parent) + : PropertyManager(parent), value_(NULL), lock_(false) +{ + options_ = addGroupProperty(NULL, QString::fromUtf8(language[lsPacking].c_str())); + excluded_from_packing_ = addBoolProperty(options_, QString::fromUtf8(language[lsExcludedFromPacking].c_str()), false); + + details_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetails].c_str())); + name_ = addStringProperty(details_, QString::fromUtf8(language[lsName].c_str()), QString()); + name_->setReadOnly(true); + address_ = addStringProperty(details_, QString::fromUtf8(language[lsAddress].c_str()), QString()); + address_->setReadOnly(true); + size_ = addStringProperty(details_, QString::fromUtf8(language[lsSize].c_str()), QString()); + size_->setReadOnly(true); + + connect(excluded_from_packing_, SIGNAL(valueChanged(bool)), this, SLOT(excludedFromPackingChanged(bool))); +} + +void ResourcePropertyManager::localize() +{ + options_->setName(QString::fromUtf8(language[lsOptions].c_str())); + excluded_from_packing_->setName(QString::fromUtf8(language[lsExcludedFromPacking].c_str())); + + details_->setName(QString::fromUtf8(language[lsDetails].c_str())); + name_->setName(QString::fromUtf8(language[lsName].c_str())); + address_->setName(QString::fromUtf8(language[lsAddress].c_str())); + size_->setName(QString::fromUtf8(language[lsSize].c_str())); +} + +void ResourcePropertyManager::setValue(IResource *value) +{ + value_ = value; + + update(); +} + +void ResourcePropertyManager::update() +{ + lock_ = true; + + name_->setValue(value_ ? QString::fromUtf8(value_->name().c_str()) : QString()); + address_->setValue(value_ ? QString::fromUtf8(DisplayValue(value_->address_size(), value_->address()).c_str()) : QString()); + size_->setValue(value_ ? QString::fromUtf8(DisplayValue(osDWord, value_->size()).c_str()) : QString()); + excluded_from_packing_->setValue(value_ ? value_->excluded_from_packing() : false); + + lock_ = false; +} + +void ResourcePropertyManager::excludedFromPackingChanged(bool value) +{ + if (!value_ || lock_) + return; + + value_->set_excluded_from_packing(value); +} + +/** + * CorePropertyManager + */ + +CorePropertyManager::CorePropertyManager(QObject *parent) + : PropertyManager(parent), core_(NULL), lock_(false) +{ + file_ = addGroupProperty(NULL, QString::fromUtf8(language[lsFile].c_str())); + memoryProtection_ = addBoolProperty(file_, QString::fromUtf8(language[lsMemoryProtection].c_str()), false); + connect(memoryProtection_, SIGNAL(valueChanged(bool)), this, SLOT(memoryProtectionChanged(bool))); + importProtection_ = addBoolProperty(file_, QString::fromUtf8(language[lsImportProtection].c_str()), false); + connect(importProtection_, SIGNAL(valueChanged(bool)), this, SLOT(importProtectionChanged(bool))); + resourceProtection_ = addBoolProperty(file_, QString::fromUtf8(language[lsResourceProtection].c_str()), false); + connect(resourceProtection_, SIGNAL(valueChanged(bool)), this, SLOT(resourceProtectionChanged(bool))); + packOutputFile_ = addBoolProperty(file_, QString::fromUtf8(language[lsPackOutputFile].c_str()), false); + connect(packOutputFile_, SIGNAL(valueChanged(bool)), this, SLOT(packOutputFileChanged(bool))); + outputFileName_ = addFileNameProperty(file_, QString::fromUtf8(language[lsOutputFile].c_str()), QString("%1 (" +#ifdef VMP_GNU + "*.dylib *.exe *.dll *.bpl *.ocx *.sys *.scr *.so);;%2 (*)" +#else + "*.exe *.dll *.bpl *.ocx *.sys *.scr *.dylib *.so);;%2 (*.*)" +#endif + ).arg(QString::fromUtf8(language[lsExecutableFiles].c_str())).arg(QString::fromUtf8(language[lsAllFiles].c_str())), QString(), true); + connect(outputFileName_, SIGNAL(valueChanged(const QString &)), this, SLOT(outputFileChanged(const QString &))); + + detection_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetection].c_str())); + detectionDebugger_ = addEnumProperty(detection_, QString::fromUtf8(language[lsDebugger].c_str()), QStringList() << QString::fromUtf8(language[lsNo].c_str()) << "User-mode" << "User-mode + Kernel-mode", 0); + connect(detectionDebugger_, SIGNAL(valueChanged(int)), this, SLOT(detectionDebuggerChanged(int))); + detectionVMTools_ = addBoolProperty(detection_, QString::fromUtf8(language[lsVirtualizationTools].c_str()), false); + connect(detectionVMTools_, SIGNAL(valueChanged(bool)), this, SLOT(detectioncpVMToolsChanged(bool))); + + additional_ = addGroupProperty(NULL, QString::fromUtf8(language[lsAdditional].c_str())); + vmSectionName_ = addStringProperty(additional_, QString::fromUtf8(language[lsVMSegments].c_str()), QString()); + connect(vmSectionName_, SIGNAL(valueChanged(const QString &)), this, SLOT(vmSectionNameChanged(const QString &))); + stripDebugInfo_ = addBoolProperty(additional_, QString::fromUtf8(language[lsStripDebugInfo].c_str()), false); + connect(stripDebugInfo_, SIGNAL(valueChanged(bool)), this, SLOT(stripDebugInfoChanged(bool))); + stripRelocations_ = addBoolProperty(additional_, QString::fromUtf8(language[lsStripRelocations].c_str()), false); + connect(stripRelocations_, SIGNAL(valueChanged(bool)), this, SLOT(stripRelocationsChanged(bool))); +#ifndef LITE + watermarkName_ = addWatermarkProperty(additional_, QString::fromUtf8(language[lsWatermark].c_str()), QString()); + connect(watermarkName_, SIGNAL(valueChanged(const QString &)), this, SLOT(watermarkNameChanged(const QString &))); +#ifdef ULTIMATE + hwid_ = addStringProperty(additional_, QString::fromUtf8(language[lsLockToHWID].c_str()), QString()); + connect(hwid_, SIGNAL(valueChanged(const QString &)), this, SLOT(hwidChanged(const QString &))); +#ifdef DEMO + if (true) +#else + if (VMProtectGetSerialNumberState() != SERIAL_STATE_SUCCESS) +#endif + { + size_t size = VMProtectGetCurrentHWID(NULL, 0); + char *hwid = new char[size]; + VMProtectGetCurrentHWID(hwid, (int)size); + hwid_->setValue(QString().fromLatin1(hwid)); + hwid_->setReadOnly(true); + delete [] hwid; + } + +#endif + + messages_ = addGroupProperty(NULL, QString::fromUtf8(language[lsMessages].c_str())); + messageDebuggerFound_ = addStringListProperty(messages_, QString::fromUtf8(language[lsDebuggerFound].c_str()), QString()); + connect(messageDebuggerFound_, SIGNAL(valueChanged(const QString &)), this, SLOT(messageDebuggerFoundChanged(const QString &))); + messageVMToolsFound_ = addStringListProperty(messages_, QString::fromUtf8(language[lsVirtualizationToolsFound].c_str()), QString()); + connect(messageVMToolsFound_, SIGNAL(valueChanged(const QString &)), this, SLOT(messageVMToolsFoundChanged(const QString &))); + messageFileCorrupted_ = addStringListProperty(messages_, QString::fromUtf8(language[lsFileCorrupted].c_str()), QString()); + connect(messageFileCorrupted_, SIGNAL(valueChanged(const QString &)), this, SLOT(messageFileCorruptedChanged(const QString &))); + messageSerialNumberRequired_ = addStringListProperty(messages_, QString::fromUtf8(language[lsSerialNumberRequired].c_str()), QString()); + connect(messageSerialNumberRequired_, SIGNAL(valueChanged(const QString &)), this, SLOT(messageSerialNumberRequiredChanged(const QString &))); + messageHWIDMismatched_ = addStringListProperty(messages_, QString::fromUtf8(language[lsHWIDMismatched].c_str()), QString()); + connect(messageHWIDMismatched_, SIGNAL(valueChanged(const QString &)), this, SLOT(messageHWIDMismatchedChanged(const QString &))); +#endif + +#ifdef ULTIMATE + licensingParameters_ = addGroupProperty(NULL, QString::fromUtf8(language[lsLicensingParameters].c_str())); + licenseDataFileName_ = addFileNameProperty(licensingParameters_, QString::fromUtf8(language[lsFileName].c_str()), QString("%1 (*.vmp);;" +#ifdef VMP_GNU + " %2 (*)" +#else + " %2 (*.*)" +#endif + ).arg(QString::fromUtf8(language[lsProjectFiles].c_str())).arg(QString::fromUtf8(language[lsAllFiles].c_str())), QString()); + connect(licenseDataFileName_, SIGNAL(valueChanged(const QString &)), this, SLOT(licenseDataFileNameChanged(const QString &))); + keyPairAlgorithm_ = addStringProperty(licensingParameters_, QString::fromUtf8(language[lsKeyPairAlgorithm].c_str()), QString()); + keyPairAlgorithm_->setReadOnly(true); + activationServer_ = addStringProperty(licensingParameters_, QString::fromUtf8(language[lsActivationServer].c_str()), QString()); + connect(activationServer_, SIGNAL(valueChanged(const QString &)), this, SLOT(activationServerChanged(const QString &))); +#endif +} + +void CorePropertyManager::localize() +{ + file_->setName(QString::fromUtf8(language[lsFile].c_str())); + memoryProtection_->setName(QString::fromUtf8(language[lsMemoryProtection].c_str())); + memoryProtection_->setToolTip(QString::fromUtf8(language[lsMemoryProtectionHelp].c_str())); + importProtection_->setName(QString::fromUtf8(language[lsImportProtection].c_str())); + importProtection_->setToolTip(QString::fromUtf8(language[lsImportProtectionHelp].c_str())); + resourceProtection_->setName(QString::fromUtf8(language[lsResourceProtection].c_str())); + resourceProtection_->setToolTip(QString::fromUtf8(language[lsResourceProtectionHelp].c_str())); + packOutputFile_->setName(QString::fromUtf8(language[lsPackOutputFile].c_str())); + packOutputFile_->setToolTip(QString::fromUtf8(language[lsPackOutputFileHelp].c_str())); +#ifndef LITE + watermarkName_->setName(QString::fromUtf8(language[lsWatermark].c_str())); + watermarkName_->setToolTip(QString::fromUtf8(language[lsWatermarkHelp].c_str())); +#endif + outputFileName_->setName(QString::fromUtf8(language[lsOutputFile].c_str())); + outputFileName_->setFilter(QString("%1 (" +#ifdef VMP_GNU + "*.dylib *.exe *.dll *.bpl *.ocx *.sys *.scr *.so);;%2 (*)" +#else + "*.exe *.dll *.bpl *.ocx *.sys *.scr *.dylib *.so);;%2 (*.*)" +#endif + ).arg(QString::fromUtf8(language[lsExecutableFiles].c_str())).arg(QString::fromUtf8(language[lsAllFiles].c_str()))); + + detection_->setName(QString::fromUtf8(language[lsDetection].c_str())); + detectionDebugger_->setName(QString::fromUtf8(language[lsDebugger].c_str())); + detectionDebugger_->setToolTip(QString::fromUtf8(language[lsDebuggerHelp].c_str())); + detectionDebugger_->setText(0, QString::fromUtf8(language[lsNo].c_str())); + detectionVMTools_->setName(QString::fromUtf8(language[lsVirtualizationTools].c_str())); + detectionVMTools_->setToolTip(QString::fromUtf8(language[lsVirtualizationToolsHelp].c_str())); + +#ifndef LITE + messages_->setName(QString::fromUtf8(language[lsMessages].c_str())); + messageDebuggerFound_->setName(QString::fromUtf8(language[lsDebuggerFound].c_str())); + messageVMToolsFound_->setName(QString::fromUtf8(language[lsVirtualizationToolsFound].c_str())); + messageFileCorrupted_->setName(QString::fromUtf8(language[lsFileCorrupted].c_str())); + messageSerialNumberRequired_->setName(QString::fromUtf8(language[lsSerialNumberRequired].c_str())); + messageHWIDMismatched_->setName(QString::fromUtf8(language[lsHWIDMismatched].c_str())); +#endif + + additional_->setName(QString::fromUtf8(language[lsAdditional].c_str())); + vmSectionName_->setName(QString::fromUtf8(language[lsVMSegments].c_str())); + vmSectionName_->setToolTip(QString::fromUtf8(language[lsVMSegmentsHelp].c_str())); + stripDebugInfo_->setName(QString::fromUtf8(language[lsStripDebugInfo].c_str())); + stripRelocations_->setName(QString::fromUtf8(language[lsStripRelocations].c_str())); + +#ifdef ULTIMATE + hwid_->setName(QString::fromUtf8(language[lsLockToHWID].c_str())); + licensingParameters_->setName(QString::fromUtf8(language[lsLicensingParameters].c_str())); + licensingParameters_->setToolTip(QString::fromUtf8(language[lsLicensingParametersHelp].c_str())); + licenseDataFileName_->setName(QString::fromUtf8(language[lsFileName].c_str())); + licenseDataFileName_->setFilter(QString( +#ifdef VMP_GNU + "%1 (*.vmp);;%2 (*)" +#else + "%1 (*.vmp);;%2 (*.*)" +#endif + ).arg(QString::fromUtf8(language[lsProjectFiles].c_str())).arg(QString::fromUtf8(language[lsAllFiles].c_str()))); + keyPairAlgorithm_->setName(QString::fromUtf8(language[lsKeyPairAlgorithm].c_str())); + if (keyPairAlgorithm_->childCount()) { + QList<Property *> keyProps = keyPairAlgorithm_->children(); + keyProps[0]->setName(QString::fromUtf8(language[lsPublicExp].c_str())); + keyProps[1]->setName(QString::fromUtf8(language[lsPrivateExp].c_str())); + keyProps[2]->setName(QString::fromUtf8(language[lsModulus].c_str())); + keyProps[3]->setName(QString::fromUtf8(language[lsProductCode].c_str())); + } else { + keyPairAlgorithm_->setValue(QString::fromUtf8(language[lsNone].c_str())); + } + activationServer_->setName(QString::fromUtf8(language[lsActivationServer].c_str())); +#endif +} + +void CorePropertyManager::setCore(Core *core) +{ + core_ = core; + if (core_ && core_->input_file()) { + uint32_t disable_options = core_->input_file()->disable_options(); + stripRelocations_->setReadOnly(disable_options & cpStripFixups); + importProtection_->setReadOnly(disable_options & cpImportProtection); + resourceProtection_->setReadOnly(disable_options & cpResourceProtection); + packOutputFile_->setReadOnly(disable_options & cpPack); + } + outputFileName_->setRelativePath(core ? QString::fromUtf8(core->project_path().c_str()) : QString()); +#ifdef ULTIMATE + licenseDataFileName_->setRelativePath(core ? QString::fromUtf8(core->project_path().c_str()) : QString()); +#endif + update(); +} + +QVariant CorePropertyManager::data(const QModelIndex &index, int role) const +{ + if (role == Qt::FontRole) { +#ifdef ULTIMATE + Property *prop = indexToProperty(index); + if (prop && prop->parent() == keyPairAlgorithm_ && index.column() == 1) + return QFont(MONOSPACE_FONT_FAMILY); +#endif + } + + return PropertyManager::data(index, role); +} + +void CorePropertyManager::update() +{ + lock_ = true; + + uint32_t options = core_ ? core_->options() : 0; + if (core_ && core_->input_file()) + options &= ~core_->input_file()->disable_options(); + memoryProtection_->setValue(core_ ? (options & cpMemoryProtection) != 0 : false); + importProtection_->setValue(core_ ? (options & cpImportProtection) != 0 : false); + resourceProtection_->setValue(core_ ? (options & cpResourceProtection) != 0 : false); + packOutputFile_->setValue(core_ ? (options & cpPack) != 0 : false); +#ifndef LITE + watermarkName_->setValue(core_ ? QString::fromUtf8(core_->watermark_name().c_str()) : QString()); +#endif + outputFileName_->setValue(core_ ? QString::fromUtf8(core_->output_file_name().c_str()) : QString()); + int i; + switch (options & (cpCheckDebugger | cpCheckKernelDebugger)) { + case cpCheckDebugger: + i = 1; + break; + case cpCheckDebugger | cpCheckKernelDebugger: + i = 2; + break; + default: + i = 0; + break; + } + detectionDebugger_->setValue(core_ ? i : 0); + detectionVMTools_->setValue(core_ ? (options & cpCheckVirtualMachine) != 0 : false); +#ifndef LITE + messageDebuggerFound_->setValue(core_ ? QString::fromUtf8(core_->message(MESSAGE_DEBUGGER_FOUND).c_str()) : QString()); + messageVMToolsFound_->setValue(core_ ? QString::fromUtf8(core_->message(MESSAGE_VIRTUAL_MACHINE_FOUND).c_str()) : QString()); + messageFileCorrupted_->setValue(core_ ? QString::fromUtf8(core_->message(MESSAGE_FILE_CORRUPTED).c_str()) : QString()); + messageSerialNumberRequired_->setValue(core_ ? QString::fromUtf8(core_->message(MESSAGE_SERIAL_NUMBER_REQUIRED).c_str()) : QString()); + messageHWIDMismatched_->setValue(core_ ? QString::fromUtf8(core_->message(MESSAGE_HWID_MISMATCHED).c_str()) : QString()); +#endif + + vmSectionName_->setValue(core_ ? QString::fromUtf8(core_->vm_section_name().c_str()) : QString()); + stripDebugInfo_->setValue(core_ ? (options & cpStripDebugInfo) != 0 : false); + stripRelocations_->setValue(core_ ? (options & cpStripFixups) != 0 : false); + +#ifdef ULTIMATE + if (!hwid_->readOnly()) + hwid_->setValue(core_ ? QString::fromUtf8(core_->hwid().c_str()) : QString()); + licenseDataFileName_->setValue(core_ ? QString::fromUtf8(core_->license_data_file_name().c_str()) : QString()); + QString str; + if (core_) { + LicensingManager *licensingManager = core_->licensing_manager(); + switch (licensingManager->algorithm()) { + case alNone: + str = QString::fromUtf8(language[lsNone].c_str()); + if (keyPairAlgorithm_->childCount()) { + beginRemoveRows(propertyToIndex(keyPairAlgorithm_), 0, keyPairAlgorithm_->childCount()); + keyPairAlgorithm_->clear(); + endRemoveRows(); + } + break; + case alRSA: + str = QString("RSA %1").arg(licensingManager->bits()); + if (!keyPairAlgorithm_->childCount()) { + beginInsertRows(propertyToIndex(keyPairAlgorithm_), 0, 4); + + StringProperty *prop = addStringProperty(keyPairAlgorithm_, QString::fromUtf8(language[lsPublicExp].c_str()), QString()); + prop->setReadOnly(true); + + prop = addStringProperty(keyPairAlgorithm_, QString::fromUtf8(language[lsPrivateExp].c_str()), QString()); + prop->setReadOnly(true); + + prop = addStringProperty(keyPairAlgorithm_, QString::fromUtf8(language[lsModulus].c_str()), QString()); + prop->setReadOnly(true); + + prop = addStringProperty(keyPairAlgorithm_, QString::fromUtf8(language[lsProductCode].c_str()), QString()); + prop->setReadOnly(true); + + endInsertRows(); + } + QList<Property *> list = keyPairAlgorithm_->children(); + reinterpret_cast<StringProperty *>(list.at(0))->setValue(QString::fromLatin1(formatVector(licensingManager->public_exp()).c_str())); + reinterpret_cast<StringProperty *>(list.at(1))->setValue(QString::fromLatin1(formatVector(licensingManager->private_exp()).c_str())); + reinterpret_cast<StringProperty *>(list.at(2))->setValue(QString::fromLatin1(formatVector(licensingManager->modulus()).c_str())); + uint64_t product_code = licensingManager->product_code(); + reinterpret_cast<StringProperty *>(list.at(3))->setValue(QByteArray(reinterpret_cast<char *>(&product_code), sizeof(product_code)).toBase64()); + break; + } + } + keyPairAlgorithm_->setValue(str); + activationServer_->setValue(core_ ? QString::fromUtf8(core_->activation_server().c_str()) : QString()); +#endif + + lock_ = false; +} + +void CorePropertyManager::memoryProtectionChanged(bool value) +{ + if (!core_ || lock_) + return; + + if (value) { + core_->include_option(cpMemoryProtection); + } else { + core_->exclude_option(cpMemoryProtection); + } +} + +void CorePropertyManager::importProtectionChanged(bool value) +{ + if (!core_ || lock_) + return; + + if (value) { + core_->include_option(cpImportProtection); + } else { + core_->exclude_option(cpImportProtection); + } +} + +void CorePropertyManager::resourceProtectionChanged(bool value) +{ + if (!core_ || lock_) + return; + + if (value) { + core_->include_option(cpResourceProtection); + } else { + core_->exclude_option(cpResourceProtection); + } +} + +void CorePropertyManager::packOutputFileChanged(bool value) +{ + if (!core_ || lock_) + return; + + if (value) { + core_->include_option(cpPack); + } else { + core_->exclude_option(cpPack); + } +} + +void CorePropertyManager::watermarkNameChanged(const QString &value) +{ + if (!core_ || lock_) + return; + + core_->set_watermark_name(value.toUtf8().constData()); +} + +void CorePropertyManager::outputFileChanged(const QString &value) +{ + if (!core_ || lock_) + return; + + core_->set_output_file_name(value.toUtf8().constData()); +} + +void CorePropertyManager::detectionDebuggerChanged(int value) +{ + if (!core_ || lock_) + return; + + if (value) + core_->include_option(cpCheckDebugger); + else + core_->exclude_option(cpCheckDebugger); + if (value == 2) + core_->include_option(cpCheckKernelDebugger); + else + core_->exclude_option(cpCheckKernelDebugger); +} + +void CorePropertyManager::detectioncpVMToolsChanged(bool value) +{ + if (!core_ || lock_) + return; + + if (value) { + core_->include_option(cpCheckVirtualMachine); + } else { + core_->exclude_option(cpCheckVirtualMachine); + } +} + +void CorePropertyManager::vmSectionNameChanged(const QString &value) +{ + if (!core_ || lock_) + return; + + core_->set_vm_section_name(value.toUtf8().constData()); +} + +void CorePropertyManager::stripDebugInfoChanged(bool value) +{ + if (!core_ || lock_) + return; + + if (value) { + core_->include_option(cpStripDebugInfo); + } else { + core_->exclude_option(cpStripDebugInfo); + } +} + +void CorePropertyManager::stripRelocationsChanged(bool value) +{ + if (!core_ || lock_) + return; + + if (value) { + core_->include_option(cpStripFixups); + } else { + core_->exclude_option(cpStripFixups); + } +} + +void CorePropertyManager::debugModeChanged(bool value) +{ + if (!core_ || lock_) + return; + + if (value) { + core_->include_option(cpDebugMode); + } else { + core_->exclude_option(cpDebugMode); + } +} + +void CorePropertyManager::messageDebuggerFoundChanged(const QString &value) +{ + if (!core_ || lock_) + return; + + core_->set_message(MESSAGE_DEBUGGER_FOUND, value.toUtf8().constData()); +} + +void CorePropertyManager::messageVMToolsFoundChanged(const QString &value) +{ + if (!core_ || lock_) + return; + + core_->set_message(MESSAGE_VIRTUAL_MACHINE_FOUND, value.toUtf8().constData()); +} + +void CorePropertyManager::messageFileCorruptedChanged(const QString &value) +{ + if (!core_ || lock_) + return; + + core_->set_message(MESSAGE_FILE_CORRUPTED, value.toUtf8().constData()); +} + +void CorePropertyManager::messageSerialNumberRequiredChanged(const QString &value) +{ + if (!core_ || lock_) + return; + + core_->set_message(MESSAGE_SERIAL_NUMBER_REQUIRED, value.toUtf8().constData()); +} + +void CorePropertyManager::messageHWIDMismatchedChanged(const QString &value) +{ + if (!core_ || lock_) + return; + + core_->set_message(MESSAGE_HWID_MISMATCHED, value.toUtf8().constData()); +} + +#ifdef ULTIMATE +void CorePropertyManager::hwidChanged(const QString &value) +{ + if (!core_ || lock_) + return; + + core_->set_hwid(value.toUtf8().constData()); +} + +void CorePropertyManager::licenseDataFileNameChanged(const QString &value) +{ + if (!core_ || lock_) + return; + + core_->set_license_data_file_name(value.toUtf8().constData()); +} + +void CorePropertyManager::activationServerChanged(const QString &value) +{ + if (!core_ || lock_) + return; + + core_->set_activation_server(value.toUtf8().constData()); +} +#else +void CorePropertyManager::hwidChanged(const QString &) {} +void CorePropertyManager::licenseDataFileNameChanged(const QString &) {} +void CorePropertyManager::activationServerChanged(const QString &) {} +#endif + +/** + * WatermarkPropertyManager + */ + +WatermarkPropertyManager::WatermarkPropertyManager(QObject *parent) + : PropertyManager(parent), lock_(false), watermark_(NULL) +{ + GroupProperty *details_ = addGroupProperty(NULL, QString::fromUtf8(language[lsDetails].c_str())); + name_ = addStringProperty(details_, QString::fromUtf8(language[lsName].c_str()), QString()); + blocked_ = addBoolProperty(details_, QString::fromUtf8(language[lsBlocked].c_str()), false); + useCount_ = addStringProperty(details_, QString::fromUtf8(language[lsUsageCount].c_str()), QString()); + useCount_->setReadOnly(true); + + connect(name_, SIGNAL(valueChanged(const QString &)), this, SLOT(nameChanged(const QString &))); + connect(blocked_, SIGNAL(valueChanged(bool)), this, SLOT(blockedChanged(bool))); +} + +void WatermarkPropertyManager::setWatermark(Watermark *watermark) +{ + watermark_ = watermark; + update(); +} + +void WatermarkPropertyManager::update() +{ + lock_ = true; + + name_->setValue(watermark_ ? QString::fromUtf8(watermark_->name().c_str()) : QString()); + blocked_->setValue(watermark_ ? !watermark_->enabled() : false); + useCount_->setValue(watermark_ ? QString::number(watermark_->use_count()) : QString()); + + lock_ = false; +} + +void WatermarkPropertyManager::nameChanged(const QString &value) +{ + if (!watermark_ || lock_) + return; + + watermark_->set_name(value.toUtf8().constData()); +} + +void WatermarkPropertyManager::blockedChanged(bool value) +{ + if (!watermark_ || lock_) + return; + + watermark_->set_enabled(!value); +} + +/** + * AddressCalculator + */ + +AddressCalculator::AddressCalculator(QObject *parent) + : PropertyManager(parent), lock_(false), file_(NULL) +{ + address_ = addStringProperty(NULL, QString::fromUtf8(language[lsAddress].c_str()), QString()); + offset_ = addStringProperty(NULL, QString::fromUtf8(language[lsRawAddress].c_str()), QString()); + segment_ = addEnumProperty(NULL, QString::fromUtf8(language[lsSegment].c_str()), QStringList(), -1); + + connect(address_, SIGNAL(valueChanged(const QString &)), this, SLOT(addressChanged(const QString &))); + connect(offset_, SIGNAL(valueChanged(const QString &)), this, SLOT(offsetChanged(const QString &))); + connect(segment_, SIGNAL(valueChanged(int)), this, SLOT(segmentChanged(int))); +} + +void AddressCalculator::localize() +{ + address_->setName(QString::fromUtf8(language[lsAddress].c_str())); + offset_->setName(QString::fromUtf8(language[lsRawAddress].c_str())); + segment_->setName(QString::fromUtf8(language[lsSegment].c_str())); +} + +void AddressCalculator::setValue(IArchitecture *file) +{ + if (file_ == file) + return; + + file_ = file; + + lock_ = true; + address_->setValue(QString()); + offset_->setValue(QString()); + QStringList segments; + if (file_) { + for (size_t i = 0; i < file_->segment_list()->count(); i++) { + segments.push_back(QString::fromUtf8(file_->segment_list()->item(i)->name().c_str())); + } + } + segment_->setValue(-1); + segment_->setItems(segments); + lock_ = false; +} + +void AddressCalculator::addressChanged(const QString &value) +{ + if (!file_ || lock_) + return; + + lock_ = true; + bool is_valid; + ISection *segment = NULL; + uint64_t address = value.toULongLong(&is_valid, 16); + if (is_valid) + segment = file_->segment_list()->GetSectionByAddress(address); + offset_->setValue(segment ? QString::fromUtf8(DisplayValue(osDWord, segment->physical_offset() + address - segment->address()).c_str()) : QString()); + segment_->setValue(segment ? (int)file_->segment_list()->IndexOf(segment) : -1); + lock_ = false; +} + +void AddressCalculator::offsetChanged(const QString &value) +{ + if (!file_ || lock_) + return; + + lock_ = true; + bool is_valid; + ISection *segment = NULL; + uint64_t offset = value.toULongLong(&is_valid, 16); + if (is_valid) + segment = file_->segment_list()->GetSectionByOffset(offset); + uint64_t address = segment ? segment->address() + offset - segment->physical_offset() : 0; + address_->setValue(segment ? QString::fromUtf8(DisplayValue(file_->cpu_address_size(), address).c_str()) : QString()); + segment_->setValue(segment ? (int)file_->segment_list()->IndexOf(segment) : -1); + lock_ = false; +} + +void AddressCalculator::segmentChanged(int value) +{ + if (!file_ || lock_) + return; + + lock_ = true; + ISection *segment = file_->segment_list()->item(value); + uint64_t address = segment ? segment->address() : 0; + address_->setValue(segment ? QString::fromUtf8(DisplayValue(file_->cpu_address_size(), address).c_str()) : QString()); + offset_->setValue(segment ? QString::fromUtf8(DisplayValue(osDWord, segment->physical_offset() + address - segment->address()).c_str()) : QString()); + lock_ = false; +}
\ No newline at end of file |