/*
* This library is part of OpenCms -
* the Open Source Content Management System
*
* Copyright (c) Alkacon Software GmbH (http://www.alkacon.com)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* For further information about Alkacon Software, please see the
* company website: http://www.alkacon.com
*
* For further information about OpenCms, please see the
* project website: http://www.opencms.org
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package org.opencms.ade.sitemap;
import org.opencms.file.CmsResource;
import org.opencms.jsp.CmsJspNavElement;
import org.opencms.main.CmsLog;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.logging.Log;
/**
* Helper class for recalculating navigation positions when a user has changed the order of navigation entries in the sitemap
* editor.<p>
*
* This is harder than it sounds because we need to handle special cases like e.g. the user inserting an entry
* between two existing entries with the same navigation position, which means we need to update the navigation positions
* of multiple entries to force the ordering which the user wanted.<p>
*/
public class CmsSitemapNavPosCalculator {
/**
* Internal class which encapsulates information about a position in the navigation list.<p>
*/
private class PositionInfo {
/** Flag which indicates whether the position is inside the navigation list. */
private boolean m_exists;
/** The navigation position as a float. */
private float m_navPos;
/**
* Creates a new position info bean.<p>
*
* @param exists true if the position is not out of bounds
*
* @param navPos the navigation position
*/
public PositionInfo(boolean exists, float navPos) {
m_exists = exists;
m_navPos = navPos;
}
/**
* Gets the navigation position.
*
* @return the navigation position
*/
public float getNavPos() {
return m_navPos;
}
/**
* Checks whether there is a maximal nav pos value at the position.<p>
*
* @return true if there is a maximal nav pos value at the position
*/
public boolean isMax() {
return m_navPos == Float.MAX_VALUE;
}
/**
* Returns true if the position is neither out of bounds nor a position with a maximal nav pos value.<p>
*
* @return true if the position is neither out of bounds nor a position with a maximal nav pos value
*/
public boolean isNormal() {
return !isOutOfBounds() && !isMax();
}
/**
* Returns true if the position is not in the list of navigation entries.<p>
*
* @return true if the position is not in the list of navigation entries
*/
public boolean isOutOfBounds() {
return !m_exists;
}
}
/** Dummy file name for the inserted dummy navigation element. */
public static final String DUMMY_PATH = "@moved@";
/** The logger instance for this class. */
private static final Log LOG = CmsLog.getLog(CmsSitemapNavPosCalculator.class);
/** The insert position in the final result list. */
private int m_insertPositionInResult;
/** The final result list. */
private List<CmsJspNavElement> m_resultList;
/**
* Creates a new sitemap navigation position calculator and performs the navigation position calculation for a given
* insertion operation.<p>
*
* @param navigation the existing navigation element list
* @param movedElement the resource which should be inserted
* @param insertPosition the insertion position in the list
*/
public CmsSitemapNavPosCalculator(List<CmsJspNavElement> navigation, CmsResource movedElement, int insertPosition) {
List<CmsJspNavElement> workList = new ArrayList<CmsJspNavElement>(navigation);
CmsJspNavElement dummyNavElement = new CmsJspNavElement(DUMMY_PATH, movedElement, new HashMap<String, String>());
// There may be another navigation element for the same resource in the navigation, so remove it
for (int i = 0; i < workList.size(); i++) {
CmsJspNavElement currentElement = workList.get(i);
if ((i != insertPosition)
&& currentElement.getResource().getStructureId().equals(movedElement.getStructureId())) {
workList.remove(i);
break;
}
}
if (insertPosition > workList.size()) {
// could happen if the navigation was concurrently changed by another user
insertPosition = workList.size();
}
// First, insert the dummy element at the correct position in the list.
workList.add(insertPosition, dummyNavElement);
// now remove elements which aren't actually part of the navigation
Iterator<CmsJspNavElement> it = workList.iterator();
while (it.hasNext()) {
CmsJspNavElement nav = it.next();
if (!nav.isInNavigation() && (nav != dummyNavElement)) {
it.remove();
}
}
insertPosition = workList.indexOf(dummyNavElement);
m_insertPositionInResult = insertPosition;
/*
* Now calculate the "block" of the inserted element.
* The block is the range of indices for which the navigation
* positions need to be updated. This range only needs to contain
* more than the inserted element if it was inserted either between two elements
* with the same navigation position or after an element with Float.MAX_VALUE
* navigation position. In either of those two cases, the block will contain
* all elements with the same navigation position.
*/
int blockStart = insertPosition;
int blockEnd = insertPosition + 1;
PositionInfo before = getPositionInfo(workList, insertPosition - 1);
PositionInfo after = getPositionInfo(workList, insertPosition + 1);
boolean extendBlock = false;
float blockValue = 0;
if (before.isMax()) {
blockValue = Float.MAX_VALUE;
extendBlock = true;
} else if (before.isNormal() && after.isNormal() && (before.getNavPos() == after.getNavPos())) {
blockValue = before.getNavPos();
extendBlock = true;
}
if (extendBlock) {
while ((blockStart > 0) && (workList.get(blockStart - 1).getNavPosition() == blockValue)) {
blockStart -= 1;
}
while ((blockEnd < workList.size())
&& ((blockEnd == (insertPosition + 1)) || (workList.get(blockEnd).getNavPosition() == blockValue))) {
blockEnd += 1;
}
}
/*
* Now calculate the new navigation positions for the elements in the block using the information
* from the elements directly before and after the block, and set the positions in the nav element
* instances.
*/
PositionInfo beforeBlock = getPositionInfo(workList, blockStart - 1);
PositionInfo afterBlock = getPositionInfo(workList, blockEnd);
// now calculate the new navigation positions for the elements in the block (
List<Float> newNavPositions = interpolatePositions(beforeBlock, afterBlock, blockEnd - blockStart);
for (int i = 0; i < (blockEnd - blockStart); i++) {
workList.get(i + blockStart).setNavPosition(newNavPositions.get(i).floatValue());
}
m_resultList = Collections.unmodifiableList(workList);
}
/**
* Gets the insert position in the final result list.<p>
*
* @return the insert position in the final result
*/
public int getInsertPositionInResult() {
return m_insertPositionInResult;
}
/**
* Gets the changed navigation entries from the final result list.<p>
*
* @return the changed navigation entries for the final result list
*/
public List<CmsJspNavElement> getNavigationChanges() {
List<CmsJspNavElement> newNav = getResultList();
List<CmsJspNavElement> changedElements = new ArrayList<CmsJspNavElement>();
for (CmsJspNavElement elem : newNav) {
if (elem.hasChangedNavPosition()) {
changedElements.add(elem);
}
}
return changedElements;
}
/**
* Gets the final result list.<p>
*
* @return the final result list
*/
public List<CmsJspNavElement> getResultList() {
return m_resultList;
}
/**
* Gets the position info bean for a given position.<p>
*
* @param navigation the navigation element list
* @param index the index in the navigation element list
*
* @return the position info bean for a given position
*/
private PositionInfo getPositionInfo(List<CmsJspNavElement> navigation, int index) {
if ((index < 0) || (index >= navigation.size())) {
return new PositionInfo(false, -1);
}
float navPos = navigation.get(index).getNavPosition();
return new PositionInfo(true, navPos);
}
/**
* Helper method to generate a list of floats between two given values.<p>
*
* @param min the lower bound
* @param max the upper bound
* @param steps the number of floats to generate
*
* @return the generated floats
*/
private List<Float> interpolateBetween(float min, float max, int steps) {
float delta = (max - min) / (steps + 1);
List<Float> result = new ArrayList<Float>();
float num = min;
for (int i = 0; i < steps; i++) {
num += delta;
result.add(new Float(num));
}
return result;
}
/**
* Helper method to generate an ascending list of floats below a given number.<p>
*
* @param max the upper bound
* @param steps the number of floats to generate
*
* @return the generated floats
*/
private List<Float> interpolateDownwards(float max, int steps) {
List<Float> result = new ArrayList<Float>();
if (max > 0) {
// We try to generate a "nice" descending list of non-negative floats
// where the step size is bigger for bigger "max" values.
float base = (max > 1) ? (float)Math.floor(max) : max;
float stepSize = 1000f;
// reduce step size until the smallest element is greater than max/10.
while ((base - (steps * stepSize)) < (max / 10.0f)) {
stepSize = reduceStepSize(stepSize);
}
// we have determined the step size, now we generate the actual numbers
for (int i = 0; i < steps; i++) {
result.add(new Float(base - ((i + 1) * stepSize)));
}
Collections.reverse(result);
} else {
LOG.warn("Invalid navpos value: " + max);
for (int i = 0; i < steps; i++) {
result.add(new Float(max - (i + 1)));
}
Collections.reverse(result);
}
return result;
}
/**
* Helper method to generate an ascending list of floats.<p>
*
* @param steps the number of floats to generate
*
* @return the generated floats
*/
private List<Float> interpolateEmpty(int steps) {
List<Float> result = new ArrayList<Float>();
for (int i = 0; i < steps; i++) {
result.add(new Float(1 + i));
}
return result;
}
/**
* Generates the new navigation positions for a range of navigation items.<p>
*
* @param left the position info for the navigation entry left of the range
* @param right the position info for the navigation entry right of the range
* @param steps the number of entries in the range
*
* @return the list of new navigation positions
*/
private List<Float> interpolatePositions(PositionInfo left, PositionInfo right, int steps) {
if (left.isOutOfBounds()) {
if (right.isNormal()) {
return interpolateDownwards(right.getNavPos(), steps);
} else if (right.isMax() || right.isOutOfBounds()) {
return interpolateEmpty(steps);
} else {
// can't happen
assert false;
}
} else if (left.isNormal()) {
if (right.isOutOfBounds() || right.isMax()) {
return interpolateUpwards(left.getNavPos(), steps);
} else if (right.isNormal()) {
return interpolateBetween(left.getNavPos(), right.getNavPos(), steps);
} else {
// can't happen
assert false;
}
} else {
// can't happen
assert false;
}
return null;
}
/**
* Helper method for generating an ascending list of floats above a given number.<p>
*
* @param min the lower bound
* @param steps the number of floats to generate
*
* @return the generated floats
*/
private List<Float> interpolateUpwards(float min, int steps) {
List<Float> result = new ArrayList<Float>();
for (int i = 0; i < steps; i++) {
result.add(new Float(min + 1 + i));
}
return result;
}
/**
* Reduces the step size for generating descending navpos sequences.<p>
*
* @param oldStepSize the previous step size
*
* @return the new (smaller) step size
*/
private float reduceStepSize(float oldStepSize) {
if (oldStepSize > 1) {
// try to reduce unnecessary digits after the decimal point
return oldStepSize / 10f;
} else {
return oldStepSize / 2f;
}
}
}