mouseDown(id, event) {
        let self = this
        if (this.reorder) {
            this.last.move = {
                x: event.screenX,
                y: event.screenY,
                divX: 0,
                divY: 0,
                reorder: true,
                moved: false
            }
            // display empty record and ghost record
            let mv = this.last.move
            let body = query(this.box).find('.w2ui-sidebar-body')
            if (!mv.ghost) {
                let node = query(this.box).find(`#node_${w2utils.escapeId(id)}`)
                mv.offsetY = event.offsetY
                mv.target = id
                mv.pos = { top: node.get(0).offsetTop - 1, left: node.get(0).offsetLeft }
                // ghost content
                let clone = query(node.find('.w2ui-node-data').get(0).cloneNode(true))
                mv.node = node
                mv.nodeSub = node.next()
                body.append('<div id="sidebar_'+ this.name + '_ghost" class="w2ui-node w2ui-ghost"></div>')
                query(this.box).find('#sidebar_'+ this.name + '_ghost').append(clone)
                mv.ghost = query(this.box).find('#sidebar_'+ this.name + '_ghost')
                mv.ghost.css({ display: 'none' })
                mv.restore = () => {
                    mv.resetReorder()
                    this.refresh()
                }
                mv.resetReorder = () => {
                    this.last.move = null
                    query(this.box).find(`#sidebar_${this.name}_ghost`).remove()
                    query(document).off(`.w2ui-${this.name}-reorder`)
                }
            }
            // add mouse move and stop events
            query(document)
                .on(`mousemove.w2ui-${this.name}-reorder`, _mouseMove)
                .on(`mouseup.w2ui-${this.name}-reorder`, _mouseStop)
        }
        function _mouseMove(event) {
            if (!event.target.tagName) {
                // element has no tagName - most likely the target is the #document itself
                // this can happen is you click+drag and move the mouse out of the DOM area,
                // e.g. into the browser's toolbar area
                return
            }
            let mv = self.last.move
            mv.divX = (event.screenX - mv.x)
            mv.divY = (event.screenY - mv.y)
            if (Math.abs(mv.divX) <= 1 && Math.abs(mv.divY) <= 1) return // only if moved more then 1px
            if (self.reorder == true && mv.reorder && !mv.moved) {
                let edata = self.trigger('dragStart', { target: mv.target, moved: true, node: self.get(mv.target), mv, originalEvent: event })
                if (edata.isCancelled === true) {
                    mv.restore()
                    return
                }
                let rect = mv.node.get(0).getBoundingClientRect()
                mv.moved = true
                mv.node.html('')
                    .removeAttr('id', 'data-id')
                    .addClass('w2ui-reorder-empty')
                    .css({ height: rect.height + 'px' })
                // if there are children
                if (mv.node.next().css('display') !== 'none') {
                    let rect = mv.node.next().get(0).getBoundingClientRect()
                    mv.node.next()
                        .html('<div class="w2ui-reorder-empty-sub"></div>')
                        .css({ height: rect.height + 'px' })
                }
                mv.ghost.css({ display: 'block' })
                // event after
                edata.finish()
            }
            // move ghost mode
            mv.ghost.css({
                top: (mv.pos.top + mv.divY) + 'px',
                left: 0
            })
            let over = query(event.target).closest('.w2ui-node, .w2ui-node-group')
            let id = over.attr('data-id')
            // append to the end
            if (query(event.target).hasClass('w2ui-sidebar-body') && event.layerY > 5 && !mv.append) {
                let edata = self.trigger('dragOver', { target: mv.target, append: true, mv, originalEvent: event })
                if (edata.isCancelled === true) {
                    return
                }
                mv.ghost.before(mv.node)
                mv.ghost.before(mv.nodeSub)
                mv.append = true
                mv.moveBefore = null
                // event after
                edata.finish()
            } else if (id != null && id != mv.moveBefore) {
                mv.append = false
                mv.moveBefore = id
                // reorder nodes
                let edata = self.trigger('dragOver', { target: mv.target, moveBefore: id, mv, originalEvent: event })
                if (edata.isCancelled === true) {
                    return
                }
                let el = query(self.box).find(`#node_${w2utils.escapeId(id)}`)
                el.before(mv.node)
                el.before(mv.nodeSub)
                // event after
                edata.finish()
            }
        }
        function _mouseStop(event) {
            let mv = self.last.move
            mv.resetReorder()
            if (mv.moved) {
                if (((mv.moveBefore != null && mv.target != mv.moveBefore) || mv.append)) {
                    let edata = self.trigger('reorder', { target: mv.target, moveBefore: mv.moveBefore, append: mv.append, originalEvent: event })
                    if (edata.isCancelled === true) {
                        self.refresh()
                        return
                    }
                    // remove
                    let target = self.get(mv.target)
                    let targetInd = target.parent.nodes.indexOf(target)
                    let cut = target.parent.nodes.splice(targetInd, 1)
                    // insert
                    if (mv.append) {
                        self.nodes.push(...cut)
                        cut.forEach(nd => nd.parent = self)
                    } else {
                        let before = self.get(mv.moveBefore)
                        let beforeInd = before.parent.nodes.indexOf(before)
                        cut.forEach(nd => nd.parent = before.parent)
                        before.parent.nodes.splice(beforeInd, 0, ...cut)
                    }
                    // refresh
                    self.refresh()
                    // event after
                    edata.finish()
                } else {
                    self.refresh()
                }
            }
        }
    }
This is needed for not reorder