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