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