1b3f79822SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3b3f79822SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4b3f79822SAndrew Rist * or more contributor license agreements. See the NOTICE file
5b3f79822SAndrew Rist * distributed with this work for additional information
6b3f79822SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7b3f79822SAndrew Rist * to you under the Apache License, Version 2.0 (the
8b3f79822SAndrew Rist * "License"); you may not use this file except in compliance
9b3f79822SAndrew Rist * with the License. You may obtain a copy of the License at
10b3f79822SAndrew Rist *
11b3f79822SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12b3f79822SAndrew Rist *
13b3f79822SAndrew Rist * Unless required by applicable law or agreed to in writing,
14b3f79822SAndrew Rist * software distributed under the License is distributed on an
15b3f79822SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16b3f79822SAndrew Rist * KIND, either express or implied. See the License for the
17b3f79822SAndrew Rist * specific language governing permissions and limitations
18b3f79822SAndrew Rist * under the License.
19b3f79822SAndrew Rist *
20b3f79822SAndrew Rist *************************************************************/
21b3f79822SAndrew Rist
22b3f79822SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sc.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir // INCLUDE ---------------------------------------------------------------
28cdf0e10cSrcweir
29cdf0e10cSrcweir #include "scitems.hxx"
30cdf0e10cSrcweir #include <svtools/colorcfg.hxx>
31cdf0e10cSrcweir #include <editeng/eeitem.hxx>
32cdf0e10cSrcweir #include <editeng/outlobj.hxx>
33cdf0e10cSrcweir #include <svx/sdshitm.hxx>
34cdf0e10cSrcweir #include <svx/sdsxyitm.hxx>
35cdf0e10cSrcweir #include <svx/sdtditm.hxx>
36cdf0e10cSrcweir #include <svx/svditer.hxx>
37cdf0e10cSrcweir #include <svx/svdocapt.hxx>
38cdf0e10cSrcweir #include <svx/svdocirc.hxx>
39cdf0e10cSrcweir #include <svx/svdopath.hxx>
40cdf0e10cSrcweir #include <svx/svdorect.hxx>
41cdf0e10cSrcweir #include <svx/svdpage.hxx>
42cdf0e10cSrcweir #include <svx/svdundo.hxx>
43cdf0e10cSrcweir #include <svx/xfillit0.hxx>
44cdf0e10cSrcweir #include <svx/xflclit.hxx>
45cdf0e10cSrcweir #include <svx/xlnclit.hxx>
46cdf0e10cSrcweir #include <svx/xlnedcit.hxx>
47cdf0e10cSrcweir #include <svx/xlnedit.hxx>
48cdf0e10cSrcweir #include <svx/xlnedwit.hxx>
49cdf0e10cSrcweir #include <svx/xlnstcit.hxx>
50cdf0e10cSrcweir #include <svx/xlnstit.hxx>
51cdf0e10cSrcweir #include <svx/xlnstwit.hxx>
52cdf0e10cSrcweir #include <svx/xlnwtit.hxx>
53cdf0e10cSrcweir #include <svx/xtable.hxx>
54cdf0e10cSrcweir #include <editeng/outliner.hxx>
55cdf0e10cSrcweir #include <editeng/editobj.hxx>
56cdf0e10cSrcweir #include <svx/sxcecitm.hxx>
57cdf0e10cSrcweir #include <svl/whiter.hxx>
58cdf0e10cSrcweir #include <editeng/writingmodeitem.hxx>
59cdf0e10cSrcweir
60cdf0e10cSrcweir #include <basegfx/point/b2dpoint.hxx>
61cdf0e10cSrcweir #include <basegfx/polygon/b2dpolygontools.hxx>
62cdf0e10cSrcweir #include <basegfx/polygon/b2dpolygon.hxx>
63cdf0e10cSrcweir
64cdf0e10cSrcweir #include "detfunc.hxx"
65cdf0e10cSrcweir #include "document.hxx"
66cdf0e10cSrcweir #include "dociter.hxx"
67cdf0e10cSrcweir #include "drwlayer.hxx"
68cdf0e10cSrcweir #include "userdat.hxx"
69cdf0e10cSrcweir #include "validat.hxx"
70cdf0e10cSrcweir #include "cell.hxx"
71cdf0e10cSrcweir #include "docpool.hxx"
72cdf0e10cSrcweir #include "patattr.hxx"
73cdf0e10cSrcweir #include "attrib.hxx"
74cdf0e10cSrcweir #include "scmod.hxx"
75cdf0e10cSrcweir #include "postit.hxx"
76cdf0e10cSrcweir
77cdf0e10cSrcweir //------------------------------------------------------------------------
78cdf0e10cSrcweir
79cdf0e10cSrcweir // #99319# line ends are now created with an empty name.
80cdf0e10cSrcweir // The checkForUniqueItem method then finds a unique name for the item's value.
81cdf0e10cSrcweir #define SC_LINEEND_NAME EMPTY_STRING
82cdf0e10cSrcweir
83cdf0e10cSrcweir //------------------------------------------------------------------------
84cdf0e10cSrcweir
85cdf0e10cSrcweir enum DetInsertResult { // Return-Werte beim Einfuegen in einen Level
86cdf0e10cSrcweir DET_INS_CONTINUE,
87cdf0e10cSrcweir DET_INS_INSERTED,
88cdf0e10cSrcweir DET_INS_EMPTY,
89cdf0e10cSrcweir DET_INS_CIRCULAR };
90cdf0e10cSrcweir
91cdf0e10cSrcweir
92cdf0e10cSrcweir //------------------------------------------------------------------------
93cdf0e10cSrcweir
94cdf0e10cSrcweir class ScDetectiveData
95cdf0e10cSrcweir {
96cdf0e10cSrcweir private:
97cdf0e10cSrcweir SfxItemSet aBoxSet;
98cdf0e10cSrcweir SfxItemSet aArrowSet;
99cdf0e10cSrcweir SfxItemSet aToTabSet;
100cdf0e10cSrcweir SfxItemSet aFromTabSet;
101cdf0e10cSrcweir SfxItemSet aCircleSet; //! einzeln ?
102cdf0e10cSrcweir sal_uInt16 nMaxLevel;
103cdf0e10cSrcweir
104cdf0e10cSrcweir public:
105cdf0e10cSrcweir ScDetectiveData( SdrModel* pModel );
106cdf0e10cSrcweir
GetBoxSet()107cdf0e10cSrcweir SfxItemSet& GetBoxSet() { return aBoxSet; }
GetArrowSet()108cdf0e10cSrcweir SfxItemSet& GetArrowSet() { return aArrowSet; }
GetToTabSet()109cdf0e10cSrcweir SfxItemSet& GetToTabSet() { return aToTabSet; }
GetFromTabSet()110cdf0e10cSrcweir SfxItemSet& GetFromTabSet() { return aFromTabSet; }
GetCircleSet()111cdf0e10cSrcweir SfxItemSet& GetCircleSet() { return aCircleSet; }
112cdf0e10cSrcweir
SetMaxLevel(sal_uInt16 nVal)113cdf0e10cSrcweir void SetMaxLevel( sal_uInt16 nVal ) { nMaxLevel = nVal; }
GetMaxLevel() const114cdf0e10cSrcweir sal_uInt16 GetMaxLevel() const { return nMaxLevel; }
115cdf0e10cSrcweir };
116cdf0e10cSrcweir
117cdf0e10cSrcweir class ScCommentData
118cdf0e10cSrcweir {
119cdf0e10cSrcweir public:
120cdf0e10cSrcweir ScCommentData( ScDocument& rDoc, SdrModel* pModel );
121cdf0e10cSrcweir
GetCaptionSet()122cdf0e10cSrcweir SfxItemSet& GetCaptionSet() { return aCaptionSet; }
123cdf0e10cSrcweir void UpdateCaptionSet( const SfxItemSet& rItemSet );
124cdf0e10cSrcweir
125cdf0e10cSrcweir private:
126cdf0e10cSrcweir SfxItemSet aCaptionSet;
127cdf0e10cSrcweir };
128cdf0e10cSrcweir
129cdf0e10cSrcweir //------------------------------------------------------------------------
130cdf0e10cSrcweir
131cdf0e10cSrcweir ColorData ScDetectiveFunc::nArrowColor = 0;
132cdf0e10cSrcweir ColorData ScDetectiveFunc::nErrorColor = 0;
133cdf0e10cSrcweir ColorData ScDetectiveFunc::nCommentColor = 0;
134cdf0e10cSrcweir sal_Bool ScDetectiveFunc::bColorsInitialized = sal_False;
135cdf0e10cSrcweir
136cdf0e10cSrcweir //------------------------------------------------------------------------
137cdf0e10cSrcweir
lcl_HasThickLine(SdrObject & rObj)138cdf0e10cSrcweir sal_Bool lcl_HasThickLine( SdrObject& rObj )
139cdf0e10cSrcweir {
140cdf0e10cSrcweir // thin lines get width 0 -> everything greater 0 is a thick line
141cdf0e10cSrcweir
142cdf0e10cSrcweir return ( ((const XLineWidthItem&)rObj.GetMergedItem(XATTR_LINEWIDTH)).GetValue() > 0 );
143cdf0e10cSrcweir }
144cdf0e10cSrcweir
145cdf0e10cSrcweir //------------------------------------------------------------------------
146cdf0e10cSrcweir
ScDetectiveData(SdrModel * pModel)147cdf0e10cSrcweir ScDetectiveData::ScDetectiveData( SdrModel* pModel ) :
148cdf0e10cSrcweir aBoxSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ),
149cdf0e10cSrcweir aArrowSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ),
150cdf0e10cSrcweir aToTabSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ),
151cdf0e10cSrcweir aFromTabSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END ),
152cdf0e10cSrcweir aCircleSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END )
153cdf0e10cSrcweir {
154cdf0e10cSrcweir nMaxLevel = 0;
155cdf0e10cSrcweir
156cdf0e10cSrcweir aBoxSet.Put( XLineColorItem( EMPTY_STRING, Color( ScDetectiveFunc::GetArrowColor() ) ) );
157cdf0e10cSrcweir aBoxSet.Put( XFillStyleItem( XFILL_NONE ) );
158cdf0e10cSrcweir
159cdf0e10cSrcweir // #66479# Standard-Linienenden (wie aus XLineEndList::Create) selber zusammenbasteln,
160cdf0e10cSrcweir // um von den konfigurierten Linienenden unabhaengig zu sein
161cdf0e10cSrcweir
162cdf0e10cSrcweir basegfx::B2DPolygon aTriangle;
163cdf0e10cSrcweir aTriangle.append(basegfx::B2DPoint(10.0, 0.0));
164cdf0e10cSrcweir aTriangle.append(basegfx::B2DPoint(0.0, 30.0));
165cdf0e10cSrcweir aTriangle.append(basegfx::B2DPoint(20.0, 30.0));
166cdf0e10cSrcweir aTriangle.setClosed(true);
167cdf0e10cSrcweir
168cdf0e10cSrcweir basegfx::B2DPolygon aSquare;
169cdf0e10cSrcweir aSquare.append(basegfx::B2DPoint(0.0, 0.0));
170cdf0e10cSrcweir aSquare.append(basegfx::B2DPoint(10.0, 0.0));
171cdf0e10cSrcweir aSquare.append(basegfx::B2DPoint(10.0, 10.0));
172cdf0e10cSrcweir aSquare.append(basegfx::B2DPoint(0.0, 10.0));
173cdf0e10cSrcweir aSquare.setClosed(true);
174cdf0e10cSrcweir
175cdf0e10cSrcweir basegfx::B2DPolygon aCircle(basegfx::tools::createPolygonFromEllipse(basegfx::B2DPoint(0.0, 0.0), 100.0, 100.0));
176cdf0e10cSrcweir aCircle.setClosed(true);
177cdf0e10cSrcweir
178cdf0e10cSrcweir String aName = SC_LINEEND_NAME;
179cdf0e10cSrcweir
180cdf0e10cSrcweir aArrowSet.Put( XLineStartItem( aName, basegfx::B2DPolyPolygon(aCircle) ) );
181cdf0e10cSrcweir aArrowSet.Put( XLineStartWidthItem( 200 ) );
182cdf0e10cSrcweir aArrowSet.Put( XLineStartCenterItem( sal_True ) );
183cdf0e10cSrcweir aArrowSet.Put( XLineEndItem( aName, basegfx::B2DPolyPolygon(aTriangle) ) );
184cdf0e10cSrcweir aArrowSet.Put( XLineEndWidthItem( 200 ) );
185cdf0e10cSrcweir aArrowSet.Put( XLineEndCenterItem( sal_False ) );
186cdf0e10cSrcweir
187cdf0e10cSrcweir aToTabSet.Put( XLineStartItem( aName, basegfx::B2DPolyPolygon(aCircle) ) );
188cdf0e10cSrcweir aToTabSet.Put( XLineStartWidthItem( 200 ) );
189cdf0e10cSrcweir aToTabSet.Put( XLineStartCenterItem( sal_True ) );
190cdf0e10cSrcweir aToTabSet.Put( XLineEndItem( aName, basegfx::B2DPolyPolygon(aSquare) ) );
191cdf0e10cSrcweir aToTabSet.Put( XLineEndWidthItem( 300 ) );
192cdf0e10cSrcweir aToTabSet.Put( XLineEndCenterItem( sal_False ) );
193cdf0e10cSrcweir
194cdf0e10cSrcweir aFromTabSet.Put( XLineStartItem( aName, basegfx::B2DPolyPolygon(aSquare) ) );
195cdf0e10cSrcweir aFromTabSet.Put( XLineStartWidthItem( 300 ) );
196cdf0e10cSrcweir aFromTabSet.Put( XLineStartCenterItem( sal_True ) );
197cdf0e10cSrcweir aFromTabSet.Put( XLineEndItem( aName, basegfx::B2DPolyPolygon(aTriangle) ) );
198cdf0e10cSrcweir aFromTabSet.Put( XLineEndWidthItem( 200 ) );
199cdf0e10cSrcweir aFromTabSet.Put( XLineEndCenterItem( sal_False ) );
200cdf0e10cSrcweir
201cdf0e10cSrcweir aCircleSet.Put( XLineColorItem( String(), Color( ScDetectiveFunc::GetErrorColor() ) ) );
202cdf0e10cSrcweir aCircleSet.Put( XFillStyleItem( XFILL_NONE ) );
203cdf0e10cSrcweir sal_uInt16 nWidth = 55; // 54 = 1 Pixel
204cdf0e10cSrcweir aCircleSet.Put( XLineWidthItem( nWidth ) );
205cdf0e10cSrcweir }
206cdf0e10cSrcweir
ScCommentData(ScDocument & rDoc,SdrModel * pModel)207cdf0e10cSrcweir ScCommentData::ScCommentData( ScDocument& rDoc, SdrModel* pModel ) :
208cdf0e10cSrcweir aCaptionSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END, EE_ITEMS_START, EE_ITEMS_END, 0, 0 )
209cdf0e10cSrcweir {
210cdf0e10cSrcweir basegfx::B2DPolygon aTriangle;
211cdf0e10cSrcweir aTriangle.append(basegfx::B2DPoint(10.0, 0.0));
212cdf0e10cSrcweir aTriangle.append(basegfx::B2DPoint(0.0, 30.0));
213cdf0e10cSrcweir aTriangle.append(basegfx::B2DPoint(20.0, 30.0));
214cdf0e10cSrcweir aTriangle.setClosed(true);
215cdf0e10cSrcweir
216cdf0e10cSrcweir String aName = SC_LINEEND_NAME;
217cdf0e10cSrcweir
218cdf0e10cSrcweir aCaptionSet.Put( XLineStartItem( aName, basegfx::B2DPolyPolygon(aTriangle) ) );
219cdf0e10cSrcweir aCaptionSet.Put( XLineStartWidthItem( 200 ) );
220cdf0e10cSrcweir aCaptionSet.Put( XLineStartCenterItem( sal_False ) );
221cdf0e10cSrcweir aCaptionSet.Put( XFillStyleItem( XFILL_SOLID ) );
222cdf0e10cSrcweir Color aYellow( ScDetectiveFunc::GetCommentColor() );
223cdf0e10cSrcweir aCaptionSet.Put( XFillColorItem( String(), aYellow ) );
224cdf0e10cSrcweir
225cdf0e10cSrcweir // shadow
226cdf0e10cSrcweir // SdrShadowItem has sal_False, instead the shadow is set for the rectangle
227cdf0e10cSrcweir // only with SetSpecialTextBoxShadow when the object is created
228cdf0e10cSrcweir // (item must be set to adjust objects from older files)
229cdf0e10cSrcweir aCaptionSet.Put( SdrShadowItem( sal_False ) );
230cdf0e10cSrcweir aCaptionSet.Put( SdrShadowXDistItem( 100 ) );
231cdf0e10cSrcweir aCaptionSet.Put( SdrShadowYDistItem( 100 ) );
232cdf0e10cSrcweir
233cdf0e10cSrcweir // text attributes
234cdf0e10cSrcweir aCaptionSet.Put( SdrTextLeftDistItem( 100 ) );
235cdf0e10cSrcweir aCaptionSet.Put( SdrTextRightDistItem( 100 ) );
236cdf0e10cSrcweir aCaptionSet.Put( SdrTextUpperDistItem( 100 ) );
237cdf0e10cSrcweir aCaptionSet.Put( SdrTextLowerDistItem( 100 ) );
238cdf0e10cSrcweir
239cdf0e10cSrcweir aCaptionSet.Put( SdrTextAutoGrowWidthItem( sal_False ) );
240cdf0e10cSrcweir aCaptionSet.Put( SdrTextAutoGrowHeightItem( sal_True ) );
241cdf0e10cSrcweir
242cdf0e10cSrcweir // #78943# do use the default cell style, so the user has a chance to
243cdf0e10cSrcweir // modify the font for the annotations
244cdf0e10cSrcweir ((const ScPatternAttr&)rDoc.GetPool()->GetDefaultItem(ATTR_PATTERN)).
245cdf0e10cSrcweir FillEditItemSet( &aCaptionSet );
246cdf0e10cSrcweir
247cdf0e10cSrcweir // support the best position for the tail connector now that
248cdf0e10cSrcweir // that notes can be resized and repositioned.
249cdf0e10cSrcweir aCaptionSet.Put( SdrCaptionEscDirItem( SDRCAPT_ESCBESTFIT) );
250cdf0e10cSrcweir }
251cdf0e10cSrcweir
UpdateCaptionSet(const SfxItemSet & rItemSet)252cdf0e10cSrcweir void ScCommentData::UpdateCaptionSet( const SfxItemSet& rItemSet )
253cdf0e10cSrcweir {
254cdf0e10cSrcweir SfxWhichIter aWhichIter( rItemSet );
255cdf0e10cSrcweir const SfxPoolItem* pPoolItem = 0;
256cdf0e10cSrcweir
257cdf0e10cSrcweir for( sal_uInt16 nWhich = aWhichIter.FirstWhich(); nWhich > 0; nWhich = aWhichIter.NextWhich() )
258cdf0e10cSrcweir {
259cdf0e10cSrcweir if(rItemSet.GetItemState(nWhich, sal_False, &pPoolItem) == SFX_ITEM_SET)
260cdf0e10cSrcweir {
261cdf0e10cSrcweir switch(nWhich)
262cdf0e10cSrcweir {
263cdf0e10cSrcweir case SDRATTR_SHADOW:
264cdf0e10cSrcweir // use existing Caption default - appears that setting this
265cdf0e10cSrcweir // to true screws up the tail appearance. See also comment
266cdf0e10cSrcweir // for default setting above.
267cdf0e10cSrcweir break;
268cdf0e10cSrcweir case SDRATTR_SHADOWXDIST:
269cdf0e10cSrcweir // use existing Caption default - svx sets a value of 35
270cdf0e10cSrcweir // but default 100 gives a better appearance.
271cdf0e10cSrcweir break;
272cdf0e10cSrcweir case SDRATTR_SHADOWYDIST:
273cdf0e10cSrcweir // use existing Caption default - svx sets a value of 35
274cdf0e10cSrcweir // but default 100 gives a better appearance.
275cdf0e10cSrcweir break;
276cdf0e10cSrcweir
277cdf0e10cSrcweir default:
278cdf0e10cSrcweir aCaptionSet.Put(*pPoolItem);
279cdf0e10cSrcweir }
280cdf0e10cSrcweir }
281cdf0e10cSrcweir }
282cdf0e10cSrcweir }
283cdf0e10cSrcweir
284cdf0e10cSrcweir //------------------------------------------------------------------------
285cdf0e10cSrcweir
Modified()286cdf0e10cSrcweir void ScDetectiveFunc::Modified()
287cdf0e10cSrcweir {
288cdf0e10cSrcweir if (pDoc->IsStreamValid(nTab))
289cdf0e10cSrcweir pDoc->SetStreamValid(nTab, sal_False);
290cdf0e10cSrcweir }
291cdf0e10cSrcweir
Intersect(SCCOL nStartCol1,SCROW nStartRow1,SCCOL nEndCol1,SCROW nEndRow1,SCCOL nStartCol2,SCROW nStartRow2,SCCOL nEndCol2,SCROW nEndRow2)292cdf0e10cSrcweir inline sal_Bool Intersect( SCCOL nStartCol1, SCROW nStartRow1, SCCOL nEndCol1, SCROW nEndRow1,
293cdf0e10cSrcweir SCCOL nStartCol2, SCROW nStartRow2, SCCOL nEndCol2, SCROW nEndRow2 )
294cdf0e10cSrcweir {
295cdf0e10cSrcweir return nEndCol1 >= nStartCol2 && nEndCol2 >= nStartCol1 &&
296cdf0e10cSrcweir nEndRow1 >= nStartRow2 && nEndRow2 >= nStartRow1;
297cdf0e10cSrcweir }
298cdf0e10cSrcweir
HasError(const ScRange & rRange,ScAddress & rErrPos)299cdf0e10cSrcweir sal_Bool ScDetectiveFunc::HasError( const ScRange& rRange, ScAddress& rErrPos )
300cdf0e10cSrcweir {
301cdf0e10cSrcweir rErrPos = rRange.aStart;
302cdf0e10cSrcweir sal_uInt16 nError = 0;
303cdf0e10cSrcweir
304cdf0e10cSrcweir ScCellIterator aCellIter( pDoc, rRange);
305cdf0e10cSrcweir ScBaseCell* pCell = aCellIter.GetFirst();
306cdf0e10cSrcweir while (pCell)
307cdf0e10cSrcweir {
308cdf0e10cSrcweir if (pCell->GetCellType() == CELLTYPE_FORMULA)
309cdf0e10cSrcweir {
310cdf0e10cSrcweir nError = ((ScFormulaCell*)pCell)->GetErrCode();
311cdf0e10cSrcweir if (nError)
312cdf0e10cSrcweir rErrPos.Set( aCellIter.GetCol(), aCellIter.GetRow(), aCellIter.GetTab() );
313cdf0e10cSrcweir }
314cdf0e10cSrcweir pCell = aCellIter.GetNext();
315cdf0e10cSrcweir }
316cdf0e10cSrcweir
317cdf0e10cSrcweir return (nError != 0);
318cdf0e10cSrcweir }
319cdf0e10cSrcweir
GetDrawPos(SCCOL nCol,SCROW nRow,DrawPosMode eMode) const320cdf0e10cSrcweir Point ScDetectiveFunc::GetDrawPos( SCCOL nCol, SCROW nRow, DrawPosMode eMode ) const
321cdf0e10cSrcweir {
322cdf0e10cSrcweir DBG_ASSERT( ValidColRow( nCol, nRow ), "ScDetectiveFunc::GetDrawPos - invalid cell address" );
323cdf0e10cSrcweir SanitizeCol( nCol );
324cdf0e10cSrcweir SanitizeRow( nRow );
325cdf0e10cSrcweir
326cdf0e10cSrcweir Point aPos;
327cdf0e10cSrcweir
328cdf0e10cSrcweir switch( eMode )
329cdf0e10cSrcweir {
330cdf0e10cSrcweir case DRAWPOS_TOPLEFT:
331cdf0e10cSrcweir break;
332cdf0e10cSrcweir case DRAWPOS_BOTTOMRIGHT:
333cdf0e10cSrcweir ++nCol;
334cdf0e10cSrcweir ++nRow;
335cdf0e10cSrcweir break;
336cdf0e10cSrcweir case DRAWPOS_DETARROW:
337cdf0e10cSrcweir aPos.X() += pDoc->GetColWidth( nCol, nTab ) / 4;
338cdf0e10cSrcweir aPos.Y() += pDoc->GetRowHeight( nRow, nTab ) / 2;
339cdf0e10cSrcweir break;
340cdf0e10cSrcweir case DRAWPOS_CAPTIONLEFT:
341cdf0e10cSrcweir aPos.X() += 6;
342cdf0e10cSrcweir break;
343cdf0e10cSrcweir case DRAWPOS_CAPTIONRIGHT:
344cdf0e10cSrcweir {
345cdf0e10cSrcweir // find right end of passed cell position
346cdf0e10cSrcweir const ScMergeAttr* pMerge = static_cast< const ScMergeAttr* >( pDoc->GetAttr( nCol, nRow, nTab, ATTR_MERGE ) );
347cdf0e10cSrcweir if ( pMerge->GetColMerge() > 1 )
348cdf0e10cSrcweir nCol = nCol + pMerge->GetColMerge();
349cdf0e10cSrcweir else
350cdf0e10cSrcweir ++nCol;
351cdf0e10cSrcweir aPos.X() -= 6;
352cdf0e10cSrcweir }
353cdf0e10cSrcweir break;
354cdf0e10cSrcweir }
355cdf0e10cSrcweir
356cdf0e10cSrcweir for ( SCCOL i = 0; i < nCol; ++i )
357cdf0e10cSrcweir aPos.X() += pDoc->GetColWidth( i, nTab );
358cdf0e10cSrcweir aPos.Y() += pDoc->GetRowHeight( 0, nRow - 1, nTab );
359cdf0e10cSrcweir
360cdf0e10cSrcweir aPos.X() = static_cast< long >( aPos.X() * HMM_PER_TWIPS );
361cdf0e10cSrcweir aPos.Y() = static_cast< long >( aPos.Y() * HMM_PER_TWIPS );
362cdf0e10cSrcweir
363cdf0e10cSrcweir if ( pDoc->IsNegativePage( nTab ) )
364cdf0e10cSrcweir aPos.X() *= -1;
365cdf0e10cSrcweir
366cdf0e10cSrcweir return aPos;
367cdf0e10cSrcweir }
368cdf0e10cSrcweir
GetDrawRect(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2) const369cdf0e10cSrcweir Rectangle ScDetectiveFunc::GetDrawRect( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const
370cdf0e10cSrcweir {
371cdf0e10cSrcweir Rectangle aRect(
372cdf0e10cSrcweir GetDrawPos( ::std::min( nCol1, nCol2 ), ::std::min( nRow1, nRow2 ), DRAWPOS_TOPLEFT ),
373cdf0e10cSrcweir GetDrawPos( ::std::max( nCol1, nCol2 ), ::std::max( nRow1, nRow2 ), DRAWPOS_BOTTOMRIGHT ) );
374cdf0e10cSrcweir aRect.Justify(); // reorder left/right in RTL sheets
375cdf0e10cSrcweir return aRect;
376cdf0e10cSrcweir }
377cdf0e10cSrcweir
GetDrawRect(SCCOL nCol,SCROW nRow) const378cdf0e10cSrcweir Rectangle ScDetectiveFunc::GetDrawRect( SCCOL nCol, SCROW nRow ) const
379cdf0e10cSrcweir {
380cdf0e10cSrcweir return GetDrawRect( nCol, nRow, nCol, nRow );
381cdf0e10cSrcweir }
382cdf0e10cSrcweir
lcl_IsOtherTab(const basegfx::B2DPolyPolygon & rPolyPolygon)383cdf0e10cSrcweir sal_Bool lcl_IsOtherTab( const basegfx::B2DPolyPolygon& rPolyPolygon )
384cdf0e10cSrcweir {
385cdf0e10cSrcweir // test if rPolygon is the line end for "other table" (rectangle)
386cdf0e10cSrcweir if(1L == rPolyPolygon.count())
387cdf0e10cSrcweir {
388cdf0e10cSrcweir const basegfx::B2DPolygon aSubPoly(rPolyPolygon.getB2DPolygon(0L));
389cdf0e10cSrcweir
390cdf0e10cSrcweir // #i73305# circle consists of 4 segments, too, distinguishable from square by
391cdf0e10cSrcweir // the use of control points
392cdf0e10cSrcweir if(4L == aSubPoly.count() && aSubPoly.isClosed() && !aSubPoly.areControlPointsUsed())
393cdf0e10cSrcweir {
394cdf0e10cSrcweir return true;
395cdf0e10cSrcweir }
396cdf0e10cSrcweir }
397cdf0e10cSrcweir
398cdf0e10cSrcweir return false;
399cdf0e10cSrcweir }
400cdf0e10cSrcweir
HasArrow(const ScAddress & rStart,SCCOL nEndCol,SCROW nEndRow,SCTAB nEndTab)401cdf0e10cSrcweir sal_Bool ScDetectiveFunc::HasArrow( const ScAddress& rStart,
402cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab )
403cdf0e10cSrcweir {
404cdf0e10cSrcweir sal_Bool bStartAlien = ( rStart.Tab() != nTab );
405cdf0e10cSrcweir sal_Bool bEndAlien = ( nEndTab != nTab );
406cdf0e10cSrcweir
407cdf0e10cSrcweir if (bStartAlien && bEndAlien)
408cdf0e10cSrcweir {
409cdf0e10cSrcweir DBG_ERROR("bStartAlien && bEndAlien");
410cdf0e10cSrcweir return sal_True;
411cdf0e10cSrcweir }
412cdf0e10cSrcweir
413cdf0e10cSrcweir Rectangle aStartRect;
414cdf0e10cSrcweir Rectangle aEndRect;
415cdf0e10cSrcweir if (!bStartAlien)
416cdf0e10cSrcweir aStartRect = GetDrawRect( rStart.Col(), rStart.Row() );
417cdf0e10cSrcweir if (!bEndAlien)
418cdf0e10cSrcweir aEndRect = GetDrawRect( nEndCol, nEndRow );
419cdf0e10cSrcweir
420cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
421cdf0e10cSrcweir SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
422cdf0e10cSrcweir DBG_ASSERT(pPage,"Page ?");
423cdf0e10cSrcweir
424cdf0e10cSrcweir sal_Bool bFound = sal_False;
425cdf0e10cSrcweir SdrObjListIter aIter( *pPage, IM_FLAT );
426cdf0e10cSrcweir SdrObject* pObject = aIter.Next();
427cdf0e10cSrcweir while (pObject && !bFound)
428cdf0e10cSrcweir {
429cdf0e10cSrcweir if ( pObject->GetLayer()==SC_LAYER_INTERN &&
430cdf0e10cSrcweir pObject->IsPolyObj() && pObject->GetPointCount()==2 )
431cdf0e10cSrcweir {
432cdf0e10cSrcweir const SfxItemSet& rSet = pObject->GetMergedItemSet();
433cdf0e10cSrcweir
434cdf0e10cSrcweir sal_Bool bObjStartAlien =
435cdf0e10cSrcweir lcl_IsOtherTab( ((const XLineStartItem&)rSet.Get(XATTR_LINESTART)).GetLineStartValue() );
436cdf0e10cSrcweir sal_Bool bObjEndAlien =
437cdf0e10cSrcweir lcl_IsOtherTab( ((const XLineEndItem&)rSet.Get(XATTR_LINEEND)).GetLineEndValue() );
438cdf0e10cSrcweir
439cdf0e10cSrcweir sal_Bool bStartHit = bStartAlien ? bObjStartAlien :
440cdf0e10cSrcweir ( !bObjStartAlien && aStartRect.IsInside(pObject->GetPoint(0)) );
441cdf0e10cSrcweir sal_Bool bEndHit = bEndAlien ? bObjEndAlien :
442cdf0e10cSrcweir ( !bObjEndAlien && aEndRect.IsInside(pObject->GetPoint(1)) );
443cdf0e10cSrcweir
444cdf0e10cSrcweir if ( bStartHit && bEndHit )
445cdf0e10cSrcweir bFound = sal_True;
446cdf0e10cSrcweir }
447cdf0e10cSrcweir pObject = aIter.Next();
448cdf0e10cSrcweir }
449cdf0e10cSrcweir
450cdf0e10cSrcweir return bFound;
451cdf0e10cSrcweir }
452cdf0e10cSrcweir
IsNonAlienArrow(SdrObject * pObject)453cdf0e10cSrcweir sal_Bool ScDetectiveFunc::IsNonAlienArrow( SdrObject* pObject ) // static
454cdf0e10cSrcweir {
455cdf0e10cSrcweir if ( pObject->GetLayer()==SC_LAYER_INTERN &&
456cdf0e10cSrcweir pObject->IsPolyObj() && pObject->GetPointCount()==2 )
457cdf0e10cSrcweir {
458cdf0e10cSrcweir const SfxItemSet& rSet = pObject->GetMergedItemSet();
459cdf0e10cSrcweir
460cdf0e10cSrcweir sal_Bool bObjStartAlien =
461cdf0e10cSrcweir lcl_IsOtherTab( ((const XLineStartItem&)rSet.Get(XATTR_LINESTART)).GetLineStartValue() );
462cdf0e10cSrcweir sal_Bool bObjEndAlien =
463cdf0e10cSrcweir lcl_IsOtherTab( ((const XLineEndItem&)rSet.Get(XATTR_LINEEND)).GetLineEndValue() );
464cdf0e10cSrcweir
465cdf0e10cSrcweir return !bObjStartAlien && !bObjEndAlien;
466cdf0e10cSrcweir }
467cdf0e10cSrcweir
468cdf0e10cSrcweir return sal_False;
469cdf0e10cSrcweir }
470cdf0e10cSrcweir
471cdf0e10cSrcweir //------------------------------------------------------------------------
472cdf0e10cSrcweir
473cdf0e10cSrcweir // InsertXXX: called from DrawEntry/DrawAlienEntry and InsertObject
474cdf0e10cSrcweir
InsertArrow(SCCOL nCol,SCROW nRow,SCCOL nRefStartCol,SCROW nRefStartRow,SCCOL nRefEndCol,SCROW nRefEndRow,sal_Bool bFromOtherTab,sal_Bool bRed,ScDetectiveData & rData)475cdf0e10cSrcweir sal_Bool ScDetectiveFunc::InsertArrow( SCCOL nCol, SCROW nRow,
476cdf0e10cSrcweir SCCOL nRefStartCol, SCROW nRefStartRow,
477cdf0e10cSrcweir SCCOL nRefEndCol, SCROW nRefEndRow,
478cdf0e10cSrcweir sal_Bool bFromOtherTab, sal_Bool bRed,
479cdf0e10cSrcweir ScDetectiveData& rData )
480cdf0e10cSrcweir {
481cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
482cdf0e10cSrcweir SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
483cdf0e10cSrcweir
484cdf0e10cSrcweir sal_Bool bArea = ( nRefStartCol != nRefEndCol || nRefStartRow != nRefEndRow );
485cdf0e10cSrcweir if (bArea && !bFromOtherTab)
486cdf0e10cSrcweir {
487cdf0e10cSrcweir // insert the rectangle before the arrow - this is relied on in FindFrameForObject
488cdf0e10cSrcweir
489cdf0e10cSrcweir Rectangle aRect = GetDrawRect( nRefStartCol, nRefStartRow, nRefEndCol, nRefEndRow );
490cdf0e10cSrcweir SdrRectObj* pBox = new SdrRectObj( aRect );
491cdf0e10cSrcweir
492cdf0e10cSrcweir pBox->SetMergedItemSetAndBroadcast(rData.GetBoxSet());
493cdf0e10cSrcweir
494cdf0e10cSrcweir ScDrawLayer::SetAnchor( pBox, SCA_CELL );
495cdf0e10cSrcweir pBox->SetLayer( SC_LAYER_INTERN );
496cdf0e10cSrcweir pPage->InsertObject( pBox );
497577c0052SWang Lei pModel->AddCalcUndo< SdrUndoInsertObj >( *pBox );
498cdf0e10cSrcweir
499cdf0e10cSrcweir ScDrawObjData* pData = ScDrawLayer::GetObjData( pBox, sal_True );
500cdf0e10cSrcweir pData->maStart.Set( nRefStartCol, nRefStartRow, nTab);
501cdf0e10cSrcweir pData->maEnd.Set( nRefEndCol, nRefEndRow, nTab);
502cdf0e10cSrcweir }
503cdf0e10cSrcweir
504cdf0e10cSrcweir Point aStartPos = GetDrawPos( nRefStartCol, nRefStartRow, DRAWPOS_DETARROW );
505cdf0e10cSrcweir Point aEndPos = GetDrawPos( nCol, nRow, DRAWPOS_DETARROW );
506cdf0e10cSrcweir
507cdf0e10cSrcweir if (bFromOtherTab)
508cdf0e10cSrcweir {
509cdf0e10cSrcweir sal_Bool bNegativePage = pDoc->IsNegativePage( nTab );
510cdf0e10cSrcweir long nPageSign = bNegativePage ? -1 : 1;
511cdf0e10cSrcweir
512cdf0e10cSrcweir aStartPos = Point( aEndPos.X() - 1000 * nPageSign, aEndPos.Y() - 1000 );
513cdf0e10cSrcweir if (aStartPos.X() * nPageSign < 0)
514cdf0e10cSrcweir aStartPos.X() += 2000 * nPageSign;
515cdf0e10cSrcweir if (aStartPos.Y() < 0)
516cdf0e10cSrcweir aStartPos.Y() += 2000;
517cdf0e10cSrcweir }
518cdf0e10cSrcweir
519cdf0e10cSrcweir SfxItemSet& rAttrSet = bFromOtherTab ? rData.GetFromTabSet() : rData.GetArrowSet();
520cdf0e10cSrcweir
521cdf0e10cSrcweir if (bArea && !bFromOtherTab)
522cdf0e10cSrcweir rAttrSet.Put( XLineWidthItem( 50 ) ); // Bereich
523cdf0e10cSrcweir else
524cdf0e10cSrcweir rAttrSet.Put( XLineWidthItem( 0 ) ); // einzelne Referenz
525cdf0e10cSrcweir
526cdf0e10cSrcweir ColorData nColorData = ( bRed ? GetErrorColor() : GetArrowColor() );
527cdf0e10cSrcweir rAttrSet.Put( XLineColorItem( String(), Color( nColorData ) ) );
528cdf0e10cSrcweir
529cdf0e10cSrcweir basegfx::B2DPolygon aTempPoly;
530cdf0e10cSrcweir aTempPoly.append(basegfx::B2DPoint(aStartPos.X(), aStartPos.Y()));
531cdf0e10cSrcweir aTempPoly.append(basegfx::B2DPoint(aEndPos.X(), aEndPos.Y()));
532cdf0e10cSrcweir SdrPathObj* pArrow = new SdrPathObj(OBJ_LINE, basegfx::B2DPolyPolygon(aTempPoly));
533cdf0e10cSrcweir pArrow->NbcSetLogicRect(Rectangle(aStartPos,aEndPos)); //! noetig ???
534cdf0e10cSrcweir pArrow->SetMergedItemSetAndBroadcast(rAttrSet);
535cdf0e10cSrcweir
536cdf0e10cSrcweir ScDrawLayer::SetAnchor( pArrow, SCA_CELL );
537cdf0e10cSrcweir pArrow->SetLayer( SC_LAYER_INTERN );
538cdf0e10cSrcweir pPage->InsertObject( pArrow );
539577c0052SWang Lei pModel->AddCalcUndo< SdrUndoInsertObj >( *pArrow );
540cdf0e10cSrcweir
541cdf0e10cSrcweir ScDrawObjData* pData = ScDrawLayer::GetObjData( pArrow, sal_True );
542cdf0e10cSrcweir if (bFromOtherTab)
543cdf0e10cSrcweir pData->maStart.SetInvalid();
544cdf0e10cSrcweir else
545cdf0e10cSrcweir pData->maStart.Set( nRefStartCol, nRefStartRow, nTab);
546cdf0e10cSrcweir
547cdf0e10cSrcweir pData->maEnd.Set( nCol, nRow, nTab);
548cdf0e10cSrcweir
549cdf0e10cSrcweir Modified();
550cdf0e10cSrcweir return sal_True;
551cdf0e10cSrcweir }
552cdf0e10cSrcweir
InsertToOtherTab(SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,sal_Bool bRed,ScDetectiveData & rData)553cdf0e10cSrcweir sal_Bool ScDetectiveFunc::InsertToOtherTab( SCCOL nStartCol, SCROW nStartRow,
554cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, sal_Bool bRed,
555cdf0e10cSrcweir ScDetectiveData& rData )
556cdf0e10cSrcweir {
557cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
558cdf0e10cSrcweir SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
559cdf0e10cSrcweir
560cdf0e10cSrcweir sal_Bool bArea = ( nStartCol != nEndCol || nStartRow != nEndRow );
561cdf0e10cSrcweir if (bArea)
562cdf0e10cSrcweir {
563cdf0e10cSrcweir Rectangle aRect = GetDrawRect( nStartCol, nStartRow, nEndCol, nEndRow );
564cdf0e10cSrcweir SdrRectObj* pBox = new SdrRectObj( aRect );
565cdf0e10cSrcweir
566cdf0e10cSrcweir pBox->SetMergedItemSetAndBroadcast(rData.GetBoxSet());
567cdf0e10cSrcweir
568cdf0e10cSrcweir ScDrawLayer::SetAnchor( pBox, SCA_CELL );
569cdf0e10cSrcweir pBox->SetLayer( SC_LAYER_INTERN );
570cdf0e10cSrcweir pPage->InsertObject( pBox );
571577c0052SWang Lei pModel->AddCalcUndo< SdrUndoInsertObj >( *pBox );
572cdf0e10cSrcweir
573cdf0e10cSrcweir ScDrawObjData* pData = ScDrawLayer::GetObjData( pBox, sal_True );
574cdf0e10cSrcweir pData->maStart.Set( nStartCol, nStartRow, nTab);
575cdf0e10cSrcweir pData->maEnd.Set( nEndCol, nEndRow, nTab);
576cdf0e10cSrcweir }
577cdf0e10cSrcweir
578cdf0e10cSrcweir sal_Bool bNegativePage = pDoc->IsNegativePage( nTab );
579cdf0e10cSrcweir long nPageSign = bNegativePage ? -1 : 1;
580cdf0e10cSrcweir
581cdf0e10cSrcweir Point aStartPos = GetDrawPos( nStartCol, nStartRow, DRAWPOS_DETARROW );
582cdf0e10cSrcweir Point aEndPos = Point( aStartPos.X() + 1000 * nPageSign, aStartPos.Y() - 1000 );
583cdf0e10cSrcweir if (aEndPos.Y() < 0)
584cdf0e10cSrcweir aEndPos.Y() += 2000;
585cdf0e10cSrcweir
586cdf0e10cSrcweir SfxItemSet& rAttrSet = rData.GetToTabSet();
587cdf0e10cSrcweir if (bArea)
588cdf0e10cSrcweir rAttrSet.Put( XLineWidthItem( 50 ) ); // Bereich
589cdf0e10cSrcweir else
590cdf0e10cSrcweir rAttrSet.Put( XLineWidthItem( 0 ) ); // einzelne Referenz
591cdf0e10cSrcweir
592cdf0e10cSrcweir ColorData nColorData = ( bRed ? GetErrorColor() : GetArrowColor() );
593cdf0e10cSrcweir rAttrSet.Put( XLineColorItem( String(), Color( nColorData ) ) );
594cdf0e10cSrcweir
595cdf0e10cSrcweir basegfx::B2DPolygon aTempPoly;
596cdf0e10cSrcweir aTempPoly.append(basegfx::B2DPoint(aStartPos.X(), aStartPos.Y()));
597cdf0e10cSrcweir aTempPoly.append(basegfx::B2DPoint(aEndPos.X(), aEndPos.Y()));
598cdf0e10cSrcweir SdrPathObj* pArrow = new SdrPathObj(OBJ_LINE, basegfx::B2DPolyPolygon(aTempPoly));
599cdf0e10cSrcweir pArrow->NbcSetLogicRect(Rectangle(aStartPos,aEndPos)); //! noetig ???
600cdf0e10cSrcweir
601cdf0e10cSrcweir pArrow->SetMergedItemSetAndBroadcast(rAttrSet);
602cdf0e10cSrcweir
603cdf0e10cSrcweir ScDrawLayer::SetAnchor( pArrow, SCA_CELL );
604cdf0e10cSrcweir pArrow->SetLayer( SC_LAYER_INTERN );
605cdf0e10cSrcweir pPage->InsertObject( pArrow );
606577c0052SWang Lei pModel->AddCalcUndo< SdrUndoInsertObj >( *pArrow );
607cdf0e10cSrcweir
608cdf0e10cSrcweir ScDrawObjData* pData = ScDrawLayer::GetObjData( pArrow, sal_True );
609cdf0e10cSrcweir pData->maStart.Set( nStartCol, nStartRow, nTab);
610cdf0e10cSrcweir pData->maEnd.SetInvalid();
611cdf0e10cSrcweir
612cdf0e10cSrcweir Modified();
613cdf0e10cSrcweir return sal_True;
614cdf0e10cSrcweir }
615cdf0e10cSrcweir
616cdf0e10cSrcweir //------------------------------------------------------------------------
617cdf0e10cSrcweir
618cdf0e10cSrcweir // DrawEntry: Formel auf dieser Tabelle,
619cdf0e10cSrcweir // Referenz auf dieser oder anderer
620cdf0e10cSrcweir // DrawAlienEntry: Formel auf anderer Tabelle,
621cdf0e10cSrcweir // Referenz auf dieser
622cdf0e10cSrcweir
623cdf0e10cSrcweir // return FALSE: da war schon ein Pfeil
624cdf0e10cSrcweir
DrawEntry(SCCOL nCol,SCROW nRow,const ScRange & rRef,ScDetectiveData & rData)625cdf0e10cSrcweir sal_Bool ScDetectiveFunc::DrawEntry( SCCOL nCol, SCROW nRow,
626cdf0e10cSrcweir const ScRange& rRef,
627cdf0e10cSrcweir ScDetectiveData& rData )
628cdf0e10cSrcweir {
629cdf0e10cSrcweir if ( HasArrow( rRef.aStart, nCol, nRow, nTab ) )
630cdf0e10cSrcweir return sal_False;
631cdf0e10cSrcweir
632cdf0e10cSrcweir ScAddress aErrorPos;
633cdf0e10cSrcweir sal_Bool bError = HasError( rRef, aErrorPos );
634cdf0e10cSrcweir sal_Bool bAlien = ( rRef.aEnd.Tab() < nTab || rRef.aStart.Tab() > nTab );
635cdf0e10cSrcweir
636cdf0e10cSrcweir return InsertArrow( nCol, nRow,
637cdf0e10cSrcweir rRef.aStart.Col(), rRef.aStart.Row(),
638cdf0e10cSrcweir rRef.aEnd.Col(), rRef.aEnd.Row(),
639cdf0e10cSrcweir bAlien, bError, rData );
640cdf0e10cSrcweir }
641cdf0e10cSrcweir
DrawAlienEntry(const ScRange & rRef,ScDetectiveData & rData)642cdf0e10cSrcweir sal_Bool ScDetectiveFunc::DrawAlienEntry( const ScRange& rRef,
643cdf0e10cSrcweir ScDetectiveData& rData )
644cdf0e10cSrcweir {
645cdf0e10cSrcweir if ( HasArrow( rRef.aStart, 0, 0, nTab+1 ) )
646cdf0e10cSrcweir return sal_False;
647cdf0e10cSrcweir
648cdf0e10cSrcweir ScAddress aErrorPos;
649cdf0e10cSrcweir sal_Bool bError = HasError( rRef, aErrorPos );
650cdf0e10cSrcweir
651cdf0e10cSrcweir return InsertToOtherTab( rRef.aStart.Col(), rRef.aStart.Row(),
652cdf0e10cSrcweir rRef.aEnd.Col(), rRef.aEnd.Row(),
653cdf0e10cSrcweir bError, rData );
654cdf0e10cSrcweir }
655cdf0e10cSrcweir
DrawCircle(SCCOL nCol,SCROW nRow,ScDetectiveData & rData)656cdf0e10cSrcweir void ScDetectiveFunc::DrawCircle( SCCOL nCol, SCROW nRow, ScDetectiveData& rData )
657cdf0e10cSrcweir {
658cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
659cdf0e10cSrcweir SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
660cdf0e10cSrcweir
661cdf0e10cSrcweir Rectangle aRect = GetDrawRect( nCol, nRow );
662cdf0e10cSrcweir aRect.Left() -= 250;
663cdf0e10cSrcweir aRect.Right() += 250;
664cdf0e10cSrcweir aRect.Top() -= 70;
665cdf0e10cSrcweir aRect.Bottom() += 70;
666cdf0e10cSrcweir
667cdf0e10cSrcweir SdrCircObj* pCircle = new SdrCircObj( OBJ_CIRC, aRect );
668cdf0e10cSrcweir SfxItemSet& rAttrSet = rData.GetCircleSet();
669cdf0e10cSrcweir
670cdf0e10cSrcweir pCircle->SetMergedItemSetAndBroadcast(rAttrSet);
671cdf0e10cSrcweir
672cdf0e10cSrcweir ScDrawLayer::SetAnchor( pCircle, SCA_CELL );
673cdf0e10cSrcweir pCircle->SetLayer( SC_LAYER_INTERN );
674cdf0e10cSrcweir pPage->InsertObject( pCircle );
675577c0052SWang Lei pModel->AddCalcUndo< SdrUndoInsertObj >( *pCircle );
676cdf0e10cSrcweir
677cdf0e10cSrcweir ScDrawObjData* pData = ScDrawLayer::GetObjData( pCircle, sal_True );
678cdf0e10cSrcweir pData->maStart.Set( nCol, nRow, nTab);
679cdf0e10cSrcweir pData->maEnd.SetInvalid();
680cdf0e10cSrcweir
681cdf0e10cSrcweir Modified();
682cdf0e10cSrcweir }
683cdf0e10cSrcweir
DeleteArrowsAt(SCCOL nCol,SCROW nRow,sal_Bool bDestPnt)684cdf0e10cSrcweir void ScDetectiveFunc::DeleteArrowsAt( SCCOL nCol, SCROW nRow, sal_Bool bDestPnt )
685cdf0e10cSrcweir {
686cdf0e10cSrcweir Rectangle aRect = GetDrawRect( nCol, nRow );
687cdf0e10cSrcweir
688cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
689cdf0e10cSrcweir SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
690cdf0e10cSrcweir DBG_ASSERT(pPage,"Page ?");
691cdf0e10cSrcweir
692cdf0e10cSrcweir pPage->RecalcObjOrdNums();
693cdf0e10cSrcweir
694cdf0e10cSrcweir long nDelCount = 0;
695cdf0e10cSrcweir sal_uLong nObjCount = pPage->GetObjCount();
696cdf0e10cSrcweir if (nObjCount)
697cdf0e10cSrcweir {
698cdf0e10cSrcweir SdrObject** ppObj = new SdrObject*[nObjCount];
699cdf0e10cSrcweir
700cdf0e10cSrcweir SdrObjListIter aIter( *pPage, IM_FLAT );
701cdf0e10cSrcweir SdrObject* pObject = aIter.Next();
702cdf0e10cSrcweir while (pObject)
703cdf0e10cSrcweir {
704cdf0e10cSrcweir if ( pObject->GetLayer()==SC_LAYER_INTERN &&
705cdf0e10cSrcweir pObject->IsPolyObj() && pObject->GetPointCount()==2 )
706cdf0e10cSrcweir {
707cdf0e10cSrcweir if (aRect.IsInside(pObject->GetPoint(bDestPnt))) // Start/Zielpunkt
708cdf0e10cSrcweir ppObj[nDelCount++] = pObject;
709cdf0e10cSrcweir }
710cdf0e10cSrcweir
711cdf0e10cSrcweir pObject = aIter.Next();
712cdf0e10cSrcweir }
713cdf0e10cSrcweir
714cdf0e10cSrcweir long i;
715cdf0e10cSrcweir for (i=1; i<=nDelCount; i++)
716577c0052SWang Lei pModel->AddCalcUndo< SdrUndoRemoveObj >( *ppObj[nDelCount-i] );
717cdf0e10cSrcweir
718cdf0e10cSrcweir for (i=1; i<=nDelCount; i++)
719cdf0e10cSrcweir pPage->RemoveObject( ppObj[nDelCount-i]->GetOrdNum() );
720cdf0e10cSrcweir
721cdf0e10cSrcweir delete[] ppObj;
722cdf0e10cSrcweir
723cdf0e10cSrcweir Modified();
724cdf0e10cSrcweir }
725cdf0e10cSrcweir }
726cdf0e10cSrcweir
727cdf0e10cSrcweir // Box um Referenz loeschen
728cdf0e10cSrcweir
729cdf0e10cSrcweir #define SC_DET_TOLERANCE 50
730cdf0e10cSrcweir
RectIsPoints(const Rectangle & rRect,const Point & rStart,const Point & rEnd)731cdf0e10cSrcweir inline sal_Bool RectIsPoints( const Rectangle& rRect, const Point& rStart, const Point& rEnd )
732cdf0e10cSrcweir {
733cdf0e10cSrcweir return rRect.Left() >= rStart.X() - SC_DET_TOLERANCE
734cdf0e10cSrcweir && rRect.Left() <= rStart.X() + SC_DET_TOLERANCE
735cdf0e10cSrcweir && rRect.Right() >= rEnd.X() - SC_DET_TOLERANCE
736cdf0e10cSrcweir && rRect.Right() <= rEnd.X() + SC_DET_TOLERANCE
737cdf0e10cSrcweir && rRect.Top() >= rStart.Y() - SC_DET_TOLERANCE
738cdf0e10cSrcweir && rRect.Top() <= rStart.Y() + SC_DET_TOLERANCE
739cdf0e10cSrcweir && rRect.Bottom() >= rEnd.Y() - SC_DET_TOLERANCE
740cdf0e10cSrcweir && rRect.Bottom() <= rEnd.Y() + SC_DET_TOLERANCE;
741cdf0e10cSrcweir }
742cdf0e10cSrcweir
743cdf0e10cSrcweir #undef SC_DET_TOLERANCE
744cdf0e10cSrcweir
DeleteBox(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2)745cdf0e10cSrcweir void ScDetectiveFunc::DeleteBox( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
746cdf0e10cSrcweir {
747cdf0e10cSrcweir /* String aStr;
748cdf0e10cSrcweir aStr += nCol1;
749cdf0e10cSrcweir aStr += '/';
750cdf0e10cSrcweir aStr += nRow1;
751cdf0e10cSrcweir aStr += '/';
752cdf0e10cSrcweir aStr += nCol2;
753cdf0e10cSrcweir aStr += '/';
754cdf0e10cSrcweir aStr += nRow2;
755cdf0e10cSrcweir InfoBox(0,aStr).Execute();
756cdf0e10cSrcweir */
757cdf0e10cSrcweir
758cdf0e10cSrcweir Rectangle aCornerRect = GetDrawRect( nCol1, nRow1, nCol2, nRow2 );
759cdf0e10cSrcweir Point aStartCorner = aCornerRect.TopLeft();
760cdf0e10cSrcweir Point aEndCorner = aCornerRect.BottomRight();
761cdf0e10cSrcweir Rectangle aObjRect;
762cdf0e10cSrcweir
763cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
764cdf0e10cSrcweir SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
765cdf0e10cSrcweir DBG_ASSERT(pPage,"Page ?");
766cdf0e10cSrcweir
767cdf0e10cSrcweir pPage->RecalcObjOrdNums();
768cdf0e10cSrcweir
769cdf0e10cSrcweir long nDelCount = 0;
770cdf0e10cSrcweir sal_uLong nObjCount = pPage->GetObjCount();
771cdf0e10cSrcweir if (nObjCount)
772cdf0e10cSrcweir {
773cdf0e10cSrcweir SdrObject** ppObj = new SdrObject*[nObjCount];
774cdf0e10cSrcweir
775cdf0e10cSrcweir SdrObjListIter aIter( *pPage, IM_FLAT );
776cdf0e10cSrcweir SdrObject* pObject = aIter.Next();
777cdf0e10cSrcweir while (pObject)
778cdf0e10cSrcweir {
779cdf0e10cSrcweir if ( pObject->GetLayer() == SC_LAYER_INTERN &&
780cdf0e10cSrcweir pObject->Type() == TYPE(SdrRectObj) )
781cdf0e10cSrcweir {
782cdf0e10cSrcweir aObjRect = ((SdrRectObj*)pObject)->GetLogicRect();
783cdf0e10cSrcweir aObjRect.Justify();
784cdf0e10cSrcweir if ( RectIsPoints( aObjRect, aStartCorner, aEndCorner ) )
785cdf0e10cSrcweir ppObj[nDelCount++] = pObject;
786cdf0e10cSrcweir }
787cdf0e10cSrcweir
788cdf0e10cSrcweir pObject = aIter.Next();
789cdf0e10cSrcweir }
790cdf0e10cSrcweir
791cdf0e10cSrcweir long i;
792cdf0e10cSrcweir for (i=1; i<=nDelCount; i++)
793577c0052SWang Lei pModel->AddCalcUndo< SdrUndoRemoveObj >( *ppObj[nDelCount-i] );
794cdf0e10cSrcweir
795cdf0e10cSrcweir for (i=1; i<=nDelCount; i++)
796cdf0e10cSrcweir pPage->RemoveObject( ppObj[nDelCount-i]->GetOrdNum() );
797cdf0e10cSrcweir
798cdf0e10cSrcweir delete[] ppObj;
799cdf0e10cSrcweir
800cdf0e10cSrcweir Modified();
801cdf0e10cSrcweir }
802cdf0e10cSrcweir }
803cdf0e10cSrcweir
804cdf0e10cSrcweir //------------------------------------------------------------------------
805cdf0e10cSrcweir
InsertPredLevelArea(const ScRange & rRef,ScDetectiveData & rData,sal_uInt16 nLevel)806cdf0e10cSrcweir sal_uInt16 ScDetectiveFunc::InsertPredLevelArea( const ScRange& rRef,
807cdf0e10cSrcweir ScDetectiveData& rData, sal_uInt16 nLevel )
808cdf0e10cSrcweir {
809cdf0e10cSrcweir sal_uInt16 nResult = DET_INS_EMPTY;
810cdf0e10cSrcweir
811cdf0e10cSrcweir ScCellIterator aCellIter( pDoc, rRef);
812cdf0e10cSrcweir ScBaseCell* pCell = aCellIter.GetFirst();
813cdf0e10cSrcweir while (pCell)
814cdf0e10cSrcweir {
815cdf0e10cSrcweir if (pCell->GetCellType() == CELLTYPE_FORMULA)
816cdf0e10cSrcweir switch( InsertPredLevel( aCellIter.GetCol(), aCellIter.GetRow(), rData, nLevel ) )
817cdf0e10cSrcweir {
818cdf0e10cSrcweir case DET_INS_INSERTED:
819cdf0e10cSrcweir nResult = DET_INS_INSERTED;
820cdf0e10cSrcweir break;
821cdf0e10cSrcweir case DET_INS_CONTINUE:
822cdf0e10cSrcweir if (nResult != DET_INS_INSERTED)
823cdf0e10cSrcweir nResult = DET_INS_CONTINUE;
824cdf0e10cSrcweir break;
825cdf0e10cSrcweir case DET_INS_CIRCULAR:
826cdf0e10cSrcweir if (nResult == DET_INS_EMPTY)
827cdf0e10cSrcweir nResult = DET_INS_CIRCULAR;
828cdf0e10cSrcweir break;
829cdf0e10cSrcweir }
830cdf0e10cSrcweir
831cdf0e10cSrcweir pCell = aCellIter.GetNext();
832cdf0e10cSrcweir }
833cdf0e10cSrcweir
834cdf0e10cSrcweir return nResult;
835cdf0e10cSrcweir }
836cdf0e10cSrcweir
InsertPredLevel(SCCOL nCol,SCROW nRow,ScDetectiveData & rData,sal_uInt16 nLevel)837cdf0e10cSrcweir sal_uInt16 ScDetectiveFunc::InsertPredLevel( SCCOL nCol, SCROW nRow, ScDetectiveData& rData,
838cdf0e10cSrcweir sal_uInt16 nLevel )
839cdf0e10cSrcweir {
840cdf0e10cSrcweir ScBaseCell* pCell;
841cdf0e10cSrcweir pDoc->GetCell( nCol, nRow, nTab, pCell );
842cdf0e10cSrcweir if (!pCell)
843cdf0e10cSrcweir return DET_INS_EMPTY;
844cdf0e10cSrcweir if (pCell->GetCellType() != CELLTYPE_FORMULA)
845cdf0e10cSrcweir return DET_INS_EMPTY;
846cdf0e10cSrcweir
847cdf0e10cSrcweir ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
848cdf0e10cSrcweir if (pFCell->IsRunning())
849cdf0e10cSrcweir return DET_INS_CIRCULAR;
850cdf0e10cSrcweir
851cdf0e10cSrcweir if (pFCell->GetDirty())
852cdf0e10cSrcweir pFCell->Interpret(); // nach SetRunning geht's nicht mehr!
853cdf0e10cSrcweir pFCell->SetRunning(sal_True);
854cdf0e10cSrcweir
855cdf0e10cSrcweir sal_uInt16 nResult = DET_INS_EMPTY;
856cdf0e10cSrcweir
857cdf0e10cSrcweir ScDetectiveRefIter aIter( (ScFormulaCell*) pCell );
858cdf0e10cSrcweir ScRange aRef;
859cdf0e10cSrcweir while ( aIter.GetNextRef( aRef ) )
860cdf0e10cSrcweir {
861cdf0e10cSrcweir if (DrawEntry( nCol, nRow, aRef, rData ))
862cdf0e10cSrcweir {
863cdf0e10cSrcweir nResult = DET_INS_INSERTED; // neuer Pfeil eingetragen
864cdf0e10cSrcweir }
865cdf0e10cSrcweir else
866cdf0e10cSrcweir {
867cdf0e10cSrcweir // weiterverfolgen
868cdf0e10cSrcweir
869cdf0e10cSrcweir if ( nLevel < rData.GetMaxLevel() )
870cdf0e10cSrcweir {
871cdf0e10cSrcweir sal_uInt16 nSubResult;
872cdf0e10cSrcweir sal_Bool bArea = (aRef.aStart != aRef.aEnd);
873cdf0e10cSrcweir if (bArea)
874cdf0e10cSrcweir nSubResult = InsertPredLevelArea( aRef, rData, nLevel+1 );
875cdf0e10cSrcweir else
876cdf0e10cSrcweir nSubResult = InsertPredLevel( aRef.aStart.Col(), aRef.aStart.Row(),
877cdf0e10cSrcweir rData, nLevel+1 );
878cdf0e10cSrcweir
879cdf0e10cSrcweir switch (nSubResult)
880cdf0e10cSrcweir {
881cdf0e10cSrcweir case DET_INS_INSERTED:
882cdf0e10cSrcweir nResult = DET_INS_INSERTED;
883cdf0e10cSrcweir break;
884cdf0e10cSrcweir case DET_INS_CONTINUE:
885cdf0e10cSrcweir if (nResult != DET_INS_INSERTED)
886cdf0e10cSrcweir nResult = DET_INS_CONTINUE;
887cdf0e10cSrcweir break;
888cdf0e10cSrcweir case DET_INS_CIRCULAR:
889cdf0e10cSrcweir if (nResult == DET_INS_EMPTY)
890cdf0e10cSrcweir nResult = DET_INS_CIRCULAR;
891cdf0e10cSrcweir break;
892cdf0e10cSrcweir // DET_INS_EMPTY: unveraendert lassen
893cdf0e10cSrcweir }
894cdf0e10cSrcweir }
895cdf0e10cSrcweir else // nMaxLevel erreicht
896cdf0e10cSrcweir if (nResult != DET_INS_INSERTED)
897cdf0e10cSrcweir nResult = DET_INS_CONTINUE;
898cdf0e10cSrcweir }
899cdf0e10cSrcweir }
900cdf0e10cSrcweir
901cdf0e10cSrcweir pFCell->SetRunning(sal_False);
902cdf0e10cSrcweir
903cdf0e10cSrcweir return nResult;
904cdf0e10cSrcweir }
905cdf0e10cSrcweir
FindPredLevelArea(const ScRange & rRef,sal_uInt16 nLevel,sal_uInt16 nDeleteLevel)906cdf0e10cSrcweir sal_uInt16 ScDetectiveFunc::FindPredLevelArea( const ScRange& rRef,
907cdf0e10cSrcweir sal_uInt16 nLevel, sal_uInt16 nDeleteLevel )
908cdf0e10cSrcweir {
909cdf0e10cSrcweir sal_uInt16 nResult = nLevel;
910cdf0e10cSrcweir
911cdf0e10cSrcweir ScCellIterator aCellIter( pDoc, rRef);
912cdf0e10cSrcweir ScBaseCell* pCell = aCellIter.GetFirst();
913cdf0e10cSrcweir while (pCell)
914cdf0e10cSrcweir {
915cdf0e10cSrcweir if (pCell->GetCellType() == CELLTYPE_FORMULA)
916cdf0e10cSrcweir {
917cdf0e10cSrcweir sal_uInt16 nTemp = FindPredLevel( aCellIter.GetCol(), aCellIter.GetRow(), nLevel, nDeleteLevel );
918cdf0e10cSrcweir if (nTemp > nResult)
919cdf0e10cSrcweir nResult = nTemp;
920cdf0e10cSrcweir }
921cdf0e10cSrcweir pCell = aCellIter.GetNext();
922cdf0e10cSrcweir }
923cdf0e10cSrcweir
924cdf0e10cSrcweir return nResult;
925cdf0e10cSrcweir }
926cdf0e10cSrcweir
927cdf0e10cSrcweir // nDeleteLevel != 0 -> loeschen
928cdf0e10cSrcweir
FindPredLevel(SCCOL nCol,SCROW nRow,sal_uInt16 nLevel,sal_uInt16 nDeleteLevel)929cdf0e10cSrcweir sal_uInt16 ScDetectiveFunc::FindPredLevel( SCCOL nCol, SCROW nRow, sal_uInt16 nLevel, sal_uInt16 nDeleteLevel )
930cdf0e10cSrcweir {
931cdf0e10cSrcweir DBG_ASSERT( nLevel<1000, "Level" );
932cdf0e10cSrcweir
933cdf0e10cSrcweir ScBaseCell* pCell;
934cdf0e10cSrcweir pDoc->GetCell( nCol, nRow, nTab, pCell );
935cdf0e10cSrcweir if (!pCell)
936cdf0e10cSrcweir return nLevel;
937cdf0e10cSrcweir if (pCell->GetCellType() != CELLTYPE_FORMULA)
938cdf0e10cSrcweir return nLevel;
939cdf0e10cSrcweir
940cdf0e10cSrcweir ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
941cdf0e10cSrcweir if (pFCell->IsRunning())
942cdf0e10cSrcweir return nLevel;
943cdf0e10cSrcweir
944cdf0e10cSrcweir if (pFCell->GetDirty())
945cdf0e10cSrcweir pFCell->Interpret(); // nach SetRunning geht's nicht mehr!
946cdf0e10cSrcweir pFCell->SetRunning(sal_True);
947cdf0e10cSrcweir
948cdf0e10cSrcweir sal_uInt16 nResult = nLevel;
949cdf0e10cSrcweir sal_Bool bDelete = ( nDeleteLevel && nLevel == nDeleteLevel-1 );
950cdf0e10cSrcweir
951cdf0e10cSrcweir if ( bDelete )
952cdf0e10cSrcweir {
953cdf0e10cSrcweir DeleteArrowsAt( nCol, nRow, sal_True ); // Pfeile, die hierher zeigen
954cdf0e10cSrcweir }
955cdf0e10cSrcweir
956cdf0e10cSrcweir ScDetectiveRefIter aIter( (ScFormulaCell*) pCell );
957cdf0e10cSrcweir ScRange aRef;
958cdf0e10cSrcweir while ( aIter.GetNextRef( aRef) )
959cdf0e10cSrcweir {
960cdf0e10cSrcweir sal_Bool bArea = ( aRef.aStart != aRef.aEnd );
961cdf0e10cSrcweir
962cdf0e10cSrcweir if ( bDelete ) // Rahmen loeschen ?
963cdf0e10cSrcweir {
964cdf0e10cSrcweir if (bArea)
965cdf0e10cSrcweir {
966cdf0e10cSrcweir DeleteBox( aRef.aStart.Col(), aRef.aStart.Row(), aRef.aEnd.Col(), aRef.aEnd.Row() );
967cdf0e10cSrcweir }
968cdf0e10cSrcweir }
969cdf0e10cSrcweir else // weitersuchen
970cdf0e10cSrcweir {
971cdf0e10cSrcweir if ( HasArrow( aRef.aStart, nCol,nRow,nTab ) )
972cdf0e10cSrcweir {
973cdf0e10cSrcweir sal_uInt16 nTemp;
974cdf0e10cSrcweir if (bArea)
975cdf0e10cSrcweir nTemp = FindPredLevelArea( aRef, nLevel+1, nDeleteLevel );
976cdf0e10cSrcweir else
977cdf0e10cSrcweir nTemp = FindPredLevel( aRef.aStart.Col(),aRef.aStart.Row(),
978cdf0e10cSrcweir nLevel+1, nDeleteLevel );
979cdf0e10cSrcweir if (nTemp > nResult)
980cdf0e10cSrcweir nResult = nTemp;
981cdf0e10cSrcweir }
982cdf0e10cSrcweir }
983cdf0e10cSrcweir }
984cdf0e10cSrcweir
985cdf0e10cSrcweir pFCell->SetRunning(sal_False);
986cdf0e10cSrcweir
987cdf0e10cSrcweir return nResult;
988cdf0e10cSrcweir }
989cdf0e10cSrcweir
990cdf0e10cSrcweir //------------------------------------------------------------------------
991cdf0e10cSrcweir
InsertErrorLevel(SCCOL nCol,SCROW nRow,ScDetectiveData & rData,sal_uInt16 nLevel)992cdf0e10cSrcweir sal_uInt16 ScDetectiveFunc::InsertErrorLevel( SCCOL nCol, SCROW nRow, ScDetectiveData& rData,
993cdf0e10cSrcweir sal_uInt16 nLevel )
994cdf0e10cSrcweir {
995cdf0e10cSrcweir ScBaseCell* pCell;
996cdf0e10cSrcweir pDoc->GetCell( nCol, nRow, nTab, pCell );
997cdf0e10cSrcweir if (!pCell)
998cdf0e10cSrcweir return DET_INS_EMPTY;
999cdf0e10cSrcweir if (pCell->GetCellType() != CELLTYPE_FORMULA)
1000cdf0e10cSrcweir return DET_INS_EMPTY;
1001cdf0e10cSrcweir
1002cdf0e10cSrcweir ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
1003cdf0e10cSrcweir if (pFCell->IsRunning())
1004cdf0e10cSrcweir return DET_INS_CIRCULAR;
1005cdf0e10cSrcweir
1006cdf0e10cSrcweir if (pFCell->GetDirty())
1007cdf0e10cSrcweir pFCell->Interpret(); // nach SetRunning geht's nicht mehr!
1008cdf0e10cSrcweir pFCell->SetRunning(sal_True);
1009cdf0e10cSrcweir
1010cdf0e10cSrcweir sal_uInt16 nResult = DET_INS_EMPTY;
1011cdf0e10cSrcweir
1012cdf0e10cSrcweir ScDetectiveRefIter aIter( (ScFormulaCell*) pCell );
1013cdf0e10cSrcweir ScRange aRef;
1014cdf0e10cSrcweir ScAddress aErrorPos;
1015cdf0e10cSrcweir sal_Bool bHasError = sal_False;
1016cdf0e10cSrcweir while ( aIter.GetNextRef( aRef ) )
1017cdf0e10cSrcweir {
1018cdf0e10cSrcweir if (HasError( aRef, aErrorPos ))
1019cdf0e10cSrcweir {
1020cdf0e10cSrcweir bHasError = sal_True;
1021cdf0e10cSrcweir if (DrawEntry( nCol, nRow, ScRange( aErrorPos), rData ))
1022cdf0e10cSrcweir nResult = DET_INS_INSERTED;
1023cdf0e10cSrcweir
1024cdf0e10cSrcweir // und weiterverfolgen
1025cdf0e10cSrcweir
1026cdf0e10cSrcweir if ( nLevel < rData.GetMaxLevel() ) // praktisch immer
1027cdf0e10cSrcweir {
1028cdf0e10cSrcweir if (InsertErrorLevel( aErrorPos.Col(), aErrorPos.Row(),
1029cdf0e10cSrcweir rData, nLevel+1 ) == DET_INS_INSERTED)
1030cdf0e10cSrcweir nResult = DET_INS_INSERTED;
1031cdf0e10cSrcweir }
1032cdf0e10cSrcweir }
1033cdf0e10cSrcweir }
1034cdf0e10cSrcweir
1035cdf0e10cSrcweir pFCell->SetRunning(sal_False);
1036cdf0e10cSrcweir
1037cdf0e10cSrcweir // Blaetter ?
1038cdf0e10cSrcweir if (!bHasError)
1039cdf0e10cSrcweir if (InsertPredLevel( nCol, nRow, rData, rData.GetMaxLevel() ) == DET_INS_INSERTED)
1040cdf0e10cSrcweir nResult = DET_INS_INSERTED;
1041cdf0e10cSrcweir
1042cdf0e10cSrcweir return nResult;
1043cdf0e10cSrcweir }
1044cdf0e10cSrcweir
1045cdf0e10cSrcweir //------------------------------------------------------------------------
1046cdf0e10cSrcweir
InsertSuccLevel(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,ScDetectiveData & rData,sal_uInt16 nLevel)1047cdf0e10cSrcweir sal_uInt16 ScDetectiveFunc::InsertSuccLevel( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
1048cdf0e10cSrcweir ScDetectiveData& rData, sal_uInt16 nLevel )
1049cdf0e10cSrcweir {
1050cdf0e10cSrcweir // ueber ganzes Dokument
1051cdf0e10cSrcweir
1052cdf0e10cSrcweir sal_uInt16 nResult = DET_INS_EMPTY;
1053cdf0e10cSrcweir // ScCellIterator aCellIter( pDoc, 0,0, nTab, MAXCOL,MAXROW, nTab );
1054cdf0e10cSrcweir ScCellIterator aCellIter( pDoc, 0,0,0, MAXCOL,MAXROW,MAXTAB ); // alle Tabellen
1055cdf0e10cSrcweir ScBaseCell* pCell = aCellIter.GetFirst();
1056cdf0e10cSrcweir while (pCell)
1057cdf0e10cSrcweir {
1058cdf0e10cSrcweir if (pCell->GetCellType() == CELLTYPE_FORMULA)
1059cdf0e10cSrcweir {
1060cdf0e10cSrcweir ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
1061cdf0e10cSrcweir sal_Bool bRunning = pFCell->IsRunning();
1062cdf0e10cSrcweir
1063cdf0e10cSrcweir if (pFCell->GetDirty())
1064cdf0e10cSrcweir pFCell->Interpret(); // nach SetRunning geht's nicht mehr!
1065cdf0e10cSrcweir pFCell->SetRunning(sal_True);
1066cdf0e10cSrcweir
1067cdf0e10cSrcweir ScDetectiveRefIter aIter( (ScFormulaCell*) pCell );
1068cdf0e10cSrcweir ScRange aRef;
1069cdf0e10cSrcweir while ( aIter.GetNextRef( aRef) )
1070cdf0e10cSrcweir {
1071cdf0e10cSrcweir if (aRef.aStart.Tab() <= nTab && aRef.aEnd.Tab() >= nTab)
1072cdf0e10cSrcweir {
1073cdf0e10cSrcweir if (Intersect( nCol1,nRow1,nCol2,nRow2,
1074cdf0e10cSrcweir aRef.aStart.Col(),aRef.aStart.Row(),
1075cdf0e10cSrcweir aRef.aEnd.Col(),aRef.aEnd.Row() ))
1076cdf0e10cSrcweir {
1077cdf0e10cSrcweir sal_Bool bAlien = ( aCellIter.GetTab() != nTab );
1078cdf0e10cSrcweir sal_Bool bDrawRet;
1079cdf0e10cSrcweir if (bAlien)
1080cdf0e10cSrcweir bDrawRet = DrawAlienEntry( aRef, rData );
1081cdf0e10cSrcweir else
1082cdf0e10cSrcweir bDrawRet = DrawEntry( aCellIter.GetCol(), aCellIter.GetRow(),
1083cdf0e10cSrcweir aRef, rData );
1084cdf0e10cSrcweir if (bDrawRet)
1085cdf0e10cSrcweir {
1086cdf0e10cSrcweir nResult = DET_INS_INSERTED; // neuer Pfeil eingetragen
1087cdf0e10cSrcweir }
1088cdf0e10cSrcweir else
1089cdf0e10cSrcweir {
1090cdf0e10cSrcweir if (bRunning)
1091cdf0e10cSrcweir {
1092cdf0e10cSrcweir if (nResult == DET_INS_EMPTY)
1093cdf0e10cSrcweir nResult = DET_INS_CIRCULAR;
1094cdf0e10cSrcweir }
1095cdf0e10cSrcweir else
1096cdf0e10cSrcweir {
1097cdf0e10cSrcweir // weiterverfolgen
1098cdf0e10cSrcweir
1099cdf0e10cSrcweir if ( nLevel < rData.GetMaxLevel() )
1100cdf0e10cSrcweir {
1101cdf0e10cSrcweir sal_uInt16 nSubResult = InsertSuccLevel(
1102cdf0e10cSrcweir aCellIter.GetCol(), aCellIter.GetRow(),
1103cdf0e10cSrcweir aCellIter.GetCol(), aCellIter.GetRow(),
1104cdf0e10cSrcweir rData, nLevel+1 );
1105cdf0e10cSrcweir switch (nSubResult)
1106cdf0e10cSrcweir {
1107cdf0e10cSrcweir case DET_INS_INSERTED:
1108cdf0e10cSrcweir nResult = DET_INS_INSERTED;
1109cdf0e10cSrcweir break;
1110cdf0e10cSrcweir case DET_INS_CONTINUE:
1111cdf0e10cSrcweir if (nResult != DET_INS_INSERTED)
1112cdf0e10cSrcweir nResult = DET_INS_CONTINUE;
1113cdf0e10cSrcweir break;
1114cdf0e10cSrcweir case DET_INS_CIRCULAR:
1115cdf0e10cSrcweir if (nResult == DET_INS_EMPTY)
1116cdf0e10cSrcweir nResult = DET_INS_CIRCULAR;
1117cdf0e10cSrcweir break;
1118cdf0e10cSrcweir // DET_INS_EMPTY: unveraendert lassen
1119cdf0e10cSrcweir }
1120cdf0e10cSrcweir }
1121cdf0e10cSrcweir else // nMaxLevel erreicht
1122cdf0e10cSrcweir if (nResult != DET_INS_INSERTED)
1123cdf0e10cSrcweir nResult = DET_INS_CONTINUE;
1124cdf0e10cSrcweir }
1125cdf0e10cSrcweir }
1126cdf0e10cSrcweir }
1127cdf0e10cSrcweir }
1128cdf0e10cSrcweir }
1129cdf0e10cSrcweir pFCell->SetRunning(bRunning);
1130cdf0e10cSrcweir }
1131cdf0e10cSrcweir pCell = aCellIter.GetNext();
1132cdf0e10cSrcweir }
1133cdf0e10cSrcweir
1134cdf0e10cSrcweir return nResult;
1135cdf0e10cSrcweir }
1136cdf0e10cSrcweir
FindSuccLevel(SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,sal_uInt16 nLevel,sal_uInt16 nDeleteLevel)1137cdf0e10cSrcweir sal_uInt16 ScDetectiveFunc::FindSuccLevel( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
1138cdf0e10cSrcweir sal_uInt16 nLevel, sal_uInt16 nDeleteLevel )
1139cdf0e10cSrcweir {
1140cdf0e10cSrcweir DBG_ASSERT( nLevel<1000, "Level" );
1141cdf0e10cSrcweir
1142cdf0e10cSrcweir sal_uInt16 nResult = nLevel;
1143cdf0e10cSrcweir sal_Bool bDelete = ( nDeleteLevel && nLevel == nDeleteLevel-1 );
1144cdf0e10cSrcweir
1145cdf0e10cSrcweir ScCellIterator aCellIter( pDoc, 0,0, nTab, MAXCOL,MAXROW, nTab );
1146cdf0e10cSrcweir ScBaseCell* pCell = aCellIter.GetFirst();
1147cdf0e10cSrcweir while (pCell)
1148cdf0e10cSrcweir {
1149cdf0e10cSrcweir if (pCell->GetCellType() == CELLTYPE_FORMULA)
1150cdf0e10cSrcweir {
1151cdf0e10cSrcweir ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
1152cdf0e10cSrcweir sal_Bool bRunning = pFCell->IsRunning();
1153cdf0e10cSrcweir
1154cdf0e10cSrcweir if (pFCell->GetDirty())
1155cdf0e10cSrcweir pFCell->Interpret(); // nach SetRunning geht's nicht mehr!
1156cdf0e10cSrcweir pFCell->SetRunning(sal_True);
1157cdf0e10cSrcweir
1158cdf0e10cSrcweir ScDetectiveRefIter aIter( (ScFormulaCell*) pCell );
1159cdf0e10cSrcweir ScRange aRef;
1160cdf0e10cSrcweir while ( aIter.GetNextRef( aRef) )
1161cdf0e10cSrcweir {
1162cdf0e10cSrcweir if (aRef.aStart.Tab() <= nTab && aRef.aEnd.Tab() >= nTab)
1163cdf0e10cSrcweir {
1164cdf0e10cSrcweir if (Intersect( nCol1,nRow1,nCol2,nRow2,
1165cdf0e10cSrcweir aRef.aStart.Col(),aRef.aStart.Row(),
1166cdf0e10cSrcweir aRef.aEnd.Col(),aRef.aEnd.Row() ))
1167cdf0e10cSrcweir {
1168cdf0e10cSrcweir if ( bDelete ) // Pfeile, die hier anfangen
1169cdf0e10cSrcweir {
1170cdf0e10cSrcweir if (aRef.aStart != aRef.aEnd)
1171cdf0e10cSrcweir {
1172cdf0e10cSrcweir DeleteBox( aRef.aStart.Col(), aRef.aStart.Row(),
1173cdf0e10cSrcweir aRef.aEnd.Col(), aRef.aEnd.Row() );
1174cdf0e10cSrcweir }
1175cdf0e10cSrcweir DeleteArrowsAt( aRef.aStart.Col(), aRef.aStart.Row(), sal_False );
1176cdf0e10cSrcweir }
1177cdf0e10cSrcweir else if ( !bRunning &&
1178cdf0e10cSrcweir HasArrow( aRef.aStart,
1179cdf0e10cSrcweir aCellIter.GetCol(),aCellIter.GetRow(),aCellIter.GetTab() ) )
1180cdf0e10cSrcweir {
1181cdf0e10cSrcweir sal_uInt16 nTemp = FindSuccLevel( aCellIter.GetCol(), aCellIter.GetRow(),
1182cdf0e10cSrcweir aCellIter.GetCol(), aCellIter.GetRow(),
1183cdf0e10cSrcweir nLevel+1, nDeleteLevel );
1184cdf0e10cSrcweir if (nTemp > nResult)
1185cdf0e10cSrcweir nResult = nTemp;
1186cdf0e10cSrcweir }
1187cdf0e10cSrcweir }
1188cdf0e10cSrcweir }
1189cdf0e10cSrcweir }
1190cdf0e10cSrcweir
1191cdf0e10cSrcweir pFCell->SetRunning(bRunning);
1192cdf0e10cSrcweir }
1193cdf0e10cSrcweir pCell = aCellIter.GetNext();
1194cdf0e10cSrcweir }
1195cdf0e10cSrcweir
1196cdf0e10cSrcweir return nResult;
1197cdf0e10cSrcweir }
1198cdf0e10cSrcweir
1199cdf0e10cSrcweir
1200cdf0e10cSrcweir //
1201cdf0e10cSrcweir // --------------------------------------------------------------------------------
1202cdf0e10cSrcweir //
1203cdf0e10cSrcweir
ShowPred(SCCOL nCol,SCROW nRow)1204cdf0e10cSrcweir sal_Bool ScDetectiveFunc::ShowPred( SCCOL nCol, SCROW nRow )
1205cdf0e10cSrcweir {
1206cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
1207cdf0e10cSrcweir if (!pModel)
1208cdf0e10cSrcweir return sal_False;
1209cdf0e10cSrcweir
1210cdf0e10cSrcweir ScDetectiveData aData( pModel );
1211cdf0e10cSrcweir
1212cdf0e10cSrcweir sal_uInt16 nMaxLevel = 0;
1213cdf0e10cSrcweir sal_uInt16 nResult = DET_INS_CONTINUE;
1214cdf0e10cSrcweir while (nResult == DET_INS_CONTINUE && nMaxLevel < 1000)
1215cdf0e10cSrcweir {
1216cdf0e10cSrcweir aData.SetMaxLevel( nMaxLevel );
1217cdf0e10cSrcweir nResult = InsertPredLevel( nCol, nRow, aData, 0 );
1218cdf0e10cSrcweir ++nMaxLevel;
1219cdf0e10cSrcweir }
1220cdf0e10cSrcweir
1221cdf0e10cSrcweir return ( nResult == DET_INS_INSERTED );
1222cdf0e10cSrcweir }
1223cdf0e10cSrcweir
ShowSucc(SCCOL nCol,SCROW nRow)1224cdf0e10cSrcweir sal_Bool ScDetectiveFunc::ShowSucc( SCCOL nCol, SCROW nRow )
1225cdf0e10cSrcweir {
1226cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
1227cdf0e10cSrcweir if (!pModel)
1228cdf0e10cSrcweir return sal_False;
1229cdf0e10cSrcweir
1230cdf0e10cSrcweir ScDetectiveData aData( pModel );
1231cdf0e10cSrcweir
1232cdf0e10cSrcweir sal_uInt16 nMaxLevel = 0;
1233cdf0e10cSrcweir sal_uInt16 nResult = DET_INS_CONTINUE;
1234cdf0e10cSrcweir while (nResult == DET_INS_CONTINUE && nMaxLevel < 1000)
1235cdf0e10cSrcweir {
1236cdf0e10cSrcweir aData.SetMaxLevel( nMaxLevel );
1237cdf0e10cSrcweir nResult = InsertSuccLevel( nCol, nRow, nCol, nRow, aData, 0 );
1238cdf0e10cSrcweir ++nMaxLevel;
1239cdf0e10cSrcweir }
1240cdf0e10cSrcweir
1241cdf0e10cSrcweir return ( nResult == DET_INS_INSERTED );
1242cdf0e10cSrcweir }
1243cdf0e10cSrcweir
ShowError(SCCOL nCol,SCROW nRow)1244cdf0e10cSrcweir sal_Bool ScDetectiveFunc::ShowError( SCCOL nCol, SCROW nRow )
1245cdf0e10cSrcweir {
1246cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
1247cdf0e10cSrcweir if (!pModel)
1248cdf0e10cSrcweir return sal_False;
1249cdf0e10cSrcweir
1250cdf0e10cSrcweir ScRange aRange( nCol, nRow, nTab );
1251cdf0e10cSrcweir ScAddress aErrPos;
1252cdf0e10cSrcweir if ( !HasError( aRange,aErrPos ) )
1253cdf0e10cSrcweir return sal_False;
1254cdf0e10cSrcweir
1255cdf0e10cSrcweir ScDetectiveData aData( pModel );
1256cdf0e10cSrcweir
1257cdf0e10cSrcweir aData.SetMaxLevel( 1000 );
1258cdf0e10cSrcweir sal_uInt16 nResult = InsertErrorLevel( nCol, nRow, aData, 0 );
1259cdf0e10cSrcweir
1260cdf0e10cSrcweir return ( nResult == DET_INS_INSERTED );
1261cdf0e10cSrcweir }
1262cdf0e10cSrcweir
DeleteSucc(SCCOL nCol,SCROW nRow)1263cdf0e10cSrcweir sal_Bool ScDetectiveFunc::DeleteSucc( SCCOL nCol, SCROW nRow )
1264cdf0e10cSrcweir {
1265cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
1266cdf0e10cSrcweir if (!pModel)
1267cdf0e10cSrcweir return sal_False;
1268cdf0e10cSrcweir
1269cdf0e10cSrcweir sal_uInt16 nLevelCount = FindSuccLevel( nCol, nRow, nCol, nRow, 0, 0 );
1270cdf0e10cSrcweir if ( nLevelCount )
1271cdf0e10cSrcweir FindSuccLevel( nCol, nRow, nCol, nRow, 0, nLevelCount ); // loeschen
1272cdf0e10cSrcweir
1273cdf0e10cSrcweir return ( nLevelCount != 0 );
1274cdf0e10cSrcweir }
1275cdf0e10cSrcweir
DeletePred(SCCOL nCol,SCROW nRow)1276cdf0e10cSrcweir sal_Bool ScDetectiveFunc::DeletePred( SCCOL nCol, SCROW nRow )
1277cdf0e10cSrcweir {
1278cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
1279cdf0e10cSrcweir if (!pModel)
1280cdf0e10cSrcweir return sal_False;
1281cdf0e10cSrcweir
1282cdf0e10cSrcweir sal_uInt16 nLevelCount = FindPredLevel( nCol, nRow, 0, 0 );
1283cdf0e10cSrcweir if ( nLevelCount )
1284cdf0e10cSrcweir FindPredLevel( nCol, nRow, 0, nLevelCount ); // loeschen
1285cdf0e10cSrcweir
1286cdf0e10cSrcweir return ( nLevelCount != 0 );
1287cdf0e10cSrcweir }
1288cdf0e10cSrcweir
DeleteAll(ScDetectiveDelete eWhat)1289cdf0e10cSrcweir sal_Bool ScDetectiveFunc::DeleteAll( ScDetectiveDelete eWhat )
1290cdf0e10cSrcweir {
1291cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
1292cdf0e10cSrcweir if (!pModel)
1293cdf0e10cSrcweir return sal_False;
1294cdf0e10cSrcweir
1295cdf0e10cSrcweir SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
1296cdf0e10cSrcweir DBG_ASSERT(pPage,"Page ?");
1297cdf0e10cSrcweir
1298cdf0e10cSrcweir pPage->RecalcObjOrdNums();
1299cdf0e10cSrcweir
1300cdf0e10cSrcweir long nDelCount = 0;
1301cdf0e10cSrcweir sal_uLong nObjCount = pPage->GetObjCount();
1302cdf0e10cSrcweir if (nObjCount)
1303cdf0e10cSrcweir {
1304cdf0e10cSrcweir SdrObject** ppObj = new SdrObject*[nObjCount];
1305cdf0e10cSrcweir
1306cdf0e10cSrcweir SdrObjListIter aIter( *pPage, IM_FLAT );
1307cdf0e10cSrcweir SdrObject* pObject = aIter.Next();
1308cdf0e10cSrcweir while (pObject)
1309cdf0e10cSrcweir {
1310cdf0e10cSrcweir if ( pObject->GetLayer() == SC_LAYER_INTERN )
1311cdf0e10cSrcweir {
1312cdf0e10cSrcweir sal_Bool bDoThis = sal_True;
1313cdf0e10cSrcweir if ( eWhat != SC_DET_ALL )
1314cdf0e10cSrcweir {
1315cdf0e10cSrcweir sal_Bool bCircle = ( pObject->ISA(SdrCircObj) );
1316cdf0e10cSrcweir sal_Bool bCaption = ScDrawLayer::IsNoteCaption( pObject );
1317cdf0e10cSrcweir if ( eWhat == SC_DET_DETECTIVE ) // Detektiv, aus Menue
1318cdf0e10cSrcweir bDoThis = !bCaption; // auch Kreise
1319cdf0e10cSrcweir else if ( eWhat == SC_DET_CIRCLES ) // Kreise, wenn neue erzeugt werden
1320cdf0e10cSrcweir bDoThis = bCircle;
1321cdf0e10cSrcweir else if ( eWhat == SC_DET_ARROWS ) // DetectiveRefresh
1322cdf0e10cSrcweir bDoThis = !bCaption && !bCircle; // don't include circles
1323cdf0e10cSrcweir else
1324cdf0e10cSrcweir {
1325cdf0e10cSrcweir DBG_ERROR("wat?");
1326cdf0e10cSrcweir }
1327cdf0e10cSrcweir }
1328cdf0e10cSrcweir if ( bDoThis )
1329cdf0e10cSrcweir ppObj[nDelCount++] = pObject;
1330cdf0e10cSrcweir }
1331cdf0e10cSrcweir
1332cdf0e10cSrcweir pObject = aIter.Next();
1333cdf0e10cSrcweir }
1334cdf0e10cSrcweir
1335cdf0e10cSrcweir long i;
1336cdf0e10cSrcweir for (i=1; i<=nDelCount; i++)
1337577c0052SWang Lei pModel->AddCalcUndo< SdrUndoRemoveObj >( *ppObj[nDelCount-i] );
1338cdf0e10cSrcweir
1339cdf0e10cSrcweir for (i=1; i<=nDelCount; i++)
1340cdf0e10cSrcweir pPage->RemoveObject( ppObj[nDelCount-i]->GetOrdNum() );
1341cdf0e10cSrcweir
1342cdf0e10cSrcweir delete[] ppObj;
1343cdf0e10cSrcweir
1344cdf0e10cSrcweir Modified();
1345cdf0e10cSrcweir }
1346cdf0e10cSrcweir
1347cdf0e10cSrcweir return ( nDelCount != 0 );
1348cdf0e10cSrcweir }
1349cdf0e10cSrcweir
MarkInvalid(sal_Bool & rOverflow)1350cdf0e10cSrcweir sal_Bool ScDetectiveFunc::MarkInvalid(sal_Bool& rOverflow)
1351cdf0e10cSrcweir {
1352cdf0e10cSrcweir rOverflow = sal_False;
1353cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
1354cdf0e10cSrcweir if (!pModel)
1355cdf0e10cSrcweir return sal_False;
1356cdf0e10cSrcweir
1357cdf0e10cSrcweir sal_Bool bDeleted = DeleteAll( SC_DET_CIRCLES ); // nur die Kreise
1358cdf0e10cSrcweir
1359cdf0e10cSrcweir ScDetectiveData aData( pModel );
1360cdf0e10cSrcweir long nInsCount = 0;
1361cdf0e10cSrcweir
1362cdf0e10cSrcweir // Stellen suchen, wo Gueltigkeit definiert ist
1363cdf0e10cSrcweir
1364cdf0e10cSrcweir ScDocAttrIterator aAttrIter( pDoc, nTab, 0,0,MAXCOL,MAXROW );
1365cdf0e10cSrcweir SCCOL nCol;
1366cdf0e10cSrcweir SCROW nRow1;
1367cdf0e10cSrcweir SCROW nRow2;
1368cdf0e10cSrcweir const ScPatternAttr* pPattern = aAttrIter.GetNext( nCol, nRow1, nRow2 );
1369cdf0e10cSrcweir while ( pPattern && nInsCount < SC_DET_MAXCIRCLE )
1370cdf0e10cSrcweir {
1371cdf0e10cSrcweir sal_uLong nIndex = ((const SfxUInt32Item&)pPattern->GetItem(ATTR_VALIDDATA)).GetValue();
1372cdf0e10cSrcweir if (nIndex)
1373cdf0e10cSrcweir {
1374cdf0e10cSrcweir const ScValidationData* pData = pDoc->GetValidationEntry( nIndex );
1375cdf0e10cSrcweir if ( pData )
1376cdf0e10cSrcweir {
1377cdf0e10cSrcweir // Zellen in dem Bereich durchgehen
1378cdf0e10cSrcweir
1379cdf0e10cSrcweir sal_Bool bMarkEmpty = !pData->IsIgnoreBlank();
1380cdf0e10cSrcweir SCROW nNextRow = nRow1;
1381cdf0e10cSrcweir SCROW nRow;
1382cdf0e10cSrcweir ScCellIterator aCellIter( pDoc, nCol,nRow1,nTab, nCol,nRow2,nTab );
1383cdf0e10cSrcweir ScBaseCell* pCell = aCellIter.GetFirst();
1384cdf0e10cSrcweir while ( pCell && nInsCount < SC_DET_MAXCIRCLE )
1385cdf0e10cSrcweir {
1386cdf0e10cSrcweir SCROW nCellRow = aCellIter.GetRow();
1387cdf0e10cSrcweir if ( bMarkEmpty )
1388cdf0e10cSrcweir for ( nRow = nNextRow; nRow < nCellRow && nInsCount < SC_DET_MAXCIRCLE; nRow++ )
1389cdf0e10cSrcweir {
1390cdf0e10cSrcweir DrawCircle( nCol, nRow, aData );
1391cdf0e10cSrcweir ++nInsCount;
1392cdf0e10cSrcweir }
1393cdf0e10cSrcweir if ( !pData->IsDataValid( pCell, ScAddress( nCol, nCellRow, nTab ) ) )
1394cdf0e10cSrcweir {
1395cdf0e10cSrcweir DrawCircle( nCol, nCellRow, aData );
1396cdf0e10cSrcweir ++nInsCount;
1397cdf0e10cSrcweir }
1398cdf0e10cSrcweir nNextRow = nCellRow + 1;
1399cdf0e10cSrcweir pCell = aCellIter.GetNext();
1400cdf0e10cSrcweir }
1401cdf0e10cSrcweir if ( bMarkEmpty )
1402cdf0e10cSrcweir for ( nRow = nNextRow; nRow <= nRow2 && nInsCount < SC_DET_MAXCIRCLE; nRow++ )
1403cdf0e10cSrcweir {
1404cdf0e10cSrcweir DrawCircle( nCol, nRow, aData );
1405cdf0e10cSrcweir ++nInsCount;
1406cdf0e10cSrcweir }
1407cdf0e10cSrcweir }
1408cdf0e10cSrcweir }
1409cdf0e10cSrcweir
1410cdf0e10cSrcweir pPattern = aAttrIter.GetNext( nCol, nRow1, nRow2 );
1411cdf0e10cSrcweir }
1412cdf0e10cSrcweir
1413cdf0e10cSrcweir if ( nInsCount >= SC_DET_MAXCIRCLE )
1414cdf0e10cSrcweir rOverflow = sal_True;
1415cdf0e10cSrcweir
1416cdf0e10cSrcweir return ( bDeleted || nInsCount != 0 );
1417cdf0e10cSrcweir }
1418cdf0e10cSrcweir
UpdateAllComments(ScDocument & rDoc)1419cdf0e10cSrcweir void ScDetectiveFunc::UpdateAllComments( ScDocument& rDoc )
1420cdf0e10cSrcweir {
1421cdf0e10cSrcweir // for all caption objects, update attributes and SpecialTextBoxShadow flag
1422cdf0e10cSrcweir // (on all tables - nTab is ignored!)
1423cdf0e10cSrcweir
1424cdf0e10cSrcweir // no undo actions, this is refreshed after undo
1425cdf0e10cSrcweir
1426cdf0e10cSrcweir ScDrawLayer* pModel = rDoc.GetDrawLayer();
1427cdf0e10cSrcweir if (!pModel)
1428cdf0e10cSrcweir return;
1429cdf0e10cSrcweir
1430cdf0e10cSrcweir for( SCTAB nObjTab = 0, nTabCount = rDoc.GetTableCount(); nObjTab < nTabCount; ++nObjTab )
1431cdf0e10cSrcweir {
1432cdf0e10cSrcweir rDoc.InitializeNoteCaptions( nObjTab );
1433cdf0e10cSrcweir SdrPage* pPage = pModel->GetPage( static_cast< sal_uInt16 >( nObjTab ) );
1434cdf0e10cSrcweir DBG_ASSERT( pPage, "Page ?" );
1435cdf0e10cSrcweir if( pPage )
1436cdf0e10cSrcweir {
1437cdf0e10cSrcweir SdrObjListIter aIter( *pPage, IM_FLAT );
1438cdf0e10cSrcweir for( SdrObject* pObject = aIter.Next(); pObject; pObject = aIter.Next() )
1439cdf0e10cSrcweir {
1440cdf0e10cSrcweir if ( ScDrawObjData* pData = ScDrawLayer::GetNoteCaptionData( pObject, nObjTab ) )
1441cdf0e10cSrcweir {
1442cdf0e10cSrcweir ScPostIt* pNote = rDoc.GetNote( pData->maStart );
1443cdf0e10cSrcweir // caption should exist, we iterate over drawing objects...
1444cdf0e10cSrcweir DBG_ASSERT( pNote && (pNote->GetCaption() == pObject), "ScDetectiveFunc::UpdateAllComments - invalid cell note" );
1445cdf0e10cSrcweir if( pNote )
1446cdf0e10cSrcweir {
1447cdf0e10cSrcweir ScCommentData aData( rDoc, pModel );
1448cdf0e10cSrcweir SfxItemSet aAttrColorSet = pObject->GetMergedItemSet();
1449cdf0e10cSrcweir aAttrColorSet.Put( XFillColorItem( String(), GetCommentColor() ) );
1450cdf0e10cSrcweir aData.UpdateCaptionSet( aAttrColorSet );
1451cdf0e10cSrcweir pObject->SetMergedItemSetAndBroadcast( aData.GetCaptionSet() );
1452cdf0e10cSrcweir if( SdrCaptionObj* pCaption = dynamic_cast< SdrCaptionObj* >( pObject ) )
1453cdf0e10cSrcweir {
1454cdf0e10cSrcweir pCaption->SetSpecialTextBoxShadow();
1455cdf0e10cSrcweir pCaption->SetFixedTail();
1456cdf0e10cSrcweir }
1457cdf0e10cSrcweir }
1458cdf0e10cSrcweir }
1459cdf0e10cSrcweir }
1460cdf0e10cSrcweir }
1461cdf0e10cSrcweir }
1462cdf0e10cSrcweir }
1463cdf0e10cSrcweir
UpdateAllArrowColors()1464cdf0e10cSrcweir void ScDetectiveFunc::UpdateAllArrowColors()
1465cdf0e10cSrcweir {
1466cdf0e10cSrcweir // no undo actions necessary
1467cdf0e10cSrcweir
1468cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
1469cdf0e10cSrcweir if (!pModel)
1470cdf0e10cSrcweir return;
1471cdf0e10cSrcweir
1472cdf0e10cSrcweir for( SCTAB nObjTab = 0, nTabCount = pDoc->GetTableCount(); nObjTab < nTabCount; ++nObjTab )
1473cdf0e10cSrcweir {
1474cdf0e10cSrcweir SdrPage* pPage = pModel->GetPage( static_cast< sal_uInt16 >( nObjTab ) );
1475cdf0e10cSrcweir DBG_ASSERT( pPage, "Page ?" );
1476cdf0e10cSrcweir if( pPage )
1477cdf0e10cSrcweir {
1478cdf0e10cSrcweir SdrObjListIter aIter( *pPage, IM_FLAT );
1479cdf0e10cSrcweir for( SdrObject* pObject = aIter.Next(); pObject; pObject = aIter.Next() )
1480cdf0e10cSrcweir {
1481cdf0e10cSrcweir if ( pObject->GetLayer() == SC_LAYER_INTERN )
1482cdf0e10cSrcweir {
1483cdf0e10cSrcweir sal_Bool bArrow = sal_False;
1484cdf0e10cSrcweir sal_Bool bError = sal_False;
1485cdf0e10cSrcweir
1486cdf0e10cSrcweir ScAddress aPos;
1487cdf0e10cSrcweir ScRange aSource;
1488cdf0e10cSrcweir sal_Bool bDummy;
1489cdf0e10cSrcweir ScDetectiveObjType eType = GetDetectiveObjectType( pObject, nObjTab, aPos, aSource, bDummy );
1490cdf0e10cSrcweir if ( eType == SC_DETOBJ_ARROW || eType == SC_DETOBJ_TOOTHERTAB )
1491cdf0e10cSrcweir {
1492cdf0e10cSrcweir // source is valid, determine error flag from source range
1493cdf0e10cSrcweir
1494cdf0e10cSrcweir ScAddress aErrPos;
1495cdf0e10cSrcweir if ( HasError( aSource, aErrPos ) )
1496cdf0e10cSrcweir bError = sal_True;
1497cdf0e10cSrcweir else
1498cdf0e10cSrcweir bArrow = sal_True;
1499cdf0e10cSrcweir }
1500cdf0e10cSrcweir else if ( eType == SC_DETOBJ_FROMOTHERTAB )
1501cdf0e10cSrcweir {
1502cdf0e10cSrcweir // source range is no longer known, take error flag from formula itself
1503cdf0e10cSrcweir // (this means, if the formula has an error, all references to other tables
1504cdf0e10cSrcweir // are marked red)
1505cdf0e10cSrcweir
1506cdf0e10cSrcweir ScAddress aErrPos;
1507cdf0e10cSrcweir if ( HasError( ScRange( aPos), aErrPos ) )
1508cdf0e10cSrcweir bError = sal_True;
1509cdf0e10cSrcweir else
1510cdf0e10cSrcweir bArrow = sal_True;
1511cdf0e10cSrcweir }
1512cdf0e10cSrcweir else if ( eType == SC_DETOBJ_CIRCLE )
1513cdf0e10cSrcweir {
1514cdf0e10cSrcweir // circles (error marks) are always red
1515cdf0e10cSrcweir
1516cdf0e10cSrcweir bError = sal_True;
1517cdf0e10cSrcweir }
1518cdf0e10cSrcweir else if ( eType == SC_DETOBJ_NONE )
1519cdf0e10cSrcweir {
1520cdf0e10cSrcweir // frame for area reference has no ObjType, always gets arrow color
1521cdf0e10cSrcweir
1522cdf0e10cSrcweir if ( pObject->ISA( SdrRectObj ) && !pObject->ISA( SdrCaptionObj ) )
1523cdf0e10cSrcweir {
1524cdf0e10cSrcweir bArrow = sal_True;
1525cdf0e10cSrcweir }
1526cdf0e10cSrcweir }
1527cdf0e10cSrcweir
1528cdf0e10cSrcweir if ( bArrow || bError )
1529cdf0e10cSrcweir {
1530cdf0e10cSrcweir ColorData nColorData = ( bError ? GetErrorColor() : GetArrowColor() );
1531cdf0e10cSrcweir //pObject->SendRepaintBroadcast(pObject->GetBoundRect());
1532cdf0e10cSrcweir pObject->SetMergedItem( XLineColorItem( String(), Color( nColorData ) ) );
1533cdf0e10cSrcweir
1534cdf0e10cSrcweir // repaint only
1535cdf0e10cSrcweir pObject->ActionChanged();
1536cdf0e10cSrcweir // pObject->SendRepaintBroadcast(pObject->GetBoundRect());
1537cdf0e10cSrcweir }
1538cdf0e10cSrcweir }
1539cdf0e10cSrcweir }
1540cdf0e10cSrcweir }
1541cdf0e10cSrcweir }
1542cdf0e10cSrcweir }
1543cdf0e10cSrcweir
FindFrameForObject(SdrObject * pObject,ScRange & rRange)1544cdf0e10cSrcweir sal_Bool ScDetectiveFunc::FindFrameForObject( SdrObject* pObject, ScRange& rRange )
1545cdf0e10cSrcweir {
1546cdf0e10cSrcweir // find the rectangle for an arrow (always the object directly before the arrow)
1547cdf0e10cSrcweir // rRange must be initialized to the source cell of the arrow (start of area)
1548cdf0e10cSrcweir
1549cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
1550cdf0e10cSrcweir if (!pModel) return sal_False;
1551cdf0e10cSrcweir
1552cdf0e10cSrcweir SdrPage* pPage = pModel->GetPage(static_cast<sal_uInt16>(nTab));
1553cdf0e10cSrcweir DBG_ASSERT(pPage,"Page ?");
1554cdf0e10cSrcweir if (!pPage) return sal_False;
1555cdf0e10cSrcweir
1556cdf0e10cSrcweir // test if the object is a direct page member
1557cdf0e10cSrcweir if( pObject && pObject->GetPage() && (pObject->GetPage() == pObject->GetObjList()) )
1558cdf0e10cSrcweir {
1559cdf0e10cSrcweir // Is there a previous object?
1560cdf0e10cSrcweir const sal_uInt32 nOrdNum(pObject->GetOrdNum());
1561cdf0e10cSrcweir
1562cdf0e10cSrcweir if(nOrdNum > 0)
1563cdf0e10cSrcweir {
1564cdf0e10cSrcweir SdrObject* pPrevObj = pPage->GetObj(nOrdNum - 1);
1565cdf0e10cSrcweir
1566cdf0e10cSrcweir if ( pPrevObj && pPrevObj->GetLayer() == SC_LAYER_INTERN && pPrevObj->ISA(SdrRectObj) )
1567cdf0e10cSrcweir {
1568cdf0e10cSrcweir ScDrawObjData* pPrevData = ScDrawLayer::GetObjDataTab( pPrevObj, rRange.aStart.Tab() );
1569cdf0e10cSrcweir if ( pPrevData && pPrevData->maStart.IsValid() && pPrevData->maEnd.IsValid() && (pPrevData->maStart == rRange.aStart) )
1570cdf0e10cSrcweir {
1571cdf0e10cSrcweir rRange.aEnd = pPrevData->maEnd;
1572cdf0e10cSrcweir return sal_True;
1573cdf0e10cSrcweir }
1574cdf0e10cSrcweir }
1575cdf0e10cSrcweir }
1576cdf0e10cSrcweir }
1577cdf0e10cSrcweir return sal_False;
1578cdf0e10cSrcweir }
1579cdf0e10cSrcweir
GetDetectiveObjectType(SdrObject * pObject,SCTAB nObjTab,ScAddress & rPosition,ScRange & rSource,sal_Bool & rRedLine)1580cdf0e10cSrcweir ScDetectiveObjType ScDetectiveFunc::GetDetectiveObjectType( SdrObject* pObject, SCTAB nObjTab,
1581cdf0e10cSrcweir ScAddress& rPosition, ScRange& rSource, sal_Bool& rRedLine )
1582cdf0e10cSrcweir {
1583cdf0e10cSrcweir rRedLine = sal_False;
1584cdf0e10cSrcweir ScDetectiveObjType eType = SC_DETOBJ_NONE;
1585cdf0e10cSrcweir
1586cdf0e10cSrcweir if ( pObject && pObject->GetLayer() == SC_LAYER_INTERN )
1587cdf0e10cSrcweir {
1588cdf0e10cSrcweir if ( ScDrawObjData* pData = ScDrawLayer::GetObjDataTab( pObject, nObjTab ) )
1589cdf0e10cSrcweir {
1590cdf0e10cSrcweir bool bValidStart = pData->maStart.IsValid();
1591cdf0e10cSrcweir bool bValidEnd = pData->maEnd.IsValid();
1592cdf0e10cSrcweir
1593cdf0e10cSrcweir if ( pObject->IsPolyObj() && pObject->GetPointCount() == 2 )
1594cdf0e10cSrcweir {
1595cdf0e10cSrcweir // line object -> arrow
1596cdf0e10cSrcweir
1597cdf0e10cSrcweir if ( bValidStart )
1598cdf0e10cSrcweir eType = bValidEnd ? SC_DETOBJ_ARROW : SC_DETOBJ_TOOTHERTAB;
1599cdf0e10cSrcweir else if ( bValidEnd )
1600cdf0e10cSrcweir eType = SC_DETOBJ_FROMOTHERTAB;
1601cdf0e10cSrcweir
1602cdf0e10cSrcweir if ( bValidStart )
1603cdf0e10cSrcweir rSource = pData->maStart;
1604cdf0e10cSrcweir if ( bValidEnd )
1605cdf0e10cSrcweir rPosition = pData->maEnd;
1606cdf0e10cSrcweir
1607cdf0e10cSrcweir if ( bValidStart && lcl_HasThickLine( *pObject ) )
1608cdf0e10cSrcweir {
1609cdf0e10cSrcweir // thick line -> look for frame before this object
1610cdf0e10cSrcweir
1611cdf0e10cSrcweir FindFrameForObject( pObject, rSource ); // modifies rSource
1612cdf0e10cSrcweir }
1613cdf0e10cSrcweir
1614cdf0e10cSrcweir ColorData nObjColor = ((const XLineColorItem&)pObject->GetMergedItem(XATTR_LINECOLOR)).GetColorValue().GetColor();
1615cdf0e10cSrcweir if ( nObjColor == GetErrorColor() && nObjColor != GetArrowColor() )
1616cdf0e10cSrcweir rRedLine = sal_True;
1617cdf0e10cSrcweir }
1618cdf0e10cSrcweir else if ( pObject->ISA(SdrCircObj) )
1619cdf0e10cSrcweir {
1620cdf0e10cSrcweir if ( bValidStart )
1621cdf0e10cSrcweir {
1622cdf0e10cSrcweir // cell position is returned in rPosition
1623cdf0e10cSrcweir
1624cdf0e10cSrcweir rPosition = pData->maStart;
1625cdf0e10cSrcweir eType = SC_DETOBJ_CIRCLE;
1626cdf0e10cSrcweir }
1627cdf0e10cSrcweir }
1628cdf0e10cSrcweir }
1629cdf0e10cSrcweir }
1630cdf0e10cSrcweir
1631cdf0e10cSrcweir return eType;
1632cdf0e10cSrcweir }
1633cdf0e10cSrcweir
InsertObject(ScDetectiveObjType eType,const ScAddress & rPosition,const ScRange & rSource,sal_Bool bRedLine)1634cdf0e10cSrcweir void ScDetectiveFunc::InsertObject( ScDetectiveObjType eType,
1635cdf0e10cSrcweir const ScAddress& rPosition, const ScRange& rSource,
1636cdf0e10cSrcweir sal_Bool bRedLine )
1637cdf0e10cSrcweir {
1638cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
1639cdf0e10cSrcweir if (!pModel) return;
1640cdf0e10cSrcweir ScDetectiveData aData( pModel );
1641cdf0e10cSrcweir
1642cdf0e10cSrcweir switch (eType)
1643cdf0e10cSrcweir {
1644cdf0e10cSrcweir case SC_DETOBJ_ARROW:
1645cdf0e10cSrcweir case SC_DETOBJ_FROMOTHERTAB:
1646cdf0e10cSrcweir InsertArrow( rPosition.Col(), rPosition.Row(),
1647cdf0e10cSrcweir rSource.aStart.Col(), rSource.aStart.Row(),
1648cdf0e10cSrcweir rSource.aEnd.Col(), rSource.aEnd.Row(),
1649cdf0e10cSrcweir (eType == SC_DETOBJ_FROMOTHERTAB), bRedLine, aData );
1650cdf0e10cSrcweir break;
1651cdf0e10cSrcweir case SC_DETOBJ_TOOTHERTAB:
1652cdf0e10cSrcweir InsertToOtherTab( rSource.aStart.Col(), rSource.aStart.Row(),
1653cdf0e10cSrcweir rSource.aEnd.Col(), rSource.aEnd.Row(),
1654cdf0e10cSrcweir bRedLine, aData );
1655cdf0e10cSrcweir break;
1656cdf0e10cSrcweir case SC_DETOBJ_CIRCLE:
1657cdf0e10cSrcweir DrawCircle( rPosition.Col(), rPosition.Row(), aData );
1658cdf0e10cSrcweir break;
1659cdf0e10cSrcweir default:
1660cdf0e10cSrcweir {
1661cdf0e10cSrcweir // added to avoid warnings
1662cdf0e10cSrcweir }
1663cdf0e10cSrcweir }
1664cdf0e10cSrcweir }
1665cdf0e10cSrcweir
1666cdf0e10cSrcweir // static
GetArrowColor()1667cdf0e10cSrcweir ColorData ScDetectiveFunc::GetArrowColor()
1668cdf0e10cSrcweir {
1669cdf0e10cSrcweir if (!bColorsInitialized)
1670cdf0e10cSrcweir InitializeColors();
1671cdf0e10cSrcweir return nArrowColor;
1672cdf0e10cSrcweir }
1673cdf0e10cSrcweir
1674cdf0e10cSrcweir // static
GetErrorColor()1675cdf0e10cSrcweir ColorData ScDetectiveFunc::GetErrorColor()
1676cdf0e10cSrcweir {
1677cdf0e10cSrcweir if (!bColorsInitialized)
1678cdf0e10cSrcweir InitializeColors();
1679cdf0e10cSrcweir return nErrorColor;
1680cdf0e10cSrcweir }
1681cdf0e10cSrcweir
1682cdf0e10cSrcweir // static
GetCommentColor()1683cdf0e10cSrcweir ColorData ScDetectiveFunc::GetCommentColor()
1684cdf0e10cSrcweir {
1685cdf0e10cSrcweir if (!bColorsInitialized)
1686cdf0e10cSrcweir InitializeColors();
1687cdf0e10cSrcweir return nCommentColor;
1688cdf0e10cSrcweir }
1689cdf0e10cSrcweir
1690cdf0e10cSrcweir // static
InitializeColors()1691cdf0e10cSrcweir void ScDetectiveFunc::InitializeColors()
1692cdf0e10cSrcweir {
1693cdf0e10cSrcweir // may be called several times to update colors from configuration
1694cdf0e10cSrcweir
1695cdf0e10cSrcweir const svtools::ColorConfig& rColorCfg = SC_MOD()->GetColorConfig();
1696cdf0e10cSrcweir nArrowColor = rColorCfg.GetColorValue(svtools::CALCDETECTIVE).nColor;
1697cdf0e10cSrcweir nErrorColor = rColorCfg.GetColorValue(svtools::CALCDETECTIVEERROR).nColor;
1698cdf0e10cSrcweir nCommentColor = rColorCfg.GetColorValue(svtools::CALCNOTESBACKGROUND).nColor;
1699cdf0e10cSrcweir
1700cdf0e10cSrcweir bColorsInitialized = sal_True;
1701cdf0e10cSrcweir }
1702cdf0e10cSrcweir
1703cdf0e10cSrcweir // static
IsColorsInitialized()1704cdf0e10cSrcweir sal_Bool ScDetectiveFunc::IsColorsInitialized()
1705cdf0e10cSrcweir {
1706cdf0e10cSrcweir return bColorsInitialized;
1707cdf0e10cSrcweir }
1708cdf0e10cSrcweir
AppendChangTrackNoteSeparator(String & aDisplay)1709*0deba7fbSSteve Yin void ScDetectiveFunc::AppendChangTrackNoteSeparator(String &aDisplay)
1710*0deba7fbSSteve Yin {
1711*0deba7fbSSteve Yin aDisplay.AppendAscii( RTL_CONSTASCII_STRINGPARAM("\n--------\n") );
1712*0deba7fbSSteve Yin }
1713*0deba7fbSSteve Yin
1714