C++ PropertyPtr类代码示例

	void GroupTextureController::notifyChangeDataSelector(DataPtr _data, bool _changeOnlySelection)
	{
		mParentData = _data;
		if (mParentData != nullptr && mParentData->getType()->getName() != mParentTypeName)
			mParentData = nullptr;

		std::string texture;
		PropertyPtr property = PropertyUtility::getPropertyByName("Group", "Texture");
		if (property != nullptr)
		{
			texture = property->getValue();

			if (!property->eventChangeProperty.exist(this, &GroupTextureController::notifyChangeProperty))
				property->eventChangeProperty.connect(this, &GroupTextureController::notifyChangeProperty);
		}

		std::string coord;
		property = PropertyUtility::getPropertyByName("Group", "Size");
		if (property != nullptr)
		{
			coord = property->getValue();

			if (!property->eventChangeProperty.exist(this, &GroupTextureController::notifyChangeProperty))
				property->eventChangeProperty.connect(this, &GroupTextureController::notifyChangeProperty);
		}

		mControl->setTextureValue(texture);
		updateCoords(coord);
	}

	void PropertyPanelControl::InitialiseProperty(PropertyPtr _property, int& _height)
	{
		std::string type = _property->getType()->getType();
		PropertyControl* control = nullptr;

		for (VectorPairControl::iterator child = mPropertyControls.begin(); child != mPropertyControls.end(); child ++)
		{
			if ((*child).first == type && !(*child).second->getRoot()->getVisible())
			{
				control = (*child).second;
				control->getRoot()->setVisible(true);
				break;
			}
		}

		if (control == nullptr)
		{
			control = components::FactoryManager::GetInstance().CreateItem<PropertyControl>(_property->getType()->getType());
			if (control != nullptr)
			{
				control->Initialise(this, mScrollView, "");

				mPropertyControls.push_back(std::make_pair(_property->getType()->getType(), control));
			}
		}

		if (control != nullptr)
		{
			control->setProperty(_property);
			control->getRoot()->setPosition(0, _height);

			_height += control->getRoot()->getHeight() + mDistance;
		}
	}

void ImageSyncApp::populateGuiFromConfiguration()
{
   PropertyPtr property = configurationFile_->value( "destinationDirectory", DESTINATION_DIRECTORY );
   mainWindowContent_->textEditDestination->setText( !property ? "" : property->asString() );
   property = configurationFile_->value( "sourceDirectory", SOURCE_DIRECTORY );
   mainWindowContent_->textEditSource->setText( !property ? "" : property->asString() );
   
}

	void UniqueNamePropertyInitialisator::initialise(PropertyPtr _property)
	{
		DataPtr parent = DataUtility::getSelectedParentDataByType(_property->getOwner()->getType()->getName());
		if (parent == nullptr)
			return;

		std::string name = DataUtility::getUniqueName(parent, "unnamed_");
		_property->setValue(name);
	}

void UsReconstructionImplService::onServiceAdded(ReconstructionMethodService* service)
{
	QStringList range = mParams->getAlgorithmAdapter()->getValueRange();
	range << service->getName();
	mParams->getAlgorithmAdapter()->setValueRange(range);

	// select algo if none selected
	PropertyPtr algoName = mParams->getParameter("Algorithm");
	if (algoName->getValueAsVariant().value<QString>().isEmpty())
		algoName->setValueFromVariant(service->getName());
}

	void FontTextureController::notifyChangeProperty(PropertyPtr _sender)
	{
		if (!mActivated || !PropertyUtility::isDataSelected(_sender->getOwner()))
			return;

		if (_sender->getOwner()->getType()->getName() == "Font")
		{
			if (_sender->getType()->getName() == "FontName")
				updateTexture(_sender->getValue());
		}
	}

	void ChangeSkinSizeAction::storeRegionValues(DataPtr _skinData, VectorPairProperty& _store)
	{
		const Data::VectorData& childs = _skinData->getChilds();
		for (Data::VectorData::const_iterator child = childs.begin(); child != childs.end(); child++)
		{
			if ((*child)->getType()->getName() != "Region")
				continue;

			PropertyPtr property = (*child)->getProperty("Coord");
			_store.push_back(std::make_pair(property, property->getValue()));
		}
	}

PageProgression Package::PageProgressionDirection() const
{
    PropertyPtr prop = PropertyMatching("page-progression-direction");
    if ( prop )
    {
        if ( prop->Value() == "ltr" )
            return PageProgression::LeftToRight;
        else if ( prop->Value() == "rtl" )
            return PageProgression::RightToLeft;
    }
    return PageProgression::Default;
}

	void PropertyBoolControl::updateProperty()
	{
		PropertyPtr proper = getProperty();
		if (proper != nullptr)
		{
			mComboBox->setEnabled(!proper->getType()->getReadOnly());
			size_t index = getComboIndex(proper->getValue());
			mComboBox->setIndexSelected(index);
		}
		else
		{
			mComboBox->setIndexSelected(MyGUI::ITEM_NONE);
			mComboBox->setEnabled(false);
		}
	}

	void FontTextureController::notifyChangeDataSelector(DataPtr _data, bool _changeOnlySelection)
	{
		mParentData = _data;
		if (mParentData != nullptr && mParentData->getType()->getName() != mParentTypeName)
			mParentData = nullptr;

		std::string texture;
		PropertyPtr property = PropertyUtility::getPropertyByName("Font", "FontName");
		if (property != nullptr)
		{
			texture = property->getValue();
		}

		updateTexture(texture);
	}

 void PropertyInt2ListControl::updateProperty()
 {
   PropertyPtr proper = getProperty();
   if (proper != nullptr)
   {
     mList->setEnabled(!proper->getType()->getReadOnly());
     std::string value = getValue();
     if (value != proper->getValue())
       setValue(proper->getValue());
   }
   else
   {
     mList->removeAllItems();
     mList->setEnabled(false);
   }
 }

	void TexturePropertyInitialisator::initialise(PropertyPtr _property)
	{
		if (SettingsManager::getInstance().getValue<bool>("Settings/SaveLastTexture"))
		{
			std::string texture = SettingsManager::getInstance().getValue("Resources/LastTextureName");
			_property->setValue(texture);
		}
	}

Statement::Statement(ResourcePtr subject, PropertyPtr predicate,
                        NodePtr object) : d(new StatementPrivate)
{
    d->model = subject->model().d;
    d->subjectID = subject->id();
    d->predicateID = predicate->id();
    d->objectID = object->id();
}

	void Data::setType(DataTypePtr _value)
	{
		mType = _value;

		mProperties.clear();

		if (mType != nullptr)
		{
			const DataType::VectorProperty& properties = mType->getProperties();
			for (DataType::VectorProperty::const_iterator property = properties.begin(); property != properties.end(); property++)
			{
				PropertyPtr data = Property::CreateInstance(*property, mWeakThis.lock());
				data->initialise();

				mProperties[(*property)->getName()] = data;
			}
		}
	}

	void PropertyIntControl::updateProperty()
	{
		PropertyPtr proper = getProperty();
		if (proper != nullptr)
		{
			mEdit->setEnabled(!proper->getType()->getReadOnly());
			if (mEdit->getOnlyText() != proper->getValue())
				mEdit->setCaption(proper->getValue());

			bool validate = isValidate();
			setColour(validate);
		}
		else
		{
			mEdit->setCaption("");
			mEdit->setEnabled(false);
		}
	}