    001    // This file is part of the Attempto Java Packages.
    002    // Copyright 2008, Attempto Group, University of Zurich (see http://attempto.ifi.uzh.ch).
    003    //
    004    // The Attempto Java Packages is free software: you can redistribute it and/or modify it under the
    005    // terms of the GNU Lesser General Public License as published by the Free Software Foundation,
    006    // either version 3 of the License, or (at your option) any later version.
    007    //
    008    // The Attempto Java Packages is distributed in the hope that it will be useful, but WITHOUT ANY
    009    // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
    010    // PURPOSE. See the GNU Lesser General Public License for more details.
    011    //
    012    // You should have received a copy of the GNU Lesser General Public License along with the Attempto
    013    // Java Packages. If not, see http://www.gnu.org/licenses/.
    014
    015    package ch.uzh.ifi.attempto.acewiki.gui.editor;
    016
    017    import java.util.ArrayList;
    018
    019    import nextapp.echo2.app.event.ActionEvent;
    020    import nextapp.echo2.app.event.ActionListener;
    021    import ch.uzh.ifi.attempto.acewiki.Task;
    022    import ch.uzh.ifi.attempto.acewiki.Wiki;
    023    import ch.uzh.ifi.attempto.acewiki.core.ontology.OntologyElement;
    024    import ch.uzh.ifi.attempto.acewiki.core.ontology.Sentence;
    025    import ch.uzh.ifi.attempto.acewiki.gui.page.ArticlePage;
    026    import ch.uzh.ifi.attempto.echocomp.MessageWindow;
    027    import ch.uzh.ifi.attempto.preditor.PreditorWindow;
    028    import ch.uzh.ifi.attempto.preditor.text.TextContainer;
    029    import ch.uzh.ifi.attempto.preditor.text.TextElement;
    030
    031    /**
    032     * This class manages the predictive editor. It creates the editor window and handles its
    033     * responses.
    034     *
    035     * @author Tobias Kuhn
    036     */
    037    public class SentenceEditorHandler implements ActionListener {
    038
    039            private static final long serialVersionUID = -2083910385095284075L;
    040
    041            private PreditorWindow editorWindow;
    042            private ArticlePage page;
    043            private Wiki wiki;
    044            private boolean edit;
    045            private Sentence sentence;
    046
    047            private SentenceEditorHandler(Sentence sentence, ArticlePage page, boolean edit) {
    048                    this.page = page;
    049                    this.wiki = page.getWiki();
    050                    this.edit = edit;
    051                    this.sentence = sentence;
    052                    AceWikiMenuCreator menuCreator = new AceWikiMenuCreator(wiki, page.getOntologyElement(), this);
    053                    editorWindow = new PreditorWindow("Sentence Editor", wiki.getGrammar(), menuCreator);
    054                    editorWindow.addActionListener(this);
    055
    056                    if (edit) {
    057                            String t = sentence.getPrettyText();
    058                            // remove the last element (i.e. the period '.' or question mark '?'):
    059                            editorWindow.addText(t.substring(0, t.length()-1));
    060                    }
    061            }
    062
    063            /**
    064             * Generates a new preditive editor (short "preditor") window to create a new sentence.
    065             *
    066             * @param followingSentence The sentence in front of which the new sentences should be added,
    067             *   or null if the sentences should be added to the end of the article.
    068             * @param page The host page into which the sentence should be added.
    069             * @return A new preditor window.
    070             */
    071            public static PreditorWindow generatePreditorAddWindow(Sentence followingSentence, ArticlePage page) {
    072                    SentenceEditorHandler h = new SentenceEditorHandler(followingSentence, page, false);
    073                    return h.getPreditorWindow();
    074            }
    075
    076            /**
    077             * Generates a new preditive editor (short "preditor") window to create a new sentence.
    078             *
    079             * @param sentence The sentence that should be edited.
    080             * @param page The host page which contains the sentence to be edited.
    081             * @return A new preditor window.
    082             */
    083            public static PreditorWindow generatePreditorEditWindow(Sentence sentence, ArticlePage page) {
    084                    SentenceEditorHandler h = new SentenceEditorHandler(sentence, page, true);
    085                    return h.getPreditorWindow();
    086            }
    087
    088            private PreditorWindow getPreditorWindow() {
    089                    return editorWindow;
    090            }
    091
    092            public void actionPerformed(ActionEvent e) {
    093                    if (e.getSource() == editorWindow && e.getActionCommand().equals("OK")) {
    094                            final TextContainer textContainer = editorWindow.getTextContainer();
    095
    096                            TextElement finalElement = editorWindow.getPossibleNextToken(".");
    097                            if (finalElement == null) {
    098                                    finalElement = editorWindow.getPossibleNextToken("?");
    099                            }
    100                            if (finalElement != null) textContainer.addElement(finalElement);
    101
    102                            ArrayList<TextElement> l = textContainer.getTextElements();
    103                            if (l.isEmpty() || l.get(l.size() - 1).getText().matches("[.?]")) {
    104                                    Task task = new Task() {
    105
    106                                            int success;
    107
    108                                            public void run() {
    109                                                    OntologyElement el = page.getOntologyElement();
    110                                                    if (edit) {
    111                                                            wiki.log("edit", "sentence updated: " + textContainer.getText());
    112                                                            success = el.edit(sentence, Sentence.generateSentences(textContainer, el));
    113                                                    } else {
    114                                                            wiki.log("edit", "sentence created: " + textContainer.getText());
    115                                                            success = el.add(sentence, Sentence.generateSentences(textContainer, el));
    116                                                    }
    117                                            }
    118
    119                                            public void updateGUI() {
    120                                                    page.update();
    121                                                    if (success == 1) {
    122                                                            wiki.showWindow(
    123                                                                    new MessageWindow(
    124                                                                            "Conflict",
    125                                                                            "A sentence is in conflict with the current knowledge. For that reason, " +
    126                                                                                    "it cannot be added to the knowledge base.",
    127                                                                            "OK"
    128                                                                    )
    129                                                            );
    130                                                    } else if (success == 2) {
    131                                                            wiki.showWindow(
    132                                                                    new MessageWindow(
    133                                                                            "Error",
    134                                                                            "A sentence could not be added to the knowledge base because the knowledge " +
    135                                                                                    "base got too complex.",
    136                                                                            "OK"
    137                                                                    )
    138                                                            );
    139                                                    }
    140                                                    if (page != null) {
    141                                                            page.update();
    142                                                            page.getWiki().update();
    143                                                    }
    144                                            }
    145
    146                                    };
    147
    148                                    if (edit) {
    149                                            wiki.enqueueTaskShowingWaitWindow("Updating", "The knowledge base is being updated...", task);
    150                                    } else {
    151                                            wiki.enqueueTaskShowingWaitWindow("Updating", "The sentence is being added to the knowledge base...", task);
    152                                    }
    153
    154                                    editorWindow.setVisible(false);
    155
    156                            } else {
    157                                    wiki.log("edit", "error: unfinished sentences");
    158                                    MessageWindow mw = new MessageWindow("Error", "There are unfinished sentences.", editorWindow, "OK");
    159                                    page.getWiki().showWindow(mw);
    160                            }
    161                    } else if (e.getSource() == editorWindow && e.getActionCommand().equals("Cancel")) {
    162                            editorWindow.setVisible(false);
    163                            editorWindow.dispose();
    164                    } else if (e.getSource() instanceof TextElement) {
    165                            editorWindow.addTextElement((TextElement) e.getSource());
    166                    }
    167            }
    168
    169    }