From: Javen O'Neal Date: Sun, 1 Nov 2015 23:30:48 +0000 (+0000) Subject: whitespace changes: replaced tabs with 4 spaces X-Git-Tag: REL_3_14_BETA1~187 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=64b5c3884e6565460e8fab8c34ffbc58cc28448a;p=poi.git whitespace changes: replaced tabs with 4 spaces git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1711862 13f79535-47bb-0310-9956-ffa450edef68 --- diff --git a/src/java/org/apache/poi/ss/formula/FormulaShifter.java b/src/java/org/apache/poi/ss/formula/FormulaShifter.java index ffbee7f8a9..2c1e5101fc 100644 --- a/src/java/org/apache/poi/ss/formula/FormulaShifter.java +++ b/src/java/org/apache/poi/ss/formula/FormulaShifter.java @@ -44,20 +44,20 @@ public final class FormulaShifter { Sheet } - /** - * Extern sheet index of sheet where moving is occurring, - * used for updating HSSF style 3D references - */ - private final int _externSheetIndex; - /** - * Sheet name of the sheet where moving is occurring, - * used for updating XSSF style 3D references on row shifts. - */ - private final String _sheetName; - - private final int _firstMovedIndex; - private final int _lastMovedIndex; - private final int _amountToMove; + /** + * Extern sheet index of sheet where moving is occurring, + * used for updating HSSF style 3D references + */ + private final int _externSheetIndex; + /** + * Sheet name of the sheet where moving is occurring, + * used for updating XSSF style 3D references on row shifts. + */ + private final String _sheetName; + + private final int _firstMovedIndex; + private final int _lastMovedIndex; + private final int _amountToMove; private final int _srcSheetIndex; private final int _dstSheetIndex; @@ -69,22 +69,22 @@ public final class FormulaShifter { * * For example, this will be called on {@link org.apache.poi.hssf.usermodel.HSSFSheet#shiftRows(int, int, int)} } */ - private FormulaShifter(int externSheetIndex, String sheetName, int firstMovedIndex, int lastMovedIndex, int amountToMove) { - if (amountToMove == 0) { - throw new IllegalArgumentException("amountToMove must not be zero"); - } - if (firstMovedIndex > lastMovedIndex) { - throw new IllegalArgumentException("firstMovedIndex, lastMovedIndex out of order"); - } - _externSheetIndex = externSheetIndex; - _sheetName = sheetName; - _firstMovedIndex = firstMovedIndex; - _lastMovedIndex = lastMovedIndex; - _amountToMove = amountToMove; + private FormulaShifter(int externSheetIndex, String sheetName, int firstMovedIndex, int lastMovedIndex, int amountToMove) { + if (amountToMove == 0) { + throw new IllegalArgumentException("amountToMove must not be zero"); + } + if (firstMovedIndex > lastMovedIndex) { + throw new IllegalArgumentException("firstMovedIndex, lastMovedIndex out of order"); + } + _externSheetIndex = externSheetIndex; + _sheetName = sheetName; + _firstMovedIndex = firstMovedIndex; + _lastMovedIndex = lastMovedIndex; + _amountToMove = amountToMove; _mode = ShiftMode.Row; _srcSheetIndex = _dstSheetIndex = -1; - } + } /** * Create an instance for shifting sheets. @@ -100,45 +100,45 @@ public final class FormulaShifter { _mode = ShiftMode.Sheet; } - public static FormulaShifter createForRowShift(int externSheetIndex, String sheetName, int firstMovedRowIndex, int lastMovedRowIndex, int numberOfRowsToMove) { - return new FormulaShifter(externSheetIndex, sheetName, firstMovedRowIndex, lastMovedRowIndex, numberOfRowsToMove); - } + public static FormulaShifter createForRowShift(int externSheetIndex, String sheetName, int firstMovedRowIndex, int lastMovedRowIndex, int numberOfRowsToMove) { + return new FormulaShifter(externSheetIndex, sheetName, firstMovedRowIndex, lastMovedRowIndex, numberOfRowsToMove); + } public static FormulaShifter createForSheetShift(int srcSheetIndex, int dstSheetIndex) { return new FormulaShifter(srcSheetIndex, dstSheetIndex); } - @Override - public String toString() { - StringBuffer sb = new StringBuffer(); - - sb.append(getClass().getName()); - sb.append(" ["); - sb.append(_firstMovedIndex); - sb.append(_lastMovedIndex); - sb.append(_amountToMove); - return sb.toString(); - } - - /** - * @param ptgs - if necessary, will get modified by this method - * @param currentExternSheetIx - the extern sheet index of the sheet that contains the formula being adjusted - * @return true if a change was made to the formula tokens - */ - public boolean adjustFormula(Ptg[] ptgs, int currentExternSheetIx) { - boolean refsWereChanged = false; - for(int i=0; itrue if a change was made to the formula tokens + */ + public boolean adjustFormula(Ptg[] ptgs, int currentExternSheetIx) { + boolean refsWereChanged = false; + for(int i=0; i _lastMovedIndex) - if (_amountToMove < 0) { - // simple case - expand area by shifting top upward - aptg.setFirstRow(aFirstRow + _amountToMove); - return aptg; - } - if (destFirstRowIndex > aLastRow) { - // in this case, excel ignores the row move - return null; - } - int newFirstRowIx = aFirstRow + _amountToMove; - if (destLastRowIndex < aLastRow) { - // end of area is preserved (will remain exact same row) - // the top area row is moved simply - aptg.setFirstRow(newFirstRowIx); - return aptg; - } - // else - bottom area row has been replaced - both area top and bottom may move now - int areaRemainingTopRowIx = _lastMovedIndex + 1; - if (destFirstRowIndex > areaRemainingTopRowIx) { - // old top row of area has moved deep within the area, and exposed a new top row - newFirstRowIx = areaRemainingTopRowIx; - } - aptg.setFirstRow(newFirstRowIx); - aptg.setLastRow(Math.max(aLastRow, destLastRowIndex)); - return aptg; - } - if (_firstMovedIndex <= aLastRow && aLastRow <= _lastMovedIndex) { - // Rows moved include the last row of the area ref, but not the first - // btw: (aFirstRow < _firstMovedIndex) - if (_amountToMove > 0) { - // simple case - expand area by shifting bottom downward - aptg.setLastRow(aLastRow + _amountToMove); - return aptg; - } - if (destLastRowIndex < aFirstRow) { - // in this case, excel ignores the row move - return null; - } - int newLastRowIx = aLastRow + _amountToMove; - if (destFirstRowIndex > aFirstRow) { - // top of area is preserved (will remain exact same row) - // the bottom area row is moved simply - aptg.setLastRow(newLastRowIx); - return aptg; - } - // else - top area row has been replaced - both area top and bottom may move now - int areaRemainingBottomRowIx = _firstMovedIndex - 1; - if (destLastRowIndex < areaRemainingBottomRowIx) { - // old bottom row of area has moved up deep within the area, and exposed a new bottom row - newLastRowIx = areaRemainingBottomRowIx; - } - aptg.setFirstRow(Math.min(aFirstRow, destFirstRowIndex)); - aptg.setLastRow(newLastRowIx); - return aptg; - } - // else source rows include none of the rows of the area ref - // check for clashes with destination - - if (destLastRowIndex < aFirstRow || aLastRow < destFirstRowIndex) { - // destination rows are completely outside area ref - return null; - } - - if (destFirstRowIndex <= aFirstRow && aLastRow <= destLastRowIndex) { - // destination rows enclose the area (possibly exactly) - return createDeletedRef(aptg); - } - - if (aFirstRow <= destFirstRowIndex && destLastRowIndex <= aLastRow) { - // destination rows are within area ref (possibly exact on top or bottom, but not both) - return null; // - no change to area - } - - if (destFirstRowIndex < aFirstRow && aFirstRow <= destLastRowIndex) { - // dest rows overlap top of area - // - truncate the top - aptg.setFirstRow(destLastRowIndex+1); - return aptg; - } - if (destFirstRowIndex <= aLastRow && aLastRow < destLastRowIndex) { - // dest rows overlap bottom of area - // - truncate the bottom - aptg.setLastRow(destFirstRowIndex-1); - return aptg; - } - throw new IllegalStateException("Situation not covered: (" + _firstMovedIndex + ", " + - _lastMovedIndex + ", " + _amountToMove + ", " + aFirstRow + ", " + aLastRow + ")"); - } - - private static Ptg createDeletedRef(Ptg ptg) { - if (ptg instanceof RefPtg) { - return new RefErrorPtg(); - } - if (ptg instanceof Ref3DPtg) { - Ref3DPtg rptg = (Ref3DPtg) ptg; - return new DeletedRef3DPtg(rptg.getExternSheetIndex()); - } - if (ptg instanceof AreaPtg) { - return new AreaErrPtg(); - } - if (ptg instanceof Area3DPtg) { - Area3DPtg area3DPtg = (Area3DPtg) ptg; - return new DeletedArea3DPtg(area3DPtg.getExternSheetIndex()); - } + private Ptg rowMoveRefPtg(RefPtgBase rptg) { + int refRow = rptg.getRow(); + if (_firstMovedIndex <= refRow && refRow <= _lastMovedIndex) { + // Rows being moved completely enclose the ref. + // - move the area ref along with the rows regardless of destination + rptg.setRow(refRow + _amountToMove); + return rptg; + } + // else rules for adjusting area may also depend on the destination of the moved rows + + int destFirstRowIndex = _firstMovedIndex + _amountToMove; + int destLastRowIndex = _lastMovedIndex + _amountToMove; + + // ref is outside source rows + // check for clashes with destination + + if (destLastRowIndex < refRow || refRow < destFirstRowIndex) { + // destination rows are completely outside ref + return null; + } + + if (destFirstRowIndex <= refRow && refRow <= destLastRowIndex) { + // destination rows enclose the area (possibly exactly) + return createDeletedRef(rptg); + } + throw new IllegalStateException("Situation not covered: (" + _firstMovedIndex + ", " + + _lastMovedIndex + ", " + _amountToMove + ", " + refRow + ", " + refRow + ")"); + } + + private Ptg rowMoveAreaPtg(AreaPtgBase aptg) { + int aFirstRow = aptg.getFirstRow(); + int aLastRow = aptg.getLastRow(); + if (_firstMovedIndex <= aFirstRow && aLastRow <= _lastMovedIndex) { + // Rows being moved completely enclose the area ref. + // - move the area ref along with the rows regardless of destination + aptg.setFirstRow(aFirstRow + _amountToMove); + aptg.setLastRow(aLastRow + _amountToMove); + return aptg; + } + // else rules for adjusting area may also depend on the destination of the moved rows + + int destFirstRowIndex = _firstMovedIndex + _amountToMove; + int destLastRowIndex = _lastMovedIndex + _amountToMove; + + if (aFirstRow < _firstMovedIndex && _lastMovedIndex < aLastRow) { + // Rows moved were originally *completely* within the area ref + + // If the destination of the rows overlaps either the top + // or bottom of the area ref there will be a change + if (destFirstRowIndex < aFirstRow && aFirstRow <= destLastRowIndex) { + // truncate the top of the area by the moved rows + aptg.setFirstRow(destLastRowIndex+1); + return aptg; + } else if (destFirstRowIndex <= aLastRow && aLastRow < destLastRowIndex) { + // truncate the bottom of the area by the moved rows + aptg.setLastRow(destFirstRowIndex-1); + return aptg; + } + // else - rows have moved completely outside the area ref, + // or still remain completely within the area ref + return null; // - no change to the area + } + if (_firstMovedIndex <= aFirstRow && aFirstRow <= _lastMovedIndex) { + // Rows moved include the first row of the area ref, but not the last row + // btw: (aLastRow > _lastMovedIndex) + if (_amountToMove < 0) { + // simple case - expand area by shifting top upward + aptg.setFirstRow(aFirstRow + _amountToMove); + return aptg; + } + if (destFirstRowIndex > aLastRow) { + // in this case, excel ignores the row move + return null; + } + int newFirstRowIx = aFirstRow + _amountToMove; + if (destLastRowIndex < aLastRow) { + // end of area is preserved (will remain exact same row) + // the top area row is moved simply + aptg.setFirstRow(newFirstRowIx); + return aptg; + } + // else - bottom area row has been replaced - both area top and bottom may move now + int areaRemainingTopRowIx = _lastMovedIndex + 1; + if (destFirstRowIndex > areaRemainingTopRowIx) { + // old top row of area has moved deep within the area, and exposed a new top row + newFirstRowIx = areaRemainingTopRowIx; + } + aptg.setFirstRow(newFirstRowIx); + aptg.setLastRow(Math.max(aLastRow, destLastRowIndex)); + return aptg; + } + if (_firstMovedIndex <= aLastRow && aLastRow <= _lastMovedIndex) { + // Rows moved include the last row of the area ref, but not the first + // btw: (aFirstRow < _firstMovedIndex) + if (_amountToMove > 0) { + // simple case - expand area by shifting bottom downward + aptg.setLastRow(aLastRow + _amountToMove); + return aptg; + } + if (destLastRowIndex < aFirstRow) { + // in this case, excel ignores the row move + return null; + } + int newLastRowIx = aLastRow + _amountToMove; + if (destFirstRowIndex > aFirstRow) { + // top of area is preserved (will remain exact same row) + // the bottom area row is moved simply + aptg.setLastRow(newLastRowIx); + return aptg; + } + // else - top area row has been replaced - both area top and bottom may move now + int areaRemainingBottomRowIx = _firstMovedIndex - 1; + if (destLastRowIndex < areaRemainingBottomRowIx) { + // old bottom row of area has moved up deep within the area, and exposed a new bottom row + newLastRowIx = areaRemainingBottomRowIx; + } + aptg.setFirstRow(Math.min(aFirstRow, destFirstRowIndex)); + aptg.setLastRow(newLastRowIx); + return aptg; + } + // else source rows include none of the rows of the area ref + // check for clashes with destination + + if (destLastRowIndex < aFirstRow || aLastRow < destFirstRowIndex) { + // destination rows are completely outside area ref + return null; + } + + if (destFirstRowIndex <= aFirstRow && aLastRow <= destLastRowIndex) { + // destination rows enclose the area (possibly exactly) + return createDeletedRef(aptg); + } + + if (aFirstRow <= destFirstRowIndex && destLastRowIndex <= aLastRow) { + // destination rows are within area ref (possibly exact on top or bottom, but not both) + return null; // - no change to area + } + + if (destFirstRowIndex < aFirstRow && aFirstRow <= destLastRowIndex) { + // dest rows overlap top of area + // - truncate the top + aptg.setFirstRow(destLastRowIndex+1); + return aptg; + } + if (destFirstRowIndex <= aLastRow && aLastRow < destLastRowIndex) { + // dest rows overlap bottom of area + // - truncate the bottom + aptg.setLastRow(destFirstRowIndex-1); + return aptg; + } + throw new IllegalStateException("Situation not covered: (" + _firstMovedIndex + ", " + + _lastMovedIndex + ", " + _amountToMove + ", " + aFirstRow + ", " + aLastRow + ")"); + } + + private static Ptg createDeletedRef(Ptg ptg) { + if (ptg instanceof RefPtg) { + return new RefErrorPtg(); + } + if (ptg instanceof Ref3DPtg) { + Ref3DPtg rptg = (Ref3DPtg) ptg; + return new DeletedRef3DPtg(rptg.getExternSheetIndex()); + } + if (ptg instanceof AreaPtg) { + return new AreaErrPtg(); + } + if (ptg instanceof Area3DPtg) { + Area3DPtg area3DPtg = (Area3DPtg) ptg; + return new DeletedArea3DPtg(area3DPtg.getExternSheetIndex()); + } if (ptg instanceof Ref3DPxg) { Ref3DPxg pxg = (Ref3DPxg)ptg; return new Deleted3DPxg(pxg.getExternalWorkbookNumber(), pxg.getSheetName()); @@ -400,6 +400,6 @@ public final class FormulaShifter { return new Deleted3DPxg(pxg.getExternalWorkbookNumber(), pxg.getSheetName()); } - throw new IllegalArgumentException("Unexpected ref ptg class (" + ptg.getClass().getName() + ")"); - } + throw new IllegalArgumentException("Unexpected ref ptg class (" + ptg.getClass().getName() + ")"); + } }