30#include <editeng/editeng.hxx>
51#include <com/sun/star/awt/XBitmap.hpp>
52#include <com/sun/star/util/CellProtection.hpp>
53#include <com/sun/star/table/CellHoriJustify.hpp>
54#include <com/sun/star/table/CellOrientation.hpp>
55#include <com/sun/star/table/ShadowFormat.hpp>
56#include <com/sun/star/table/TableBorder.hpp>
57#include <com/sun/star/table/TableBorder2.hpp>
58#include <com/sun/star/sheet/CellFlags.hpp>
59#include <com/sun/star/sheet/FormulaResult.hpp>
60#include <com/sun/star/beans/PropertyAttribute.hpp>
61#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
62#include <com/sun/star/lang/Locale.hpp>
63#include <com/sun/star/beans/TolerantPropertySetResultType.hpp>
64#include <com/sun/star/beans/SetPropertyTolerantFailed.hpp>
65#include <com/sun/star/text/WritingMode2.hpp>
66#include <com/sun/star/text/textfield/Type.hpp>
67#include <com/sun/star/sheet/XConditionalFormats.hpp>
101#include <stlsheet.hxx>
116#include <globstr.hrc>
118#include <unonames.hxx>
130#include <tokenarray.hxx>
253 return &aCellsPropertySet;
363 return &aRangePropertySet;
479 return &aCellPropertySet;
593 return &aColumnPropertySet;
705 return &aRowPropertySet;
829 return &aSheetPropertySet;
843 return aEditPropertyMap_Impl;
848 return &aEditPropertySet;
884 uno::Reference<beans::XPropertySetInfo> xInfo(rSource.getPropertySetInfo());
887 const uno::Sequence<beans::Property>
aSeq(xInfo->getProperties());
888 for (
const beans::Property& rProp :
aSeq)
890 OUString
aName(rProp.Name);
891 rDest.setPropertyValue(
aName, rSource.getPropertyValue(
aName ) );
899 throw std::out_of_range(
"empty range");
900 const ScRange & rFirst = rRanges[0];
906 if ( rRanges.
size() == 1 )
908 const ScRange & rRange = rRanges[0];
917template<
typename BorderLineType>
918const ::editeng::SvxBorderLine* lcl_getBorderLine(
935 return lcl_getBorderLine( rLine, rStruct);
941 return lcl_getBorderLine( rLine, rStruct);
945template<
typename TableBorderType>
956 rInner.
SetValid( SvxBoxInfoItemValidFlags::TOP, rBorder.IsTopLineValid );
957 rInner.
SetValid( SvxBoxInfoItemValidFlags::BOTTOM, rBorder.IsBottomLineValid );
958 rInner.
SetValid( SvxBoxInfoItemValidFlags::LEFT, rBorder.IsLeftLineValid );
959 rInner.
SetValid( SvxBoxInfoItemValidFlags::RIGHT, rBorder.IsRightLineValid );
960 rInner.
SetValid( SvxBoxInfoItemValidFlags::HORI, rBorder.IsHorizontalLineValid );
961 rInner.
SetValid( SvxBoxInfoItemValidFlags::VERT, rBorder.IsVerticalLineValid );
962 rInner.
SetValid( SvxBoxInfoItemValidFlags::DISTANCE, rBorder.IsDistanceValid );
969 lcl_fillBoxItems( rOuter, rInner, rBorder);
974 lcl_fillBoxItems( rOuter, rInner, rBorder);
989template<
typename TableBorderItem>
991 bool bInvalidateHorVerDist )
1001 rBorder.IsTopLineValid = rInner.
IsValid(SvxBoxInfoItemValidFlags::TOP);
1002 rBorder.IsBottomLineValid = rInner.
IsValid(SvxBoxInfoItemValidFlags::BOTTOM);
1003 rBorder.IsLeftLineValid = rInner.
IsValid(SvxBoxInfoItemValidFlags::LEFT);
1004 rBorder.IsRightLineValid = rInner.
IsValid(SvxBoxInfoItemValidFlags::RIGHT);
1005 rBorder.IsHorizontalLineValid = !bInvalidateHorVerDist && rInner.
IsValid(SvxBoxInfoItemValidFlags::HORI);
1006 rBorder.IsVerticalLineValid = !bInvalidateHorVerDist && rInner.
IsValid(SvxBoxInfoItemValidFlags::VERT);
1007 rBorder.IsDistanceValid = !bInvalidateHorVerDist && rInner.
IsValid(SvxBoxInfoItemValidFlags::DISTANCE);
1014 table::TableBorder aBorder;
1015 lcl_fillTableBorder( aBorder, rOuter, rInner, bInvalidateHorVerDist);
1022 table::TableBorder2 aBorder;
1023 lcl_fillTableBorder( aBorder, rOuter, rInner, bInvalidateHorVerDist);
1040 ScRange const & rRange = rRanges[
i ];
1046 pUndoDoc->InitUndo( rDoc, nTab, nTab );
1048 pUndoDoc->AddUndoTab( nTab, nTab );
1063 std::make_unique<ScUndoBorder>( pDocShell, rRanges, std::move(pUndoDoc), rOuter, rInner ) );
1076 const uno::Sequence< uno::Sequence<uno::Any> >& aData )
1087 if ( !rDoc.
IsBlockEditable( nTab, nStartCol,nStartRow, nEndCol,nEndRow ) )
1093 sal_Int32 nCols = 0;
1094 sal_Int32 nRows =
aData.getLength();
1096 nCols =
aData[0].getLength();
1098 if ( nCols != nEndCol-nStartCol+1 || nRows != nEndRow-nStartRow+1 )
1108 pUndoDoc->InitUndo( rDoc, nTab, nTab );
1114 bool bError =
false;
1115 SCROW nDocRow = nStartRow;
1116 for (
const uno::Sequence<uno::Any>& rColSeq :
aData)
1118 if ( rColSeq.getLength() == nCols )
1120 SCCOL nDocCol = nStartCol;
1121 for (
const uno::Any& rElement : rColSeq)
1125 switch( rElement.getValueTypeClass() )
1127 case uno::TypeClass_VOID:
1130 rDoc.
SetError( nDocCol, nDocRow, nTab, FormulaError::NotAvailable );
1136 case uno::TypeClass_BYTE:
1137 case uno::TypeClass_SHORT:
1138 case uno::TypeClass_UNSIGNED_SHORT:
1139 case uno::TypeClass_LONG:
1140 case uno::TypeClass_UNSIGNED_LONG:
1141 case uno::TypeClass_FLOAT:
1142 case uno::TypeClass_DOUBLE:
1150 case uno::TypeClass_STRING:
1154 if ( !aUStr.isEmpty() )
1174 case uno::TypeClass_SEQUENCE:
1176 uno::Sequence< sheet::FormulaToken > aTokens;
1177 if ( rElement >>= aTokens )
1207 std::make_unique<ScUndoPaste>(
1208 &rDocShell,
ScRange(nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab),
1221 const uno::Sequence< uno::Sequence<OUString> >& aData,
1232 if ( !rDoc.
IsBlockEditable( nTab, nStartCol,nStartRow, nEndCol,nEndRow ) )
1238 sal_Int32 nCols = 0;
1239 sal_Int32 nRows =
aData.getLength();
1241 nCols =
aData[0].getLength();
1243 if ( nCols != nEndCol-nStartCol+1 || nRows != nEndRow-nStartRow+1 )
1253 pUndoDoc->InitUndo( rDoc, nTab, nTab );
1259 bool bError =
false;
1260 SCROW nDocRow = nStartRow;
1261 for (
const uno::Sequence<OUString>& rColSeq :
aData)
1263 if ( rColSeq.getLength() == nCols )
1265 SCCOL nDocCol = nStartCol;
1266 for (
const OUString& aText : rColSeq)
1268 ScAddress aPos( nDocCol, nDocRow, nTab );
1304 std::make_unique<ScUndoPaste>( &rDocShell,
1305 ScRange(nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab), aDestMark,
1359 OUString aTempString = aVal;
1360 bool bIsNumberFormat(pFormatter->
IsNumberFormat(aTempString, nNumFmt, fDummy));
1361 if ( bIsNumberFormat )
1362 aTempString =
"'" + aTempString;
1363 else if ( aTempString.startsWith(
"'") )
1367 if ( bEnglish || ( pFormatter->
GetType(nNumFmt) != SvNumFormatType::TEXT ) )
1368 aTempString =
"'" + aTempString;
1377 pDocShell( pDocSh ),
1379 bChartColAsHdr( false ),
1380 bChartRowAsHdr( false ),
1381 bCursorOnly( false ),
1382 bGotDataChangedHint( false ),
1383 aValueListeners( 0 )
1399 pDocShell( pDocSh ),
1400 aRanges(
std::move( aR )),
1402 bChartColAsHdr( false ),
1403 bChartRowAsHdr( false ),
1404 bCursorOnly( false ),
1405 bGotDataChangedHint( false ),
1406 aValueListeners( 0 )
1512 if (
nId == SfxHintId::Dying )
1523 lang::EventObject
aEvent;
1525 for (uno::Reference<util::XModifyListener> & xValueListener :
aValueListeners)
1526 xValueListener->disposing(
aEvent );
1534 else if (
nId == SfxHintId::DataChanged )
1549 lang::EventObject
aEvent;
1555 for (
const uno::Reference<util::XModifyListener> & xValueListener :
aValueListeners)
1561 else if (
nId == SfxHintId::ScCalcAll )
1569 else if (
auto pRefHint =
dynamic_cast<const ScUpdateRefHint*
>(&rHint) )
1572 std::unique_ptr<ScRangeList> pUndoRanges;
1577 pRefHint->GetDx(), pRefHint->GetDy(), pRefHint->GetDz() ) )
1603 if ( pUndoHint->GetObjectId() ==
nObjectId )
1607 aRanges = pUndoHint->GetRanges();
1713 throw uno::RuntimeException();
1742 sal_uInt16& rItemWhich )
1750 rItemWhich = pEntry->
nWID;
1752 switch ( pEntry->
nWID )
1774 beans::PropertyState eRet = beans::PropertyState_DIRECT_VALUE;
1789 if ( eState == SfxItemState::SET )
1790 eRet = beans::PropertyState_DIRECT_VALUE;
1791 else if ( eState == SfxItemState::DEFAULT )
1792 eRet = beans::PropertyState_DEFAULT_VALUE;
1793 else if ( eState == SfxItemState::DONTCARE )
1794 eRet = beans::PropertyState_AMBIGUOUS_VALUE;
1797 OSL_FAIL(
"unknown ItemState");
1804 eRet = beans::PropertyState_DIRECT_VALUE;
1810 eRet = beans::PropertyState_DIRECT_VALUE;
1812 eRet = beans::PropertyState_AMBIGUOUS_VALUE;
1815 eRet = beans::PropertyState_DEFAULT_VALUE;
1824 throw uno::RuntimeException();
1827 sal_uInt16 nItemWhich = 0;
1834 const uno::Sequence<OUString>& aPropertyNames )
1840 uno::Sequence<beans::PropertyState> aRet(aPropertyNames.getLength());
1841 std::transform(aPropertyNames.begin(), aPropertyNames.end(), aRet.getArray(),
1842 [
this, &rPropertyMap](
const auto& rName) -> beans::PropertyState {
1843 sal_uInt16 nItemWhich = 0;
1844 const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( rName );
1845 lcl_GetPropertyWhich( pEntry, nItemWhich );
1846 return GetOnePropertyState(nItemWhich, pEntry);
1858 sal_uInt16 nItemWhich = 0;
1869 sal_uInt16 aWIDs[3];
1870 aWIDs[0] = nItemWhich;
1889 OUString aStyleName(
ScResId( STR_STYLENAME_STANDARD ) );
1916 switch ( pEntry->
nWID )
1932 switch ( pEntry->
nWID )
1940 ScResId(STR_STYLENAME_STANDARD), SfxStyleFamily::Para );
1969 aAny <<= uno::Reference<sheet::XSheetConditionalEntries>(
1983 aAny <<= uno::Reference<beans::XPropertySet>(
2004 static uno::Reference<beans::XPropertySetInfo> aRef(
2011 sal_uInt16& rFirstItemId, sal_uInt16& rSecondItemId )
2013 rFirstItemId = rEntry.
nWID;
2017 switch ( rEntry.
nWID )
2027 sal_Int32 nIntVal = 0;
2028 if ( !(rValue >>= nIntVal) )
2029 throw lang::IllegalArgumentException();
2057 sal_Int16 nIntVal = 0;
2058 if ( !(rValue >>= nIntVal) )
2059 throw lang::IllegalArgumentException();
2067 sal_Int32 nRotVal = 0;
2068 if ( !(rValue >>= nRotVal) )
2069 throw lang::IllegalArgumentException();
2082 table::CellOrientation eOrient;
2083 if( rValue >>= eOrient )
2087 case table::CellOrientation_STANDARD:
2090 case table::CellOrientation_TOPBOTTOM:
2095 case table::CellOrientation_BOTTOMTOP:
2100 case table::CellOrientation_STACKED:
2119 const OUString& aPropertyName,
const uno::Any& aValue )
2124 throw uno::RuntimeException();
2129 throw beans::UnknownPropertyException(aPropertyName);
2156 sal_uInt16 nFirstItem, nSecondItem;
2160 if ( nWhich != nFirstItem && nWhich != nSecondItem )
2167 switch ( pEntry->
nWID )
2220 aStrVal, SfxStyleFamily::Para ));
2226 table::TableBorder aBorder;
2239 table::TableBorder2 aBorder2;
2254 uno::Reference<sheet::XSheetConditionalEntries> xInterface(aValue, uno::UNO_QUERY);
2258 comphelper::getFromUnoTunnel<ScTableConditionalFormat>( xInterface );
2283 auto pNew = std::make_unique<ScConditionalFormat>( 0, &rDoc );
2284 pFormat->
FillFormat( *pNew, rDoc, eGrammar );
2301 uno::Reference<beans::XPropertySet> xInterface(aValue, uno::UNO_QUERY);
2305 comphelper::getFromUnoTunnel<ScTableValidationObj>( xInterface );
2315 std::unique_ptr<ScValidationData> pNewData(
2336 throw uno::RuntimeException();
2341 throw beans::UnknownPropertyException(aPropertyName);
2358 switch ( pEntry->
nWID )
2369 GetFormatForLanguageIfBuiltIn( nOldFormat, eOldLang );
2370 rAny <<= static_cast<sal_Int32>(nOldFormat);
2390 switch ( pEntry->
nWID )
2400 OUString aStyleName;
2403 aStyleName = pStyle->
GetName();
2405 aStyleName, SfxStyleFamily::Para );
2449 rAny <<= uno::Reference<sheet::XSheetConditionalEntries>(
2469 rAny <<= uno::Reference<beans::XPropertySet>(
2490 rAny <<= pPattern->
GetKey();
2497 const uno::Reference<beans::XPropertyChangeListener>& )
2501 throw uno::RuntimeException();
2503 OSL_FAIL(
"not implemented");
2507 const uno::Reference<beans::XPropertyChangeListener>& )
2511 throw uno::RuntimeException();
2513 OSL_FAIL(
"not implemented");
2517 const uno::Reference<beans::XVetoableChangeListener>&)
2519 OSL_FAIL(
"not implemented");
2523 const uno::Reference<beans::XVetoableChangeListener>&)
2525 OSL_FAIL(
"not implemented");
2531 const uno::Sequence< uno::Any >& aValues )
2535 sal_Int32
nCount(aPropertyNames.getLength());
2536 sal_Int32 nValues(aValues.getLength());
2538 throw lang::IllegalArgumentException();
2544 const OUString* pNames = aPropertyNames.getConstArray();
2556 pEntryArray[
i] = pEntry;
2565 catch ( lang::IllegalArgumentException& )
2574 std::unique_ptr<ScPatternAttr> pOldPattern;
2575 std::unique_ptr<ScPatternAttr> pNewPattern;
2589 pOldPattern->GetItemSet().ClearInvalidItems();
2595 sal_uInt16 nFirstItem, nSecondItem;
2600 pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nFirstItem ) );
2602 pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nSecondItem ) );
2617 const uno::Sequence< OUString >& aPropertyNames )
2623 uno::Sequence<uno::Any> aRet(aPropertyNames.getLength());
2624 uno::Any* pProperties = aRet.getArray();
2625 for(sal_Int32
i = 0;
i < aPropertyNames.getLength();
i++)
2634 const uno::Reference< beans::XPropertiesChangeListener >& )
2636 OSL_FAIL(
"not implemented");
2641 OSL_FAIL(
"not implemented");
2645 const uno::Reference< beans::XPropertiesChangeListener >& )
2647 OSL_FAIL(
"not implemented");
2652 if ( pDocShell && (rHint.GetId() == SfxHintId::ScDataChanged))
2658 bGotDataChangedHint =
true;
2664 const uno::Sequence< uno::Any >& aValues )
2668 sal_Int32
nCount(aPropertyNames.getLength());
2669 sal_Int32 nValues(aValues.getLength());
2671 throw lang::IllegalArgumentException();
2675 uno::Sequence < beans::SetPropertyTolerantFailed > aReturns(
nCount);
2676 beans::SetPropertyTolerantFailed* pReturns = aReturns.getArray();
2679 const OUString* pNames = aPropertyNames.getConstArray();
2691 pMapArray[
i] = pEntry;
2700 catch ( lang::IllegalArgumentException& )
2709 std::unique_ptr<ScPatternAttr> pOldPattern;
2710 std::unique_ptr<ScPatternAttr> pNewPattern;
2712 sal_Int32 nFailed(0);
2718 if ( pEntry && ((pEntry->
nFlags & beans::PropertyAttribute::READONLY) == 0))
2725 pOldPattern->GetItemSet().ClearInvalidItems();
2732 sal_uInt16 nFirstItem, nSecondItem;
2737 pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nFirstItem ) );
2739 pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nSecondItem ) );
2741 catch ( lang::IllegalArgumentException& )
2743 pReturns[nFailed].Name = pNames[
i];
2744 pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::ILLEGAL_ARGUMENT;
2754 catch ( lang::IllegalArgumentException& )
2756 pReturns[nFailed].Name = pNames[
i];
2757 pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::ILLEGAL_ARGUMENT;
2763 pReturns[nFailed].Name = pNames[
i];
2765 pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::PROPERTY_VETO;
2767 pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
2774 aReturns.realloc(nFailed);
2778 return uno::Sequence < beans::SetPropertyTolerantFailed >();
2785 sal_Int32
nCount(aPropertyNames.getLength());
2786 uno::Sequence < beans::GetPropertyTolerantResult > aReturns(
nCount);
2787 beans::GetPropertyTolerantResult* pReturns = aReturns.getArray();
2796 pReturns[
i].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
2800 sal_uInt16 nItemWhich = 0;
2804 pReturns[
i].Result = beans::TolerantPropertySetResultType::SUCCESS;
2814 sal_Int32
nCount(aPropertyNames.getLength());
2815 uno::Sequence < beans::GetDirectPropertyTolerantResult > aReturns(
nCount);
2816 beans::GetDirectPropertyTolerantResult* pReturns = aReturns.getArray();
2826 pReturns[
i].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
2830 sal_uInt16 nItemWhich = 0;
2833 if (pReturns[j].
State == beans::PropertyState_DIRECT_VALUE)
2836 pReturns[j].Result = beans::TolerantPropertySetResultType::SUCCESS;
2837 pReturns[j].Name = aPropertyNames[
i];
2843 aReturns.realloc(j);
2909 xChartRanges =
new ScRangeList(
ScRange( nStartX, nStartY, nTab, nEndX, nEndY, nTab ) );
2912 if (!xChartRanges.
is())
2919 return aArr.CreateMemChart();
2930 sal_Int32 nColCount = pMemChart->GetColCount();
2931 sal_Int32 nRowCount =
static_cast<sal_Int32
>(pMemChart->GetRowCount());
2933 uno::Sequence< uno::Sequence<double> > aRowSeq( nRowCount );
2934 uno::Sequence<double>* pRowAry = aRowSeq.getArray();
2935 for (sal_Int32 nRow = 0; nRow < nRowCount; nRow++)
2937 uno::Sequence<double> aColSeq( nColCount );
2938 double* pColAry = aColSeq.getArray();
2939 for (sal_Int32 nCol = 0; nCol < nColCount; nCol++)
2940 pColAry[nCol] = pMemChart->GetData( nCol, nRow );
2942 pRowAry[nRow] = aColSeq;
2964 sal_Int32 nEndColumn = nDataColumns - 1 + (
bChartColAsHdr ? 1 : 0 );
2965 if ( nEndColumn < 0 )
2967 if ( nEndColumn > rDoc.
MaxCol() )
2968 nEndColumn = rDoc.
MaxCol();
2973 if ( nEndRow > rDoc.
MaxRow() )
2977 return xChartRanges;
2988 sal_Int32 nRowCount =
aData.getLength();
2989 sal_Int32 nColCount = nRowCount ?
aData[0].getLength() : 0;
3002 for (sal_Int32 nRow=0; nRow<nRowCount; nRow++)
3004 const uno::Sequence<double>& rRowSeq =
aData[nRow];
3005 const double* pArray = rRowSeq.getConstArray();
3006 nColCount = rRowSeq.getLength();
3007 for (sal_Int32 nCol=0; nCol<nColCount; nCol++)
3010 sal::static_int_cast<SCCOL>(nCol),
3011 sal::static_int_cast<SCROW>(nRow) );
3014 double fVal = pArray[nCol];
3015 if ( fVal == DBL_MIN )
3018 rDoc.
SetValue(*pPos, pArray[nCol]);
3033 throw uno::RuntimeException();
3042 sal_Int32 nRowCount =
static_cast<sal_Int32
>(pMemChart->GetRowCount());
3043 uno::Sequence<OUString>
aSeq( nRowCount );
3044 OUString* pAry =
aSeq.getArray();
3045 for (sal_Int32 nRow = 0; nRow < nRowCount; nRow++)
3046 pAry[nRow] = pMemChart->GetRowText(nRow);
3054 const uno::Sequence<OUString>& aRowDescriptions )
3060 sal_Int32 nRowCount = aRowDescriptions.getLength();
3072 const OUString* pArray = aRowDescriptions.getConstArray();
3073 for (sal_Int32 nRow=0; nRow<nRowCount; nRow++)
3076 static_cast<SCSIZE>(nRow) );
3079 const OUString&
aStr = pArray[nRow];
3102 throw uno::RuntimeException();
3111 sal_Int32 nColCount = pMemChart->GetColCount();
3112 uno::Sequence<OUString>
aSeq( nColCount );
3113 OUString* pAry =
aSeq.getArray();
3114 for (sal_Int32 nCol = 0; nCol < nColCount; nCol++)
3115 pAry[nCol] = pMemChart->GetColText(nCol);
3123 const uno::Sequence<OUString>& aColumnDescriptions )
3129 sal_Int32 nColCount = aColumnDescriptions.getLength();
3141 const OUString* pArray = aColumnDescriptions.getConstArray();
3142 for (sal_Int32 nCol=0; nCol<nColCount; nCol++)
3145 sal::static_int_cast<SCCOL>(nCol) );
3148 const OUString&
aStr = pArray[nCol];
3171 throw uno::RuntimeException();
3187 for (
auto const& it : rListeners)
3191 if (
p->GetUnoSource() ==
static_cast<chart::XChartData*
>(
this) &&
p->IsDirty())
3197 chart::XChartDataChangeEventListener >& aListener )
3209 if (
aName.isEmpty())
3214 pListener->
SetUno( aListener,
this );
3215 pColl->
insert( pListener );
3220 chart::XChartDataChangeEventListener >& aListener )
3227 pColl->
FreeUno( aListener,
this );
3240 return (nNumber == DBL_MIN);
3249 throw uno::RuntimeException();
3271 throw uno::RuntimeException();
3279 if ( rObj == aListener )
3309 SCCOL nCol = 0, nLastCol;
3310 while (nCol <= rDoc.
MaxCol())
3312 if (rDoc.
ColHidden(nCol, nTab,
nullptr, &nLastCol))
3316 nCol = nLastCol + 1;
3319 SCROW nRow = 0, nLastRow;
3320 while (nRow <= rDoc.
MaxRow())
3322 if (rDoc.
RowHidden(nRow, nTab,
nullptr, &nLastRow))
3326 nRow = nLastRow + 1;
3331 return new ScCellRangesObj(
pDocShell, aNewRanges );
3352 for (
bool bHasCell = aIter.
first(); bHasCell; bHasCell = aIter.
next())
3365 return new ScCellRangesObj(
pDocShell, aNewRanges );
3372 sal_Int16 nContentFlags )
3387 for (
bool bHasCell = aIter.
first(); bHasCell; bHasCell = aIter.
next())
3393 if ( nContentFlags & sheet::CellFlags::STRING )
3397 if ( (nContentFlags & sheet::CellFlags::STRING) || (nContentFlags & sheet::CellFlags::FORMATTED) )
3405 if ( (nContentFlags & (sheet::CellFlags::VALUE|sheet::CellFlags::DATETIME))
3406 == (sheet::CellFlags::VALUE|sheet::CellFlags::DATETIME) )
3415 if ((nTyp == SvNumFormatType::DATE) || (nTyp == SvNumFormatType::TIME) ||
3416 (nTyp == SvNumFormatType::DATETIME))
3418 if ( nContentFlags & sheet::CellFlags::DATETIME )
3423 if ( nContentFlags & sheet::CellFlags::VALUE )
3439 if (nContentFlags & sheet::CellFlags::ANNOTATION)
3441 std::vector<sc::NoteEntry> aNotes;
3444 for (
const auto&
i : aNotes)
3454 return new ScCellRangesObj(
pDocShell, aNewRanges );
3461 sal_Int32 nResultFlags )
3476 for (
bool bHasCell = aIter.
first(); bHasCell; bHasCell = aIter.
next())
3482 if (pFCell->
GetErrCode() != FormulaError::NONE)
3484 if ( nResultFlags & sheet::FormulaResult::ERROR )
3489 if ( nResultFlags & sheet::FormulaResult::VALUE )
3494 if ( nResultFlags & sheet::FormulaResult::STRING )
3508 return new ScCellRangesObj(
pDocShell, aNewRanges );
3515 const table::CellAddress& aCompare,
bool bColumnDiff)
3530 ScRange aCmpRange, aCellRange;
3532 aCmpRange =
ScRange( 0,nCmpPos,nTab, rDoc.
MaxCol(),nCmpPos,nTab );
3536 for (
bool bHasCell = aCmpIter.
first(); bHasCell; bHasCell = aCmpIter.
next())
3540 aCellRange =
ScRange(
static_cast<SCCOL>(nCellPos),0,nTab,
3541 static_cast<SCCOL>(nCellPos),rDoc.
MaxRow(),nTab );
3543 aCellRange =
ScRange( 0,nCellPos,nTab, rDoc.
MaxCol(),nCellPos,nTab );
3545 for (
i=0;
i<nRangeCount;
i++)
3569 for (
i=0;
i<nRangeCount;
i++)
3574 for (
bool bHasCell = aIter.
first(); bHasCell; bHasCell = aIter.
next())
3593 return new ScCellRangesObj(
pDocShell, aNewRanges );
3599 const table::CellAddress& aCompare )
3606 const table::CellAddress& aCompare )
3613 const table::CellRangeAddress& aRange )
3616 ScRange aMask(
static_cast<SCCOL>(aRange.StartColumn),
static_cast<SCROW>(aRange.StartRow), aRange.Sheet,
3617 static_cast<SCCOL>(aRange.EndColumn),
static_cast<SCROW>(aRange.EndRow), aRange.Sheet );
3632 return new ScCellRangesObj(
pDocShell, aNew );
3657 ScRange const & rRange = aNewRanges[ nR];
3659 for (
bool bHasCell = aIter.
first(); bHasCell; bHasCell = aIter.
next())
3668 if ( bRecursive && !bFound && !aMarkData.
IsAllMarked( aRefRange ) )
3677 while ( bRecursive && bFound );
3679 return new ScCellRangesObj(
pDocShell, aNewRanges );
3706 for (
bool bHasCell = aCellIter.
first(); bHasCell; bHasCell = aCellIter.
next())
3714 while ( aIter.
GetNextRef( aRefRange) && !bMark )
3716 size_t nRangesCount = aNewRanges.
size();
3717 for (
size_t nR = 0; nR < nRangesCount; ++nR)
3719 ScRange const & rRange = aNewRanges[ nR ];
3730 if ( bRecursive && !bFound && !aMarkData.
IsAllMarked( aCellRange ) )
3738 while ( bRecursive && bFound );
3740 return new ScCellRangesObj(
pDocShell, aNewRanges );
3754 const uno::Reference<util::XSearchDescriptor>& xDesc )
3758 uno::Reference<container::XIndexAccess> xRet;
3761 ScCellSearchObj* pSearch = comphelper::getFromUnoTunnel<ScCellSearchObj>( xDesc );
3768 pSearchItem->
SetCommand( SvxSearchCmd::FIND_ALL );
3774 OUString aDummyUndo;
3779 bool bMatchedRangesWereClamped =
false;
3781 *pSearchItem, nCol, nRow, nTab, aMark, aMatchedRanges, aDummyUndo,
nullptr, bMatchedRangesWereClamped);
3785 xRet.set(
new ScCellRangesObj(
pDocShell, aMatchedRanges ));
3794 const uno::Reference<util::XSearchDescriptor>& xDesc,
3797 uno::Reference<uno::XInterface> xRet;
3800 ScCellSearchObj* pSearch = comphelper::getFromUnoTunnel<ScCellSearchObj>( xDesc );
3807 pSearchItem->
SetCommand( SvxSearchCmd::FIND );
3817 pLastPos->
GetVars( nCol, nRow, nTab );
3824 OUString aDummyUndo;
3826 bool bMatchedRangesWereClamped;
3828 *pSearchItem, nCol, nRow, nTab, aMark, aMatchedRanges, aDummyUndo,
nullptr, bMatchedRangesWereClamped);
3831 ScAddress aFoundPos( nCol, nRow, nTab );
3841 const uno::Reference<util::XSearchDescriptor>& xDesc )
3848 const uno::Reference<uno::XInterface>& xStartAt,
3849 const uno::Reference<util::XSearchDescriptor >& xDesc )
3852 if ( xStartAt.is() )