Adds the dropped *component* into the model. 
        :meth:`Re-implemented<sparkle.gui.abstract_drag_view.AbstractDragView.dropped>`
519828
def dropped(self, component, event):
        
        if isinstance(component, AbstractStimulusComponent):
            row, col = self.splitAt(event.pos())
            index = self.model().createIndex(row, col, component)
            
            self.model().insertComponent(index, component)

            if isinstance(event.source(), DragLabel):
                if component.__class__.__name__ in self._componentDefaults:
                    component.loadState(self._componentDefaults[component.__class__.__name__])
                self.edit(index)

            self._viewIsDirty = True
            self.viewport().update()
677206
def dropEvent( self, event ):
        
        tags = nativestring(event.mimeData().text())
        
        # handle an internal move
        if event.source() == self:
            curr_item = self.selectedItems()[0]
            create_item = self.createItem()
            
            # don't allow moving of the creation item
            if curr_item == create_item:
                return
            
            targ_item = self.itemAt(event.pos())
            if not targ_item:
                targ_item = create_item
            
            curr_idx  = self.row(curr_item)
            targ_idx  = self.row(targ_item)
            if ( targ_idx == self.count() - 1 ):
                targ_idx -= 1
            
            # don't bother moving the same item
            if ( curr_idx == targ_idx ):
                return
            
            self.takeItem(self.row(curr_item))
            self.insertItem(targ_idx, curr_item)
            self.setCurrentItem(curr_item)
        
        elif ( tags ):
            for tag in tags.split(','):
                tag = tag.strip()
                if ( self.isTagValid(tag) ):
                    self.addTag(tag)
            
        else:
            event.accept()
535895
public void drop() {

        // notifying controller, if false is returned, dropping will be canceled
        if (!m_controller.onBeforeDrop(m_draggable, m_currentTarget, this)) {
            cancel();
            return;
        }
        animateDrop(m_draggable, m_currentTarget, m_controller);
    }
248090
private void addComponent(final WComponent component) {
		collapsibleList.add(component);
		MemoryUtil.checkSize(collapsibleList.size(), this.getClass().getSimpleName());
	}
499783
function updateDragger(isDraggable) {
        if (isDraggable) {
            if (!dragger) {
                $el.addClass(CSS_CLASS_DRAGGABLE);
                dragger = scope.createComponent('dragger');
                dragger.init(config.$viewport);
            }
        } else {
            if (dragger) {
                $el.removeClass(CSS_CLASS_DRAGGABLE);
                scope.destroyComponent(dragger);
                dragger = null;
            }
        }
    }
7731
function() {
    this._destroyDraggableColumns();
    if(util.DD) {
        var oColumn, elTh, elDragTarget;
        for(var i=0, len=this._oColumnSet.tree[0].length; i<len; i++) {
            oColumn = this._oColumnSet.tree[0][i];
            elTh = oColumn.getThEl();
            Dom.addClass(elTh, DT.CLASS_DRAGGABLE);
            elDragTarget = DT._initColumnDragTargetEl();
            oColumn._dd = new YAHOO.widget.ColumnDD(this, oColumn, elTh, elDragTarget);
        }
    }
    else {
        YAHOO.log("Could not find DragDrop for draggable Columns", "warn", this.toString());
    }
}
925312
private void recoverDraggablePanelState(Bundle savedInstanceState) {
    final DraggableState draggableState =
        (DraggableState) savedInstanceState.getSerializable(DRAGGABLE_PANEL_STATE);
    if (draggableState == null) {
      draggablePanel.setVisibility(View.GONE);
      return;
    }
    updateDraggablePanelStateDelayed(draggableState);
  }
1068021
def dragEnterEvent( self, event ):
        
        filt = self.dragDropFilter()
        if ( filt and filt(self, event) ):
            return
            
        super(XTableWidget, self).dragEnterEvent(event)
50543
def dragEnterEvent( self, event ):
        
        filt = self.dragDropFilter()
        if not filt:
            super(XTreeWidget, self).dragEnterEvent(event)
            return
            
        filt(self, event)
1219446
public void dragAndDropOn(QuickWidget widget, DropPosition dropPos) {
    /*
                         * FIXME: Handle MousePosition
                         */
    Point currentLocation = getCenterLocation();
    Point dropPoint = getDropPoint(widget, dropPos);

    List<ModifierPressed> alist = new ArrayList<ModifierPressed>();
    alist.add(ModifierPressed.NONE);

    getSystemInputManager().mouseDown(currentLocation, MouseButton.LEFT, alist);
    getSystemInputManager().mouseMove(dropPoint, MouseButton.LEFT, alist);
    getSystemInputManager().mouseUp(dropPoint, MouseButton.LEFT, alist);
  }
1292847
function (sortableElement) {
        var opts = addData(sortableElement, 'opts');
        var items = _filter(sortableElement.children, opts.items);
        var handles = _getHandles(items, opts.handle);
        addAttribute(sortableElement, 'aria-dropeffect', 'move');
        addData(sortableElement, '_disabled', 'false');
        addAttribute(handles, 'draggable', 'true');
        // @todo: remove this fix
        // IE FIX for ghost
        // can be disabled as it has the side effect that other events
        // (e.g. click) will be ignored
        if (opts.disableIEFix === false) {
            var spanEl = (document || window.document).createElement('span');
            if (typeof spanEl.dragDrop === 'function') {
                addEventListener(handles, 'mousedown', function () {
                    if (items.indexOf(this) !== -1) {
                        this.dragDrop();
                    }
                    else {
                        var parent = this.parentElement;
                        while (items.indexOf(parent) === -1) {
                            parent = parent.parentElement;
                        }
                        parent.dragDrop();
                    }
                });
            }
        }
    }
846742
public void registerComponent(java.awt.Component c)
    {
        unregisterComponent(c);
        if (recognizerAbstractClass == null)
        {
            hmDragGestureRecognizers.put(c,  
                dragSource.createDefaultDragGestureRecognizer(c, 
                    dragWorker.getAcceptableActions(c), dgListener)
                                        );
        }
        else
        {
            hmDragGestureRecognizers.put(c, 
                dragSource.createDragGestureRecognizer (recognizerAbstractClass,
                    c, dragWorker.getAcceptableActions(c), dgListener)
                                        );
        }
    }
125435
def append(self, component, default=False):
        
        if not isinstance(component, Composable):
            if callable(component):
                component = Composable(component)
            else:
                raise ValueError("component '%s' is not Optionable nor Composable and even not callable" % component)
        if component.name in self._components:
            raise ValueError("We already have a component with the name '%s'" % component.name)
        self._components[component.name] = component
        if default:
            if self.multiple:
                self.defaults = self.defaults + [component.name]
            else:
                self.defaults = component.name
        self._logger.info("<block: %s> add component: %s:%s" % (self.name, component.name, component))
545642
def child_moved(self, child):
        
        super(UiKitView, self).child_moved(child)
        #: Remove and re-add in correct spot
        #: TODO: Should use exchangeSubviewAtIndex
        self.child_removed(child)
        self.child_added(child)
1223670
def drop(self):
        
        if self._is_dropped is False:
            self.table.drop(self.engine)
        self._is_dropped = True
1363056
function resetUpDragDrop() {
        // Add an index to the sortable to allow sorting of the
        // underlying data.
        const children = element.children();
        for (let i = 0; i < children.length; ++i) {
          angular.element(children[i]).data('idx', i);
        }

        const sortableElement = $(element);

        // the element is already sortable; reset it.
        if (sortableElement.data('ui-sortable')) {
          sortableElement.off('sortupdate');
          sortableElement.sortable('destroy');
        }

        const sortableOptions = {
          'axis': 'y',
          'classes': {
            'ui-sortable-helper': options['draggerClassName']
          }
        };

        // CSS class of the handle
        if (options['handleClassName']) {
          sortableOptions['handle'] = `.${options['handleClassName']}`;
        }

        // Placeholder for the item being dragged in the sortable list
        if (options['placeholderClassName']) {
          sortableOptions['placeholder'] = options['placeholderClassName'];
          sortableOptions['forcePlaceholderSize'] = true;
        }

        sortableElement.sortable(sortableOptions);

        // This event is triggered when the user stopped sorting and
        // the DOM position (i.e. order in the sortable list) has changed.
        sortableElement.on('sortupdate', (event, ui) => {
          const oldIndex = $(ui.item[0]).data('idx');
          const newIndex = ui.item.index();

          // Update (data)-index on dom element to its new position
          $(ui.item[0]).data('idx', newIndex);

          // Move dragged item to new position
          scope.$apply(() => {
            sortable.splice(newIndex, 0, sortable.splice(oldIndex, 1)[0]);
          });

          // Call the callback function if it exists.
          if (callbackFn instanceof Function) {
            callbackFn.apply(callbackCtx, [element, sortable]);
          }
        });
      }
1043437
def add(self, child):
        

        if isinstance(child, Component):
            self.add_child(child)
        else:
            raise ModelError('Unsupported child element')