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