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