?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix baseline build (old cairo) - 'cairo_rectangle_int_t' does not name a type
[LibreOffice.git] / sc / source / core / data / drwlayer.cxx
blob27e47c81719dbbf11ac0505166a24500986d7da3
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <com/sun/star/uno/Reference.hxx>
21 #include <com/sun/star/chart/XChartDocument.hpp>
22 #include <com/sun/star/embed/XEmbeddedObject.hpp>
23 #include <com/sun/star/embed/XVisualObject.hpp>
24 #include <com/sun/star/embed/XClassifiedObject.hpp>
25 #include <com/sun/star/embed/XComponentSupplier.hpp>
26 #include <com/sun/star/embed/EmbedStates.hpp>
27 #include <com/sun/star/embed/ElementModes.hpp>
28 #include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
29 #include <com/sun/star/datatransfer/XTransferable.hpp>
30 #include <basegfx/matrix/b2dhommatrixtools.hxx>
31
32 #include "scitems.hxx"
33 #include <editeng/eeitem.hxx>
34 #include <editeng/frmdiritem.hxx>
35 #include <sot/exchange.hxx>
36 #include <svx/objfac3d.hxx>
37 #include <svx/xtable.hxx>
38 #include <svx/svdoutl.hxx>
39 #include <svx/svditer.hxx>
40 #include <svx/svdocapt.hxx>
41 #include <svx/svdocirc.hxx>
42 #include <svx/svdoedge.hxx>
43 #include <svx/svdograf.hxx>
44 #include <svx/svdoole2.hxx>
45 #include <svx/svdundo.hxx>
46 #include <i18nlangtag/mslangid.hxx>
47 #include <editeng/unolingu.hxx>
48 #include <svx/drawitem.hxx>
49 #include <editeng/fhgtitem.hxx>
50 #include <editeng/scriptspaceitem.hxx>
51 #include <svx/shapepropertynotifier.hxx>
52 #include <sfx2/viewsh.hxx>
53 #include <sfx2/docfile.hxx>
54 #include <sot/storage.hxx>
55 #include <unotools/pathoptions.hxx>
56 #include <svl/itempool.hxx>
57 #include <vcl/virdev.hxx>
58 #include <vcl/svapp.hxx>
59 #include <vcl/settings.hxx>
60 #include <unotools/ucbstreamhelper.hxx>
61
62 #include <basegfx/polygon/b2dpolygon.hxx>
63 #include <basegfx/polygon/b2dpolygontools.hxx>
64
65 #include "drwlayer.hxx"
66 #include "drawpage.hxx"
67 #include "global.hxx"
68 #include "document.hxx"
69 #include "rechead.hxx"
70 #include "userdat.hxx"
71 #include "markdata.hxx"
72 #include "globstr.hrc"
73 #include "scmod.hxx"
74 #include "chartarr.hxx"
75 #include "postit.hxx"
76 #include "attrib.hxx"
77 #include "charthelper.hxx"
78 #include <basegfx/matrix/b2dhommatrix.hxx>
79
80 #include <vcl/field.hxx>
81 #include <boost/scoped_array.hpp>
82
83 #define DET_ARROW_OFFSET 1000
84
85 using namespace ::com::sun::star;
86
87 // STATIC DATA -----------------------------------------------------------
88
89 static ScDrawObjFactory* pFac = NULL;
90 static E3dObjFactory* pF3d = NULL;
91 static sal_uInt16 nInst = 0;
92
93 SfxObjectShell* ScDrawLayer::pGlobalDrawPersist = NULL;
94
95 bool bDrawIsInUndo = false; //TODO: Member
96
97 ScUndoObjData::ScUndoObjData( SdrObject* pObjP, const ScAddress& rOS, const ScAddress& rOE,
98 const ScAddress& rNS, const ScAddress& rNE ) :
99 SdrUndoObj( *pObjP ),
100 aOldStt( rOS ),
101 aOldEnd( rOE ),
102 aNewStt( rNS ),
103 aNewEnd( rNE )
104 {
105 }
106
107 ScUndoObjData::~ScUndoObjData()
108 {
109 }
110
111 void ScUndoObjData::Undo()
112 {
113 ScDrawObjData* pData = ScDrawLayer::GetObjData( pObj );
114 OSL_ENSURE(pData,"ScUndoObjData: Data missing");
115 if (pData)
116 {
117 pData->maStart = aOldStt;
118 pData->maEnd = aOldEnd;
119 }
120
121 // Undo also an untransformed anchor
122 pData = ScDrawLayer::GetNonRotatedObjData( pObj );
123 if (pData)
124 {
125 pData->maStart = aOldStt;
126 pData->maEnd = aOldEnd;
127 }
128 }
129
130 void ScUndoObjData::Redo()
131 {
132 ScDrawObjData* pData = ScDrawLayer::GetObjData( pObj );
133 OSL_ENSURE(pData,"ScUndoObjData: Data missing");
134 if (pData)
135 {
136 pData->maStart = aNewStt;
137 pData->maEnd = aNewEnd;
138 }
139
140 // Redo also an untransformed anchor
141 pData = ScDrawLayer::GetNonRotatedObjData( pObj );
142 if (pData)
143 {
144 pData->maStart = aNewStt;
145 pData->maEnd = aNewEnd;
146 }
147 }
148
149 ScUndoAnchorData::ScUndoAnchorData( SdrObject* pObjP, ScDocument* pDoc, SCTAB nTab ) :
150 SdrUndoObj( *pObjP ),
151 mpDoc( pDoc ),
152 mnTab( nTab )
153 {
154 mbWasCellAnchored = ScDrawLayer::IsCellAnchored( *pObjP );
155 }
156
157 ScUndoAnchorData::~ScUndoAnchorData()
158 {
159 }
160
161 void ScUndoAnchorData::Undo()
162 {
163 // Trigger Object Change
164 if (pObj->IsInserted() && pObj->GetPage() && pObj->GetModel())
165 {
166 SdrHint aHint(*pObj);
167 pObj->GetModel()->Broadcast(aHint);
168 }
169
170 if (mbWasCellAnchored)
171 ScDrawLayer::SetCellAnchoredFromPosition(*pObj, *mpDoc, mnTab);
172 else
173 ScDrawLayer::SetPageAnchored( *pObj );
174 }
175
176 void ScUndoAnchorData::Redo()
177 {
178 if (mbWasCellAnchored)
179 ScDrawLayer::SetPageAnchored( *pObj );
180 else
181 ScDrawLayer::SetCellAnchoredFromPosition(*pObj, *mpDoc, mnTab);
182
183 // Trigger Object Change
184 if (pObj->IsInserted() && pObj->GetPage() && pObj->GetModel())
185 {
186 SdrHint aHint(*pObj);
187 pObj->GetModel()->Broadcast(aHint);
188 }
189 }
190
191 ScTabDeletedHint::ScTabDeletedHint( SCTAB nTabNo ) :
192 nTab( nTabNo )
193 {
194 }
195
196 ScTabDeletedHint::~ScTabDeletedHint()
197 {
198 }
199
200 ScTabSizeChangedHint::ScTabSizeChangedHint( SCTAB nTabNo ) :
201 nTab( nTabNo )
202 {
203 }
204
205 ScTabSizeChangedHint::~ScTabSizeChangedHint()
206 {
207 }
208
209 #define MAXMM 10000000
210
211 inline long TwipsToHmm (long nVal)
212 {
213 return static_cast< long >( MetricField::ConvertDoubleValue (static_cast<sal_Int64>(nVal), 0, 0,
214 FUNIT_TWIP, FUNIT_100TH_MM) );
215 }
216
217 inline long HmmToTwips (long nVal)
218 {
219 return static_cast< long > ( MetricField::ConvertDoubleValue (static_cast<sal_Int64>(nVal), 0, 0,
220 FUNIT_100TH_MM, FUNIT_TWIP) );
221 }
222
223 inline void TwipsToMM( long& nVal )
224 {
225 nVal = TwipsToHmm (nVal);
226 }
227
228 inline void ReverseTwipsToMM( long& nVal )
229 {
230 nVal = HmmToTwips (nVal);
231 }
232
233 static void lcl_ReverseTwipsToMM( Rectangle& rRect )
234 {
235 ReverseTwipsToMM( rRect.Left() );
236 ReverseTwipsToMM( rRect.Right() );
237 ReverseTwipsToMM( rRect.Top() );
238 ReverseTwipsToMM( rRect.Bottom() );
239 }
240
241 ScDrawLayer::ScDrawLayer( ScDocument* pDocument, const OUString& rName ) :
242 FmFormModel( SvtPathOptions().GetPalettePath(),
243 NULL, // SfxItemPool* Pool
244 pGlobalDrawPersist ?
245 pGlobalDrawPersist :
246 ( pDocument ? pDocument->GetDocumentShell() : NULL ),
247 true ), // bUseExtColorTable (is set below)
248 aName( rName ),
249 pDoc( pDocument ),
250 pUndoGroup( NULL ),
251 bRecording( false ),
252 bAdjustEnabled( true ),
253 bHyphenatorSet( false )
254 {
255 pGlobalDrawPersist = NULL; // Only use once
256
257 SfxObjectShell* pObjSh = pDocument ? pDocument->GetDocumentShell() : NULL;
258 XColorListRef pXCol = XColorList::GetStdColorList();
259 if ( pObjSh )
260 {
261 SetObjectShell( pObjSh );
262
263 // set color table
264 const SvxColorListItem* pColItem = static_cast<const SvxColorListItem*>( pObjSh->GetItem( SID_COLOR_TABLE ) );
265 if ( pColItem )
266 pXCol = pColItem->GetColorList();
267 }
268 SetPropertyList( static_cast<XPropertyList *> (pXCol.get()) );
269
270 SetSwapGraphics(true);
271
272 SetScaleUnit(MAP_100TH_MM);
273 SfxItemPool& rPool = GetItemPool();
274 rPool.SetDefaultMetric(SFX_MAPUNIT_100TH_MM);
275 SvxFrameDirectionItem aModeItem( FRMDIR_ENVIRONMENT, EE_PARA_WRITINGDIR );
276 rPool.SetPoolDefaultItem( aModeItem );
277
278 // #i33700#
279 // Set shadow distance defaults as PoolDefaultItems. Details see bug.
280 rPool.SetPoolDefaultItem(makeSdrShadowXDistItem(300));
281 rPool.SetPoolDefaultItem(makeSdrShadowYDistItem(300));
282
283 // default for script spacing depends on locale, see SdDrawDocument ctor in sd
284 LanguageType eOfficeLanguage = Application::GetSettings().GetLanguageTag().getLanguageType();
285 if (MsLangId::isKorean(eOfficeLanguage) || eOfficeLanguage == LANGUAGE_JAPANESE)
286 {
287 // secondary is edit engine pool
288 rPool.GetSecondaryPool()->SetPoolDefaultItem( SvxScriptSpaceItem( false, EE_PARA_ASIANCJKSPACING ) );
289 }
290
291 rPool.FreezeIdRanges(); // the pool is also used directly
292
293 SdrLayerAdmin& rAdmin = GetLayerAdmin();
294 rAdmin.NewLayer(OUString("vorne"), SC_LAYER_FRONT);
295 rAdmin.NewLayer(OUString("hinten"), SC_LAYER_BACK);
296 rAdmin.NewLayer(OUString("intern"), SC_LAYER_INTERN);
297 rAdmin.NewLayer(OUString("Controls"), SC_LAYER_CONTROLS);
298 rAdmin.NewLayer(OUString("hidden"), SC_LAYER_HIDDEN);
299 // "Controls" is new - must also be created when loading
300
301 // Set link for URL-Fields
302 ScModule* pScMod = SC_MOD();
303 Outliner& rOutliner = GetDrawOutliner();
304 rOutliner.SetCalcFieldValueHdl( LINK( pScMod, ScModule, CalcFieldValueHdl ) );
305
306 Outliner& rHitOutliner = GetHitTestOutliner();
307 rHitOutliner.SetCalcFieldValueHdl( LINK( pScMod, ScModule, CalcFieldValueHdl ) );
308
309 // set FontHeight pool defaults without changing static SdrEngineDefaults
310 SfxItemPool* pOutlinerPool = rOutliner.GetEditTextObjectPool();
311 if ( pOutlinerPool )
312 {
313 pItemPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT )); // 12Pt
314 pItemPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT_CJK )); // 12Pt
315 pItemPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT_CTL )); // 12Pt
316 }
317 SfxItemPool* pHitOutlinerPool = rHitOutliner.GetEditTextObjectPool();
318 if ( pHitOutlinerPool )
319 {
320 pHitOutlinerPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT )); // 12Pt
321 pHitOutlinerPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT_CJK )); // 12Pt
322 pHitOutlinerPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT_CTL )); // 12Pt
323 }
324
325 // initial undo mode as in Calc document
326 if( pDoc )
327 EnableUndo( pDoc->IsUndoEnabled() );
328
329 // URL-Buttons have no handler anymore, all is done by themselves
330
331 if( !nInst++ )
332 {
333 pFac = new ScDrawObjFactory;
334 pF3d = new E3dObjFactory;
335 }
336 }
337
338 ScDrawLayer::~ScDrawLayer()
339 {
340 Broadcast(SdrHint(HINT_MODELCLEARED));
341
342 ClearModel(true);
343
344 delete pUndoGroup;
345 if( !--nInst )
346 {
347 delete pFac, pFac = NULL;
348 delete pF3d, pF3d = NULL;
349 }
350 }
351
352 void ScDrawLayer::UseHyphenator()
353 {
354 if (!bHyphenatorSet)
355 {
356 com::sun::star::uno::Reference< com::sun::star::linguistic2::XHyphenator >
357 xHyphenator = LinguMgr::GetHyphenator();
358
359 GetDrawOutliner().SetHyphenator( xHyphenator );
360 GetHitTestOutliner().SetHyphenator( xHyphenator );
361
362 bHyphenatorSet = true;
363 }
364 }
365
366 SdrPage* ScDrawLayer::AllocPage(bool bMasterPage)
367 {
368 return new ScDrawPage(*this, bMasterPage);
369 }
370
371 bool ScDrawLayer::HasObjects() const
372 {
373 bool bFound = false;
374
375 sal_uInt16 nCount = GetPageCount();
376 for (sal_uInt16 i=0; i<nCount && !bFound; i++)
377 if (GetPage(i)->GetObjCount())
378 bFound = true;
379
380 return bFound;
381 }
382
383 SdrModel* ScDrawLayer::AllocModel() const
384 {
385 // Allocated model (for clipboard etc) must not have a pointer
386 // to the original model's document, pass NULL as document:
387
388 return new ScDrawLayer( NULL, aName );
389 }
390
391 bool ScDrawLayer::ScAddPage( SCTAB nTab )
392 {
393 if (bDrawIsInUndo)
394 return false; // not inserted
395
396 ScDrawPage* pPage = static_cast<ScDrawPage*>(AllocPage( false ));
397 InsertPage(pPage, static_cast<sal_uInt16>(nTab));
398 if (bRecording)
399 AddCalcUndo(new SdrUndoNewPage(*pPage));
400
401 ResetTab(nTab, pDoc->GetTableCount()-1);
402 return true; // inserted
403 }
404
405 void ScDrawLayer::ScRemovePage( SCTAB nTab )
406 {
407 if (bDrawIsInUndo)
408 return;
409
410 Broadcast( ScTabDeletedHint( nTab ) );
411 if (bRecording)
412 {
413 SdrPage* pPage = GetPage(static_cast<sal_uInt16>(nTab));
414 AddCalcUndo(new SdrUndoDelPage(*pPage)); // Undo-Action becomes the page owner
415 RemovePage( static_cast<sal_uInt16>(nTab) ); // just deliver, not deleting
416 }
417 else
418 DeletePage( static_cast<sal_uInt16>(nTab) ); // just get rid of it
419
420 ResetTab(nTab, pDoc->GetTableCount()-1);
421 }
422
423 void ScDrawLayer::ScRenamePage( SCTAB nTab, const OUString& rNewName )
424 {
425 ScDrawPage* pPage = static_cast<ScDrawPage*>( GetPage(static_cast<sal_uInt16>(nTab)) );
426 if (pPage)
427 pPage->SetName(rNewName);
428 }
429
430 void ScDrawLayer::ScMovePage( sal_uInt16 nOldPos, sal_uInt16 nNewPos )
431 {
432 MovePage( nOldPos, nNewPos );
433 sal_uInt16 nMinPos = std::min(nOldPos, nNewPos);
434 ResetTab(nMinPos, pDoc->GetTableCount()-1);
435 }
436
437 void ScDrawLayer::ScCopyPage( sal_uInt16 nOldPos, sal_uInt16 nNewPos)
438 {
439 if (bDrawIsInUndo)
440 return;
441
442 SdrPage* pOldPage = GetPage(nOldPos);
443 SdrPage* pNewPage = GetPage(nNewPos);
444
445 // Copying
446
447 if (pOldPage && pNewPage)
448 {
449 SCTAB nOldTab = static_cast<SCTAB>(nOldPos);
450 SCTAB nNewTab = static_cast<SCTAB>(nNewPos);
451
452 SdrObjListIter aIter( *pOldPage, IM_FLAT );
453 SdrObject* pOldObject = aIter.Next();
454 while (pOldObject)
455 {
456 ScDrawObjData* pOldData = GetObjData(pOldObject);
457 if (pOldData)
458 {
459 pOldData->maStart.SetTab(nOldTab);
460 pOldData->maEnd.SetTab(nOldTab);
461 }
462 SdrObject* pNewObject = pOldObject->Clone();
463 pNewObject->SetModel(this);
464 pNewObject->SetPage(pNewPage);
465
466 pNewObject->NbcMove(Size(0,0));
467 pNewPage->InsertObject( pNewObject );
468 ScDrawObjData* pNewData = GetObjData(pNewObject);
469 if (pNewData)
470 {
471 pNewData->maStart.SetTab(nNewTab);
472 pNewData->maEnd.SetTab(nNewTab);
473 }
474
475 if (bRecording)
476 AddCalcUndo( new SdrUndoInsertObj( *pNewObject ) );
477
478 pOldObject = aIter.Next();
479 }
480 }
481
482 ResetTab(static_cast<SCTAB>(nNewPos), pDoc->GetTableCount()-1);
483 }
484
485 void ScDrawLayer::ResetTab( SCTAB nStart, SCTAB nEnd )
486 {
487 SCTAB nPageSize = static_cast<SCTAB>(GetPageCount());
488 if (nPageSize < 0)
489 // No drawing pages exist.
490 return;
491
492 if (nEnd >= nPageSize)
493 // Avoid iterating beyond the last existing page.
494 nEnd = nPageSize - 1;
495
496 for (SCTAB i = nStart; i <= nEnd; ++i)
497 {
498 SdrPage* pPage = GetPage(static_cast<sal_uInt16>(i));
499 if (!pPage)
500 continue;
501
502 SdrObjListIter aIter(*pPage, IM_FLAT);
503 for (SdrObject* pObj = aIter.Next(); pObj; pObj = aIter.Next())
504 {
505 ScDrawObjData* pData = GetObjData(pObj);
506 if (!pData)
507 continue;
508
509 pData->maStart.SetTab(i);
510 pData->maEnd.SetTab(i);
511 }
512 }
513 }
514
515 inline bool IsInBlock( const ScAddress& rPos, SCCOL nCol1,SCROW nRow1, SCCOL nCol2,SCROW nRow2 )
516 {
517 return rPos.Col() >= nCol1 && rPos.Col() <= nCol2 &&
518 rPos.Row() >= nRow1 && rPos.Row() <= nRow2;
519 }
520
521 void ScDrawLayer::MoveCells( SCTAB nTab, SCCOL nCol1,SCROW nRow1, SCCOL nCol2,SCROW nRow2,
522 SCsCOL nDx,SCsROW nDy, bool bUpdateNoteCaptionPos )
523 {
524 SdrPage* pPage = GetPage(static_cast<sal_uInt16>(nTab));
525 OSL_ENSURE(pPage,"Page not found");
526 if (!pPage)
527 return;
528
529 bool bNegativePage = pDoc && pDoc->IsNegativePage( nTab );
530
531 const size_t nCount = pPage->GetObjCount();
532 for ( size_t i = 0; i < nCount; ++i )
533 {
534 SdrObject* pObj = pPage->GetObj( i );
535 ScDrawObjData* pData = GetObjDataTab( pObj, nTab );
536 if( pData )
537 {
538 const ScAddress aOldStt = pData->maStart;
539 const ScAddress aOldEnd = pData->maEnd;
540 bool bChange = false;
541 if ( aOldStt.IsValid() && IsInBlock( aOldStt, nCol1,nRow1, nCol2,nRow2 ) )
542 {
543 pData->maStart.IncCol( nDx );
544 pData->maStart.IncRow( nDy );
545 bChange = true;
546 }
547 if ( aOldEnd.IsValid() && IsInBlock( aOldEnd, nCol1,nRow1, nCol2,nRow2 ) )
548 {
549 pData->maEnd.IncCol( nDx );
550 pData->maEnd.IncRow( nDy );
551 bChange = true;
552 }
553 if (bChange)
554 {
555 if ( pObj->ISA( SdrRectObj ) && pData->maStart.IsValid() && pData->maEnd.IsValid() )
556 pData->maStart.PutInOrder( pData->maEnd );
557
558 // Update also an untransformed anchor thats what we stored ( and still do ) to xml
559 ScDrawObjData* pNoRotatedAnchor = GetNonRotatedObjData( pObj, false );
560 if ( pNoRotatedAnchor )
561 {
562 pNoRotatedAnchor->maStart = pData->maStart;
563 pNoRotatedAnchor->maEnd = pData->maEnd;
564 }
565
566 AddCalcUndo( new ScUndoObjData( pObj, aOldStt, aOldEnd, pData->maStart, pData->maEnd ) );
567 RecalcPos( pObj, *pData, bNegativePage, bUpdateNoteCaptionPos );
568 }
569 }
570 }
571 }
572
573 void ScDrawLayer::SetPageSize( sal_uInt16 nPageNo, const Size& rSize, bool bUpdateNoteCaptionPos )
574 {
575 SdrPage* pPage = GetPage(nPageNo);
576 if (pPage)
577 {
578 if ( rSize != pPage->GetSize() )
579 {
580 pPage->SetSize( rSize );
581 Broadcast( ScTabSizeChangedHint( static_cast<SCTAB>(nPageNo) ) ); // SetWorkArea() an den Views
582 }
583
584 // Implement Detective lines (adjust to new heights / widths)
585 // even if size is still the same
586 // (individual rows/columns can have been changed))
587
588 bool bNegativePage = pDoc && pDoc->IsNegativePage( static_cast<SCTAB>(nPageNo) );
589
590 const size_t nCount = pPage->GetObjCount();
591 for ( size_t i = 0; i < nCount; ++i )
592 {
593 SdrObject* pObj = pPage->GetObj( i );
594 ScDrawObjData* pData = GetObjDataTab( pObj, static_cast<SCTAB>(nPageNo) );
595 if( pData )
596 RecalcPos( pObj, *pData, bNegativePage, bUpdateNoteCaptionPos );
597 }
598 }
599 }
600
601 namespace
602 {
603 //Can't have a zero width dimension
604 Rectangle lcl_makeSafeRectangle(const Rectangle &rNew)
605 {
606 Rectangle aRect = rNew;
607 if (aRect.Bottom() == aRect.Top())
608 aRect.Bottom() = aRect.Top()+1;
609 if (aRect.Right() == aRect.Left())
610 aRect.Right() = aRect.Left()+1;
611 return aRect;
612 }
613
614 Point lcl_calcAvailableDiff(ScDocument &rDoc, SCCOL nCol, SCROW nRow, SCTAB nTab, const Point &aWantedDiff)
615 {
616 Point aAvailableDiff(aWantedDiff);
617 long nHeight = static_cast<long>(rDoc.GetRowHeight( nRow, nTab ) * HMM_PER_TWIPS);
618 long nWidth = static_cast<long>(rDoc.GetColWidth( nCol, nTab ) * HMM_PER_TWIPS);
619 if (aAvailableDiff.Y() > nHeight)
620 aAvailableDiff.Y() = nHeight;
621 if (aAvailableDiff.X() > nWidth)
622 aAvailableDiff.X() = nWidth;
623 return aAvailableDiff;
624 }
625
626 Rectangle lcl_UpdateCalcPoly(basegfx::B2DPolygon &rCalcPoly, int nWhichPoint, const Point &rPos)
627 {
628 rCalcPoly.setB2DPoint(nWhichPoint, basegfx::B2DPoint(rPos.X(), rPos.Y()));
629 basegfx::B2DRange aRange(basegfx::tools::getRange(rCalcPoly));
630 return Rectangle(static_cast<long>(aRange.getMinX()), static_cast<long>(aRange.getMinY()),
631 static_cast<long>(aRange.getMaxX()), static_cast<long>(aRange.getMaxY()));
632 }
633 }
634 void ScDrawLayer::ResizeLastRectFromAnchor( SdrObject* pObj, ScDrawObjData& rData, bool bUseLogicRect, bool bNegativePage, bool bCanResize, bool bHiddenAsZero )
635 {
636 rData.maLastRect = ( bUseLogicRect ? pObj->GetLogicRect() : pObj->GetSnapRect() );
637 SCCOL nCol1 = rData.maStart.Col();
638 SCROW nRow1 = rData.maStart.Row();
639 SCTAB nTab1 = rData.maStart.Tab();
640 SCCOL nCol2 = rData.maEnd.Col();
641 SCROW nRow2 = rData.maEnd.Row();
642 SCTAB nTab2 = rData.maEnd.Tab();
643 Point aPos( pDoc->GetColOffset( nCol1, nTab1, bHiddenAsZero ), pDoc->GetRowOffset( nRow1, nTab1, bHiddenAsZero ) );
644 TwipsToMM( aPos.X() );
645 TwipsToMM( aPos.Y() );
646 aPos += lcl_calcAvailableDiff(*pDoc, nCol1, nRow1, nTab1, rData.maStartOffset);
647
648 if( bCanResize )
649 {
650 Point aEnd( pDoc->GetColOffset( nCol2, nTab2, bHiddenAsZero ), pDoc->GetRowOffset( nRow2, nTab2, bHiddenAsZero ) );
651 TwipsToMM( aEnd.X() );
652 TwipsToMM( aEnd.Y() );
653 aEnd += lcl_calcAvailableDiff(*pDoc, nCol2, nRow2, nTab2, rData.maEndOffset);
654
655 Rectangle aNew = Rectangle( aPos, aEnd );
656 if ( bNegativePage )
657 MirrorRectRTL( aNew );
658
659 rData.maLastRect = lcl_makeSafeRectangle(aNew);
660 }
661 else
662 {
663 if ( bNegativePage )
664 aPos.X() = -aPos.X() - rData.maLastRect.GetWidth();
665 // shouldn't we initialise maLastRect with the object rectangle ?
666 rData.maLastRect.SetPos( aPos );
667 }
668 }
669
670 void ScDrawLayer::RecalcPos( SdrObject* pObj, ScDrawObjData& rData, bool bNegativePage, bool bUpdateNoteCaptionPos )
671 {
672 OSL_ENSURE( pDoc, "ScDrawLayer::RecalcPos - missing document" );
673 if( !pDoc )
674 return;
675
676 if (rData.meType == ScDrawObjData::CellNote)
677 {
678 OSL_ENSURE( rData.maStart.IsValid(), "ScDrawLayer::RecalcPos - invalid position for cell note" );
679 /* #i109372# On insert/remove rows/columns/cells: Updating the caption
680 position must not be done, if the cell containing the note has not
681 been moved yet in the document. The calling code now passes an
682 additional boolean stating if the cells are already moved. */
683 if( bUpdateNoteCaptionPos )
684 /* When inside an undo action, there may be pending note captions
685 where cell note is already deleted (thus document cannot find
686 the note object anymore). The caption will be deleted later
687 with drawing undo. */
688 if( ScPostIt* pNote = pDoc->GetNote( rData.maStart ) )
689 pNote->UpdateCaptionPos( rData.maStart );
690 return;
691 }
692
693 bool bValid1 = rData.maStart.IsValid();
694 SCCOL nCol1 = rData.maStart.Col();
695 SCROW nRow1 = rData.maStart.Row();
696 SCTAB nTab1 = rData.maStart.Tab();
697 bool bValid2 = rData.maEnd.IsValid();
698 SCCOL nCol2 = rData.maEnd.Col();
699 SCROW nRow2 = rData.maEnd.Row();
700 SCTAB nTab2 = rData.maEnd.Tab();
701
702 if (rData.meType == ScDrawObjData::ValidationCircle)
703 {
704 // Validation circle for detective.
705 rData.maLastRect = pObj->GetLogicRect();
706
707 Point aPos( pDoc->GetColOffset( nCol1, nTab1 ), pDoc->GetRowOffset( nRow1, nTab1 ) );
708 TwipsToMM( aPos.X() );
709 TwipsToMM( aPos.Y() );
710
711 // Calculations and values as in detfunc.cxx
712
713 Size aSize( (long)( TwipsToHmm( pDoc->GetColWidth( nCol1, nTab1) ) ),
714 (long)( TwipsToHmm( pDoc->GetRowHeight( nRow1, nTab1) ) ) );
715 Rectangle aRect( aPos, aSize );
716 aRect.Left() -= 250;
717 aRect.Right() += 250;
718 aRect.Top() -= 70;
719 aRect.Bottom() += 70;
720 if ( bNegativePage )
721 MirrorRectRTL( aRect );
722
723 if ( pObj->GetLogicRect() != aRect )
724 {
725 if (bRecording)
726 AddCalcUndo( new SdrUndoGeoObj( *pObj ) );
727 rData.maLastRect = lcl_makeSafeRectangle(aRect);
728 pObj->SetLogicRect(rData.maLastRect);
729 }
730 }
731 else if (rData.meType == ScDrawObjData::DetectiveArrow)
732 {
733 rData.maLastRect = pObj->GetLogicRect();
734 basegfx::B2DPolygon aCalcPoly;
735 Point aOrigStartPos(pObj->GetPoint(0));
736 Point aOrigEndPos(pObj->GetPoint(1));
737 aCalcPoly.append(basegfx::B2DPoint(aOrigStartPos.X(), aOrigStartPos.Y()));
738 aCalcPoly.append(basegfx::B2DPoint(aOrigEndPos.X(), aOrigEndPos.Y()));
739 //TODO: do not create multiple Undos for one object (last one can be omitted then)
740
741 SCCOL nLastCol;
742 SCROW nLastRow;
743 if( bValid1 )
744 {
745 Point aPos( pDoc->GetColOffset( nCol1, nTab1 ), pDoc->GetRowOffset( nRow1, nTab1 ) );
746 if (!pDoc->ColHidden(nCol1, nTab1, NULL, &nLastCol))
747 aPos.X() += pDoc->GetColWidth( nCol1, nTab1 ) / 4;
748 if (!pDoc->RowHidden(nRow1, nTab1, NULL, &nLastRow))
749 aPos.Y() += pDoc->GetRowHeight( nRow1, nTab1 ) / 2;
750 TwipsToMM( aPos.X() );
751 TwipsToMM( aPos.Y() );
752 Point aStartPos = aPos;
753 if ( bNegativePage )
754 aStartPos.X() = -aStartPos.X(); // don't modify aPos - used below
755 if ( pObj->GetPoint( 0 ) != aStartPos )
756 {
757 if (bRecording)
758 AddCalcUndo( new SdrUndoGeoObj( *pObj ) );
759
760 rData.maLastRect = lcl_UpdateCalcPoly(aCalcPoly, 0, aStartPos);
761 pObj->SetPoint( aStartPos, 0 );
762 }
763
764 if( !bValid2 )
765 {
766 Point aEndPos( aPos.X() + DET_ARROW_OFFSET, aPos.Y() - DET_ARROW_OFFSET );
767 if (aEndPos.Y() < 0)
768 aEndPos.Y() += (2 * DET_ARROW_OFFSET);
769 if ( bNegativePage )
770 aEndPos.X() = -aEndPos.X();
771 if ( pObj->GetPoint( 1 ) != aEndPos )
772 {
773 if (bRecording)
774 AddCalcUndo( new SdrUndoGeoObj( *pObj ) );
775
776 rData.maLastRect = lcl_UpdateCalcPoly(aCalcPoly, 1, aEndPos);
777 pObj->SetPoint( aEndPos, 1 );
778 }
779 }
780 }
781 if( bValid2 )
782 {
783 Point aPos( pDoc->GetColOffset( nCol2, nTab2 ), pDoc->GetRowOffset( nRow2, nTab2 ) );
784 if (!pDoc->ColHidden(nCol2, nTab2, NULL, &nLastCol))
785 aPos.X() += pDoc->GetColWidth( nCol2, nTab2 ) / 4;
786 if (!pDoc->RowHidden(nRow2, nTab2, NULL, &nLastRow))
787 aPos.Y() += pDoc->GetRowHeight( nRow2, nTab2 ) / 2;
788 TwipsToMM( aPos.X() );
789 TwipsToMM( aPos.Y() );
790 Point aEndPos = aPos;
791 if ( bNegativePage )
792 aEndPos.X() = -aEndPos.X(); // don't modify aPos - used below
793 if ( pObj->GetPoint( 1 ) != aEndPos )
794 {
795 if (bRecording)
796 AddCalcUndo( new SdrUndoGeoObj( *pObj ) );
797
798 rData.maLastRect = lcl_UpdateCalcPoly(aCalcPoly, 1, aEndPos);
799 pObj->SetPoint( aEndPos, 1 );
800 }
801
802 if( !bValid1 )
803 {
804 Point aStartPos( aPos.X() - DET_ARROW_OFFSET, aPos.Y() - DET_ARROW_OFFSET );
805 if (aStartPos.X() < 0)
806 aStartPos.X() += (2 * DET_ARROW_OFFSET);
807 if (aStartPos.Y() < 0)
808 aStartPos.Y() += (2 * DET_ARROW_OFFSET);
809 if ( bNegativePage )
810 aStartPos.X() = -aStartPos.X();
811 if ( pObj->GetPoint( 0 ) != aStartPos )
812 {
813 if (bRecording)
814 AddCalcUndo( new SdrUndoGeoObj( *pObj ) );
815
816 rData.maLastRect = lcl_UpdateCalcPoly(aCalcPoly, 0, aStartPos);
817 pObj->SetPoint( aStartPos, 0 );
818 }
819 }
820 }
821 }
822 else
823 {
824 bool bCanResize = bValid2 && !pObj->IsResizeProtect();
825
826 //First time positioning, must be able to at least move it
827 ScDrawObjData& rNoRotatedAnchor = *GetNonRotatedObjData( pObj, true );
828 if (rData.maLastRect.IsEmpty())
829 {
830 // Every shape it is saved with an negative offset relative to cell
831 if (ScDrawLayer::GetAnchorType(*pObj) == SCA_CELL)
832 {
833 double fRotate(0.0);
834 double fShearX(0.0);
835
836 Point aPoint;
837 Rectangle aRect;
838
839 basegfx::B2DTuple aScale;
840 basegfx::B2DTuple aTranslate;
841 basegfx::B2DPolyPolygon aPolyPolygon;
842 basegfx::B2DHomMatrix aOriginalMatrix;
843
844 aRect = pDoc->GetMMRect(nCol1, nRow1, nCol1 , nRow1, nTab1);
845
846 if (bNegativePage)
847 aPoint.X() = aRect.Right();
848 else
849 aPoint.X() = aRect.Left();
850 aPoint.Y() = aRect.Top();
851
852 pObj->TRGetBaseGeometry(aOriginalMatrix, aPolyPolygon);
853 aOriginalMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
854 aTranslate += ::basegfx::B2DTuple(aPoint.X(), aPoint.Y());
855 aOriginalMatrix = basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
856 aScale,
857 fShearX,
858 fRotate,
859 aTranslate);
860 pObj->TRSetBaseGeometry(aOriginalMatrix, aPolyPolygon);
861 }
862
863 // It's confusing ( but blame that we persist the anchor in terms of unrotated shape )
864 // that the initial anchor we get here is in terms of an unrotated shape ( if the shape is rotated )
865 // we need to save the old anchor ( for persisting ) and also track any resize or repositions that happen.
866
867 // This is an evil hack, having a anchor that is one minute in terms of untransformed object and then later
868 // in terms of the transformed object is not ideal, similary having 2 anchors per object is wasteful, can't
869 // see another way out of this at the moment though.
870 rNoRotatedAnchor.maStart = rData.maStart;
871 rNoRotatedAnchor.maEnd = rData.maEnd;
872 rNoRotatedAnchor.maStartOffset = rData.maStartOffset;
873 rNoRotatedAnchor.maEndOffset = rData.maEndOffset;
874
875 Rectangle aRect = pObj->GetLogicRect();
876
877 // get bounding rectangle of shape ( include any hidden row/columns ), <sigh> we need to do this
878 // because if the shape is rotated the anchor from xml is in terms of the unrotated shape, if
879 // the shape is hidden ( by the rows that contain the shape being hidden ) then our hack of
880 // trying to infer the 'real' e.g. rotated anchor from the SnapRect will fail ( because the LogicRect will
881 // not have the correct position or size ) The only way we can possible do this is to first get the
882 // 'unrotated' shape dimensions from the persisted Anchor (from xml) and then 'create' an Anchor from the
883 // associated rotated shape ( note: we do this by actually setting the LogicRect for the shape temporarily to the
884 // *full* size then grabbing the SnapRect ( which gives the transformed rotated dimensions ), it would be
885 // wonderful if we could do this mathematically without having to temporarily tweak the object... othoh this way
886 // is guaranteed to get consistent results )
887 ResizeLastRectFromAnchor( pObj, rData, true, bNegativePage, bCanResize, false );
888 // aFullRect contains the unrotated size and position of the shape ( regardless of any hidden row/columns )
889 Rectangle aFullRect = rData.maLastRect;
890
891 // get current size and position from the anchor for use later
892 ResizeLastRectFromAnchor( pObj, rNoRotatedAnchor, true, bNegativePage, bCanResize );
893
894 // resize/position the shape to *full* size e.g. how it would be ( if no hidden rows/cols affected things )
895 pObj->SetLogicRect(aFullRect);
896 // capture rotated shape ( if relevant )
897 aRect = pObj->GetSnapRect();
898
899 // Ok, here is more nastyness, from xml the Anchor is in terms of the LogicRect which is the
900 // untransformed unrotated shape, here we swap out that initial anchor and from now on use
901 // an Anchor based on the SnapRect ( which is what you see on the screen )
902 ScDrawLayer::GetCellAnchorFromPosition( *pObj, rData, *pDoc, nTab1, false, false );
903 // reset shape to true 'maybe affected by hidden rows/cols' size calculated previously
904 pObj->SetLogicRect(rNoRotatedAnchor.maLastRect);
905 }
906
907 // update anchor with snap rect
908 ResizeLastRectFromAnchor( pObj, rData, false, bNegativePage, bCanResize );
909
910 if( bCanResize )
911 {
912 Rectangle aNew = rData.maLastRect;
913
914 if ( pObj->GetSnapRect() != aNew )
915 {
916 Rectangle aOld(pObj->GetSnapRect());
917
918 if (bRecording)
919 AddCalcUndo( new SdrUndoGeoObj( *pObj ) );
920 long nOldWidth = aOld.GetWidth();
921 long nOldHeight = aOld.GetHeight();
922 if (pObj->IsPolyObj() && nOldWidth && nOldHeight)
923 {
924 // Polyline objects need special treatment.
925 Size aSizeMove(aNew.Left()-aOld.Left(), aNew.Top()-aOld.Top());
926 pObj->NbcMove(aSizeMove);
927
928 double fXFrac = static_cast<double>(aNew.GetWidth()) / static_cast<double>(nOldWidth);
929 double fYFrac = static_cast<double>(aNew.GetHeight()) / static_cast<double>(nOldHeight);
930 pObj->NbcResize(aNew.TopLeft(), Fraction(fXFrac), Fraction(fYFrac));
931 }
932 // order of these lines is important, modify rData.maLastRect carefully it is used as both
933 // a value and a flag for initialisation
934 rData.maLastRect = lcl_makeSafeRectangle(rData.maLastRect);
935 pObj->SetSnapRect(rData.maLastRect);
936 // update 'unrotated anchor' it's the anchor we persist, it must be kept in sync
937 // with the normal Anchor
938 ResizeLastRectFromAnchor( pObj, rNoRotatedAnchor, true, bNegativePage, bCanResize );
939 }
940 }
941 else
942 {
943 Point aPos( rData.maLastRect.getX(), rData.maLastRect.getY() );
944 if ( pObj->GetRelativePos() != aPos )
945 {
946 if (bRecording)
947 AddCalcUndo( new SdrUndoGeoObj( *pObj ) );
948 pObj->SetRelativePos( aPos );
949 }
950 }
951 /*
952 * If we were not allowed resize the object, then the end cell anchor
953 * is possibly incorrect now, and if the object has no end-cell (e.g.
954 * missing in original .xml) we are also forced to generate one
955 */
956 bool bEndAnchorIsBad = !bValid2 || pObj->IsResizeProtect();
957 if (bEndAnchorIsBad)
958 {
959 // update 'rotated' anchor
960 ScDrawLayer::UpdateCellAnchorFromPositionEnd(*pObj, rData, *pDoc, nTab1, false);
961 // update 'unrotated' anchor
962 ScDrawLayer::UpdateCellAnchorFromPositionEnd(*pObj, rNoRotatedAnchor, *pDoc, nTab1 );
963 }
964 }
965 }
966
967 bool ScDrawLayer::GetPrintArea( ScRange& rRange, bool bSetHor, bool bSetVer ) const
968 {
969 OSL_ENSURE( pDoc, "ScDrawLayer::GetPrintArea without document" );
970 if ( !pDoc )
971 return false;
972
973 SCTAB nTab = rRange.aStart.Tab();
974 OSL_ENSURE( rRange.aEnd.Tab() == nTab, "GetPrintArea: Tab differ" );
975
976 bool bNegativePage = pDoc->IsNegativePage( nTab );
977
978 bool bAny = false;
979 long nEndX = 0;
980 long nEndY = 0;
981 long nStartX = LONG_MAX;
982 long nStartY = LONG_MAX;
983
984 // Calculate borders
985
986 if (!bSetHor)
987 {
988 nStartX = 0;
989 SCCOL nStartCol = rRange.aStart.Col();
990 SCCOL i;
991 for (i=0; i<nStartCol; i++)
992 nStartX +=pDoc->GetColWidth(i,nTab);
993 nEndX = nStartX;
994 SCCOL nEndCol = rRange.aEnd.Col();
995 for (i=nStartCol; i<=nEndCol; i++)
996 nEndX += pDoc->GetColWidth(i,nTab);
997 nStartX = TwipsToHmm( nStartX );
998 nEndX = TwipsToHmm( nEndX );
999 }
1000 if (!bSetVer)
1001 {
1002 nStartY = pDoc->GetRowHeight( 0, rRange.aStart.Row()-1, nTab);
1003 nEndY = nStartY + pDoc->GetRowHeight( rRange.aStart.Row(),
1004 rRange.aEnd.Row(), nTab);
1005 nStartY = TwipsToHmm( nStartY );
1006 nEndY = TwipsToHmm( nEndY );
1007 }
1008
1009 if ( bNegativePage )
1010 {
1011 nStartX = -nStartX; // positions are negative, swap start/end so the same comparisons work
1012 nEndX = -nEndX;
1013 ::std::swap( nStartX, nEndX );
1014 }
1015
1016 const SdrPage* pPage = GetPage(static_cast<sal_uInt16>(nTab));
1017 OSL_ENSURE(pPage,"Page not found");
1018 if (pPage)
1019 {
1020 SdrObjListIter aIter( *pPage, IM_FLAT );
1021 SdrObject* pObject = aIter.Next();
1022 while (pObject)
1023 {
1024 //TODO: test Flags (hidden?)
1025
1026 Rectangle aObjRect = pObject->GetCurrentBoundRect();
1027 bool bFit = true;
1028 if ( !bSetHor && ( aObjRect.Right() < nStartX || aObjRect.Left() > nEndX ) )
1029 bFit = false;
1030 if ( !bSetVer && ( aObjRect.Bottom() < nStartY || aObjRect.Top() > nEndY ) )
1031 bFit = false;
1032 // #i104716# don't include hidden note objects
1033 if ( bFit && pObject->GetLayer() != SC_LAYER_HIDDEN )
1034 {
1035 if (bSetHor)
1036 {
1037 if (aObjRect.Left() < nStartX) nStartX = aObjRect.Left();
1038 if (aObjRect.Right() > nEndX) nEndX = aObjRect.Right();
1039 }
1040 if (bSetVer)
1041 {
1042 if (aObjRect.Top() < nStartY) nStartY = aObjRect.Top();
1043 if (aObjRect.Bottom() > nEndY) nEndY = aObjRect.Bottom();
1044 }
1045 bAny = true;
1046 }
1047
1048 pObject = aIter.Next();
1049 }
1050 }
1051
1052 if ( bNegativePage )
1053 {
1054 nStartX = -nStartX; // reverse transformation, so the same cell address calculation works
1055 nEndX = -nEndX;
1056 ::std::swap( nStartX, nEndX );
1057 }
1058
1059 if (bAny)
1060 {
1061 OSL_ENSURE( nStartX<=nEndX && nStartY<=nEndY, "Start/End wrong in ScDrawLayer::GetPrintArea" );
1062
1063 if (bSetHor)
1064 {
1065 nStartX = HmmToTwips( nStartX );
1066 nEndX = HmmToTwips( nEndX );
1067 long nWidth;
1068 SCCOL i;
1069
1070 nWidth = 0;
1071 for (i=0; i<=MAXCOL && nWidth<=nStartX; i++)
1072 nWidth += pDoc->GetColWidth(i,nTab);
1073 rRange.aStart.SetCol( i>0 ? (i-1) : 0 );
1074
1075 nWidth = 0;
1076 for (i=0; i<=MAXCOL && nWidth<=nEndX; i++) //TODO: start at Start
1077 nWidth += pDoc->GetColWidth(i,nTab);
1078 rRange.aEnd.SetCol( i>0 ? (i-1) : 0 );
1079 }
1080
1081 if (bSetVer)
1082 {
1083 nStartY = HmmToTwips( nStartY );
1084 nEndY = HmmToTwips( nEndY );
1085 SCROW nRow = pDoc->GetRowForHeight( nTab, nStartY);
1086 rRange.aStart.SetRow( nRow>0 ? (nRow-1) : 0);
1087 nRow = pDoc->GetRowForHeight( nTab, nEndY);
1088 rRange.aEnd.SetRow( nRow == MAXROW ? MAXROW :
1089 (nRow>0 ? (nRow-1) : 0));
1090 }
1091 }
1092 else
1093 {
1094 if (bSetHor)
1095 {
1096 rRange.aStart.SetCol(0);
1097 rRange.aEnd.SetCol(0);
1098 }
1099 if (bSetVer)
1100 {
1101 rRange.aStart.SetRow(0);
1102 rRange.aEnd.SetRow(0);
1103 }
1104 }
1105 return bAny;
1106 }
1107
1108 void ScDrawLayer::AddCalcUndo( SdrUndoAction* pUndo )
1109 {
1110 if (bRecording)
1111 {
1112 if (!pUndoGroup)
1113 pUndoGroup = new SdrUndoGroup(*this);
1114
1115 pUndoGroup->AddAction( pUndo );
1116 }
1117 else
1118 delete pUndo;
1119 }
1120
1121 void ScDrawLayer::BeginCalcUndo(bool bDisableTextEditUsesCommonUndoManager)
1122 {
1123 SetDisableTextEditUsesCommonUndoManager(bDisableTextEditUsesCommonUndoManager);
1124 DELETEZ(pUndoGroup);
1125 bRecording = true;
1126 }
1127
1128 SdrUndoGroup* ScDrawLayer::GetCalcUndo()
1129 {
1130 SdrUndoGroup* pRet = pUndoGroup;
1131 pUndoGroup = NULL;
1132 bRecording = false;
1133 SetDisableTextEditUsesCommonUndoManager(false);
1134 return pRet;
1135 }
1136
1137 void ScDrawLayer::MoveArea( SCTAB nTab, SCCOL nCol1,SCROW nRow1, SCCOL nCol2,SCROW nRow2,
1138 SCsCOL nDx,SCsROW nDy, bool bInsDel, bool bUpdateNoteCaptionPos )
1139 {
1140 OSL_ENSURE( pDoc, "ScDrawLayer::MoveArea without document" );
1141 if ( !pDoc )
1142 return;
1143
1144 if (!bAdjustEnabled)
1145 return;
1146
1147 bool bNegativePage = pDoc->IsNegativePage( nTab );
1148
1149 Rectangle aRect = pDoc->GetMMRect( nCol1, nRow1, nCol2, nRow2, nTab );
1150 lcl_ReverseTwipsToMM( aRect );
1151 //TODO: use twips directly?
1152
1153 Point aMove;
1154
1155 if (nDx > 0)
1156 for (SCsCOL s=0; s<nDx; s++)
1157 aMove.X() += pDoc->GetColWidth(s+(SCsCOL)nCol1,nTab);
1158 else
1159 for (SCsCOL s=-1; s>=nDx; s--)
1160 aMove.X() -= pDoc->GetColWidth(s+(SCsCOL)nCol1,nTab);
1161 if (nDy > 0)
1162 aMove.Y() += pDoc->GetRowHeight( nRow1, nRow1+nDy-1, nTab);
1163 else
1164 aMove.Y() -= pDoc->GetRowHeight( nRow1+nDy, nRow1-1, nTab);
1165
1166 if ( bNegativePage )
1167 aMove.X() = -aMove.X();
1168
1169 Point aTopLeft = aRect.TopLeft(); // Beginning when zoomed out
1170 if (bInsDel)
1171 {
1172 if ( aMove.X() != 0 && nDx < 0 ) // nDx counts cells, sign is independent of RTL
1173 aTopLeft.X() += aMove.X();
1174 if ( aMove.Y() < 0 )
1175 aTopLeft.Y() += aMove.Y();
1176 }
1177
1178 // Detectiv arrows: Adjust cell position
1179
1180 MoveCells( nTab, nCol1,nRow1, nCol2,nRow2, nDx,nDy, bUpdateNoteCaptionPos );
1181 }
1182
1183 bool ScDrawLayer::HasObjectsInRows( SCTAB nTab, SCROW nStartRow, SCROW nEndRow )
1184 {
1185 OSL_ENSURE( pDoc, "ScDrawLayer::HasObjectsInRows without document" );
1186 if ( !pDoc )
1187 return false;
1188
1189 SdrPage* pPage = GetPage(static_cast<sal_uInt16>(nTab));
1190 OSL_ENSURE(pPage,"Page not found");
1191 if (!pPage)
1192 return false;
1193
1194 // for an empty page, there's no need to calculate the row heights
1195 if (!pPage->GetObjCount())
1196 return false;
1197
1198 Rectangle aTestRect;
1199
1200 aTestRect.Top() += pDoc->GetRowHeight( 0, nStartRow-1, nTab);
1201
1202 if (nEndRow==MAXROW)
1203 aTestRect.Bottom() = MAXMM;
1204 else
1205 {
1206 aTestRect.Bottom() = aTestRect.Top();
1207 aTestRect.Bottom() += pDoc->GetRowHeight( nStartRow, nEndRow, nTab);
1208 TwipsToMM( aTestRect.Bottom() );
1209 }
1210
1211 TwipsToMM( aTestRect.Top() );
1212
1213 aTestRect.Left() = 0;
1214 aTestRect.Right() = MAXMM;
1215
1216 bool bNegativePage = pDoc->IsNegativePage( nTab );
1217 if ( bNegativePage )
1218 MirrorRectRTL( aTestRect );
1219
1220 bool bFound = false;
1221
1222 Rectangle aObjRect;
1223 SdrObjListIter aIter( *pPage );
1224 SdrObject* pObject = aIter.Next();
1225 while ( pObject && !bFound )
1226 {
1227 aObjRect = pObject->GetSnapRect(); //TODO: GetLogicRect ?
1228 if (aTestRect.IsInside(aObjRect.TopLeft()) || aTestRect.IsInside(aObjRect.BottomLeft()))
1229 bFound = true;
1230
1231 pObject = aIter.Next();
1232 }
1233
1234 return bFound;
1235 }
1236
1237 void ScDrawLayer::DeleteObjectsInArea( SCTAB nTab, SCCOL nCol1,SCROW nRow1,
1238 SCCOL nCol2,SCROW nRow2 )
1239 {
1240 OSL_ENSURE( pDoc, "ScDrawLayer::DeleteObjectsInArea without document" );
1241 if ( !pDoc )
1242 return;
1243
1244 SdrPage* pPage = GetPage(static_cast<sal_uInt16>(nTab));
1245 OSL_ENSURE(pPage,"Page ?");
1246 if (!pPage)
1247 return;
1248
1249 pPage->RecalcObjOrdNums();
1250
1251 const size_t nObjCount = pPage->GetObjCount();
1252 if (nObjCount)
1253 {
1254 size_t nDelCount = 0;
1255 Rectangle aDelRect = pDoc->GetMMRect( nCol1, nRow1, nCol2, nRow2, nTab );
1256
1257 boost::scoped_array<SdrObject*> ppObj(new SdrObject*[nObjCount]);
1258
1259 SdrObjListIter aIter( *pPage, IM_FLAT );
1260 SdrObject* pObject = aIter.Next();
1261 while (pObject)
1262 {
1263 // do not delete note caption, they are always handled by the cell note
1264 // TODO: detective objects are still deleted, is this desired?
1265 if (!IsNoteCaption( pObject ))
1266 {
1267 Rectangle aObjRect = pObject->GetCurrentBoundRect();
1268 if ( aDelRect.IsInside( aObjRect ) )
1269 ppObj[nDelCount++] = pObject;
1270 }
1271
1272 pObject = aIter.Next();
1273 }
1274
1275 if (bRecording)
1276 for (size_t i=1; i<=nDelCount; ++i)
1277 AddCalcUndo( new SdrUndoRemoveObj( *ppObj[nDelCount-i] ) );
1278
1279 for (size_t i=1; i<=nDelCount; ++i)
1280 pPage->RemoveObject( ppObj[nDelCount-i]->GetOrdNum() );
1281 }
1282 }
1283
1284 void ScDrawLayer::DeleteObjectsInSelection( const ScMarkData& rMark )
1285 {
1286 OSL_ENSURE( pDoc, "ScDrawLayer::DeleteObjectsInSelection without document" );
1287 if ( !pDoc )
1288 return;
1289
1290 if ( !rMark.IsMultiMarked() )
1291 return;
1292
1293 ScRange aMarkRange;
1294 rMark.GetMultiMarkArea( aMarkRange );
1295
1296 SCTAB nTabCount = pDoc->GetTableCount();
1297 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
1298 for (; itr != itrEnd && *itr < nTabCount; ++itr)
1299 {
1300 SCTAB nTab = *itr;
1301 SdrPage* pPage = GetPage(static_cast<sal_uInt16>(nTab));
1302 if (pPage)
1303 {
1304 pPage->RecalcObjOrdNums();
1305 const size_t nObjCount = pPage->GetObjCount();
1306 if (nObjCount)
1307 {
1308 size_t nDelCount = 0;
1309 // Rectangle around the whole selection
1310 Rectangle aMarkBound = pDoc->GetMMRect(
1311 aMarkRange.aStart.Col(), aMarkRange.aStart.Row(),
1312 aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(), nTab );
1313
1314 boost::scoped_array<SdrObject*> ppObj(new SdrObject*[nObjCount]);
1315
1316 SdrObjListIter aIter( *pPage, IM_FLAT );
1317 SdrObject* pObject = aIter.Next();
1318 while (pObject)
1319 {
1320 // do not delete note caption, they are always handled by the cell note
1321 // TODO: detective objects are still deleted, is this desired?
1322 if (!IsNoteCaption( pObject ))
1323 {
1324 Rectangle aObjRect = pObject->GetCurrentBoundRect();
1325 if ( aMarkBound.IsInside( aObjRect ) )
1326 {
1327 ScRange aRange = pDoc->GetRange( nTab, aObjRect );
1328 if (rMark.IsAllMarked(aRange))
1329 ppObj[nDelCount++] = pObject;
1330 }
1331 }
1332
1333 pObject = aIter.Next();
1334 }
1335
1336 // Delete objects (backwards)
1337
1338 if (bRecording)
1339 for (size_t i=1; i<=nDelCount; ++i)
1340 AddCalcUndo( new SdrUndoRemoveObj( *ppObj[nDelCount-i] ) );
1341
1342 for (size_t i=1; i<=nDelCount; ++i)
1343 pPage->RemoveObject( ppObj[nDelCount-i]->GetOrdNum() );
1344 }
1345 }
1346 else
1347 {
1348 OSL_FAIL("pPage?");
1349 }
1350 }
1351 }
1352
1353 void ScDrawLayer::CopyToClip( ScDocument* pClipDoc, SCTAB nTab, const Rectangle& rRange )
1354 {
1355 // copy everything in the specified range into the same page (sheet) in the clipboard doc
1356
1357 SdrPage* pSrcPage = GetPage(static_cast<sal_uInt16>(nTab));
1358 if (pSrcPage)
1359 {
1360 ScDrawLayer* pDestModel = NULL;
1361 SdrPage* pDestPage = NULL;
1362
1363 SdrObjListIter aIter( *pSrcPage, IM_FLAT );
1364 SdrObject* pOldObject = aIter.Next();
1365 while (pOldObject)
1366 {
1367 Rectangle aObjRect = pOldObject->GetCurrentBoundRect();
1368 // do not copy internal objects (detective) and note captions
1369 if ( rRange.IsInside( aObjRect ) && (pOldObject->GetLayer() != SC_LAYER_INTERN) && !IsNoteCaption( pOldObject ) )
1370 {
1371 if ( !pDestModel )
1372 {
1373 pDestModel = pClipDoc->GetDrawLayer(); // does the document already have a drawing layer?
1374 if ( !pDestModel )
1375 {
1376 // allocate drawing layer in clipboard document only if there are objects to copy
1377
1378 pClipDoc->InitDrawLayer(); //TODO: create contiguous pages
1379 pDestModel = pClipDoc->GetDrawLayer();
1380 }
1381 if (pDestModel)
1382 pDestPage = pDestModel->GetPage( static_cast<sal_uInt16>(nTab) );
1383 }
1384
1385 OSL_ENSURE( pDestPage, "no page" );
1386 if (pDestPage)
1387 {
1388 SdrObject* pNewObject = pOldObject->Clone();
1389 pNewObject->SetModel(pDestModel);
1390 pNewObject->SetPage(pDestPage);
1391
1392 uno::Reference< chart2::XChartDocument > xOldChart( ScChartHelper::GetChartFromSdrObject( pOldObject ) );
1393 if(!xOldChart.is())//#i110034# do not move charts as they lose all their data references otherwise
1394 pNewObject->NbcMove(Size(0,0));
1395 pDestPage->InsertObject( pNewObject );
1396
1397 // no undo needed in clipboard document
1398 // charts are not updated
1399 }
1400 }
1401
1402 pOldObject = aIter.Next();
1403 }
1404 }
1405 }
1406
1407 static bool lcl_IsAllInRange( const ::std::vector< ScRangeList >& rRangesVector, const ScRange& rClipRange )
1408 {
1409 // check if every range of rRangesVector is completely in rClipRange
1410
1411 ::std::vector< ScRangeList >::const_iterator aIt = rRangesVector.begin();
1412 for( ;aIt!=rRangesVector.end(); ++aIt )
1413 {
1414 const ScRangeList& rRanges = *aIt;
1415 for ( size_t i = 0, nCount = rRanges.size(); i < nCount; i++ )
1416 {
1417 ScRange aRange = *rRanges[ i ];
1418 if ( !rClipRange.In( aRange ) )
1419 {
1420 return false; // at least one range is not valid
1421 }
1422 }
1423 }
1424
1425 return true; // everything is fine
1426 }
1427
1428 static bool lcl_MoveRanges( ::std::vector< ScRangeList >& rRangesVector, const ScRange& rSourceRange, const ScAddress& rDestPos )
1429 {
1430 bool bChanged = false;
1431
1432 ::std::vector< ScRangeList >::iterator aIt = rRangesVector.begin();
1433 for( ;aIt!=rRangesVector.end(); ++aIt )
1434 {
1435 ScRangeList& rRanges = *aIt;
1436 for ( size_t i = 0, nCount = rRanges.size(); i < nCount; i++ )
1437 {
1438 ScRange* pRange = rRanges[ i ];
1439 if ( rSourceRange.In( *pRange ) )
1440 {
1441 SCsCOL nDiffX = rDestPos.Col() - (SCsCOL)rSourceRange.aStart.Col();
1442 SCsROW nDiffY = rDestPos.Row() - (SCsROW)rSourceRange.aStart.Row();
1443 SCsTAB nDiffZ = rDestPos.Tab() - (SCsTAB)rSourceRange.aStart.Tab();
1444 pRange->Move( nDiffX, nDiffY, nDiffZ );
1445 bChanged = true;
1446 }
1447 }
1448 }
1449
1450 return bChanged;
1451 }
1452
1453 void ScDrawLayer::CopyFromClip( ScDrawLayer* pClipModel, SCTAB nSourceTab, const Rectangle& rSourceRange,
1454 const ScAddress& rDestPos, const Rectangle& rDestRange )
1455 {
1456 OSL_ENSURE( pDoc, "ScDrawLayer::CopyFromClip without document" );
1457 if ( !pDoc )
1458 return;
1459
1460 if (!pClipModel)
1461 return;
1462
1463 if (bDrawIsInUndo) //TODO: can this happen?
1464 {
1465 OSL_FAIL("CopyFromClip, bDrawIsInUndo");
1466 return;
1467 }
1468
1469 bool bMirrorObj = ( rSourceRange.Left() < 0 && rSourceRange.Right() < 0 &&
1470 rDestRange.Left() > 0 && rDestRange.Right() > 0 ) ||
1471 ( rSourceRange.Left() > 0 && rSourceRange.Right() > 0 &&
1472 rDestRange.Left() < 0 && rDestRange.Right() < 0 );
1473 Rectangle aMirroredSource = rSourceRange;
1474 if ( bMirrorObj )
1475 MirrorRectRTL( aMirroredSource );
1476
1477 SCTAB nDestTab = rDestPos.Tab();
1478
1479 SdrPage* pSrcPage = pClipModel->GetPage(static_cast<sal_uInt16>(nSourceTab));
1480 SdrPage* pDestPage = GetPage(static_cast<sal_uInt16>(nDestTab));
1481 OSL_ENSURE( pSrcPage && pDestPage, "draw page missing" );
1482 if ( !pSrcPage || !pDestPage )
1483 return;
1484
1485 SdrObjListIter aIter( *pSrcPage, IM_FLAT );
1486 SdrObject* pOldObject = aIter.Next();
1487
1488 ScDocument* pClipDoc = pClipModel->GetDocument();
1489 // a clipboard document and its source share the same document item pool,
1490 // so the pointers can be compared to see if this is copy&paste within
1491 // the same document
1492 bool bSameDoc = pDoc && pClipDoc && pDoc->GetPool() == pClipDoc->GetPool();
1493 bool bDestClip = pDoc && pDoc->IsClipboard();
1494
1495 //#i110034# charts need correct sheet names for xml range conversion during load
1496 //so the target sheet name is temporarily renamed (if we have any SdrObjects)
1497 OUString aDestTabName;
1498 bool bRestoreDestTabName = false;
1499 if( pOldObject && !bSameDoc && !bDestClip )
1500 {
1501 if( pDoc && pClipDoc )
1502 {
1503 OUString aSourceTabName;
1504 if( pClipDoc->GetName( nSourceTab, aSourceTabName )
1505 && pDoc->GetName( nDestTab, aDestTabName ) )
1506 {
1507 if( !aSourceTabName.equals(aDestTabName) &&
1508 pDoc->ValidNewTabName(aSourceTabName) )
1509 {
1510 bRestoreDestTabName = pDoc->RenameTab( nDestTab, aSourceTabName ); //sal_Bool bUpdateRef = sal_True, sal_Bool bExternalDocument = sal_False
1511 }
1512 }
1513 }
1514 }
1515
1516 // first mirror, then move
1517 Size aMove( rDestRange.Left() - aMirroredSource.Left(), rDestRange.Top() - aMirroredSource.Top() );
1518
1519 long nDestWidth = rDestRange.GetWidth();
1520 long nDestHeight = rDestRange.GetHeight();
1521 long nSourceWidth = rSourceRange.GetWidth();
1522 long nSourceHeight = rSourceRange.GetHeight();
1523
1524 long nWidthDiff = nDestWidth - nSourceWidth;
1525 long nHeightDiff = nDestHeight - nSourceHeight;
1526
1527 Fraction aHorFract(1,1);
1528 Fraction aVerFract(1,1);
1529 bool bResize = false;
1530 // sizes can differ by 1 from twips->1/100mm conversion for equal cell sizes,
1531 // don't resize to empty size when pasting into hidden columns or rows
1532 if ( std::abs(nWidthDiff) > 1 && nDestWidth > 1 && nSourceWidth > 1 )
1533 {
1534 aHorFract = Fraction( nDestWidth, nSourceWidth );
1535 bResize = true;
1536 }
1537 if ( std::abs(nHeightDiff) > 1 && nDestHeight > 1 && nSourceHeight > 1 )
1538 {
1539 aVerFract = Fraction( nDestHeight, nSourceHeight );
1540 bResize = true;
1541 }
1542 Point aRefPos = rDestRange.TopLeft(); // for resizing (after moving)
1543
1544 while (pOldObject)
1545 {
1546 Rectangle aObjRect = pOldObject->GetCurrentBoundRect();
1547 // do not copy internal objects (detective) and note captions
1548 if ( rSourceRange.IsInside( aObjRect ) && (pOldObject->GetLayer() != SC_LAYER_INTERN) && !IsNoteCaption( pOldObject ) )
1549 {
1550 SdrObject* pNewObject = pOldObject->Clone();
1551 pNewObject->SetModel(this);
1552 pNewObject->SetPage(pDestPage);
1553
1554 if ( bMirrorObj )
1555 MirrorRTL( pNewObject ); // first mirror, then move
1556
1557 pNewObject->NbcMove( aMove );
1558 if ( bResize )
1559 pNewObject->NbcResize( aRefPos, aHorFract, aVerFract );
1560
1561 pDestPage->InsertObject( pNewObject );
1562 if (bRecording)
1563 AddCalcUndo( new SdrUndoInsertObj( *pNewObject ) );
1564
1565 //#i110034# handle chart data references (after InsertObject)
1566
1567 if ( pNewObject->GetObjIdentifier() == OBJ_OLE2 )
1568 {
1569 uno::Reference< embed::XEmbeddedObject > xIPObj = static_cast<SdrOle2Obj*>(pNewObject)->GetObjRef();
1570 uno::Reference< embed::XClassifiedObject > xClassified( xIPObj, uno::UNO_QUERY );
1571 SvGlobalName aObjectClassName;
1572 if ( xClassified.is() )
1573 {
1574 try {
1575 aObjectClassName = SvGlobalName( xClassified->getClassID() );
1576 } catch( uno::Exception& )
1577 {
1578 // TODO: handle error?
1579 }
1580 }
1581
1582 if ( xIPObj.is() && SotExchange::IsChart( aObjectClassName ) )
1583 {
1584 uno::Reference< chart2::XChartDocument > xNewChart( ScChartHelper::GetChartFromSdrObject( pNewObject ) );
1585 if( xNewChart.is() && !xNewChart->hasInternalDataProvider() )
1586 {
1587 OUString aChartName = static_cast<SdrOle2Obj*>(pNewObject)->GetPersistName();
1588 ::std::vector< ScRangeList > aRangesVector;
1589 pDoc->GetChartRanges( aChartName, aRangesVector, pDoc );
1590 if( !aRangesVector.empty() )
1591 {
1592 bool bInSourceRange = false;
1593 ScRange aClipRange;
1594 if ( pClipDoc )
1595 {
1596 SCCOL nClipStartX;
1597 SCROW nClipStartY;
1598 SCCOL nClipEndX;
1599 SCROW nClipEndY;
1600 pClipDoc->GetClipStart( nClipStartX, nClipStartY );
1601 pClipDoc->GetClipArea( nClipEndX, nClipEndY, true );
1602 nClipEndX = nClipEndX + nClipStartX;
1603 nClipEndY += nClipStartY; // GetClipArea returns the difference
1604
1605 SCTAB nClipTab = bRestoreDestTabName ? nDestTab : nSourceTab;
1606 aClipRange = ScRange( nClipStartX, nClipStartY, nClipTab,
1607 nClipEndX, nClipEndY, nClipTab );
1608
1609 bInSourceRange = lcl_IsAllInRange( aRangesVector, aClipRange );
1610 }
1611
1612 // always lose references when pasting into a clipboard document (transpose)
1613 if ( ( bInSourceRange || bSameDoc ) && !bDestClip )
1614 {
1615 if ( bInSourceRange )
1616 {
1617 if ( rDestPos != aClipRange.aStart )
1618 {
1619 // update the data ranges to the new (copied) position
1620 if ( lcl_MoveRanges( aRangesVector, aClipRange, rDestPos ) )
1621 pDoc->SetChartRanges( aChartName, aRangesVector );
1622 }
1623 }
1624 else
1625 {
1626 // leave the ranges unchanged
1627 }
1628 }
1629 else
1630 {
1631 // pasting into a new document without the complete source data
1632 // -> break connection to source data and switch to own data
1633
1634 uno::Reference< chart::XChartDocument > xOldChartDoc( ScChartHelper::GetChartFromSdrObject( pOldObject ), uno::UNO_QUERY );
1635 uno::Reference< chart::XChartDocument > xNewChartDoc( xNewChart, uno::UNO_QUERY );
1636 if( xOldChartDoc.is() && xNewChartDoc.is() )
1637 xNewChartDoc->attachData( xOldChartDoc->getData() );
1638
1639 // (see ScDocument::UpdateChartListenerCollection, PastingDrawFromOtherDoc)
1640 }
1641 }
1642 }
1643 }
1644 }
1645 }
1646
1647 pOldObject = aIter.Next();
1648 }
1649
1650 if( bRestoreDestTabName )
1651 pDoc->RenameTab( nDestTab, aDestTabName );
1652 }
1653
1654 void ScDrawLayer::MirrorRTL( SdrObject* pObj )
1655 {
1656 sal_uInt16 nIdent = pObj->GetObjIdentifier();
1657
1658 // don't mirror OLE or graphics, otherwise ask the object
1659 // if it can be mirrored
1660 bool bCanMirror = ( nIdent != OBJ_GRAF && nIdent != OBJ_OLE2 );
1661 if (bCanMirror)
1662 {
1663 SdrObjTransformInfoRec aInfo;
1664 pObj->TakeObjInfo( aInfo );
1665 bCanMirror = aInfo.bMirror90Allowed;
1666 }
1667
1668 if (bCanMirror)
1669 {
1670 Point aRef1( 0, 0 );
1671 Point aRef2( 0, 1 );
1672 if (bRecording)
1673 AddCalcUndo( new SdrUndoGeoObj( *pObj ) );
1674 pObj->Mirror( aRef1, aRef2 );
1675 }
1676 else
1677 {
1678 // Move instead of mirroring:
1679 // New start position is negative of old end position
1680 // -> move by sum of start and end position
1681 Rectangle aObjRect = pObj->GetLogicRect();
1682 Size aMoveSize( -(aObjRect.Left() + aObjRect.Right()), 0 );
1683 if (bRecording)
1684 AddCalcUndo( new SdrUndoMoveObj( *pObj, aMoveSize ) );
1685 pObj->Move( aMoveSize );
1686 }
1687 }
1688
1689 void ScDrawLayer::MirrorRectRTL( Rectangle& rRect )
1690 {
1691 // mirror and swap left/right
1692 long nTemp = rRect.Left();
1693 rRect.Left() = -rRect.Right();
1694 rRect.Right() = -nTemp;
1695 }
1696
1697 Rectangle ScDrawLayer::GetCellRect( ScDocument& rDoc, const ScAddress& rPos, bool bMergedCell )
1698 {
1699 Rectangle aCellRect;
1700 OSL_ENSURE( ValidColRowTab( rPos.Col(), rPos.Row(), rPos.Tab() ), "ScDrawLayer::GetCellRect - invalid cell address" );
1701 if( ValidColRowTab( rPos.Col(), rPos.Row(), rPos.Tab() ) )
1702 {
1703 // find top left position of passed cell address
1704 Point aTopLeft;
1705 for( SCCOL nCol = 0; nCol < rPos.Col(); ++nCol )
1706 aTopLeft.X() += rDoc.GetColWidth( nCol, rPos.Tab() );
1707 if( rPos.Row() > 0 )
1708 aTopLeft.Y() += rDoc.GetRowHeight( 0, rPos.Row() - 1, rPos.Tab() );
1709
1710 // find bottom-right position of passed cell address
1711 ScAddress aEndPos = rPos;
1712 if( bMergedCell )
1713 {
1714 const ScMergeAttr* pMerge = static_cast< const ScMergeAttr* >( rDoc.GetAttr( rPos.Col(), rPos.Row(), rPos.Tab(), ATTR_MERGE ) );
1715 if( pMerge->GetColMerge() > 1 )
1716 aEndPos.IncCol( pMerge->GetColMerge() - 1 );
1717 if( pMerge->GetRowMerge() > 1 )
1718 aEndPos.IncRow( pMerge->GetRowMerge() - 1 );
1719 }
1720 Point aBotRight = aTopLeft;
1721 for( SCCOL nCol = rPos.Col(); nCol <= aEndPos.Col(); ++nCol )
1722 aBotRight.X() += rDoc.GetColWidth( nCol, rPos.Tab() );
1723 aBotRight.Y() += rDoc.GetRowHeight( rPos.Row(), aEndPos.Row(), rPos.Tab() );
1724
1725 // twips -> 1/100 mm
1726 aTopLeft.X() = static_cast< long >( aTopLeft.X() * HMM_PER_TWIPS );
1727 aTopLeft.Y() = static_cast< long >( aTopLeft.Y() * HMM_PER_TWIPS );
1728 aBotRight.X() = static_cast< long >( aBotRight.X() * HMM_PER_TWIPS );
1729 aBotRight.Y() = static_cast< long >( aBotRight.Y() * HMM_PER_TWIPS );
1730
1731 aCellRect = Rectangle( aTopLeft, aBotRight );
1732 if( rDoc.IsNegativePage( rPos.Tab() ) )
1733 MirrorRectRTL( aCellRect );
1734 }
1735 return aCellRect;
1736 }
1737
1738 OUString ScDrawLayer::GetVisibleName( SdrObject* pObj )
1739 {
1740 OUString aName = pObj->GetName();
1741 if ( pObj->GetObjIdentifier() == OBJ_OLE2 )
1742 {
1743 // For OLE, the user defined name (GetName) is used
1744 // if it's not empty (accepting possibly duplicate names),
1745 // otherwise the persist name is used so every object appears
1746 // in the Navigator at all.
1747
1748 if ( aName.isEmpty() )
1749 aName = static_cast<SdrOle2Obj*>(pObj)->GetPersistName();
1750 }
1751 return aName;
1752 }
1753
1754 inline bool IsNamedObject( SdrObject* pObj, const OUString& rName )
1755 {
1756 // sal_True if rName is the object's Name or PersistName
1757 // (used to find a named object)
1758
1759 return ( pObj->GetName().equals(rName) ||
1760 ( pObj->GetObjIdentifier() == OBJ_OLE2 &&
1761 static_cast<SdrOle2Obj*>(pObj)->GetPersistName() == rName ) );
1762 }
1763
1764 SdrObject* ScDrawLayer::GetNamedObject( const OUString& rName, sal_uInt16 nId, SCTAB& rFoundTab ) const
1765 {
1766 sal_uInt16 nTabCount = GetPageCount();
1767 for (sal_uInt16 nTab=0; nTab<nTabCount; nTab++)
1768 {
1769 const SdrPage* pPage = GetPage(nTab);
1770 OSL_ENSURE(pPage,"Page ?");
1771 if (pPage)
1772 {
1773 SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
1774 SdrObject* pObject = aIter.Next();
1775 while (pObject)
1776 {
1777 if ( nId == 0 || pObject->GetObjIdentifier() == nId )
1778 if ( IsNamedObject( pObject, rName ) )
1779 {
1780 rFoundTab = static_cast<SCTAB>(nTab);
1781 return pObject;
1782 }
1783
1784 pObject = aIter.Next();
1785 }
1786 }
1787 }
1788
1789 return NULL;
1790 }
1791
1792 OUString ScDrawLayer::GetNewGraphicName( long* pnCounter ) const
1793 {
1794 OUString aBase = ScGlobal::GetRscString(STR_GRAPHICNAME);
1795 aBase += " ";
1796
1797 bool bThere = true;
1798 OUString aGraphicName;
1799 SCTAB nDummy;
1800 long nId = pnCounter ? *pnCounter : 0;
1801 while (bThere)
1802 {
1803 ++nId;
1804 aGraphicName = aBase;
1805 aGraphicName += OUString::number( nId );
1806 bThere = ( GetNamedObject( aGraphicName, 0, nDummy ) != NULL );
1807 }
1808
1809 if ( pnCounter )
1810 *pnCounter = nId;
1811
1812 return aGraphicName;
1813 }
1814
1815 void ScDrawLayer::EnsureGraphicNames()
1816 {
1817 // make sure all graphic objects have names (after Excel import etc.)
1818
1819 sal_uInt16 nTabCount = GetPageCount();
1820 for (sal_uInt16 nTab=0; nTab<nTabCount; nTab++)
1821 {
1822 SdrPage* pPage = GetPage(nTab);
1823 OSL_ENSURE(pPage,"Page ?");
1824 if (pPage)
1825 {
1826 SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
1827 SdrObject* pObject = aIter.Next();
1828
1829 /* The index passed to GetNewGraphicName() will be set to
1830 the used index in each call. This prevents the repeated search
1831 for all names from 1 to current index. */
1832 long nCounter = 0;
1833
1834 while (pObject)
1835 {
1836 if ( pObject->GetObjIdentifier() == OBJ_GRAF && pObject->GetName().isEmpty())
1837 pObject->SetName( GetNewGraphicName( &nCounter ) );
1838
1839 pObject = aIter.Next();
1840 }
1841 }
1842 }
1843 }
1844
1845 namespace
1846 {
1847 SdrObjUserData* GetFirstUserDataOfType(const SdrObject *pObj, sal_uInt16 nId)
1848 {
1849 sal_uInt16 nCount = pObj ? pObj->GetUserDataCount() : 0;
1850 for( sal_uInt16 i = 0; i < nCount; i++ )
1851 {
1852 SdrObjUserData* pData = pObj->GetUserData( i );
1853 if( pData && pData->GetInventor() == SC_DRAWLAYER && pData->GetId() == nId )
1854 return pData;
1855 }
1856 return NULL;
1857 }
1858
1859 void DeleteFirstUserDataOfType(SdrObject *pObj, sal_uInt16 nId)
1860 {
1861 sal_uInt16 nCount = pObj ? pObj->GetUserDataCount() : 0;
1862 for( sal_uInt16 i = nCount; i > 0; i-- )
1863 {
1864 SdrObjUserData* pData = pObj->GetUserData( i-1 );
1865 if( pData && pData->GetInventor() == SC_DRAWLAYER && pData->GetId() == nId )
1866 pObj->DeleteUserData(i-1);
1867 }
1868 }
1869 }
1870
1871 void ScDrawLayer::SetVisualCellAnchored( SdrObject &rObj, const ScDrawObjData &rAnchor )
1872 {
1873 ScDrawObjData* pAnchor = GetNonRotatedObjData( &rObj, true );
1874 pAnchor->maStart = rAnchor.maStart;
1875 pAnchor->maEnd = rAnchor.maEnd;
1876 pAnchor->maStartOffset = rAnchor.maStartOffset;
1877 pAnchor->maEndOffset = rAnchor.maEndOffset;
1878 }
1879
1880 void ScDrawLayer::SetCellAnchored( SdrObject &rObj, const ScDrawObjData &rAnchor )
1881 {
1882 ScDrawObjData* pAnchor = GetObjData( &rObj, true );
1883 pAnchor->maStart = rAnchor.maStart;
1884 pAnchor->maEnd = rAnchor.maEnd;
1885 pAnchor->maStartOffset = rAnchor.maStartOffset;
1886 pAnchor->maEndOffset = rAnchor.maEndOffset;
1887 }
1888
1889 void ScDrawLayer::SetCellAnchoredFromPosition( SdrObject &rObj, const ScDocument &rDoc, SCTAB nTab )
1890 {
1891 ScDrawObjData aAnchor;
1892 // set anchor in terms of the visual ( SnapRect )
1893 // object ( e.g. for when object is rotated )
1894 GetCellAnchorFromPosition( rObj, aAnchor, rDoc, nTab, false );
1895 SetCellAnchored( rObj, aAnchor );
1896 // - keep also an anchor in terms of the Logic ( untransformed ) object
1897 // because thats what we stored ( and still do ) to xml
1898 ScDrawObjData aVisAnchor;
1899 GetCellAnchorFromPosition( rObj, aVisAnchor, rDoc, nTab );
1900 SetVisualCellAnchored( rObj, aVisAnchor );
1901 // absolutely necessary to set flag that in order to preven ScDrawLayer::RecalcPos
1902 // doing an initialisation hack
1903 if ( ScDrawObjData* pAnchor = GetObjData( &rObj ) )
1904 {
1905 pAnchor->maLastRect = rObj.GetSnapRect();
1906 }
1907 }
1908
1909 void ScDrawLayer::GetCellAnchorFromPosition( SdrObject &rObj, ScDrawObjData &rAnchor, const ScDocument &rDoc, SCTAB nTab, bool bUseLogicRect, bool bHiddenAsZero )
1910 {
1911 Rectangle aObjRect( bUseLogicRect ? rObj.GetLogicRect() : rObj.GetSnapRect() );
1912 ScRange aRange = rDoc.GetRange( nTab, aObjRect, bHiddenAsZero );
1913
1914 Rectangle aCellRect;
1915
1916 rAnchor.maStart = aRange.aStart;
1917 aCellRect = rDoc.GetMMRect( aRange.aStart.Col(), aRange.aStart.Row(),
1918 aRange.aStart.Col(), aRange.aStart.Row(), aRange.aStart.Tab(), bHiddenAsZero );
1919 rAnchor.maStartOffset.Y() = aObjRect.Top()-aCellRect.Top();
1920 if (!rDoc.IsNegativePage(nTab))
1921 rAnchor.maStartOffset.X() = aObjRect.Left()-aCellRect.Left();
1922 else
1923 rAnchor.maStartOffset.X() = aCellRect.Right()-aObjRect.Right();
1924
1925 rAnchor.maEnd = aRange.aEnd;
1926 aCellRect = rDoc.GetMMRect( aRange.aEnd.Col(), aRange.aEnd.Row(),
1927 aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aEnd.Tab(), bHiddenAsZero );
1928 rAnchor.maEndOffset.Y() = aObjRect.Bottom()-aCellRect.Top();
1929 if (!rDoc.IsNegativePage(nTab))
1930 rAnchor.maEndOffset.X() = aObjRect.Right()-aCellRect.Left();
1931 else
1932 rAnchor.maEndOffset.X() = aCellRect.Right()-aObjRect.Left();
1933
1934 }
1935
1936 void ScDrawLayer::UpdateCellAnchorFromPositionEnd( SdrObject &rObj, ScDrawObjData &rAnchor, const ScDocument &rDoc, SCTAB nTab, bool bUseLogicRect )
1937 {
1938 Rectangle aObjRect(bUseLogicRect ? rObj.GetLogicRect() : rObj.GetSnapRect());
1939 ScRange aRange = rDoc.GetRange( nTab, aObjRect );
1940
1941 ScDrawObjData* pAnchor = &rAnchor;
1942 pAnchor->maEnd = aRange.aEnd;
1943
1944 Rectangle aCellRect;
1945 aCellRect = rDoc.GetMMRect( aRange.aEnd.Col(), aRange.aEnd.Row(),
1946 aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aEnd.Tab() );
1947 pAnchor->maEndOffset.Y() = aObjRect.Bottom()-aCellRect.Top();
1948 if (!rDoc.IsNegativePage(nTab))
1949 pAnchor->maEndOffset.X() = aObjRect.Right()-aCellRect.Left();
1950 else
1951 pAnchor->maEndOffset.X() = aCellRect.Right()-aObjRect.Left();
1952 }
1953
1954 bool ScDrawLayer::IsCellAnchored( const SdrObject& rObj )
1955 {
1956 // Cell anchored object always has a user data, to store the anchor cell
1957 // info. If it doesn't then it's page-anchored.
1958 return GetFirstUserDataOfType(&rObj, SC_UD_OBJDATA) != NULL;
1959 }
1960
1961 void ScDrawLayer::SetPageAnchored( SdrObject &rObj )
1962 {
1963 DeleteFirstUserDataOfType(&rObj, SC_UD_OBJDATA);
1964 DeleteFirstUserDataOfType(&rObj, SC_UD_OBJDATA);
1965 }
1966
1967 ScAnchorType ScDrawLayer::GetAnchorType( const SdrObject &rObj )
1968 {
1969 //If this object has a cell anchor associated with it
1970 //then its cell-anchored, otherwise its page-anchored
1971 return ScDrawLayer::GetObjData(const_cast<SdrObject*>(&rObj)) ? SCA_CELL : SCA_PAGE;
1972 }
1973
1974 ScDrawObjData* ScDrawLayer::GetNonRotatedObjData( SdrObject* pObj, bool bCreate )
1975 {
1976 sal_uInt16 nCount = pObj ? pObj->GetUserDataCount() : 0;
1977 sal_uInt16 nFound = 0;
1978 for( sal_uInt16 i = 0; i < nCount; i++ )
1979 {
1980 SdrObjUserData* pData = pObj->GetUserData( i );
1981 if( pData && pData->GetInventor() == SC_DRAWLAYER && pData->GetId() == SC_UD_OBJDATA && ++nFound == 2 )
1982 return static_cast<ScDrawObjData*>(pData);
1983 }
1984 if( pObj && bCreate )
1985 {
1986 ScDrawObjData* pData = new ScDrawObjData;
1987 pObj->AppendUserData(pData);
1988 return pData;
1989 }
1990 return 0;
1991 }
1992
1993 ScDrawObjData* ScDrawLayer::GetObjData( SdrObject* pObj, bool bCreate )
1994 {
1995 if (SdrObjUserData *pData = GetFirstUserDataOfType(pObj, SC_UD_OBJDATA))
1996 return static_cast<ScDrawObjData*>(pData);
1997
1998 if( pObj && bCreate )
1999 {
2000 ScDrawObjData* pData = new ScDrawObjData;
2001 pObj->AppendUserData(pData);
2002 return pData;
2003 }
2004 return 0;
2005 }
2006
2007 ScDrawObjData* ScDrawLayer::GetObjDataTab( SdrObject* pObj, SCTAB nTab )
2008 {
2009 ScDrawObjData* pData = GetObjData( pObj );
2010 if ( pData )
2011 {
2012 if ( pData->maStart.IsValid() )
2013 pData->maStart.SetTab( nTab );
2014 if ( pData->maEnd.IsValid() )
2015 pData->maEnd.SetTab( nTab );
2016 }
2017 return pData;
2018 }
2019
2020 bool ScDrawLayer::IsNoteCaption( SdrObject* pObj )
2021 {
2022 ScDrawObjData* pData = pObj ? GetObjData( pObj ) : 0;
2023 return pData && pData->meType == ScDrawObjData::CellNote;
2024 }
2025
2026 ScDrawObjData* ScDrawLayer::GetNoteCaptionData( SdrObject* pObj, SCTAB nTab )
2027 {
2028 ScDrawObjData* pData = pObj ? GetObjDataTab( pObj, nTab ) : 0;
2029 return (pData && pData->meType == ScDrawObjData::CellNote) ? pData : 0;
2030 }
2031
2032 ScIMapInfo* ScDrawLayer::GetIMapInfo( SdrObject* pObj )
2033 {
2034 return static_cast<ScIMapInfo*>(GetFirstUserDataOfType(pObj, SC_UD_IMAPDATA));
2035 }
2036
2037 IMapObject* ScDrawLayer::GetHitIMapObject( SdrObject* pObj,
2038 const Point& rWinPoint, const vcl::Window& rCmpWnd )
2039 {
2040 const MapMode aMap100( MAP_100TH_MM );
2041 MapMode aWndMode = rCmpWnd.GetMapMode();
2042 Point aRelPoint( rCmpWnd.LogicToLogic( rWinPoint, &aWndMode, &aMap100 ) );
2043 Rectangle aLogRect = rCmpWnd.LogicToLogic( pObj->GetLogicRect(), &aWndMode, &aMap100 );
2044 ScIMapInfo* pIMapInfo = GetIMapInfo( pObj );
2045 IMapObject* pIMapObj = NULL;
2046
2047 if ( pIMapInfo )
2048 {
2049 Size aGraphSize;
2050 ImageMap& rImageMap = (ImageMap&) pIMapInfo->GetImageMap();
2051 Graphic aGraphic;
2052 bool bObjSupported = false;
2053
2054 if ( pObj->ISA( SdrGrafObj ) ) // Simple Graphics object
2055 {
2056 const SdrGrafObj* pGrafObj = static_cast<const SdrGrafObj*>( pObj );
2057 const GeoStat& rGeo = pGrafObj->GetGeoStat();
2058 const Graphic& rGraphic = pGrafObj->GetGraphic();
2059
2060 // Reverse rotation
2061 if ( rGeo.nRotationAngle )
2062 RotatePoint( aRelPoint, aLogRect.TopLeft(), -rGeo.nSin, rGeo.nCos );
2063
2064 // Reverse mirroring
2065 if ( static_cast<const SdrGrafObjGeoData*>( pGrafObj->GetGeoData() )->bMirrored )
2066 aRelPoint.X() = aLogRect.Right() + aLogRect.Left() - aRelPoint.X();
2067
2068 // Possible Unshear:
2069 if ( rGeo.nShearAngle )
2070 ShearPoint( aRelPoint, aLogRect.TopLeft(), -rGeo.nTan );
2071
2072 if ( rGraphic.GetPrefMapMode().GetMapUnit() == MAP_PIXEL )
2073 aGraphSize = rCmpWnd.PixelToLogic( rGraphic.GetPrefSize(),
2074 aMap100 );
2075 else
2076 aGraphSize = OutputDevice::LogicToLogic( rGraphic.GetPrefSize(),
2077 rGraphic.GetPrefMapMode(),
2078 aMap100 );
2079
2080 bObjSupported = true;
2081 }
2082 else if ( pObj->ISA( SdrOle2Obj ) ) // OLE object
2083 {
2084 // TODO/LEAN: working with visual area needs running state
2085 aGraphSize = static_cast<const SdrOle2Obj*>(pObj)->GetOrigObjSize();
2086 bObjSupported = true;
2087 }
2088
2089 // If everything has worked out, then perform HitTest
2090 if ( bObjSupported )
2091 {
2092 // Calculate relative mouse point
2093 aRelPoint -= aLogRect.TopLeft();
2094 pIMapObj = rImageMap.GetHitIMapObject( aGraphSize, aLogRect.GetSize(), aRelPoint );
2095 }
2096 }
2097
2098 return pIMapObj;
2099 }
2100
2101 ScMacroInfo* ScDrawLayer::GetMacroInfo( SdrObject* pObj, bool bCreate )
2102 {
2103 if (SdrObjUserData *pData = GetFirstUserDataOfType(pObj, SC_UD_MACRODATA))
2104 return static_cast<ScMacroInfo*>(pData);
2105
2106 if ( bCreate )
2107 {
2108 ScMacroInfo* pData = new ScMacroInfo;
2109 pObj->AppendUserData(pData);
2110 return pData;
2111 }
2112 return 0;
2113 }
2114
2115 ImageMap* ScDrawLayer::GetImageMapForObject(SdrObject* pObj)
2116 {
2117 ScIMapInfo* pIMapInfo = const_cast<ScIMapInfo*>( GetIMapInfo( pObj ) );
2118 if ( pIMapInfo )
2119 {
2120 return const_cast<ImageMap*>( &(pIMapInfo->GetImageMap()) );
2121 }
2122 return NULL;
2123 }
2124
2125 sal_Int32 ScDrawLayer::GetHyperlinkCount(SdrObject* pObj)
2126 {
2127 sal_Int32 nHLCount = 0;
2128 ScMacroInfo* pMacroInfo = GetMacroInfo(pObj, false);
2129 if (pMacroInfo)
2130 // MT IA2: GetHlink*( doesn't exist in DEV300 anymore...
2131 nHLCount = 0; // pMacroInfo->GetHlink().getLength() > 0 ? 1 : 0;
2132 return nHLCount;
2133 }
2134
2135 void ScDrawLayer::SetGlobalDrawPersist(SfxObjectShell* pPersist)
2136 {
2137 OSL_ENSURE(!pGlobalDrawPersist,"Multiple SetGlobalDrawPersist");
2138 pGlobalDrawPersist = pPersist;
2139 }
2140
2141 void ScDrawLayer::SetChanged( bool bFlg /* = true */ )
2142 {
2143 if ( bFlg && pDoc )
2144 pDoc->SetChartListenerCollectionNeedsUpdate( true );
2145 FmFormModel::SetChanged( bFlg );
2146 }
2147
2148 SdrLayerID ScDrawLayer::GetControlExportLayerId( const SdrObject & ) const
2149 {
2150 // Layer for export of Form-Controls in Versions before 5.0 - always SC_LAYER_FRONT
2151 return SC_LAYER_FRONT;
2152 }
2153
2154 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > ScDrawLayer::createUnoModel()
2155 {
2156 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xRet;
2157 if( pDoc && pDoc->GetDocumentShell() )
2158 xRet = pDoc->GetDocumentShell()->GetModel();
2159
2160 return xRet;
2161 }
2162
2163 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE