// 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);
}
// Sets a single property as dirty.
void ElementStyle::DirtyProperty(const String& property)
{
PropertyNameList properties;
properties.insert(String(property));
DirtyProperties(properties);
}
// 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);
}
}
// 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();
}
bool isSkippedNode(const ModelNode &node)
{
static const PropertyNameList skipList({"QtQuick.XmlRole", "Qt.XmlRole", "QtQuick.ListElement", "Qt.ListElement"});
if (skipList.contains(node.type()))
return true;
return false;
}
void ElementImage::OnPropertyChange(const PropertyNameList& changed_properties)
{
Element::OnPropertyChange(changed_properties);
if (changed_properties.find(COLOR) != changed_properties.end())
{
geometry_dirty = true;
}
}
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();
}
}
// 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);
}
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;
}
}
// 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();
}
// 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;
}
}
static QList<ModelNode> acceptedModelNodeChildren(const ModelNode &parentNode)
{
QList<ModelNode> children;
PropertyNameList properties;
if (parentNode.metaInfo().hasDefaultProperty())
properties.append(parentNode.metaInfo().defaultPropertyName());
#ifndef DISABLE_VISIBLE_PROPERTIES
properties.append(visibleProperties(parentNode));
#endif
foreach (const PropertyName &propertyName, properties) {
AbstractProperty property(parentNode.property(propertyName));
if (property.isNodeAbstractProperty())
children.append(property.toNodeAbstractProperty().directSubNodes());
}
// 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();
}
// 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);
}
// 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);
}
}
bool detectVerticalCycle(const ModelNode &node, QList<ModelNode> knownNodeList)
{
if (!node.isValid())
return false;
if (knownNodeList.contains(node))
return true;
knownNodeList.append(node);
static PropertyNameList validAnchorLines(PropertyNameList() << "top" << "bottom" << "verticalCenter" << "baseline");
static PropertyNameList anchorNames(PropertyNameList() << "anchors.top" << "anchors.bottom" << "anchors.verticalCenter" << "anchors.baseline");
foreach (const PropertyName &anchorName, anchorNames) {
if (node.hasBindingProperty(anchorName)) {
AbstractProperty targetProperty = node.bindingProperty(anchorName).resolveToProperty();
if (targetProperty.isValid()) {
if (!validAnchorLines.contains(targetProperty.name()))
return true;
if (detectVerticalCycle(targetProperty.parentModelNode(), knownNodeList))
return true;
}
}
}
static PropertyNameList anchorShortcutNames(PropertyNameList() << "anchors.fill" << "anchors.centerIn");
foreach (const PropertyName &anchorName, anchorShortcutNames) {
if (node.hasBindingProperty(anchorName)) {
ModelNode targetNode = node.bindingProperty(anchorName).resolveToModelNode();
if (targetNode.isValid() && detectVerticalCycle(targetNode, knownNodeList))
return true;
}
}
return false;
}
// 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);
}
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();
}
}