')
256 | .addClass('dt-rowReorder-float-parent')
257 | .width(scrollWidth)
258 | .append(clone)
259 | .appendTo('body')
260 | .scrollLeft(scrollLeft);
261 |
262 | // Insert into the document to have it floating around
263 |
264 | this.dom.clone = clone;
265 | this.dom.cloneParent = cloneParent;
266 | this.s.domCloneOuterHeight = clone.outerHeight();
267 | },
268 |
269 | /**
270 | * Update the cloned item's position in the document
271 | *
272 | * @param {object} e Event giving the mouse's position
273 | * @private
274 | */
275 | _clonePosition: function (e) {
276 | var start = this.s.start;
277 | var topDiff = this._eventToPage(e, 'Y') - start.top;
278 | var leftDiff = this._eventToPage(e, 'X') - start.left;
279 | var snap = this.c.snapX;
280 | var left;
281 | var top = topDiff + start.offsetTop;
282 |
283 | if (snap === true) {
284 | left = start.offsetLeft;
285 | }
286 | else if (typeof snap === 'number') {
287 | left = start.offsetLeft + snap;
288 | }
289 | else {
290 | left = leftDiff + start.offsetLeft + this.dom.cloneParent.scrollLeft();
291 | }
292 |
293 | if (top < 0) {
294 | top = 0;
295 | }
296 | else if (top + this.s.domCloneOuterHeight > this.s.documentOuterHeight) {
297 | top = this.s.documentOuterHeight - this.s.domCloneOuterHeight;
298 | }
299 |
300 | this.dom.cloneParent.css({
301 | top: top,
302 | left: left
303 | });
304 | },
305 |
306 | /**
307 | * Emit an event on the DataTable for listeners
308 | *
309 | * @param {string} name Event name
310 | * @param {array} args Event arguments
311 | * @private
312 | */
313 | _emitEvent: function ( name, args )
314 | {
315 | var ret;
316 |
317 | this.s.dt.iterator( 'table', function ( ctx, i ) {
318 | var innerRet = $(ctx.nTable).triggerHandler( name+'.dt', args );
319 |
320 | if (innerRet !== undefined) {
321 | ret = innerRet;
322 | }
323 | } );
324 |
325 | return ret;
326 | },
327 |
328 | /**
329 | * Get pageX/Y position from an event, regardless of if it is a mouse or
330 | * touch event.
331 | *
332 | * @param {object} e Event
333 | * @param {string} pos X or Y (must be a capital)
334 | * @private
335 | */
336 | _eventToPage: function (e, pos) {
337 | if (e.type.indexOf('touch') !== -1) {
338 | return e.originalEvent.touches[0]['page' + pos];
339 | }
340 |
341 | return e['page' + pos];
342 | },
343 |
344 | /**
345 | * Mouse down event handler. Read initial positions and add event handlers
346 | * for the move.
347 | *
348 | * @param {object} e Mouse event
349 | * @param {jQuery} target TR element that is to be moved
350 | * @private
351 | */
352 | _mouseDown: function (e, target) {
353 | var that = this;
354 | var dt = this.s.dt;
355 | var start = this.s.start;
356 | var cancelable = this.c.cancelable;
357 |
358 | var offset = target.offset();
359 | start.top = this._eventToPage(e, 'Y');
360 | start.left = this._eventToPage(e, 'X');
361 | start.offsetTop = offset.top;
362 | start.offsetLeft = offset.left;
363 | start.nodes = $.unique(dt.rows({ page: 'current' }).nodes().toArray());
364 |
365 | this._cachePositions();
366 | this._clone(target);
367 | this._clonePosition(e);
368 |
369 | var bodyY = this._eventToPage(e, 'Y') - this.s.bodyTop;
370 | start.rowIndex = this._calcRowIndexByPos(bodyY);
371 |
372 | this.dom.target = target;
373 | target.addClass('dt-rowReorder-moving');
374 |
375 | $(document)
376 | .on('mouseup.rowReorder touchend.rowReorder', function (e) {
377 | that._mouseUp(e);
378 | })
379 | .on('mousemove.rowReorder touchmove.rowReorder', function (e) {
380 | that._mouseMove(e);
381 | });
382 |
383 | // Check if window is x-scrolling - if not, disable it for the duration
384 | // of the drag
385 | if ($(window).width() === $(document).width()) {
386 | $(document.body).addClass('dt-rowReorder-noOverflow');
387 | }
388 |
389 | // Cache scrolling information so mouse move doesn't need to read.
390 | // This assumes that the window and DT scroller will not change size
391 | // during an row drag, which I think is a fair assumption
392 | var scrollWrapper = this.dom.dtScroll;
393 | this.s.scroll = {
394 | windowHeight: $(window).height(),
395 | windowWidth: $(window).width(),
396 | dtTop: scrollWrapper.length ? scrollWrapper.offset().top : null,
397 | dtLeft: scrollWrapper.length ? scrollWrapper.offset().left : null,
398 | dtHeight: scrollWrapper.length ? scrollWrapper.outerHeight() : null,
399 | dtWidth: scrollWrapper.length ? scrollWrapper.outerWidth() : null
400 | };
401 |
402 | // Add keyup handler if dragging is cancelable
403 | if (cancelable) {
404 | $(document).on('keyup', this._keyup);
405 | }
406 | },
407 |
408 | /**
409 | * Mouse move event handler - move the cloned row and shuffle the table's
410 | * rows if required.
411 | *
412 | * @param {object} e Mouse event
413 | * @private
414 | */
415 | _mouseMove: function (e) {
416 | this._clonePosition(e);
417 |
418 | var start = this.s.start;
419 | var cancelable = this.c.cancelable;
420 |
421 | if (cancelable) {
422 | var bodyArea = this.s.bodyArea;
423 | var cloneArea = this._calcCloneParentArea();
424 |
425 | this.s.dropAllowed = this._rectanglesIntersect(bodyArea, cloneArea);
426 | $(this.dom.cloneParent).toggleClass('drop-not-allowed', !this.s.dropAllowed);
427 | }
428 |
429 | // Transform the mouse position into a position in the table's body
430 | var bodyY = this._eventToPage(e, 'Y') - this.s.bodyTop;
431 | var middles = this.s.middles;
432 | var insertPoint = null;
433 |
434 | // Determine where the row should be inserted based on the mouse
435 | // position
436 | for (var i = 0, ien = middles.length; i < ien; i++) {
437 | if (bodyY < middles[i]) {
438 | insertPoint = i;
439 | break;
440 | }
441 | }
442 |
443 | if (insertPoint === null) {
444 | insertPoint = middles.length;
445 | }
446 |
447 | if (cancelable) {
448 | if (!this.s.dropAllowed) {
449 | // Move the row back to its original position becasuse the drop is not allowed
450 | insertPoint =
451 | start.rowIndex > this.s.lastInsert ? start.rowIndex + 1 : start.rowIndex;
452 | }
453 |
454 | this.dom.target.toggleClass('dt-rowReorder-moving', this.s.dropAllowed);
455 | }
456 |
457 | this._moveTargetIntoPosition(insertPoint);
458 |
459 | this._shiftScroll(e);
460 | },
461 |
462 | /**
463 | * Mouse up event handler - release the event handlers and perform the
464 | * table updates
465 | *
466 | * @param {object} e Mouse event
467 | * @private
468 | */
469 | _mouseUp: function (e) {
470 | var that = this;
471 | var dt = this.s.dt;
472 | var i, ien;
473 | var dataSrc = this.c.dataSrc;
474 | var dropAllowed = this.s.dropAllowed;
475 |
476 | if (!dropAllowed) {
477 | that._cancel();
478 | return;
479 | }
480 |
481 | // Calculate the difference
482 | var startNodes = this.s.start.nodes;
483 | var endNodes = $.unique(dt.rows({ page: 'current' }).nodes().toArray());
484 | var idDiff = {};
485 | var fullDiff = [];
486 | var diffNodes = [];
487 | var getDataFn = this.s.getDataFn;
488 | var setDataFn = this.s.setDataFn;
489 |
490 | for (i = 0, ien = startNodes.length; i < ien; i++) {
491 | if (startNodes[i] !== endNodes[i]) {
492 | var id = dt.row(endNodes[i]).id();
493 | var endRowData = dt.row(endNodes[i]).data();
494 | var startRowData = dt.row(startNodes[i]).data();
495 |
496 | if (id) {
497 | idDiff[id] = getDataFn(startRowData);
498 | }
499 |
500 | fullDiff.push({
501 | node: endNodes[i],
502 | oldData: getDataFn(endRowData),
503 | newData: getDataFn(startRowData),
504 | newPosition: i,
505 | oldPosition: $.inArray(endNodes[i], startNodes)
506 | });
507 |
508 | diffNodes.push(endNodes[i]);
509 | }
510 | }
511 |
512 | // Create event args
513 | var eventArgs = [
514 | fullDiff,
515 | {
516 | dataSrc: dataSrc,
517 | nodes: diffNodes,
518 | values: idDiff,
519 | triggerRow: dt.row(this.dom.target),
520 | originalEvent: e
521 | }
522 | ];
523 |
524 | // Emit event
525 | var eventResult = this._emitEvent( 'row-reorder', eventArgs );
526 |
527 | if (eventResult === false) {
528 | that._cancel();
529 | return;
530 | }
531 |
532 | // Remove cloned elements, handlers, etc
533 | this._cleanupDragging();
534 |
535 | var update = function () {
536 | if (that.c.update) {
537 | for (i = 0, ien = fullDiff.length; i < ien; i++) {
538 | var row = dt.row(fullDiff[i].node);
539 | var rowData = row.data();
540 |
541 | setDataFn(rowData, fullDiff[i].newData);
542 |
543 | // Invalidate the cell that has the same data source as the dataSrc
544 | dt.columns().every(function () {
545 | if (this.dataSrc() === dataSrc) {
546 | dt.cell(fullDiff[i].node, this.index()).invalidate('data');
547 | }
548 | });
549 | }
550 |
551 | // Trigger row reordered event
552 | that._emitEvent('row-reordered', eventArgs);
553 |
554 | dt.draw(false);
555 | }
556 | };
557 |
558 | // Editor interface
559 | if (this.c.editor) {
560 | // Disable user interaction while Editor is submitting
561 | this.c.enable = false;
562 |
563 | this.c.editor
564 | .edit(diffNodes, false, $.extend({ submit: 'changed' }, this.c.formOptions))
565 | .multiSet(dataSrc, idDiff)
566 | .one('preSubmitCancelled.rowReorder', function () {
567 | that.c.enable = true;
568 | that.c.editor.off('.rowReorder');
569 | dt.draw(false);
570 | })
571 | .one('submitUnsuccessful.rowReorder', function () {
572 | dt.draw(false);
573 | })
574 | .one('submitSuccess.rowReorder', function () {
575 | update();
576 | })
577 | .one('submitComplete', function () {
578 | that.c.enable = true;
579 | that.c.editor.off('.rowReorder');
580 | })
581 | .submit();
582 | }
583 | else {
584 | update();
585 | }
586 | },
587 |
588 | /**
589 | * Moves the current target into the given position within the table
590 | * and caches the new positions
591 | *
592 | * @param {integer} insertPoint Position
593 | * @private
594 | */
595 | _moveTargetIntoPosition: function (insertPoint) {
596 | var dt = this.s.dt;
597 |
598 | // Perform the DOM shuffle if it has changed from last time
599 | if (this.s.lastInsert === null || this.s.lastInsert !== insertPoint) {
600 | var nodes = $.unique(dt.rows({ page: 'current' }).nodes().toArray());
601 | var insertPlacement = '';
602 |
603 | if (insertPoint > this.s.lastInsert) {
604 | this.dom.target.insertAfter(nodes[insertPoint - 1]);
605 | insertPlacement = 'after';
606 | }
607 | else {
608 | this.dom.target.insertBefore(nodes[insertPoint]);
609 | insertPlacement = 'before';
610 | }
611 |
612 | this._cachePositions();
613 |
614 | this.s.lastInsert = insertPoint;
615 |
616 | this._emitEvent('row-reorder-changed', {
617 | insertPlacement,
618 | insertPoint,
619 | row: dt.row(this.dom.target)
620 | });
621 | }
622 | },
623 |
624 | /**
625 | * Removes the cloned elements, event handlers, scrolling intervals, etc
626 | *
627 | * @private
628 | */
629 | _cleanupDragging: function () {
630 | var cancelable = this.c.cancelable;
631 |
632 | this.dom.clone.remove();
633 | this.dom.cloneParent.remove();
634 | this.dom.clone = null;
635 | this.dom.cloneParent = null;
636 |
637 | this.dom.target.removeClass('dt-rowReorder-moving');
638 | //this.dom.target = null;
639 |
640 | $(document).off('.rowReorder');
641 | $(document.body).removeClass('dt-rowReorder-noOverflow');
642 |
643 | clearInterval(this.s.scrollInterval);
644 | this.s.scrollInterval = null;
645 |
646 | if (cancelable) {
647 | $(document).off('keyup', this._keyup);
648 | }
649 | },
650 |
651 | /**
652 | * Move the window and DataTables scrolling during a drag to scroll new
653 | * content into view.
654 | *
655 | * This matches the `_shiftScroll` method used in AutoFill, but only
656 | * horizontal scrolling is considered here.
657 | *
658 | * @param {object} e Mouse move event object
659 | * @private
660 | */
661 | _shiftScroll: function (e) {
662 | var that = this;
663 | var scroll = this.s.scroll;
664 | var runInterval = false;
665 | var scrollSpeed = 5;
666 | var buffer = 65;
667 | var windowY = e.pageY - document.body.scrollTop,
668 | windowVert,
669 | dtVert;
670 |
671 | // Window calculations - based on the mouse position in the window,
672 | // regardless of scrolling
673 | if (windowY < $(window).scrollTop() + buffer) {
674 | windowVert = scrollSpeed * -1;
675 | }
676 | else if (windowY > scroll.windowHeight + $(window).scrollTop() - buffer) {
677 | windowVert = scrollSpeed;
678 | }
679 |
680 | // DataTables scrolling calculations - based on the table's position in
681 | // the document and the mouse position on the page
682 | if (scroll.dtTop !== null && e.pageY < scroll.dtTop + buffer) {
683 | dtVert = scrollSpeed * -1;
684 | }
685 | else if (scroll.dtTop !== null && e.pageY > scroll.dtTop + scroll.dtHeight - buffer) {
686 | dtVert = scrollSpeed;
687 | }
688 |
689 | // This is where it gets interesting. We want to continue scrolling
690 | // without requiring a mouse move, so we need an interval to be
691 | // triggered. The interval should continue until it is no longer needed,
692 | // but it must also use the latest scroll commands (for example consider
693 | // that the mouse might move from scrolling up to scrolling left, all
694 | // with the same interval running. We use the `scroll` object to "pass"
695 | // this information to the interval. Can't use local variables as they
696 | // wouldn't be the ones that are used by an already existing interval!
697 | if (windowVert || dtVert) {
698 | scroll.windowVert = windowVert;
699 | scroll.dtVert = dtVert;
700 | runInterval = true;
701 | }
702 | else if (this.s.scrollInterval) {
703 | // Don't need to scroll - remove any existing timer
704 | clearInterval(this.s.scrollInterval);
705 | this.s.scrollInterval = null;
706 | }
707 |
708 | // If we need to run the interval to scroll and there is no existing
709 | // interval (if there is an existing one, it will continue to run)
710 | if (!this.s.scrollInterval && runInterval) {
711 | this.s.scrollInterval = setInterval(function () {
712 | // Don't need to worry about setting scroll <0 or beyond the
713 | // scroll bound as the browser will just reject that.
714 | if (scroll.windowVert) {
715 | var top = $(document).scrollTop();
716 | $(document).scrollTop(top + scroll.windowVert);
717 |
718 | if (top !== $(document).scrollTop()) {
719 | var move = parseFloat(that.dom.cloneParent.css('top'));
720 | that.dom.cloneParent.css('top', move + scroll.windowVert);
721 | }
722 | }
723 |
724 | // DataTables scrolling
725 | if (scroll.dtVert) {
726 | var scroller = that.dom.dtScroll[0];
727 |
728 | if (scroll.dtVert) {
729 | scroller.scrollTop += scroll.dtVert;
730 | }
731 | }
732 | }, 20);
733 | }
734 | },
735 |
736 | /**
737 | * Calculates the current area of the table body and returns it as a rectangle
738 | *
739 | * @private
740 | */
741 | _calcBodyArea: function (e) {
742 | var dt = this.s.dt;
743 | var offset = $(dt.table().body()).offset();
744 | var area = {
745 | left: offset.left,
746 | top: offset.top,
747 | right: offset.left + $(dt.table().body()).width(),
748 | bottom: offset.top + $(dt.table().body()).height()
749 | };
750 |
751 | return area;
752 | },
753 |
754 | /**
755 | * Calculates the current area of the cloned parent element and returns it as a rectangle
756 | *
757 | * @private
758 | */
759 | _calcCloneParentArea: function (e) {
760 | var offset = $(this.dom.cloneParent).offset();
761 | var area = {
762 | left: offset.left,
763 | top: offset.top,
764 | right: offset.left + $(this.dom.cloneParent).width(),
765 | bottom: offset.top + $(this.dom.cloneParent).height()
766 | };
767 |
768 | return area;
769 | },
770 |
771 | /**
772 | * Returns whether the given reactangles intersect or not
773 | *
774 | * @private
775 | */
776 | _rectanglesIntersect: function (a, b) {
777 | var noOverlap =
778 | a.left >= b.right || b.left >= a.right || a.top >= b.bottom || b.top >= a.bottom;
779 |
780 | return !noOverlap;
781 | },
782 |
783 | /**
784 | * Calculates the index of the row which lays under the given Y position or
785 | * returns -1 if no such row
786 | *
787 | * @param {integer} insertPoint Position
788 | * @private
789 | */
790 | _calcRowIndexByPos: function (bodyY) {
791 | // Determine where the row is located based on the mouse
792 | // position
793 |
794 | var dt = this.s.dt;
795 | var nodes = $.unique(dt.rows({ page: 'current' }).nodes().toArray());
796 | var rowIndex = -1;
797 | var headerHeight = $(dt.table().node()).find('thead').outerHeight();
798 |
799 | $.each(nodes, function (i, node) {
800 | var top = $(node).position().top - headerHeight;
801 | var bottom = top + $(node).outerHeight();
802 |
803 | if (bodyY >= top && bodyY <= bottom) {
804 | rowIndex = i;
805 | }
806 | });
807 |
808 | return rowIndex;
809 | },
810 |
811 | /**
812 | * Handles key up events and cancels the dragging if ESC key is pressed
813 | *
814 | * @param {object} e Mouse move event object
815 | * @private
816 | */
817 | _keyup: function (e) {
818 | var cancelable = this.c.cancelable;
819 |
820 | if (cancelable && e.which === 27) {
821 | // ESC key is up
822 | e.preventDefault();
823 | this._cancel();
824 | }
825 | },
826 |
827 | /**
828 | * Cancels the dragging, moves target back into its original position
829 | * and cleans up the dragging
830 | *
831 | * @param {object} e Mouse move event object
832 | * @private
833 | */
834 | _cancel: function () {
835 | var start = this.s.start;
836 | var insertPoint = start.rowIndex > this.s.lastInsert ? start.rowIndex + 1 : start.rowIndex;
837 |
838 | this._moveTargetIntoPosition(insertPoint);
839 |
840 | this._cleanupDragging();
841 |
842 | // Emit event
843 | this._emitEvent('row-reorder-canceled', [this.s.start.rowIndex]);
844 | }
845 | });
846 |
847 | /**
848 | * RowReorder default settings for initialisation
849 | *
850 | * @namespace
851 | * @name RowReorder.defaults
852 | * @static
853 | */
854 | RowReorder.defaults = {
855 | /**
856 | * Data point in the host row's data source object for where to get and set
857 | * the data to reorder. This will normally also be the sorting column.
858 | *
859 | * @type {Number}
860 | */
861 | dataSrc: 0,
862 |
863 | /**
864 | * Editor instance that will be used to perform the update
865 | *
866 | * @type {DataTable.Editor}
867 | */
868 | editor: null,
869 |
870 | /**
871 | * Enable / disable RowReorder's user interaction
872 | * @type {Boolean}
873 | */
874 | enable: true,
875 |
876 | /**
877 | * Form options to pass to Editor when submitting a change in the row order.
878 | * See the Editor `from-options` object for details of the options
879 | * available.
880 | * @type {Object}
881 | */
882 | formOptions: {},
883 |
884 | /**
885 | * Drag handle selector. This defines the element that when dragged will
886 | * reorder a row.
887 | *
888 | * @type {String}
889 | */
890 | selector: 'td:first-child',
891 |
892 | /**
893 | * Optionally lock the dragged row's x-position. This can be `true` to
894 | * fix the position match the host table's, `false` to allow free movement
895 | * of the row, or a number to define an offset from the host table.
896 | *
897 | * @type {Boolean|number}
898 | */
899 | snapX: false,
900 |
901 | /**
902 | * Update the table's data on drop
903 | *
904 | * @type {Boolean}
905 | */
906 | update: true,
907 |
908 | /**
909 | * Selector for children of the drag handle selector that mouseDown events
910 | * will be passed through to and drag will not activate
911 | *
912 | * @type {String}
913 | */
914 | excludedChildren: 'a',
915 |
916 | /**
917 | * Enable / disable the canceling of the drag & drop interaction
918 | *
919 | * @type {Boolean}
920 | */
921 | cancelable: false
922 | };
923 |
924 | /*
925 | * API
926 | */
927 | var Api = $.fn.dataTable.Api;
928 |
929 | // Doesn't do anything - work around for a bug in DT... Not documented
930 | Api.register('rowReorder()', function () {
931 | return this;
932 | });
933 |
934 | Api.register('rowReorder.enable()', function (toggle) {
935 | if (toggle === undefined) {
936 | toggle = true;
937 | }
938 |
939 | return this.iterator('table', function (ctx) {
940 | if (ctx.rowreorder) {
941 | ctx.rowreorder.c.enable = toggle;
942 | }
943 | });
944 | });
945 |
946 | Api.register('rowReorder.disable()', function () {
947 | return this.iterator('table', function (ctx) {
948 | if (ctx.rowreorder) {
949 | ctx.rowreorder.c.enable = false;
950 | }
951 | });
952 | });
953 |
954 | /**
955 | * Version information
956 | *
957 | * @name RowReorder.version
958 | * @static
959 | */
960 | RowReorder.version = '1.5.0';
961 |
962 | $.fn.dataTable.RowReorder = RowReorder;
963 | $.fn.DataTable.RowReorder = RowReorder;
964 |
965 | // Attach a listener to the document which listens for DataTables initialisation
966 | // events so we can automatically initialise
967 | $(document).on('init.dt.dtr', function (e, settings, json) {
968 | if (e.namespace !== 'dt') {
969 | return;
970 | }
971 |
972 | var init = settings.oInit.rowReorder;
973 | var defaults = DataTable.defaults.rowReorder;
974 |
975 | if (init || defaults) {
976 | var opts = $.extend({}, init, defaults);
977 |
978 | if (init !== false) {
979 | new RowReorder(settings, opts);
980 | }
981 | }
982 | });
983 |
--------------------------------------------------------------------------------
/js/rowReorder.bootstrap.js:
--------------------------------------------------------------------------------
1 | /*! Bootstrap 3 styling wrapper for RowReorder
2 | * © SpryMedia Ltd - datatables.net/license
3 | */
4 |
5 |
--------------------------------------------------------------------------------
/js/rowReorder.bootstrap4.js:
--------------------------------------------------------------------------------
1 | /*! Bootstrap 4 styling wrapper for RowReorder
2 | * © SpryMedia Ltd - datatables.net/license
3 | */
4 |
--------------------------------------------------------------------------------
/js/rowReorder.bootstrap5.js:
--------------------------------------------------------------------------------
1 | /*! Bootstrap 5 styling wrapper for RowReorder
2 | * © SpryMedia Ltd - datatables.net/license
3 | */
4 |
--------------------------------------------------------------------------------
/js/rowReorder.bulma.js:
--------------------------------------------------------------------------------
1 | /*! Bulma styling wrapper for RowReorder
2 | * © SpryMedia Ltd - datatables.net/license
3 | */
4 |
--------------------------------------------------------------------------------
/js/rowReorder.dataTables.js:
--------------------------------------------------------------------------------
1 | /*! DataTables styling wrapper for RowReorder
2 | * © SpryMedia Ltd - datatables.net/license
3 | */
4 |
--------------------------------------------------------------------------------
/js/rowReorder.foundation.js:
--------------------------------------------------------------------------------
1 | /*! Foundation styling wrapper for RowReorder
2 | * © SpryMedia Ltd - datatables.net/license
3 | */
4 |
--------------------------------------------------------------------------------
/js/rowReorder.jqueryui.js:
--------------------------------------------------------------------------------
1 | /*! jQuery UI styling wrapper for RowReorder
2 | * © SpryMedia Ltd - datatables.net/license
3 | */
4 |
--------------------------------------------------------------------------------
/js/rowReorder.semanticui.js:
--------------------------------------------------------------------------------
1 | /*! Semanic UI styling wrapper for RowReorder
2 | * © SpryMedia Ltd - datatables.net/license
3 | */
4 |
--------------------------------------------------------------------------------
/make.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | DT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )/../.."
4 | if [ "$1" = "debug" ]; then
5 | DEBUG="debug"
6 | else
7 | OUT_DIR=$1
8 | DEBUG=$2
9 | fi
10 |
11 | # If not run from DataTables build script, redirect to there
12 | if [ -z "$DT_BUILD" ]; then
13 | cd $DT_DIR/build
14 | ./make.sh extension RowReorder $DEBUG
15 | cd -
16 | exit
17 | fi
18 |
19 | # Change into script's own dir
20 | cd $(dirname $0)
21 |
22 | DT_SRC=$(dirname $(dirname $(pwd)))
23 | DT_BUILT="${DT_SRC}/built/DataTables"
24 | . $DT_SRC/build/include.sh
25 |
26 | # Copy CSS
27 | rsync -r css $OUT_DIR
28 | css_frameworks rowReorder $OUT_DIR/css
29 |
30 | # Copy JS
31 | rsync -r js $OUT_DIR
32 | js_wrap $OUT_DIR/js/dataTables.rowReorder.js "jquery datatables.net"
33 | js_frameworks rowReorder $OUT_DIR/js "jquery datatables.net-FW datatables.net-rowreorder"
34 |
35 |
36 | # Copy Types
37 | if [ -d $OUT_DIR/types ]; then
38 | rm -r $OUT_DIR/types
39 | fi
40 | mkdir $OUT_DIR/types
41 |
42 | if [ -d types/ ]; then
43 | cp types/* $OUT_DIR/types
44 | else
45 | if [ -f types.d.ts ]; then
46 | cp types.d.ts $OUT_DIR/types
47 | fi
48 | fi
49 |
50 | # Copy and build examples
51 | rsync -r examples $OUT_DIR
52 | examples_process $OUT_DIR/examples
53 |
54 | # Readme and license
55 | cp Readme.md $OUT_DIR
56 | cp License.txt $OUT_DIR
57 |
58 |
--------------------------------------------------------------------------------
/types/rowReorder.bootstrap.d.ts:
--------------------------------------------------------------------------------
1 |
2 | import DataTable from 'datatables.net-rowreorder';
3 |
4 | export default DataTable;
5 | export * from 'datatables.net-rowreorder';
6 |
--------------------------------------------------------------------------------
/types/rowReorder.bootstrap4.d.ts:
--------------------------------------------------------------------------------
1 |
2 | import DataTable from 'datatables.net-rowreorder';
3 |
4 | export default DataTable;
5 | export * from 'datatables.net-rowreorder';
6 |
--------------------------------------------------------------------------------
/types/rowReorder.bootstrap5.d.ts:
--------------------------------------------------------------------------------
1 |
2 | import DataTable from 'datatables.net-rowreorder';
3 |
4 | export default DataTable;
5 | export * from 'datatables.net-rowreorder';
6 |
--------------------------------------------------------------------------------
/types/rowReorder.bulma.d.ts:
--------------------------------------------------------------------------------
1 |
2 | import DataTable from 'datatables.net-rowreorder';
3 |
4 | export default DataTable;
5 | export * from 'datatables.net-rowreorder';
6 |
--------------------------------------------------------------------------------
/types/rowReorder.dataTables.d.ts:
--------------------------------------------------------------------------------
1 |
2 | import DataTable from 'datatables.net-rowreorder';
3 |
4 | export default DataTable;
5 | export * from 'datatables.net-rowreorder';
6 |
--------------------------------------------------------------------------------
/types/rowReorder.foundation.d.ts:
--------------------------------------------------------------------------------
1 |
2 | import DataTable from 'datatables.net-rowreorder';
3 |
4 | export default DataTable;
5 | export * from 'datatables.net-rowreorder';
6 |
--------------------------------------------------------------------------------
/types/rowReorder.jqueryui.d.ts:
--------------------------------------------------------------------------------
1 |
2 | import DataTable from 'datatables.net-rowreorder';
3 |
4 | export default DataTable;
5 | export * from 'datatables.net-rowreorder';
6 |
--------------------------------------------------------------------------------
/types/rowReorder.semanticui.d.ts:
--------------------------------------------------------------------------------
1 |
2 | import DataTable from 'datatables.net-rowreorder';
3 |
4 | export default DataTable;
5 | export * from 'datatables.net-rowreorder';
6 |
--------------------------------------------------------------------------------
/types/types.d.ts:
--------------------------------------------------------------------------------
1 | // Type definitions for DataTables RowReorder
2 | //
3 | // Project: https://datatables.net/extensions/rowreorder/, https://datatables.net
4 | // Definitions by:
5 | // SpryMedia
6 | // Vincent Biret
7 |
8 | import DataTables, {Api} from 'datatables.net';
9 |
10 | export default DataTables;
11 |
12 | /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
13 | * DataTables' types integration
14 | */
15 | declare module 'datatables.net' {
16 | interface Config {
17 | /**
18 | * RowReorder extension options
19 | */
20 | rowReorder?: boolean | ConfigRowReorder;
21 | }
22 |
23 | interface Api {
24 | /**
25 | * RowReorder methods container
26 | *
27 | * @returns Api for chaining with the additional RowReorder methods
28 | */
29 | rowReorder: ApiRowReorderMethods;
30 | }
31 |
32 | interface DataTablesStatic {
33 | /**
34 | * RowReorder class
35 | */
36 | RowReorder: {
37 | /**
38 | * Create a new RowReorder instance for the target DataTable
39 | */
40 | new (dt: Api, settings: boolean | ConfigRowReorder): DataTablesStatic['RowReorder'];
41 |
42 | /**
43 | * RowReorder version
44 | */
45 | version: string;
46 |
47 | /**
48 | * Default configuration values
49 | */
50 | defaults: ConfigRowReorder;
51 | }
52 | }
53 | }
54 |
55 |
56 | /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
57 | * Options
58 | */
59 |
60 | interface ConfigRowReorder {
61 | /**
62 | * Configure the data point that will be used for the reordering data
63 | */
64 | dataSrc?: string;
65 |
66 | /**
67 | * Attach an Editor instance for database updating
68 | */
69 | editor?: any;
70 |
71 | /**
72 | * Enable / disable RowReorder's user interaction
73 | */
74 | enable?: boolean;
75 |
76 | /**
77 | * Set the options for the Editor form when submitting data
78 | */
79 | formOptions?: any;
80 |
81 | /**
82 | * Define the selector used to pick the elements that will start a drag
83 | */
84 | selector?: string;
85 |
86 | /**
87 | * Horizontal position control of the row being dragged
88 | */
89 | snapX?: number | boolean;
90 |
91 | /**
92 | * Control automatic of data when a row is dropped
93 | */
94 | update?: boolean;
95 | }
96 |
97 |
98 | /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
99 | * API
100 | */
101 |
102 | interface ApiRowReorderMethods extends Api {
103 | /**
104 | * Disable the end user's ability to click and drag to reorder rows.
105 | *
106 | * @returns DataTables API instance
107 | */
108 | disable(): Api;
109 |
110 | /**
111 | * Enable, or optionally disable, the end user's ability to click and drag to reorder rows.
112 | *
113 | * @param enable that can be used to indicate if row reordering should be enabled or disabled.
114 | * @returns DataTables API instance
115 | */
116 | enable(enable?: boolean): Api;
117 | }
118 |
--------------------------------------------------------------------------------