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