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