1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#ifndef INCLUDED_SW_INC_TBLSEL_HXX
#define INCLUDED_SW_INC_TBLSEL_HXX
#include "swtable.hxx"
#include "swrect.hxx"
#include "swdllapi.h"
#include <o3tl/sorted_vector.hxx>
#include <memory>
#include <deque>
#include <vector>
class SwCursorShell;
class SwCursor;
class SwTableCursor;
class SwFrame;
class SwTabFrame;
class SwLayoutFrame;
class SwPaM;
class SwNode;
class SwUndoTableMerge;
class SwCellFrame;
typedef std::deque< SwCellFrame* > SwCellFrames;
struct CompareSwSelBoxes
{
bool operator()(SwTableBox* const& lhs, SwTableBox* const& rhs) const
{
return lhs->GetSttIdx() < rhs->GetSttIdx();
}
};
class SwSelBoxes : public o3tl::sorted_vector<SwTableBox*, CompareSwSelBoxes> {};
// Collects all boxes in table that are selected.
// Selection gets extended in given direction according to enum-parameter.
// Boxes are collected via the Layout; works correctly if tables are split.
// (Cf. MakeSelUnions().)
enum class SwTableSearchType : sal_uInt16
{
NONE = 0x01, // No extension.
Row = 0x02, // Extend to rows.
Col = 0x03, // Extend to columns.
// As flags to the other values!
Protect = 0x08, // Collect protected boxes too.
NoUnionCorrect = 0x10, // Do not correct collected Union.
};
namespace o3tl {
template<> struct typed_flags<SwTableSearchType> : is_typed_flags<SwTableSearchType, 0x1b> {};
}
SW_DLLPUBLIC void GetTableSel( const SwCursorShell& rShell, SwSelBoxes& rBoxes,
const SwTableSearchType = SwTableSearchType::NONE );
void GetTableSel( const SwCursor& rCursor, SwSelBoxes& rBoxes,
const SwTableSearchType = SwTableSearchType::NONE );
// As before, but don't start from selection but from Start- EndFrames.
void GetTableSel( const SwLayoutFrame* pStart, const SwLayoutFrame* pEnd,
SwSelBoxes& rBoxes, SwCellFrames* pCells,
const SwTableSearchType = SwTableSearchType::NONE );
// As before but directly via PaMs.
void GetTableSelCrs( const SwCursorShell& rShell, SwSelBoxes& rBoxes );
void GetTableSelCrs( const SwTableCursor& rTableCursor, SwSelBoxes& rBoxes );
// Collect boxes relevant for auto sum.
bool GetAutoSumSel( const SwCursorShell&, SwCellFrames& );
// Check if the SelBoxes contains protected Boxes.
bool HasProtectedCells( const SwSelBoxes& rBoxes );
// Check if selection is balanced.
bool ChkChartSel( const SwNode& rSttNd, const SwNode& rEndNd);
// Check if cell is part of SSelection.
// (Became a function, in order to make sure that GetTableSel() and MakeTableCursor()
// have always the same concept of the selection.
bool IsFrameInTableSel( const SwRect& rUnion, const SwFrame* pCell );
// Determine boxes to be merged.
// In this process the rectangle gets "adapted" on the base of the layout,
// i.e. boxes are added if some overlap at the sides.
// Additionally a new box is created and filled with the relevant content.
void GetMergeSel( const SwPaM& rPam, SwSelBoxes& rBoxes,
SwTableBox** ppMergeBox, SwUndoTableMerge* pUndo );
// Check if selected boxes allow for a valid merge.
TableMergeErr CheckMergeSel( const SwPaM& rPam );
TableMergeErr CheckMergeSel( const SwSelBoxes& rBoxes );
bool IsEmptyBox( const SwTableBox& rBox, SwPaM& rPam );
// Check if Split or InsertCol lead to a box becoming smaller than MINLAY.
bool CheckSplitCells( const SwCursorShell& rShell, sal_uInt16 nDiv,
const SwTableSearchType );
bool CheckSplitCells( const SwCursor& rCursor, sal_uInt16 nDiv,
const SwTableSearchType );
// For working on tab selection also for split tables.
class SwSelUnion
{
SwRect m_aUnion; // The rectangle enclosing the selection.
SwTabFrame *m_pTable; // The (Follow-)Table for the Union.
public:
SwSelUnion( const SwRect &rRect, SwTabFrame *pTab ) :
m_aUnion( rRect ), m_pTable( pTab ) {}
const SwRect& GetUnion() const { return m_aUnion; }
SwRect& GetUnion() { return m_aUnion; }
const SwTabFrame *GetTable() const { return m_pTable; }
SwTabFrame *GetTable() { return m_pTable; }
};
// Determines tables affected by a table selection and union rectangles
// of the selection (also for split tables)
typedef std::vector<SwSelUnion> SwSelUnions;
// Gets the tables involved in a table selection and the union-rectangles of the selections
// - also for split tables.
// If a parameter is passed that != SwTableSearchType::NONE
// the selection is extended in the given direction.
void MakeSelUnions( SwSelUnions&, const SwLayoutFrame *pStart,
const SwLayoutFrame *pEnd,
const SwTableSearchType = SwTableSearchType::NONE );
// These classes copy the current table selections (rBoxes) into a
// separate structure while keeping the table structure.
class FndBox_;
class FndLine_;
typedef std::vector<std::unique_ptr<FndBox_>> FndBoxes_t;
typedef std::vector<std::unique_ptr<FndLine_>> FndLines_t;
class FndBox_
{
SwTableBox* m_pBox;
FndLines_t m_Lines;
FndLine_* m_pUpper;
SwTableLine *m_pLineBefore; ///< For deleting/restoring the layout.
SwTableLine *m_pLineBehind; ///< For deleting/restoring the layout.
FndBox_(FndBox_ const&) = delete;
FndBox_& operator=(FndBox_ const&) = delete;
public:
inline FndBox_( SwTableBox* pB, FndLine_* pFL );
const FndLines_t& GetLines() const { return m_Lines; }
FndLines_t& GetLines() { return m_Lines; }
const SwTableBox* GetBox() const { return m_pBox; }
SwTableBox* GetBox() { return m_pBox; }
const FndLine_* GetUpper() const { return m_pUpper; }
FndLine_* GetUpper() { return m_pUpper; }
void SetTableLines( const SwSelBoxes &rBoxes, const SwTable &rTable );
void SetTableLines( const SwTable &rTable );
//Add an input param to identify if acc table should be disposed
void DelFrames ( SwTable &rTable );
void MakeFrames( SwTable &rTable );
void MakeNewFrames( SwTable &rTable, const sal_uInt16 nNumber,
const bool bBehind );
bool AreLinesToRestore( const SwTable &rTable ) const;
void ClearLineBehind() { m_pLineBehind = nullptr; }
};
class FndLine_
{
SwTableLine* m_pLine;
FndBoxes_t m_Boxes;
FndBox_* m_pUpper;
FndLine_(FndLine_ const&) = delete;
FndLine_& operator=(FndLine_ const&) = delete;
public:
FndLine_(SwTableLine* pL, FndBox_* pFB) : m_pLine(pL), m_pUpper(pFB) {}
const FndBoxes_t& GetBoxes() const { return m_Boxes; }
FndBoxes_t& GetBoxes() { return m_Boxes; }
const SwTableLine* GetLine() const { return m_pLine; }
SwTableLine* GetLine() { return m_pLine; }
const FndBox_* GetUpper() const { return m_pUpper; }
FndBox_* GetUpper() { return m_pUpper; }
void SetUpper( FndBox_* pUp ) { m_pUpper = pUp; }
};
FndBox_::FndBox_( SwTableBox* pB, FndLine_* pFL ) :
m_pBox(pB), m_pUpper(pFL), m_pLineBefore( nullptr ), m_pLineBehind( nullptr ) {}
struct FndPara
{
const SwSelBoxes& rBoxes;
FndLine_* pFndLine;
FndBox_* pFndBox;
FndPara( const SwSelBoxes& rBxs, FndBox_* pFB )
: rBoxes(rBxs), pFndLine(nullptr), pFndBox(pFB) {}
FndPara( const FndPara& rPara, FndBox_* pFB )
: rBoxes(rPara.rBoxes), pFndLine(rPara.pFndLine), pFndBox(pFB) {}
FndPara( const FndPara& rPara, FndLine_* pFL )
: rBoxes(rPara.rBoxes), pFndLine(pFL), pFndBox(rPara.pFndBox) {}
};
/** This creates a structure mirroring the SwTable structure that contains all
rows and non-leaf boxes (as pointers to SwTableBox/SwTableLine, not copies),
plus the leaf boxes that are selected by pFndPara->rBoxes
*/
SW_DLLPUBLIC void ForEach_FndLineCopyCol(SwTableLines& rLines, FndPara* pFndPara );
#endif // INCLUDED_SW_INC_TBLSEL_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
