void EditorConfig::ParseConfig(const FilePath &filePath) { ClearConfig(); YamlParser *parser = YamlParser::Create(filePath); if(parser) { YamlNode *rootNode = parser->GetRootNode(); if(rootNode) { const Vector<YamlNode*> &yamlNodes = rootNode->AsVector(); int32 propertiesCount = yamlNodes.size(); for(int32 i = 0; i < propertiesCount; ++i) { YamlNode *propertyNode = yamlNodes[i]; if(propertyNode) { const YamlNode *nameNode = propertyNode->Get("name"); const YamlNode *typeNode = propertyNode->Get("type"); const YamlNode *defaultNode = propertyNode->Get("default"); if(nameNode && typeNode) { const String &nameStr = nameNode->AsString(); const String &typeStr = typeNode->AsString(); int32 type = ParseType(typeStr); if(type) { bool isOk = true; for(uint32 n = 0; n < propertyNames.size(); ++n) { if(propertyNames[n] == nameStr) { isOk = false; Logger::Error("EditorConfig::ParseConfig %s ERROR property %d property %s already exists", filePath.GetAbsolutePathname().c_str(), i, nameStr.c_str()); break; } } if(isOk) { properties[nameStr] = new PropertyDescription(); properties[nameStr]->name = nameStr; properties[nameStr]->type = type; switch(type) { case PT_BOOL: { bool defaultValue = false; if(defaultNode) { defaultValue = defaultNode->AsBool(); } properties[nameStr]->defaultValue.SetBool(defaultValue); } break; case PT_INT: { int32 defaultValue = 0; if(defaultNode) { defaultValue = defaultNode->AsInt(); } properties[nameStr]->defaultValue.SetInt32(defaultValue); } break; case PT_STRING: { String defaultValue; if(defaultNode) { defaultValue = defaultNode->AsString(); } properties[nameStr]->defaultValue.SetString(defaultValue); } break; case PT_FLOAT: { float32 defaultValue = 0.0f; if(defaultNode) { defaultValue = defaultNode->AsFloat(); } properties[nameStr]->defaultValue.SetFloat(defaultValue); } break; case PT_COMBOBOX: { int32 defaultValue = 0; if(defaultNode) { defaultValue = defaultNode->AsInt(); } properties[nameStr]->defaultValue.SetInt32(defaultValue); const YamlNode *comboNode = propertyNode->Get("list"); if(comboNode) { const Vector<YamlNode*> &comboValueNodes = comboNode->AsVector(); int32 comboValuesCount = comboValueNodes.size(); for(int32 i = 0; i < comboValuesCount; ++i) { properties[nameStr]->comboValues.push_back(comboValueNodes[i]->AsString()); } } } break; case PT_COLOR_LIST: { int32 defaultValue = 0; if(defaultNode) { defaultValue = defaultNode->AsInt(); } properties[nameStr]->defaultValue.SetInt32(defaultValue); const YamlNode *colorListNode = propertyNode->Get("list"); if(colorListNode) { const Vector<YamlNode*> &colorListNodes = colorListNode->AsVector(); int32 colorListValuesCount = colorListNodes.size(); for(int32 i = 0; i < colorListValuesCount; ++i) { const YamlNode* colorNode = colorListNodes[i]; if(!colorNode || colorNode->GetCount() != 4) continue; Color color(colorNode->Get(0)->AsFloat()/255.f, colorNode->Get(1)->AsFloat()/255.f, colorNode->Get(2)->AsFloat()/255.f, colorNode->Get(3)->AsFloat()/255.f); properties[nameStr]->colorListValues.push_back(color); } } } break; } propertyNames.push_back(nameStr); } //isOk } else { Logger::Error("EditorConfig::ParseConfig %s ERROR property %d unknown type %s", filePath.GetAbsolutePathname().c_str(), i, typeStr.c_str()); } } else { Logger::Error("EditorConfig::ParseConfig %s ERROR property %d type or name is missing", filePath.GetAbsolutePathname().c_str(), i); } } else { Logger::Error("EditorConfig::ParseConfig %s ERROR property %d is missing", filePath.GetAbsolutePathname().c_str(), i); } } } // else file is empty - ok, no custom properties parser->Release(); } // else file not found - ok, no custom properties }
RefPtr< PropertyLine<Vector3> > PropertyLineYamlReader::CreateVector3PropertyLineFromYamlNode( YamlNode * parentNode, const String & propertyName, RefPtr< PropertyLine<Vector3> > defaultPropertyLine /*= 0*/ ) { YamlNode * node = parentNode->Get(propertyName); if (!node)return defaultPropertyLine; if (node->GetType() == YamlNode::TYPE_STRING) { if(propertyName == "emissionAngle") // for old emissionAngle compatibility { Vector3 res(0, 0, 0); float32 angle = DegToRad(node->AsFloat()); res.x = cosf(angle); res.y = sinf(angle); return RefPtr< PropertyLine<Vector3> >(new PropertyLineValue<Vector3>(res)); } float32 v = node->AsFloat(); return RefPtr< PropertyLine<Vector3> >(new PropertyLineValue<Vector3>(Vector3(v, v, v))); } else if (node->GetType() == YamlNode::TYPE_ARRAY) { if(node->GetCount() == 2) // for 2D forces compatibility { Vector3 res(node->AsVector2()); res.z = 0.0f; return RefPtr< PropertyLine<Vector3> >(new PropertyLineValue<Vector3>(res)); } if (node->GetCount() == 3 || node->GetCount() == 2) { Vector3 res(0.0f, 0.0f, 0.0f); res = node->AsVector3(); return RefPtr< PropertyLine<Vector3> >(new PropertyLineValue<Vector3>(res)); } RefPtr< PropertyLineKeyframes<Vector3> > keyframes (new PropertyLineKeyframes<Vector3>()); for (int k = 0; k < node->GetCount() / 2; ++k) { YamlNode * time = node->Get(k * 2); YamlNode * value = node->Get(k * 2 + 1); if (time && value) { if (value->GetType() == YamlNode::TYPE_ARRAY) { keyframes->AddValue(time->AsFloat(), value->AsVector3()); } else { Vector3 v = value->AsVector3(); if(propertyName == "emissionAngle") // for old emissionAngle compatibility { float32 angle = DegToRad(value->AsFloat()); v.x = cosf(angle); v.y = sinf(angle); v.z = 0.0f; } keyframes->AddValue(time->AsFloat(), v); } } } return keyframes; } return RefPtr< PropertyLine<Vector3> >(); }
void UIButton::LoadFromYamlNode(YamlNode * node, UIYamlLoader * loader) { UIControl::LoadFromYamlNode(node, loader); //int32 stateArray[] = {STATE_NORMAL, STATE_PRESSED_INSIDE, STATE_PRESSED_OUTSIDE, STATE_DISABLED, STATE_SELECTED, STATE_HOVER}; //String statePostfix[] = {"Normal", "PressedInside", "PressedOutside", "Disabled", "Selected", "Hover"}; for (int k = 0; k < STATE_COUNT; ++k) { YamlNode * stateSpriteNode = node->Get(Format("stateSprite%s", statePostfix[k].c_str())); if (stateSpriteNode) { YamlNode * spriteNode = stateSpriteNode->Get(0); YamlNode * frameNode = stateSpriteNode->Get(1); int32 frame = 0; if (frameNode)frame = frameNode->AsInt(); if (spriteNode) { SetStateSprite(stateArray[k], spriteNode->AsString(), frame); } } YamlNode * stateDrawTypeNode = node->Get(Format("stateDrawType%s", statePostfix[k].c_str())); if (stateDrawTypeNode) { UIControlBackground::eDrawType type = (UIControlBackground::eDrawType)loader->GetDrawTypeFromNode(stateDrawTypeNode); SetStateDrawType(stateArray[k],type); YamlNode * leftRightStretchCapNode = node->Get(Format("leftRightStretchCap%s", statePostfix[k].c_str())); YamlNode * topBottomStretchCapNode = node->Get(Format("topBottomStretchCap%s", statePostfix[k].c_str())); if(leftRightStretchCapNode) { float32 leftStretchCap = leftRightStretchCapNode->AsFloat(); GetActualBackground(stateArray[k])->SetLeftRightStretchCap(leftStretchCap); } if(topBottomStretchCapNode) { float32 topStretchCap = topBottomStretchCapNode->AsFloat(); GetActualBackground(stateArray[k])->SetTopBottomStretchCap(topStretchCap); } } YamlNode * stateAlignNode = node->Get(Format("stateAlign%s", statePostfix[k].c_str())); if (stateAlignNode) { int32 align = loader->GetAlignFromYamlNode(stateAlignNode); SetStateAlign(stateArray[k],align); } YamlNode * stateFontNode = node->Get(Format("stateFont%s", statePostfix[k].c_str())); if (stateFontNode) { Font * font = loader->GetFontByName(stateFontNode->AsString()); if (font)SetStateFont(stateArray[k], font); } YamlNode * stateTextNode = node->Get(Format("stateText%s", statePostfix[k].c_str())); if (stateTextNode) { SetStateText(stateArray[k], LocalizedString(stateTextNode->AsWString())); } YamlNode * stateTextColorNode = node->Get(Format("stateTextcolor%s", statePostfix[k].c_str())); if (stateTextColorNode) { Vector4 c = stateTextColorNode->AsVector4(); SetStateFontColor(stateArray[k], Color(c.x, c.y, c.z, c.w)); } YamlNode * stateShadowColorNode = node->Get(Format("stateShadowcolor%s", statePostfix[k].c_str())); if (stateShadowColorNode) { Vector4 c = stateShadowColorNode->AsVector4(); SetStateShadowColor(stateArray[k], Color(c.x, c.y, c.z, c.w)); } YamlNode * stateShadowOffsetNode = node->Get(Format("stateShadowoffset%s", statePostfix[k].c_str())); if (stateShadowOffsetNode) { SetStateShadowOffset(stateArray[k], stateShadowOffsetNode->AsVector2()); } } for (int k = 0; k < STATE_COUNT; ++k) { YamlNode * colorInheritNode = node->Get("colorInherit"); UIControlBackground::eColorInheritType type = (UIControlBackground::eColorInheritType)loader->GetColorInheritTypeFromNode(colorInheritNode); if(colorInheritNode) { for(int32 i = 0; i < DRAW_STATE_COUNT; ++i) { if(stateBacks[i]) { stateBacks[i]->SetColorInheritType(type); } } } } }
YamlNode * UIButton::SaveToYamlNode(UIYamlLoader * loader) { YamlNode *node = UIControl::SaveToYamlNode(loader); //Temp variable VariantType *nodeValue = new VariantType(); String stringValue; UIButton *baseControl = new UIButton(); //Control Type SetPreferredNodeType(node, "UIButton"); //Remove values of UIControl //UIButton has state specific properties YamlNode *spriteNode = node->Get("sprite"); YamlNode *drawTypeNode = node->Get("drawType"); YamlNode *colorInheritNode = node->Get("colorInherit"); YamlNode *alignNode = node->Get("align"); YamlNode *leftRightStretchCapNode = node->Get("leftRightStretchCap"); YamlNode *topBottomStretchCapNode = node->Get("topBottomStretchCap"); if (spriteNode) { node->RemoveNodeFromMap("sprite"); } if (drawTypeNode) { node->RemoveNodeFromMap("drawType"); } if (colorInheritNode) { node->RemoveNodeFromMap("colorInherit"); } if (alignNode) { node->RemoveNodeFromMap("align"); } if (leftRightStretchCapNode) { node->RemoveNodeFromMap("leftRightStretchCap"); } if (topBottomStretchCapNode) { node->RemoveNodeFromMap("topBottomStretchCap"); } //States cycle for values for (int i = 0; i < STATE_COUNT; ++i) { //Get sprite and frame for state Sprite *stateSprite = this->GetStateSprite(stateArray[i]); int32 stateFrame = this->GetStateFrame(stateArray[i]); if (stateSprite) { //Create array yamlnode and add it to map YamlNode *spriteNode = new YamlNode(YamlNode::TYPE_ARRAY); spriteNode->AddValueToArray(TruncateTxtFileExtension(stateSprite->GetName())); spriteNode->AddValueToArray(stateFrame); node->AddNodeToMap(Format("stateSprite%s", statePostfix[i].c_str()), spriteNode); } //StateDrawType UIControlBackground::eDrawType drawType = this->GetStateDrawType(stateArray[i]); if (baseControl->GetStateDrawType(stateArray[i]) != drawType) { node->Set(Format("stateDrawType%s", statePostfix[i].c_str()), loader->GetDrawTypeNodeValue(drawType)); } //leftRightStretchCap float32 leftStretchCap = this->GetActualBackground(stateArray[i])->GetLeftRightStretchCap(); float32 baseLeftStretchCap = baseControl->GetActualBackground(stateArray[i])->GetLeftRightStretchCap(); if (baseLeftStretchCap != leftStretchCap) { node->Set(Format("leftRightStretchCap%s", statePostfix[i].c_str()), leftStretchCap); } //topBottomStretchCap float32 topBottomStretchCap = this->GetActualBackground(stateArray[i])->GetTopBottomStretchCap(); float32 baseTopBottomStretchCap = baseControl->GetActualBackground(stateArray[i])->GetTopBottomStretchCap(); if (baseTopBottomStretchCap != topBottomStretchCap) { node->Set(Format("topBottomStretchCap%s", statePostfix[i].c_str()), topBottomStretchCap); } //State align int32 stateAlign = this->GetStateAlign(stateArray[i]); int32 baseStateAlign = baseControl->GetStateAlign(stateArray[i]); if (baseStateAlign != stateAlign) { node->AddNodeToMap(Format("stateAlign%s", statePostfix[i].c_str()), loader->GetAlignNodeValue(stateAlign)); } //State font, state text, text color, shadow color and shadow offset if (this->GetStateTextControl(stateArray[i])) { Font *stateFont = this->GetStateTextControl(stateArray[i])->GetFont(); node->Set(Format("stateFont%s", statePostfix[i].c_str()), FontManager::Instance()->GetFontName(stateFont)); nodeValue->SetWideString(this->GetStateTextControl(stateArray[i])->GetText()); node->Set(Format("stateText%s", statePostfix[i].c_str()), nodeValue); Color textColor = this->GetStateTextControl(stateArray[i])->GetTextColor(); nodeValue->SetVector4(Vector4(textColor.r, textColor.g, textColor.b, textColor.a)); node->Set(Format("stateTextcolor%s", statePostfix[i].c_str()), nodeValue); Color shadowColor = this->GetStateTextControl(stateArray[i])->GetShadowColor(); nodeValue->SetVector4(Vector4(shadowColor.r, shadowColor.g, shadowColor.b, shadowColor.a)); node->Set(Format("stateShadowcolor%s", statePostfix[i].c_str()), nodeValue); Vector2 shadowOffset = this->GetStateTextControl(stateArray[i])->GetShadowOffset(); nodeValue->SetVector2(shadowOffset); node->Set(Format("stateShadowoffset%s", statePostfix[i].c_str()), nodeValue); } //colorInherit ???? For different states? // Yuri Coder, 2012/11/16. Temporarily commented out until clarification. //UIControlBackground::eColorInheritType colorInheritType = this->GetStateBackground(stateArray[i])->GetColorInheritType(); //node->Set(Format("stateColorInherit%s", statePostfix[i].c_str()), loader->GetColorInheritTypeNodeValue(colorInheritType)); } SafeDelete(nodeValue); SafeRelease(baseControl); return node; }
void UISlider::LoadFromYamlNode(YamlNode * node, UIYamlLoader * loader) { UIControl::LoadFromYamlNode(node, loader); InitThumb(); YamlNode * thumbSpriteNode = node->Get("thumbSprite"); if (thumbSpriteNode) { YamlNode * spriteNode = thumbSpriteNode->Get(0); YamlNode * frameNode = thumbSpriteNode->Get(1); if (spriteNode) SetThumbSprite(spriteNode->AsString(), frameNode->AsInt()); //SetMinSprite("/XGfx/Options/slider_bg", 1); //SetMaxSprite("/XGfx/Options/slider_bg", 0); } YamlNode * minSpriteNode = node->Get("minSprite"); if (minSpriteNode) { YamlNode * spriteNode = minSpriteNode->Get(0); YamlNode * frameNode = minSpriteNode->Get(1); if (spriteNode) SetMinSprite(spriteNode->AsString(), frameNode->AsInt()); //SetMinSprite("/XGfx/Options/slider_bg", 1); //SetMaxSprite("/XGfx/Options/slider_bg", 0); } YamlNode * maxSpriteNode = node->Get("maxSprite"); if (maxSpriteNode) { YamlNode * spriteNode = maxSpriteNode->Get(0); YamlNode * frameNode = maxSpriteNode->Get(1); if (spriteNode) SetMaxSprite(spriteNode->AsString(), frameNode->AsInt()); //SetMinSprite("/XGfx/Options/slider_bg", 1); //SetMaxSprite("/XGfx/Options/slider_bg", 0); } // Values YamlNode * valueNode = node->Get("value"); if (valueNode) SetValue(valueNode->AsFloat()); YamlNode * minValueNode= node->Get("minValue"); if (minValueNode) SetMinValue(minValueNode->AsFloat()); YamlNode * maxValueNode= node->Get("maxValue"); if (maxValueNode) SetMaxValue(maxValueNode->AsFloat()); // Min/Max draw type YamlNode * minDrawTypeNode = node->Get("minDrawType"); if(minDrawTypeNode) { UIControlBackground::eDrawType type = (UIControlBackground::eDrawType)loader->GetDrawTypeFromNode(minDrawTypeNode); SetMinDrawType(type); } YamlNode * maxDrawTypeNode = node->Get("maxDrawType"); if(maxDrawTypeNode) { UIControlBackground::eDrawType type = (UIControlBackground::eDrawType)loader->GetDrawTypeFromNode(maxDrawTypeNode); SetMaxDrawType(type); } }