| /* | |
| * Copyright 2015 Google Inc. All Rights Reserved. | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| #include "cobalt/base/localized_strings.h" | |
| #include <libxml/parser.h> | |
| #include <libxml/tree.h> | |
| #include "base/file_path.h" | |
| #include "base/file_util.h" | |
| #include "base/logging.h" | |
| #include "base/path_service.h" | |
| namespace base { | |
| namespace { | |
| // Does a DFS over the tree starting at |node| and ending at the first element | |
| // whose name is |name|. | |
| xmlNode* FindXmlNode(xmlNode* node, const char* name) { | |
| xmlNode* child = node->children; | |
| while (child) { | |
| if (child->type == XML_ELEMENT_NODE) { | |
| if (strcmp((const char*)child->name, name) == 0) { | |
| return child; | |
| } | |
| xmlNode* descendant = FindXmlNode(child, name); | |
| if (descendant) { | |
| return descendant; | |
| } | |
| } | |
| child = child->next; | |
| } | |
| return NULL; | |
| } | |
| } // namespace | |
| LocalizedStrings* LocalizedStrings::GetInstance() { | |
| return Singleton<LocalizedStrings>::get(); | |
| } | |
| LocalizedStrings::LocalizedStrings() { | |
| // Initialize to US English on creation. A subsequent call to Initialize | |
| // will overwrite all available strings in the specified language. | |
| LoadStrings("en-US"); | |
| } | |
| LocalizedStrings::~LocalizedStrings() {} | |
| void LocalizedStrings::Initialize(const std::string& language) { | |
| LoadStrings(language); | |
| } | |
| std::string LocalizedStrings::GetString(const std::string& id, | |
| const std::string& fallback) { | |
| StringContainer::iterator iter = strings_.find(id); | |
| if (iter == strings_.end()) { | |
| return fallback; | |
| } | |
| return iter->second; | |
| } | |
| void LocalizedStrings::LoadStrings(const std::string& language) { | |
| // Construct the XLB filename. | |
| FilePath xlb_path; | |
| PathService::Get(base::DIR_EXE, &xlb_path); | |
| xlb_path = xlb_path.Append("i18n").Append(language).AddExtension("xlb"); | |
| // Try to open the XLB file. | |
| std::string content; | |
| if (!file_util::ReadFileToString(xlb_path, &content)) { | |
| DLOG(WARNING) << "Cannot open XLB file: " << xlb_path.value(); | |
| // Fall back to a generic version of the same language. | |
| size_t dash = language.find('-'); | |
| if (dash != std::string::npos) { | |
| // Chop off the country part of the language string and try again. | |
| std::string generic_lang(language.c_str(), dash); | |
| LoadStrings(generic_lang); | |
| } | |
| return; | |
| } | |
| // Parse the XML document. | |
| xmlDoc* doc = xmlParseDoc(reinterpret_cast<const xmlChar*>(content.c_str())); | |
| if (!doc) { | |
| DLOG(WARNING) << "Cannot parse XLB file: " << xlb_path.value(); | |
| return; | |
| } | |
| // Find the first <msg> node by DFS. | |
| xmlNode* msg = FindXmlNode(xmlDocGetRootElement(doc), "msg"); | |
| // Iterate through the sibling <msg> elements. | |
| while (msg) { | |
| if (!strcmp((const char*)msg->name, "msg")) { | |
| // Add the data from this element to the strings list. | |
| char* name = | |
| reinterpret_cast<char*>(xmlGetProp(msg, (const xmlChar*)"name")); | |
| char* value = | |
| reinterpret_cast<char*>(xmlNodeListGetString(doc, msg->children, 1)); | |
| strings_[name] = value; | |
| xmlFree(name); | |
| xmlFree(value); | |
| } | |
| msg = msg->next; | |
| } | |
| xmlFreeDoc(doc); | |
| } | |
| } // namespace base |