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