diff --git a/public/javascripts/drag_and_drop.js b/public/javascripts/drag_and_drop.js
index 2e911e569..6212a56e4 100644
--- a/public/javascripts/drag_and_drop.js
+++ b/public/javascripts/drag_and_drop.js
@@ -46,14 +46,19 @@ const dragAndDropSetup = {
         // This function MUST be defined to enable dropping of items on the tree.
         // data.hitMode is 'before', 'after', or 'over'.
 
+        const nodeToMove = data.otherNode;
+        nodeToMove.setSelected(true);
+
+        const selectedNodes = noteTree.getSelectedNodes();
+
         if (data.hitMode === "before") {
-            treeChanges.moveBeforeNode(data.otherNode, node);
+            treeChanges.moveBeforeNode(selectedNodes, node);
         }
         else if (data.hitMode === "after") {
-            treeChanges.moveAfterNode(data.otherNode, node);
+            treeChanges.moveAfterNode(selectedNodes, node);
         }
         else if (data.hitMode === "over") {
-            treeChanges.moveToNode(data.otherNode, node);
+            treeChanges.moveToNode(selectedNodes, node);
         }
         else {
             throw new Exception("Unknown hitMode=" + data.hitMode);
diff --git a/public/javascripts/note_tree.js b/public/javascripts/note_tree.js
index 00e72acff..d560c1df8 100644
--- a/public/javascripts/note_tree.js
+++ b/public/javascripts/note_tree.js
@@ -405,24 +405,32 @@ const noteTree = (function() {
                 const beforeNode = node.getPrevSibling();
 
                 if (beforeNode !== null) {
-                    treeChanges.moveBeforeNode(node, beforeNode);
+                    treeChanges.moveBeforeNode([node], beforeNode);
                 }
+
+                return false;
             },
             "ctrl+down": node => {
                 let afterNode = node.getNextSibling();
                 if (afterNode !== null) {
-                    treeChanges.moveAfterNode(node, afterNode);
+                    treeChanges.moveAfterNode([node], afterNode);
                 }
+
+                return false;
             },
             "ctrl+left": node => {
                 treeChanges.moveNodeUpInHierarchy(node);
+
+                return false;
             },
             "ctrl+right": node => {
                 let toNode = node.getPrevSibling();
 
                 if (toNode !== null) {
-                    treeChanges.moveToNode(node, toNode);
+                    treeChanges.moveToNode([node], toNode);
                 }
+
+                return false;
             },
             "shift+up": node => {
                 node.navigate($.ui.keyCode.UP, true).then(() => {
@@ -434,6 +442,8 @@ const noteTree = (function() {
 
                     currentNode.setSelected(true);
                 });
+
+                return false;
             },
             "shift+down": node => {
                 node.navigate($.ui.keyCode.DOWN, true).then(() => {
@@ -445,6 +455,8 @@ const noteTree = (function() {
 
                     currentNode.setSelected(true);
                 });
+
+                return false;
             },
             "f2": node => {
                 editTreePrefix.showDialog(node);
diff --git a/public/javascripts/tree_changes.js b/public/javascripts/tree_changes.js
index 0c382fc34..8c39c0709 100644
--- a/public/javascripts/tree_changes.js
+++ b/public/javascripts/tree_changes.js
@@ -1,16 +1,20 @@
 "use strict";
 
 const treeChanges = (function() {
-    async function moveBeforeNode(node, beforeNode) {
-        await server.put('notes/' + node.data.note_tree_id + '/move-before/' + beforeNode.data.note_tree_id);
+    async function moveBeforeNode(nodesToMove, beforeNode) {
+        for (const nodeToMove of nodesToMove) {
+            await server.put('notes/' + nodeToMove.data.note_tree_id + '/move-before/' + beforeNode.data.note_tree_id);
 
-        changeNode(node, node => node.moveTo(beforeNode, 'before'));
+            changeNode(nodeToMove, node => node.moveTo(beforeNode, 'before'));
+        }
     }
 
-    async function moveAfterNode(node, afterNode) {
-        await server.put('notes/' + node.data.note_tree_id + '/move-after/' + afterNode.data.note_tree_id);
+    async function moveAfterNode(nodesToMove, afterNode) {
+        for (const nodeToMove of nodesToMove) {
+            await server.put('notes/' + nodeToMove.data.note_tree_id + '/move-after/' + afterNode.data.note_tree_id);
 
-        changeNode(node, node => node.moveTo(afterNode, 'after'));
+            changeNode(nodeToMove, node => node.moveTo(afterNode, 'after'));
+        }
     }
 
     // beware that first arg is noteId and second is noteTreeId!
@@ -25,19 +29,21 @@ const treeChanges = (function() {
         await noteTree.reload();
     }
 
-    async function moveToNode(node, toNode) {
-        await server.put('notes/' + node.data.note_tree_id + '/move-to/' + toNode.data.note_id);
+    async function moveToNode(nodesToMove, toNode) {
+        for (const nodeToMove of nodesToMove) {
+            await server.put('notes/' + nodeToMove.data.note_tree_id + '/move-to/' + toNode.data.note_id);
 
-        changeNode(node, node => {
-            // first expand which will force lazy load and only then move the node
-            // if this is not expanded before moving, then lazy load won't happen because it already contains node
-            toNode.setExpanded(true);
+            changeNode(nodeToMove, node => {
+                // first expand which will force lazy load and only then move the node
+                // if this is not expanded before moving, then lazy load won't happen because it already contains node
+                toNode.setExpanded(true);
 
-            node.moveTo(toNode);
+                node.moveTo(toNode);
 
-            toNode.folder = true;
-            toNode.renderTitle();
-        });
+                toNode.folder = true;
+                toNode.renderTitle();
+            });
+        }
     }
 
     async function cloneNoteTo(childNoteId, parentNoteId, prefix) {