LibreOffice Module svx (master)  1
tablecontroller.cxx
Go to the documentation of this file.
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 #include <algorithm>
21 
22 #include <svx/sdr/table/tablecontroller.hxx>
23 #include <tablemodel.hxx>
24 
25 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
26 #include <com/sun/star/container/XIndexAccess.hpp>
27 
28 #include <com/sun/star/beans/XPropertySet.hpp>
29 #include <com/sun/star/table/XMergeableCellRange.hpp>
30 #include <com/sun/star/table/XMergeableCell.hpp>
31 
32 #include <sal/config.h>
33 #include <sal/log.hxx>
34 
35 #include <vcl/svapp.hxx>
36 #include <vcl/settings.hxx>
37 #include <vcl/window.hxx>
38 
39 #include <svl/whiter.hxx>
40 #include <svl/stritem.hxx>
41 
42 #include <sfx2/request.hxx>
43 
44 #include <svx/svdotable.hxx>
45 #include <sdr/overlay/overlayobjectcell.hxx>
46 #include <svx/sdr/overlay/overlaymanager.hxx>
47 #include <svx/svxids.hrc>
48 #include <editeng/outlobj.hxx>
49 #include <svx/svdoutl.hxx>
50 #include <svx/svdpagv.hxx>
51 #include <svx/svdetc.hxx>
52 #include <svx/selectioncontroller.hxx>
53 #include <svx/svdmodel.hxx>
54 #include <svx/sdrpaintwindow.hxx>
55 #include <svx/svxdlg.hxx>
56 #include <editeng/boxitem.hxx>
57 #include <cell.hxx>
58 #include <editeng/borderline.hxx>
59 #include <editeng/colritem.hxx>
60 #include <editeng/lineitem.hxx>
61 #include <svx/strings.hrc>
62 #include <svx/dialmgr.hxx>
63 #include <svx/svdpage.hxx>
64 #include <svx/sdmetitm.hxx>
65 #include <svx/sdtditm.hxx>
66 #include "tableundo.hxx"
67 #include "tablelayouter.hxx"
68 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
69 #include <memory>
70 #include <o3tl/enumarray.hxx>
71 #include <o3tl/enumrange.hxx>
72 #include <cppuhelper/implbase.hxx>
73 #include <comphelper/lok.hxx>
74 #include <sfx2/viewsh.hxx>
75 #include <editeng/editview.hxx>
76 #include <tools/UnitConversion.hxx>
77 #include <tools/diagnose_ex.h>
78 
79 using ::editeng::SvxBorderLine;
80 using namespace sdr::table;
81 using namespace ::com::sun::star;
82 using namespace ::com::sun::star::uno;
83 using namespace ::com::sun::star::table;
84 using namespace ::com::sun::star::beans;
85 using namespace ::com::sun::star::container;
86 using namespace ::com::sun::star::text;
87 using namespace ::com::sun::star::style;
88 
89 namespace {
90 
91 enum class CellPosFlag // signals the relative position of a cell to a selection
92 {
93  NONE = 0x0000, // not set or inside
94  // row
95  Before = 0x0001,
96  Left = 0x0002,
97  Right = 0x0004,
98  After = 0x0008,
99  // column
100  Upper = 0x0010,
101  Top = 0x0020,
102  Bottom = 0x0040,
103  Lower = 0x0080
104 };
105 
106 }
107 
108 namespace o3tl
109 { template<> struct typed_flags<CellPosFlag> : is_typed_flags<CellPosFlag, 0xff> {}; }
110 
111 namespace sdr::table {
112 
113 namespace {
114 
115 class SvxTableControllerModifyListener : public ::cppu::WeakImplHelper< css::util::XModifyListener >
116 {
117 public:
118  explicit SvxTableControllerModifyListener( SvxTableController* pController )
119  : mpController( pController ) {}
120 
121  // XModifyListener
122  virtual void SAL_CALL modified( const css::lang::EventObject& aEvent ) override;
123 
124  // XEventListener
125  virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
126 
127  SvxTableController* mpController;
128 };
129 
130 }
131 
132 // XModifyListener
133 
134 
135 void SAL_CALL SvxTableControllerModifyListener::modified( const css::lang::EventObject& )
136 {
137  if( mpController )
138  mpController->onTableModified();
139 }
140 
141 
142 // XEventListener
143 
144 
145 void SAL_CALL SvxTableControllerModifyListener::disposing( const css::lang::EventObject& )
146 {
147  mpController = nullptr;
148 }
149 
150 
151 
152 
153 rtl::Reference< sdr::SelectionController > CreateTableController(
154  SdrView& rView,
155  const SdrTableObj& rObj,
156  const rtl::Reference< sdr::SelectionController >& xRefController )
157 {
158  return SvxTableController::create(rView, rObj, xRefController);
159 }
160 
161 
162 rtl::Reference< sdr::SelectionController > SvxTableController::create(
163  SdrView& rView,
164  const SdrTableObj& rObj,
165  const rtl::Reference< sdr::SelectionController >& xRefController )
166 {
167  if( xRefController.is() )
168  {
169  SvxTableController* pController = dynamic_cast< SvxTableController* >( xRefController.get() );
170 
171  if(pController && (pController->mxTableObj.get() == &rObj) && (&pController->mrView == &rView))
172  {
173  return xRefController;
174  }
175  }
176 
177  return new SvxTableController(rView, rObj);
178 }
179 
180 
181 SvxTableController::SvxTableController(
182  SdrView& rView,
183  const SdrTableObj& rObj)
184 : mbCellSelectionMode(false)
185  ,mbHasJustMerged(false)
186  ,mbLeftButtonDown(false)
187  ,mrView(rView)
188  ,mxTableObj(const_cast< SdrTableObj* >(&rObj))
189  ,mnUpdateEvent( nullptr )
190 {
191  mxTableObj->getActiveCellPos( maCursorFirstPos );
192  maCursorLastPos = maCursorFirstPos;
193 
194  Reference< XTable > xTable( mxTableObj->getTable() );
195  if( xTable.is() )
196  {
197  mxModifyListener = new SvxTableControllerModifyListener( this );
198  xTable->addModifyListener( mxModifyListener );
199 
200  mxTable.set( dynamic_cast< TableModel* >( xTable.get() ) );
201  }
202 }
203 
204 SvxTableController::~SvxTableController()
205 {
206  if( mnUpdateEvent )
207  {
208  Application::RemoveUserEvent( mnUpdateEvent );
209  }
210 
211  if( mxModifyListener.is() && mxTableObj )
212  {
213  Reference< XTable > xTable( mxTableObj->getTable() );
214  if( xTable.is() )
215  {
216  xTable->removeModifyListener( mxModifyListener );
217  mxModifyListener.clear();
218  }
219  }
220 }
221 
222 bool SvxTableController::onKeyInput(const KeyEvent& rKEvt, vcl::Window* pWindow )
223 {
224  if(!checkTableObject())
225  return false;
226 
227  SdrTableObj& rTableObj(*mxTableObj);
228  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
229 
230  // check if we are read only
231  if( rModel.IsReadOnly())
232  {
233  switch( rKEvt.GetKeyCode().GetCode() )
234  {
235  case awt::Key::DOWN:
236  case awt::Key::UP:
237  case awt::Key::LEFT:
238  case awt::Key::RIGHT:
239  case awt::Key::TAB:
240  case awt::Key::HOME:
241  case awt::Key::END:
242  case awt::Key::NUM2:
243  case awt::Key::NUM4:
244  case awt::Key::NUM6:
245  case awt::Key::NUM8:
246  case awt::Key::ESCAPE:
247  case awt::Key::F2:
248  break;
249  default:
250  // tell the view we eat the event, no further processing needed
251  return true;
252  }
253  }
254 
255  TblAction nAction = getKeyboardAction(rKEvt);
256 
257  return executeAction( nAction, rKEvt.GetKeyCode().IsShift(), pWindow );
258 }
259 
260 namespace {
261 
262 Point pixelToLogic(const Point& rPoint, vcl::Window const * pWindow)
263 {
264  if (!pWindow)
265  return rPoint;
266 
267  return pWindow->PixelToLogic(rPoint);
268 }
269 
270 }
271 
272 bool SvxTableController::onMouseButtonDown(const MouseEvent& rMEvt, vcl::Window* pWindow )
273 {
274  if (comphelper::LibreOfficeKit::isActive() && !pWindow)
275  {
276  // Tiled rendering: get the window that has the disabled map mode.
277  if (OutputDevice* pOutputDevice = mrView.GetFirstOutputDevice())
278  {
279  if (pOutputDevice->GetOutDevType() == OUTDEV_WINDOW)
280  pWindow = static_cast<vcl::Window*>(pOutputDevice);
281  }
282  }
283 
284  if( !pWindow || !checkTableObject() )
285  return false;
286 
287  SdrViewEvent aVEvt;
288  if( !rMEvt.IsRight() && mrView.PickAnything(rMEvt,SdrMouseEventKind::BUTTONDOWN, aVEvt) == SdrHitKind::Handle )
289  return false;
290 
291  TableHitKind eHit = mxTableObj->CheckTableHit(pixelToLogic(rMEvt.GetPosPixel(), pWindow), maMouseDownPos.mnCol, maMouseDownPos.mnRow);
292 
293  mbLeftButtonDown = (rMEvt.GetClicks() == 1) && rMEvt.IsLeft();
294 
295  if( eHit == TableHitKind::Cell )
296  {
297  StartSelection( maMouseDownPos );
298  return true;
299  }
300 
301  if( rMEvt.IsRight() && eHit != TableHitKind::NONE )
302  return true; // right click will become context menu
303 
304  // for cell selection with the mouse remember our first hit
305  if( mbLeftButtonDown )
306  {
307  RemoveSelection();
308 
309  SdrHdl* pHdl = mrView.PickHandle(pixelToLogic(rMEvt.GetPosPixel(), pWindow));
310 
311  if( pHdl )
312  {
313  mbLeftButtonDown = false;
314  }
315  else
316  {
317  sdr::table::SdrTableObj* pTableObj = mxTableObj.get();
318 
319  if (!pTableObj || eHit == TableHitKind::NONE)
320  {
321  mbLeftButtonDown = false;
322  }
323  }
324  }
325 
326  if (comphelper::LibreOfficeKit::isActive() && rMEvt.GetClicks() == 2 && rMEvt.IsLeft() && eHit == TableHitKind::CellTextArea)
327  {
328  bool bEmptyOutliner = false;
329  if (Outliner* pOutliner = mrView.GetTextEditOutliner())
330  {
331  if (pOutliner->GetParagraphCount() == 1)
332  {
333  if (Paragraph* pParagraph = pOutliner->GetParagraph(0))
334  bEmptyOutliner = pOutliner->GetText(pParagraph).isEmpty();
335  }
336  }
337  if (bEmptyOutliner)
338  {
339  // Tiled rendering: a left double-click in an empty cell: select it.
340  StartSelection(maMouseDownPos);
341  setSelectedCells(maMouseDownPos, maMouseDownPos);
342  // Update graphic selection, should be hidden now.
343  mrView.AdjustMarkHdl();
344  return true;
345  }
346  }
347 
348  return false;
349 }
350 
351 
352 bool SvxTableController::onMouseButtonUp(const MouseEvent& rMEvt, vcl::Window* /*pWin*/)
353 {
354  if( !checkTableObject() )
355  return false;
356 
357  mbLeftButtonDown = false;
358 
359  return rMEvt.GetClicks() == 2;
360 }
361 
362 
363 bool SvxTableController::onMouseMove(const MouseEvent& rMEvt, vcl::Window* pWindow )
364 {
365  if( !checkTableObject() )
366  return false;
367 
368  SdrTableObj* pTableObj = mxTableObj.get();
369  CellPos aPos;
370  if (mbLeftButtonDown && pTableObj && pTableObj->CheckTableHit(pixelToLogic(rMEvt.GetPosPixel(), pWindow), aPos.mnCol, aPos.mnRow ) != TableHitKind::NONE)
371  {
372  if(aPos != maMouseDownPos)
373  {
374  if( mbCellSelectionMode )
375  {
376  setSelectedCells( maMouseDownPos, aPos );
377  return true;
378  }
379  else
380  {
381  StartSelection( maMouseDownPos );
382  }
383  }
384  else if( mbCellSelectionMode )
385  {
386  UpdateSelection( aPos );
387  return true;
388  }
389  }
390  return false;
391 }
392 
393 
394 void SvxTableController::onSelectionHasChanged()
395 {
396  bool bSelected = false;
397 
398  SdrTableObj* pTableObj = mxTableObj.get();
399  if( pTableObj && pTableObj->IsTextEditActive() )
400  {
401  pTableObj->getActiveCellPos( maCursorFirstPos );
402  maCursorLastPos = maCursorFirstPos;
403  mbCellSelectionMode = false;
404  }
405  else
406  {
407  const SdrMarkList& rMarkList= mrView.GetMarkedObjectList();
408  if( rMarkList.GetMarkCount() == 1 )
409  bSelected = mxTableObj.get() == rMarkList.GetMark(0)->GetMarkedSdrObj();
410  }
411 
412  if( bSelected )
413  {
414  updateSelectionOverlay();
415  }
416  else
417  {
418  destroySelectionOverlay();
419  }
420 }
421 void SvxTableController::onSelectAll()
422 {
423  sdr::table::SdrTableObj* pTableObj = mxTableObj.get();
424  if ( pTableObj && !pTableObj->IsTextEditActive())
425  {
426  selectAll();
427  }
428 }
429 
430 
431 void SvxTableController::GetState( SfxItemSet& rSet )
432 {
433  if(!mxTable.is() || !mxTableObj.is())
434  return;
435 
436  SdrTableObj& rTableObj(*mxTableObj);
437  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
438  std::unique_ptr<SfxItemSet> xSet;
439  bool bVertDone(false);
440 
441  // Iterate over all requested items in the set.
442  SfxWhichIter aIter( rSet );
443  sal_uInt16 nWhich = aIter.FirstWhich();
444  while (nWhich)
445  {
446  switch (nWhich)
447  {
448  case SID_TABLE_VERT_BOTTOM:
449  case SID_TABLE_VERT_CENTER:
450  case SID_TABLE_VERT_NONE:
451  {
452  if(!bVertDone)
453  {
454  if (!xSet)
455  {
456  xSet.reset(new SfxItemSet(rModel.GetItemPool()));
457  MergeAttrFromSelectedCells(*xSet, false);
458  }
459 
460  SdrTextVertAdjust eAdj = SDRTEXTVERTADJUST_BLOCK;
461 
462  if (xSet->GetItemState( SDRATTR_TEXT_VERTADJUST ) != SfxItemState::DONTCARE)
463  eAdj = xSet->Get(SDRATTR_TEXT_VERTADJUST).GetValue();
464 
465  rSet.Put(SfxBoolItem(SID_TABLE_VERT_BOTTOM, eAdj == SDRTEXTVERTADJUST_BOTTOM));
466  rSet.Put(SfxBoolItem(SID_TABLE_VERT_CENTER, eAdj == SDRTEXTVERTADJUST_CENTER));
467  rSet.Put(SfxBoolItem(SID_TABLE_VERT_NONE, eAdj == SDRTEXTVERTADJUST_TOP));
468  bVertDone = true;
469  }
470  break;
471  }
472  case SID_TABLE_DELETE_ROW:
473  if( !mxTable.is() || !hasSelectedCells() || (!comphelper::LibreOfficeKit::isActive() && mxTable->getRowCount() <= 1) )
474  rSet.DisableItem(SID_TABLE_DELETE_ROW);
475  break;
476  case SID_TABLE_DELETE_COL:
477  if( !mxTable.is() || !hasSelectedCells() || (!comphelper::LibreOfficeKit::isActive() && mxTable->getColumnCount() <= 1) )
478  rSet.DisableItem(SID_TABLE_DELETE_COL);
479  break;
480  case SID_TABLE_DELETE_TABLE:
481  if( !mxTable.is() )
482  rSet.DisableItem(SID_TABLE_DELETE_TABLE);
483  break;
484  case SID_TABLE_MERGE_CELLS:
485  if( !mxTable.is() || !hasSelectedCells() )
486  rSet.DisableItem(SID_TABLE_MERGE_CELLS);
487  break;
488  case SID_TABLE_SPLIT_CELLS:
489  if( !hasSelectedCells() || !mxTable.is() )
490  rSet.DisableItem(SID_TABLE_SPLIT_CELLS);
491  break;
492 
493  case SID_TABLE_OPTIMAL_ROW_HEIGHT:
494  case SID_TABLE_DISTRIBUTE_COLUMNS:
495  case SID_TABLE_DISTRIBUTE_ROWS:
496  {
497  bool bDistributeColumns = false;
498  bool bDistributeRows = false;
499  if( mxTable.is() )
500  {
501  CellPos aStart, aEnd;
502  getSelectedCells( aStart, aEnd );
503 
504  bDistributeColumns = aStart.mnCol != aEnd.mnCol;
505  bDistributeRows = aStart.mnRow != aEnd.mnRow;
506  }
507  if( !bDistributeColumns )
508  rSet.DisableItem(SID_TABLE_DISTRIBUTE_COLUMNS);
509  if( !bDistributeRows )
510  {
511  rSet.DisableItem(SID_TABLE_OPTIMAL_ROW_HEIGHT);
512  rSet.DisableItem(SID_TABLE_DISTRIBUTE_ROWS);
513  }
514  break;
515  }
516 
517  default:
518  break;
519  }
520  nWhich = aIter.NextWhich();
521  }
522 }
523 
524 
525 void SvxTableController::onInsert( sal_uInt16 nSId, const SfxItemSet* pArgs )
526 {
527  if(!checkTableObject())
528  return;
529 
530  SdrTableObj& rTableObj(*mxTableObj);
531  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
532  bool bInsertAfter = true;
533  sal_uInt16 nCount = 0;
534 
535  if( pArgs )
536  {
537  const SfxPoolItem* pItem = nullptr;
538  pArgs->GetItemState(nSId, false, &pItem);
539  if (pItem)
540  {
541  nCount = static_cast<const SfxInt16Item*>(pItem)->GetValue();
542  if(SfxItemState::SET == pArgs->GetItemState(SID_TABLE_PARAM_INSERT_AFTER, true, &pItem))
543  bInsertAfter = static_cast<const SfxBoolItem*>(pItem)->GetValue();
544  }
545  }
546 
547  CellPos aStart, aEnd;
548  if( hasSelectedCells() )
549  {
550  getSelectedCells( aStart, aEnd );
551  }
552  else
553  {
554  if( bInsertAfter )
555  {
556  aStart.mnCol = mxTable->getColumnCount() - 1;
557  aStart.mnRow = mxTable->getRowCount() - 1;
558  aEnd = aStart;
559  }
560  }
561 
562  if( rTableObj.IsTextEditActive() )
563  mrView.SdrEndTextEdit(true);
564 
565  RemoveSelection();
566 
567  static const OUStringLiteral sSize( u"Size" );
568  const bool bUndo(rModel.IsUndoEnabled());
569 
570  switch( nSId )
571  {
572  case SID_TABLE_INSERT_COL:
573  {
574  TableModelNotifyGuard aGuard( mxTable.get() );
575 
576  if( bUndo )
577  {
578  rModel.BegUndo( SvxResId(STR_TABLE_INSCOL) );
579  rModel.AddUndo(rModel.GetSdrUndoFactory().CreateUndoGeoObject(rTableObj));
580  }
581 
582  Reference< XTableColumns > xCols( mxTable->getColumns() );
583  const sal_Int32 nNewColumns = (nCount == 0) ? (aEnd.mnCol - aStart.mnCol + 1) : nCount;
584  const sal_Int32 nNewStartColumn = aEnd.mnCol + (bInsertAfter ? 1 : 0);
585  xCols->insertByIndex( nNewStartColumn, nNewColumns );
586 
587  for( sal_Int32 nOffset = 0; nOffset < nNewColumns; nOffset++ )
588  {
589  // Resolves fdo#61540
590  // On Insert before, the reference column whose size is going to be
591  // used for newly created column(s) is wrong. As the new columns are
592  // inserted before the reference column, the reference column moved
593  // to the new position by no., of new columns i.e (earlier+newcolumns).
594  Reference< XPropertySet >(xCols->getByIndex(nNewStartColumn+nOffset), UNO_QUERY_THROW )->
595  setPropertyValue( sSize,
596  Reference< XPropertySet >(xCols->getByIndex( bInsertAfter?nNewStartColumn-1:nNewStartColumn+nNewColumns ), UNO_QUERY_THROW )->
597  getPropertyValue( sSize ) );
598  }
599 
600  // Copy cell properties
601  sal_Int32 nPropSrcCol = (bInsertAfter ? aEnd.mnCol : aStart.mnCol + nNewColumns);
602  sal_Int32 nRowSpan = 0;
603  bool bNewSpan = false;
604 
605  for( sal_Int32 nRow = 0; nRow < mxTable->getRowCount(); ++nRow )
606  {
607  CellRef xSourceCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nPropSrcCol, nRow ).get() ) );
608 
609  // When we insert new COLUMNs, we want to copy ROW spans.
610  if (xSourceCell.is() && nRowSpan == 0)
611  {
612  // we are not in a span yet. Let's find out if the current cell is in a span.
613  sal_Int32 nColSpan = sal_Int32();
614  sal_Int32 nSpanInfoCol = sal_Int32();
615 
616  if( xSourceCell->getRowSpan() > 1 )
617  {
618  // The current cell is the top-left cell in a span.
619  // Get the span info and propagate it to the target.
620  nRowSpan = xSourceCell->getRowSpan();
621  nColSpan = xSourceCell->getColumnSpan();
622  nSpanInfoCol = nPropSrcCol;
623  }
624  else if( xSourceCell->isMerged() )
625  {
626  // The current cell is a middle cell in a 2D span.
627  // Look for the top-left cell in the span.
628  for( nSpanInfoCol = nPropSrcCol - 1; nSpanInfoCol >= 0; --nSpanInfoCol )
629  {
630  CellRef xMergeInfoCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nSpanInfoCol, nRow ).get() ) );
631  if (xMergeInfoCell.is() && !xMergeInfoCell->isMerged())
632  {
633  nRowSpan = xMergeInfoCell->getRowSpan();
634  nColSpan = xMergeInfoCell->getColumnSpan();
635  break;
636  }
637  }
638  if( nRowSpan == 1 )
639  nRowSpan = 0;
640  }
641 
642  // The target columns are outside the span; Start a new span.
643  if( nRowSpan > 0 && ( nNewStartColumn < nSpanInfoCol || nSpanInfoCol + nColSpan <= nNewStartColumn ) )
644  bNewSpan = true;
645  }
646 
647  // Now copy the properties from the source to the targets
648  for( sal_Int32 nOffset = 0; nOffset < nNewColumns; nOffset++ )
649  {
650  CellRef xTargetCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nNewStartColumn + nOffset, nRow ).get() ) );
651  if( xTargetCell.is() )
652  {
653  if( nRowSpan > 0 )
654  {
655  if( bNewSpan )
656  xTargetCell->merge( 1, nRowSpan );
657  else
658  xTargetCell->setMerged();
659  }
660  xTargetCell->copyFormatFrom( xSourceCell );
661  }
662  }
663 
664  if( nRowSpan > 0 )
665  {
666  --nRowSpan;
667  bNewSpan = false;
668  }
669  }
670 
671  if( bUndo )
672  rModel.EndUndo();
673 
674  aStart.mnCol = nNewStartColumn;
675  aStart.mnRow = 0;
676  aEnd.mnCol = aStart.mnCol + nNewColumns - 1;
677  aEnd.mnRow = mxTable->getRowCount() - 1;
678  break;
679  }
680 
681  case SID_TABLE_INSERT_ROW:
682  {
683  TableModelNotifyGuard aGuard( mxTable.get() );
684 
685  if( bUndo )
686  {
687  rModel.BegUndo( SvxResId(STR_TABLE_INSROW ) );
688  rModel.AddUndo(rModel.GetSdrUndoFactory().CreateUndoGeoObject(rTableObj));
689  }
690 
691  Reference< XTableRows > xRows( mxTable->getRows() );
692  const sal_Int32 nNewRows = (nCount == 0) ? (aEnd.mnRow - aStart.mnRow + 1) : nCount;
693  const sal_Int32 nNewRowStart = aEnd.mnRow + (bInsertAfter ? 1 : 0);
694  xRows->insertByIndex( nNewRowStart, nNewRows );
695 
696  for( sal_Int32 nOffset = 0; nOffset < nNewRows; nOffset++ )
697  {
698  Reference< XPropertySet >( xRows->getByIndex( aEnd.mnRow + nOffset + 1 ), UNO_QUERY_THROW )->
699  setPropertyValue( sSize,
700  Reference< XPropertySet >( xRows->getByIndex( aStart.mnRow + nOffset ), UNO_QUERY_THROW )->
701  getPropertyValue( sSize ) );
702  }
703 
704  // Copy the cell properties
705  sal_Int32 nPropSrcRow = (bInsertAfter ? aEnd.mnRow : aStart.mnRow + nNewRows);
706  sal_Int32 nColSpan = 0;
707  bool bNewSpan = false;
708 
709  for( sal_Int32 nCol = 0; nCol < mxTable->getColumnCount(); ++nCol )
710  {
711  CellRef xSourceCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nPropSrcRow ).get() ) );
712 
713  if (!xSourceCell.is())
714  continue;
715 
716  // When we insert new ROWs, we want to copy COLUMN spans.
717  if( nColSpan == 0 )
718  {
719  // we are not in a span yet. Let's find out if the current cell is in a span.
720  sal_Int32 nRowSpan = sal_Int32();
721  sal_Int32 nSpanInfoRow = sal_Int32();
722 
723  if( xSourceCell->getColumnSpan() > 1 )
724  {
725  // The current cell is the top-left cell in a span.
726  // Get the span info and propagate it to the target.
727  nColSpan = xSourceCell->getColumnSpan();
728  nRowSpan = xSourceCell->getRowSpan();
729  nSpanInfoRow = nPropSrcRow;
730  }
731  else if( xSourceCell->isMerged() )
732  {
733  // The current cell is a middle cell in a 2D span.
734  // Look for the top-left cell in the span.
735  for( nSpanInfoRow = nPropSrcRow - 1; nSpanInfoRow >= 0; --nSpanInfoRow )
736  {
737  CellRef xMergeInfoCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nSpanInfoRow ).get() ) );
738  if (xMergeInfoCell.is() && !xMergeInfoCell->isMerged())
739  {
740  nColSpan = xMergeInfoCell->getColumnSpan();
741  nRowSpan = xMergeInfoCell->getRowSpan();
742  break;
743  }
744  }
745  if( nColSpan == 1 )
746  nColSpan = 0;
747  }
748 
749  // Inserted rows are outside the span; Start a new span.
750  if( nColSpan > 0 && ( nNewRowStart < nSpanInfoRow || nSpanInfoRow + nRowSpan <= nNewRowStart ) )
751  bNewSpan = true;
752  }
753 
754  // Now copy the properties from the source to the targets
755  for( sal_Int32 nOffset = 0; nOffset < nNewRows; ++nOffset )
756  {
757  CellRef xTargetCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nNewRowStart + nOffset ).get() ) );
758  if( xTargetCell.is() )
759  {
760  if( nColSpan > 0 )
761  {
762  if( bNewSpan )
763  xTargetCell->merge( nColSpan, 1 );
764  else
765  xTargetCell->setMerged();
766  }
767  xTargetCell->copyFormatFrom( xSourceCell );
768  }
769  }
770 
771  if( nColSpan > 0 )
772  {
773  --nColSpan;
774  bNewSpan = false;
775  }
776  }
777 
778  if( bUndo )
779  rModel.EndUndo();
780 
781  aStart.mnCol = 0;
782  aStart.mnRow = nNewRowStart;
783  aEnd.mnCol = mxTable->getColumnCount() - 1;
784  aEnd.mnRow = aStart.mnRow + nNewRows - 1;
785  break;
786  }
787  }
788 
789  StartSelection( aStart );
790  UpdateSelection( aEnd );
791 }
792 
793 
794 void SvxTableController::onDelete( sal_uInt16 nSId )
795 {
796  sdr::table::SdrTableObj* pTableObj = mxTableObj.get();
797  if( !pTableObj || !mxTable.is() )
798  return;
799 
800  if( nSId == SID_TABLE_DELETE_TABLE )
801  {
802  if( pTableObj->IsTextEditActive() )
803  mrView.SdrEndTextEdit(true);
804 
805  mrView.DeleteMarkedObj();
806  }
807  else if( hasSelectedCells() )
808  {
809  CellPos aStart, aEnd;
810  getSelectedCells( aStart, aEnd );
811 
812  if( pTableObj->IsTextEditActive() )
813  mrView.SdrEndTextEdit(true);
814 
815  RemoveSelection();
816 
817  bool bDeleteTable = false;
818  switch( nSId )
819  {
820  case SID_TABLE_DELETE_COL:
821  {
822  const sal_Int32 nRemovedColumns = aEnd.mnCol - aStart.mnCol + 1;
823  if( nRemovedColumns == mxTable->getColumnCount() )
824  {
825  bDeleteTable = true;
826  }
827  else
828  {
829  Reference< XTableColumns > xCols( mxTable->getColumns() );
830  xCols->removeByIndex( aStart.mnCol, nRemovedColumns );
831  }
832  break;
833  }
834 
835  case SID_TABLE_DELETE_ROW:
836  {
837  const sal_Int32 nRemovedRows = aEnd.mnRow - aStart.mnRow + 1;
838  if( nRemovedRows == mxTable->getRowCount() )
839  {
840  bDeleteTable = true;
841  }
842  else
843  {
844  Reference< XTableRows > xRows( mxTable->getRows() );
845  xRows->removeByIndex( aStart.mnRow, nRemovedRows );
846  }
847  break;
848  }
849  }
850 
851  if( bDeleteTable )
852  mrView.DeleteMarkedObj();
853  else
854  UpdateTableShape();
855  }
856 }
857 
858 
859 void SvxTableController::onSelect( sal_uInt16 nSId )
860 {
861  if( !mxTable.is() )
862  return;
863 
864  const sal_Int32 nRowCount = mxTable->getRowCount();
865  const sal_Int32 nColCount = mxTable->getColumnCount();
866  if( !(nRowCount && nColCount) )
867  return;
868 
869  CellPos aStart, aEnd;
870  getSelectedCells( aStart, aEnd );
871 
872  switch( nSId )
873  {
874  case SID_TABLE_SELECT_ALL:
875  aEnd.mnCol = 0; aEnd.mnRow = 0;
876  aStart.mnCol = nColCount - 1; aStart.mnRow = nRowCount - 1;
877  break;
878  case SID_TABLE_SELECT_COL:
879  aEnd.mnRow = nRowCount - 1;
880  aStart.mnRow = 0;
881  break;
882  case SID_TABLE_SELECT_ROW:
883  aEnd.mnCol = nColCount - 1;
884  aStart.mnCol = 0;
885  break;
886  }
887 
888  StartSelection( aEnd );
889  gotoCell( aStart, true, nullptr );
890 }
891 
892 namespace
893 {
894  SvxBoxItem mergeDrawinglayerTextDistancesAndSvxBoxItem(const SfxItemSet& rAttrSet)
895  {
896  // merge drawing layer text distance items into SvxBoxItem used by the dialog
897  SvxBoxItem aBoxItem( rAttrSet.Get( SDRATTR_TABLE_BORDER ) );
898  aBoxItem.SetDistance( sal::static_int_cast< sal_uInt16 >( rAttrSet.Get(SDRATTR_TEXT_LEFTDIST).GetValue()), SvxBoxItemLine::LEFT );
899  aBoxItem.SetDistance( sal::static_int_cast< sal_uInt16 >( rAttrSet.Get(SDRATTR_TEXT_RIGHTDIST).GetValue()), SvxBoxItemLine::RIGHT );
900  aBoxItem.SetDistance( sal::static_int_cast< sal_uInt16 >( rAttrSet.Get(SDRATTR_TEXT_UPPERDIST).GetValue()), SvxBoxItemLine::TOP );
901  aBoxItem.SetDistance( sal::static_int_cast< sal_uInt16 >( rAttrSet.Get(SDRATTR_TEXT_LOWERDIST).GetValue()), SvxBoxItemLine::BOTTOM );
902  return aBoxItem;
903  }
904 }
905 
906 void SvxTableController::onFormatTable(const SfxRequest& rReq)
907 {
908  if(!mxTableObj.is())
909  return;
910 
911  SdrTableObj& rTableObj(*mxTableObj);
912  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
913  const SfxItemSet* pArgs = rReq.GetArgs();
914 
915  if(pArgs)
916  return;
917 
918  SfxItemSet aNewAttr(rModel.GetItemPool());
919 
920  // merge drawing layer text distance items into SvxBoxItem used by the dialog
921  SvxBoxItem aBoxItem(mergeDrawinglayerTextDistancesAndSvxBoxItem(aNewAttr));
922 
923  SvxBoxInfoItem aBoxInfoItem( aNewAttr.Get( SDRATTR_TABLE_BORDER_INNER ) );
924 
925  MergeAttrFromSelectedCells(aNewAttr, false);
926  FillCommonBorderAttrFromSelectedCells( aBoxItem, aBoxInfoItem );
927  aNewAttr.Put( aBoxItem );
928  aNewAttr.Put( aBoxInfoItem );
929 
930  // Fill in shadow properties.
931  const SfxItemSet& rTableItemSet = rTableObj.GetMergedItemSet();
932  for (sal_uInt16 nWhich = SDRATTR_SHADOW_FIRST; nWhich <= SDRATTR_SHADOW_LAST; ++nWhich)
933  {
934  if (rTableItemSet.GetItemState(nWhich, false) != SfxItemState::SET)
935  {
936  continue;
937  }
938 
939  aNewAttr.Put(rTableItemSet.Get(nWhich));
940  }
941 
942  SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
943  VclPtr<SfxAbstractTabDialog> xDlg( pFact->CreateSvxFormatCellsDialog(
944  rReq.GetFrameWeld(),
945  &aNewAttr,
946  rModel) );
947 
948  // Even Cancel Button is returning positive(101) value,
949  xDlg->StartExecuteAsync([xDlg, this, aBoxItem, aBoxInfoItem](int nResult){
950  if (nResult == RET_OK)
951  {
952  SfxItemSet aNewSet(*(xDlg->GetOutputItemSet()));
953 
954  //Only properties that were unchanged by the dialog appear in this
955  //itemset. We had constructed these two properties from other
956  //ones, so if they were not changed, then forcible set them back to
957  //their originals in the new result set so we can decompose that
958  //unchanged state back to their input properties
959  if (aNewSet.GetItemState(SDRATTR_TABLE_BORDER, false) != SfxItemState::SET)
960  {
961  aNewSet.Put(aBoxItem);
962  }
963  if (aNewSet.GetItemState(SDRATTR_TABLE_BORDER_INNER, false) != SfxItemState::SET)
964  {
965  aNewSet.Put(aBoxInfoItem);
966  }
967 
968  SvxBoxItem aNewBoxItem( aNewSet.Get( SDRATTR_TABLE_BORDER ) );
969 
970  if( aNewBoxItem.GetDistance( SvxBoxItemLine::LEFT ) != aBoxItem.GetDistance( SvxBoxItemLine::LEFT ) )
971  aNewSet.Put(makeSdrTextLeftDistItem( aNewBoxItem.GetDistance( SvxBoxItemLine::LEFT ) ) );
972 
973  if( aNewBoxItem.GetDistance( SvxBoxItemLine::RIGHT ) != aBoxItem.GetDistance( SvxBoxItemLine::RIGHT ) )
974  aNewSet.Put(makeSdrTextRightDistItem( aNewBoxItem.GetDistance( SvxBoxItemLine::RIGHT ) ) );
975 
976  if( aNewBoxItem.GetDistance( SvxBoxItemLine::TOP ) != aBoxItem.GetDistance( SvxBoxItemLine::TOP ) )
977  aNewSet.Put(makeSdrTextUpperDistItem( aNewBoxItem.GetDistance( SvxBoxItemLine::TOP ) ) );
978 
979  if( aNewBoxItem.GetDistance( SvxBoxItemLine::BOTTOM ) != aBoxItem.GetDistance( SvxBoxItemLine::BOTTOM ) )
980  aNewSet.Put(makeSdrTextLowerDistItem( aNewBoxItem.GetDistance( SvxBoxItemLine::BOTTOM ) ) );
981 
982  if (checkTableObject() && mxTable.is())
983  {
984  // Create a single undo action when applying the result of the dialog.
985  SdrTableObj& rTableObject(*mxTableObj);
986  SdrModel& rSdrModel(rTableObject.getSdrModelFromSdrObject());
987  bool bUndo = rSdrModel.IsUndoEnabled() && !mrView.IsTextEdit();
988  if (bUndo)
989  {
990  rSdrModel.BegUndo(SvxResId(STR_TABLE_NUMFORMAT));
991  }
992 
993  this->SetAttrToSelectedCells(aNewSet, false);
994 
995  this->SetAttrToSelectedShape(aNewSet);
996 
997  if (bUndo)
998  {
999  rSdrModel.EndUndo();
1000  }
1001  }
1002  }
1003 
1004  xDlg->disposeOnce();
1005  });
1006 }
1007 
1008 void SvxTableController::Execute( SfxRequest& rReq )
1009 {
1010  const sal_uInt16 nSId = rReq.GetSlot();
1011  switch( nSId )
1012  {
1013  case SID_TABLE_INSERT_ROW:
1014  case SID_TABLE_INSERT_COL:
1015  onInsert( nSId, rReq.GetArgs() );
1016  break;
1017  case SID_TABLE_DELETE_ROW:
1018  case SID_TABLE_DELETE_COL:
1019  case SID_TABLE_DELETE_TABLE:
1020  onDelete( nSId );
1021  break;
1022  case SID_TABLE_SELECT_ALL:
1023  case SID_TABLE_SELECT_COL:
1024  case SID_TABLE_SELECT_ROW:
1025  onSelect( nSId );
1026  break;
1027  case SID_FORMAT_TABLE_DLG:
1028  onFormatTable( rReq );
1029  break;
1030 
1031  case SID_FRAME_LINESTYLE:
1032  case SID_FRAME_LINECOLOR:
1033  case SID_ATTR_BORDER:
1034  {
1035  const SfxItemSet* pArgs = rReq.GetArgs();
1036  if( pArgs )
1037  ApplyBorderAttr( *pArgs );
1038  }
1039  break;
1040 
1041  case SID_ATTR_FILL_STYLE:
1042  {
1043  const SfxItemSet* pArgs = rReq.GetArgs();
1044  if( pArgs )
1045  SetAttributes( *pArgs, false );
1046  }
1047  break;
1048 
1049  case SID_TABLE_MERGE_CELLS:
1050  MergeMarkedCells();
1051  break;
1052 
1053  case SID_TABLE_SPLIT_CELLS:
1054  SplitMarkedCells(rReq);
1055  break;
1056 
1057  case SID_TABLE_MINIMAL_COLUMN_WIDTH:
1058  DistributeColumns(/*bOptimize=*/true, /*bMinimize=*/true);
1059  break;
1060 
1061  case SID_TABLE_OPTIMAL_COLUMN_WIDTH:
1062  DistributeColumns(/*bOptimize=*/true, /*bMinimize=*/false);
1063  break;
1064 
1065  case SID_TABLE_DISTRIBUTE_COLUMNS:
1066  DistributeColumns(/*bOptimize=*/false, /*bMinimize=*/false);
1067  break;
1068 
1069  case SID_TABLE_MINIMAL_ROW_HEIGHT:
1070  DistributeRows(/*bOptimize=*/true, /*bMinimize=*/true);
1071  break;
1072 
1073  case SID_TABLE_OPTIMAL_ROW_HEIGHT:
1074  DistributeRows(/*bOptimize=*/true, /*bMinimize=*/false);
1075  break;
1076 
1077  case SID_TABLE_DISTRIBUTE_ROWS:
1078  DistributeRows(/*bOptimize=*/false, /*bMinimize=*/false);
1079  break;
1080 
1081  case SID_TABLE_VERT_BOTTOM:
1082  case SID_TABLE_VERT_CENTER:
1083  case SID_TABLE_VERT_NONE:
1084  SetVertical( nSId );
1085  break;
1086 
1087  case SID_AUTOFORMAT:
1088  case SID_TABLE_SORT_DIALOG:
1089  case SID_TABLE_AUTOSUM:
1090  default:
1091  break;
1092 
1093  case SID_TABLE_STYLE:
1094  SetTableStyle( rReq.GetArgs() );
1095  break;
1096 
1097  case SID_TABLE_STYLE_SETTINGS:
1098  SetTableStyleSettings( rReq.GetArgs() );
1099  break;
1100  case SID_TABLE_CHANGE_CURRENT_BORDER_POSITION:
1101  changeTableEdge(rReq);
1102  break;
1103  }
1104 }
1105 
1106 void SvxTableController::SetTableStyle( const SfxItemSet* pArgs )
1107 {
1108  if(!checkTableObject())
1109  return;
1110 
1111  SdrTableObj& rTableObj(*mxTableObj);
1112  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
1113 
1114  if(!pArgs || (SfxItemState::SET != pArgs->GetItemState(SID_TABLE_STYLE, false)))
1115  return;
1116 
1117  const SfxStringItem* pArg = dynamic_cast< const SfxStringItem* >( &pArgs->Get( SID_TABLE_STYLE ) );
1118  if( !(pArg && mxTable.is()) )
1119  return;
1120 
1121  try
1122  {
1123  Reference< XStyleFamiliesSupplier > xSFS( rModel.getUnoModel(), UNO_QUERY_THROW );
1124  Reference< XNameAccess > xFamilyNameAccess( xSFS->getStyleFamilies(), UNO_SET_THROW );
1125  Reference< XNameAccess > xTableFamilyAccess( xFamilyNameAccess->getByName( "table" ), UNO_QUERY_THROW );
1126 
1127  if( xTableFamilyAccess->hasByName( pArg->GetValue() ) )
1128  {
1129  // found table style with the same name
1130  Reference< XIndexAccess > xNewTableStyle( xTableFamilyAccess->getByName( pArg->GetValue() ), UNO_QUERY_THROW );
1131 
1132  const bool bUndo = rModel.IsUndoEnabled();
1133 
1134  if( bUndo )
1135  {
1136  rModel.BegUndo(SvxResId(STR_TABLE_STYLE));
1137  rModel.AddUndo(std::make_unique<TableStyleUndo>(rTableObj));
1138  }
1139 
1140  rTableObj.setTableStyle( xNewTableStyle );
1141 
1142  const sal_Int32 nRowCount = mxTable->getRowCount();
1143  const sal_Int32 nColCount = mxTable->getColumnCount();
1144  for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ )
1145  {
1146  for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ ) try
1147  {
1148  CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
1149  if( xCell.is() )
1150  {
1151  SfxItemSet aSet( xCell->GetItemSet() );
1152  bool bChanges = false;
1153  SfxStyleSheet *pStyleSheet = xCell->GetStyleSheet();
1154  SAL_WARN_IF(!pStyleSheet, "svx", "no stylesheet for table cell?");
1155  if (pStyleSheet)
1156  {
1157  const SfxItemSet& rStyleAttribs = pStyleSheet->GetItemSet();
1158 
1159  for ( sal_uInt16 nWhich = SDRATTR_START; nWhich <= SDRATTR_TABLE_LAST; nWhich++ )
1160  {
1161  if( (rStyleAttribs.GetItemState( nWhich ) == SfxItemState::SET) && (aSet.GetItemState( nWhich ) == SfxItemState::SET) )
1162  {
1163  aSet.ClearItem( nWhich );
1164  bChanges = true;
1165  }
1166  }
1167  }
1168 
1169  if( bChanges )
1170  {
1171  if( bUndo )
1172  xCell->AddUndo();
1173 
1174  xCell->SetMergedItemSetAndBroadcast( aSet, true );
1175  }
1176  }
1177  }
1178  catch( Exception& )
1179  {
1180  TOOLS_WARN_EXCEPTION("svx.table", "");
1181  }
1182  }
1183 
1184  if( bUndo )
1185  rModel.EndUndo();
1186  }
1187  }
1188  catch( Exception& )
1189  {
1190  TOOLS_WARN_EXCEPTION("svx.table", "");
1191  }
1192 }
1193 
1194 void SvxTableController::SetTableStyleSettings( const SfxItemSet* pArgs )
1195 {
1196  if(!checkTableObject())
1197  return;
1198 
1199  SdrTableObj& rTableObj(*mxTableObj);
1200  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
1201 
1202  TableStyleSettings aSettings(rTableObj.getTableStyleSettings() );
1203  const SfxPoolItem *pPoolItem=nullptr;
1204 
1205  if( SfxItemState::SET == pArgs->GetItemState(ID_VAL_USEFIRSTROWSTYLE, false,&pPoolItem) )
1206  aSettings.mbUseFirstRow = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
1207 
1208  if( SfxItemState::SET == pArgs->GetItemState(ID_VAL_USELASTROWSTYLE, false,&pPoolItem) )
1209  aSettings.mbUseLastRow = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
1210 
1211  if( SfxItemState::SET == pArgs->GetItemState(ID_VAL_USEBANDINGROWSTYLE, false,&pPoolItem) )
1212  aSettings.mbUseRowBanding = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
1213 
1214  if( SfxItemState::SET == pArgs->GetItemState(ID_VAL_USEFIRSTCOLUMNSTYLE, false,&pPoolItem) )
1215  aSettings.mbUseFirstColumn = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
1216 
1217  if( SfxItemState::SET == pArgs->GetItemState(ID_VAL_USELASTCOLUMNSTYLE, false,&pPoolItem) )
1218  aSettings.mbUseLastColumn = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
1219 
1220  if( SfxItemState::SET == pArgs->GetItemState(ID_VAL_USEBANDINGCOLUMNSTYLE, false,&pPoolItem) )
1221  aSettings.mbUseColumnBanding = static_cast< const SfxBoolItem* >(pPoolItem)->GetValue();
1222 
1223  if( aSettings == rTableObj.getTableStyleSettings() )
1224  return;
1225 
1226  const bool bUndo(rModel.IsUndoEnabled());
1227 
1228  if( bUndo )
1229  {
1230  rModel.BegUndo( SvxResId(STR_TABLE_STYLE_SETTINGS) );
1231  rModel.AddUndo(std::make_unique<TableStyleUndo>(rTableObj));
1232  }
1233 
1234  rTableObj.setTableStyleSettings( aSettings );
1235 
1236  if( bUndo )
1237  rModel.EndUndo();
1238 }
1239 
1240 void SvxTableController::SetVertical( sal_uInt16 nSId )
1241 {
1242  if(!checkTableObject())
1243  return;
1244 
1245  SdrTableObj& rTableObj(*mxTableObj);
1246  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
1247 
1248  TableModelNotifyGuard aGuard( mxTable.get() );
1249  const bool bUndo(rModel.IsUndoEnabled());
1250 
1251  if (bUndo)
1252  {
1253  rModel.BegUndo(SvxResId(STR_TABLE_NUMFORMAT));
1254  rModel.AddUndo(rModel.GetSdrUndoFactory().CreateUndoAttrObject(rTableObj));
1255  }
1256 
1257  CellPos aStart, aEnd;
1258  getSelectedCells( aStart, aEnd );
1259 
1260  SdrTextVertAdjust eAdj = SDRTEXTVERTADJUST_TOP;
1261 
1262  switch( nSId )
1263  {
1264  case SID_TABLE_VERT_BOTTOM:
1265  eAdj = SDRTEXTVERTADJUST_BOTTOM;
1266  break;
1267  case SID_TABLE_VERT_CENTER:
1268  eAdj = SDRTEXTVERTADJUST_CENTER;
1269  break;
1270  //case SID_TABLE_VERT_NONE:
1271  default:
1272  break;
1273  }
1274 
1275  SdrTextVertAdjustItem aItem( eAdj );
1276 
1277  for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
1278  {
1279  for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
1280  {
1281  CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
1282  if( xCell.is() )
1283  {
1284  if (bUndo)
1285  xCell->AddUndo();
1286  SfxItemSet aSet(xCell->GetItemSet());
1287  aSet.Put(aItem);
1288  xCell->SetMergedItemSetAndBroadcast(aSet, /*bClearAllItems=*/false);
1289  }
1290  }
1291  }
1292 
1293  UpdateTableShape();
1294 
1295  if (bUndo)
1296  rModel.EndUndo();
1297 }
1298 
1299 void SvxTableController::MergeMarkedCells()
1300 {
1301  CellPos aStart, aEnd;
1302  getSelectedCells( aStart, aEnd );
1303  SdrTableObj* pTableObj = mxTableObj.get();
1304  if( pTableObj )
1305  {
1306  if( pTableObj->IsTextEditActive() )
1307  mrView.SdrEndTextEdit(true);
1308 
1309  TableModelNotifyGuard aGuard( mxTable.get() );
1310  MergeRange( aStart.mnCol, aStart.mnRow, aEnd.mnCol, aEnd.mnRow );
1311  }
1312 }
1313 
1314 void SvxTableController::SplitMarkedCells(const SfxRequest& rReq)
1315 {
1316  if(!checkTableObject() || !mxTable.is())
1317  return;
1318 
1319  SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
1320  VclPtr<SvxAbstractSplitTableDialog> xDlg(pFact->CreateSvxSplitTableDialog(rReq.GetFrameWeld(), false, 99));
1321 
1322  xDlg->StartExecuteAsync([xDlg, this](int) {
1323  const sal_Int32 nCount = xDlg->GetCount() - 1;
1324 
1325  if( nCount < 1 )
1326  return;
1327 
1328  CellPos aStart, aEnd;
1329  getSelectedCells( aStart, aEnd );
1330  Reference< XMergeableCellRange > xRange( mxTable->createCursorByRange( mxTable->getCellRangeByPosition( aStart.mnCol, aStart.mnRow, aEnd.mnCol, aEnd.mnRow ) ), UNO_QUERY_THROW );
1331  const sal_Int32 nRowCount = mxTable->getRowCount();
1332  const sal_Int32 nColCount = mxTable->getColumnCount();
1333  SdrTableObj& rTableObj(*mxTableObj);
1334 
1335  if( rTableObj.IsTextEditActive() )
1336  mrView.SdrEndTextEdit(true);
1337 
1338  TableModelNotifyGuard aGuard( mxTable.get() );
1339  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
1340  const bool bUndo(rModel.IsUndoEnabled());
1341 
1342  if( bUndo )
1343  {
1344  rModel.BegUndo( SvxResId(STR_TABLE_SPLIT) );
1345  rModel.AddUndo(rModel.GetSdrUndoFactory().CreateUndoGeoObject(rTableObj));
1346  }
1347 
1348  if( xDlg->IsHorizontal() )
1349  {
1350  xRange->split( 0, nCount );
1351  }
1352  else
1353  {
1354  xRange->split( nCount, 0 );
1355  }
1356 
1357  if( bUndo )
1358  rModel.EndUndo();
1359 
1360  aEnd.mnRow += mxTable->getRowCount() - nRowCount;
1361  aEnd.mnCol += mxTable->getColumnCount() - nColCount;
1362 
1363  setSelectedCells( aStart, aEnd );
1364 
1365  xDlg->disposeOnce();
1366  });
1367 }
1368 
1369 void SvxTableController::DistributeColumns(const bool bOptimize, const bool bMinimize)
1370 {
1371  if(!checkTableObject())
1372  return;
1373 
1374  SdrTableObj& rTableObj(*mxTableObj);
1375  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
1376  const bool bUndo(rModel.IsUndoEnabled());
1377 
1378  if( bUndo )
1379  {
1380  rModel.BegUndo( SvxResId(STR_TABLE_DISTRIBUTE_COLUMNS) );
1381  rModel.AddUndo(rModel.GetSdrUndoFactory().CreateUndoGeoObject(rTableObj));
1382  }
1383 
1384  CellPos aStart, aEnd;
1385  getSelectedCells( aStart, aEnd );
1386  rTableObj.DistributeColumns( aStart.mnCol, aEnd.mnCol, bOptimize, bMinimize );
1387 
1388  if( bUndo )
1389  rModel.EndUndo();
1390 }
1391 
1392 void SvxTableController::DistributeRows(const bool bOptimize, const bool bMinimize)
1393 {
1394  if(!checkTableObject())
1395  return;
1396 
1397  SdrTableObj& rTableObj(*mxTableObj);
1398  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
1399  const bool bUndo(rModel.IsUndoEnabled());
1400 
1401  if( bUndo )
1402  {
1403  rModel.BegUndo( SvxResId(STR_TABLE_DISTRIBUTE_ROWS) );
1404  rModel.AddUndo(rModel.GetSdrUndoFactory().CreateUndoGeoObject(rTableObj));
1405  }
1406 
1407  CellPos aStart, aEnd;
1408  getSelectedCells( aStart, aEnd );
1409  rTableObj.DistributeRows( aStart.mnRow, aEnd.mnRow, bOptimize, bMinimize );
1410 
1411  if( bUndo )
1412  rModel.EndUndo();
1413 }
1414 
1415 bool SvxTableController::HasMarked() const
1416 {
1417  return mbCellSelectionMode && mxTable.is();
1418 }
1419 
1420 bool SvxTableController::DeleteMarked()
1421 {
1422  if(!checkTableObject() || !HasMarked())
1423  return false;
1424 
1425  SdrTableObj& rTableObj(*mxTableObj);
1426  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
1427  const bool bUndo(rModel.IsUndoEnabled());
1428 
1429  if (bUndo)
1430  rModel.BegUndo(SvxResId(STR_TABLE_DELETE_CELL_CONTENTS));
1431 
1432  CellPos aStart, aEnd;
1433  getSelectedCells( aStart, aEnd );
1434  for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
1435  {
1436  for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
1437  {
1438  CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
1439  if (xCell.is() && xCell->hasText())
1440  {
1441  if (bUndo)
1442  xCell->AddUndo();
1443  xCell->SetOutlinerParaObject(nullptr);
1444  }
1445  }
1446  }
1447 
1448  if (bUndo)
1449  rModel.EndUndo();
1450 
1451  UpdateTableShape();
1452  return true;
1453 }
1454 
1455 bool SvxTableController::GetStyleSheet( SfxStyleSheet*& rpStyleSheet ) const
1456 {
1457  if( hasSelectedCells() )
1458  {
1459  rpStyleSheet = nullptr;
1460 
1461  if( mxTable.is() )
1462  {
1463  SfxStyleSheet* pRet=nullptr;
1464  bool b1st=true;
1465 
1466  CellPos aStart, aEnd;
1467  const_cast<SvxTableController&>(*this).getSelectedCells( aStart, aEnd );
1468 
1469  for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
1470  {
1471  for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
1472  {
1473  CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
1474  if( xCell.is() )
1475  {
1476  SfxStyleSheet* pSS=xCell->GetStyleSheet();
1477  if(b1st)
1478  {
1479  pRet=pSS;
1480  }
1481  else if(pRet != pSS)
1482  {
1483  return true;
1484  }
1485  b1st=false;
1486  }
1487  }
1488  }
1489  rpStyleSheet = pRet;
1490  return true;
1491  }
1492  }
1493  return false;
1494 }
1495 
1496 bool SvxTableController::SetStyleSheet( SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr )
1497 {
1498  if( hasSelectedCells() && (!pStyleSheet || pStyleSheet->GetFamily() == SfxStyleFamily::Frame) )
1499  {
1500  if( mxTable.is() )
1501  {
1502  CellPos aStart, aEnd;
1503  getSelectedCells( aStart, aEnd );
1504 
1505  for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
1506  {
1507  for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
1508  {
1509  CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
1510  if( xCell.is() )
1511  xCell->SetStyleSheet(pStyleSheet,bDontRemoveHardAttr);
1512  }
1513  }
1514 
1515  UpdateTableShape();
1516  return true;
1517  }
1518  }
1519  return false;
1520 }
1521 
1522 void SvxTableController::changeTableEdge(const SfxRequest& rReq)
1523 {
1524  if (!checkTableObject())
1525  return;
1526 
1527  const auto* pType = rReq.GetArg<SfxStringItem>(SID_TABLE_BORDER_TYPE);
1528  const auto* pIndex = rReq.GetArg<SfxUInt16Item>(SID_TABLE_BORDER_INDEX);
1529  const auto* pOffset = rReq.GetArg<SfxInt32Item>(SID_TABLE_BORDER_OFFSET);
1530 
1531  if (!(pType && pIndex && pOffset))
1532  return;
1533 
1534  const OUString sType = pType->GetValue();
1535  const sal_uInt16 nIndex = pIndex->GetValue();
1536  const sal_Int32 nOffset = convertTwipToMm100(pOffset->GetValue());
1537 
1538  SdrTableObj& rTableObj(*mxTableObj);
1539 
1540  sal_Int32 nEdgeIndex = -1;
1541  bool bHorizontal = sType.startsWith("row");
1542 
1543  if (sType == "column-left" || sType == "row-left")
1544  {
1545  nEdgeIndex = 0;
1546  }
1547  else if (sType == "column-right")
1548  {
1549  // Number of edges = number of columns + 1
1550  nEdgeIndex = rTableObj.getColumnCount();
1551  }
1552  else if (sType == "row-right")
1553  {
1554  // Number of edges = number of rows + 1
1555  nEdgeIndex = rTableObj.getRowCount();
1556  }
1557  else if (sType == "column-middle" || sType == "row-middle")
1558  {
1559  nEdgeIndex = nIndex + 1;
1560  }
1561 
1562  if (nEdgeIndex < 0)
1563  return;
1564 
1565  TableModelNotifyGuard aGuard(mxTable.get());
1566  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
1567  const bool bUndo(rModel.IsUndoEnabled());
1568  if (bUndo)
1569  {
1570  auto pUndoObject = rModel.GetSdrUndoFactory().CreateUndoGeoObject(rTableObj);
1571  rModel.BegUndo(pUndoObject->GetComment());
1572 
1573  auto* pGeoUndo = static_cast<SdrUndoGeoObj*>(pUndoObject.get());
1574  if (pGeoUndo)
1575  pGeoUndo->SetSkipChangeLayout(true);
1576 
1577  rModel.AddUndo(std::move(pUndoObject));
1578  }
1579  tools::Rectangle aBoundRect;
1580  if (rTableObj.GetUserCall())
1581  aBoundRect = rTableObj.GetLastBoundRect();
1582  rTableObj.changeEdge(bHorizontal, nEdgeIndex, nOffset);
1583  rTableObj.SetChanged();
1584  rTableObj.SendUserCall(SdrUserCallType::Resize, aBoundRect);
1585  if (bUndo)
1586  rModel.EndUndo();
1587 }
1588 
1589 // internals
1590 
1591 
1592 bool SvxTableController::checkTableObject()
1593 {
1594  return mxTableObj.is();
1595 }
1596 
1597 
1598 SvxTableController::TblAction SvxTableController::getKeyboardAction(const KeyEvent& rKEvt)
1599 {
1600  const bool bMod1 = rKEvt.GetKeyCode().IsMod1(); // ctrl
1601  const bool bMod2 = rKEvt.GetKeyCode().IsMod2(); // Alt
1602  const bool bTextEdit = mrView.IsTextEdit();
1603 
1604  TblAction nAction = TblAction::HandledByView;
1605 
1606  sdr::table::SdrTableObj* pTableObj = mxTableObj.get();
1607  if( !pTableObj )
1608  return nAction;
1609 
1610  // handle special keys
1611  const sal_Int16 nCode = rKEvt.GetKeyCode().GetCode();
1612  switch( nCode )
1613  {
1614  case awt::Key::ESCAPE: // handle escape
1615  {
1616  if( bTextEdit )
1617  {
1618  // escape during text edit ends text edit
1619  nAction = TblAction::StopTextEdit;
1620  }
1621  if( mbCellSelectionMode )
1622  {
1623  // escape with selected cells removes selection
1624  nAction = TblAction::RemoveSelection;
1625  }
1626  break;
1627  }
1628  case awt::Key::RETURN: // handle return
1629  {
1630  if( !bMod1 && !bMod2 && !bTextEdit )
1631  {
1632  // when not already editing, return starts text edit
1633  setSelectionStart( SdrTableObj::getFirstCell() );
1634  nAction = TblAction::EditCell;
1635  }
1636  break;
1637  }
1638  case awt::Key::F2: // f2 toggles text edit
1639  {
1640  if( bMod1 || bMod2 ) // f2 with modifiers is handled by the view
1641  {
1642  }
1643  else if( bTextEdit )
1644  {
1645  // f2 during text edit stops text edit
1646  nAction = TblAction::StopTextEdit;
1647  }
1648  else if( mbCellSelectionMode )
1649  {
1650  // f2 with selected cells removes selection
1651  nAction = TblAction::RemoveSelection;
1652  }
1653  else
1654  {
1655  // f2 with no selection and no text edit starts text edit
1656  setSelectionStart( SdrTableObj::getFirstCell() );
1657  nAction = TblAction::EditCell;
1658  }
1659  break;
1660  }
1661  case awt::Key::HOME:
1662  case awt::Key::NUM7:
1663  {
1664  if( (bMod1 || bMod2) && (bTextEdit || mbCellSelectionMode) )
1665  {
1666  if( bMod1 && !bMod2 )
1667  {
1668  // ctrl + home jumps to first cell
1669  nAction = TblAction::GotoFirstCell;
1670  }
1671  else if( !bMod1 && bMod2 )
1672  {
1673  // alt + home jumps to first column
1674  nAction = TblAction::GotoFirstColumn;
1675  }
1676  }
1677  break;
1678  }
1679  case awt::Key::END:
1680  case awt::Key::NUM1:
1681  {
1682  if( (bMod1 || bMod2) && (bTextEdit || mbCellSelectionMode) )
1683  {
1684  if( bMod1 && !bMod2 )
1685  {
1686  // ctrl + end jumps to last cell
1687  nAction = TblAction::GotoLastCell;
1688  }
1689  else if( !bMod1 && bMod2 )
1690  {
1691  // alt + home jumps to last column
1692  nAction = TblAction::GotoLastColumn;
1693  }
1694  }
1695  break;
1696  }
1697 
1698  case awt::Key::TAB:
1699  {
1700  if( bTextEdit || mbCellSelectionMode )
1701  nAction = TblAction::Tab;
1702  break;
1703  }
1704 
1705  case awt::Key::UP:
1706  case awt::Key::NUM8:
1707  case awt::Key::DOWN:
1708  case awt::Key::NUM2:
1709  case awt::Key::LEFT:
1710  case awt::Key::NUM4:
1711  case awt::Key::RIGHT:
1712  case awt::Key::NUM6:
1713  {
1714 
1715  if( !bMod1 && bMod2 )
1716  {
1717  if(bTextEdit || mbCellSelectionMode)
1718  {
1719  if( (nCode == awt::Key::UP) || (nCode == awt::Key::NUM8) )
1720  {
1721  nAction = TblAction::GotoLeftCell;
1722  break;
1723  }
1724  else if( (nCode == awt::Key::DOWN) || (nCode == awt::Key::NUM2) )
1725  {
1726  nAction = TblAction::GotoRightCell;
1727  break;
1728  }
1729  }
1730  }
1731 
1732  bool bTextMove = false;
1733  OutlinerView* pOLV = mrView.GetTextEditOutlinerView();
1734  if( pOLV )
1735  {
1736  RemoveSelection();
1737  // during text edit, check if we navigate out of the cell
1738  ESelection aOldSelection = pOLV->GetSelection();
1739  pOLV->PostKeyEvent(rKEvt);
1740  bTextMove = aOldSelection == pOLV->GetSelection();
1741  if( !bTextMove )
1742  {
1743  nAction = TblAction::NONE;
1744  }
1745  }
1746 
1747  if( mbCellSelectionMode || bTextMove )
1748  {
1749  // no text edit, navigate in cells if selection active
1750  switch( nCode )
1751  {
1752  case awt::Key::LEFT:
1753  case awt::Key::NUM4:
1754  nAction = TblAction::GotoLeftCell;
1755  break;
1756  case awt::Key::RIGHT:
1757  case awt::Key::NUM6:
1758  nAction = TblAction::GotoRightCell;
1759  break;
1760  case awt::Key::DOWN:
1761  case awt::Key::NUM2:
1762  nAction = TblAction::GotoDownCell;
1763  break;
1764  case awt::Key::UP:
1765  case awt::Key::NUM8:
1766  nAction = TblAction::GotoUpCell;
1767  break;
1768  }
1769  }
1770  break;
1771  }
1772  case awt::Key::PAGEUP:
1773  if( bMod2 )
1774  nAction = TblAction::GotoFirstRow;
1775  break;
1776 
1777  case awt::Key::PAGEDOWN:
1778  if( bMod2 )
1779  nAction = TblAction::GotoLastRow;
1780  break;
1781  }
1782  return nAction;
1783 }
1784 
1785 bool SvxTableController::executeAction(TblAction nAction, bool bSelect, vcl::Window* pWindow)
1786 {
1787  sdr::table::SdrTableObj* pTableObj = mxTableObj.get();
1788  if( !pTableObj )
1789  return false;
1790 
1791  switch( nAction )
1792  {
1793  case TblAction::GotoFirstCell:
1794  {
1795  gotoCell( SdrTableObj::getFirstCell(), bSelect, pWindow, nAction );
1796  break;
1797  }
1798 
1799  case TblAction::GotoLeftCell:
1800  {
1801  gotoCell( pTableObj->getLeftCell( getSelectionEnd(), !bSelect ), bSelect, pWindow, nAction );
1802  break;
1803  }
1804 
1805  case TblAction::GotoRightCell:
1806  {
1807  gotoCell( pTableObj->getRightCell( getSelectionEnd(), !bSelect ), bSelect, pWindow, nAction);
1808  break;
1809  }
1810 
1811  case TblAction::GotoLastCell:
1812  {
1813  gotoCell( pTableObj->getLastCell(), bSelect, pWindow, nAction );
1814  break;
1815  }
1816 
1817  case TblAction::GotoFirstColumn:
1818  {
1819  CellPos aPos( SdrTableObj::getFirstCell().mnCol, getSelectionEnd().mnRow );
1820  gotoCell( aPos, bSelect, pWindow, nAction );
1821  break;
1822  }
1823 
1824  case TblAction::GotoLastColumn:
1825  {
1826  CellPos aPos( pTableObj->getLastCell().mnCol, getSelectionEnd().mnRow );
1827  gotoCell( aPos, bSelect, pWindow, nAction );
1828  break;
1829  }
1830 
1831  case TblAction::GotoFirstRow:
1832  {
1833  CellPos aPos( getSelectionEnd().mnCol, SdrTableObj::getFirstCell().mnRow );
1834  gotoCell( aPos, bSelect, pWindow, nAction );
1835  break;
1836  }
1837 
1838  case TblAction::GotoUpCell:
1839  {
1840  gotoCell( pTableObj->getUpCell(getSelectionEnd(), !bSelect), bSelect, pWindow, nAction );
1841  break;
1842  }
1843 
1844  case TblAction::GotoDownCell:
1845  {
1846  gotoCell( pTableObj->getDownCell(getSelectionEnd(), !bSelect), bSelect, pWindow, nAction );
1847  break;
1848  }
1849 
1850  case TblAction::GotoLastRow:
1851  {
1852  CellPos aPos( getSelectionEnd().mnCol, pTableObj->getLastCell().mnRow );
1853  gotoCell( aPos, bSelect, pWindow, nAction );
1854  break;
1855  }
1856 
1857  case TblAction::EditCell:
1858  EditCell( getSelectionStart(), pWindow, nAction );
1859  break;
1860 
1861  case TblAction::StopTextEdit:
1862  StopTextEdit();
1863  break;
1864 
1865  case TblAction::RemoveSelection:
1866  RemoveSelection();
1867  break;
1868 
1869  case TblAction::Tab:
1870  {
1871  if( bSelect )
1872  gotoCell( pTableObj->getPreviousCell( getSelectionEnd(), true ), false, pWindow, nAction );
1873  else
1874  {
1875  CellPos aSelectionEnd( getSelectionEnd() );
1876  CellPos aNextCell( pTableObj->getNextCell( aSelectionEnd, true ) );
1877  if( aSelectionEnd == aNextCell )
1878  {
1879  onInsert( SID_TABLE_INSERT_ROW );
1880  aNextCell = pTableObj->getNextCell( aSelectionEnd, true );
1881  }
1882  gotoCell( aNextCell, false, pWindow, nAction );
1883  }
1884  break;
1885  }
1886  default:
1887  break;
1888  }
1889 
1890  return nAction != TblAction::HandledByView;
1891 }
1892 
1893 
1894 void SvxTableController::gotoCell(const CellPos& rPos, bool bSelect, vcl::Window* pWindow, TblAction nAction /*= TblAction::NONE */)
1895 {
1896  if( mxTableObj.is() && mxTableObj->IsTextEditActive() )
1897  mrView.SdrEndTextEdit(true);
1898 
1899  if( bSelect )
1900  {
1901  maCursorLastPos = rPos;
1902  if( mxTableObj.is() )
1903  mxTableObj->setActiveCell( rPos );
1904 
1905  if( !mbCellSelectionMode )
1906  {
1907  setSelectedCells( maCursorFirstPos, rPos );
1908  }
1909  else
1910  {
1911  UpdateSelection( rPos );
1912  }
1913  }
1914  else
1915  {
1916  RemoveSelection();
1917  EditCell( rPos, pWindow, nAction );
1918  }
1919 }
1920 
1921 
1922 const CellPos& SvxTableController::getSelectionStart()
1923 {
1924  checkCell( maCursorFirstPos );
1925  return maCursorFirstPos;
1926 }
1927 
1928 
1929 void SvxTableController::setSelectionStart( const CellPos& rPos )
1930 {
1931  maCursorFirstPos = rPos;
1932 }
1933 
1934 
1935 const CellPos& SvxTableController::getSelectionEnd()
1936 {
1937  checkCell( maCursorLastPos );
1938  return maCursorLastPos;
1939 }
1940 
1941 
1942 void SvxTableController::MergeRange( sal_Int32 nFirstCol, sal_Int32 nFirstRow, sal_Int32 nLastCol, sal_Int32 nLastRow )
1943 {
1944  if(!checkTableObject() || !mxTable.is())
1945  return;
1946 
1947  try
1948  {
1949  Reference< XMergeableCellRange > xRange( mxTable->createCursorByRange( mxTable->getCellRangeByPosition( nFirstCol, nFirstRow,nLastCol, nLastRow ) ), UNO_QUERY_THROW );
1950 
1951  if( xRange->isMergeable() )
1952  {
1953  SdrTableObj& rTableObj(*mxTableObj);
1954  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
1955  const bool bUndo(rModel.IsUndoEnabled());
1956 
1957  if( bUndo )
1958  {
1959  rModel.BegUndo( SvxResId(STR_TABLE_MERGE) );
1960  rModel.AddUndo(rModel.GetSdrUndoFactory().CreateUndoGeoObject(rTableObj));
1961  }
1962 
1963  xRange->merge();
1964  mbHasJustMerged = true;
1965  setSelectedCells( maCursorFirstPos, maCursorFirstPos );
1966 
1967  if( bUndo )
1968  rModel.EndUndo();
1969  }
1970  }
1971  catch( Exception& )
1972  {
1973  TOOLS_WARN_EXCEPTION( "svx.table", "" );
1974  }
1975 }
1976 
1977 
1978 void SvxTableController::checkCell( CellPos& rPos )
1979 {
1980  if( !mxTable.is() )
1981  return;
1982 
1983  try
1984  {
1985  if( rPos.mnCol >= mxTable->getColumnCount() )
1986  rPos.mnCol = mxTable->getColumnCount()-1;
1987 
1988  if( rPos.mnRow >= mxTable->getRowCount() )
1989  rPos.mnRow = mxTable->getRowCount()-1;
1990  }
1991  catch( Exception& )
1992  {
1993  TOOLS_WARN_EXCEPTION("svx.table", "");
1994  }
1995 }
1996 
1997 
1998 void SvxTableController::findMergeOrigin( CellPos& rPos )
1999 {
2000  if( !mxTable.is() )
2001  return;
2002 
2003  try
2004  {
2005  Reference< XMergeableCell > xCell( mxTable->getCellByPosition( rPos.mnCol, rPos.mnRow ), UNO_QUERY_THROW );
2006  if( xCell->isMerged() )
2007  {
2008  ::findMergeOrigin( mxTable, rPos.mnCol, rPos.mnRow, rPos.mnCol, rPos.mnRow );
2009  }
2010  }
2011  catch( Exception& )
2012  {
2013  TOOLS_WARN_EXCEPTION("svx.table", "");
2014  }
2015 }
2016 
2017 
2018 void SvxTableController::EditCell(const CellPos& rPos, vcl::Window* pWindow, TblAction nAction /*= TblAction::NONE */)
2019 {
2020  SdrPageView* pPV(mrView.GetSdrPageView());
2021 
2022  if(nullptr == pPV || !checkTableObject())
2023  return;
2024 
2025  SdrTableObj& rTableObj(*mxTableObj);
2026 
2027  if(rTableObj.getSdrPageFromSdrObject() != pPV->GetPage())
2028  return;
2029 
2030  bool bEmptyOutliner = false;
2031 
2032  if(!rTableObj.GetOutlinerParaObject() && mrView.GetTextEditOutliner())
2033  {
2034  ::Outliner* pOutl = mrView.GetTextEditOutliner();
2035  sal_Int32 nParaCnt = pOutl->GetParagraphCount();
2036  Paragraph* p1stPara = pOutl->GetParagraph( 0 );
2037 
2038  if(nParaCnt==1 && p1stPara)
2039  {
2040  // with only one paragraph
2041  if (pOutl->GetText(p1stPara).isEmpty())
2042  {
2043  bEmptyOutliner = true;
2044  }
2045  }
2046  }
2047 
2048  CellPos aPos( rPos );
2049  findMergeOrigin( aPos );
2050 
2051  if( &rTableObj == mrView.GetTextEditObject() && !bEmptyOutliner && rTableObj.IsTextEditActive( aPos ) )
2052  return;
2053 
2054  if( rTableObj.IsTextEditActive() )
2055  mrView.SdrEndTextEdit(true);
2056 
2057  rTableObj.setActiveCell( aPos );
2058 
2059  // create new outliner, owner will be the SdrObjEditView
2060  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
2061  std::unique_ptr<SdrOutliner> pOutl(SdrMakeOutliner(OutlinerMode::OutlineObject, rModel));
2062 
2063  if (pOutl && rTableObj.IsVerticalWriting())
2064  pOutl->SetVertical( true );
2065 
2066  if (!mrView.SdrBeginTextEdit(&rTableObj, pPV, pWindow, true, pOutl.release()))
2067  return;
2068 
2069  maCursorLastPos = maCursorFirstPos = rPos;
2070 
2071  OutlinerView* pOLV = mrView.GetTextEditOutlinerView();
2072 
2073  // Move cursor to end of text
2074  ESelection aNewSelection;
2075 
2076  const WritingMode eMode = rTableObj.GetWritingMode();
2077  if (((nAction == TblAction::GotoLeftCell) || (nAction == TblAction::GotoRightCell)) && (eMode != WritingMode_TB_RL))
2078  {
2079  const bool bLast = ((nAction == TblAction::GotoLeftCell) && (eMode == WritingMode_LR_TB)) ||
2080  ((nAction == TblAction::GotoRightCell) && (eMode == WritingMode_RL_TB));
2081 
2082  if( bLast )
2083  aNewSelection = ESelection(EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND, EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND);
2084  }
2085  pOLV->SetSelection(aNewSelection);
2086 }
2087 
2088 
2089 void SvxTableController::StopTextEdit()
2090 {
2091  if(mrView.IsTextEdit())
2092  {
2093  mrView.SdrEndTextEdit();
2094  mrView.SetCurrentObj(OBJ_TABLE);
2095  mrView.SetEditMode(SdrViewEditMode::Edit);
2096  }
2097 }
2098 
2099 
2100 void SvxTableController::getSelectedCells( CellPos& rFirst, CellPos& rLast )
2101 {
2102  if( mbCellSelectionMode )
2103  {
2104  checkCell( maCursorFirstPos );
2105  checkCell( maCursorLastPos );
2106 
2107  rFirst.mnCol = std::min( maCursorFirstPos.mnCol, maCursorLastPos.mnCol );
2108  rFirst.mnRow = std::min( maCursorFirstPos.mnRow, maCursorLastPos.mnRow );
2109  rLast.mnCol = std::max( maCursorFirstPos.mnCol, maCursorLastPos.mnCol );
2110  rLast.mnRow = std::max( maCursorFirstPos.mnRow, maCursorLastPos.mnRow );
2111 
2112  bool bExt = false;
2113  if( mxTable.is() ) do
2114  {
2115  bExt = false;
2116  for( sal_Int32 nRow = rFirst.mnRow; nRow <= rLast.mnRow && !bExt; nRow++ )
2117  {
2118  for( sal_Int32 nCol = rFirst.mnCol; nCol <= rLast.mnCol && !bExt; nCol++ )
2119  {
2120  Reference< XMergeableCell > xCell( mxTable->getCellByPosition( nCol, nRow ), UNO_QUERY );
2121  if( !xCell.is() )
2122  continue;
2123 
2124  if( xCell->isMerged() )
2125  {
2126  CellPos aPos( nCol, nRow );
2127  findMergeOrigin( aPos );
2128  if( (aPos.mnCol < rFirst.mnCol) || (aPos.mnRow < rFirst.mnRow) )
2129  {
2130  rFirst.mnCol = std::min( rFirst.mnCol, aPos.mnCol );
2131  rFirst.mnRow = std::min( rFirst.mnRow, aPos.mnRow );
2132  bExt = true;
2133  }
2134  }
2135  else
2136  {
2137  if( ((nCol + xCell->getColumnSpan() - 1) > rLast.mnCol) || (nRow + xCell->getRowSpan() - 1 ) > rLast.mnRow )
2138  {
2139  rLast.mnCol = std::max( rLast.mnCol, nCol + xCell->getColumnSpan() - 1 );
2140  rLast.mnRow = std::max( rLast.mnRow, nRow + xCell->getRowSpan() - 1 );
2141  bExt = true;
2142  }
2143  }
2144  }
2145  }
2146  }
2147  while(bExt);
2148  }
2149  else if(mrView.IsTextEdit())
2150  {
2151  rFirst = getSelectionStart();
2152  findMergeOrigin( rFirst );
2153  rLast = rFirst;
2154 
2155  if( mxTable.is() )
2156  {
2157  Reference< XMergeableCell > xCell( mxTable->getCellByPosition( rLast.mnCol, rLast.mnRow ), UNO_QUERY );
2158  if( xCell.is() )
2159  {
2160  rLast.mnCol += xCell->getColumnSpan() - 1;
2161  rLast.mnRow += xCell->getRowSpan() - 1;
2162  }
2163  }
2164  }
2165  else
2166  {
2167  rFirst.mnCol = 0;
2168  rFirst.mnRow = 0;
2169  if( mxTable.is() )
2170  {
2171  rLast.mnRow = mxTable->getRowCount()-1;
2172  rLast.mnCol = mxTable->getColumnCount()-1;
2173  }
2174  else
2175  {
2176  rLast.mnRow = 0;
2177  rLast.mnCol = 0;
2178  }
2179  }
2180 }
2181 
2182 
2183 void SvxTableController::StartSelection( const CellPos& rPos )
2184 {
2185  StopTextEdit();
2186  mbCellSelectionMode = true;
2187  maCursorLastPos = maCursorFirstPos = rPos;
2188  mrView.MarkListHasChanged();
2189 }
2190 
2191 
2192 void SvxTableController::setSelectedCells( const CellPos& rStart, const CellPos& rEnd )
2193 {
2194  StopTextEdit();
2195  mbCellSelectionMode = true;
2196  maCursorFirstPos = rStart;
2197  UpdateSelection( rEnd );
2198 }
2199 
2200 
2201 bool SvxTableController::ChangeFontSize(bool bGrow, const FontList* pFontList)
2202 {
2203  if(!checkTableObject() || !mxTable.is())
2204  return false;
2205 
2206  SdrTableObj& rTableObj(*mxTableObj);
2207  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
2208 
2209  if (mrView.IsTextEdit())
2210  return true;
2211 
2212  CellPos aStart, aEnd;
2213 
2214  if(hasSelectedCells())
2215  {
2216  getSelectedCells(aStart, aEnd);
2217  }
2218  else
2219  {
2220  aStart.mnRow = 0;
2221  aStart.mnCol = 0;
2222  aEnd.mnRow = mxTable->getRowCount() - 1;
2223  aEnd.mnCol = mxTable->getColumnCount() - 1;
2224  }
2225 
2226  for (sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++)
2227  {
2228  for (sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++)
2229  {
2230  CellRef xCell(dynamic_cast< Cell* >(mxTable->getCellByPosition(nCol, nRow).get()));
2231  if (xCell.is())
2232  {
2233  if (rModel.IsUndoEnabled())
2234  xCell->AddUndo();
2235 
2236  SfxItemSet aCellSet(xCell->GetItemSet());
2237  if (EditView::ChangeFontSize(bGrow, aCellSet, pFontList))
2238  {
2239  xCell->SetMergedItemSetAndBroadcast(aCellSet, false);
2240  }
2241  }
2242  }
2243  }
2244 
2245  UpdateTableShape();
2246 
2247  return true;
2248 }
2249 
2250 
2251 void SvxTableController::UpdateSelection( const CellPos& rPos )
2252 {
2253  maCursorLastPos = rPos;
2254  mrView.MarkListHasChanged();
2255 }
2256 
2257 
2258 void SvxTableController::clearSelection()
2259 {
2260  RemoveSelection();
2261 }
2262 
2263 
2264 void SvxTableController::selectAll()
2265 {
2266  if( mxTable.is() )
2267  {
2268  CellPos aPos2( mxTable->getColumnCount()-1, mxTable->getRowCount()-1 );
2269  if( (aPos2.mnCol >= 0) && (aPos2.mnRow >= 0) )
2270  {
2271  CellPos aPos1;
2272  setSelectedCells( aPos1, aPos2 );
2273  }
2274  }
2275 }
2276 
2277 
2278 void SvxTableController::RemoveSelection()
2279 {
2280  if( mbCellSelectionMode )
2281  {
2282  mbCellSelectionMode = false;
2283  mrView.MarkListHasChanged();
2284  }
2285 }
2286 
2287 
2288 void SvxTableController::onTableModified()
2289 {
2290  if( mnUpdateEvent == nullptr )
2291  mnUpdateEvent = Application::PostUserEvent( LINK( this, SvxTableController, UpdateHdl ) );
2292 }
2293 
2294 
2295 void SvxTableController::updateSelectionOverlay()
2296 {
2297  // There is no need to update selection overlay after merging cells
2298  // since the selection overlay should remain the same
2299  if ( mbHasJustMerged )
2300  return;
2301 
2302  destroySelectionOverlay();
2303  if( !mbCellSelectionMode )
2304  return;
2305 
2306  sdr::table::SdrTableObj* pTableObj = mxTableObj.get();
2307  if( !pTableObj )
2308  return;
2309 
2310  sdr::overlay::OverlayObjectCell::RangeVector aRanges;
2311 
2312  tools::Rectangle aStartRect, aEndRect;
2313  CellPos aStart,aEnd;
2314  getSelectedCells( aStart, aEnd );
2315  pTableObj->getCellBounds( aStart, aStartRect );
2316 
2317  basegfx::B2DRange a2DRange( basegfx::B2DPoint(aStartRect.Left(), aStartRect.Top()) );
2318  a2DRange.expand( basegfx::B2DPoint(aStartRect.Right(), aStartRect.Bottom()) );
2319 
2320  findMergeOrigin( aEnd );
2321  pTableObj->getCellBounds( aEnd, aEndRect );
2322  a2DRange.expand( basegfx::B2DPoint(aEndRect.Left(), aEndRect.Top()) );
2323  a2DRange.expand( basegfx::B2DPoint(aEndRect.Right(), aEndRect.Bottom()) );
2324  aRanges.push_back( a2DRange );
2325 
2326  ::Color aHighlight( COL_BLUE );
2327  OutputDevice* pOutDev = mrView.GetFirstOutputDevice();
2328  if( pOutDev )
2329  aHighlight = pOutDev->GetSettings().GetStyleSettings().GetHighlightColor();
2330 
2331  const sal_uInt32 nCount = mrView.PaintWindowCount();
2332  for( sal_uInt32 nIndex = 0; nIndex < nCount; nIndex++ )
2333  {
2334  SdrPaintWindow* pPaintWindow = mrView.GetPaintWindow(nIndex);
2335  if( pPaintWindow )
2336  {
2337  const rtl::Reference < sdr::overlay::OverlayManager >& xOverlayManager = pPaintWindow->GetOverlayManager();
2338  if( xOverlayManager.is() )
2339  {
2340  std::unique_ptr<sdr::overlay::OverlayObjectCell> pOverlay(new sdr::overlay::OverlayObjectCell( aHighlight, aRanges ));
2341 
2342  xOverlayManager->add(*pOverlay);
2343  mpSelectionOverlay.reset(new sdr::overlay::OverlayObjectList);
2344  mpSelectionOverlay->append(std::move(pOverlay));
2345  }
2346  }
2347  }
2348 
2349  // If tiled rendering, emit callbacks for sdr table selection.
2350  if (!(pOutDev && comphelper::LibreOfficeKit::isActive()))
2351  return;
2352 
2353  tools::Rectangle aSelection(a2DRange.getMinX(), a2DRange.getMinY(), a2DRange.getMaxX(), a2DRange.getMaxY());
2354 
2355  if (pOutDev->GetMapMode().GetMapUnit() == MapUnit::Map100thMM)
2356  aSelection = OutputDevice::LogicToLogic(aSelection, MapMode(MapUnit::Map100thMM), MapMode(MapUnit::MapTwip));
2357 
2358  if(SfxViewShell* pViewShell = SfxViewShell::Current())
2359  {
2360  pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_CELL_SELECTION_AREA, aSelection.toString().getStr());
2361  pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_TEXT_SELECTION, aSelection.toString().getStr());
2362  }
2363 }
2364 
2365 
2366 void SvxTableController::destroySelectionOverlay()
2367 {
2368  if( !mpSelectionOverlay )
2369  return;
2370 
2371  mpSelectionOverlay.reset();
2372 
2373  if (comphelper::LibreOfficeKit::isActive())
2374  {
2375  // Clear the LOK text selection so far provided by this table.
2376  if(SfxViewShell* pViewShell = SfxViewShell::Current())
2377  {
2378  pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_CELL_SELECTION_AREA, "EMPTY");
2379  pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_TEXT_SELECTION_START, "EMPTY");
2380  pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_TEXT_SELECTION_END, "EMPTY");
2381  pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_TEXT_SELECTION, "EMPTY");
2382  }
2383  }
2384 }
2385 
2386 
2387 void SvxTableController::MergeAttrFromSelectedCells(SfxItemSet& rAttr, bool bOnlyHardAttr) const
2388 {
2389  if( !mxTable.is() )
2390  return;
2391 
2392  CellPos aStart, aEnd;
2393  const_cast<SvxTableController&>(*this).getSelectedCells( aStart, aEnd );
2394 
2395  for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
2396  {
2397  for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
2398  {
2399  CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
2400  if( xCell.is() && !xCell->isMerged() )
2401  {
2402  const SfxItemSet& rSet = xCell->GetItemSet();
2403  SfxWhichIter aIter(rSet);
2404  sal_uInt16 nWhich(aIter.FirstWhich());
2405  while(nWhich)
2406  {
2407  if(!bOnlyHardAttr)
2408  {
2409  if(SfxItemState::DONTCARE == rSet.GetItemState(nWhich, false))
2410  rAttr.InvalidateItem(nWhich);
2411  else
2412  rAttr.MergeValue(rSet.Get(nWhich), true);
2413  }
2414  else if(SfxItemState::SET == rSet.GetItemState(nWhich, false))
2415  {
2416  const SfxPoolItem& rItem = rSet.Get(nWhich);
2417  rAttr.MergeValue(rItem, true);
2418  }
2419 
2420  nWhich = aIter.NextWhich();
2421  }
2422  }
2423  }
2424  }
2425 }
2426 
2427 
2428 static void ImplSetLinePreserveColor( SvxBoxItem& rNewFrame, const SvxBorderLine* pNew, SvxBoxItemLine nLine )
2429 {
2430  if( pNew )
2431  {
2432  const SvxBorderLine* pOld = rNewFrame.GetLine(nLine);
2433  if( pOld )
2434  {
2435  SvxBorderLine aNewLine( *pNew );
2436  aNewLine.SetColor( pOld->GetColor() );
2437  rNewFrame.SetLine( &aNewLine, nLine );
2438  return;
2439  }
2440  }
2441  rNewFrame.SetLine( pNew, nLine );
2442 }
2443 
2444 
2445 static void ImplApplyBoxItem( CellPosFlag nCellPosFlags, const SvxBoxItem* pBoxItem, const SvxBoxInfoItem* pBoxInfoItem, SvxBoxItem& rNewFrame )
2446 {
2447  if (nCellPosFlags & (CellPosFlag::Before|CellPosFlag::After|CellPosFlag::Upper|CellPosFlag::Lower))
2448  {
2449  // current cell is outside the selection
2450 
2451  if (!(nCellPosFlags & (CellPosFlag::Before|CellPosFlag::After))) // check if it's not any corner
2452  {
2453  if (nCellPosFlags & CellPosFlag::Upper)
2454  {
2455  if( pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::TOP) )
2456  rNewFrame.SetLine(nullptr, SvxBoxItemLine::BOTTOM );
2457  }
2458  else if (nCellPosFlags & CellPosFlag::Lower)
2459  {
2460  if( pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::BOTTOM) )
2461  rNewFrame.SetLine( nullptr, SvxBoxItemLine::TOP );
2462  }
2463  }
2464  else if (!(nCellPosFlags & (CellPosFlag::Upper|CellPosFlag::Lower))) // check if it's not any corner
2465  {
2466  if (nCellPosFlags & CellPosFlag::Before)
2467  {
2468  if( pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::LEFT) )
2469  rNewFrame.SetLine( nullptr, SvxBoxItemLine::RIGHT );
2470  }
2471  else if (nCellPosFlags & CellPosFlag::After)
2472  {
2473  if( pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::RIGHT) )
2474  rNewFrame.SetLine( nullptr, SvxBoxItemLine::LEFT );
2475  }
2476  }
2477  }
2478  else
2479  {
2480  // current cell is inside the selection
2481 
2482  if ((nCellPosFlags & CellPosFlag::Left) ? pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::LEFT)
2483  : pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::VERT))
2484  rNewFrame.SetLine( (nCellPosFlags & CellPosFlag::Left) ? pBoxItem->GetLeft() : pBoxInfoItem->GetVert(), SvxBoxItemLine::LEFT );
2485 
2486  if( (nCellPosFlags & CellPosFlag::Right) ? pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::RIGHT) : pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::VERT) )
2487  rNewFrame.SetLine( (nCellPosFlags & CellPosFlag::Right) ? pBoxItem->GetRight() : pBoxInfoItem->GetVert(), SvxBoxItemLine::RIGHT );
2488 
2489  if( (nCellPosFlags & CellPosFlag::Top) ? pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::TOP) : pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::HORI) )
2490  rNewFrame.SetLine( (nCellPosFlags & CellPosFlag::Top) ? pBoxItem->GetTop() : pBoxInfoItem->GetHori(), SvxBoxItemLine::TOP );
2491 
2492  if( (nCellPosFlags & CellPosFlag::Bottom) ? pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::BOTTOM) : pBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::HORI) )
2493  rNewFrame.SetLine( (nCellPosFlags & CellPosFlag::Bottom) ? pBoxItem->GetBottom() : pBoxInfoItem->GetHori(), SvxBoxItemLine::BOTTOM );
2494 
2495  // apply distance to borders
2496  if( pBoxInfoItem->IsValid( SvxBoxInfoItemValidFlags::DISTANCE ) )
2497  for( SvxBoxItemLine nLine : o3tl::enumrange<SvxBoxItemLine>() )
2498  rNewFrame.SetDistance( pBoxItem->GetDistance( nLine ), nLine );
2499  }
2500 }
2501 
2502 
2503 static void ImplSetLineColor( SvxBoxItem& rNewFrame, SvxBoxItemLine nLine, const Color& rColor )
2504 {
2505  const SvxBorderLine* pSourceLine = rNewFrame.GetLine( nLine );
2506  if( pSourceLine )
2507  {
2508  SvxBorderLine aLine( *pSourceLine );
2509  aLine.SetColor( rColor );
2510  rNewFrame.SetLine( &aLine, nLine );
2511  }
2512 }
2513 
2514 
2515 static void ImplApplyLineColorItem( CellPosFlag nCellPosFlags, const SvxColorItem* pLineColorItem, SvxBoxItem& rNewFrame )
2516 {
2517  const Color aColor( pLineColorItem->GetValue() );
2518 
2519  if (!(nCellPosFlags & (CellPosFlag::Lower|CellPosFlag::Before|CellPosFlag::After)))
2520  ImplSetLineColor( rNewFrame, SvxBoxItemLine::BOTTOM, aColor );
2521 
2522  if (!(nCellPosFlags & (CellPosFlag::Upper|CellPosFlag::Before|CellPosFlag::After)))
2523  ImplSetLineColor( rNewFrame, SvxBoxItemLine::TOP, aColor );
2524 
2525  if (!(nCellPosFlags & (CellPosFlag::Upper|CellPosFlag::Lower|CellPosFlag::After)))
2526  ImplSetLineColor( rNewFrame, SvxBoxItemLine::RIGHT, aColor );
2527 
2528  if (!(nCellPosFlags & (CellPosFlag::Upper|CellPosFlag::Lower|CellPosFlag::Before)))
2529  ImplSetLineColor( rNewFrame, SvxBoxItemLine::LEFT, aColor );
2530 }
2531 
2532 
2533 static void ImplApplyBorderLineItem( CellPosFlag nCellPosFlags, const SvxBorderLine* pBorderLineItem, SvxBoxItem& rNewFrame )
2534 {
2535  if (nCellPosFlags & (CellPosFlag::Before|CellPosFlag::After|CellPosFlag::Upper|CellPosFlag::Lower))
2536  {
2537  if (!(nCellPosFlags & (CellPosFlag::Before|CellPosFlag::After))) // check if it's not any corner
2538  {
2539  if (nCellPosFlags & CellPosFlag::Upper)
2540  {
2541  if( rNewFrame.GetBottom() )
2542  ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, SvxBoxItemLine::BOTTOM );
2543  }
2544  else if (nCellPosFlags & CellPosFlag::Lower)
2545  {
2546  if( rNewFrame.GetTop() )
2547  ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, SvxBoxItemLine::TOP );
2548  }
2549  }
2550  else if (!(nCellPosFlags & (CellPosFlag::Upper|CellPosFlag::Lower))) // check if it's not any corner
2551  {
2552  if (nCellPosFlags & CellPosFlag::Before)
2553  {
2554  if( rNewFrame.GetRight() )
2555  ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, SvxBoxItemLine::RIGHT );
2556  }
2557  else if (nCellPosFlags & CellPosFlag::After)
2558  {
2559  if( rNewFrame.GetLeft() )
2560  ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, SvxBoxItemLine::LEFT );
2561  }
2562  }
2563  }
2564  else
2565  {
2566  if( rNewFrame.GetBottom() )
2567  ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, SvxBoxItemLine::BOTTOM );
2568  if( rNewFrame.GetTop() )
2569  ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, SvxBoxItemLine::TOP );
2570  if( rNewFrame.GetRight() )
2571  ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, SvxBoxItemLine::RIGHT );
2572  if( rNewFrame.GetLeft() )
2573  ImplSetLinePreserveColor( rNewFrame, pBorderLineItem, SvxBoxItemLine::LEFT );
2574  }
2575 }
2576 
2577 
2578 void SvxTableController::ApplyBorderAttr( const SfxItemSet& rAttr )
2579 {
2580  if( !mxTable.is() )
2581  return;
2582 
2583  const sal_Int32 nRowCount = mxTable->getRowCount();
2584  const sal_Int32 nColCount = mxTable->getColumnCount();
2585  if( !(nRowCount && nColCount) )
2586  return;
2587 
2588  const SvxBoxItem* pBoxItem = nullptr;
2589  if(SfxItemState::SET == rAttr.GetItemState(SDRATTR_TABLE_BORDER, false) )
2590  pBoxItem = &rAttr.Get( SDRATTR_TABLE_BORDER );
2591 
2592  const SvxBoxInfoItem* pBoxInfoItem = nullptr;
2593  if(SfxItemState::SET == rAttr.GetItemState(SDRATTR_TABLE_BORDER_INNER, false) )
2594  pBoxInfoItem = &rAttr.Get( SDRATTR_TABLE_BORDER_INNER );
2595 
2596  const SvxColorItem* pLineColorItem = nullptr;
2597  if(SfxItemState::SET == rAttr.GetItemState(SID_FRAME_LINECOLOR, false) )
2598  pLineColorItem = &rAttr.Get( SID_FRAME_LINECOLOR );
2599 
2600  const SvxBorderLine* pBorderLineItem = nullptr;
2601  if(SfxItemState::SET == rAttr.GetItemState(SID_FRAME_LINESTYLE, false) )
2602  pBorderLineItem = rAttr.Get( SID_FRAME_LINESTYLE ).GetLine();
2603 
2604  if( pBoxInfoItem && !pBoxItem )
2605  {
2606  const static SvxBoxItem gaEmptyBoxItem( SDRATTR_TABLE_BORDER );
2607  pBoxItem = &gaEmptyBoxItem;
2608  }
2609  else if( pBoxItem && !pBoxInfoItem )
2610  {
2611  const static SvxBoxInfoItem gaEmptyBoxInfoItem( SDRATTR_TABLE_BORDER_INNER );
2612  pBoxInfoItem = &gaEmptyBoxInfoItem;
2613  }
2614 
2615  CellPos aStart, aEnd;
2616  getSelectedCells( aStart, aEnd );
2617 
2618  const sal_Int32 nLastRow = std::min( aEnd.mnRow + 2, nRowCount );
2619  const sal_Int32 nLastCol = std::min( aEnd.mnCol + 2, nColCount );
2620 
2621  for( sal_Int32 nRow = std::max( aStart.mnRow - 1, sal_Int32(0) ); nRow < nLastRow; nRow++ )
2622  {
2623  CellPosFlag nRowFlags = CellPosFlag::NONE;
2624  nRowFlags |= (nRow == aStart.mnRow) ? CellPosFlag::Top : CellPosFlag::NONE;
2625  nRowFlags |= (nRow == aEnd.mnRow) ? CellPosFlag::Bottom : CellPosFlag::NONE;
2626  nRowFlags |= (nRow < aStart.mnRow) ? CellPosFlag::Upper : CellPosFlag::NONE;
2627  nRowFlags |= (nRow > aEnd.mnRow) ? CellPosFlag::Lower : CellPosFlag::NONE;
2628 
2629  for( sal_Int32 nCol = std::max( aStart.mnCol - 1, sal_Int32(0) ); nCol < nLastCol; nCol++ )
2630  {
2631  CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
2632  if( !xCell.is() )
2633  continue;
2634 
2635  const SfxItemSet& rSet = xCell->GetItemSet();
2636  const SvxBoxItem* pOldOuter = &rSet.Get( SDRATTR_TABLE_BORDER );
2637 
2638  SvxBoxItem aNewFrame( *pOldOuter );
2639 
2640  CellPosFlag nCellPosFlags = nRowFlags;
2641  nCellPosFlags |= (nCol == aStart.mnCol) ? CellPosFlag::Left : CellPosFlag::NONE;
2642  nCellPosFlags |= (nCol == aEnd.mnCol) ? CellPosFlag::Right : CellPosFlag::NONE;
2643  nCellPosFlags |= (nCol < aStart.mnCol) ? CellPosFlag::Before : CellPosFlag::NONE;
2644  nCellPosFlags |= (nCol > aEnd.mnCol) ? CellPosFlag::After : CellPosFlag::NONE;
2645 
2646  if( pBoxItem && pBoxInfoItem )
2647  ImplApplyBoxItem( nCellPosFlags, pBoxItem, pBoxInfoItem, aNewFrame );
2648 
2649  if( pLineColorItem )
2650  ImplApplyLineColorItem( nCellPosFlags, pLineColorItem, aNewFrame );
2651 
2652  if( pBorderLineItem )
2653  ImplApplyBorderLineItem( nCellPosFlags, pBorderLineItem, aNewFrame );
2654 
2655  if (aNewFrame != *pOldOuter)
2656  {
2657  SfxItemSet aAttr(*rSet.GetPool(), rSet.GetRanges());
2658  aAttr.Put(aNewFrame);
2659  xCell->SetMergedItemSetAndBroadcast( aAttr, false );
2660  }
2661  }
2662  }
2663 }
2664 
2665 
2666 void SvxTableController::UpdateTableShape()
2667 {
2668  SdrObject* pTableObj = mxTableObj.get();
2669  if( pTableObj )
2670  {
2671  pTableObj->ActionChanged();
2672  pTableObj->BroadcastObjectChange();
2673  }
2674  updateSelectionOverlay();
2675 }
2676 
2677 
2678 void SvxTableController::SetAttrToSelectedCells(const SfxItemSet& rAttr, bool bReplaceAll)
2679 {
2680  if(!checkTableObject() || !mxTable.is())
2681  return;
2682 
2683  SdrTableObj& rTableObj(*mxTableObj);
2684  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
2685  const bool bUndo(rModel.IsUndoEnabled());
2686 
2687  if( bUndo )
2688  rModel.BegUndo( SvxResId(STR_TABLE_NUMFORMAT) );
2689 
2690  CellPos aStart, aEnd;
2691  getSelectedCells( aStart, aEnd );
2692 
2693  SfxItemSet aAttr(*rAttr.GetPool(), rAttr.GetRanges());
2694  aAttr.Put(rAttr);
2695 
2696  const bool bFrame = (rAttr.GetItemState( SDRATTR_TABLE_BORDER ) == SfxItemState::SET) || (rAttr.GetItemState( SDRATTR_TABLE_BORDER_INNER ) == SfxItemState::SET);
2697 
2698  if( bFrame )
2699  {
2700  aAttr.ClearItem( SDRATTR_TABLE_BORDER );
2701  aAttr.ClearItem( SDRATTR_TABLE_BORDER_INNER );
2702  }
2703 
2704  for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
2705  {
2706  for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
2707  {
2708  CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
2709  if( xCell.is() )
2710  {
2711  if( bUndo )
2712  xCell->AddUndo();
2713  xCell->SetMergedItemSetAndBroadcast(aAttr, bReplaceAll);
2714  }
2715  }
2716  }
2717 
2718  if( bFrame )
2719  {
2720  ApplyBorderAttr( rAttr );
2721  }
2722 
2723  UpdateTableShape();
2724 
2725  if( bUndo )
2726  rModel.EndUndo();
2727 }
2728 
2729 void SvxTableController::SetAttrToSelectedShape(const SfxItemSet& rAttr)
2730 {
2731  if (!checkTableObject() || !mxTable.is())
2732  return;
2733 
2734  // Filter out non-shadow items from rAttr.
2735  SfxItemSet aSet(*rAttr.GetPool(), svl::Items<SDRATTR_SHADOW_FIRST, SDRATTR_SHADOW_LAST>{});
2736  aSet.Put(rAttr);
2737 
2738  // Set shadow items on the marked shape.
2739  mrView.SetAttrToMarked(aSet, /*bReplaceAll=*/false);
2740 }
2741 
2742 bool SvxTableController::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const
2743 {
2744  if( mxTableObj.is() && hasSelectedCells() )
2745  {
2746  MergeAttrFromSelectedCells( rTargetSet, bOnlyHardAttr );
2747 
2748  if( mrView.IsTextEdit() )
2749  {
2750  OutlinerView* pTextEditOutlinerView = mrView.GetTextEditOutlinerView();
2751  if(pTextEditOutlinerView)
2752  {
2753  // FALSE= consider InvalidItems not as the default, but as "holes"
2754  rTargetSet.Put(pTextEditOutlinerView->GetAttribs(), false);
2755  }
2756  }
2757 
2758  return true;
2759  }
2760  else
2761  {
2762  return false;
2763  }
2764 }
2765 
2766 
2767 bool SvxTableController::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll)
2768 {
2769  if( mbCellSelectionMode || mrView.IsTextEdit() )
2770  {
2771  SetAttrToSelectedCells( rSet, bReplaceAll );
2772  return true;
2773  }
2774  return false;
2775 }
2776 
2777 SdrObject* SvxTableController::GetMarkedSdrObjClone(SdrModel& rTargetModel)
2778 {
2779  SdrTableObj* pRetval(nullptr);
2780  sdr::table::SdrTableObj* pCurrentSdrTableObj(GetTableObj());
2781 
2782  if(nullptr == pCurrentSdrTableObj)
2783  {
2784  return pRetval;
2785  }
2786 
2787  if(!mxTableObj.is())
2788  {
2789  return pRetval;
2790  }
2791 
2792  // get selection and create full selection
2793  CellPos aStart, aEnd;
2794  const CellPos aFullStart, aFullEnd(mxTable->getColumnCount()-1, mxTable->getRowCount()-1);
2795 
2796  getSelectedCells(aStart, aEnd);
2797 
2798  // compare to see if we have a partial selection
2799  if(aStart != aFullStart || aEnd != aFullEnd)
2800  {
2801  // create full clone
2802  pRetval = pCurrentSdrTableObj->CloneSdrObject(rTargetModel);
2803 
2804  // limit SdrObject's TableModel to partial selection
2805  pRetval->CropTableModelToSelection(aStart, aEnd);
2806  }
2807 
2808  return pRetval;
2809 }
2810 
2811 bool SvxTableController::PasteObjModel( const SdrModel& rModel )
2812 {
2813  if( mxTableObj.is() && (rModel.GetPageCount() >= 1) )
2814  {
2815  const SdrPage* pPastePage = rModel.GetPage(0);
2816  if( pPastePage && pPastePage->GetObjCount() == 1 )
2817  {
2818  SdrTableObj* pPasteTableObj = dynamic_cast< SdrTableObj* >( pPastePage->GetObj(0) );
2819  if( pPasteTableObj )
2820  {
2821  return PasteObject( pPasteTableObj );
2822  }
2823  }
2824  }
2825 
2826  return false;
2827 }
2828 
2829 
2830 bool SvxTableController::PasteObject( SdrTableObj const * pPasteTableObj )
2831 {
2832  if( !pPasteTableObj )
2833  return false;
2834 
2835  Reference< XTable > xPasteTable( pPasteTableObj->getTable() );
2836  if( !xPasteTable.is() )
2837  return false;
2838 
2839  if( !mxTable.is() )
2840  return false;
2841 
2842  sal_Int32 nPasteColumns = xPasteTable->getColumnCount();
2843  sal_Int32 nPasteRows = xPasteTable->getRowCount();
2844 
2845  CellPos aStart, aEnd;
2846  getSelectedCells( aStart, aEnd );
2847 
2848  if( mrView.IsTextEdit() )
2849  mrView.SdrEndTextEdit(true);
2850 
2851  sal_Int32 nColumns = mxTable->getColumnCount();
2852  sal_Int32 nRows = mxTable->getRowCount();
2853 
2854  const sal_Int32 nMissing = nPasteRows - ( nRows - aStart.mnRow );
2855  if( nMissing > 0 )
2856  {
2857  Reference< XTableRows > xRows( mxTable->getRows() );
2858  xRows->insertByIndex( nRows, nMissing );
2859  nRows = mxTable->getRowCount();
2860  }
2861 
2862  nPasteRows = std::min( nPasteRows, nRows - aStart.mnRow );
2863  nPasteColumns = std::min( nPasteColumns, nColumns - aStart.mnCol );
2864 
2865  // copy cell contents
2866  for( sal_Int32 nRow = 0; nRow < nPasteRows; ++nRow )
2867  {
2868  for( sal_Int32 nCol = 0, nTargetCol = aStart.mnCol; nCol < nPasteColumns; ++nCol )
2869  {
2870  CellRef xTargetCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nTargetCol, aStart.mnRow + nRow ).get() ) );
2871  if( xTargetCell.is() && !xTargetCell->isMerged() )
2872  {
2873  CellRef xSourceCell(dynamic_cast<Cell*>(xPasteTable->getCellByPosition(nCol, nRow).get()));
2874  if (xSourceCell.is())
2875  {
2876  xTargetCell->AddUndo();
2877  // Prevent cell span exceeding the pasting range.
2878  if (nColumns < nTargetCol + xSourceCell->getColumnSpan())
2879  xTargetCell->replaceContentAndFormatting(xSourceCell);
2880  else
2881  xTargetCell->cloneFrom(xSourceCell);
2882 
2883  nCol += xSourceCell->getColumnSpan() - 1;
2884  nTargetCol += xTargetCell->getColumnSpan();
2885  }
2886  }
2887  }
2888  }
2889 
2890  UpdateTableShape();
2891 
2892  return true;
2893 }
2894 
2895 bool SvxTableController::ApplyFormatPaintBrush( SfxItemSet& rFormatSet, bool bNoCharacterFormats, bool bNoParagraphFormats )
2896 {
2897  if(!mbCellSelectionMode)
2898  {
2899  return false;
2900  }
2901 
2902  if(!checkTableObject())
2903  return false;
2904 
2905  SdrTableObj& rTableObj(*mxTableObj);
2906  SdrModel& rModel(rTableObj.getSdrModelFromSdrObject());
2907  const bool bUndo(rModel.IsUndoEnabled());
2908 
2909  if( bUndo )
2910  rModel.BegUndo(SvxResId(STR_TABLE_NUMFORMAT));
2911 
2912  CellPos aStart, aEnd;
2913  getSelectedCells( aStart, aEnd );
2914  const bool bFrame = (rFormatSet.GetItemState( SDRATTR_TABLE_BORDER ) == SfxItemState::SET) || (rFormatSet.GetItemState( SDRATTR_TABLE_BORDER_INNER ) == SfxItemState::SET);
2915 
2916  for( sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++ )
2917  {
2918  for( sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++ )
2919  {
2920  CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
2921  if( xCell.is() )
2922  {
2923  if (bUndo)
2924  xCell->AddUndo();
2925  SdrText* pText = xCell.get();
2926  SdrObjEditView::ApplyFormatPaintBrushToText( rFormatSet, rTableObj, pText, bNoCharacterFormats, bNoParagraphFormats );
2927  }
2928  }
2929  }
2930 
2931  if( bFrame )
2932  {
2933  ApplyBorderAttr( rFormatSet );
2934  }
2935 
2936  UpdateTableShape();
2937 
2938  if( bUndo )
2939  rModel.EndUndo();
2940 
2941  return true;
2942 }
2943 
2944 
2945 IMPL_LINK_NOARG(SvxTableController, UpdateHdl, void*, void)
2946 {
2947  mnUpdateEvent = nullptr;
2948 
2949  if( mbCellSelectionMode )
2950  {
2951  CellPos aStart( maCursorFirstPos );
2952  CellPos aEnd( maCursorLastPos );
2953  checkCell(aStart);
2954  checkCell(aEnd);
2955  if( aStart != maCursorFirstPos || aEnd != maCursorLastPos )
2956  {
2957  setSelectedCells( aStart, aEnd );
2958  }
2959  }
2960 
2961  updateSelectionOverlay();
2962  mbHasJustMerged = false;
2963 }
2964 
2965 namespace
2966 {
2967 
2968 struct LinesState
2969 {
2970  LinesState(SvxBoxItem& rBoxItem_, SvxBoxInfoItem& rBoxInfoItem_)
2971  : rBoxItem(rBoxItem_)
2972  , rBoxInfoItem(rBoxInfoItem_)
2973  , bDistanceIndeterminate(false)
2974  {
2975  aBorderSet.fill(false);
2976  aInnerLineSet.fill(false);
2977  aBorderIndeterminate.fill(false);
2978  aInnerLineIndeterminate.fill(false);
2979  aDistanceSet.fill(false);
2980  aDistance.fill(0);
2981  }
2982 
2983  SvxBoxItem& rBoxItem;
2984  SvxBoxInfoItem& rBoxInfoItem;
2985  o3tl::enumarray<SvxBoxItemLine, bool> aBorderSet;
2986  o3tl::enumarray<SvxBoxInfoItemLine, bool> aInnerLineSet;
2987  o3tl::enumarray<SvxBoxItemLine, bool> aBorderIndeterminate;
2988  o3tl::enumarray<SvxBoxInfoItemLine, bool> aInnerLineIndeterminate;
2989  o3tl::enumarray<SvxBoxItemLine, bool> aDistanceSet;
2990  o3tl::enumarray<SvxBoxItemLine, sal_uInt16> aDistance;
2991  bool bDistanceIndeterminate;
2992 };
2993 
2994 class BoxItemWrapper
2995 {
2996 public:
2997  BoxItemWrapper(SvxBoxItem& rBoxItem, SvxBoxInfoItem& rBoxInfoItem, SvxBoxItemLine nBorderLine, SvxBoxInfoItemLine nInnerLine, bool bBorder);
2998 
2999  const SvxBorderLine* getLine() const;
3000  void setLine(const SvxBorderLine* pLine);
3001 
3002 private:
3003  SvxBoxItem& m_rBoxItem;
3004  SvxBoxInfoItem& m_rBoxInfoItem;
3005  const SvxBoxItemLine m_nBorderLine;
3006  const SvxBoxInfoItemLine m_nInnerLine;
3007  const bool m_bBorder;
3008 };
3009 
3010 BoxItemWrapper::BoxItemWrapper(
3011  SvxBoxItem& rBoxItem, SvxBoxInfoItem& rBoxInfoItem,
3012  const SvxBoxItemLine nBorderLine, const SvxBoxInfoItemLine nInnerLine, const bool bBorder)
3013  : m_rBoxItem(rBoxItem)
3014  , m_rBoxInfoItem(rBoxInfoItem)
3015  , m_nBorderLine(nBorderLine)
3016  , m_nInnerLine(nInnerLine)
3017  , m_bBorder(bBorder)
3018 {
3019 }
3020 
3021 const SvxBorderLine* BoxItemWrapper::getLine() const
3022 {
3023  if (m_bBorder)
3024  return m_rBoxItem.GetLine(m_nBorderLine);
3025  else
3026  return (m_nInnerLine == SvxBoxInfoItemLine::HORI) ? m_rBoxInfoItem.GetHori() : m_rBoxInfoItem.GetVert();
3027 }
3028 
3029 void BoxItemWrapper::setLine(const SvxBorderLine* pLine)
3030 {
3031  if (m_bBorder)
3032  m_rBoxItem.SetLine(pLine, m_nBorderLine);
3033  else
3034  m_rBoxInfoItem.SetLine(pLine, m_nInnerLine);
3035 }
3036 
3037 void lcl_MergeBorderLine(
3038  LinesState& rLinesState, const SvxBorderLine* const pLine, const SvxBoxItemLine nLine,
3039  SvxBoxInfoItemValidFlags nValidFlag, const bool bBorder = true)
3040 {
3041  const SvxBoxInfoItemLine nInnerLine(bBorder ? SvxBoxInfoItemLine::HORI : ((nValidFlag & SvxBoxInfoItemValidFlags::HORI) ? SvxBoxInfoItemLine::HORI : SvxBoxInfoItemLine::VERT));
3042  BoxItemWrapper aBoxItem(rLinesState.rBoxItem, rLinesState.rBoxInfoItem, nLine, nInnerLine, bBorder);
3043  bool& rbSet(bBorder ? rLinesState.aBorderSet[nLine] : rLinesState.aInnerLineSet[nInnerLine]);
3044 
3045  if (rbSet)
3046  {
3047  bool& rbIndeterminate(bBorder ? rLinesState.aBorderIndeterminate[nLine] : rLinesState.aInnerLineIndeterminate[nInnerLine]);
3048  if (!rbIndeterminate)
3049  {
3050  const SvxBorderLine* const pMergedLine(aBoxItem.getLine());
3051  if ((pLine && !pMergedLine) || (!pLine && pMergedLine) || (pLine && (*pLine != *pMergedLine)))
3052  {
3053  aBoxItem.setLine(nullptr);
3054  rbIndeterminate = true;
3055  }
3056  }
3057  }
3058  else
3059  {
3060  aBoxItem.setLine(pLine);
3061  rbSet = true;
3062  }
3063 }
3064 
3065 void lcl_MergeBorderOrInnerLine(
3066  LinesState& rLinesState, const SvxBorderLine* const pLine, const SvxBoxItemLine nLine,
3067  SvxBoxInfoItemValidFlags nValidFlag, const bool bBorder)
3068 {
3069  if (bBorder)
3070  lcl_MergeBorderLine(rLinesState, pLine, nLine, nValidFlag);
3071  else
3072  {
3073  const bool bVertical = (nLine == SvxBoxItemLine::LEFT) || (nLine == SvxBoxItemLine::RIGHT);
3074  lcl_MergeBorderLine(rLinesState, pLine, nLine, bVertical ? SvxBoxInfoItemValidFlags::VERT : SvxBoxInfoItemValidFlags::HORI, false);
3075  }
3076 }
3077 
3078 void lcl_MergeDistance(
3079  LinesState& rLinesState, const SvxBoxItemLine nIndex, const sal_uInt16 nDistance)
3080 {
3081  if (rLinesState.aDistanceSet[nIndex])
3082  {
3083  if (!rLinesState.bDistanceIndeterminate)
3084  rLinesState.bDistanceIndeterminate = nDistance != rLinesState.aDistance[nIndex];
3085  }
3086  else
3087  {
3088  rLinesState.aDistance[nIndex] = nDistance;
3089  rLinesState.aDistanceSet[nIndex] = true;
3090  }
3091 }
3092 
3093 void lcl_MergeCommonBorderAttr(LinesState& rLinesState, const SvxBoxItem& rCellBoxItem, const CellPosFlag nCellPosFlags)
3094 {
3095  if (nCellPosFlags & (CellPosFlag::Before|CellPosFlag::After|CellPosFlag::Upper|CellPosFlag::Lower))
3096  {
3097  // current cell is outside the selection
3098 
3099  if (!(nCellPosFlags & (CellPosFlag::Before|CellPosFlag::After))) // check if it's not any corner
3100  {
3101  if (nCellPosFlags & CellPosFlag::Upper)
3102  lcl_MergeBorderLine(rLinesState, rCellBoxItem.GetBottom(), SvxBoxItemLine::TOP, SvxBoxInfoItemValidFlags::TOP);
3103  else if (nCellPosFlags & CellPosFlag::Lower)
3104  lcl_MergeBorderLine(rLinesState, rCellBoxItem.GetTop(), SvxBoxItemLine::BOTTOM, SvxBoxInfoItemValidFlags::BOTTOM);
3105  }
3106  else if (!(nCellPosFlags & (CellPosFlag::Upper|CellPosFlag::Lower))) // check if it's not any corner
3107  {
3108  if (nCellPosFlags & CellPosFlag::Before)
3109  lcl_MergeBorderLine(rLinesState, rCellBoxItem.GetRight(), SvxBoxItemLine::LEFT, SvxBoxInfoItemValidFlags::LEFT);
3110  else if (nCellPosFlags & CellPosFlag::After)
3111  lcl_MergeBorderLine(rLinesState, rCellBoxItem.GetLeft(), SvxBoxItemLine::RIGHT, SvxBoxInfoItemValidFlags::RIGHT);
3112  }
3113 
3114  // NOTE: inner distances for cells outside the selected range
3115  // are not relevant -> we ignore them.
3116  }
3117  else
3118  {
3119  // current cell is inside the selection
3120 
3121  lcl_MergeBorderOrInnerLine(rLinesState, rCellBoxItem.GetTop(), SvxBoxItemLine::TOP, SvxBoxInfoItemValidFlags::TOP, static_cast<bool>(nCellPosFlags & CellPosFlag::Top));
3122  lcl_MergeBorderOrInnerLine(rLinesState, rCellBoxItem.GetBottom(), SvxBoxItemLine::BOTTOM, SvxBoxInfoItemValidFlags::BOTTOM, static_cast<bool>(nCellPosFlags & CellPosFlag::Bottom));
3123  lcl_MergeBorderOrInnerLine(rLinesState, rCellBoxItem.GetLeft(), SvxBoxItemLine::LEFT, SvxBoxInfoItemValidFlags::LEFT, static_cast<bool>(nCellPosFlags & CellPosFlag::Left));
3124  lcl_MergeBorderOrInnerLine(rLinesState, rCellBoxItem.GetRight(), SvxBoxItemLine::RIGHT, SvxBoxInfoItemValidFlags::RIGHT, static_cast<bool>(nCellPosFlags & CellPosFlag::Right));
3125 
3126  lcl_MergeDistance(rLinesState, SvxBoxItemLine::TOP, rCellBoxItem.GetDistance(SvxBoxItemLine::TOP));
3127  lcl_MergeDistance(rLinesState, SvxBoxItemLine::BOTTOM, rCellBoxItem.GetDistance(SvxBoxItemLine::BOTTOM));
3128  lcl_MergeDistance(rLinesState, SvxBoxItemLine::LEFT, rCellBoxItem.GetDistance(SvxBoxItemLine::LEFT));
3129  lcl_MergeDistance(rLinesState, SvxBoxItemLine::RIGHT, rCellBoxItem.GetDistance(SvxBoxItemLine::RIGHT));
3130  }
3131 }
3132 
3133 }
3134 
3135 void SvxTableController::FillCommonBorderAttrFromSelectedCells( SvxBoxItem& rBoxItem, SvxBoxInfoItem& rBoxInfoItem ) const
3136 {
3137  if( !mxTable.is() )
3138  return;
3139 
3140  const sal_Int32 nRowCount = mxTable->getRowCount();
3141  const sal_Int32 nColCount = mxTable->getColumnCount();
3142  if( !(nRowCount && nColCount) )
3143  return;
3144 
3145  CellPos aStart, aEnd;
3146  const_cast< SvxTableController* >( this )->getSelectedCells( aStart, aEnd );
3147 
3148  // We are adding one more row/column around the block of selected cells.
3149  // We will be checking the adjoining border of these too.
3150  const sal_Int32 nLastRow = std::min( aEnd.mnRow + 2, nRowCount );
3151  const sal_Int32 nLastCol = std::min( aEnd.mnCol + 2, nColCount );
3152 
3153  rBoxInfoItem.SetValid( SvxBoxInfoItemValidFlags::ALL, false );
3154  LinesState aLinesState( rBoxItem, rBoxInfoItem );
3155 
3156  /* Here we go through all the selected cells (enhanced by
3157  * the adjoining row/column on each side) and determine the
3158  * lines for presentation. The algorithm is simple:
3159  * 1. if a border or inner line is set (or unset) in all
3160  * cells to the same value, it will be used.
3161  * 2. if a border or inner line is set only in some cells,
3162  * it will be set to indeterminate state (SetValid() on
3163  * rBoxInfoItem).
3164  */
3165  for( sal_Int32 nRow = std::max( aStart.mnRow - 1, sal_Int32(0) ); nRow < nLastRow; nRow++ )
3166  {
3167  CellPosFlag nRowFlags = CellPosFlag::NONE;
3168  nRowFlags |= (nRow == aStart.mnRow) ? CellPosFlag::Top : CellPosFlag::NONE;
3169  nRowFlags |= (nRow == aEnd.mnRow) ? CellPosFlag::Bottom : CellPosFlag::NONE;
3170  nRowFlags |= (nRow < aStart.mnRow) ? CellPosFlag::Upper : CellPosFlag::NONE;
3171  nRowFlags |= (nRow > aEnd.mnRow) ? CellPosFlag::Lower : CellPosFlag::NONE;
3172 
3173  for( sal_Int32 nCol = std::max( aStart.mnCol - 1, sal_Int32(0) ); nCol < nLastCol; nCol++ )
3174  {
3175  CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
3176  if( !xCell.is() )
3177  continue;
3178 
3179  CellPosFlag nCellPosFlags = nRowFlags;
3180  nCellPosFlags |= (nCol == aStart.mnCol) ? CellPosFlag::Left : CellPosFlag::NONE;
3181  nCellPosFlags |= (nCol == aEnd.mnCol) ? CellPosFlag::Right : CellPosFlag::NONE;
3182  nCellPosFlags |= (nCol < aStart.mnCol) ? CellPosFlag::Before : CellPosFlag::NONE;
3183  nCellPosFlags |= (nCol > aEnd.mnCol) ? CellPosFlag::After : CellPosFlag::NONE;
3184 
3185  const SfxItemSet& rSet = xCell->GetItemSet();
3186  SvxBoxItem aCellBoxItem(mergeDrawinglayerTextDistancesAndSvxBoxItem(rSet));
3187  lcl_MergeCommonBorderAttr( aLinesState, aCellBoxItem, nCellPosFlags );
3188  }
3189  }
3190 
3191  if (!aLinesState.aBorderIndeterminate[SvxBoxItemLine::TOP])
3192  aLinesState.rBoxInfoItem.SetValid(SvxBoxInfoItemValidFlags::TOP);
3193  if (!aLinesState.aBorderIndeterminate[SvxBoxItemLine::BOTTOM])
3194  aLinesState.rBoxInfoItem.SetValid(SvxBoxInfoItemValidFlags::BOTTOM);
3195  if (!aLinesState.aBorderIndeterminate[SvxBoxItemLine::LEFT])
3196  aLinesState.rBoxInfoItem.SetValid(SvxBoxInfoItemValidFlags::LEFT);
3197  if (!aLinesState.aBorderIndeterminate[SvxBoxItemLine::RIGHT])
3198  aLinesState.rBoxInfoItem.SetValid(SvxBoxInfoItemValidFlags::RIGHT);
3199  if (!aLinesState.aInnerLineIndeterminate[SvxBoxInfoItemLine::HORI])
3200  aLinesState.rBoxInfoItem.SetValid(SvxBoxInfoItemValidFlags::HORI);
3201  if (!aLinesState.aInnerLineIndeterminate[SvxBoxInfoItemLine::VERT])
3202  aLinesState.rBoxInfoItem.SetValid(SvxBoxInfoItemValidFlags::VERT);
3203 
3204  if (!aLinesState.bDistanceIndeterminate)
3205  {
3206  if (aLinesState.aDistanceSet[SvxBoxItemLine::TOP])
3207  aLinesState.rBoxItem.SetDistance(aLinesState.aDistance[SvxBoxItemLine::TOP], SvxBoxItemLine::TOP);
3208  if (aLinesState.aDistanceSet[SvxBoxItemLine::BOTTOM])
3209  aLinesState.rBoxItem.SetDistance(aLinesState.aDistance[SvxBoxItemLine::BOTTOM], SvxBoxItemLine::BOTTOM);
3210  if (aLinesState.aDistanceSet[SvxBoxItemLine::LEFT])
3211  aLinesState.rBoxItem.SetDistance(aLinesState.aDistance[SvxBoxItemLine::LEFT], SvxBoxItemLine::LEFT);
3212  if (aLinesState.aDistanceSet[SvxBoxItemLine::RIGHT])
3213  aLinesState.rBoxItem.SetDistance(aLinesState.aDistance[SvxBoxItemLine::RIGHT], SvxBoxItemLine::RIGHT);
3214  aLinesState.rBoxInfoItem.SetValid(SvxBoxInfoItemValidFlags::DISTANCE);
3215  }
3216 }
3217 
3218 bool SvxTableController::selectRow( sal_Int32 row )
3219 {
3220  if( !mxTable.is() )
3221  return false;
3222  CellPos aStart( 0, row ), aEnd( mxTable->getColumnCount() - 1, row );
3223  StartSelection( aEnd );
3224  gotoCell( aStart, true, nullptr );
3225  return true;
3226 }
3227 
3228 bool SvxTableController::selectColumn( sal_Int32 column )
3229 {
3230  if( !mxTable.is() )
3231  return false;
3232  CellPos aStart( column, 0 ), aEnd( column, mxTable->getRowCount() - 1 );
3233  StartSelection( aEnd );
3234  gotoCell( aStart, true, nullptr );
3235  return true;
3236 }
3237 
3238 bool SvxTableController::deselectRow( sal_Int32 row )
3239 {
3240  if( !mxTable.is() )
3241  return false;
3242  CellPos aStart( 0, row ), aEnd( mxTable->getColumnCount() - 1, row );
3243  StartSelection( aEnd );
3244  gotoCell( aStart, false, nullptr );
3245  return true;
3246 }
3247 
3248 bool SvxTableController::deselectColumn( sal_Int32 column )
3249 {
3250  if( !mxTable.is() )
3251  return false;
3252  CellPos aStart( column, 0 ), aEnd( column, mxTable->getRowCount() - 1 );
3253  StartSelection( aEnd );
3254  gotoCell( aStart, false, nullptr );
3255  return true;
3256 }
3257 
3258 bool SvxTableController::isRowSelected( sal_Int32 nRow )
3259 {
3260  if( hasSelectedCells() )
3261  {
3262  CellPos aFirstPos, aLastPos;
3263  getSelectedCells( aFirstPos, aLastPos );
3264  if( (aFirstPos.mnCol == 0) && (nRow >= aFirstPos.mnRow && nRow <= aLastPos.mnRow) && (mxTable->getColumnCount() - 1 == aLastPos.mnCol) )
3265  return true;
3266  }
3267  return false;
3268 }
3269 
3270 bool SvxTableController::isColumnSelected( sal_Int32 nColumn )
3271 {
3272  if( hasSelectedCells() )
3273  {
3274  CellPos aFirstPos, aLastPos;
3275  getSelectedCells( aFirstPos, aLastPos );
3276  if( (aFirstPos.mnRow == 0) && (nColumn >= aFirstPos.mnCol && nColumn <= aLastPos.mnCol) && (mxTable->getRowCount() - 1 == aLastPos.mnRow) )
3277  return true;
3278  }
3279  return false;
3280 }
3281 
3282 bool SvxTableController::isRowHeader()
3283 {
3284  if(!checkTableObject())
3285  return false;
3286 
3287  SdrTableObj& rTableObj(*mxTableObj);
3288  TableStyleSettings aSettings(rTableObj.getTableStyleSettings());
3289 
3290  return aSettings.mbUseFirstRow;
3291 }
3292 
3293 bool SvxTableController::isColumnHeader()
3294 {
3295  if(!checkTableObject())
3296  return false;
3297 
3298  SdrTableObj& rTableObj(*mxTableObj);
3299  TableStyleSettings aSettings(rTableObj.getTableStyleSettings());
3300 
3301  return aSettings.mbUseFirstColumn;
3302 }
3303 
3304 bool SvxTableController::setCursorLogicPosition(const Point& rPosition, bool bPoint)
3305 {
3306  if (mxTableObj->GetObjIdentifier() != OBJ_TABLE)
3307  return false;
3308 
3309  SdrTableObj* pTableObj = mxTableObj.get();
3310  CellPos aCellPos;
3311  if (pTableObj->CheckTableHit(rPosition, aCellPos.mnCol, aCellPos.mnRow) != TableHitKind::NONE)
3312  {
3313  // Position is a table cell.
3314  if (mbCellSelectionMode)
3315  {
3316  // We have a table selection already: adjust the point or the mark.
3317  if (bPoint)
3318  setSelectedCells(maCursorFirstPos, aCellPos);
3319  else
3320  setSelectedCells(aCellPos, maCursorLastPos);
3321  return true;
3322  }
3323  else if (aCellPos != maMouseDownPos)
3324  {
3325  // No selection, but rPosition is at another cell: start table selection.
3326  StartSelection(maMouseDownPos);
3327  // Update graphic selection, should be hidden now.
3328  mrView.AdjustMarkHdl();
3329  }
3330  }
3331 
3332  return false;
3333 }
3334 
3335 }
3336 
3337 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
makeSdrTextUpperDistItem
SdrMetricItem makeSdrTextUpperDistItem(tools::Long mnHeight)
Definition: sdtditm.hxx:35
sdr::table::IMPL_LINK_NOARG
IMPL_LINK_NOARG(SvxTableController, UpdateHdl, void *, void)
Definition: tablecontroller.cxx:2945
basegfx::B2DRange::expand
void expand(const B2DTuple &rTuple)
sdr::table::SdrTableObj::getRightCell
CellPos getRightCell(const CellPos &rPos, bool bEdgeTravel) const
Definition: svdotable.cxx:982
sdr::table::SdrTableObj::GetOutlinerParaObject
virtual OutlinerParaObject * GetOutlinerParaObject() const override
Definition: svdotable.cxx:1890
nIndex
sal_Int32 nIndex
sdr::table::SvxTableController::~SvxTableController
virtual SVX_DLLPRIVATE ~SvxTableController() override
Definition: tablecontroller.cxx:204
SDRATTR_SHADOW_FIRST
constexpr sal_uInt16 SDRATTR_SHADOW_FIRST(XATTR_END+1)
SdrMarkList::GetMarkCount
size_t GetMarkCount() const
Definition: svdmark.hxx:180
aInnerLineSet
o3tl::enumarray< SvxBoxInfoItemLine, bool > aInnerLineSet
Definition: tablecontroller.cxx:2986
sdr::table::SvxTableController::destroySelectionOverlay
SVX_DLLPRIVATE void destroySelectionOverlay()
Definition: tablecontroller.cxx:2366
sdr::table::SdrTableObj::getTable
css::uno::Reference< css::table::XTable > getTable() const
Definition: svdotable.cxx:937
SdrObjEditView::SdrEndTextEdit
virtual SdrEndTextEditKind SdrEndTextEdit(bool bDontDeleteReally=false)
Definition: svdedxv.cxx:1409
sdr::table::SdrTableObj::setTableStyle
void setTableStyle(const css::uno::Reference< css::container::XIndexAccess > &xAutoFormatStyle)
Definition: svdotable.cxx:1307
sdr::table::SdrTableObj::getUpCell
CellPos getUpCell(const CellPos &rPos, bool bEdgeTravel) const
Definition: svdotable.cxx:997
SdrPaintWindow::GetOverlayManager
rtl::Reference< sdr::overlay::OverlayManager > const & GetOverlayManager() const
Definition: sdrpaintwindow.cxx:257
SdrUndoGeoObj::SetSkipChangeLayout
void SetSkipChangeLayout(bool bOn)
Definition: svdundo.hxx:224
SfxAbstractDialog::GetOutputItemSet
virtual const SfxItemSet * GetOutputItemSet() const =0
GetValue
std::string GetValue
OutputDevice::LogicToLogic
Point LogicToLogic(const Point &rPtSource, const MapMode *pMapModeSource, const MapMode *pMapModeDest) const
sdr::table::SvxTableController::RemoveSelection
SVX_DLLPRIVATE void RemoveSelection()
Definition: tablecontroller.cxx:2278
sdr::table::ImplApplyLineColorItem
static void ImplApplyLineColorItem(CellPosFlag nCellPosFlags, const SvxColorItem *pLineColorItem, SvxBoxItem &rNewFrame)
Definition: tablecontroller.cxx:2515
sdr::table::SvxTableController::findMergeOrigin
SVX_DLLPRIVATE void findMergeOrigin(CellPos &rPos)
Definition: tablecontroller.cxx:1998
sdr::table::SvxTableController::onDelete
SVX_DLLPRIVATE void onDelete(sal_uInt16 nSId)
Definition: tablecontroller.cxx:794
SdrObjEditView::GetTextEditObject
SdrTextObj * GetTextEditObject() const
Definition: svdedxv.hxx:226
SvxAbstractDialogFactory::Create
static SvxAbstractDialogFactory * Create()
Definition: svxdlg.cxx:22
sdr::table::SvxTableController::HasMarked
SVX_DLLPRIVATE bool HasMarked() const
Definition: tablecontroller.cxx:1415
AllSettings::GetStyleSettings
const StyleSettings & GetStyleSettings() const
SfxItemSet::MergeValue
void MergeValue(const SfxPoolItem &rItem, bool bOverwriteDefaults=false)
SvxBoxInfoItem::GetVert
const editeng::SvxBorderLine * GetVert() const
sdr::table::SvxTableController::mxModifyListener
css::uno::Reference< css::util::XModifyListener > mxModifyListener
Definition: tablecontroller.hxx:188
EE_INDEX_NOT_FOUND
#define EE_INDEX_NOT_FOUND
sdr::table::CreateTableController
rtl::Reference< sdr::SelectionController > CreateTableController(SdrView &rView, const SdrTableObj &rObj, const rtl::Reference< sdr::SelectionController > &xRefController)
Definition: tablecontroller.cxx:153
mpController
SvxTableController * mpController
Definition: tablecontroller.cxx:127
rBoxInfoItem
SvxBoxInfoItem & rBoxInfoItem
Definition: tablecontroller.cxx:2984
SdrObjList::GetObj
SdrObject * GetObj(size_t nNum) const
Definition: svdpage.cxx:770
SdrObjList::GetObjCount
size_t GetObjCount() const
Definition: svdpage.cxx:764
CntUInt16Item::GetValue
sal_uInt16 GetValue() const
SfxItemSet::InvalidateItem
void InvalidateItem(sal_uInt16 nWhich)
SvxBoxItem::GetDistance
sal_uInt16 GetDistance(SvxBoxItemLine nLine) const
sdr::table::SdrTableObj::CropTableModelToSelection
void CropTableModelToSelection(const CellPos &rStart, const CellPos &rEnd)
Definition: svdotable.cxx:2390
SfxWhichIter::FirstWhich
sal_uInt16 FirstWhich()
SvxAbstractDialogFactory::CreateSvxFormatCellsDialog
virtual VclPtr< SfxAbstractTabDialog > CreateSvxFormatCellsDialog(weld::Window *pParent, const SfxItemSet *pAttr, const SdrModel &rModel)=0
sdr::table::SvxTableController::StartSelection
SVX_DLLPRIVATE void StartSelection(const CellPos &rPos)
Definition: tablecontroller.cxx:2183
Application::PostUserEvent
static ImplSVEvent * PostUserEvent(const Link< void *, void > &rLink, void *pCaller=nullptr, bool bReferenceLink=false)
OutputDevice::GetMapMode
const MapMode & GetMapMode() const
vcl::KeyCode::GetCode
sal_uInt16 GetCode() const
sdr::table::SvxTableController::SetAttrToSelectedShape
void SetAttrToSelectedShape(const SfxItemSet &rAttr)
Definition: tablecontroller.cxx:2729
SdrUndoGeoObj
Changing the geometry of an object.
Definition: svdundo.hxx:207
SdrMarkList::GetMark
SdrMark * GetMark(size_t nNum) const
Definition: svdmark.cxx:230
Outliner::GetParagraphCount
sal_Int32 GetParagraphCount() const
EditView::ChangeFontSize
void ChangeFontSize(bool bGrow, const FontList *pList)
sdr::table::SvxTableController::hasSelectedCells
virtual SVX_DLLPRIVATE bool hasSelectedCells() const override
This is a table object, and one or more of its cells are selected.
Definition: tablecontroller.hxx:104
sdr::table::ImplApplyBorderLineItem
static void ImplApplyBorderLineItem(CellPosFlag nCellPosFlags, const SvxBorderLine *pBorderLineItem, SvxBoxItem &rNewFrame)
Definition: tablecontroller.cxx:2533
bDistanceIndeterminate
bool bDistanceIndeterminate
Definition: tablecontroller.cxx:2991
SvxBoxInfoItemLine
SvxBoxInfoItemLine
SfxStyleSheetBase::GetItemSet
virtual SfxItemSet & GetItemSet()
makeSdrTextRightDistItem
SdrMetricItem makeSdrTextRightDistItem(tools::Long mnHeight)
Definition: sdtditm.hxx:30
SdrView::PickAnything
SdrHitKind PickAnything(const MouseEvent &rMEvt, SdrMouseEventKind nMouseDownOrMoveOrUp, SdrViewEvent &rVEvt) const
Definition: svdview.cxx:253
makeSdrTextLowerDistItem
SdrMetricItem makeSdrTextLowerDistItem(tools::Long mnHeight)
Definition: sdtditm.hxx:40
SfxRequest::GetArgs
const SfxItemSet * GetArgs() const
sdr::table::SvxTableController::GetStyleSheet
virtual SVX_DLLPRIVATE bool GetStyleSheet(SfxStyleSheet *&rpStyleSheet) const override
Definition: tablecontroller.cxx:1455
SvxBoxItem::GetRight
const editeng::SvxBorderLine * GetRight() const
SfxStyleSheetBase::GetFamily
SfxStyleFamily GetFamily() const
aInnerLineIndeterminate
o3tl::enumarray< SvxBoxInfoItemLine, bool > aInnerLineIndeterminate
Definition: tablecontroller.cxx:2988
OBJ_TABLE
media shape
Definition: svdobjkind.hxx:57
sdr::table::SvxTableController::changeTableEdge
SVX_DLLPRIVATE void changeTableEdge(const SfxRequest &rReq)
Definition: tablecontroller.cxx:1522
sdr::table::SdrTableObj::getLeftCell
CellPos getLeftCell(const CellPos &rPos, bool bEdgeTravel) const
Definition: svdotable.cxx:967
sdr::table::ImplSetLineColor
static void ImplSetLineColor(SvxBoxItem &rNewFrame, SvxBoxItemLine nLine, const Color &rColor)
Definition: tablecontroller.cxx:2503
basegfx::B2DRange::getMaxX
double getMaxX() const
SdrModel::BegUndo
void BegUndo()
Definition: svdmodel.cxx:405
SdrObjEditView::MarkListHasChanged
virtual void MarkListHasChanged() override
Definition: svdedxv.cxx:2484
sdr::table::SvxTableController::deselectColumn
bool deselectColumn(sal_Int32 column)
Definition: tablecontroller.cxx:3248
SDRATTR_START
constexpr sal_uInt16 SDRATTR_START(XATTR_START)
StyleSettings::GetHighlightColor
const Color & GetHighlightColor() const
SfxWhichIter::NextWhich
sal_uInt16 NextWhich()
sdr::table::SvxTableController::DistributeColumns
SVX_DLLPRIVATE void DistributeColumns(const bool bOptimize, const bool bMinimize)
Definition: tablecontroller.cxx:1369
SvxAbstractSplitTableDialog::IsHorizontal
virtual bool IsHorizontal() const =0
convertTwipToMm100
constexpr auto convertTwipToMm100(N n)
sdr::table::SvxTableController::mxTableObj
tools::WeakReference< SdrTableObj > mxTableObj
Definition: tablecontroller.hxx:187
EE_PARA_NOT_FOUND
#define EE_PARA_NOT_FOUND
sdr::overlay::OverlayObjectCell::RangeVector
::std::vector< basegfx::B2DRange > RangeVector
Definition: overlayobjectcell.hxx:34
MouseEvent::GetClicks
sal_uInt16 GetClicks() const
sdr::table::SvxTableController::PasteObject
SVX_DLLPRIVATE bool PasteObject(SdrTableObj const *pPasteTableObj)
Definition: tablecontroller.cxx:2830
SdrEditView::SetAttrToMarked
void SetAttrToMarked(const SfxItemSet &rAttr, bool bReplaceAll)
Definition: svdedtv1.cxx:1033
sdr::table::SvxTableController::GetTableObj
sdr::table::SdrTableObj * GetTableObj()
Definition: tablecontroller.hxx:127
sdr::table::SvxTableController::setSelectionStart
SVX_DLLPRIVATE void setSelectionStart(const CellPos &rPos)
Definition: tablecontroller.cxx:1929
aNewSelection
ESelection aNewSelection(GetSelection())
tools::Rectangle::Left
tools::Long Left() const
SdrObject::getSdrPageFromSdrObject
SdrPage * getSdrPageFromSdrObject() const
Definition: svdobj.cxx:266
sdr::table::SvxTableController::onMouseMove
virtual SVX_DLLPRIVATE bool onMouseMove(const MouseEvent &rMEvt, vcl::Window *pWin) override
Definition: tablecontroller.cxx:363
SvxResId
OUString SvxResId(const char *pId)
Definition: dialmgr.cxx:25
mnCol
size_t mnCol
Definition: framelinkarray.cxx:388
OUTDEV_WINDOW
OUTDEV_WINDOW
SvxBoxInfoItemValidFlags
SvxBoxInfoItemValidFlags
getPropertyValue
bool getPropertyValue(ValueType &rValue, css::uno::Reference< css::beans::XPropertySet > const &xPropSet, OUString const &propName)
sdr::table::ImplSetLinePreserveColor
static void ImplSetLinePreserveColor(SvxBoxItem &rNewFrame, const SvxBorderLine *pNew, SvxBoxItemLine nLine)
Definition: tablecontroller.cxx:2428
nCount
int nCount
SdrObjEditView::ApplyFormatPaintBrushToText
static void ApplyFormatPaintBrushToText(SfxItemSet const &rFormatSet, SdrTextObj &rTextObj, SdrText *pText, bool bNoCharacterFormats, bool bNoParagraphFormats)
helper function for selections with multiple SdrText for one SdrTextObj (f.e.
Definition: svdedxv.cxx:2710
tools::Rectangle::Bottom
tools::Long Bottom() const
aBorderIndeterminate
o3tl::enumarray< SvxBoxItemLine, bool > aBorderIndeterminate
Definition: tablecontroller.cxx:2987
SfxViewShell::Current
static SfxViewShell * Current()
sdr::table::SvxTableController::UpdateSelection
SVX_DLLPRIVATE void UpdateSelection(const CellPos &rPos)
Definition: tablecontroller.cxx:2251
eMode
Mode eMode
sdr::table::SdrTableObj::DistributeColumns
void DistributeColumns(sal_Int32 nFirstColumn, sal_Int32 nLastColumn, const bool bOptimize, const bool bMinimize)
Definition: svdotable.cxx:2400
SdrCreateView::SetEditMode
void SetEditMode(SdrViewEditMode eMode)
Definition: svdcrtv.hxx:89
sdr::table::SdrTableObj::getTableStyleSettings
const sdr::table::TableStyleSettings & getTableStyleSettings() const
Definition: svdotable.cxx:1163
sdr::table::SvxTableController::onSelectAll
virtual SVX_DLLPRIVATE void onSelectAll() override
Definition: tablecontroller.cxx:421
SvxBoxItem::GetLine
const editeng::SvxBorderLine * GetLine(SvxBoxItemLine nLine) const
sdr::table::SdrTableObj::getPreviousCell
CellPos getPreviousCell(const CellPos &rPos, bool bEdgeTravel) const
Definition: svdotable.cxx:1025
SdrPaintView::GetFirstOutputDevice
OutputDevice * GetFirstOutputDevice() const
Definition: svdpntv.cxx:88
basegfx::B2DRange::getMaxY
double getMaxY() const
sdr::table::SdrTableObj::DistributeRows
void DistributeRows(sal_Int32 nFirstRow, sal_Int32 nLastRow, const bool bOptimize, const bool bMinimize)
Definition: svdotable.cxx:2410
SDRATTR_TEXT_LOWERDIST
constexpr TypedWhichId< SdrMetricItem > SDRATTR_TEXT_LOWERDIST(SDRATTR_MISC_FIRST+7)
sdr::table::SdrTableObj::getActiveCellPos
void getActiveCellPos(sdr::table::CellPos &rPos) const
Definition: svdotable.cxx:1635
nCode
sal_uInt16 nCode
sdr::table::SvxTableController::selectColumn
bool selectColumn(sal_Int32 column)
Definition: tablecontroller.cxx:3228
SdrPaintView::PaintWindowCount
sal_uInt32 PaintWindowCount() const
Definition: svdpntv.hxx:223
aDistanceSet
o3tl::enumarray< SvxBoxItemLine, bool > aDistanceSet
Definition: tablecontroller.cxx:2989
SDRATTR_TABLE_BORDER_INNER
constexpr TypedWhichId< SvxBoxInfoItem > SDRATTR_TABLE_BORDER_INNER(SDRATTR_TABLE_FIRST+1)
Application::RemoveUserEvent
static void RemoveUserEvent(ImplSVEvent *nUserEvent)
SdrMark::GetMarkedSdrObj
SdrObject * GetMarkedSdrObj() const
Definition: svdmark.hxx:68
SvxBoxInfoItem::GetHori
const editeng::SvxBorderLine * GetHori() const
m_bBorder
const bool m_bBorder
Definition: tablecontroller.cxx:3007
SvxBoxItem::GetTop
const editeng::SvxBorderLine * GetTop() const
sdr::table::SvxTableController::getKeyboardAction
SVX_DLLPRIVATE TblAction getKeyboardAction(const KeyEvent &rKEvt)
Definition: tablecontroller.cxx:1598
m_nBorderLine
const SvxBoxItemLine m_nBorderLine
Definition: tablecontroller.cxx:3005
SfxItemSet::ClearItem
sal_uInt16 ClearItem(sal_uInt16 nWhich=0)
SdrObjEditView::GetTextEditOutliner
const SdrOutliner * GetTextEditOutliner() const
Definition: svdedxv.hxx:236
Right
Right
TOOLS_WARN_EXCEPTION
#define TOOLS_WARN_EXCEPTION(area, stream)
sType
OptionalString sType
SvxBoxItem::GetLeft
const editeng::SvxBorderLine * GetLeft() const
SfxItemSet::GetItemState
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
m_rBoxItem
SvxBoxItem & m_rBoxItem
Definition: tablecontroller.cxx:3003
sdr::table::SvxTableController::DistributeRows
SVX_DLLPRIVATE void DistributeRows(const bool bOptimize, const bool bMinimize)
Definition: tablecontroller.cxx:1392
SdrModel::IsUndoEnabled
bool IsUndoEnabled() const
returns true if undo is currently enabled This returns false if undo was disabled using EnableUndo( f...
Definition: svdmodel.cxx:570
sdr::table::TableHitKind
TableHitKind
SdrTableHitKind.
Definition: svdotable.hxx:51
sdr::table::SvxTableController::gotoCell
SVX_DLLPRIVATE void gotoCell(const CellPos &rCell, bool bSelect, vcl::Window *pWindow, TblAction nAction=TblAction::NONE)
Definition: tablecontroller.cxx:1894
diagnose_ex.h
sdr::table::SvxTableController::onFormatTable
SVX_DLLPRIVATE void onFormatTable(const SfxRequest &rReq)
Definition: tablecontroller.cxx:906
sdr::table::SvxTableController::PasteObjModel
virtual SVX_DLLPRIVATE bool PasteObjModel(const SdrModel &rModel) override
Definition: tablecontroller.cxx:2811
sdr::table::SvxTableController::mxTable
rtl::Reference< TableModel > mxTable
Definition: tablecontroller.hxx:177
sdr::table::SvxTableController::isRowSelected
bool isRowSelected(sal_Int32 nRow)
Definition: tablecontroller.cxx:3258
sdr::table::SvxTableController::mpSelectionOverlay
std::unique_ptr< sdr::overlay::OverlayObjectList > mpSelectionOverlay
Definition: tablecontroller.hxx:185
sdr::table::SvxTableController::setSelectedCells
void setSelectedCells(const CellPos &rFirstPos, const CellPos &rLastPos)
Definition: tablecontroller.cxx:2192
SdrObject::BroadcastObjectChange
void BroadcastObjectChange() const
Definition: svdobj.cxx:982
SDRATTR_TEXT_VERTADJUST
constexpr TypedWhichId< SdrTextVertAdjustItem > SDRATTR_TEXT_VERTADJUST(SDRATTR_MISC_FIRST+8)
CntUnencodedStringItem::GetValue
const OUString & GetValue() const
SdrMarkView::GetMarkedObjectList
const SdrMarkList & GetMarkedObjectList() const
Definition: svdmrkv.hxx:252
sdr::table::SdrTableObj::getLastCell
CellPos getLastCell() const
Definition: svdotable.cxx:955
SfxRequest::GetArg
const T * GetArg(sal_uInt16 nSlotId) const
SDRATTR_TEXT_LEFTDIST
constexpr TypedWhichId< SdrMetricItem > SDRATTR_TEXT_LEFTDIST(SDRATTR_MISC_FIRST+4)
SvxBoxInfoItem::SetLine
void SetLine(const editeng::SvxBorderLine *pNew, SvxBoxInfoItemLine nLine)
SdrObjEditView::SdrBeginTextEdit
virtual bool SdrBeginTextEdit(SdrObject *pObj, SdrPageView *pPV=nullptr, vcl::Window *pWin=nullptr, bool bIsNewObj=false, SdrOutliner *pGivenOutliner=nullptr, OutlinerView *pGivenOutlinerView=nullptr, bool bDontDeleteOutliner=false, bool bOnlyOneView=false, bool bGrabFocus=true)
Definition: svdedxv.cxx:1062
SdrModel::GetPage
const SdrPage * GetPage(sal_uInt16 nPgNum) const
Definition: svdmodel.cxx:1832
SdrObject::ActionChanged
void ActionChanged() const
Definition: svdobj.cxx:260
sdr::table::SvxTableController::DeleteMarked
virtual SVX_DLLPRIVATE bool DeleteMarked() override
Definition: tablecontroller.cxx:1420
u
float u
SdrMarkView::PickHandle
SdrHdl * PickHandle(const Point &rPnt) const
Definition: svdmrkv.cxx:1855
m_nInnerLine
const SvxBoxInfoItemLine m_nInnerLine
Definition: tablecontroller.cxx:3006
SdrObject::getSdrModelFromSdrObject
SdrModel & getSdrModelFromSdrObject() const
Definition: svdobj.cxx:276
SdrCreateView::SetCurrentObj
void SetCurrentObj(SdrObjKind nIdent, SdrInventor nInvent=SdrInventor::Default)
Definition: svdcrtv.cxx:331
sdr::table::SvxTableController::SplitMarkedCells
SVX_DLLPRIVATE void SplitMarkedCells(const SfxRequest &rReq)
Definition: tablecontroller.cxx:1314
sdr::table::SvxTableController::ChangeFontSize
virtual bool ChangeFontSize(bool bGrow, const FontList *pFontList) override
Changes the font (grow/shrink) according to the input parameters.
Definition: tablecontroller.cxx:2201
sdr::table::SvxTableController::SetAttrToSelectedCells
SVX_DLLPRIVATE void SetAttrToSelectedCells(const SfxItemSet &rAttr, bool bReplaceAll)
Definition: tablecontroller.cxx:2678
SdrObjEditView::GetTextEditOutlinerView
const OutlinerView * GetTextEditOutlinerView() const
Definition: svdedxv.hxx:238
o3tl::is_typed_flags
sdr::table::SvxTableController::SetTableStyle
SVX_DLLPRIVATE void SetTableStyle(const SfxItemSet *pArgs)
Definition: tablecontroller.cxx:1106
sdr::table::SvxTableController::getSelectionEnd
SVX_DLLPRIVATE const CellPos & getSelectionEnd()
Definition: tablecontroller.cxx:1935
Outliner::GetText
OUString GetText(Paragraph const *pPara, sal_Int32 nParaCount=1) const
OutputDevice::GetSettings
const AllSettings & GetSettings() const
MapMode::GetMapUnit
MapUnit GetMapUnit() const
SvxBoxItem::SetDistance
void SetDistance(sal_uInt16 nNew, SvxBoxItemLine nLine)
setPropertyValue
bool setPropertyValue(uno::Sequence< beans::PropertyValue > &aProp, const OUString &aName, const uno::Any &aValue)
tools::Rectangle::Top
tools::Long Top() const
m_rBoxInfoItem
SvxBoxInfoItem & m_rBoxInfoItem
Definition: tablecontroller.cxx:3004
sdr::table::SvxTableController::Execute
virtual void Execute(SfxRequest &rReq) override
Definition: tablecontroller.cxx:1008
sdr::table::SvxTableController::onInsert
SVX_DLLPRIVATE void onInsert(sal_uInt16 nSId, const SfxItemSet *pArgs=nullptr)
Definition: tablecontroller.cxx:525
VclAbstractDialog::StartExecuteAsync
bool StartExecuteAsync(const std::function< void(sal_Int32)> &rEndDialogFn)
SdrObject
Abstract DrawObject.
Definition: svdobj.hxx:258
SfxItemSet::GetPool
SfxItemPool * GetPool() const
CellPosFlag
CellPosFlag
Definition: tablecontroller.cxx:91
sdr::table::SdrTableObj::CheckTableHit
TableHitKind CheckTableHit(const Point &rPos, sal_Int32 &rnX, sal_Int32 &rnY, const sal_uInt16 aTol=0) const
Definition: svdotable.cxx:1187
SdrModel::GetSdrUndoFactory
SdrUndoFactory & GetSdrUndoFactory() const
returns the models undo factory.
Definition: svdmodel.cxx:1889
sdr::table::SvxTableController::EditCell
SVX_DLLPRIVATE void EditCell(const CellPos &rPos, vcl::Window *pWindow, TblAction nAction)
Definition: tablecontroller.cxx:2018
sdr::table::SvxTableController::onKeyInput
virtual SVX_DLLPRIVATE bool onKeyInput(const KeyEvent &rKEvt, vcl::Window *pWin) override
Definition: tablecontroller.cxx:222
sdr::table::SdrTableObj::getDownCell
CellPos getDownCell(const CellPos &rPos, bool bEdgeTravel) const
Definition: svdotable.cxx:1011
sdr::table::SvxTableController::StopTextEdit
SVX_DLLPRIVATE void StopTextEdit()
Definition: tablecontroller.cxx:2089
sdr::table::SdrTableObj::CloneSdrObject
virtual SdrTableObj * CloneSdrObject(SdrModel &rTargetModel) const override
Definition: svdotable.cxx:1780
makeSdrTextLeftDistItem
SdrMetricItem makeSdrTextLeftDistItem(tools::Long mnHeight)
Definition: sdtditm.hxx:25
sdr::table::SdrTableObj::GetWritingMode
css::text::WritingMode GetWritingMode() const
Definition: svdotable.cxx:2026
Outliner::GetParagraph
Paragraph * GetParagraph(sal_Int32 nAbsPos) const
sdr::table::SdrTableObj::setTableStyleSettings
void setTableStyleSettings(const sdr::table::TableStyleSettings &rStyle)
Definition: svdotable.cxx:1177
SDRATTR_TEXT_UPPERDIST
constexpr TypedWhichId< SdrMetricItem > SDRATTR_TEXT_UPPERDIST(SDRATTR_MISC_FIRST+6)
sdr::table::SvxTableController::MergeMarkedCells
SVX_DLLPRIVATE void MergeMarkedCells()
Definition: tablecontroller.cxx:1299
SdrUndoFactory::CreateUndoGeoObject
virtual std::unique_ptr< SdrUndoAction > CreateUndoGeoObject(SdrObject &rObject)
Definition: svdundo.cxx:1638
SvxBoxInfoItem::IsValid
bool IsValid(SvxBoxInfoItemValidFlags nValid) const
sdr::table::SvxTableController::MergeAttrFromSelectedCells
SVX_DLLPRIVATE void MergeAttrFromSelectedCells(SfxItemSet &rAttr, bool bOnlyHardAttr) const
Definition: tablecontroller.cxx:2387
OutputDevice::PixelToLogic
Point PixelToLogic(const Point &rDevicePt) const
OutlinerView::GetSelection
ESelection GetSelection() const
SfxRequest::GetFrameWeld
weld::Window * GetFrameWeld() const
sdr::table::SvxTableController::setCursorLogicPosition
virtual SVX_DLLPRIVATE bool setCursorLogicPosition(const Point &rPosition, bool bPoint) override
Definition: tablecontroller.cxx:3304
sdr::table::SvxTableController::create
static SVX_DLLPRIVATE rtl::Reference< sdr::SelectionController > create(SdrView &rView, const SdrTableObj &rObj, const rtl::Reference< sdr::SelectionController > &xRefController)
Definition: tablecontroller.cxx:162
SDRATTR_TABLE_BORDER
constexpr TypedWhichId< SvxBoxItem > SDRATTR_TABLE_BORDER(SDRATTR_TABLE_FIRST+0)
sdr::table::SdrTableObj::getFirstCell
static CellPos getFirstCell()
Definition: svdotable.cxx:949
SvxAbstractSplitTableDialog::GetCount
virtual tools::Long GetCount() const =0
SfxItemSet::Put
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
SDRATTR_SHADOW_LAST
constexpr sal_uInt16 SDRATTR_SHADOW_LAST(SDRATTR_SHADOWBLUR)
KeyEvent::GetKeyCode
const vcl::KeyCode & GetKeyCode() const
SfxRequest::GetSlot
sal_uInt16 GetSlot() const
SDRATTR_TABLE_LAST
constexpr sal_uInt16 SDRATTR_TABLE_LAST(SDRATTR_TABLE_TEXT_ROTATION)
OutlinerView::SetSelection
void SetSelection(const ESelection &)
sdr::table::SdrTableObj::IsTextEditActive
bool IsTextEditActive() const
Definition: svdotable.hxx:181
basegfx::B2DRange::getMinY
double getMinY() const
vcl::KeyCode::IsShift
bool IsShift() const
aBorderSet
o3tl::enumarray< SvxBoxItemLine, bool > aBorderSet
Definition: tablecontroller.cxx:2985
SdrObjEditView::IsTextEdit
virtual bool IsTextEdit() const final override
Definition: svdedxv.cxx:1672
SfxItemSet::DisableItem
void DisableItem(sal_uInt16 nWhich)
SDRATTR_TEXT_RIGHTDIST
constexpr TypedWhichId< SdrMetricItem > SDRATTR_TEXT_RIGHTDIST(SDRATTR_MISC_FIRST+5)
SfxItemSet::Get
const SfxPoolItem & Get(sal_uInt16 nWhich, bool bSrchInParent=true) const
sdr::table::SvxTableController::SetVertical
SVX_DLLPRIVATE void SetVertical(sal_uInt16 nSId)
Definition: tablecontroller.cxx:1240
SAL_WARN_IF
#define SAL_WARN_IF(condition, area, stream)
SdrEditView::DeleteMarkedObj
void DeleteMarkedObj()
Definition: svdedtv.cxx:796
mrView
SlideSorterView & mrView
sdr::table::SdrTableObj::IsVerticalWriting
virtual bool IsVerticalWriting() const override
Definition: svdotable.cxx:2009
SdrObject::GetMergedItemSet
const SfxItemSet & GetMergedItemSet() const
Definition: svdobj.cxx:1952
mnRow
size_t mnRow
Definition: framelinkarray.cxx:389
sdr::table::SdrTableObj::getNextCell
CellPos getNextCell(const CellPos &rPos, bool bEdgeTravel) const
Definition: svdotable.cxx:1052
SdrMakeOutliner
std::unique_ptr< SdrOutliner > SdrMakeOutliner(OutlinerMode nOutlinerMode, SdrModel &rModel)
Create an Outliner with the engine-global default settings on the heap.
Definition: svdetc.cxx:325
OutlinerView::PostKeyEvent
bool PostKeyEvent(const KeyEvent &rKEvt, vcl::Window const *pFrameWin=nullptr)
MouseEvent::IsLeft
bool IsLeft() const
RET_OK
RET_OK
SvxBoxItemLine
SvxBoxItemLine
SdrMarkView::AdjustMarkHdl
void AdjustMarkHdl(SfxViewShell *pOtherShell=nullptr)
Definition: svdmrkv.cxx:2540
vcl::KeyCode::IsMod1
bool IsMod1() const
sdr::table::SvxTableController::ApplyBorderAttr
SVX_DLLPRIVATE void ApplyBorderAttr(const SfxItemSet &rAttr)
Definition: tablecontroller.cxx:2578
VclReferenceBase::release
void release() const
o3tl::typed_flags
sdr::table::SvxTableController::GetMarkedSdrObjClone
virtual SVX_DLLPRIVATE SdrObject * GetMarkedSdrObjClone(SdrModel &rTargetModel) override
Definition: tablecontroller.cxx:2777
MouseEvent::GetPosPixel
const Point & GetPosPixel() const
sdr::table::SdrTableObj::setActiveCell
void setActiveCell(const sdr::table::CellPos &rPos)
Definition: svdotable.cxx:1608
rBoxItem
SvxBoxItem & rBoxItem
Definition: tablecontroller.cxx:2983
sdr::table::SvxTableController::SetTableStyleSettings
SVX_DLLPRIVATE void SetTableStyleSettings(const SfxItemSet *pArgs)
Definition: tablecontroller.cxx:1194
SdrPaintView::GetSdrPageView
SdrPageView * GetSdrPageView() const
Definition: svdpntv.hxx:304
sdr::table::TableStyleSettings
TableStyleSettings.
Definition: svdotable.hxx:75
sdr::table::SvxTableController::onSelectionHasChanged
virtual SVX_DLLPRIVATE void onSelectionHasChanged() override
Definition: tablecontroller.cxx:394
SfxItemSet::GetRanges
const sal_uInt16 * GetRanges() const
SvxBoxInfoItem::SetValid
void SetValid(SvxBoxInfoItemValidFlags nValid, bool bValid=true)
sdr::table::SvxTableController::getSelectedCells
void getSelectedCells(CellPos &rFirstPos, CellPos &rLastPos) override
Definition: tablecontroller.cxx:2100
sdr::table::SvxTableController::isColumnSelected
bool isColumnSelected(sal_Int32 nColumn)
Definition: tablecontroller.cxx:3270
sdr::table::SvxTableController::executeAction
SVX_DLLPRIVATE bool executeAction(TblAction nAction, bool bSelect, vcl::Window *pWindow)
Definition: tablecontroller.cxx:1785
OutlinerView::GetAttribs
SfxItemSet GetAttribs()
basegfx::B2DRange::getMinX
double getMinX() const
COL_BLUE
constexpr::Color COL_BLUE(0x00, 0x00, 0x80)
MouseEvent::IsRight
bool IsRight() const
SdrPage
A SdrPage contains exactly one SdrObjList and a description of the physical page dimensions (size / m...
Definition: svdpage.hxx:365
Left
Left
sdr::table::SvxTableController::FillCommonBorderAttrFromSelectedCells
SVX_DLLPRIVATE void FillCommonBorderAttrFromSelectedCells(SvxBoxItem &rBox, SvxBoxInfoItem &rBoxInfo) const
Fill the values that are common for all selected cells.
Definition: tablecontroller.cxx:3135
aDistance
o3tl::enumarray< SvxBoxItemLine, sal_uInt16 > aDistance
Definition: tablecontroller.cxx:2990
sdr::table::ImplApplyBoxItem
static void ImplApplyBoxItem(CellPosFlag nCellPosFlags, const SvxBoxItem *pBoxItem, const SvxBoxInfoItem *pBoxInfoItem, SvxBoxItem &rNewFrame)
Definition: tablecontroller.cxx:2445
sdr::table::SvxTableController::UpdateTableShape
SVX_DLLPRIVATE void UpdateTableShape()
Definition: tablecontroller.cxx:2666
sdr::table::SvxTableController::onTableModified
SVX_DLLPRIVATE void onTableModified()
Definition: tablecontroller.cxx:2288
sdr::table::SvxTableController::updateSelectionOverlay
SVX_DLLPRIVATE void updateSelectionOverlay()
Definition: tablecontroller.cxx:2295
sdr::table::SvxTableController::onSelect
SVX_DLLPRIVATE void onSelect(sal_uInt16 nSId)
Definition: tablecontroller.cxx:859
sdr::table::SvxTableController::GetAttributes
virtual SVX_DLLPRIVATE bool GetAttributes(SfxItemSet &rTargetSet, bool bOnlyHardAttr) const override
Definition: tablecontroller.cxx:2742
sdr::table::SvxTableController::SetAttributes
virtual SVX_DLLPRIVATE bool SetAttributes(const SfxItemSet &rSet, bool bReplaceAll) override
Definition: tablecontroller.cxx:2767
sdr::table::SvxTableController::SetStyleSheet
virtual SVX_DLLPRIVATE bool SetStyleSheet(SfxStyleSheet *pStyleSheet, bool bDontRemoveHardAttr) override
Definition: tablecontroller.cxx:1496
SvxBoxItem::GetBottom
const editeng::SvxBorderLine * GetBottom() const
SvxAbstractDialogFactory::CreateSvxSplitTableDialog
virtual VclPtr< SvxAbstractSplitTableDialog > CreateSvxSplitTableDialog(weld::Window *pParent, bool bIsTableVertical, tools::Long nMaxVertical)=0
SdrPaintView::GetPaintWindow
SdrPaintWindow * GetPaintWindow(sal_uInt32 nIndex) const
Definition: svdpntv.cxx:72
sdr::table::SvxTableController::MergeRange
SVX_DLLPRIVATE void MergeRange(sal_Int32 nFirstCol, sal_Int32 nFirstRow, sal_Int32 nLastCol, sal_Int32 nLastRow)
Definition: tablecontroller.cxx:1942
sdr::table::SvxTableController::onMouseButtonDown
virtual SVX_DLLPRIVATE bool onMouseButtonDown(const MouseEvent &rMEvt, vcl::Window *pWin) override
Definition: tablecontroller.cxx:272
tools::Rectangle::Right
tools::Long Right() const
SdrTextVertAdjust
SdrTextVertAdjust
Definition: sdtaitm.hxx:29
sdr::table::SvxTableController::onMouseButtonUp
virtual SVX_DLLPRIVATE bool onMouseButtonUp(const MouseEvent &rMEvt, vcl::Window *pWin) override
Definition: tablecontroller.cxx:352
sdr::table::SvxTableController::checkTableObject
SVX_DLLPRIVATE bool checkTableObject()
Definition: tablecontroller.cxx:1592
sdr::table::SvxTableController::ApplyFormatPaintBrush
virtual SVX_DLLPRIVATE bool ApplyFormatPaintBrush(SfxItemSet &rFormatSet, bool bNoCharacterFormats, bool bNoParagraphFormats) override
applies a format paint brush set from the current selection.
Definition: tablecontroller.cxx:2895
sdr::table::SvxTableController::SvxTableController
SVX_DLLPRIVATE SvxTableController(SdrView &rView, const SdrTableObj &rObj)
Definition: tablecontroller.cxx:181
sdr::table::SvxTableController::getSelectionStart
SVX_DLLPRIVATE const CellPos & getSelectionStart()
Definition: tablecontroller.cxx:1922
SdrModel::GetPageCount
sal_uInt16 GetPageCount() const
Definition: svdmodel.cxx:1844
SvxColorItem::GetValue
const Color & GetValue() const
sdr::table::SvxTableController::GetState
virtual SVX_DLLPRIVATE void GetState(SfxItemSet &rSet) override
Definition: tablecontroller.cxx:431
sdr::table::SdrTableObj::getCellBounds
void getCellBounds(const sdr::table::CellPos &rPos,::tools::Rectangle &rCellRect)
Definition: svdotable.cxx:1641
vcl::KeyCode::IsMod2
bool IsMod2() const
SvxBoxItem::SetLine
void SetLine(const editeng::SvxBorderLine *pNew, SvxBoxItemLine nLine)
sdr::table::SvxTableController::checkCell
SVX_DLLPRIVATE void checkCell(CellPos &rPos)
Definition: tablecontroller.cxx:1978
Generated on Fri May 7 2021 00:35:32 for LibreOffice Module svx (master) by   doxygen 1.8.10