?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / svx / source / table / tablecontroller.cxx
blob4d6eb39511aa60f3e15401c675329d7456eea1e3
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: tablecontroller.cxx,v $
10 * $Revision: 1.3 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_svx.hxx"
33
34 #include "tablecontroller.hxx"
35
36 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
37 #include <com/sun/star/container/XIndexAccess.hpp>
38
39 #include <com/sun/star/beans/XPropertySet.hpp>
40 #include <com/sun/star/table/XMergeableCellRange.hpp>
41 #include <com/sun/star/table/XMergeableCell.hpp>
42
43 #include <sal/config.h>
44
45 #include <vcl/svapp.hxx>
46 #include <svtools/whiter.hxx>
47
48 #include <sfx2/request.hxx>
49
50 #include <svx/scripttypeitem.hxx>
51 #include <svx/svdotable.hxx>
52 #include <svx/sdr/overlay/overlayobjectcell.hxx>
53 #include <svx/sdr/overlay/overlaymanager.hxx>
54 #include <svx/svxids.hrc>
55 #include <svx/outlobj.hxx>
56 #include <svx/svdoutl.hxx>
57 #include <svx/svdpagv.hxx>
58 #include <svx/svdetc.hxx>
59 #include <svx/editobj.hxx>
60 #include "editstat.hxx"
61 #include "unolingu.hxx"
62 #include "svx/sdrpagewindow.hxx"
63 #include <svx/selectioncontroller.hxx>
64 #include <svx/svdmodel.hxx>
65 #include "sdrpaintwindow.hxx"
66 #include <svx/svxdlg.hxx>
67 #include <svx/boxitem.hxx>
68 #include "cell.hxx"
69 #include <svx/borderline.hxx>
70 #include <svx/colritem.hxx>
71 #include "bolnitem.hxx"
72 #include "svdstr.hrc"
73 #include "svdglob.hxx"
74 #include "svx/svdpage.hxx"
75 #include "tableundo.hxx"
76 #include "tablelayouter.hxx"
77
78 using ::rtl::OUString;
79 using namespace ::sdr::table;
80 using namespace ::com::sun::star;
81 using namespace ::com::sun::star::uno;
82 using namespace ::com::sun::star::table;
83 using namespace ::com::sun::star::beans;
84 using namespace ::com::sun::star::container;
85 using namespace ::com::sun::star::text;
86 using namespace ::com::sun::star::style;
87
88 namespace sdr { namespace table {
89
90 // --------------------------------------------------------------------
91 // class SvxTableControllerModifyListener
92 // --------------------------------------------------------------------
93
94 class SvxTableControllerModifyListener : public ::cppu::WeakImplHelper1< ::com::sun::star::util::XModifyListener >
95 {
96 public:
97 SvxTableControllerModifyListener( SvxTableController* pController )
98 : mpController( pController ) {}
99
100 // XModifyListener
101 virtual void SAL_CALL modified( const ::com::sun::star::lang::EventObject& aEvent ) throw (::com::sun::star::uno::RuntimeException);
102
103 // XEventListener
104 virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw (::com::sun::star::uno::RuntimeException);
105
106 SvxTableController* mpController;
107 };
108
109 // --------------------------------------------------------------------
110 // XModifyListener
111 // --------------------------------------------------------------------
112
113 void SAL_CALL SvxTableControllerModifyListener::modified( const ::com::sun::star::lang::EventObject& ) throw (::com::sun::star::uno::RuntimeException)
114 {
115 if( mpController )
116 mpController->onTableModified();
117 }
118
119 // --------------------------------------------------------------------
120 // XEventListener
121 // --------------------------------------------------------------------
122
123 void SAL_CALL SvxTableControllerModifyListener::disposing( const ::com::sun::star::lang::EventObject& ) throw (::com::sun::star::uno::RuntimeException)
124 {
125 mpController = 0;
126 }
127
128 // --------------------------------------------------------------------
129 // class SvxTableController
130 // --------------------------------------------------------------------
131
132 rtl::Reference< sdr::SelectionController > CreateTableController( SdrObjEditView* pView, const SdrObject* pObj, const rtl::Reference< sdr::SelectionController >& xRefController )
133 {
134 return SvxTableController::create( pView, pObj, xRefController );
135 }
136
137 // --------------------------------------------------------------------
138
139 rtl::Reference< sdr::SelectionController > SvxTableController::create( SdrObjEditView* pView, const SdrObject* pObj, const rtl::Reference< sdr::SelectionController >& xRefController )
140 {
141 if( xRefController.is() )
142 {
143 SvxTableController* pController = dynamic_cast< SvxTableController* >( xRefController.get() );
144 if( pController && (pController->mxTableObj.get() == pObj) && (pController->mpView == pView) )
145 return xRefController;
146 }
147 return new SvxTableController( pView, pObj );
148 }
149
150 // --------------------------------------------------------------------
151
152 SvxTableController::SvxTableController( SdrObjEditView* pView, const SdrObject* pObj )
153 : mbCellSelectionMode(false)
154 , mbLeftButtonDown(false)
155 , mpSelectionOverlay(0)
156 , mpView( dynamic_cast< SdrView* >( pView ) )
157 , mxTableObj( dynamic_cast< SdrTableObj* >( const_cast< SdrObject* >( pObj ) ) )
158 , mpModel( 0 )
159 , mnUpdateEvent( 0 )
160 {
161 if( pObj )
162 mpModel = pObj->GetModel();
163
164 if( mxTableObj.is() )
165 {
166 static_cast< const SdrTableObj* >( pObj )->getActiveCellPos( maCursorFirstPos );
167 maCursorLastPos = maCursorFirstPos;
168
169 Reference< XTable > xTable( static_cast< const SdrTableObj* >( pObj )->getTable() );
170 if( xTable.is() )
171 {
172 mxModifyListener = new SvxTableControllerModifyListener( this );
173 xTable->addModifyListener( mxModifyListener );
174
175 mxTable.set( dynamic_cast< TableModel* >( xTable.get() ) );
176 }
177 }
178 }
179
180 // --------------------------------------------------------------------
181
182 SvxTableController::~SvxTableController()
183 {
184 if( mnUpdateEvent )
185 {
186 Application::RemoveUserEvent( mnUpdateEvent );
187 }
188
189 if( mxModifyListener.is() && mxTableObj.get() )
190 {
191 Reference< XTable > xTable( static_cast< SdrTableObj* >( mxTableObj.get() )->getTable() );
192 if( xTable.is() )
193 {
194 xTable->removeModifyListener( mxModifyListener );
195 mxModifyListener.clear();
196 }
197 }
198 }
199
200 // --------------------------------------------------------------------
201
202 const sal_uInt16 ACTION_NONE = 0;
203 const sal_uInt16 ACTION_GOTO_FIRST_CELL = 1;
204 const sal_uInt16 ACTION_GOTO_FIRST_COLUMN = 2;
205 const sal_uInt16 ACTION_GOTO_FIRST_ROW = 3;
206 const sal_uInt16 ACTION_GOTO_LEFT_CELL = 4;
207 const sal_uInt16 ACTION_GOTO_UP_CELL = 5;
208 const sal_uInt16 ACTION_GOTO_RIGHT_CELL = 6;
209 const sal_uInt16 ACTION_GOTO_DOWN_CELL = 7;
210 const sal_uInt16 ACTION_GOTO_LAST_CELL = 8;
211 const sal_uInt16 ACTION_GOTO_LAST_COLUMN = 9;
212 const sal_uInt16 ACTION_GOTO_LAST_ROW = 10;
213 const sal_uInt16 ACTION_EDIT_CELL = 11;
214 const sal_uInt16 ACTION_STOP_TEXT_EDIT = 12;
215 const sal_uInt16 ACTION_REMOVE_SELECTION = 13;
216 const sal_uInt16 ACTION_START_SELECTION = 14;
217 const sal_uInt16 ACTION_HANDLED_BY_VIEW = 15;
218 const sal_uInt16 ACTION_TAB = 18;
219
220 bool SvxTableController::onKeyInput(const KeyEvent& rKEvt, Window* pWindow )
221 {
222 if( !checkTableObject() )
223 return false;
224
225 // check if we are read only
226 if( mpModel && mpModel->IsReadOnly())
227 {
228 switch( rKEvt.GetKeyCode().GetCode() )
229 {
230 case awt::Key::DOWN:
231 case awt::Key::UP:
232 case awt::Key::LEFT:
233 case awt::Key::RIGHT:
234 case awt::Key::TAB:
235 case awt::Key::HOME:
236 case awt::Key::END:
237 case awt::Key::NUM2:
238 case awt::Key::NUM4:
239 case awt::Key::NUM6:
240 case awt::Key::NUM8:
241 case awt::Key::ESCAPE:
242 case awt::Key::F2:
243 break;
244 default:
245 // tell the view we eat the event, no further processing needed
246 return true;
247 }
248 }
249
250 sal_uInt16 nAction = getKeyboardAction( rKEvt, pWindow );
251
252 return executeAction( nAction, ( rKEvt.GetKeyCode().IsShift() ) ? sal_True : sal_False, pWindow );
253 }
254
255 // --------------------------------------------------------------------
256 // ::com::sun::star::awt::XMouseClickHandler:
257 // --------------------------------------------------------------------
258
259 bool SvxTableController::onMouseButtonDown(const MouseEvent& rMEvt, Window* pWindow )
260 {
261 if( !pWindow || !checkTableObject() )
262 return false;
263
264 SdrViewEvent aVEvt;
265 if( !rMEvt.IsRight() && mpView->PickAnything(rMEvt,SDRMOUSEBUTTONDOWN, aVEvt) == SDRHIT_HANDLE )
266 return false;
267
268 TableHitKind eHit = static_cast< SdrTableObj* >(mxTableObj.get())->CheckTableHit( pWindow->PixelToLogic(rMEvt.GetPosPixel()), maMouseDownPos.mnCol, maMouseDownPos.mnRow, 0 );
269
270 mbLeftButtonDown = (rMEvt.GetClicks() == 1) && rMEvt.IsLeft();
271
272 if( eHit == SDRTABLEHIT_CELL )
273 {
274 StartSelection( maMouseDownPos );
275 return true;
276 }
277
278 if( rMEvt.IsRight() && eHit != SDRTABLEHIT_NONE )
279 return true; // right click will become context menu
280
281 // for cell selektion with the mouse remember our first hit
282 if( mbLeftButtonDown )
283 {
284 RemoveSelection();
285
286 Point aPnt(rMEvt.GetPosPixel());
287 if (pWindow!=NULL)
288 aPnt=pWindow->PixelToLogic(aPnt);
289
290 SdrHdl* pHdl = mpView->PickHandle(aPnt);
291
292 if( pHdl )
293 {
294 mbLeftButtonDown = false;
295 }
296 else
297 {
298 ::sdr::table::SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
299
300 if( !pWindow || !pTableObj || eHit == SDRTABLEHIT_NONE)
301 {
302 mbLeftButtonDown = false;
303 }
304 }
305 }
306
307 return false;
308 }
309
310 // --------------------------------------------------------------------
311
312 bool SvxTableController::onMouseButtonUp(const MouseEvent& rMEvt, Window* /*pWin*/)
313 {
314 if( !checkTableObject() )
315 return false;
316
317 mbLeftButtonDown = false;
318
319 if( rMEvt.GetClicks() == 2 )
320 return true;
321
322 return false;
323 }
324
325 // --------------------------------------------------------------------
326
327 bool SvxTableController::onMouseMove(const MouseEvent& rMEvt, Window* pWindow )
328 {
329 if( !checkTableObject() )
330 return false;
331
332 if( rMEvt.IsLeft() )
333 {
334 int i = 0;
335 i++;
336 }
337
338 SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxTableObj.get() );
339 CellPos aPos;
340 if( mbLeftButtonDown && pTableObj && pTableObj->CheckTableHit( pWindow->PixelToLogic(rMEvt.GetPosPixel()), aPos.mnCol, aPos.mnRow, 0 ) != SDRTABLEHIT_NONE )
341 {
342 if(aPos != maMouseDownPos)
343 {
344 if( mbCellSelectionMode )
345 {
346 setSelectedCells( maMouseDownPos, aPos );
347 return true;
348 }
349 else
350 {
351 StartSelection( maMouseDownPos );
352 }
353 }
354 else if( mbCellSelectionMode )
355 {
356 UpdateSelection( aPos );
357 return true;
358 }
359 }
360 return false;
361 }
362
363 // --------------------------------------------------------------------
364
365 void SvxTableController::onSelectionHasChanged()
366 {
367 bool bSelected = false;
368
369 SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxTableObj.get() );
370 if( pTableObj && pTableObj->IsTextEditActive() )
371 {
372 pTableObj->getActiveCellPos( maCursorFirstPos );
373 maCursorLastPos = maCursorFirstPos;
374 mbCellSelectionMode = false;
375 }
376 else
377 {
378 const SdrMarkList& rMarkList= mpView->GetMarkedObjectList();
379 if( rMarkList.GetMarkCount() == 1 )
380 bSelected = mxTableObj.get() == rMarkList.GetMark(0)->GetMarkedSdrObj();
381 }
382
383 if( bSelected )
384 {
385 updateSelectionOverlay();
386 }
387 else
388 {
389 destroySelectionOverlay();
390 }
391 }
392
393 // --------------------------------------------------------------------
394
395 void SvxTableController::GetState( SfxItemSet& rSet )
396 {
397 if( !mxTable.is() || !mxTableObj.is() || !mxTableObj->GetModel() )
398 return;
399
400 SfxItemSet* pSet = 0;
401
402 bool bVertDone = false;
403
404 // Iterate over all requested items in the set.
405 SfxWhichIter aIter( rSet );
406 USHORT nWhich = aIter.FirstWhich();
407 while (nWhich)
408 {
409 switch (nWhich)
410 {
411 case SID_TABLE_VERT_BOTTOM:
412 case SID_TABLE_VERT_CENTER:
413 case SID_TABLE_VERT_NONE:
414 {
415 if( !mxTable.is() || !mxTableObj->GetModel() )
416 {
417 rSet.DisableItem(nWhich);
418 }
419 else if(!bVertDone)
420 {
421 if( !pSet )
422 {
423 pSet = new SfxItemSet( mxTableObj->GetModel()->GetItemPool() );
424 MergeAttrFromSelectedCells(*pSet, FALSE);
425 }
426
427 SdrTextVertAdjust eAdj = SDRTEXTVERTADJUST_BLOCK;
428
429 if( pSet->GetItemState( SDRATTR_TEXT_VERTADJUST ) != SFX_ITEM_DONTCARE )
430 eAdj = ((SdrTextVertAdjustItem&)(pSet->Get(SDRATTR_TEXT_VERTADJUST))).GetValue();
431
432 rSet.Put(SfxBoolItem(SID_TABLE_VERT_BOTTOM, eAdj == SDRTEXTVERTADJUST_BOTTOM));
433 rSet.Put(SfxBoolItem(SID_TABLE_VERT_CENTER, eAdj == SDRTEXTVERTADJUST_CENTER));
434 rSet.Put(SfxBoolItem(SID_TABLE_VERT_NONE, eAdj == SDRTEXTVERTADJUST_TOP));
435 bVertDone = true;
436 }
437 break;
438 }
439 case SID_TABLE_DELETE_ROW:
440 if( !mxTable.is() || !hasSelectedCells() || (mxTable->getRowCount() <= 1) )
441 rSet.DisableItem(SID_TABLE_DELETE_ROW);
442 break;
443 case SID_TABLE_DELETE_COL:
444 if( !mxTable.is() || !hasSelectedCells() || (mxTable->getColumnCount() <= 1) )
445 rSet.DisableItem(SID_TABLE_DELETE_COL);
446 break;
447 case SID_TABLE_MERGE_CELLS:
448 if( !mxTable.is() || !hasSelectedCells() )
449 rSet.DisableItem(SID_TABLE_MERGE_CELLS);
450 break;
451 case SID_TABLE_SPLIT_CELLS:
452 if( !hasSelectedCells() || !mxTable.is() )
453 rSet.DisableItem(SID_TABLE_SPLIT_CELLS);
454 break;
455
456 case SID_OPTIMIZE_TABLE:
457 case SID_TABLE_DISTRIBUTE_COLUMNS:
458 case SID_TABLE_DISTRIBUTE_ROWS:
459 {
460 bool bDistributeColumns = false;
461 bool bDistributeRows = false;
462 if( mxTable.is() )
463 {
464 CellPos aStart, aEnd;
465 getSelectedCells( aStart, aEnd );
466
467 bDistributeColumns = aStart.mnCol != aEnd.mnCol;
468 bDistributeRows = aStart.mnRow != aEnd.mnRow;
469 }
470 if( !bDistributeColumns && !bDistributeRows )
471 rSet.DisableItem(SID_OPTIMIZE_TABLE);
472 if( !bDistributeColumns )
473 rSet.DisableItem(SID_TABLE_DISTRIBUTE_COLUMNS);
474 if( !bDistributeRows )
475 rSet.DisableItem(SID_TABLE_DISTRIBUTE_ROWS);
476 break;
477 }
478
479 case SID_AUTOFORMAT:
480 case SID_TABLE_SORT_DIALOG:
481 case SID_TABLE_AUTOSUM:
482 // if( !mxTable.is() )
483 // rSet.DisableItem( nWhich );
484 break;
485 default:
486 break;
487 }
488 nWhich = aIter.NextWhich();
489 }
490 if( pSet )
491 delete pSet;
492 }
493
494 // --------------------------------------------------------------------
495
496 void SvxTableController::onInsert( sal_uInt16 nSId, const SfxItemSet* pArgs )
497 {
498 ::sdr::table::SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
499 if( !pTableObj )
500 return;
501
502 if( mxTable.is() ) try
503 {
504 //
505 bool bInsertAfter = true;
506 sal_uInt16 nCount = 0;
507 if( pArgs )
508 {
509 const SfxPoolItem* pItem = 0;
510 pArgs->GetItemState(nSId, FALSE, &pItem);
511 if (pItem)
512 {
513 nCount = ((const SfxInt16Item* )pItem)->GetValue();
514 if(SFX_ITEM_SET == pArgs->GetItemState(SID_TABLE_PARAM_INSERT_AFTER, TRUE, &pItem))
515 bInsertAfter = ((const SfxBoolItem* )pItem)->GetValue();
516 }
517 }
518
519 CellPos aStart, aEnd;
520 if( hasSelectedCells() )
521 {
522 getSelectedCells( aStart, aEnd );
523 }
524 else
525 {
526 if( bInsertAfter )
527 {
528 aStart.mnCol = mxTable->getColumnCount() - 1;
529 aStart.mnRow = mxTable->getRowCount() - 1;
530 aEnd = aStart;
531 }
532 }
533
534 if( pTableObj->IsTextEditActive() )
535 mpView->SdrEndTextEdit(sal_True);
536
537 RemoveSelection();
538
539 const OUString sSize( RTL_CONSTASCII_USTRINGPARAM( "Size" ) );
540
541 const bool bUndo = mpModel && mpModel->IsUndoEnabled();
542
543 switch( nSId )
544 {
545 case SID_TABLE_INSERT_COL:
546 {
547 TableModelNotifyGuard aGuard( mxTable.get() );
548
549 if( bUndo )
550 {
551 mpModel->BegUndo( ImpGetResStr(STR_TABLE_INSCOL) );
552 mpModel->AddUndo( mpModel->GetSdrUndoFactory().CreateUndoGeoObject(*pTableObj) );
553 }
554
555 Reference< XTableColumns > xCols( mxTable->getColumns() );
556 const sal_Int32 nNewColumns = (nCount == 0) ? (aEnd.mnCol - aStart.mnCol + 1) : nCount;
557 const sal_Int32 nNewStartColumn = aEnd.mnCol + (bInsertAfter ? 1 : 0);
558 xCols->insertByIndex( nNewStartColumn, nNewColumns );
559
560 for( sal_Int32 nOffset = 0; nOffset < nNewColumns; nOffset++ )
561 {
562 Reference< XPropertySet >( xCols->getByIndex( aEnd.mnCol + nOffset + 1 ), UNO_QUERY_THROW )->
563 setPropertyValue( sSize,
564 Reference< XPropertySet >( xCols->getByIndex( aStart.mnCol + nOffset ), UNO_QUERY_THROW )->
565 getPropertyValue( sSize ) );
566 }
567
568 if( bUndo )
569 mpModel->EndUndo();
570
571 aStart.mnCol = nNewStartColumn;
572 aStart.mnRow = 0;
573 aEnd.mnCol = aStart.mnCol + nNewColumns - 1;
574 aEnd.mnRow = mxTable->getRowCount() - 1;
575 break;
576 }
577
578 case SID_TABLE_INSERT_ROW:
579 {
580 TableModelNotifyGuard aGuard( mxTable.get() );
581
582 if( bUndo )
583 {
584 mpModel->BegUndo( ImpGetResStr(STR_TABLE_INSROW ) );
585 mpModel->AddUndo( mpModel->GetSdrUndoFactory().CreateUndoGeoObject(*pTableObj) );
586 }
587
588 Reference< XTableRows > xRows( mxTable->getRows() );
589 const sal_Int32 nNewRows = (nCount == 0) ? (aEnd.mnRow - aStart.mnRow + 1) : nCount;
590 const sal_Int32 nNewRowStart = aEnd.mnRow + (bInsertAfter ? 1 : 0);
591 xRows->insertByIndex( nNewRowStart, nNewRows );
592
593 for( sal_Int32 nOffset = 0; nOffset < nNewRows; nOffset++ )
594 {
595 Reference< XPropertySet >( xRows->getByIndex( aEnd.mnRow + nOffset + 1 ), UNO_QUERY_THROW )->
596 setPropertyValue( sSize,
597 Reference< XPropertySet >( xRows->getByIndex( aStart.mnRow + nOffset ), UNO_QUERY_THROW )->
598 getPropertyValue( sSize ) );
599 }
600
601 if( bUndo )
602 mpModel->EndUndo();
603
604 aStart.mnCol = 0;
605 aStart.mnRow = nNewRowStart;
606 aEnd.mnCol = mxTable->getColumnCount() - 1;
607 aEnd.mnRow = aStart.mnRow + nNewRows - 1;
608 break;
609 }
610 }
611
612 StartSelection( aStart );
613 UpdateSelection( aEnd );
614 }
615 catch( Exception& e )
616 {
617 (void)e;
618 DBG_ERROR("svx::SvxTableController::onInsert(), exception caught!");
619 }
620 }
621
622 // --------------------------------------------------------------------
623
624 void SvxTableController::onDelete( sal_uInt16 nSId )
625 {
626 ::sdr::table::SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
627 if( !pTableObj )
628 return;
629
630 if( mxTable.is() && hasSelectedCells() )
631 {
632 CellPos aStart, aEnd;
633 getSelectedCells( aStart, aEnd );
634
635 if( pTableObj->IsTextEditActive() )
636 mpView->SdrEndTextEdit(sal_True);
637
638 RemoveSelection();
639
640 bool bDeleteTable = false;
641 switch( nSId )
642 {
643 case SID_TABLE_DELETE_COL:
644 {
645 const sal_Int32 nRemovedColumns = aEnd.mnCol - aStart.mnCol + 1;
646 if( nRemovedColumns == mxTable->getColumnCount() )
647 {
648 bDeleteTable = true;
649 }
650 else
651 {
652 Reference< XTableColumns > xCols( mxTable->getColumns() );
653 xCols->removeByIndex( aStart.mnCol, nRemovedColumns );
654 }
655 break;
656 }
657
658 case SID_TABLE_DELETE_ROW:
659 {
660 const sal_Int32 nRemovedRows = aEnd.mnRow - aStart.mnRow + 1;
661 if( nRemovedRows == mxTable->getRowCount() )
662 {
663 bDeleteTable = true;
664 }
665 else
666 {
667 Reference< XTableRows > xRows( mxTable->getRows() );
668 xRows->removeByIndex( aStart.mnRow, nRemovedRows );
669 }
670 break;
671 }
672 }
673
674 if( bDeleteTable )
675 mpView->DeleteMarkedObj();
676 else
677 UpdateTableShape();
678 }
679 }
680
681 // --------------------------------------------------------------------
682
683 void SvxTableController::onSelect( sal_uInt16 nSId )
684 {
685 if( mxTable.is() )
686 {
687 const sal_Int32 nRowCount = mxTable->getRowCount();
688 const sal_Int32 nColCount = mxTable->getColumnCount();
689 if( nRowCount && nColCount )
690 {
691 CellPos aStart, aEnd;
692 getSelectedCells( aStart, aEnd );
693
694 switch( nSId )
695 {
696 case SID_TABLE_SELECT_ALL:
697 aEnd.mnCol = 0; aEnd.mnRow = 0;
698 aStart.mnCol = nColCount - 1; aStart.mnRow = nRowCount - 1;
699 break;
700 case SID_TABLE_SELECT_COL:
701 aEnd.mnRow = nRowCount - 1;
702 aStart.mnRow = 0;
703 break;
704 case SID_TABLE_SELECT_ROW:
705 aEnd.mnCol = nColCount - 1;
706 aStart.mnCol = 0;
707 break;
708 }
709
710 StartSelection( aEnd );
711 gotoCell( aStart, true, 0 );
712 }
713 }
714 }
715
716 // --------------------------------------------------------------------
717 void SvxTableController::onFormatTable( SfxRequest& rReq )
718 {
719 ::sdr::table::SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
720 if( !pTableObj )
721 return;
722
723 const SfxItemSet* pArgs = rReq.GetArgs();
724
725 if( !pArgs && pTableObj->GetModel() )
726 {
727 SfxItemSet aNewAttr( pTableObj->GetModel()->GetItemPool() );
728 MergeAttrFromSelectedCells(aNewAttr, FALSE);
729
730 // merge drawing layer text distance items into SvxBoxItem used by the dialog
731 SvxBoxItem aBoxItem( static_cast< const SvxBoxItem& >( aNewAttr.Get( SDRATTR_TABLE_BORDER ) ) );
732 aBoxItem.SetDistance( sal::static_int_cast< USHORT >( ((SdrTextLeftDistItem&)(aNewAttr.Get(SDRATTR_TEXT_LEFTDIST))).GetValue()), BOX_LINE_LEFT );
733 aBoxItem.SetDistance( sal::static_int_cast< USHORT >( ((SdrTextRightDistItem&)(aNewAttr.Get(SDRATTR_TEXT_RIGHTDIST))).GetValue()), BOX_LINE_RIGHT );
734 aBoxItem.SetDistance( sal::static_int_cast< USHORT >( ((SdrTextUpperDistItem&)(aNewAttr.Get(SDRATTR_TEXT_UPPERDIST))).GetValue()), BOX_LINE_TOP );
735 aBoxItem.SetDistance( sal::static_int_cast< USHORT >( ((SdrTextLowerDistItem&)(aNewAttr.Get(SDRATTR_TEXT_LOWERDIST))).GetValue()), BOX_LINE_BOTTOM );
736 aNewAttr.Put( aBoxItem );
737
738 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
739 std::auto_ptr< SfxAbstractTabDialog > pDlg( pFact ? pFact->CreateSvxFormatCellsDialog( NULL, &aNewAttr, pTableObj->GetModel(), pTableObj) : 0 );
740 if( pDlg.get() && pDlg->Execute() )
741 {
742 SfxItemSet aNewSet( *(pDlg->GetOutputItemSet ()) );
743
744 SvxBoxItem aNewBoxItem( static_cast< const SvxBoxItem& >( aNewSet.Get( SDRATTR_TABLE_BORDER ) ) );
745
746 if( aNewBoxItem.GetDistance( BOX_LINE_LEFT ) != aBoxItem.GetDistance( BOX_LINE_LEFT ) )
747 aNewSet.Put(SdrTextLeftDistItem( aNewBoxItem.GetDistance( BOX_LINE_LEFT ) ) );
748
749 if( aNewBoxItem.GetDistance( BOX_LINE_RIGHT ) != aBoxItem.GetDistance( BOX_LINE_RIGHT ) )
750 aNewSet.Put(SdrTextRightDistItem( aNewBoxItem.GetDistance( BOX_LINE_RIGHT ) ) );
751
752 if( aNewBoxItem.GetDistance( BOX_LINE_TOP ) != aBoxItem.GetDistance( BOX_LINE_TOP ) )
753 aNewSet.Put(SdrTextUpperDistItem( aNewBoxItem.GetDistance( BOX_LINE_TOP ) ) );
754
755 if( aNewBoxItem.GetDistance( BOX_LINE_BOTTOM ) != aBoxItem.GetDistance( BOX_LINE_BOTTOM ) )
756 aNewSet.Put(SdrTextLowerDistItem( aNewBoxItem.GetDistance( BOX_LINE_BOTTOM ) ) );
757
758 SetAttrToSelectedCells(aNewSet, FALSE);
759 }
760 UpdateTableShape();
761 }
762 }
763
764 // --------------------------------------------------------------------
765
766 void SvxTableController::Execute( SfxRequest& rReq )
767 {
768 const sal_uInt16 nSId = rReq.GetSlot();
769 switch( nSId )
770 {
771 case SID_TABLE_INSERT_ROW:
772 case SID_TABLE_INSERT_COL:
773 onInsert( nSId, rReq.GetArgs() );
774 break;
775 case SID_TABLE_DELETE_ROW:
776 case SID_TABLE_DELETE_COL:
777 onDelete( nSId );
778 break;
779 case SID_TABLE_SELECT_ALL:
780 case SID_TABLE_SELECT_COL:
781 case SID_TABLE_SELECT_ROW:
782 onSelect( nSId );
783 break;
784 case SID_FORMAT_TABLE_DLG:
785 onFormatTable( rReq );
786 break;
787
788 case SID_FRAME_LINESTYLE:
789 case SID_FRAME_LINECOLOR:
790 case SID_ATTR_BORDER:
791 {
792 const SfxItemSet* pArgs = rReq.GetArgs();
793 if( pArgs )
794 ApplyBorderAttr( *pArgs );
795 }
796 break;
797
798 case SID_ATTR_FILL_STYLE:
799 {
800 const SfxItemSet* pArgs = rReq.GetArgs();
801 if( pArgs )
802 SetAttributes( *pArgs, false );
803 }
804 break;
805
806 case SID_TABLE_MERGE_CELLS:
807 MergeMarkedCells();
808 break;
809
810 case SID_TABLE_SPLIT_CELLS:
811 SplitMarkedCells();
812 break;
813
814 case SID_TABLE_DISTRIBUTE_COLUMNS:
815 DistributeColumns();
816 break;
817
818 case SID_TABLE_DISTRIBUTE_ROWS:
819 DistributeRows();
820 break;
821
822 case SID_TABLE_VERT_BOTTOM:
823 case SID_TABLE_VERT_CENTER:
824 case SID_TABLE_VERT_NONE:
825 SetVertical( nSId );
826 break;
827
828 case SID_AUTOFORMAT:
829 case SID_TABLE_SORT_DIALOG:
830 case SID_TABLE_AUTOSUM:
831 default:
832 break;
833
834 case SID_TABLE_STYLE:
835 SetTableStyle( rReq.GetArgs() );
836 break;
837
838 case SID_TABLE_STYLE_SETTINGS:
839 SetTableStyleSettings( rReq.GetArgs() );
840 break;
841 }
842 }
843
844 void SvxTableController::SetTableStyle( const SfxItemSet* pArgs )
845 {
846 SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
847 SdrModel* pModel = pTableObj ? pTableObj->GetModel() : 0;
848
849 if( !pTableObj || !pModel || !pArgs || (SFX_ITEM_SET != pArgs->GetItemState(SID_TABLE_STYLE, FALSE)) )
850 return;
851
852 const SfxStringItem* pArg = dynamic_cast< const SfxStringItem* >( &pArgs->Get( SID_TABLE_STYLE ) );
853 if( pArg && mxTable.is() ) try
854 {
855 Reference< XStyleFamiliesSupplier > xSFS( pModel->getUnoModel(), UNO_QUERY_THROW );
856 Reference< XNameAccess > xFamilyNameAccess( xSFS->getStyleFamilies(), UNO_QUERY_THROW );
857 const OUString sFamilyName( RTL_CONSTASCII_USTRINGPARAM( "table" ) );
858 Reference< XNameAccess > xTableFamilyAccess( xFamilyNameAccess->getByName( sFamilyName ), UNO_QUERY_THROW );
859
860 if( xTableFamilyAccess->hasByName( pArg->GetValue() ) )
861 {
862 // found table style with the same name
863 Reference< XIndexAccess > xNewTableStyle( xTableFamilyAccess->getByName( pArg->GetValue() ), UNO_QUERY_THROW );
864
865 const bool bUndo = pModel->IsUndoEnabled();
866
867 if( bUndo )
868 {
869 pModel->BegUndo( ImpGetResStr(STR_TABLE_STYLE) );
870 pModel->AddUndo( new TableStyleUndo( *pTableObj ) );
871 }
872
873 pTableObj->setTableStyle( xNewTableStyle );
874
875 const sal_Int32 nRowCount = mxTable->getRowCount();
876 const sal_Int32 nColCount = mxTable->getColumnCount();
877 for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ )
878 {
879 for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ ) try
880 {
881 CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
882 if( xCell.is() )
883 {
884 SfxItemSet aSet( xCell->GetItemSet() );
885 bool bChanges = false;
886 const SfxItemSet& rStyleAttribs = xCell->GetStyleSheet()->GetItemSet();
887
888 for ( USHORT nWhich = SDRATTR_START; nWhich <= SDRATTR_TABLE_LAST; nWhich++ )
889 {
890 if( (rStyleAttribs.GetItemState( nWhich ) == SFX_ITEM_ON) && (aSet.GetItemState( nWhich ) == SFX_ITEM_ON) )
891 {
892 aSet.ClearItem( nWhich );
893 bChanges = true;
894 }
895 }
896
897 if( bChanges )
898 {
899 if( bUndo )
900 xCell->AddUndo();
901
902 xCell->SetMergedItemSetAndBroadcast( aSet, sal_True );
903 }
904 }
905 }
906 catch( Exception& e )
907 {
908 (void)e;
909 DBG_ERROR( "svx::SvxTableController::SetTableStyle(), exception caught!" );
910 }
911 }
912
913 if( bUndo )
914 pModel->EndUndo();
915 }
916 }
917 catch( Exception& e )
918 {
919 (void)e;
920 DBG_ERROR( "svx::SvxTableController::SetTableStyle(), exception caught!" );
921 }
922 }
923
924 void SvxTableController::SetTableStyleSettings( const SfxItemSet* pArgs )
925 {
926 SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
927 SdrModel* pModel = pTableObj ? pTableObj->GetModel() : 0;
928
929 if( !pTableObj || !pModel )
930 return;
931
932 TableStyleSettings aSettings( pTableObj->getTableStyleSettings() );
933
934 const SfxPoolItem *pPoolItem=NULL;
935
936 if( (SFX_ITEM_SET == pArgs->GetItemState(ID_VAL_USEFIRSTROWSTYLE, FALSE,&pPoolItem)) )
937 aSettings.mbUseFirstRow = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
938
939 if( (SFX_ITEM_SET == pArgs->GetItemState(ID_VAL_USELASTROWSTYLE, FALSE,&pPoolItem)) )
940 aSettings.mbUseLastRow = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
941
942 if( (SFX_ITEM_SET == pArgs->GetItemState(ID_VAL_USEBANDINGROWSTYLE, FALSE,&pPoolItem)) )
943 aSettings.mbUseRowBanding = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
944
945 if( (SFX_ITEM_SET == pArgs->GetItemState(ID_VAL_USEFIRSTCOLUMNSTYLE, FALSE,&pPoolItem)) )
946 aSettings.mbUseFirstColumn = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
947
948 if( (SFX_ITEM_SET == pArgs->GetItemState(ID_VAL_USELASTCOLUMNSTYLE, FALSE,&pPoolItem)) )
949 aSettings.mbUseLastColumn = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
950
951 if( (SFX_ITEM_SET == pArgs->GetItemState(ID_VAL_USEBANDINGCOLUMNSTYLE, FALSE,&pPoolItem)) )
952 aSettings.mbUseColumnBanding = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
953
954 if( aSettings == pTableObj->getTableStyleSettings() )
955 return;
956
957 const bool bUndo = pModel->IsUndoEnabled();
958
959 if( bUndo )
960 {
961 pModel->BegUndo( ImpGetResStr(STR_TABLE_STYLE_SETTINGS) );
962 pModel->AddUndo( new TableStyleUndo( *pTableObj ) );
963 }
964
965 pTableObj->setTableStyleSettings( aSettings );
966
967 if( bUndo )
968 pModel->EndUndo();
969 }
970
971 void SvxTableController::SetVertical( sal_uInt16 nSId )
972 {
973 SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
974 if( mxTable.is() && pTableObj )
975 {
976 TableModelNotifyGuard aGuard( mxTable.get() );
977
978 CellPos aStart, aEnd;
979 getSelectedCells( aStart, aEnd );
980
981 SdrTextVertAdjust eAdj = SDRTEXTVERTADJUST_TOP;
982
983 switch( nSId )
984 {
985 case SID_TABLE_VERT_BOTTOM:
986 eAdj = SDRTEXTVERTADJUST_BOTTOM;
987 break;
988 case SID_TABLE_VERT_CENTER:
989 eAdj = SDRTEXTVERTADJUST_CENTER;
990 break;
991 //case SID_TABLE_VERT_NONE:
992 default:
993 break;
994 }
995
996 SdrTextVertAdjustItem aItem( eAdj );
997
998 for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
999 {
1000 for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
1001 {
1002 CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
1003 if( xCell.is() )
1004 xCell->SetMergedItem(aItem);
1005 }
1006 }
1007
1008 UpdateTableShape();
1009 }
1010 }
1011
1012 void SvxTableController::MergeMarkedCells()
1013 {
1014 CellPos aStart, aEnd;
1015 getSelectedCells( aStart, aEnd );
1016 SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
1017 if( pTableObj )
1018 {
1019 if( pTableObj->IsTextEditActive() )
1020 mpView->SdrEndTextEdit(sal_True);
1021
1022 TableModelNotifyGuard aGuard( mxTable.get() );
1023 MergeRange( aStart.mnCol, aStart.mnRow, aEnd.mnCol, aEnd.mnRow );
1024 }
1025 }
1026
1027 void SvxTableController::SplitMarkedCells()
1028 {
1029 if( mxTable.is() )
1030 {
1031 CellPos aStart, aEnd;
1032 getSelectedCells( aStart, aEnd );
1033
1034 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
1035 std::auto_ptr< SvxAbstractSplittTableDialog > xDlg( pFact ? pFact->CreateSvxSplittTableDialog( NULL, false, 99, 99 ) : 0 );
1036 if( xDlg.get() && xDlg->Execute() )
1037 {
1038 const sal_Int32 nCount = xDlg->GetCount() - 1;
1039 if( nCount < 1 )
1040 return;
1041
1042 getSelectedCells( aStart, aEnd );
1043
1044 Reference< XMergeableCellRange > xRange( mxTable->createCursorByRange( mxTable->getCellRangeByPosition( aStart.mnCol, aStart.mnRow, aEnd.mnCol, aEnd.mnRow ) ), UNO_QUERY_THROW );
1045
1046 const sal_Int32 nRowCount = mxTable->getRowCount();
1047 const sal_Int32 nColCount = mxTable->getColumnCount();
1048
1049
1050 SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxTableObj.get() );
1051 if( pTableObj )
1052 {
1053 if( pTableObj->IsTextEditActive() )
1054 mpView->SdrEndTextEdit(sal_True);
1055
1056 TableModelNotifyGuard aGuard( mxTable.get() );
1057
1058 const bool bUndo = mpModel && mpModel->IsUndoEnabled();
1059 if( bUndo )
1060 {
1061 mpModel->BegUndo( ImpGetResStr(STR_TABLE_SPLIT) );
1062 mpModel->AddUndo( mpModel->GetSdrUndoFactory().CreateUndoGeoObject(*pTableObj) );
1063 }
1064
1065 if( xDlg->IsHorizontal() )
1066 {
1067 xRange->split( 0, nCount );
1068 }
1069 else
1070 {
1071 xRange->split( nCount, 0 );
1072 }
1073
1074 if( bUndo )
1075 mpModel->EndUndo();
1076 }
1077 aEnd.mnRow += mxTable->getRowCount() - nRowCount;
1078 aEnd.mnCol += mxTable->getColumnCount() - nColCount;
1079
1080 setSelectedCells( aStart, aEnd );
1081 }
1082 }
1083 }
1084
1085 void SvxTableController::DistributeColumns()
1086 {
1087 SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxTableObj.get() );
1088 if( pTableObj )
1089 {
1090 const bool bUndo = mpModel && mpModel->IsUndoEnabled();
1091 if( bUndo )
1092 {
1093 mpModel->BegUndo( ImpGetResStr(STR_TABLE_DISTRIBUTE_COLUMNS) );
1094 mpModel->AddUndo( mpModel->GetSdrUndoFactory().CreateUndoGeoObject(*pTableObj) );
1095 }
1096
1097 CellPos aStart, aEnd;
1098 getSelectedCells( aStart, aEnd );
1099 pTableObj->DistributeColumns( aStart.mnCol, aEnd.mnCol );
1100
1101 if( bUndo )
1102 mpModel->EndUndo();
1103 }
1104 }
1105
1106 void SvxTableController::DistributeRows()
1107 {
1108 SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxTableObj.get() );
1109 if( pTableObj )
1110 {
1111 const bool bUndo = mpModel && mpModel->IsUndoEnabled();
1112 if( bUndo )
1113 {
1114 mpModel->BegUndo( ImpGetResStr(STR_TABLE_DISTRIBUTE_ROWS) );
1115 mpModel->AddUndo( mpModel->GetSdrUndoFactory().CreateUndoGeoObject(*pTableObj) );
1116 }
1117
1118 CellPos aStart, aEnd;
1119 getSelectedCells( aStart, aEnd );
1120 pTableObj->DistributeRows( aStart.mnRow, aEnd.mnRow );
1121
1122 if( bUndo )
1123 mpModel->EndUndo();
1124 }
1125 }
1126
1127 bool SvxTableController::DeleteMarked()
1128 {
1129 if( mbCellSelectionMode )
1130 {
1131 if( mxTable.is() )
1132 {
1133 CellPos aStart, aEnd;
1134 getSelectedCells( aStart, aEnd );
1135 for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
1136 {
1137 for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
1138 {
1139 CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
1140 if( xCell.is() )
1141 xCell->SetOutlinerParaObject( 0 );
1142 }
1143 }
1144
1145 UpdateTableShape();
1146 return true;
1147 }
1148 }
1149
1150 return false;
1151 }
1152
1153 bool SvxTableController::GetStyleSheet( SfxStyleSheet*& rpStyleSheet ) const
1154 {
1155 if( hasSelectedCells() )
1156 {
1157 rpStyleSheet = 0;
1158
1159 if( mxTable.is() )
1160 {
1161 SfxStyleSheet* pRet=0;
1162 bool b1st=true;
1163
1164 CellPos aStart, aEnd;
1165 const_cast<SvxTableController&>(*this).getSelectedCells( aStart, aEnd );
1166
1167 for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
1168 {
1169 for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
1170 {
1171 CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
1172 if( xCell.is() )
1173 {
1174 SfxStyleSheet* pSS=xCell->GetStyleSheet();
1175 if(b1st)
1176 {
1177 pRet=pSS;
1178 }
1179 else if(pRet != pSS)
1180 {
1181 return true;
1182 }
1183 b1st=false;
1184 }
1185 }
1186 }
1187 rpStyleSheet = pRet;
1188 return true;
1189 }
1190 }
1191 return false;
1192 }
1193
1194 bool SvxTableController::SetStyleSheet( SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr )
1195 {
1196 if( hasSelectedCells() && (!pStyleSheet || pStyleSheet->GetFamily() == SFX_STYLE_FAMILY_FRAME) )
1197 {
1198 if( mxTable.is() )
1199 {
1200 CellPos aStart, aEnd;
1201 getSelectedCells( aStart, aEnd );
1202
1203 for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
1204 {
1205 for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
1206 {
1207 CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
1208 if( xCell.is() )
1209 xCell->SetStyleSheet(pStyleSheet,bDontRemoveHardAttr);
1210 }
1211 }
1212
1213 UpdateTableShape();
1214 return true;
1215 }
1216 }
1217 return false;
1218 }
1219
1220 // --------------------------------------------------------------------
1221 // internals
1222 // --------------------------------------------------------------------
1223
1224 bool SvxTableController::checkTableObject()
1225 {
1226 return mxTableObj.is();
1227 }
1228
1229 // --------------------------------------------------------------------
1230
1231 sal_uInt16 SvxTableController::getKeyboardAction( const KeyEvent& rKEvt, Window* /*pWindow*/ )
1232 {
1233 const bool bMod1 = rKEvt.GetKeyCode().IsMod1(); // ctrl
1234 const bool bMod2 = rKEvt.GetKeyCode().IsMod2() != 0; // Alt
1235
1236 const bool bTextEdit = mpView->IsTextEdit();
1237
1238 sal_uInt16 nAction = ACTION_HANDLED_BY_VIEW;
1239
1240 ::sdr::table::SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
1241 if( !pTableObj )
1242 return nAction;
1243
1244 // handle special keys
1245 const sal_Int16 nCode = rKEvt.GetKeyCode().GetCode();
1246 switch( nCode )
1247 {
1248 case awt::Key::ESCAPE: // handle escape
1249 {
1250 if( bTextEdit )
1251 {
1252 // escape during text edit ends text edit
1253 nAction = ACTION_STOP_TEXT_EDIT;
1254 }
1255 if( mbCellSelectionMode )
1256 {
1257 // escape with selected cells removes selection
1258 nAction = ACTION_REMOVE_SELECTION;
1259 }
1260 break;
1261 }
1262 case awt::Key::RETURN: // handle return
1263 {
1264 if( !bMod1 && !bMod2 && !bTextEdit )
1265 {
1266 // when not already editing, return starts text edit
1267 setSelectionStart( pTableObj->getFirstCell() );
1268 nAction = ACTION_EDIT_CELL;
1269 }
1270 break;
1271 }
1272 case awt::Key::F2: // f2 toggles text edit
1273 {
1274 if( bMod1 || bMod2 ) // f2 with modifiers is handled by the view
1275 {
1276 }
1277 else if( bTextEdit )
1278 {
1279 // f2 during text edit stops text edit
1280 nAction = ACTION_STOP_TEXT_EDIT;
1281 }
1282 else if( mbCellSelectionMode )
1283 {
1284 // f2 with selected cells removes selection
1285 nAction = ACTION_REMOVE_SELECTION;
1286 }
1287 else
1288 {
1289 // f2 with no selection and no text edit starts text edit
1290 setSelectionStart( pTableObj->getFirstCell() );
1291 nAction = ACTION_EDIT_CELL;
1292 }
1293 break;
1294 }
1295 case awt::Key::HOME:
1296 case awt::Key::NUM7:
1297 {
1298 if( (bMod1 || bMod2) && (bTextEdit || mbCellSelectionMode) )
1299 {
1300 if( bMod1 && !bMod2 )
1301 {
1302 // strg + home jumps to first cell
1303 nAction = ACTION_GOTO_FIRST_CELL;
1304 }
1305 else if( !bMod1 && bMod2 )
1306 {
1307 // alt + home jumps to first column
1308 nAction = ACTION_GOTO_FIRST_COLUMN;
1309 }
1310 }
1311 break;
1312 }
1313 case awt::Key::END:
1314 case awt::Key::NUM1:
1315 {
1316 if( (bMod1 || bMod2) && (bTextEdit || mbCellSelectionMode) )
1317 {
1318 if( bMod1 && !bMod2 )
1319 {
1320 // strg + end jumps to last cell
1321 nAction = ACTION_GOTO_LAST_CELL;
1322 }
1323 else if( !bMod1 && bMod2 )
1324 {
1325 // alt + home jumps to last column
1326 nAction = ACTION_GOTO_LAST_COLUMN;
1327 }
1328 }
1329 break;
1330 }
1331
1332 case awt::Key::TAB:
1333 {
1334 if( bTextEdit || mbCellSelectionMode )
1335 nAction = ACTION_TAB;
1336 break;
1337 }
1338
1339 case awt::Key::UP:
1340 case awt::Key::NUM8:
1341 case awt::Key::DOWN:
1342 case awt::Key::NUM2:
1343 case awt::Key::LEFT:
1344 case awt::Key::NUM4:
1345 case awt::Key::RIGHT:
1346 case awt::Key::NUM6:
1347 {
1348 bool bTextMove = false;
1349
1350 if( !bMod1 && bMod2 )
1351 {
1352 if( (nCode == awt::Key::UP) || (nCode == awt::Key::NUM8) )
1353 {
1354 nAction = ACTION_GOTO_LEFT_CELL;
1355 }
1356 else if( (nCode == awt::Key::DOWN) || (nCode == awt::Key::NUM2) )
1357 {
1358 nAction = ACTION_GOTO_RIGHT_CELL;
1359 }
1360 break;
1361 }
1362
1363 if( !bTextMove )
1364 {
1365 OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
1366 if( pOLV )
1367 {
1368 RemoveSelection();
1369 // during text edit, check if we navigate out of the cell
1370 ESelection aOldSelection = pOLV->GetSelection();
1371 pOLV->PostKeyEvent(rKEvt);
1372 bTextMove = pOLV && ( aOldSelection.IsEqual(pOLV->GetSelection()) );
1373 if( !bTextMove )
1374 {
1375 nAction = ACTION_NONE;
1376 }
1377 }
1378 }
1379
1380 if( mbCellSelectionMode || bTextMove )
1381 {
1382 // no text edit, navigate in cells if selection active
1383 switch( nCode )
1384 {
1385 case awt::Key::LEFT:
1386 case awt::Key::NUM4:
1387 nAction = ACTION_GOTO_LEFT_CELL;
1388 break;
1389 case awt::Key::RIGHT:
1390 case awt::Key::NUM6:
1391 nAction = ACTION_GOTO_RIGHT_CELL;
1392 break;
1393 case awt::Key::DOWN:
1394 case awt::Key::NUM2:
1395 nAction = ACTION_GOTO_DOWN_CELL;
1396 break;
1397 case awt::Key::UP:
1398 case awt::Key::NUM8:
1399 nAction = ACTION_GOTO_UP_CELL;
1400 break;
1401 }
1402 }
1403 break;
1404 }
1405 case awt::Key::PAGEUP:
1406 if( bMod2 )
1407 nAction = ACTION_GOTO_FIRST_ROW;
1408 break;
1409
1410 case awt::Key::PAGEDOWN:
1411 if( bMod2 )
1412 nAction = ACTION_GOTO_LAST_ROW;
1413 break;
1414 }
1415 return nAction;
1416 }
1417
1418 bool SvxTableController::executeAction( sal_uInt16 nAction, bool bSelect, Window* pWindow )
1419 {
1420 ::sdr::table::SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
1421 if( !pTableObj )
1422 return false;
1423
1424 switch( nAction )
1425 {
1426 case ACTION_GOTO_FIRST_CELL:
1427 {
1428 gotoCell( pTableObj->getFirstCell(), bSelect, pWindow, nAction );
1429 break;
1430 }
1431
1432 case ACTION_GOTO_LEFT_CELL:
1433 {
1434 gotoCell( pTableObj->getLeftCell( getSelectionEnd(), !bSelect ), bSelect, pWindow, nAction );
1435 break;
1436 }
1437
1438 case ACTION_GOTO_RIGHT_CELL:
1439 {
1440 gotoCell( pTableObj->getRightCell( getSelectionEnd(), !bSelect ), bSelect, pWindow, nAction);
1441 break;
1442 }
1443
1444 case ACTION_GOTO_LAST_CELL:
1445 {
1446 gotoCell( pTableObj->getLastCell(), bSelect, pWindow, nAction );
1447 break;
1448 }
1449
1450 case ACTION_GOTO_FIRST_COLUMN:
1451 {
1452 CellPos aPos( pTableObj->getFirstCell().mnCol, getSelectionEnd().mnRow );
1453 gotoCell( aPos, bSelect, pWindow, nAction );
1454 break;
1455 }
1456
1457 case ACTION_GOTO_LAST_COLUMN:
1458 {
1459 CellPos aPos( pTableObj->getLastCell().mnCol, getSelectionEnd().mnRow );
1460 gotoCell( aPos, bSelect, pWindow, nAction );
1461 break;
1462 }
1463
1464 case ACTION_GOTO_FIRST_ROW:
1465 {
1466 CellPos aPos( getSelectionEnd().mnCol, pTableObj->getFirstCell().mnRow );
1467 gotoCell( aPos, bSelect, pWindow, nAction );
1468 break;
1469 }
1470
1471 case ACTION_GOTO_UP_CELL:
1472 {
1473 gotoCell( pTableObj->getUpCell(getSelectionEnd(), !bSelect), bSelect, pWindow, nAction );
1474 break;
1475 }
1476
1477 case ACTION_GOTO_DOWN_CELL:
1478 {
1479 gotoCell( pTableObj->getDownCell(getSelectionEnd(), !bSelect), bSelect, pWindow, nAction );
1480 break;
1481 }
1482
1483 case ACTION_GOTO_LAST_ROW:
1484 {
1485 CellPos aPos( getSelectionEnd().mnCol, pTableObj->getLastCell().mnRow );
1486 gotoCell( aPos, bSelect, pWindow, nAction );
1487 break;
1488 }
1489
1490 case ACTION_EDIT_CELL:
1491 EditCell( getSelectionStart(), pWindow, 0, nAction );
1492 break;
1493
1494 case ACTION_STOP_TEXT_EDIT:
1495 StopTextEdit();
1496 break;
1497
1498 case ACTION_REMOVE_SELECTION:
1499 RemoveSelection();
1500 break;
1501
1502 case ACTION_START_SELECTION:
1503 StartSelection( getSelectionStart() );
1504 break;
1505
1506 case ACTION_TAB:
1507 {
1508 if( bSelect )
1509 gotoCell( pTableObj->getPreviousCell( getSelectionEnd(), true ), false, pWindow, nAction );
1510 else
1511 {
1512 CellPos aSelectionEnd( getSelectionEnd() );
1513 CellPos aNextCell( pTableObj->getNextCell( aSelectionEnd, true ) );
1514 if( aSelectionEnd == aNextCell )
1515 {
1516 onInsert( SID_TABLE_INSERT_ROW, 0 );
1517 aNextCell = pTableObj->getNextCell( aSelectionEnd, true );
1518 }
1519 gotoCell( aNextCell, false, pWindow, nAction );
1520 }
1521 break;
1522 }
1523 }
1524
1525 return nAction != ACTION_HANDLED_BY_VIEW;
1526 }
1527
1528 // --------------------------------------------------------------------
1529
1530 void SvxTableController::gotoCell( const CellPos& rPos, bool bSelect, Window* pWindow, sal_uInt16 nAction )
1531 {
1532 if( mxTableObj.is() && static_cast<SdrTableObj*>(mxTableObj.get())->IsTextEditActive() )
1533 mpView->SdrEndTextEdit(sal_True);
1534
1535 if( bSelect )
1536 {
1537 maCursorLastPos = rPos;
1538 if( mxTableObj.is() )
1539 static_cast< SdrTableObj* >( mxTableObj.get() )->setActiveCell( rPos );
1540
1541 if( !mbCellSelectionMode )
1542 {
1543 setSelectedCells( maCursorFirstPos, rPos );
1544 }
1545 else
1546 {
1547 UpdateSelection( rPos );
1548 }
1549 }
1550 else
1551 {
1552 RemoveSelection();
1553 EditCell( rPos, pWindow, 0, nAction );
1554 }
1555 }
1556
1557 // --------------------------------------------------------------------
1558
1559 const CellPos& SvxTableController::getSelectionStart()
1560 {
1561 checkCell( maCursorFirstPos );
1562 return maCursorFirstPos;
1563 }
1564
1565 // --------------------------------------------------------------------
1566
1567 void SvxTableController::setSelectionStart( const CellPos& rPos )
1568 {
1569 maCursorFirstPos = rPos;
1570 }
1571
1572 // --------------------------------------------------------------------
1573
1574 const CellPos& SvxTableController::getSelectionEnd()
1575 {
1576 checkCell( maCursorLastPos );
1577 return maCursorLastPos;
1578 }
1579
1580 // --------------------------------------------------------------------
1581
1582 Reference< XCellCursor > SvxTableController::getSelectionCursor()
1583 {
1584 Reference< XCellCursor > xCursor;
1585
1586 if( mxTable.is() )
1587 {
1588 if( hasSelectedCells() )
1589 {
1590 CellPos aStart, aEnd;
1591 getSelectedCells( aStart, aEnd );
1592 xCursor = mxTable->createCursorByRange( mxTable->getCellRangeByPosition( aStart.mnCol, aStart.mnRow, aEnd.mnCol, aEnd.mnRow ) );
1593 }
1594 else
1595 {
1596 xCursor = mxTable->createCursor();
1597 }
1598 }
1599
1600 return xCursor;
1601 }
1602
1603 void SvxTableController::MergeRange( sal_Int32 nFirstCol, sal_Int32 nFirstRow, sal_Int32 nLastCol, sal_Int32 nLastRow )
1604 {
1605 if( mxTable.is() ) try
1606 {
1607 Reference< XMergeableCellRange > xRange( mxTable->createCursorByRange( mxTable->getCellRangeByPosition( nFirstCol, nFirstRow,nLastCol, nLastRow ) ), UNO_QUERY_THROW );
1608 if( xRange->isMergeable() )
1609 {
1610 const bool bUndo = mpModel && mpModel->IsUndoEnabled();
1611 if( bUndo )
1612 {
1613 mpModel->BegUndo( ImpGetResStr(STR_TABLE_MERGE) );
1614 mpModel->AddUndo( mpModel->GetSdrUndoFactory().CreateUndoGeoObject(*mxTableObj.get()) );
1615 }
1616
1617 xRange->merge();
1618
1619 if( bUndo )
1620 mpModel->EndUndo();
1621 }
1622 }
1623 catch( Exception& )
1624 {
1625 DBG_ASSERT( false, "sdr::table::SvxTableController::MergeRange(), exception caught!" );
1626 }
1627 }
1628
1629
1630
1631 // --------------------------------------------------------------------
1632
1633 void SvxTableController::checkCell( CellPos& rPos )
1634 {
1635 if( mxTable.is() ) try
1636 {
1637 if( rPos.mnCol >= mxTable->getColumnCount() )
1638 rPos.mnCol = mxTable->getColumnCount()-1;
1639
1640 if( rPos.mnRow >= mxTable->getRowCount() )
1641 rPos.mnRow = mxTable->getRowCount()-1;
1642 }
1643 catch( Exception& e )
1644 {
1645 (void)e;
1646 DBG_ERROR("sdr::table::SvxTableController::checkCell(), exception caught!" );
1647 }
1648 }
1649
1650 // --------------------------------------------------------------------
1651
1652 void SvxTableController::findMergeOrigin( CellPos& rPos )
1653 {
1654 if( mxTable.is() ) try
1655 {
1656 Reference< XMergeableCell > xCell( mxTable->getCellByPosition( rPos.mnCol, rPos.mnRow ), UNO_QUERY_THROW );
1657 if( xCell.is() && xCell->isMerged() )
1658 {
1659 ::findMergeOrigin( mxTable, rPos.mnCol, rPos.mnRow, rPos.mnCol, rPos.mnRow );
1660 }
1661 }
1662 catch( Exception& e )
1663 {
1664 (void)e;
1665 DBG_ERROR("sdr::table::SvxTableController::findMergeOrigin(), exception caught!" );
1666 }
1667 }
1668
1669 // --------------------------------------------------------------------
1670
1671 void SvxTableController::EditCell( const CellPos& rPos, ::Window* pWindow, const awt::MouseEvent* pMouseEvent /*= 0*/, sal_uInt16 nAction /*= ACTION_NONE */ )
1672 {
1673 SdrPageView* pPV = mpView->GetSdrPageView();
1674
1675 ::sdr::table::SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
1676 if( pTableObj && pTableObj->GetPage() == pPV->GetPage() )
1677 {
1678 bool bEmptyOutliner = false;
1679
1680 if(!pTableObj->GetOutlinerParaObject() && mpView->GetTextEditOutliner())
1681 {
1682 ::Outliner* pOutl = mpView->GetTextEditOutliner();
1683 ULONG nParaAnz = pOutl->GetParagraphCount();
1684 Paragraph* p1stPara = pOutl->GetParagraph( 0 );
1685
1686 if(nParaAnz==1 && p1stPara)
1687 {
1688 // Bei nur einem Pararaph
1689 if (pOutl->GetText(p1stPara).Len() == 0)
1690 {
1691 bEmptyOutliner = true;
1692 }
1693 }
1694 }
1695
1696 CellPos aPos( rPos );
1697 findMergeOrigin( aPos );
1698
1699 if( pTableObj != mpView->GetTextEditObject() || bEmptyOutliner || !pTableObj->IsTextEditActive( aPos ) )
1700 {
1701 if( pTableObj->IsTextEditActive() )
1702 mpView->SdrEndTextEdit(sal_True);
1703
1704 pTableObj->setActiveCell( aPos );
1705
1706 // create new outliner, owner will be the SdrObjEditView
1707 SdrOutliner* pOutl = SdrMakeOutliner( OUTLINERMODE_OUTLINEOBJECT, mpModel );
1708 if( pTableObj->IsVerticalWriting() )
1709 pOutl->SetVertical( TRUE );
1710
1711 if(mpView->SdrBeginTextEdit(pTableObj, pPV, pWindow, sal_True, pOutl))
1712 {
1713 maCursorLastPos = maCursorFirstPos = rPos;
1714
1715 OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
1716
1717 bool bNoSel = true;
1718
1719 if( pMouseEvent )
1720 {
1721 ::MouseEvent aMEvt( *pMouseEvent );
1722
1723 SdrViewEvent aVEvt;
1724 SdrHitKind eHit = mpView->PickAnything(aMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
1725
1726 if (eHit == SDRHIT_TEXTEDIT)
1727 {
1728 // Text getroffen
1729 pOLV->MouseButtonDown(aMEvt);
1730 pOLV->MouseMove(aMEvt);
1731 pOLV->MouseButtonUp(aMEvt);
1732 // pOLV->MouseButtonDown(aMEvt);
1733 bNoSel = false;
1734 }
1735 else
1736 {
1737 nAction = ACTION_GOTO_LEFT_CELL;
1738 }
1739 }
1740
1741 if( bNoSel )
1742 {
1743 // Move cursor to end of text
1744 ESelection aNewSelection;
1745
1746 const WritingMode eMode = pTableObj->GetWritingMode();
1747 if( ((nAction == ACTION_GOTO_LEFT_CELL) || (nAction == ACTION_GOTO_RIGHT_CELL)) && (eMode != WritingMode_TB_RL) )
1748 {
1749 const bool bLast = ((nAction == ACTION_GOTO_LEFT_CELL) && (eMode == WritingMode_LR_TB)) ||
1750 ((nAction == ACTION_GOTO_RIGHT_CELL) && (eMode == WritingMode_RL_TB));
1751
1752 if( bLast )
1753 aNewSelection = ESelection(EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND, EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND);
1754 }
1755 pOLV->SetSelection(aNewSelection);
1756 }
1757 }
1758 }
1759 }
1760 }
1761
1762 // --------------------------------------------------------------------
1763
1764 bool SvxTableController::StopTextEdit()
1765 {
1766 if(mpView->IsTextEdit())
1767 {
1768 mpView->SdrEndTextEdit();
1769 mpView->SetCurrentObj(OBJ_TABLE);
1770 mpView->SetEditMode(SDREDITMODE_EDIT);
1771 return true;
1772 }
1773 else
1774 {
1775 return false;
1776 }
1777 }
1778
1779 // --------------------------------------------------------------------
1780
1781 void SvxTableController::DeleteTable()
1782 {
1783 //
1784 }
1785
1786 // --------------------------------------------------------------------
1787
1788 void SvxTableController::getSelectedCells( CellPos& rFirst, CellPos& rLast )
1789 {
1790 if( mbCellSelectionMode )
1791 {
1792 checkCell( maCursorFirstPos );
1793 checkCell( maCursorLastPos );
1794
1795 rFirst.mnCol = std::min( maCursorFirstPos.mnCol, maCursorLastPos.mnCol );
1796 rFirst.mnRow = std::min( maCursorFirstPos.mnRow, maCursorLastPos.mnRow );
1797 rLast.mnCol = std::max( maCursorFirstPos.mnCol, maCursorLastPos.mnCol );
1798 rLast.mnRow = std::max( maCursorFirstPos.mnRow, maCursorLastPos.mnRow );
1799
1800 bool bExt = false;
1801 if( mxTable.is() ) do
1802 {
1803 bExt = false;
1804 for( sal_Int32 nRow = rFirst.mnRow; nRow <= rLast.mnRow && !bExt; nRow++ )
1805 {
1806 for( sal_Int32 nCol = rFirst.mnCol; nCol <= rLast.mnCol && !bExt; nCol++ )
1807 {
1808 Reference< XMergeableCell > xCell( mxTable->getCellByPosition( nCol, nRow ), UNO_QUERY );
1809 if( !xCell.is() )
1810 continue;
1811
1812 if( xCell->isMerged() )
1813 {
1814 CellPos aPos( nCol, nRow );
1815 findMergeOrigin( aPos );
1816 if( (aPos.mnCol < rFirst.mnCol) || (aPos.mnRow < rFirst.mnRow) )
1817 {
1818 rFirst.mnCol = std::min( rFirst.mnCol, aPos.mnCol );
1819 rFirst.mnRow = std::min( rFirst.mnRow, aPos.mnRow );
1820 bExt = true;
1821 }
1822 }
1823 else
1824 {
1825 if( ((nCol + xCell->getColumnSpan() - 1) > rLast.mnCol) || (nRow + xCell->getRowSpan() - 1 ) > rLast.mnRow )
1826 {
1827 rLast.mnCol = std::max( rLast.mnCol, nCol + xCell->getColumnSpan() - 1 );
1828 rLast.mnRow = std::max( rLast.mnRow, nRow + xCell->getRowSpan() - 1 );
1829 bExt = true;
1830 }
1831 }
1832 }
1833 }
1834 }
1835 while(bExt);
1836 }
1837 else if( mpView && mpView->IsTextEdit() )
1838 {
1839 rFirst = getSelectionStart();
1840 findMergeOrigin( rFirst );
1841 rLast = rFirst;
1842
1843 if( mxTable.is() )
1844 {
1845 Reference< XMergeableCell > xCell( mxTable->getCellByPosition( rLast.mnCol, rLast.mnRow ), UNO_QUERY );
1846 if( xCell.is() )
1847 {
1848 rLast.mnCol += xCell->getColumnSpan() - 1;
1849 rLast.mnRow += xCell->getRowSpan() - 1;
1850 }
1851 }
1852 }
1853 else
1854 {
1855 rFirst.mnCol = 0;
1856 rFirst.mnRow = 0;
1857 if( mxTable.is() )
1858 {
1859 rLast.mnRow = mxTable->getRowCount()-1;
1860 rLast.mnCol = mxTable->getColumnCount()-1;
1861 }
1862 else
1863 {
1864 rLast.mnRow = 0;
1865 rLast.mnCol = 0;
1866 }
1867 }
1868 }
1869
1870 // --------------------------------------------------------------------
1871
1872 void SvxTableController::StartSelection( const CellPos& rPos )
1873 {
1874 StopTextEdit();
1875 mbCellSelectionMode = true;
1876 maCursorLastPos = maCursorFirstPos = rPos;
1877 mpView->MarkListHasChanged();
1878 }
1879
1880 // --------------------------------------------------------------------
1881
1882 void SvxTableController::setSelectedCells( const CellPos& rStart, const CellPos& rEnd )
1883 {
1884 StopTextEdit();
1885 mbCellSelectionMode = true;
1886 maCursorFirstPos = rStart;
1887 UpdateSelection( rEnd );
1888 }
1889
1890 // --------------------------------------------------------------------
1891
1892 void SvxTableController::UpdateSelection( const CellPos& rPos )
1893 {
1894 maCursorLastPos = rPos;
1895 mpView->MarkListHasChanged();
1896 }
1897
1898 // --------------------------------------------------------------------
1899
1900 void SvxTableController::clearSelection()
1901 {
1902 RemoveSelection();
1903 }
1904
1905 // --------------------------------------------------------------------
1906
1907 void SvxTableController::selectAll()
1908 {
1909 if( mxTable.is() )
1910 {
1911 CellPos aPos1, aPos2( mxTable->getColumnCount()-1, mxTable->getRowCount()-1 );
1912 if( (aPos2.mnCol >= 0) && (aPos2.mnRow >= 0) )
1913 {
1914 setSelectedCells( aPos1, aPos2 );
1915 }
1916 }
1917 }
1918
1919 // --------------------------------------------------------------------
1920
1921 void SvxTableController::RemoveSelection()
1922 {
1923 if( mbCellSelectionMode )
1924 {
1925 mbCellSelectionMode = false;
1926 mpView->MarkListHasChanged();
1927 }
1928 }
1929
1930 // --------------------------------------------------------------------
1931
1932 void SvxTableController::onTableModified()
1933 {
1934 if( mnUpdateEvent == 0 )
1935 mnUpdateEvent = Application::PostUserEvent( LINK( this, SvxTableController, UpdateHdl ) );
1936 }
1937 // --------------------------------------------------------------------
1938
1939 void SvxTableController::updateSelectionOverlay()
1940 {
1941 destroySelectionOverlay();
1942 if( mbCellSelectionMode )
1943 {
1944 ::sdr::table::SdrTableObj* pTableObj = dynamic_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
1945 if( pTableObj )
1946 {
1947 sdr::overlay::OverlayObjectCell::RangeVector aRanges;
1948
1949 Rectangle aRect;
1950 CellPos aStart,aEnd;
1951 getSelectedCells( aStart, aEnd );
1952 pTableObj->getCellBounds( aStart, aRect );
1953
1954 basegfx::B2DRange a2DRange( basegfx::B2DPoint(aRect.Left(), aRect.Top()) );
1955 a2DRange.expand( basegfx::B2DPoint(aRect.Right(), aRect.Bottom()) );
1956
1957 findMergeOrigin( aEnd );
1958 pTableObj->getCellBounds( aEnd, aRect );
1959 a2DRange.expand( basegfx::B2DPoint(aRect.Left(), aRect.Top()) );
1960 a2DRange.expand( basegfx::B2DPoint(aRect.Right(), aRect.Bottom()) );
1961 aRanges.push_back( a2DRange );
1962
1963 ::Color aHighlight( COL_BLUE );
1964 OutputDevice* pOutDev = mpView->GetFirstOutputDevice();
1965 if( pOutDev )
1966 aHighlight = pOutDev->GetSettings().GetStyleSettings().GetHighlightColor();
1967
1968 const sal_uInt32 nCount = mpView->PaintWindowCount();
1969 for( sal_uInt32 nIndex = 0; nIndex < nCount; nIndex++ )
1970 {
1971 SdrPaintWindow* pPaintWindow = mpView->GetPaintWindow(nIndex);
1972 if( pPaintWindow )
1973 {
1974 ::sdr::overlay::OverlayManager* pOverlayManager = pPaintWindow->GetOverlayManager();
1975 if( pOverlayManager )
1976 {
1977 // sdr::overlay::CellOverlayType eType = sdr::overlay::CELL_OVERLAY_INVERT;
1978 sdr::overlay::CellOverlayType eType = sdr::overlay::CELL_OVERLAY_TRANSPARENT;
1979
1980 sdr::overlay::OverlayObjectCell* pOverlay = new sdr::overlay::OverlayObjectCell( eType, aHighlight, aRanges );
1981
1982 pOverlayManager->add(*pOverlay);
1983 mpSelectionOverlay = new ::sdr::overlay::OverlayObjectList;
1984 mpSelectionOverlay->append(*pOverlay);
1985 }
1986 }
1987 }
1988 }
1989 }
1990 }
1991
1992 // --------------------------------------------------------------------
1993
1994 void SvxTableController::destroySelectionOverlay()
1995 {
1996 if( mpSelectionOverlay )
1997 {
1998 delete mpSelectionOverlay;
1999 mpSelectionOverlay = 0;
2000 }
2001 }
2002
2003 // --------------------------------------------------------------------
2004
2005 void SvxTableController::MergeAttrFromSelectedCells(SfxItemSet& rAttr, bool bOnlyHardAttr) const
2006 {
2007 if( mxTable.is() )
2008 {
2009 CellPos aStart, aEnd;
2010 const_cast<SvxTableController&>(*this).getSelectedCells( aStart, aEnd );
2011
2012 for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
2013 {
2014 for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
2015 {
2016 CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
2017 if( xCell.is() && !xCell->isMerged() )
2018 {
2019 const SfxItemSet& rSet = xCell->GetItemSet();
2020 SfxWhichIter aIter(rSet);
2021 sal_uInt16 nWhich(aIter.FirstWhich());
2022 while(nWhich)
2023 {
2024 if(!bOnlyHardAttr)
2025 {
2026 if(SFX_ITEM_DONTCARE == rSet.GetItemState(nWhich, FALSE))
2027 rAttr.InvalidateItem(nWhich);
2028 else
2029 rAttr.MergeValue(rSet.Get(nWhich), TRUE);
2030 }
2031 else if(SFX_ITEM_SET == rSet.GetItemState(nWhich, FALSE))
2032 {
2033 const SfxPoolItem& rItem = rSet.Get(nWhich);
2034 rAttr.MergeValue(rItem, TRUE);
2035 }
2036
2037 nWhich = aIter.NextWhich();
2038 }
2039 }
2040 }
2041 }
2042 }
2043
2044 if( mpView->IsTextEdit() )
2045 {
2046 }
2047 }
2048
2049 // --------------------------------------------------------------------
2050
2051 const sal_uInt16 CELL_BEFORE = 0x0001;
2052 const sal_uInt16 CELL_LEFT = 0x0002;
2053 const sal_uInt16 CELL_RIGHT = 0x0004;
2054 const sal_uInt16 CELL_AFTER = 0x0008;
2055
2056 const sal_uInt16 CELL_UPPER = 0x0010;
2057 const sal_uInt16 CELL_TOP = 0x0020;
2058 const sal_uInt16 CELL_BOTTOM = 0x0040;
2059 const sal_uInt16 CELL_LOWER = 0x0080;
2060
2061 // --------------------------------------------------------------------
2062
2063 static void ImplSetLinePreserveColor( SvxBoxItem& rNewFrame, const SvxBorderLine* pNew, USHORT nLine )
2064 {
2065 if( pNew )
2066 {
2067 const SvxBorderLine* pOld = rNewFrame.GetLine(nLine);
2068 if( pOld )
2069 {
2070 SvxBorderLine aNewLine( *pNew );
2071 aNewLine.SetColor( pOld->GetColor() );
2072 rNewFrame.SetLine( &aNewLine, nLine );
2073 return;
2074 }
2075 }
2076 rNewFrame.SetLine( pNew, nLine );
2077 }
2078
2079 // --------------------------------------------------------------------
2080
2081 static void ImplApplyBoxItem( sal_uInt16 nCellFlags, const SvxBoxItem* pBoxItem, const SvxBoxInfoItem* pBoxInfoItem, SvxBoxItem& rNewFrame )
2082 {
2083 if( (nCellFlags & (CELL_BEFORE|CELL_AFTER|CELL_UPPER|CELL_LOWER)) != 0 )
2084 {
2085 // current cell is outside the selection
2086
2087 if( (nCellFlags & ( CELL_BEFORE|CELL_AFTER)) == 0 ) // check if its not nw or ne corner
2088 {
2089 if( nCellFlags & CELL_UPPER )
2090 {
2091 if( pBoxInfoItem->IsValid(VALID_TOP) )
2092 rNewFrame.SetLine(0, BOX_LINE_BOTTOM );
2093 }
2094 else if( nCellFlags & CELL_LOWER )
2095 {
2096 if( pBoxInfoItem->IsValid(VALID_BOTTOM) )
2097 rNewFrame.SetLine( 0, BOX_LINE_TOP );
2098 }
2099 }
2100 else if( (nCellFlags & ( CELL_UPPER|CELL_LOWER)) == 0 ) // check if its not sw or se corner
2101 {
2102 if( nCellFlags & CELL_BEFORE )
2103 {
2104 if( pBoxInfoItem->IsValid(VALID_LEFT) )
2105 rNewFrame.SetLine( 0, BOX_LINE_RIGHT );
2106 }
2107 else if( nCellFlags & CELL_AFTER )
2108 {
2109 if( pBoxInfoItem->IsValid(VALID_RIGHT) )
2110 rNewFrame.SetLine( 0, BOX_LINE_LEFT );
2111 }
2112 }
2113 }
2114 else
2115 {
2116 // current cell is inside the selection
2117
2118 if( (nCellFlags & CELL_LEFT) ? pBoxInfoItem->IsValid(VALID_LEFT) : pBoxInfoItem->IsValid(VALID_VERT) )
2119 rNewFrame.SetLine( (nCellFlags & CELL_LEFT) ? pBoxItem->GetLeft() : pBoxInfoItem->GetVert(), BOX_LINE_LEFT );
2120
2121 if( (nCellFlags & CELL_RIGHT) ? pBoxInfoItem->IsValid(VALID_RIGHT) : pBoxInfoItem->IsValid(VALID_VERT) )
2122 rNewFrame.SetLine( (nCellFlags & CELL_RIGHT) ? pBoxItem->GetRight() : pBoxInfoItem->GetVert(), BOX_LINE_RIGHT );
2123
2124 if( (nCellFlags & CELL_TOP) ? pBoxInfoItem->IsValid(VALID_TOP) : pBoxInfoItem->IsValid(VALID_HORI) )
2125 rNewFrame.SetLine( (nCellFlags & CELL_TOP) ? pBoxItem->GetTop() : pBoxInfoItem->GetHori(), BOX_LINE_TOP );
2126
2127 if( (nCellFlags & CELL_BOTTOM) ? pBoxInfoItem->IsValid(VALID_BOTTOM) : pBoxInfoItem->IsValid(VALID_HORI) )
2128 rNewFrame.SetLine( (nCellFlags & CELL_BOTTOM) ? pBoxItem->GetBottom() : pBoxInfoItem->GetHori(), BOX_LINE_BOTTOM );
2129
2130 // apply distance to borders
2131 if( pBoxInfoItem->IsValid( VALID_DISTANCE ) )
2132 for( USHORT nLine = 0; nLine < 4; ++nLine )
2133 rNewFrame.SetDistance( pBoxItem->GetDistance( nLine ), nLine );
2134 }
2135 }
2136
2137 // --------------------------------------------------------------------
2138
2139 static void ImplSetLineColor( SvxBoxItem& rNewFrame, USHORT nLine, const Color& rColor )
2140 {
2141 const SvxBorderLine* pSourceLine = rNewFrame.GetLine( nLine );
2142 if( pSourceLine )
2143 {
2144 SvxBorderLine aLine( *pSourceLine );
2145 aLine.SetColor( rColor );
2146 rNewFrame.SetLine( &aLine, nLine );
2147 }
2148 }
2149
2150 // --------------------------------------------------------------------
2151
2152 static void ImplApplyLineColorItem( sal_uInt16 nCellFlags, const SvxColorItem* pLineColorItem, SvxBoxItem& rNewFrame )
2153 {
2154 const Color aColor( pLineColorItem->GetValue() );
2155
2156 if( (nCellFlags & (CELL_LOWER|CELL_BEFORE|CELL_AFTER)) == 0 )
2157 ImplSetLineColor( rNewFrame, BOX_LINE_BOTTOM, aColor );
2158
2159 if( (nCellFlags & (CELL_UPPER|CELL_BEFORE|CELL_AFTER)) == 0 )
2160 ImplSetLineColor( rNewFrame, BOX_LINE_TOP, aColor );
2161
2162 if( (nCellFlags & (CELL_UPPER|CELL_LOWER|CELL_AFTER)) == 0 )
2163 ImplSetLineColor( rNewFrame, BOX_LINE_RIGHT, aColor );
2164
2165 if( (nCellFlags & (CELL_UPPER|CELL_LOWER|CELL_BEFORE)) == 0 )
2166 ImplSetLineColor( rNewFrame, BOX_LINE_LEFT, aColor );
2167 }
2168
2169 // --------------------------------------------------------------------
2170
2171 static void ImplApplyBorderLineItem( sal_uInt16 nCellFlags, const SvxBorderLine* pBorderLineItem, SvxBoxItem& rNewFrame )
2172 {
2173 if( (nCellFlags & ( CELL_BEFORE|CELL_AFTER|CELL_UPPER|CELL_LOWER)) != 0 )
2174 {
2175 if( (nCellFlags & ( CELL_BEFORE|CELL_AFTER)) == 0 ) // check if its not nw or ne corner
2176 {
2177 if( nCellFlags & CELL_UPPER )
2178 {
2179 if( rNewFrame.GetBottom() )
2180 ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, BOX_LINE_BOTTOM );
2181 }
2182 else if( nCellFlags & CELL_LOWER )
2183 {
2184 if( rNewFrame.GetTop() )
2185 ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, BOX_LINE_TOP );
2186 }
2187 }
2188 else if( (nCellFlags & ( CELL_UPPER|CELL_LOWER)) == 0 ) // check if its not sw or se corner
2189 {
2190 if( nCellFlags & CELL_BEFORE )
2191 {
2192 if( rNewFrame.GetRight() )
2193 ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, BOX_LINE_RIGHT );
2194 }
2195 else if( nCellFlags & CELL_AFTER )
2196 {
2197 if( rNewFrame.GetLeft() )
2198 ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, BOX_LINE_LEFT );
2199 }
2200 }
2201 }
2202 else
2203 {
2204 if( rNewFrame.GetBottom() )
2205 ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, BOX_LINE_BOTTOM );
2206 if( rNewFrame.GetTop() )
2207 ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, BOX_LINE_TOP );
2208 if( rNewFrame.GetRight() )
2209 ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, BOX_LINE_RIGHT );
2210 if( rNewFrame.GetLeft() )
2211 ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, BOX_LINE_LEFT );
2212 }
2213 }
2214
2215 // --------------------------------------------------------------------
2216
2217 void SvxTableController::ApplyBorderAttr( const SfxItemSet& rAttr )
2218 {
2219 if( mxTable.is() )
2220 {
2221 const sal_Int32 nRowCount = mxTable->getRowCount();
2222 const sal_Int32 nColCount = mxTable->getColumnCount();
2223 if( nRowCount && nColCount )
2224 {
2225 const SvxBoxItem* pBoxItem = 0;
2226 if(SFX_ITEM_SET == rAttr.GetItemState(SDRATTR_TABLE_BORDER, FALSE) )
2227 pBoxItem = dynamic_cast< const SvxBoxItem* >( &rAttr.Get( SDRATTR_TABLE_BORDER ) );
2228
2229 const SvxBoxInfoItem* pBoxInfoItem = 0;
2230 if(SFX_ITEM_SET == rAttr.GetItemState(SDRATTR_TABLE_BORDER_INNER, FALSE) )
2231 pBoxInfoItem = dynamic_cast< const SvxBoxInfoItem* >( &rAttr.Get( SDRATTR_TABLE_BORDER_INNER ) );
2232
2233 const SvxColorItem* pLineColorItem = 0;
2234 if(SFX_ITEM_SET == rAttr.GetItemState(SID_FRAME_LINECOLOR, FALSE) )
2235 pLineColorItem = dynamic_cast< const SvxColorItem* >( &rAttr.Get( SID_FRAME_LINECOLOR ) );
2236
2237 const SvxBorderLine* pBorderLineItem = 0;
2238 if(SFX_ITEM_SET == rAttr.GetItemState(SID_FRAME_LINESTYLE, FALSE) )
2239 pBorderLineItem = ((const SvxLineItem&)rAttr.Get( SID_FRAME_LINESTYLE )).GetLine();
2240
2241 if( pBoxInfoItem && !pBoxItem )
2242 {
2243 const static SvxBoxItem gaEmptyBoxItem( SDRATTR_TABLE_BORDER );
2244 pBoxItem = &gaEmptyBoxItem;
2245 }
2246 else if( pBoxItem && !pBoxInfoItem )
2247 {
2248 const static SvxBoxInfoItem gaEmptyBoxInfoItem( SDRATTR_TABLE_BORDER_INNER );
2249 pBoxInfoItem = &gaEmptyBoxInfoItem;
2250 }
2251
2252 CellPos aStart, aEnd;
2253 getSelectedCells( aStart, aEnd );
2254
2255 const sal_Int32 nLastRow = std::min( aEnd.mnRow + 2, nRowCount );
2256 const sal_Int32 nLastCol = std::min( aEnd.mnCol + 2, nColCount );
2257
2258 for( sal_Int32 nRow = std::max( aStart.mnRow - 1, (sal_Int32)0 ); nRow < nLastRow; nRow++ )
2259 {
2260 sal_uInt16 nRowFlags = 0;
2261 nRowFlags |= (nRow == aStart.mnRow) ? CELL_TOP : 0;
2262 nRowFlags |= (nRow == aEnd.mnRow) ? CELL_BOTTOM : 0;
2263 nRowFlags |= (nRow < aStart.mnRow) ? CELL_UPPER : 0;
2264 nRowFlags |= (nRow > aEnd.mnRow) ? CELL_LOWER : 0;
2265
2266 for( sal_Int32 nCol = std::max( aStart.mnCol - 1, (sal_Int32)0 ); nCol < nLastCol; nCol++ )
2267 {
2268 CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
2269 if( !xCell.is() )
2270 continue;
2271
2272 const SfxItemSet& rSet = xCell->GetItemSet();
2273 const SvxBoxItem* pOldOuter = (const SvxBoxItem*) &rSet.Get( SDRATTR_TABLE_BORDER );
2274
2275 SvxBoxItem aNewFrame( *pOldOuter );
2276
2277 sal_uInt16 nCellFlags = nRowFlags;
2278 nCellFlags |= (nCol == aStart.mnCol) ? CELL_LEFT : 0;
2279 nCellFlags |= (nCol == aEnd.mnCol) ? CELL_RIGHT : 0;
2280 nCellFlags |= (nCol < aStart.mnCol) ? CELL_BEFORE : 0;
2281 nCellFlags |= (nCol > aEnd.mnCol) ? CELL_AFTER : 0;
2282
2283 if( pBoxItem && pBoxInfoItem )
2284 ImplApplyBoxItem( nCellFlags, pBoxItem, pBoxInfoItem, aNewFrame );
2285
2286 if( pLineColorItem )
2287 ImplApplyLineColorItem( nCellFlags, pLineColorItem, aNewFrame );
2288
2289 if( pBorderLineItem )
2290 ImplApplyBorderLineItem( nCellFlags, pBorderLineItem, aNewFrame );
2291
2292 if (aNewFrame != *pOldOuter)
2293 {
2294 SfxItemSet aAttr(*rSet.GetPool(), rSet.GetRanges());
2295 aAttr.Put(aNewFrame);
2296 xCell->SetMergedItemSetAndBroadcast( aAttr, false );
2297 }
2298 }
2299 }
2300 }
2301 }
2302 }
2303
2304 // --------------------------------------------------------------------
2305
2306 void SvxTableController::UpdateTableShape()
2307 {
2308 SdrObject* pTableObj = mxTableObj.get();
2309 if( pTableObj )
2310 {
2311 pTableObj->ActionChanged();
2312 pTableObj->BroadcastObjectChange();
2313 }
2314 updateSelectionOverlay();
2315 }
2316
2317
2318 // --------------------------------------------------------------------
2319
2320 void SvxTableController::SetAttrToSelectedCells(const SfxItemSet& rAttr, bool bReplaceAll)
2321 {
2322 if( mxTable.is() )
2323 {
2324 const bool bUndo = mpModel && mpModel->IsUndoEnabled();
2325
2326 if( bUndo )
2327 mpModel->BegUndo( ImpGetResStr(STR_TABLE_NUMFORMAT) );
2328
2329 CellPos aStart, aEnd;
2330 getSelectedCells( aStart, aEnd );
2331
2332 SfxItemSet aAttr(*rAttr.GetPool(), rAttr.GetRanges());
2333 aAttr.Put(rAttr, TRUE);
2334
2335 const bool bFrame = (rAttr.GetItemState( SDRATTR_TABLE_BORDER ) == SFX_ITEM_SET) || (rAttr.GetItemState( SDRATTR_TABLE_BORDER_INNER ) == SFX_ITEM_SET);
2336
2337 if( bFrame )
2338 {
2339 aAttr.ClearItem( SDRATTR_TABLE_BORDER );
2340 aAttr.ClearItem( SDRATTR_TABLE_BORDER_INNER );
2341 }
2342
2343 for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
2344 {
2345 for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
2346 {
2347 CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
2348 if( xCell.is() )
2349 {
2350 if( bUndo )
2351 xCell->AddUndo();
2352 xCell->SetMergedItemSetAndBroadcast(aAttr, bReplaceAll);
2353 }
2354 }
2355 }
2356
2357 if( bFrame )
2358 {
2359 ApplyBorderAttr( rAttr );
2360 }
2361
2362 UpdateTableShape();
2363
2364 if( bUndo )
2365 mpModel->EndUndo();
2366
2367 }
2368 }
2369
2370 // --------------------------------------------------------------------
2371
2372 bool SvxTableController::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const
2373 {
2374 if( mxTableObj.is() && hasSelectedCells() )
2375 {
2376 MergeAttrFromSelectedCells( rTargetSet, bOnlyHardAttr );
2377
2378 if( mpView->IsTextEdit() )
2379 {
2380 if( mxTableObj->GetOutlinerParaObject() )
2381 rTargetSet.Put( SvxScriptTypeItem( mxTableObj->GetOutlinerParaObject()->GetTextObject().GetScriptType() ) );
2382
2383 OutlinerView* pTextEditOutlinerView = mpView->GetTextEditOutlinerView();
2384 if(pTextEditOutlinerView)
2385 {
2386 // FALSE= InvalidItems nicht al Default, sondern als "Loecher" betrachten
2387 rTargetSet.Put(pTextEditOutlinerView->GetAttribs(), FALSE);
2388 rTargetSet.Put( SvxScriptTypeItem( pTextEditOutlinerView->GetSelectedScriptType() ), FALSE );
2389 }
2390 }
2391
2392 return true;
2393 }
2394 else
2395 {
2396 return false;
2397 }
2398 }
2399
2400 // --------------------------------------------------------------------
2401
2402 bool SvxTableController::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll)
2403 {
2404 if( mbCellSelectionMode || mpView->IsTextEdit() )
2405 {
2406 SetAttrToSelectedCells( rSet, bReplaceAll );
2407 return true;
2408 }
2409 return false;
2410 }
2411
2412 // --------------------------------------------------------------------
2413
2414 bool SvxTableController::GetMarkedObjModel( SdrPage* pNewPage )
2415 {
2416 if( mxTableObj.is() && mbCellSelectionMode && pNewPage ) try
2417 {
2418 ::sdr::table::SdrTableObj& rTableObj = *static_cast< ::sdr::table::SdrTableObj* >( mxTableObj.get() );
2419
2420 CellPos aStart, aEnd;
2421 getSelectedCells( aStart, aEnd );
2422
2423 SdrTableObj* pNewTableObj = rTableObj.CloneRange( aStart, aEnd );
2424
2425 pNewTableObj->SetPage( pNewPage );
2426 pNewTableObj->SetModel( pNewPage->GetModel() );
2427
2428 SdrInsertReason aReason(SDRREASON_VIEWCALL);
2429 pNewPage->InsertObject(pNewTableObj,CONTAINER_APPEND,&aReason);
2430
2431 return true;
2432 }
2433 catch( Exception& )
2434 {
2435 DBG_ERROR( "svx::SvxTableController::GetMarkedObjModel(), exception caught!" );
2436 }
2437 return false;
2438 }
2439
2440 // --------------------------------------------------------------------
2441
2442 bool SvxTableController::PasteObjModel( const SdrModel& rModel )
2443 {
2444 if( mxTableObj.is() && mpView && (rModel.GetPageCount() >= 1) )
2445 {
2446 const SdrPage* pPastePage = rModel.GetPage(0);
2447 if( pPastePage && pPastePage->GetObjCount() == 1 )
2448 {
2449 SdrTableObj* pPasteTableObj = dynamic_cast< SdrTableObj* >( pPastePage->GetObj(0) );
2450 if( pPasteTableObj )
2451 {
2452 return PasteObject( pPasteTableObj );
2453 }
2454 }
2455 }
2456
2457 return false;
2458 }
2459
2460 // --------------------------------------------------------------------
2461
2462 bool SvxTableController::PasteObject( SdrTableObj* pPasteTableObj )
2463 {
2464 if( !pPasteTableObj )
2465 return false;
2466
2467 Reference< XTable > xPasteTable( pPasteTableObj->getTable() );
2468 if( !xPasteTable.is() )
2469 return false;
2470
2471 if( !mxTable.is() )
2472 return false;
2473
2474 sal_Int32 nPasteColumns = xPasteTable->getColumnCount();
2475 sal_Int32 nPasteRows = xPasteTable->getRowCount();
2476
2477 CellPos aStart, aEnd;
2478 getSelectedCells( aStart, aEnd );
2479
2480 if( mpView->IsTextEdit() )
2481 mpView->SdrEndTextEdit(sal_True);
2482
2483 sal_Int32 nColumns = mxTable->getColumnCount();
2484 sal_Int32 nRows = mxTable->getRowCount();
2485
2486 const sal_Int32 nMissing = nPasteRows - ( nRows - aStart.mnRow );
2487 if( nMissing > 0 )
2488 {
2489 Reference< XTableRows > xRows( mxTable->getRows() );
2490 xRows->insertByIndex( nRows, nMissing );
2491 nRows = mxTable->getRowCount();
2492 }
2493
2494 nPasteRows = std::min( nPasteRows, nRows - aStart.mnRow );
2495 nPasteColumns = std::min( nPasteColumns, nColumns - aStart.mnCol );
2496
2497 // copy cell contents
2498 for( sal_Int32 nRow = 0; nRow < nPasteRows; ++nRow )
2499 {
2500 for( sal_Int32 nCol = 0; nCol < nPasteColumns; ++nCol )
2501 {
2502 CellRef xTargetCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( aStart.mnCol + nCol, aStart.mnRow + nRow ).get() ) );
2503 if( xTargetCell.is() && !xTargetCell->isMerged() )
2504 {
2505 xTargetCell->AddUndo();
2506 xTargetCell->cloneFrom( dynamic_cast< Cell* >( xPasteTable->getCellByPosition( nCol, nRow ).get() ) );
2507 nCol += xTargetCell->getColumnSpan() - 1;
2508 }
2509 }
2510 }
2511
2512 UpdateTableShape();
2513
2514 return true;
2515 }
2516
2517 // --------------------------------------------------------------------
2518
2519 IMPL_LINK( SvxTableController, UpdateHdl, void *, EMPTYARG )
2520 {
2521 mnUpdateEvent = 0;
2522
2523 if( mbCellSelectionMode )
2524 {
2525 CellPos aStart( maCursorFirstPos );
2526 CellPos aEnd( maCursorLastPos );
2527 checkCell(aStart);
2528 checkCell(aEnd);
2529 if( aStart != maCursorFirstPos || aEnd != maCursorLastPos )
2530 {
2531 setSelectedCells( aStart, aEnd );
2532 }
2533 }
2534 updateSelectionOverlay();
2535
2536 return 0;
2537 }
2538
2539 } }
vba interoperability for OOo