Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sc / source / core / tool / detfunc.cxx
blob: ba70f18a6786ac7ea7f770520cae1c32a70688ff [file] [log] [blame]
/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sc.hxx"
// INCLUDE ---------------------------------------------------------------
#include "scitems.hxx"
#include <svtools/colorcfg.hxx>
#include <editeng/eeitem.hxx>
#include <editeng/outlobj.hxx>
#include <svx/sdshitm.hxx>
#include <svx/sdsxyitm.hxx>
#include <svx/sdtditm.hxx>
#include <svx/svditer.hxx>
#include <svx/svdocapt.hxx>
#include <svx/svdocirc.hxx>
#include <svx/svdopath.hxx>
#include <svx/svdorect.hxx>
#include <svx/svdpage.hxx>
#include <svx/svdundo.hxx>
#include <svx/xfillit0.hxx>
#include <svx/xflclit.hxx>
#include <svx/xlnclit.hxx>
#include <svx/xlnedcit.hxx>
#include <svx/xlnedit.hxx>
#include <svx/xlnedwit.hxx>
#include <svx/xlnstcit.hxx>
#include <svx/xlnstit.hxx>
#include <svx/xlnstwit.hxx>
#include <svx/xlnwtit.hxx>
#include <svx/xtable.hxx>
#include <editeng/outliner.hxx>
#include <editeng/editobj.hxx>
#include <svx/sxcecitm.hxx>
#include <svl/whiter.hxx>
#include <editeng/writingmodeitem.hxx>
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include "detfunc.hxx"
#include "document.hxx"
#include "dociter.hxx"
#include "drwlayer.hxx"
#include "userdat.hxx"
#include "validat.hxx"
#include "cell.hxx"
#include "docpool.hxx"
#include "patattr.hxx"
#include "attrib.hxx"
#include "scmod.hxx"
#include "postit.hxx"
//------------------------------------------------------------------------
// #99319# line ends are now created with an empty name.
// The checkForUniqueItem method then finds a unique name for the item's value.
#define SC_LINEEND_NAME EMPTY_STRING
//------------------------------------------------------------------------
enum DetInsertResult { // Return-Werte beim Einfuegen in einen Level
DET_INS_CONTINUE,
DET_INS_INSERTED,
DET_INS_EMPTY,
DET_INS_CIRCULAR };
//------------------------------------------------------------------------
class ScDetectiveData
{
private:
SfxItemSet aBoxSet;
SfxItemSet aArrowSet;
SfxItemSet aToTabSet;
SfxItemSet aFromTabSet;
SfxItemSet aCircleSet; //! einzeln ?
sal_uInt16 nMaxLevel;
public:
ScDetectiveData( SdrModel* pModel );
SfxItemSet& GetBoxSet() { return aBoxSet; }
SfxItemSet& GetArrowSet() { return aArrowSet; }
SfxItemSet& GetToTabSet() { return aToTabSet; }
SfxItemSet& GetFromTabSet() { return aFromTabSet; }
SfxItemSet& GetCircleSet() { return aCircleSet; }
void SetMaxLevel( sal_uInt16 nVal ) { nMaxLevel = nVal; }
sal_uInt16 GetMaxLevel() const { return nMaxLevel; }
};
class ScCommentData
{
public:
ScCommentData( ScDocument& rDoc, SdrModel* pModel );
SfxItemSet& GetCaptionSet() { return aCaptionSet; }
void UpdateCaptionSet( const SfxItemSet& rItemSet );
private:
SfxItemSet aCaptionSet;
};
//------------------------------------------------------------------------
ColorData ScDetectiveFunc::nArrowColor = 0;
ColorData ScDetectiveFunc::nErrorColor = 0;
ColorData ScDetectiveFunc::nCommentColor = 0;
sal_Bool ScDetectiveFunc::bColorsInitialized = sal_False;
//------------------------------------------------------------------------
sal_Bool lcl_HasThickLine( SdrObject& rObj )
{
// thin lines get width 0 -> everything greater 0 is a thick line
return ( ((const XLineWidthItem&)rObj.GetMergedItem(XATTR_LINEWIDTH)).GetValue() > 0 );
}
//------------------------------------------------------------------------
ScDetectiveData::ScDetectiveData( SdrModel* pModel ) :
aBoxSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ),
aArrowSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ),
aToTabSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ),
aFromTabSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ),
aCircleSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END )
{
nMaxLevel = 0;
aBoxSet.Put( XLineColorItem( EMPTY_STRING, Color( ScDetectiveFunc::GetArrowColor() ) ) );
aBoxSet.Put( XFillStyleItem( XFILL_NONE ) );
// #66479# Standard-Linienenden (wie aus XLineEndList::Create) selber zusammenbasteln,
// um von den konfigurierten Linienenden unabhaengig zu sein
basegfx::B2DPolygon aTriangle;
aTriangle.append(basegfx::B2DPoint(10.0, 0.0));
aTriangle.append(basegfx::B2DPoint(0.0, 30.0));
aTriangle.append(basegfx::B2DPoint(20.0, 30.0));
aTriangle.setClosed(true);
basegfx::B2DPolygon aSquare;
aSquare.append(basegfx::B2DPoint(0.0, 0.0));
aSquare.append(basegfx::B2DPoint(10.0, 0.0));
aSquare.append(basegfx::B2DPoint(10.0, 10.0));
aSquare.append(basegfx::B2DPoint(0.0, 10.0));
aSquare.setClosed(true);
basegfx::B2DPolygon aCircle(basegfx::tools::createPolygonFromEllipse(basegfx::B2DPoint(0.0, 0.0), 100.0, 100.0));
aCircle.setClosed(true);
String aName = SC_LINEEND_NAME;
aArrowSet.Put( XLineStartItem( aName, basegfx::B2DPolyPolygon(aCircle) ) );
aArrowSet.Put( XLineStartWidthItem( 200 ) );
aArrowSet.Put( XLineStartCenterItem( sal_True ) );
aArrowSet.Put( XLineEndItem( aName, basegfx::B2DPolyPolygon(aTriangle) ) );
aArrowSet.Put( XLineEndWidthItem( 200 ) );
aArrowSet.Put( XLineEndCenterItem( sal_False ) );
aToTabSet.Put( XLineStartItem( aName, basegfx::B2DPolyPolygon(aCircle) ) );
aToTabSet.Put( XLineStartWidthItem( 200 ) );
aToTabSet.Put( XLineStartCenterItem( sal_True ) );
aToTabSet.Put( XLineEndItem( aName, basegfx::B2DPolyPolygon(aSquare) ) );
aToTabSet.Put( XLineEndWidthItem( 300 ) );
aToTabSet.Put( XLineEndCenterItem( sal_False ) );
aFromTabSet.Put( XLineStartItem( aName, basegfx::B2DPolyPolygon(aSquare) ) );
aFromTabSet.Put( XLineStartWidthItem( 300 ) );
aFromTabSet.Put( XLineStartCenterItem( sal_True ) );
aFromTabSet.Put( XLineEndItem( aName, basegfx::B2DPolyPolygon(aTriangle) ) );
aFromTabSet.Put( XLineEndWidthItem( 200 ) );
aFromTabSet.Put( XLineEndCenterItem( sal_False ) );
aCircleSet.Put( XLineColorItem( String(), Color( ScDetectiveFunc::GetErrorColor() ) ) );
aCircleSet.Put( XFillStyleItem( XFILL_NONE ) );
sal_uInt16 nWidth = 55; // 54 = 1 Pixel
aCircleSet.Put( XLineWidthItem( nWidth ) );
}
ScCommentData::ScCommentData( ScDocument& rDoc, SdrModel* pModel ) :
aCaptionSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END, EE_ITEMS_START, EE_ITEMS_END, 0, 0 )
{
basegfx::B2DPolygon aTriangle;
aTriangle.append(basegfx::B2DPoint(10.0, 0.0));
aTriangle.append(basegfx::B2DPoint(0.0, 30.0));
aTriangle.append(basegfx::B2DPoint(20.0, 30.0));
aTriangle.setClosed(true);
String aName = SC_LINEEND_NAME;
aCaptionSet.Put( XLineStartItem( aName, basegfx::B2DPolyPolygon(aTriangle) ) );
aCaptionSet.Put( XLineStartWidthItem( 200 ) );
aCaptionSet.Put( XLineStartCenterItem( sal_False ) );
aCaptionSet.Put( XFillStyleItem( XFILL_SOLID ) );
Color aYellow( ScDetectiveFunc::GetCommentColor() );
aCaptionSet.Put( XFillColorItem( String(), aYellow ) );
// shadow
// SdrShadowItem has sal_False, instead the shadow is set for the rectangle
// only with SetSpecialTextBoxShadow when the object is created
// (item must be set to adjust objects from older files)
aCaptionSet.Put( SdrShadowItem( sal_False ) );
aCaptionSet.Put( SdrShadowXDistItem( 100 ) );
aCaptionSet.Put( SdrShadowYDistItem( 100 ) );
// text attributes
aCaptionSet.Put( SdrTextLeftDistItem( 100 ) );
aCaptionSet.Put( SdrTextRightDistItem( 100 ) );
aCaptionSet.Put( SdrTextUpperDistItem( 100 ) );
aCaptionSet.Put( SdrTextLowerDistItem( 100 ) );
aCaptionSet.Put( SdrTextAutoGrowWidthItem( sal_False ) );
aCaptionSet.Put( SdrTextAutoGrowHeightItem( sal_True ) );
// #78943# do use the default cell style, so the user has a chance to
// modify the font for the annotations
((const ScPatternAttr&)rDoc.GetPool()->GetDefaultItem(ATTR_PATTERN)).
FillEditItemSet( &aCaptionSet );
// support the best position for the tail connector now that
// that notes can be resized and repositioned.
aCaptionSet.Put( SdrCaptionEscDirItem( SDRCAPT_ESCBESTFIT) );
}
void ScCommentData::UpdateCaptionSet( const SfxItemSet& rItemSet )
{
SfxWhichIter aWhichIter( rItemSet );
const SfxPoolItem* pPoolItem = 0;
for( sal_uInt16 nWhich = aWhichIter.FirstWhich(); nWhich > 0; nWhich = aWhichIter.NextWhich() )
{
if(rItemSet.GetItemState(nWhich, sal_False, &pPoolItem) == SFX_ITEM_SET)
{
switch(nWhich)
{
case SDRATTR_SHADOW:
// use existing Caption default - appears that setting this
// to true screws up the tail appearance. See also comment
// for default setting above.
break;
case SDRATTR_SHADOWXDIST:
// use existing Caption default - svx sets a value of 35
// but default 100 gives a better appearance.
break;
case SDRATTR_SHADOWYDIST:
// use existing Caption default - svx sets a value of 35
// but default 100 gives a better appearance.
break;
default:
aCaptionSet.Put(*pPoolItem);
}
}
}
}
//------------------------------------------------------------------------
void ScDetectiveFunc::Modified()
{
if (pDoc->IsStreamValid(nTab))
pDoc->SetStreamValid(nTab, sal_False);
}
inline sal_Bool Intersect( SCCOL nStartCol1, SCROW nStartRow1, SCCOL nEndCol1, SCROW nEndRow1,
SCCOL nStartCol2, SCROW nStartRow2, SCCOL nEndCol2, SCROW nEndRow2 )
{
return nEndCol1 >= nStartCol2 && nEndCol2 >= nStartCol1 &&
nEndRow1 >= nStartRow2 && nEndRow2 >= nStartRow1;
}
sal_Bool ScDetectiveFunc::HasError( const ScRange& rRange, ScAddress& rErrPos )
{
rErrPos = rRange.aStart;
sal_uInt16 nError = 0;
ScCellIterator aCellIter( pDoc, rRange);
ScBaseCell* pCell = aCellIter.GetFirst();
while (pCell)
{
if (pCell->GetCellType() == CELLTYPE_FORMULA)
{
nError = ((ScFormulaCell*)pCell)->GetErrCode();
if (nError)
rErrPos.Set( aCellIter.GetCol(), aCellIter.GetRow(), aCellIter.GetTab() );
}
pCell = aCellIter.GetNext();
}
return (nError != 0);
}
Point ScDetectiveFunc::GetDrawPos( SCCOL nCol, SCROW nRow, DrawPosMode eMode ) const
{
DBG_ASSERT( ValidColRow( nCol, nRow ), "ScDetectiveFunc::GetDrawPos - invalid cell address" );
SanitizeCol( nCol );
SanitizeRow( nRow );
Point aPos;
switch( eMode )
{
case DRAWPOS_TOPLEFT:
break;
case DRAWPOS_BOTTOMRIGHT:
++nCol;
++nRow;
break;
case DRAWPOS_DETARROW:
aPos.X() += pDoc->GetColWidth( nCol, nTab ) / 4;
aPos.Y() += pDoc->GetRowHeight( nRow, nTab ) / 2;
break;
case DRAWPOS_CAPTIONLEFT:
aPos.X() += 6;
break;
case DRAWPOS_CAPTIONRIGHT:
{
// find right end of passed cell position
const ScMergeAttr* pMerge = static_cast< const ScMergeAttr* >( pDoc->GetAttr( nCol, nRow, nTab, ATTR_MERGE ) );
if ( pMerge->GetColMerge() > 1 )
nCol = nCol + pMerge->GetColMerge();
else
++nCol;
aPos.X() -= 6;
}
break;
}
for ( SCCOL i = 0; i < nCol; ++i )
aPos.X() += pDoc->GetColWidth( i, nTab );
aPos.Y() += pDoc->GetRowHeight( 0, nRow - 1, nTab );
aPos.X() = static_cast< long >( aPos.X() * HMM_PER_TWIPS );
aPos.Y() = static_cast< long >( aPos.Y() * HMM_PER_TWIPS );
if ( pDoc->IsNegativePage( nTab ) )
aPos.X() *= -1;
return aPos;
}
Rectangle ScDetectiveFunc::GetDrawRect( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const
{
Rectangle aRect(
GetDrawPos( ::std::min( nCol1, nCol2 ), ::std::min( nRow1, nRow2 ), DRAWPOS_TOPLEFT ),
GetDrawPos( ::std::max( nCol1, nCol2 ), ::std::max( nRow1, nRow2 ), DRAWPOS_BOTTOMRIGHT ) );
aRect.Justify(); // reorder left/right in RTL sheets
return aRect;
}
Rectangle ScDetectiveFunc::GetDrawRect( SCCOL nCol, SCROW nRow ) const
{
return GetDrawRect( nCol, nRow, nCol, nRow );
}
sal_Bool lcl_IsOtherTab( const basegfx::B2DPolyPolygon& rPolyPolygon )
{
// test if rPolygon is the line end for "other table" (rectangle)
if(1L == rPolyPolygon.count())
{
const basegfx::B2DPolygon aSubPoly(rPolyPolygon.getB2DPolygon(0L));
// #i73305# circle consists of 4 segments, too, distinguishable from square by
// the use of control points
if(4L == aSubPoly.count() && aSubPoly.isClosed() && !aSubPoly.areControlPointsUsed())
{
return true;
}
}
return false;
}
sal_Bool ScDetectiveFunc::HasArrow( const ScAddress& rStart,
SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab )
{
sal_Bool bStartAlien = ( rStart.Tab() != nTab );
sal_Bool bEndAlien = ( nEndTab != nTab );
if (bStartAlien && bEndAlien)
{
DBG_ERROR("bStartAlien && bEndAlien");
return sal_True;
}
Rectangle aStartRect;
Rectangle aEndRect;
if (!bStartAlien)
aStartRect = GetDrawRect( rStart.Col(), rStart.Row() );
if (!bEndAlien)
aEndRect = GetDrawRect( nEndCol, nEndRow );
ScDrawLayer* pModel = pDoc->GetDrawLayer();
SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
DBG_ASSERT(pPage,"Page ?");
sal_Bool bFound = sal_False;
SdrObjListIter aIter( *pPage, IM_FLAT );
SdrObject* pObject = aIter.Next();
while (pObject && !bFound)
{
if ( pObject->GetLayer()==SC_LAYER_INTERN &&
pObject->IsPolyObj() && pObject->GetPointCount()==2 )
{
const SfxItemSet& rSet = pObject->GetMergedItemSet();
sal_Bool bObjStartAlien =
lcl_IsOtherTab( ((const XLineStartItem&)rSet.Get(XATTR_LINESTART)).GetLineStartValue() );
sal_Bool bObjEndAlien =
lcl_IsOtherTab( ((const XLineEndItem&)rSet.Get(XATTR_LINEEND)).GetLineEndValue() );
sal_Bool bStartHit = bStartAlien ? bObjStartAlien :
( !bObjStartAlien && aStartRect.IsInside(pObject->GetPoint(0)) );
sal_Bool bEndHit = bEndAlien ? bObjEndAlien :
( !bObjEndAlien && aEndRect.IsInside(pObject->GetPoint(1)) );
if ( bStartHit && bEndHit )
bFound = sal_True;
}
pObject = aIter.Next();
}
return bFound;
}
sal_Bool ScDetectiveFunc::IsNonAlienArrow( SdrObject* pObject ) // static
{
if ( pObject->GetLayer()==SC_LAYER_INTERN &&
pObject->IsPolyObj() && pObject->GetPointCount()==2 )
{
const SfxItemSet& rSet = pObject->GetMergedItemSet();
sal_Bool bObjStartAlien =
lcl_IsOtherTab( ((const XLineStartItem&)rSet.Get(XATTR_LINESTART)).GetLineStartValue() );
sal_Bool bObjEndAlien =
lcl_IsOtherTab( ((const XLineEndItem&)rSet.Get(XATTR_LINEEND)).GetLineEndValue() );
return !bObjStartAlien && !bObjEndAlien;
}
return sal_False;
}
//------------------------------------------------------------------------
// InsertXXX: called from DrawEntry/DrawAlienEntry and InsertObject
sal_Bool ScDetectiveFunc::InsertArrow( SCCOL nCol, SCROW nRow,
SCCOL nRefStartCol, SCROW nRefStartRow,
SCCOL nRefEndCol, SCROW nRefEndRow,
sal_Bool bFromOtherTab, sal_Bool bRed,
ScDetectiveData& rData )
{
ScDrawLayer* pModel = pDoc->GetDrawLayer();
SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
sal_Bool bArea = ( nRefStartCol != nRefEndCol || nRefStartRow != nRefEndRow );
if (bArea && !bFromOtherTab)
{
// insert the rectangle before the arrow - this is relied on in FindFrameForObject
Rectangle aRect = GetDrawRect( nRefStartCol, nRefStartRow, nRefEndCol, nRefEndRow );
SdrRectObj* pBox = new SdrRectObj( aRect );
pBox->SetMergedItemSetAndBroadcast(rData.GetBoxSet());
ScDrawLayer::SetAnchor( pBox, SCA_CELL );
pBox->SetLayer( SC_LAYER_INTERN );
pPage->InsertObject( pBox );
pModel->AddCalcUndo< SdrUndoInsertObj >( *pBox );
ScDrawObjData* pData = ScDrawLayer::GetObjData( pBox, sal_True );
pData->maStart.Set( nRefStartCol, nRefStartRow, nTab);
pData->maEnd.Set( nRefEndCol, nRefEndRow, nTab);
}
Point aStartPos = GetDrawPos( nRefStartCol, nRefStartRow, DRAWPOS_DETARROW );
Point aEndPos = GetDrawPos( nCol, nRow, DRAWPOS_DETARROW );
if (bFromOtherTab)
{
sal_Bool bNegativePage = pDoc->IsNegativePage( nTab );
long nPageSign = bNegativePage ? -1 : 1;
aStartPos = Point( aEndPos.X() - 1000 * nPageSign, aEndPos.Y() - 1000 );
if (aStartPos.X() * nPageSign < 0)
aStartPos.X() += 2000 * nPageSign;
if (aStartPos.Y() < 0)
aStartPos.Y() += 2000;
}
SfxItemSet& rAttrSet = bFromOtherTab ? rData.GetFromTabSet() : rData.GetArrowSet();
if (bArea && !bFromOtherTab)
rAttrSet.Put( XLineWidthItem( 50 ) ); // Bereich
else
rAttrSet.Put( XLineWidthItem( 0 ) ); // einzelne Referenz
ColorData nColorData = ( bRed ? GetErrorColor() : GetArrowColor() );
rAttrSet.Put( XLineColorItem( String(), Color( nColorData ) ) );
basegfx::B2DPolygon aTempPoly;
aTempPoly.append(basegfx::B2DPoint(aStartPos.X(), aStartPos.Y()));
aTempPoly.append(basegfx::B2DPoint(aEndPos.X(), aEndPos.Y()));
SdrPathObj* pArrow = new SdrPathObj(OBJ_LINE, basegfx::B2DPolyPolygon(aTempPoly));
pArrow->NbcSetLogicRect(Rectangle(aStartPos,aEndPos)); //! noetig ???
pArrow->SetMergedItemSetAndBroadcast(rAttrSet);
ScDrawLayer::SetAnchor( pArrow, SCA_CELL );
pArrow->SetLayer( SC_LAYER_INTERN );
pPage->InsertObject( pArrow );
pModel->AddCalcUndo< SdrUndoInsertObj >( *pArrow );
ScDrawObjData* pData = ScDrawLayer::GetObjData( pArrow, sal_True );
if (bFromOtherTab)
pData->maStart.SetInvalid();
else
pData->maStart.Set( nRefStartCol, nRefStartRow, nTab);
pData->maEnd.Set( nCol, nRow, nTab);
Modified();
return sal_True;
}
sal_Bool ScDetectiveFunc::InsertToOtherTab( SCCOL nStartCol, SCROW nStartRow,
SCCOL nEndCol, SCROW nEndRow, sal_Bool bRed,
ScDetectiveData& rData )
{
ScDrawLayer* pModel = pDoc->GetDrawLayer();
SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
sal_Bool bArea = ( nStartCol != nEndCol || nStartRow != nEndRow );
if (bArea)
{
Rectangle aRect = GetDrawRect( nStartCol, nStartRow, nEndCol, nEndRow );
SdrRectObj* pBox = new SdrRectObj( aRect );
pBox->SetMergedItemSetAndBroadcast(rData.GetBoxSet());
ScDrawLayer::SetAnchor( pBox, SCA_CELL );
pBox->SetLayer( SC_LAYER_INTERN );
pPage->InsertObject( pBox );
pModel->AddCalcUndo< SdrUndoInsertObj >( *pBox );
ScDrawObjData* pData = ScDrawLayer::GetObjData( pBox, sal_True );
pData->maStart.Set( nStartCol, nStartRow, nTab);
pData->maEnd.Set( nEndCol, nEndRow, nTab);
}
sal_Bool bNegativePage = pDoc->IsNegativePage( nTab );
long nPageSign = bNegativePage ? -1 : 1;
Point aStartPos = GetDrawPos( nStartCol, nStartRow, DRAWPOS_DETARROW );
Point aEndPos = Point( aStartPos.X() + 1000 * nPageSign, aStartPos.Y() - 1000 );
if (aEndPos.Y() < 0)
aEndPos.Y() += 2000;
SfxItemSet& rAttrSet = rData.GetToTabSet();
if (bArea)
rAttrSet.Put( XLineWidthItem( 50 ) ); // Bereich
else
rAttrSet.Put( XLineWidthItem( 0 ) ); // einzelne Referenz
ColorData nColorData = ( bRed ? GetErrorColor() : GetArrowColor() );
rAttrSet.Put( XLineColorItem( String(), Color( nColorData ) ) );
basegfx::B2DPolygon aTempPoly;
aTempPoly.append(basegfx::B2DPoint(aStartPos.X(), aStartPos.Y()));
aTempPoly.append(basegfx::B2DPoint(aEndPos.X(), aEndPos.Y()));
SdrPathObj* pArrow = new SdrPathObj(OBJ_LINE, basegfx::B2DPolyPolygon(aTempPoly));
pArrow->NbcSetLogicRect(Rectangle(aStartPos,aEndPos)); //! noetig ???
pArrow->SetMergedItemSetAndBroadcast(rAttrSet);
ScDrawLayer::SetAnchor( pArrow, SCA_CELL );
pArrow->SetLayer( SC_LAYER_INTERN );
pPage->InsertObject( pArrow );
pModel->AddCalcUndo< SdrUndoInsertObj >( *pArrow );
ScDrawObjData* pData = ScDrawLayer::GetObjData( pArrow, sal_True );
pData->maStart.Set( nStartCol, nStartRow, nTab);
pData->maEnd.SetInvalid();
Modified();
return sal_True;
}
//------------------------------------------------------------------------
// DrawEntry: Formel auf dieser Tabelle,
// Referenz auf dieser oder anderer
// DrawAlienEntry: Formel auf anderer Tabelle,
// Referenz auf dieser
// return FALSE: da war schon ein Pfeil
sal_Bool ScDetectiveFunc::DrawEntry( SCCOL nCol, SCROW nRow,
const ScRange& rRef,
ScDetectiveData& rData )
{
if ( HasArrow( rRef.aStart, nCol, nRow, nTab ) )
return sal_False;
ScAddress aErrorPos;
sal_Bool bError = HasError( rRef, aErrorPos );
sal_Bool bAlien = ( rRef.aEnd.Tab() < nTab || rRef.aStart.Tab() > nTab );
return InsertArrow( nCol, nRow,
rRef.aStart.Col(), rRef.aStart.Row(),
rRef.aEnd.Col(), rRef.aEnd.Row(),
bAlien, bError, rData );
}
sal_Bool ScDetectiveFunc::DrawAlienEntry( const ScRange& rRef,
ScDetectiveData& rData )
{
if ( HasArrow( rRef.aStart, 0, 0, nTab+1 ) )
return sal_False;
ScAddress aErrorPos;
sal_Bool bError = HasError( rRef, aErrorPos );
return InsertToOtherTab( rRef.aStart.Col(), rRef.aStart.Row(),
rRef.aEnd.Col(), rRef.aEnd.Row(),
bError, rData );
}
void ScDetectiveFunc::DrawCircle( SCCOL nCol, SCROW nRow, ScDetectiveData& rData )
{
ScDrawLayer* pModel = pDoc->GetDrawLayer();
SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
Rectangle aRect = GetDrawRect( nCol, nRow );
aRect.Left() -= 250;
aRect.Right() += 250;
aRect.Top() -= 70;
aRect.Bottom() += 70;
SdrCircObj* pCircle = new SdrCircObj( OBJ_CIRC, aRect );
SfxItemSet& rAttrSet = rData.GetCircleSet();
pCircle->SetMergedItemSetAndBroadcast(rAttrSet);
ScDrawLayer::SetAnchor( pCircle, SCA_CELL );
pCircle->SetLayer( SC_LAYER_INTERN );
pPage->InsertObject( pCircle );
pModel->AddCalcUndo< SdrUndoInsertObj >( *pCircle );
ScDrawObjData* pData = ScDrawLayer::GetObjData( pCircle, sal_True );
pData->maStart.Set( nCol, nRow, nTab);
pData->maEnd.SetInvalid();
Modified();
}
void ScDetectiveFunc::DeleteArrowsAt( SCCOL nCol, SCROW nRow, sal_Bool bDestPnt )
{
Rectangle aRect = GetDrawRect( nCol, nRow );
ScDrawLayer* pModel = pDoc->GetDrawLayer();
SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
DBG_ASSERT(pPage,"Page ?");
pPage->RecalcObjOrdNums();
long nDelCount = 0;
sal_uLong nObjCount = pPage->GetObjCount();
if (nObjCount)
{
SdrObject** ppObj = new SdrObject*[nObjCount];
SdrObjListIter aIter( *pPage, IM_FLAT );
SdrObject* pObject = aIter.Next();
while (pObject)
{
if ( pObject->GetLayer()==SC_LAYER_INTERN &&
pObject->IsPolyObj() && pObject->GetPointCount()==2 )
{
if (aRect.IsInside(pObject->GetPoint(bDestPnt))) // Start/Zielpunkt
ppObj[nDelCount++] = pObject;
}
pObject = aIter.Next();
}
long i;
for (i=1; i<=nDelCount; i++)
pModel->AddCalcUndo< SdrUndoRemoveObj >( *ppObj[nDelCount-i] );
for (i=1; i<=nDelCount; i++)
pPage->RemoveObject( ppObj[nDelCount-i]->GetOrdNum() );
delete[] ppObj;
Modified();
}
}
// Box um Referenz loeschen
#define SC_DET_TOLERANCE 50
inline sal_Bool RectIsPoints( const Rectangle& rRect, const Point& rStart, const Point& rEnd )
{
return rRect.Left() >= rStart.X() - SC_DET_TOLERANCE
&& rRect.Left() <= rStart.X() + SC_DET_TOLERANCE
&& rRect.Right() >= rEnd.X() - SC_DET_TOLERANCE
&& rRect.Right() <= rEnd.X() + SC_DET_TOLERANCE
&& rRect.Top() >= rStart.Y() - SC_DET_TOLERANCE
&& rRect.Top() <= rStart.Y() + SC_DET_TOLERANCE
&& rRect.Bottom() >= rEnd.Y() - SC_DET_TOLERANCE
&& rRect.Bottom() <= rEnd.Y() + SC_DET_TOLERANCE;
}
#undef SC_DET_TOLERANCE
void ScDetectiveFunc::DeleteBox( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
{
/* String aStr;
aStr += nCol1;
aStr += '/';
aStr += nRow1;
aStr += '/';
aStr += nCol2;
aStr += '/';
aStr += nRow2;
InfoBox(0,aStr).Execute();
*/
Rectangle aCornerRect = GetDrawRect( nCol1, nRow1, nCol2, nRow2 );
Point aStartCorner = aCornerRect.TopLeft();
Point aEndCorner = aCornerRect.BottomRight();
Rectangle aObjRect;
ScDrawLayer* pModel = pDoc->GetDrawLayer();
SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
DBG_ASSERT(pPage,"Page ?");
pPage->RecalcObjOrdNums();
long nDelCount = 0;
sal_uLong nObjCount = pPage->GetObjCount();
if (nObjCount)
{
SdrObject** ppObj = new SdrObject*[nObjCount];
SdrObjListIter aIter( *pPage, IM_FLAT );
SdrObject* pObject = aIter.Next();
while (pObject)
{
if ( pObject->GetLayer() == SC_LAYER_INTERN &&
pObject->Type() == TYPE(SdrRectObj) )
{
aObjRect = ((SdrRectObj*)pObject)->GetLogicRect();
aObjRect.Justify();
if ( RectIsPoints( aObjRect, aStartCorner, aEndCorner ) )
ppObj[nDelCount++] = pObject;
}
pObject = aIter.Next();
}
long i;
for (i=1; i<=nDelCount; i++)
pModel->AddCalcUndo< SdrUndoRemoveObj >( *ppObj[nDelCount-i] );
for (i=1; i<=nDelCount; i++)
pPage->RemoveObject( ppObj[nDelCount-i]->GetOrdNum() );
delete[] ppObj;
Modified();
}
}
//------------------------------------------------------------------------
sal_uInt16 ScDetectiveFunc::InsertPredLevelArea( const ScRange& rRef,
ScDetectiveData& rData, sal_uInt16 nLevel )
{
sal_uInt16 nResult = DET_INS_EMPTY;
ScCellIterator aCellIter( pDoc, rRef);
ScBaseCell* pCell = aCellIter.GetFirst();
while (pCell)
{
if (pCell->GetCellType() == CELLTYPE_FORMULA)
switch( InsertPredLevel( aCellIter.GetCol(), aCellIter.GetRow(), rData, nLevel ) )
{
case DET_INS_INSERTED:
nResult = DET_INS_INSERTED;
break;
case DET_INS_CONTINUE:
if (nResult != DET_INS_INSERTED)
nResult = DET_INS_CONTINUE;
break;
case DET_INS_CIRCULAR:
if (nResult == DET_INS_EMPTY)
nResult = DET_INS_CIRCULAR;
break;
}
pCell = aCellIter.GetNext();
}
return nResult;
}
sal_uInt16 ScDetectiveFunc::InsertPredLevel( SCCOL nCol, SCROW nRow, ScDetectiveData& rData,
sal_uInt16 nLevel )
{
ScBaseCell* pCell;
pDoc->GetCell( nCol, nRow, nTab, pCell );
if (!pCell)
return DET_INS_EMPTY;
if (pCell->GetCellType() != CELLTYPE_FORMULA)
return DET_INS_EMPTY;
ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
if (pFCell->IsRunning())
return DET_INS_CIRCULAR;
if (pFCell->GetDirty())
pFCell->Interpret(); // nach SetRunning geht's nicht mehr!
pFCell->SetRunning(sal_True);
sal_uInt16 nResult = DET_INS_EMPTY;
ScDetectiveRefIter aIter( (ScFormulaCell*) pCell );
ScRange aRef;
while ( aIter.GetNextRef( aRef ) )
{
if (DrawEntry( nCol, nRow, aRef, rData ))
{
nResult = DET_INS_INSERTED; // neuer Pfeil eingetragen
}
else
{
// weiterverfolgen
if ( nLevel < rData.GetMaxLevel() )
{
sal_uInt16 nSubResult;
sal_Bool bArea = (aRef.aStart != aRef.aEnd);
if (bArea)
nSubResult = InsertPredLevelArea( aRef, rData, nLevel+1 );
else
nSubResult = InsertPredLevel( aRef.aStart.Col(), aRef.aStart.Row(),
rData, nLevel+1 );
switch (nSubResult)
{
case DET_INS_INSERTED:
nResult = DET_INS_INSERTED;
break;
case DET_INS_CONTINUE:
if (nResult != DET_INS_INSERTED)
nResult = DET_INS_CONTINUE;
break;
case DET_INS_CIRCULAR:
if (nResult == DET_INS_EMPTY)
nResult = DET_INS_CIRCULAR;
break;
// DET_INS_EMPTY: unveraendert lassen
}
}
else // nMaxLevel erreicht
if (nResult != DET_INS_INSERTED)
nResult = DET_INS_CONTINUE;
}
}
pFCell->SetRunning(sal_False);
return nResult;
}
sal_uInt16 ScDetectiveFunc::FindPredLevelArea( const ScRange& rRef,
sal_uInt16 nLevel, sal_uInt16 nDeleteLevel )
{
sal_uInt16 nResult = nLevel;
ScCellIterator aCellIter( pDoc, rRef);
ScBaseCell* pCell = aCellIter.GetFirst();
while (pCell)
{
if (pCell->GetCellType() == CELLTYPE_FORMULA)
{
sal_uInt16 nTemp = FindPredLevel( aCellIter.GetCol(), aCellIter.GetRow(), nLevel, nDeleteLevel );
if (nTemp > nResult)
nResult = nTemp;
}
pCell = aCellIter.GetNext();
}
return nResult;
}
// nDeleteLevel != 0 -> loeschen
sal_uInt16 ScDetectiveFunc::FindPredLevel( SCCOL nCol, SCROW nRow, sal_uInt16 nLevel, sal_uInt16 nDeleteLevel )
{
DBG_ASSERT( nLevel<1000, "Level" );
ScBaseCell* pCell;
pDoc->GetCell( nCol, nRow, nTab, pCell );
if (!pCell)
return nLevel;
if (pCell->GetCellType() != CELLTYPE_FORMULA)
return nLevel;
ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
if (pFCell->IsRunning())
return nLevel;
if (pFCell->GetDirty())
pFCell->Interpret(); // nach SetRunning geht's nicht mehr!
pFCell->SetRunning(sal_True);
sal_uInt16 nResult = nLevel;
sal_Bool bDelete = ( nDeleteLevel && nLevel == nDeleteLevel-1 );
if ( bDelete )
{
DeleteArrowsAt( nCol, nRow, sal_True ); // Pfeile, die hierher zeigen
}
ScDetectiveRefIter aIter( (ScFormulaCell*) pCell );
ScRange aRef;
while ( aIter.GetNextRef( aRef) )
{
sal_Bool bArea = ( aRef.aStart != aRef.aEnd );
if ( bDelete ) // Rahmen loeschen ?
{
if (bArea)
{
DeleteBox( aRef.aStart.Col(), aRef.aStart.Row(), aRef.aEnd.Col(), aRef.aEnd.Row() );
}
}
else // weitersuchen
{
if ( HasArrow( aRef.aStart, nCol,nRow,nTab ) )
{
sal_uInt16 nTemp;
if (bArea)
nTemp = FindPredLevelArea( aRef, nLevel+1, nDeleteLevel );
else
nTemp = FindPredLevel( aRef.aStart.Col(),aRef.aStart.Row(),
nLevel+1, nDeleteLevel );
if (nTemp > nResult)
nResult = nTemp;
}
}
}
pFCell->SetRunning(sal_False);
return nResult;
}
//------------------------------------------------------------------------
sal_uInt16 ScDetectiveFunc::InsertErrorLevel( SCCOL nCol, SCROW nRow, ScDetectiveData& rData,
sal_uInt16 nLevel )
{
ScBaseCell* pCell;
pDoc->GetCell( nCol, nRow, nTab, pCell );
if (!pCell)
return DET_INS_EMPTY;
if (pCell->GetCellType() != CELLTYPE_FORMULA)
return DET_INS_EMPTY;
ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
if (pFCell->IsRunning())
return DET_INS_CIRCULAR;
if (pFCell->GetDirty())
pFCell->Interpret(); // nach SetRunning geht's nicht mehr!
pFCell->SetRunning(sal_True);
sal_uInt16 nResult = DET_INS_EMPTY;
ScDetectiveRefIter aIter( (ScFormulaCell*) pCell );
ScRange aRef;
ScAddress aErrorPos;
sal_Bool bHasError = sal_False;
while ( aIter.GetNextRef( aRef ) )
{
if (HasError( aRef, aErrorPos ))
{
bHasError = sal_True;
if (DrawEntry( nCol, nRow, ScRange( aErrorPos), rData ))
nResult = DET_INS_INSERTED;
// und weiterverfolgen
if ( nLevel < rData.GetMaxLevel() ) // praktisch immer
{
if (InsertErrorLevel( aErrorPos.Col(), aErrorPos.Row(),
rData, nLevel+1 ) == DET_INS_INSERTED)
nResult = DET_INS_INSERTED;
}
}
}
pFCell->SetRunning(sal_False);
// Blaetter ?
if (!bHasError)
if (InsertPredLevel( nCol, nRow, rData, rData.GetMaxLevel() ) == DET_INS_INSERTED)
nResult = DET_INS_INSERTED;
return nResult;
}
//------------------------------------------------------------------------
sal_uInt16 ScDetectiveFunc::InsertSuccLevel( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
ScDetectiveData& rData, sal_uInt16 nLevel )
{
// ueber ganzes Dokument
sal_uInt16 nResult = DET_INS_EMPTY;
// ScCellIterator aCellIter( pDoc, 0,0, nTab, MAXCOL,MAXROW, nTab );
ScCellIterator aCellIter( pDoc, 0,0,0, MAXCOL,MAXROW,MAXTAB ); // alle Tabellen
ScBaseCell* pCell = aCellIter.GetFirst();
while (pCell)
{
if (pCell->GetCellType() == CELLTYPE_FORMULA)
{
ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
sal_Bool bRunning = pFCell->IsRunning();
if (pFCell->GetDirty())
pFCell->Interpret(); // nach SetRunning geht's nicht mehr!
pFCell->SetRunning(sal_True);
ScDetectiveRefIter aIter( (ScFormulaCell*) pCell );
ScRange aRef;
while ( aIter.GetNextRef( aRef) )
{
if (aRef.aStart.Tab() <= nTab && aRef.aEnd.Tab() >= nTab)
{
if (Intersect( nCol1,nRow1,nCol2,nRow2,
aRef.aStart.Col(),aRef.aStart.Row(),
aRef.aEnd.Col(),aRef.aEnd.Row() ))
{
sal_Bool bAlien = ( aCellIter.GetTab() != nTab );
sal_Bool bDrawRet;
if (bAlien)
bDrawRet = DrawAlienEntry( aRef, rData );
else
bDrawRet = DrawEntry( aCellIter.GetCol(), aCellIter.GetRow(),
aRef, rData );
if (bDrawRet)
{
nResult = DET_INS_INSERTED; // neuer Pfeil eingetragen
}
else
{
if (bRunning)
{
if (nResult == DET_INS_EMPTY)
nResult = DET_INS_CIRCULAR;
}
else
{
// weiterverfolgen
if ( nLevel < rData.GetMaxLevel() )
{
sal_uInt16 nSubResult = InsertSuccLevel(
aCellIter.GetCol(), aCellIter.GetRow(),
aCellIter.GetCol(), aCellIter.GetRow(),
rData, nLevel+1 );
switch (nSubResult)
{
case DET_INS_INSERTED:
nResult = DET_INS_INSERTED;
break;
case DET_INS_CONTINUE:
if (nResult != DET_INS_INSERTED)
nResult = DET_INS_CONTINUE;
break;
case DET_INS_CIRCULAR:
if (nResult == DET_INS_EMPTY)
nResult = DET_INS_CIRCULAR;
break;
// DET_INS_EMPTY: unveraendert lassen
}
}
else // nMaxLevel erreicht
if (nResult != DET_INS_INSERTED)
nResult = DET_INS_CONTINUE;
}
}
}
}
}
pFCell->SetRunning(bRunning);
}
pCell = aCellIter.GetNext();
}
return nResult;
}
sal_uInt16 ScDetectiveFunc::FindSuccLevel( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
sal_uInt16 nLevel, sal_uInt16 nDeleteLevel )
{
DBG_ASSERT( nLevel<1000, "Level" );
sal_uInt16 nResult = nLevel;
sal_Bool bDelete = ( nDeleteLevel && nLevel == nDeleteLevel-1 );
ScCellIterator aCellIter( pDoc, 0,0, nTab, MAXCOL,MAXROW, nTab );
ScBaseCell* pCell = aCellIter.GetFirst();
while (pCell)
{
if (pCell->GetCellType() == CELLTYPE_FORMULA)
{
ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
sal_Bool bRunning = pFCell->IsRunning();
if (pFCell->GetDirty())
pFCell->Interpret(); // nach SetRunning geht's nicht mehr!
pFCell->SetRunning(sal_True);
ScDetectiveRefIter aIter( (ScFormulaCell*) pCell );
ScRange aRef;
while ( aIter.GetNextRef( aRef) )
{
if (aRef.aStart.Tab() <= nTab && aRef.aEnd.Tab() >= nTab)
{
if (Intersect( nCol1,nRow1,nCol2,nRow2,
aRef.aStart.Col(),aRef.aStart.Row(),
aRef.aEnd.Col(),aRef.aEnd.Row() ))
{
if ( bDelete ) // Pfeile, die hier anfangen
{
if (aRef.aStart != aRef.aEnd)
{
DeleteBox( aRef.aStart.Col(), aRef.aStart.Row(),
aRef.aEnd.Col(), aRef.aEnd.Row() );
}
DeleteArrowsAt( aRef.aStart.Col(), aRef.aStart.Row(), sal_False );
}
else if ( !bRunning &&
HasArrow( aRef.aStart,
aCellIter.GetCol(),aCellIter.GetRow(),aCellIter.GetTab() ) )
{
sal_uInt16 nTemp = FindSuccLevel( aCellIter.GetCol(), aCellIter.GetRow(),
aCellIter.GetCol(), aCellIter.GetRow(),
nLevel+1, nDeleteLevel );
if (nTemp > nResult)
nResult = nTemp;
}
}
}
}
pFCell->SetRunning(bRunning);
}
pCell = aCellIter.GetNext();
}
return nResult;
}
//
// --------------------------------------------------------------------------------
//
sal_Bool ScDetectiveFunc::ShowPred( SCCOL nCol, SCROW nRow )
{
ScDrawLayer* pModel = pDoc->GetDrawLayer();
if (!pModel)
return sal_False;
ScDetectiveData aData( pModel );
sal_uInt16 nMaxLevel = 0;
sal_uInt16 nResult = DET_INS_CONTINUE;
while (nResult == DET_INS_CONTINUE && nMaxLevel < 1000)
{
aData.SetMaxLevel( nMaxLevel );
nResult = InsertPredLevel( nCol, nRow, aData, 0 );
++nMaxLevel;
}
return ( nResult == DET_INS_INSERTED );
}
sal_Bool ScDetectiveFunc::ShowSucc( SCCOL nCol, SCROW nRow )
{
ScDrawLayer* pModel = pDoc->GetDrawLayer();
if (!pModel)
return sal_False;
ScDetectiveData aData( pModel );
sal_uInt16 nMaxLevel = 0;
sal_uInt16 nResult = DET_INS_CONTINUE;
while (nResult == DET_INS_CONTINUE && nMaxLevel < 1000)
{
aData.SetMaxLevel( nMaxLevel );
nResult = InsertSuccLevel( nCol, nRow, nCol, nRow, aData, 0 );
++nMaxLevel;
}
return ( nResult == DET_INS_INSERTED );
}
sal_Bool ScDetectiveFunc::ShowError( SCCOL nCol, SCROW nRow )
{
ScDrawLayer* pModel = pDoc->GetDrawLayer();
if (!pModel)
return sal_False;
ScRange aRange( nCol, nRow, nTab );
ScAddress aErrPos;
if ( !HasError( aRange,aErrPos ) )
return sal_False;
ScDetectiveData aData( pModel );
aData.SetMaxLevel( 1000 );
sal_uInt16 nResult = InsertErrorLevel( nCol, nRow, aData, 0 );
return ( nResult == DET_INS_INSERTED );
}
sal_Bool ScDetectiveFunc::DeleteSucc( SCCOL nCol, SCROW nRow )
{
ScDrawLayer* pModel = pDoc->GetDrawLayer();
if (!pModel)
return sal_False;
sal_uInt16 nLevelCount = FindSuccLevel( nCol, nRow, nCol, nRow, 0, 0 );
if ( nLevelCount )
FindSuccLevel( nCol, nRow, nCol, nRow, 0, nLevelCount ); // loeschen
return ( nLevelCount != 0 );
}
sal_Bool ScDetectiveFunc::DeletePred( SCCOL nCol, SCROW nRow )
{
ScDrawLayer* pModel = pDoc->GetDrawLayer();
if (!pModel)
return sal_False;
sal_uInt16 nLevelCount = FindPredLevel( nCol, nRow, 0, 0 );
if ( nLevelCount )
FindPredLevel( nCol, nRow, 0, nLevelCount ); // loeschen
return ( nLevelCount != 0 );
}
sal_Bool ScDetectiveFunc::DeleteAll( ScDetectiveDelete eWhat )
{
ScDrawLayer* pModel = pDoc->GetDrawLayer();
if (!pModel)
return sal_False;
SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
DBG_ASSERT(pPage,"Page ?");
pPage->RecalcObjOrdNums();
long nDelCount = 0;
sal_uLong nObjCount = pPage->GetObjCount();
if (nObjCount)
{
SdrObject** ppObj = new SdrObject*[nObjCount];
SdrObjListIter aIter( *pPage, IM_FLAT );
SdrObject* pObject = aIter.Next();
while (pObject)
{
if ( pObject->GetLayer() == SC_LAYER_INTERN )
{
sal_Bool bDoThis = sal_True;
if ( eWhat != SC_DET_ALL )
{
sal_Bool bCircle = ( pObject->ISA(SdrCircObj) );
sal_Bool bCaption = ScDrawLayer::IsNoteCaption( pObject );
if ( eWhat == SC_DET_DETECTIVE ) // Detektiv, aus Menue
bDoThis = !bCaption; // auch Kreise
else if ( eWhat == SC_DET_CIRCLES ) // Kreise, wenn neue erzeugt werden
bDoThis = bCircle;
else if ( eWhat == SC_DET_ARROWS ) // DetectiveRefresh
bDoThis = !bCaption && !bCircle; // don't include circles
else
{
DBG_ERROR("wat?");
}
}
if ( bDoThis )
ppObj[nDelCount++] = pObject;
}
pObject = aIter.Next();
}
long i;
for (i=1; i<=nDelCount; i++)
pModel->AddCalcUndo< SdrUndoRemoveObj >( *ppObj[nDelCount-i] );
for (i=1; i<=nDelCount; i++)
pPage->RemoveObject( ppObj[nDelCount-i]->GetOrdNum() );
delete[] ppObj;
Modified();
}
return ( nDelCount != 0 );
}
sal_Bool ScDetectiveFunc::MarkInvalid(sal_Bool& rOverflow)
{
rOverflow = sal_False;
ScDrawLayer* pModel = pDoc->GetDrawLayer();
if (!pModel)
return sal_False;
sal_Bool bDeleted = DeleteAll( SC_DET_CIRCLES ); // nur die Kreise
ScDetectiveData aData( pModel );
long nInsCount = 0;
// Stellen suchen, wo Gueltigkeit definiert ist
ScDocAttrIterator aAttrIter( pDoc, nTab, 0,0,MAXCOL,MAXROW );
SCCOL nCol;
SCROW nRow1;
SCROW nRow2;
const ScPatternAttr* pPattern = aAttrIter.GetNext( nCol, nRow1, nRow2 );
while ( pPattern && nInsCount < SC_DET_MAXCIRCLE )
{
sal_uLong nIndex = ((const SfxUInt32Item&)pPattern->GetItem(ATTR_VALIDDATA)).GetValue();
if (nIndex)
{
const ScValidationData* pData = pDoc->GetValidationEntry( nIndex );
if ( pData )
{
// Zellen in dem Bereich durchgehen
sal_Bool bMarkEmpty = !pData->IsIgnoreBlank();
SCROW nNextRow = nRow1;
SCROW nRow;
ScCellIterator aCellIter( pDoc, nCol,nRow1,nTab, nCol,nRow2,nTab );
ScBaseCell* pCell = aCellIter.GetFirst();
while ( pCell && nInsCount < SC_DET_MAXCIRCLE )
{
SCROW nCellRow = aCellIter.GetRow();
if ( bMarkEmpty )
for ( nRow = nNextRow; nRow < nCellRow && nInsCount < SC_DET_MAXCIRCLE; nRow++ )
{
DrawCircle( nCol, nRow, aData );
++nInsCount;
}
if ( !pData->IsDataValid( pCell, ScAddress( nCol, nCellRow, nTab ) ) )
{
DrawCircle( nCol, nCellRow, aData );
++nInsCount;
}
nNextRow = nCellRow + 1;
pCell = aCellIter.GetNext();
}
if ( bMarkEmpty )
for ( nRow = nNextRow; nRow <= nRow2 && nInsCount < SC_DET_MAXCIRCLE; nRow++ )
{
DrawCircle( nCol, nRow, aData );
++nInsCount;
}
}
}
pPattern = aAttrIter.GetNext( nCol, nRow1, nRow2 );
}
if ( nInsCount >= SC_DET_MAXCIRCLE )
rOverflow = sal_True;
return ( bDeleted || nInsCount != 0 );
}
void ScDetectiveFunc::UpdateAllComments( ScDocument& rDoc )
{
// for all caption objects, update attributes and SpecialTextBoxShadow flag
// (on all tables - nTab is ignored!)
// no undo actions, this is refreshed after undo
ScDrawLayer* pModel = rDoc.GetDrawLayer();
if (!pModel)
return;
for( SCTAB nObjTab = 0, nTabCount = rDoc.GetTableCount(); nObjTab < nTabCount; ++nObjTab )
{
rDoc.InitializeNoteCaptions( nObjTab );
SdrPage* pPage = pModel->GetPage( static_cast< sal_uInt16 >( nObjTab ) );
DBG_ASSERT( pPage, "Page ?" );
if( pPage )
{
SdrObjListIter aIter( *pPage, IM_FLAT );
for( SdrObject* pObject = aIter.Next(); pObject; pObject = aIter.Next() )
{
if ( ScDrawObjData* pData = ScDrawLayer::GetNoteCaptionData( pObject, nObjTab ) )
{
ScPostIt* pNote = rDoc.GetNote( pData->maStart );
// caption should exist, we iterate over drawing objects...
DBG_ASSERT( pNote && (pNote->GetCaption() == pObject), "ScDetectiveFunc::UpdateAllComments - invalid cell note" );
if( pNote )
{
ScCommentData aData( rDoc, pModel );
SfxItemSet aAttrColorSet = pObject->GetMergedItemSet();
aAttrColorSet.Put( XFillColorItem( String(), GetCommentColor() ) );
aData.UpdateCaptionSet( aAttrColorSet );
pObject->SetMergedItemSetAndBroadcast( aData.GetCaptionSet() );
if( SdrCaptionObj* pCaption = dynamic_cast< SdrCaptionObj* >( pObject ) )
{
pCaption->SetSpecialTextBoxShadow();
pCaption->SetFixedTail();
}
}
}
}
}
}
}
void ScDetectiveFunc::UpdateAllArrowColors()
{
// no undo actions necessary
ScDrawLayer* pModel = pDoc->GetDrawLayer();
if (!pModel)
return;
for( SCTAB nObjTab = 0, nTabCount = pDoc->GetTableCount(); nObjTab < nTabCount; ++nObjTab )
{
SdrPage* pPage = pModel->GetPage( static_cast< sal_uInt16 >( nObjTab ) );
DBG_ASSERT( pPage, "Page ?" );
if( pPage )
{
SdrObjListIter aIter( *pPage, IM_FLAT );
for( SdrObject* pObject = aIter.Next(); pObject; pObject = aIter.Next() )
{
if ( pObject->GetLayer() == SC_LAYER_INTERN )
{
sal_Bool bArrow = sal_False;
sal_Bool bError = sal_False;
ScAddress aPos;
ScRange aSource;
sal_Bool bDummy;
ScDetectiveObjType eType = GetDetectiveObjectType( pObject, nObjTab, aPos, aSource, bDummy );
if ( eType == SC_DETOBJ_ARROW || eType == SC_DETOBJ_TOOTHERTAB )
{
// source is valid, determine error flag from source range
ScAddress aErrPos;
if ( HasError( aSource, aErrPos ) )
bError = sal_True;
else
bArrow = sal_True;
}
else if ( eType == SC_DETOBJ_FROMOTHERTAB )
{
// source range is no longer known, take error flag from formula itself
// (this means, if the formula has an error, all references to other tables
// are marked red)
ScAddress aErrPos;
if ( HasError( ScRange( aPos), aErrPos ) )
bError = sal_True;
else
bArrow = sal_True;
}
else if ( eType == SC_DETOBJ_CIRCLE )
{
// circles (error marks) are always red
bError = sal_True;
}
else if ( eType == SC_DETOBJ_NONE )
{
// frame for area reference has no ObjType, always gets arrow color
if ( pObject->ISA( SdrRectObj ) && !pObject->ISA( SdrCaptionObj ) )
{
bArrow = sal_True;
}
}
if ( bArrow || bError )
{
ColorData nColorData = ( bError ? GetErrorColor() : GetArrowColor() );
//pObject->SendRepaintBroadcast(pObject->GetBoundRect());
pObject->SetMergedItem( XLineColorItem( String(), Color( nColorData ) ) );
// repaint only
pObject->ActionChanged();
// pObject->SendRepaintBroadcast(pObject->GetBoundRect());
}
}
}
}
}
}
sal_Bool ScDetectiveFunc::FindFrameForObject( SdrObject* pObject, ScRange& rRange )
{
// find the rectangle for an arrow (always the object directly before the arrow)
// rRange must be initialized to the source cell of the arrow (start of area)
ScDrawLayer* pModel = pDoc->GetDrawLayer();
if (!pModel) return sal_False;
SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
DBG_ASSERT(pPage,"Page ?");
if (!pPage) return sal_False;
// test if the object is a direct page member
if( pObject && pObject->GetPage() && (pObject->GetPage() == pObject->GetObjList()) )
{
// Is there a previous object?
const sal_uInt32 nOrdNum(pObject->GetOrdNum());
if(nOrdNum > 0)
{
SdrObject* pPrevObj = pPage->GetObj(nOrdNum - 1);
if ( pPrevObj && pPrevObj->GetLayer() == SC_LAYER_INTERN && pPrevObj->ISA(SdrRectObj) )
{
ScDrawObjData* pPrevData = ScDrawLayer::GetObjDataTab( pPrevObj, rRange.aStart.Tab() );
if ( pPrevData && pPrevData->maStart.IsValid() && pPrevData->maEnd.IsValid() && (pPrevData->maStart == rRange.aStart) )
{
rRange.aEnd = pPrevData->maEnd;
return sal_True;
}
}
}
}
return sal_False;
}
ScDetectiveObjType ScDetectiveFunc::GetDetectiveObjectType( SdrObject* pObject, SCTAB nObjTab,
ScAddress& rPosition, ScRange& rSource, sal_Bool& rRedLine )
{
rRedLine = sal_False;
ScDetectiveObjType eType = SC_DETOBJ_NONE;
if ( pObject && pObject->GetLayer() == SC_LAYER_INTERN )
{
if ( ScDrawObjData* pData = ScDrawLayer::GetObjDataTab( pObject, nObjTab ) )
{
bool bValidStart = pData->maStart.IsValid();
bool bValidEnd = pData->maEnd.IsValid();
if ( pObject->IsPolyObj() && pObject->GetPointCount() == 2 )
{
// line object -> arrow
if ( bValidStart )
eType = bValidEnd ? SC_DETOBJ_ARROW : SC_DETOBJ_TOOTHERTAB;
else if ( bValidEnd )
eType = SC_DETOBJ_FROMOTHERTAB;
if ( bValidStart )
rSource = pData->maStart;
if ( bValidEnd )
rPosition = pData->maEnd;
if ( bValidStart && lcl_HasThickLine( *pObject ) )
{
// thick line -> look for frame before this object
FindFrameForObject( pObject, rSource ); // modifies rSource
}
ColorData nObjColor = ((const XLineColorItem&)pObject->GetMergedItem(XATTR_LINECOLOR)).GetColorValue().GetColor();
if ( nObjColor == GetErrorColor() && nObjColor != GetArrowColor() )
rRedLine = sal_True;
}
else if ( pObject->ISA(SdrCircObj) )
{
if ( bValidStart )
{
// cell position is returned in rPosition
rPosition = pData->maStart;
eType = SC_DETOBJ_CIRCLE;
}
}
}
}
return eType;
}
void ScDetectiveFunc::InsertObject( ScDetectiveObjType eType,
const ScAddress& rPosition, const ScRange& rSource,
sal_Bool bRedLine )
{
ScDrawLayer* pModel = pDoc->GetDrawLayer();
if (!pModel) return;
ScDetectiveData aData( pModel );
switch (eType)
{
case SC_DETOBJ_ARROW:
case SC_DETOBJ_FROMOTHERTAB:
InsertArrow( rPosition.Col(), rPosition.Row(),
rSource.aStart.Col(), rSource.aStart.Row(),
rSource.aEnd.Col(), rSource.aEnd.Row(),
(eType == SC_DETOBJ_FROMOTHERTAB), bRedLine, aData );
break;
case SC_DETOBJ_TOOTHERTAB:
InsertToOtherTab( rSource.aStart.Col(), rSource.aStart.Row(),
rSource.aEnd.Col(), rSource.aEnd.Row(),
bRedLine, aData );
break;
case SC_DETOBJ_CIRCLE:
DrawCircle( rPosition.Col(), rPosition.Row(), aData );
break;
default:
{
// added to avoid warnings
}
}
}
// static
ColorData ScDetectiveFunc::GetArrowColor()
{
if (!bColorsInitialized)
InitializeColors();
return nArrowColor;
}
// static
ColorData ScDetectiveFunc::GetErrorColor()
{
if (!bColorsInitialized)
InitializeColors();
return nErrorColor;
}
// static
ColorData ScDetectiveFunc::GetCommentColor()
{
if (!bColorsInitialized)
InitializeColors();
return nCommentColor;
}
// static
void ScDetectiveFunc::InitializeColors()
{
// may be called several times to update colors from configuration
const svtools::ColorConfig& rColorCfg = SC_MOD()->GetColorConfig();
nArrowColor = rColorCfg.GetColorValue(svtools::CALCDETECTIVE).nColor;
nErrorColor = rColorCfg.GetColorValue(svtools::CALCDETECTIVEERROR).nColor;
nCommentColor = rColorCfg.GetColorValue(svtools::CALCNOTESBACKGROUND).nColor;
bColorsInitialized = sal_True;
}
// static
sal_Bool ScDetectiveFunc::IsColorsInitialized()
{
return bColorsInitialized;
}
void ScDetectiveFunc::AppendChangTrackNoteSeparator(String &aDisplay)
{
aDisplay.AppendAscii( RTL_CONSTASCII_STRINGPARAM("\n--------\n") );
}