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 "sdr/properties/textproperties.hxx"
22 : #include "editeng/outlobj.hxx"
23 :
24 : #include "cell.hxx"
25 : #include "tableundo.hxx"
26 : #include "svx/svdotable.hxx"
27 : #include "tablerow.hxx"
28 : #include "tablecolumn.hxx"
29 :
30 :
31 :
32 :
33 : using namespace ::com::sun::star::uno;
34 : using namespace ::com::sun::star::table;
35 :
36 :
37 :
38 : namespace sdr { namespace table {
39 :
40 0 : CellUndo::CellUndo( const SdrObjectWeakRef& xObjRef, const CellRef& xCell )
41 0 : : SdrUndoAction( *xCell->GetModel() )
42 : , mxObjRef( xObjRef )
43 : , mxCell( xCell )
44 0 : , mbUndo( true )
45 : {
46 0 : if( mxCell.is() && mxObjRef.is() )
47 : {
48 0 : getDataFromCell( maUndoData );
49 0 : mxObjRef->AddObjectUser( *this );
50 : }
51 0 : }
52 :
53 0 : CellUndo::~CellUndo()
54 : {
55 0 : if( mxObjRef.is() )
56 0 : mxObjRef->RemoveObjectUser( *this );
57 0 : dispose();
58 0 : }
59 :
60 0 : void CellUndo::dispose()
61 : {
62 0 : mxCell.clear();
63 0 : delete maUndoData.mpProperties;
64 0 : maUndoData.mpProperties = 0;
65 0 : delete maRedoData.mpProperties;
66 0 : maRedoData.mpProperties = 0;
67 0 : delete maUndoData.mpOutlinerParaObject;
68 0 : maUndoData.mpOutlinerParaObject = 0;
69 0 : delete maRedoData.mpOutlinerParaObject;
70 0 : maRedoData.mpOutlinerParaObject = 0;
71 0 : }
72 :
73 0 : void CellUndo::ObjectInDestruction(const SdrObject& )
74 : {
75 0 : dispose();
76 0 : }
77 :
78 0 : void CellUndo::Undo()
79 : {
80 0 : if( mxCell.is() && mbUndo )
81 : {
82 0 : if( maRedoData.mpProperties == 0 )
83 0 : getDataFromCell( maRedoData );
84 :
85 0 : setDataToCell( maUndoData );
86 0 : mbUndo = false;
87 : }
88 0 : }
89 :
90 0 : void CellUndo::Redo()
91 : {
92 0 : if( mxCell.is() && !mbUndo )
93 : {
94 0 : setDataToCell( maRedoData );
95 0 : mbUndo = true;
96 : }
97 0 : }
98 :
99 0 : bool CellUndo::Merge( SfxUndoAction *pNextAction )
100 : {
101 0 : CellUndo* pNext = dynamic_cast< CellUndo* >( pNextAction );
102 0 : if( pNext && pNext->mxCell.get() == mxCell.get() )
103 : {
104 0 : return true;
105 : }
106 : else
107 : {
108 0 : return false;
109 : }
110 : }
111 :
112 0 : void CellUndo::setDataToCell( const Data& rData )
113 : {
114 0 : delete mxCell->mpProperties;
115 0 : if( rData.mpProperties )
116 0 : mxCell->mpProperties = Cell::CloneProperties( rData.mpProperties, *mxObjRef.get(), *mxCell.get() );
117 : else
118 0 : mxCell->mpProperties = 0;
119 :
120 0 : if( rData.mpOutlinerParaObject )
121 0 : mxCell->SetOutlinerParaObject( new OutlinerParaObject(*rData.mpOutlinerParaObject) );
122 : else
123 0 : mxCell->RemoveOutlinerParaObject();
124 :
125 0 : mxCell->msFormula = rData.msFormula;
126 0 : mxCell->mfValue = rData.mfValue;
127 0 : mxCell->mnError = rData.mnError;
128 0 : mxCell->mbMerged = rData.mbMerged;
129 0 : mxCell->mnRowSpan = rData.mnRowSpan;
130 0 : mxCell->mnColSpan = rData.mnColSpan;
131 :
132 0 : if(mxObjRef.is())
133 : {
134 : // #i120201# ActionChanged is not enough, we need to trigger TableLayouter::UpdateBorderLayout()
135 : // and this is done best using ReformatText() for table objects
136 0 : mxObjRef->ActionChanged();
137 0 : mxObjRef->NbcReformatText();
138 : }
139 0 : }
140 :
141 0 : void CellUndo::getDataFromCell( Data& rData )
142 : {
143 0 : if( mxObjRef.is() && mxCell.is() )
144 : {
145 0 : if( mxCell->mpProperties )
146 0 : rData.mpProperties = mxCell->CloneProperties( *mxObjRef.get(), *mxCell.get());
147 :
148 0 : if( mxCell->GetOutlinerParaObject() )
149 0 : rData.mpOutlinerParaObject = new OutlinerParaObject(*mxCell->GetOutlinerParaObject());
150 : else
151 0 : rData.mpOutlinerParaObject = 0;
152 :
153 0 : rData.mnCellContentType = mxCell->mnCellContentType;
154 :
155 0 : rData.msFormula = mxCell->msFormula;
156 0 : rData.mfValue = mxCell->mfValue;
157 0 : rData.mnError = mxCell->mnError;
158 0 : rData.mbMerged = mxCell->mbMerged;
159 0 : rData.mnRowSpan = mxCell->mnRowSpan;
160 0 : rData.mnColSpan = mxCell->mnColSpan;
161 : }
162 0 : }
163 :
164 :
165 : // class InsertRowUndo : public SdrUndoAction
166 :
167 :
168 0 : static void Dispose( RowVector& rRows )
169 : {
170 0 : RowVector::iterator aIter( rRows.begin() );
171 0 : while( aIter != rRows.end() )
172 0 : (*aIter++)->dispose();
173 0 : }
174 :
175 :
176 :
177 7 : InsertRowUndo::InsertRowUndo( const TableModelRef& xTable, sal_Int32 nIndex, RowVector& aNewRows )
178 7 : : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
179 : , mxTable( xTable )
180 : , mnIndex( nIndex )
181 7 : , mbUndo( true )
182 : {
183 7 : maRows.swap( aNewRows );
184 7 : }
185 :
186 :
187 :
188 18 : InsertRowUndo::~InsertRowUndo()
189 : {
190 6 : if( !mbUndo )
191 0 : Dispose( maRows );
192 12 : }
193 :
194 :
195 :
196 0 : void InsertRowUndo::Undo()
197 : {
198 0 : if( mxTable.is() )
199 : {
200 0 : mxTable->UndoInsertRows( mnIndex, sal::static_int_cast< sal_Int32 >( maRows.size() ) );
201 0 : mbUndo = false;
202 : }
203 0 : }
204 :
205 :
206 :
207 0 : void InsertRowUndo::Redo()
208 : {
209 0 : if( mxTable.is() )
210 : {
211 0 : mxTable->UndoRemoveRows( mnIndex, maRows );
212 0 : mbUndo = true;
213 : }
214 0 : }
215 :
216 :
217 : // class RemoveRowUndo : public SdrUndoAction
218 :
219 :
220 0 : RemoveRowUndo::RemoveRowUndo( const TableModelRef& xTable, sal_Int32 nIndex, RowVector& aRemovedRows )
221 0 : : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
222 : , mxTable( xTable )
223 : , mnIndex( nIndex )
224 0 : , mbUndo( true )
225 : {
226 0 : maRows.swap( aRemovedRows );
227 0 : }
228 :
229 :
230 :
231 0 : RemoveRowUndo::~RemoveRowUndo()
232 : {
233 0 : if( mbUndo )
234 0 : Dispose( maRows );
235 0 : }
236 :
237 :
238 :
239 0 : void RemoveRowUndo::Undo()
240 : {
241 0 : if( mxTable.is() )
242 : {
243 0 : mxTable->UndoRemoveRows( mnIndex, maRows );
244 0 : mbUndo = false;
245 : }
246 0 : }
247 :
248 :
249 :
250 0 : void RemoveRowUndo::Redo()
251 : {
252 0 : if( mxTable.is() )
253 : {
254 0 : mxTable->UndoInsertRows( mnIndex, sal::static_int_cast< sal_Int32 >( maRows.size() ) );
255 0 : mbUndo = true;
256 : }
257 0 : }
258 :
259 :
260 : // class InsertColUndo : public SdrUndoAction
261 :
262 :
263 0 : static void Dispose( ColumnVector& rCols )
264 : {
265 0 : ColumnVector::iterator aIter( rCols.begin() );
266 0 : while( aIter != rCols.end() )
267 0 : (*aIter++)->dispose();
268 0 : }
269 :
270 :
271 :
272 0 : static void Dispose( CellVector& rCells )
273 : {
274 0 : CellVector::iterator aIter( rCells.begin() );
275 0 : while( aIter != rCells.end() )
276 0 : (*aIter++)->dispose();
277 0 : }
278 :
279 :
280 :
281 15 : InsertColUndo::InsertColUndo( const TableModelRef& xTable, sal_Int32 nIndex, ColumnVector& aNewCols, CellVector& aCells )
282 15 : : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
283 : , mxTable( xTable )
284 : , mnIndex( nIndex )
285 15 : , mbUndo( true )
286 : {
287 15 : maColumns.swap( aNewCols );
288 15 : maCells.swap( aCells );
289 15 : }
290 :
291 :
292 :
293 42 : InsertColUndo::~InsertColUndo()
294 : {
295 14 : if( !mbUndo )
296 : {
297 0 : Dispose( maColumns );
298 0 : Dispose( maCells );
299 : }
300 28 : }
301 :
302 :
303 :
304 0 : void InsertColUndo::Undo()
305 : {
306 0 : if( mxTable.is() )
307 : {
308 0 : mxTable->UndoInsertColumns( mnIndex, sal::static_int_cast< sal_Int32 >( maColumns.size() ) );
309 0 : mbUndo = false;
310 : }
311 0 : }
312 :
313 :
314 :
315 0 : void InsertColUndo::Redo()
316 : {
317 0 : if( mxTable.is() )
318 : {
319 0 : mxTable->UndoRemoveColumns( mnIndex, maColumns, maCells );
320 0 : mbUndo = true;
321 : }
322 0 : }
323 :
324 :
325 : // class RemoveColUndo : public SdrUndoAction
326 :
327 :
328 0 : RemoveColUndo::RemoveColUndo( const TableModelRef& xTable, sal_Int32 nIndex, ColumnVector& aNewCols, CellVector& aCells )
329 0 : : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
330 : , mxTable( xTable )
331 : , mnIndex( nIndex )
332 0 : , mbUndo( true )
333 : {
334 0 : maColumns.swap( aNewCols );
335 0 : maCells.swap( aCells );
336 0 : }
337 :
338 :
339 :
340 0 : RemoveColUndo::~RemoveColUndo()
341 : {
342 0 : if( mbUndo )
343 : {
344 0 : Dispose( maColumns );
345 0 : Dispose( maCells );
346 : }
347 0 : }
348 :
349 :
350 :
351 0 : void RemoveColUndo::Undo()
352 : {
353 0 : if( mxTable.is() )
354 : {
355 0 : mxTable->UndoRemoveColumns( mnIndex, maColumns, maCells );
356 0 : mbUndo = false;
357 : }
358 0 : }
359 :
360 :
361 :
362 0 : void RemoveColUndo::Redo()
363 : {
364 0 : if( mxTable.is() )
365 : {
366 0 : mxTable->UndoInsertColumns( mnIndex, sal::static_int_cast< sal_Int32 >( maColumns.size() ) );
367 0 : mbUndo = true;
368 : }
369 0 : }
370 :
371 :
372 : // class TableColumnUndo : public SdrUndoAction
373 :
374 :
375 66 : TableColumnUndo::TableColumnUndo( const TableColumnRef& xCol )
376 66 : : SdrUndoAction( *xCol->mxTableModel->getSdrTableObj()->GetModel() )
377 : , mxCol( xCol )
378 66 : , mbHasRedoData( false )
379 : {
380 66 : getData( maUndoData );
381 66 : }
382 :
383 :
384 :
385 126 : TableColumnUndo::~TableColumnUndo()
386 : {
387 126 : }
388 :
389 :
390 :
391 0 : void TableColumnUndo::Undo()
392 : {
393 0 : if( !mbHasRedoData )
394 : {
395 0 : getData( maRedoData );
396 0 : mbHasRedoData = true;
397 : }
398 0 : setData( maUndoData );
399 0 : }
400 :
401 :
402 :
403 0 : void TableColumnUndo::Redo()
404 : {
405 0 : setData( maRedoData );
406 0 : }
407 :
408 :
409 :
410 0 : bool TableColumnUndo::Merge( SfxUndoAction *pNextAction )
411 : {
412 0 : TableColumnUndo* pNext = dynamic_cast< TableColumnUndo* >( pNextAction );
413 0 : return pNext && pNext->mxCol == mxCol;
414 : }
415 :
416 :
417 :
418 0 : void TableColumnUndo::setData( const Data& rData )
419 : {
420 0 : mxCol->mnColumn = rData.mnColumn;
421 0 : mxCol->mnWidth = rData.mnWidth;
422 0 : mxCol->mbOptimalWidth = rData.mbOptimalWidth;
423 0 : mxCol->mbIsVisible = rData.mbIsVisible;
424 0 : mxCol->mbIsStartOfNewPage = rData.mbIsStartOfNewPage;
425 0 : mxCol->maName = rData.maName;
426 0 : }
427 :
428 :
429 :
430 66 : void TableColumnUndo::getData( Data& rData )
431 : {
432 66 : rData.mnColumn = mxCol->mnColumn;
433 66 : rData.mnWidth = mxCol->mnWidth;
434 66 : rData.mbOptimalWidth = mxCol->mbOptimalWidth;
435 66 : rData.mbIsVisible = mxCol->mbIsVisible;
436 66 : rData.mbIsStartOfNewPage = mxCol->mbIsStartOfNewPage;
437 66 : rData.maName = mxCol->maName;
438 66 : }
439 :
440 :
441 : // class TableRowUndo : public SdrUndoAction
442 :
443 :
444 78 : TableRowUndo::TableRowUndo( const TableRowRef& xRow )
445 78 : : SdrUndoAction( *xRow->mxTableModel->getSdrTableObj()->GetModel() )
446 : , mxRow( xRow )
447 78 : , mbHasRedoData( false )
448 : {
449 78 : getData( maUndoData );
450 78 : }
451 :
452 :
453 :
454 148 : TableRowUndo::~TableRowUndo()
455 : {
456 148 : }
457 :
458 :
459 :
460 0 : void TableRowUndo::Undo()
461 : {
462 0 : if( !mbHasRedoData )
463 : {
464 0 : getData( maRedoData );
465 0 : mbHasRedoData = true;
466 : }
467 0 : setData( maUndoData );
468 0 : }
469 :
470 :
471 :
472 0 : void TableRowUndo::Redo()
473 : {
474 0 : setData( maRedoData );
475 0 : }
476 :
477 :
478 :
479 0 : bool TableRowUndo::Merge( SfxUndoAction *pNextAction )
480 : {
481 0 : TableRowUndo* pNext = dynamic_cast< TableRowUndo* >( pNextAction );
482 0 : return pNext && pNext->mxRow == mxRow;
483 : }
484 :
485 :
486 :
487 0 : void TableRowUndo::setData( const Data& rData )
488 : {
489 0 : mxRow->mnRow = rData.mnRow;
490 0 : mxRow->mnHeight = rData.mnHeight;
491 0 : mxRow->mbOptimalHeight = rData.mbOptimalHeight;
492 0 : mxRow->mbIsVisible = rData.mbIsVisible;
493 0 : mxRow->mbIsStartOfNewPage = rData.mbIsStartOfNewPage;
494 0 : mxRow->maName = rData.maName;
495 0 : }
496 :
497 :
498 :
499 78 : void TableRowUndo::getData( Data& rData )
500 : {
501 78 : rData.mnRow = mxRow->mnRow;
502 78 : rData.mnHeight = mxRow->mnHeight;
503 78 : rData.mbOptimalHeight = mxRow->mbOptimalHeight;
504 78 : rData.mbIsVisible = mxRow->mbIsVisible;
505 78 : rData.mbIsStartOfNewPage = mxRow->mbIsStartOfNewPage;
506 78 : rData.maName = mxRow->maName;
507 78 : }
508 :
509 :
510 :
511 0 : TableStyleUndo::TableStyleUndo( const SdrTableObj& rTableObj )
512 0 : : SdrUndoAction( *rTableObj.GetModel() )
513 : , mxObjRef( const_cast< sdr::table::SdrTableObj*>( &rTableObj ) )
514 0 : , mbHasRedoData(false)
515 : {
516 0 : getData( maUndoData );
517 0 : }
518 :
519 0 : void TableStyleUndo::Undo()
520 : {
521 0 : if( !mbHasRedoData )
522 : {
523 0 : getData( maRedoData );
524 0 : mbHasRedoData = true;
525 : }
526 0 : setData( maUndoData );
527 0 : }
528 :
529 0 : void TableStyleUndo::Redo()
530 : {
531 0 : setData( maRedoData );
532 0 : }
533 :
534 0 : void TableStyleUndo::setData( const Data& rData )
535 : {
536 0 : SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxObjRef.get() );
537 0 : if( pTableObj )
538 : {
539 0 : pTableObj->setTableStyle( rData.mxTableStyle );
540 0 : pTableObj->setTableStyleSettings( rData.maSettings );
541 : }
542 0 : }
543 :
544 0 : void TableStyleUndo::getData( Data& rData )
545 : {
546 0 : SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxObjRef.get() );
547 0 : if( pTableObj )
548 : {
549 0 : rData.maSettings = pTableObj->getTableStyleSettings();
550 0 : rData.mxTableStyle = pTableObj->getTableStyle();
551 : }
552 0 : }
553 :
554 435 : } }
555 :
556 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
