Index: src/webapp/components/reorderer/js/GeometricManager.js =================================================================== --- src/webapp/components/reorderer/js/GeometricManager.js (revision 8783) +++ src/webapp/components/reorderer/js/GeometricManager.js (working copy) @@ -450,23 +450,65 @@ }; }; - function getRelativeElement(element, direction, elements) { + // this function moves a list element forward or backward + // the new 4th parameter wrapSwitch allows to turn wrapping OFF + function getRelativeElement(element, direction, elements, wrappingON) { + // determine the direction (1 or -1) var folded = fluid.directionSign(direction); + // add direction in var folded var index = $(elements).index(element) + folded; + + // if wrapping is off make sure the index is not getting + // smaller than 0 and not bigger or equal than the length + if (!wrappingON) { + if (index < 0) { + index = 0; + } + if (index >= elements.length) { + index = (elements.length - 1); + } + } + /* no else necessary since function is not changed if wrapping stays on */ + + // enable wrapping backwards (add number of elements + // to negative index to add the element at the end of list) if (index < 0) { index += elements.length; } + // enable wrapping forward (modulo by length always has a + // remainder that is equal to index except for index getting + // bigger than length. This sets index to 0) index %= elements.length; return elements[index]; } + // this function is called to have a list that does not wrap during move that.logicalFrom = function (element, direction, includeLocked) { - var orderables = that.getOwningSpan(element, fluid.position.INTERLEAVED, includeLocked); - return {element: getRelativeElement(element, direction, orderables), + return that.logicalFromFusion (element, direction, includeLocked, false); + }; + + // this function is called to have a list that does wrap during move + that.logicalWrapFrom = function (element, direction, includeLocked) { + return that.logicalFromFusion (element, direction, includeLocked, true); + }; + + // function to avoid the duplication of code. Instead this function is called by + // logicalFrom and logicalWrapFrom with false or true to turn wrapping during move off/on + that.logicalFromFusion = function (element, direction, includeLocked, wrappingON) { + var orderables = that.getOwningSpan(element, fluid.position.INTERLEAVED, includeLocked); + // wrappingOn string not necessary, but consistent and better understandable + return {element: getRelativeElement(element, direction, orderables, wrappingON), position: fluid.position.REPLACE}; }; - + + // since the function getRelativeElement now has a function to turn wrapping on/off + // a new strategy for locked items has to be introduced with wrapping OFF + /*that.lockedFrom = function (element, direction, includeLocked) { + return that.lockedFromFusion(element, direction, includeLocked, false); + };*/ + + // this is the old strategy for lists with locked items. No functionality changed that.lockedWrapFrom = function (element, direction, includeLocked) { var base = that.logicalFrom(element, direction, includeLocked); var selectables = that.getOwningSpan(element, fluid.position.INTERLEAVED, includeLocked); @@ -474,13 +516,30 @@ if (includeLocked || selectables[0] === allElements[0]) { return base; } - var directElement = getRelativeElement(element, direction, allElements); + var directElement = getRelativeElement(element, direction, allElements, true); + if (lastGeometry.elementMapper(directElement) === "locked") { + base.element = null; + base.clazz = "locked"; + } + return base; + }; + + // this is the function to handle lists with locked items. Has a parameter for wrapping + // that is passed to getRelativeElement + /*that.lockedFromFusion = function (element, direction, includeLocked, wrappingON) { + var base = that.logicalFrom(element, direction, includeLocked); + var selectables = that.getOwningSpan(element, fluid.position.INTERLEAVED, includeLocked); + var allElements = cache[cacheKey(element)].owner.elements; + if (includeLocked || selectables[0] === allElements[0]) { + return base; + } + var directElement = getRelativeElement(element, direction, allElements, wrappingON); if (lastGeometry.elementMapper(directElement) === "locked") { base.element = null; base.clazz = "locked"; } return base; - }; + }; */ that.getOwningSpan = function (element, position, includeLocked) { var owner = cache[cacheKey(element)].owner; Index: src/webapp/components/reorderer/js/Reorderer.js =================================================================== --- src/webapp/components/reorderer/js/Reorderer.js (revision 8795) +++ src/webapp/components/reorderer/js/Reorderer.js (working copy) @@ -576,6 +576,8 @@ fluid.reorderer.SHUFFLE_GEOMETRIC_STRATEGY = "shuffleProjectFrom"; fluid.reorderer.GEOMETRIC_STRATEGY = "projectFrom"; fluid.reorderer.LOGICAL_STRATEGY = "logicalFrom"; + fluid.reorderer.WRAP_LOGICAL_STRATEGY = "logicalWrapFrom"; + //fluid.reorderer.LOCKED_STRATEGY = "lockedFrom"; fluid.reorderer.WRAP_LOCKED_STRATEGY = "lockedWrapFrom"; fluid.reorderer.NO_STRATEGY = null; @@ -650,16 +652,24 @@ {orientation: fluid.orientation.VERTICAL, containerRole: fluid.reorderer.roles.LIST, selectablesTabindex: -1, - sentinelize: true + sentinelize: true, + wrapDuringMove: true }); // Public layout handlers. fluid.listLayoutHandler = function (container, options, dropManager, dom) { var that = {}; - that.getRelativePosition = - fluid.reorderer.relativeInfoGetter(options.orientation, - fluid.reorderer.LOGICAL_STRATEGY, null, dropManager, dom); + if (options.wrapDuringMove) { + that.getRelativePosition = + fluid.reorderer.relativeInfoGetter(options.orientation, + fluid.reorderer.WRAP_LOGICAL_STRATEGY, null, dropManager, dom); + } + else { + that.getRelativePosition = + fluid.reorderer.relativeInfoGetter(options.orientation, + fluid.reorderer.LOGICAL_STRATEGY, null, dropManager, dom); + } that.getGeometricInfo = geometricInfoGetter(options.orientation, options.sentinelize, dom); @@ -670,7 +680,8 @@ {orientation: fluid.orientation.HORIZONTAL, containerRole: fluid.reorderer.roles.GRID, selectablesTabindex: -1, - sentinelize: false + sentinelize: false, + wrapDuringMove: true }); /* * Items in the Lightbox are stored in a list, but they are visually presented as a grid that @@ -683,10 +694,18 @@ fluid.gridLayoutHandler = function (container, options, dropManager, dom) { var that = {}; - that.getRelativePosition = - fluid.reorderer.relativeInfoGetter(options.orientation, - fluid.reorderer.LOGICAL_STRATEGY, fluid.reorderer.SHUFFLE_GEOMETRIC_STRATEGY, - dropManager, dom); + if (options.wrapDuringMove) { + that.getRelativePosition = + fluid.reorderer.relativeInfoGetter(options.orientation, + fluid.reorderer.WRAP_LOGICAL_STRATEGY, fluid.reorderer.SHUFFLE_GEOMETRIC_STRATEGY, + dropManager, dom); + } + else { + that.getRelativePosition = + fluid.reorderer.relativeInfoGetter(options.orientation, + fluid.reorderer.LOGICAL_STRATEGY, fluid.reorderer.SHUFFLE_GEOMETRIC_STRATEGY, + dropManager, dom); + } that.getGeometricInfo = geometricInfoGetter(options.orientation, options.sentinelize, dom); Index: src/webapp/components/reorderer/js/Antranig.txt =================================================================== --- src/webapp/components/reorderer/js/Antranig.txt (revision 0) +++ src/webapp/components/reorderer/js/Antranig.txt (revision 0) @@ -0,0 +1,24 @@ +Hi there Armin + +the LayoutHandlers within the Reorderer are now parameterised with "parallel" and "perpendicular" +"strategies" (if Colin has had even a thimbleful of wine this evening he is going to come after me now :) +which are used to compute the results of keyboard and other navigation. +These directions are assessed relative to the "dominant" orientation configured into the LayoutHandler +(horizontal, vertical). + +Around line 576 these are mapped onto methods of the corresponding name in GeometricManager - the one +of greatest interest to you is "that.logicalFrom" defined at line 464. + +In order to configure non-wrapped navigation, the best method would be to add an extra argument to +"getRelativeElement" above it to defeat wrapping and then define a new GeometricManager strategy +and label to go with it. +The best naming would probably be to rename the existing "logicalFrom" to "logicalWrapFrom" by analogy +to "lockedWrapFrom" below it, and call your new strategy "logicalFrom". +This is fine since these methods have never been advertised as part of a public API... + +Sorry for the slight obscurity of implementation but it at least means that this work you are doing now +has a clear place to take in an existing infrastructure of named parameterisation :P + +Do ask more if there are any further obscure points - +Cheers, +A.