RubyGems - iqvoc - Versions diffs - 4.12.0 → 4.13.2 - Mend

iqvoc 4.12.0 → 4.13.2

Files changed (855) hide show

data/vendor/assets/bower_components/jqtree/src/drag_and_drop_handler.coffee DELETED Viewed

@@ -1,466 +0,0 @@
-node_module = require './node'
-Position = node_module.Position
-class DragAndDropHandler
-    constructor: (tree_widget) ->
-        @tree_widget = tree_widget
-        @hovered_area = null
-        @$ghost = null
-        @hit_areas = []
-        @is_dragging = false
-        @current_item = null
-    mouseCapture: (position_info) ->
-        $element = $(position_info.target)
-        if not @mustCaptureElement($element)
-            return null
-        if @tree_widget.options.onIsMoveHandle and not @tree_widget.options.onIsMoveHandle($element)
-            return null
-        node_element = @tree_widget._getNodeElement($element)
-        if node_element and @tree_widget.options.onCanMove
-            if not @tree_widget.options.onCanMove(node_element.node)
-                node_element = null
-        @current_item = node_element
-        return (@current_item != null)
-    mouseStart: (position_info) ->
-        @refresh()
-        offset = $(position_info.target).offset()
-        @drag_element = new DragElement(
-            @current_item.node
-            position_info.page_x - offset.left,
-            position_info.page_y - offset.top,
-            @tree_widget.element
-        )
-        @is_dragging = true
-        @current_item.$element.addClass('jqtree-moving')
-        return true
-    mouseDrag: (position_info) ->
-        @drag_element.move(position_info.page_x, position_info.page_y)
-        area = @findHoveredArea(position_info.page_x, position_info.page_y)
-        can_move_to = @canMoveToArea(area)
-        if can_move_to and area
-            if !area.node.isFolder()
-                @stopOpenFolderTimer();
-            if @hovered_area != area
-                @hovered_area = area
-                # If this is a closed folder, start timer to open it
-                if @mustOpenFolderTimer(area)
-                    @startOpenFolderTimer(area.node)
-                else
-                    @stopOpenFolderTimer()
-                @updateDropHint()
-        else
-            @removeHover()
-            @removeDropHint()
-            @stopOpenFolderTimer()
-        return true
-    mustCaptureElement: ($element) ->
-        return not $element.is('input,select')
-    canMoveToArea: (area) ->
-        if not area
-            return false
-        else if @tree_widget.options.onCanMoveTo
-            position_name = Position.getName(area.position)
-            return @tree_widget.options.onCanMoveTo(@current_item.node, area.node, position_name)
-        else
-            return true
-    mouseStop: (position_info) ->
-        @moveItem(position_info)
-        @clear()
-        @removeHover()
-        @removeDropHint()
-        @removeHitAreas()
-        if @current_item
-            @current_item.$element.removeClass('jqtree-moving')
-            @current_item = null
-        @is_dragging = false
-        return false
-    refresh: ->
-        @removeHitAreas()
-        if @current_item
-            @generateHitAreas()
-            @current_item = @tree_widget._getNodeElementForNode(@current_item.node)
-            if @is_dragging
-                @current_item.$element.addClass('jqtree-moving')
-    removeHitAreas: ->
-        @hit_areas = []
-    clear: ->
-        @drag_element.remove()
-        @drag_element = null
-    removeDropHint: ->
-        if @previous_ghost
-            @previous_ghost.remove()
-    removeHover: ->
-        @hovered_area = null
-    generateHitAreas: ->
-        hit_areas_generator = new HitAreasGenerator(
-            @tree_widget.tree,
-            @current_item.node,
-            @getTreeDimensions().bottom
-        )
-        @hit_areas = hit_areas_generator.generate()
-    findHoveredArea: (x, y) ->
-        dimensions = @getTreeDimensions()
-        if (
-            x < dimensions.left or
-            y < dimensions.top or
-            x > dimensions.right or
-            y > dimensions.bottom
-        )
-            return null
-        low = 0
-        high = @hit_areas.length
-        while (low < high)
-            mid = (low + high) >> 1
-            area = @hit_areas[mid]
-            if y < area.top
-                high = mid
-            else if y > area.bottom
-                low = mid + 1
-            else
-                return area
-        return null
-    mustOpenFolderTimer: (area) ->
-        node = area.node
-        return (
-            node.isFolder() and
-            not node.is_open and
-            area.position == Position.INSIDE
-        )
-    updateDropHint: ->
-        if not @hovered_area
-            return
-        # remove previous drop hint
-        @removeDropHint()
-        # add new drop hint
-        node_element = @tree_widget._getNodeElementForNode(@hovered_area.node)
-        @previous_ghost = node_element.addDropHint(@hovered_area.position)
-    startOpenFolderTimer: (folder) ->
-        openFolder = =>
-            @tree_widget._openNode(
-                folder,
-                @tree_widget.options.slide,
-                =>
-                    @refresh()
-                    @updateDropHint()
-            )
-        @stopOpenFolderTimer()
-        @open_folder_timer = setTimeout(openFolder, @tree_widget.options.openFolderDelay)
-    stopOpenFolderTimer: ->
-        if @open_folder_timer
-            clearTimeout(@open_folder_timer)
-            @open_folder_timer = null
-    moveItem: (position_info) ->
-        if (
-            @hovered_area and
-            @hovered_area.position != Position.NONE and
-            @canMoveToArea(@hovered_area)
-        )
-            moved_node = @current_item.node
-            target_node = @hovered_area.node
-            position = @hovered_area.position
-            previous_parent = moved_node.parent
-            if position == Position.INSIDE
-                @hovered_area.node.is_open = true
-            doMove = =>
-                @tree_widget.tree.moveNode(moved_node, target_node, position)
-                @tree_widget.element.empty()
-                @tree_widget._refreshElements()
-            event = @tree_widget._triggerEvent(
-                'tree.move',
-                move_info:
-                    moved_node: moved_node
-                    target_node: target_node
-                    position: Position.getName(position)
-                    previous_parent: previous_parent
-                    do_move: doMove
-                    original_event: position_info.original_event
-            )
-            doMove() unless event.isDefaultPrevented()
-    getTreeDimensions: ->
-        # Return the dimensions of the tree. Add a margin to the bottom to allow
-        # for some to drag-and-drop the last element.
-        offset = @tree_widget.element.offset()
-        return {
-            left: offset.left,
-            top: offset.top,
-            right: offset.left + @tree_widget.element.width(),
-            bottom: offset.top + @tree_widget.element.height() + 16
-        }
-class VisibleNodeIterator
-    constructor: (tree) ->
-        @tree = tree
-    iterate: ->
-        is_first_node = true
-        _iterateNode = (node, next_node) =>
-            must_iterate_inside = (
-                (node.is_open or not node.element) and node.hasChildren()
-            )
-            if node.element
-                $element = $(node.element)
-                if not $element.is(':visible')
-                    return
-                if is_first_node
-                    @handleFirstNode(node, $element)
-                    is_first_node = false
-                if not node.hasChildren()
-                    @handleNode(node, next_node, $element)
-                else if node.is_open
-                    if not @handleOpenFolder(node, $element)
-                        must_iterate_inside = false
-                else
-                    @handleClosedFolder(node, next_node, $element)
-            if must_iterate_inside
-                children_length = node.children.length
-                for child, i in node.children
-                    if i == (children_length - 1)
-                        _iterateNode(node.children[i], null)
-                    else
-                        _iterateNode(node.children[i], node.children[i+1])
-                if node.is_open
-                    @handleAfterOpenFolder(node, next_node, $element)
-        _iterateNode(@tree, null)
-    handleNode: (node, next_node, $element) ->
-        # override
-    handleOpenFolder: (node, $element) ->
-        # override
-        # return
-        #   - true: continue iterating
-        #   - false: stop iterating
-    handleClosedFolder: (node, next_node, $element) ->
-        # override
-    handleAfterOpenFolder: (node, next_node, $element) ->
-        # override
-    handleFirstNode: (node, $element) ->
-        # override
-class HitAreasGenerator extends VisibleNodeIterator
-    constructor: (tree, current_node, tree_bottom) ->
-        super(tree)
-        @current_node = current_node
-        @tree_bottom = tree_bottom
-    generate: ->
-        @positions = []
-        @last_top = 0
-        @iterate()
-        return @generateHitAreas(@positions)
-    getTop: ($element) ->
-        return $element.offset().top
-    addPosition: (node, position, top) ->
-        area = {
-            top: top
-            node: node
-            position: position
-        }
-        @positions.push(area)
-        @last_top = top
-    handleNode: (node, next_node, $element) ->
-        top = @getTop($element)
-        if node == @current_node
-            # Cannot move inside current item
-            @addPosition(node, Position.NONE, top)
-        else
-            @addPosition(node, Position.INSIDE, top)
-        if (
-            next_node == @current_node or
-            node == @current_node
-        )
-            # Cannot move before or after current item
-            @addPosition(node, Position.NONE, top)
-        else
-            @addPosition(node, Position.AFTER, top)
-    handleOpenFolder: (node, $element) ->
-        if node == @current_node
-            # Cannot move inside current item
-            # Stop iterating
-            return false
-        # Cannot move before current item
-        if node.children[0] != @current_node
-            @addPosition(node, Position.INSIDE, @getTop($element))
-        # Continue iterating
-        return true
-    handleClosedFolder: (node, next_node, $element) ->
-        top = @getTop($element)
-        if node == @current_node
-            # Cannot move after current item
-            @addPosition(node, Position.NONE, top)
-        else
-            @addPosition(node, Position.INSIDE, top)
-            # Cannot move before current item
-            if next_node != @current_node
-                @addPosition(node, Position.AFTER, top)
-    handleFirstNode: (node, $element) ->
-        if node != @current_node
-            @addPosition(node, Position.BEFORE, @getTop($(node.element)))
-    handleAfterOpenFolder: (node, next_node, $element) ->
-        if (
-            node == @current_node.node or
-            next_node == @current_node.node
-        )
-            # Cannot move before or after current item
-            @addPosition(node, Position.NONE, @last_top)
-        else
-            @addPosition(node, Position.AFTER, @last_top)
-    generateHitAreas: (positions) ->
-        previous_top = -1
-        group = []
-        hit_areas = []
-        for position in positions
-            if position.top != previous_top and group.length
-                if group.length
-                    @generateHitAreasForGroup(
-                        hit_areas,
-                        group,
-                        previous_top,
-                        position.top
-                    )
-                previous_top = position.top
-                group = []
-            group.push(position)
-        @generateHitAreasForGroup(
-            hit_areas,
-            group,
-            previous_top,
-            @tree_bottom
-        )
-        return hit_areas
-    generateHitAreasForGroup: (hit_areas, positions_in_group, top, bottom) ->
-        # limit positions in group
-        position_count = Math.min(positions_in_group.length, 4)
-        area_height = Math.round((bottom - top) / position_count)
-        area_top = top
-        i = 0
-        while (i < position_count)
-            position = positions_in_group[i]
-            hit_areas.push(
-                top: area_top,
-                bottom: area_top + area_height,
-                node: position.node,
-                position: position.position
-            )
-            area_top += area_height
-            i += 1
-        return null
-class DragElement
-    constructor: (node, offset_x, offset_y, $tree) ->
-        @offset_x = offset_x
-        @offset_y = offset_y
-        @$element = $("<span class=\"jqtree-title jqtree-dragging\">#{ node.name }</span>")
-        @$element.css("position", "absolute")
-        $tree.append(@$element)
-    move: (page_x, page_y) ->
-        @$element.offset(
-            left: page_x - @offset_x,
-            top: page_y - @offset_y
-        )
-    remove: ->
-        @$element.remove()
-module.exports = DragAndDropHandler

data/vendor/assets/bower_components/jqtree/src/elements_renderer.coffee DELETED Viewed

@@ -1,198 +0,0 @@
-node_element = require './node_element'
-NodeElement = node_element.NodeElement
-util = require './util'
-html_escape = util.html_escape
-class ElementsRenderer
-    constructor: (tree_widget) ->
-        @tree_widget = tree_widget
-        @opened_icon_element = @createButtonElement(tree_widget.options.openedIcon)
-        @closed_icon_element = @createButtonElement(tree_widget.options.closedIcon)
-    render: (from_node) ->
-        if from_node and from_node.parent
-            @renderFromNode(from_node)
-        else
-            @renderFromRoot()
-    renderFromRoot: ->
-        $element = @tree_widget.element
-        $element.empty()
-        @createDomElements($element[0], @tree_widget.tree.children, true, true)
-    renderFromNode: (node) ->
-        # remember current li
-        $previous_li = $(node.element)
-        # create element
-        parent_node_element = new NodeElement(node.parent, @tree_widget)
-        li = @createLi(node)
-        @attachNodeData(node, li)
-        # add element to dom
-        $previous_li.after(li)
-        # remove previous li
-        $previous_li.remove()
-        # create children
-        if node.children
-            @createDomElements(li, node.children, false, false)
-    createDomElements: (element, children, is_root_node, is_open) ->
-        ul = @createUl(is_root_node)
-        element.appendChild(ul)
-        for child in children
-            li = @createLi(child)
-            ul.appendChild(li)
-            @attachNodeData(child, li)
-            if child.hasChildren()
-                @createDomElements(li, child.children, false, child.is_open)
-        return null
-    attachNodeData: (node, li) ->
-        node.element = li
-        $(li).data('node', node)
-    createUl: (is_root_node) ->
-        if is_root_node
-            class_string = 'jqtree-tree'
-        else
-            class_string = ''
-        ul = document.createElement('ul')
-        ul.className = "jqtree_common #{ class_string }"
-        return ul
-    createLi: (node) ->
-        if node.isFolder()
-            li = @createFolderLi(node)
-        else
-            li = @createNodeLi(node)
-        if @tree_widget.options.onCreateLi
-            @tree_widget.options.onCreateLi(node, $(li))
-        return li
-    createFolderLi: (node) ->
-        button_classes = @getButtonClasses(node)
-        folder_classes = @getFolderClasses(node)
-        escaped_name = @escapeIfNecessary(node.name)
-        if node.is_open
-            icon_element = @opened_icon_element
-        else
-            icon_element = @closed_icon_element
-        # li
-        li = document.createElement('li')
-        li.className = "jqtree_common #{ folder_classes }"
-        # div
-        div = document.createElement('div')
-        div.className = "jqtree-element jqtree_common"
-        li.appendChild(div)
-        # button link
-        button_link = document.createElement('a')
-        button_link.className = "jqtree_common #{ button_classes }"
-        button_link.appendChild(
-            icon_element.cloneNode(false)
-        )
-        div.appendChild(button_link)
-        # title span
-        title_span = document.createElement('span')
-        title_span.className = "jqtree_common jqtree-title jqtree-title-folder"
-        div.appendChild(title_span)
-        title_span.innerHTML = escaped_name
-        return li
-    createNodeLi: (node) ->
-        li_classes = ['jqtree_common']
-        if @tree_widget.select_node_handler and @tree_widget.select_node_handler.isNodeSelected(node)
-            li_classes.push('jqtree-selected')
-        class_string = li_classes.join(' ')
-        escaped_name = @escapeIfNecessary(node.name)
-        # li
-        li = document.createElement('li')
-        li.className = class_string
-        # div
-        div = document.createElement('div')
-        div.className = "jqtree-element jqtree_common"
-        li.appendChild(div)
-        # title span
-        title_span = document.createElement('span')
-        title_span.className = "jqtree-title jqtree_common"
-        title_span.innerHTML = escaped_name
-        div.appendChild(title_span)
-        return li
-    getButtonClasses: (node) ->
-        classes = ['jqtree-toggler']
-        if not node.is_open
-            classes.push('jqtree-closed')
-        return classes.join(' ')
-    getFolderClasses: (node) ->
-        classes = ['jqtree-folder']
-        if not node.is_open
-            classes.push('jqtree-closed')
-        if @tree_widget.select_node_handler and @tree_widget.select_node_handler.isNodeSelected(node)
-            classes.push('jqtree-selected')
-        if node.is_loading
-            classes.push('jqtree-loading')
-        return classes.join(' ')
-    escapeIfNecessary: (value) ->
-        if @tree_widget.options.autoEscape
-            return html_escape(value)
-        else
-            return value
-    createButtonElement: (value) ->
-        if typeof value == 'string'
-            # convert value to html
-            div = document.createElement('div')
-            div.innerHTML = value
-            return document.createTextNode(div.innerHTML)
-        else
-            return $(value)[0]
-module.exports = ElementsRenderer