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 : #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
21 : #include <com/sun/star/container/XNamed.hpp>
22 : #include <com/sun/star/container/XNameAccess.hpp>
23 : #include <com/sun/star/container/XIndexAccess.hpp>
24 :
25 : #include <vcl/canvastools.hxx>
26 : #include <com/sun/star/style/XStyle.hpp>
27 : #include <com/sun/star/beans/XPropertySet.hpp>
28 : #include <basegfx/polygon/b2dpolygontools.hxx>
29 : #include <basegfx/polygon/b2dpolypolygon.hxx>
30 : #include <basegfx/polygon/b2dpolygon.hxx>
31 : #include <svl/style.hxx>
32 : #include "editeng/editstat.hxx"
33 : #include "editeng/outlobj.hxx"
34 : #include "svx/svdview.hxx"
35 : #include "sdr/properties/textproperties.hxx"
36 : #include "svx/svdotable.hxx"
37 : #include "svx/svdhdl.hxx"
38 : #include "viewcontactoftableobj.hxx"
39 : #include "svx/svdoutl.hxx"
40 : #include "svx/svddrag.hxx"
41 : #include "svx/svdpagv.hxx"
42 : #include "tablemodel.hxx"
43 : #include "cell.hxx"
44 : #include "svx/xflclit.hxx"
45 : #include "tablelayouter.hxx"
46 : #include "svx/svdetc.hxx"
47 : #include "tablehandles.hxx"
48 : #include "editeng/boxitem.hxx"
49 : #include "svx/framelink.hxx"
50 : #include "svx/sdr/table/tabledesign.hxx"
51 : #include "svx/svdundo.hxx"
52 : #include "svx/svdstr.hrc"
53 : #include "svdglob.hxx"
54 : #include "editeng/writingmodeitem.hxx"
55 : #include "editeng/frmdiritem.hxx"
56 : #include "svx/xflhtit.hxx"
57 : #include "svx/xflftrit.hxx"
58 : #include "svx/xfltrit.hxx"
59 :
60 :
61 :
62 : using ::com::sun::star::uno::Any;
63 : using ::com::sun::star::uno::Reference;
64 : using ::com::sun::star::uno::XInterface;
65 : using ::com::sun::star::uno::UNO_QUERY;
66 : using ::com::sun::star::uno::UNO_QUERY_THROW;
67 : using ::com::sun::star::uno::Exception;
68 : using ::com::sun::star::container::XIndexAccess;
69 : using ::com::sun::star::style::XStyle;
70 : using ::com::sun::star::table::XTableRows;
71 : using ::com::sun::star::table::XTableColumns;
72 : using ::com::sun::star::table::XTable;
73 : using ::com::sun::star::beans::XPropertySet;
74 : using ::com::sun::star::util::XModifyBroadcaster;
75 : using sdr::properties::TextProperties;
76 : using sdr::properties::BaseProperties;
77 : using namespace ::com::sun::star;
78 : using namespace ::com::sun::star::text;
79 : using namespace ::com::sun::star::container;
80 : using namespace ::com::sun::star::style;
81 :
82 : namespace sdr { namespace table {
83 :
84 : class TableProperties : public TextProperties
85 : {
86 : protected:
87 : // create a new itemset
88 : SfxItemSet& CreateObjectSpecificItemSet(SfxItemPool& rPool) SAL_OVERRIDE;
89 :
90 : public:
91 : // basic constructor
92 : TableProperties(SdrObject& rObj );
93 :
94 : // constructor for copying, but using new object
95 : TableProperties(const TableProperties& rProps, SdrObject& rObj );
96 :
97 : // destructor
98 : virtual ~TableProperties();
99 :
100 : // Clone() operator, normally just calls the local copy constructor
101 : BaseProperties& Clone(SdrObject& rObj) const SAL_OVERRIDE;
102 :
103 : virtual void ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem) SAL_OVERRIDE;
104 : };
105 :
106 78 : TableProperties::TableProperties(SdrObject& rObj)
107 78 : : TextProperties(rObj)
108 : {
109 78 : }
110 :
111 0 : TableProperties::TableProperties(const TableProperties& rProps, SdrObject& rObj)
112 0 : : TextProperties(rProps, rObj)
113 : {
114 0 : }
115 :
116 156 : TableProperties::~TableProperties()
117 : {
118 156 : }
119 :
120 0 : BaseProperties& TableProperties::Clone(SdrObject& rObj) const
121 : {
122 0 : return *(new TableProperties(*this, rObj));
123 : }
124 :
125 876 : void TableProperties::ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem)
126 : {
127 876 : if( nWhich == SDRATTR_TEXTDIRECTION )
128 870 : AttributeProperties::ItemChange( nWhich, pNewItem );
129 : else
130 6 : TextProperties::ItemChange( nWhich, pNewItem );
131 876 : }
132 :
133 : // create a new itemset
134 78 : SfxItemSet& TableProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool)
135 : {
136 : return *(new SfxItemSet(rPool,
137 :
138 : // range from SdrAttrObj
139 : SDRATTR_START, SDRATTR_SHADOW_LAST,
140 : SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST,
141 : SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION,
142 :
143 : // range for SdrTableObj
144 : SDRATTR_TABLE_FIRST, SDRATTR_TABLE_LAST,
145 :
146 : // range from SdrTextObj
147 : EE_ITEMS_START, EE_ITEMS_END,
148 :
149 : // end
150 78 : 0, 0));
151 : }
152 :
153 36 : class TableObjectGeoData : public SdrTextObjGeoData
154 : {
155 : public:
156 : Rectangle maLogicRect;
157 : };
158 :
159 78 : TableStyleSettings::TableStyleSettings()
160 : : mbUseFirstRow(true)
161 : , mbUseLastRow(false)
162 : , mbUseFirstColumn(false)
163 : , mbUseLastColumn(false)
164 : , mbUseRowBanding(true)
165 78 : , mbUseColumnBanding(false)
166 : {
167 78 : }
168 :
169 36 : TableStyleSettings::TableStyleSettings( const TableStyleSettings& rStyle )
170 : {
171 36 : (*this) = rStyle;
172 36 : }
173 :
174 72 : TableStyleSettings& TableStyleSettings::operator=(const TableStyleSettings& rStyle)
175 : {
176 72 : mbUseFirstRow = rStyle.mbUseFirstRow;
177 72 : mbUseLastRow = rStyle.mbUseLastRow;
178 72 : mbUseFirstColumn = rStyle.mbUseFirstColumn;
179 72 : mbUseLastColumn = rStyle.mbUseLastColumn;
180 72 : mbUseRowBanding = rStyle.mbUseRowBanding;
181 72 : mbUseColumnBanding = rStyle.mbUseColumnBanding;
182 72 : return *this;
183 : }
184 :
185 0 : bool TableStyleSettings::operator==( const TableStyleSettings& rStyle ) const
186 : {
187 : return
188 0 : (mbUseFirstRow == rStyle.mbUseFirstRow) &&
189 0 : (mbUseLastRow == rStyle.mbUseLastRow) &&
190 0 : (mbUseFirstColumn == rStyle.mbUseFirstColumn) &&
191 0 : (mbUseLastColumn == rStyle.mbUseLastColumn) &&
192 0 : (mbUseRowBanding == rStyle.mbUseRowBanding) &&
193 0 : (mbUseColumnBanding == rStyle.mbUseColumnBanding);
194 : }
195 :
196 :
197 :
198 : class SdrTableObjImpl : public TableDesignUser, public ::cppu::WeakImplHelper1< ::com::sun::star::util::XModifyListener >
199 : {
200 : public:
201 : CellRef mxActiveCell;
202 : TableModelRef mxTable;
203 : SdrTableObj* mpTableObj;
204 : TableLayouter* mpLayouter;
205 : CellPos maEditPos;
206 : TableStyleSettings maTableStyle;
207 : Reference< XIndexAccess > mxTableStyle;
208 : bool mbModifyPending;
209 :
210 : void SetModel(SdrModel* pOldModel, SdrModel* pNewModel);
211 :
212 : CellRef getCell( const CellPos& rPos ) const;
213 : void LayoutTable( Rectangle& rArea, bool bFitWidth, bool bFitHeight );
214 :
215 : bool ApplyCellStyles();
216 : void UpdateCells( Rectangle& rArea );
217 :
218 : SdrTableObjImpl();
219 : virtual ~SdrTableObjImpl();
220 :
221 : void init( SdrTableObj* pTable, sal_Int32 nColumns, sal_Int32 nRows );
222 : void dispose();
223 :
224 : sal_Int32 getColumnCount() const;
225 : sal_Int32 getRowCount() const;
226 :
227 : void DragEdge( bool mbHorizontal, int nEdge, sal_Int32 nOffset );
228 :
229 : SdrTableObjImpl& operator=( const SdrTableObjImpl& rSource );
230 :
231 : // XModifyListener
232 : virtual void SAL_CALL modified( const ::com::sun::star::lang::EventObject& aEvent ) throw (::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
233 :
234 : // XEventListener
235 : virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw (::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
236 :
237 : void update();
238 :
239 : void connectTableStyle();
240 : void disconnectTableStyle();
241 : virtual bool isInUse() SAL_OVERRIDE;
242 : private:
243 : static SdrTableObjImpl* lastLayoutTable;
244 : static Rectangle lastLayoutRectangle;
245 : static bool lastLayoutFitWidth;
246 : static bool lastLayoutFitHeight;
247 : static WritingMode lastLayoutMode;
248 : static sal_Int32 lastRowCount;
249 : static sal_Int32 lastColCount;
250 : };
251 :
252 : SdrTableObjImpl* SdrTableObjImpl::lastLayoutTable = NULL;
253 217 : Rectangle SdrTableObjImpl::lastLayoutRectangle;
254 : bool SdrTableObjImpl::lastLayoutFitWidth;
255 : bool SdrTableObjImpl::lastLayoutFitHeight;
256 : WritingMode SdrTableObjImpl::lastLayoutMode;
257 : sal_Int32 SdrTableObjImpl::lastRowCount;
258 : sal_Int32 SdrTableObjImpl::lastColCount;
259 :
260 78 : SdrTableObjImpl::SdrTableObjImpl()
261 : : mpTableObj( 0 )
262 : , mpLayouter( 0 )
263 78 : , mbModifyPending( false )
264 : {
265 78 : }
266 :
267 :
268 :
269 234 : SdrTableObjImpl::~SdrTableObjImpl()
270 : {
271 78 : if( lastLayoutTable == this )
272 10 : lastLayoutTable = NULL;
273 156 : }
274 :
275 :
276 :
277 78 : void SdrTableObjImpl::init( SdrTableObj* pTable, sal_Int32 nColumns, sal_Int32 nRows )
278 : {
279 78 : mpTableObj = pTable;
280 78 : mxTable = new TableModel( pTable );
281 78 : mxTable->init( nColumns, nRows );
282 78 : Reference< XModifyListener > xListener( static_cast< ::com::sun::star::util::XModifyListener* >(this) );
283 78 : mxTable->addModifyListener( xListener );
284 78 : mpLayouter = new TableLayouter( mxTable );
285 78 : LayoutTable( mpTableObj->aRect, true, true );
286 78 : mpTableObj->maLogicRect = mpTableObj->aRect;
287 78 : }
288 :
289 :
290 :
291 0 : SdrTableObjImpl& SdrTableObjImpl::operator=( const SdrTableObjImpl& rSource )
292 : {
293 0 : if (this != &rSource)
294 : {
295 0 : disconnectTableStyle();
296 :
297 0 : if( mpLayouter )
298 : {
299 0 : delete mpLayouter;
300 0 : mpLayouter = 0;
301 : }
302 :
303 0 : if( mxTable.is() )
304 : {
305 0 : Reference< XModifyListener > xListener( static_cast< ::com::sun::star::util::XModifyListener* >(this) );
306 0 : mxTable->removeModifyListener( xListener );
307 0 : mxTable->dispose();
308 0 : mxTable.clear();
309 : }
310 :
311 0 : maTableStyle = rSource.maTableStyle;
312 :
313 0 : mxTable = new TableModel( mpTableObj, rSource.mxTable );
314 0 : mpLayouter = new TableLayouter( mxTable );
315 0 : Reference< XModifyListener > xListener( static_cast< ::com::sun::star::util::XModifyListener* >(this) );
316 0 : mxTable->addModifyListener( xListener );
317 0 : mxTableStyle = rSource.mxTableStyle;
318 0 : ApplyCellStyles();
319 0 : mpTableObj->aRect = mpTableObj->maLogicRect;
320 0 : LayoutTable( mpTableObj->aRect, false, false );
321 :
322 0 : connectTableStyle();
323 : }
324 0 : return *this;
325 : }
326 :
327 :
328 :
329 0 : void SdrTableObjImpl::SetModel(SdrModel* /*pOldModel*/, SdrModel* pNewModel)
330 : {
331 : // try to find new table style
332 0 : disconnectTableStyle();
333 :
334 0 : Reference< XIndexAccess > xNewTableStyle;
335 0 : if( mxTableStyle.is() ) try
336 : {
337 0 : const OUString sStyleName( Reference< XNamed >( mxTableStyle, UNO_QUERY_THROW )->getName() );
338 :
339 0 : Reference< XStyleFamiliesSupplier > xSFS( pNewModel->getUnoModel(), UNO_QUERY_THROW );
340 0 : Reference< XNameAccess > xFamilyNameAccess( xSFS->getStyleFamilies(), UNO_QUERY_THROW );
341 0 : const OUString sFamilyName( "table" );
342 0 : Reference< XNameAccess > xTableFamilyAccess( xFamilyNameAccess->getByName( sFamilyName ), UNO_QUERY_THROW );
343 :
344 0 : if( xTableFamilyAccess->hasByName( sStyleName ) )
345 : {
346 : // found table style with the same name
347 0 : xTableFamilyAccess->getByName( sStyleName ) >>= xNewTableStyle;
348 : }
349 : else
350 : {
351 : // copy or?
352 0 : Reference< XIndexAccess > xIndexAccess( xTableFamilyAccess, UNO_QUERY_THROW );
353 0 : xIndexAccess->getByIndex( 0 ) >>= xNewTableStyle;
354 0 : }
355 : }
356 0 : catch( Exception& )
357 : {
358 : OSL_FAIL("svx::SdrTableObjImpl::SetModel(), exception caught!");
359 : }
360 :
361 0 : mxTableStyle = xNewTableStyle;
362 :
363 0 : connectTableStyle();
364 0 : update();
365 0 : }
366 :
367 :
368 :
369 216 : bool SdrTableObjImpl::ApplyCellStyles()
370 : {
371 216 : if( !mxTable.is() || !mxTableStyle.is() )
372 162 : return false;
373 :
374 54 : bool bChanges = false;
375 :
376 54 : const sal_Int32 nColCount = getColumnCount();
377 54 : const sal_Int32 nRowCount = getRowCount();
378 :
379 54 : const TableStyleSettings& rStyle = maTableStyle;
380 :
381 54 : CellPos aPos;
382 156 : for( aPos.mnRow = 0; aPos.mnRow < nRowCount; ++aPos.mnRow )
383 : {
384 102 : const bool bFirstRow = (aPos.mnRow == 0) && rStyle.mbUseFirstRow;
385 102 : const bool bLastRow = (aPos.mnRow == nRowCount-1) && rStyle.mbUseLastRow;
386 :
387 248 : for( aPos.mnCol = 0; aPos.mnCol < nColCount; ++aPos.mnCol )
388 : {
389 146 : Reference< XStyle > xStyle;
390 :
391 : // first and last row win first, if used and available
392 146 : if( bFirstRow )
393 : {
394 82 : mxTableStyle->getByIndex(first_row_style) >>= xStyle;
395 : }
396 64 : else if( bLastRow )
397 : {
398 0 : mxTableStyle->getByIndex(last_row_style) >>= xStyle;
399 : }
400 :
401 146 : if( !xStyle.is() )
402 : {
403 : // next come first and last column, if used and available
404 64 : if( rStyle.mbUseFirstColumn && (aPos.mnCol == 0) )
405 : {
406 0 : mxTableStyle->getByIndex(first_column_style) >>= xStyle;
407 : }
408 64 : else if( rStyle.mbUseLastColumn && (aPos.mnCol == nColCount-1) )
409 : {
410 0 : mxTableStyle->getByIndex(last_column_style) >>= xStyle;
411 : }
412 : }
413 :
414 146 : if( !xStyle.is() && rStyle.mbUseRowBanding )
415 : {
416 32 : if( (aPos.mnRow & 1) == 0 )
417 : {
418 16 : mxTableStyle->getByIndex(even_rows_style) >>= xStyle;
419 : }
420 : else
421 : {
422 16 : mxTableStyle->getByIndex(odd_rows_style) >>= xStyle;
423 : }
424 : }
425 :
426 146 : if( !xStyle.is() && rStyle.mbUseColumnBanding )
427 : {
428 0 : if( (aPos.mnCol & 1) == 0 )
429 : {
430 0 : mxTableStyle->getByIndex(even_columns_style) >>= xStyle;
431 : }
432 : else
433 : {
434 0 : mxTableStyle->getByIndex(odd_columns_style) >>= xStyle;
435 : }
436 : }
437 :
438 146 : if( !xStyle.is() )
439 : {
440 : // use default cell style if non found yet
441 48 : mxTableStyle->getByIndex(body_style) >>= xStyle;
442 : }
443 :
444 :
445 146 : if( xStyle.is() )
446 : {
447 146 : SfxUnoStyleSheet* pStyle = SfxUnoStyleSheet::getUnoStyleSheet(xStyle);
448 :
449 146 : if( pStyle )
450 : {
451 146 : CellRef xCell( getCell( aPos ) );
452 146 : if( xCell.is() && ( xCell->GetStyleSheet() != pStyle ) )
453 : {
454 52 : bChanges = true;
455 52 : xCell->SetStyleSheet( pStyle, true );
456 146 : }
457 : }
458 : }
459 146 : }
460 : }
461 :
462 54 : return bChanges;
463 : }
464 :
465 :
466 :
467 78 : void SdrTableObjImpl::dispose()
468 : {
469 78 : disconnectTableStyle();
470 78 : mxTableStyle.clear();
471 :
472 78 : if( mpLayouter )
473 : {
474 78 : delete mpLayouter;
475 78 : mpLayouter = 0;
476 : }
477 :
478 78 : if( mxTable.is() )
479 : {
480 78 : Reference< XModifyListener > xListener( static_cast< ::com::sun::star::util::XModifyListener* >(this) );
481 78 : mxTable->removeModifyListener( xListener );
482 78 : mxTable->dispose();
483 78 : mxTable.clear();
484 : }
485 78 : }
486 :
487 :
488 :
489 0 : void SdrTableObjImpl::DragEdge( bool mbHorizontal, int nEdge, sal_Int32 nOffset )
490 : {
491 0 : if( (nEdge >= 0) && mxTable.is()) try
492 : {
493 0 : const OUString sSize( "Size" );
494 0 : if( mbHorizontal )
495 : {
496 0 : if( (nEdge >= 0) && (nEdge <= getRowCount()) )
497 : {
498 0 : sal_Int32 nHeight = mpLayouter->getRowHeight( (!nEdge)?nEdge:(nEdge-1) );
499 0 : if(nEdge==0)
500 0 : nHeight -= nOffset;
501 : else
502 0 : nHeight += nOffset;
503 0 : Reference< XIndexAccess > xRows( mxTable->getRows(), UNO_QUERY_THROW );
504 0 : Reference< XPropertySet > xRowSet( xRows->getByIndex( (!nEdge)?nEdge:(nEdge-1) ), UNO_QUERY_THROW );
505 0 : xRowSet->setPropertyValue( sSize, Any( nHeight ) );
506 : }
507 : }
508 : else
509 : {
510 : /*
511 : fixes fdo#59889 and resizing of table in edge dragging
512 : Total vertical edges in a NxN table is N+1, indexed from 0 to N and total Columns is N, indexed from 0 to N-1
513 : In LTR table vertical edge responsible for dragging of column x(x=0 to N-1) is, Edge x+1
514 : But in RTL table vertical edge responisble for dragging of column x(x=0 to N-1, but from right to left)is, Edge x
515 : In LTR table dragging of edge 0(for RTL table edge N) does nothing.
516 : */
517 : //Todo: Implement Dragging functionality for leftmost edge of table.
518 0 : if( (nEdge >= 0) && (nEdge <= getColumnCount()) )
519 : {
520 0 : const bool bRTL = !mpTableObj? false: (mpTableObj->GetWritingMode() == WritingMode_RL_TB);
521 : sal_Int32 nWidth;
522 0 : if(bRTL)
523 : {
524 0 : nWidth = mpLayouter->getColumnWidth( nEdge );
525 : }
526 : else
527 : {
528 0 : nWidth = mpLayouter->getColumnWidth( (!nEdge)?nEdge:(nEdge-1) );
529 : }
530 0 : Reference< XIndexAccess > xCols( mxTable->getColumns(), UNO_QUERY_THROW );
531 0 : nWidth += nOffset;
532 0 : if(bRTL && nEdge<getColumnCount())
533 : {
534 0 : Reference< XPropertySet > xColSet( xCols->getByIndex( nEdge ), UNO_QUERY_THROW );
535 0 : xColSet->setPropertyValue( sSize, Any( nWidth ) );
536 : }
537 0 : else if(!bRTL && nEdge>0)
538 : {
539 0 : Reference< XPropertySet > xColSet( xCols->getByIndex( (nEdge-1) ), UNO_QUERY_THROW );
540 0 : xColSet->setPropertyValue( sSize, Any( nWidth ) );
541 : }
542 : /* To prevent the table resizing on edge dragging */
543 0 : if( nEdge > 0 && nEdge < mxTable->getColumnCount() )
544 : {
545 :
546 0 : if( bRTL )
547 0 : nEdge--;
548 :
549 0 : if( (bRTL && (nEdge >= 0)) || (!bRTL && (nEdge < mxTable->getColumnCount())) )
550 : {
551 0 : nWidth = mpLayouter->getColumnWidth( nEdge );
552 0 : nWidth = std::max( (sal_Int32)(nWidth - nOffset), (sal_Int32)0 );
553 :
554 0 : Reference< XPropertySet > xColSet( xCols->getByIndex( nEdge ), UNO_QUERY_THROW );
555 0 : xColSet->setPropertyValue( sSize, Any( nWidth ) );
556 : }
557 0 : }
558 : }
559 0 : }
560 : }
561 0 : catch( Exception& )
562 : {
563 : OSL_FAIL( "svx::SdrTableObjImpl::DragEdge(), exception caught!" );
564 : }
565 0 : }
566 :
567 :
568 : // XModifyListener
569 :
570 :
571 174 : void SAL_CALL SdrTableObjImpl::modified( const ::com::sun::star::lang::EventObject& /*aEvent*/ ) throw (::com::sun::star::uno::RuntimeException, std::exception)
572 : {
573 174 : update();
574 174 : }
575 :
576 216 : void SdrTableObjImpl::update()
577 : {
578 : // source can be the table model itself or the assigned table template
579 216 : TableModelNotifyGuard aGuard( mxTable.get() );
580 216 : if( mpTableObj )
581 : {
582 216 : if( (maEditPos.mnRow >= getRowCount()) || (maEditPos.mnCol >= getColumnCount()) || (getCell( maEditPos ) != mxActiveCell) )
583 : {
584 150 : if(maEditPos.mnRow >= getRowCount())
585 0 : maEditPos.mnRow = getRowCount()-1;
586 :
587 150 : if(maEditPos.mnCol >= getColumnCount())
588 0 : maEditPos.mnCol = getColumnCount()-1;
589 :
590 150 : mpTableObj->setActiveCell( maEditPos );
591 : }
592 :
593 216 : ApplyCellStyles();
594 :
595 216 : mpTableObj->aRect = mpTableObj->maLogicRect;
596 216 : LayoutTable( mpTableObj->aRect, false, false );
597 :
598 216 : mpTableObj->SetRectsDirty();
599 216 : mpTableObj->ActionChanged();
600 216 : mpTableObj->BroadcastObjectChange();
601 216 : }
602 216 : }
603 :
604 :
605 :
606 6 : void SdrTableObjImpl::connectTableStyle()
607 : {
608 6 : if( mxTableStyle.is() )
609 : {
610 6 : Reference< XModifyBroadcaster > xBroadcaster( mxTableStyle, UNO_QUERY );
611 6 : if( xBroadcaster.is() )
612 : {
613 6 : Reference< XModifyListener > xListener( static_cast< ::com::sun::star::util::XModifyListener* >(this) );
614 6 : xBroadcaster->addModifyListener( xListener );
615 6 : }
616 : }
617 6 : }
618 :
619 :
620 :
621 84 : void SdrTableObjImpl::disconnectTableStyle()
622 : {
623 84 : if( mxTableStyle.is() )
624 : {
625 6 : Reference< XModifyBroadcaster > xBroadcaster( mxTableStyle, UNO_QUERY );
626 6 : if( xBroadcaster.is() )
627 : {
628 6 : Reference< XModifyListener > xListener( static_cast< ::com::sun::star::util::XModifyListener* >(this) );
629 6 : xBroadcaster->removeModifyListener( xListener );
630 6 : }
631 : }
632 84 : }
633 :
634 :
635 :
636 0 : bool SdrTableObjImpl::isInUse()
637 : {
638 0 : return mpTableObj && mpTableObj->IsInserted();
639 : }
640 :
641 :
642 : // XEventListener
643 :
644 :
645 0 : void SAL_CALL SdrTableObjImpl::disposing( const ::com::sun::star::lang::EventObject& /*Source*/ ) throw (::com::sun::star::uno::RuntimeException, std::exception)
646 : {
647 0 : mxActiveCell.clear();
648 0 : mxTable.clear();
649 0 : if( mpLayouter )
650 : {
651 0 : delete mpLayouter;
652 0 : mpLayouter = 0;
653 : }
654 0 : mpTableObj = 0;
655 0 : }
656 :
657 :
658 :
659 6266 : CellRef SdrTableObjImpl::getCell( const CellPos& rPos ) const
660 : {
661 6266 : CellRef xCell;
662 6266 : if( mxTable.is() ) try
663 : {
664 6266 : xCell.set( dynamic_cast< Cell* >( mxTable->getCellByPosition( rPos.mnCol, rPos.mnRow ).get() ) );
665 : }
666 0 : catch( Exception& )
667 : {
668 : OSL_FAIL( "svx::SdrTableObjImpl::getCell(), exception caught!" );
669 : }
670 6266 : return xCell;
671 : }
672 :
673 :
674 :
675 11942 : sal_Int32 SdrTableObjImpl::getColumnCount() const
676 : {
677 11942 : return mxTable.is() ? mxTable->getColumnCount() : 0;
678 : }
679 :
680 :
681 :
682 11140 : sal_Int32 SdrTableObjImpl::getRowCount() const
683 : {
684 11140 : return mxTable.is() ? mxTable->getRowCount() : 0;
685 : }
686 :
687 :
688 :
689 10666 : void SdrTableObjImpl::LayoutTable( Rectangle& rArea, bool bFitWidth, bool bFitHeight )
690 : {
691 10666 : if( mpLayouter && mpTableObj->GetModel() )
692 : {
693 : // Optimization: SdrTableObj::SetChanged() can call this very often, repeatedly
694 : // with the same settings, noticeably increasing load time. Skip if already done.
695 10666 : WritingMode writingMode = mpTableObj->GetWritingMode();
696 31920 : if( lastLayoutTable != this || lastLayoutRectangle != rArea
697 10128 : || lastLayoutFitWidth != bFitWidth || lastLayoutFitHeight != bFitHeight
698 10038 : || lastLayoutMode != writingMode
699 10038 : || lastRowCount != getRowCount()
700 20674 : || lastColCount != getColumnCount() )
701 : {
702 662 : lastLayoutTable = this;
703 662 : lastLayoutRectangle = rArea;
704 662 : lastLayoutFitWidth = bFitWidth;
705 662 : lastLayoutFitHeight = bFitHeight;
706 662 : lastLayoutMode = writingMode;
707 662 : lastRowCount = getRowCount();
708 662 : lastColCount = getColumnCount();
709 662 : TableModelNotifyGuard aGuard( mxTable.get() );
710 662 : mpLayouter->LayoutTable( rArea, bFitWidth, bFitHeight );
711 : }
712 : }
713 10666 : }
714 :
715 :
716 :
717 12 : void SdrTableObjImpl::UpdateCells( Rectangle& rArea )
718 : {
719 12 : if( mpLayouter && mxTable.is() )
720 : {
721 12 : TableModelNotifyGuard aGuard( mxTable.get() );
722 12 : mpLayouter->updateCells( rArea );
723 12 : mxTable->setModified(true);
724 : }
725 12 : }
726 :
727 :
728 : // BaseProperties section
729 :
730 :
731 78 : sdr::properties::BaseProperties* SdrTableObj::CreateObjectSpecificProperties()
732 : {
733 78 : return new TableProperties(*this);
734 : }
735 :
736 :
737 : // DrawContact section
738 :
739 :
740 78 : sdr::contact::ViewContact* SdrTableObj::CreateObjectSpecificViewContact()
741 : {
742 78 : return new sdr::contact::ViewContactOfTableObj(*this);
743 : }
744 :
745 :
746 :
747 96120 : TYPEINIT1(SdrTableObj,SdrTextObj);
748 :
749 :
750 :
751 78 : SdrTableObj::SdrTableObj(SdrModel* _pModel)
752 : {
753 78 : pModel = _pModel;
754 78 : init( 1, 1 );
755 78 : }
756 :
757 :
758 :
759 0 : SdrTableObj::SdrTableObj(SdrModel* _pModel, const ::Rectangle& rNewRect, sal_Int32 nColumns, sal_Int32 nRows)
760 : : SdrTextObj( rNewRect )
761 0 : , maLogicRect( rNewRect )
762 : {
763 0 : pModel = _pModel;
764 :
765 0 : if( nColumns <= 0 )
766 0 : nColumns = 1;
767 :
768 0 : if( nRows <= 0 )
769 0 : nRows = 1;
770 :
771 0 : init( nColumns, nRows );
772 0 : }
773 :
774 :
775 :
776 78 : void SdrTableObj::init( sal_Int32 nColumns, sal_Int32 nRows )
777 : {
778 78 : bClosedObj = true;
779 :
780 78 : mpImpl = new SdrTableObjImpl;
781 78 : mpImpl->acquire();
782 78 : mpImpl->init( this, nColumns, nRows );
783 78 : }
784 :
785 :
786 :
787 234 : SdrTableObj::~SdrTableObj()
788 : {
789 78 : mpImpl->dispose();
790 78 : mpImpl->release();
791 156 : }
792 :
793 :
794 : // table stuff
795 :
796 :
797 1006 : Reference< XTable > SdrTableObj::getTable() const
798 : {
799 1006 : return Reference< XTable >( mpImpl->mxTable.get() );
800 : }
801 :
802 :
803 :
804 0 : bool SdrTableObj::isValid( const CellPos& rPos ) const
805 : {
806 0 : return (rPos.mnCol >= 0) && (rPos.mnCol < mpImpl->getColumnCount()) && (rPos.mnRow >= 0) && (rPos.mnRow < mpImpl->getRowCount());
807 : }
808 :
809 :
810 :
811 2 : CellPos SdrTableObj::getFirstCell() const
812 : {
813 2 : return CellPos( 0,0 );
814 : }
815 :
816 :
817 :
818 2 : CellPos SdrTableObj::getLastCell() const
819 : {
820 2 : CellPos aPos;
821 2 : if( mpImpl->mxTable.is() )
822 : {
823 2 : aPos.mnCol = mpImpl->getColumnCount()-1;
824 2 : aPos.mnRow = mpImpl->getRowCount()-1;
825 : }
826 2 : return aPos;
827 : }
828 :
829 :
830 :
831 0 : CellPos SdrTableObj::getLeftCell( const CellPos& rPos, bool bEdgeTravel ) const
832 : {
833 0 : switch( GetWritingMode() )
834 : {
835 : default:
836 : case WritingMode_LR_TB:
837 0 : return getPreviousCell( rPos, bEdgeTravel );
838 : case WritingMode_RL_TB:
839 0 : return getNextCell( rPos, bEdgeTravel );
840 : case WritingMode_TB_RL:
841 0 : return getPreviousRow( rPos, bEdgeTravel );
842 : }
843 : }
844 :
845 :
846 :
847 0 : CellPos SdrTableObj::getRightCell( const CellPos& rPos, bool bEdgeTravel ) const
848 : {
849 0 : switch( GetWritingMode() )
850 : {
851 : default:
852 : case WritingMode_LR_TB:
853 0 : return getNextCell( rPos, bEdgeTravel );
854 : case WritingMode_RL_TB:
855 0 : return getPreviousCell( rPos, bEdgeTravel );
856 : case WritingMode_TB_RL:
857 0 : return getNextRow( rPos, bEdgeTravel );
858 : }
859 : }
860 :
861 :
862 :
863 0 : CellPos SdrTableObj::getUpCell( const CellPos& rPos, bool bEdgeTravel ) const
864 : {
865 0 : switch( GetWritingMode() )
866 : {
867 : default:
868 : case WritingMode_LR_TB:
869 : case WritingMode_RL_TB:
870 0 : return getPreviousRow( rPos, bEdgeTravel );
871 : case WritingMode_TB_RL:
872 0 : return getPreviousCell( rPos, bEdgeTravel );
873 : }
874 : }
875 :
876 :
877 :
878 0 : CellPos SdrTableObj::getDownCell( const CellPos& rPos, bool bEdgeTravel ) const
879 : {
880 0 : switch( GetWritingMode() )
881 : {
882 : default:
883 : case WritingMode_LR_TB:
884 : case WritingMode_RL_TB:
885 0 : return getNextRow( rPos, bEdgeTravel );
886 : case WritingMode_TB_RL:
887 0 : return getNextCell( rPos, bEdgeTravel );
888 : }
889 : }
890 :
891 :
892 :
893 0 : CellPos SdrTableObj::getPreviousCell( const CellPos& rPos, bool bEdgeTravel ) const
894 : {
895 0 : CellPos aPos( rPos );
896 0 : if( mpImpl )
897 : {
898 0 : CellRef xCell( mpImpl->getCell( aPos ) );
899 0 : if( xCell.is() && xCell->isMerged() )
900 : {
901 0 : sal_Int32 nTemp = 0;
902 0 : findMergeOrigin( mpImpl->mxTable.get(), aPos.mnCol, aPos.mnRow, aPos.mnCol, nTemp );
903 : }
904 :
905 0 : if( aPos.mnCol > 0 )
906 : {
907 0 : --aPos.mnCol;
908 : }
909 :
910 0 : else if( bEdgeTravel && (aPos.mnRow > 0) )
911 : {
912 0 : aPos.mnCol = mpImpl->mxTable->getColumnCount()-1;
913 0 : --aPos.mnRow;
914 0 : }
915 : }
916 0 : return aPos;
917 : }
918 :
919 :
920 :
921 0 : CellPos SdrTableObj::getNextCell( const CellPos& rPos, bool bEdgeTravel ) const
922 : {
923 0 : CellPos aPos( rPos );
924 0 : if( mpImpl )
925 : {
926 0 : CellRef xCell( mpImpl->getCell( aPos ) );
927 0 : if( xCell.is() )
928 : {
929 0 : if( xCell->isMerged() )
930 : {
931 0 : findMergeOrigin( mpImpl->mxTable, aPos.mnCol, aPos.mnRow, aPos.mnCol, aPos.mnRow );
932 :
933 0 : xCell = mpImpl->getCell(aPos);
934 :
935 0 : if( xCell.is() )
936 : {
937 0 : aPos.mnCol += xCell->getColumnSpan();
938 0 : aPos.mnRow = rPos.mnRow;
939 : }
940 : }
941 : else
942 : {
943 0 : aPos.mnCol += xCell->getColumnSpan();
944 : }
945 :
946 0 : if( aPos.mnCol < mpImpl->mxTable->getColumnCount() )
947 0 : return aPos;
948 :
949 0 : if( bEdgeTravel && ((aPos.mnRow + 1) < mpImpl->getRowCount()) )
950 : {
951 0 : aPos.mnCol = 0;
952 0 : aPos.mnRow += 1;
953 0 : return aPos;
954 : }
955 0 : }
956 : }
957 :
958 : // last cell reached, no traveling possible
959 0 : return rPos;
960 : }
961 :
962 :
963 :
964 0 : CellPos SdrTableObj::getPreviousRow( const CellPos& rPos, bool bEdgeTravel ) const
965 : {
966 0 : CellPos aPos( rPos );
967 0 : if( mpImpl )
968 : {
969 0 : CellRef xCell( mpImpl->getCell( aPos ) );
970 0 : if( xCell.is() )
971 : {
972 0 : if( xCell->isMerged() )
973 : {
974 0 : sal_Int32 nTemp = 0;
975 0 : findMergeOrigin( mpImpl->mxTable, aPos.mnCol, aPos.mnRow, nTemp, aPos.mnRow );
976 : }
977 : }
978 :
979 0 : if( aPos.mnRow > 0 )
980 : {
981 0 : --aPos.mnRow;
982 : }
983 0 : else if( bEdgeTravel && (aPos.mnCol > 0) )
984 : {
985 0 : aPos.mnRow = mpImpl->mxTable->getRowCount()-1;
986 0 : --aPos.mnCol;
987 0 : }
988 : }
989 0 : return aPos;
990 : }
991 :
992 :
993 :
994 0 : CellPos SdrTableObj::getNextRow( const CellPos& rPos, bool bEdgeTravel ) const
995 : {
996 0 : CellPos aPos( rPos );
997 :
998 0 : if( mpImpl )
999 : {
1000 0 : CellRef xCell( mpImpl->getCell( rPos ) );
1001 0 : if( xCell.is() )
1002 : {
1003 0 : if( xCell->isMerged() )
1004 : {
1005 0 : findMergeOrigin( mpImpl->mxTable, aPos.mnCol, aPos.mnRow, aPos.mnCol, aPos.mnRow );
1006 0 : xCell = mpImpl->getCell(aPos);
1007 0 : aPos.mnCol = rPos.mnCol;
1008 : }
1009 :
1010 0 : if( xCell.is() )
1011 0 : aPos.mnRow += xCell->getRowSpan();
1012 :
1013 0 : if( aPos.mnRow < mpImpl->mxTable->getRowCount() )
1014 0 : return aPos;
1015 :
1016 0 : if( bEdgeTravel && (aPos.mnCol + 1) < mpImpl->mxTable->getColumnCount() )
1017 : {
1018 0 : aPos.mnRow = 0;
1019 0 : aPos.mnCol += 1;
1020 :
1021 0 : while( aPos.mnCol < mpImpl->mxTable->getColumnCount() )
1022 : {
1023 0 : xCell = mpImpl->getCell( aPos );
1024 0 : if( xCell.is() && !xCell->isMerged() )
1025 0 : return aPos;
1026 0 : aPos.mnCol += 1;
1027 : }
1028 : }
1029 0 : }
1030 : }
1031 :
1032 : // last position reached, no more traveling possible
1033 0 : return rPos;
1034 : }
1035 :
1036 :
1037 :
1038 36 : const TableStyleSettings& SdrTableObj::getTableStyleSettings() const
1039 : {
1040 36 : if( mpImpl )
1041 : {
1042 36 : return mpImpl->maTableStyle;
1043 : }
1044 : else
1045 : {
1046 0 : static TableStyleSettings aTmp;
1047 0 : return aTmp;
1048 : }
1049 : }
1050 :
1051 :
1052 :
1053 36 : void SdrTableObj::setTableStyleSettings( const TableStyleSettings& rStyle )
1054 : {
1055 36 : if( mpImpl )
1056 : {
1057 36 : mpImpl->maTableStyle = rStyle;
1058 36 : mpImpl->update();
1059 : }
1060 36 : }
1061 :
1062 :
1063 :
1064 0 : TableHitKind SdrTableObj::CheckTableHit( const Point& rPos, sal_Int32& rnX, sal_Int32& rnY, int nTol ) const
1065 : {
1066 0 : if( !mpImpl || !mpImpl->mxTable.is() )
1067 0 : return SDRTABLEHIT_NONE;
1068 :
1069 0 : rnX = 0;
1070 0 : rnY = 0;
1071 :
1072 0 : const sal_Int32 nColCount = mpImpl->getColumnCount();
1073 0 : const sal_Int32 nRowCount = mpImpl->getRowCount();
1074 :
1075 0 : sal_Int32 nX = rPos.X() + nTol - aRect.Left();
1076 0 : sal_Int32 nY = rPos.Y() + nTol - aRect.Top();
1077 :
1078 0 : if( (nX < 0) || (nX > (aRect.GetWidth() + nTol)) || (nY < 0) || (nY > (aRect.GetHeight() + nTol) ) )
1079 0 : return SDRTABLEHIT_NONE;
1080 :
1081 : // get vertical edge number and check for a hit
1082 0 : const bool bRTL = (GetWritingMode() == WritingMode_RL_TB);
1083 0 : bool bVrtHit = false;
1084 0 : if( nX >= 0 )
1085 : {
1086 0 : if( !bRTL )
1087 : {
1088 0 : while( rnX <= nColCount )
1089 : {
1090 0 : if( nX <= (2*nTol) )
1091 : {
1092 0 : bVrtHit = true;
1093 0 : break;
1094 : }
1095 :
1096 0 : if( rnX == nColCount )
1097 0 : break;
1098 :
1099 0 : nX -= mpImpl->mpLayouter->getColumnWidth( rnX );
1100 0 : if( nX < 0 )
1101 0 : break;
1102 0 : rnX++;
1103 : }
1104 : }
1105 : else
1106 : {
1107 0 : rnX = nColCount;
1108 0 : while( rnX >= 0 )
1109 : {
1110 0 : if( nX <= (2*nTol) )
1111 : {
1112 0 : bVrtHit = true;
1113 0 : break;
1114 : }
1115 :
1116 0 : if( rnX == 0 )
1117 0 : break;
1118 :
1119 0 : rnX--;
1120 0 : nX -= mpImpl->mpLayouter->getColumnWidth( rnX );
1121 0 : if( nX < 0 )
1122 0 : break;
1123 : }
1124 : }
1125 : }
1126 :
1127 : // rnX is now the edge number left to the pointer, if it was hit bHrzHit is also true
1128 :
1129 : // get vertical edge number and check for a hit
1130 0 : bool bHrzHit = false;
1131 0 : if( nY >= 0 )
1132 : {
1133 0 : while( rnY <= nRowCount )
1134 : {
1135 0 : if( nY <= (2*nTol) )
1136 : {
1137 0 : bHrzHit = true;
1138 0 : break;
1139 : }
1140 :
1141 0 : if( rnY == nRowCount )
1142 0 : break;
1143 :
1144 0 : nY -= mpImpl->mpLayouter->getRowHeight(rnY);
1145 0 : if( nY < 0 )
1146 0 : break;
1147 0 : rnY++;
1148 : }
1149 : }
1150 :
1151 : // rnY is now the edge number above the pointer, if it was hit bVrtHit is also true
1152 :
1153 0 : if( bVrtHit && mpImpl->mpLayouter->isEdgeVisible( rnX, rnY, false ) )
1154 0 : return SDRTABLEHIT_VERTICAL_BORDER;
1155 :
1156 0 : if( bHrzHit && mpImpl->mpLayouter->isEdgeVisible( rnX, rnY, true ) )
1157 0 : return SDRTABLEHIT_HORIZONTAL_BORDER;
1158 :
1159 0 : CellRef xCell( mpImpl->getCell( CellPos( rnX, rnY ) ) );
1160 0 : if( xCell.is() && xCell->isMerged() )
1161 0 : findMergeOrigin( mpImpl->mxTable.get(), rnX, rnY, rnX, rnY );
1162 :
1163 0 : if( xCell.is() )
1164 : {
1165 0 : nX += mpImpl->mpLayouter->getColumnWidth( rnX );
1166 : //Fix for fdo#62673 : non-editable cell in table on cell merge
1167 0 : sal_Int32 i=0;
1168 0 : while(xCell.is() && xCell->isMerged())
1169 : {
1170 0 : nX += mpImpl->mpLayouter->getColumnWidth( rnX+i );
1171 0 : i++;
1172 0 : if(rnX+i < nColCount)
1173 0 : xCell=mpImpl->getCell( CellPos( rnX+i, rnY) );
1174 : else
1175 0 : break;
1176 : }
1177 :
1178 0 : if( nX < xCell->GetTextLeftDistance() )
1179 0 : return SDRTABLEHIT_CELL;
1180 : }
1181 :
1182 0 : return SDRTABLEHIT_CELLTEXTAREA;
1183 : }
1184 :
1185 0 : const SfxItemSet& SdrTableObj::GetActiveCellItemSet() const
1186 : {
1187 0 : return getActiveCell()->GetItemSet();
1188 : }
1189 :
1190 :
1191 :
1192 6 : void SdrTableObj::setTableStyle( const Reference< XIndexAccess >& xTableStyle )
1193 : {
1194 6 : if( mpImpl && (mpImpl->mxTableStyle != xTableStyle) )
1195 : {
1196 6 : mpImpl->disconnectTableStyle();
1197 6 : mpImpl->mxTableStyle = xTableStyle;
1198 6 : mpImpl->connectTableStyle();
1199 6 : mpImpl->update();
1200 : }
1201 6 : }
1202 :
1203 :
1204 :
1205 0 : const Reference< XIndexAccess >& SdrTableObj::getTableStyle() const
1206 : {
1207 0 : if( mpImpl )
1208 : {
1209 0 : return mpImpl->mxTableStyle;
1210 : }
1211 : else
1212 : {
1213 0 : static Reference< XIndexAccess > aTmp;
1214 0 : return aTmp;
1215 : }
1216 : }
1217 :
1218 :
1219 : // text stuff
1220 :
1221 :
1222 : /** returns the currently active text. */
1223 106 : SdrText* SdrTableObj::getActiveText() const
1224 : {
1225 106 : return dynamic_cast< SdrText* >( getActiveCell().get() );
1226 : }
1227 :
1228 :
1229 :
1230 : /** returns the nth available text. */
1231 830 : SdrText* SdrTableObj::getText( sal_Int32 nIndex ) const
1232 : {
1233 830 : if( mpImpl->mxTable.is() )
1234 : {
1235 830 : const sal_Int32 nColCount = mpImpl->getColumnCount();
1236 830 : if( nColCount )
1237 : {
1238 830 : CellPos aPos( nIndex % nColCount, nIndex / nColCount );
1239 :
1240 830 : CellRef xCell( mpImpl->getCell( aPos ) );
1241 830 : return dynamic_cast< SdrText* >( xCell.get() );
1242 : }
1243 : }
1244 0 : return 0;
1245 : }
1246 :
1247 :
1248 :
1249 : /** returns the number of texts available for this object. */
1250 18 : sal_Int32 SdrTableObj::getTextCount() const
1251 : {
1252 18 : if( mpImpl->mxTable.is() )
1253 : {
1254 18 : const sal_Int32 nColCount = mpImpl->getColumnCount();
1255 18 : const sal_Int32 nRowCount = mpImpl->getRowCount();
1256 :
1257 18 : return nColCount * nRowCount;
1258 : }
1259 : else
1260 : {
1261 0 : return 0;
1262 : }
1263 : }
1264 :
1265 :
1266 :
1267 : /** changes the current active text */
1268 0 : void SdrTableObj::setActiveText( sal_Int32 nIndex )
1269 : {
1270 0 : if( mpImpl && mpImpl->mxTable.is() )
1271 : {
1272 0 : const sal_Int32 nColCount = mpImpl->mxTable->getColumnCount();
1273 0 : if( nColCount )
1274 : {
1275 0 : CellPos aPos( nIndex % nColCount, nIndex / nColCount );
1276 0 : if( isValid( aPos ) )
1277 0 : setActiveCell( aPos );
1278 : }
1279 : }
1280 0 : }
1281 :
1282 :
1283 :
1284 : /** returns the index of the text that contains the given point or -1 */
1285 0 : sal_Int32 SdrTableObj::CheckTextHit(const Point& rPnt) const
1286 : {
1287 0 : if( mpImpl && mpImpl->mxTable.is() )
1288 : {
1289 0 : CellPos aPos;
1290 0 : if( CheckTableHit( rPnt, aPos.mnCol, aPos.mnRow, 0 ) == SDRTABLEHIT_CELLTEXTAREA )
1291 0 : return aPos.mnRow * mpImpl->mxTable->getColumnCount() + aPos.mnCol;
1292 : }
1293 :
1294 0 : return 0;
1295 : }
1296 :
1297 5074 : SdrOutliner* SdrTableObj::GetCellTextEditOutliner( const Cell& rCell ) const
1298 : {
1299 5074 : if( mpImpl && (mpImpl->getCell( mpImpl->maEditPos ).get() == &rCell) )
1300 662 : return pEdtOutl;
1301 : else
1302 4412 : return 0;
1303 : }
1304 :
1305 0 : const TableLayouter& SdrTableObj::getTableLayouter() const
1306 : {
1307 : assert(mpImpl && mpImpl->mpLayouter && "getTableLayouter() error: no mpImpl or mpLayouter (!)");
1308 0 : return *(mpImpl->mpLayouter);
1309 : }
1310 :
1311 0 : bool SdrTableObj::IsAutoGrowHeight() const
1312 : {
1313 0 : return true;
1314 : }
1315 :
1316 0 : bool SdrTableObj::IsAutoGrowWidth() const
1317 : {
1318 0 : return true;
1319 : }
1320 :
1321 6 : bool SdrTableObj::HasText() const
1322 : {
1323 6 : return true;
1324 : }
1325 :
1326 0 : bool SdrTableObj::IsTextEditActive( const CellPos& rPos )
1327 : {
1328 0 : return pEdtOutl && mpImpl && (rPos == mpImpl->maEditPos);
1329 : }
1330 :
1331 :
1332 :
1333 0 : void SdrTableObj::onEditOutlinerStatusEvent( EditStatus* pEditStatus )
1334 : {
1335 0 : if( (pEditStatus->GetStatusWord() & EE_STAT_TEXTHEIGHTCHANGED) && mpImpl && mpImpl->mpLayouter )
1336 : {
1337 0 : Rectangle aRect0( aRect );
1338 0 : aRect = maLogicRect;
1339 0 : mpImpl->LayoutTable( aRect, false, false );
1340 0 : SetRectsDirty();
1341 0 : ActionChanged();
1342 0 : BroadcastObjectChange();
1343 0 : if( aRect0 != aRect )
1344 0 : SendUserCall(SDRUSERCALL_RESIZE,aRect0);
1345 : }
1346 0 : }
1347 :
1348 :
1349 :
1350 0 : void SdrTableObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
1351 : {
1352 0 : rInfo.bResizeFreeAllowed=true;
1353 0 : rInfo.bResizePropAllowed=true;
1354 0 : rInfo.bRotateFreeAllowed=false;
1355 0 : rInfo.bRotate90Allowed =false;
1356 0 : rInfo.bMirrorFreeAllowed=false;
1357 0 : rInfo.bMirror45Allowed =false;
1358 0 : rInfo.bMirror90Allowed =false;
1359 :
1360 : // allow transparence
1361 0 : rInfo.bTransparenceAllowed = true;
1362 :
1363 : // gradient depends on fillstyle
1364 0 : drawing::FillStyle eFillStyle = static_cast<const XFillStyleItem&>(GetObjectItem(XATTR_FILLSTYLE)).GetValue();
1365 0 : rInfo.bGradientAllowed = (eFillStyle == drawing::FillStyle_GRADIENT);
1366 0 : rInfo.bShearAllowed =false;
1367 0 : rInfo.bEdgeRadiusAllowed=false;
1368 0 : rInfo.bCanConvToPath =false;
1369 0 : rInfo.bCanConvToPoly =false;
1370 0 : rInfo.bCanConvToPathLineToArea=false;
1371 0 : rInfo.bCanConvToPolyLineToArea=false;
1372 0 : rInfo.bCanConvToContour = false;
1373 0 : }
1374 :
1375 :
1376 :
1377 430 : sal_uInt16 SdrTableObj::GetObjIdentifier() const
1378 : {
1379 430 : return static_cast<sal_uInt16>(OBJ_TABLE);
1380 : }
1381 :
1382 :
1383 :
1384 90 : void SdrTableObj::SetPage(SdrPage* pNewPage)
1385 : {
1386 90 : SdrTextObj::SetPage(pNewPage);
1387 90 : }
1388 :
1389 :
1390 :
1391 12 : void SdrTableObj::SetModel(SdrModel* pNewModel)
1392 : {
1393 12 : SdrModel* pOldModel = GetModel();
1394 12 : if( pNewModel != pOldModel )
1395 : {
1396 0 : SdrTextObj::SetModel(pNewModel);
1397 :
1398 0 : if( mpImpl )
1399 : {
1400 0 : mpImpl->SetModel( pOldModel, pNewModel );
1401 :
1402 0 : if( !maLogicRect.IsEmpty() )
1403 : {
1404 0 : aRect = maLogicRect;
1405 0 : mpImpl->LayoutTable( aRect, false, false );
1406 : }
1407 : }
1408 : }
1409 12 : }
1410 :
1411 :
1412 :
1413 0 : void SdrTableObj::TakeTextRect( SdrOutliner& rOutliner, Rectangle& rTextRect, bool bNoEditText, Rectangle* pAnchorRect, bool bLineWidth ) const
1414 : {
1415 0 : if( mpImpl )
1416 0 : TakeTextRect( mpImpl->maEditPos, rOutliner, rTextRect, bNoEditText, pAnchorRect, bLineWidth );
1417 0 : }
1418 :
1419 :
1420 :
1421 0 : void SdrTableObj::TakeTextRect( const CellPos& rPos, SdrOutliner& rOutliner, Rectangle& rTextRect, bool bNoEditText, Rectangle* pAnchorRect, bool /*bLineWidth*/ ) const
1422 : {
1423 0 : if( !mpImpl )
1424 0 : return;
1425 :
1426 0 : CellRef xCell( mpImpl->getCell( rPos ) );
1427 0 : if( !xCell.is() )
1428 0 : return;
1429 :
1430 0 : Rectangle aAnkRect;
1431 0 : TakeTextAnchorRect( rPos, aAnkRect );
1432 :
1433 0 : SdrTextVertAdjust eVAdj=xCell->GetTextVerticalAdjust();
1434 :
1435 0 : sal_uIntPtr nStat0=rOutliner.GetControlWord();
1436 0 : Size aNullSize;
1437 0 : nStat0 |= EE_CNTRL_AUTOPAGESIZE;
1438 0 : rOutliner.SetControlWord(nStat0);
1439 0 : rOutliner.SetMinAutoPaperSize(aNullSize);
1440 0 : rOutliner.SetMaxAutoPaperSize(aAnkRect.GetSize());
1441 0 : rOutliner.SetPaperSize(aAnkRect.GetSize());
1442 :
1443 : // #103516# New try with _BLOCK for hor and ver after completely
1444 : // supporting full width for vertical text.
1445 : // if( SDRTEXTHORZADJUST_BLOCK == eHAdj && !IsVerticalWriting())
1446 : // {
1447 0 : rOutliner.SetMinAutoPaperSize(Size(aAnkRect.GetWidth(), 0));
1448 : // }
1449 : // else if(SDRTEXTVERTADJUST_BLOCK == eVAdj && IsVerticalWriting())
1450 : // {
1451 : // rOutliner.SetMinAutoPaperSize(Size(0, aAnkRect.GetHeight()));
1452 : // }
1453 :
1454 :
1455 :
1456 : // set text at outliner, maybe from edit outliner
1457 0 : OutlinerParaObject* pPara= xCell->GetOutlinerParaObject();
1458 0 : if (pEdtOutl && !bNoEditText && mpImpl->mxActiveCell == xCell )
1459 0 : pPara=pEdtOutl->CreateParaObject();
1460 :
1461 0 : if (pPara)
1462 : {
1463 0 : const bool bHitTest = pModel && (&pModel->GetHitTestOutliner() == &rOutliner);
1464 :
1465 0 : const SdrTextObj* pTestObj = rOutliner.GetTextObj();
1466 0 : if( !pTestObj || !bHitTest || (pTestObj != this) || (pTestObj->GetOutlinerParaObject() != xCell->GetOutlinerParaObject()) )
1467 : {
1468 0 : if( bHitTest ) // #i33696# take back fix #i27510#
1469 0 : rOutliner.SetTextObj( this );
1470 :
1471 0 : rOutliner.SetUpdateMode(true);
1472 0 : rOutliner.SetText(*pPara);
1473 : }
1474 : }
1475 : else
1476 : {
1477 0 : rOutliner.SetTextObj( NULL );
1478 : }
1479 :
1480 0 : if (pEdtOutl && !bNoEditText && pPara && mpImpl->mxActiveCell == xCell )
1481 0 : delete pPara;
1482 :
1483 0 : rOutliner.SetUpdateMode(true);
1484 0 : rOutliner.SetControlWord(nStat0);
1485 :
1486 0 : Point aTextPos(aAnkRect.TopLeft());
1487 0 : Size aTextSiz(rOutliner.GetPaperSize());
1488 0 : if (eVAdj==SDRTEXTVERTADJUST_CENTER || eVAdj==SDRTEXTVERTADJUST_BOTTOM)
1489 : {
1490 0 : long nFreeHgt=aAnkRect.GetHeight()-aTextSiz.Height();
1491 0 : if (eVAdj==SDRTEXTVERTADJUST_CENTER)
1492 0 : aTextPos.Y()+=nFreeHgt/2;
1493 0 : if (eVAdj==SDRTEXTVERTADJUST_BOTTOM)
1494 0 : aTextPos.Y()+=nFreeHgt;
1495 : }
1496 :
1497 0 : if (pAnchorRect)
1498 0 : *pAnchorRect=aAnkRect;
1499 :
1500 0 : rTextRect=Rectangle(aTextPos,aTextSiz);
1501 : }
1502 :
1503 :
1504 :
1505 32278 : const CellRef& SdrTableObj::getActiveCell() const
1506 : {
1507 32278 : if( mpImpl )
1508 : {
1509 32278 : if( !mpImpl->mxActiveCell.is() )
1510 : {
1511 0 : CellPos aPos;
1512 0 : const_cast< SdrTableObj* >(this)->setActiveCell( aPos );
1513 : }
1514 32278 : return mpImpl->mxActiveCell;
1515 : }
1516 : else
1517 : {
1518 0 : static CellRef xCell;
1519 0 : return xCell;
1520 : }
1521 : }
1522 :
1523 :
1524 :
1525 2 : sal_Int32 SdrTableObj::getColumnCount() const
1526 : {
1527 2 : return mpImpl ? mpImpl->getColumnCount() : 0;
1528 : }
1529 :
1530 :
1531 :
1532 150 : void SdrTableObj::setActiveCell( const CellPos& rPos )
1533 : {
1534 150 : if( mpImpl && mpImpl->mxTable.is() ) try
1535 : {
1536 150 : mpImpl->mxActiveCell.set( dynamic_cast< Cell* >( mpImpl->mxTable->getCellByPosition( rPos.mnCol, rPos.mnRow ).get() ) );
1537 150 : if( mpImpl->mxActiveCell.is() && mpImpl->mxActiveCell->isMerged() )
1538 : {
1539 0 : CellPos aOrigin;
1540 0 : findMergeOrigin( mpImpl->mxTable.get(), rPos.mnCol, rPos.mnRow, aOrigin.mnCol, aOrigin.mnRow );
1541 0 : mpImpl->mxActiveCell.set( dynamic_cast< Cell* >( mpImpl->mxTable->getCellByPosition( aOrigin.mnCol, aOrigin.mnRow ).get() ) );
1542 0 : mpImpl->maEditPos = aOrigin;
1543 : }
1544 : else
1545 : {
1546 150 : mpImpl->maEditPos = rPos;
1547 : }
1548 : }
1549 0 : catch( Exception& )
1550 : {
1551 : OSL_FAIL("SdrTableObj::setActiveCell(), exception caught!");
1552 : }
1553 150 : }
1554 :
1555 :
1556 :
1557 0 : void SdrTableObj::getActiveCellPos( CellPos& rPos ) const
1558 : {
1559 0 : rPos = mpImpl->maEditPos;
1560 0 : }
1561 :
1562 :
1563 :
1564 0 : void SdrTableObj::getCellBounds( const CellPos& rPos, ::Rectangle& rCellRect )
1565 : {
1566 0 : if( mpImpl )
1567 : {
1568 0 : CellRef xCell( mpImpl->getCell( rPos ) );
1569 0 : if( xCell.is() )
1570 0 : rCellRect = xCell->getCellRect();
1571 : }
1572 0 : }
1573 :
1574 :
1575 :
1576 0 : void SdrTableObj::TakeTextAnchorRect(Rectangle& rAnchorRect) const
1577 : {
1578 0 : if( mpImpl )
1579 0 : TakeTextAnchorRect( mpImpl->maEditPos, rAnchorRect );
1580 0 : }
1581 :
1582 :
1583 :
1584 0 : void SdrTableObj::TakeTextAnchorRect( const CellPos& rPos, Rectangle& rAnchorRect ) const
1585 : {
1586 0 : Rectangle aAnkRect(aRect);
1587 :
1588 0 : if( mpImpl )
1589 : {
1590 0 : CellRef xCell( mpImpl->getCell( rPos ) );
1591 0 : if( xCell.is() )
1592 0 : xCell->TakeTextAnchorRect( aAnkRect );
1593 : }
1594 :
1595 0 : ImpJustifyRect(aAnkRect);
1596 0 : rAnchorRect=aAnkRect;
1597 0 : }
1598 :
1599 :
1600 :
1601 0 : void SdrTableObj::TakeTextEditArea(Size* pPaperMin, Size* pPaperMax, Rectangle* pViewInit, Rectangle* pViewMin) const
1602 : {
1603 0 : if( mpImpl )
1604 0 : TakeTextEditArea( mpImpl->maEditPos, pPaperMin, pPaperMax, pViewInit, pViewMin );
1605 0 : }
1606 :
1607 :
1608 :
1609 0 : void SdrTableObj::TakeTextEditArea( const CellPos& rPos, Size* pPaperMin, Size* pPaperMax, Rectangle* pViewInit, Rectangle* pViewMin ) const
1610 : {
1611 0 : Size aPaperMin,aPaperMax;
1612 0 : Rectangle aViewInit;
1613 0 : TakeTextAnchorRect( rPos, aViewInit );
1614 :
1615 0 : Size aAnkSiz(aViewInit.GetSize());
1616 0 : aAnkSiz.Width()--; aAnkSiz.Height()--; // weil GetSize() ein draufaddiert
1617 :
1618 0 : Size aMaxSiz(aAnkSiz.Width(),1000000);
1619 0 : if (pModel!=NULL)
1620 : {
1621 0 : Size aTmpSiz(pModel->GetMaxObjSize());
1622 0 : if (aTmpSiz.Height()!=0)
1623 0 : aMaxSiz.Height()=aTmpSiz.Height();
1624 : }
1625 :
1626 0 : CellRef xCell( mpImpl->getCell( rPos ) );
1627 0 : SdrTextVertAdjust eVAdj = xCell.is() ? xCell->GetTextVerticalAdjust() : SDRTEXTVERTADJUST_TOP;
1628 :
1629 0 : aPaperMax=aMaxSiz;
1630 :
1631 0 : aPaperMin.Width() = aAnkSiz.Width();
1632 :
1633 0 : if (pViewMin!=NULL)
1634 : {
1635 0 : *pViewMin=aViewInit;
1636 0 : long nYFree=aAnkSiz.Height()-aPaperMin.Height();
1637 :
1638 0 : if (eVAdj==SDRTEXTVERTADJUST_TOP)
1639 : {
1640 0 : pViewMin->Bottom()-=nYFree;
1641 : }
1642 0 : else if (eVAdj==SDRTEXTVERTADJUST_BOTTOM)
1643 : {
1644 0 : pViewMin->Top()+=nYFree;
1645 : }
1646 : else
1647 : {
1648 0 : pViewMin->Top()+=nYFree/2;
1649 0 : pViewMin->Bottom()=pViewMin->Top()+aPaperMin.Height();
1650 : }
1651 : }
1652 :
1653 :
1654 0 : if(IsVerticalWriting())
1655 0 : aPaperMin.Width() = 0;
1656 : else
1657 0 : aPaperMin.Height() = 0;
1658 :
1659 0 : if (pPaperMin!=NULL) *pPaperMin=aPaperMin;
1660 0 : if (pPaperMax!=NULL) *pPaperMax=aPaperMax;
1661 0 : if (pViewInit!=NULL) *pViewInit=aViewInit;
1662 0 : }
1663 :
1664 :
1665 :
1666 0 : sal_uInt16 SdrTableObj::GetOutlinerViewAnchorMode() const
1667 : {
1668 0 : EVAnchorMode eRet=ANCHOR_TOP_LEFT;
1669 0 : CellRef xCell( getActiveCell() );
1670 0 : if( xCell.is() )
1671 : {
1672 0 : SdrTextVertAdjust eV=xCell->GetTextVerticalAdjust();
1673 :
1674 : {
1675 0 : if (eV==SDRTEXTVERTADJUST_TOP)
1676 : {
1677 0 : eRet=ANCHOR_TOP_LEFT;
1678 : }
1679 0 : else if (eV==SDRTEXTVERTADJUST_BOTTOM)
1680 : {
1681 0 : eRet=ANCHOR_BOTTOM_LEFT;
1682 : }
1683 : else
1684 : {
1685 0 : eRet=ANCHOR_VCENTER_LEFT;
1686 : }
1687 : }
1688 : }
1689 0 : return (sal_uInt16)eRet;
1690 : }
1691 :
1692 :
1693 :
1694 2636 : OutlinerParaObject* SdrTableObj::GetEditOutlinerParaObject() const
1695 : {
1696 2636 : return SdrTextObj::GetEditOutlinerParaObject();
1697 : }
1698 :
1699 24 : OUString SdrTableObj::TakeObjNameSingul() const
1700 : {
1701 24 : OUStringBuffer sName(ImpGetResStr(STR_ObjNameSingulTable));
1702 :
1703 48 : OUString aName(GetName());
1704 24 : if (!aName.isEmpty())
1705 : {
1706 12 : sName.append(' ');
1707 12 : sName.append('\'');
1708 12 : sName.append(aName);
1709 12 : sName.append('\'');
1710 : }
1711 :
1712 48 : return sName.makeStringAndClear();
1713 : }
1714 :
1715 :
1716 :
1717 0 : OUString SdrTableObj::TakeObjNamePlural() const
1718 : {
1719 0 : return ImpGetResStr(STR_ObjNamePluralTable);
1720 : }
1721 :
1722 :
1723 :
1724 0 : SdrTableObj* SdrTableObj::Clone() const
1725 : {
1726 0 : return CloneHelper< SdrTableObj >();
1727 : }
1728 :
1729 0 : SdrTableObj& SdrTableObj::operator=(const SdrTableObj& rObj)
1730 : {
1731 0 : if( this == &rObj )
1732 0 : return *this;
1733 : // call parent
1734 0 : SdrObject::operator=(rObj);
1735 :
1736 0 : TableModelNotifyGuard aGuard( mpImpl ? mpImpl->mxTable.get() : 0 );
1737 :
1738 0 : maLogicRect = rObj.maLogicRect;
1739 0 : aRect = rObj.aRect;
1740 0 : aGeo = rObj.aGeo;
1741 0 : eTextKind = rObj.eTextKind;
1742 0 : bTextFrame = rObj.bTextFrame;
1743 0 : aTextSize = rObj.aTextSize;
1744 0 : bTextSizeDirty = rObj.bTextSizeDirty;
1745 0 : bNoShear = rObj.bNoShear;
1746 0 : bNoRotate = rObj.bNoRotate;
1747 0 : bNoMirror = rObj.bNoMirror;
1748 0 : bDisableAutoWidthOnDragging = rObj.bDisableAutoWidthOnDragging;
1749 :
1750 0 : if (mpImpl && rObj.mpImpl)
1751 0 : *mpImpl = *rObj.mpImpl;
1752 0 : return *this;
1753 : }
1754 :
1755 :
1756 :
1757 0 : basegfx::B2DPolyPolygon SdrTableObj::TakeXorPoly() const
1758 : {
1759 0 : return SdrTextObj::TakeXorPoly();
1760 : }
1761 :
1762 :
1763 :
1764 0 : basegfx::B2DPolyPolygon SdrTableObj::TakeContour() const
1765 : {
1766 0 : return SdrTextObj::TakeContour();
1767 : }
1768 :
1769 :
1770 :
1771 30 : const Rectangle& SdrTableObj::GetSnapRect() const
1772 : {
1773 30 : return aRect;
1774 : }
1775 :
1776 :
1777 :
1778 90 : void SdrTableObj::NbcSetSnapRect(const Rectangle& rRect)
1779 : {
1780 90 : NbcSetLogicRect( rRect );
1781 90 : }
1782 :
1783 :
1784 :
1785 32 : const Rectangle& SdrTableObj::GetLogicRect() const
1786 : {
1787 32 : return maLogicRect;
1788 : }
1789 :
1790 :
1791 :
1792 0 : void SdrTableObj::RecalcSnapRect()
1793 : {
1794 0 : }
1795 :
1796 :
1797 :
1798 0 : sal_uInt32 SdrTableObj::GetSnapPointCount() const
1799 : {
1800 0 : return SdrTextObj::GetSnapPointCount();
1801 : }
1802 :
1803 :
1804 :
1805 :
1806 0 : Point SdrTableObj::GetSnapPoint(sal_uInt32 i) const
1807 : {
1808 0 : return SdrTextObj::GetSnapPoint(i);
1809 : }
1810 :
1811 :
1812 :
1813 0 : bool SdrTableObj::BegTextEdit(SdrOutliner& rOutl)
1814 : {
1815 0 : if( pEdtOutl != NULL )
1816 0 : return false;
1817 :
1818 0 : pEdtOutl=&rOutl;
1819 :
1820 0 : mbInEditMode = true;
1821 :
1822 0 : rOutl.Init( OUTLINERMODE_TEXTOBJECT );
1823 0 : rOutl.SetRefDevice( pModel->GetRefDevice() );
1824 :
1825 0 : bool bUpdMerk=rOutl.GetUpdateMode();
1826 0 : if (bUpdMerk) rOutl.SetUpdateMode(false);
1827 0 : Size aPaperMin;
1828 0 : Size aPaperMax;
1829 0 : Rectangle aEditArea;
1830 0 : TakeTextEditArea(&aPaperMin,&aPaperMax,&aEditArea,NULL);
1831 :
1832 0 : rOutl.SetMinAutoPaperSize(aPaperMin);
1833 0 : rOutl.SetMaxAutoPaperSize(aPaperMax);
1834 0 : rOutl.SetPaperSize(aPaperMax);
1835 :
1836 0 : if (bUpdMerk) rOutl.SetUpdateMode(true);
1837 :
1838 0 : sal_uIntPtr nStat=rOutl.GetControlWord();
1839 0 : nStat |= EE_CNTRL_AUTOPAGESIZE;
1840 0 : nStat &=~EE_CNTRL_STRETCHING;
1841 0 : rOutl.SetControlWord(nStat);
1842 :
1843 0 : OutlinerParaObject* pPara = GetOutlinerParaObject();
1844 0 : if(pPara)
1845 0 : rOutl.SetText(*pPara);
1846 :
1847 0 : rOutl.UpdateFields();
1848 0 : rOutl.ClearModifyFlag();
1849 :
1850 0 : return true;
1851 : }
1852 :
1853 :
1854 :
1855 0 : void SdrTableObj::EndTextEdit(SdrOutliner& rOutl)
1856 : {
1857 0 : if(rOutl.IsModified())
1858 : {
1859 0 : if( GetModel() && GetModel()->IsUndoEnabled() )
1860 0 : GetModel()->AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*this) );
1861 :
1862 0 : OutlinerParaObject* pNewText = 0;
1863 0 : Paragraph* p1stPara = rOutl.GetParagraph( 0 );
1864 0 : sal_Int32 nParaAnz = rOutl.GetParagraphCount();
1865 :
1866 0 : if(p1stPara)
1867 : {
1868 0 : if(nParaAnz == 1)
1869 : {
1870 : // if its only one paragraph, check if it is empty
1871 0 : OUString aStr(rOutl.GetText(p1stPara));
1872 0 : if (aStr.isEmpty())
1873 : {
1874 : // gotcha!
1875 0 : nParaAnz = 0;
1876 0 : }
1877 : }
1878 :
1879 : // to remove the grey field background
1880 0 : rOutl.UpdateFields();
1881 :
1882 0 : if(nParaAnz != 0)
1883 : {
1884 : // create new text object
1885 0 : pNewText = rOutl.CreateParaObject( 0, nParaAnz );
1886 : }
1887 : }
1888 0 : SetOutlinerParaObject(pNewText);
1889 : }
1890 :
1891 0 : pEdtOutl = 0;
1892 0 : rOutl.Clear();
1893 0 : sal_uInt32 nStat = rOutl.GetControlWord();
1894 0 : nStat &= ~EE_CNTRL_AUTOPAGESIZE;
1895 0 : rOutl.SetControlWord(nStat);
1896 :
1897 0 : mbInEditMode = false;
1898 0 : }
1899 :
1900 :
1901 :
1902 1740 : OutlinerParaObject* SdrTableObj::GetOutlinerParaObject() const
1903 : {
1904 1740 : CellRef xCell( getActiveCell() );
1905 1740 : if( xCell.is() )
1906 1740 : return xCell->GetOutlinerParaObject();
1907 : else
1908 0 : return 0;
1909 : }
1910 :
1911 :
1912 :
1913 0 : void SdrTableObj::NbcSetOutlinerParaObject( OutlinerParaObject* pTextObject)
1914 : {
1915 0 : CellRef xCell( getActiveCell() );
1916 0 : if( xCell.is() )
1917 : {
1918 0 : if( pModel )
1919 : {
1920 : // Update HitTestOutliner
1921 0 : const SdrTextObj* pTestObj = pModel->GetHitTestOutliner().GetTextObj();
1922 0 : if( pTestObj && pTestObj->GetOutlinerParaObject() == xCell->GetOutlinerParaObject() )
1923 0 : pModel->GetHitTestOutliner().SetTextObj( NULL );
1924 : }
1925 :
1926 0 : xCell->SetOutlinerParaObject( pTextObject );
1927 :
1928 0 : SetTextSizeDirty();
1929 0 : NbcAdjustTextFrameWidthAndHeight();
1930 0 : }
1931 0 : }
1932 :
1933 :
1934 :
1935 102 : void SdrTableObj::NbcSetLogicRect(const Rectangle& rRect)
1936 : {
1937 102 : maLogicRect=rRect;
1938 102 : ImpJustifyRect(maLogicRect);
1939 102 : const bool bWidth = maLogicRect.getWidth() != aRect.getWidth();
1940 102 : const bool bHeight = maLogicRect.getHeight() != aRect.getHeight();
1941 102 : aRect=maLogicRect;
1942 102 : NbcAdjustTextFrameWidthAndHeight( !bHeight, !bWidth );
1943 102 : SetRectsDirty();
1944 102 : }
1945 :
1946 :
1947 :
1948 :
1949 0 : void SdrTableObj::AdjustToMaxRect( const Rectangle& rMaxRect, bool /* bShrinkOnly = false */ )
1950 : {
1951 0 : Rectangle aAdjustRect( rMaxRect );
1952 0 : aAdjustRect.setHeight( GetLogicRect().getHeight() );
1953 0 : SetLogicRect( aAdjustRect );
1954 0 : }
1955 :
1956 :
1957 :
1958 12 : void SdrTableObj::NbcMove(const Size& rSiz)
1959 : {
1960 12 : MoveRect(maLogicRect,rSiz);
1961 12 : SdrTextObj::NbcMove( rSiz );
1962 12 : if( mpImpl )
1963 12 : mpImpl->UpdateCells( aRect );
1964 12 : }
1965 :
1966 :
1967 :
1968 0 : void SdrTableObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
1969 : {
1970 0 : Rectangle aOldRect( maLogicRect );
1971 0 : ResizeRect(maLogicRect,rRef,xFact,yFact);
1972 :
1973 0 : aRect = maLogicRect;
1974 0 : NbcAdjustTextFrameWidthAndHeight( maLogicRect.GetHeight() == aOldRect.GetHeight(), maLogicRect.GetWidth() == aOldRect.GetWidth() );
1975 0 : SetRectsDirty();
1976 0 : }
1977 :
1978 :
1979 :
1980 0 : bool SdrTableObj::AdjustTextFrameWidthAndHeight(bool bHgt, bool bWdt)
1981 : {
1982 0 : Rectangle aNeuRect(maLogicRect);
1983 0 : bool bRet=AdjustTextFrameWidthAndHeight(aNeuRect,bHgt,bWdt);
1984 0 : if (bRet)
1985 : {
1986 0 : Rectangle aBoundRect0;
1987 0 : if (pUserCall!=NULL)
1988 0 : aBoundRect0=GetLastBoundRect();
1989 0 : aRect=aNeuRect;
1990 0 : SetRectsDirty();
1991 0 : SetChanged();
1992 0 : BroadcastObjectChange();
1993 0 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1994 : }
1995 0 : return bRet;
1996 : }
1997 :
1998 :
1999 :
2000 102 : bool SdrTableObj::AdjustTextFrameWidthAndHeight(Rectangle& rR, bool bHeight, bool bWidth) const
2001 : {
2002 102 : if((pModel == NULL) || rR.IsEmpty() || !mpImpl || !mpImpl->mxTable.is() )
2003 0 : return false;
2004 :
2005 102 : Rectangle aRectangle( rR );
2006 102 : mpImpl->LayoutTable( aRectangle, !bWidth, !bHeight );
2007 :
2008 102 : if( aRectangle != rR )
2009 : {
2010 84 : rR = aRectangle;
2011 84 : return true;
2012 : }
2013 : else
2014 : {
2015 18 : return false;
2016 : }
2017 : }
2018 :
2019 :
2020 :
2021 0 : void SdrTableObj::NbcReformatText()
2022 : {
2023 0 : NbcAdjustTextFrameWidthAndHeight();
2024 0 : }
2025 :
2026 :
2027 :
2028 0 : void SdrTableObj::ReformatText()
2029 : {
2030 0 : Rectangle aBoundRect0;
2031 0 : if (pUserCall!=NULL)
2032 0 : aBoundRect0=GetLastBoundRect();
2033 0 : NbcReformatText();
2034 0 : SetChanged();
2035 0 : BroadcastObjectChange();
2036 0 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
2037 0 : }
2038 :
2039 :
2040 :
2041 0 : bool SdrTableObj::IsVerticalWriting() const
2042 : {
2043 0 : const SvxWritingModeItem* pModeItem = dynamic_cast< const SvxWritingModeItem* >( &GetObjectItem( SDRATTR_TEXTDIRECTION ) );
2044 0 : return pModeItem && pModeItem->GetValue() == com::sun::star::text::WritingMode_TB_RL;
2045 : }
2046 :
2047 :
2048 :
2049 0 : void SdrTableObj::SetVerticalWriting(bool bVertical )
2050 : {
2051 0 : if( bVertical != IsVerticalWriting() )
2052 : {
2053 0 : SvxWritingModeItem aModeItem( com::sun::star::text::WritingMode_LR_TB, SDRATTR_TEXTDIRECTION );
2054 0 : SetObjectItem( aModeItem );
2055 : }
2056 0 : }
2057 :
2058 :
2059 :
2060 21616 : WritingMode SdrTableObj::GetWritingMode() const
2061 : {
2062 21616 : SfxStyleSheet* pStyle = GetStyleSheet();
2063 21616 : if ( !pStyle )
2064 18016 : return WritingMode_LR_TB;
2065 :
2066 3600 : WritingMode eWritingMode = WritingMode_LR_TB;
2067 3600 : const SfxItemSet &rSet = pStyle->GetItemSet();
2068 : const SfxPoolItem *pItem;
2069 :
2070 3600 : if ( rSet.GetItemState( SDRATTR_TEXTDIRECTION, false, &pItem ) == SfxItemState::SET )
2071 0 : eWritingMode = static_cast< WritingMode >( static_cast< const SvxWritingModeItem * >( pItem )->GetValue() );
2072 :
2073 7200 : if ( ( eWritingMode != WritingMode_TB_RL ) &&
2074 3600 : ( rSet.GetItemState( EE_PARA_WRITINGDIR, false, &pItem ) == SfxItemState::SET ) )
2075 : {
2076 0 : if ( static_cast< const SvxFrameDirectionItem * >( pItem )->GetValue() == FRMDIR_HORI_LEFT_TOP )
2077 0 : eWritingMode = WritingMode_LR_TB;
2078 : else
2079 0 : eWritingMode = WritingMode_RL_TB;
2080 : }
2081 :
2082 3600 : return eWritingMode;
2083 : }
2084 :
2085 :
2086 :
2087 : // gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon
2088 : // with the base geometry and returns TRUE. Otherwise it returns FALSE.
2089 12 : bool SdrTableObj::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& rPolyPolygon ) const
2090 : {
2091 12 : return SdrTextObj::TRGetBaseGeometry( rMatrix, rPolyPolygon );
2092 : }
2093 :
2094 :
2095 :
2096 : // sets the base geometry of the object using infos contained in the homogen 3x3 matrix.
2097 : // If it's an SdrPathObj it will use the provided geometry information. The Polygon has
2098 : // to use (0,0) as upper left and will be scaled to the given size in the matrix.
2099 12 : void SdrTableObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& rPolyPolygon )
2100 : {
2101 12 : SdrTextObj::TRSetBaseGeometry( rMatrix, rPolyPolygon );
2102 12 : }
2103 :
2104 :
2105 :
2106 0 : bool SdrTableObj::IsRealyEdited() const
2107 : {
2108 0 : return pEdtOutl && pEdtOutl->IsModified();
2109 : }
2110 :
2111 :
2112 :
2113 0 : bool SdrTableObj::IsFontwork() const
2114 : {
2115 0 : return false;
2116 : }
2117 :
2118 :
2119 :
2120 0 : sal_uInt32 SdrTableObj::GetHdlCount() const
2121 : {
2122 0 : sal_uInt32 nCount = SdrTextObj::GetHdlCount();
2123 0 : const sal_Int32 nRowCount = mpImpl->getRowCount();
2124 0 : const sal_Int32 nColCount = mpImpl->getColumnCount();
2125 :
2126 0 : if( nRowCount && nColCount )
2127 0 : nCount += nRowCount + nColCount + 2 + 1;
2128 :
2129 0 : return nCount;
2130 : }
2131 :
2132 :
2133 :
2134 0 : void SdrTableObj::AddToHdlList(SdrHdlList& rHdlList) const
2135 : {
2136 0 : const sal_Int32 nRowCount = mpImpl->getRowCount();
2137 0 : const sal_Int32 nColCount = mpImpl->getColumnCount();
2138 :
2139 : // first add row handles
2140 0 : std::vector< TableEdgeHdl* > aRowEdges( nRowCount + 1 );
2141 :
2142 0 : for( sal_Int32 nRow = 0; nRow <= nRowCount; nRow++ )
2143 : {
2144 : sal_Int32 nEdgeMin, nEdgeMax;
2145 0 : const sal_Int32 nEdge = mpImpl->mpLayouter->getHorizontalEdge( nRow, &nEdgeMin, &nEdgeMax );
2146 0 : nEdgeMin -= nEdge;
2147 0 : nEdgeMax -= nEdge;
2148 :
2149 0 : Point aPoint( aRect.TopLeft() );
2150 0 : aPoint.Y() += nEdge;
2151 :
2152 0 : TableEdgeHdl* pHdl= new TableEdgeHdl(aPoint,true,nEdgeMin,nEdgeMax,nColCount+1);
2153 0 : pHdl->SetPointNum( nRow );
2154 0 : rHdlList.AddHdl( pHdl );
2155 0 : aRowEdges[nRow] = pHdl;
2156 : }
2157 :
2158 : // second add column handles
2159 0 : std::vector< TableEdgeHdl* > aColEdges( nColCount + 1 );
2160 :
2161 0 : for( sal_Int32 nCol = 0; nCol <= nColCount; nCol++ )
2162 : {
2163 : sal_Int32 nEdgeMin, nEdgeMax;
2164 0 : const sal_Int32 nEdge = mpImpl->mpLayouter->getVerticalEdge( nCol, &nEdgeMin, &nEdgeMax );
2165 0 : nEdgeMin -= nEdge;
2166 0 : nEdgeMax -= nEdge;
2167 :
2168 0 : Point aPoint( aRect.TopLeft() );
2169 0 : aPoint.X() += nEdge;
2170 :
2171 0 : TableEdgeHdl* pHdl = new TableEdgeHdl(aPoint,false,nEdgeMin,nEdgeMax, nRowCount+1);
2172 0 : pHdl->SetPointNum( nCol );
2173 0 : rHdlList.AddHdl( pHdl );
2174 0 : aColEdges[nCol] = pHdl;
2175 : }
2176 :
2177 : // now add visible edges to row and column handles
2178 0 : if( mpImpl->mpLayouter )
2179 : {
2180 0 : TableLayouter& rLayouter = *mpImpl->mpLayouter;
2181 :
2182 0 : sal_Int32 nY = 0;
2183 :
2184 0 : for( sal_Int32 nRow = 0; nRow <= nRowCount; ++nRow )
2185 : {
2186 0 : const sal_Int32 nRowHeight = (nRow == nRowCount) ? 0 : rLayouter.getRowHeight(nRow);
2187 0 : sal_Int32 nX = 0;
2188 :
2189 0 : for( sal_Int32 nCol = 0; nCol <= nColCount; ++nCol )
2190 : {
2191 0 : const sal_Int32 nColWidth = (nCol == nColCount) ? 0 : rLayouter.getColumnWidth(nCol);
2192 :
2193 0 : if( nRowHeight > 0 )
2194 : {
2195 0 : if( rLayouter.isEdgeVisible( nCol, nRow, false ) )
2196 0 : aColEdges[nCol]->SetEdge( nRow, nY, nY + nRowHeight, (rLayouter.getBorderLine( nCol, nRow, false ) == 0) ? Visible : Invisible);
2197 : }
2198 :
2199 0 : if( nColWidth > 0 )
2200 : {
2201 0 : if( rLayouter.isEdgeVisible( nCol, nRow, true ) )
2202 0 : aRowEdges[nRow]->SetEdge( nCol, nX, nX + nColWidth, (rLayouter.getBorderLine( nCol, nRow, true ) == 0) ? Visible : Invisible);
2203 : }
2204 :
2205 0 : nX += nColWidth;
2206 : }
2207 :
2208 0 : nY += nRowHeight;
2209 : }
2210 : }
2211 :
2212 : // add remaining handles
2213 0 : SdrHdl* pH=0;
2214 0 : rHdlList.AddHdl( pH = new TableBorderHdl( aRect, !IsTextEditActive() ) ); pH->SetMoveOutside( true );
2215 0 : rHdlList.AddHdl( pH = new SdrHdl(aRect.TopLeft(),HDL_UPLFT) ); pH->SetMoveOutside( true );
2216 0 : rHdlList.AddHdl( pH = new SdrHdl(aRect.TopCenter(),HDL_UPPER) ); pH->SetMoveOutside( true );
2217 0 : rHdlList.AddHdl( pH = new SdrHdl(aRect.TopRight(),HDL_UPRGT) ); pH->SetMoveOutside( true );
2218 0 : rHdlList.AddHdl( pH = new SdrHdl(aRect.LeftCenter(),HDL_LEFT) ); pH->SetMoveOutside( true );
2219 0 : rHdlList.AddHdl( pH = new SdrHdl(aRect.RightCenter(),HDL_RIGHT) ); pH->SetMoveOutside( true );
2220 0 : rHdlList.AddHdl( pH = new SdrHdl(aRect.BottomLeft(),HDL_LWLFT) ); pH->SetMoveOutside( true );
2221 0 : rHdlList.AddHdl( pH = new SdrHdl(aRect.BottomCenter(),HDL_LOWER) ); pH->SetMoveOutside( true );
2222 0 : rHdlList.AddHdl( pH = new SdrHdl(aRect.BottomRight(),HDL_LWRGT) ); pH->SetMoveOutside( true );
2223 :
2224 0 : const size_t nHdlCount = rHdlList.GetHdlCount();
2225 0 : for( size_t nHdl = 0; nHdl < nHdlCount; ++nHdl )
2226 0 : rHdlList.GetHdl(nHdl)->SetObj((SdrObject*)this);
2227 0 : }
2228 :
2229 :
2230 :
2231 0 : SdrHdl* SdrTableObj::GetHdl(sal_uInt32 nHdlNum) const
2232 : {
2233 : // #i73248#
2234 : // Warn the user that this is ineffective and show alternatives. Should not be used at all.
2235 : OSL_FAIL("SdrTableObj::GetHdl(): ineffective, use AddToHdlList instead (!)");
2236 :
2237 : // to have an alternative, get single handle using the ineffective way
2238 0 : SdrHdl* pRetval = 0;
2239 0 : SdrHdlList aLocalList(0);
2240 0 : AddToHdlList(aLocalList);
2241 0 : const size_t nHdlCount(aLocalList.GetHdlCount());
2242 :
2243 0 : if(nHdlCount && static_cast<size_t>(nHdlNum) < nHdlCount)
2244 : {
2245 : // remove and remember. The other created handles will be deleted again with the
2246 : // destruction of the local list
2247 0 : pRetval = aLocalList.RemoveHdl(nHdlNum);
2248 : }
2249 :
2250 0 : return pRetval;
2251 : }
2252 :
2253 :
2254 : // Draging
2255 :
2256 0 : bool SdrTableObj::hasSpecialDrag() const
2257 : {
2258 0 : return true;
2259 : }
2260 :
2261 0 : bool SdrTableObj::beginSpecialDrag(SdrDragStat& rDrag) const
2262 : {
2263 0 : const SdrHdl* pHdl = rDrag.GetHdl();
2264 0 : const SdrHdlKind eHdl((pHdl == NULL) ? HDL_MOVE : pHdl->GetKind());
2265 :
2266 0 : switch( eHdl )
2267 : {
2268 : case HDL_UPLFT:
2269 : case HDL_UPPER:
2270 : case HDL_UPRGT:
2271 : case HDL_LEFT:
2272 : case HDL_RIGHT:
2273 : case HDL_LWLFT:
2274 : case HDL_LOWER:
2275 : case HDL_LWRGT:
2276 : case HDL_MOVE:
2277 : {
2278 0 : break;
2279 : }
2280 :
2281 : case HDL_USER:
2282 : {
2283 0 : rDrag.SetEndDragChangesAttributes(false);
2284 0 : rDrag.SetNoSnap(true);
2285 0 : break;
2286 : }
2287 :
2288 : default:
2289 : {
2290 0 : return false;
2291 : }
2292 : }
2293 :
2294 0 : return true;
2295 : }
2296 :
2297 0 : bool SdrTableObj::applySpecialDrag(SdrDragStat& rDrag)
2298 : {
2299 0 : bool bRet(true);
2300 0 : const SdrHdl* pHdl = rDrag.GetHdl();
2301 0 : const SdrHdlKind eHdl((pHdl == NULL) ? HDL_MOVE : pHdl->GetKind());
2302 :
2303 0 : switch( eHdl )
2304 : {
2305 : case HDL_UPLFT:
2306 : case HDL_UPPER:
2307 : case HDL_UPRGT:
2308 : case HDL_LEFT:
2309 : case HDL_RIGHT:
2310 : case HDL_LWLFT:
2311 : case HDL_LOWER:
2312 : case HDL_LWRGT:
2313 : {
2314 0 : const Rectangle aNewRectangle(ImpDragCalcRect(rDrag));
2315 :
2316 0 : if(aNewRectangle != aRect)
2317 : {
2318 0 : NbcSetLogicRect(aNewRectangle);
2319 : }
2320 :
2321 0 : break;
2322 : }
2323 :
2324 : case HDL_MOVE:
2325 : {
2326 0 : NbcMove( Size( rDrag.GetDX(), rDrag.GetDY() ) );
2327 0 : break;
2328 : }
2329 :
2330 : case HDL_USER:
2331 : {
2332 0 : rDrag.SetEndDragChangesAttributes(false);
2333 0 : rDrag.SetNoSnap(true);
2334 0 : const TableEdgeHdl* pEdgeHdl = dynamic_cast< const TableEdgeHdl* >( pHdl );
2335 :
2336 0 : if( pEdgeHdl )
2337 : {
2338 0 : if( GetModel() && IsInserted() )
2339 : {
2340 0 : rDrag.SetEndDragChangesAttributes(true);
2341 : }
2342 :
2343 0 : mpImpl->DragEdge( pEdgeHdl->IsHorizontalEdge(), pEdgeHdl->GetPointNum(), pEdgeHdl->GetValidDragOffset( rDrag ) );
2344 : }
2345 0 : break;
2346 : }
2347 :
2348 : default:
2349 : {
2350 0 : bRet = false;
2351 : }
2352 : }
2353 :
2354 0 : return bRet;
2355 : }
2356 :
2357 0 : OUString SdrTableObj::getSpecialDragComment(const SdrDragStat& rDrag) const
2358 : {
2359 0 : return SdrTextObj::getSpecialDragComment( rDrag );
2360 : }
2361 :
2362 0 : basegfx::B2DPolyPolygon SdrTableObj::getSpecialDragPoly(const SdrDragStat& rDrag) const
2363 : {
2364 0 : basegfx::B2DPolyPolygon aRetval;
2365 0 : const SdrHdl* pHdl = rDrag.GetHdl();
2366 :
2367 0 : if( pHdl && (HDL_USER == pHdl->GetKind()) )
2368 : {
2369 0 : const TableEdgeHdl* pEdgeHdl = dynamic_cast< const TableEdgeHdl* >( pHdl );
2370 :
2371 0 : if( pEdgeHdl )
2372 : {
2373 0 : aRetval = pEdgeHdl->getSpecialDragPoly( rDrag );
2374 : }
2375 : }
2376 :
2377 0 : return aRetval;
2378 : }
2379 :
2380 :
2381 : // Create
2382 :
2383 :
2384 0 : bool SdrTableObj::BegCreate(SdrDragStat& rStat)
2385 : {
2386 0 : rStat.SetOrtho4Possible();
2387 0 : Rectangle aRect1(rStat.GetStart(), rStat.GetNow());
2388 0 : aRect1.Justify();
2389 0 : rStat.SetActionRect(aRect1);
2390 0 : aRect = aRect1;
2391 0 : return true;
2392 : }
2393 :
2394 :
2395 :
2396 0 : bool SdrTableObj::MovCreate(SdrDragStat& rStat)
2397 : {
2398 0 : Rectangle aRect1;
2399 0 : rStat.TakeCreateRect(aRect1);
2400 0 : ImpJustifyRect(aRect1);
2401 0 : rStat.SetActionRect(aRect1);
2402 0 : aRect=aRect1; // fuer ObjName
2403 0 : SetBoundRectDirty();
2404 0 : bSnapRectDirty=true;
2405 0 : return true;
2406 : }
2407 :
2408 :
2409 :
2410 0 : bool SdrTableObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
2411 : {
2412 0 : rStat.TakeCreateRect(aRect);
2413 0 : ImpJustifyRect(aRect);
2414 0 : return (eCmd==SDRCREATE_FORCEEND || rStat.GetPointAnz()>=2);
2415 : }
2416 :
2417 0 : void SdrTableObj::BrkCreate(SdrDragStat& /*rStat*/)
2418 : {
2419 0 : }
2420 :
2421 :
2422 :
2423 0 : bool SdrTableObj::BckCreate(SdrDragStat& /*rStat*/)
2424 : {
2425 0 : return true;
2426 : }
2427 :
2428 :
2429 :
2430 0 : basegfx::B2DPolyPolygon SdrTableObj::TakeCreatePoly(const SdrDragStat& rDrag) const
2431 : {
2432 0 : Rectangle aRect1;
2433 0 : rDrag.TakeCreateRect(aRect1);
2434 0 : aRect1.Justify();
2435 :
2436 0 : basegfx::B2DPolyPolygon aRetval;
2437 0 : const basegfx::B2DRange aRange(aRect1.Left(), aRect1.Top(), aRect1.Right(), aRect1.Bottom());
2438 0 : aRetval.append(basegfx::tools::createPolygonFromRect(aRange));
2439 0 : return aRetval;
2440 : }
2441 :
2442 :
2443 :
2444 0 : Pointer SdrTableObj::GetCreatePointer() const
2445 : {
2446 0 : return Pointer(POINTER_CROSS);
2447 : }
2448 :
2449 :
2450 :
2451 922 : void SdrTableObj::createCell( CellRef& xNewCell )
2452 : {
2453 922 : xNewCell = Cell::create( *this, 0 );
2454 922 : }
2455 :
2456 :
2457 :
2458 12 : SdrObjGeoData *SdrTableObj::NewGeoData() const
2459 : {
2460 12 : return new TableObjectGeoData;
2461 : }
2462 :
2463 :
2464 :
2465 12 : void SdrTableObj::SaveGeoData(SdrObjGeoData& rGeo) const
2466 : {
2467 : DBG_ASSERT( dynamic_cast< TableObjectGeoData* >( &rGeo ), "svx::SdrTableObj::SaveGeoData(), illegal geo data!" );
2468 12 : SdrTextObj::SaveGeoData (rGeo);
2469 :
2470 12 : static_cast<TableObjectGeoData &>(rGeo).maLogicRect = maLogicRect;
2471 12 : }
2472 :
2473 :
2474 :
2475 0 : void SdrTableObj::RestGeoData(const SdrObjGeoData& rGeo)
2476 : {
2477 : DBG_ASSERT( dynamic_cast< const TableObjectGeoData* >( &rGeo ), "svx::SdrTableObj::SaveGeoData(), illegal geo data!" );
2478 :
2479 0 : maLogicRect = static_cast<const TableObjectGeoData &>(rGeo).maLogicRect;
2480 :
2481 0 : SdrTextObj::RestGeoData (rGeo);
2482 :
2483 0 : if( mpImpl )
2484 0 : mpImpl->LayoutTable( aRect, false, false );
2485 0 : ActionChanged();
2486 0 : }
2487 :
2488 :
2489 :
2490 0 : SdrTableObj* SdrTableObj::CloneRange( const CellPos& rStart, const CellPos& rEnd )
2491 : {
2492 0 : const sal_Int32 nColumns = rEnd.mnCol - rStart.mnCol + 1;
2493 0 : const sal_Int32 nRows = rEnd.mnRow - rStart.mnRow + 1;
2494 :
2495 0 : SdrTableObj* pNewTableObj = new SdrTableObj( GetModel(), GetCurrentBoundRect(), nColumns, nRows);
2496 0 : pNewTableObj->setTableStyleSettings( getTableStyleSettings() );
2497 0 : pNewTableObj->setTableStyle( getTableStyle() );
2498 :
2499 0 : Reference< XTable > xTable( getTable() );
2500 0 : Reference< XTable > xNewTable( pNewTableObj->getTable() );
2501 :
2502 0 : if( !xTable.is() || !xNewTable.is() )
2503 : {
2504 0 : delete pNewTableObj;
2505 0 : return 0;
2506 : }
2507 :
2508 : // copy cells
2509 0 : for( sal_Int32 nRow = 0; nRow < nRows; ++nRow )
2510 : {
2511 0 : for( sal_Int32 nCol = 0; nCol < nColumns; ++nCol ) try
2512 : {
2513 0 : CellRef xTargetCell( dynamic_cast< Cell* >( xNewTable->getCellByPosition( nCol, nRow ).get() ) );
2514 0 : if( xTargetCell.is() )
2515 0 : xTargetCell->cloneFrom( dynamic_cast< Cell* >( xTable->getCellByPosition( rStart.mnCol + nCol, rStart.mnRow + nRow ).get() ) );
2516 : }
2517 0 : catch( Exception& )
2518 : {
2519 : OSL_FAIL( "svx::SvxTableController::GetMarkedObjModel(), exception caught!" );
2520 : }
2521 : }
2522 :
2523 : // copy row heights
2524 0 : Reference< XTableRows > xNewRows( xNewTable->getRows(), UNO_QUERY_THROW );
2525 0 : const OUString sHeight( "Height" );
2526 0 : for( sal_Int32 nRow = 0; nRow < nRows; ++nRow )
2527 : {
2528 0 : Reference< XPropertySet > xNewSet( xNewRows->getByIndex( nRow ), UNO_QUERY_THROW );
2529 0 : xNewSet->setPropertyValue( sHeight, Any( mpImpl->mpLayouter->getRowHeight( rStart.mnRow + nRow ) ) );
2530 0 : }
2531 :
2532 : // copy column widths
2533 0 : Reference< XTableColumns > xNewColumns( xNewTable->getColumns(), UNO_QUERY_THROW );
2534 0 : const OUString sWidth( "Width" );
2535 0 : for( sal_Int32 nCol = 0; nCol < nColumns; ++nCol )
2536 : {
2537 0 : Reference< XPropertySet > xNewSet( xNewColumns->getByIndex( nCol ), UNO_QUERY_THROW );
2538 0 : xNewSet->setPropertyValue( sWidth, Any( mpImpl->mpLayouter->getColumnWidth( rStart.mnCol + nCol ) ) );
2539 0 : }
2540 :
2541 0 : pNewTableObj->NbcReformatText();
2542 0 : pNewTableObj->SetLogicRect( pNewTableObj->GetCurrentBoundRect() );
2543 :
2544 0 : return pNewTableObj;
2545 : }
2546 :
2547 :
2548 :
2549 0 : void SdrTableObj::DistributeColumns( sal_Int32 nFirstColumn, sal_Int32 nLastColumn )
2550 : {
2551 0 : if( mpImpl && mpImpl->mpLayouter )
2552 : {
2553 0 : TableModelNotifyGuard aGuard( mpImpl->mxTable.get() );
2554 0 : mpImpl->mpLayouter->DistributeColumns( aRect, nFirstColumn, nLastColumn );
2555 : }
2556 0 : }
2557 :
2558 :
2559 :
2560 0 : void SdrTableObj::DistributeRows( sal_Int32 nFirstRow, sal_Int32 nLastRow )
2561 : {
2562 0 : if( mpImpl && mpImpl->mpLayouter )
2563 : {
2564 0 : TableModelNotifyGuard aGuard( mpImpl->mxTable.get() );
2565 0 : mpImpl->mpLayouter->DistributeRows( aRect, nFirstRow, nLastRow );
2566 : }
2567 0 : }
2568 :
2569 :
2570 :
2571 10270 : void SdrTableObj::SetChanged()
2572 : {
2573 10270 : if( mpImpl )
2574 : {
2575 10270 : mpImpl->LayoutTable( aRect, false, false );
2576 : }
2577 :
2578 10270 : ::SdrTextObj::SetChanged();
2579 10270 : }
2580 :
2581 :
2582 :
2583 78 : void SdrTableObj::uno_lock()
2584 : {
2585 78 : if( mpImpl && mpImpl->mxTable.is() )
2586 78 : mpImpl->mxTable->lockBroadcasts();
2587 78 : }
2588 :
2589 :
2590 :
2591 78 : void SdrTableObj::uno_unlock()
2592 : {
2593 78 : if( mpImpl && mpImpl->mxTable.is() )
2594 78 : mpImpl->mxTable->unlockBroadcasts();
2595 78 : }
2596 :
2597 :
2598 :
2599 :
2600 :
2601 651 : } }
2602 :
2603 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
