Ejemplo n.º 1
0
QVariant QtPropertyModel::data(const QModelIndex & index, int role /* = Qt::DisplayRole */) const
{
	QVariant ret;

	QtPropertyData *data = itemFromIndex(index);
	if(NULL != data)
	{
		if(index.column() == 0)
		{
			switch(role)
			{
			case Qt::DisplayRole:
                        case Qt::ToolTipRole:
				ret = data->GetName();
				break;
			case Qt::FontRole:
			case Qt::BackgroundRole:
			case Qt::ForegroundRole:
				ret = data->data(role);
				break;
			default:
				break;
			}
		}
		else if(index.column() == 1)
		{
			ret = data->data(role);
		}
	}

	return ret;
}
Ejemplo n.º 2
0
void QtPropertyModel::MergeProperty(QtPropertyData* data, QModelIndex const& parent)
{
	if(NULL != data)
	{
		QtPropertyData *parentData = itemFromIndexInternal(parent);
		if(NULL != parentData)
		{
            parentData->MergeChild(data);
		}
	}
}
void QtPropertyDataIntrospection::AddMember(const DAVA::IntrospectionMember *member, int hasAnyFlags, int hasNotAnyFlags)
{
	void *memberObject = member->Data(object);
	const DAVA::MetaInfo *memberMetaInfo = member->Type();
	const DAVA::IntrospectionInfo *memberIntrospection = memberMetaInfo->GetIntrospection(memberObject);
	bool isKeyedArchive = false;

	// keyed archive
	if(NULL != memberIntrospection && (memberIntrospection->Type() == DAVA::MetaInfo::Instance<DAVA::KeyedArchive>()))
	{
		QtPropertyDataDavaKeyedArcive *childData = new QtPropertyDataDavaKeyedArcive((DAVA::KeyedArchive *) memberObject);
		ChildAdd(member->Name(), childData);
	}
	// introspection
	else if(NULL != memberObject && NULL != memberIntrospection)
    {
		QtPropertyDataIntrospection *childData = new QtPropertyDataIntrospection(memberObject, memberIntrospection, hasAnyFlags, hasNotAnyFlags);
		ChildAdd(member->Name(), childData);
    }
	// any other value
    else
    {
		// pointer
        if(memberMetaInfo->IsPointer())
        {
			QString s;
            QtPropertyData* childData = new QtPropertyData(s.sprintf("[%p] Pointer", memberObject));
            childData->SetFlags(childData->GetFlags() | FLAG_IS_DISABLED);
            ChildAdd(member->Name(), childData);
        }
		// other value
        else
        {
			// collection
            if(member->Collection() && !isKeyedArchive)
            {
                QtPropertyDataIntroCollection *childCollection = new QtPropertyDataIntroCollection(memberObject, member->Collection(), hasAnyFlags, hasNotAnyFlags);
                ChildAdd(member->Name(), childCollection);
            }
			// variant
            else
            {
                QtPropertyDataDavaVariant *childData = new QtPropertyDataDavaVariant(member->Value(object));
                if(member->Flags() & DAVA::INTROSPECTION_EDITOR_READONLY)
                {
                    childData->SetFlags(childData->GetFlags() | FLAG_IS_NOT_EDITABLE);
                }
                
                ChildAdd(member->Name(), childData);
                childVariantMembers.insert(childData, member);
            }
        }
    }
}
Ejemplo n.º 4
0
void QtPropertyModel::RemoveProperty(const QModelIndex &index)
{
	QtPropertyData *data = itemFromIndex(index);
	if(NULL != data)
	{
		QtPropertyData *parentData = data->Parent();
		if(NULL != parentData)
		{
			parentData->ChildRemove(data);
		}
	}
}
Ejemplo n.º 5
0
bool QtPropertyModel::setData(const QModelIndex & index, const QVariant & value, int role /* = Qt::EditRole */)
{
	bool ret = false;

	QtPropertyData *data = itemFromIndex(index);
	if(NULL != data && index.column() == 1)
	{
		ret = data->setData(value, role);
	}

	return ret;
}
Ejemplo n.º 6
0
QVariant QtPropertyData::GetValue() const
{
    QtPropertyData *self = const_cast<QtPropertyData*>(this);
    
    if(curValue.isValid() || !curValue.isNull())
	{
		self->UpdateValue();
	}

    self->BuildCurrentValue();
	return curValue;
}
Ejemplo n.º 7
0
int QtPropertyModel::rowCount(const QModelIndex & parent /* = QModelIndex() */) const
{
	int count = 0;

	QtPropertyData *data = itemFromIndexInternal(parent);
	if(NULL != data)
	{
		count = data->ChildCount();
	}

	return count;
}
Ejemplo n.º 8
0
void QtPropertyModel::UpdateStructureInternal(const QModelIndex &i)
{
	QtPropertyData *data = itemFromIndexInternal(i);
	if(NULL != data)
	{
		data->UpdateValue();

		for(int row = 0; row < rowCount(i); ++row)
		{
			UpdateStructureInternal(index(row, 0, i));
		}
	}
}
Ejemplo n.º 9
0
QModelIndex QtPropertyModel::InsertProperty(const QString &name, QtPropertyData* data, int row, const QModelIndex &parent /* = QModelIndex() */)
{
	if(NULL != data)
	{
		QtPropertyData *parentData = itemFromIndexInternal(parent);
		if(NULL != parentData)
		{
			parentData->ChildInsert(name, data, row);
		}
	}

	return indexFromItem(data);
}
Ejemplo n.º 10
0
void QtPropertyItemDelegate::hideAllChildOptionalWidgets(QtPropertyData* data)
{
	for(int i = 0; i < data->ChildCount(); i++)
	{
		QPair<QString, QtPropertyData *> childPair = data->ChildGet(i);
		QtPropertyData *childData = childPair.second;

		for (int j = 0; j < childData->GetOWCount(); j++)
		{
			childData->GetOW(j)->widget->hide();
		}

		hideAllChildOptionalWidgets(childData);
	}
}
Ejemplo n.º 11
0
QtPropertyData* QtPropertyModel::itemFromIndex(const QModelIndex & index) const
{
	QtPropertyData *ret = NULL;

	if(index.isValid() && index.model() == this)
	{
		QtPropertyData *parent = static_cast<QtPropertyData *>(index.internalPointer());
		if(NULL != parent)
		{
			ret = parent->ChildGet(index.row());
		}
	}

	return ret;
}
void QtPropertyItemDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
{
    const QtPropertyModel *propertyModel = dynamic_cast<const QtPropertyModel *>(index.model());
	if(NULL != propertyModel)
	{
		QtPropertyItem* item = (QtPropertyItem*) propertyModel->itemFromIndex(index);
		QtPropertyData* data = item->GetPropertyData();
		if(NULL != data)
		{
            data->EditorDone(editor);
		}
	}

    QStyledItemDelegate::setModelData(editor, model, index);
}
Ejemplo n.º 13
0
QModelIndex QtPropertyModel::index(int row, int column, const QModelIndex & parent /* = QModelIndex() */) const
{
	QModelIndex ret;

	QtPropertyData *data = itemFromIndexInternal(parent);
	if((NULL != data) &&
		(row >= 0) &&
		(column >= 0) &&
		(row < data->ChildCount()) &&
		(column < 2))
	{
		ret = createIndex(row, column, data);
	}

	return ret;
}
Ejemplo n.º 14
0
void QtPropertyItemDelegate::recalcOptionalWidgets(const QModelIndex &index, QStyleOptionViewItem *option) const
{
	QtPropertyData* data = index.data(QtPropertyItem::PropertyDataRole).value<QtPropertyData*>();

	if(NULL != data)
	{
		QWidget *owViewport = data->GetOWViewport();

		int prevOWSpace = 0;
		int owSpacing = 1;
		int optionRectRight = option->rect.right();

		int dataCount = data->GetOWCount();
		for (int i = 0; i < dataCount; ++i)
		{

			const QtPropertyOW *ow = data->GetOW(i);
			if(NULL != ow && NULL != owViewport && NULL != ow->widget)
			{
				QWidget *owWidget = ow->widget;
				int owWidth = ow->size.width();

				if(0 != owWidth)
				{
					QRect owRect = option->rect;
					owRect.setLeft(optionRectRight - owWidth - prevOWSpace);
					owRect.setRight(owRect.left() + owWidth);
									
					owWidget->setGeometry(owRect);
					owWidget->show();

					// if this widget isn't overlayed we should modify rect for tree view cell to be drawn in.
					if(!ow->overlay)
					{
						option->rect.setRight(owRect.left());
					}

					prevOWSpace += (owWidth + owSpacing);
				}
				else
				{
					owWidget->hide();
				}
			}
		}
	}
}
Ejemplo n.º 15
0
QWidget* QtPropertyItemDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
	QWidget* editWidget = NULL;
	QtPropertyData* data = index.data(QtPropertyItem::PropertyDataRole).value<QtPropertyData*>();
	
	recalcOptionalWidgets(index, (QStyleOptionViewItem *) &option);

	if(NULL != data)
	{
		editWidget = data->CreateEditor(parent, option);
	}

	if(NULL == editWidget)
	{
		editWidget = QStyledItemDelegate::createEditor(parent, option, index);
	}

    return editWidget;
}
Ejemplo n.º 16
0
QModelIndex QtPropertyModel::indexFromItem(QtPropertyData *data) const
{
	QModelIndex ret;

	if(NULL != data)
	{
		QtPropertyData *parent = data->Parent();
		if(NULL != parent)
		{
			int row = parent->ChildIndex(data);
			if(row >= 0)
			{
				ret = createIndex(row, 0, parent);
			}
		}
	}

	return ret;
}
Ejemplo n.º 17
0
Qt::ItemFlags QtPropertyModel::flags(const QModelIndex & index) const
{
	Qt::ItemFlags ret = 0;

	if(index.column() == 1)
	{
		QtPropertyData *data = itemFromIndex(index);
		if(NULL != data)
		{
			ret = Qt::ItemIsSelectable | data->GetFlags();
		}
	}
	else
	{
		ret = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
	}

	return ret;
}
Ejemplo n.º 18
0
void QtPropertyItemDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
{
	bool doneByInternalEditor = false;

    const QtPropertyModel *propertyModel = dynamic_cast<const QtPropertyModel *>(index.model());
	if(NULL != propertyModel)
	{
		QtPropertyItem* item = (QtPropertyItem*) propertyModel->itemFromIndex(index);
		QtPropertyData* data = item->GetPropertyData();
		if(NULL != data)
		{
            doneByInternalEditor = data->SetEditorData(editor);
		}
	}

	if(!doneByInternalEditor)
	{
		QStyledItemDelegate::setEditorData(editor, index);
	}
}
Ejemplo n.º 19
0
void QtPropertyData::BuildCurrentValue()
{
    // Build value
    const QVariant master = GetValueInternal();
    bool isAllEqual = true;

    isValuesMerged = false;
    for ( int i = 0; i < mergedData.size(); i++ )
    {
        QtPropertyData *item = mergedData.at(i);
        const QVariant slave = item->GetValue();
        if (master != slave)
        {
            isAllEqual = false;
            break;
        }
    }

    curValue = isAllEqual ? master : QVariant();
    isValuesMerged = isAllEqual;

    // Update Qt MVC properties
    if ( !isAllEqual )
    {
        QList<int> roles;
        roles << Qt::DecorationRole;
        for ( int iRole = 0; iRole < roles.size(); iRole++ )
        {
            const int role = roles.at(iRole);
            auto it = style.find( role );
            if ( it != style.end() )
            {
                *it = QVariant();
            }
        }
    }

}
Ejemplo n.º 20
0
void QtPropertyDataDavaKeyedArcive::ChildCreate(const QString &key, DAVA::VariantType *value)
{
    QtPropertyData *childData = NULL;

    if(value->type == DAVA::VariantType::TYPE_KEYED_ARCHIVE)
    {
        childData = new QtPropertyDataDavaKeyedArcive(value->AsKeyedArchive());
    }
    else
    {
        childData = new QtPropertyDataDavaVariant(*value);
    }

    ChildAdd(key, childData);

    // add optional widget (button) to remove this key
    QPushButton *remButton = new QPushButton(QIcon(":/QtIcons/keyminus.png"), "");
    remButton->setIconSize(QSize(12, 12));
    childData->AddOW(QtPropertyOW(remButton));
    childData->SetOWViewport(GetOWViewport());

    QObject::connect(remButton, SIGNAL(pressed()), this, SLOT(RemKeyedArchiveField()));
}
QWidget* QtPropertyItemDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
	QWidget* editWidget = NULL;
	const QtPropertyModel *propertyModel = dynamic_cast<const QtPropertyModel *>(index.model());

	if(NULL != propertyModel)
	{
		QtPropertyItem* item = (QtPropertyItem*) propertyModel->itemFromIndex(index);
		QtPropertyData* data = item->GetPropertyData();
		if(NULL != data)
		{
			editWidget = data->CreateEditor(parent, option);
		}

		TryEditorWorkarounds(editWidget);
	}

	if(NULL == editWidget)
	{
		editWidget = QStyledItemDelegate::createEditor(parent, option, index);
	}

    return editWidget;
}
void QtPropertyDataDavaKeyedArcive::ChildCreate(const QString &key, DAVA::VariantType *value)
{
	QtPropertyData *childData = NULL;

	if(value->type == DAVA::VariantType::TYPE_KEYED_ARCHIVE)
	{
		childData = new QtPropertyDataDavaKeyedArcive(value->AsKeyedArchive());
	}
	else
	{
		childData = new QtPropertyKeyedArchiveMember(curArchive, key.toStdString());

		int presetValueType = EditorConfig::Instance()->GetPropertyValueType(key.toStdString());
		if(presetValueType != DAVA::VariantType::TYPE_NONE)
		{
			if(value->type == presetValueType)
			{
				const DAVA::Vector<DAVA::String>& allowedValues = EditorConfig::Instance()->GetComboPropertyValues(key.toStdString());
				for(size_t i = 0; i < allowedValues.size(); ++i)
				{
					((QtPropertyKeyedArchiveMember *) childData)->AddAllowedValue(DAVA::VariantType((int) i), allowedValues[i].c_str());
				}
			}
		}
	}

	ChildAdd(key, childData);

	// add optional widget (button) to remove this key
	QPushButton *remButton = new QPushButton(QIcon(":/QtIcons/keyminus.png"), "");
	remButton->setIconSize(QSize(12, 12));
	childData->AddOW(QtPropertyOW(remButton));
	childData->SetOWViewport(GetOWViewport());

	QObject::connect(remButton, SIGNAL(pressed()), this, SLOT(RemKeyedArchiveField()));
}
void QtPropertyDataDavaVariant::ChildsCreate()
{
	switch(curVariantValue.type)
	{
	case DAVA::VariantType::TYPE_KEYED_ARCHIVE:
		{
			DAVA::KeyedArchive *archive = curVariantValue.AsKeyedArchive();
			DAVA::Map<DAVA::String, DAVA::VariantType*> data = archive->GetArchieveData();
			DAVA::Map<DAVA::String, DAVA::VariantType*>::iterator i = data.begin();

			for(; i != data.end(); ++i)
			{
				ChildAdd(i->first.c_str(), new QtPropertyDataDavaVariant(*(i->second)));
			}
		}
		break;
	case DAVA::VariantType::TYPE_MATRIX2:
		break;
	case DAVA::VariantType::TYPE_MATRIX3:
		break;
	case DAVA::VariantType::TYPE_MATRIX4:
		break;
	case DAVA::VariantType::TYPE_VECTOR2:
		{
			DAVA::Vector2 vec = curVariantValue.AsVector2();
			ChildAdd("X", vec.x);
			ChildAdd("Y", vec.y);
		}
		break;
	case DAVA::VariantType::TYPE_VECTOR3:
		{
			DAVA::Vector3 vec = curVariantValue.AsVector3();
			ChildAdd("X", vec.x);
			ChildAdd("Y", vec.y);
			ChildAdd("Z", vec.z);
		}
		break;
	case DAVA::VariantType::TYPE_VECTOR4:
		{
			DAVA::Vector4 vec = curVariantValue.AsVector4();
			ChildAdd("X", vec.x);
			ChildAdd("Y", vec.y);
			ChildAdd("Z", vec.z);
			ChildAdd("W", vec.w);
		}
		break;
    case DAVA::VariantType::TYPE_COLOR:
        {
//            DAVA::Color color = curVariantValue.AsColor();
//            ChildAdd("R", color.r);
//            ChildAdd("G", color.g);
//            ChildAdd("B", color.b);
//            ChildAdd("A", color.a);
        }
        break;
	case DAVA::VariantType::TYPE_AABBOX3:
        {
            DAVA::AABBox3 box = curVariantValue.AsAABBox3();
            
            ChildAdd("min", FromVector3(box.min));
            ChildAdd("max", FromVector3(box.max));
            
            QtPropertyData* min = ChildGet("min");
            min->SetFlags(FLAG_IS_NOT_EDITABLE);
            min->ChildAdd("X", box.min.x);
            min->ChildAdd("Y", box.min.y);
            min->ChildAdd("Z", box.min.z);
            
            QtPropertyData* max = ChildGet("max");
            max->SetFlags(FLAG_IS_NOT_EDITABLE);
            max->ChildAdd("X", box.max.x);
            max->ChildAdd("Y", box.max.y);
            max->ChildAdd("Z", box.max.z);
        }
		break;
	}
}
void QtPropertyDataDavaVariant::MeSetFromChilds(const QString &lastChangedChildKey, QtPropertyData *lastChangedChildData)
{
	switch(curVariantValue.type)
	{
	case DAVA::VariantType::TYPE_KEYED_ARCHIVE:
		{
			QtPropertyDataDavaVariant *childVariantData = (QtPropertyDataDavaVariant *) lastChangedChildData;
			DAVA::KeyedArchive *archive = curVariantValue.AsKeyedArchive();

			if(NULL != archive && NULL != childVariantData)
			{
				archive->SetVariant(lastChangedChildKey.toStdString(), childVariantData->curVariantValue);
			}
		}
		break;
	case DAVA::VariantType::TYPE_MATRIX2:
		break;
	case DAVA::VariantType::TYPE_MATRIX3:
		break;
	case DAVA::VariantType::TYPE_MATRIX4:
		break;
	case DAVA::VariantType::TYPE_VECTOR2:
		{
			DAVA::Vector2 vec;
			vec.x = ChildGet("X")->GetValue().toFloat();
			vec.y = ChildGet("Y")->GetValue().toFloat();
			curVariantValue.SetVector2(vec);
		}
		break;
	case DAVA::VariantType::TYPE_VECTOR3:
		{
			DAVA::Vector3 vec;
			vec.x = ChildGet("X")->GetValue().toFloat();
			vec.y = ChildGet("Y")->GetValue().toFloat();
			vec.z = ChildGet("Z")->GetValue().toFloat();
			curVariantValue.SetVector3(vec);
		}
		break;
	case DAVA::VariantType::TYPE_VECTOR4:
		{
			DAVA::Vector4 vec;
			vec.x = ChildGet("X")->GetValue().toFloat();
			vec.y = ChildGet("Y")->GetValue().toFloat();
			vec.z = ChildGet("Z")->GetValue().toFloat();
			vec.w = ChildGet("W")->GetValue().toFloat();
			curVariantValue.SetVector4(vec);
		}
		break;
    case DAVA::VariantType::TYPE_COLOR:
		{
//			DAVA::Color color;
//			color.r = ChildGet("R")->GetValue().toFloat();
//			color.g = ChildGet("G")->GetValue().toFloat();
//			color.b = ChildGet("B")->GetValue().toFloat();
//			color.a = ChildGet("A")->GetValue().toFloat();
//			curVariantValue.SetColor(color);
		}
        break;
        case DAVA::VariantType::TYPE_AABBOX3:
        {
            DAVA::AABBox3 box;
            
            QtPropertyData* min = ChildGet("min");
            box.min.x = min->ChildGet("X")->GetValue().toFloat();
            box.min.y = min->ChildGet("Y")->GetValue().toFloat();
            box.min.z = min->ChildGet("Z")->GetValue().toFloat();
            
            QtPropertyData* max = ChildGet("max");
            box.max.x = max->ChildGet("X")->GetValue().toFloat();
            box.max.y = max->ChildGet("Y")->GetValue().toFloat();
            box.max.z = max->ChildGet("Z")->GetValue().toFloat();
            
            curVariantValue.SetAABBox3(box);
        }
            break;
	}
}
Ejemplo n.º 25
0
QtPropertyDataInspColl::QtPropertyDataInspColl(void *_object, const DAVA::InspColl *_collection, bool autoAddChilds)
	: object(_object)
	, collection(_collection)
{
	if(NULL != collection && collection->Size(object) > 0 && autoAddChilds)
	{
		int index = 0;
		DAVA::MetaInfo *valueType = collection->ItemType();
		DAVA::InspColl::Iterator i = collection->Begin(object);
		while(NULL != i)
		{
			if(NULL != valueType->GetIntrospection())
			{
				void * itemObject = collection->ItemData(i);
				const DAVA::InspInfo *itemInfo = valueType->GetIntrospection(itemObject);

				if(NULL != itemInfo && NULL != itemObject)
				{
					QtPropertyData *childData = new QtPropertyDataIntrospection(itemObject, itemInfo);
					ChildAdd(QString::number(index), childData);
				}
				else
				{
					QString s;
					QtPropertyData* childData = new QtPropertyData(s.sprintf("[%p] Pointer", itemObject));
					childData->SetEnabled(false);
					ChildAdd(QString::number(index), childData);
				}
			}
			else
			{
				if(!valueType->IsPointer())
				{
					QtPropertyDataMetaObject *childData = new QtPropertyDataMetaObject(collection->ItemPointer(i), valueType);
					ChildAdd(QString::number(index), childData);
				}
				else
				{
					QString s;
					QtPropertyData* childData = new QtPropertyData(s.sprintf("[%p] Pointer", collection->ItemData(i)));
					childData->SetEnabled(false);

					if(collection->ItemKeyType() == DAVA::MetaInfo::Instance<DAVA::FastName>())
					{
						const DAVA::FastName *fname = (const DAVA::FastName *) collection->ItemKeyData(i);
						ChildAdd(fname->operator*(), childData);
					}
					else
					{
						ChildAdd(QString::number(index), childData);
					}
				}
			}

			index++;
			i = collection->Next(i);
		}
	}

	SetEnabled(false);
}
QtPropertyData * QtPropertyDataIntrospection::CreateMemberData(void *_object, const DAVA::InspMember *member, int hasAllFlags)
{
	void *memberObject = member->Data(_object);
	const DAVA::MetaInfo *memberMetaInfo = member->Type();
	const DAVA::InspInfo *memberIntrospection = memberMetaInfo->GetIntrospection(memberObject);
	bool isKeyedArchive = false;

	QtPropertyData * retData = NULL;
	// keyed archive
	if(NULL != memberIntrospection && (memberIntrospection->Type() == DAVA::MetaInfo::Instance<DAVA::KeyedArchive>()))
	{
		retData = new QtPropertyDataDavaKeyedArcive((DAVA::KeyedArchive *) memberObject);
	}
	// introspection
	else if(NULL != memberObject && NULL != memberIntrospection)
    {
		retData = new QtPropertyDataIntrospection(memberObject, memberIntrospection, hasAllFlags);
    }
	// any other value
    else
    {
		// pointer
        if(memberMetaInfo->IsPointer())
        {
			QString s;
            retData = new QtPropertyData(s.sprintf("[%p] Pointer", memberObject));
            retData->SetFlags(retData->GetFlags() | FLAG_IS_DISABLED);
        }
		// other value
        else
        {
			// collection
            if(member->Collection() && !isKeyedArchive)
            {
                retData = new QtPropertyDataInspColl(memberObject, member->Collection(), hasAllFlags);
            }
			// variant
            else
            {
                QtPropertyDataInspMember *childData = new QtPropertyDataInspMember(_object, member);
                if(!(member->Flags() & DAVA::I_EDIT))
                {
                    childData->SetFlags(childData->GetFlags() | FLAG_IS_NOT_EDITABLE);
                }
				else
				{
					// check if description has some predefines enum values
					const DAVA::InspDesc &desc = member->Desc();

					if(NULL != desc.enumMap)
					{
						for(size_t i = 0; i < desc.enumMap->GetCount(); ++i)
						{
							int v;
							if(desc.enumMap->GetValue(i, v))
							{
								childData->AddAllowedValue(DAVA::VariantType(v), desc.enumMap->ToString(v));
							}
						}
					}
				}
                
                retData = childData;
            }
        }
    }
	return retData;
}
void QtPropertyDataDavaVariant::ChildsSetFromMe()
{
	switch(curVariantValue.type)
	{
	case DAVA::VariantType::TYPE_KEYED_ARCHIVE:
		{
			// No way to change whole archive
			// so don't need to re-set childs
		}
		break;
	case DAVA::VariantType::TYPE_MATRIX2:
		break;
	case DAVA::VariantType::TYPE_MATRIX3:
		break;
	case DAVA::VariantType::TYPE_MATRIX4:
		break;
	case DAVA::VariantType::TYPE_VECTOR2:
		{
			DAVA::Vector2 vec = curVariantValue.AsVector2();
			ChildGet("X")->SetValue(vec.x);
			ChildGet("Y")->SetValue(vec.y);
		}
		break;
	case DAVA::VariantType::TYPE_VECTOR3:
		{
			DAVA::Vector3 vec = curVariantValue.AsVector3();
			ChildGet("X")->SetValue(vec.x);
			ChildGet("Y")->SetValue(vec.y);
			ChildGet("Z")->SetValue(vec.z);
		}
		break;
	case DAVA::VariantType::TYPE_VECTOR4:
		{
			DAVA::Vector4 vec = curVariantValue.AsVector4();
			ChildGet("X")->SetValue(vec.x);
			ChildGet("Y")->SetValue(vec.y);
			ChildGet("Z")->SetValue(vec.z);
			ChildGet("W")->SetValue(vec.w);
		}
		break;
    case DAVA::VariantType::TYPE_COLOR:
		{
//			DAVA::Color color = curVariantValue.AsColor();
//			ChildGet("R")->SetValue(color.r);
//			ChildGet("G")->SetValue(color.g);
//			ChildGet("B")->SetValue(color.b);
//			ChildGet("A")->SetValue(color.a);
		}
        break;
	case DAVA::VariantType::TYPE_AABBOX3:
        {
            DAVA::AABBox3 box = curVariantValue.AsAABBox3();
            
            QtPropertyData* min = ChildGet("min");
            min->SetValue(FromVector3(box.min));
            min->ChildGet("X")->SetValue(box.min.x);
            min->ChildGet("Y")->SetValue(box.min.y);
            min->ChildGet("Z")->SetValue(box.min.z);
            
            QtPropertyData* max = ChildGet("max");
            max->SetValue(FromVector3(box.max));
            max->ChildGet("X")->SetValue(box.max.x);
            max->ChildGet("Y")->SetValue(box.max.y);
            max->ChildGet("Z")->SetValue(box.max.z);
        }
            break;
	}
}