Java WSEditor类代码示例

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
/**
 * Extracts encoding from XML prologue in editor string content and the String content as second element,
 * returns empty string as first element if no prologue is found.
 * @param editorAccess editor handle
 * @return encoding encoding and editor content as String array, empty if no encoding could be extracted
 */
private static String[] editorStringEncoding(WSEditor editorAccess) {
    String encodingString[] = new String[2];
    String pageID = editorAccess.getCurrentPageID();
    if (!pageID.equals(EditorPageConstants.PAGE_TEXT))
        editorAccess.changePage(EditorPageConstants.PAGE_TEXT);
    WSTextEditorPage textPage = (WSTextEditorPage)editorAccess.getCurrentPage();
    Document doc = textPage.getDocument();
    if (!pageID.equals(EditorPageConstants.PAGE_TEXT))
        editorAccess.changePage(pageID);
    try {
        encodingString[1] = doc.getText(0, doc.getLength());
        encodingString[0] = XMLUtils.encodingFromPrologue(encodingString[1]);
    } catch (BadLocationException ex) {
        logger.error(ex);
        encodingString[0] = "";
    }
    return encodingString;
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
/**
 * Store the content of an editor editorAccess to a BaseX resource url. Checks for encoding in prologue and byte code,
 * if none can be obtained assumes UTF-8 encoding.
 * @param editorAccess editor handle
 * @param url BaseX target url
 * @throws IOException BaseX connection can return exception
 */
public static void saveEditorToBaseXURL(WSEditor editorAccess, URL url) throws IOException {
    byte[] content = WorkspaceUtils.getEditorContent(editorAccess);
    String[] encodingString = WorkspaceUtils.editorStringEncoding(editorAccess);
    if (encodingString[0].equals(""))
        encodingString[0] = XMLUtils.encodingFromBytes(content);
    if (!URLUtils.isXML(url) && (URLUtils.isBinary(url) || !IOUtils.isXML(content))) {
        ConnectionWrapper.save(true, url, content);
    } else {
        switch (encodingString[0]) {
            case "": {
                ConnectionWrapper.save(url, IOUtils.returnUTF8Array(encodingString[1]), "UTF-8");
                break;
            }
            case "UTF-8": {
                ConnectionWrapper.save(url, content, "UTF-8");
                break;
            }
            default:
                ConnectionWrapper.save(url, IOUtils.convertToUTF8(content, encodingString[0]), encodingString[0]);
        }
    }
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
private URL[] selectURLs() {
        final URL[] urls = new URL[2];
        int[] selection = table.getSelectedRows();
        // if only one revision row is selected, it is compared to the last (current) one
        if (selection.length == 1) {
            int rows = table.getModel().getRowCount();
            urls[0] = ((VersionHistoryTableModel) table.getModel()).getURL(0);
            urls[1] = ((VersionHistoryTableModel) table.getModel()).getURL(selection[0]);
            WSEditor editorAccess = PluginWorkspaceProvider.getPluginWorkspace().
                    getCurrentEditorAccess(PluginWorkspace.MAIN_EDITING_AREA);
/*            if (editorAccess.isModified())
                JOptionPane.showMessageDialog(null, "The content in the editor was changed.\n" +
                    "Save first to compare with current content.",  "Compare File Revisions", JOptionPane.PLAIN_MESSAGE);*/
            if (editorAccess.isModified()) {    // take current version editor instead
                editorAccess.save();
                urls[0] = editorAccess.getEditorLocation();
            }
        } else {
            urls[0] = ((VersionHistoryTableModel) table.getModel()).getURL(selection[1]);
            urls[1] = ((VersionHistoryTableModel) table.getModel()).getURL(selection[0]);
        }
        return urls;
    }
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
private static String[] getContentAndExtractExtVars(WSEditor editorAccess, StringBuilder content) {
    List<String> extVars = new ArrayList<>();
    MutableBoolean inComment = new MutableBoolean(false);
    try (InputStream editorStream = editorAccess.createContentInputStream()) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(editorStream))) {
            String line;
            while ((line = reader.readLine()) != null) {
                extractVarFromLine(extVars, line, inComment);
                content.append(line).append("\n");
            }
        }
    } catch (IOException ioe) {
        logger.error("Failed extracting editor content: ", ioe.getMessage());
    }
    return extVars.toArray(new String[extVars.size()]);
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
@Override
public void actionPerformed(ActionEvent e) {
    WSEditor editorAccess = workspace.getCurrentEditorAccess(StandalonePluginWorkspace.MAIN_EDITING_AREA);
    URL url = editorAccess.getEditorLocation();
    if (url.toString().startsWith(ArgonConst.ARGON)) {
        String protocol = CustomProtocolURLHandlerExtension.protocolFromURL(url);
        CustomProtocolURLHandlerExtension handlerExtension = new CustomProtocolURLHandlerExtension();
        if (handlerExtension.canCheckReadOnly(protocol) && !handlerExtension.isReadOnly(url)) {
            byte[] outputArray = WorkspaceUtils.getEditorByteContent(editorAccess);
            WorkspaceUtils.setCursor(WorkspaceUtils.WAIT_CURSOR);
            String encoding = ArgonEditorsWatchMap.getInstance().getEncoding(url);
            if (!encoding.equals("UTF-8"))
                outputArray = IOUtils.convertToUTF8(outputArray, encoding);
            updateFile(url, outputArray, encoding);
            WorkspaceUtils.setCursor(WorkspaceUtils.DEFAULT_CURSOR);
        } else {
             workspace.showInformationMessage(Lang.get(Lang.Keys.msg_noupdate1) + " " + url.toString() + ".\n" +
                     Lang.get(Lang.Keys.msg_noupdate2));
        }
    }
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
static void checkIn(URL url) {
    BaseXSource source = CustomProtocolURLHandlerExtension.sourceFromURL(url);
    String path = CustomProtocolURLHandlerExtension.pathFromURL(url);
    try (Connection connection = BaseXConnectionWrapper.getConnection()) {
        if (connection.lockedByUser(source, path)) {
            WSEditor editorAccess = PluginWorkspaceProvider.getPluginWorkspace().
                    getEditorAccess(url, StandalonePluginWorkspace.MAIN_EDITING_AREA);
            ArgonEditorsWatchMap.getInstance().setAskedForCheckIn(url, true);
            if (editorAccess != null)
                editorAccess.close(true);
            connection.unlock(source, path);
        }
    } catch (IOException ex) {
        logger.debug(ex);
    }
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
@Override
public void editorOpened(URL editorLocation) {
    logger.debug("editor opened: " + editorLocation.toString());
    if (editorLocation.toString().startsWith(ArgonConst.ARGON))
        ArgonEditorsWatchMap.getInstance().addURL(editorLocation);
    checkEditorDependentMenuButtonStatus(pluginWorkspaceAccess);
    TopicHolder.changedEditorStatus.postMessage(VersionHistoryUpdater.checkVersionHistory(editorLocation));

    customizeEditorPopupMenu();

    final WSEditor editorAccess = pluginWorkspaceAccess.getEditorAccess(editorLocation, PluginWorkspace.MAIN_EDITING_AREA);
    boolean isArgon = URLUtils.isArgon(editorLocation);

    if (isArgon)
        editorAccess.addEditorListener(new ArgonEditorListener(pluginWorkspaceAccess));

    if (isArgon && URLUtils.isQuery(editorLocation))
        editorAccess.addValidationProblemsFilter(new ArgonValidationProblemsFilter(editorAccess));
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
private void checkEditorDependentMenuButtonStatus(PluginWorkspace pluginWorkspaceAccess){
    WSEditor currentEditor = pluginWorkspaceAccess.getCurrentEditorAccess(PluginWorkspace.MAIN_EDITING_AREA);

    if(currentEditor == null) {
        runQueryButton.setEnabled(false);
        newVersionButton.setEnabled(false);
        saveToArgonButton.setEnabled(false);
    } else {
        saveToArgonButton.setEnabled(true);
        URL url = currentEditor.getEditorLocation();
        if (URLUtils.isArgon(url)) {
            newVersionButton.setEnabled(true);
        } else {
            newVersionButton.setEnabled(false);
        }
        if (URLUtils.isQuery(currentEditor.getEditorLocation())) {
            runQueryButton.setEnabled(true);
        } else {
            runQueryButton.setEnabled(false);
        }
    }
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
@Override
public void editorClosed(URL path) {
	// TODO Auto-generated method stub
	super.editorClosed(path);
	if (path != null) {
		editors.remove(path);
		openOrderMap.remove(path);
		if(editorByUrl.containsKey(path)){
			WSEditor editor = editorByUrl.get(path);
			this.closedEditor.add(editor);
			if(closedEditor.size() > 50){
				closedEditor.remove(0);
			}
		}
		updateEditors();
	}
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
@Override
public void customizePopUpMenu(Object popUp, WSTextEditorPage textPage) {
  Object textComponent = textPage.getTextComponent();
  if (textComponent instanceof JTextArea) {
    int caretOffset = textPage.getCaretOffset();
    WSEditor editorAccess = pluginWorkspaceAccess.getCurrentEditorAccess(StandalonePluginWorkspace.MAIN_EDITING_AREA);
    HighlightData highlightData = perEditorHighlightData.get(editorAccess);
    HighlightInfo hInfo = highlightData.getInfoForCaretOrNull(caretOffset);
    if (hInfo != null) {
      RuleMatch match = hInfo.ruleMatch;
      replaceMenuItems((JPopupMenu) popUp, match, new TextModeApplyReplacementAction(match, textPage, highlightData, editorAccess));
    }
  } else {
    System.err.println("textComponent not of type JTextArea: " + textComponent.getClass().getName());
  }
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
@Override
public void actionPerformed(@NotNull ActionEvent event) {
  WSEditor editorAccess = pluginWorkspaceAccess.getCurrentEditorAccess(StandalonePluginWorkspace.MAIN_EDITING_AREA);
  WSAuthorEditorPage authorPageAccess = (WSAuthorEditorPage) editorAccess.getCurrentPage();
  AuthorDocumentController controller = authorPageAccess.getDocumentController();
  controller.beginCompoundEdit();
  try {
    boolean deleted = controller.delete(match.getOxygenOffsetStart(), match.getOxygenOffsetEnd());
    if (!deleted) {
      System.err.println("Could not delete text for match " + match);
    } else {
      AuthorHighlighter highlighter = authorAccess.getEditorAccess().getHighlighter();
      highlighter.removeAllHighlights();
      controller.insertText(match.getOxygenOffsetStart(), event.getActionCommand());
      checkTextInBackground(highlighter, authorPageAccess);
    }
  } finally {
    controller.endCompoundEdit();
  }
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
/**
 * Inserts a text fragment into a text or author editor pane.
 *
 * @param workspace oXygen's plugin workspace
 * @param d         the glyph definition
 */
private void insertFragment(StandalonePluginWorkspace workspace,
                            GlyphDefinition d) {
    WSEditor editorAccess = workspace.getCurrentEditorAccess(
            PluginWorkspace.MAIN_EDITING_AREA);
    if (editorAccess != null) {
        WSEditorPage currentPage = editorAccess.getCurrentPage();
        if (currentPage instanceof WSTextEditorPage) {
            insertIntoTextEditorPage(d.getXmlString(), (WSTextEditorPage) currentPage);
            transferFocus();
            return;
        } else if (currentPage instanceof WSAuthorEditorPage) {
            insertIntoAuthorPage(d.getXmlString(), (WSAuthorEditorPage) currentPage);
            transferFocus();
            return;
        } 
    } 
     
    workspace.showErrorMessage(getI18n().getString("GlyphPickerPluginExtension.noEditorFound"));
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
private static byte[] getEditorContent(WSEditor editorAccess) throws IOException {
    byte[] content;
    try (InputStream contentStream = editorAccess.createContentInputStream()) {
        content = IOUtils.getBytesFromInputStream(contentStream);
    } catch (IOException ie) {
        logger.error(ie);
        content = new byte[0];
    }
    return content;
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
public static Document getDocumentFromEditor(WSEditor editorAccess) {
    boolean editorInAuthorMode = false;
    if (editorAccess.getCurrentPageID().equals(EditorPageConstants.PAGE_AUTHOR)) {
        editorInAuthorMode = true;
        editorAccess.changePage(EditorPageConstants.PAGE_TEXT);
    }
    WSTextEditorPage  textPage = (WSTextEditorPage)editorAccess.getCurrentPage();
    Document doc = textPage.getDocument();
    if (editorInAuthorMode) {
        editorAccess.changePage(EditorPageConstants.PAGE_AUTHOR);
    }
    return doc;
}
 

import ro.sync.exml.workspace.api.editor.WSEditor; //导入依赖的package包/类
@Override
public void actionPerformed(ActionEvent arg0) {
    WSEditor editorAccess = workspace.getCurrentEditorAccess(StandalonePluginWorkspace.MAIN_EDITING_AREA);

    if (editorAccess != null) {
        if (URLUtils.isQuery(editorAccess.getEditorLocation())) {

            StringBuilder contentBuilder = new StringBuilder();
            String[] parameterNames = getContentAndExtractExtVars(editorAccess, contentBuilder);
            String editorContent = contentBuilder.toString();

            String[] arguments;
            if (parameterNames.length > 0) {
                List<String> argumentList = askForArguments(parameterNames);
                if (argumentList.size() == 0)
                    return;
                arguments = argumentList.toArray(new String[argumentList.size()]);
            } else
                arguments = new String[0];

            String queryRes;
            try {
                queryRes = ConnectionWrapper.query(editorContent, arguments);
            } catch (Exception er) {
                logger.error("query to BaseX failed");
                queryRes = "";
            }

            workspace.createNewEditor("xml", ContentTypes.XML_CONTENT_TYPE, queryRes);

        } else {
            workspace.showInformationMessage(Lang.get(Lang.Keys.msg_noquery));
        }

    } else {
        workspace.showInformationMessage(Lang.get(Lang.Keys.msg_noeditor));
    }
}