コード例 #1
0
ファイル: ElementImage.cpp プロジェクト: aquawicket/libRocket
void ElementImage::OnPropertyChange(const PropertyNameList& changed_properties)
{
    Element::OnPropertyChange(changed_properties);

    if (changed_properties.find(BACKGROUND_COLOR) != changed_properties.end() ||
        changed_properties.find(OPACITY) != changed_properties.end()) {
        GenerateGeometry();
    }
}
コード例 #2
0
ファイル: ElementDocument.cpp プロジェクト: Kaperstone/warsow
// Repositions the document if necessary.
void ElementDocument::OnPropertyChange(const PropertyNameList& changed_properties)
{
	Element::OnPropertyChange(changed_properties);

	if (changed_properties.find(TOP) != changed_properties.end() ||
		changed_properties.find(RIGHT) != changed_properties.end() ||
		changed_properties.find(BOTTOM) != changed_properties.end() ||
		changed_properties.find(LEFT) != changed_properties.end())
		UpdatePosition();
}
コード例 #3
0
ファイル: ElementHandle.cpp プロジェクト: LiberatorUSA/GUCEF
void ElementHandle::OnAttributeChange(const PropertyNameList& changed_attributes)
{
	Element::OnAttributeChange(changed_attributes);

	// Reset initialised state if the move or size targets have changed.
	if (changed_attributes.find("move_target") != changed_attributes.end() ||
		changed_attributes.find("size_target") != changed_attributes.end())
	{
		initialised = false;
		move_target = NULL;
		size_target = NULL;
	}
}
コード例 #4
0
ファイル: ElementDocument.cpp プロジェクト: Gambini/libRocket
// Repositions the document if necessary.
void ElementDocument::OnPropertyChange(const PropertyNameList& changed_properties)
{
	Element::OnPropertyChange(changed_properties);

	// If the document's font-size has been changed, we need to dirty all rem properties.
	if (changed_properties.find(FONT_SIZE) != changed_properties.end())
		GetStyle()->DirtyRemProperties();

	if (changed_properties.find(TOP) != changed_properties.end() ||
		changed_properties.find(RIGHT) != changed_properties.end() ||
		changed_properties.find(BOTTOM) != changed_properties.end() ||
		changed_properties.find(LEFT) != changed_properties.end())
		UpdatePosition();
}
コード例 #5
0
// Returns the list of properties this element definition defines for an element with the given set of pseudo-classes.
void ElementDefinition::GetDefinedProperties(PropertyNameList& property_names, const PseudoClassList& pseudo_classes) const
{
	for (PropertyMap::const_iterator i = properties.GetProperties().begin(); i != properties.GetProperties().end(); ++i)
		property_names.insert((*i).first);

	for (PseudoClassPropertyDictionary::const_iterator i = pseudo_class_properties.begin(); i != pseudo_class_properties.end(); ++i)
	{
		// If this property is already in the default dictionary, don't bother checking for it here.
		if (property_names.find((*i).first) != property_names.end())
			continue;

		const PseudoClassPropertyList& property_list = (*i).second;

		// Search through all the pseudo-class combinations that have a definition for this property; if the calling
		// element matches at least one of them, then add it to the list.
		bool property_defined = false;
		for (size_t j = 0; j < property_list.size(); ++j)
		{
			if (IsPseudoClassRuleApplicable(property_list[j].first, pseudo_classes))
			{
				property_defined = true;
				break;
			}
		}

		if (property_defined)
			property_names.insert((*i).first);
	}
}
コード例 #6
0
// Sets a list of properties as dirty.
void ElementStyle::DirtyProperties(const PropertyNameList& properties)
{
	if (properties.empty())
		return;

	PropertyNameList inherited_properties;
	for (PropertyNameList::const_iterator i = properties.begin(); i != properties.end(); ++i)
	{
		// If this property is an inherited property, then push it into the list to be passed onto our children.
		const PropertyDefinition* property = StyleSheetSpecification::GetProperty(*i);
		if (property != NULL &&
			property->IsInherited())
			inherited_properties.insert(*i);
	}

	// Pass the list of those properties that are inherited onto our children.
	if (!inherited_properties.empty())
	{
		for (int i = 0; i < element->GetNumChildren(true); i++)
			element->GetChild(i)->GetStyle()->DirtyInheritedProperties(inherited_properties);
	}

	// And send the event.
	element->OnPropertyChange(properties);
}
コード例 #7
0
// called when element properites are changed
void ElementImage::OnPropertyChange(const PropertyNameList& changed_properties)
{
	Rocket::Core::Element::OnPropertyChange(changed_properties);

	// Check if color property has been changed.
	if (changed_properties.find(COLOR) != changed_properties.end() )
	{
		geometry_dirty = true;
	}

	// Check if opacity has been changed
	if (changed_properties.find(OPACITY) != changed_properties.end() )
	{
		geometry_dirty = true;
	}
}
コード例 #8
0
void ElementImage::OnPropertyChange(const PropertyNameList& changed_properties)
{
	Element::OnPropertyChange(changed_properties);

	if (changed_properties.find(COLOR) != changed_properties.end())
	{
		geometry_dirty = true;
	}
}
コード例 #9
0
ファイル: ElementStyle.cpp プロジェクト: Gambini/libRocket
// Sets a list of properties as dirty.
void ElementStyle::DirtyProperties(const PropertyNameList& properties, bool clear_em_properties)
{
	if (properties.empty())
		return;

	bool all_inherited_dirty = 
		StyleSheetSpecification::GetRegisteredProperties() == properties ||
		StyleSheetSpecification::GetRegisteredInheritedProperties() == properties;

	if (all_inherited_dirty)
	{
		const PropertyNameList &all_inherited_properties = StyleSheetSpecification::GetRegisteredInheritedProperties();
		for (int i = 0; i < element->GetNumChildren(true); i++)
			element->GetChild(i)->GetStyle()->DirtyInheritedProperties(all_inherited_properties);

		// Clear all cached properties.
		cache->Clear();
	}
	else
	{
		PropertyNameList inherited_properties;

		for (PropertyNameList::const_iterator i = properties.begin(); i != properties.end(); ++i)
		{
			// If this property is an inherited property, then push it into the list to be passed onto our children.
			const PropertyDefinition* property = StyleSheetSpecification::GetProperty(*i);
			if (property != NULL &&
				property->IsInherited())
				inherited_properties.insert(*i);
		}

		// Pass the list of those properties that are inherited onto our children.
		if (!inherited_properties.empty())
		{
			for (int i = 0; i < element->GetNumChildren(true); i++)
				element->GetChild(i)->GetStyle()->DirtyInheritedProperties(inherited_properties);
		}

		// Clear cached properties.
		cache->Clear();
	}

	// clear the list of EM-properties, we will refill it in DirtyEmProperties
	if (clear_em_properties && em_properties != NULL)
	{
		delete em_properties;
		em_properties = NULL;
	}

	// And send the event.
	element->OnPropertyChange(properties);
}
コード例 #10
0
// Sets a list of our potentially inherited properties as dirtied by an ancestor.
void ElementStyle::DirtyInheritedProperties(const PropertyNameList& properties)
{
	PropertyNameList inherited_properties;
	for (PropertyNameList::const_iterator i = properties.begin(); i != properties.end(); ++i)
	{
		if (GetLocalProperty((*i)) == NULL)
			inherited_properties.insert(*i);
	}

	if (inherited_properties.empty())
		return;

	// Pass the list of those properties that this element doesn't override onto our children.
	for (int i = 0; i < element->GetNumChildren(true); i++)
		element->GetChild(i)->GetStyle()->DirtyInheritedProperties(inherited_properties);

	element->OnPropertyChange(properties);
}
コード例 #11
0
// Returns the list of properties this element definition has explicit definitions for involving the given
// pseudo-class.
void ElementDefinition::GetDefinedProperties(PropertyNameList& property_names, const PseudoClassList& pseudo_classes, const String& pseudo_class) const
{
	for (PseudoClassPropertyDictionary::const_iterator i = pseudo_class_properties.begin(); i != pseudo_class_properties.end(); ++i)
	{
		// If this property has already been found, don't bother checking for it again.
		if (property_names.find((*i).first) != property_names.end())
			continue;

		const PseudoClassPropertyList& property_list = (*i).second;

		bool property_defined = false;
		for (size_t j = 0; j < property_list.size(); ++j)
		{
			bool rule_valid = true;
			bool found_toggled_pseudo_class = false;

			const StringList& rule_pseudo_classes = property_list[j].first;
			for (size_t j = 0; j < rule_pseudo_classes.size(); ++j)
			{
				if (rule_pseudo_classes[j] == pseudo_class)
				{
					found_toggled_pseudo_class = true;
					continue;
				}

				if (pseudo_classes.find(rule_pseudo_classes[j]) == pseudo_classes.end())
				{			
					rule_valid = false;
					break;
				}
			}

			if (rule_valid &&
				found_toggled_pseudo_class)
			{
				property_defined = true;
				break;
			}
		}

		if (property_defined)
			property_names.insert((*i).first);
	}
}
コード例 #12
0
ファイル: ElementStyle.cpp プロジェクト: Gambini/libRocket
// Sets a list of our potentially inherited properties as dirtied by an ancestor.
void ElementStyle::DirtyInheritedProperties(const PropertyNameList& properties)
{
	bool clear_em_properties = em_properties != NULL;

	PropertyNameList inherited_properties;
	for (PropertyNameList::const_iterator i = properties.begin(); i != properties.end(); ++i)
	{
		const Property *property = GetLocalProperty((*i));
		if (property == NULL)
		{
			inherited_properties.insert(*i);
			if (!clear_em_properties && em_properties != NULL && em_properties->find((*i)) != em_properties->end()) {
				clear_em_properties = true;
			}
		}
	}

	if (inherited_properties.empty())
		return;

	// clear the list of EM-properties, we will refill it in DirtyEmProperties
	if (clear_em_properties && em_properties != NULL)
	{
		delete em_properties;
		em_properties = NULL;
	}

	// Clear cached inherited properties.
	cache->ClearInherited();

	// Pass the list of those properties that this element doesn't override onto our children.
	for (int i = 0; i < element->GetNumChildren(true); i++)
		element->GetChild(i)->GetStyle()->DirtyInheritedProperties(inherited_properties);

	element->OnPropertyChange(properties);
}
コード例 #13
0
void ElementTextDefault::OnPropertyChange(const PropertyNameList& changed_properties)
{
	Element::OnPropertyChange(changed_properties);

	bool colour_changed = false;
	bool font_face_changed = false;

	if (changed_properties.find(COLOR) != changed_properties.end())
	{
		// Fetch our (potentially) new colour.
		Colourb new_colour = GetProperty(COLOR)->value.Get< Colourb >();
		colour_changed = colour != new_colour;
		if (colour_changed)
			colour = new_colour;
	}

	if (changed_properties.find(FONT_FAMILY) != changed_properties.end() ||
		changed_properties.find(FONT_CHARSET) != changed_properties.end() ||
		changed_properties.find(FONT_WEIGHT) != changed_properties.end() ||
		changed_properties.find(FONT_STYLE) != changed_properties.end() ||
		changed_properties.find(FONT_SIZE) != changed_properties.end())
	{
		font_face_changed = true;

		geometry.clear();
		font_dirty = true;
	}

	if (changed_properties.find(TEXT_DECORATION) != changed_properties.end())
	{
		decoration_property = GetProperty< int >(TEXT_DECORATION);
		if (decoration_property != TEXT_DECORATION_NONE)
		{
			if (decoration_property != generated_decoration)
			{
				decoration.Release(true);

				FontFaceHandle* font_face_handle = GetFontFaceHandle();
				if (font_face_handle != NULL)
				{
					for (size_t i = 0; i < lines.size(); ++i)
						GenerateDecoration(font_face_handle, lines[i]);
				}

				generated_decoration = decoration_property;
			}
		}
	}

	if (font_face_changed)
	{
		// We have to let our document know we need to be regenerated.
		if (dirty_layout_on_change)
			DirtyLayout();
	}
	else if (colour_changed)
	{
		// Force the geometry to be regenerated.
		geometry_dirty = true;

		// Re-colour the decoration geometry.
		Container::vector< Vertex >::Type& vertices = decoration.GetVertices();
		for (size_t i = 0; i < vertices.size(); ++i)
			vertices[i].colour = colour;

		decoration.Release();
	}
}
コード例 #14
0
// Dirties em-relative properties.
void ElementStyle::DirtyEmProperties()
{
	PropertyNameList properties;
	StyleSheetSpecification::GetRegisteredProperties(properties);

	// Check if any of these are currently em-relative. If so, dirty them.
	PropertyNameList em_properties;
	for (PropertyNameList::iterator list_iterator = properties.begin(); list_iterator != properties.end(); ++list_iterator)
	{
		// Skip font-size; this is relative to our parent's em, not ours.
		if (*list_iterator == FONT_SIZE)
			continue;

		// Get this element from this element. If this is em-relative, then add it to the list to
		// dirty.
		if (element->GetProperty(*list_iterator)->unit == Property::EM)
			em_properties.insert(*list_iterator);
	}

	if (!em_properties.empty())
		DirtyProperties(em_properties);

	// Now dirty all of our descendant's font-size properties that are relative to ems.
	int num_children = element->GetNumChildren(true);
	for (int i = 0; i < num_children; ++i)
		element->GetChild(i)->GetStyle()->DirtyInheritedEmProperties();
}