Java Code Examples for javafx.scene.input.Clipboard#getSystemClipboard()

@Override
@FxThread
protected void execute(@Nullable ActionEvent event) {
    super.execute(event);

    var files = getElements().stream()
            .map(ResourceElement::getFile)
            .map(Path::toFile)
            .collect(toList());

    var content = new ClipboardContent();
    content.putFiles(files);
    content.put(EditorUtil.JAVA_PARAM, "cut");

    var clipboard = Clipboard.getSystemClipboard();
    clipboard.setContent(content);
}
 

@Override
@FxThread
protected void execute(@Nullable ActionEvent event) {
    super.execute(event);

    var clipboard = Clipboard.getSystemClipboard();
    if (clipboard == null) {
        return;
    }

    List<File> files = unsafeCast(clipboard.getContent(DataFormat.FILES));
    if (files == null || files.isEmpty()) {
        return;
    }

    var currentFile = getElement().getFile();
    var isCut = "cut".equals(clipboard.getContent(EditorUtil.JAVA_PARAM));

    if (isCut) {
        files.forEach(file -> moveFile(currentFile, file.toPath()));
    } else {
        files.forEach(file -> copyFile(currentFile, file.toPath()));
    }

    clipboard.clear();
}
 

/**
 * Fill the items actions for this node.
 *
 * @param nodeTree the node tree
 * @param items    the items
 */
@FxThread
public void fillContextMenu(@NotNull final NodeTree<?> nodeTree, @NotNull final ObservableList<MenuItem> items) {

    if (canEditName()) {
        items.add(new RenameNodeAction(nodeTree, this));
    }

    if (canCopy()) {
        items.add(new CopyNodeAction(nodeTree, this));
    }

    final Clipboard clipboard = Clipboard.getSystemClipboard();
    final Object content = clipboard.getContent(DATA_FORMAT);
    if (!(content instanceof Long)) {
        return;
    }

    final Long objectId = (Long) content;
    final TreeItem<?> treeItem = UiUtils.findItem(nodeTree.getTreeView(), objectId);
    final TreeNode<?> treeNode = treeItem == null ? null : (TreeNode<?>) treeItem.getValue();

    if (treeNode != null && canAccept(treeNode, true)) {
        items.add(new PasteNodeAction(nodeTree, this, treeNode));
    }
}
 

@WebkitCall(from = "hterm")
public void copy(String text) {
	final Clipboard clipboard = Clipboard.getSystemClipboard();
	final ClipboardContent clipboardContent = new ClipboardContent();
	clipboardContent.putString(text);
	clipboard.setContent(clipboardContent);
}
 

/** Paste commands from clipboard, append after currently selected item */
void pasteFromClipboard()
{
    final Clipboard clip = Clipboard.getSystemClipboard();
    if (ScanCommandDragDrop.hasCommands(clip))
    {
        final List<ScanCommand> commands = ScanCommandDragDrop.getCommands(clip);

        final TreeItem<ScanCommand> item = getSelectionModel().getSelectedItem();
        final ScanCommand location = item != null ? item.getValue() : null;
        undo.execute(new AddCommands(model, location, commands, true));
    }
}
 

@Override
public void paste() {
    Clipboard clipboard = Clipboard.getSystemClipboard();
    if (clipboard.hasString()) {
        String text = clipboard.getString();
        if (text.length() > 2 && text.charAt(0) == '"' && text.charAt(text.length() - 1) == '"') {
            replaceSelection(text.substring(1, text.length() - 1));
        } else {
            super.paste();
        }
    }
}
 

public SystemClipboard() {
    clipboard = Clipboard.getSystemClipboard();
    Timeline monitorTask = new Timeline(new KeyFrame(Duration.millis(200), this));
    monitorTask.setCycleCount(Animation.INDEFINITE);
    monitorTask.play();
    prevData = null;
}
 

public static Image fetchImageInClipboard(boolean clear) {
    Clipboard clipboard = Clipboard.getSystemClipboard();
    if (!clipboard.hasImage()) {
        return null;
    }
    Image image = clipboard.getImage();
    if (clear) {
        clipboard.clear();
    }
    return image;
}
 

@FXML private void copy() {
	try {
		Clipboard clipboard = Clipboard.getSystemClipboard();
        ClipboardContent content = new ClipboardContent();
        String string = stackTrace.getText();
		// add 4 spaces before each line so when pasted on GitHub it's formatted as code
        content.putString("    " + string.replace("\n", "\n    ").trim());
        clipboard.setContent(content);
	} catch (Exception e) {
		ExceptionController.display(e);
	}
}
 

@FXML
protected void copyAddress(ActionEvent event) {
    // User clicked icon or menu item.
    Clipboard clipboard = Clipboard.getSystemClipboard();
    ClipboardContent content = new ClipboardContent();
    content.putString(addressStr.get());
    content.putHtml(String.format("<a href='%s'>%s</a>", uri(), addressStr.get()));
    clipboard.setContent(content);
}
 

public boolean handleCopy() {
    TextField focused = getFocusedTextField();
    if (focused == null) return false;
    String text = focused.getSelectedText();

    if (!StringHelper.isStringEmptyOrNull(text)) {
        Clipboard systemClipboard = Clipboard.getSystemClipboard();
        ClipboardContent content = new ClipboardContent();
        content.putString(text);
        systemClipboard.setContent(content);
    }
    return true;
}
 

@Override
public void call(final Selection selection) throws Exception
{
    final List<ProcessVariable> pvs = selection.getSelections();

    final Clipboard clipboard = Clipboard.getSystemClipboard();
    final ClipboardContent content = new ClipboardContent();
    content.putString(pvs.stream().map(ProcessVariable::getName).collect(Collectors.joining(" ")));
    clipboard.setContent(content);
}
 

/**
 * Save screenshot to clipbaord
 */
public void screenshotToClipboard() {
    Image image = getScreenshot();
    Clipboard clipboard = Clipboard.getSystemClipboard();
    final ClipboardContent content = new ClipboardContent();
    content.putImage(image);
    clipboard.setContent(content);
    LOGGER.atInfo().log("Copied screenshot to clipboard");
}
 

/**
 * Copy the given text to the system clipboard.
 *
 * @param text the text to copy.
 */
public static void copyToClipboard(final String text) {
    final Clipboard clipboard = Clipboard.getSystemClipboard();
    final ClipboardContent content = new ClipboardContent();
    content.putString(text);
    clipboard.setContent(content);
}
 

@Override
@FxThread
protected void process() {
    super.process();

    final TreeNode<?> node = getNode();

    final ClipboardContent content = new ClipboardContent();
    content.put(DATA_FORMAT, node.getObjectId());

    final Clipboard clipboard = Clipboard.getSystemClipboard();
    clipboard.setContent(content);
}
 

private ObjectModel fromClipboard() {
    Clipboard clipboard = Clipboard.getSystemClipboard();
    if (clipboard.getContentTypes().contains(DATA_FORMAT_JAXB)) {
        try {
            String content = (String)clipboard.getContent(DATA_FORMAT_JAXB);
            Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
            return (ObjectModel) unmarshaller.unmarshal(new StringReader(content));
        }
        catch (Exception ex) {
            LOG.log(Level.SEVERE, "Unable to get content from clipboard", ex);
        }
    }
    return null;
}
 

private String collectCurrentClipboardText() {
    Clipboard clipboard = Clipboard.getSystemClipboard();

    return clipboard.getString();
}
 

void copySelectedComponents() {
	CircuitManager manager = getCurrentCircuit();
	if(manager != null) {
		Set<GuiElement> selectedElements = manager.getSelectedElements();
		if(selectedElements.isEmpty()) {
			return;
		}
		
		List<ComponentInfo> components =
			selectedElements
				.stream()
				.filter(element -> element instanceof ComponentPeer<?>)
				.map(element -> (ComponentPeer<?>)element)
				.map(component ->
					     new ComponentInfo(component.getClass().getName(),
					                       component.getX(), component.getY(),
					                       component.getProperties()))
				.collect(Collectors.toList());
		
		List<WireInfo> wires = selectedElements
			                       .stream()
			                       .filter(element -> element instanceof Wire)
			                       .map(element -> (Wire)element)
			                       .map(wire -> new WireInfo(wire.getX(), wire.getY(),
			                                                 wire.getLength(), wire.isHorizontal()))
			                       .collect(Collectors.toList());
		
		try {
			String data = FileFormat.stringify(
				new CircuitFile(0, 0, null, Collections.singletonList(
					new CircuitInfo("Copy", components, wires))));
			
			Clipboard clipboard = Clipboard.getSystemClipboard();
			ClipboardContent content = new ClipboardContent();
			content.put(copyDataFormat, data);
			clipboard.setContent(content);
		} catch(Exception exc) {
			setLastException(exc);
			getDebugUtil().logException("Error while copying", exc);
		}
	}
}
 

public void paste() {
	final Clipboard clipboard = Clipboard.getSystemClipboard();
	String content = (String) clipboard.getContent(DataFormat.PLAIN_TEXT);
	webView.getEngine().executeScript(String.format("editor.replaceSelection(\"%s\");", content));
}
 

public static void toClipboard(String message) {
    Clipboard clipboard = Clipboard.getSystemClipboard();
    ClipboardContent clipboardContent = new ClipboardContent();
    clipboardContent.putString(message);
    clipboard.setContent(clipboardContent);
}