?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix baseline build (old cairo) - 'cairo_rectangle_int_t' does not name a type
[LibreOffice.git] / svx / source / dialog / framelinkarray.cxx
blob615970dbcfc5835e0036329d21897942e6183eca
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 <algorithm>
25 #include <vcl/outdev.hxx>
26
27 namespace svx {
28 namespace frame {
29
30 struct Cell
31 {
32 Style maLeft;
33 Style maRight;
34 Style maTop;
35 Style maBottom;
36 Style maTLBR;
37 Style maBLTR;
38 long mnAddLeft;
39 long mnAddRight;
40 long mnAddTop;
41 long mnAddBottom;
42 bool mbMergeOrig;
43 bool mbOverlapX;
44 bool mbOverlapY;
45
46 explicit Cell();
47
48 inline bool IsMerged() const { return mbMergeOrig || mbOverlapX || mbOverlapY; }
49
50 void MirrorSelfX( bool bMirrorStyles, bool bSwapDiag );
51 };
52
53 typedef std::vector< long > LongVec;
54 typedef std::vector< Cell > CellVec;
55
56 Cell::Cell() :
57 mnAddLeft( 0 ),
58 mnAddRight( 0 ),
59 mnAddTop( 0 ),
60 mnAddBottom( 0 ),
61 mbMergeOrig( false ),
62 mbOverlapX( false ),
63 mbOverlapY( false )
64 {
65 }
66
67 void Cell::MirrorSelfX( bool bMirrorStyles, bool bSwapDiag )
68 {
69 std::swap( maLeft, maRight );
70 std::swap( mnAddLeft, mnAddRight );
71 if( bMirrorStyles )
72 {
73 maLeft.MirrorSelf();
74 maRight.MirrorSelf();
75 }
76 if( bSwapDiag )
77 {
78 std::swap( maTLBR, maBLTR );
79 if( bMirrorStyles )
80 {
81 maTLBR.MirrorSelf();
82 maBLTR.MirrorSelf();
83 }
84 }
85 }
86
87
88
89
90 void lclRecalcCoordVec( LongVec& rCoords, const LongVec& rSizes )
91 {
92 DBG_ASSERT( rCoords.size() == rSizes.size() + 1, "lclRecalcCoordVec - inconsistent vectors" );
93 LongVec::iterator aCIt = rCoords.begin();
94 LongVec::const_iterator aSIt = rSizes.begin(), aSEnd = rSizes.end();
95 for( ; aSIt != aSEnd; ++aCIt, ++aSIt )
96 *(aCIt + 1) = *aCIt + *aSIt;
97 }
98
99 void lclSetMergedRange( CellVec& rCells, size_t nWidth, size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow )
100 {
101 for( size_t nCol = nFirstCol; nCol <= nLastCol; ++nCol )
102 {
103 for( size_t nRow = nFirstRow; nRow <= nLastRow; ++nRow )
104 {
105 Cell& rCell = rCells[ nRow * nWidth + nCol ];
106 rCell.mbMergeOrig = false;
107 rCell.mbOverlapX = nCol > nFirstCol;
108 rCell.mbOverlapY = nRow > nFirstRow;
109 }
110 }
111 rCells[ nFirstRow * nWidth + nFirstCol ].mbMergeOrig = true;
112 }
113
114
115
116 static const Style OBJ_STYLE_NONE;
117 static const Cell OBJ_CELL_NONE;
118
119 const bool DIAG_DBL_CLIP_DEFAULT = false;
120
121 struct ArrayImpl
122 {
123 CellVec maCells;
124 LongVec maWidths;
125 LongVec maHeights;
126 mutable LongVec maXCoords;
127 mutable LongVec maYCoords;
128 size_t mnWidth;
129 size_t mnHeight;
130 size_t mnFirstClipCol;
131 size_t mnFirstClipRow;
132 size_t mnLastClipCol;
133 size_t mnLastClipRow;
134 mutable bool mbXCoordsDirty;
135 mutable bool mbYCoordsDirty;
136 bool mbDiagDblClip;
137
138 explicit ArrayImpl( size_t nWidth, size_t nHeight, bool bDiagDblClip );
139
140 inline bool IsValidPos( size_t nCol, size_t nRow ) const
141 { return (nCol < mnWidth) && (nRow < mnHeight); }
142 inline size_t GetIndex( size_t nCol, size_t nRow ) const
143 { return nRow * mnWidth + nCol; }
144
145 const Cell& GetCell( size_t nCol, size_t nRow ) const;
146 Cell& GetCellAcc( size_t nCol, size_t nRow );
147
148 size_t GetMergedFirstCol( size_t nCol, size_t nRow ) const;
149 size_t GetMergedFirstRow( size_t nCol, size_t nRow ) const;
150 size_t GetMergedLastCol( size_t nCol, size_t nRow ) const;
151 size_t GetMergedLastRow( size_t nCol, size_t nRow ) const;
152
153 const Cell& GetMergedOriginCell( size_t nCol, size_t nRow ) const;
154
155 bool IsMergedOverlappedLeft( size_t nCol, size_t nRow ) const;
156 bool IsMergedOverlappedRight( size_t nCol, size_t nRow ) const;
157 bool IsMergedOverlappedTop( size_t nCol, size_t nRow ) const;
158 bool IsMergedOverlappedBottom( size_t nCol, size_t nRow ) const;
159
160 bool IsInClipRange( size_t nCol, size_t nRow ) const;
161 bool IsColInClipRange( size_t nCol ) const;
162 bool IsRowInClipRange( size_t nRow ) const;
163
164 inline size_t GetMirrorCol( size_t nCol ) const { return mnWidth - nCol - 1; }
165
166 long GetColPosition( size_t nCol ) const;
167 long GetRowPosition( size_t nRow ) const;
168
169 long GetColWidth( size_t nFirstCol, size_t nLastCol ) const;
170 long GetRowHeight( size_t nFirstRow, size_t nLastRow ) const;
171
172 double GetHorDiagAngle( size_t nCol, size_t nRow, bool bSimple = false ) const;
173 double GetVerDiagAngle( size_t nCol, size_t nRow, bool bSimple = false ) const;
174 };
175
176 ArrayImpl::ArrayImpl( size_t nWidth, size_t nHeight, bool bDiagDblClip ) :
177 mnWidth( nWidth ),
178 mnHeight( nHeight ),
179 mnFirstClipCol( 0 ),
180 mnFirstClipRow( 0 ),
181 mnLastClipCol( nWidth - 1 ),
182 mnLastClipRow( nHeight - 1 ),
183 mbXCoordsDirty( false ),
184 mbYCoordsDirty( false ),
185 mbDiagDblClip( bDiagDblClip )
186 {
187 // default-construct all vectors
188 maCells.resize( mnWidth * mnHeight );
189 maWidths.resize( mnWidth, 0L );
190 maHeights.resize( mnHeight, 0L );
191 maXCoords.resize( mnWidth + 1, 0L );
192 maYCoords.resize( mnHeight + 1, 0L );
193 }
194
195 const Cell& ArrayImpl::GetCell( size_t nCol, size_t nRow ) const
196 {
197 return IsValidPos( nCol, nRow ) ? maCells[ GetIndex( nCol, nRow ) ] : OBJ_CELL_NONE;
198 }
199
200 Cell& ArrayImpl::GetCellAcc( size_t nCol, size_t nRow )
201 {
202 static Cell aDummy;
203 return IsValidPos( nCol, nRow ) ? maCells[ GetIndex( nCol, nRow ) ] : aDummy;
204 }
205
206 size_t ArrayImpl::GetMergedFirstCol( size_t nCol, size_t nRow ) const
207 {
208 size_t nFirstCol = nCol;
209 while( (nFirstCol > 0) && GetCell( nFirstCol, nRow ).mbOverlapX ) --nFirstCol;
210 return nFirstCol;
211 }
212
213 size_t ArrayImpl::GetMergedFirstRow( size_t nCol, size_t nRow ) const
214 {
215 size_t nFirstRow = nRow;
216 while( (nFirstRow > 0) && GetCell( nCol, nFirstRow ).mbOverlapY ) --nFirstRow;
217 return nFirstRow;
218 }
219
220 size_t ArrayImpl::GetMergedLastCol( size_t nCol, size_t nRow ) const
221 {
222 size_t nLastCol = nCol + 1;
223 while( (nLastCol < mnWidth) && GetCell( nLastCol, nRow ).mbOverlapX ) ++nLastCol;
224 return nLastCol - 1;
225 }
226
227 size_t ArrayImpl::GetMergedLastRow( size_t nCol, size_t nRow ) const
228 {
229 size_t nLastRow = nRow + 1;
230 while( (nLastRow < mnHeight) && GetCell( nCol, nLastRow ).mbOverlapY ) ++nLastRow;
231 return nLastRow - 1;
232 }
233
234 const Cell& ArrayImpl::GetMergedOriginCell( size_t nCol, size_t nRow ) const
235 {
236 return GetCell( GetMergedFirstCol( nCol, nRow ), GetMergedFirstRow( nCol, nRow ) );
237 }
238
239 bool ArrayImpl::IsMergedOverlappedLeft( size_t nCol, size_t nRow ) const
240 {
241 const Cell& rCell = GetCell( nCol, nRow );
242 return rCell.mbOverlapX || (rCell.mnAddLeft > 0);
243 }
244
245 bool ArrayImpl::IsMergedOverlappedRight( size_t nCol, size_t nRow ) const
246 {
247 return GetCell( nCol + 1, nRow ).mbOverlapX || (GetCell( nCol, nRow ).mnAddRight > 0);
248 }
249
250 bool ArrayImpl::IsMergedOverlappedTop( size_t nCol, size_t nRow ) const
251 {
252 const Cell& rCell = GetCell( nCol, nRow );
253 return rCell.mbOverlapY || (rCell.mnAddTop > 0);
254 }
255
256 bool ArrayImpl::IsMergedOverlappedBottom( size_t nCol, size_t nRow ) const
257 {
258 return GetCell( nCol, nRow + 1 ).mbOverlapY || (GetCell( nCol, nRow ).mnAddBottom > 0);
259 }
260
261 bool ArrayImpl::IsColInClipRange( size_t nCol ) const
262 {
263 return (mnFirstClipCol <= nCol) && (nCol <= mnLastClipCol);
264 }
265
266 bool ArrayImpl::IsRowInClipRange( size_t nRow ) const
267 {
268 return (mnFirstClipRow <= nRow) && (nRow <= mnLastClipRow);
269 }
270
271 bool ArrayImpl::IsInClipRange( size_t nCol, size_t nRow ) const
272 {
273 return IsColInClipRange( nCol ) && IsRowInClipRange( nRow );
274 }
275
276 long ArrayImpl::GetColPosition( size_t nCol ) const
277 {
278 if( mbXCoordsDirty )
279 {
280 lclRecalcCoordVec( maXCoords, maWidths );
281 mbXCoordsDirty = false;
282 }
283 return maXCoords[ nCol ];
284 }
285
286 long ArrayImpl::GetRowPosition( size_t nRow ) const
287 {
288 if( mbYCoordsDirty )
289 {
290 lclRecalcCoordVec( maYCoords, maHeights );
291 mbYCoordsDirty = false;
292 }
293 return maYCoords[ nRow ];
294 }
295
296 long ArrayImpl::GetColWidth( size_t nFirstCol, size_t nLastCol ) const
297 {
298 return GetColPosition( nLastCol + 1 ) - GetColPosition( nFirstCol );
299 }
300
301 long ArrayImpl::GetRowHeight( size_t nFirstRow, size_t nLastRow ) const
302 {
303 return GetRowPosition( nLastRow + 1 ) - GetRowPosition( nFirstRow );
304 }
305
306 double ArrayImpl::GetHorDiagAngle( size_t nCol, size_t nRow, bool bSimple ) const
307 {
308 double fAngle = 0.0;
309 if( IsValidPos( nCol, nRow ) )
310 {
311 if( bSimple || !GetCell( nCol, nRow ).IsMerged() )
312 {
313 fAngle = frame::GetHorDiagAngle( maWidths[ nCol ] + 1, maHeights[ nRow ] + 1 );
314 }
315 else
316 {
317 // return correct angle for each cell in the merged range
318 size_t nFirstCol = GetMergedFirstCol( nCol, nRow );
319 size_t nFirstRow = GetMergedFirstRow( nCol, nRow );
320 const Cell& rCell = GetCell( nFirstCol, nFirstRow );
321 long nWidth = GetColWidth( nFirstCol, GetMergedLastCol( nCol, nRow ) ) + rCell.mnAddLeft + rCell.mnAddRight;
322 long nHeight = GetRowHeight( nFirstRow, GetMergedLastRow( nCol, nRow ) ) + rCell.mnAddTop + rCell.mnAddBottom;
323 fAngle = frame::GetHorDiagAngle( nWidth + 1, nHeight + 1 );
324 }
325 }
326 return fAngle;
327 }
328
329 double ArrayImpl::GetVerDiagAngle( size_t nCol, size_t nRow, bool bSimple ) const
330 {
331 double fAngle = GetHorDiagAngle( nCol, nRow, bSimple );
332 return (fAngle > 0.0) ? (F_PI2 - fAngle) : 0.0;
333 }
334
335
336
337 class MergedCellIterator
338 {
339 public:
340 explicit MergedCellIterator( const Array& rArray, size_t nCol, size_t nRow );
341
342 inline bool Is() const { return (mnCol <= mnLastCol) && (mnRow <= mnLastRow); }
343 inline size_t Col() const { return mnCol; }
344 inline size_t Row() const { return mnRow; }
345
346 MergedCellIterator& operator++();
347
348 private:
349 size_t mnFirstCol;
350 size_t mnFirstRow;
351 size_t mnLastCol;
352 size_t mnLastRow;
353 size_t mnCol;
354 size_t mnRow;
355 };
356
357
358
359 MergedCellIterator::MergedCellIterator( const Array& rArray, size_t nCol, size_t nRow )
360 {
361 DBG_ASSERT( rArray.IsMerged( nCol, nRow ), "svx::frame::MergedCellIterator::MergedCellIterator - not in merged range" );
362 rArray.GetMergedRange( mnFirstCol, mnFirstRow, mnLastCol, mnLastRow, nCol, nRow );
363 mnCol = mnFirstCol;
364 mnRow = mnFirstRow;
365 }
366
367 MergedCellIterator& MergedCellIterator::operator++()
368 {
369 DBG_ASSERT( Is(), "svx::frame::MergedCellIterator::operator++() - already invalid" );
370 if( ++mnCol > mnLastCol )
371 {
372 mnCol = mnFirstCol;
373 ++mnRow;
374 }
375 return *this;
376 }
377
378
379
380 #define DBG_FRAME_CHECK( cond, funcname, error ) DBG_ASSERT( cond, "svx::frame::Array::" funcname " - " error )
381 #define DBG_FRAME_CHECK_COL( col, funcname ) DBG_FRAME_CHECK( (col) < GetColCount(), funcname, "invalid column index" )
382 #define DBG_FRAME_CHECK_ROW( row, funcname ) DBG_FRAME_CHECK( (row) < GetRowCount(), funcname, "invalid row index" )
383 #define DBG_FRAME_CHECK_COLROW( col, row, funcname ) DBG_FRAME_CHECK( ((col) < GetColCount()) && ((row) < GetRowCount()), funcname, "invalid cell index" )
384 #define DBG_FRAME_CHECK_COL_1( col, funcname ) DBG_FRAME_CHECK( (col) <= GetColCount(), funcname, "invalid column index" )
385 #define DBG_FRAME_CHECK_ROW_1( row, funcname ) DBG_FRAME_CHECK( (row) <= GetRowCount(), funcname, "invalid row index" )
386
387
388
389 #define CELL( col, row ) mxImpl->GetCell( col, row )
390 #define CELLACC( col, row ) mxImpl->GetCellAcc( col, row )
391 #define ORIGCELL( col, row ) mxImpl->GetMergedOriginCell( col, row )
392
393
394
395 Array::Array()
396 {
397 Initialize( 0, 0 );
398 }
399
400 Array::~Array()
401 {
402 }
403
404 // array size and column/row indexes
405 void Array::Initialize( size_t nWidth, size_t nHeight )
406 {
407 bool bDiagDblClip = mxImpl.get() ? mxImpl->mbDiagDblClip : DIAG_DBL_CLIP_DEFAULT;
408 mxImpl.reset( new ArrayImpl( nWidth, nHeight, bDiagDblClip ) );
409 }
410
411 size_t Array::GetColCount() const
412 {
413 return mxImpl->mnWidth;
414 }
415
416 size_t Array::GetRowCount() const
417 {
418 return mxImpl->mnHeight;
419 }
420
421 size_t Array::GetCellCount() const
422 {
423 return mxImpl->maCells.size();
424 }
425
426 size_t Array::GetCellIndex( size_t nCol, size_t nRow, bool bRTL ) const
427 {
428 DBG_FRAME_CHECK_COLROW( nCol, nRow, "GetCellIndex" );
429 if (bRTL)
430 nCol = mxImpl->GetMirrorCol(nCol);
431 return mxImpl->GetIndex( nCol, nRow );
432 }
433
434 // cell border styles
435 void Array::SetCellStyleLeft( size_t nCol, size_t nRow, const Style& rStyle )
436 {
437 DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleLeft" );
438 CELLACC( nCol, nRow ).maLeft = rStyle;
439 }
440
441 void Array::SetCellStyleRight( size_t nCol, size_t nRow, const Style& rStyle )
442 {
443 DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleRight" );
444 CELLACC( nCol, nRow ).maRight = rStyle;
445 }
446
447 void Array::SetCellStyleTop( size_t nCol, size_t nRow, const Style& rStyle )
448 {
449 DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleTop" );
450 CELLACC( nCol, nRow ).maTop = rStyle;
451 }
452
453 void Array::SetCellStyleBottom( size_t nCol, size_t nRow, const Style& rStyle )
454 {
455 DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleBottom" );
456 CELLACC( nCol, nRow ).maBottom = rStyle;
457 }
458
459 void Array::SetCellStyleTLBR( size_t nCol, size_t nRow, const Style& rStyle )
460 {
461 DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleTLBR" );
462 CELLACC( nCol, nRow ).maTLBR = rStyle;
463 }
464
465 void Array::SetCellStyleBLTR( size_t nCol, size_t nRow, const Style& rStyle )
466 {
467 DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleBLTR" );
468 CELLACC( nCol, nRow ).maBLTR = rStyle;
469 }
470
471 void Array::SetCellStyleDiag( size_t nCol, size_t nRow, const Style& rTLBR, const Style& rBLTR )
472 {
473 DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleDiag" );
474 Cell& rCell = CELLACC( nCol, nRow );
475 rCell.maTLBR = rTLBR;
476 rCell.maBLTR = rBLTR;
477 }
478
479 void Array::SetColumnStyleLeft( size_t nCol, const Style& rStyle )
480 {
481 DBG_FRAME_CHECK_COL( nCol, "SetColumnStyleLeft" );
482 for( size_t nRow = 0; nRow < mxImpl->mnHeight; ++nRow )
483 SetCellStyleLeft( nCol, nRow, rStyle );
484 }
485
486 void Array::SetColumnStyleRight( size_t nCol, const Style& rStyle )
487 {
488 DBG_FRAME_CHECK_COL( nCol, "SetColumnStyleRight" );
489 for( size_t nRow = 0; nRow < mxImpl->mnHeight; ++nRow )
490 SetCellStyleRight( nCol, nRow, rStyle );
491 }
492
493 void Array::SetRowStyleTop( size_t nRow, const Style& rStyle )
494 {
495 DBG_FRAME_CHECK_ROW( nRow, "SetRowStyleTop" );
496 for( size_t nCol = 0; nCol < mxImpl->mnWidth; ++nCol )
497 SetCellStyleTop( nCol, nRow, rStyle );
498 }
499
500 void Array::SetRowStyleBottom( size_t nRow, const Style& rStyle )
501 {
502 DBG_FRAME_CHECK_ROW( nRow, "SetRowStyleBottom" );
503 for( size_t nCol = 0; nCol < mxImpl->mnWidth; ++nCol )
504 SetCellStyleBottom( nCol, nRow, rStyle );
505 }
506
507 const Style& Array::GetCellStyleLeft( size_t nCol, size_t nRow, bool bSimple ) const
508 {
509 // simple: always return own left style
510 if( bSimple )
511 return CELL( nCol, nRow ).maLeft;
512 // outside clipping rows or overlapped in merged cells: invisible
513 if( !mxImpl->IsRowInClipRange( nRow ) || mxImpl->IsMergedOverlappedLeft( nCol, nRow ) )
514 return OBJ_STYLE_NONE;
515 // left clipping border: always own left style
516 if( nCol == mxImpl->mnFirstClipCol )
517 return ORIGCELL( nCol, nRow ).maLeft;
518 // right clipping border: always right style of left neighbor cell
519 if( nCol == mxImpl->mnLastClipCol + 1 )
520 return ORIGCELL( nCol - 1, nRow ).maRight;
521 // outside clipping columns: invisible
522 if( !mxImpl->IsColInClipRange( nCol ) )
523 return OBJ_STYLE_NONE;
524 // inside clipping range: maximum of own left style and right style of left neighbor cell
525 return std::max( ORIGCELL( nCol, nRow ).maLeft, ORIGCELL( nCol - 1, nRow ).maRight );
526 }
527
528 const Style& Array::GetCellStyleRight( size_t nCol, size_t nRow, bool bSimple ) const
529 {
530 // simple: always return own right style
531 if( bSimple )
532 return CELL( nCol, nRow ).maRight;
533 // outside clipping rows or overlapped in merged cells: invisible
534 if( !mxImpl->IsRowInClipRange( nRow ) || mxImpl->IsMergedOverlappedRight( nCol, nRow ) )
535 return OBJ_STYLE_NONE;
536 // left clipping border: always left style of right neighbor cell
537 if( nCol + 1 == mxImpl->mnFirstClipCol )
538 return ORIGCELL( nCol + 1, nRow ).maLeft;
539 // right clipping border: always own right style
540 if( nCol == mxImpl->mnLastClipCol )
541 return ORIGCELL( nCol, nRow ).maRight;
542 // outside clipping columns: invisible
543 if( !mxImpl->IsColInClipRange( nCol ) )
544 return OBJ_STYLE_NONE;
545 // inside clipping range: maximum of own right style and left style of right neighbor cell
546 return std::max( ORIGCELL( nCol, nRow ).maRight, ORIGCELL( nCol + 1, nRow ).maLeft );
547 }
548
549 const Style& Array::GetCellStyleTop( size_t nCol, size_t nRow, bool bSimple ) const
550 {
551 // simple: always return own top style
552 if( bSimple )
553 return CELL( nCol, nRow ).maTop;
554 // outside clipping columns or overlapped in merged cells: invisible
555 if( !mxImpl->IsColInClipRange( nCol ) || mxImpl->IsMergedOverlappedTop( nCol, nRow ) )
556 return OBJ_STYLE_NONE;
557 // top clipping border: always own top style
558 if( nRow == mxImpl->mnFirstClipRow )
559 return ORIGCELL( nCol, nRow ).maTop;
560 // bottom clipping border: always bottom style of top neighbor cell
561 if( nRow == mxImpl->mnLastClipRow + 1 )
562 return ORIGCELL( nCol, nRow - 1 ).maBottom;
563 // outside clipping rows: invisible
564 if( !mxImpl->IsRowInClipRange( nRow ) )
565 return OBJ_STYLE_NONE;
566 // inside clipping range: maximum of own top style and bottom style of top neighbor cell
567 return std::max( ORIGCELL( nCol, nRow ).maTop, ORIGCELL( nCol, nRow - 1 ).maBottom );
568 }
569
570 const Style& Array::GetCellStyleBottom( size_t nCol, size_t nRow, bool bSimple ) const
571 {
572 // simple: always return own bottom style
573 if( bSimple )
574 return CELL( nCol, nRow ).maBottom;
575 // outside clipping columns or overlapped in merged cells: invisible
576 if( !mxImpl->IsColInClipRange( nCol ) || mxImpl->IsMergedOverlappedBottom( nCol, nRow ) )
577 return OBJ_STYLE_NONE;
578 // top clipping border: always top style of bottom neighbor cell
579 if( nRow + 1 == mxImpl->mnFirstClipRow )
580 return ORIGCELL( nCol, nRow + 1 ).maTop;
581 // bottom clipping border: always own bottom style
582 if( nRow == mxImpl->mnLastClipRow )
583 return ORIGCELL( nCol, nRow ).maBottom;
584 // outside clipping rows: invisible
585 if( !mxImpl->IsRowInClipRange( nRow ) )
586 return OBJ_STYLE_NONE;
587 // inside clipping range: maximum of own bottom style and top style of bottom neighbor cell
588 return std::max( ORIGCELL( nCol, nRow ).maBottom, ORIGCELL( nCol, nRow + 1 ).maTop );
589 }
590
591 const Style& Array::GetCellStyleTLBR( size_t nCol, size_t nRow, bool bSimple ) const
592 {
593 return bSimple ? CELL( nCol, nRow ).maTLBR :
594 (mxImpl->IsInClipRange( nCol, nRow ) ? ORIGCELL( nCol, nRow ).maTLBR : OBJ_STYLE_NONE);
595 }
596
597 const Style& Array::GetCellStyleBLTR( size_t nCol, size_t nRow, bool bSimple ) const
598 {
599 return bSimple ? CELL( nCol, nRow ).maBLTR :
600 (mxImpl->IsInClipRange( nCol, nRow ) ? ORIGCELL( nCol, nRow ).maBLTR : OBJ_STYLE_NONE);
601 }
602
603 const Style& Array::GetCellStyleTL( size_t nCol, size_t nRow ) const
604 {
605 // not in clipping range: always invisible
606 if( !mxImpl->IsInClipRange( nCol, nRow ) )
607 return OBJ_STYLE_NONE;
608 // return style only for top-left cell
609 size_t nFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow );
610 size_t nFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow );
611 return ((nCol == nFirstCol) && (nRow == nFirstRow)) ?
612 CELL( nFirstCol, nFirstRow ).maTLBR : OBJ_STYLE_NONE;
613 }
614
615 const Style& Array::GetCellStyleBR( size_t nCol, size_t nRow ) const
616 {
617 // not in clipping range: always invisible
618 if( !mxImpl->IsInClipRange( nCol, nRow ) )
619 return OBJ_STYLE_NONE;
620 // return style only for bottom-right cell
621 size_t nLastCol = mxImpl->GetMergedLastCol( nCol, nRow );
622 size_t nLastRow = mxImpl->GetMergedLastRow( nCol, nRow );
623 return ((nCol == nLastCol) && (nRow == nLastRow)) ?
624 CELL( mxImpl->GetMergedFirstCol( nCol, nRow ), mxImpl->GetMergedFirstRow( nCol, nRow ) ).maTLBR : OBJ_STYLE_NONE;
625 }
626
627 const Style& Array::GetCellStyleBL( size_t nCol, size_t nRow ) const
628 {
629 // not in clipping range: always invisible
630 if( !mxImpl->IsInClipRange( nCol, nRow ) )
631 return OBJ_STYLE_NONE;
632 // return style only for bottom-left cell
633 size_t nFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow );
634 size_t nLastRow = mxImpl->GetMergedLastRow( nCol, nRow );
635 return ((nCol == nFirstCol) && (nRow == nLastRow)) ?
636 CELL( nFirstCol, mxImpl->GetMergedFirstRow( nCol, nRow ) ).maBLTR : OBJ_STYLE_NONE;
637 }
638
639 const Style& Array::GetCellStyleTR( size_t nCol, size_t nRow ) const
640 {
641 // not in clipping range: always invisible
642 if( !mxImpl->IsInClipRange( nCol, nRow ) )
643 return OBJ_STYLE_NONE;
644 // return style only for top-right cell
645 size_t nFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow );
646 size_t nLastCol = mxImpl->GetMergedLastCol( nCol, nRow );
647 return ((nCol == nLastCol) && (nRow == nFirstRow)) ?
648 CELL( mxImpl->GetMergedFirstCol( nCol, nRow ), nFirstRow ).maBLTR : OBJ_STYLE_NONE;
649 }
650
651 // cell merging
652 void Array::SetMergedRange( size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow )
653 {
654 DBG_FRAME_CHECK_COLROW( nFirstCol, nFirstRow, "SetMergedRange" );
655 DBG_FRAME_CHECK_COLROW( nLastCol, nLastRow, "SetMergedRange" );
656 #if OSL_DEBUG_LEVEL >= 2
657 {
658 bool bFound = false;
659 for( size_t nCurrCol = nFirstCol; !bFound && (nCurrCol <= nLastCol); ++nCurrCol )
660 for( size_t nCurrRow = nFirstRow; !bFound && (nCurrRow <= nLastRow); ++nCurrRow )
661 bFound = CELL( nCurrCol, nCurrRow ).IsMerged();
662 DBG_FRAME_CHECK( !bFound, "SetMergedRange", "overlapping merged ranges" );
663 }
664 #endif
665 if( mxImpl->IsValidPos( nFirstCol, nFirstRow ) && mxImpl->IsValidPos( nLastCol, nLastRow ) )
666 lclSetMergedRange( mxImpl->maCells, mxImpl->mnWidth, nFirstCol, nFirstRow, nLastCol, nLastRow );
667 }
668
669 void Array::SetAddMergedLeftSize( size_t nCol, size_t nRow, long nAddSize )
670 {
671 DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedLeftSize" );
672 DBG_FRAME_CHECK( mxImpl->GetMergedFirstCol( nCol, nRow ) == 0, "SetAddMergedLeftSize", "additional border inside array" );
673 for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt )
674 CELLACC( aIt.Col(), aIt.Row() ).mnAddLeft = nAddSize;
675 }
676
677 void Array::SetAddMergedRightSize( size_t nCol, size_t nRow, long nAddSize )
678 {
679 DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedRightSize" );
680 DBG_FRAME_CHECK( mxImpl->GetMergedLastCol( nCol, nRow ) + 1 == mxImpl->mnWidth, "SetAddMergedRightSize", "additional border inside array" );
681 for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt )
682 CELLACC( aIt.Col(), aIt.Row() ).mnAddRight = nAddSize;
683 }
684
685 void Array::SetAddMergedTopSize( size_t nCol, size_t nRow, long nAddSize )
686 {
687 DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedTopSize" );
688 DBG_FRAME_CHECK( mxImpl->GetMergedFirstRow( nCol, nRow ) == 0, "SetAddMergedTopSize", "additional border inside array" );
689 for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt )
690 CELLACC( aIt.Col(), aIt.Row() ).mnAddTop = nAddSize;
691 }
692
693 void Array::SetAddMergedBottomSize( size_t nCol, size_t nRow, long nAddSize )
694 {
695 DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedBottomSize" );
696 DBG_FRAME_CHECK( mxImpl->GetMergedLastRow( nCol, nRow ) + 1 == mxImpl->mnHeight, "SetAddMergedBottomSize", "additional border inside array" );
697 for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt )
698 CELLACC( aIt.Col(), aIt.Row() ).mnAddBottom = nAddSize;
699 }
700
701 bool Array::IsMerged( size_t nCol, size_t nRow ) const
702 {
703 DBG_FRAME_CHECK_COLROW( nCol, nRow, "IsMerged" );
704 return CELL( nCol, nRow ).IsMerged();
705 }
706
707 bool Array::IsMergedOverlappedLeft( size_t nCol, size_t nRow ) const
708 {
709 DBG_FRAME_CHECK_COLROW( nCol, nRow, "IsMergedOverlappedLeft" );
710 return mxImpl->IsMergedOverlappedLeft( nCol, nRow );
711 }
712
713 bool Array::IsMergedOverlappedRight( size_t nCol, size_t nRow ) const
714 {
715 DBG_FRAME_CHECK_COLROW( nCol, nRow, "IsMergedOverlappedRight" );
716 return mxImpl->IsMergedOverlappedRight( nCol, nRow );
717 }
718
719 void Array::GetMergedOrigin( size_t& rnFirstCol, size_t& rnFirstRow, size_t nCol, size_t nRow ) const
720 {
721 DBG_FRAME_CHECK_COLROW( nCol, nRow, "GetMergedOrigin" );
722 rnFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow );
723 rnFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow );
724 }
725
726 void Array::GetMergedRange( size_t& rnFirstCol, size_t& rnFirstRow,
727 size_t& rnLastCol, size_t& rnLastRow, size_t nCol, size_t nRow ) const
728 {
729 GetMergedOrigin( rnFirstCol, rnFirstRow, nCol, nRow );
730 rnLastCol = mxImpl->GetMergedLastCol( nCol, nRow );
731 rnLastRow = mxImpl->GetMergedLastRow( nCol, nRow );
732 }
733
734 // clipping
735 void Array::SetClipRange( size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow )
736 {
737 DBG_FRAME_CHECK_COLROW( nFirstCol, nFirstRow, "SetClipRange" );
738 DBG_FRAME_CHECK_COLROW( nLastCol, nLastRow, "SetClipRange" );
739 mxImpl->mnFirstClipCol = nFirstCol;
740 mxImpl->mnFirstClipRow = nFirstRow;
741 mxImpl->mnLastClipCol = nLastCol;
742 mxImpl->mnLastClipRow = nLastRow;
743 }
744
745 Rectangle Array::GetClipRangeRectangle() const
746 {
747 return Rectangle(
748 mxImpl->GetColPosition( mxImpl->mnFirstClipCol ),
749 mxImpl->GetRowPosition( mxImpl->mnFirstClipRow ),
750 mxImpl->GetColPosition( mxImpl->mnLastClipCol + 1 ),
751 mxImpl->GetRowPosition( mxImpl->mnLastClipRow + 1 ) );
752 }
753
754 // cell coordinates
755 void Array::SetXOffset( long nXOffset )
756 {
757 mxImpl->maXCoords[ 0 ] = nXOffset;
758 mxImpl->mbXCoordsDirty = true;
759 }
760
761 void Array::SetYOffset( long nYOffset )
762 {
763 mxImpl->maYCoords[ 0 ] = nYOffset;
764 mxImpl->mbYCoordsDirty = true;
765 }
766
767 void Array::SetColWidth( size_t nCol, long nWidth )
768 {
769 DBG_FRAME_CHECK_COL( nCol, "SetColWidth" );
770 mxImpl->maWidths[ nCol ] = nWidth;
771 mxImpl->mbXCoordsDirty = true;
772 }
773
774 void Array::SetRowHeight( size_t nRow, long nHeight )
775 {
776 DBG_FRAME_CHECK_ROW( nRow, "SetRowHeight" );
777 mxImpl->maHeights[ nRow ] = nHeight;
778 mxImpl->mbYCoordsDirty = true;
779 }
780
781 void Array::SetAllColWidths( long nWidth )
782 {
783 std::fill( mxImpl->maWidths.begin(), mxImpl->maWidths.end(), nWidth );
784 mxImpl->mbXCoordsDirty = true;
785 }
786
787 void Array::SetAllRowHeights( long nHeight )
788 {
789 std::fill( mxImpl->maHeights.begin(), mxImpl->maHeights.end(), nHeight );
790 mxImpl->mbYCoordsDirty = true;
791 }
792
793 long Array::GetColPosition( size_t nCol ) const
794 {
795 DBG_FRAME_CHECK_COL_1( nCol, "GetColPosition" );
796 return mxImpl->GetColPosition( nCol );
797 }
798
799 long Array::GetRowPosition( size_t nRow ) const
800 {
801 DBG_FRAME_CHECK_ROW_1( nRow, "GetRowPosition" );
802 return mxImpl->GetRowPosition( nRow );
803 }
804
805 long Array::GetColWidth( size_t nFirstCol, size_t nLastCol ) const
806 {
807 DBG_FRAME_CHECK_COL( nFirstCol, "GetColWidth" );
808 DBG_FRAME_CHECK_COL( nLastCol, "GetColWidth" );
809 return GetColPosition( nLastCol + 1 ) - GetColPosition( nFirstCol );
810 }
811
812 long Array::GetRowHeight( size_t nFirstRow, size_t nLastRow ) const
813 {
814 DBG_FRAME_CHECK_ROW( nFirstRow, "GetRowHeight" );
815 DBG_FRAME_CHECK_ROW( nLastRow, "GetRowHeight" );
816 return GetRowPosition( nLastRow + 1 ) - GetRowPosition( nFirstRow );
817 }
818
819 long Array::GetWidth() const
820 {
821 return GetColPosition( mxImpl->mnWidth ) - GetColPosition( 0 );
822 }
823
824 long Array::GetHeight() const
825 {
826 return GetRowPosition( mxImpl->mnHeight ) - GetRowPosition( 0 );
827 }
828
829 Point Array::GetCellPosition( size_t nCol, size_t nRow, bool bSimple ) const
830 {
831 size_t nFirstCol = bSimple ? nCol : mxImpl->GetMergedFirstCol( nCol, nRow );
832 size_t nFirstRow = bSimple ? nRow : mxImpl->GetMergedFirstRow( nCol, nRow );
833 return Point( GetColPosition( nFirstCol ), GetRowPosition( nFirstRow ) );
834 }
835
836 Size Array::GetCellSize( size_t nCol, size_t nRow, bool bSimple ) const
837 {
838 size_t nFirstCol = bSimple ? nCol : mxImpl->GetMergedFirstCol( nCol, nRow );
839 size_t nFirstRow = bSimple ? nRow : mxImpl->GetMergedFirstRow( nCol, nRow );
840 size_t nLastCol = bSimple ? nCol : mxImpl->GetMergedLastCol( nCol, nRow );
841 size_t nLastRow = bSimple ? nRow : mxImpl->GetMergedLastRow( nCol, nRow );
842 return Size( GetColWidth( nFirstCol, nLastCol ) + 1, GetRowHeight( nFirstRow, nLastRow ) + 1 );
843 }
844
845 Rectangle Array::GetCellRect( size_t nCol, size_t nRow, bool bSimple ) const
846 {
847 Rectangle aRect( GetCellPosition( nCol, nRow, bSimple ), GetCellSize( nCol, nRow, bSimple ) );
848
849 // adjust rectangle for partly visible merged cells
850 const Cell& rCell = CELL( nCol, nRow );
851 if( !bSimple && rCell.IsMerged() )
852 {
853 aRect.Left() -= rCell.mnAddLeft;
854 aRect.Right() += rCell.mnAddRight;
855 aRect.Top() -= rCell.mnAddTop;
856 aRect.Bottom() += rCell.mnAddBottom;
857 }
858 return aRect;
859 }
860
861 // diagonal frame borders
862 double Array::GetHorDiagAngle( size_t nCol, size_t nRow, bool bSimple ) const
863 {
864 DBG_FRAME_CHECK_COLROW( nCol, nRow, "GetHorDiagAngle" );
865 return mxImpl->GetHorDiagAngle( nCol, nRow, bSimple );
866 }
867
868 double Array::GetVerDiagAngle( size_t nCol, size_t nRow, bool bSimple ) const
869 {
870 DBG_FRAME_CHECK_COLROW( nCol, nRow, "GetVerDiagAngle" );
871 return mxImpl->GetVerDiagAngle( nCol, nRow, bSimple );
872 }
873
874 void Array::SetUseDiagDoubleClipping( bool bSet )
875 {
876 mxImpl->mbDiagDblClip = bSet;
877 }
878
879 // mirroring
880 void Array::MirrorSelfX( bool bMirrorStyles, bool bSwapDiag )
881 {
882 CellVec aNewCells;
883 aNewCells.reserve( GetCellCount() );
884
885 size_t nCol, nRow;
886 for( nRow = 0; nRow < mxImpl->mnHeight; ++nRow )
887 {
888 for( nCol = 0; nCol < mxImpl->mnWidth; ++nCol )
889 {
890 aNewCells.push_back( CELL( mxImpl->GetMirrorCol( nCol ), nRow ) );
891 aNewCells.back().MirrorSelfX( bMirrorStyles, bSwapDiag );
892 }
893 }
894 for( nRow = 0; nRow < mxImpl->mnHeight; ++nRow )
895 {
896 for( nCol = 0; nCol < mxImpl->mnWidth; ++nCol )
897 {
898 if( CELL( nCol, nRow ).mbMergeOrig )
899 {
900 size_t nLastCol = mxImpl->GetMergedLastCol( nCol, nRow );
901 size_t nLastRow = mxImpl->GetMergedLastRow( nCol, nRow );
902 lclSetMergedRange( aNewCells, mxImpl->mnWidth,
903 mxImpl->GetMirrorCol( nLastCol ), nRow,
904 mxImpl->GetMirrorCol( nCol ), nLastRow );
905 }
906 }
907 }
908 mxImpl->maCells.swap( aNewCells );
909
910 std::reverse( mxImpl->maWidths.begin(), mxImpl->maWidths.end() );
911 mxImpl->mbXCoordsDirty = true;
912 }
913
914 // drawing
915 void Array::DrawRange( drawinglayer::processor2d::BaseProcessor2D* pProcessor,
916 size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow,
917 const Color* pForceColor ) const
918 {
919 DBG_FRAME_CHECK_COLROW( nFirstCol, nFirstRow, "DrawRange" );
920 DBG_FRAME_CHECK_COLROW( nLastCol, nLastRow, "DrawRange" );
921
922 size_t nCol, nRow;
923
924 // *** diagonal frame borders ***
925 for( nRow = nFirstRow; nRow <= nLastRow; ++nRow )
926 {
927 for( nCol = nFirstCol; nCol <= nLastCol; ++nCol )
928 {
929 const Cell& rCell = CELL( nCol, nRow );
930 bool bOverlapX = rCell.mbOverlapX;
931 bool bOverlapY = rCell.mbOverlapY;
932 bool bFirstCol = nCol == nFirstCol;
933 bool bFirstRow = nRow == nFirstRow;
934 if( (!bOverlapX && !bOverlapY) || (bFirstCol && bFirstRow) ||
935 (!bOverlapY && bFirstCol) || (!bOverlapX && bFirstRow) )
936 {
937 Rectangle aRect( GetCellRect( nCol, nRow ) );
938 if( (aRect.GetWidth() > 1) && (aRect.GetHeight() > 1) )
939 {
940 size_t _nFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow );
941 size_t _nFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow );
942
943 const Style aTlbrStyle = GetCellStyleTLBR( _nFirstCol, _nFirstRow, true );
944 if ( aTlbrStyle.GetWidth( ) )
945 pProcessor->process( CreateClippedBorderPrimitives(
946 aRect.TopLeft(), aRect.BottomRight(),
947 aTlbrStyle, aRect ) );
948
949 const Style aBltrStyle = GetCellStyleBLTR( _nFirstCol, _nFirstRow, true );
950 if ( aBltrStyle.GetWidth( ) )
951 pProcessor->process( CreateClippedBorderPrimitives(
952 aRect.BottomLeft(), aRect.TopRight(),
953 aBltrStyle, aRect ) );
954 }
955 }
956 }
957 }
958
959 // *** horizontal frame borders ***
960
961 for( nRow = nFirstRow; nRow <= nLastRow + 1; ++nRow )
962 {
963 double fAngle = mxImpl->GetHorDiagAngle( nFirstCol, nRow );
964 double fTAngle = mxImpl->GetHorDiagAngle( nFirstCol, nRow - 1 );
965
966 // *Start*** variables store the data of the left end of the cached frame border
967 Point aStartPos( mxImpl->GetColPosition( nFirstCol ), mxImpl->GetRowPosition( nRow ) );
968 const Style* pStart = &GetCellStyleTop( nFirstCol, nRow );
969 DiagStyle aStartLFromTR( GetCellStyleBL( nFirstCol, nRow - 1 ), fTAngle );
970 const Style* pStartLFromT = &GetCellStyleLeft( nFirstCol, nRow - 1 );
971 const Style* pStartLFromL = &GetCellStyleTop( nFirstCol - 1, nRow );
972 const Style* pStartLFromB = &GetCellStyleLeft( nFirstCol, nRow );
973 DiagStyle aStartLFromBR( GetCellStyleTL( nFirstCol, nRow ), fAngle );
974
975 // *End*** variables store the data of the right end of the cached frame border
976 DiagStyle aEndRFromTL( GetCellStyleBR( nFirstCol, nRow - 1 ), fTAngle );
977 const Style* pEndRFromT = &GetCellStyleRight( nFirstCol, nRow - 1 );
978 const Style* pEndRFromR = &GetCellStyleTop( nFirstCol + 1, nRow );
979 const Style* pEndRFromB = &GetCellStyleRight( nFirstCol, nRow );
980 DiagStyle aEndRFromBL( GetCellStyleTR( nFirstCol, nRow ), fAngle );
981
982 for( nCol = nFirstCol + 1; nCol <= nLastCol; ++nCol )
983 {
984 fAngle = mxImpl->GetHorDiagAngle( nCol, nRow );
985 fTAngle = mxImpl->GetHorDiagAngle( nCol, nRow - 1 );
986
987 const Style& rCurr = *pEndRFromR;
988
989 DiagStyle aLFromTR( GetCellStyleBL( nCol, nRow - 1 ), fTAngle );
990 const Style& rLFromT = *pEndRFromT;
991 const Style& rLFromL = *pStart;
992 const Style& rLFromB = *pEndRFromB;
993 DiagStyle aLFromBR( GetCellStyleTL( nCol, nRow ), fAngle );
994
995 DiagStyle aRFromTL( GetCellStyleBR( nCol, nRow - 1 ), fTAngle );
996 const Style& rRFromT = GetCellStyleRight( nCol, nRow - 1 );
997 const Style& rRFromR = GetCellStyleTop( nCol + 1, nRow );
998 const Style& rRFromB = GetCellStyleRight( nCol, nRow );
999 DiagStyle aRFromBL( GetCellStyleTR( nCol, nRow ), fAngle );
1000
1001 // check if current frame border can be connected to cached frame border
1002 if( !CheckFrameBorderConnectable( *pStart, rCurr,
1003 aEndRFromTL, rLFromT, aLFromTR, aEndRFromBL, rLFromB, aLFromBR ) )
1004 {
1005 // draw previous frame border
1006 Point aEndPos( mxImpl->GetColPosition( nCol ), aStartPos.Y() );
1007 if( pStart->Prim() && (aStartPos.X() <= aEndPos.X()) )
1008 pProcessor->process( CreateBorderPrimitives( aStartPos, aEndPos, *pStart,
1009 aStartLFromTR, *pStartLFromT, *pStartLFromL, *pStartLFromB, aStartLFromBR,
1010 aEndRFromTL, *pEndRFromT, *pEndRFromR, *pEndRFromB, aEndRFromBL, pForceColor ) );
1011
1012 // re-init "*Start***" variables
1013 aStartPos = aEndPos;
1014 pStart = &rCurr;
1015 aStartLFromTR = aLFromTR;
1016 pStartLFromT = &rLFromT;
1017 pStartLFromL = &rLFromL;
1018 pStartLFromB = &rLFromB;
1019 aStartLFromBR = aLFromBR;
1020 }
1021
1022 // store current styles in "*End***" variables
1023 aEndRFromTL = aRFromTL;
1024 pEndRFromT = &rRFromT;
1025 pEndRFromR = &rRFromR;
1026 pEndRFromB = &rRFromB;
1027 aEndRFromBL = aRFromBL;
1028 }
1029
1030 // draw last frame border
1031 Point aEndPos( mxImpl->GetColPosition( nCol ), aStartPos.Y() );
1032 if( pStart->Prim() && (aStartPos.X() <= aEndPos.X()) )
1033 pProcessor->process( CreateBorderPrimitives( aStartPos, aEndPos, *pStart,
1034 aStartLFromTR, *pStartLFromT, *pStartLFromL, *pStartLFromB, aStartLFromBR,
1035 aEndRFromTL, *pEndRFromT, *pEndRFromR, *pEndRFromB, aEndRFromBL, pForceColor ) );
1036 }
1037
1038 // *** vertical frame borders ***
1039 for( nCol = nFirstCol; nCol <= nLastCol + 1; ++nCol )
1040 {
1041 double fAngle = mxImpl->GetVerDiagAngle( nCol, nFirstRow );
1042 double fLAngle = mxImpl->GetVerDiagAngle( nCol - 1, nFirstRow );
1043
1044 // *Start*** variables store the data of the top end of the cached frame border
1045 Point aStartPos( mxImpl->GetColPosition( nCol ), mxImpl->GetRowPosition( nFirstRow ) );
1046 const Style* pStart = &GetCellStyleLeft( nCol, nFirstRow );
1047 DiagStyle aStartTFromBL( GetCellStyleTR( nCol - 1, nFirstRow ), fLAngle );
1048 const Style* pStartTFromL = &GetCellStyleTop( nCol - 1, nFirstRow );
1049 const Style* pStartTFromT = &GetCellStyleLeft( nCol, nFirstRow - 1 );
1050 const Style* pStartTFromR = &GetCellStyleTop( nCol, nFirstRow );
1051 DiagStyle aStartTFromBR( GetCellStyleTL( nCol, nFirstRow ), fAngle );
1052
1053 // *End*** variables store the data of the bottom end of the cached frame border
1054 DiagStyle aEndBFromTL( GetCellStyleBR( nCol - 1, nFirstRow ), fLAngle );
1055 const Style* pEndBFromL = &GetCellStyleBottom( nCol - 1, nFirstRow );
1056 const Style* pEndBFromB = &GetCellStyleLeft( nCol, nFirstRow + 1 );
1057 const Style* pEndBFromR = &GetCellStyleBottom( nCol, nFirstRow );
1058 DiagStyle aEndBFromTR( GetCellStyleBL( nCol, nFirstRow ), fAngle );
1059
1060 for( nRow = nFirstRow + 1; nRow <= nLastRow; ++nRow )
1061 {
1062 fAngle = mxImpl->GetVerDiagAngle( nCol, nRow );
1063 fLAngle = mxImpl->GetVerDiagAngle( nCol - 1, nRow );
1064
1065 const Style& rCurr = *pEndBFromB;
1066
1067 DiagStyle aTFromBL( GetCellStyleTR( nCol - 1, nRow ), fLAngle );
1068 const Style& rTFromL = *pEndBFromL;
1069 const Style& rTFromT = *pStart;
1070 const Style& rTFromR = *pEndBFromR;
1071 DiagStyle aTFromBR( GetCellStyleTL( nCol, nRow ), fAngle );
1072
1073 DiagStyle aBFromTL( GetCellStyleBR( nCol - 1, nRow ), fLAngle );
1074 const Style& rBFromL = GetCellStyleBottom( nCol - 1, nRow );
1075 const Style& rBFromB = GetCellStyleLeft( nCol, nRow + 1 );
1076 const Style& rBFromR = GetCellStyleBottom( nCol, nRow );
1077 DiagStyle aBFromTR( GetCellStyleBL( nCol, nRow ), fAngle );
1078
1079 // check if current frame border can be connected to cached frame border
1080 if( !CheckFrameBorderConnectable( *pStart, rCurr,
1081 aEndBFromTL, rTFromL, aTFromBL, aEndBFromTR, rTFromR, aTFromBR ) )
1082 {
1083 // draw previous frame border
1084 Point aEndPos( aStartPos.X(), mxImpl->GetRowPosition( nRow ) );
1085 if( pStart->Prim() && (aStartPos.Y() <= aEndPos.Y()) )
1086 pProcessor->process( CreateBorderPrimitives( aEndPos, aStartPos, *pStart,
1087 aEndBFromTL, *pEndBFromL, *pEndBFromB, *pEndBFromR, aEndBFromTR,
1088 aStartTFromBL, *pStartTFromL, *pStartTFromT, *pStartTFromR, aStartTFromBR, pForceColor ) );
1089
1090 // re-init "*Start***" variables
1091 aStartPos = aEndPos;
1092 pStart = &rCurr;
1093 aStartTFromBL = aTFromBL;
1094 pStartTFromL = &rTFromL;
1095 pStartTFromT = &rTFromT;
1096 pStartTFromR = &rTFromR;
1097 aStartTFromBR = aTFromBR;
1098 }
1099
1100 // store current styles in "*End***" variables
1101 aEndBFromTL = aBFromTL;
1102 pEndBFromL = &rBFromL;
1103 pEndBFromB = &rBFromB;
1104 pEndBFromR = &rBFromR;
1105 aEndBFromTR = aBFromTR;
1106 }
1107
1108 // draw last frame border
1109 Point aEndPos( aStartPos.X(), mxImpl->GetRowPosition( nRow ) );
1110 if( pStart->Prim() && (aStartPos.Y() <= aEndPos.Y()) )
1111 pProcessor->process( CreateBorderPrimitives( aEndPos, aStartPos, *pStart,
1112 aEndBFromTL, *pEndBFromL, *pEndBFromB, *pEndBFromR, aEndBFromTR,
1113 aStartTFromBL, *pStartTFromL, *pStartTFromT, *pStartTFromR, aStartTFromBR, pForceColor ) );
1114 }
1115 }
1116
1117 void Array::DrawRange( OutputDevice& rDev,
1118 size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow,
1119 const Color* pForceColor ) const
1120 {
1121 DBG_FRAME_CHECK_COLROW( nFirstCol, nFirstRow, "DrawRange" );
1122 DBG_FRAME_CHECK_COLROW( nLastCol, nLastRow, "DrawRange" );
1123
1124 size_t nCol, nRow;
1125
1126 // *** diagonal frame borders ***
1127
1128 // set clipping region to clip partly visible merged cells
1129 rDev.Push( PushFlags::CLIPREGION );
1130 rDev.IntersectClipRegion( GetClipRangeRectangle() );
1131 for( nRow = nFirstRow; nRow <= nLastRow; ++nRow )
1132 {
1133 for( nCol = nFirstCol; nCol <= nLastCol; ++nCol )
1134 {
1135 const Cell& rCell = CELL( nCol, nRow );
1136 bool bOverlapX = rCell.mbOverlapX;
1137 bool bOverlapY = rCell.mbOverlapY;
1138 bool bFirstCol = nCol == nFirstCol;
1139 bool bFirstRow = nRow == nFirstRow;
1140 if( (!bOverlapX && !bOverlapY) || (bFirstCol && bFirstRow) ||
1141 (!bOverlapY && bFirstCol) || (!bOverlapX && bFirstRow) )
1142 {
1143 Rectangle aRect( GetCellRect( nCol, nRow ) );
1144 if( (aRect.GetWidth() > 1) && (aRect.GetHeight() > 1) )
1145 {
1146 size_t _nFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow );
1147 size_t _nFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow );
1148 size_t _nLastCol = mxImpl->GetMergedLastCol( nCol, nRow );
1149 size_t _nLastRow = mxImpl->GetMergedLastRow( nCol, nRow );
1150
1151 DrawDiagFrameBorders( rDev, aRect,
1152 GetCellStyleTLBR( _nFirstCol, _nFirstRow, true ), GetCellStyleBLTR( _nFirstCol, _nFirstRow, true ),
1153 GetCellStyleLeft( _nFirstCol, _nFirstRow ), GetCellStyleTop( _nFirstCol, _nFirstRow ),
1154 GetCellStyleRight( _nLastCol, _nLastRow ), GetCellStyleBottom( _nLastCol, _nLastRow ),
1155 GetCellStyleLeft( _nFirstCol, _nLastRow ), GetCellStyleBottom( _nFirstCol, _nLastRow ),
1156 GetCellStyleRight( _nLastCol, _nFirstRow ), GetCellStyleTop( _nLastCol, _nFirstRow ),
1157 pForceColor, mxImpl->mbDiagDblClip );
1158 }
1159 }
1160 }
1161 }
1162 rDev.Pop(); // clip region
1163
1164 // *** horizontal frame borders ***
1165
1166 for( nRow = nFirstRow; nRow <= nLastRow + 1; ++nRow )
1167 {
1168 double fAngle = mxImpl->GetHorDiagAngle( nFirstCol, nRow );
1169 double fTAngle = mxImpl->GetHorDiagAngle( nFirstCol, nRow - 1 );
1170
1171 // *Start*** variables store the data of the left end of the cached frame border
1172 Point aStartPos( mxImpl->GetColPosition( nFirstCol ), mxImpl->GetRowPosition( nRow ) );
1173 const Style* pStart = &GetCellStyleTop( nFirstCol, nRow );
1174 DiagStyle aStartLFromTR( GetCellStyleBL( nFirstCol, nRow - 1 ), fTAngle );
1175 const Style* pStartLFromT = &GetCellStyleLeft( nFirstCol, nRow - 1 );
1176 const Style* pStartLFromL = &GetCellStyleTop( nFirstCol - 1, nRow );
1177 const Style* pStartLFromB = &GetCellStyleLeft( nFirstCol, nRow );
1178 DiagStyle aStartLFromBR( GetCellStyleTL( nFirstCol, nRow ), fAngle );
1179
1180 // *End*** variables store the data of the right end of the cached frame border
1181 DiagStyle aEndRFromTL( GetCellStyleBR( nFirstCol, nRow - 1 ), fTAngle );
1182 const Style* pEndRFromT = &GetCellStyleRight( nFirstCol, nRow - 1 );
1183 const Style* pEndRFromR = &GetCellStyleTop( nFirstCol + 1, nRow );
1184 const Style* pEndRFromB = &GetCellStyleRight( nFirstCol, nRow );
1185 DiagStyle aEndRFromBL( GetCellStyleTR( nFirstCol, nRow ), fAngle );
1186
1187 for( nCol = nFirstCol + 1; nCol <= nLastCol; ++nCol )
1188 {
1189 fAngle = mxImpl->GetHorDiagAngle( nCol, nRow );
1190 fTAngle = mxImpl->GetHorDiagAngle( nCol, nRow - 1 );
1191
1192 const Style& rCurr = *pEndRFromR;
1193
1194 DiagStyle aLFromTR( GetCellStyleBL( nCol, nRow - 1 ), fTAngle );
1195 const Style& rLFromT = *pEndRFromT;
1196 const Style& rLFromL = *pStart;
1197 const Style& rLFromB = *pEndRFromB;
1198 DiagStyle aLFromBR( GetCellStyleTL( nCol, nRow ), fAngle );
1199
1200 DiagStyle aRFromTL( GetCellStyleBR( nCol, nRow - 1 ), fTAngle );
1201 const Style& rRFromT = GetCellStyleRight( nCol, nRow - 1 );
1202 const Style& rRFromR = GetCellStyleTop( nCol + 1, nRow );
1203 const Style& rRFromB = GetCellStyleRight( nCol, nRow );
1204 DiagStyle aRFromBL( GetCellStyleTR( nCol, nRow ), fAngle );
1205
1206 // check if current frame border can be connected to cached frame border
1207 if( !CheckFrameBorderConnectable( *pStart, rCurr,
1208 aEndRFromTL, rLFromT, aLFromTR, aEndRFromBL, rLFromB, aLFromBR ) )
1209 {
1210 // draw previous frame border
1211 Point aEndPos( mxImpl->GetColPosition( nCol ), aStartPos.Y() );
1212 if( pStart->Prim() && (aStartPos.X() <= aEndPos.X()) )
1213 DrawHorFrameBorder( rDev, aStartPos, aEndPos, *pStart,
1214 aStartLFromTR, *pStartLFromT, *pStartLFromL, *pStartLFromB, aStartLFromBR,
1215 aEndRFromTL, *pEndRFromT, *pEndRFromR, *pEndRFromB, aEndRFromBL, pForceColor );
1216
1217 // re-init "*Start***" variables
1218 aStartPos = aEndPos;
1219 pStart = &rCurr;
1220 aStartLFromTR = aLFromTR;
1221 pStartLFromT = &rLFromT;
1222 pStartLFromL = &rLFromL;
1223 pStartLFromB = &rLFromB;
1224 aStartLFromBR = aLFromBR;
1225 }
1226
1227 // store current styles in "*End***" variables
1228 aEndRFromTL = aRFromTL;
1229 pEndRFromT = &rRFromT;
1230 pEndRFromR = &rRFromR;
1231 pEndRFromB = &rRFromB;
1232 aEndRFromBL = aRFromBL;
1233 }
1234
1235 // draw last frame border
1236 Point aEndPos( mxImpl->GetColPosition( nCol ), aStartPos.Y() );
1237 if( pStart->Prim() && (aStartPos.X() <= aEndPos.X()) )
1238 DrawHorFrameBorder( rDev, aStartPos, aEndPos, *pStart,
1239 aStartLFromTR, *pStartLFromT, *pStartLFromL, *pStartLFromB, aStartLFromBR,
1240 aEndRFromTL, *pEndRFromT, *pEndRFromR, *pEndRFromB, aEndRFromBL, pForceColor );
1241 }
1242
1243 // *** vertical frame borders ***
1244
1245 for( nCol = nFirstCol; nCol <= nLastCol + 1; ++nCol )
1246 {
1247 double fAngle = mxImpl->GetVerDiagAngle( nCol, nFirstRow );
1248 double fLAngle = mxImpl->GetVerDiagAngle( nCol - 1, nFirstRow );
1249
1250 // *Start*** variables store the data of the top end of the cached frame border
1251 Point aStartPos( mxImpl->GetColPosition( nCol ), mxImpl->GetRowPosition( nFirstRow ) );
1252 const Style* pStart = &GetCellStyleLeft( nCol, nFirstRow );
1253 DiagStyle aStartTFromBL( GetCellStyleTR( nCol - 1, nFirstRow ), fLAngle );
1254 const Style* pStartTFromL = &GetCellStyleTop( nCol - 1, nFirstRow );
1255 const Style* pStartTFromT = &GetCellStyleLeft( nCol, nFirstRow - 1 );
1256 const Style* pStartTFromR = &GetCellStyleTop( nCol, nFirstRow );
1257 DiagStyle aStartTFromBR( GetCellStyleTL( nCol, nFirstRow ), fAngle );
1258
1259 // *End*** variables store the data of the bottom end of the cached frame border
1260 DiagStyle aEndBFromTL( GetCellStyleBR( nCol - 1, nFirstRow ), fLAngle );
1261 const Style* pEndBFromL = &GetCellStyleBottom( nCol - 1, nFirstRow );
1262 const Style* pEndBFromB = &GetCellStyleLeft( nCol, nFirstRow + 1 );
1263 const Style* pEndBFromR = &GetCellStyleBottom( nCol, nFirstRow );
1264 DiagStyle aEndBFromTR( GetCellStyleBL( nCol, nFirstRow ), fAngle );
1265
1266 for( nRow = nFirstRow + 1; nRow <= nLastRow; ++nRow )
1267 {
1268 fAngle = mxImpl->GetVerDiagAngle( nCol, nRow );
1269 fLAngle = mxImpl->GetVerDiagAngle( nCol - 1, nRow );
1270
1271 const Style& rCurr = *pEndBFromB;
1272
1273 DiagStyle aTFromBL( GetCellStyleTR( nCol - 1, nRow ), fLAngle );
1274 const Style& rTFromL = *pEndBFromL;
1275 const Style& rTFromT = *pStart;
1276 const Style& rTFromR = *pEndBFromR;
1277 DiagStyle aTFromBR( GetCellStyleTL( nCol, nRow ), fAngle );
1278
1279 DiagStyle aBFromTL( GetCellStyleBR( nCol - 1, nRow ), fLAngle );
1280 const Style& rBFromL = GetCellStyleBottom( nCol - 1, nRow );
1281 const Style& rBFromB = GetCellStyleLeft( nCol, nRow + 1 );
1282 const Style& rBFromR = GetCellStyleBottom( nCol, nRow );
1283 DiagStyle aBFromTR( GetCellStyleBL( nCol, nRow ), fAngle );
1284
1285 // check if current frame border can be connected to cached frame border
1286 if( !CheckFrameBorderConnectable( *pStart, rCurr,
1287 aEndBFromTL, rTFromL, aTFromBL, aEndBFromTR, rTFromR, aTFromBR ) )
1288 {
1289 // draw previous frame border
1290 Point aEndPos( aStartPos.X(), mxImpl->GetRowPosition( nRow ) );
1291 if( pStart->Prim() && (aStartPos.Y() <= aEndPos.Y()) )
1292 DrawVerFrameBorder( rDev, aStartPos, aEndPos, *pStart,
1293 aStartTFromBL, *pStartTFromL, *pStartTFromT, *pStartTFromR, aStartTFromBR,
1294 aEndBFromTL, *pEndBFromL, *pEndBFromB, *pEndBFromR, aEndBFromTR, pForceColor );
1295
1296 // re-init "*Start***" variables
1297 aStartPos = aEndPos;
1298 pStart = &rCurr;
1299 aStartTFromBL = aTFromBL;
1300 pStartTFromL = &rTFromL;
1301 pStartTFromT = &rTFromT;
1302 pStartTFromR = &rTFromR;
1303 aStartTFromBR = aTFromBR;
1304 }
1305
1306 // store current styles in "*End***" variables
1307 aEndBFromTL = aBFromTL;
1308 pEndBFromL = &rBFromL;
1309 pEndBFromB = &rBFromB;
1310 pEndBFromR = &rBFromR;
1311 aEndBFromTR = aBFromTR;
1312 }
1313
1314 // draw last frame border
1315 Point aEndPos( aStartPos.X(), mxImpl->GetRowPosition( nRow ) );
1316 if( pStart->Prim() && (aStartPos.Y() <= aEndPos.Y()) )
1317 DrawVerFrameBorder( rDev, aStartPos, aEndPos, *pStart,
1318 aStartTFromBL, *pStartTFromL, *pStartTFromT, *pStartTFromR, aStartTFromBR,
1319 aEndBFromTL, *pEndBFromL, *pEndBFromB, *pEndBFromR, aEndBFromTR, pForceColor );
1320 }
1321 }
1322
1323 void Array::DrawArray( OutputDevice& rDev, const Color* pForceColor ) const
1324 {
1325 if( mxImpl->mnWidth && mxImpl->mnHeight )
1326 DrawRange( rDev, 0, 0, mxImpl->mnWidth - 1, mxImpl->mnHeight - 1, pForceColor );
1327 }
1328
1329
1330
1331 #undef ORIGCELL
1332 #undef CELLACC
1333 #undef CELL
1334
1335
1336
1337 #undef DBG_FRAME_CHECK_ROW_1
1338 #undef DBG_FRAME_CHECK_COL_1
1339 #undef DBG_FRAME_CHECK_COLROW
1340 #undef DBG_FRAME_CHECK_ROW
1341 #undef DBG_FRAME_CHECK_COL
1342 #undef DBG_FRAME_CHECK
1343
1344
1345
1346 }
1347 }
1348
1349 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE