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