void Configuration::SetDefaultTextProperty(ConfigEnum eConfig, std::wstring strValue)
{
switch (eConfig)
{
case ConfigEnum_DefaultTextFace_English:
case ConfigEnum_DefaultTextFace_Chinese:
m_mapConfig.insert(make_pair(eConfig, PropertyValue(CString(strValue.c_str()))));
break;
case ConfigEnum_DefaultTextSize:
m_mapConfig.insert(make_pair(eConfig, PropertyValue(std::stoi(strValue))));
break;
default:
break;
}
}
bool GetProperty(TObject object, TProperty property, PropertyValue & value) const override
{
ASSERT(HasProperty(object, property), ());
// Current position = target position - amplutide * e ^ (elapsed / duration).
// We calculate current position not based on start position, but based on target position.
value = PropertyValue(m_endPos - m_direction * exp(-kKineticFadeoff * GetT()));
return true;
}
bool MapFollowAnimation::GetProperty(TObject object, TProperty property, bool targetValue, PropertyValue & value) const
{
if (property == Animation::Position)
{
ScreenBase tmp = AnimationSystem::Instance().GetLastScreen();
if (targetValue)
{
tmp.SetFromParams(m_globalPosition, m_angleInterpolator.GetTargetAngle(), m_isAutoZoom ? m_scaleInterpolator.GetScale()
: m_scaleInterpolator.GetTargetScale());
tmp.MatchGandP3d(m_globalPosition, m_endPixelPosition);
}
else
{
double const scale = m_scaleInterpolator.GetScale() / m_scaleInterpolator.GetStartScale();
double const angle = m_angleInterpolator.GetAngle() - m_angleInterpolator.GetStartAngle();
m2::PointD offset = m_offsetInterpolator.GetPosition() * scale;
offset.Rotate(angle);
m2::PointD pos = m_globalPosition + offset;
tmp.SetFromParams(m_globalPosition, m_angleInterpolator.GetAngle(), m_scaleInterpolator.GetScale());
tmp.MatchGandP3d(pos, m_endPixelPosition);
}
value = PropertyValue(tmp.GetOrg());
return true;
}
if (property == Animation::Angle)
{
value = PropertyValue(targetValue ? m_angleInterpolator.GetTargetAngle() : m_angleInterpolator.GetAngle());
return true;
}
if (property == Animation::Scale)
{
value = PropertyValue((targetValue && !m_isAutoZoom) ? m_scaleInterpolator.GetTargetScale()
: m_scaleInterpolator.GetScale());
return true;
}
ASSERT(false, ("Wrong property:", property));
return false;
}
void
FramePropertyTable::Set(nsIFrame* aFrame, const FramePropertyDescriptor* aProperty,
void* aValue)
{
NS_ASSERTION(aFrame, "Null frame?");
NS_ASSERTION(aProperty, "Null property?");
if (mLastFrame != aFrame || !mLastEntry) {
mLastFrame = aFrame;
mLastEntry = mEntries.PutEntry(aFrame);
}
Entry* entry = mLastEntry;
if (!entry->mProp.IsArray()) {
if (!entry->mProp.mProperty) {
// Empty entry, so we can just store our property in the empty slot
entry->mProp.mProperty = aProperty;
entry->mProp.mValue = aValue;
return;
}
if (entry->mProp.mProperty == aProperty) {
// Just overwrite the current value
entry->mProp.DestroyValueFor(aFrame);
entry->mProp.mValue = aValue;
return;
}
// We need to expand the single current entry to an array
PropertyValue current = entry->mProp;
entry->mProp.mProperty = nullptr;
static_assert(sizeof(nsTArray<PropertyValue>) <= sizeof(void *),
"Property array must fit entirely within entry->mProp.mValue");
new (&entry->mProp.mValue) nsTArray<PropertyValue>(4);
entry->mProp.ToArray()->AppendElement(current);
}
nsTArray<PropertyValue>* array = entry->mProp.ToArray();
nsTArray<PropertyValue>::index_type index =
array->IndexOf(aProperty, 0, PropertyComparator());
if (index != nsTArray<PropertyValue>::NoIndex) {
PropertyValue* pv = &array->ElementAt(index);
pv->DestroyValueFor(aFrame);
pv->mValue = aValue;
return;
}
array->AppendElement(PropertyValue(aProperty, aValue));
}
static bool parse_config_file(const char* ld_config_file_path,
const char* binary_realpath,
std::unordered_map<std::string, PropertyValue>* properties,
std::string* error_msg) {
std::string content;
if (!android::base::ReadFileToString(ld_config_file_path, &content)) {
if (errno != ENOENT) {
*error_msg = std::string("error reading file \"") +
ld_config_file_path + "\": " + strerror(errno);
}
return false;
}
ConfigParser cp(std::move(content));
std::string section_name;
while (true) {
std::string name;
std::string value;
std::string error;
int result = cp.next_token(&name, &value, &error);
if (result == ConfigParser::kError) {
DL_WARN("%s:%zd: warning: couldn't parse %s (ignoring this line)",
ld_config_file_path,
cp.lineno(),
error.c_str());
continue;
}
if (result == ConfigParser::kSection || result == ConfigParser::kEndOfFile) {
return false;
}
if (result == ConfigParser::kPropertyAssign) {
if (!android::base::StartsWith(name, "dir.")) {
DL_WARN("%s:%zd: warning: unexpected property name \"%s\", "
"expected format dir.<section_name> (ignoring this line)",
ld_config_file_path,
cp.lineno(),
name.c_str());
continue;
}
// remove trailing '/'
while (value[value.size() - 1] == '/') {
value = value.substr(0, value.size() - 1);
}
if (value.empty()) {
DL_WARN("%s:%zd: warning: property value is empty (ignoring this line)",
ld_config_file_path,
cp.lineno());
continue;
}
if (file_is_under_dir(binary_realpath, value)) {
section_name = name.substr(4);
break;
}
}
}
// skip everything until we meet a correct section
while (true) {
std::string name;
std::string value;
std::string error;
int result = cp.next_token(&name, &value, &error);
if (result == ConfigParser::kSection && name == section_name) {
break;
}
if (result == ConfigParser::kEndOfFile) {
*error_msg = create_error_msg(ld_config_file_path,
cp.lineno(),
std::string("section \"") + section_name + "\" not found");
return false;
}
}
// found the section - parse it
while (true) {
std::string name;
std::string value;
std::string error;
int result = cp.next_token(&name, &value, &error);
if (result == ConfigParser::kEndOfFile || result == ConfigParser::kSection) {
break;
}
if (result == ConfigParser::kPropertyAssign) {
if (properties->find(name) != properties->end()) {
DL_WARN("%s:%zd: warning: redefining property \"%s\" (overriding previous value)",
ld_config_file_path,
cp.lineno(),
name.c_str());
}
(*properties)[name] = PropertyValue(std::move(value), cp.lineno());
} else if (result == ConfigParser::kPropertyAppend) {
if (properties->find(name) == properties->end()) {
DL_WARN("%s:%zd: warning: appending to undefined property \"%s\" (treating as assignment)",
ld_config_file_path,
cp.lineno(),
name.c_str());
(*properties)[name] = PropertyValue(std::move(value), cp.lineno());
} else {
if (android::base::EndsWith(name, ".links") ||
android::base::EndsWith(name, ".namespaces")) {
value = "," + value;
(*properties)[name].append_value(std::move(value));
} else if (android::base::EndsWith(name, ".paths") ||
android::base::EndsWith(name, ".shared_libs")) {
value = ":" + value;
(*properties)[name].append_value(std::move(value));
} else {
DL_WARN("%s:%zd: warning: += isn't allowed for property \"%s\" (ignoring)",
ld_config_file_path,
cp.lineno(),
name.c_str());
}
}
}
if (result == ConfigParser::kError) {
DL_WARN("%s:%zd: warning: couldn't parse %s (ignoring this line)",
ld_config_file_path,
cp.lineno(),
error.c_str());
continue;
}
}
return true;
}
