Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.waveprotocol.wave.client.editor.harness; import com.google.gwt.core.client.Duration; import com.google.gwt.core.client.GWT; import com.google.gwt.core.client.GWT.UncaughtExceptionHandler; import com.google.gwt.dom.client.Document; import com.google.gwt.dom.client.Element; import com.google.gwt.event.dom.client.ChangeEvent; import com.google.gwt.event.dom.client.ChangeHandler; import com.google.gwt.event.dom.client.ClickEvent; import com.google.gwt.event.dom.client.ClickHandler; import com.google.gwt.event.logical.shared.SelectionEvent; import com.google.gwt.event.logical.shared.SelectionHandler; import com.google.gwt.event.logical.shared.ValueChangeEvent; import com.google.gwt.event.logical.shared.ValueChangeHandler; import com.google.gwt.user.client.ui.Button; import com.google.gwt.user.client.ui.CheckBox; import com.google.gwt.user.client.ui.Composite; import com.google.gwt.user.client.ui.FlowPanel; import com.google.gwt.user.client.ui.HTML; import com.google.gwt.user.client.ui.HorizontalPanel; import com.google.gwt.user.client.ui.InlineLabel; import com.google.gwt.user.client.ui.Label; import com.google.gwt.user.client.ui.ListBox; import com.google.gwt.user.client.ui.MultiWordSuggestOracle; import com.google.gwt.user.client.ui.RootPanel; import com.google.gwt.user.client.ui.SuggestBox; import com.google.gwt.user.client.ui.SuggestOracle; import com.google.gwt.user.client.ui.TextArea; import com.google.gwt.user.client.ui.Widget; import org.waveprotocol.wave.client.common.util.KeySignalListener; import org.waveprotocol.wave.client.common.util.LogicalPanel; import org.waveprotocol.wave.client.common.util.SignalEvent; import org.waveprotocol.wave.client.debug.logger.DomLogger; import org.waveprotocol.wave.client.debug.logger.LogLevel; import org.waveprotocol.wave.client.debug.logger.LoggerListener; import org.waveprotocol.wave.client.doodad.diff.DiffAnnotationHandler; import org.waveprotocol.wave.client.doodad.link.LinkAnnotationHandler; import org.waveprotocol.wave.client.doodad.link.LinkAnnotationHandler.LinkAttributeAugmenter; import org.waveprotocol.wave.client.editor.Editor; import org.waveprotocol.wave.client.editor.EditorImpl; import org.waveprotocol.wave.client.editor.EditorSettings; import org.waveprotocol.wave.client.editor.EditorStaticDeps; import org.waveprotocol.wave.client.editor.EditorUpdateEvent; import org.waveprotocol.wave.client.editor.EditorUpdateEvent.EditorUpdateListener; import org.waveprotocol.wave.client.editor.Editors; import org.waveprotocol.wave.client.editor.ElementHandlerRegistry; import org.waveprotocol.wave.client.editor.content.ContentDocument; import org.waveprotocol.wave.client.editor.content.ContentDocument.Level; import org.waveprotocol.wave.client.editor.content.ContentNode; import org.waveprotocol.wave.client.editor.content.Registries; import org.waveprotocol.wave.client.editor.content.misc.StyleAnnotationHandler; import org.waveprotocol.wave.client.editor.content.paragraph.LineRendering; import org.waveprotocol.wave.client.editor.keys.KeyBindingRegistry; import org.waveprotocol.wave.client.editor.util.EditorDocFormatter; import org.waveprotocol.wave.client.editor.webdriver.EditorWebDriverUtil; import org.waveprotocol.wave.client.scheduler.ScheduleCommand; import org.waveprotocol.wave.client.scheduler.Scheduler; import org.waveprotocol.wave.client.scheduler.Scheduler.Task; import org.waveprotocol.wave.client.widget.popup.PopupChrome; import org.waveprotocol.wave.client.widget.popup.PopupChromeProvider; import org.waveprotocol.wave.client.widget.popup.simple.Popup; import org.waveprotocol.wave.common.logging.AbstractLogger; import org.waveprotocol.wave.common.logging.LoggerBundle; import org.waveprotocol.wave.model.document.operation.DocInitialization; import org.waveprotocol.wave.model.document.operation.DocOp; import org.waveprotocol.wave.model.document.operation.automaton.DocOpAutomaton.ViolationCollector; import org.waveprotocol.wave.model.document.operation.automaton.DocumentSchema; import org.waveprotocol.wave.model.document.operation.impl.DocOpValidator; import org.waveprotocol.wave.model.document.parser.XmlParseException; import org.waveprotocol.wave.model.document.util.DocIterate; import org.waveprotocol.wave.model.document.util.DocProviders; import org.waveprotocol.wave.model.document.util.LineContainers; import org.waveprotocol.wave.model.operation.OperationException; import org.waveprotocol.wave.model.operation.SilentOperationSink; import org.waveprotocol.wave.model.schema.conversation.ConversationSchemas; import java.util.ArrayList; import java.util.Map; /** * */ public class EditorHarness extends Composite implements KeySignalListener { private static final String TOPLEVEL_CONTAINER_TAGNAME = "body"; static { LineContainers.setTopLevelContainerTagname(TOPLEVEL_CONTAINER_TAGNAME); } /** * Debug logger for the test module */ LoggerBundle logger = new DomLogger("test"); ContentDocument doc1, doc2; /** * The editors we are testing */ Editor editor1; EditorBundle editorBundle1; /** * The editors we are testing */ Editor editor2; EditorBundle editorBundle2; LogicalPanel.Impl displayDoc1 = new LogicalPanel.Impl() { { setElement(Document.get().createDivElement()); getElement().getStyle().setProperty("border", "1px dashed silver"); } }; /** * Flag is ops coming out from editor1 should go to editor2 */ public boolean sendOps = true; /** * Flag if harness should operate quitly */ boolean quiet = false; /** * Output widgets for editor1's content */ private HTML prettyContent1; /** * Output widget for editor1's html content */ private HTML prettyHtml1; /** * Output widgets for editor2's content */ private HTML prettyContent2; /** * Output widget for editor2's html content */ private HTML prettyHtml2; /** * Oracle for contentBox */ MultiWordSuggestOracle contentOracle; /** * Input content box. Note: Only one of these regions is used. */ private TextArea contentBox; private SuggestBox contentSuggestBox; /** * Input content box */ private final Button setContentButton = new Button("Set content:", new ClickHandler() { public void onClick(ClickEvent e) { setFromContentBox(); } }); /** * Output widget for last operation */ private final HTML operationOutput = new HTML(); /** * Report errors here * * Error is triggered by error log messages. * Fatal is triggered by fatal log messages and uncaught exceptions. */ private HTML error = null; private HTML fatal = null; /** * Our log div */ private HTML log = null; private final Registries testEditorRegistries = Editor.ROOT_REGISTRIES; /** * Checkbox that toggles editing/display */ private CheckBox toggleEditCheck1; private CheckBox toggleEditCheck2; private CheckBox createEditToggleCheckBox(final Editor editor) { CheckBox check = new CheckBox("Toggle edit"); check.addValueChangeHandler(new ValueChangeHandler<Boolean>() { @Override public void onValueChange(ValueChangeEvent<Boolean> event) { setEditing(editor, event.getValue()); } }); return check; } private void setEditing(Editor editor, boolean isEditing) { editor.setEditing(isEditing); if (editor.isEditing()) { editor.focus(true); } } /** * Clear log button */ private final Button clearLogButton = new Button("Clear log", new ClickHandler() { public void onClick(ClickEvent e) { if (LogLevel.showDebug() && log != null) { log.setHTML(""); error.setText(""); fatal.setText(""); editor1.focus(true); } } }); /** * Quiet button */ private final Button quietButton = new Button("Quiet (app runs faster)", new ClickHandler() { public void onClick(ClickEvent e) { littleLogging(); quiet = true; editor1.focus(true); } }); /** * Loud button */ private final Button loudButton = new Button("Loud (more info)", new ClickHandler() { public void onClick(ClickEvent e) { lottaLogging(); quiet = false; editor1.focus(true); } }); private final CheckBox createEditor2DocDetached = new CheckBox("Create detached"); /** * Sets content in both editors * @param content */ private void syncEditors(String content) { DocInitialization op; try { op = DocProviders.POJO.parse(content).asOperation(); } catch (IllegalArgumentException e) { if (e.getCause() instanceof XmlParseException) { logger.error().log("Ill-formed XML string ", e.getCause()); } else { logger.error().log("Error", e); } return; } DocumentSchema schema = getSchema(); ViolationCollector vc = new ViolationCollector(); if (!DocOpValidator.validate(vc, schema, op).isValid()) { logger.error().log("That content does not conform to the schema", vc); return; } boolean useHack = createEditor2DocDetached.getValue(); // EDITOR1: Pojo -> editor mode double start = Duration.currentTimeMillis(); doc1 = new ContentDocument(testEditorRegistries, op, schema); double middle = Duration.currentTimeMillis(); editor1.setContent(doc1); double end = Duration.currentTimeMillis(); logger.log(AbstractLogger.Level.TRACE, "Set content1 took: " + (end - start) + " (Pojo creation: " + (middle - start) + ", rendering: " + (end - middle)); // EDITOR2: Build document in edit mode start = Duration.currentTimeMillis(); doc2 = new ContentDocument(schema); doc2.setRegistries(testEditorRegistries); editor2.setContent(doc2); // HACK to ensure it's created non-attached to dom, to ensure fair speed comparisons double start2, end2; if (useHack) { Element docDiv = doc2.getFullContentView().getDocumentElement().getImplNodelet(); Element editorDiv = editor2.getWidget().getElement(); assert docDiv.getParentElement() == editorDiv; docDiv.removeFromParent(); start2 = Duration.currentTimeMillis(); doc2.consume(op); end2 = Duration.currentTimeMillis(); editorDiv.appendChild(docDiv); } else { start2 = Duration.currentTimeMillis(); doc2.consume(op); end2 = Duration.currentTimeMillis(); } end = Duration.currentTimeMillis(); logger.log(AbstractLogger.Level.TRACE, "Set content2 took: " + (end - start) + " Just the op: " + (end2 - start2) + " Op + appendChild: " + (end - start2)); documentModeSelect.setSelectedIndex(doc1.getLevel().ordinal()); outputBothEditorStates(); } /** * Shows a red ERROR! message above the log panel. */ private void showRedErrorIndicator() { error.setText("ERROR!"); } /** * Shows a red FATAL! message above the log panel. */ private void showRedFatalIndicator() { fatal.setText("FATAL!"); } /** * Logs an error exception and shouts error! * * @param t */ private void logUncaughtExceptions(Throwable t) { showRedFatalIndicator(); logger.fatal().log(t); logger.trace(); GWT.log("Uncaught Exception", t); t.printStackTrace(System.err); } // // /** // * @param testCase // */ // private void runTestCase(TestBase testCase) { // String content = editor1.getContent(); // boolean pass = true; // try { // sendOps = false; // littleLogging(); // testCase.runTests(); // } catch (Throwable t) { // GWT.getUncaughtExceptionHandler().onUncaughtException(t); // pass = false; // } finally { // sendOps = true; // lottaLogging(); // } // // if (pass) { // logger.trace().log("<span style='color:green'>Pass :-)</span>"); // syncEditors(content); // } else { // syncEditors(); // } // editor1.focus(); // } // // /** // * Operations test button // */ // private final Button operationTestButton = new Button("Ops tests", new ClickHandler() { // public void onClick(ClickEvent e) { // runTestCase(new OperationTest()); // } // }); // // /** // * Paragaph test button // */ // private final Button pTestButton = new Button("P tests", new ClickHandler() { // public void onClick(ClickEvent e) { // runTestCase(new ParagraphTest()); // } // }); // // /** // * Title test button // */ // private final Button titleTestButton = new Button("Title tests", new ClickHandler() { // public void onClick(ClickEvent e) { // runTestCase(new ParagraphTest()); // } // }); // // /** // * Image thumbnail test button // */ // private final Button thumbnailTestButton = new Button("Thumb tests", new ClickHandler() { // public void onClick(ClickEvent e) { // runTestCase(new ImageThumbnailTest()); // } // }); /** * A queue of operations */ ArrayList<DocOp> queue = new ArrayList<DocOp>(); /** * Checkbox if harness should queue up operations from editor1 rather * than sending them straight to editor2 */ private final CheckBox queuingCheck = new CheckBox("Queue"); private final ClickHandler queuingCheckHandler = new ClickHandler() { public void onClick(ClickEvent e) { if (!queuingCheck.getValue()) { // Play any remaining operations in the queue while (queue.size() > 0) { playOne(); } } editor1.focus(true); } }; /** * Button for playing queued operations */ private final Button playButton = new Button("Play", new ClickHandler() { public void onClick(ClickEvent e) { playOne(); } }); /** * Button for clearing diff annotations and problem markers */ private final Button clearAnnotationsButton = new Button("Clear Annotations", new ClickHandler() { public void onClick(ClickEvent e) { editorBundle1.clearDiffs(); // ((EditorImpl)editor1).clearProblemMarkers(); } }); /** * Checkbox if editor2 should show incoming operations as diffs */ private final CheckBox diffCheck = new CheckBox("Diffs"); private final ClickHandler diffCheckHandler = new ClickHandler() { public void onClick(ClickEvent e) { editorBundle2.setShowDiffMode(diffCheck.getValue()); } }; private final CheckBox disabledCheck = new CheckBox("Disable"); private final ClickHandler disabledCheckHandler = new ClickHandler() { public void onClick(ClickEvent e) { ((EditorImpl) editor1).debugSetDisabled(disabledCheck.getValue()); } }; private final ListBox documentModeSelect = new ListBox(); { for (Level level : Level.values()) { documentModeSelect.addItem(level.name()); } documentModeSelect.addChangeHandler(new ChangeHandler() { @Override public void onChange(ChangeEvent event) { setEditorLevel(); } }); } private void setEditorLevel() { Level newLevel = Level.values()[documentModeSelect.getSelectedIndex()]; Level current = doc1.getLevel(); logger.log(AbstractLogger.Level.TRACE, "Switching to " + newLevel); if (current == newLevel) { return; } if (current == Level.EDITING) { if (newLevel == Level.SHELVED) { editor1.removeContentAndUnrender(); } else { editor1.removeContent(); } doc1.replaceOutgoingSink(editor1Sink); } if (newLevel == Level.SHELVED) { doc1.setShelved(); } else if (newLevel == Level.EDITING) { editor1.setContent(doc1); } else { assert newLevel == Level.RENDERED || newLevel == Level.INTERACTIVE; if (newLevel == Level.RENDERED) { doc1.setRendering(); } else { doc1.setInteractive(displayDoc1); } } assert doc1.getLevel() == newLevel; if (doc1.getLevel() == Level.RENDERED || doc1.getLevel() == Level.INTERACTIVE) { displayDoc1.getElement().appendChild(doc1.getFullContentView().getDocumentElement().getImplNodelet()); } else if (doc1.getLevel() == Level.SHELVED) { for (ContentNode n : DocIterate.deep(doc1.getFullContentView(), doc1.getFullContentView().getDocumentElement(), null)) { assert n.getImplNodelet() == null; } } } /** * Clears both editors */ private final Button clearEditorsButton = new Button("Clear", new ClickHandler() { public void onClick(ClickEvent e) { clearEditors(); editor1.focus(true); } }); private final FlowPanel widgetRow; public void clearEditors() { syncEditors(""); LineContainers.appendLine(((EditorImpl) editor2).mutable(), null); } private int randomTestCounter; Scheduler.IncrementalTask randomTestProcess = new Scheduler.IncrementalTask() { @Override public boolean execute() { randomTestCounter++; logger.trace().log("Random test #" + randomTestCounter); try { // TODO(nigeltao): This might trigger an (incorrect) exception where the // FakeAtttachmentsManager returns null. I should fix that. // new ContentAnnotationPainterRandomTest().testPainter(); } catch (RuntimeException e) { logger.error().log(e); logger.error().log("TEST FAILED"); return true; } return true; } }; /** * Plays a single operation from the queue */ private void playOne() { if (queue.size() > 0) { DocOp operation = queue.remove(0); try { outputOperation(operation); editorBundle2.execute(operation); outputEditorState(editor2, prettyContent2, prettyHtml2); } catch (Throwable t) { GWT.getUncaughtExceptionHandler().onUncaughtException(t); } } setPlayButtonState(); } /** * Sets enabled/disabled state of play button */ private void setPlayButtonState() { playButton.setEnabled(queue.size() > 0); playButton.setHTML("Play" + (queue.size() > 0 ? " (" + queue.size() + ")" : "")); } /** * Output content */ private void outputBothEditorStates() { outputEditorState(editor1, prettyContent1, prettyHtml1); outputEditorState(editor2, prettyContent2, prettyHtml2); } /** * Output content for and editor */ private void outputEditorState(final Editor editor, final HTML prettyContent, final HTML prettyHtml) { Runnable printer = new Runnable() { public void run() { if (!quiet) { String content = EditorDocFormatter.formatContentDomString(editor); String html = EditorDocFormatter.formatImplDomString(editor); if (content != null) { prettyContent.setText(content); } if (html != null) { prettyHtml.setText(html); } } } }; if (LogLevel.showDebug()) { // Flush and update once it's safe if (editor.getContent().flush(printer)) { printer.run(); // note that if true is returned, the command isn't run inside flush. } } } /** * Output an operation * * @param operation */ private void outputOperation(DocOp operation) { if (!quiet) { operationOutput.setText(operation != null ? operation.toString() : ""); } } /** * Sets content in both editors from current text in content box. * Also adds that content to the content box oracle. */ private void setFromContentBox() { String content = contentBox != null ? contentBox.getText() : contentSuggestBox.getText(); if (contentOracle != null) { contentOracle.add(content); } syncEditors(bodyWrap(content)); editor1.focus(true); } /** * This is used for unit testing to call this to attach the main panel to an * arbitrary root. The unit testing framework does not call onModuleLoad(). * */ public static EditorHarness createTestPage() { EditorHarness harness = new EditorHarness(); RootPanel.get().add(harness, 0, 0); return harness; } void initContentText() { contentBox = new TextArea(); contentBox.getElement().setId("content-box"); } void initContentOracle() { contentOracle = new MultiWordSuggestOracle(); contentSuggestBox = new SuggestBox(contentOracle); contentSuggestBox.getElement().setId("content-box"); // Some initial content xml strings contentOracle.add(""); contentOracle.add("abcd"); contentSuggestBox.addSelectionHandler(new SelectionHandler<SuggestOracle.Suggestion>() { @Override public void onSelection(SelectionEvent<SuggestOracle.Suggestion> event) { setFromContentBox(); } }); String[] extra = extendSampleContent(); if (extra != null) { for (String content : extra) { contentOracle.add(content); } } } /** * Override this to provide additional sample content for the suggest box */ public String[] extendSampleContent() { return null; } /** * Convenience method to wrap sample content in the required body and line tags. */ public String bodyWrap(String sampleContent) { // Put an extra space so that the content oracle indexing works nicely on // the actual sample content. return "<body><line/> " + sampleContent + "</body>"; } public EditorHarness() { try { // Start with queueing off queuingCheck.setValue(false); setPlayButtonState(); // Construct log panel if (LogLevel.showDebug()) { log = new HTML(); log.setStyleName("log"); log.getElement().setId("log1"); error = new HTML(); error.getElement().setId("error1"); error.setStyleName("redIndicator"); fatal = new HTML(); fatal.getElement().setId("fatal1"); fatal.setStyleName("redIndicator"); // Initialize listener that turns error indicator red when any error // messages are logged DomLogger.addLoggerListener(new LoggerListener() { @Override public void onError() { showRedErrorIndicator(); } @Override public void onFatal() { showRedFatalIndicator(); } @Override public void onNeedOutput() { } @Override public void onNewLogger(String loggerName) { } }); } // Setup content and html display if (LogLevel.showDebug()) { prettyContent1 = new HTML(); prettyContent1.addStyleName("content"); prettyContent2 = new HTML(); prettyContent2.addStyleName("content"); prettyHtml1 = new HTML(); prettyHtml1.addStyleName("html"); prettyHtml2 = new HTML(); prettyHtml2.addStyleName("html"); } EditorWebDriverUtil.setDocumentSchema(getSchema()); registerDoodads(testEditorRegistries); // The editors we are testing editor1 = createEditor("editor1"); editorBundle1 = new EditorBundle(editor1, true); editor2 = createEditor("editor2"); editorBundle2 = new EditorBundle(editor2, false); toggleEditCheck1 = createEditToggleCheckBox(editor1); toggleEditCheck2 = createEditToggleCheckBox(editor2); operationOutput.setStyleName("operation"); final FlowPanel editMain = new FlowPanel(); editMain.setStyleName("main"); HorizontalPanel editors = new HorizontalPanel(); FlowPanel editorStack1 = new FlowPanel(); FlowPanel editorStack2 = new FlowPanel(); editorStack1.add(editor1.getWidget()); editorStack1.add(displayDoc1); editorStack1.add(toggleEditCheck1); editorStack1.add(disabledCheck); editorStack1.add(documentModeSelect); // xx editorStack1.add(disabledCheck); if (LogLevel.showDebug()) { editorStack1.add(prettyContent1); } editorStack2.add(editor2.getWidget()); editorStack2.add(toggleEditCheck2); editorStack2.add(diffCheck); editorStack2.add(createEditor2DocDetached); if (LogLevel.showDebug()) { editorStack2.add(prettyContent2); } editors.add(editorStack1); if (LogLevel.showDebug()) { editors.add(prettyHtml1); } editors.add(editorStack2); if (LogLevel.showDebug()) { editors.add(prettyHtml2); } HorizontalPanel operations = new HorizontalPanel(); operations.setVerticalAlignment(HorizontalPanel.ALIGN_MIDDLE); queuingCheck.addClickHandler(queuingCheckHandler); disabledCheck.addClickHandler(disabledCheckHandler); diffCheck.addClickHandler(diffCheckHandler); setPlayButtonState(); operations.add(clearAnnotationsButton); operations.add(queuingCheck); operations.add(playButton); operations.add(new Label("Operation:")); operations.add(operationOutput); editMain.add(operations); editMain.add(editors); // Exactly one of these methods should be uncommented. // initContentText(); initContentOracle(); widgetRow = new FlowPanel(); widgetRow.add(clearEditorsButton); widgetRow.add(setContentButton); widgetRow.add(new InlineLabel("<body><line/>")); widgetRow.add(contentBox != null ? contentBox : contentSuggestBox); widgetRow.add(new InlineLabel("</body>")); Button clearContentBoxButton = new Button("Clear text", new ClickHandler() { public void onClick(ClickEvent e) { if (contentBox != null) { contentBox.setValue(""); } else { contentSuggestBox.setValue(""); } } }); clearContentBoxButton.getElement().setId("clear-content-box"); widgetRow.add(clearContentBoxButton); // Hide it, only really used for webdriver tests clearContentBoxButton.setVisible(false); if (LogLevel.showDebug()) { widgetRow.add(new FlowPanel()); widgetRow.add(clearLogButton); widgetRow.add(quietButton); widgetRow.add(loudButton); } editMain.add(widgetRow); if (LogLevel.showDebug()) { editMain.add(error); editMain.add(fatal); editMain.add(log); // We need our own uncaught exception hander to make sure the error shout happens GWT.setUncaughtExceptionHandler(new UncaughtExceptionHandler() { public void onUncaughtException(Throwable e) { logUncaughtExceptions(e); } }); } else { HTML spacer = new HTML(); editMain.add(spacer); } initWidget(editMain); // Enable logging (important to do this after main is attached // such that exceptions occurring before this can be handled by // GWT's Default handler...) if (LogLevel.showDebug()) { DomLogger.enable(log.getElement()); lottaLogging(); } KeyBindingRegistry keysRegistry = new KeyBindingRegistry(); extendKeyBindings(keysRegistry); // Start editing editor1.init(testEditorRegistries, keysRegistry, EditorSettings.DEFAULT); editor2.init(testEditorRegistries, keysRegistry, EditorSettings.DEFAULT); editor1.addUpdateListener(new EditorUpdateListener() { @Override public void onUpdate(EditorUpdateEvent event) { outputBothEditorStates(); } }); editor1.setOutputSink(editor1Sink); editor2.setOutputSink(editor2Sink); clearEditors(); editor1.setEditing(true); editor2.setEditing(false); toggleEditCheck2.setValue(false); toggleEditCheck1.setValue(true); // Output initial state outputBothEditorStates(); outputOperation(null); } catch (RuntimeException r) { // Do we need this at all? UncaughtExceptionHandler handler = GWT.getUncaughtExceptionHandler(); if (handler != null) { handler.onUncaughtException(r); } else { logger.error().log(r); } throw r; } } public DocumentSchema getSchema() { return ConversationSchemas.BLIP_SCHEMA_CONSTRAINTS; } public void registerDoodads(Registries registries) { ElementHandlerRegistry testHandlerRegistry = testEditorRegistries.getElementHandlerRegistry(); LineRendering.registerContainer(TOPLEVEL_CONTAINER_TAGNAME, registries.getElementHandlerRegistry()); StyleAnnotationHandler.register(registries); DiffAnnotationHandler.register(registries.getAnnotationHandlerRegistry(), registries.getPaintRegistry()); LinkAnnotationHandler.register(registries, new LinkAttributeAugmenter() { @Override public Map<String, String> augment(Map<String, Object> annotations, boolean isEditing, Map<String, String> current) { return current; } }); // TODO(danilatos): Open source spelly stuff // SpellDocument testSpellDocument = SpellDebugHelper.createTestSpellDocument( // EditorStaticDeps.logger); // SpellAnnotationHandler.register(Editor.ROOT_REGISTRIES, // SpellySettings.DEFAULT, testSpellDocument); // SpellDebugHelper.setDebugSpellDoc(testSpellDocument); // SpellSuggestion.register(testHandlerRegistry, testSpellDocument); // SpellTesting.registerDebugCombo(keysRegistry); // SpellDebugHelper.setDebugSpellDoc(testSpellDocument); extend(registries); } /** Override this method to register additional doodads. */ public void extend(Registries registries) { } /** Override this method to add keyboard handling hooks. */ public void extendKeyBindings(KeyBindingRegistry registry) { } static { Editors.initRootRegistries(); } private class EditorBundle { private final HighlightingDiffState diffState; private final boolean is1; private boolean showDiffs; EditorBundle(Editor editor, boolean is1) { this.diffState = new HighlightingDiffState(editor); this.is1 = is1; } void setShowDiffMode(boolean showDiffs) { this.showDiffs = showDiffs; } void execute(DocOp op) throws OperationException { if (showDiffs) { diffState.consume(op); } else { // TODO(danilatos): Clean this up (is1 ? doc1 : doc2).consume(op); } } void clearDiffs() { diffState.clearDiffs(); } } private Editor createEditor(String id) { EditorStaticDeps.setPopupProvider(Popup.LIGHTWEIGHT_POPUP_PROVIDER); EditorStaticDeps.setPopupChromeProvider(new PopupChromeProvider() { public PopupChrome createPopupChrome() { return null; } }); Editor editor = Editors.create(); editor.getWidget().getElement().setId(id); editor.addKeySignalListener(this); return editor; } /** * Log from all relevant modules */ private void lottaLogging() { DomLogger.enableAllModules(); DomLogger.enableModule("test", true); DomLogger.enableModule("editor", true); DomLogger.enableModule("editor-node", true); DomLogger.enableModule("operator", true); DomLogger.enableModule("dragdrop", true); } /** * Only log from test module */ private void littleLogging() { DomLogger.setMaxLevel(AbstractLogger.Level.ERROR); DomLogger.enableModule("test", true); } private final SilentOperationSink<DocOp> editor1Sink = new SilentOperationSink<DocOp>() { public void consume(DocOp operation) { try { if (operation != null && sendOps) { if (queuingCheck.getValue()) { queue.add(operation); setPlayButtonState(); } else { editorBundle2.execute(operation); } } } catch (Throwable t) { GWT.getUncaughtExceptionHandler().onUncaughtException(t); } finally { outputOperation(operation); } } }; private final SilentOperationSink<DocOp> editor2Sink = new SilentOperationSink<DocOp>() { public void consume(DocOp operation) { try { if (operation != null && sendOps) { editorBundle1.execute(operation); } } catch (Throwable t) { GWT.getUncaughtExceptionHandler().onUncaughtException(t); } finally { outputOperation(operation); } } }; /** * {@inheritDoc} */ public boolean onKeySignal(final Widget sender, SignalEvent event) { // Deferred command so we have a look at the content after it's updated ScheduleCommand.addCommand(new Task() { public void execute() { if (sender == editor1) { outputEditorState(editor1, prettyContent1, prettyHtml1); } else { outputEditorState(editor2, prettyContent2, prettyHtml2); } } }); return false; } public Editor getEditor1() { return editor1; } public Editor getEditor2() { return editor2; } /** * Convenience method to run the harness when it's the main application. */ public void run() { RootPanel.get().add(this); getEditor1().focus(true); } }