Example usage for org.apache.commons.configuration Configuration setProperty

List of usage examples for org.apache.commons.configuration Configuration setProperty

Introduction

In this page you can find the example usage for org.apache.commons.configuration Configuration setProperty.

Prototype

void setProperty(String key, Object value);

Source Link

Document

Set a property, this will replace any previously set values.

Usage

From source file:revaligner.service.FileAligner.java

public void buildTargetContentMap() throws Exception {
    System.out.println("rebuilding target content map file....");

    ExtractionSupportImpl extractionSupportImpl_trg = new ExtractionSupportImpl(
            Locale.makeLocale(this.targetlanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config_trg = new BaseConfiguration();
    config_trg.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl_trg.setConfiguration(config_trg);

    this.txlftrgsegmap = new LinkedHashMap();
    this.txlftrgsewsmap = new LinkedHashMap();
    org.dom4j.Document document_target_seg = XmlParser.parseXmlFile(this.reformattedtargettxlf_seg);
    org.dom4j.Element root_target_seg = document_target_seg.getRootElement();
    List list_target_para = root_target_seg.selectNodes("//*[name() = 'group'][@restype = 'x-paragraph']");
    int segmentId = 1;
    for (int i = 0; i < list_target_para.size(); i++) {
        org.dom4j.Element group = (org.dom4j.Element) list_target_para.get(i);
        for (int j = 0; j < group.elements("trans-unit").size(); j++) {
            org.dom4j.Element trg_txlf_seg = (org.dom4j.Element) group.elements("trans-unit").get(j);
            String trgseg = trg_txlf_seg.element("source").getText().trim().replaceAll("(\\s)+", " ");
            if (extractionSupportImpl_trg.isExtractable(trgseg)) {
                List tmp_content = new ArrayList();
                for (int z = 0; z < trg_txlf_seg.content().size(); z++) {
                    if ((trg_txlf_seg.content().get(z) instanceof org.dom4j.Element)) {
                        tmp_content.add(trg_txlf_seg.content().get(z));
                    }/* ww  w  .  j a v a  2  s  .c  o  m*/
                }
                this.txlftrgsegmap.put(Integer.valueOf(segmentId), tmp_content);
                boolean[] seg_attr = { false, false };
                if (j == 0) {
                    seg_attr[0] = true;
                }
                if (j == group.elements("trans-unit").size() - 1) {
                    seg_attr[1] = true;
                }
                this.txlftrgsewsmap.put(Integer.valueOf(segmentId), seg_attr);
                segmentId++;
            }
        }
    }
}

From source file:revaligner.service.FileAligner.java

public boolean verifysegments() throws Exception {
    System.out.println("verifying segments mapping....");
    boolean isValid = false;
    ExtractionSupportImpl extractionSupportImpl = new ExtractionSupportImpl(
            Locale.makeLocale(this.sourcelanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config = new BaseConfiguration();
    config.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl.setConfiguration(config);

    org.dom4j.Document document_source = XmlParser.parseXmlFile(this.sourcetxlf_seg);
    org.dom4j.Element root_source = document_source.getRootElement();

    List list_source = root_source.selectNodes("//*[name() = 'trans-unit']");
    int numberOfPara_source = list_source.size();

    List<org.dom4j.Element> text_source = new ArrayList();
    Iterator iter_source = list_source.iterator();
    while (iter_source.hasNext()) {
        org.dom4j.Element source = ((org.dom4j.Element) iter_source.next()).element("source");
        text_source.add(source);/*  www  .  j a  v  a 2s .c o  m*/
    }
    List<String> mergedsegtext = new ArrayList();
    org.dom4j.Document alignedxml = XmlParser.parseXmlFile(this.alignedfile);
    org.dom4j.Element root = alignedxml.getRootElement();
    List groups = root.selectNodes("//*[name() = 'group']");
    for (int i = 0; i < groups.size(); i++) {
        org.dom4j.Element group = (org.dom4j.Element) groups.get(i);
        List units = group.elements("unit");
        ArrayList<String> keys = new ArrayList();
        ArrayList<String> key_left = new ArrayList();
        ArrayList<String> key_right = new ArrayList();
        ArrayList<String> org_keys = new ArrayList();
        for (int j = 0; j < units.size(); j++) {
            org.dom4j.Element unit = (org.dom4j.Element) units.get(j);
            org.dom4j.Element src_para = unit.element("src_para");
            if (src_para != null) {
                List segs = src_para.element("segments").elements("src_seg");
                for (int z = 0; z < segs.size(); z++) {
                    org.dom4j.Element seg = (org.dom4j.Element) segs.get(z);
                    keys.add(seg.getText().replaceAll("(?s)<del>.*?</del>", "").replaceAll("<(/)*ins>", "")
                            .replace("<br>", "").replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&")
                            .trim());
                    org_keys.add(seg.getText());
                    if ((z == 0) && (z == segs.size() - 1)) {
                        key_left.add(src_para.attributeValue("lefttrim"));
                        key_right.add(src_para.attributeValue("righttrim"));
                    } else if (z == 0) {
                        key_left.add(src_para.attributeValue("lefttrim"));
                        key_right.add("true");
                    } else if (z == segs.size() - 1) {
                        key_left.add("true");
                        key_right.add(src_para.attributeValue("righttrim"));
                    } else {
                        key_left.add("true");
                        key_right.add("true");
                    }
                }
            }
        }
        SegmenterFactory factory = new SegmenterFactory();
        Configuration segconfig = createConfigForSegmenter(false, this.sourcelanguage);
        Segmenter segmenter = factory.getSegmenter("trados", Locale.makeLocale(this.sourcelanguage), segconfig);
        List<String> finsegs = segmenter.segment(
                group.elementText("text").replaceAll("(?s)<del>.*?</del>", "").replaceAll("<(/)*ins>", "")
                        .replace("<br>", "").replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&"));
        ArrayList<ArrayList<Integer>> indices = new ArrayList();
        int key_start_index = 0;
        ArrayList<Integer> indice;
        for (int k = 0; k < finsegs.size(); k++) {
            String finsegtext = (String) finsegs.get(k);

            String combined_key = "";
            indice = new ArrayList();
            for (int x = key_start_index; x < keys.size(); x++) {
                combined_key = combined_key + (String) keys.get(x);

                indice.add(Integer.valueOf(x));
                if (combined_key.replace("", " ").trim().replaceAll("(\\s)+", "")
                        .equals(finsegtext.replace("", " ").trim().replaceAll("(\\s)+", ""))) {
                    indices.add(indice);
                    key_start_index = x + 1;
                    break;
                }
            }
        }
        for (int m = 0; m < indices.size(); m++) {
            ArrayList<Integer> temp_indice = (ArrayList) indices.get(m);
            String temp = "";
            for (int it : temp_indice) {
                temp = temp + (String) org_keys.get(it);
            }
            mergedsegtext.add(temp);
        }
    }
    List<String> rejectedtexts = new ArrayList();
    Workbook wb = new Workbook();
    Worksheet ws = wb.getWorksheets().get(0);
    Cells cells = ws.getCells();
    int count = Math.max(text_source.size(), mergedsegtext.size());
    int t_count = 0;
    for (int i = 0; i < count; i++) {
        String t_src = "";
        String t_fom = "";
        if (i < text_source.size()) {
            org.dom4j.Element src = (org.dom4j.Element) text_source.get(i);
            for (int j = 0; j < src.content().size(); j++) {
                if ((src.content().get(j) instanceof org.dom4j.Text)) {
                    t_src = t_src + ((org.dom4j.Text) src.content().get(j)).getText().replace("&", "&amp;")
                            .replace("<", "&lt;").replace(">", "&gt;");
                } else if ((src.content().get(j) instanceof org.dom4j.Element)) {
                    org.dom4j.Element e = (org.dom4j.Element) src.content().get(j);
                    if ((e.getName().equals("x")) && (e.attribute("ctype").getValue().equals("x-tab"))) {
                        t_src = t_src + " ";
                    } else if ((e.getName().equals("x")) && (e.attribute("ctype").getValue().equals("lb"))) {
                        t_src = t_src + "<br> ";
                    }
                }
            }
        }
        cells.get(i, 0).setHtmlString(t_src);
        if (i < mergedsegtext.size()) {
            t_fom = ((String) mergedsegtext.get(i)).replace("<ins>", "<u>").replace("</ins>", "</u>")
                    .replace("<del>", "<strike>").replace("</del>", "</strike>");
        }
        String accepted_t_fom = t_fom.replaceAll("(?s)<strike>.*?</strike>", "").replace("<u>", "")
                .replace("</u>", "").replace("&amp;paradel;", "").replace("<br>", "");
        String rejected_t_fom = t_fom.replaceAll("(?s)<u>.*?</u>", "").replace("<strike>", "")
                .replace("</strike>", "").replace("&amp;paradel;", "").replace("<br>", "");
        if (extractionSupportImpl.isExtractable(accepted_t_fom)) {
            String input = "<html>" + t_fom.replace("<br> ", "&#8629;<br>").replace("&amp;paradel;",
                    "<strike>&para;</strike><br>") + "</html>";

            cells.get(t_count, 1).setHtmlString(input);
            t_count++;
            if ((i < mergedsegtext.size())
                    && (TrackChangeHelper.getTrackChangeType((String) mergedsegtext.get(i)) == 3)) {
                rejectedtexts.add(rejected_t_fom);
            } else {
                rejectedtexts.add("");
            }
        }
    }
    wb.save(this.prjfolder + File.separator + "verifySegs.xlsx");
    if (numberOfPara_source == t_count) {
        System.out.println("result: TRUE source: " + numberOfPara_source + " formatted: " + t_count);
        isValid = true;

        String timestamp = new SimpleDateFormat("yyyyMMdd'T'HHmmss'Z'").format(new Date());
        for (int r = 0; r < list_source.size(); r++) {
            if (!((String) rejectedtexts.get(r)).equals("")) {
                org.dom4j.Element transunit = (org.dom4j.Element) list_source.get(r);
                org.dom4j.Element originalbase = transunit.addElement("alt-trans");
                org.dom4j.Element source = transunit.element("source");
                org.dom4j.Element target = transunit.element("target");
                source.addAttribute("gs4tr:seginfo",
                        "<root username=\"TC Aligner\" timestamp=\"" + timestamp + "\"/>");
                if (target != null) {
                    transunit.elements().add(transunit.elements().indexOf(target) + 1, originalbase.clone());
                } else {
                    transunit.elements().add(transunit.elements().indexOf(source) + 1, originalbase.clone());
                }
                transunit.remove(originalbase);

                org.dom4j.Element original = transunit.element("alt-trans");
                original.addAttribute("alttranstype", "x-previous-source-version");
                original.addAttribute("gs4tr:seginfo",
                        "<root username=\"Original\" timestamp=\"" + timestamp + "\"/>");
                org.dom4j.Element original_source = original.addElement("source");
                original_source.addText((String) rejectedtexts.get(r));
                original.addElement("target");
            }
        }
        OutputStreamWriter writer = new OutputStreamWriter(
                new BufferedOutputStream(new FileOutputStream(this.sourcetxlf_seg)), "UTF8");
        document_source.write(writer);
        writer.close();
    } else {
        System.out.println("result: false source: " + numberOfPara_source + " formatted: " + t_count);
    }
    return isValid;
}

From source file:revaligner.service.FileAligner.java

public void align() throws Exception {
    org.dom4j.Document document = DocumentHelper.createDocument();
    org.dom4j.Element root = document.addElement("alinger");
    org.dom4j.Element head = root.addElement("head");
    head.addAttribute("src_lang", this.sourcelanguage);
    head.addAttribute("trg_lang", this.targetlanguage);
    head.addAttribute("creator", this.creatorid);

    ExtractionSupportImpl extractionSupportImpl = new ExtractionSupportImpl(
            Locale.makeLocale(this.sourcelanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config = new BaseConfiguration();
    config.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl.setConfiguration(config);

    org.dom4j.Element content = root.addElement("content");
    org.dom4j.Element orphans = root.addElement("orphans");

    com.aspose.words.Document doc_src = new com.aspose.words.Document(this.sourcefile);
    com.aspose.words.Document doc_trg = new com.aspose.words.Document(this.targetfile);

    doc_src.joinRunsWithSameFormatting();
    trimParaLeadingTrailingSpace(doc_src);

    UnlinkFields(doc_src);/*w  w  w .ja v  a 2s  .  co  m*/
    doc_src.save(this.sourcefile + ".docx");

    doc_trg.joinRunsWithSameFormatting();
    trimParaLeadingTrailingSpace(doc_trg);

    UnlinkFields(doc_trg);

    int seqnum = 0;
    int srcparaindex = 0;
    int srcparaindex_accept = 0;
    int trgparaindex = 0;
    int srcparacnt = doc_src.getChildNodes(8, true).getCount();
    int trgparacnt = doc_trg.getChildNodes(8, true).getCount();

    boolean ismovefrom = false;
    boolean ismoveto = false;
    boolean isprvdelpara = false;

    int prv = 999999;
    int unitid = 0;
    for (int i = 0; i < srcparacnt; i++) {
        Paragraph para_src = (Paragraph) doc_src.getChildNodes(8, true).get(i);

        String para_text = getParaText(para_src);

        boolean isExtractable = extractionSupportImpl.isExtractable(para_text);
        boolean isNumeric = org.gs4tr.foundation3.core.utils.Text.isNumeric(para_text);
        if ((!para_text.equals("")) && (isExtractable) && (!isNumeric)) {
            String src_para_text = "";
            boolean hasadds = false;
            boolean hasdels = false;
            boolean hasnorm = false;
            for (int j = 0; j < para_src.getChildNodes(0, true).getCount(); j++) {
                com.aspose.words.Node node = para_src.getChildNodes(0, true).get(j);
                if (node.getNodeType() == 13) {
                    ismovefrom = true;
                } else if (node.getNodeType() == 14) {
                    ismovefrom = false;
                } else if (node.getNodeType() == 15) {
                    ismoveto = true;
                } else if (node.getNodeType() == 16) {
                    ismoveto = false;
                } else if (node.getNodeType() == 21) {
                    Run run = (Run) para_src.getChildNodes(0, true).get(j);
                    if (!run.getFont().getName().equals("Wingdings")) {
                        if ((run.isInsertRevision()) && (!run.isDeleteRevision())) {
                            hasadds = true;
                            src_para_text = src_para_text + "<ins>"
                                    + run.getText().replace("<", "&lt;").replace(">", "&gt;") + "</ins>";
                        } else if (run.isDeleteRevision()) {
                            hasdels = true;
                            src_para_text = src_para_text + "<del>"
                                    + run.getText().replace("<", "&lt;").replace(">", "&gt;") + "</del>";
                        } else if (ismoveto) {
                            hasadds = true;
                            src_para_text = src_para_text + "<ins>"
                                    + run.getText().replace("<", "&lt;").replace(">", "&gt;") + "</ins>";
                        } else if (ismovefrom) {
                            hasdels = true;
                            src_para_text = src_para_text + "<del>"
                                    + run.getText().replace("<", "&lt;").replace(">", "&gt;") + "</del>";
                        } else {
                            hasnorm = true;
                            src_para_text = src_para_text
                                    + run.getText().replace("<", "&lt;").replace(">", "&gt;");
                        }
                    }
                }
            }
            org.dom4j.Element unit;
            org.dom4j.Element src_para;
            if ((hasadds) && (!hasdels) && (!hasnorm)) {
                unit = content.addElement("unit");
                src_para = unit.addElement("src_para");
                unit.addAttribute("id", Integer.toString(unitid++));
                src_para.addAttribute("para_type", "insertion");
            } else if ((!hasadds) && (!hasdels) && (hasnorm)) {
                unit = content.addElement("unit");
                src_para = unit.addElement("src_para");
                unit.addAttribute("id", Integer.toString(unitid++));
                src_para.addAttribute("para_type", "regular");
            } else if ((!hasadds) && (hasdels) && (!hasnorm)) {
                unit = content.addElement("unit");
                src_para = unit.addElement("src_para");
                unit.addAttribute("id", Integer.toString(unitid++));
                src_para.addAttribute("para_type", "deletion");
            } else {
                unit = content.addElement("unit");
                src_para = unit.addElement("src_para");
                unit.addAttribute("id", Integer.toString(unitid++));
                src_para.addAttribute("para_type", "mix");
            }
            src_para.addAttribute("para_seq", Integer.toString(srcparaindex));
            src_para.addAttribute("para_seq_acpt", Integer.toString(srcparaindex_accept));
            if (prv != srcparaindex_accept) {
            }
            prv = srcparaindex_accept;
            src_para.addText(wordToHtml(src_para_text));
            if (((hasdels) || (hasnorm)) && (!isNumeric)) {
                if (trgparaindex < trgparacnt) {
                    Paragraph para_trg = (Paragraph) doc_trg.getChildNodes(8, true).get(trgparaindex);
                    String para_trg_text = getParaText(para_trg);
                    boolean isExtractable_trg = extractionSupportImpl.isExtractable(para_trg_text);
                    if (trgparaindex == trgparacnt - 1) {
                        if ((!para_trg_text.equals("")) && (isExtractable_trg)) {
                            org.dom4j.Element trg_para = unit.addElement("trg_para");

                            String trg_para_text = "";
                            for (int j = 0; j < para_trg.getChildNodes(21, true).getCount(); j++) {
                                Run run = (Run) para_trg.getChildNodes(21, true).get(j);
                                if (!run.getFont().getName().equals("Wingdings")) {
                                    trg_para_text = trg_para_text
                                            + run.getText().replace("<", "&lt;").replace(">", "&gt;");
                                }
                            }
                            trg_para.addAttribute("para_seq", Integer.toString(trgparaindex));
                            trg_para.addText(wordToHtml(trg_para_text));
                        }
                    } else {
                        while ((doc_trg.getChildNodes(8, true).get(trgparaindex).getText().trim().equals(""))
                                || (!extractionSupportImpl.isExtractable(
                                        doc_trg.getChildNodes(8, true).get(trgparaindex).getText()))
                                || (org.gs4tr.foundation3.core.utils.Text.isNumeric(
                                        doc_trg.getChildNodes(8, true).get(trgparaindex).getText().trim()))) {
                            trgparaindex++;
                            if (trgparaindex == trgparacnt - 1) {
                                break;
                            }
                        }
                        para_trg = (Paragraph) doc_trg.getChildNodes(8, true).get(trgparaindex);
                        para_trg_text = getParaText(para_trg);
                        if ((!para_trg_text.equals("")) && (extractionSupportImpl.isExtractable(para_trg_text))
                                && (!org.gs4tr.foundation3.core.utils.Text.isNumeric(para_trg_text))) {
                            org.dom4j.Element trg_para = unit.addElement("trg_para");

                            String trg_para_text = "";
                            for (int j = 0; j < para_trg.getChildNodes(21, true).getCount(); j++) {
                                Run run = (Run) para_trg.getChildNodes(21, true).get(j);
                                if (!run.getFont().getName().equals("Wingdings")) {
                                    trg_para_text = trg_para_text
                                            + run.getText().replace("<", "&lt;").replace(">", "&gt;");
                                }
                            }
                            trg_para.addAttribute("para_seq", Integer.toString(trgparaindex));
                            trg_para.addText(wordToHtml(trg_para_text));
                        }
                    }
                }
                trgparaindex++;
            }
            if (para_src.isDeleteRevision()) {
                isprvdelpara = true;
            } else {
                seqnum++;
                isprvdelpara = false;
            }
            if ((para_src.isEndOfCell()) || (para_src.isEndOfHeaderFooter()) || (para_src.isEndOfSection())) {
                seqnum++;
                isprvdelpara = false;
            }
            srcparaindex++;
            if (!isprvdelpara) {
                srcparaindex_accept++;
            }
        } else {
            for (int j = 0; j < para_src.getChildNodes(0, true).getCount(); j++) {
                com.aspose.words.Node node = para_src.getChildNodes(0, true).get(j);
                if (node.getNodeType() == 13) {
                    ismovefrom = true;
                } else if (node.getNodeType() == 14) {
                    ismovefrom = false;
                } else if (node.getNodeType() == 15) {
                    ismoveto = true;
                } else if (node.getNodeType() == 16) {
                    ismoveto = false;
                }
            }
            if (!para_src.isDeleteRevision()) {
                seqnum++;
                isprvdelpara = false;

                srcparaindex_accept++;
            }
            srcparaindex++;
        }
    }
    if (trgparaindex < trgparacnt) {
        for (int i = trgparaindex; i < trgparacnt; i++) {
            Paragraph para_trg = (Paragraph) doc_trg.getChildNodes(8, true).get(i);
            if ((!para_trg.getText().trim().equals(""))
                    && (extractionSupportImpl.isExtractable(para_trg.getText()))) {
                org.dom4j.Element unit = content.addElement("unit");
                unit.addAttribute("id", Integer.toString(seqnum));
                org.dom4j.Element trg_para = unit.addElement("trg_para");

                String trg_para_text = "";
                for (int j = 0; j < para_trg.getChildNodes(21, true).getCount(); j++) {
                    Run run = (Run) para_trg.getChildNodes(21, true).get(j);
                    if (!run.getFont().getName().equals("Wingdings")) {
                        trg_para_text = trg_para_text + run.getText().replace("<", "&lt;").replace(">", "&gt;");
                    }
                }
                trg_para.addAttribute("para_seq", Integer.toString(trgparaindex));
                trg_para.addText(wordToHtml(trg_para_text));

                seqnum++;
                trgparaindex++;
            }
        }
    }
    this.alignedfile = (new File(new File(this.sourcefile).getParent()).getParent() + "/rev_aligned.xml");
    if (new File(this.alignedfile).exists()) {
        new File(this.alignedfile).delete();
    }
    OutputStreamWriter writer = new OutputStreamWriter(
            new BufferedOutputStream(new FileOutputStream(this.alignedfile)), "UTF8");
    document.write(writer);
    writer.close();
}

From source file:revaligner.service.FileAligner.java

public void update(JSONArray arr, JSONArray missings, JSONArray locks, JSONArray segaligned, JSONArray targets,
        JSONArray missing_targets, int cnt) throws Exception {
    File alignedFile = new File(this.alignedfile);
    if (!alignedFile.exists()) {
        throw new FileNotFoundException("Could not find aligned xml file");
    }//from   www  .  jav  a  2  s .  c o m
    ExtractionSupportImpl extractionSupportImpl = new ExtractionSupportImpl(
            Locale.makeLocale(this.sourcelanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config = new BaseConfiguration();
    config.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl.setConfiguration(config);

    List<JSONArray> trg_list = new ArrayList();
    for (int i = 0; i < arr.length(); i++) {
        trg_list.add(arr.getJSONArray(i));
    }
    List<JSONArray> missings_list = new ArrayList();
    for (int i = 0; i < missings.length(); i++) {
        missings_list.add(missings.getJSONArray(i));
    }
    List<String> locks_list = new ArrayList();
    for (int i = 0; i < locks.length(); i++) {
        locks_list.add(locks.getString(i));
    }
    List<String> segaligned_list = new ArrayList();
    for (int i = 0; i < segaligned.length(); i++) {
        segaligned_list.add(segaligned.getString(i));
    }
    this.nullcnt = cnt;

    int unitcnt = 0;
    org.dom4j.Document document = XmlParser.parseXmlFile(this.alignedfile);
    org.dom4j.Element root = document.getRootElement();
    List<org.dom4j.Element> groups = document.getRootElement().element("aligned").elements("group");
    for (int i = 0; i < groups.size(); i++) {
        org.dom4j.Element group = (org.dom4j.Element) groups.get(i);

        List<org.dom4j.Element> units = group.elements("unit");
        for (int j = 0; j < units.size(); j++) {
            unitcnt++;
            org.dom4j.Element unit = (org.dom4j.Element) units.get(j);
            String seq = i + " - " + j;
            if (locks_list.contains(seq)) {
                unit.attribute("locked").setValue("true");
            } else {
                unit.attribute("locked").setValue("false");
            }
            if (segaligned_list.contains(seq)) {
                unit.attribute("alignsegs").setValue("true");
            } else {
                unit.attribute("alignsegs").setValue("false");
            }
            if (unitcnt <= trg_list.size()) {
                JSONArray segs = (JSONArray) trg_list.get(unitcnt - 1);
                String trg_para_text = targets.getString(unitcnt - 1);

                org.dom4j.Element trg_para = unit.element("trg_para");
                if (trg_para != null) {
                    trg_para.clearContent();
                } else {
                    trg_para = unit.addElement("trg_para");
                }
                trg_para.addAttribute("id", segs.getString(0));
                org.dom4j.Element trg_text = trg_para.addElement("text");
                org.dom4j.Element trg_segs = trg_para.addElement("segments");
                for (int s = 1; s < segs.length(); s++) {
                    org.dom4j.Element trg_seg = trg_segs.addElement("trg_seg");
                    trg_seg.addAttribute("id", Integer.toString(s - 1));
                    trg_seg.addAttribute("isExtractable",
                            Boolean.toString(extractionSupportImpl.isExtractable(segs.getString(s))));
                    trg_seg.setText(decodehtmlstring(segs.getString(s)));
                }
                trg_text.setText(decodehtmlstring(trg_para_text));
            } else {
                units.remove(j);
                j--;
            }
        }
        if (group.elements("unit").size() == 0) {
            groups.remove(i);
            i--;
        }
    }
    org.dom4j.Element orphans = root.element("orphans");
    orphans.clearContent();
    for (int i = 0; i < missings_list.size(); i++) {
        JSONArray segs = (JSONArray) missings_list.get(i);
        String trg_para_text = missing_targets.getString(i);

        org.dom4j.Element unit = orphans.addElement("unit");
        unit.addAttribute("id", Integer.toString(i));
        org.dom4j.Element trg_para = unit.addElement("trg_para");
        trg_para.addAttribute("id", segs.getString(0));
        org.dom4j.Element trg_text = trg_para.addElement("text");
        org.dom4j.Element trg_segs = trg_para.addElement("segments");
        for (int s = 1; s < segs.length(); s++) {
            org.dom4j.Element trg_seg = trg_segs.addElement("trg_seg");
            trg_seg.addAttribute("id", Integer.toString(s));
            trg_seg.addAttribute("isExtractable",
                    Boolean.toString(extractionSupportImpl.isExtractable(segs.getString(s))));
            trg_seg.setText(decodehtmlstring(segs.getString(s)));
        }
        trg_text.setText(decodehtmlstring(trg_para_text));
    }
    new File(this.alignedfile).delete();
    OutputStreamWriter writer = new OutputStreamWriter(
            new BufferedOutputStream(new FileOutputStream(this.alignedfile)), "UTF8");
    document.write(writer);
    writer.close();
}

From source file:revaligner.service.FileAligner.java

public void update_seg(JSONArray targets, JSONArray trg_seqs, JSONArray missing_targets,
        JSONArray missing_trg_seqs, JSONArray locks, int cnt, JSONArray edited, JSONArray review,
        JSONArray ignore) throws Exception {
    File alignedFile = new File(this.alignedfile);
    if (!alignedFile.exists()) {
        throw new FileNotFoundException("Could not find aligned xml file");
    }//  w  ww .  ja  v a  2s .  c om
    ExtractionSupportImpl extractionSupportImpl = new ExtractionSupportImpl(
            Locale.makeLocale(this.sourcelanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config = new BaseConfiguration();
    config.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl.setConfiguration(config);

    List<String> trg_list = new ArrayList();
    for (int i = 0; i < targets.length(); i++) {
        trg_list.add(targets.getString(i));
    }
    List<String> trg_seq_list = new ArrayList();
    for (int i = 0; i < trg_seqs.length(); i++) {
        trg_seq_list.add(trg_seqs.getString(i));
    }
    List<String> missing_list = new ArrayList();
    for (int i = 0; i < missing_targets.length(); i++) {
        missing_list.add(missing_targets.getString(i));
    }
    List<String> missing_seq_list = new ArrayList();
    for (int i = 0; i < missing_trg_seqs.length(); i++) {
        missing_seq_list.add(missing_trg_seqs.getString(i));
    }
    List<String> locks_list = new ArrayList();
    for (int i = 0; i < locks.length(); i++) {
        locks_list.add(locks.getString(i));
    }
    this.nullcnt = cnt;

    List<String> edited_list = new ArrayList();
    for (int i = 0; i < edited.length(); i++) {
        edited_list.add(edited.getString(i));
    }
    List<String> review_list = new ArrayList();
    for (int i = 0; i < review.length(); i++) {
        review_list.add(review.getString(i));
    }
    List<String> ignore_list = new ArrayList();
    for (int i = 0; i < ignore.length(); i++) {
        ignore_list.add(ignore.getString(i));
    }
    int segcnt = 0;
    org.dom4j.Document document = XmlParser.parseXmlFile(this.alignedfile);
    org.dom4j.Element root = document.getRootElement();
    List<org.dom4j.Element> groups = document.getRootElement().element("aligned").elements("group");
    for (int i = 0; i < groups.size(); i++) {
        org.dom4j.Element group = (org.dom4j.Element) groups.get(i);

        List<org.dom4j.Element> units = group.elements("unit");
        for (int j = 0; j < units.size(); j++) {
            org.dom4j.Element unit = (org.dom4j.Element) units.get(j);
            unit.addAttribute("alignsegs", "true");
            org.dom4j.Element src_para = unit.element("src_para");
            if (src_para != null) {
                List<org.dom4j.Element> src_segs = src_para.element("segments").elements("src_seg");
                for (int z = 0; z < src_segs.size(); z++) {
                    org.dom4j.Element src_seg = (org.dom4j.Element) src_segs.get(z);
                    String seq = i + " - " + j + " - " + z;
                    if (locks_list.contains(seq)) {
                        src_seg.attribute("locked").setValue("true");
                    } else {
                        src_seg.attribute("locked").setValue("false");
                    }
                    if (review_list.contains(seq)) {
                        src_seg.attribute("needreview").setValue("true");
                    } else {
                        src_seg.attribute("needreview").setValue("false");
                    }
                    if (ignore_list.contains(seq)) {
                        src_seg.attribute("ignored").setValue("true");
                    } else {
                        src_seg.attribute("ignored").setValue("false");
                    }
                }
                org.dom4j.Element trg_para = unit.element("trg_para");
                trg_para.remove(trg_para.element("text"));
                List<org.dom4j.Element> trg_segs = trg_para.element("segments").elements("trg_seg");
                for (int z = 0; z < trg_segs.size(); z++) {
                    org.dom4j.Element trg_seg = (org.dom4j.Element) trg_segs.get(z);
                    if (z >= src_segs.size()) {
                        trg_para.element("segments").remove(trg_seg);
                    } else if (segcnt < trg_list.size()) {
                        trg_seg.addAttribute("id", decodehtmlstring((String) trg_seq_list.get(segcnt)));
                        if ((edited_list.contains(decodehtmlstring((String) trg_seq_list.get(segcnt))))
                                || (decodehtmlstring((String) trg_seq_list.get(segcnt)).startsWith("n - "))) {
                            trg_seg.addAttribute("edited", "true");
                        }
                        String text = decodehtmlstring((String) trg_list.get(segcnt));
                        trg_seg.addAttribute("isExtractable",
                                Boolean.toString(extractionSupportImpl.isExtractable(text)));
                        trg_seg.setText(text);
                        segcnt++;
                    } else {
                        trg_para.element("segments").remove(trg_seg);
                    }
                }
                if (trg_para.element("segments").elements("trg_seg").size() == 0) {
                    group.remove(unit);
                }
            } else {
                org.dom4j.Element trg_para = unit.element("trg_para");
                trg_para.remove(trg_para.element("text"));
                List<org.dom4j.Element> trg_segs = trg_para.element("segments").elements("trg_seg");
                for (int z = 0; z < trg_segs.size(); z++) {
                    org.dom4j.Element trg_seg = (org.dom4j.Element) trg_segs.get(z);
                    if (segcnt < trg_list.size()) {
                        trg_seg.addAttribute("id", decodehtmlstring((String) trg_seq_list.get(segcnt)));
                        if ((edited_list.contains(decodehtmlstring((String) trg_seq_list.get(segcnt))))
                                || (decodehtmlstring((String) trg_seq_list.get(segcnt)).startsWith("n - "))) {
                            trg_seg.addAttribute("edited", "true");
                        }
                        String text = decodehtmlstring((String) trg_list.get(segcnt));
                        trg_seg.addAttribute("isExtractable",
                                Boolean.toString(extractionSupportImpl.isExtractable(text)));
                        trg_seg.setText(text);
                        segcnt++;
                    } else {
                        trg_para.element("segments").remove(trg_seg);
                    }
                }
                if (trg_para.element("segments").elements("trg_seg").size() == 0) {
                    group.remove(unit);
                }
            }
        }
        if (group.elements("unit").size() == 0) {
            groups.remove(i);
            i--;
        }
    }
    if (segcnt < trg_list.size()) {
        org.dom4j.Element group = root.element("aligned").addElement("group");
        group.addAttribute("id", Integer.toString(groups.size()));
        org.dom4j.Element unit = group.addElement("unit");
        unit.addAttribute("id", "0");
        org.dom4j.Element trg_para = unit.addElement("trg_para");
        trg_para.addAttribute("id", Integer.toString(groups.size()) + " - 0");
        org.dom4j.Element trgsegs = trg_para.addElement("segments");
        for (int x = segcnt; x < trg_list.size(); x++) {
            String text = decodehtmlstring((String) trg_list.get(x));
            org.dom4j.Element trg_seg = trgsegs.addElement("trg_seg");
            trg_seg.addAttribute("id", decodehtmlstring((String) trg_seq_list.get(x)));
            if ((edited_list.contains(decodehtmlstring((String) trg_seq_list.get(x))))
                    || (decodehtmlstring((String) trg_seq_list.get(x)).startsWith("n - "))) {
                trg_seg.addAttribute("edited", "true");
            }
            trg_seg.addAttribute("isExtractable", Boolean.toString(extractionSupportImpl.isExtractable(text)));
            trg_seg.setText(text);
        }
    }
    org.dom4j.Element orphans = root.element("orphans");
    orphans.clearContent();
    org.dom4j.Element unit = orphans.addElement("unit");
    unit.addAttribute("id", "0");
    org.dom4j.Element trg_para = unit.addElement("trg_para");
    trg_para.addAttribute("id", "0 - 0");
    org.dom4j.Element trg_segs = trg_para.addElement("segments");
    for (int i = 0; i < missing_list.size(); i++) {
        org.dom4j.Element trg_seg = trg_segs.addElement("trg_seg");
        String text = decodehtmlstring((String) missing_list.get(i));
        trg_seg.addAttribute("id", decodehtmlstring((String) missing_seq_list.get(i)));
        if ((edited_list.contains(decodehtmlstring((String) missing_seq_list.get(i))))
                || (decodehtmlstring((String) trg_seq_list.get(i)).startsWith("n - "))) {
            trg_seg.addAttribute("edited", "true");
        }
        trg_seg.addAttribute("isExtractable", Boolean.toString(extractionSupportImpl.isExtractable(text)));
        trg_seg.setText(text);
    }
    new File(this.alignedfile).delete();
    OutputStreamWriter writer = new OutputStreamWriter(
            new BufferedOutputStream(new FileOutputStream(this.alignedfile)), "UTF8");
    document.write(writer);
    writer.close();
    if (new File(this.auto_saved_alignedfile).exists()) {
        new File(this.auto_saved_alignedfile).delete();
    }
}

From source file:revaligner.service.FileAligner.java

public void auto_update_seg(JSONArray targets, JSONArray trg_seqs, JSONArray missing_targets,
        JSONArray missing_trg_seqs, JSONArray locks, int cnt, JSONArray edited, JSONArray review,
        JSONArray ignore) throws Exception {
    File alignedFile = new File(this.alignedfile);
    if (!alignedFile.exists()) {
        throw new FileNotFoundException("Could not find aligned xml file");
    }// w w  w  .j  a  va2s .co  m
    ExtractionSupportImpl extractionSupportImpl = new ExtractionSupportImpl(
            Locale.makeLocale(this.sourcelanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config = new BaseConfiguration();
    config.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl.setConfiguration(config);

    List<String> trg_list = new ArrayList();
    for (int i = 0; i < targets.length(); i++) {
        trg_list.add(targets.getString(i));
    }
    List<String> trg_seq_list = new ArrayList();
    for (int i = 0; i < trg_seqs.length(); i++) {
        trg_seq_list.add(trg_seqs.getString(i));
    }
    List<String> missing_list = new ArrayList();
    for (int i = 0; i < missing_targets.length(); i++) {
        missing_list.add(missing_targets.getString(i));
    }
    List<String> missing_seq_list = new ArrayList();
    for (int i = 0; i < missing_trg_seqs.length(); i++) {
        missing_seq_list.add(missing_trg_seqs.getString(i));
    }
    List<String> locks_list = new ArrayList();
    for (int i = 0; i < locks.length(); i++) {
        locks_list.add(locks.getString(i));
    }
    this.nullcnt = cnt;

    List<String> edited_list = new ArrayList();
    for (int i = 0; i < edited.length(); i++) {
        edited_list.add(edited.getString(i));
    }
    List<String> review_list = new ArrayList();
    for (int i = 0; i < review.length(); i++) {
        review_list.add(review.getString(i));
    }
    List<String> ignore_list = new ArrayList();
    for (int i = 0; i < ignore.length(); i++) {
        ignore_list.add(ignore.getString(i));
    }
    int segcnt = 0;
    org.dom4j.Document document = XmlParser.parseXmlFile(this.alignedfile);
    org.dom4j.Element root = document.getRootElement();
    List<org.dom4j.Element> groups = document.getRootElement().element("aligned").elements("group");
    for (int i = 0; i < groups.size(); i++) {
        org.dom4j.Element group = (org.dom4j.Element) groups.get(i);

        List<org.dom4j.Element> units = group.elements("unit");
        for (int j = 0; j < units.size(); j++) {
            org.dom4j.Element unit = (org.dom4j.Element) units.get(j);
            unit.addAttribute("alignsegs", "true");
            org.dom4j.Element src_para = unit.element("src_para");
            if (src_para != null) {
                List<org.dom4j.Element> src_segs = src_para.element("segments").elements("src_seg");
                for (int z = 0; z < src_segs.size(); z++) {
                    org.dom4j.Element src_seg = (org.dom4j.Element) src_segs.get(z);
                    String seq = i + " - " + j + " - " + z;
                    if (locks_list.contains(seq)) {
                        src_seg.attribute("locked").setValue("true");
                    } else {
                        src_seg.attribute("locked").setValue("false");
                    }
                    if (review_list.contains(seq)) {
                        src_seg.attribute("needreview").setValue("true");
                    } else {
                        src_seg.attribute("needreview").setValue("false");
                    }
                    if (ignore_list.contains(seq)) {
                        src_seg.attribute("ignored").setValue("true");
                    } else {
                        src_seg.attribute("ignored").setValue("false");
                    }
                }
                org.dom4j.Element trg_para = unit.element("trg_para");
                trg_para.remove(trg_para.element("text"));
                List<org.dom4j.Element> trg_segs = trg_para.element("segments").elements("trg_seg");
                for (int z = 0; z < trg_segs.size(); z++) {
                    org.dom4j.Element trg_seg = (org.dom4j.Element) trg_segs.get(z);
                    if (z >= src_segs.size()) {
                        trg_para.element("segments").remove(trg_seg);
                    } else if (segcnt < trg_list.size()) {
                        trg_seg.addAttribute("id", decodehtmlstring((String) trg_seq_list.get(segcnt)));
                        if ((edited_list.contains(decodehtmlstring((String) trg_seq_list.get(segcnt))))
                                || (decodehtmlstring((String) trg_seq_list.get(segcnt)).startsWith("n - "))) {
                            trg_seg.addAttribute("edited", "true");
                        }
                        String text = decodehtmlstring((String) trg_list.get(segcnt));
                        trg_seg.addAttribute("isExtractable",
                                Boolean.toString(extractionSupportImpl.isExtractable(text)));
                        trg_seg.setText(text);
                        segcnt++;
                    } else {
                        trg_para.element("segments").remove(trg_seg);
                    }
                }
                if (trg_para.element("segments").elements("trg_seg").size() == 0) {
                    group.remove(unit);
                }
            } else {
                org.dom4j.Element trg_para = unit.element("trg_para");
                trg_para.remove(trg_para.element("text"));
                List<org.dom4j.Element> trg_segs = trg_para.element("segments").elements("trg_seg");
                for (int z = 0; z < trg_segs.size(); z++) {
                    org.dom4j.Element trg_seg = (org.dom4j.Element) trg_segs.get(z);
                    if (segcnt < trg_list.size()) {
                        trg_seg.addAttribute("id", decodehtmlstring((String) trg_seq_list.get(segcnt)));
                        if ((edited_list.contains(decodehtmlstring((String) trg_seq_list.get(segcnt))))
                                || (decodehtmlstring((String) trg_seq_list.get(segcnt)).startsWith("n - "))) {
                            trg_seg.addAttribute("edited", "true");
                        }
                        String text = decodehtmlstring((String) trg_list.get(segcnt));
                        trg_seg.addAttribute("isExtractable",
                                Boolean.toString(extractionSupportImpl.isExtractable(text)));
                        trg_seg.setText(text);
                        segcnt++;
                    } else {
                        trg_para.element("segments").remove(trg_seg);
                    }
                }
                if (trg_para.element("segments").elements("trg_seg").size() == 0) {
                    group.remove(unit);
                }
            }
        }
        if (group.elements("unit").size() == 0) {
            groups.remove(i);
            i--;
        }
    }
    if (segcnt < trg_list.size()) {
        org.dom4j.Element group = root.element("aligned").addElement("group");
        group.addAttribute("id", Integer.toString(groups.size()));
        org.dom4j.Element unit = group.addElement("unit");
        unit.addAttribute("id", "0");
        org.dom4j.Element trg_para = unit.addElement("trg_para");
        org.dom4j.Element trgsegs = trg_para.addElement("segments");
        for (int x = segcnt; x < trg_list.size(); x++) {
            String text = decodehtmlstring((String) trg_list.get(x));
            org.dom4j.Element trg_seg = trgsegs.addElement("trg_seg");
            trg_seg.addAttribute("id", decodehtmlstring((String) trg_seq_list.get(x)));
            if ((edited_list.contains(decodehtmlstring((String) trg_seq_list.get(x))))
                    || (decodehtmlstring((String) trg_seq_list.get(x)).startsWith("n - "))) {
                trg_seg.addAttribute("edited", "true");
            }
            trg_seg.addAttribute("isExtractable", Boolean.toString(extractionSupportImpl.isExtractable(text)));
            trg_seg.setText(text);
        }
    }
    org.dom4j.Element orphans = root.element("orphans");
    orphans.clearContent();
    org.dom4j.Element unit = orphans.addElement("unit");
    unit.addAttribute("id", "0");
    org.dom4j.Element trg_para = unit.addElement("trg_para");
    org.dom4j.Element trg_segs = trg_para.addElement("segments");
    for (int i = 0; i < missing_list.size(); i++) {
        org.dom4j.Element trg_seg = trg_segs.addElement("trg_seg");
        String text = decodehtmlstring((String) missing_list.get(i));
        trg_seg.addAttribute("id", decodehtmlstring((String) missing_seq_list.get(i)));
        if ((edited_list.contains(decodehtmlstring((String) missing_seq_list.get(i))))
                || (decodehtmlstring((String) trg_seq_list.get(i)).startsWith("n - "))) {
            trg_seg.addAttribute("edited", "true");
        }
        trg_seg.addAttribute("isExtractable", Boolean.toString(extractionSupportImpl.isExtractable(text)));
        trg_seg.setText(text);
    }
    this.auto_saved_alignedfile = (this.alignedfile + ".temp");
    if (new File(this.auto_saved_alignedfile).exists()) {
        new File(this.auto_saved_alignedfile).delete();
    }
    OutputStreamWriter writer = new OutputStreamWriter(
            new BufferedOutputStream(new FileOutputStream(this.auto_saved_alignedfile)), "UTF8");
    document.write(writer);
    writer.close();
}

From source file:revaligner.service.FileAligner.java

public String convertFileToTxlf(String filePath, boolean segmentParagraph, String sourcelanguage)
        throws Exception {
    com.aspose.words.Document doc = new com.aspose.words.Document(filePath);
    doc.joinRunsWithSameFormatting();//  w w w.j av  a  2 s . c om
    doc.save(filePath);

    ArrayList<String> srcs = new ArrayList();
    srcs.add(filePath);

    String orgtxlfname = filePath + ".txlf";
    if (new File(orgtxlfname).exists()) {
        new File(orgtxlfname).delete();
    }
    Locale locale = Locale.makeLocale(sourcelanguage);
    Configuration config = new BaseConfiguration();
    config.setProperty("word.acceptTrackChanges", "true");
    config.setProperty("word.extractDropDownList", "false");
    config.setProperty("word.extractEquations", "false");
    config.setProperty("word.extractComments", "false");
    config.setProperty("extraction.tokens.extract", "all");
    config.setProperty("word.translateHyperlinkText", "true");
    config.setProperty("word.translateHyperlinkValue", "false");
    config.setProperty("word.ignoreBiLingualStyles", "true");
    ConvertDOC converter = new ConvertDOC();
    converter.setConfiguration(config);
    converter.setIgnoreSuccessfullConversion(true);

    converter.convert(srcs, locale);

    segmentTxlf(orgtxlfname, segmentParagraph, sourcelanguage);

    return orgtxlfname;
}

From source file:revaligner.service.FileAligner.java

public boolean verifyParas() throws Exception {
    System.out.println("verifying paragraphs mapping....");
    boolean isValid = false;
    ExtractionSupportImpl extractionSupportImpl = new ExtractionSupportImpl(
            Locale.makeLocale(this.sourcelanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config = new BaseConfiguration();
    config.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl.setConfiguration(config);

    org.dom4j.Document document_source = XmlParser.parseXmlFile(this.sourcetxlf_nonSeg);
    org.dom4j.Element root_source = document_source.getRootElement();

    org.dom4j.Document document_formatted = XmlParser.parseXmlFile(this.reformattedsourcetxlf_nonSeg);
    org.dom4j.Element root_formatted = document_formatted.getRootElement();

    List list_source = root_source.selectNodes("//*[name() = 'trans-unit']");
    int numberOfPara_source = list_source.size();

    List list_formatted = root_formatted.selectNodes("//*[name() = 'trans-unit']");
    int numberOfPara_formatted = list_formatted.size();

    List<org.dom4j.Element> text_source = new ArrayList();
    Iterator iter_source = list_source.iterator();
    while (iter_source.hasNext()) {
        org.dom4j.Element source = ((org.dom4j.Element) iter_source.next()).element("source");
        text_source.add(source);//from  w  w  w  .  j  av a2  s. co  m
    }
    List<org.dom4j.Element> text_formatted = new ArrayList();
    Iterator iter_formatted = list_formatted.iterator();
    while (iter_formatted.hasNext()) {
        org.dom4j.Element source = ((org.dom4j.Element) iter_formatted.next()).element("source");
        text_formatted.add(source);
    }
    Workbook wb = new Workbook();
    Worksheet ws = wb.getWorksheets().get(0);
    Cells cells = ws.getCells();
    int count = Math.max(text_source.size(), text_formatted.size());
    int t_count = 0;
    for (int i = 0; i < count; i++) {
        String t_src = "";
        String t_fom = "";
        if (i < text_source.size()) {
            org.dom4j.Element src = (org.dom4j.Element) text_source.get(i);
            for (int j = 0; j < src.content().size(); j++) {
                if ((src.content().get(j) instanceof org.dom4j.Text)) {
                    t_src = t_src + ((org.dom4j.Text) src.content().get(j)).getText().replace("&", "&amp;")
                            .replace("<", "&lt;").replace(">", "&gt;");
                } else if ((src.content().get(j) instanceof org.dom4j.Element)) {
                    org.dom4j.Element e = (org.dom4j.Element) src.content().get(j);
                    if ((e.getName().equals("x")) && (e.attribute("ctype").getValue().equals("x-tab"))) {
                        t_src = t_src + " ";
                    } else if ((e.getName().equals("x")) && (e.attribute("ctype").getValue().equals("lb"))) {
                        t_src = t_src + "<br> ";
                    }
                }
            }
        }
        cells.get(i, 0).setHtmlString("<html>" + t_src.trim().replace("<br> ", "&#8629;<br>") + "</html>");
        if (i < text_formatted.size()) {
            org.dom4j.Element src = (org.dom4j.Element) text_formatted.get(i);

            ArrayList<String> node_ids = new ArrayList();
            for (int j = 0; j < src.content().size(); j++) {
                if ((src.content().get(j) instanceof org.dom4j.Text)) {
                    t_fom = t_fom + ((org.dom4j.Text) src.content().get(j)).getText().replace("&", "&amp;")
                            .replace("<", "&lt;").replace(">", "&gt;");
                } else if ((src.content().get(j) instanceof org.dom4j.Element)) {
                    org.dom4j.Element e = (org.dom4j.Element) src.content().get(j);
                    if ((e.getName().equals("bx"))
                            && (e.attribute("ctype").getValue().equals("x-strike-through"))) {
                        t_fom = t_fom + "<strike>";
                        node_ids.add(e.attribute("rid").getValue());
                    } else if (e.getName().equals("ex")) {
                        if (node_ids.contains(e.attribute("rid").getValue())) {
                            t_fom = t_fom + "</strike>";
                            node_ids.remove(e.attribute("rid").getValue());
                        }
                    } else if ((e.getName().equals("bpt"))
                            && (e.attribute("ctype").getValue().equals("x-underlined"))
                            && (e.getText().contains("type=\"1\""))) {
                        t_fom = t_fom + "<u>";
                        node_ids.add(e.attribute("rid").getValue());
                    } else if (e.getName().equals("ept")) {
                        if (node_ids.contains(e.attribute("rid").getValue())) {
                            t_fom = t_fom + "</u>";
                            node_ids.remove(e.attribute("rid").getValue());
                        }
                    } else if ((e.getName().equals("x")) && (e.attribute("ctype").getValue().equals("x-tab"))) {
                        t_fom = t_fom + " ";
                    } else if ((e.getName().equals("x")) && (e.attribute("ctype").getValue().equals("lb"))) {
                        t_fom = t_fom + "<br> ";
                    }
                }
            }
            if (!t_fom.contains("<u>")) {
                if (src.selectNodes("..//*[name() = 'it'][@ctype = 'x-underlined'][@pos = 'open']")
                        .size() != 0) {
                    org.dom4j.Node node = (org.dom4j.Node) src
                            .selectNodes("..//*[name() = 'it'][@ctype = 'x-underlined'][@pos = 'open']").get(0);
                    if (node.getText().contains("type=\"1\"")) {
                        t_fom = "<u>" + t_fom + "</u>";
                    }
                }
            } else if ((!t_fom.contains("<strike>"))
                    && (src.selectNodes("..//*[name() = 'it'][@ctype = 'x-strike-through'][@pos = 'open']")
                            .size() != 0)) {
                t_fom = "<strike>" + t_fom + "</strike>";
            }
        }
        String accepted_t_fom = t_fom.replaceAll("(?s)<strike>.*?</strike>", "").replace("<u>", "")
                .replace("</u>", "").replace("&amp;paradel;", "").replace("&amp;parains;", "")
                .replace("&amp;hf;", "").replace("<br>", "");
        if (extractionSupportImpl.isExtractable(accepted_t_fom)) {
            String input = "<html>" + t_fom.replace("&amp;hf;", "").replace("&amp;parains;", "")
                    .replace("<br> ", "&#8629;<br>").replace("&amp;paradel;", "<strike>&para;</strike><br>")
                    + "</html>";
            cells.get(t_count, 1).setHtmlString(input);
            t_count++;
        }
    }
    wb.save(this.prjfolder + File.separator + "verifyParas.xlsx");
    if (numberOfPara_source == t_count) {
        System.out.println("result: TRUE source: " + numberOfPara_source + " formatted: " + t_count);
        isValid = true;
    } else {
        System.out.println("result: false source: " + numberOfPara_source + " formatted: " + t_count);
    }
    return isValid;
}

From source file:revaligner.service.FileAligner.java

private Configuration createConfigForSegmenter(boolean segmentParagraph, String srcLangcode) throws Exception {
    Configuration config = new BaseConfiguration();
    config.setProperty("segmenter.default.paragraphsegmenter", Boolean.valueOf(segmentParagraph));
    config.setProperty("segmenter.strategy.trados.rule1enabled", "true");

    config.setProperty("segmenter.default.strategy", "trados");
    config.setProperty("segmenter.default.simplifier", "fontformat");
    config.setProperty("breakiterator.strategy.sentence.trados.esps",
            createESMString(Locale.makeLocale(srcLangcode)));

    String abbv = getAbbreviations(srcLangcode);
    if (!abbv.equals("")) {
        config.setProperty("abbreviations." + srcLangcode.split("-")[0], abbv);
    }/*from  ww  w .j av a  2s. c  om*/
    return config;
}

From source file:revaligner.service.FileAligner.java

public ArrayList<String[]> populateSourceTxlf() throws Exception {
    System.out.println("populating source txlf with aligned segments....");

    ArrayList<String[]> reportStates = new ArrayList();

    ExtractionSupportImpl extractionSupportImpl = new ExtractionSupportImpl(
            Locale.makeLocale(this.sourcelanguage), Locale.makeLocale(this.targetlanguage));
    Configuration config = new BaseConfiguration();
    config.setProperty("extraction.tokens.extract", "all");
    extractionSupportImpl.setConfiguration(config);

    Locale locale = Locale.makeLocale(this.sourcelanguage);
    TradosWordCounter wcounter = new TradosWordCounter(locale, config);

    org.dom4j.Document document_src = XmlParser.parseXmlFile(this.sourcetxlf_nonSeg);
    org.dom4j.Element root_src = document_src.getRootElement();

    org.dom4j.Document document_src_ingt = XmlParser.parseXmlFile(this.sourcetxlf_nonSeg);
    org.dom4j.Element root_src_ingt = document_src_ingt.getRootElement();

    org.dom4j.Document document_src_seg = XmlParser.parseXmlFile(this.sourcetxlf_seg);
    org.dom4j.Element root_src_seg = document_src_seg.getRootElement();

    List<com.aspose.words.Node> list_source = root_src
            .selectNodes("//*[name() = 'group'][@restype = 'x-paragraph']");
    List<com.aspose.words.Node> list_source_ingt = root_src_ingt
            .selectNodes("//*[name() = 'group'][@restype = 'x-paragraph']");
    List<com.aspose.words.Node> list_source_seg = root_src_seg
            .selectNodes("//*[name() = 'group'][@restype = 'x-paragraph']");
    int count = 0;
    int totalWC = 0;

    org.dom4j.Document document = XmlParser.parseXmlFile(this.alignedfile);
    List<org.dom4j.Element> groups = document.getRootElement().element("aligned").elements("group");
    for (int i = 0; i < groups.size(); i++) {
        org.dom4j.Element group = (org.dom4j.Element) groups.get(i);
        List<org.dom4j.Element> units = group.elements("unit");
        if (((org.dom4j.Element) units.get(0)).element("src_para") != null) {
            boolean isParaAllSegmented = true;
            for (int j = 0; j < units.size(); j++) {
                if (((org.dom4j.Element) units.get(j)).attributeValue("alignsegs").equals("false")) {
                    isParaAllSegmented = false;
                    break;
                }/*from  ww w  . j  a  va2 s .c  om*/
            }
            String srcTextAccepted = group.elementText("text").replaceAll("(?s)<del>.*?</del>", "")
                    .replaceAll("<(/)*ins>", "");
            if (!extractionSupportImpl.isExtractable(srcTextAccepted)) {
                if (isParaAllSegmented) {
                    for (int j = 0; j < units.size(); j++) {
                        org.dom4j.Element unit = (org.dom4j.Element) units.get(j);
                        List<org.dom4j.Element> srcsegs = unit.element("src_para").element("segments")
                                .elements("src_seg");
                        List<org.dom4j.Element> trgsegs = unit.element("trg_para").element("segments")
                                .elements("trg_seg");
                        for (int x = 0; x < srcsegs.size(); x++) {
                            String[] s = new String[7];
                            s[0] = ((org.dom4j.Element) srcsegs.get(x)).getText();
                            if (x >= trgsegs.size()) {
                                s[1] = "";
                            } else {
                                org.dom4j.Element trgseg = (org.dom4j.Element) trgsegs.get(x);
                                String id = trgseg.attributeValue("id");
                                if (id.startsWith("n - ")) {
                                    s[1] = trgseg.getText();
                                } else {
                                    List tmp_contents = new ArrayList();
                                    if (id.contains(" - ")) {
                                        int start = Integer.parseInt(id.split(" - ")[0]);
                                        int end = Integer.parseInt(id.split(" - ")[1]);
                                        tmp_contents.addAll(
                                                (Collection) this.txlftrgsegmap.get(Integer.valueOf(start)));
                                        for (int su = start + 1; su <= end; su++) {
                                            boolean isprevendofpara = ((boolean[]) this.txlftrgsewsmap
                                                    .get(Integer.valueOf(su - 1)))[1];
                                            boolean iscurrentstartofpara = ((boolean[]) this.txlftrgsewsmap
                                                    .get(Integer.valueOf(su)))[0];
                                            if ((isprevendofpara) && (iscurrentstartofpara)) {
                                                List prevseg = (List) this.txlftrgsegmap
                                                        .get(Integer.valueOf(su - 1));
                                                int previdx = -1;
                                                for (int prev = 0; prev < prevseg.size(); prev++) {
                                                    org.dom4j.Node prevnode = (org.dom4j.Node) prevseg
                                                            .get(prev);
                                                    if (prevnode.getNodeType() == 1) {
                                                        org.dom4j.Element prevnode_e = (org.dom4j.Element) prevnode;
                                                        if ((prevnode_e.getName().equals("ws")) && (prevnode_e
                                                                .attributeValue("pos").equals("after"))) {
                                                            previdx = prevseg.size() - prev;
                                                        }
                                                    }
                                                }
                                                if (previdx != -1) {
                                                    tmp_contents.remove(tmp_contents.size() - previdx);
                                                }
                                                List currseg = (List) this.txlftrgsegmap
                                                        .get(Integer.valueOf(su));
                                                int curridx = -1;
                                                for (int curr = 0; curr < currseg.size(); curr++) {
                                                    org.dom4j.Node currnode = (org.dom4j.Node) currseg
                                                            .get(curr);
                                                    if (currnode.getNodeType() == 1) {
                                                        org.dom4j.Element currnode_e = (org.dom4j.Element) currnode;
                                                        if ((currnode_e.getName().equals("ws")) && (currnode_e
                                                                .attributeValue("pos").equals("before"))) {
                                                            curridx = curr;
                                                        }
                                                    }
                                                }
                                                if (curridx != -1) {
                                                    currseg.remove(curridx);
                                                }
                                                if (Locale.makeLocale(this.targetlanguage).isFarEast()) {
                                                    tmp_contents.addAll(currseg);
                                                } else {
                                                    tmp_contents.add(DocumentHelper.createText(" "));
                                                    tmp_contents.addAll(currseg);
                                                }
                                            } else {
                                                tmp_contents.addAll((Collection) this.txlftrgsegmap
                                                        .get(Integer.valueOf(su)));
                                            }
                                        }
                                    } else {
                                        tmp_contents.addAll((Collection) this.txlftrgsegmap
                                                .get(Integer.valueOf(Integer.parseInt(id))));
                                    }
                                    s[1] = trimText(assembleText(tmp_contents).replace("<br> ", "&#8629;<br>"),
                                            false)[0];
                                }
                            }
                            s[2] = "N/A";
                            s[3] = "N/A";
                            s[4] = ((org.dom4j.Element) srcsegs.get(x)).attributeValue("tctype");
                            s[5] = "0";
                            s[6] = "";
                            reportStates.add(s);
                        }
                    }
                } else {
                    String[] s = new String[7];
                    for (int j = 0; j < units.size(); j++) {
                        s[0] = ((org.dom4j.Element) units.get(j)).element("src_para").elementText("text");
                        if (((org.dom4j.Element) units.get(j)).element("trg_para") != null) {
                            s[1] = ((org.dom4j.Element) units.get(j)).element("trg_para").elementText("text");
                        } else {
                            s[1] = "";
                        }
                        s[2] = "N/A";
                        s[3] = "N/A";
                        s[4] = ((org.dom4j.Element) units.get(j)).element("src_para").attributeValue("tctype");
                        s[5] = "0";
                        s[6] = "";
                        reportStates.add(s);
                    }
                }
            } else {
                if (isParaAllSegmented) {
                    org.dom4j.Element txlf_group = (org.dom4j.Element) list_source.get(count);
                    org.dom4j.Element txlf_group_ingt = (org.dom4j.Element) list_source_ingt.get(count);
                    org.dom4j.Element txlf_group_seg = (org.dom4j.Element) list_source_seg.get(count);
                    txlf_group.setContent(txlf_group_seg.content());
                    List transunits = txlf_group.elements("trans-unit");

                    txlf_group_ingt.setContent(txlf_group_seg.content());
                    List transunits_ingt = txlf_group_ingt.elements("trans-unit");

                    ArrayList<String> mergedsegtext = new ArrayList();
                    ArrayList<List> merged_trg_contents = new ArrayList();
                    ArrayList<String> mergedsegtctypes = new ArrayList();

                    ArrayList<String> keys = new ArrayList();
                    ArrayList<String> key_left = new ArrayList();
                    ArrayList<String> key_right = new ArrayList();
                    ArrayList<String> org_keys = new ArrayList();
                    ArrayList<String> trg_keys = new ArrayList();
                    ArrayList<List> trg_contents = new ArrayList();
                    ArrayList<String> src_tctypes = new ArrayList();
                    ArrayList<String> src_review_stats = new ArrayList();
                    ArrayList<String> src_ignore_stats = new ArrayList();
                    ArrayList<Integer> edited_idx = new ArrayList();
                    for (int j = 0; j < units.size(); j++) {
                        org.dom4j.Element unit = (org.dom4j.Element) units.get(j);
                        org.dom4j.Element src_para = unit.element("src_para");
                        org.dom4j.Element trg_para = unit.element("trg_para");
                        List src_segs = src_para.element("segments").elements("src_seg");
                        for (int z = 0; z < src_segs.size(); z++) {
                            org.dom4j.Element src_seg = (org.dom4j.Element) src_segs.get(z);
                            src_tctypes.add(src_seg.attributeValue("tctype"));
                            src_review_stats.add(src_seg.attributeValue("needreview"));
                            src_ignore_stats.add(src_seg.attributeValue("ignored"));
                            keys.add(src_seg.getText().replaceAll("(?s)<del>.*?</del>", "")
                                    .replaceAll("<(/)*ins>", "").replace("<br>", "").trim());
                            org_keys.add(src_seg.getText());
                            if (trg_para != null) {
                                List trg_segs = trg_para.element("segments").elements("trg_seg");
                                if (((org.dom4j.Element) trg_segs.get(z)).attributeValue("edited")
                                        .equals("true")) {
                                    edited_idx.add(Integer.valueOf(trg_contents.size()));
                                }
                                if (trg_segs.size() > z) {
                                    trg_keys.add(((org.dom4j.Element) trg_segs.get(z)).getText());
                                    String id = ((org.dom4j.Element) trg_segs.get(z)).attributeValue("id");
                                    if (id.startsWith("n - ")) {
                                        trg_contents.add(new ArrayList());
                                    } else {
                                        List tmp_contents = new ArrayList();
                                        if (id.contains(" - ")) {
                                            int start = Integer.parseInt(id.split(" - ")[0]);
                                            int end = Integer.parseInt(id.split(" - ")[1]);
                                            tmp_contents.addAll((Collection) this.txlftrgsegmap
                                                    .get(Integer.valueOf(start)));
                                            for (int su = start + 1; su <= end; su++) {
                                                boolean isprevendofpara = ((boolean[]) this.txlftrgsewsmap
                                                        .get(Integer.valueOf(su - 1)))[1];
                                                boolean iscurrentstartofpara = ((boolean[]) this.txlftrgsewsmap
                                                        .get(Integer.valueOf(su)))[0];
                                                if ((isprevendofpara) && (iscurrentstartofpara)) {
                                                    List prevseg = (List) this.txlftrgsegmap
                                                            .get(Integer.valueOf(su - 1));
                                                    int previdx = -1;
                                                    for (int prev = 0; prev < prevseg.size(); prev++) {
                                                        org.dom4j.Node prevnode = (org.dom4j.Node) prevseg
                                                                .get(prev);
                                                        if (prevnode.getNodeType() == 1) {
                                                            org.dom4j.Element prevnode_e = (org.dom4j.Element) prevnode;
                                                            if ((prevnode_e.getName().equals("ws"))
                                                                    && (prevnode_e.attributeValue("pos")
                                                                            .equals("after"))) {
                                                                previdx = prevseg.size() - prev;
                                                            }
                                                        }
                                                    }
                                                    if (previdx != -1) {
                                                        tmp_contents.remove(tmp_contents.size() - previdx);
                                                    }
                                                    List currseg = (List) this.txlftrgsegmap
                                                            .get(Integer.valueOf(su));
                                                    int curridx = -1;
                                                    for (int curr = 0; curr < currseg.size(); curr++) {
                                                        org.dom4j.Node currnode = (org.dom4j.Node) currseg
                                                                .get(curr);
                                                        if (currnode.getNodeType() == 1) {
                                                            org.dom4j.Element currnode_e = (org.dom4j.Element) currnode;
                                                            if ((currnode_e.getName().equals("ws"))
                                                                    && (currnode_e.attributeValue("pos")
                                                                            .equals("before"))) {
                                                                curridx = curr;
                                                            }
                                                        }
                                                    }
                                                    if (curridx != -1) {
                                                        currseg.remove(curridx);
                                                    }
                                                    if (Locale.makeLocale(this.targetlanguage).isFarEast()) {
                                                        tmp_contents.addAll(currseg);
                                                    } else {
                                                        tmp_contents.add(DocumentHelper.createText(" "));
                                                        tmp_contents.addAll(currseg);
                                                    }
                                                } else {
                                                    tmp_contents.addAll((Collection) this.txlftrgsegmap
                                                            .get(Integer.valueOf(su)));
                                                }
                                            }
                                        } else {
                                            tmp_contents.addAll((Collection) this.txlftrgsegmap
                                                    .get(Integer.valueOf(Integer.parseInt(id))));
                                        }
                                        trg_contents.add(tmp_contents);
                                    }
                                } else {
                                    trg_keys.add("");
                                    trg_contents.add(new ArrayList());
                                }
                            } else {
                                trg_keys.add("");
                                trg_contents.add(new ArrayList());
                            }
                            if ((z == 0) && (z == src_segs.size() - 1)) {
                                key_left.add(src_para.attributeValue("lefttrim"));
                                key_right.add(src_para.attributeValue("righttrim"));
                            } else if (z == 0) {
                                key_left.add(src_para.attributeValue("lefttrim"));
                                key_right.add("true");
                            } else if (z == src_segs.size() - 1) {
                                key_left.add("true");
                                key_right.add(src_para.attributeValue("righttrim"));
                            } else {
                                key_left.add("true");
                                key_right.add("true");
                            }
                        }
                    }
                    SegmenterFactory factory = new SegmenterFactory();
                    Configuration segconfig = createConfigForSegmenter(false, this.sourcelanguage);
                    Segmenter segmenter = factory.getSegmenter("trados", Locale.makeLocale(this.sourcelanguage),
                            segconfig);
                    List<String> finsegs = segmenter
                            .segment(group.elementText("text").replaceAll("(?s)<del>.*?</del>", "")
                                    .replaceAll("<(/)*ins>", "").replace("<br>", "").replace("&lt;", "<")
                                    .replace("&gt;", ">").replace("&amp;", "&"));
                    ArrayList<ArrayList<Integer>> indices = new ArrayList();
                    int key_start_index = 0;
                    for (int k = 0; k < finsegs.size(); k++) {
                        String finsegtext = ((String) finsegs.get(k)).replace("&", "&amp;").replace("<", "&lt;")
                                .replace(">", "&gt;");

                        String combined_key = "";
                        ArrayList<Integer> indice = new ArrayList();
                        for (int x = key_start_index; x < keys.size(); x++) {
                            combined_key = combined_key + (String) keys.get(x);

                            indice.add(Integer.valueOf(x));
                            if (combined_key.replace("", " ").trim().replaceAll("(\\s)+", "")
                                    .equals(finsegtext.replace("", " ").trim().replaceAll("(\\s)+", ""))) {
                                indices.add(indice);
                                key_start_index = x + 1;
                                break;
                            }
                        }
                    }
                    ArrayList<Integer> merged_edited_idx = new ArrayList();
                    ArrayList<String[]> statss = new ArrayList();
                    for (int m = 0; m < indices.size(); m++) {
                        boolean iscontentsuseable = true;
                        ArrayList<Integer> temp_indice = (ArrayList) indices.get(m);
                        String temp_src = "";
                        String temp_org_src = "";
                        String temp_trg = "";
                        List temp_trg_content = new ArrayList();
                        int id = 1;
                        int rid = 1;
                        int bxrid = 1;
                        int bptrid = 1;
                        int bxid = 1;
                        int bptid = 1;
                        HashMap<String, String> map_rid = new HashMap();
                        String temp_tctype = (String) src_tctypes
                                .get(((Integer) temp_indice.get(0)).intValue());
                        String temp_review_stats = (String) src_review_stats
                                .get(((Integer) temp_indice.get(0)).intValue());
                        for (Iterator localIterator = temp_indice.iterator(); localIterator.hasNext();) {
                            int it = ((Integer) localIterator.next()).intValue();
                            temp_tctype = temp_tctype.equals(src_tctypes.get(it)) ? temp_tctype : "MIX";
                            temp_review_stats = ((String) src_review_stats.get(it)).equals("true") ? "true"
                                    : temp_review_stats.equals("true") ? "true" : "false";
                            String temp_ignore_stats = (String) src_ignore_stats.get(it);
                            if (edited_idx.contains(Integer.valueOf(it))) {
                                iscontentsuseable = false;
                            }
                            temp_src = temp_src + (String) keys.get(it);
                            temp_org_src = temp_org_src + (String) org_keys.get(it);
                            if (temp_ignore_stats.equals("true")) {
                                temp_trg = temp_trg + "[skipseg]";
                                temp_trg_content.add(DocumentHelper.createText("[skipseg]"));
                            } else {
                                temp_trg = temp_trg + (String) trg_keys.get(it);

                                List trg_content = (List) trg_contents.get(it);
                                for (int nc = 0; nc < trg_content.size(); nc++) {
                                    org.dom4j.Node raw = (org.dom4j.Node) trg_content.get(nc);
                                    if (raw.getNodeType() == 3) {
                                        temp_trg_content.add(raw);
                                    } else if (raw.getNodeType() == 1) {
                                        org.dom4j.Element rawe = (org.dom4j.Element) raw;
                                        if (rawe.getName().equals("source")) {
                                            for (int ncc = 0; ncc < rawe.content().size(); ncc++) {
                                                org.dom4j.Node node = (org.dom4j.Node) rawe.content().get(ncc);
                                                if (node.getNodeType() == 3) {
                                                    temp_trg_content.add(node);
                                                } else if (node.getNodeType() == 1) {
                                                    org.dom4j.Element e = (org.dom4j.Element) node;
                                                    if (!e.getName().equals("x")) {
                                                        if (!e.getName().equals("ph")) {
                                                            if (e.getName().equals("bx")) {
                                                                if ((e.attribute("fake") != null)
                                                                        && (e.attributeValue("fake")
                                                                                .equals("true"))
                                                                        && (temp_indice.indexOf(
                                                                                Integer.valueOf(it)) != 0)) {
                                                                    continue;
                                                                }
                                                                if ((e.attribute("fake") == null)
                                                                        || (!e.attributeValue("fake")
                                                                                .equals("true"))) {
                                                                }
                                                            } else if (e.getName().equals("ex")) {
                                                                if ((e.attribute("fake") != null)
                                                                        && (e.attributeValue("fake")
                                                                                .equals("true"))
                                                                        && (temp_indice.indexOf(Integer.valueOf(
                                                                                it)) != temp_indice.size()
                                                                                        - 1)) {
                                                                    continue;
                                                                }
                                                                if ((e.attribute("fake") == null)
                                                                        || (!e.attributeValue("fake")
                                                                                .equals("true"))) {
                                                                }
                                                            } else if (e.getName().equals("bpt")) {
                                                                if ((e.attribute("fake") != null)
                                                                        && (e.attributeValue("fake")
                                                                                .equals("true"))
                                                                        && (temp_indice.indexOf(
                                                                                Integer.valueOf(it)) != 0)) {
                                                                    continue;
                                                                }
                                                                if ((e.attribute("fake") == null)
                                                                        || (!e.attributeValue("fake")
                                                                                .equals("true"))) {
                                                                }
                                                            } else if (e.getName().equals("ept")) {
                                                                if ((e.attribute("fake") != null)
                                                                        && (e.attributeValue("fake")
                                                                                .equals("true"))
                                                                        && (temp_indice.indexOf(Integer.valueOf(
                                                                                it)) != temp_indice.size()
                                                                                        - 1)) {
                                                                    continue;
                                                                }
                                                                if ((e.attribute("fake") == null)
                                                                        || (!e.attributeValue("fake")
                                                                                .equals("true"))) {
                                                                }
                                                            }
                                                        }
                                                    }
                                                    if (e.attribute("fake") != null) {
                                                        e.remove(e.attribute("fake"));
                                                    }
                                                    temp_trg_content.add(e);
                                                }
                                            }
                                        } else if (rawe.getName().equals("ws")) {
                                            String pos = rawe.attributeValue("pos");
                                            if (pos.equals("before")) {
                                                for (int ncc = 0; ncc < rawe.content().size(); ncc++) {
                                                    org.dom4j.Node node = (org.dom4j.Node) rawe.content()
                                                            .get(ncc);
                                                    if (node.getNodeType() == 3) {
                                                        temp_trg_content.add(0, node);
                                                    } else if (node.getNodeType() == 1) {
                                                        org.dom4j.Element e = (org.dom4j.Element) node;
                                                        if ((!e.getName().equals("x"))
                                                                && (e.getName().equals("it"))) {
                                                            if (e.attributeValue("pos").equals("open")) {
                                                                if ((e.attribute("fake") != null)
                                                                        && (e.attributeValue("fake")
                                                                                .equals("true"))
                                                                        && (temp_indice.indexOf(
                                                                                Integer.valueOf(it)) != 0)) {
                                                                    continue;
                                                                }
                                                                if (e.getText().equals("")) {
                                                                    e.setName("bx");
                                                                } else {
                                                                    e.setName("bpt");
                                                                }
                                                                if ((e.attribute("fake") == null)
                                                                        || (!e.attributeValue("fake")
                                                                                .equals("true"))) {
                                                                }
                                                            } else if (e.attributeValue("pos")
                                                                    .equals("close")) {
                                                                if ((e.attribute("fake") != null)
                                                                        && (e.attributeValue("fake")
                                                                                .equals("true"))
                                                                        && (temp_indice.indexOf(Integer.valueOf(
                                                                                it)) != temp_indice.size()
                                                                                        - 1)) {
                                                                    continue;
                                                                }
                                                                if (e.getText().equals("")) {
                                                                    e.setName("ex");
                                                                } else {
                                                                    e.setName("ept");
                                                                }
                                                                e.remove(e.attribute("ctype"));
                                                                if ((e.attribute("fake") == null)
                                                                        || (!e.attributeValue("fake")
                                                                                .equals("true"))) {
                                                                }
                                                            }
                                                            e.remove(e.attribute("pos"));
                                                        } else {
                                                            if (e.attribute("fake") != null) {
                                                                e.remove(e.attribute("fake"));
                                                            }
                                                            temp_trg_content.add(0, e);
                                                        }
                                                    }
                                                }
                                            } else if (pos.equals("after")) {
                                                for (int ncc = 0; ncc < rawe.content().size(); ncc++) {
                                                    org.dom4j.Node node = (org.dom4j.Node) rawe.content()
                                                            .get(ncc);
                                                    if (node.getNodeType() == 3) {
                                                        temp_trg_content.add(node);
                                                    } else if (node.getNodeType() == 1) {
                                                        org.dom4j.Element e = (org.dom4j.Element) node;
                                                        if ((!e.getName().equals("x"))
                                                                && (e.getName().equals("it"))) {
                                                            if (e.attributeValue("pos").equals("open")) {
                                                                if ((e.attribute("fake") != null)
                                                                        && (e.attributeValue("fake")
                                                                                .equals("true"))
                                                                        && (temp_indice.indexOf(
                                                                                Integer.valueOf(it)) != 0)) {
                                                                    continue;
                                                                }
                                                                if (e.getText().equals("")) {
                                                                    e.setName("bx");
                                                                } else {
                                                                    e.setName("bpt");
                                                                }
                                                                if ((e.attribute("fake") == null)
                                                                        || (!e.attributeValue("fake")
                                                                                .equals("true"))) {
                                                                }
                                                            } else if (e.attributeValue("pos")
                                                                    .equals("close")) {
                                                                if ((e.attribute("fake") != null)
                                                                        && (e.attributeValue("fake")
                                                                                .equals("true"))
                                                                        && (temp_indice.indexOf(Integer.valueOf(
                                                                                it)) != temp_indice.size()
                                                                                        - 1)) {
                                                                    continue;
                                                                }
                                                                if (e.getText().equals("")) {
                                                                    e.setName("ex");
                                                                } else {
                                                                    e.setName("ept");
                                                                }
                                                                e.remove(e.attribute("ctype"));
                                                                if ((e.attribute("fake") == null)
                                                                        || (!e.attributeValue("fake")
                                                                                .equals("true"))) {
                                                                }
                                                            }
                                                            e.remove(e.attribute("pos"));
                                                        } else {
                                                            if (e.attribute("fake") != null) {
                                                                e.remove(e.attribute("fake"));
                                                            }
                                                            temp_trg_content.add(e);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        String[] stats = TrackChangeHelper.getTxlfTrgStatsFromTCType(temp_tctype, temp_trg);
                        if ((stats[0].equals("1")) && (temp_review_stats.equals("true"))) {
                            stats[2] = "fuzzy-match";
                        }
                        String[] s = new String[7];
                        s[0] = temp_org_src.replace("<br> ", "&#8629;<br>");
                        if (iscontentsuseable) {
                            s[1] = trimText(assembleText(temp_trg_content).replace("<br> ", "&#8629;<br>"),
                                    false)[0];
                        } else {
                            s[1] = temp_trg.replace("<br> ", "&#8629;<br>");
                        }
                        if (s[1].contains("[skipseg]")) {
                            if (s[1].replace("[skipseg]", "").trim().equals("")) {
                                s[1] = "";
                                temp_trg_content = new ArrayList();
                                temp_trg_content.add(DocumentHelper.createText(""));
                                temp_trg = "";
                                stats[0] = "1";
                                stats[1] = "translated";
                                stats[2] = "exact-match";
                            } else {
                                s[1] = s[1].replace("[skipseg]", "");
                                temp_trg_content = replacetextinDomObj(temp_trg_content);
                                temp_trg = temp_trg.replace("[skipseg]", "");
                            }
                        }
                        s[2] = stats[0];
                        s[3] = stats[2];
                        s[4] = temp_tctype;
                        wcounter = new TradosWordCounter(locale, config);
                        wcounter.countText(((org.dom4j.Element) transunits.get(m)).element("source").getText());
                        s[5] = Integer.toString(wcounter.getWordCount());
                        s[6] = "";
                        totalWC += wcounter.getWordCount();
                        reportStates.add(s);
                        if (extractionSupportImpl.isExtractable(temp_src)) {
                            mergedsegtext.add(temp_trg);
                            if (!iscontentsuseable) {
                                merged_edited_idx.add(Integer.valueOf(merged_trg_contents.size()));
                            }
                            merged_trg_contents.add(temp_trg_content);
                            mergedsegtctypes.add(temp_tctype);
                            statss.add(stats);
                        }
                    }
                    for (int t = 0; t < transunits.size(); t++) {
                        org.dom4j.Element trans_unit = (org.dom4j.Element) transunits.get(t);
                        org.dom4j.Element trans_unit_ignt = (org.dom4j.Element) transunits_ingt.get(t);
                        trans_unit.addAttribute("gs4tr:editStatus", "leveraged");
                        org.dom4j.Element source = trans_unit.element("source");

                        org.dom4j.Element target = trans_unit.addElement("target");
                        trans_unit.elements().add(source.indexOf(source.getParent()) + 2, target.clone());
                        trans_unit.remove(target);
                        target = trans_unit.element("target");

                        org.dom4j.Element target_ignt = trans_unit_ignt.addElement("target");
                        trans_unit_ignt.elements().add(source.indexOf(source.getParent()) + 2,
                                target_ignt.clone());
                        trans_unit_ignt.remove(target_ignt);
                        target_ignt = trans_unit_ignt.element("target");
                        if (merged_edited_idx.contains(Integer.valueOf(t))) {
                            target.setText(((String) mergedsegtext.get(t)).replace("&lt;", "<")
                                    .replace("&gt;", ">").replace("&amp;", "&").trim());
                            target_ignt.setText(((String) mergedsegtext.get(t)).replace("&lt;", "<")
                                    .replace("&gt;", ">").replace("&amp;", "&").trim());
                        } else {
                            target.setContent(trimContents((List) merged_trg_contents.get(t)));
                            target_ignt.setContent(trimContents((List) merged_trg_contents.get(t)));
                            if (!((String[]) statss.get(t))[0].equals("75")) {
                                org.dom4j.Element source_ingt = trans_unit_ignt.element("source");
                                source_ingt.setContent(trimContents((List) merged_trg_contents.get(t)));
                            }
                        }
                        String[] stats = (String[]) statss.get(t);
                        if (stats[0].equals("1")) {
                            trans_unit.addAttribute("gs4tr:locked", "true");
                        }
                        target.addAttribute("gs4tr:score", stats[0]);
                        target.addAttribute("state", stats[1]);
                        target.addAttribute("state-qualifier", stats[2]);
                        if (stats[0].equals("0")) {
                            trans_unit.remove(target);
                        }
                    }
                } else {
                    String trgtext = "";
                    if (((org.dom4j.Element) units.get(0)).element("trg_para") != null) {
                        trgtext = ((org.dom4j.Element) units.get(0)).element("trg_para").elementText("text");
                    }
                    String temp_tctype = ((org.dom4j.Element) units.get(0)).element("src_para")
                            .attributeValue("tctype");
                    for (int j = 1; j < units.size(); j++) {
                        org.dom4j.Element prev_unit = (org.dom4j.Element) units.get(j - 1);
                        org.dom4j.Element unit = (org.dom4j.Element) units.get(j);
                        String src_tctype = unit.element("src_para").attributeValue("tctype");
                        temp_tctype = temp_tctype.equals(src_tctype) ? temp_tctype : "MIX";
                        if (unit.element("trg_para") != null) {
                            String Rtrim = prev_unit.element("src_para").attributeValue("righttrim");
                            String Ltrim = unit.element("src_para").attributeValue("lefttrim");
                            if ((Rtrim.equals("true")) || (Ltrim.equals("true"))) {
                                trgtext = trgtext + " " + unit.element("trg_para").elementText("text");
                            } else {
                                trgtext = trgtext + unit.element("trg_para").elementText("text");
                            }
                        }
                    }
                    org.dom4j.Element txlf_group = (org.dom4j.Element) list_source.get(count);
                    org.dom4j.Element trans_unit = txlf_group.element("trans-unit");
                    trans_unit.addAttribute("gs4tr:editStatus", "leveraged");
                    org.dom4j.Element source = trans_unit.element("source");

                    org.dom4j.Element target = trans_unit.addElement("target");
                    trans_unit.elements().add(source.indexOf(source.getParent()) + 2, target.clone());
                    trans_unit.remove(target);
                    target = trans_unit.element("target");

                    int lb_cnt = 0;
                    String surfix = trgtext;
                    while (surfix.indexOf("<br> ") != -1) {
                        lb_cnt++;
                        int pos = surfix.indexOf("<br> ");
                        String prefix = surfix.substring(0, pos);
                        target.addText(prefix.replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&"));
                        org.dom4j.Element x = target.addElement("x");
                        x.addAttribute("ctype", "lb");
                        x.addAttribute("id", Integer.toString(lb_cnt));
                        x.addAttribute("equiv-text", " ");
                        surfix = surfix.substring(pos + 5, surfix.length());
                    }
                    target.addText(surfix.replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&"));
                    String[] stats = TrackChangeHelper.getTxlfTrgStatsFromTCType(temp_tctype, trgtext);
                    target.addAttribute("gs4tr:score", stats[0]);
                    target.addAttribute("state", stats[1]);
                    target.addAttribute("state-qualifier", stats[2]);

                    String[] s = new String[7];
                    s[0] = group.elementText("text").replace("<br> ", "&#8629;<br>");
                    s[1] = trgtext.replace("<br> ", "&#8629;<br>");
                    s[2] = stats[0];
                    s[3] = stats[2];
                    s[4] = temp_tctype;
                    wcounter = new TradosWordCounter(locale, config);
                    wcounter.countText(source.getText());
                    s[5] = Integer.toString(wcounter.getWordCount());
                    s[6] = "";
                    totalWC += wcounter.getWordCount();
                    reportStates.add(s);
                }
                count++;
            }
        }
    }
    root_src.element("file").addAttribute("gs4tr:wordcount", Integer.toString(totalWC));
    fixTxlfTrgTags(document_src);

    this.populatedsourcetxlf = (this.sourcefile + ".txlf");
    if (new File(this.populatedsourcetxlf).exists()) {
        new File(this.populatedsourcetxlf).delete();
    }
    OutputStreamWriter writer = new OutputStreamWriter(
            new BufferedOutputStream(new FileOutputStream(this.populatedsourcetxlf)), "UTF8");
    document_src.write(writer);
    writer.close();

    removeBlankLinesAndNameSpace(this.populatedsourcetxlf);

    root_src_ingt.element("file").addAttribute("gs4tr:wordcount", Integer.toString(totalWC));
    fixTxlfTrgTags(document_src_ingt);

    String ingtfile = this.sourcefile + ".ingt.txlf";
    if (new File(ingtfile).exists()) {
        new File(ingtfile).delete();
    }
    OutputStreamWriter writer_ingt = new OutputStreamWriter(
            new BufferedOutputStream(new FileOutputStream(ingtfile)), "UTF8");
    document_src_ingt.write(writer_ingt);
    writer_ingt.close();

    removeBlankLinesAndNameSpace(ingtfile);

    return reportStates;
}