| /* |
| ***************************************************************************** |
| * Copyright (C) 2000-2004, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ***************************************************************************** |
| */ |
| package com.ibm.rbm; |
| |
| |
| import java.io.*; |
| import java.util.*; |
| |
| import javax.xml.parsers.*; |
| |
| import com.ibm.rbm.gui.RBManagerGUI; |
| import org.xml.sax.*; |
| import org.w3c.dom.*; |
| |
| /** |
| * This imports XLIFF files into RBManager. |
| * For more information see |
| * <a href="http://www.oasis-open.org/committees/xliff/documents/xliff-specification.htm"> |
| * http://www.oasis-open.org/committees/xliff/documents/xliff-specification.htm</a> |
| * |
| * @author George Rhoten |
| * @see com.ibm.rbm.RBManager |
| */ |
| public class RBxliffImporter extends RBImporter { |
| |
| Document xlf_xml = null; |
| |
| /** |
| * Basic constructor for the XLIFF importer from the parent RBManager data and a Dialog title. |
| */ |
| public RBxliffImporter(String title, RBManager rbm, RBManagerGUI gui) { |
| super(title, rbm, gui); |
| } |
| |
| protected void setupFileChooser() { |
| chooser.setFileFilter(new javax.swing.filechooser.FileFilter(){ |
| public boolean accept(File f) { |
| return (f.isDirectory() || f.getName().endsWith(".xlf")); |
| } |
| |
| public String getDescription() { |
| return Resources.getTranslation("import_XLF_file_description"); |
| } |
| }); |
| } |
| |
| protected void beginImport() throws IOException { |
| super.beginImport(); |
| File xlf_file = getChosenFile(); |
| |
| try { |
| FileInputStream fis = new FileInputStream(xlf_file); |
| InputSource is = new InputSource(fis); |
| DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder(); |
| xlf_xml = builder.parse(is); |
| fis.close(); |
| } |
| catch (SAXException e) { |
| e.printStackTrace(System.err); |
| throw new IOException(e.getMessage()); |
| } |
| catch (ParserConfigurationException pce) { |
| pce.printStackTrace(System.err); |
| throw new IOException(pce.getMessage()); |
| } |
| if (xlf_xml == null) |
| return; |
| |
| importDoc(); |
| |
| } |
| |
| private void importDoc() { |
| if (xlf_xml == null) |
| return; |
| String language = ""; |
| String bundle_note = null; |
| String bundle_name = null; |
| String manager_name = null; |
| String language_name = null; |
| String country_name = null; |
| String variant_name = null; |
| |
| Element root = xlf_xml.getDocumentElement(); |
| Node fileNode = root.getFirstChild(); |
| Node header = null; |
| Node node = null; |
| while (fileNode != null && !(fileNode instanceof Element && fileNode.getNodeName().equalsIgnoreCase("file"))) { |
| fileNode = fileNode.getNextSibling(); |
| } |
| header = fileNode.getFirstChild(); |
| while (header != null |
| && !(header.getNodeType() == Node.ELEMENT_NODE |
| && (header.getNodeName().equalsIgnoreCase("header") |
| || header.getNodeName().equalsIgnoreCase("body")))) |
| { |
| header = header.getNextSibling(); |
| } |
| if (header.getNodeName().equalsIgnoreCase("header")) { |
| // Get the notes if from the header if they exist. |
| NodeList header_note_list = ((Element)header).getElementsByTagName("note"); |
| if (header_note_list.getLength() > 0) { |
| Text text_elem = (Text)header_note_list.item(0).getChildNodes().item(0); |
| if (text_elem != null) { |
| String value = text_elem.getNodeValue(); |
| if (value != null && value.length() > 0) { |
| bundle_note = value; |
| } |
| } |
| } |
| Node prop_group_list = ((Element)header).getElementsByTagName("prop-group").item(0); |
| NodeList prop_list = prop_group_list.getChildNodes(); |
| int propertyNum = prop_list.getLength(); |
| if (propertyNum > 0) { |
| for (int prop = 0; prop < propertyNum; prop++) { |
| if (prop_list.item(prop) instanceof Element) { |
| Element property_elem = (Element)prop_list.item(prop); |
| String propertyType = property_elem.getAttribute("prop-type"); |
| if (propertyType != null) { |
| String value = property_elem.getChildNodes().item(0).getNodeValue(); |
| if (value != null && value.length() > 0) { |
| if (propertyType.equals("name")) { |
| bundle_name = value; |
| } |
| else if (propertyType.equals("manager")) { |
| manager_name = value; |
| } |
| else if (propertyType.equals("language")) { |
| language_name = value; |
| } |
| else if (propertyType.equals("country")) { |
| country_name = value; |
| } |
| else if (propertyType.equals("variant")) { |
| variant_name = value; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| node = header.getNextSibling(); |
| while (node != null && !(node instanceof Element && node.getNodeName().equalsIgnoreCase("body"))) { |
| node = node.getNextSibling(); |
| } |
| |
| Element body = (Element)node; |
| //resolveEncodings(getEncodingsVector(body)); |
| |
| String sourceLocale = ((Element)fileNode).getAttribute("source-language"); |
| String targetLocale = ((Element)fileNode).getAttribute("target-language"); |
| if (!sourceLocale.equals("")) { |
| language = sourceLocale; |
| } |
| if (!targetLocale.equals("")) { |
| // The target language is the real data. The source is only for reference. |
| // We could do verification that all the data is translated the same though. |
| language = targetLocale; |
| } |
| |
| // Now do the actual import resource by resource |
| NodeList tu_list = body.getElementsByTagName("group"); |
| int body_nodes_length = body.getChildNodes().getLength(); |
| NodeList body_list = body.getChildNodes(); |
| int groupCount = 0, elementCount = 0; |
| Node last_group_node = null; |
| for (int i=0; i < body_nodes_length; i++) { |
| Node body_elem = body_list.item(i); |
| if (body_elem.getNodeType() == Node.ELEMENT_NODE) { |
| if (body_elem.getNodeName().equalsIgnoreCase("group")) { |
| groupCount++; |
| last_group_node = body_elem; |
| } |
| elementCount++; |
| } |
| } |
| if (elementCount == 1 && groupCount == 1) { |
| // ICU style group where the top group is just the locale. |
| Element localeNode = (Element)last_group_node; |
| tu_list = last_group_node.getChildNodes(); |
| String rootGroupName = localeNode.getAttribute("id"); |
| if (rootGroupName != null && rootGroupName.equals("root")) { |
| rootGroupName = ""; |
| } |
| // It's done this way because ICU handles rfc3066bis (the successor of rfc3066) |
| // XLIFF requires rfc3066, which doesn't handle scripts. |
| language = rootGroupName; |
| } |
| |
| // Add the locale if needed, and normalize it to the correct format. |
| Vector localeNames = new Vector(); |
| char array[] = language.toCharArray(); |
| for (int k=0; k < array.length; k++) { |
| if (array[k] == '-') |
| array[k] = '_'; |
| } |
| language = String.valueOf(array); |
| localeNames.add(language); |
| resolveEncodings(localeNames); |
| Bundle main_bundle = rbm.getBundle(language); |
| main_bundle.name = bundle_name; |
| main_bundle.comment = bundle_note; |
| main_bundle.manager = manager_name; |
| main_bundle.language = language_name; |
| main_bundle.country = country_name; |
| main_bundle.variant = variant_name; |
| |
| for (int i=0; i < tu_list.getLength(); i++) { |
| if (!(tu_list.item(i) instanceof Element)) { |
| continue; |
| } |
| Element tu_elem = (Element)tu_list.item(i); |
| |
| // Get the key value |
| String name = tu_elem.getAttribute("id"); |
| if (name == null || name.length() < 1) |
| continue; |
| // Get the group if it exists |
| String group = null; |
| if (tu_elem.getNodeName().equalsIgnoreCase("group")) { |
| group = name; |
| String groupComment = ""; |
| NodeList notes_list = tu_elem.getElementsByTagName("note"); |
| if (notes_list.getLength() > 0) { |
| Text text_elem = (Text)notes_list.item(0).getChildNodes().item(0); |
| String value = text_elem.getNodeValue(); |
| if (value != null && value.length() > 0) { |
| groupComment = value; |
| } |
| } |
| rbm.createGroup(group, groupComment); |
| //NodeList group_list = tu_elem.getElementsByTagName("group"); |
| } |
| |
| if (group == null || group.length() < 1) { |
| group = getDefaultGroup(); |
| parseTranslationUnit(language, group, tu_elem); |
| } |
| |
| NodeList trans_unit_list = tu_elem.getElementsByTagName("trans-unit"); |
| // For each trans-unit element |
| for (int j=0; j < trans_unit_list.getLength(); j++) { |
| parseTranslationUnit(language, group, (Element)trans_unit_list.item(j)); |
| } |
| } |
| } |
| |
| private void parseTranslationUnit(String language, String group, Element trans_unit_elem) { |
| // Get the translation value |
| Node target_elem = trans_unit_elem.getElementsByTagName("target").item(0); |
| if (target_elem == null) { |
| // This is a template, or a skeleton |
| target_elem = trans_unit_elem.getElementsByTagName("source").item(0); |
| } |
| // If there is a source or target, even if empty, it must be parsed. |
| if (target_elem == null) |
| return; |
| target_elem.normalize(); |
| NodeList text_list = target_elem.getChildNodes(); |
| if (text_list.getLength() < 1) |
| return; |
| Text text_elem = (Text)text_list.item(0); |
| String transValue = text_elem.getNodeValue(); |
| if (transValue == null || transValue.length() < 1) |
| return; |
| /*NamedNodeMap attribMap = trans_unit_elem.getAttributes(); |
| for (int k = 0; k < attribMap.getLength(); k++) { |
| String attribMapName = attribMap.item(k).getNodeName(); |
| System.out.println(attribMapName); |
| }*/ |
| String name = trans_unit_elem.getAttribute("id"); |
| if (name == null || name.length() < 1) |
| return; |
| // Create the bundle item |
| BundleItem item = new BundleItem(null, name, transValue); |
| // Get creation, modification values |
| |
| String state = trans_unit_elem.getAttribute("state"); |
| if (state != null && state.length() > 0) { |
| item.setTranslated(state.equalsIgnoreCase("translated")); |
| } |
| |
| String date = trans_unit_elem.getAttribute("date"); |
| if (date != null && date.length() > 0) { |
| item.setModifiedDate(date); |
| } |
| |
| Element note_elem = (Element)trans_unit_elem.getElementsByTagName("note").item(0); |
| if (note_elem != null) { |
| NodeList note_list = note_elem.getChildNodes(); |
| if (note_list.getLength() > 0) { |
| Text note_text_elem = (Text)note_list.item(0); |
| String comment = note_text_elem.getNodeValue(); |
| if (comment != null && comment.length() > 0) { |
| item.setComment(comment); |
| } |
| } |
| } |
| |
| Element prop_group_elem = (Element)trans_unit_elem.getElementsByTagName("prop-group").item(0); |
| if (prop_group_elem != null) { |
| NodeList prop_list = prop_group_elem.getChildNodes(); |
| int propertyLen = prop_list.getLength(); |
| for (int prop = 0; prop < propertyLen; prop++) { |
| if (prop_list.item(prop) instanceof Element) { |
| Element property_elem = (Element)prop_list.item(prop); |
| String propertyType = property_elem.getAttribute("prop-type"); |
| if (propertyType != null) { |
| String value = property_elem.getChildNodes().item(0).getNodeValue(); |
| if (value != null && value.length() > 0) { |
| if (propertyType.equals("creator")) { |
| item.setCreator(value); |
| } |
| else if (propertyType.equals("created")) { |
| item.setCreatedDate(value); |
| } |
| else if (propertyType.equals("modifier")) { |
| item.setModifier(value); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // if (lookups != null) |
| // item.setLookups(lookups); |
| importResource(item, language, group); |
| } |
| } |