LibreOffice Module svx (master)  1
framelinkarray.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 <svx/framelinkarray.hxx>
21 
22 #include <math.h>
23 #include <vector>
24 #include <set>
25 #include <algorithm>
26 #include <tools/debug.hxx>
27 #include <tools/gen.hxx>
28 #include <vcl/canvastools.hxx>
31 
32 namespace svx::frame {
33 
34 namespace {
35 
36 class Cell
37 {
38 private:
45 
46 public:
47  long mnAddLeft;
48  long mnAddRight;
49  long mnAddTop;
51 
53  double mfOrientation;
54 
56  bool mbOverlapX;
57  bool mbOverlapY;
58 
59 public:
60  explicit Cell();
61 
62  void SetStyleLeft(const Style& rStyle) { maLeft = rStyle; }
63  void SetStyleRight(const Style& rStyle) { maRight = rStyle; }
64  void SetStyleTop(const Style& rStyle) { maTop = rStyle; }
65  void SetStyleBottom(const Style& rStyle) { maBottom = rStyle; }
66  void SetStyleTLBR(const Style& rStyle) { maTLBR = rStyle; }
67  void SetStyleBLTR(const Style& rStyle) { maBLTR = rStyle; }
68 
69  const Style& GetStyleLeft() const { return maLeft; }
70  const Style& GetStyleRight() const { return maRight; }
71  const Style& GetStyleTop() const { return maTop; }
72  const Style& GetStyleBottom() const { return maBottom; }
73  const Style& GetStyleTLBR() const { return maTLBR; }
74  const Style& GetStyleBLTR() const { return maBLTR; }
75 
76  bool IsMerged() const { return mbMergeOrig || mbOverlapX || mbOverlapY; }
77  bool IsRotated() const { return mfOrientation != 0.0; }
78 
79  void MirrorSelfX();
80 
81  basegfx::B2DHomMatrix CreateCoordinateSystem(const Array& rArray, size_t nCol, size_t nRow, bool bExpandMerged) const;
82 };
83 
84 }
85 
86 typedef std::vector< Cell > CellVec;
87 
88 basegfx::B2DHomMatrix Cell::CreateCoordinateSystem(const Array& rArray, size_t nCol, size_t nRow, bool bExpandMerged) const
89 {
90  basegfx::B2DHomMatrix aRetval;
91  const basegfx::B2DRange aRange(rArray.GetCellRange(nCol, nRow, bExpandMerged));
92 
93  if(!aRange.isEmpty())
94  {
95  basegfx::B2DPoint aOrigin(aRange.getMinimum());
96  basegfx::B2DVector aX(aRange.getWidth(), 0.0);
97  basegfx::B2DVector aY(0.0, aRange.getHeight());
98 
100  {
101  // when rotated, adapt values. Get Skew (cos/sin == 1/tan)
102  const double fSkew(aY.getY() * (cos(mfOrientation) / sin(mfOrientation)));
103 
104  switch (meRotMode)
105  {
107  // shear Y-Axis
108  aY.setX(-fSkew);
109  break;
111  // shear origin half, Y full
112  aOrigin.setX(aOrigin.getX() + (fSkew * 0.5));
113  aY.setX(-fSkew);
114  break;
116  // shear origin full, Y full
117  aOrigin.setX(aOrigin.getX() + fSkew);
118  aY.setX(-fSkew);
119  break;
120  default: // SvxRotateMode::SVX_ROTATE_MODE_STANDARD, already excluded above
121  break;
122  }
123  }
124 
125  // use column vectors as coordinate axes, homogen column for translation
126  aRetval = basegfx::utils::createCoordinateSystemTransform(aOrigin, aX, aY);
127  }
128 
129  return aRetval;
130 }
131 
132 Cell::Cell() :
133  mnAddLeft( 0 ),
134  mnAddRight( 0 ),
135  mnAddTop( 0 ),
136  mnAddBottom( 0 ),
138  mfOrientation( 0.0 ),
139  mbMergeOrig( false ),
140  mbOverlapX( false ),
141  mbOverlapY( false )
142 {
143 }
144 
145 void Cell::MirrorSelfX()
146 {
147  std::swap( maLeft, maRight );
148  std::swap( mnAddLeft, mnAddRight );
149  maLeft.MirrorSelf();
150  maRight.MirrorSelf();
152 }
153 
154 
155 static void lclRecalcCoordVec( std::vector<long>& rCoords, const std::vector<long>& rSizes )
156 {
157  DBG_ASSERT( rCoords.size() == rSizes.size() + 1, "lclRecalcCoordVec - inconsistent vectors" );
158  auto aCIt = rCoords.begin();
159  for( const auto& rSize : rSizes )
160  {
161  *(aCIt + 1) = *aCIt + rSize;
162  ++aCIt;
163  }
164 }
165 
166 static void lclSetMergedRange( CellVec& rCells, size_t nWidth, size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow )
167 {
168  for( size_t nCol = nFirstCol; nCol <= nLastCol; ++nCol )
169  {
170  for( size_t nRow = nFirstRow; nRow <= nLastRow; ++nRow )
171  {
172  Cell& rCell = rCells[ nRow * nWidth + nCol ];
173  rCell.mbMergeOrig = false;
174  rCell.mbOverlapX = nCol > nFirstCol;
175  rCell.mbOverlapY = nRow > nFirstRow;
176  }
177  }
178  rCells[ nFirstRow * nWidth + nFirstCol ].mbMergeOrig = true;
179 }
180 
181 
184 
185 struct ArrayImpl
186 {
187  CellVec maCells;
188  std::vector<long> maWidths;
189  std::vector<long> maHeights;
190  mutable std::vector<long> maXCoords;
191  mutable std::vector<long> maYCoords;
192  size_t mnWidth;
193  size_t mnHeight;
198  mutable bool mbXCoordsDirty;
199  mutable bool mbYCoordsDirty;
201 
202  explicit ArrayImpl( size_t nWidth, size_t nHeight );
203 
204  bool IsValidPos( size_t nCol, size_t nRow ) const
205  { return (nCol < mnWidth) && (nRow < mnHeight); }
206  size_t GetIndex( size_t nCol, size_t nRow ) const
207  { return nRow * mnWidth + nCol; }
208 
209  const Cell& GetCell( size_t nCol, size_t nRow ) const;
210  Cell& GetCellAcc( size_t nCol, size_t nRow );
211 
212  size_t GetMergedFirstCol( size_t nCol, size_t nRow ) const;
213  size_t GetMergedFirstRow( size_t nCol, size_t nRow ) const;
214  size_t GetMergedLastCol( size_t nCol, size_t nRow ) const;
215  size_t GetMergedLastRow( size_t nCol, size_t nRow ) const;
216 
217  const Cell& GetMergedOriginCell( size_t nCol, size_t nRow ) const;
218 
219  bool IsMergedOverlappedLeft( size_t nCol, size_t nRow ) const;
220  bool IsMergedOverlappedRight( size_t nCol, size_t nRow ) const;
221  bool IsMergedOverlappedTop( size_t nCol, size_t nRow ) const;
222  bool IsMergedOverlappedBottom( size_t nCol, size_t nRow ) const;
223 
224  bool IsInClipRange( size_t nCol, size_t nRow ) const;
225  bool IsColInClipRange( size_t nCol ) const;
226  bool IsRowInClipRange( size_t nRow ) const;
227 
228  size_t GetMirrorCol( size_t nCol ) const { return mnWidth - nCol - 1; }
229 
230  long GetColPosition( size_t nCol ) const;
231  long GetRowPosition( size_t nRow ) const;
232 
233  bool HasCellRotation() const;
234 };
235 
236 ArrayImpl::ArrayImpl( size_t nWidth, size_t nHeight ) :
237  mnWidth( nWidth ),
238  mnHeight( nHeight ),
239  mnFirstClipCol( 0 ),
240  mnFirstClipRow( 0 ),
241  mnLastClipCol( nWidth - 1 ),
242  mnLastClipRow( nHeight - 1 ),
243  mbXCoordsDirty( false ),
244  mbYCoordsDirty( false ),
245  mbMayHaveCellRotation( false )
246 {
247  // default-construct all vectors
248  maCells.resize( mnWidth * mnHeight );
249  maWidths.resize( mnWidth, 0 );
250  maHeights.resize( mnHeight, 0 );
251  maXCoords.resize( mnWidth + 1, 0 );
252  maYCoords.resize( mnHeight + 1, 0 );
253 }
254 
255 const Cell& ArrayImpl::GetCell( size_t nCol, size_t nRow ) const
256 {
257  return IsValidPos( nCol, nRow ) ? maCells[ GetIndex( nCol, nRow ) ] : OBJ_CELL_NONE;
258 }
259 
260 Cell& ArrayImpl::GetCellAcc( size_t nCol, size_t nRow )
261 {
262  static Cell aDummy;
263  return IsValidPos( nCol, nRow ) ? maCells[ GetIndex( nCol, nRow ) ] : aDummy;
264 }
265 
266 size_t ArrayImpl::GetMergedFirstCol( size_t nCol, size_t nRow ) const
267 {
268  size_t nFirstCol = nCol;
269  while( (nFirstCol > 0) && GetCell( nFirstCol, nRow ).mbOverlapX ) --nFirstCol;
270  return nFirstCol;
271 }
272 
273 size_t ArrayImpl::GetMergedFirstRow( size_t nCol, size_t nRow ) const
274 {
275  size_t nFirstRow = nRow;
276  while( (nFirstRow > 0) && GetCell( nCol, nFirstRow ).mbOverlapY ) --nFirstRow;
277  return nFirstRow;
278 }
279 
280 size_t ArrayImpl::GetMergedLastCol( size_t nCol, size_t nRow ) const
281 {
282  size_t nLastCol = nCol + 1;
283  while( (nLastCol < mnWidth) && GetCell( nLastCol, nRow ).mbOverlapX ) ++nLastCol;
284  return nLastCol - 1;
285 }
286 
287 size_t ArrayImpl::GetMergedLastRow( size_t nCol, size_t nRow ) const
288 {
289  size_t nLastRow = nRow + 1;
290  while( (nLastRow < mnHeight) && GetCell( nCol, nLastRow ).mbOverlapY ) ++nLastRow;
291  return nLastRow - 1;
292 }
293 
294 const Cell& ArrayImpl::GetMergedOriginCell( size_t nCol, size_t nRow ) const
295 {
296  return GetCell( GetMergedFirstCol( nCol, nRow ), GetMergedFirstRow( nCol, nRow ) );
297 }
298 
299 bool ArrayImpl::IsMergedOverlappedLeft( size_t nCol, size_t nRow ) const
300 {
301  const Cell& rCell = GetCell( nCol, nRow );
302  return rCell.mbOverlapX || (rCell.mnAddLeft > 0);
303 }
304 
305 bool ArrayImpl::IsMergedOverlappedRight( size_t nCol, size_t nRow ) const
306 {
307  return GetCell( nCol + 1, nRow ).mbOverlapX || (GetCell( nCol, nRow ).mnAddRight > 0);
308 }
309 
310 bool ArrayImpl::IsMergedOverlappedTop( size_t nCol, size_t nRow ) const
311 {
312  const Cell& rCell = GetCell( nCol, nRow );
313  return rCell.mbOverlapY || (rCell.mnAddTop > 0);
314 }
315 
316 bool ArrayImpl::IsMergedOverlappedBottom( size_t nCol, size_t nRow ) const
317 {
318  return GetCell( nCol, nRow + 1 ).mbOverlapY || (GetCell( nCol, nRow ).mnAddBottom > 0);
319 }
320 
321 bool ArrayImpl::IsColInClipRange( size_t nCol ) const
322 {
323  return (mnFirstClipCol <= nCol) && (nCol <= mnLastClipCol);
324 }
325 
326 bool ArrayImpl::IsRowInClipRange( size_t nRow ) const
327 {
328  return (mnFirstClipRow <= nRow) && (nRow <= mnLastClipRow);
329 }
330 
331 bool ArrayImpl::IsInClipRange( size_t nCol, size_t nRow ) const
332 {
333  return IsColInClipRange( nCol ) && IsRowInClipRange( nRow );
334 }
335 
336 long ArrayImpl::GetColPosition( size_t nCol ) const
337 {
338  if( mbXCoordsDirty )
339  {
341  mbXCoordsDirty = false;
342  }
343  return maXCoords[ nCol ];
344 }
345 
346 long ArrayImpl::GetRowPosition( size_t nRow ) const
347 {
348  if( mbYCoordsDirty )
349  {
351  mbYCoordsDirty = false;
352  }
353  return maYCoords[ nRow ];
354 }
355 
357 {
358  // check cell array
359  for (const auto& aCell : maCells)
360  {
361  if (aCell.IsRotated())
362  {
363  return true;
364  }
365  }
366 
367  return false;
368 }
369 
370 namespace {
371 
372 class MergedCellIterator
373 {
374 public:
375  explicit MergedCellIterator( const Array& rArray, size_t nCol, size_t nRow );
376 
377  bool Is() const { return (mnCol <= mnLastCol) && (mnRow <= mnLastRow); }
378  size_t Col() const { return mnCol; }
379  size_t Row() const { return mnRow; }
380 
381  MergedCellIterator& operator++();
382 
383 private:
384  size_t mnFirstCol;
385  size_t mnFirstRow;
386  size_t mnLastCol;
387  size_t mnLastRow;
388  size_t mnCol;
389  size_t mnRow;
390 };
391 
392 }
393 
394 MergedCellIterator::MergedCellIterator( const Array& rArray, size_t nCol, size_t nRow )
395 {
396  DBG_ASSERT( rArray.IsMerged( nCol, nRow ), "svx::frame::MergedCellIterator::MergedCellIterator - not in merged range" );
397  rArray.GetMergedRange( mnFirstCol, mnFirstRow, mnLastCol, mnLastRow, nCol, nRow );
398  mnCol = mnFirstCol;
399  mnRow = mnFirstRow;
400 }
401 
402 MergedCellIterator& MergedCellIterator::operator++()
403 {
404  DBG_ASSERT( Is(), "svx::frame::MergedCellIterator::operator++() - already invalid" );
405  if( ++mnCol > mnLastCol )
406  {
407  mnCol = mnFirstCol;
408  ++mnRow;
409  }
410  return *this;
411 }
412 
413 
414 #define DBG_FRAME_CHECK( cond, funcname, error ) DBG_ASSERT( cond, "svx::frame::Array::" funcname " - " error )
415 #define DBG_FRAME_CHECK_COL( col, funcname ) DBG_FRAME_CHECK( (col) < GetColCount(), funcname, "invalid column index" )
416 #define DBG_FRAME_CHECK_ROW( row, funcname ) DBG_FRAME_CHECK( (row) < GetRowCount(), funcname, "invalid row index" )
417 #define DBG_FRAME_CHECK_COLROW( col, row, funcname ) DBG_FRAME_CHECK( ((col) < GetColCount()) && ((row) < GetRowCount()), funcname, "invalid cell index" )
418 #define DBG_FRAME_CHECK_COL_1( col, funcname ) DBG_FRAME_CHECK( (col) <= GetColCount(), funcname, "invalid column index" )
419 #define DBG_FRAME_CHECK_ROW_1( row, funcname ) DBG_FRAME_CHECK( (row) <= GetRowCount(), funcname, "invalid row index" )
420 
421 
422 #define CELL( col, row ) mxImpl->GetCell( col, row )
423 #define CELLACC( col, row ) mxImpl->GetCellAcc( col, row )
424 #define ORIGCELL( col, row ) mxImpl->GetMergedOriginCell( col, row )
425 
426 
428 {
429  Initialize( 0, 0 );
430 }
431 
433 {
434 }
435 
436 // array size and column/row indexes
437 void Array::Initialize( size_t nWidth, size_t nHeight )
438 {
439  mxImpl.reset( new ArrayImpl( nWidth, nHeight ) );
440 }
441 
442 size_t Array::GetColCount() const
443 {
444  return mxImpl->mnWidth;
445 }
446 
447 size_t Array::GetRowCount() const
448 {
449  return mxImpl->mnHeight;
450 }
451 
452 size_t Array::GetCellCount() const
453 {
454  return mxImpl->maCells.size();
455 }
456 
457 size_t Array::GetCellIndex( size_t nCol, size_t nRow, bool bRTL ) const
458 {
459  DBG_FRAME_CHECK_COLROW( nCol, nRow, "GetCellIndex" );
460  if (bRTL)
461  nCol = mxImpl->GetMirrorCol(nCol);
462  return mxImpl->GetIndex( nCol, nRow );
463 }
464 
465 // cell border styles
466 void Array::SetCellStyleLeft( size_t nCol, size_t nRow, const Style& rStyle )
467 {
468  DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleLeft" );
469  CELLACC( nCol, nRow ).SetStyleLeft(rStyle);
470 }
471 
472 void Array::SetCellStyleRight( size_t nCol, size_t nRow, const Style& rStyle )
473 {
474  DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleRight" );
475  CELLACC( nCol, nRow ).SetStyleRight(rStyle);
476 }
477 
478 void Array::SetCellStyleTop( size_t nCol, size_t nRow, const Style& rStyle )
479 {
480  DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleTop" );
481  CELLACC( nCol, nRow ).SetStyleTop(rStyle);
482 }
483 
484 void Array::SetCellStyleBottom( size_t nCol, size_t nRow, const Style& rStyle )
485 {
486  DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleBottom" );
487  CELLACC( nCol, nRow ).SetStyleBottom(rStyle);
488 }
489 
490 void Array::SetCellStyleTLBR( size_t nCol, size_t nRow, const Style& rStyle )
491 {
492  DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleTLBR" );
493  CELLACC( nCol, nRow ).SetStyleTLBR(rStyle);
494 }
495 
496 void Array::SetCellStyleBLTR( size_t nCol, size_t nRow, const Style& rStyle )
497 {
498  DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleBLTR" );
499  CELLACC( nCol, nRow ).SetStyleBLTR(rStyle);
500 }
501 
502 void Array::SetCellStyleDiag( size_t nCol, size_t nRow, const Style& rTLBR, const Style& rBLTR )
503 {
504  DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleDiag" );
505  Cell& rCell = CELLACC( nCol, nRow );
506  rCell.SetStyleTLBR(rTLBR);
507  rCell.SetStyleBLTR(rBLTR);
508 }
509 
510 void Array::SetColumnStyleLeft( size_t nCol, const Style& rStyle )
511 {
512  DBG_FRAME_CHECK_COL( nCol, "SetColumnStyleLeft" );
513  for( size_t nRow = 0; nRow < mxImpl->mnHeight; ++nRow )
514  SetCellStyleLeft( nCol, nRow, rStyle );
515 }
516 
517 void Array::SetColumnStyleRight( size_t nCol, const Style& rStyle )
518 {
519  DBG_FRAME_CHECK_COL( nCol, "SetColumnStyleRight" );
520  for( size_t nRow = 0; nRow < mxImpl->mnHeight; ++nRow )
521  SetCellStyleRight( nCol, nRow, rStyle );
522 }
523 
524 void Array::SetRowStyleTop( size_t nRow, const Style& rStyle )
525 {
526  DBG_FRAME_CHECK_ROW( nRow, "SetRowStyleTop" );
527  for( size_t nCol = 0; nCol < mxImpl->mnWidth; ++nCol )
528  SetCellStyleTop( nCol, nRow, rStyle );
529 }
530 
531 void Array::SetRowStyleBottom( size_t nRow, const Style& rStyle )
532 {
533  DBG_FRAME_CHECK_ROW( nRow, "SetRowStyleBottom" );
534  for( size_t nCol = 0; nCol < mxImpl->mnWidth; ++nCol )
535  SetCellStyleBottom( nCol, nRow, rStyle );
536 }
537 
538 void Array::SetCellRotation(size_t nCol, size_t nRow, SvxRotateMode eRotMode, double fOrientation)
539 {
540  DBG_FRAME_CHECK_COLROW(nCol, nRow, "SetCellRotation");
541  Cell& rTarget = CELLACC(nCol, nRow);
542  rTarget.meRotMode = eRotMode;
543  rTarget.mfOrientation = fOrientation;
544 
545  if (!mxImpl->mbMayHaveCellRotation)
546  {
547  // activate once when a cell gets actually rotated to allow fast
548  // answering HasCellRotation() calls
549  mxImpl->mbMayHaveCellRotation = rTarget.IsRotated();
550  }
551 }
552 
554 {
555  if (!mxImpl->mbMayHaveCellRotation)
556  {
557  // never set, no need to check
558  return false;
559  }
560 
561  return mxImpl->HasCellRotation();
562 }
563 
564 const Style& Array::GetCellStyleLeft( size_t nCol, size_t nRow ) const
565 {
566  // outside clipping rows or overlapped in merged cells: invisible
567  if( !mxImpl->IsRowInClipRange( nRow ) || mxImpl->IsMergedOverlappedLeft( nCol, nRow ) )
568  return OBJ_STYLE_NONE;
569  // left clipping border: always own left style
570  if( nCol == mxImpl->mnFirstClipCol )
571  return ORIGCELL( nCol, nRow ).GetStyleLeft();
572  // right clipping border: always right style of left neighbor cell
573  if( nCol == mxImpl->mnLastClipCol + 1 )
574  return ORIGCELL( nCol - 1, nRow ).GetStyleRight();
575  // outside clipping columns: invisible
576  if( !mxImpl->IsColInClipRange( nCol ) )
577  return OBJ_STYLE_NONE;
578  // inside clipping range: maximum of own left style and right style of left neighbor cell
579  return std::max( ORIGCELL( nCol, nRow ).GetStyleLeft(), ORIGCELL( nCol - 1, nRow ).GetStyleRight() );
580 }
581 
582 const Style& Array::GetCellStyleRight( size_t nCol, size_t nRow ) const
583 {
584  // outside clipping rows or overlapped in merged cells: invisible
585  if( !mxImpl->IsRowInClipRange( nRow ) || mxImpl->IsMergedOverlappedRight( nCol, nRow ) )
586  return OBJ_STYLE_NONE;
587  // left clipping border: always left style of right neighbor cell
588  if( nCol + 1 == mxImpl->mnFirstClipCol )
589  return ORIGCELL( nCol + 1, nRow ).GetStyleLeft();
590  // right clipping border: always own right style
591  if( nCol == mxImpl->mnLastClipCol )
592  return ORIGCELL( nCol, nRow ).GetStyleRight();
593  // outside clipping columns: invisible
594  if( !mxImpl->IsColInClipRange( nCol ) )
595  return OBJ_STYLE_NONE;
596  // inside clipping range: maximum of own right style and left style of right neighbor cell
597  return std::max( ORIGCELL( nCol, nRow ).GetStyleRight(), ORIGCELL( nCol + 1, nRow ).GetStyleLeft() );
598 }
599 
600 const Style& Array::GetCellStyleTop( size_t nCol, size_t nRow ) const
601 {
602  // outside clipping columns or overlapped in merged cells: invisible
603  if( !mxImpl->IsColInClipRange( nCol ) || mxImpl->IsMergedOverlappedTop( nCol, nRow ) )
604  return OBJ_STYLE_NONE;
605  // top clipping border: always own top style
606  if( nRow == mxImpl->mnFirstClipRow )
607  return ORIGCELL( nCol, nRow ).GetStyleTop();
608  // bottom clipping border: always bottom style of top neighbor cell
609  if( nRow == mxImpl->mnLastClipRow + 1 )
610  return ORIGCELL( nCol, nRow - 1 ).GetStyleBottom();
611  // outside clipping rows: invisible
612  if( !mxImpl->IsRowInClipRange( nRow ) )
613  return OBJ_STYLE_NONE;
614  // inside clipping range: maximum of own top style and bottom style of top neighbor cell
615  return std::max( ORIGCELL( nCol, nRow ).GetStyleTop(), ORIGCELL( nCol, nRow - 1 ).GetStyleBottom() );
616 }
617 
618 const Style& Array::GetCellStyleBottom( size_t nCol, size_t nRow ) const
619 {
620  // outside clipping columns or overlapped in merged cells: invisible
621  if( !mxImpl->IsColInClipRange( nCol ) || mxImpl->IsMergedOverlappedBottom( nCol, nRow ) )
622  return OBJ_STYLE_NONE;
623  // top clipping border: always top style of bottom neighbor cell
624  if( nRow + 1 == mxImpl->mnFirstClipRow )
625  return ORIGCELL( nCol, nRow + 1 ).GetStyleTop();
626  // bottom clipping border: always own bottom style
627  if( nRow == mxImpl->mnLastClipRow )
628  return ORIGCELL( nCol, nRow ).GetStyleBottom();
629  // outside clipping rows: invisible
630  if( !mxImpl->IsRowInClipRange( nRow ) )
631  return OBJ_STYLE_NONE;
632  // inside clipping range: maximum of own bottom style and top style of bottom neighbor cell
633  return std::max( ORIGCELL( nCol, nRow ).GetStyleBottom(), ORIGCELL( nCol, nRow + 1 ).GetStyleTop() );
634 }
635 
636 const Style& Array::GetCellStyleTLBR( size_t nCol, size_t nRow ) const
637 {
638  return CELL( nCol, nRow ).GetStyleTLBR();
639 }
640 
641 const Style& Array::GetCellStyleBLTR( size_t nCol, size_t nRow ) const
642 {
643  return CELL( nCol, nRow ).GetStyleBLTR();
644 }
645 
646 const Style& Array::GetCellStyleTL( size_t nCol, size_t nRow ) const
647 {
648  // not in clipping range: always invisible
649  if( !mxImpl->IsInClipRange( nCol, nRow ) )
650  return OBJ_STYLE_NONE;
651  // return style only for top-left cell
652  size_t nFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow );
653  size_t nFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow );
654  return ((nCol == nFirstCol) && (nRow == nFirstRow)) ?
655  CELL( nFirstCol, nFirstRow ).GetStyleTLBR() : OBJ_STYLE_NONE;
656 }
657 
658 const Style& Array::GetCellStyleBR( size_t nCol, size_t nRow ) const
659 {
660  // not in clipping range: always invisible
661  if( !mxImpl->IsInClipRange( nCol, nRow ) )
662  return OBJ_STYLE_NONE;
663  // return style only for bottom-right cell
664  size_t nLastCol = mxImpl->GetMergedLastCol( nCol, nRow );
665  size_t nLastRow = mxImpl->GetMergedLastRow( nCol, nRow );
666  return ((nCol == nLastCol) && (nRow == nLastRow)) ?
667  CELL( mxImpl->GetMergedFirstCol( nCol, nRow ), mxImpl->GetMergedFirstRow( nCol, nRow ) ).GetStyleTLBR() : OBJ_STYLE_NONE;
668 }
669 
670 const Style& Array::GetCellStyleBL( size_t nCol, size_t nRow ) const
671 {
672  // not in clipping range: always invisible
673  if( !mxImpl->IsInClipRange( nCol, nRow ) )
674  return OBJ_STYLE_NONE;
675  // return style only for bottom-left cell
676  size_t nFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow );
677  size_t nLastRow = mxImpl->GetMergedLastRow( nCol, nRow );
678  return ((nCol == nFirstCol) && (nRow == nLastRow)) ?
679  CELL( nFirstCol, mxImpl->GetMergedFirstRow( nCol, nRow ) ).GetStyleBLTR() : OBJ_STYLE_NONE;
680 }
681 
682 const Style& Array::GetCellStyleTR( size_t nCol, size_t nRow ) const
683 {
684  // not in clipping range: always invisible
685  if( !mxImpl->IsInClipRange( nCol, nRow ) )
686  return OBJ_STYLE_NONE;
687  // return style only for top-right cell
688  size_t nFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow );
689  size_t nLastCol = mxImpl->GetMergedLastCol( nCol, nRow );
690  return ((nCol == nLastCol) && (nRow == nFirstRow)) ?
691  CELL( mxImpl->GetMergedFirstCol( nCol, nRow ), nFirstRow ).GetStyleBLTR() : OBJ_STYLE_NONE;
692 }
693 
694 // cell merging
695 void Array::SetMergedRange( size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow )
696 {
697  DBG_FRAME_CHECK_COLROW( nFirstCol, nFirstRow, "SetMergedRange" );
698  DBG_FRAME_CHECK_COLROW( nLastCol, nLastRow, "SetMergedRange" );
699 #if OSL_DEBUG_LEVEL >= 2
700  {
701  bool bFound = false;
702  for( size_t nCurrCol = nFirstCol; !bFound && (nCurrCol <= nLastCol); ++nCurrCol )
703  for( size_t nCurrRow = nFirstRow; !bFound && (nCurrRow <= nLastRow); ++nCurrRow )
704  bFound = CELL( nCurrCol, nCurrRow ).IsMerged();
705  DBG_FRAME_CHECK( !bFound, "SetMergedRange", "overlapping merged ranges" );
706  }
707 #endif
708  if( mxImpl->IsValidPos( nFirstCol, nFirstRow ) && mxImpl->IsValidPos( nLastCol, nLastRow ) )
709  lclSetMergedRange( mxImpl->maCells, mxImpl->mnWidth, nFirstCol, nFirstRow, nLastCol, nLastRow );
710 }
711 
712 void Array::SetAddMergedLeftSize( size_t nCol, size_t nRow, long nAddSize )
713 {
714  DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedLeftSize" );
715  DBG_FRAME_CHECK( mxImpl->GetMergedFirstCol( nCol, nRow ) == 0, "SetAddMergedLeftSize", "additional border inside array" );
716  for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt )
717  CELLACC( aIt.Col(), aIt.Row() ).mnAddLeft = nAddSize;
718 }
719 
720 void Array::SetAddMergedRightSize( size_t nCol, size_t nRow, long nAddSize )
721 {
722  DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedRightSize" );
723  DBG_FRAME_CHECK( mxImpl->GetMergedLastCol( nCol, nRow ) + 1 == mxImpl->mnWidth, "SetAddMergedRightSize", "additional border inside array" );
724  for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt )
725  CELLACC( aIt.Col(), aIt.Row() ).mnAddRight = nAddSize;
726 }
727 
728 void Array::SetAddMergedTopSize( size_t nCol, size_t nRow, long nAddSize )
729 {
730  DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedTopSize" );
731  DBG_FRAME_CHECK( mxImpl->GetMergedFirstRow( nCol, nRow ) == 0, "SetAddMergedTopSize", "additional border inside array" );
732  for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt )
733  CELLACC( aIt.Col(), aIt.Row() ).mnAddTop = nAddSize;
734 }
735 
736 void Array::SetAddMergedBottomSize( size_t nCol, size_t nRow, long nAddSize )
737 {
738  DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedBottomSize" );
739  DBG_FRAME_CHECK( mxImpl->GetMergedLastRow( nCol, nRow ) + 1 == mxImpl->mnHeight, "SetAddMergedBottomSize", "additional border inside array" );
740  for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt )
741  CELLACC( aIt.Col(), aIt.Row() ).mnAddBottom = nAddSize;
742 }
743 
744 bool Array::IsMerged( size_t nCol, size_t nRow ) const
745 {
746  DBG_FRAME_CHECK_COLROW( nCol, nRow, "IsMerged" );
747  return CELL( nCol, nRow ).IsMerged();
748 }
749 
750 void Array::GetMergedOrigin( size_t& rnFirstCol, size_t& rnFirstRow, size_t nCol, size_t nRow ) const
751 {
752  DBG_FRAME_CHECK_COLROW( nCol, nRow, "GetMergedOrigin" );
753  rnFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow );
754  rnFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow );
755 }
756 
757 void Array::GetMergedRange( size_t& rnFirstCol, size_t& rnFirstRow,
758  size_t& rnLastCol, size_t& rnLastRow, size_t nCol, size_t nRow ) const
759 {
760  GetMergedOrigin( rnFirstCol, rnFirstRow, nCol, nRow );
761  rnLastCol = mxImpl->GetMergedLastCol( nCol, nRow );
762  rnLastRow = mxImpl->GetMergedLastRow( nCol, nRow );
763 }
764 
765 // clipping
766 void Array::SetClipRange( size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow )
767 {
768  DBG_FRAME_CHECK_COLROW( nFirstCol, nFirstRow, "SetClipRange" );
769  DBG_FRAME_CHECK_COLROW( nLastCol, nLastRow, "SetClipRange" );
770  mxImpl->mnFirstClipCol = nFirstCol;
771  mxImpl->mnFirstClipRow = nFirstRow;
772  mxImpl->mnLastClipCol = nLastCol;
773  mxImpl->mnLastClipRow = nLastRow;
774 }
775 
776 // cell coordinates
777 void Array::SetXOffset( long nXOffset )
778 {
779  mxImpl->maXCoords[ 0 ] = nXOffset;
780  mxImpl->mbXCoordsDirty = true;
781 }
782 
783 void Array::SetYOffset( long nYOffset )
784 {
785  mxImpl->maYCoords[ 0 ] = nYOffset;
786  mxImpl->mbYCoordsDirty = true;
787 }
788 
789 void Array::SetColWidth( size_t nCol, long nWidth )
790 {
791  DBG_FRAME_CHECK_COL( nCol, "SetColWidth" );
792  mxImpl->maWidths[ nCol ] = nWidth;
793  mxImpl->mbXCoordsDirty = true;
794 }
795 
796 void Array::SetRowHeight( size_t nRow, long nHeight )
797 {
798  DBG_FRAME_CHECK_ROW( nRow, "SetRowHeight" );
799  mxImpl->maHeights[ nRow ] = nHeight;
800  mxImpl->mbYCoordsDirty = true;
801 }
802 
803 void Array::SetAllColWidths( long nWidth )
804 {
805  std::fill( mxImpl->maWidths.begin(), mxImpl->maWidths.end(), nWidth );
806  mxImpl->mbXCoordsDirty = true;
807 }
808 
809 void Array::SetAllRowHeights( long nHeight )
810 {
811  std::fill( mxImpl->maHeights.begin(), mxImpl->maHeights.end(), nHeight );
812  mxImpl->mbYCoordsDirty = true;
813 }
814 
815 long Array::GetColPosition( size_t nCol ) const
816 {
817  DBG_FRAME_CHECK_COL_1( nCol, "GetColPosition" );
818  return mxImpl->GetColPosition( nCol );
819 }
820 
821 long Array::GetRowPosition( size_t nRow ) const
822 {
823  DBG_FRAME_CHECK_ROW_1( nRow, "GetRowPosition" );
824  return mxImpl->GetRowPosition( nRow );
825 }
826 
827 long Array::GetColWidth( size_t nFirstCol, size_t nLastCol ) const
828 {
829  DBG_FRAME_CHECK_COL( nFirstCol, "GetColWidth" );
830  DBG_FRAME_CHECK_COL( nLastCol, "GetColWidth" );
831  return GetColPosition( nLastCol + 1 ) - GetColPosition( nFirstCol );
832 }
833 
834 long Array::GetRowHeight( size_t nFirstRow, size_t nLastRow ) const
835 {
836  DBG_FRAME_CHECK_ROW( nFirstRow, "GetRowHeight" );
837  DBG_FRAME_CHECK_ROW( nLastRow, "GetRowHeight" );
838  return GetRowPosition( nLastRow + 1 ) - GetRowPosition( nFirstRow );
839 }
840 
841 long Array::GetWidth() const
842 {
843  return GetColPosition( mxImpl->mnWidth ) - GetColPosition( 0 );
844 }
845 
846 long Array::GetHeight() const
847 {
848  return GetRowPosition( mxImpl->mnHeight ) - GetRowPosition( 0 );
849 }
850 
851 basegfx::B2DRange Array::GetCellRange( size_t nCol, size_t nRow, bool bExpandMerged ) const
852 {
853  if(bExpandMerged)
854  {
855  // get the Range of the fully expanded cell (if merged)
856  const size_t nFirstCol(mxImpl->GetMergedFirstCol( nCol, nRow ));
857  const size_t nFirstRow(mxImpl->GetMergedFirstRow( nCol, nRow ));
858  const size_t nLastCol(mxImpl->GetMergedLastCol( nCol, nRow ));
859  const size_t nLastRow(mxImpl->GetMergedLastRow( nCol, nRow ));
860  const Point aPoint( GetColPosition( nFirstCol ), GetRowPosition( nFirstRow ) );
861  const Size aSize( GetColWidth( nFirstCol, nLastCol ) + 1, GetRowHeight( nFirstRow, nLastRow ) + 1 );
862  tools::Rectangle aRect(aPoint, aSize);
863 
864  // adjust rectangle for partly visible merged cells
865  const Cell& rCell = CELL( nCol, nRow );
866 
867  if( rCell.IsMerged() )
868  {
869  // not *sure* what exactly this is good for,
870  // it is just a hard set extension at merged cells,
871  // probably *should* be included in the above extended
872  // GetColPosition/GetColWidth already. This might be
873  // added due to GetColPosition/GetColWidth not working
874  // correctly over PageChanges (if used), but not sure.
875  aRect.AdjustLeft( -(rCell.mnAddLeft) );
876  aRect.AdjustRight(rCell.mnAddRight );
877  aRect.AdjustTop( -(rCell.mnAddTop) );
878  aRect.AdjustBottom(rCell.mnAddBottom );
879  }
880 
882  }
883  else
884  {
885  const Point aPoint( GetColPosition( nCol ), GetRowPosition( nRow ) );
886  const Size aSize( GetColWidth( nCol, nCol ) + 1, GetRowHeight( nRow, nRow ) + 1 );
887  const tools::Rectangle aRect(aPoint, aSize);
888 
890  }
891 }
892 
893 // mirroring
895 {
896  CellVec aNewCells;
897  aNewCells.reserve( GetCellCount() );
898 
899  size_t nCol, nRow;
900  for( nRow = 0; nRow < mxImpl->mnHeight; ++nRow )
901  {
902  for( nCol = 0; nCol < mxImpl->mnWidth; ++nCol )
903  {
904  aNewCells.push_back( CELL( mxImpl->GetMirrorCol( nCol ), nRow ) );
905  aNewCells.back().MirrorSelfX();
906  }
907  }
908  for( nRow = 0; nRow < mxImpl->mnHeight; ++nRow )
909  {
910  for( nCol = 0; nCol < mxImpl->mnWidth; ++nCol )
911  {
912  if( CELL( nCol, nRow ).mbMergeOrig )
913  {
914  size_t nLastCol = mxImpl->GetMergedLastCol( nCol, nRow );
915  size_t nLastRow = mxImpl->GetMergedLastRow( nCol, nRow );
916  lclSetMergedRange( aNewCells, mxImpl->mnWidth,
917  mxImpl->GetMirrorCol( nLastCol ), nRow,
918  mxImpl->GetMirrorCol( nCol ), nLastRow );
919  }
920  }
921  }
922  mxImpl->maCells.swap( aNewCells );
923 
924  std::reverse( mxImpl->maWidths.begin(), mxImpl->maWidths.end() );
925  mxImpl->mbXCoordsDirty = true;
926 }
927 
928 // drawing
930  const Array& rArray,
931  const Style& rStyle,
932  size_t col,
933  size_t row,
934  const basegfx::B2DPoint& rOrigin,
935  const basegfx::B2DVector& rX,
936  const basegfx::B2DVector& rY,
938  bool bUpper,
939  const Color* pForceColor)
940 {
941  // prepare SdrFrameBorderData
942  rData.emplace_back(
943  bUpper ? rOrigin : basegfx::B2DPoint(rOrigin + rY),
944  rX,
945  rStyle,
946  pForceColor);
947  drawinglayer::primitive2d::SdrFrameBorderData& rInstance(rData.back());
948 
949  // get involved styles at start
950  const Style& rStartFromTR(rArray.GetCellStyleBL( col, row - 1 ));
951  const Style& rStartLFromT(rArray.GetCellStyleLeft( col, row - 1 ));
952  const Style& rStartLFromL(rArray.GetCellStyleTop( col - 1, row ));
953  const Style& rStartLFromB(rArray.GetCellStyleLeft( col, row ));
954  const Style& rStartFromBR(rArray.GetCellStyleTL( col, row ));
955 
956  rInstance.addSdrConnectStyleData(true, rStartFromTR, rX - rY, false);
957  rInstance.addSdrConnectStyleData(true, rStartLFromT, -rY, true);
958  rInstance.addSdrConnectStyleData(true, rStartLFromL, -rX, true);
959  rInstance.addSdrConnectStyleData(true, rStartLFromB, rY, false);
960  rInstance.addSdrConnectStyleData(true, rStartFromBR, rX + rY, false);
961 
962  // get involved styles at end
963  const Style& rEndFromTL(rArray.GetCellStyleBR( col, row - 1 ));
964  const Style& rEndRFromT(rArray.GetCellStyleRight( col, row - 1 ));
965  const Style& rEndRFromR(rArray.GetCellStyleTop( col + 1, row ));
966  const Style& rEndRFromB(rArray.GetCellStyleRight( col, row ));
967  const Style& rEndFromBL(rArray.GetCellStyleTR( col, row ));
968 
969  rInstance.addSdrConnectStyleData(false, rEndFromTL, -rX - rY, true);
970  rInstance.addSdrConnectStyleData(false, rEndRFromT, -rY, true);
971  rInstance.addSdrConnectStyleData(false, rEndRFromR, rX, false);
972  rInstance.addSdrConnectStyleData(false, rEndRFromB, rY, false);
973  rInstance.addSdrConnectStyleData(false, rEndFromBL, rY - rX, true);
974 }
975 
977  const Array& rArray,
978  const Style& rStyle,
979  size_t col,
980  size_t row,
981  const basegfx::B2DPoint& rOrigin,
982  const basegfx::B2DVector& rX,
983  const basegfx::B2DVector& rY,
985  bool bLeft,
986  const Color* pForceColor)
987 {
988  // prepare SdrFrameBorderData
989  rData.emplace_back(
990  bLeft ? rOrigin : basegfx::B2DPoint(rOrigin + rX),
991  rY,
992  rStyle,
993  pForceColor);
994  drawinglayer::primitive2d::SdrFrameBorderData& rInstance(rData.back());
995 
996  // get involved styles at start
997  const Style& rStartFromBL(rArray.GetCellStyleTR( col - 1, row ));
998  const Style& rStartTFromL(rArray.GetCellStyleTop( col - 1, row ));
999  const Style& rStartTFromT(rArray.GetCellStyleLeft( col, row - 1 ));
1000  const Style& rStartTFromR(rArray.GetCellStyleTop( col, row ));
1001  const Style& rStartFromBR(rArray.GetCellStyleTL( col, row ));
1002 
1003  rInstance.addSdrConnectStyleData(true, rStartFromBR, rX + rY, false);
1004  rInstance.addSdrConnectStyleData(true, rStartTFromR, rX, false);
1005  rInstance.addSdrConnectStyleData(true, rStartTFromT, -rY, true);
1006  rInstance.addSdrConnectStyleData(true, rStartTFromL, -rX, true);
1007  rInstance.addSdrConnectStyleData(true, rStartFromBL, rY - rX, true);
1008 
1009  // get involved styles at end
1010  const Style& rEndFromTL(rArray.GetCellStyleBR( col - 1, row ));
1011  const Style& rEndBFromL(rArray.GetCellStyleBottom( col - 1, row ));
1012  const Style& rEndBFromB(rArray.GetCellStyleLeft( col, row + 1 ));
1013  const Style& rEndBFromR(rArray.GetCellStyleBottom( col, row ));
1014  const Style& rEndFromTR(rArray.GetCellStyleBL( col, row ));
1015 
1016  rInstance.addSdrConnectStyleData(false, rEndFromTR, rX - rY, false);
1017  rInstance.addSdrConnectStyleData(false, rEndBFromR, rX, false);
1018  rInstance.addSdrConnectStyleData(false, rEndBFromB, rY, false);
1019  rInstance.addSdrConnectStyleData(false, rEndBFromL, -rX, true);
1020  rInstance.addSdrConnectStyleData(false, rEndFromTL, -rY - rX, true);
1021 }
1022 
1024  size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow,
1025  const Color* pForceColor ) const
1026 {
1027  DBG_FRAME_CHECK_COLROW( nFirstCol, nFirstRow, "CreateB2DPrimitiveRange" );
1028  DBG_FRAME_CHECK_COLROW( nLastCol, nLastRow, "CreateB2DPrimitiveRange" );
1029 
1030  // It may be necessary to extend the loop ranges by one cell to the outside,
1031  // when possible. This is needed e.g. when there is in Calc a Cell with an
1032  // upper CellBorder using DoubleLine and that is right/left connected upwards
1033  // to also DoubleLine. These upper DoubleLines will be extended to meet the
1034  // lower of the upper CellBorder and thus have graphical parts that are
1035  // displayed one cell below and right/left of the target cell - analog to
1036  // other examples in all other directions.
1037  // It would be possible to explicitly test this (if possible by indices at all)
1038  // looping and testing the styles in the outer cells to detect this, but since
1039  // for other usages (e.g. UI) usually nFirstRow==0 and nLastRow==GetRowCount()-1
1040  // (and analog for Col) it is okay to just expand the range when available.
1041  // Do *not* change nFirstRow/nLastRow due to these needed to the boolean tests
1042  // below (!)
1043  // Checked usages, this method is used in Calc EditView/Print/Export stuff and
1044  // in UI (Dialog), not for Writer Tables and Draw/Impress tables. All usages
1045  // seem okay with this change, so I will add it.
1046  const size_t nStartRow(nFirstRow > 0 ? nFirstRow - 1 : nFirstRow);
1047  const size_t nEndRow(nLastRow < GetRowCount() - 1 ? nLastRow + 1 : nLastRow);
1048  const size_t nStartCol(nFirstCol > 0 ? nFirstCol - 1 : nFirstCol);
1049  const size_t nEndCol(nLastCol < GetColCount() - 1 ? nLastCol + 1 : nLastCol);
1050 
1051  // prepare SdrFrameBorderDataVector
1052  std::shared_ptr<drawinglayer::primitive2d::SdrFrameBorderDataVector> aData(
1053  std::make_shared<drawinglayer::primitive2d::SdrFrameBorderDataVector>());
1054 
1055  // remember for which merged cells crossed lines were already created. To
1056  // do so, hold the size_t cell index in a set for fast check
1057  std::set< size_t > aMergedCells;
1058 
1059  for (size_t nRow(nStartRow); nRow <= nEndRow; ++nRow)
1060  {
1061  for (size_t nCol(nStartCol); nCol <= nEndCol; ++nCol)
1062  {
1063  // get Cell and CoordinateSystem (*only* for this Cell, do *not* expand for
1064  // merged cells (!)), check if used (non-empty vectors)
1065  const Cell& rCell(CELL(nCol, nRow));
1066  basegfx::B2DHomMatrix aCoordinateSystem(rCell.CreateCoordinateSystem(*this, nCol, nRow, false));
1067  basegfx::B2DVector aX(basegfx::utils::getColumn(aCoordinateSystem, 0));
1068  basegfx::B2DVector aY(basegfx::utils::getColumn(aCoordinateSystem, 1));
1069 
1070  // get needed local values
1071  basegfx::B2DPoint aOrigin(basegfx::utils::getColumn(aCoordinateSystem, 2));
1072  const bool bOverlapX(rCell.mbOverlapX);
1073  const bool bFirstCol(nCol == nFirstCol);
1074 
1075  // handle rotation: If cell is rotated, handle lower/right edge inside
1076  // this local geometry due to the created CoordinateSystem already representing
1077  // the needed transformations.
1078  const bool bRotated(rCell.IsRotated());
1079 
1080  // Additionally avoid double-handling by suppressing handling when self not rotated,
1081  // but above/left is rotated and thus already handled. Two directly connected
1082  // rotated will paint/create both edges, they might be rotated differently.
1083  const bool bSupressLeft(!bRotated && nCol > nFirstCol && CELL(nCol - 1, nRow).IsRotated());
1084  const bool bSuppressAbove(!bRotated && nRow > nFirstRow && CELL(nCol, nRow - 1).IsRotated());
1085 
1086  if(!aX.equalZero() && !aY.equalZero())
1087  {
1088  // additionally needed local values
1089  const bool bOverlapY(rCell.mbOverlapY);
1090  const bool bLastCol(nCol == nLastCol);
1091  const bool bFirstRow(nRow == nFirstRow);
1092  const bool bLastRow(nRow == nLastRow);
1093 
1094  // create upper line for this Cell
1095  if ((!bOverlapY // true for first line in merged cells or cells
1096  || bFirstRow) // true for non_Calc usages of this tooling
1097  && !bSuppressAbove) // true when above is not rotated, so edge is already handled (see bRotated)
1098  {
1099  // get CellStyle - method will take care to get the correct one, e.g.
1100  // for merged cells (it uses ORIGCELL that works with topLeft's of these)
1101  const Style& rTop(GetCellStyleTop(nCol, nRow));
1102 
1103  if(rTop.IsUsed())
1104  {
1105  HelperCreateHorizontalEntry(*this, rTop, nCol, nRow, aOrigin, aX, aY, *aData, true, pForceColor);
1106  }
1107  }
1108 
1109  // create lower line for this Cell
1110  if (bLastRow // true for non_Calc usages of this tooling
1111  || bRotated) // true if cell is rotated, handle lower edge in local geometry
1112  {
1113  const Style& rBottom(GetCellStyleBottom(nCol, nRow));
1114 
1115  if(rBottom.IsUsed())
1116  {
1117  HelperCreateHorizontalEntry(*this, rBottom, nCol, nRow + 1, aOrigin, aX, aY, *aData, false, pForceColor);
1118  }
1119  }
1120 
1121  // create left line for this Cell
1122  if ((!bOverlapX // true for first column in merged cells or cells
1123  || bFirstCol) // true for non_Calc usages of this tooling
1124  && !bSupressLeft) // true when left is not rotated, so edge is already handled (see bRotated)
1125  {
1126  const Style& rLeft(GetCellStyleLeft(nCol, nRow));
1127 
1128  if(rLeft.IsUsed())
1129  {
1130  HelperCreateVerticalEntry(*this, rLeft, nCol, nRow, aOrigin, aX, aY, *aData, true, pForceColor);
1131  }
1132  }
1133 
1134  // create right line for this Cell
1135  if (bLastCol // true for non_Calc usages of this tooling
1136  || bRotated) // true if cell is rotated, handle right edge in local geometry
1137  {
1138  const Style& rRight(GetCellStyleRight(nCol, nRow));
1139 
1140  if(rRight.IsUsed())
1141  {
1142  HelperCreateVerticalEntry(*this, rRight, nCol + 1, nRow, aOrigin, aX, aY, *aData, false, pForceColor);
1143  }
1144  }
1145 
1146  // check for crossed lines, these need special treatment, especially
1147  // for merged cells, see below
1148  const Style& rTLBR(GetCellStyleTLBR(nCol, nRow));
1149  const Style& rBLTR(GetCellStyleBLTR(nCol, nRow));
1150 
1151  if(rTLBR.IsUsed() || rBLTR.IsUsed())
1152  {
1153  bool bContinue(true);
1154 
1155  if(rCell.IsMerged())
1156  {
1157  // first check if this merged cell was already handled. To do so,
1158  // calculate and use the index of the TopLeft cell
1159  const size_t _nMergedFirstCol(mxImpl->GetMergedFirstCol(nCol, nRow));
1160  const size_t _nMergedFirstRow(mxImpl->GetMergedFirstRow(nCol, nRow));
1161  const size_t nIndexOfMergedCell(mxImpl->GetIndex(_nMergedFirstCol, _nMergedFirstRow));
1162  bContinue = (aMergedCells.end() == aMergedCells.find(nIndexOfMergedCell));
1163 
1164  if(bContinue)
1165  {
1166  // not found, add now to mark as handled
1167  aMergedCells.insert(nIndexOfMergedCell);
1168 
1169  // when merged, get extended coordinate system and derived values
1170  // for the full range of this merged cell
1171  aCoordinateSystem = rCell.CreateCoordinateSystem(*this, nCol, nRow, true);
1172  aX = basegfx::utils::getColumn(aCoordinateSystem, 0);
1173  aY = basegfx::utils::getColumn(aCoordinateSystem, 1);
1174  aOrigin = basegfx::utils::getColumn(aCoordinateSystem, 2);
1175  }
1176  }
1177 
1178  if(bContinue)
1179  {
1180  if(rTLBR.IsUsed())
1181  {
1183  aData->emplace_back(
1184  aOrigin,
1185  aX + aY,
1186  rTLBR,
1187  pForceColor);
1188  drawinglayer::primitive2d::SdrFrameBorderData& rInstance(aData->back());
1189 
1191  const Style& rTLFromRight(GetCellStyleTop(nCol, nRow));
1192  const Style& rTLFromBottom(GetCellStyleLeft(nCol, nRow));
1193 
1194  rInstance.addSdrConnectStyleData(true, rTLFromRight, aX, false);
1195  rInstance.addSdrConnectStyleData(true, rTLFromBottom, aY, false);
1196 
1198  const Style& rBRFromBottom(GetCellStyleRight(nCol, nRow));
1199  const Style& rBRFromLeft(GetCellStyleBottom(nCol, nRow));
1200 
1201  rInstance.addSdrConnectStyleData(false, rBRFromBottom, -aY, true);
1202  rInstance.addSdrConnectStyleData(false, rBRFromLeft, -aX, true);
1203  }
1204 
1205  if(rBLTR.IsUsed())
1206  {
1208  aData->emplace_back(
1209  aOrigin + aY,
1210  aX - aY,
1211  rBLTR,
1212  pForceColor);
1213  drawinglayer::primitive2d::SdrFrameBorderData& rInstance(aData->back());
1214 
1216  const Style& rBLFromTop(GetCellStyleLeft(nCol, nRow));
1217  const Style& rBLFromBottom(GetCellStyleBottom(nCol, nRow));
1218 
1219  rInstance.addSdrConnectStyleData(true, rBLFromTop, -aY, true);
1220  rInstance.addSdrConnectStyleData(true, rBLFromBottom, aX, false);
1221 
1223  const Style& rTRFromLeft(GetCellStyleTop(nCol, nRow));
1224  const Style& rTRFromBottom(GetCellStyleRight(nCol, nRow));
1225 
1226  rInstance.addSdrConnectStyleData(false, rTRFromLeft, -aX, true);
1227  rInstance.addSdrConnectStyleData(false, rTRFromBottom, aY, false);
1228  }
1229  }
1230  }
1231  }
1232  else
1233  {
1234  // create left line for this Cell
1235  if ((!bOverlapX // true for first column in merged cells or cells
1236  || bFirstCol) // true for non_Calc usages of this tooling
1237  && !bSupressLeft) // true when left is not rotated, so edge is already handled (see bRotated)
1238  {
1239  const Style& rLeft(GetCellStyleLeft(nCol, nRow));
1240 
1241  if (rLeft.IsUsed())
1242  {
1243  HelperCreateVerticalEntry(*this, rLeft, nCol, nRow, aOrigin, aX, aY, *aData, true, pForceColor);
1244  }
1245  }
1246  }
1247  }
1248  }
1249 
1250  // create instance of SdrFrameBorderPrimitive2D if
1251  // SdrFrameBorderDataVector is used
1253 
1254  if(!aData->empty())
1255  {
1256  aSequence.append(
1259  aData,
1260  true))); // force visualization to minimal one discrete unit (pixel)
1261  }
1262 
1263  return aSequence;
1264 }
1265 
1267 {
1269 
1270  if (mxImpl->mnWidth && mxImpl->mnHeight)
1271  {
1272  aPrimitives = CreateB2DPrimitiveRange(0, 0, mxImpl->mnWidth - 1, mxImpl->mnHeight - 1, nullptr);
1273  }
1274 
1275  return aPrimitives;
1276 }
1277 
1278 #undef ORIGCELL
1279 #undef CELLACC
1280 #undef CELL
1281 #undef DBG_FRAME_CHECK_ROW_1
1282 #undef DBG_FRAME_CHECK_COL_1
1283 #undef DBG_FRAME_CHECK_COLROW
1284 #undef DBG_FRAME_CHECK_ROW
1285 #undef DBG_FRAME_CHECK_COL
1286 #undef DBG_FRAME_CHECK
1287 
1288 }
1289 
1290 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
long GetColPosition(size_t nCol) const
std::vector< SdrFrameBorderData > SdrFrameBorderDataVector
void SetAddMergedLeftSize(size_t nCol, size_t nRow, long nAddSize)
Sets an additional left width for the merged range that contains (nCol,nRow).
double mnHeight
static void lclSetMergedRange(CellVec &rCells, size_t nWidth, size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow)
void SetAllColWidths(long nWidth)
Sets the same output width for all columns.
const Cell & GetCell(size_t nCol, size_t nRow) const
long mnAddRight
void SetCellStyleTLBR(size_t nCol, size_t nRow, const Style &rStyle)
Sets the top-left to bottom-right frame style of the cell (nCol,nRow).
void SetAddMergedTopSize(size_t nCol, size_t nRow, long nAddSize)
Sets an additional top height for the merged range that contains (nCol,nRow).
size_t mnLastRow
#define DBG_FRAME_CHECK_ROW_1(row, funcname)
bool IsInClipRange(size_t nCol, size_t nRow) const
bool IsMergedOverlappedRight(size_t nCol, size_t nRow) const
void SetXOffset(long nXOffset)
Sets the X output coordinate of the left column.
const char aData[]
SvxRotateMode
Definition: rotmodit.hxx:29
long GetColPosition(size_t nCol) const
Returns the X output coordinate of the left border of the specified column.
#define CELL(col, row)
long AdjustLeft(long nHorzMoveDelta)
FilterGroup & rTarget
void SetAddMergedRightSize(size_t nCol, size_t nRow, long nAddSize)
Sets an additional right width for the merged range that contains (nCol,nRow).
basegfx::B2DRange GetCellRange(size_t nCol, size_t nRow, bool bExpandMerged) const
Returns the output range of the cell (nCol,nRow).
size_t GetRowCount() const
Returns the number of rows in the array.
long mnAddLeft
void SetCellRotation(size_t nCol, size_t nRow, SvxRotateMode eRotMode, double fOrientation)
Sets the rotation parameters of the cell (nCol,nRow).
#define ORIGCELL(col, row)
std::vector< long > maWidths
void SetColWidth(size_t nCol, long nWidth)
Sets the output width of the specified column.
long GetColWidth(size_t nFirstCol, size_t nLastCol) const
Returns the output width of the specified range of columns.
SotClipboardFormatId & operator++(SotClipboardFormatId &eFormat)
size_t GetCellIndex(size_t nCol, size_t nRow, bool bRTL) const
Returns the cell index from the cell address (nCol,nRow).
size_t GetMergedFirstRow(size_t nCol, size_t nRow) const
void SetCellStyleTop(size_t nCol, size_t nRow, const Style &rStyle)
Sets the top frame style of the cell (nCol,nRow).
void SetCellStyleBottom(size_t nCol, size_t nRow, const Style &rStyle)
Sets the bottom frame style of the specified cell (nCol,nRow).
std::vector< long > maHeights
#define DBG_FRAME_CHECK_ROW(row, funcname)
bool IsUsed() const
Check if this style is used - this depends on it having any width definition.
Definition: framelink.hxx:138
Cell & GetCellAcc(size_t nCol, size_t nRow)
long GetWidth() const
Returns the output width of the entire array.
const Style & GetCellStyleTL(size_t nCol, size_t nRow) const
Returns the top-left to bottom-right frame style of the cell (nCol,nRow).
long AdjustBottom(long nVertMoveDelta)
void SetAddMergedBottomSize(size_t nCol, size_t nRow, long nAddSize)
Sets an additional bottom height for the merged range that contains (nCol,nRow).
long GetRowPosition(size_t nRow) const
Returns the Y output coordinate of the top border of the specified row.
const Cell OBJ_CELL_NONE
const Style & GetCellStyleTop(size_t nCol, size_t nRow) const
Returns the top frame style of the cell (nCol,nRow).
#define DBG_FRAME_CHECK_COL_1(col, funcname)
void SetYOffset(long nYOffset)
Sets the Y output coordinate of the top row.
B2DTuple getColumn(const B2DHomMatrix &rMatrix, sal_uInt16 nCol)
static void HelperCreateHorizontalEntry(const Array &rArray, const Style &rStyle, size_t col, size_t row, const basegfx::B2DPoint &rOrigin, const basegfx::B2DVector &rX, const basegfx::B2DVector &rY, drawinglayer::primitive2d::SdrFrameBorderDataVector &rData, bool bUpper, const Color *pForceColor)
Array()
Constructs an empty array.
size_t mnCol
bool IsRowInClipRange(size_t nRow) const
void SetRowStyleTop(size_t nRow, const Style &rStyle)
Sets the top frame style of the specified row.
const Style & GetCellStyleBL(size_t nCol, size_t nRow) const
Returns the bottom-left to top-right frame style of the cell (nCol,nRow).
size_t mnFirstRow
bool mbMergeOrig
size_t mnFirstCol
bool IsValidPos(size_t nCol, size_t nRow) const
Is
Style maTop
std::vector< long > maYCoords
long GetHeight() const
Returns the output height of the entire array.
const Style & GetCellStyleRight(size_t nCol, size_t nRow) const
Returns the right frame style of the cell (nCol,nRow).
void SetCellStyleLeft(size_t nCol, size_t nRow, const Style &rStyle)
Sets the left frame style of the cell (nCol,nRow).
long GetRowPosition(size_t nRow) const
drawinglayer::primitive2d::Primitive2DContainer CreateB2DPrimitiveRange(size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow, const Color *pForceColor) const
Draws the part of the specified range, that is inside the clipping range.
void SetCellStyleDiag(size_t nCol, size_t nRow, const Style &rTLBR, const Style &rBLTR)
Sets both diagonal frame styles of the specified cell (nCol,nRow).
std::unique_ptr< ArrayImpl > mxImpl
bool IsMergedOverlappedTop(size_t nCol, size_t nRow) const
drawinglayer::primitive2d::Primitive2DContainer CreateB2DPrimitiveArray() const
Draws the part of the array, that is inside the clipping range.
#define DBG_FRAME_CHECK_COL(col, funcname)
#define DBG_ASSERT(sCon, aError)
const Style & GetCellStyleBR(size_t nCol, size_t nRow) const
Returns the top-left to bottom-right frame style of the cell (nCol,nRow).
const Style & GetCellStyleBLTR(size_t nCol, size_t nRow) const
Returns the bottom-left to top-right frame style of the cell (nCol,nRow).
const Style OBJ_STYLE_NONE
void SetColumnStyleRight(size_t nCol, const Style &rStyle)
Sets the right frame style of the specified column.
SvxRotateMode meRotMode
const Cell & GetMergedOriginCell(size_t nCol, size_t nRow) const
const Style & GetCellStyleBottom(size_t nCol, size_t nRow) const
Returns the top frame style of the cell (nCol,nRow).
Style maLeft
size_t mnLastCol
long mnAddBottom
virtual void append(const Primitive2DReference &) override
void Initialize(size_t nWidth, size_t nHeight)
Reinitializes the array with the specified size.
Style maRight
bool IsMerged(size_t nCol, size_t nRow) const
Returns true, if the cell (nCol,nRow) is part of a merged range.
const Style & GetCellStyleTLBR(size_t nCol, size_t nRow) const
Returns the top-left to bottom-right frame style of the cell (nCol,nRow).
#define CELLACC(col, row)
void SetCellStyleBLTR(size_t nCol, size_t nRow, const Style &rStyle)
Sets the bottom-left to top-right frame style of the cell (nCol,nRow).
long mnAddTop
double mfOrientation
basegfx::B2DRange b2DRectangleFromRectangle(const ::tools::Rectangle &rRect)
void SetRowHeight(size_t nRow, long nHeight)
Sets the output height of the specified row.
void SetAllRowHeights(long nHeight)
Sets the same output height for all rows.
const Style & GetCellStyleTR(size_t nCol, size_t nRow) const
Returns the bottom-left to top-right frame style of the cell (nCol,nRow).
css::uno::Reference< css::graphic::XPrimitive2D > Primitive2DReference
void SetMergedRange(size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow)
Inserts a new merged cell range.
bool HasCellRotation() const
bool IsColInClipRange(size_t nCol) const
static void lclRecalcCoordVec(std::vector< long > &rCoords, const std::vector< long > &rSizes)
bool HasCellRotation() const
Check if at least one cell is rotated.
long AdjustRight(long nHorzMoveDelta)
static void HelperCreateVerticalEntry(const Array &rArray, const Style &rStyle, size_t col, size_t row, const basegfx::B2DPoint &rOrigin, const basegfx::B2DVector &rX, const basegfx::B2DVector &rY, drawinglayer::primitive2d::SdrFrameBorderDataVector &rData, bool bLeft, const Color *pForceColor)
bool equalZero() const
bool IsMergedOverlappedBottom(size_t nCol, size_t nRow) const
#define DBG_FRAME_CHECK(cond, funcname, error)
const Style & GetCellStyleLeft(size_t nCol, size_t nRow) const
Returns the left frame style of the cell (nCol,nRow).
size_t GetColCount() const
Returns the number of columns in the array.
size_t mnRow
std::vector< Cell > CellVec
double mnWidth
B2DHomMatrix createCoordinateSystemTransform(const B2DPoint &rOrigin, const B2DVector &rX, const B2DVector &rY)
Cell
Definition: svdotable.hxx:96
bool mbOverlapX
size_t GetIndex(size_t nCol, size_t nRow) const
Contains the widths of primary and secondary line of a frame style.
Definition: framelink.hxx:100
long AdjustTop(long nVertMoveDelta)
std::vector< long > maXCoords
long GetRowHeight(size_t nFirstRow, size_t nLastRow) const
Returns the output height of the specified range of rows.
void SetCellStyleRight(size_t nCol, size_t nRow, const Style &rStyle)
Sets the right frame style of the cell (nCol,nRow).
size_t GetMergedFirstCol(size_t nCol, size_t nRow) const
bool mbOverlapY
void SetColumnStyleLeft(size_t nCol, const Style &rStyle)
Sets the left frame style of the specified column.
size_t GetCellCount() const
Returns the number of cells in the array.
void MirrorSelfX()
Mirrors the entire array horizontally.
void GetMergedRange(size_t &rnFirstCol, size_t &rnFirstRow, size_t &rnLastCol, size_t &rnLastRow, size_t nCol, size_t nRow) const
Returns the top-left and bottom-right address of the merged range that contains (nCol,nRow).
Stores frame styles of an array of cells, supports merged ranges.
Style maTLBR
void SetClipRange(size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow)
Sets a clipping range.
bool IsRotated(const OUString &rsCommandName, const OUString &rsModuleName)
bool IsMergedOverlappedLeft(size_t nCol, size_t nRow) const
size_t GetMirrorCol(size_t nCol) const
~Array()
Destructs the array.
void GetMergedOrigin(size_t &rnFirstCol, size_t &rnFirstRow, size_t nCol, size_t nRow) const
Returns the address of the top-left cell of the merged range that contains (nCol,nRow).
Style maBLTR
void SetRowStyleBottom(size_t nRow, const Style &rStyle)
Sets the bottom frame style of the specified row.
#define DBG_FRAME_CHECK_COLROW(col, row, funcname)
size_t GetMergedLastRow(size_t nCol, size_t nRow) const
Style maBottom
size_t GetMergedLastCol(size_t nCol, size_t nRow) const