/**
 * Registers the given [source] javafx Node as a source for a drag
 * and drop even with {@link #NODE_RANGE_DATA_FORMAT} content.
 */
public static Subscription registerAsNodeDragSource(javafx.scene.Node source, Node data, DesignerRoot root) {
    source.setOnDragDetected(evt -> {
        // drag and drop
        Dragboard db = source.startDragAndDrop(TransferMode.LINK);
        ClipboardContent content = new ClipboardContent();
        content.put(NODE_RANGE_DATA_FORMAT, TextRange.fullLine(data.getBeginLine(), 10000));
        db.setContent(content);
        root.getService(DesignerRoot.IS_NODE_BEING_DRAGGED).setValue(true);
        evt.consume();
    });

    source.setOnDragDone(evt -> {
        if (evt.getDragboard().hasContent(NODE_RANGE_DATA_FORMAT)) {
            root.getService(DesignerRoot.IS_NODE_BEING_DRAGGED).setValue(false);
        }
    });

    return () -> source.setOnDragDetected(null);
}
 

private void onDragDetected(MouseEvent e) {
	if (getTreeItem() == getTreeView().getRoot()) {
		return;
	}
	Dragboard db = startDragAndDrop(TransferMode.MOVE);
	WritableImage wi = new WritableImage((int) getWidth(), (int) getHeight());
	Image dbImg = snapshot(null, wi);
	db.setDragView(dbImg);
	if (USE_DRAGVIEW_OFFSET) {
		db.setDragViewOffsetX(getWidth() / 2);
		db.setDragViewOffsetY(getHeight() / 2);
	}
	ClipboardContent cbc = new ClipboardContent();
	cbc.put(CLIPBOARD_DATAFORMAT, true);
	db.setContent(cbc);
	dragboardContent = getTreeItem();
	e.consume();
}
 

/** For leaf nodes, drag PV name */
private void addDragSupport()
{
    tree_view.setOnDragDetected(event ->
    {
        final ObservableList<TreeItem<AlarmTreeItem<?>>> items = tree_view.getSelectionModel().getSelectedItems();
        if (items.size() != 1)
            return;
        final AlarmTreeItem<?> item = items.get(0).getValue();
        if (! (item instanceof AlarmClientLeaf))
            return;
        final Dragboard db = tree_view.startDragAndDrop(TransferMode.COPY);
        final ClipboardContent content = new ClipboardContent();
        content.putString(item.getName());
        db.setContent(content);
        event.consume();
    });
}
 

/** Enable dragging the PV name from a table cell.
 *  @param cell Table cell
 */
static void enablePVDrag(TableCell<AlarmInfoRow, ?> cell)
{
    // Tried to use table.setOnDragDetected() to drag PV names
    // from all selected cells, but with drag enabled on the table
    // it is no longer possible to resize columns:
    // Moving a column divider starts a drag.
    // So now hooking drag to table cell.
    cell.setOnDragDetected(event ->
    {
        // Anything to drag?
        if (cell.getTableRow() == null  ||  cell.getTableRow().getItem() == null)
            return;

        final Dragboard db = cell.startDragAndDrop(TransferMode.COPY);
        final ClipboardContent content = new ClipboardContent();
        content.putString(cell.getTableRow().getItem().pv.get());
        db.setContent(content);
        event.consume();
    });
}
 

/** Allow dragging {@link ChannelInfo} from search view (into plot) */
private void setupDrag()
{
    channel_table.setOnDragDetected(event ->
    {
        final List<ChannelInfo> selection = channel_table.getSelectionModel().getSelectedItems();
        if (selection.size() > 0)
        {
            final Dragboard db = channel_table.startDragAndDrop(TransferMode.COPY);
            final ClipboardContent content = new ClipboardContent();
            // Publish PV names as "PV1, PV2, ..."
            content.putString(selection.stream().map(ChannelInfo::getName).collect(Collectors.joining(", ")));
            // Copy into ArrayList which is for sure Serializable
            content.put(CHANNEL_INFOS, new ArrayList<>(selection));
            db.setContent(content);
        }
        event.consume();
    });
}
 

/** Allow dragging this item */
private void handleDragDetected(final MouseEvent event)
{
    // Disable dragging from a 'fixed' pane
    if (getDockPane().isFixed())
        return;

    final Dragboard db = name_tab.startDragAndDrop(TransferMode.MOVE);

    final ClipboardContent content = new ClipboardContent();
    content.put(DOCK_ITEM, getLabel());
    db.setContent(content);

    final DockItem previous = dragged_item.getAndSet(this);
    if (previous != null)
        logger.log(Level.WARNING, "Already dragging " + previous);

    event.consume();
}
 

private void addDragEvenHandlers(Control control) {
    control.setOnDragOver(event -> {
        if (event.getGestureSource() != control && event.getDragboard().hasFiles()) {
            event.acceptTransferModes(TransferMode.ANY);
        }

        event.consume();
    });

    control.setOnDragDropped(event -> {
        processFiles(event.getDragboard().getFiles());
        event.setDropCompleted(true);
        event.consume();
        if (!chaptersMode.get()) {
            if (!filesChapters.getTabs().contains(filesTab)) {
                filesChapters.getTabs().add(filesTab);
                filesChapters.getSelectionModel().select(filesTab);
            }
        }
    });
}
 

/**
 * Handle drag over.
 */
@FxThread
private void dragOver(@NotNull DragEvent dragEvent) {

    var dragboard = dragEvent.getDragboard();
    var files = ClassUtils.<List<File>>unsafeCast(dragboard.getContent(DataFormat.FILES));

    if (files == null || files.size() != 1) {
        return;
    }

    var file = files.get(0);
    if (!canAccept(file)) {
        return;
    }

    var transferModes = dragboard.getTransferModes();
    var isCopy = transferModes.contains(TransferMode.COPY);

    dragEvent.acceptTransferModes(isCopy ? TransferMode.COPY : TransferMode.MOVE);
    dragEvent.consume();
}
 

/**
 * Handle drag over events.
 *
 * @param dragEvent the drag over event.
 */
@FxThread
private void handleDragOverEvent(@NotNull DragEvent dragEvent) {

    var dragboard = dragEvent.getDragboard();
    var files = EditorUtil.getFiles(dragboard);
    if (files.size() != 1) {
        return;
    }

    var file = files.get(0);

    if (!file.getName().endsWith(FileExtensions.JME_MATERIAL)) {
        return;
    }

    var transferModes = dragboard.getTransferModes();
    var isCopy = transferModes.contains(TransferMode.COPY);

    dragEvent.acceptTransferModes(isCopy ? TransferMode.COPY : TransferMode.MOVE);
    dragEvent.consume();
}
 

private EventHandler<DragEvent> createOnDragOverHandler(final ImageView pView)
{
	return new EventHandler<DragEvent>()
   	{
   	    public void handle(DragEvent pEvent) 
   	    {
   	    	if(pEvent.getGestureSource() != pView && pEvent.getDragboard().hasString())
   	    	{
   	    		CardTransfer transfer = new CardTransfer(pEvent.getDragboard().getString());
   	    		if( transfer.size() == 1 && GameModel.instance().isLegalMove(transfer.getTop(), aIndex) )
   	    		{
   	    			pEvent.acceptTransferModes(TransferMode.MOVE);
   	    		}
   	    	}

   	    	pEvent.consume();
   	    }
   	};
}
 

private EventHandler<DragEvent> createDragOverHandler(final ImageView pImageView, final Card pCard)
{
	return new EventHandler<DragEvent>()
	{
		@Override
		public void handle(DragEvent pEvent) 
		{
			if(pEvent.getGestureSource() != pImageView && pEvent.getDragboard().hasString())
			{
				CardTransfer transfer = new CardTransfer(pEvent.getDragboard().getString());
				if( GameModel.instance().isLegalMove(transfer.getTop(), aIndex) )
				{
					pEvent.acceptTransferModes(TransferMode.MOVE);
				}
			}
			pEvent.consume();
		}
	};
}
 

ArtistCell() {
    super();
    artistImage.setFitWidth(40);
    artistImage.setFitHeight(40);
    artistImage.setPreserveRatio(true);
    artistImage.setSmooth(true);
    artistImage.setCache(true);
    title.setTextOverrun(OverrunStyle.CLIP);
    cell.getChildren().addAll(artistImage, title);
    cell.setAlignment(Pos.CENTER_LEFT);
    HBox.setMargin(artistImage, new Insets(0, 10, 0, 0));
    this.setPrefWidth(248);
    
    this.setOnMouseClicked(event -> artistList.getSelectionModel().select(artist));
    
    this.setOnDragDetected(event -> {
    	Dragboard db = this.startDragAndDrop(TransferMode.ANY);
    	ClipboardContent content = new ClipboardContent();
        content.putString("Artist");
        db.setContent(content);
    	MusicPlayer.setDraggedItem(artist);
    	db.setDragView(this.snapshot(null, null), 125, 25);
    	event.consume();
    });
}
 

AlbumCell() {
    super();
    setAlignment(Pos.CENTER);
    setPrefHeight(140);
    setPrefWidth(140);
    albumArtwork.setFitWidth(130);
    albumArtwork.setFitHeight(130);
    albumArtwork.setPreserveRatio(true);
    albumArtwork.setSmooth(true);
    albumArtwork.setCache(true);
    
    this.setOnMouseClicked(event -> albumList.getSelectionModel().select(album));
    
    this.setOnDragDetected(event -> {
    	Dragboard db = this.startDragAndDrop(TransferMode.ANY);
    	ClipboardContent content = new ClipboardContent();
        content.putString("Album");
        db.setContent(content);
    	MusicPlayer.setDraggedItem(album);
    	db.setDragView(this.snapshot(null, null), 75, 75);
        event.consume();
    });
}
 

private void processDragEnteredEvent(DragEvent evt) {
    MediaEntry media = null;
    if (evt.getDragboard().hasFiles()) {
        media = MediaCache.getMediaFromFile(getDraggedFile(evt.getDragboard().getFiles()));
    } else if (evt.getDragboard().hasUrl()) {
        media = MediaCache.getMediaFromUrl(evt.getDragboard().getUrl());
    } else if (evt.getDragboard().hasString()) {
        String path = evt.getDragboard().getString();
        try {
            URI.create(path);
            media = MediaCache.getMediaFromUrl(path);
        } catch (IllegalArgumentException ex) {
            File f = new File(path);
            if (f.exists()) {
                media = MediaCache.getMediaFromFile(f);
            }
        }
    }
    if (media != null) {
        evt.acceptTransferModes(TransferMode.LINK, TransferMode.COPY);
        startDragEvent(media);
    }
}
 

/**
 * Drag-n-drop support (dragOver consumer)
 * */
@FXML
private void handleDragOver(DragEvent event){
    if (event.getDragboard().hasFiles())
        event.acceptTransferModes(TransferMode.ANY);
    event.consume();
}
 

/**
 * Drag-n-drop support (dragOver consumer)
 * */
@FXML
private void handleDragOver(DragEvent event){
    if (event.getDragboard().hasFiles() && ! MediatorControl.getInstance().getTransferActive())
        event.acceptTransferModes(TransferMode.ANY);
    event.consume();
}
 

/**
 * Drag-n-drop support (dragOver consumer)
 * */
@FXML
private void handleDragOver(DragEvent event){
    if (event.getDragboard().hasFiles() && ! MediatorControl.getInstance().getTransferActive())
        event.acceptTransferModes(TransferMode.ANY);
    event.consume();
}
 

/**
 * The method activateSetOnDragOver controlling what happens when something is dragged over.
 * Implemented activateSetOnDragOver to accept when files are dragged over it.
 * @param event - DragEvent
 */
public static void activateSetOnDragOver(DragEvent event){
  Dragboard dragBoard = event.getDragboard();
  if (dragBoard.hasFiles()) {
    event.acceptTransferModes(TransferMode.COPY);
  } else {
    event.consume();
  }
}
 

private static TransferMode[] getFXDndAction(int wkDndAction) {
	LinkedList<TransferMode> tms = new LinkedList<TransferMode>();
	if ((wkDndAction & WK_DND_ACTION_COPY) != 0)
		tms.add(TransferMode.COPY);
	if ((wkDndAction & WK_DND_ACTION_MOVE) != 0)
		tms.add(TransferMode.MOVE);
	if ((wkDndAction & WK_DND_ACTION_LINK) != 0)
		tms.add(TransferMode.LINK);
	return tms.toArray(new TransferMode[0]);
}
 

private static int getWKDndAction(TransferMode... tms) {
	int dndActionId = WK_DND_ACTION_NONE;
	for (TransferMode tm : tms) {
		if (tm == TransferMode.COPY)
			dndActionId |= WK_DND_ACTION_COPY;
		else if (tm == TransferMode.MOVE)
			dndActionId |= WK_DND_ACTION_MOVE;
		else if (tm == TransferMode.LINK)
			dndActionId |= WK_DND_ACTION_LINK;
	}
	return dndActionId;
}
 

/** By default, allow dragging a "pv_name" from the widget in runtime mode
 *
 *  <p>Derived classes can override, for example to disable
 *  in case the representation already handles dragging moves
 *  to for example operate a slider or pan something.
 */
// Note: In RCP version, the D&D had to be handled in SWT,
// and was implemented in the org.csstudio.display.builder.rcp.RuntimeViewPart.
// Widget.isDragEnabled() was used to enable/disable.
// Now the enablement is left to the representation,
// and since only Ctrl-drag is supported,
// only very few widget representations need to disable it.
protected void configurePVNameDrag()
{
    // If there is a "pv_name", allow dragging it out
    final Optional<WidgetProperty<String>> pv_name = model_widget.checkProperty(CommonWidgetProperties.propPVName);
    if (! pv_name.isPresent())
        return;

    jfx_node.addEventFilter(MouseEvent.DRAG_DETECTED, event ->
    {
        // Ignore drag unless Ctrl is held.
        // When plain drag starts a PV name move,
        // this prevents selecting content within a text field
        // via a mouse drag.
        // Ctrl-drag is thus required to start dragging a PV name.
        if (! event.isControlDown())
            return;

        final String pv = pv_name.get().getValue();
        if (! pv.isEmpty())
        {
            final Dragboard db = jfx_node.startDragAndDrop(TransferMode.COPY);
            final ClipboardContent content = new ClipboardContent();
            content.putString(pv);
            db.setContent(content);
        }
    });
}
 

private void hookDrag()
{
    final List<ScanCommand> commands = new ArrayList<>();
    setOnDragDetected(event ->
    {
        // Only start drag on left (primary) button,
        // not also on right button which opens the context menu,
        // or the apple 'Command' button which is again for the context menu
        if (event.isPrimaryButtonDown() &&  !event.isMetaDown())
        {
            commands.clear();
            commands.addAll(getSelectedCommands());
            if (! commands.isEmpty())
            {
                // Would like to default to move,
                // allowing key modifiers for copy.
                // TransferMode.COPY_OR_MOVE will default to copy,
                // i.e. wrong order.
                // --> Deciding based on key modifier at start of drag
                // https://stackoverflow.com/questions/38699306/how-to-adjust-or-deviate-from-the-default-javafx-transfer-mode-behavior
                final Dragboard db = startDragAndDrop(event.isShortcutDown()
                                                      ? TransferMode.COPY
                                                      : TransferMode.MOVE);
                db.setContent(ScanCommandDragDrop.createClipboardContent(commands));
            }
        }
        event.consume();
    });

    setOnDragDone(event ->
    {
        if (event.getTransferMode() == TransferMode.MOVE)
            undo.execute(new RemoveCommands(model, commands));
        commands.clear();
    });
}
 

private void hookDrag()
{
    // Drag command out as XML
    command_list.setOnDragDetected(event ->
    {
        final ScanCommand command = command_list.getSelectionModel().getSelectedItem();
        final Dragboard db = command_list.startDragAndDrop(TransferMode.COPY);
        db.setContent(ScanCommandDragDrop.createClipboardContent(command));
        event.consume();
    });
}
 

/** @param file File to move or copy
 *  @param target_item Destination directory's tree item
 */
private void move_or_copy(final File file, final TreeItem<FileInfo> target_item, final TransferMode transferMode)
{
    final File dir = target_item.getValue().file;
    // Ignore NOP move
    if (file.getParentFile().equals(dir))
        return;

    JobManager.schedule(Messages.MoveOrCopyJobName, monitor ->
    {
        // System.out.println("Move " + file + " into " + dir);
        final File new_name = new File(dir, file.getName());

        final DirectoryMonitor mon = ((FileTreeItem)target_item).getMonitor();
        try
        {
            if (transferMode.equals(TransferMode.MOVE))
                FileHelper.move(file, dir);
            else
                FileHelper.copy(file, dir);
            Platform.runLater(() ->
            {
                // System.out.println("Add tree item for " + new_name + " to " + target_item.getValue());
                final ObservableList<TreeItem<FileInfo>> siblings = target_item.getChildren();
                siblings.add(new FileTreeItem(mon, new_name));
                FileTreeItem.sortSiblings(siblings);
            });
        }
        catch (Exception ex)
        {
            final TreeTableView<FileInfo> tree = getTreeTableView();
            ExceptionDetailsErrorDialog.openError(tree, Messages.MoveOrCopyAlertTitle,
                                                  MessageFormat.format(Messages.MoveOrCopyAlert, file, target_item.getValue()), ex);
            // Force full refresh
            Platform.runLater(() ->
                tree.setRoot(new FileTreeItem(mon, tree.getRoot().getValue().file)) );
        }
    });
}
 

/**
 * Determines the {@link TransferMode} based on the state of the modifier key.
 * This method must consider the
 * operating system as the identity of the modifier key varies (alt/option on Mac OS, ctrl on the rest).
 * @param event The mouse event containing information on key press.
 * @return {@link TransferMode#COPY} if modifier key is pressed, otherwise {@link TransferMode#MOVE}.
 */
private TransferMode getTransferMode(MouseEvent event){
    if(event.isControlDown() && (PlatformInfo.is_linux || PlatformInfo.isWindows || PlatformInfo.isUnix)){
        return TransferMode.COPY;
    }
    else if(event.isAltDown() && PlatformInfo.is_mac_os_x){
        return TransferMode.COPY;
    }
    return TransferMode.MOVE;
}
 

/** Accept dock items */
private void handleDragOver(final DragEvent event)
{
    if (!isFixed()  &&
        DockItem.dragged_item.get() != null)
        event.acceptTransferModes(TransferMode.MOVE);
    event.consume();
}
 

/** Accept other items that are dropped onto this one */
private void handleDragOver(final DragEvent event)
{
    // Don't suggest dropping into a 'fixed' pane
    if (getDockPane().isFixed())
        return;

    final DockItem item = dragged_item.get();
    if (item != null  &&  item != this)
        event.acceptTransferModes(TransferMode.MOVE);
    event.consume();
}
 

protected void startDrag(MouseEvent event) {
	TextField textBox = ((TextField)event.getSource());
	if(!"".equals(textBox.getSelectedText()) && textBox.getText().equals(textBox.getSelectedText())) {
        Dragboard db = textBox.startDragAndDrop(TransferMode.MOVE);
        snapshotter.setText(textBox.getText());
        db.setDragView(snapshotter.snapshot(null, null));
        ClipboardContent cc = new ClipboardContent();
        cc.put(DataFormat.PLAIN_TEXT, textBox.getSelectedText());
        db.setContent(cc);
        event.consume();
	}
}
 

public void onDragOverLinkFile(DragEvent event){
    Dragboard db = event.getDragboard();
    if (db.hasFiles()) {
        event.acceptTransferModes(TransferMode.LINK);
    } else {
        event.consume();
    }
}
 

@FXML
public void onSongPathDragOver(DragEvent ev) {
	Dragboard db = ev.getDragboard();
	if (db.hasFiles()) {
		ev.acceptTransferModes(TransferMode.COPY_OR_MOVE);
	}
	ev.consume();
}