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 : #include <com/sun/star/table/XMergeableCell.hpp>
22 :
23 : #include <algorithm>
24 :
25 : #include <vcl/svapp.hxx>
26 : #include <osl/mutex.hxx>
27 :
28 : #include "cell.hxx"
29 : #include "cellcursor.hxx"
30 : #include "tablemodel.hxx"
31 : #include "tablerow.hxx"
32 : #include "tablerows.hxx"
33 : #include "tablecolumn.hxx"
34 : #include "tablecolumns.hxx"
35 : #include "tableundo.hxx"
36 : #include "svx/svdotable.hxx"
37 : #include "svx/svdmodel.hxx"
38 : #include "svx/svdstr.hrc"
39 : #include "svdglob.hxx"
40 :
41 : using namespace ::osl;
42 : using namespace ::com::sun::star::uno;
43 : using namespace ::com::sun::star::table;
44 : using namespace ::com::sun::star::lang;
45 : using namespace ::com::sun::star::container;
46 : using namespace ::com::sun::star::beans;
47 : using namespace ::com::sun::star::util;
48 :
49 :
50 :
51 : namespace sdr { namespace table {
52 :
53 :
54 :
55 : // removes the given range from a vector
56 0 : template< class Vec, class Iter > void remove_range( Vec& rVector, sal_Int32 nIndex, sal_Int32 nCount )
57 : {
58 0 : const sal_Int32 nSize = static_cast<sal_Int32>(rVector.size());
59 0 : if( nCount && (nIndex >= 0) && (nIndex < nSize) )
60 : {
61 0 : if( (nIndex + nCount) >= nSize )
62 : {
63 : // remove at end
64 0 : rVector.resize( nIndex );
65 : }
66 : else
67 : {
68 0 : Iter aBegin( rVector.begin() );
69 0 : while( nIndex-- )
70 0 : aBegin++;
71 0 : if( nCount == 1 )
72 : {
73 0 : rVector.erase( aBegin );
74 : }
75 : else
76 : {
77 0 : Iter aEnd( aBegin );
78 :
79 0 : while( nCount-- )
80 0 : aEnd++;
81 0 : rVector.erase( aBegin, aEnd );
82 : }
83 : }
84 : }
85 0 : }
86 :
87 :
88 :
89 : /** inserts a range into a vector */
90 96 : template< class Vec, class Iter, class Entry > sal_Int32 insert_range( Vec& rVector, sal_Int32 nIndex, sal_Int32 nCount )
91 : {
92 96 : if( nCount )
93 : {
94 96 : if( nIndex >= static_cast< sal_Int32 >( rVector.size() ) )
95 : {
96 : // append at end
97 22 : nIndex = static_cast< sal_Int32 >( rVector.size() ); // cap to end
98 22 : rVector.resize( nIndex + nCount );
99 : }
100 : else
101 : {
102 : // insert
103 74 : sal_Int32 nFind = nIndex;
104 74 : Iter aIter( rVector.begin() );
105 148 : while( nFind-- )
106 0 : ++aIter;
107 :
108 74 : Entry aEmpty;
109 74 : rVector.insert( aIter, nCount, aEmpty );
110 : }
111 : }
112 96 : return nIndex;
113 : }
114 :
115 :
116 :
117 54 : TableModel::TableModel( SdrTableObj* pTableObj )
118 : : TableModelBase( m_aMutex )
119 : , mpTableObj( pTableObj )
120 : , mbModified( false )
121 : , mbNotifyPending( false )
122 54 : , mnNotifyLock( 0 )
123 : {
124 54 : }
125 :
126 0 : TableModel::TableModel( SdrTableObj* pTableObj, const TableModelRef& xSourceTable )
127 : : TableModelBase( m_aMutex )
128 : , mpTableObj( pTableObj )
129 : , mbModified( false )
130 : , mbNotifyPending( false )
131 0 : , mnNotifyLock( 0 )
132 : {
133 0 : if( xSourceTable.is() )
134 : {
135 0 : const sal_Int32 nColCount = xSourceTable->getColumnCountImpl();
136 0 : const sal_Int32 nRowCount = xSourceTable->getRowCountImpl();
137 :
138 0 : init( nColCount, nRowCount );
139 :
140 0 : sal_Int32 nRows = nRowCount;
141 0 : while( nRows-- )
142 0 : (*maRows[nRows]) = (*xSourceTable->maRows[nRows]);
143 :
144 0 : sal_Int32 nColumns = nColCount;
145 0 : while( nColumns-- )
146 0 : (*maColumns[nColumns]) = (*xSourceTable->maColumns[nColumns]);
147 :
148 : // copy cells
149 0 : for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
150 : {
151 0 : for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
152 : {
153 0 : CellRef xTargetCell( getCell( nCol, nRow ) );
154 0 : if( xTargetCell.is() )
155 0 : xTargetCell->cloneFrom( xSourceTable->getCell( nCol, nRow ) );
156 0 : }
157 : }
158 : }
159 0 : }
160 :
161 :
162 :
163 104 : TableModel::~TableModel()
164 : {
165 104 : }
166 :
167 :
168 :
169 54 : void TableModel::init( sal_Int32 nColumns, sal_Int32 nRows )
170 : {
171 54 : if( nRows < 20 )
172 54 : maRows.reserve( 20 );
173 :
174 54 : if( nColumns < 20 )
175 54 : maColumns.reserve( 20 );
176 :
177 54 : if( nRows && nColumns )
178 : {
179 54 : maColumns.resize( nColumns );
180 54 : maRows.resize( nRows );
181 :
182 162 : while( nRows-- )
183 54 : maRows[nRows].set( new TableRow( this, nRows, nColumns ) );
184 :
185 162 : while( nColumns-- )
186 54 : maColumns[nColumns].set( new TableColumn( this, nColumns ) );
187 : }
188 54 : }
189 :
190 :
191 : // ICellRange
192 :
193 :
194 0 : sal_Int32 TableModel::getLeft()
195 : {
196 0 : return 0;
197 : }
198 :
199 :
200 :
201 0 : sal_Int32 TableModel::getTop()
202 : {
203 0 : return 0;
204 : }
205 :
206 :
207 :
208 0 : sal_Int32 TableModel::getRight()
209 : {
210 0 : return getColumnCount();
211 : }
212 :
213 :
214 :
215 0 : sal_Int32 TableModel::getBottom()
216 : {
217 0 : return getRowCount();
218 : }
219 :
220 :
221 :
222 0 : Reference< XTable > TableModel::getTable()
223 : {
224 0 : return this;
225 : }
226 :
227 :
228 :
229 0 : void TableModel::UndoInsertRows( sal_Int32 nIndex, sal_Int32 nCount )
230 : {
231 0 : TableModelNotifyGuard aGuard( this );
232 :
233 : // remove the rows
234 0 : remove_range<RowVector,RowVector::iterator>( maRows, nIndex, nCount );
235 0 : updateRows();
236 0 : setModified(sal_True);
237 0 : }
238 :
239 :
240 :
241 0 : void TableModel::UndoRemoveRows( sal_Int32 nIndex, RowVector& aRows )
242 : {
243 0 : TableModelNotifyGuard aGuard( this );
244 :
245 0 : const sal_Int32 nCount = sal::static_int_cast< sal_Int32 >( aRows.size() );
246 :
247 0 : nIndex = insert_range<RowVector,RowVector::iterator,TableRowRef>( maRows, nIndex, nCount );
248 :
249 0 : for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
250 0 : maRows[nIndex+nOffset] = aRows[nOffset];
251 :
252 0 : updateRows();
253 0 : setModified(sal_True);
254 0 : }
255 :
256 :
257 :
258 0 : void TableModel::UndoInsertColumns( sal_Int32 nIndex, sal_Int32 nCount )
259 : {
260 0 : TableModelNotifyGuard aGuard( this );
261 :
262 : // now remove the columns
263 0 : remove_range<ColumnVector,ColumnVector::iterator>( maColumns, nIndex, nCount );
264 0 : sal_Int32 nRows = getRowCountImpl();
265 0 : while( nRows-- )
266 0 : maRows[nRows]->removeColumns( nIndex, nCount );
267 :
268 0 : updateColumns();
269 0 : setModified(sal_True);
270 0 : }
271 :
272 :
273 :
274 0 : void TableModel::UndoRemoveColumns( sal_Int32 nIndex, ColumnVector& aCols, CellVector& aCells )
275 : {
276 0 : TableModelNotifyGuard aGuard( this );
277 :
278 0 : const sal_Int32 nCount = sal::static_int_cast< sal_Int32 >( aCols.size() );
279 :
280 : // assert if there are not enough cells saved
281 : DBG_ASSERT( (aCols.size() * maRows.size()) == aCells.size(), "sdr::table::TableModel::UndoRemoveColumns(), invalid undo data!" );
282 :
283 0 : nIndex = insert_range<ColumnVector,ColumnVector::iterator,TableColumnRef>( maColumns, nIndex, nCount );
284 0 : for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
285 0 : maColumns[nIndex+nOffset] = aCols[nOffset];
286 :
287 0 : CellVector::iterator aIter( aCells.begin() );
288 :
289 0 : sal_Int32 nRows = getRowCountImpl();
290 0 : for( sal_Int32 nRow = 0; nRow < nRows; ++nRow )
291 : {
292 0 : CellVector::iterator aIter2 = aIter + nRow * nCount;
293 : OSL_ENSURE(aIter2 < aCells.end(), "invalid iterator!");
294 0 : maRows[nRow]->insertColumns( nIndex, nCount, &aIter2 );
295 : }
296 :
297 0 : updateColumns();
298 0 : setModified(sal_True);
299 0 : }
300 :
301 :
302 : // XTable
303 :
304 :
305 0 : Reference< XCellCursor > SAL_CALL TableModel::createCursor() throw (RuntimeException, std::exception)
306 : {
307 0 : ::SolarMutexGuard aGuard;
308 0 : return createCursorByRange( Reference< XCellRange >( this ) );
309 : }
310 :
311 :
312 :
313 8 : Reference< XCellCursor > SAL_CALL TableModel::createCursorByRange( const Reference< XCellRange >& rRange ) throw (IllegalArgumentException, RuntimeException, std::exception)
314 : {
315 8 : ::SolarMutexGuard aGuard;
316 :
317 8 : ICellRange* pRange = dynamic_cast< ICellRange* >( rRange.get() );
318 8 : if( (pRange == 0) || (pRange->getTable().get() != this) )
319 0 : throw IllegalArgumentException();
320 :
321 16 : TableModelRef xModel( this );
322 16 : return new CellCursor( xModel, pRange->getLeft(), pRange->getTop(), pRange->getRight(), pRange->getBottom() );
323 : }
324 :
325 :
326 :
327 7067 : sal_Int32 SAL_CALL TableModel::getRowCount() throw (RuntimeException, std::exception)
328 : {
329 7067 : ::SolarMutexGuard aGuard;
330 7067 : return getRowCountImpl();
331 : }
332 :
333 :
334 :
335 9532 : sal_Int32 SAL_CALL TableModel::getColumnCount() throw (RuntimeException, std::exception)
336 : {
337 9532 : ::SolarMutexGuard aGuard;
338 9532 : return getColumnCountImpl();
339 : }
340 :
341 :
342 : // XComponent
343 :
344 :
345 52 : void TableModel::dispose() throw (RuntimeException, std::exception)
346 : {
347 52 : ::SolarMutexGuard aGuard;
348 52 : TableModelBase::dispose();
349 52 : }
350 :
351 :
352 :
353 510 : void SAL_CALL TableModel::addEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException, std::exception)
354 : {
355 510 : TableModelBase::addEventListener( xListener );
356 510 : }
357 :
358 :
359 :
360 0 : void SAL_CALL TableModel::removeEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException, std::exception)
361 : {
362 0 : TableModelBase::removeEventListener( xListener );
363 0 : }
364 :
365 :
366 : // XModifiable
367 :
368 :
369 0 : sal_Bool SAL_CALL TableModel::isModified( ) throw (RuntimeException, std::exception)
370 : {
371 0 : ::SolarMutexGuard aGuard;
372 0 : return mbModified;
373 : }
374 :
375 :
376 :
377 6162 : void SAL_CALL TableModel::setModified( sal_Bool bModified ) throw (PropertyVetoException, RuntimeException, std::exception)
378 : {
379 : {
380 6162 : ::SolarMutexGuard aGuard;
381 6162 : mbModified = bModified;
382 : }
383 6162 : if( bModified )
384 6162 : notifyModification();
385 6162 : }
386 :
387 :
388 : // XModifyBroadcaster
389 :
390 :
391 54 : void SAL_CALL TableModel::addModifyListener( const Reference< XModifyListener >& xListener ) throw (RuntimeException, std::exception)
392 : {
393 54 : rBHelper.addListener( cppu::UnoType<XModifyListener>::get() , xListener );
394 54 : }
395 :
396 :
397 :
398 52 : void SAL_CALL TableModel::removeModifyListener( const Reference< XModifyListener >& xListener ) throw (RuntimeException, std::exception)
399 : {
400 52 : rBHelper.removeListener( cppu::UnoType<XModifyListener>::get() , xListener );
401 52 : }
402 :
403 :
404 : // XColumnRowRange
405 :
406 :
407 579 : Reference< XTableColumns > SAL_CALL TableModel::getColumns() throw (RuntimeException, std::exception)
408 : {
409 579 : ::SolarMutexGuard aGuard;
410 :
411 579 : if( !mxTableColumns.is() )
412 54 : mxTableColumns.set( new TableColumns( this ) );
413 579 : return mxTableColumns.get();
414 : }
415 :
416 :
417 :
418 701 : Reference< XTableRows > SAL_CALL TableModel::getRows() throw (RuntimeException, std::exception)
419 : {
420 701 : ::SolarMutexGuard aGuard;
421 :
422 701 : if( !mxTableRows.is() )
423 54 : mxTableRows.set( new TableRows( this ) );
424 701 : return mxTableRows.get();
425 : }
426 :
427 :
428 : // XCellRange
429 :
430 :
431 21057 : Reference< XCell > SAL_CALL TableModel::getCellByPosition( sal_Int32 nColumn, sal_Int32 nRow ) throw ( IndexOutOfBoundsException, RuntimeException, std::exception)
432 : {
433 21057 : ::SolarMutexGuard aGuard;
434 :
435 42114 : CellRef xCell( getCell( nColumn, nRow ) );
436 21057 : if( xCell.is() )
437 42114 : return xCell.get();
438 :
439 21057 : throw IndexOutOfBoundsException();
440 : }
441 :
442 :
443 :
444 8 : Reference< XCellRange > SAL_CALL TableModel::getCellRangeByPosition( sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
445 : {
446 8 : ::SolarMutexGuard aGuard;
447 :
448 8 : if( (nLeft >= 0) && (nTop >= 0) && (nRight >= nLeft) && (nBottom >= nTop) && (nRight < getColumnCountImpl()) && (nBottom < getRowCountImpl() ) )
449 : {
450 8 : TableModelRef xModel( this );
451 16 : return new CellRange( xModel, nLeft, nTop, nRight, nBottom );
452 : }
453 :
454 8 : throw IndexOutOfBoundsException();
455 : }
456 :
457 :
458 :
459 0 : Reference< XCellRange > SAL_CALL TableModel::getCellRangeByName( const OUString& /*aRange*/ ) throw (RuntimeException, std::exception)
460 : {
461 0 : return Reference< XCellRange >();
462 : }
463 :
464 :
465 : // XPropertySet
466 :
467 :
468 0 : Reference< XPropertySetInfo > SAL_CALL TableModel::getPropertySetInfo( ) throw (RuntimeException, std::exception)
469 : {
470 0 : Reference< XPropertySetInfo > xInfo;
471 0 : return xInfo;
472 : }
473 :
474 :
475 :
476 0 : void SAL_CALL TableModel::setPropertyValue( const OUString& /*aPropertyName*/, const Any& /*aValue*/ ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException, std::exception)
477 : {
478 0 : }
479 :
480 :
481 :
482 0 : Any SAL_CALL TableModel::getPropertyValue( const OUString& /*PropertyName*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
483 : {
484 0 : return Any();
485 : }
486 :
487 :
488 :
489 0 : void SAL_CALL TableModel::addPropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*xListener*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
490 : {
491 0 : }
492 :
493 :
494 :
495 0 : void SAL_CALL TableModel::removePropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*xListener*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
496 : {
497 0 : }
498 :
499 :
500 :
501 0 : void SAL_CALL TableModel::addVetoableChangeListener( const OUString& /*aPropertyName*/, const Reference< XVetoableChangeListener >& /*xListener*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
502 : {
503 0 : }
504 :
505 :
506 :
507 0 : void SAL_CALL TableModel::removeVetoableChangeListener( const OUString& /*aPropertyName*/, const Reference< XVetoableChangeListener >& /*xListener*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
508 : {
509 0 : }
510 :
511 :
512 : // XFastPropertySet
513 :
514 :
515 0 : void SAL_CALL TableModel::setFastPropertyValue( ::sal_Int32 /*nHandle*/, const Any& /*aValue*/ ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException, std::exception)
516 : {
517 0 : }
518 :
519 :
520 :
521 0 : Any SAL_CALL TableModel::getFastPropertyValue( ::sal_Int32 /*nHandle*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException, std::exception)
522 : {
523 0 : Any aAny;
524 0 : return aAny;
525 : }
526 :
527 :
528 : // internals
529 :
530 :
531 29731 : sal_Int32 TableModel::getRowCountImpl() const
532 : {
533 29731 : return static_cast< sal_Int32 >( maRows.size() );
534 : }
535 :
536 :
537 :
538 32663 : sal_Int32 TableModel::getColumnCountImpl() const
539 : {
540 32663 : return static_cast< sal_Int32 >( maColumns.size() );
541 : }
542 :
543 :
544 :
545 52 : void TableModel::disposing()
546 : {
547 52 : if( !maRows.empty() )
548 : {
549 52 : RowVector::iterator aIter( maRows.begin() );
550 231 : while( aIter != maRows.end() )
551 127 : (*aIter++)->dispose();
552 52 : RowVector().swap(maRows);
553 : }
554 :
555 52 : if( !maColumns.empty() )
556 : {
557 52 : ColumnVector::iterator aIter( maColumns.begin() );
558 323 : while( aIter != maColumns.end() )
559 219 : (*aIter++)->dispose();
560 52 : ColumnVector().swap(maColumns);
561 : }
562 :
563 52 : if( mxTableColumns.is() )
564 : {
565 52 : mxTableColumns->dispose();
566 52 : mxTableColumns.clear();
567 : }
568 :
569 52 : if( mxTableRows.is() )
570 : {
571 52 : mxTableRows->dispose();
572 52 : mxTableRows.clear();
573 : }
574 :
575 52 : mpTableObj = 0;
576 52 : }
577 :
578 :
579 : // XBroadcaster
580 :
581 :
582 883 : void TableModel::lockBroadcasts() throw (RuntimeException, std::exception)
583 : {
584 883 : ::SolarMutexGuard aGuard;
585 883 : ++mnNotifyLock;
586 883 : }
587 :
588 :
589 883 : void TableModel::unlockBroadcasts() throw (RuntimeException, std::exception)
590 : {
591 883 : ::SolarMutexGuard aGuard;
592 883 : --mnNotifyLock;
593 883 : if( mnNotifyLock <= 0 )
594 : {
595 415 : mnNotifyLock = 0;
596 415 : if( mbNotifyPending )
597 125 : notifyModification();
598 883 : }
599 883 : }
600 :
601 :
602 6287 : void TableModel::notifyModification()
603 : {
604 6287 : ::osl::MutexGuard guard( m_aMutex );
605 6287 : if( (mnNotifyLock == 0) && mpTableObj && mpTableObj->GetModel() )
606 : {
607 125 : mbNotifyPending = false;
608 :
609 125 : ::cppu::OInterfaceContainerHelper * pModifyListeners = rBHelper.getContainer( cppu::UnoType<XModifyListener>::get() );
610 125 : if( pModifyListeners )
611 : {
612 125 : EventObject aSource;
613 125 : aSource.Source = static_cast< ::cppu::OWeakObject* >(this);
614 125 : pModifyListeners->notifyEach( &XModifyListener::modified, aSource);
615 : }
616 : }
617 : else
618 : {
619 6162 : mbNotifyPending = true;
620 6287 : }
621 6287 : }
622 :
623 :
624 :
625 21142 : CellRef TableModel::getCell( sal_Int32 nCol, sal_Int32 nRow ) const
626 : {
627 21142 : if( ((nRow >= 0) && (nRow < getRowCountImpl())) && (nCol >= 0) && (nCol < getColumnCountImpl()) )
628 : {
629 21142 : return maRows[nRow]->maCells[nCol];
630 : }
631 : else
632 : {
633 0 : CellRef xRet;
634 0 : return xRet;
635 : }
636 : }
637 :
638 :
639 :
640 510 : CellRef TableModel::createCell()
641 : {
642 510 : CellRef xCell;
643 510 : if( mpTableObj )
644 510 : mpTableObj->createCell( xCell );
645 510 : return xCell;
646 : }
647 :
648 :
649 :
650 52 : void TableModel::insertColumns( sal_Int32 nIndex, sal_Int32 nCount )
651 : {
652 52 : if( nCount && mpTableObj )
653 : {
654 : try
655 : {
656 52 : SdrModel* pModel = mpTableObj->GetModel();
657 :
658 52 : TableModelNotifyGuard aGuard( this );
659 52 : nIndex = insert_range<ColumnVector,ColumnVector::iterator,TableColumnRef>( maColumns, nIndex, nCount );
660 :
661 52 : sal_Int32 nRows = getRowCountImpl();
662 196 : while( nRows-- )
663 92 : maRows[nRows]->insertColumns( nIndex, nCount );
664 :
665 104 : ColumnVector aNewColumns(nCount);
666 220 : for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
667 : {
668 168 : TableColumnRef xNewCol( new TableColumn( this, nIndex+nOffset ) );
669 168 : maColumns[nIndex+nOffset] = xNewCol;
670 168 : aNewColumns[nOffset] = xNewCol;
671 168 : }
672 :
673 52 : const bool bUndo = pModel && mpTableObj->IsInserted() && pModel->IsUndoEnabled();
674 52 : if( bUndo )
675 : {
676 15 : pModel->BegUndo( ImpGetResStr(STR_TABLE_INSCOL) );
677 15 : pModel->AddUndo( pModel->GetSdrUndoFactory().CreateUndoGeoObject(*mpTableObj) );
678 :
679 15 : TableModelRef xThis( this );
680 :
681 15 : nRows = getRowCountImpl();
682 30 : CellVector aNewCells( nCount * nRows );
683 15 : CellVector::iterator aCellIter( aNewCells.begin() );
684 :
685 15 : nRows = getRowCountImpl();
686 30 : for( sal_Int32 nRow = 0; nRow < nRows; ++nRow )
687 : {
688 32 : for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
689 17 : (*aCellIter++) = getCell( nIndex + nOffset, nRow );
690 : }
691 :
692 30 : pModel->AddUndo( new InsertColUndo( xThis, nIndex, aNewColumns, aNewCells ) );
693 : }
694 :
695 52 : const sal_Int32 nRowCount = getRowCountImpl();
696 : // check if cells merge over new columns
697 60 : for( sal_Int32 nCol = 0; nCol < nIndex; ++nCol )
698 : {
699 16 : for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
700 : {
701 8 : CellRef xCell( getCell( nCol, nRow ) );
702 8 : sal_Int32 nColSpan = (xCell.is() && !xCell->isMerged()) ? xCell->getColumnSpan() : 1;
703 8 : if( (nColSpan != 1) && ((nColSpan + nCol ) > nIndex) )
704 : {
705 : // cell merges over newly created columns, so add the new columns to the merged cell
706 0 : const sal_Int32 nRowSpan = xCell->getRowSpan();
707 0 : nColSpan += nCount;
708 0 : merge( nCol, nRow, nColSpan, nRowSpan );
709 : }
710 8 : }
711 : }
712 :
713 52 : if( bUndo )
714 15 : pModel->EndUndo();
715 :
716 52 : if( pModel )
717 104 : pModel->SetChanged();
718 :
719 : }
720 0 : catch( Exception& )
721 : {
722 : OSL_FAIL("sdr::table::TableModel::insertColumns(), exception caught!");
723 : }
724 52 : updateColumns();
725 52 : setModified(sal_True);
726 : }
727 52 : }
728 :
729 :
730 :
731 0 : void TableModel::removeColumns( sal_Int32 nIndex, sal_Int32 nCount )
732 : {
733 0 : sal_Int32 nColCount = getColumnCountImpl();
734 :
735 0 : if( mpTableObj && nCount && (nIndex >= 0) && (nIndex < nColCount) )
736 : {
737 : try
738 : {
739 0 : TableModelNotifyGuard aGuard( this );
740 :
741 : // clip removed columns to columns actually available
742 0 : if( (nIndex + nCount) > nColCount )
743 0 : nCount = nColCount - nIndex;
744 :
745 0 : sal_Int32 nRows = getRowCountImpl();
746 :
747 0 : SdrModel* pModel = mpTableObj->GetModel();
748 :
749 0 : const bool bUndo = pModel && mpTableObj->IsInserted() && pModel->IsUndoEnabled();
750 0 : if( bUndo )
751 : {
752 0 : pModel->BegUndo( ImpGetResStr(STR_UNDO_COL_DELETE) );
753 0 : pModel->AddUndo( pModel->GetSdrUndoFactory().CreateUndoGeoObject(*mpTableObj) );
754 :
755 0 : TableModelRef xThis( this );
756 0 : ColumnVector aRemovedCols( nCount );
757 : sal_Int32 nOffset;
758 0 : for( nOffset = 0; nOffset < nCount; ++nOffset )
759 : {
760 0 : aRemovedCols[nOffset] = maColumns[nIndex+nOffset];
761 : }
762 :
763 0 : CellVector aRemovedCells( nCount * nRows );
764 0 : CellVector::iterator aCellIter( aRemovedCells.begin() );
765 0 : for( sal_Int32 nRow = 0; nRow < nRows; ++nRow )
766 : {
767 0 : for( nOffset = 0; nOffset < nCount; ++nOffset )
768 0 : (*aCellIter++) = getCell( nIndex + nOffset, nRow );
769 : }
770 :
771 0 : pModel->AddUndo( new RemoveColUndo( xThis, nIndex, aRemovedCols, aRemovedCells ) );
772 : }
773 :
774 : // only rows before and inside the removed rows are considered
775 0 : nColCount = nIndex + nCount + 1;
776 :
777 0 : const sal_Int32 nRowCount = getRowCountImpl();
778 :
779 : // first check merged cells before and inside the removed rows
780 0 : for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
781 : {
782 0 : for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
783 : {
784 0 : CellRef xCell( getCell( nCol, nRow ) );
785 0 : sal_Int32 nColSpan = (xCell.is() && !xCell->isMerged()) ? xCell->getColumnSpan() : 1;
786 0 : if( nColSpan <= 1 )
787 0 : continue;
788 :
789 0 : if( nCol >= nIndex )
790 : {
791 : // current cell is inside the removed columns
792 0 : if( (nCol + nColSpan) > ( nIndex + nCount ) )
793 : {
794 : // current cells merges with columns after the removed columns
795 0 : const sal_Int32 nRemove = nCount - nCol + nIndex;
796 :
797 0 : CellRef xTargetCell( getCell( nIndex + nCount, nRow ) );
798 0 : if( xTargetCell.is() )
799 : {
800 0 : if( bUndo )
801 0 : xTargetCell->AddUndo();
802 0 : xTargetCell->merge( nColSpan - nRemove, xCell->getRowSpan() );
803 0 : xTargetCell->replaceContentAndFormating( xCell );
804 0 : }
805 : }
806 : }
807 0 : else if( nColSpan > (nIndex - nCol) )
808 : {
809 : // current cells spans inside the removed columns, so adjust
810 0 : const sal_Int32 nRemove = ::std::min( nCount, nCol + nColSpan - nIndex );
811 0 : if( bUndo )
812 0 : xCell->AddUndo();
813 0 : xCell->merge( nColSpan - nRemove, xCell->getRowSpan() );
814 : }
815 0 : }
816 : }
817 :
818 : // now remove the columns
819 0 : remove_range<ColumnVector,ColumnVector::iterator>( maColumns, nIndex, nCount );
820 0 : while( nRows-- )
821 0 : maRows[nRows]->removeColumns( nIndex, nCount );
822 :
823 0 : if( bUndo )
824 0 : pModel->EndUndo();
825 :
826 0 : if( pModel )
827 0 : pModel->SetChanged();
828 : }
829 0 : catch( Exception& )
830 : {
831 : OSL_FAIL("sdr::table::TableModel::removeColumns(), exception caught!");
832 : }
833 :
834 0 : updateColumns();
835 0 : setModified(sal_True);
836 : }
837 0 : }
838 :
839 :
840 :
841 44 : void TableModel::insertRows( sal_Int32 nIndex, sal_Int32 nCount )
842 : {
843 44 : if( nCount && mpTableObj )
844 : {
845 44 : SdrModel* pModel = mpTableObj->GetModel();
846 44 : const bool bUndo = pModel && mpTableObj->IsInserted() && pModel->IsUndoEnabled();
847 : try
848 : {
849 44 : TableModelNotifyGuard aGuard( this );
850 :
851 44 : nIndex = insert_range<RowVector,RowVector::iterator,TableRowRef>( maRows, nIndex, nCount );
852 :
853 88 : RowVector aNewRows(nCount);
854 44 : const sal_Int32 nColCount = getColumnCountImpl();
855 121 : for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
856 : {
857 77 : TableRowRef xNewRow( new TableRow( this, nIndex+nOffset, nColCount ) );
858 77 : maRows[nIndex+nOffset] = xNewRow;
859 77 : aNewRows[nOffset] = xNewRow;
860 77 : }
861 :
862 44 : if( bUndo )
863 : {
864 7 : pModel->BegUndo( ImpGetResStr(STR_TABLE_INSROW) );
865 7 : pModel->AddUndo( pModel->GetSdrUndoFactory().CreateUndoGeoObject(*mpTableObj) );
866 7 : TableModelRef xThis( this );
867 7 : pModel->AddUndo( new InsertRowUndo( xThis, nIndex, aNewRows ) );
868 : }
869 :
870 : // check if cells merge over new columns
871 92 : for( sal_Int32 nRow = 0; nRow < nIndex; ++nRow )
872 : {
873 108 : for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
874 : {
875 60 : CellRef xCell( getCell( nCol, nRow ) );
876 60 : sal_Int32 nRowSpan = (xCell.is() && !xCell->isMerged()) ? xCell->getRowSpan() : 1;
877 60 : if( (nRowSpan > 1) && ((nRowSpan + nRow) > nIndex) )
878 : {
879 : // cell merges over newly created columns, so add the new columns to the merged cell
880 0 : const sal_Int32 nColSpan = xCell->getColumnSpan();
881 0 : nRowSpan += nCount;
882 0 : merge( nCol, nRow, nColSpan, nRowSpan );
883 : }
884 60 : }
885 44 : }
886 : }
887 0 : catch( Exception& )
888 : {
889 : OSL_FAIL("sdr::table::TableModel::insertRows(), exception caught!");
890 : }
891 44 : if( bUndo )
892 7 : pModel->EndUndo();
893 :
894 44 : if( pModel )
895 44 : pModel->SetChanged();
896 :
897 44 : updateRows();
898 44 : setModified(sal_True);
899 : }
900 44 : }
901 :
902 :
903 :
904 0 : void TableModel::removeRows( sal_Int32 nIndex, sal_Int32 nCount )
905 : {
906 0 : sal_Int32 nRowCount = getRowCountImpl();
907 :
908 0 : if( mpTableObj && nCount && (nIndex >= 0) && (nIndex < nRowCount) )
909 : {
910 0 : SdrModel* pModel = mpTableObj->GetModel();
911 0 : const bool bUndo = pModel && mpTableObj->IsInserted()&& pModel->IsUndoEnabled();
912 :
913 : try
914 : {
915 0 : TableModelNotifyGuard aGuard( this );
916 :
917 : // clip removed rows to rows actually available
918 0 : if( (nIndex + nCount) > nRowCount )
919 0 : nCount = nRowCount - nIndex;
920 :
921 0 : if( bUndo )
922 : {
923 0 : pModel->BegUndo( ImpGetResStr(STR_UNDO_ROW_DELETE) );
924 0 : pModel->AddUndo( pModel->GetSdrUndoFactory().CreateUndoGeoObject(*mpTableObj) );
925 :
926 0 : TableModelRef xThis( this );
927 :
928 0 : RowVector aRemovedRows( nCount );
929 0 : for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
930 0 : aRemovedRows[nOffset] = maRows[nIndex+nOffset];
931 :
932 0 : pModel->AddUndo( new RemoveRowUndo( xThis, nIndex, aRemovedRows ) );
933 : }
934 :
935 : // only rows before and inside the removed rows are considered
936 0 : nRowCount = nIndex + nCount + 1;
937 :
938 0 : const sal_Int32 nColCount = getColumnCountImpl();
939 :
940 : // first check merged cells before and inside the removed rows
941 0 : for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
942 : {
943 0 : for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
944 : {
945 0 : CellRef xCell( getCell( nCol, nRow ) );
946 0 : sal_Int32 nRowSpan = (xCell.is() && !xCell->isMerged()) ? xCell->getRowSpan() : 1;
947 0 : if( nRowSpan <= 1 )
948 0 : continue;
949 :
950 0 : if( nRow >= nIndex )
951 : {
952 : // current cell is inside the removed rows
953 0 : if( (nRow + nRowSpan) > (nIndex + nCount) )
954 : {
955 : // current cells merges with rows after the removed rows
956 0 : const sal_Int32 nRemove = nCount - nRow + nIndex;
957 :
958 0 : CellRef xTargetCell( getCell( nCol, nIndex + nCount ) );
959 0 : if( xTargetCell.is() )
960 : {
961 0 : if( bUndo )
962 0 : xTargetCell->AddUndo();
963 0 : xTargetCell->merge( xCell->getColumnSpan(), nRowSpan - nRemove );
964 0 : xTargetCell->replaceContentAndFormating( xCell );
965 0 : }
966 : }
967 : }
968 0 : else if( nRowSpan > (nIndex - nRow) )
969 : {
970 : // current cells spans inside the removed rows, so adjust
971 0 : const sal_Int32 nRemove = ::std::min( nCount, nRow + nRowSpan - nIndex );
972 0 : if( bUndo )
973 0 : xCell->AddUndo();
974 0 : xCell->merge( xCell->getColumnSpan(), nRowSpan - nRemove );
975 : }
976 0 : }
977 : }
978 :
979 : // now remove the rows
980 0 : remove_range<RowVector,RowVector::iterator>( maRows, nIndex, nCount );
981 :
982 0 : if( bUndo )
983 0 : pModel->EndUndo();
984 :
985 0 : if( pModel )
986 0 : pModel->SetChanged();
987 : }
988 0 : catch( Exception& )
989 : {
990 : OSL_FAIL("sdr::table::TableModel::removeRows(), exception caught!");
991 : }
992 :
993 0 : updateRows();
994 0 : setModified(sal_True);
995 : }
996 0 : }
997 :
998 :
999 :
1000 1364 : TableRowRef TableModel::getRow( sal_Int32 nRow ) const throw (IndexOutOfBoundsException)
1001 : {
1002 1364 : if( (nRow >= 0) && (nRow < getRowCountImpl()) )
1003 2728 : return maRows[nRow];
1004 :
1005 0 : throw IndexOutOfBoundsException();
1006 : }
1007 :
1008 :
1009 :
1010 1921 : TableColumnRef TableModel::getColumn( sal_Int32 nColumn ) const throw (IndexOutOfBoundsException)
1011 : {
1012 1921 : if( (nColumn >= 0) && (nColumn < getColumnCountImpl()) )
1013 3842 : return maColumns[nColumn];
1014 :
1015 0 : throw IndexOutOfBoundsException();
1016 : }
1017 :
1018 :
1019 :
1020 : /** deletes rows and columns that are completely merged. Must be called between BegUndo/EndUndo! */
1021 8 : void TableModel::optimize()
1022 : {
1023 8 : TableModelNotifyGuard aGuard( this );
1024 :
1025 8 : bool bWasModified = false;
1026 :
1027 8 : if( !maRows.empty() && !maColumns.empty() )
1028 : {
1029 8 : sal_Int32 nCol = getColumnCountImpl() - 1;
1030 8 : sal_Int32 nRows = getRowCountImpl();
1031 54 : while( nCol > 0 )
1032 : {
1033 38 : bool bEmpty = true;
1034 76 : for( sal_Int32 nRow = 0; (nRow < nRows) && bEmpty; nRow++ )
1035 : {
1036 38 : Reference< XMergeableCell > xCell( getCellByPosition( nCol, nRow ), UNO_QUERY );
1037 38 : if( xCell.is() && !xCell->isMerged() )
1038 38 : bEmpty = false;
1039 38 : }
1040 :
1041 38 : if( bEmpty )
1042 : {
1043 0 : if( nCol > 0 ) try
1044 : {
1045 0 : const OUString sWidth("Width");
1046 0 : sal_Int32 nWidth1 = 0, nWidth2 = 0;
1047 0 : Reference< XPropertySet > xSet1( static_cast< XCellRange* >( maColumns[nCol].get() ), UNO_QUERY_THROW );
1048 0 : Reference< XPropertySet > xSet2( static_cast< XCellRange* >( maColumns[nCol-1].get() ), UNO_QUERY_THROW );
1049 0 : xSet1->getPropertyValue( sWidth ) >>= nWidth1;
1050 0 : xSet2->getPropertyValue( sWidth ) >>= nWidth2;
1051 0 : nWidth1 += nWidth2;
1052 0 : xSet2->setPropertyValue( sWidth, Any( nWidth1 ) );
1053 : }
1054 0 : catch( Exception& e )
1055 : {
1056 : (void)e;
1057 : OSL_FAIL("svx::TableModel::optimize(), exception caught!");
1058 : }
1059 :
1060 0 : removeColumns( nCol, 1 );
1061 0 : bWasModified = true;
1062 : }
1063 :
1064 38 : nCol--;
1065 : }
1066 :
1067 8 : sal_Int32 nRow = getRowCountImpl() - 1;
1068 8 : sal_Int32 nCols = getColumnCountImpl();
1069 27 : while( nRow > 0 )
1070 : {
1071 11 : bool bEmpty = true;
1072 22 : for( nCol = 0; (nCol < nCols) && bEmpty; nCol++ )
1073 : {
1074 11 : Reference< XMergeableCell > xCell( getCellByPosition( nCol, nRow ), UNO_QUERY );
1075 11 : if( xCell.is() && !xCell->isMerged() )
1076 11 : bEmpty = false;
1077 11 : }
1078 :
1079 11 : if( bEmpty )
1080 : {
1081 0 : if( nRow > 0 ) try
1082 : {
1083 0 : const OUString sHeight("Height");
1084 0 : sal_Int32 nHeight1 = 0, nHeight2 = 0;
1085 0 : Reference< XPropertySet > xSet1( static_cast< XCellRange* >( maRows[nRow].get() ), UNO_QUERY_THROW );
1086 0 : Reference< XPropertySet > xSet2( static_cast< XCellRange* >( maRows[nRow-1].get() ), UNO_QUERY_THROW );
1087 0 : xSet1->getPropertyValue( sHeight ) >>= nHeight1;
1088 0 : xSet2->getPropertyValue( sHeight ) >>= nHeight2;
1089 0 : nHeight1 += nHeight2;
1090 0 : xSet2->setPropertyValue( sHeight, Any( nHeight1 ) );
1091 : }
1092 0 : catch( Exception& e )
1093 : {
1094 : (void)e;
1095 : OSL_FAIL("svx::TableModel::optimize(), exception caught!");
1096 : }
1097 :
1098 0 : removeRows( nRow, 1 );
1099 0 : bWasModified = true;
1100 : }
1101 :
1102 11 : nRow--;
1103 : }
1104 : }
1105 8 : if( bWasModified )
1106 0 : setModified(sal_True);
1107 8 : }
1108 :
1109 :
1110 :
1111 8 : void TableModel::merge( sal_Int32 nCol, sal_Int32 nRow, sal_Int32 nColSpan, sal_Int32 nRowSpan )
1112 : {
1113 8 : SdrModel* pModel = mpTableObj->GetModel();
1114 :
1115 8 : const bool bUndo = pModel && mpTableObj->IsInserted() && pModel->IsUndoEnabled();
1116 :
1117 8 : const sal_Int32 nLastRow = nRow + nRowSpan;
1118 8 : const sal_Int32 nLastCol = nCol + nColSpan;
1119 :
1120 8 : if( (nLastRow > getRowCount()) || (nLastCol > getColumnCount() ) )
1121 : {
1122 : OSL_FAIL("TableModel::merge(), merge beyound the table!");
1123 : }
1124 :
1125 : // merge first cell
1126 8 : CellRef xOriginCell( dynamic_cast< Cell* >( getCellByPosition( nCol, nRow ).get() ) );
1127 8 : if(!xOriginCell.is())
1128 8 : return;
1129 :
1130 8 : if( bUndo )
1131 0 : xOriginCell->AddUndo();
1132 8 : xOriginCell->merge( nColSpan, nRowSpan );
1133 :
1134 8 : sal_Int32 nTempCol = nCol + 1;
1135 :
1136 : // merge remaining cells
1137 27 : for( ; nRow < nLastRow; nRow++ )
1138 : {
1139 30 : for( ; nTempCol < nLastCol; nTempCol++ )
1140 : {
1141 11 : CellRef xCell( dynamic_cast< Cell* >( getCellByPosition( nTempCol, nRow ).get() ) );
1142 11 : if( xCell.is() && !xCell->isMerged() )
1143 : {
1144 11 : if( bUndo )
1145 0 : xCell->AddUndo();
1146 11 : xCell->setMerged();
1147 11 : xOriginCell->mergeContent( xCell );
1148 : }
1149 11 : }
1150 19 : nTempCol = nCol;
1151 8 : }
1152 : }
1153 :
1154 44 : void TableModel::updateRows()
1155 : {
1156 44 : sal_Int32 nRow = 0;
1157 44 : RowVector::iterator iter = maRows.begin();
1158 243 : while( iter != maRows.end() )
1159 : {
1160 155 : (*iter++)->mnRow = nRow++;
1161 : }
1162 44 : }
1163 :
1164 52 : void TableModel::updateColumns()
1165 : {
1166 52 : sal_Int32 nColumn = 0;
1167 52 : ColumnVector::iterator iter = maColumns.begin();
1168 324 : while( iter != maColumns.end() )
1169 : {
1170 220 : (*iter++)->mnColumn = nColumn++;
1171 : }
1172 52 : }
1173 :
1174 435 : } }
1175 :
1176 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
