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