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