1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svx.hxx"
26
27 #include <com/sun/star/drawing/BitmapMode.hpp>
28 #include <com/sun/star/style/XStyle.hpp>
29 #include <com/sun/star/text/WritingMode.hpp>
30 #include <com/sun/star/table/TableBorder.hpp>
31
32 #include <cppuhelper/typeprovider.hxx>
33 #include <svl/style.hxx>
34 #include <svl/itemset.hxx>
35
36 #include <vos/mutex.hxx>
37 #include <vcl/svapp.hxx>
38
39 #include "svx/sdr/properties/textproperties.hxx"
40 #include "editeng/outlobj.hxx"
41 #include "editeng/writingmodeitem.hxx"
42 #include "svx/svdotable.hxx"
43 #include "svx/svdoutl.hxx"
44 #include "svx/unoshtxt.hxx"
45 #include "svx/svdmodel.hxx"
46
47 #include "tableundo.hxx"
48 #include "cell.hxx"
49 #include "svx/svdotable.hxx"
50 #include "svx/svdoutl.hxx"
51 #include "svx/unoshtxt.hxx"
52 #include "svx/unoshprp.hxx"
53 #include "svx/unoshape.hxx"
54 #include "editeng/editobj.hxx"
55 #include "editeng/boxitem.hxx"
56 #include "svx/xflbstit.hxx"
57 #include "svx/xflbmtit.hxx"
58 #include <svx/svdpool.hxx>
59
60 // -----------------------------------------------------------------------------
61
62 using ::rtl::OUString;
63 using ::vos::OGuard;
64 using namespace ::com::sun::star::uno;
65 using namespace ::com::sun::star::beans;
66 using namespace ::com::sun::star::lang;
67 using namespace ::com::sun::star::text;
68 using namespace ::com::sun::star::table;
69 using namespace ::com::sun::star::drawing;
70 using namespace ::com::sun::star::style;
71 using namespace ::com::sun::star::container;
72
73 // -----------------------------------------------------------------------------
74
ImplGetSvxCellPropertySet()75 static const SvxItemPropertySet* ImplGetSvxCellPropertySet()
76 {
77 // Propertymap fuer einen Outliner Text
78 static const SfxItemPropertyMapEntry aSvxCellPropertyMap[] =
79 {
80 FILL_PROPERTIES
81 // { MAP_CHAR_LEN("HasLevels"), OWN_ATTR_HASLEVELS, &::getBooleanCppuType(), ::com::sun::star::beans::PropertyAttribute::READONLY, 0},
82 { MAP_CHAR_LEN("Style"), OWN_ATTR_STYLE, &::com::sun::star::style::XStyle::static_type(), ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
83 { MAP_CHAR_LEN(UNO_NAME_TEXT_WRITINGMODE), SDRATTR_TEXTDIRECTION, &::getCppuType( (::com::sun::star::text::WritingMode*) 0 ), 0, 0},
84 { MAP_CHAR_LEN(UNO_NAME_TEXT_HORZADJUST), SDRATTR_TEXT_HORZADJUST, &::getCppuType((const ::com::sun::star::drawing::TextHorizontalAdjust*)0), 0, 0}, \
85 { MAP_CHAR_LEN(UNO_NAME_TEXT_LEFTDIST), SDRATTR_TEXT_LEFTDIST, &::getCppuType((const sal_Int32*)0), 0, SFX_METRIC_ITEM}, \
86 { MAP_CHAR_LEN(UNO_NAME_TEXT_LOWERDIST), SDRATTR_TEXT_LOWERDIST, &::getCppuType((const sal_Int32*)0), 0, SFX_METRIC_ITEM}, \
87 { MAP_CHAR_LEN(UNO_NAME_TEXT_RIGHTDIST), SDRATTR_TEXT_RIGHTDIST, &::getCppuType((const sal_Int32*)0), 0, SFX_METRIC_ITEM}, \
88 { MAP_CHAR_LEN(UNO_NAME_TEXT_UPPERDIST), SDRATTR_TEXT_UPPERDIST, &::getCppuType((const sal_Int32*)0), 0, SFX_METRIC_ITEM}, \
89 { MAP_CHAR_LEN(UNO_NAME_TEXT_VERTADJUST), SDRATTR_TEXT_VERTADJUST, &::getCppuType((const ::com::sun::star::drawing::TextVerticalAdjust*)0), 0, 0},\
90 { MAP_CHAR_LEN(UNO_NAME_TEXT_WORDWRAP), SDRATTR_TEXT_WORDWRAP, &::getBooleanCppuType(), 0, 0}, \
91
92 { MAP_CHAR_LEN("TableBorder"), OWN_ATTR_TABLEBORDER, &::getCppuType((const TableBorder*)0), 0, 0 }, \
93 { MAP_CHAR_LEN("TopBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, TOP_BORDER }, \
94 { MAP_CHAR_LEN("BottomBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, BOTTOM_BORDER }, \
95 { MAP_CHAR_LEN("LeftBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, LEFT_BORDER }, \
96 { MAP_CHAR_LEN("RightBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, RIGHT_BORDER }, \
97
98 SVX_UNOEDIT_OUTLINER_PROPERTIES,
99 SVX_UNOEDIT_CHAR_PROPERTIES,
100 SVX_UNOEDIT_PARA_PROPERTIES,
101 {0,0,0,0,0,0}
102 };
103
104 static SvxItemPropertySet aSvxCellPropertySet( aSvxCellPropertyMap, SdrObject::GetGlobalDrawObjectItemPool() );
105 return &aSvxCellPropertySet;
106 }
107
108 namespace sdr
109 {
110 namespace properties
111 {
112 class CellProperties : public TextProperties
113 {
114 protected:
115 // create a new itemset
116 SfxItemSet& CreateObjectSpecificItemSet(SfxItemPool& rPool);
117
118 public:
119 // basic constructor
120 CellProperties(SdrObject& rObj, sdr::table::Cell* pCell );
121
122 // constructor for copying, but using new object
123 CellProperties(const CellProperties& rProps, SdrObject& rObj, sdr::table::Cell* pCell);
124
125 // destructor
126 ~CellProperties();
127
128 // Clone() operator, normally just calls the local copy constructor
129 BaseProperties& Clone(SdrObject& rObj) const;
130
131 void ForceDefaultAttributes();
132
133 void ItemSetChanged(const SfxItemSet& rSet);
134
135 void ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem);
136
137 void SetStyleSheet(SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr);
138
139 sdr::table::CellRef mxCell;
140 };
141
142 // create a new itemset
CreateObjectSpecificItemSet(SfxItemPool & rPool)143 SfxItemSet& CellProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool)
144 {
145 return *(new SfxItemSet(rPool,
146
147 // range from SdrAttrObj
148 SDRATTR_START, SDRATTR_SHADOW_LAST,
149 SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST,
150 SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION,
151
152 // range for SdrTableObj
153 SDRATTR_TABLE_FIRST, SDRATTR_TABLE_LAST,
154
155 // range from SdrTextObj
156 EE_ITEMS_START, EE_ITEMS_END,
157
158 // end
159 0, 0));
160 }
161
CellProperties(SdrObject & rObj,sdr::table::Cell * pCell)162 CellProperties::CellProperties(SdrObject& rObj, sdr::table::Cell* pCell)
163 : TextProperties(rObj)
164 , mxCell(pCell)
165 {
166 }
167
CellProperties(const CellProperties & rProps,SdrObject & rObj,sdr::table::Cell * pCell)168 CellProperties::CellProperties(const CellProperties& rProps, SdrObject& rObj, sdr::table::Cell* pCell)
169 : TextProperties(rProps, rObj)
170 , mxCell( pCell )
171 {
172 }
173
~CellProperties()174 CellProperties::~CellProperties()
175 {
176 }
177
Clone(SdrObject & rObj) const178 BaseProperties& CellProperties::Clone(SdrObject& rObj) const
179 {
180 DBG_ERROR("CellProperties::Clone(), does not work yet!");
181 return *(new CellProperties(*this, rObj,0));
182 }
183
ForceDefaultAttributes()184 void CellProperties::ForceDefaultAttributes()
185 {
186 }
187
ItemSetChanged(const SfxItemSet & rSet)188 void CellProperties::ItemSetChanged(const SfxItemSet& rSet )
189 {
190 SdrTextObj& rObj = (SdrTextObj&)GetSdrObject();
191
192 if( mxCell.is() )
193 {
194 OutlinerParaObject* pParaObj = mxCell->GetEditOutlinerParaObject();
195
196 bool bOwnParaObj = pParaObj != 0;
197
198 if( pParaObj == 0 )
199 pParaObj = mxCell->GetOutlinerParaObject();
200
201 if(pParaObj)
202 {
203 // handle outliner attributes
204 Outliner* pOutliner = 0;
205
206 if(mxCell->IsTextEditActive())
207 {
208 pOutliner = rObj.GetTextEditOutliner();
209 }
210 else
211 {
212 pOutliner = &rObj.ImpGetDrawOutliner();
213 pOutliner->SetText(*pParaObj);
214 }
215
216 sal_uInt32 nParaCount(pOutliner->GetParagraphCount());
217
218 for(sal_uInt16 nPara = 0; nPara < nParaCount; nPara++)
219 {
220 SfxItemSet aSet(pOutliner->GetParaAttribs(nPara));
221 aSet.Put(rSet);
222 pOutliner->SetParaAttribs(nPara, aSet);
223 }
224
225 if(!mxCell->IsTextEditActive())
226 {
227 if(nParaCount)
228 {
229 // force ItemSet
230 GetObjectItemSet();
231
232 SfxItemSet aNewSet(pOutliner->GetParaAttribs(0L));
233 mpItemSet->Put(aNewSet);
234 }
235
236 OutlinerParaObject* pTemp = pOutliner->CreateParaObject(0, (sal_uInt16)nParaCount);
237 pOutliner->Clear();
238
239 mxCell->SetOutlinerParaObject(pTemp);
240 }
241
242 if( bOwnParaObj )
243 delete pParaObj;
244 }
245 }
246
247 // call parent
248 AttributeProperties::ItemSetChanged(rSet);
249
250 if( mxCell.is() )
251 mxCell->notifyModified();
252 }
253
ItemChange(const sal_uInt16 nWhich,const SfxPoolItem * pNewItem)254 void CellProperties::ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem)
255 {
256 if(pNewItem && (SDRATTR_TEXTDIRECTION == nWhich))
257 {
258 sal_Bool bVertical(com::sun::star::text::WritingMode_TB_RL == ((SvxWritingModeItem*)pNewItem)->GetValue());
259
260 sdr::table::SdrTableObj& rObj = (sdr::table::SdrTableObj&)GetSdrObject();
261 if( rObj.IsVerticalWriting() != bVertical )
262 rObj.SetVerticalWriting(bVertical);
263
264 // Set a cell vertical property
265 OutlinerParaObject* pParaObj = mxCell->GetEditOutlinerParaObject();
266 if( pParaObj == 0 )
267 pParaObj = mxCell->GetOutlinerParaObject();
268 if(pParaObj)
269 {
270 pParaObj->SetVertical(bVertical);
271 }
272
273 }
274
275 // call parent
276 AttributeProperties::ItemChange( nWhich, pNewItem );
277 }
278
SetStyleSheet(SfxStyleSheet * pNewStyleSheet,sal_Bool bDontRemoveHardAttr)279 void CellProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr)
280 {
281 TextProperties::SetStyleSheet( pNewStyleSheet, bDontRemoveHardAttr );
282 }
283 } // end of namespace properties
284 } // end of namespace sdr
285
286 namespace sdr { namespace table {
287
288 // -----------------------------------------------------------------------------
289 // Cell
290 // -----------------------------------------------------------------------------
291
create(SdrTableObj & rTableObj,OutlinerParaObject * pOutlinerParaObject)292 rtl::Reference< Cell > Cell::create( SdrTableObj& rTableObj, OutlinerParaObject* pOutlinerParaObject )
293 {
294 rtl::Reference< Cell > xCell( new Cell( rTableObj, pOutlinerParaObject ) );
295 if( xCell->mxTable.is() )
296 {
297 Reference< XEventListener > xListener( xCell.get() );
298 xCell->mxTable->addEventListener( xListener );
299 }
300 return xCell;
301 }
302
303 // -----------------------------------------------------------------------------
304
Cell(SdrTableObj & rTableObj,OutlinerParaObject * pOutlinerParaObject)305 Cell::Cell( SdrTableObj& rTableObj, OutlinerParaObject* pOutlinerParaObject ) throw()
306 : SdrText( rTableObj, pOutlinerParaObject )
307 , SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() )
308 , mpPropSet( ImplGetSvxCellPropertySet() )
309 , mpProperties( new sdr::properties::CellProperties( rTableObj, this ) )
310 , mnCellContentType( CellContentType_EMPTY )
311 , mfValue( 0.0 )
312 , mnError( 0 )
313 , mbMerged( sal_False )
314 , mnRowSpan( 1 )
315 , mnColSpan( 1 )
316 , mxTable( rTableObj.getTable() )
317 {
318 if( rTableObj.GetModel() )
319 SetModel( rTableObj.GetModel() );
320 }
321
322 // -----------------------------------------------------------------------------
323
~Cell()324 Cell::~Cell() throw()
325 {
326 dispose();
327 }
328
329 // -----------------------------------------------------------------------------
330
dispose()331 void Cell::dispose()
332 {
333 if( mxTable.is() )
334 {
335 try
336 {
337 Reference< XEventListener > xThis( this );
338 mxTable->removeEventListener( xThis );
339 }
340 catch( Exception& )
341 {
342 DBG_ERROR("Cell::dispose(), exception caught!");
343 }
344 mxTable.clear();
345 }
346
347 if( mpProperties )
348 {
349 delete mpProperties;
350 mpProperties = 0;
351 }
352 SetOutlinerParaObject( 0 );
353 }
354
355 // -----------------------------------------------------------------------------
356
SetModel(SdrModel * pNewModel)357 void Cell::SetModel(SdrModel* pNewModel)
358 {
359 SvxTextEditSource* pTextEditSource = dynamic_cast< SvxTextEditSource* >( GetEditSource() );
360 if( (GetModel() != pNewModel) || ( pNewModel && !pTextEditSource) )
361 {
362 if( mpProperties )
363 {
364 SfxItemPool* pItemPool = mpProperties->GetObjectItemSet().GetPool();
365
366 // test for correct pool in ItemSet; move to new pool if necessary
367 if( pNewModel && pItemPool && pItemPool != &pNewModel->GetItemPool())
368 mpProperties->MoveToItemPool(pItemPool, &pNewModel->GetItemPool(), pNewModel);
369 }
370
371 if( pTextEditSource )
372 {
373 pTextEditSource->ChangeModel( pNewModel );
374 }
375 else
376 {
377 SetEditSource( new SvxTextEditSource( &GetObject(), this, static_cast< XWeak * >( this ) ) );
378 }
379
380 SetStyleSheet( 0, sal_True );
381 SdrText::SetModel( pNewModel );
382 ForceOutlinerParaObject( OUTLINERMODE_TEXTOBJECT );
383 }
384 }
385
386 // -----------------------------------------------------------------------------
387
merge(sal_Int32 nColumnSpan,sal_Int32 nRowSpan)388 void Cell::merge( sal_Int32 nColumnSpan, sal_Int32 nRowSpan )
389 {
390 if( (mnColSpan != nColumnSpan) || (mnRowSpan != nRowSpan) || (mbMerged != sal_False) )
391 {
392 mnColSpan = nColumnSpan;
393 mnRowSpan = nRowSpan;
394 mbMerged = sal_False;
395 notifyModified();
396 }
397 }
398
399 // -----------------------------------------------------------------------------
400
mergeContent(const CellRef & xSourceCell)401 void Cell::mergeContent( const CellRef& xSourceCell )
402 {
403 SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
404
405 if( xSourceCell->hasText() )
406 {
407 SdrOutliner& rOutliner=rTableObj.ImpGetDrawOutliner();
408 rOutliner.SetUpdateMode(sal_True);
409
410 if( hasText() )
411 {
412 rOutliner.SetText(*GetOutlinerParaObject());
413 rOutliner.AddText(*xSourceCell->GetOutlinerParaObject());
414 }
415 else
416 {
417 rOutliner.SetText(*xSourceCell->GetOutlinerParaObject());
418 }
419
420 SetOutlinerParaObject( rOutliner.CreateParaObject() );
421 rOutliner.Clear();
422 xSourceCell->SetOutlinerParaObject(rOutliner.CreateParaObject());
423 rOutliner.Clear();
424 SetStyleSheet( GetStyleSheet(), sal_True );
425 }
426 }
427
428 // -----------------------------------------------------------------------------
429
cloneFrom(const CellRef & xCell)430 void Cell::cloneFrom( const CellRef& xCell )
431 {
432 if( xCell.is() )
433 {
434 replaceContentAndFormating( xCell );
435
436 mnCellContentType = xCell->mnCellContentType;
437
438 msFormula = xCell->msFormula;
439 mfValue = xCell->mfValue;
440 mnError = xCell->mnError;
441
442 mbMerged = xCell->mbMerged;
443 mnRowSpan = xCell->mnRowSpan;
444 mnColSpan = xCell->mnColSpan;
445
446 }
447 notifyModified();
448 }
449
replaceContentAndFormating(const CellRef & xSourceCell)450 void Cell::replaceContentAndFormating( const CellRef& xSourceCell )
451 {
452 if( xSourceCell.is() && mpProperties )
453 {
454 mpProperties->SetMergedItemSet( xSourceCell->GetObjectItemSet() );
455 SetOutlinerParaObject( new OutlinerParaObject(*xSourceCell->GetOutlinerParaObject()) );
456
457 SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
458 SdrTableObj& rSourceTableObj = dynamic_cast< SdrTableObj& >( xSourceCell->GetObject() );
459
460 if(rSourceTableObj.GetModel() != rTableObj.GetModel())
461 {
462 SetStyleSheet( 0, sal_True );
463 }
464 }
465 }
466
467 // -----------------------------------------------------------------------------
468
setMerged()469 void Cell::setMerged()
470 {
471 if( !mbMerged )
472 {
473 mbMerged = sal_True;
474 notifyModified();
475 }
476 }
477
478 // -----------------------------------------------------------------------------
479
notifyModified()480 void Cell::notifyModified()
481 {
482 if( mxTable.is() )
483 mxTable->setModified( sal_True );
484 }
485
486 // -----------------------------------------------------------------------------
487 // SdrTextShape proxy
488 // -----------------------------------------------------------------------------
489
IsTextEditActive()490 bool Cell::IsTextEditActive()
491 {
492 bool isActive = false;
493 SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
494 if(rTableObj.getActiveCell().get() == this )
495 {
496 OutlinerParaObject* pParaObj = rTableObj.GetEditOutlinerParaObject();
497 if( pParaObj != 0 )
498 {
499 isActive = true;
500 delete pParaObj;
501 }
502 }
503 return isActive;
504 }
505
506 // -----------------------------------------------------------------------------
507
hasText() const508 bool Cell::hasText() const
509 {
510 OutlinerParaObject* pParaObj = GetOutlinerParaObject();
511 if( pParaObj )
512 {
513 const EditTextObject& rTextObj = pParaObj->GetTextObject();
514 if( rTextObj.GetParagraphCount() >= 1 )
515 {
516 if( rTextObj.GetParagraphCount() == 1 )
517 {
518 if( rTextObj.GetText(0).Len() == 0 )
519 return false;
520 }
521 return true;
522 }
523 }
524
525 return false;
526 }
527
528 // -----------------------------------------------------------------------------
529
GetEditOutlinerParaObject() const530 OutlinerParaObject* Cell::GetEditOutlinerParaObject() const
531 {
532 SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
533 if( rTableObj.getActiveCell().get() == this )
534 return rTableObj.GetEditOutlinerParaObject();
535 return 0;
536 }
537
538 // -----------------------------------------------------------------------------
539
SetStyleSheet(SfxStyleSheet * pStyleSheet,sal_Bool bDontRemoveHardAttr)540 void Cell::SetStyleSheet( SfxStyleSheet* pStyleSheet, sal_Bool bDontRemoveHardAttr )
541 {
542 // only allow cell styles for cells
543 if( pStyleSheet && pStyleSheet->GetFamily() != SFX_STYLE_FAMILY_FRAME )
544 return;
545
546 if( mpProperties && (mpProperties->GetStyleSheet() != pStyleSheet) )
547 {
548 mpProperties->SetStyleSheet( pStyleSheet, bDontRemoveHardAttr );
549 }
550 }
551
552 // -----------------------------------------------------------------------------
553
GetObjectItemSet()554 const SfxItemSet& Cell::GetObjectItemSet()
555 {
556 if( mpProperties )
557 {
558 return mpProperties->GetObjectItemSet();
559 }
560 else
561 {
562 DBG_ERROR("Cell::GetObjectItemSet(), called without properties!");
563 return GetObject().GetObjectItemSet();
564 }
565 }
566
SetObjectItem(const SfxPoolItem & rItem)567 void Cell::SetObjectItem(const SfxPoolItem& rItem)
568 {
569 if( mpProperties )
570 {
571 mpProperties->SetObjectItem( rItem );
572 notifyModified();
573 }
574 }
575
SetMergedItem(const SfxPoolItem & rItem)576 void Cell::SetMergedItem(const SfxPoolItem& rItem)
577 {
578 SetObjectItem(rItem);
579 }
580
GetStyleSheet() const581 SfxStyleSheet* Cell::GetStyleSheet() const
582 {
583 if( mpProperties )
584 return mpProperties->GetStyleSheet();
585 else
586 return 0;
587 }
588
589 // -----------------------------------------------------------------------------
590
GetStyleSheetPool() const591 SfxStyleSheetPool* Cell::GetStyleSheetPool() const
592 {
593 if( mpProperties && mpProperties->GetStyleSheet() )
594 return dynamic_cast< SfxStyleSheetPool* >( &mpProperties->GetStyleSheet()->GetPool() );
595 else
596 return 0;
597 }
598
599 // -----------------------------------------------------------------------------
600
GetCurrentBoundRect() const601 const Rectangle& Cell::GetCurrentBoundRect() const
602 {
603 return maCellRect;
604 }
605
606 // -----------------------------------------------------------------------------
607
TakeTextAnchorRect(Rectangle & rAnchorRect) const608 void Cell::TakeTextAnchorRect(Rectangle& rAnchorRect) const
609 {
610 rAnchorRect.nLeft = maCellRect.nLeft + GetTextLeftDistance();
611 rAnchorRect.nRight = maCellRect.nRight - GetTextRightDistance();
612 rAnchorRect.nTop = maCellRect.nTop + GetTextUpperDistance();
613 rAnchorRect.nBottom = maCellRect.nBottom - GetTextLowerDistance();
614 }
615
616 // -----------------------------------------------------------------------------
617
GetItemSet() const618 const SfxItemSet& Cell::GetItemSet() const
619 {
620 return mpProperties->GetObjectItemSet();
621 }
622
623 // -----------------------------------------------------------------------------
624
SetMergedItemSetAndBroadcast(const SfxItemSet & rSet,sal_Bool bClearAllItems)625 void Cell::SetMergedItemSetAndBroadcast(const SfxItemSet& rSet, sal_Bool bClearAllItems)
626 {
627 if( mpProperties )
628 {
629 mpProperties->SetMergedItemSetAndBroadcast(rSet, bClearAllItems);
630 notifyModified();
631 }
632 }
633
634 // -----------------------------------------------------------------------------
635
getMinimumWidth()636 sal_Int32 Cell::getMinimumWidth()
637 {
638 return GetTextLeftDistance() + GetTextRightDistance() + 100;
639 }
640
641 // -----------------------------------------------------------------------------
642
getMinimumHeight()643 sal_Int32 Cell::getMinimumHeight()
644 {
645 if( !mpProperties )
646 return 0;
647
648 SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
649 sal_Int32 nMinimumHeight = 0;
650
651 Rectangle aTextRect;
652 TakeTextAnchorRect( aTextRect );
653 Size aSize( aTextRect.GetSize() );
654 aSize.Height()=0x0FFFFFFF;
655
656 SdrOutliner* pEditOutliner = rTableObj.GetCellTextEditOutliner( *this );
657 if(pEditOutliner)
658 {
659 pEditOutliner->SetMaxAutoPaperSize(aSize);
660 nMinimumHeight = pEditOutliner->GetTextHeight()+1;
661 }
662 else /*if ( hasText() )*/
663 {
664 Outliner& rOutliner=rTableObj.ImpGetDrawOutliner();
665 rOutliner.SetPaperSize(aSize);
666 rOutliner.SetUpdateMode(sal_True);
667 ForceOutlinerParaObject( OUTLINERMODE_TEXTOBJECT );
668
669 if( GetOutlinerParaObject() )
670 {
671 rOutliner.SetText(*GetOutlinerParaObject());
672 }
673 nMinimumHeight=rOutliner.GetTextHeight()+1;
674 rOutliner.Clear();
675 }
676
677 nMinimumHeight += GetTextUpperDistance() + GetTextLowerDistance();
678 return nMinimumHeight;
679 }
680
681 // -----------------------------------------------------------------------------
682
GetTextLeftDistance() const683 long Cell::GetTextLeftDistance() const
684 {
685 return ((SdrTextLeftDistItem&)(GetItemSet().Get(SDRATTR_TEXT_LEFTDIST))).GetValue();
686 }
687
688 // -----------------------------------------------------------------------------
689
GetTextRightDistance() const690 long Cell::GetTextRightDistance() const
691 {
692 return ((SdrTextRightDistItem&)(GetItemSet().Get(SDRATTR_TEXT_RIGHTDIST))).GetValue();
693 }
694
695 // -----------------------------------------------------------------------------
696
GetTextUpperDistance() const697 long Cell::GetTextUpperDistance() const
698 {
699 return ((SdrTextUpperDistItem&)(GetItemSet().Get(SDRATTR_TEXT_UPPERDIST))).GetValue();
700 }
701
702 // -----------------------------------------------------------------------------
703
GetTextLowerDistance() const704 long Cell::GetTextLowerDistance() const
705 {
706 return ((SdrTextLowerDistItem&)(GetItemSet().Get(SDRATTR_TEXT_LOWERDIST))).GetValue();
707 }
708
709 // -----------------------------------------------------------------------------
710
GetTextVerticalAdjust() const711 SdrTextVertAdjust Cell::GetTextVerticalAdjust() const
712 {
713 return ((SdrTextVertAdjustItem&)(GetItemSet().Get(SDRATTR_TEXT_VERTADJUST))).GetValue();
714 }
715
716 // -----------------------------------------------------------------------------
717
GetTextHorizontalAdjust() const718 SdrTextHorzAdjust Cell::GetTextHorizontalAdjust() const
719 {
720 return ((SdrTextHorzAdjustItem&)(GetItemSet().Get(SDRATTR_TEXT_HORZADJUST))).GetValue();
721 }
722
723 // -----------------------------------------------------------------------------
724
SetOutlinerParaObject(OutlinerParaObject * pTextObject)725 void Cell::SetOutlinerParaObject( OutlinerParaObject* pTextObject )
726 {
727 SdrText::SetOutlinerParaObject( pTextObject );
728 maSelection.nStartPara = 0xffff;
729
730 if( pTextObject == 0 )
731 ForceOutlinerParaObject( OUTLINERMODE_TEXTOBJECT );
732 }
733
734 // -----------------------------------------------------------------------------
735
AddUndo()736 void Cell::AddUndo()
737 {
738 SdrObject& rObj = GetObject();
739 if( rObj.IsInserted() && GetModel() && GetModel()->IsUndoEnabled() )
740 {
741 CellRef xCell( this );
742 GetModel()->AddUndo( new CellUndo( &rObj, xCell ) );
743 }
744 }
745
746 // -----------------------------------------------------------------------------
747
CloneProperties(sdr::properties::TextProperties * pProperties,SdrObject & rNewObj,Cell & rNewCell)748 sdr::properties::TextProperties* Cell::CloneProperties( sdr::properties::TextProperties* pProperties, SdrObject& rNewObj, Cell& rNewCell )
749 {
750 if( pProperties )
751 return new sdr::properties::CellProperties( *static_cast<sdr::properties::CellProperties*>(pProperties), rNewObj, &rNewCell );
752 else
753 return 0;
754 }
755
756 // -----------------------------------------------------------------------------
757
CloneProperties(SdrObject & rNewObj,Cell & rNewCell)758 sdr::properties::TextProperties* Cell::CloneProperties( SdrObject& rNewObj, Cell& rNewCell )
759 {
760 return CloneProperties(mpProperties,rNewObj,rNewCell);
761 }
762
763 // -----------------------------------------------------------------------------
764 // XInterface
765 // -----------------------------------------------------------------------------
766
queryInterface(const Type & rType)767 Any SAL_CALL Cell::queryInterface( const Type & rType ) throw(RuntimeException)
768 {
769 if( rType == XMergeableCell::static_type() )
770 return Any( Reference< XMergeableCell >( this ) );
771
772 if( rType == XCell::static_type() )
773 return Any( Reference< XCell >( this ) );
774
775 if( rType == XLayoutConstrains::static_type() )
776 return Any( Reference< XLayoutConstrains >( this ) );
777
778 if( rType == XEventListener::static_type() )
779 return Any( Reference< XEventListener >( this ) );
780
781 Any aRet( SvxUnoTextBase::queryAggregation( rType ) );
782 if( aRet.hasValue() )
783 return aRet;
784
785 return ::cppu::OWeakObject::queryInterface( rType );
786 }
787
788 // -----------------------------------------------------------------------------
789
acquire()790 void SAL_CALL Cell::acquire() throw ()
791 {
792 ::cppu::OWeakObject::acquire();
793 }
794
795 // -----------------------------------------------------------------------------
796
release()797 void SAL_CALL Cell::release() throw ()
798 {
799 ::cppu::OWeakObject::release();
800 }
801
802 // -----------------------------------------------------------------------------
803 // XTypeProvider
804 // -----------------------------------------------------------------------------
805
getTypes()806 Sequence< Type > SAL_CALL Cell::getTypes( ) throw (RuntimeException)
807 {
808 Sequence< Type > aTypes( SvxUnoTextBase::getTypes() );
809
810 sal_Int32 nLen = aTypes.getLength();
811 aTypes.realloc(nLen + 2);
812 aTypes[nLen++] = XMergeableCell::static_type();
813 aTypes[nLen++] = XLayoutConstrains::static_type();
814
815 return aTypes;
816 }
817
818 // -----------------------------------------------------------------------------
819
getImplementationId()820 Sequence< sal_Int8 > SAL_CALL Cell::getImplementationId( ) throw (RuntimeException)
821 {
822 static ::cppu::OImplementationId* pId = 0;
823 if (! pId)
824 {
825 ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
826 if (! pId)
827 {
828 static ::cppu::OImplementationId aId;
829 pId = &aId;
830 }
831 }
832 return pId->getImplementationId();
833 }
834
835 // -----------------------------------------------------------------------------
836 // XServiceInfo
837 // -----------------------------------------------------------------------------
838
getImplementationName()839 OUString SAL_CALL Cell::getImplementationName( ) throw (RuntimeException)
840 {
841 return OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.svx.table.Cell" ) );
842 }
843
844 // -----------------------------------------------------------------------------
845
supportsService(const OUString & ServiceName)846 sal_Bool SAL_CALL Cell::supportsService( const OUString& ServiceName ) throw (RuntimeException)
847 {
848 if( ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.table.cell" ) ) == 0 )
849 return sal_True;
850
851 if( ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.drawing.cell" ) ) == 0 )
852 return sal_True;
853
854 return SvxUnoTextBase::supportsService( ServiceName );
855 }
856
857 // -----------------------------------------------------------------------------
858
getSupportedServiceNames()859 Sequence< OUString > SAL_CALL Cell::getSupportedServiceNames( ) throw (RuntimeException)
860 {
861 Sequence< OUString > aSeq( SvxUnoTextBase::getSupportedServiceNames() );
862 sal_Int32 nIndex = aSeq.getLength();
863 aSeq.realloc( nIndex + 2 );
864 aSeq[nIndex++] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.table.cell" ) );
865 aSeq[nIndex++] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.cell" ) );
866 return aSeq;
867 }
868
869 // -----------------------------------------------------------------------------
870 // XLayoutConstrains
871 // -----------------------------------------------------------------------------
872
getMinimumSize()873 ::com::sun::star::awt::Size SAL_CALL Cell::getMinimumSize( ) throw (RuntimeException)
874 {
875 return ::com::sun::star::awt::Size( getMinimumWidth(), getMinimumHeight() );
876 }
877
878 // -----------------------------------------------------------------------------
879
getPreferredSize()880 ::com::sun::star::awt::Size SAL_CALL Cell::getPreferredSize( ) throw (RuntimeException)
881 {
882 return getMinimumSize();
883 }
884
885 // -----------------------------------------------------------------------------
886
calcAdjustedSize(const::com::sun::star::awt::Size & aNewSize)887 ::com::sun::star::awt::Size SAL_CALL Cell::calcAdjustedSize( const ::com::sun::star::awt::Size& aNewSize ) throw (RuntimeException)
888 {
889 return aNewSize;
890 }
891
892 // -----------------------------------------------------------------------------
893 // XMergeableCell
894 // -----------------------------------------------------------------------------
895
getRowSpan()896 sal_Int32 SAL_CALL Cell::getRowSpan() throw (RuntimeException)
897 {
898 return mnRowSpan;
899 }
900
901 // -----------------------------------------------------------------------------
902
getColumnSpan()903 sal_Int32 SAL_CALL Cell::getColumnSpan() throw (RuntimeException)
904 {
905 return mnColSpan;
906 }
907
908 // -----------------------------------------------------------------------------
909
isMerged()910 sal_Bool SAL_CALL Cell::isMerged() throw (RuntimeException)
911 {
912 return mbMerged;
913 }
914
915 // -----------------------------------------------------------------------------
916 // XCell
917 // -----------------------------------------------------------------------------
918
getFormula()919 OUString SAL_CALL Cell::getFormula( ) throw (RuntimeException)
920 {
921 return msFormula;
922 }
923
924 // -----------------------------------------------------------------------------
925
setFormula(const OUString & aFormula)926 void SAL_CALL Cell::setFormula( const OUString& aFormula ) throw (RuntimeException)
927 {
928 if( msFormula != aFormula )
929 {
930 msFormula = aFormula;
931 }
932 }
933
934 // -----------------------------------------------------------------------------
935
getValue()936 double SAL_CALL Cell::getValue( ) throw (RuntimeException)
937 {
938 return mfValue;
939 }
940
941 // -----------------------------------------------------------------------------
942
setValue(double nValue)943 void SAL_CALL Cell::setValue( double nValue ) throw (RuntimeException)
944 {
945 if( mfValue == nValue )
946 {
947 mfValue = nValue;
948 mnCellContentType = CellContentType_VALUE;
949 }
950 }
951
952 // -----------------------------------------------------------------------------
953
getType()954 CellContentType SAL_CALL Cell::getType() throw (RuntimeException)
955 {
956 return mnCellContentType;
957 }
958
959 // -----------------------------------------------------------------------------
960
getError()961 sal_Int32 SAL_CALL Cell::getError( ) throw (RuntimeException)
962 {
963 return mnError;
964 }
965
966 // -----------------------------------------------------------------------------
967 // XPropertySet
968 // -----------------------------------------------------------------------------
969
GetAnyForItem(SfxItemSet & aSet,const SfxItemPropertySimpleEntry * pMap)970 Any Cell::GetAnyForItem( SfxItemSet& aSet, const SfxItemPropertySimpleEntry* pMap )
971 {
972 Any aAny( SvxItemPropertySet_getPropertyValue( *mpPropSet, pMap, aSet ) );
973
974 if( *pMap->pType != aAny.getValueType() )
975 {
976 // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
977 if( ( *pMap->pType == ::getCppuType((const sal_Int16*)0)) && aAny.getValueType() == ::getCppuType((const sal_Int32*)0) )
978 {
979 sal_Int32 nValue = 0;
980 aAny >>= nValue;
981 aAny <<= (sal_Int16)nValue;
982 }
983 else
984 {
985 DBG_ERROR("GetAnyForItem() Returnvalue has wrong Type!" );
986 }
987 }
988
989 return aAny;
990 }
991
getPropertySetInfo()992 Reference< XPropertySetInfo > SAL_CALL Cell::getPropertySetInfo() throw(RuntimeException)
993 {
994 return mpPropSet->getPropertySetInfo();
995 }
996
997 // -----------------------------------------------------------------------------
998
setPropertyValue(const OUString & rPropertyName,const Any & rValue)999 void SAL_CALL Cell::setPropertyValue( const OUString& rPropertyName, const Any& rValue ) throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
1000 {
1001 OGuard aGuard( Application::GetSolarMutex() );
1002
1003 if( (mpProperties == 0) || (GetModel() == 0) )
1004 throw DisposedException();
1005
1006 const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(rPropertyName);
1007 if( pMap )
1008 {
1009 if( (pMap->nFlags & PropertyAttribute::READONLY ) != 0 )
1010 throw PropertyVetoException();
1011
1012 switch( pMap->nWID )
1013 {
1014 case OWN_ATTR_STYLE:
1015 {
1016 Reference< XStyle > xStyle;
1017 if( !( rValue >>= xStyle ) )
1018 throw IllegalArgumentException();
1019
1020 SfxUnoStyleSheet* pStyle = SfxUnoStyleSheet::getUnoStyleSheet(xStyle);
1021 SetStyleSheet( pStyle, sal_True );
1022 return;
1023 }
1024 case OWN_ATTR_TABLEBORDER:
1025 {
1026 if(rValue.getValueType() != ::getCppuType((const TableBorder*)0) )
1027 break;
1028
1029 const TableBorder* pBorder = (const TableBorder* )rValue.getValue();
1030 if( pBorder == NULL )
1031 break;
1032
1033 SvxBoxItem aBox( SDRATTR_TABLE_BORDER );
1034 SvxBoxInfoItem aBoxInfo( SDRATTR_TABLE_BORDER_INNER );
1035 SvxBorderLine aLine;
1036
1037 sal_Bool bSet = SvxBoxItem::LineToSvxLine(pBorder->TopLine, aLine, false);
1038 aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_TOP);
1039 aBoxInfo.SetValid(VALID_TOP, pBorder->IsTopLineValid);
1040
1041 bSet = SvxBoxItem::LineToSvxLine(pBorder->BottomLine, aLine, false);
1042 aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_BOTTOM);
1043 aBoxInfo.SetValid(VALID_BOTTOM, pBorder->IsBottomLineValid);
1044
1045 bSet = SvxBoxItem::LineToSvxLine(pBorder->LeftLine, aLine, false);
1046 aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_LEFT);
1047 aBoxInfo.SetValid(VALID_LEFT, pBorder->IsLeftLineValid);
1048
1049 bSet = SvxBoxItem::LineToSvxLine(pBorder->RightLine, aLine, false);
1050 aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_RIGHT);
1051 aBoxInfo.SetValid(VALID_RIGHT, pBorder->IsRightLineValid);
1052
1053 bSet = SvxBoxItem::LineToSvxLine(pBorder->HorizontalLine, aLine, false);
1054 aBoxInfo.SetLine(bSet ? &aLine : 0, BOXINFO_LINE_HORI);
1055 aBoxInfo.SetValid(VALID_HORI, pBorder->IsHorizontalLineValid);
1056
1057 bSet = SvxBoxItem::LineToSvxLine(pBorder->VerticalLine, aLine, false);
1058 aBoxInfo.SetLine(bSet ? &aLine : 0, BOXINFO_LINE_VERT);
1059 aBoxInfo.SetValid(VALID_VERT, pBorder->IsVerticalLineValid);
1060
1061 aBox.SetDistance(pBorder->Distance, false);
1062 aBoxInfo.SetValid(VALID_DISTANCE, pBorder->IsDistanceValid);
1063
1064 mpProperties->SetObjectItem(aBox);
1065 mpProperties->SetObjectItem(aBoxInfo);
1066 return;
1067 }
1068 case OWN_ATTR_FILLBMP_MODE:
1069 {
1070 BitmapMode eMode;
1071 if(!(rValue >>= eMode) )
1072 {
1073 sal_Int32 nMode = 0;
1074 if(!(rValue >>= nMode))
1075 throw IllegalArgumentException();
1076
1077 eMode = (BitmapMode)nMode;
1078 }
1079
1080 mpProperties->SetObjectItem( XFillBmpStretchItem( eMode == BitmapMode_STRETCH ) );
1081 mpProperties->SetObjectItem( XFillBmpTileItem( eMode == BitmapMode_REPEAT ) );
1082 return;
1083 }
1084 default:
1085 {
1086 SfxItemSet aSet( GetModel()->GetItemPool(), pMap->nWID, pMap->nWID);
1087 aSet.Put(mpProperties->GetItem(pMap->nWID));
1088
1089 bool bSpecial = false;
1090
1091 switch( pMap->nWID )
1092 {
1093 case XATTR_FILLBITMAP:
1094 case XATTR_FILLGRADIENT:
1095 case XATTR_FILLHATCH:
1096 case XATTR_FILLFLOATTRANSPARENCE:
1097 case XATTR_LINEEND:
1098 case XATTR_LINESTART:
1099 case XATTR_LINEDASH:
1100 {
1101 if( pMap->nMemberId == MID_NAME )
1102 {
1103 OUString aApiName;
1104 if( rValue >>= aApiName )
1105 {
1106 if( SvxShape::SetFillAttribute( pMap->nWID, aApiName, aSet, GetModel() ) )
1107 bSpecial = true;
1108 }
1109 }
1110 }
1111 break;
1112 }
1113
1114 if( !bSpecial )
1115 {
1116
1117 if( !SvxUnoTextRangeBase::SetPropertyValueHelper( aSet, pMap, rValue, aSet ))
1118 {
1119 if( aSet.GetItemState( pMap->nWID ) != SFX_ITEM_SET )
1120 {
1121 // Default aus ItemPool holen
1122 if(GetModel()->GetItemPool().IsWhich(pMap->nWID))
1123 aSet.Put(GetModel()->GetItemPool().GetDefaultItem(pMap->nWID));
1124 }
1125
1126 if( aSet.GetItemState( pMap->nWID ) == SFX_ITEM_SET )
1127 {
1128 SvxItemPropertySet_setPropertyValue( *mpPropSet, pMap, rValue, aSet );
1129 }
1130 }
1131 }
1132
1133 GetModel()->SetChanged();
1134 mpProperties->SetMergedItemSetAndBroadcast( aSet );
1135 return;
1136 }
1137 }
1138 }
1139 throw UnknownPropertyException();
1140 }
1141
1142 // -----------------------------------------------------------------------------
1143
getPropertyValue(const OUString & PropertyName)1144 Any SAL_CALL Cell::getPropertyValue( const OUString& PropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1145 {
1146 OGuard aGuard( Application::GetSolarMutex() );
1147
1148 if( (mpProperties == 0) || (GetModel() == 0) )
1149 throw DisposedException();
1150
1151 const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
1152 if( pMap )
1153 {
1154 switch( pMap->nWID )
1155 {
1156 /*
1157 case OWN_ATTR_HASLEVELS:
1158 {
1159 return Any( hasLevels() );
1160 }
1161 */
1162 case OWN_ATTR_STYLE:
1163 {
1164 return Any( Reference< XStyle >( dynamic_cast< SfxUnoStyleSheet* >( GetStyleSheet() ) ) );
1165 }
1166 case OWN_ATTR_TABLEBORDER:
1167 {
1168 const SvxBoxInfoItem& rBoxInfoItem = static_cast<const SvxBoxInfoItem&>(mpProperties->GetItem(SDRATTR_TABLE_BORDER_INNER));
1169 const SvxBoxItem& rBox = static_cast<const SvxBoxItem&>(mpProperties->GetItem(SDRATTR_TABLE_BORDER));
1170
1171 TableBorder aTableBorder;
1172 aTableBorder.TopLine = SvxBoxItem::SvxLineToLine(rBox.GetTop(), false);
1173 aTableBorder.IsTopLineValid = rBoxInfoItem.IsValid(VALID_TOP);
1174 aTableBorder.BottomLine = SvxBoxItem::SvxLineToLine(rBox.GetBottom(), false);
1175 aTableBorder.IsBottomLineValid = rBoxInfoItem.IsValid(VALID_BOTTOM);
1176 aTableBorder.LeftLine = SvxBoxItem::SvxLineToLine(rBox.GetLeft(), false);
1177 aTableBorder.IsLeftLineValid = rBoxInfoItem.IsValid(VALID_LEFT);
1178 aTableBorder.RightLine = SvxBoxItem::SvxLineToLine(rBox.GetRight(), false);
1179 aTableBorder.IsRightLineValid = rBoxInfoItem.IsValid(VALID_RIGHT );
1180 aTableBorder.HorizontalLine = SvxBoxItem::SvxLineToLine(rBoxInfoItem.GetHori(), false);
1181 aTableBorder.IsHorizontalLineValid = rBoxInfoItem.IsValid(VALID_HORI);
1182 aTableBorder.VerticalLine = SvxBoxItem::SvxLineToLine(rBoxInfoItem.GetVert(), false);
1183 aTableBorder.IsVerticalLineValid = rBoxInfoItem.IsValid(VALID_VERT);
1184 aTableBorder.Distance = rBox.GetDistance();
1185 aTableBorder.IsDistanceValid = rBoxInfoItem.IsValid(VALID_DISTANCE);
1186
1187 return Any( aTableBorder );
1188 }
1189 case OWN_ATTR_FILLBMP_MODE:
1190 {
1191 const XFillBmpStretchItem& rStretchItem = static_cast<const XFillBmpStretchItem&>(mpProperties->GetItem(XATTR_FILLBMP_STRETCH));
1192 const XFillBmpTileItem& rTileItem = static_cast<const XFillBmpTileItem&>(mpProperties->GetItem(XATTR_FILLBMP_TILE));
1193 if( rTileItem.GetValue() )
1194 {
1195 return Any( BitmapMode_REPEAT );
1196 }
1197 else if( rStretchItem.GetValue() )
1198 {
1199 return Any( BitmapMode_STRETCH );
1200 }
1201 else
1202 {
1203 return Any( BitmapMode_NO_REPEAT );
1204 }
1205 }
1206 default:
1207 {
1208 SfxItemSet aSet( GetModel()->GetItemPool(), pMap->nWID, pMap->nWID);
1209 aSet.Put(mpProperties->GetItem(pMap->nWID));
1210
1211 Any aAny;
1212 if(!SvxUnoTextRangeBase::GetPropertyValueHelper( aSet, pMap, aAny ))
1213 {
1214 if(!aSet.Count())
1215 {
1216 // Default aus ItemPool holen
1217 if(GetModel()->GetItemPool().IsWhich(pMap->nWID))
1218 aSet.Put(GetModel()->GetItemPool().GetDefaultItem(pMap->nWID));
1219 }
1220
1221 if( aSet.Count() )
1222 aAny = GetAnyForItem( aSet, pMap );
1223 }
1224
1225 return aAny;
1226 }
1227 }
1228 }
1229 throw UnknownPropertyException();
1230 }
1231
1232 // -----------------------------------------------------------------------------
1233
addPropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)1234 void SAL_CALL Cell::addPropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*xListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1235 {
1236 }
1237
1238 // -----------------------------------------------------------------------------
1239
removePropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)1240 void SAL_CALL Cell::removePropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1241 {
1242 }
1243
1244 // -----------------------------------------------------------------------------
1245
addVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)1246 void SAL_CALL Cell::addVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1247 {
1248 }
1249
1250 // -----------------------------------------------------------------------------
1251
removeVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)1252 void SAL_CALL Cell::removeVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1253 {
1254 }
1255
1256 // -----------------------------------------------------------------------------
1257 // XMultiPropertySet
1258 // -----------------------------------------------------------------------------
1259
setPropertyValues(const Sequence<OUString> & aPropertyNames,const Sequence<Any> & aValues)1260 void SAL_CALL Cell::setPropertyValues( const Sequence< OUString >& aPropertyNames, const Sequence< Any >& aValues ) throw (PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
1261 {
1262 OGuard aSolarGuard( Application::GetSolarMutex() );
1263
1264 if( (mpProperties == 0) || (GetModel() == 0) )
1265 throw DisposedException();
1266
1267 const sal_Int32 nCount = aPropertyNames.getLength();
1268
1269 const OUString* pNames = aPropertyNames.getConstArray();
1270 const Any* pValues = aValues.getConstArray();
1271
1272 for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pValues++ )
1273 {
1274 try
1275 {
1276 setPropertyValue( *pNames, *pValues );
1277 }
1278 catch( UnknownPropertyException& )
1279 {
1280 DBG_ERROR("svx::Cell::setPropertyValues(), unknown property!" );
1281 }
1282 catch( Exception& )
1283 {
1284 DBG_ERROR("svx::Cell::setPropertyValues(), Exception caught!" );
1285 }
1286 }
1287 }
1288
1289 // -----------------------------------------------------------------------------
1290
getPropertyValues(const Sequence<OUString> & aPropertyNames)1291 Sequence< Any > SAL_CALL Cell::getPropertyValues( const Sequence< OUString >& aPropertyNames ) throw (RuntimeException)
1292 {
1293 OGuard aSolarGuard( Application::GetSolarMutex() );
1294
1295 if( (mpProperties == 0) || (GetModel() == 0) )
1296 throw DisposedException();
1297
1298 const sal_Int32 nCount = aPropertyNames.getLength();
1299 const OUString* pNames = aPropertyNames.getConstArray();
1300
1301 Sequence< Any > aRet( nCount );
1302 Any* pValue = aRet.getArray();
1303
1304 for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pValue++, pNames++ )
1305 {
1306 try
1307 {
1308 *pValue = getPropertyValue( *pNames );
1309 }
1310 catch( UnknownPropertyException& )
1311 {
1312 DBG_ERROR("svx::Cell::setPropertyValues(), unknown property!" );
1313 }
1314 catch( Exception& )
1315 {
1316 DBG_ERROR( "svx::Cell::getPropertyValues(), Exception caught!" );
1317 }
1318 }
1319
1320 return aRet;
1321 }
1322
1323 // -----------------------------------------------------------------------------
1324
addPropertiesChangeListener(const Sequence<OUString> &,const Reference<XPropertiesChangeListener> &)1325 void SAL_CALL Cell::addPropertiesChangeListener( const Sequence< OUString >& /*aPropertyNames*/, const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw (RuntimeException)
1326 {
1327 }
1328
1329 // -----------------------------------------------------------------------------
1330
removePropertiesChangeListener(const Reference<XPropertiesChangeListener> &)1331 void SAL_CALL Cell::removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw (RuntimeException)
1332 {
1333 }
1334
1335 // -----------------------------------------------------------------------------
1336
firePropertiesChangeEvent(const Sequence<OUString> &,const Reference<XPropertiesChangeListener> &)1337 void SAL_CALL Cell::firePropertiesChangeEvent( const Sequence< OUString >& /*aPropertyNames*/, const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw (RuntimeException)
1338 {
1339 }
1340
1341 // -----------------------------------------------------------------------------
1342 // XPropertyState
1343 // -----------------------------------------------------------------------------
1344
getPropertyState(const OUString & PropertyName)1345 PropertyState SAL_CALL Cell::getPropertyState( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
1346 {
1347 OGuard aGuard( Application::GetSolarMutex() );
1348
1349 if( (mpProperties == 0) || (GetModel() == 0) )
1350 throw DisposedException();
1351
1352 const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
1353
1354 if( pMap )
1355 {
1356 PropertyState eState;
1357 switch( pMap->nWID )
1358 {
1359 case OWN_ATTR_FILLBMP_MODE:
1360 {
1361 const SfxItemSet& rSet = mpProperties->GetMergedItemSet();
1362
1363 const bool bStretch = rSet.GetItemState( XATTR_FILLBMP_STRETCH, false ) == SFX_ITEM_SET;
1364 const bool bTile = rSet.GetItemState( XATTR_FILLBMP_TILE, false ) == SFX_ITEM_SET;
1365 if( bStretch || bTile )
1366 {
1367 eState = PropertyState_DIRECT_VALUE;
1368 }
1369 else
1370 {
1371 eState = PropertyState_DEFAULT_VALUE;
1372 }
1373 }
1374 /*
1375 case OWN_ATTR_HASLEVELS:
1376 {
1377 return PropertyState_DIRECT_VALUE;
1378 }
1379 */
1380 case OWN_ATTR_STYLE:
1381 {
1382 return PropertyState_DIRECT_VALUE;
1383 }
1384 case OWN_ATTR_TABLEBORDER:
1385 {
1386 const SfxItemSet& rSet = mpProperties->GetMergedItemSet();
1387 if( (rSet.GetItemState( SDRATTR_TABLE_BORDER_INNER, sal_False ) == SFX_ITEM_DEFAULT) && (rSet.GetItemState( SDRATTR_TABLE_BORDER, sal_False ) == SFX_ITEM_DEFAULT) )
1388 return PropertyState_DEFAULT_VALUE;
1389
1390 return PropertyState_DIRECT_VALUE;
1391 }
1392 default:
1393 {
1394 const SfxItemSet& rSet = mpProperties->GetMergedItemSet();
1395
1396 switch( rSet.GetItemState( pMap->nWID, sal_False ) )
1397 {
1398 case SFX_ITEM_READONLY:
1399 case SFX_ITEM_SET:
1400 eState = PropertyState_DIRECT_VALUE;
1401 break;
1402 case SFX_ITEM_DEFAULT:
1403 eState = PropertyState_DEFAULT_VALUE;
1404 break;
1405 // case SFX_ITEM_UNKNOWN:
1406 // case SFX_ITEM_DONTCARE:
1407 // case SFX_ITEM_DISABLED:
1408 default:
1409 eState = PropertyState_AMBIGUOUS_VALUE;
1410 break;
1411 }
1412
1413 // if a item is set, this doesn't mean we want it :)
1414 if( ( PropertyState_DIRECT_VALUE == eState ) )
1415 {
1416 switch( pMap->nWID )
1417 {
1418 // the following items are disabled by changing the
1419 // fill style or the line style. so there is no need
1420 // to export items without names which should be empty
1421 case XATTR_FILLBITMAP:
1422 case XATTR_FILLGRADIENT:
1423 case XATTR_FILLHATCH:
1424 case XATTR_LINEDASH:
1425 {
1426 NameOrIndex* pItem = (NameOrIndex*)rSet.GetItem((sal_uInt16)pMap->nWID);
1427 if( ( pItem == NULL ) || ( pItem->GetName().Len() == 0) )
1428 eState = PropertyState_DEFAULT_VALUE;
1429 }
1430 break;
1431
1432 // #i36115#
1433 // If e.g. the LineStart is on NONE and thus the string has length 0, it still
1434 // may be a hard attribute covering the set LineStart of the parent (Style).
1435 // #i37644#
1436 // same is for fill float transparency
1437 case XATTR_LINEEND:
1438 case XATTR_LINESTART:
1439 case XATTR_FILLFLOATTRANSPARENCE:
1440 {
1441 NameOrIndex* pItem = (NameOrIndex*)rSet.GetItem((sal_uInt16)pMap->nWID);
1442 if( pItem == NULL )
1443 eState = PropertyState_DEFAULT_VALUE;
1444 }
1445 break;
1446 }
1447 }
1448 }
1449 }
1450 return eState;
1451 }
1452 throw UnknownPropertyException();
1453 }
1454
1455 // -----------------------------------------------------------------------------
1456
getPropertyStates(const Sequence<OUString> & aPropertyName)1457 Sequence< PropertyState > SAL_CALL Cell::getPropertyStates( const Sequence< OUString >& aPropertyName ) throw(UnknownPropertyException, RuntimeException)
1458 {
1459 OGuard aGuard( Application::GetSolarMutex() );
1460
1461 if( (mpProperties == 0) || (GetModel() == 0) )
1462 throw DisposedException();
1463
1464 const sal_Int32 nCount = aPropertyName.getLength();
1465
1466 Sequence< PropertyState > aRet( nCount );
1467
1468 const OUString* pNames = aPropertyName.getConstArray();
1469 PropertyState* pState = aRet.getArray();
1470
1471 for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pState++ )
1472 {
1473 try
1474 {
1475 *pState = getPropertyState( *pNames );
1476 }
1477 catch( Exception& )
1478 {
1479 *pState = PropertyState_AMBIGUOUS_VALUE;
1480 }
1481 }
1482
1483 return aRet;
1484 }
1485
1486 // -----------------------------------------------------------------------------
1487
setPropertyToDefault(const OUString & PropertyName)1488 void SAL_CALL Cell::setPropertyToDefault( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
1489 {
1490 OGuard aGuard( Application::GetSolarMutex() );
1491
1492 if( (mpProperties == 0) || (GetModel() == 0) )
1493 throw DisposedException();
1494
1495 const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
1496 if( pMap )
1497 {
1498 switch( pMap->nWID )
1499 {
1500 case OWN_ATTR_FILLBMP_MODE:
1501 {
1502 mpProperties->ClearObjectItem( XATTR_FILLBMP_STRETCH );
1503 mpProperties->ClearObjectItem( XATTR_FILLBMP_TILE );
1504 break;
1505 }
1506 // case OWN_ATTR_HASLEVELS:
1507 case OWN_ATTR_STYLE:
1508 break;
1509
1510 case OWN_ATTR_TABLEBORDER:
1511 {
1512 mpProperties->ClearObjectItem( SDRATTR_TABLE_BORDER_INNER );
1513 mpProperties->ClearObjectItem( SDRATTR_TABLE_BORDER );
1514 break;
1515 }
1516
1517 default:
1518 {
1519 mpProperties->ClearObjectItem( pMap->nWID );
1520 }
1521 }
1522
1523 GetModel()->SetChanged();
1524 return;
1525 }
1526 throw UnknownPropertyException();
1527 }
1528
1529 // -----------------------------------------------------------------------------
1530
getPropertyDefault(const OUString & aPropertyName)1531 Any SAL_CALL Cell::getPropertyDefault( const OUString& aPropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1532 {
1533 OGuard aGuard( Application::GetSolarMutex() );
1534
1535 if( (mpProperties == 0) || (GetModel() == 0) )
1536 throw DisposedException();
1537
1538 const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(aPropertyName);
1539 if( pMap )
1540 {
1541 switch( pMap->nWID )
1542 {
1543 case OWN_ATTR_FILLBMP_MODE:
1544 return Any( BitmapMode_NO_REPEAT );
1545
1546 /*
1547 case OWN_ATTR_HASLEVELS:
1548 return Any( sal_False );
1549 */
1550 case OWN_ATTR_STYLE:
1551 {
1552 Reference< XStyle > xStyle;
1553 return Any( xStyle );
1554 }
1555
1556 case OWN_ATTR_TABLEBORDER:
1557 {
1558 TableBorder aBorder;
1559 return Any( aBorder );
1560 }
1561
1562 default:
1563 {
1564 if( GetModel()->GetItemPool().IsWhich(pMap->nWID) )
1565 {
1566 SfxItemSet aSet( GetModel()->GetItemPool(), pMap->nWID, pMap->nWID);
1567 aSet.Put(GetModel()->GetItemPool().GetDefaultItem(pMap->nWID));
1568 return GetAnyForItem( aSet, pMap );
1569 }
1570 }
1571 }
1572 }
1573 throw UnknownPropertyException();
1574 }
1575
1576 // -----------------------------------------------------------------------------
1577 // XMultiPropertyStates
1578 // -----------------------------------------------------------------------------
1579
setAllPropertiesToDefault()1580 void SAL_CALL Cell::setAllPropertiesToDefault( ) throw (RuntimeException)
1581 {
1582 if( mpProperties )
1583 delete mpProperties;
1584 mpProperties = new sdr::properties::CellProperties( static_cast< SdrTableObj& >( GetObject() ), this );
1585
1586 SdrOutliner& rOutliner = GetObject().ImpGetDrawOutliner();
1587
1588 OutlinerParaObject* pParaObj = GetOutlinerParaObject();
1589 if( pParaObj )
1590 {
1591 rOutliner.SetText(*pParaObj);
1592 sal_uInt32 nParaCount(rOutliner.GetParagraphCount());
1593
1594 if(nParaCount)
1595 {
1596 ESelection aSelection( 0, 0, EE_PARA_ALL, EE_PARA_ALL);
1597 rOutliner.RemoveAttribs(aSelection, sal_True, 0);
1598
1599 OutlinerParaObject* pTemp = rOutliner.CreateParaObject(0, (sal_uInt16)nParaCount);
1600 rOutliner.Clear();
1601
1602 SetOutlinerParaObject(pTemp);
1603 }
1604 }
1605 }
1606
1607 // -----------------------------------------------------------------------------
1608
setPropertiesToDefault(const Sequence<OUString> & aPropertyNames)1609 void SAL_CALL Cell::setPropertiesToDefault( const Sequence< OUString >& aPropertyNames ) throw (UnknownPropertyException, RuntimeException)
1610 {
1611 sal_Int32 nCount = aPropertyNames.getLength();
1612 const OUString* pName = aPropertyNames.getConstArray();
1613
1614 while(nCount--)
1615 setPropertyToDefault( *pName++ );
1616 }
1617
1618 // -----------------------------------------------------------------------------
1619
getPropertyDefaults(const Sequence<OUString> & aPropertyNames)1620 Sequence< Any > SAL_CALL Cell::getPropertyDefaults( const Sequence< OUString >& aPropertyNames ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
1621 {
1622 sal_Int32 nCount = aPropertyNames.getLength();
1623 Sequence< Any > aDefaults( nCount );
1624 Any* pDefaults = aDefaults.getArray();
1625 const OUString* pName = aPropertyNames.getConstArray();
1626
1627 while(nCount--)
1628 *pDefaults++ = getPropertyDefault( *pName++ );
1629
1630 return aDefaults;
1631 }
1632
1633 // -----------------------------------------------------------------------------
1634 // XFastPropertySet
1635 // -----------------------------------------------------------------------------
1636
setFastPropertyValue(sal_Int32 nHandle,const Any & aValue)1637 void SAL_CALL Cell::setFastPropertyValue( sal_Int32 nHandle, const Any& aValue ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
1638 {
1639 (void)aValue;
1640 (void)nHandle;
1641 throw UnknownPropertyException();
1642 }
1643
1644 // -----------------------------------------------------------------------------
1645 // TODO: Refactor this method!
getFastPropertyValue(sal_Int32 nHandle)1646 Any SAL_CALL Cell::getFastPropertyValue( sal_Int32 nHandle ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
1647 {
1648 (void)nHandle;
1649 throw UnknownPropertyException();
1650 }
1651
1652 // -----------------------------------------------------------------------------
1653 // XText
1654 // -----------------------------------------------------------------------------
1655
insertTextContent(const Reference<XTextRange> & xRange,const Reference<XTextContent> & xContent,sal_Bool bAbsorb)1656 void SAL_CALL Cell::insertTextContent( const Reference< XTextRange >& xRange, const Reference< XTextContent >& xContent, sal_Bool bAbsorb ) throw (IllegalArgumentException, RuntimeException)
1657 {
1658 SvxUnoTextBase::insertTextContent( xRange, xContent, bAbsorb );
1659 notifyModified();
1660 }
1661
1662 // -----------------------------------------------------------------------------
1663
removeTextContent(const Reference<XTextContent> & xContent)1664 void SAL_CALL Cell::removeTextContent( const Reference< XTextContent >& xContent ) throw (NoSuchElementException, RuntimeException)
1665 {
1666 SvxUnoTextBase::removeTextContent( xContent );
1667 notifyModified();
1668 }
1669
1670 // -----------------------------------------------------------------------------
1671 // XSimpleText
1672 // -----------------------------------------------------------------------------
1673
createTextCursor()1674 Reference< XTextCursor > SAL_CALL Cell::createTextCursor( ) throw (RuntimeException)
1675 {
1676 return SvxUnoTextBase::createTextCursor();
1677 }
1678
1679 // -----------------------------------------------------------------------------
1680
createTextCursorByRange(const Reference<XTextRange> & aTextPosition)1681 Reference< XTextCursor > SAL_CALL Cell::createTextCursorByRange( const Reference< XTextRange >& aTextPosition ) throw (RuntimeException)
1682 {
1683 return SvxUnoTextBase::createTextCursorByRange( aTextPosition );
1684 }
1685
1686 // -----------------------------------------------------------------------------
1687
insertString(const Reference<XTextRange> & xRange,const OUString & aString,sal_Bool bAbsorb)1688 void SAL_CALL Cell::insertString( const Reference< XTextRange >& xRange, const OUString& aString, sal_Bool bAbsorb ) throw (RuntimeException)
1689 {
1690 SvxUnoTextBase::insertString( xRange, aString, bAbsorb );
1691 notifyModified();
1692 }
1693
1694 // -----------------------------------------------------------------------------
1695
insertControlCharacter(const Reference<XTextRange> & xRange,sal_Int16 nControlCharacter,sal_Bool bAbsorb)1696 void SAL_CALL Cell::insertControlCharacter( const Reference< XTextRange >& xRange, sal_Int16 nControlCharacter, sal_Bool bAbsorb ) throw (IllegalArgumentException, RuntimeException)
1697 {
1698 SvxUnoTextBase::insertControlCharacter( xRange, nControlCharacter, bAbsorb );
1699 notifyModified();
1700 }
1701
1702 // -----------------------------------------------------------------------------
1703 // XTextRange
1704 // -----------------------------------------------------------------------------
1705
getText()1706 Reference< XText > SAL_CALL Cell::getText( ) throw (RuntimeException)
1707 {
1708 return SvxUnoTextBase::getText();
1709 }
1710
1711 // -----------------------------------------------------------------------------
1712
getStart()1713 Reference< XTextRange > SAL_CALL Cell::getStart( ) throw (RuntimeException)
1714 {
1715 return SvxUnoTextBase::getStart();
1716 }
1717
1718 // -----------------------------------------------------------------------------
1719
getEnd()1720 Reference< XTextRange > SAL_CALL Cell::getEnd( ) throw (RuntimeException)
1721 {
1722 return SvxUnoTextBase::getEnd();
1723 }
1724
1725 // -----------------------------------------------------------------------------
1726
getString()1727 OUString SAL_CALL Cell::getString( ) throw (RuntimeException)
1728 {
1729 maSelection.nStartPara = 0xffff;
1730 return SvxUnoTextBase::getString();
1731 }
1732
1733 // -----------------------------------------------------------------------------
1734
setString(const OUString & aString)1735 void SAL_CALL Cell::setString( const OUString& aString ) throw (RuntimeException)
1736 {
1737 SvxUnoTextBase::setString( aString );
1738 notifyModified();
1739 }
1740
1741 // XEventListener
disposing(const EventObject &)1742 void SAL_CALL Cell::disposing( const EventObject& /*Source*/ ) throw (RuntimeException)
1743 {
1744 mxTable.clear();
1745 dispose();
1746 }
1747
getCellName(sal_Int32 nCol,sal_Int32 nRow)1748 static OUString getCellName( sal_Int32 nCol, sal_Int32 nRow )
1749 {
1750 rtl::OUStringBuffer aBuf;
1751
1752 if (nCol < 26*26)
1753 {
1754 if (nCol < 26)
1755 aBuf.append( static_cast<sal_Unicode>( 'A' +
1756 static_cast<sal_uInt16>(nCol)));
1757 else
1758 {
1759 aBuf.append( static_cast<sal_Unicode>( 'A' +
1760 (static_cast<sal_uInt16>(nCol) / 26) - 1));
1761 aBuf.append( static_cast<sal_Unicode>( 'A' +
1762 (static_cast<sal_uInt16>(nCol) % 26)));
1763 }
1764 }
1765 else
1766 {
1767 String aStr;
1768 while (nCol >= 26)
1769 {
1770 sal_Int32 nC = nCol % 26;
1771 aStr += static_cast<sal_Unicode>( 'A' +
1772 static_cast<sal_uInt16>(nC));
1773 nCol = nCol - nC;
1774 nCol = nCol / 26 - 1;
1775 }
1776 aStr += static_cast<sal_Unicode>( 'A' +
1777 static_cast<sal_uInt16>(nCol));
1778 aStr.Reverse();
1779 aBuf.append( aStr);
1780 }
1781 aBuf.append( OUString::valueOf(nRow+1) );
1782 return aBuf.makeStringAndClear();
1783 }
1784
getName()1785 OUString Cell::getName()
1786 {
1787 // todo: optimize!
1788 OUString sName;
1789 if( mxTable.is() ) try
1790 {
1791 Reference< XCell > xThis( static_cast< XCell* >( this ) );
1792
1793 sal_Int32 nRowCount = mxTable->getRowCount();
1794 sal_Int32 nColCount = mxTable->getColumnCount();
1795 for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ )
1796 {
1797 for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ )
1798 {
1799 Reference< XCell > xCell( mxTable->getCellByPosition( nCol, nRow ) );
1800 if( xCell == xThis )
1801 {
1802 return getCellName( nCol, nRow );
1803 }
1804 }
1805 }
1806 }
1807 catch( Exception& )
1808 {
1809 }
1810
1811 return sName;
1812 }
1813
1814 } }
1815
1816