void IqtFit::unFixItem() {
QtBrowserItem *item = m_ffTree->currentItem();
QtProperty *prop = item->property();
if (prop->subProperties().empty()) {
item = item->parent();
prop = item->property();
}
item->parent()->property()->addSubProperty(m_fixedProps[prop]);
item->parent()->property()->removeSubProperty(prop);
m_fixedProps.remove(prop);
QtProperty *proplbl = prop->subProperties()[0];
delete proplbl;
delete prop;
}
/** The move up button was clicked
*/
void QtSpacescapeMainWindow::onMoveLayerUp()
{
// get the selected layer
int layerId = getSelectedLayerId();
if(layerId > -1) {
if(ui->ogreWindow->moveLayerUp(layerId)) {
QList<QtBrowserItem *> bl = ui->layerProperties->topLevelItems();
unsigned int index = bl.size() - layerId - 1;
QtProperty *p = bl[index]->property();
// save expanded settings
bool expanded = ui->layerProperties->isExpanded(bl[index]);
// remove and re-insert at the new location
ui->layerProperties->removeProperty(p);
if(index == 1) {
ui->layerProperties->insertProperty(p, NULL);
}
else {
ui->layerProperties->insertProperty(p,bl[index - 2]->property());
}
// re-apply property tree visiblity settings
bl = ui->layerProperties->topLevelItems();
ui->layerProperties->setExpanded(bl[index - 1],expanded);
// un-expand the color items
QList<QtProperty *> sl = p->subProperties();
for(int i = 0; i < sl.size(); i++) {
if(((QtVariantProperty*)sl[i])->propertyType() == QVariant::Color) {
QList<QtBrowserItem *> bi = ui->layerProperties->items(sl[i]);
ui->layerProperties->setExpanded(bi.first(),false);
}
}
// re-select the item
ui->layerProperties->setFocus();
ui->layerProperties->setCurrentItem(bl[index - 1]);
}
}
}
/**
* Slot responding on a change of a masking shape.
*/
void InstrumentWindowMaskTab::shapeChanged()
{
if (!m_left) return; // check that everything is ok
m_userEditing = false; // this prevents resetting shape proeprties by doubleChanged(...)
RectF rect = m_instrWindow->getSurface()->getCurrentBoundingRect();
m_doubleManager->setValue(m_left,rect.x0());
m_doubleManager->setValue(m_top,rect.y1());
m_doubleManager->setValue(m_right,rect.x1());
m_doubleManager->setValue(m_bottom,rect.y0());
for(QMap<QtProperty *,QString>::iterator it = m_doublePropertyMap.begin(); it != m_doublePropertyMap.end(); ++it)
{
m_doubleManager->setValue(it.key(),m_instrWindow->getSurface()->getCurrentDouble(it.value()));
}
for(QMap<QString,QtProperty *>::iterator it = m_pointPropertyMap.begin(); it != m_pointPropertyMap.end(); ++it)
{
QtProperty* prop = it.value();
QList<QtProperty*> subs = prop->subProperties();
if (subs.size() != 2) continue;
QPointF p = m_instrWindow->getSurface()->getCurrentPoint(it.key());
m_doubleManager->setValue(subs[0],p.x());
m_doubleManager->setValue(subs[1],p.y());
}
m_userEditing = true;
}
void PropertyEditor::setObject(QObject *object)
{
QDesignerFormWindowInterface *oldFormWindow = QDesignerFormWindowInterface::findFormWindow(m_object);
// In the first setObject() call following the addition of a dynamic property, focus and edit it.
const bool editNewDynamicProperty = object != 0 && m_object == object && !m_recentlyAddedDynamicProperty.isEmpty();
m_object = object;
m_propertyManager->setObject(object);
QDesignerFormWindowInterface *formWindow = QDesignerFormWindowInterface::findFormWindow(m_object);
FormWindowBase *fwb = qobject_cast<FormWindowBase *>(formWindow);
m_treeFactory->setFormWindowBase(fwb);
m_groupFactory->setFormWindowBase(fwb);
storeExpansionState();
UpdateBlocker ub(this);
updateToolBarLabel();
QMap<QString, QtVariantProperty *> toRemove = m_nameToProperty;
const QDesignerDynamicPropertySheetExtension *dynamicSheet =
qt_extension<QDesignerDynamicPropertySheetExtension*>(m_core->extensionManager(), m_object);
const QDesignerPropertySheet *sheet = qobject_cast<QDesignerPropertySheet*>(m_core->extensionManager()->extension(m_object, Q_TYPEID(QDesignerPropertySheetExtension)));
// Optimizization: Instead of rebuilding the complete list every time, compile a list of properties to remove,
// remove them, traverse the sheet, in case property exists just set a value, otherwise - create it.
QExtensionManager *m = m_core->extensionManager();
m_propertySheet = qobject_cast<QDesignerPropertySheetExtension*>(m->extension(object, Q_TYPEID(QDesignerPropertySheetExtension)));
if (m_propertySheet) {
const int propertyCount = m_propertySheet->count();
for (int i = 0; i < propertyCount; ++i) {
if (!m_propertySheet->isVisible(i))
continue;
const QString propertyName = m_propertySheet->propertyName(i);
if (m_propertySheet->indexOf(propertyName) != i)
continue;
const QString groupName = m_propertySheet->propertyGroup(i);
const QMap<QString, QtVariantProperty *>::const_iterator rit = toRemove.constFind(propertyName);
if (rit != toRemove.constEnd()) {
QtVariantProperty *property = rit.value();
if (m_propertyToGroup.value(property) == groupName && toBrowserType(m_propertySheet->property(i), propertyName) == property->propertyType())
toRemove.remove(propertyName);
}
}
}
QMapIterator<QString, QtVariantProperty *> itRemove(toRemove);
while (itRemove.hasNext()) {
itRemove.next();
QtVariantProperty *property = itRemove.value();
m_nameToProperty.remove(itRemove.key());
m_propertyToGroup.remove(property);
delete property;
}
if (oldFormWindow != formWindow)
reloadResourceProperties();
bool isMainContainer = false;
if (QWidget *widget = qobject_cast<QWidget*>(object)) {
if (QDesignerFormWindowInterface *fw = QDesignerFormWindowInterface::findFormWindow(widget)) {
isMainContainer = (fw->mainContainer() == widget);
}
}
m_groups.clear();
if (m_propertySheet) {
QtProperty *lastProperty = 0;
QtProperty *lastGroup = 0;
const int propertyCount = m_propertySheet->count();
for (int i = 0; i < propertyCount; ++i) {
if (!m_propertySheet->isVisible(i))
continue;
const QString propertyName = m_propertySheet->propertyName(i);
if (m_propertySheet->indexOf(propertyName) != i)
continue;
const QVariant value = m_propertySheet->property(i);
const int type = toBrowserType(value, propertyName);
QtVariantProperty *property = m_nameToProperty.value(propertyName, 0);
bool newProperty = property == 0;
if (newProperty) {
property = m_propertyManager->addProperty(type, propertyName);
if (property) {
newProperty = true;
if (type == DesignerPropertyManager::enumTypeId()) {
const PropertySheetEnumValue e = qvariant_cast<PropertySheetEnumValue>(value);
QStringList names;
QStringListIterator it(e.metaEnum.keys());
while (it.hasNext())
names.append(it.next());
m_updatingBrowser = true;
property->setAttribute(m_strings.m_enumNamesAttribute, names);
m_updatingBrowser = false;
} else if (type == DesignerPropertyManager::designerFlagTypeId()) {
const PropertySheetFlagValue f = qvariant_cast<PropertySheetFlagValue>(value);
QList<QPair<QString, uint> > flags;
QStringListIterator it(f.metaFlags.keys());
while (it.hasNext()) {
const QString name = it.next();
const uint val = f.metaFlags.keyToValue(name);
flags.append(qMakePair(name, val));
}
m_updatingBrowser = true;
QVariant v;
qVariantSetValue(v, flags);
property->setAttribute(m_strings.m_flagsAttribute, v);
m_updatingBrowser = false;
}
}
}
if (property != 0) {
const bool dynamicProperty = (dynamicSheet && dynamicSheet->isDynamicProperty(i))
|| (sheet && sheet->isDefaultDynamicProperty(i));
switch (type) {
case QVariant::Palette:
setupPaletteProperty(property);
break;
case QVariant::KeySequence:
//addCommentProperty(property, propertyName);
break;
default:
break;
}
if (type == QVariant::String || type == qMetaTypeId<PropertySheetStringValue>())
setupStringProperty(property, isMainContainer);
property->setAttribute(m_strings.m_resettableAttribute, m_propertySheet->hasReset(i));
const QString groupName = m_propertySheet->propertyGroup(i);
QtVariantProperty *groupProperty = 0;
if (newProperty) {
QMap<QString, QtVariantProperty*>::const_iterator itPrev = m_nameToProperty.insert(propertyName, property);
m_propertyToGroup[property] = groupName;
if (m_sorting) {
QtProperty *previous = 0;
if (itPrev != m_nameToProperty.constBegin())
previous = (--itPrev).value();
m_currentBrowser->insertProperty(property, previous);
}
}
const QMap<QString, QtVariantProperty*>::const_iterator gnit = m_nameToGroup.constFind(groupName);
if (gnit != m_nameToGroup.constEnd()) {
groupProperty = gnit.value();
} else {
groupProperty = m_propertyManager->addProperty(QtVariantPropertyManager::groupTypeId(), groupName);
QtBrowserItem *item = 0;
if (!m_sorting)
item = m_currentBrowser->insertProperty(groupProperty, lastGroup);
m_nameToGroup[groupName] = groupProperty;
m_groups.append(groupProperty);
if (dynamicProperty)
m_dynamicGroup = groupProperty;
if (m_currentBrowser == m_treeBrowser && item) {
m_treeBrowser->setBackgroundColor(item, propertyColor(groupProperty));
groupProperty->setModified(true);
}
}
/* Group changed or new group. Append to last subproperty of
* that group. Note that there are cases in which a derived
* property sheet appends fake properties for the class
* which will appear after the layout group properties
* (QWizardPage). To make them appear at the end of the
* actual class group, goto last element. */
if (lastGroup != groupProperty) {
lastGroup = groupProperty;
lastProperty = 0; // Append at end
const QList<QtProperty*> subProperties = lastGroup->subProperties();
if (!subProperties.empty())
lastProperty = subProperties.back();
lastGroup = groupProperty;
}
if (!m_groups.contains(groupProperty))
m_groups.append(groupProperty);
if (newProperty)
groupProperty->insertSubProperty(property, lastProperty);
lastProperty = property;
updateBrowserValue(property, value);
property->setModified(m_propertySheet->isChanged(i));
if (propertyName == QLatin1String("geometry") && type == QVariant::Rect) {
QList<QtProperty *> subProperties = property->subProperties();
foreach (QtProperty *subProperty, subProperties) {
const QString subPropertyName = subProperty->propertyName();
if (subPropertyName == QLatin1String("X") || subPropertyName == QLatin1String("Y"))
subProperty->setEnabled(!isMainContainer);
}
}
} else {
qWarning("%s", qPrintable(msgUnsupportedType(propertyName, type)));
}
}
void SchematicSceneBuilder::setup_properties(
Item* item,
std::string name,
double value,
bool symbolic,
std::map<std::string, std::string> props
)
{
QtProperty* properties = SchematicScene::itemProperties(item);
QHash<QString, QtProperty*> subproperties;
if(properties) {
subproperties.insert("__NAME", properties);
foreach(QtProperty* prop, properties->subProperties())
subproperties.insert(prop->propertyName(), prop);
}
if(subproperties.contains("__NAME")) {
QtStringPropertyManager* spm =
qobject_cast<QtStringPropertyManager*>(
subproperties.value("__NAME")->propertyManager());
if(spm)
spm->setValue(
subproperties.value("__NAME"),
QString::fromStdString(name)
);
}
if(subproperties.contains("Value")) {
QtStringPropertyManager* spm =
qobject_cast<QtStringPropertyManager*>(
subproperties.value("Value")->propertyManager());
if(spm)
spm->setValue(
subproperties.value("Value"),
QString::number(value)
);
}
if(subproperties.contains("Symbolic")) {
QtBoolPropertyManager* bpm =
qobject_cast<QtBoolPropertyManager*>(
subproperties.value("Symbolic")->propertyManager());
if(bpm)
bpm->setValue(
subproperties.value("Symbolic"),
symbolic
);
}
if(subproperties.contains("lp:name")) {
QtStringPropertyManager* spm =
qobject_cast<QtStringPropertyManager*>(
subproperties.value("lp:name")->propertyManager());
if(spm)
spm->setValue(
subproperties.value("lp:name"),
QString::fromStdString(props["lp:name"])
);
}
if(subproperties.contains("lp:value")) {
QtStringPropertyManager* spm =
qobject_cast<QtStringPropertyManager*>(
subproperties.value("lp:value")->propertyManager());
if(spm)
spm->setValue(
subproperties.value("lp:value"),
QString::number(
QString::fromStdString(props["lp:value"]).toDouble())
);
}
if(subproperties.contains("ls:name")) {
QtStringPropertyManager* spm =
qobject_cast<QtStringPropertyManager*>(
subproperties.value("ls:name")->propertyManager());
if(spm)
spm->setValue(
subproperties.value("ls:name"),
QString::fromStdString(props["ls:name"])
);
}
if(subproperties.contains("ls:value")) {
QtStringPropertyManager* spm =
qobject_cast<QtStringPropertyManager*>(
subproperties.value("ls:value")->propertyManager());
if(spm)
spm->setValue(
subproperties.value("ls:value"),
QString::number(
QString::fromStdString(props["ls:value"]).toDouble())
);
}
}
void SchematicSceneParser::parse_item(
sapecng::abstract_builder& builder,
Item* item
)
{
SchematicScene::SupportedItemType type = SchematicScene::itemType(item);
std::map<std::string, std::string> props;
storeItemData(props, type, item);
QtProperty* properties = SchematicScene::itemProperties(item);
QHash<QString, QString> subproperties;
if(properties) {
subproperties.insert("__NAME", properties->valueText());
foreach(QtProperty* prop, properties->subProperties())
subproperties.insert(prop->propertyName(), prop->valueText());
}
switch(type)
{
case SchematicScene::GroundItemType:
case SchematicScene::PortItemType:
{
// add as unknow
Component* component = static_cast<Component*>(item);
props["node"] = QString::number(component->nodes().front()).toStdString();
builder.add_unknow_component(props);
break;
}
case SchematicScene::LabelItemType:
{
// add as unknow
Label* label = static_cast<Label*>(item);
props["text"] = label->text().toStdString();
builder.add_unknow_component(props);
break;
}
case SchematicScene::WireItemType:
{
Wire* wire = static_cast<Wire*>(item);
props["orientation"] =
QString::number(wire->orientation()).toStdString();
props["to_x"] =
QString::number(wire->toPoint().x()).toStdString();
props["to_y"] =
QString::number(wire->toPoint().y()).toStdString();
props["conn"] =
QString::number(wire->isJunctionsConnected()).toStdString();
builder.add_wire_component(props);
break;
}
case SchematicScene::OutItemType:
{
if(!discard_) {
Component* out = static_cast<Component*>(item);
builder.add_out_component(out->nodes().front(), props);
}
break;
}
case SchematicScene::VoltmeterItemType:
case SchematicScene::AmmeterItemType:
{
Component* component = static_cast<Component*>(item);
QVector<int> nodes = component->nodes();
builder.add_dual_component(
dualMap_[type], "", 1., true,
nodes.at(1), nodes.at(0),
props
);
break;
}
case SchematicScene::CapacitorItemType:
case SchematicScene::ConductanceItemType:
case SchematicScene::InductorItemType:
case SchematicScene::ResistorItemType:
case SchematicScene::CurrentSourceItemType:
case SchematicScene::VoltageSourceItemType:
{
Component* component = static_cast<Component*>(item);
QVector<int> nodes = component->nodes();
storeLabel(props, component);
builder.add_dual_component(
dualMap_[type], subproperties.value("__NAME").toStdString(),
subproperties.value("Value").toDouble(),
QVariant(subproperties.value("Symbolic")).toBool(),
nodes.at(1), nodes.at(0),
props
);
break;
}
case SchematicScene::CCCSItemType:
case SchematicScene::CCVSItemType:
case SchematicScene::VCCSItemType:
case SchematicScene::VCVSItemType:
{
Component* component = static_cast<Component*>(item);
QVector<int> nodes = component->nodes();
storeLabel(props, component);
builder.add_quad_component(
quadMap_[type], subproperties.value("__NAME").toStdString(),
subproperties.value("Value").toDouble(),
QVariant(subproperties.value("Symbolic")).toBool(),
nodes.at(1), nodes.at(0), nodes.at(3), nodes.at(2),
props
);
break;
}
case SchematicScene::OpAmplItemType:
{
Component* component = static_cast<Component*>(item);
QVector<int> nodes = component->nodes();
storeLabel(props, component);
builder.add_quad_component(
quadMap_[type], subproperties.value("__NAME").toStdString(), 1., false,
SchematicScene::Ground, nodes.at(2), nodes.at(1), nodes.at(0), props
);
break;
}
case SchematicScene::TransformerItemType:
{
Component* component = static_cast<Component*>(item);
QVector<int> nodes = component->nodes();
storeLabel(props, component);
builder.add_quad_component(
quadMap_[type], subproperties.value("__NAME").toStdString(),
subproperties.value("Value").toDouble(),
QVariant(subproperties.value("Symbolic")).toBool(),
nodes.at(3), nodes.at(2), nodes.at(1), nodes.at(0),
props
);
break;
}
case SchematicScene::MutualInductanceItemType:
{
Component* component = static_cast<Component*>(item);
QVector<int> nodes = component->nodes();
storeLabel(props, component);
props["lp:name"] = subproperties.value("lp:name").toStdString();
props["lp:value"] = subproperties.value("lp:value").toStdString();
props["ls:name"] = subproperties.value("ls:name").toStdString();
props["ls:value"] = subproperties.value("ls:value").toStdString();
builder.add_quad_component(
quadMap_[type], subproperties.value("__NAME").toStdString(),
subproperties.value("Value").toDouble(),
QVariant(subproperties.value("Symbolic")).toBool(),
nodes.at(3), nodes.at(2), nodes.at(1), nodes.at(0),
props
);
break;
}
case SchematicScene::UserDefItemType:
{
Component* component = static_cast<Component*>(item);
storeLabel(props, component);
builder.begin_userdef_component(
subproperties.value("__NAME").toStdString(),
props
);
++discard_;
QPointer<qsapecng::SchematicScene> scene =
item->data(101).value< QPointer<qsapecng::SchematicScene> >();
foreach(Item* item, scene->activeItems())
parse_item(builder, item);
--discard_;
builder.end_userdef_component(
subproperties.value("__NAME").toStdString(),
props
);
// outer-to-inner port buffer resistors
QVector<int> nodes = component->nodes();
QVector<int> ports = scene->ports();
if(nodes.size() == ports.size()) {
for(int i = 0; i < nodes.size(); ++i)
builder.add_dual_component(
dualMap_[SchematicScene::ResistorItemType],
"", .0, false, nodes.at(i), ports.at(i),
boost::assign::map_list_of("discard", "1")
);
} else {
// something strange happens - port-to-ground short circuits
foreach(int node, nodes)
builder.add_dual_component(
dualMap_[SchematicScene::ResistorItemType],
"", .0, false, node, SchematicScene::Ground,
boost::assign::map_list_of("discard", "1")
);
}
break;
}
default:
break;
}
}
