?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tdf#130857 qt weld: Implement QtInstanceWidget::strip_mnemonic
[LibreOffice.git] / sc / source / ui / unoobj / cellsuno.cxx
blob5bacf8a856b8021b11622a1c710ac8c8e3593e32
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 <scitems.hxx>
21 #include <editeng/eeitem.hxx>
22 #include <o3tl/safeint.hxx>
23 #include <svx/svdpool.hxx>
24
25 #include <utility>
26 #include <vcl/svapp.hxx>
27 #include <svx/algitem.hxx>
28 #include <editeng/borderline.hxx>
29 #include <editeng/boxitem.hxx>
30 #include <editeng/editeng.hxx>
31 #include <editeng/flditem.hxx>
32 #include <editeng/editobj.hxx>
33 #include <editeng/unoipset.hxx>
34 #include <editeng/langitem.hxx>
35 #include <sfx2/linkmgr.hxx>
36 #include <svl/numformat.hxx>
37 #include <svl/srchitem.hxx>
38 #include <svl/sharedstringpool.hxx>
39 #include <svx/unomid.hxx>
40 #include <editeng/unoprnms.hxx>
41 #include <editeng/unotext.hxx>
42 #include <svx/svdpage.hxx>
43 #include <sfx2/bindings.hxx>
44 #include <svl/zforlist.hxx>
45 #include <svl/zformat.hxx>
46 #include <cppuhelper/supportsservice.hxx>
47 #include <float.h>
48 #include <cppuhelper/queryinterface.hxx>
49 #include <comphelper/diagnose_ex.hxx>
50 #include <tools/UnitConversion.hxx>
51
52 #include <com/sun/star/awt/XBitmap.hpp>
53 #include <com/sun/star/util/CellProtection.hpp>
54 #include <com/sun/star/table/CellHoriJustify.hpp>
55 #include <com/sun/star/table/CellOrientation.hpp>
56 #include <com/sun/star/table/ShadowFormat.hpp>
57 #include <com/sun/star/table/TableBorder.hpp>
58 #include <com/sun/star/table/TableBorder2.hpp>
59 #include <com/sun/star/sheet/CellFlags.hpp>
60 #include <com/sun/star/sheet/FormulaResult.hpp>
61 #include <com/sun/star/beans/PropertyAttribute.hpp>
62 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
63 #include <com/sun/star/lang/Locale.hpp>
64 #include <com/sun/star/beans/TolerantPropertySetResultType.hpp>
65 #include <com/sun/star/beans/SetPropertyTolerantFailed.hpp>
66 #include <com/sun/star/text/WritingMode2.hpp>
67 #include <com/sun/star/text/textfield/Type.hpp>
68 #include <com/sun/star/sheet/XConditionalFormats.hpp>
69 #include <com/sun/star/sheet/XSolverSettings.hpp>
70
71 #include <autoform.hxx>
72 #include <cellvalue.hxx>
73 #include <cellmergeoption.hxx>
74 #include <cellsuno.hxx>
75 #include <cursuno.hxx>
76 #include <textuno.hxx>
77 #include <editsrc.hxx>
78 #include <notesuno.hxx>
79 #include <fielduno.hxx>
80 #include <docuno.hxx>
81 #include <datauno.hxx>
82 #include <dapiuno.hxx>
83 #include <chartuno.hxx>
84 #include <fmtuno.hxx>
85 #include <miscuno.hxx>
86 #include <convuno.hxx>
87 #include <srchuno.hxx>
88 #include <nameuno.hxx>
89 #include <targuno.hxx>
90 #include <tokenuno.hxx>
91 #include <eventuno.hxx>
92 #include <docsh.hxx>
93 #include <markdata.hxx>
94 #include <patattr.hxx>
95 #include <docpool.hxx>
96 #include <docfunc.hxx>
97 #include <dbdocfun.hxx>
98 #include <olinefun.hxx>
99 #include <hints.hxx>
100 #include <formulacell.hxx>
101 #include <undotab.hxx>
102 #include <undoblk.hxx>
103 #include <stlsheet.hxx>
104 #include <dbdata.hxx>
105 #include <attrib.hxx>
106 #include <chartarr.hxx>
107 #include <chartlis.hxx>
108 #include <drwlayer.hxx>
109 #include <printfun.hxx>
110 #include <prnsave.hxx>
111 #include <tablink.hxx>
112 #include <dociter.hxx>
113 #include <rangeutl.hxx>
114 #include <conditio.hxx>
115 #include <validat.hxx>
116 #include <sc.hrc>
117 #include <cellform.hxx>
118 #include <globstr.hrc>
119 #include <scresid.hxx>
120 #include <unonames.hxx>
121 #include <styleuno.hxx>
122 #include <rangeseq.hxx>
123 #include <unowids.hxx>
124 #include <paramisc.hxx>
125 #include <queryentry.hxx>
126 #include <formula/errorcodes.hxx>
127 #include <unoreflist.hxx>
128 #include <formula/grammar.hxx>
129 #include <editeng/escapementitem.hxx>
130 #include <stringutil.hxx>
131 #include <formulaiter.hxx>
132 #include <tokenarray.hxx>
133 #include <stylehelper.hxx>
134 #include <dputil.hxx>
135 #include <sortparam.hxx>
136 #include <condformatuno.hxx>
137 #include <TablePivotCharts.hxx>
138 #include <table.hxx>
139 #include <refundo.hxx>
140 #include <columnspanset.hxx>
141 #include <CommonProperties.hxx>
142 #include <solveruno.hxx>
143
144 #include <memory>
145
146 using namespace com::sun::star;
147
148 // The names in the maps must be sorted according to strcmp!
149 //! Instead of Which-ID 0 use special IDs and do not compare via names!
150
151 // Left/Right/Top/BottomBorder are mapped directly to the core items,
152 // not collected/applied to the borders of a range -> ATTR_BORDER can be used directly
153
154 static const SfxItemPropertySet* lcl_GetCellsPropertySet()
155 {
156 static const SfxItemPropertyMapEntry aCellsPropertyMap_Impl[] =
157 {
158 { SC_UNONAME_ABSNAME, SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
159 { SC_UNONAME_ASIANVERT,ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
160 CELL_BORDER_PROPERTIES
161 CELL_BACKGROUND_COLOR_PROPERTIES
162 { SC_UNONAME_CELLPRO, ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
163 { SC_UNONAME_CELLSTYL, SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
164 CHAR_COLOR_PROPERTIES
165 { SC_UNONAME_COUTL, ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
166 { SC_UNONAME_CCROSS, ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
167 { SC_UNONAME_CEMPHAS, ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
168 { SC_UNONAME_CFONT, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
169 { SC_UNONAME_CFCHARS, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
170 { SC_UNO_CJK_CFCHARS, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
171 { SC_UNO_CTL_CFCHARS, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
172 { SC_UNONAME_CFFAMIL, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
173 { SC_UNO_CJK_CFFAMIL, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
174 { SC_UNO_CTL_CFFAMIL, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
175 { SC_UNONAME_CFNAME, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
176 { SC_UNO_CJK_CFNAME, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
177 { SC_UNO_CTL_CFNAME, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
178 { SC_UNONAME_CFPITCH, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
179 { SC_UNO_CJK_CFPITCH, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
180 { SC_UNO_CTL_CFPITCH, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
181 { SC_UNONAME_CFSTYLE, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
182 { SC_UNO_CJK_CFSTYLE, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
183 { SC_UNO_CTL_CFSTYLE, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
184 { SC_UNONAME_CHEIGHT, ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
185 { SC_UNO_CJK_CHEIGHT, ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
186 { SC_UNO_CTL_CHEIGHT, ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
187 { SC_UNONAME_CLOCAL, ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
188 { SC_UNO_CJK_CLOCAL, ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
189 { SC_UNO_CTL_CLOCAL, ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
190 { SC_UNONAME_COVER, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
191 { SC_UNONAME_COVRLCOL, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
192 { SC_UNONAME_COVRLHAS, ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
193 { SC_UNONAME_CPOST, ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
194 { SC_UNO_CJK_CPOST, ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
195 { SC_UNO_CTL_CPOST, ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
196 { SC_UNONAME_CRELIEF, ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
197 { SC_UNONAME_CSHADD, ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
198 { SC_UNONAME_CSTRIKE, ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
199 { SC_UNONAME_CUNDER, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
200 { SC_UNONAME_CUNDLCOL, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
201 { SC_UNONAME_CUNDLHAS, ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
202 { SC_UNONAME_CWEIGHT, ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
203 { SC_UNO_CJK_CWEIGHT, ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
204 { SC_UNO_CTL_CWEIGHT, ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
205 { SC_UNONAME_CWORDMOD, ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
206 { SC_UNONAME_CHCOLHDR, SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
207 { SC_UNONAME_CHROWHDR, SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
208 { SC_UNONAME_CONDFMT, SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
209 { SC_UNONAME_CONDLOC, SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
210 { SC_UNONAME_CONDXML, SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
211 { SC_UNONAME_DIAGONAL_BLTR, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
212 { SC_UNONAME_DIAGONAL_BLTR2, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
213 { SC_UNONAME_DIAGONAL_TLBR, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
214 { SC_UNONAME_DIAGONAL_TLBR2, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
215 { SC_UNONAME_CELLHJUS, ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
216 { SC_UNONAME_CELLHJUS_METHOD, ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
217 { SC_UNONAME_CELLTRAN, ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
218 { SC_UNONAME_WRAP, ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
219 { SC_UNONAME_NUMFMT, ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
220 { SC_UNONAME_NUMRULES, SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
221 { SC_UNONAME_CELLORI, ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
222 { SC_UNONAME_PADJUST, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
223 { SC_UNONAME_PBMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
224 { SC_UNONAME_PINDENT, ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
225 { SC_UNONAME_PISCHDIST,ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
226 { SC_UNONAME_PISFORBID,ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
227 { SC_UNONAME_PISHANG, ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
228 { SC_UNONAME_PISHYPHEN,ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
229 { SC_UNONAME_PLASTADJ, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
230 { SC_UNONAME_PLMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
231 { SC_UNONAME_PRMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
232 { SC_UNONAME_PTMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
233 { SC_UNONAME_ROTANG, ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
234 { SC_UNONAME_ROTREF, ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
235 { SC_UNONAME_SHADOW, ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
236 { SC_UNONAME_SHRINK_TO_FIT, ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
237 { SC_UNONAME_TBLBORD, SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
238 { SC_UNONAME_TBLBORD2, SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
239 { SC_UNONAME_USERDEF, ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
240 { SC_UNONAME_VALIDAT, SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
241 { SC_UNONAME_VALILOC, SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
242 { SC_UNONAME_VALIXML, SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
243 { SC_UNONAME_CELLVJUS, ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
244 { SC_UNONAME_CELLVJUS_METHOD, ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
245 { SC_UNONAME_WRITING, ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
246 { SC_UNONAME_HYPERLINK, ATTR_HYPERLINK, cppu::UnoType<OUString>::get(), 0, 0 },
247 { SC_UNONAME_FORMATID, SC_WID_UNO_FORMATID, cppu::UnoType<sal_uInt64>::get(), 0, 0 },
248 };
249 static SfxItemPropertySet aCellsPropertySet( aCellsPropertyMap_Impl );
250 return &aCellsPropertySet;
251 }
252
253 // CellRange contains all entries from Cells, plus its own entries
254 // with Which-ID 0 (those are needed only for getPropertySetInfo).
255
256 static const SfxItemPropertySet* lcl_GetRangePropertySet()
257 {
258 static const SfxItemPropertyMapEntry aRangePropertyMap_Impl[] =
259 {
260 { SC_UNONAME_ABSNAME, SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
261 { SC_UNONAME_ASIANVERT,ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
262 CELL_BORDER_PROPERTIES
263 CELL_BACKGROUND_COLOR_PROPERTIES
264 { SC_UNONAME_CELLPRO, ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
265 { SC_UNONAME_CELLSTYL, SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
266 CHAR_COLOR_PROPERTIES
267 { SC_UNONAME_COUTL, ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
268 { SC_UNONAME_CCROSS, ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
269 { SC_UNONAME_CEMPHAS, ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
270 { SC_UNONAME_CFONT, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
271 { SC_UNONAME_CFCHARS, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
272 { SC_UNO_CJK_CFCHARS, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
273 { SC_UNO_CTL_CFCHARS, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
274 { SC_UNONAME_CFFAMIL, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
275 { SC_UNO_CJK_CFFAMIL, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
276 { SC_UNO_CTL_CFFAMIL, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
277 { SC_UNONAME_CFNAME, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
278 { SC_UNO_CJK_CFNAME, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
279 { SC_UNO_CTL_CFNAME, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
280 { SC_UNONAME_CFPITCH, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
281 { SC_UNO_CJK_CFPITCH, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
282 { SC_UNO_CTL_CFPITCH, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
283 { SC_UNONAME_CFSTYLE, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
284 { SC_UNO_CJK_CFSTYLE, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
285 { SC_UNO_CTL_CFSTYLE, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
286 { SC_UNONAME_CHEIGHT, ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
287 { SC_UNO_CJK_CHEIGHT, ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
288 { SC_UNO_CTL_CHEIGHT, ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
289 { SC_UNONAME_CLOCAL, ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
290 { SC_UNO_CJK_CLOCAL, ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
291 { SC_UNO_CTL_CLOCAL, ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
292 { SC_UNONAME_COVER, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
293 { SC_UNONAME_COVRLCOL, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
294 { SC_UNONAME_COVRLHAS, ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
295 { SC_UNONAME_CPOST, ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
296 { SC_UNO_CJK_CPOST, ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
297 { SC_UNO_CTL_CPOST, ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
298 { SC_UNONAME_CRELIEF, ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
299 { SC_UNONAME_CSHADD, ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
300 { SC_UNONAME_CSTRIKE, ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
301 { SC_UNONAME_CUNDER, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
302 { SC_UNONAME_CUNDLCOL, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
303 { SC_UNONAME_CUNDLHAS, ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
304 { SC_UNONAME_CWEIGHT, ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
305 { SC_UNO_CJK_CWEIGHT, ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
306 { SC_UNO_CTL_CWEIGHT, ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
307 { SC_UNONAME_CWORDMOD, ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
308 { SC_UNONAME_CHCOLHDR, SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
309 { SC_UNONAME_CHROWHDR, SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
310 { SC_UNONAME_CONDFMT, SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
311 { SC_UNONAME_CONDLOC, SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
312 { SC_UNONAME_CONDXML, SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
313 { SC_UNONAME_DIAGONAL_BLTR, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
314 { SC_UNONAME_DIAGONAL_BLTR2, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
315 { SC_UNONAME_DIAGONAL_TLBR, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
316 { SC_UNONAME_DIAGONAL_TLBR2, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
317 { SC_UNONAME_CELLHJUS, ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
318 { SC_UNONAME_CELLHJUS_METHOD, ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
319 { SC_UNONAME_CELLTRAN, ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
320 { SC_UNONAME_WRAP, ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
321 { SC_UNONAME_NUMFMT, ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
322 { SC_UNONAME_NUMRULES, SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
323 { SC_UNONAME_CELLORI, ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
324 { SC_UNONAME_PADJUST, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
325 { SC_UNONAME_PBMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
326 { SC_UNONAME_PINDENT, ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
327 { SC_UNONAME_PISCHDIST,ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
328 { SC_UNONAME_PISFORBID,ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
329 { SC_UNONAME_PISHANG, ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
330 { SC_UNONAME_PISHYPHEN,ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
331 { SC_UNONAME_PLASTADJ, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
332 { SC_UNONAME_PLMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
333 { SC_UNONAME_PRMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
334 { SC_UNONAME_PTMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
335 { SC_UNONAME_POS, SC_WID_UNO_POS, cppu::UnoType<awt::Point>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
336 { SC_UNONAME_ROTANG, ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
337 { SC_UNONAME_ROTREF, ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
338 { SC_UNONAME_SHADOW, ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
339 { SC_UNONAME_SHRINK_TO_FIT, ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
340 { SC_UNONAME_SIZE, SC_WID_UNO_SIZE, cppu::UnoType<awt::Size>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
341 { SC_UNONAME_TBLBORD, SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
342 { SC_UNONAME_TBLBORD2, SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
343 { SC_UNONAME_USERDEF, ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
344 { SC_UNONAME_VALIDAT, SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
345 { SC_UNONAME_VALILOC, SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
346 { SC_UNONAME_VALIXML, SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
347 { SC_UNONAME_CELLVJUS, ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
348 { SC_UNONAME_CELLVJUS_METHOD, ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
349 { SC_UNONAME_WRITING, ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
350 { SC_UNONAME_FORMATID, SC_WID_UNO_FORMATID, cppu::UnoType<sal_uInt64>::get(), 0, 0 },
351 };
352 static SfxItemPropertySet aRangePropertySet( aRangePropertyMap_Impl );
353 return &aRangePropertySet;
354 }
355
356 // Cell contains entries from CellRange, plus its own entries
357 // with Which-ID 0 (those are needed only for getPropertySetInfo).
358
359 static const SfxItemPropertySet* lcl_GetCellPropertySet()
360 {
361 static const SfxItemPropertyMapEntry aCellPropertyMap_Impl[] =
362 {
363 { SC_UNONAME_ABSNAME, SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
364 { SC_UNONAME_ASIANVERT,ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
365 CELL_BORDER_PROPERTIES
366 CELL_BACKGROUND_COLOR_PROPERTIES
367 { SC_UNONAME_CELLPRO, ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
368 { SC_UNONAME_CELLSTYL, SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
369 CHAR_COLOR_PROPERTIES
370 { SC_UNONAME_COUTL, ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
371 { SC_UNONAME_CCROSS, ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
372 { SC_UNONAME_CEMPHAS, ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
373 { SC_UNONAME_CFONT, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
374 { SC_UNONAME_CFCHARS, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
375 { SC_UNO_CJK_CFCHARS, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
376 { SC_UNO_CTL_CFCHARS, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
377 { SC_UNONAME_CFFAMIL, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
378 { SC_UNO_CJK_CFFAMIL, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
379 { SC_UNO_CTL_CFFAMIL, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
380 { SC_UNONAME_CFNAME, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
381 { SC_UNO_CJK_CFNAME, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
382 { SC_UNO_CTL_CFNAME, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
383 { SC_UNONAME_CFPITCH, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
384 { SC_UNO_CJK_CFPITCH, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
385 { SC_UNO_CTL_CFPITCH, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
386 { SC_UNONAME_CFSTYLE, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
387 { SC_UNO_CJK_CFSTYLE, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
388 { SC_UNO_CTL_CFSTYLE, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
389 { SC_UNONAME_CHEIGHT, ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
390 { SC_UNO_CJK_CHEIGHT, ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
391 { SC_UNO_CTL_CHEIGHT, ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
392 { SC_UNONAME_CLOCAL, ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
393 { SC_UNO_CJK_CLOCAL, ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
394 { SC_UNO_CTL_CLOCAL, ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
395 { SC_UNONAME_COVER, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
396 { SC_UNONAME_COVRLCOL, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
397 { SC_UNONAME_COVRLHAS, ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
398 { SC_UNONAME_CPOST, ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
399 { SC_UNO_CJK_CPOST, ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
400 { SC_UNO_CTL_CPOST, ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
401 { SC_UNONAME_CRELIEF, ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
402 { SC_UNONAME_CSHADD, ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
403 { SC_UNONAME_CSTRIKE, ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
404 { SC_UNONAME_CUNDER, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
405 { SC_UNONAME_CUNDLCOL, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
406 { SC_UNONAME_CUNDLHAS, ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
407 { SC_UNONAME_CWEIGHT, ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
408 { SC_UNO_CJK_CWEIGHT, ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
409 { SC_UNO_CTL_CWEIGHT, ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
410 { SC_UNONAME_CWORDMOD, ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
411 { SC_UNONAME_CHCOLHDR, SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
412 { SC_UNONAME_CHROWHDR, SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
413 { SC_UNONAME_CONDFMT, SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
414 { SC_UNONAME_CONDLOC, SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
415 { SC_UNONAME_CONDXML, SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
416 { SC_UNONAME_DIAGONAL_BLTR, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
417 { SC_UNONAME_DIAGONAL_BLTR2, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
418 { SC_UNONAME_DIAGONAL_TLBR, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
419 { SC_UNONAME_DIAGONAL_TLBR2, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
420 { SC_UNONAME_FORMLOC, SC_WID_UNO_FORMLOC, cppu::UnoType<OUString>::get(), 0, 0 },
421 { SC_UNONAME_FORMRT, SC_WID_UNO_FORMRT, cppu::UnoType<table::CellContentType>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
422 { SC_UNONAME_CELLCONTENTTYPE, SC_WID_UNO_CELLCONTENTTYPE, cppu::UnoType<table::CellContentType>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
423 { SC_UNONAME_FORMRT2, SC_WID_UNO_FORMRT2, cppu::UnoType<sal_Int32>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
424 { SC_UNONAME_CELLHJUS, ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
425 { SC_UNONAME_CELLHJUS_METHOD, ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
426 { SC_UNONAME_CELLTRAN, ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
427 { SC_UNONAME_WRAP, ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
428 { SC_UNONAME_NUMFMT, ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
429 { SC_UNONAME_NUMRULES, SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
430 { SC_UNONAME_CELLORI, ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
431 { SC_UNONAME_PADJUST, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
432 { SC_UNONAME_PBMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
433 { SC_UNONAME_PINDENT, ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
434 { SC_UNONAME_PISCHDIST,ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
435 { SC_UNONAME_PISFORBID,ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
436 { SC_UNONAME_PISHANG, ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
437 { SC_UNONAME_PISHYPHEN,ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
438 { SC_UNONAME_PLASTADJ, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
439 { SC_UNONAME_PLMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
440 { SC_UNONAME_PRMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
441 { SC_UNONAME_PTMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
442 { SC_UNONAME_POS, SC_WID_UNO_POS, cppu::UnoType<awt::Point>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
443 { SC_UNONAME_ROTANG, ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
444 { SC_UNONAME_ROTREF, ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
445 { SC_UNONAME_SHADOW, ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
446 { SC_UNONAME_SHRINK_TO_FIT, ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
447 { SC_UNONAME_SIZE, SC_WID_UNO_SIZE, cppu::UnoType<awt::Size>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
448 { SC_UNONAME_TBLBORD, SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
449 { SC_UNONAME_TBLBORD2, SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
450 { SC_UNONAME_USERDEF, ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
451 { SC_UNONAME_VALIDAT, SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
452 { SC_UNONAME_VALILOC, SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
453 { SC_UNONAME_VALIXML, SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
454 { SC_UNONAME_CELLVJUS, ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
455 { SC_UNONAME_CELLVJUS_METHOD, ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
456 { SC_UNONAME_WRITING, ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
457 { UNO_NAME_EDIT_CHAR_ESCAPEMENT, EE_CHAR_ESCAPEMENT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
458 { SC_UNONAME_HYPERLINK, ATTR_HYPERLINK, cppu::UnoType<OUString>::get(), 0, 0 },
459 { SC_UNONAME_FORMATID, SC_WID_UNO_FORMATID, cppu::UnoType<sal_uInt64>::get(), 0, 0 },
460 };
461 static SfxItemPropertySet aCellPropertySet( aCellPropertyMap_Impl );
462 return &aCellPropertySet;
463 }
464
465 // Column and Row contain all entries from CellRange, plus its own entries
466 // with Which-ID 0 (those are needed only for getPropertySetInfo).
467
468 static const SfxItemPropertySet* lcl_GetColumnPropertySet()
469 {
470 static const SfxItemPropertyMapEntry aColumnPropertyMap_Impl[] =
471 {
472 { SC_UNONAME_ABSNAME, SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
473 { SC_UNONAME_ASIANVERT,ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
474 CELL_BORDER_PROPERTIES
475 CELL_BACKGROUND_COLOR_PROPERTIES
476 { SC_UNONAME_CELLPRO, ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
477 { SC_UNONAME_CELLSTYL, SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
478 CHAR_COLOR_PROPERTIES
479 { SC_UNONAME_COUTL, ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
480 { SC_UNONAME_CCROSS, ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
481 { SC_UNONAME_CEMPHAS, ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
482 { SC_UNONAME_CFONT, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
483 { SC_UNONAME_CFCHARS, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
484 { SC_UNO_CJK_CFCHARS, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
485 { SC_UNO_CTL_CFCHARS, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
486 { SC_UNONAME_CFFAMIL, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
487 { SC_UNO_CJK_CFFAMIL, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
488 { SC_UNO_CTL_CFFAMIL, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
489 { SC_UNONAME_CFNAME, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
490 { SC_UNO_CJK_CFNAME, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
491 { SC_UNO_CTL_CFNAME, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
492 { SC_UNONAME_CFPITCH, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
493 { SC_UNO_CJK_CFPITCH, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
494 { SC_UNO_CTL_CFPITCH, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
495 { SC_UNONAME_CFSTYLE, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
496 { SC_UNO_CJK_CFSTYLE, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
497 { SC_UNO_CTL_CFSTYLE, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
498 { SC_UNONAME_CHEIGHT, ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
499 { SC_UNO_CJK_CHEIGHT, ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
500 { SC_UNO_CTL_CHEIGHT, ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
501 { SC_UNONAME_CLOCAL, ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
502 { SC_UNO_CJK_CLOCAL, ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
503 { SC_UNO_CTL_CLOCAL, ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
504 { SC_UNONAME_COVER, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
505 { SC_UNONAME_COVRLCOL, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
506 { SC_UNONAME_COVRLHAS, ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
507 { SC_UNONAME_CPOST, ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
508 { SC_UNO_CJK_CPOST, ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
509 { SC_UNO_CTL_CPOST, ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
510 { SC_UNONAME_CRELIEF, ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
511 { SC_UNONAME_CSHADD, ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
512 { SC_UNONAME_CSTRIKE, ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
513 { SC_UNONAME_CUNDER, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
514 { SC_UNONAME_CUNDLCOL, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
515 { SC_UNONAME_CUNDLHAS, ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
516 { SC_UNONAME_CWEIGHT, ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
517 { SC_UNO_CJK_CWEIGHT, ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
518 { SC_UNO_CTL_CWEIGHT, ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
519 { SC_UNONAME_CWORDMOD, ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
520 { SC_UNONAME_CHCOLHDR, SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
521 { SC_UNONAME_CHROWHDR, SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
522 { SC_UNONAME_CONDFMT, SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
523 { SC_UNONAME_CONDLOC, SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
524 { SC_UNONAME_CONDXML, SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
525 { SC_UNONAME_DIAGONAL_BLTR, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
526 { SC_UNONAME_DIAGONAL_BLTR2, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
527 { SC_UNONAME_DIAGONAL_TLBR, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
528 { SC_UNONAME_DIAGONAL_TLBR2, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
529 { SC_UNONAME_CELLHJUS, ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
530 { SC_UNONAME_CELLHJUS_METHOD, ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
531 { SC_UNONAME_CELLTRAN, ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
532 { SC_UNONAME_MANPAGE, SC_WID_UNO_MANPAGE, cppu::UnoType<bool>::get(), 0, 0 },
533 { SC_UNONAME_NEWPAGE, SC_WID_UNO_NEWPAGE, cppu::UnoType<bool>::get(), 0, 0 },
534 { SC_UNONAME_WRAP, ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
535 { SC_UNONAME_CELLVIS, SC_WID_UNO_CELLVIS, cppu::UnoType<bool>::get(), 0, 0 },
536 { SC_UNONAME_NUMFMT, ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
537 { SC_UNONAME_NUMRULES, SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
538 { SC_UNONAME_OWIDTH, SC_WID_UNO_OWIDTH, cppu::UnoType<bool>::get(), 0, 0 },
539 { SC_UNONAME_CELLORI, ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
540 { SC_UNONAME_PADJUST, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
541 { SC_UNONAME_PBMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
542 { SC_UNONAME_PINDENT, ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
543 { SC_UNONAME_PISCHDIST,ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
544 { SC_UNONAME_PISFORBID,ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
545 { SC_UNONAME_PISHANG, ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
546 { SC_UNONAME_PISHYPHEN,ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
547 { SC_UNONAME_PLASTADJ, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
548 { SC_UNONAME_PLMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
549 { SC_UNONAME_PRMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
550 { SC_UNONAME_PTMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
551 { SC_UNONAME_POS, SC_WID_UNO_POS, cppu::UnoType<awt::Point>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
552 { SC_UNONAME_ROTANG, ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
553 { SC_UNONAME_ROTREF, ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
554 { SC_UNONAME_SHADOW, ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
555 { SC_UNONAME_SHRINK_TO_FIT, ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
556 { SC_UNONAME_SIZE, SC_WID_UNO_SIZE, cppu::UnoType<awt::Size>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
557 { SC_UNONAME_TBLBORD, SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
558 { SC_UNONAME_TBLBORD2, SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
559 { SC_UNONAME_USERDEF, ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
560 { SC_UNONAME_VALIDAT, SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
561 { SC_UNONAME_VALILOC, SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
562 { SC_UNONAME_VALIXML, SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
563 { SC_UNONAME_CELLVJUS, ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
564 { SC_UNONAME_CELLVJUS_METHOD, ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
565 { SC_UNONAME_CELLWID, SC_WID_UNO_CELLWID, cppu::UnoType<sal_Int32>::get(), 0, 0 },
566 { SC_UNONAME_WRITING, ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
567 };
568 static SfxItemPropertySet aColumnPropertySet( aColumnPropertyMap_Impl );
569 return &aColumnPropertySet;
570 }
571
572 static const SfxItemPropertySet* lcl_GetRowPropertySet()
573 {
574 static const SfxItemPropertyMapEntry aRowPropertyMap_Impl[] =
575 {
576 { SC_UNONAME_ABSNAME, SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
577 { SC_UNONAME_ASIANVERT,ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
578 CELL_BORDER_PROPERTIES
579 CELL_BACKGROUND_COLOR_PROPERTIES
580 { SC_UNONAME_CELLPRO, ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
581 { SC_UNONAME_CELLSTYL, SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
582 CHAR_COLOR_PROPERTIES
583 { SC_UNONAME_COUTL, ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
584 { SC_UNONAME_CCROSS, ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
585 { SC_UNONAME_CEMPHAS, ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
586 { SC_UNONAME_CFONT, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
587 { SC_UNONAME_CFCHARS, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
588 { SC_UNO_CJK_CFCHARS, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
589 { SC_UNO_CTL_CFCHARS, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
590 { SC_UNONAME_CFFAMIL, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
591 { SC_UNO_CJK_CFFAMIL, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
592 { SC_UNO_CTL_CFFAMIL, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
593 { SC_UNONAME_CFNAME, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
594 { SC_UNO_CJK_CFNAME, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
595 { SC_UNO_CTL_CFNAME, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
596 { SC_UNONAME_CFPITCH, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
597 { SC_UNO_CJK_CFPITCH, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
598 { SC_UNO_CTL_CFPITCH, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
599 { SC_UNONAME_CFSTYLE, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
600 { SC_UNO_CJK_CFSTYLE, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
601 { SC_UNO_CTL_CFSTYLE, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
602 { SC_UNONAME_CHEIGHT, ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
603 { SC_UNO_CJK_CHEIGHT, ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
604 { SC_UNO_CTL_CHEIGHT, ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
605 { SC_UNONAME_CLOCAL, ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
606 { SC_UNO_CJK_CLOCAL, ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
607 { SC_UNO_CTL_CLOCAL, ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
608 { SC_UNONAME_COVER, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
609 { SC_UNONAME_COVRLCOL, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
610 { SC_UNONAME_COVRLHAS, ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
611 { SC_UNONAME_CPOST, ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
612 { SC_UNO_CJK_CPOST, ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
613 { SC_UNO_CTL_CPOST, ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
614 { SC_UNONAME_CRELIEF, ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
615 { SC_UNONAME_CSHADD, ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
616 { SC_UNONAME_CSTRIKE, ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
617 { SC_UNONAME_CUNDER, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
618 { SC_UNONAME_CUNDLCOL, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
619 { SC_UNONAME_CUNDLHAS, ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
620 { SC_UNONAME_CWEIGHT, ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
621 { SC_UNO_CJK_CWEIGHT, ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
622 { SC_UNO_CTL_CWEIGHT, ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
623 { SC_UNONAME_CWORDMOD, ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
624 { SC_UNONAME_CHCOLHDR, SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
625 { SC_UNONAME_CHROWHDR, SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
626 { SC_UNONAME_CONDFMT, SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
627 { SC_UNONAME_CONDLOC, SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
628 { SC_UNONAME_CONDXML, SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
629 { SC_UNONAME_DIAGONAL_BLTR, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
630 { SC_UNONAME_DIAGONAL_BLTR2, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
631 { SC_UNONAME_DIAGONAL_TLBR, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
632 { SC_UNONAME_DIAGONAL_TLBR2, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
633 { SC_UNONAME_CELLHGT, SC_WID_UNO_CELLHGT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
634 { SC_UNONAME_CELLHJUS, ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
635 { SC_UNONAME_CELLHJUS_METHOD, ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
636 { SC_UNONAME_CELLTRAN, ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
637 { SC_UNONAME_CELLFILT, SC_WID_UNO_CELLFILT,cppu::UnoType<bool>::get(), 0, 0 },
638 { SC_UNONAME_MANPAGE, SC_WID_UNO_MANPAGE, cppu::UnoType<bool>::get(), 0, 0 },
639 { SC_UNONAME_NEWPAGE, SC_WID_UNO_NEWPAGE, cppu::UnoType<bool>::get(), 0, 0 },
640 { SC_UNONAME_WRAP, ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
641 { SC_UNONAME_CELLVIS, SC_WID_UNO_CELLVIS, cppu::UnoType<bool>::get(), 0, 0 },
642 { SC_UNONAME_NUMFMT, ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
643 { SC_UNONAME_NUMRULES, SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
644 { SC_UNONAME_OHEIGHT, SC_WID_UNO_OHEIGHT, cppu::UnoType<bool>::get(), 0, 0 },
645 { SC_UNONAME_CELLORI, ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
646 { SC_UNONAME_PADJUST, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
647 { SC_UNONAME_PBMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
648 { SC_UNONAME_PINDENT, ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
649 { SC_UNONAME_PISCHDIST,ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
650 { SC_UNONAME_PISFORBID,ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
651 { SC_UNONAME_PISHANG, ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
652 { SC_UNONAME_PISHYPHEN,ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
653 { SC_UNONAME_PLASTADJ, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
654 { SC_UNONAME_PLMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
655 { SC_UNONAME_PRMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
656 { SC_UNONAME_PTMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
657 { SC_UNONAME_POS, SC_WID_UNO_POS, cppu::UnoType<awt::Point>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
658 { SC_UNONAME_ROTANG, ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
659 { SC_UNONAME_ROTREF, ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
660 { SC_UNONAME_SHADOW, ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
661 { SC_UNONAME_SHRINK_TO_FIT, ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
662 { SC_UNONAME_SIZE, SC_WID_UNO_SIZE, cppu::UnoType<awt::Size>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
663 { SC_UNONAME_TBLBORD, SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
664 { SC_UNONAME_TBLBORD2, SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
665 { SC_UNONAME_USERDEF, ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
666 { SC_UNONAME_VALIDAT, SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
667 { SC_UNONAME_VALILOC, SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
668 { SC_UNONAME_VALIXML, SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
669 { SC_UNONAME_CELLVJUS, ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
670 { SC_UNONAME_CELLVJUS_METHOD, ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
671 { SC_UNONAME_WRITING, ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
672 };
673 static SfxItemPropertySet aRowPropertySet( aRowPropertyMap_Impl );
674 return &aRowPropertySet;
675 }
676
677 static const SfxItemPropertySet* lcl_GetSheetPropertySet()
678 {
679 static const SfxItemPropertyMapEntry aSheetPropertyMap_Impl[] =
680 {
681 { SC_UNONAME_ABSNAME, SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
682 { SC_UNONAME_ASIANVERT,ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
683 { SC_UNONAME_AUTOPRINT,SC_WID_UNO_AUTOPRINT,cppu::UnoType<bool>::get(), 0, 0 },
684 { SC_UNONAME_BORDCOL, SC_WID_UNO_BORDCOL, cppu::UnoType<sal_Int32>::get(), 0, 0 },
685 CELL_BORDER_PROPERTIES
686 CELL_BACKGROUND_COLOR_PROPERTIES
687 { SC_UNONAME_CELLPRO, ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
688 { SC_UNONAME_CELLSTYL, SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
689 CHAR_COLOR_PROPERTIES
690 { SC_UNONAME_COUTL, ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
691 { SC_UNONAME_CCROSS, ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
692 { SC_UNONAME_CEMPHAS, ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
693 { SC_UNONAME_CFONT, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
694 { SC_UNONAME_CFCHARS, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
695 { SC_UNO_CJK_CFCHARS, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
696 { SC_UNO_CTL_CFCHARS, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
697 { SC_UNONAME_CFFAMIL, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
698 { SC_UNO_CJK_CFFAMIL, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
699 { SC_UNO_CTL_CFFAMIL, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
700 { SC_UNONAME_CFNAME, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
701 { SC_UNO_CJK_CFNAME, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
702 { SC_UNO_CTL_CFNAME, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
703 { SC_UNONAME_CFPITCH, ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
704 { SC_UNO_CJK_CFPITCH, ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
705 { SC_UNO_CTL_CFPITCH, ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
706 { SC_UNONAME_CFSTYLE, ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
707 { SC_UNO_CJK_CFSTYLE, ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
708 { SC_UNO_CTL_CFSTYLE, ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
709 { SC_UNONAME_CHEIGHT, ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
710 { SC_UNO_CJK_CHEIGHT, ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
711 { SC_UNO_CTL_CHEIGHT, ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
712 { SC_UNONAME_CLOCAL, ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
713 { SC_UNO_CJK_CLOCAL, ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
714 { SC_UNO_CTL_CLOCAL, ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
715 { SC_UNONAME_COVER, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
716 { SC_UNONAME_COVRLCOL, ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
717 { SC_UNONAME_COVRLHAS, ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
718 { SC_UNONAME_CPOST, ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
719 { SC_UNO_CJK_CPOST, ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
720 { SC_UNO_CTL_CPOST, ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
721 { SC_UNONAME_CRELIEF, ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
722 { SC_UNONAME_CSHADD, ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
723 { SC_UNONAME_CSTRIKE, ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
724 { SC_UNONAME_CUNDER, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
725 { SC_UNONAME_CUNDLCOL, ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
726 { SC_UNONAME_CUNDLHAS, ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
727 { SC_UNONAME_CWEIGHT, ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
728 { SC_UNO_CJK_CWEIGHT, ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
729 { SC_UNO_CTL_CWEIGHT, ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
730 { SC_UNONAME_CWORDMOD, ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
731 { SC_UNONAME_CHCOLHDR, SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
732 { SC_UNONAME_CHROWHDR, SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
733 { SC_UNONAME_CONDFMT, SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
734 { SC_UNONAME_CONDLOC, SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
735 { SC_UNONAME_CONDXML, SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
736 { SC_UNONAME_COPYBACK, SC_WID_UNO_COPYBACK,cppu::UnoType<bool>::get(), 0, 0 },
737 { SC_UNONAME_COPYFORM, SC_WID_UNO_COPYFORM,cppu::UnoType<bool>::get(), 0, 0 },
738 { SC_UNONAME_COPYSTYL, SC_WID_UNO_COPYSTYL,cppu::UnoType<bool>::get(), 0, 0 },
739 { SC_UNONAME_DIAGONAL_BLTR, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
740 { SC_UNONAME_DIAGONAL_BLTR2, ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
741 { SC_UNONAME_DIAGONAL_TLBR, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
742 { SC_UNONAME_DIAGONAL_TLBR2, ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
743 { SC_UNONAME_CELLHJUS, ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
744 { SC_UNONAME_CELLHJUS_METHOD, ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
745 { SC_UNONAME_ISACTIVE, SC_WID_UNO_ISACTIVE,cppu::UnoType<bool>::get(), 0, 0 },
746 { SC_UNONAME_CELLTRAN, ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
747 { SC_UNONAME_WRAP, ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
748 { SC_UNONAME_CELLVIS, SC_WID_UNO_CELLVIS, cppu::UnoType<bool>::get(), 0, 0 },
749 { SC_UNO_LINKDISPBIT, SC_WID_UNO_LINKDISPBIT,cppu::UnoType<awt::XBitmap>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
750 { SC_UNO_LINKDISPNAME, SC_WID_UNO_LINKDISPNAME,cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
751 { SC_UNONAME_NUMFMT, ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
752 { SC_UNONAME_NUMRULES, SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
753 { SC_UNONAME_CELLORI, ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
754 { SC_UNONAME_PAGESTL, SC_WID_UNO_PAGESTL, cppu::UnoType<OUString>::get(), 0, 0 },
755 { SC_UNONAME_PADJUST, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
756 { SC_UNONAME_PBMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
757 { SC_UNONAME_PINDENT, ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
758 { SC_UNONAME_PISCHDIST,ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
759 { SC_UNONAME_PISFORBID,ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
760 { SC_UNONAME_PISHANG, ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
761 { SC_UNONAME_PISHYPHEN,ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
762 { SC_UNONAME_PLASTADJ, ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
763 { SC_UNONAME_PLMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
764 { SC_UNONAME_PRMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
765 { SC_UNONAME_PTMARGIN, ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
766 { SC_UNONAME_POS, SC_WID_UNO_POS, cppu::UnoType<awt::Point>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
767 { SC_UNONAME_PRINTBORD,SC_WID_UNO_PRINTBORD,cppu::UnoType<bool>::get(), 0, 0 },
768 { SC_UNONAME_PROTECT, SC_WID_UNO_PROTECT, cppu::UnoType<bool>::get(), 0, 0 },
769 { SC_UNONAME_ROTANG, ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
770 { SC_UNONAME_ROTREF, ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
771 { SC_UNONAME_SHADOW, ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
772 { SC_UNONAME_SHOWBORD, SC_WID_UNO_SHOWBORD,cppu::UnoType<bool>::get(), 0, 0 },
773 { SC_UNONAME_SHRINK_TO_FIT, ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
774 { SC_UNONAME_SIZE, SC_WID_UNO_SIZE, cppu::UnoType<awt::Size>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
775 { SC_UNONAME_TBLBORD, SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
776 { SC_UNONAME_TBLBORD2, SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
777 { SC_UNONAME_TABLAYOUT,SC_WID_UNO_TABLAYOUT,cppu::UnoType<sal_Int16>::get(), 0, 0 },
778 { SC_UNONAME_CONDFORMAT, SC_WID_UNO_CONDFORMAT, cppu::UnoType<sheet::XConditionalFormats>::get(), 0, 0},
779 { SC_UNONAME_USERDEF, ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
780 { SC_UNONAME_VALIDAT, SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
781 { SC_UNONAME_VALILOC, SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
782 { SC_UNONAME_VALIXML, SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
783 { SC_UNONAME_CELLVJUS, ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
784 { SC_UNONAME_CELLVJUS_METHOD, ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
785 { SC_UNONAME_WRITING, ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
786 { SC_UNONAME_TABCOLOR, SC_WID_UNO_TABCOLOR, cppu::UnoType<sal_Int32>::get(), 0, 0 },
787 { SC_UNO_CODENAME, SC_WID_UNO_CODENAME, cppu::UnoType<OUString>::get(), 0, 0},
788 { SC_UNO_NAMEDRANGES, SC_WID_UNO_NAMES, cppu::UnoType<sheet::XNamedRanges>::get(), 0, 0 },
789 { SC_UNO_SOLVERSETTINGS, SC_WID_UNO_SOLVERSETTINGS, cppu::UnoType<sheet::XSolverSettings>::get(), 0, 0 },
790 { SC_UNONAME_TOTALBELOW, SC_WID_UNO_TOTALBELOW, cppu::UnoType<bool>::get(), 0, 0 },
791 };
792 static SfxItemPropertySet aSheetPropertySet( aSheetPropertyMap_Impl );
793 return &aSheetPropertySet;
794 }
795
796 static std::span<const SfxItemPropertyMapEntry> lcl_GetEditPropertyMap()
797 {
798 static const SfxItemPropertyMapEntry aEditPropertyMap_Impl[] =
799 {
800 SVX_UNOEDIT_CHAR_PROPERTIES,
801 SVX_UNOEDIT_FONT_PROPERTIES,
802 SVX_UNOEDIT_PARA_PROPERTIES,
803 SVX_UNOEDIT_NUMBERING_PROPERTY, // for completeness of service ParagraphProperties
804 { SC_UNONAME_TEXTUSER, EE_CHAR_XMLATTRIBS, cppu::UnoType<container::XNameContainer>::get(), 0, 0},
805 { SC_UNONAME_USERDEF, EE_PARA_XMLATTRIBS, cppu::UnoType<container::XNameContainer>::get(), 0, 0},
806 };
807 return aEditPropertyMap_Impl;
808 }
809 static const SvxItemPropertySet* lcl_GetEditPropertySet()
810 {
811 static SvxItemPropertySet aEditPropertySet( lcl_GetEditPropertyMap(), SdrObject::GetGlobalDrawObjectItemPool() );
812 return &aEditPropertySet;
813 }
814
815 constexpr OUString SCCHARPROPERTIES_SERVICE = u"com.sun.star.style.CharacterProperties"_ustr;
816 constexpr OUString SCPARAPROPERTIES_SERVICE = u"com.sun.star.style.ParagraphProperties"_ustr;
817 constexpr OUString SCCELLPROPERTIES_SERVICE = u"com.sun.star.table.CellProperties"_ustr;
818 constexpr OUString SCCELLRANGE_SERVICE = u"com.sun.star.table.CellRange"_ustr;
819 constexpr OUString SCCELL_SERVICE = u"com.sun.star.table.Cell"_ustr;
820 constexpr OUString SCSHEETCELLRANGES_SERVICE = u"com.sun.star.sheet.SheetCellRanges"_ustr;
821 constexpr OUString SCSHEETCELLRANGE_SERVICE = u"com.sun.star.sheet.SheetCellRange"_ustr;
822 constexpr OUString SCSPREADSHEET_SERVICE = u"com.sun.star.sheet.Spreadsheet"_ustr;
823 constexpr OUString SCSHEETCELL_SERVICE = u"com.sun.star.sheet.SheetCell"_ustr;
824
825 SC_SIMPLE_SERVICE_INFO( ScCellFormatsEnumeration, u"ScCellFormatsEnumeration"_ustr, u"com.sun.star.sheet.CellFormatRangesEnumeration"_ustr )
826 SC_SIMPLE_SERVICE_INFO( ScCellFormatsObj, u"ScCellFormatsObj"_ustr, u"com.sun.star.sheet.CellFormatRanges"_ustr )
827 SC_SIMPLE_SERVICE_INFO( ScUniqueCellFormatsEnumeration, u"ScUniqueCellFormatsEnumeration"_ustr, u"com.sun.star.sheet.UniqueCellFormatRangesEnumeration"_ustr )
828 SC_SIMPLE_SERVICE_INFO( ScUniqueCellFormatsObj, u"ScUniqueCellFormatsObj"_ustr, u"com.sun.star.sheet.UniqueCellFormatRanges"_ustr )
829 SC_SIMPLE_SERVICE_INFO( ScCellRangesBase, u"ScCellRangesBase"_ustr, u"stardiv.unknown"_ustr )
830 SC_SIMPLE_SERVICE_INFO( ScCellsEnumeration, u"ScCellsEnumeration"_ustr, u"com.sun.star.sheet.CellsEnumeration"_ustr )
831 SC_SIMPLE_SERVICE_INFO( ScCellsObj, u"ScCellsObj"_ustr, u"com.sun.star.sheet.Cells"_ustr )
832 SC_SIMPLE_SERVICE_INFO( ScTableColumnObj, u"ScTableColumnObj"_ustr, u"com.sun.star.table.TableColumn"_ustr )
833 SC_SIMPLE_SERVICE_INFO( ScTableRowObj, u"ScTableRowObj"_ustr, u"com.sun.star.table.TableRow"_ustr )
834
835 //! move ScLinkListener into another file !!!
836
837 ScLinkListener::~ScLinkListener()
838 {
839 }
840
841 void ScLinkListener::Notify( const SfxHint& rHint )
842 {
843 aLink.Call( rHint );
844 }
845
846 static void lcl_CopyProperties( beans::XPropertySet& rDest, beans::XPropertySet& rSource )
847 {
848 uno::Reference<beans::XPropertySetInfo> xInfo(rSource.getPropertySetInfo());
849 if (xInfo.is())
850 {
851 const uno::Sequence<beans::Property> aSeq(xInfo->getProperties());
852 for (const beans::Property& rProp : aSeq)
853 {
854 OUString aName(rProp.Name);
855 rDest.setPropertyValue( aName, rSource.getPropertyValue( aName ) );
856 }
857 }
858 }
859
860 static SCTAB lcl_FirstTab( const ScRangeList& rRanges )
861 {
862 if (rRanges.empty())
863 throw std::out_of_range("empty range");
864 const ScRange & rFirst = rRanges[0];
865 return rFirst.aStart.Tab();
866 }
867
868 static bool lcl_WholeSheet( const ScDocument& rDoc, const ScRangeList& rRanges )
869 {
870 if ( rRanges.size() == 1 )
871 {
872 const ScRange & rRange = rRanges[0];
873 if ( rRange.aStart.Col() == 0 && rRange.aEnd.Col() == rDoc.MaxCol() &&
874 rRange.aStart.Row() == 0 && rRange.aEnd.Row() == rDoc.MaxRow() )
875 return true;
876 }
877 return false;
878 }
879
880 namespace {
881 template<typename BorderLineType>
882 const ::editeng::SvxBorderLine* lcl_getBorderLine(
883 ::editeng::SvxBorderLine& rLine, const BorderLineType& rStruct )
884 {
885 // Convert from 1/100mm to Twips.
886 if (!SvxBoxItem::LineToSvxLine( rStruct, rLine, true))
887 return nullptr;
888
889 if ( rLine.GetOutWidth() || rLine.GetInWidth() || rLine.GetDistance() )
890 return &rLine;
891 else
892 return nullptr;
893 }
894 }
895
896 const ::editeng::SvxBorderLine* ScHelperFunctions::GetBorderLine(
897 ::editeng::SvxBorderLine& rLine, const table::BorderLine& rStruct )
898 {
899 return lcl_getBorderLine( rLine, rStruct);
900 }
901
902 const ::editeng::SvxBorderLine* ScHelperFunctions::GetBorderLine(
903 ::editeng::SvxBorderLine& rLine, const table::BorderLine2& rStruct )
904 {
905 return lcl_getBorderLine( rLine, rStruct);
906 }
907
908 namespace {
909 template<typename TableBorderType>
910 void lcl_fillBoxItems( SvxBoxItem& rOuter, SvxBoxInfoItem& rInner, const TableBorderType& rBorder )
911 {
912 ::editeng::SvxBorderLine aLine;
913 rOuter.SetAllDistances(o3tl::toTwips(rBorder.Distance, o3tl::Length::mm100));
914 rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.TopLine ), SvxBoxItemLine::TOP );
915 rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.BottomLine ), SvxBoxItemLine::BOTTOM );
916 rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.LeftLine ), SvxBoxItemLine::LEFT );
917 rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.RightLine ), SvxBoxItemLine::RIGHT );
918 rInner.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.HorizontalLine ), SvxBoxInfoItemLine::HORI );
919 rInner.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.VerticalLine ), SvxBoxInfoItemLine::VERT );
920 rInner.SetValid( SvxBoxInfoItemValidFlags::TOP, rBorder.IsTopLineValid );
921 rInner.SetValid( SvxBoxInfoItemValidFlags::BOTTOM, rBorder.IsBottomLineValid );
922 rInner.SetValid( SvxBoxInfoItemValidFlags::LEFT, rBorder.IsLeftLineValid );
923 rInner.SetValid( SvxBoxInfoItemValidFlags::RIGHT, rBorder.IsRightLineValid );
924 rInner.SetValid( SvxBoxInfoItemValidFlags::HORI, rBorder.IsHorizontalLineValid );
925 rInner.SetValid( SvxBoxInfoItemValidFlags::VERT, rBorder.IsVerticalLineValid );
926 rInner.SetValid( SvxBoxInfoItemValidFlags::DISTANCE, rBorder.IsDistanceValid );
927 rInner.SetTable( true );
928 }
929 }
930
931 void ScHelperFunctions::FillBoxItems( SvxBoxItem& rOuter, SvxBoxInfoItem& rInner, const table::TableBorder& rBorder )
932 {
933 lcl_fillBoxItems( rOuter, rInner, rBorder);
934 }
935
936 void ScHelperFunctions::FillBoxItems( SvxBoxItem& rOuter, SvxBoxInfoItem& rInner, const table::TableBorder2& rBorder )
937 {
938 lcl_fillBoxItems( rOuter, rInner, rBorder);
939 }
940
941 void ScHelperFunctions::FillBorderLine( table::BorderLine& rStruct, const ::editeng::SvxBorderLine* pLine )
942 {
943 // Convert from Twips to 1/100mm.
944 rStruct = SvxBoxItem::SvxLineToLine( pLine, true);
945 }
946
947 void ScHelperFunctions::FillBorderLine( table::BorderLine2& rStruct, const ::editeng::SvxBorderLine* pLine )
948 {
949 rStruct = SvxBoxItem::SvxLineToLine( pLine, true);
950 }
951
952 namespace {
953 template<typename TableBorderItem>
954 void lcl_fillTableBorder( TableBorderItem& rBorder, const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner,
955 bool bInvalidateHorVerDist )
956 {
957 ScHelperFunctions::FillBorderLine( rBorder.TopLine, rOuter.GetTop() );
958 ScHelperFunctions::FillBorderLine( rBorder.BottomLine, rOuter.GetBottom() );
959 ScHelperFunctions::FillBorderLine( rBorder.LeftLine, rOuter.GetLeft() );
960 ScHelperFunctions::FillBorderLine( rBorder.RightLine, rOuter.GetRight() );
961 ScHelperFunctions::FillBorderLine( rBorder.HorizontalLine, rInner.GetHori() );
962 ScHelperFunctions::FillBorderLine( rBorder.VerticalLine, rInner.GetVert() );
963
964 rBorder.Distance = rOuter.GetSmallestDistance();
965 rBorder.IsTopLineValid = rInner.IsValid(SvxBoxInfoItemValidFlags::TOP);
966 rBorder.IsBottomLineValid = rInner.IsValid(SvxBoxInfoItemValidFlags::BOTTOM);
967 rBorder.IsLeftLineValid = rInner.IsValid(SvxBoxInfoItemValidFlags::LEFT);
968 rBorder.IsRightLineValid = rInner.IsValid(SvxBoxInfoItemValidFlags::RIGHT);
969 rBorder.IsHorizontalLineValid = !bInvalidateHorVerDist && rInner.IsValid(SvxBoxInfoItemValidFlags::HORI);
970 rBorder.IsVerticalLineValid = !bInvalidateHorVerDist && rInner.IsValid(SvxBoxInfoItemValidFlags::VERT);
971 rBorder.IsDistanceValid = !bInvalidateHorVerDist && rInner.IsValid(SvxBoxInfoItemValidFlags::DISTANCE);
972 }
973 }
974
975 void ScHelperFunctions::AssignTableBorderToAny( uno::Any& rAny,
976 const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner, bool bInvalidateHorVerDist )
977 {
978 table::TableBorder aBorder;
979 lcl_fillTableBorder( aBorder, rOuter, rInner, bInvalidateHorVerDist);
980 rAny <<= aBorder;
981 }
982
983 void ScHelperFunctions::AssignTableBorder2ToAny( uno::Any& rAny,
984 const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner, bool bInvalidateHorVerDist )
985 {
986 table::TableBorder2 aBorder;
987 lcl_fillTableBorder( aBorder, rOuter, rInner, bInvalidateHorVerDist);
988 rAny <<= aBorder;
989 }
990
991 //! move lcl_ApplyBorder to docfunc !
992
993 void ScHelperFunctions::ApplyBorder( ScDocShell* pDocShell, const ScRangeList& rRanges,
994 const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner )
995 {
996 ScDocument& rDoc = pDocShell->GetDocument();
997 bool bUndo(rDoc.IsUndoEnabled());
998 ScDocumentUniquePtr pUndoDoc;
999 if (bUndo)
1000 pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
1001 size_t nCount = rRanges.size();
1002 for (size_t i = 0; i < nCount; ++i)
1003 {
1004 ScRange const & rRange = rRanges[ i ];
1005 SCTAB nTab = rRange.aStart.Tab();
1006
1007 if (bUndo)
1008 {
1009 if ( i==0 )
1010 pUndoDoc->InitUndo( rDoc, nTab, nTab );
1011 else
1012 pUndoDoc->AddUndoTab( nTab, nTab );
1013 rDoc.CopyToDocument(rRange, InsertDeleteFlags::ATTRIB, false, *pUndoDoc);
1014 }
1015
1016 ScMarkData aMark(rDoc.GetSheetLimits());
1017 aMark.SetMarkArea( rRange );
1018 aMark.SelectTable( nTab, true );
1019
1020 rDoc.ApplySelectionFrame(aMark, rOuter, &rInner);
1021 // don't need RowHeight if there is only a border
1022 }
1023
1024 if (bUndo)
1025 {
1026 pDocShell->GetUndoManager()->AddUndoAction(
1027 std::make_unique<ScUndoBorder>( pDocShell, rRanges, std::move(pUndoDoc), rOuter, rInner ) );
1028 }
1029
1030 for (size_t i = 0; i < nCount; ++i )
1031 pDocShell->PostPaint( rRanges[ i ], PaintPartFlags::Grid, SC_PF_LINES | SC_PF_TESTMERGE );
1032
1033 pDocShell->SetDocumentModified();
1034 }
1035
1036 //! move lcl_PutDataArray to docfunc?
1037 //! merge loop with ScFunctionAccess::callFunction
1038
1039 static bool lcl_PutDataArray( ScDocShell& rDocShell, const ScRange& rRange,
1040 const uno::Sequence< uno::Sequence<uno::Any> >& aData )
1041 {
1042 ScDocument& rDoc = rDocShell.GetDocument();
1043 ScFieldEditEngine& rEngine = rDoc.GetEditEngine();
1044 SCTAB nTab = rRange.aStart.Tab();
1045 SCCOL nStartCol = rRange.aStart.Col();
1046 SCROW nStartRow = rRange.aStart.Row();
1047 SCCOL nEndCol = rRange.aEnd.Col();
1048 SCROW nEndRow = rRange.aEnd.Row();
1049 bool bUndo(rDoc.IsUndoEnabled());
1050
1051 if ( !rDoc.IsBlockEditable( nTab, nStartCol,nStartRow, nEndCol,nEndRow ) )
1052 {
1053 //! error message
1054 return false;
1055 }
1056
1057 sal_Int32 nCols = 0;
1058 sal_Int32 nRows = aData.getLength();
1059 if ( nRows )
1060 nCols = aData[0].getLength();
1061
1062 if ( nCols != nEndCol-nStartCol+1 || nRows != nEndRow-nStartRow+1 )
1063 {
1064 //! error message?
1065 return false;
1066 }
1067
1068 ScDocumentUniquePtr pUndoDoc;
1069 if ( bUndo )
1070 {
1071 pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
1072 pUndoDoc->InitUndo( rDoc, nTab, nTab );
1073 rDoc.CopyToDocument(rRange, InsertDeleteFlags::CONTENTS|InsertDeleteFlags::NOCAPTIONS, false, *pUndoDoc);
1074 }
1075
1076 rDoc.DeleteAreaTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, InsertDeleteFlags::CONTENTS );
1077
1078 bool bError = false;
1079 SCROW nDocRow = nStartRow;
1080 for (const uno::Sequence<uno::Any>& rColSeq : aData)
1081 {
1082 if ( rColSeq.getLength() == nCols )
1083 {
1084 SCCOL nDocCol = nStartCol;
1085 for (const uno::Any& rElement : rColSeq)
1086 {
1087 ScAddress aPos(nDocCol, nDocRow, nTab);
1088
1089 switch( rElement.getValueTypeClass() )
1090 {
1091 case uno::TypeClass_VOID:
1092 {
1093 // void = "no value"
1094 rDoc.SetError( nDocCol, nDocRow, nTab, FormulaError::NotAvailable );
1095 }
1096 break;
1097
1098 // #87871# accept integer types because Basic passes a floating point
1099 // variable as byte, short or long if it's an integer number.
1100 case uno::TypeClass_BYTE:
1101 case uno::TypeClass_SHORT:
1102 case uno::TypeClass_UNSIGNED_SHORT:
1103 case uno::TypeClass_LONG:
1104 case uno::TypeClass_UNSIGNED_LONG:
1105 case uno::TypeClass_FLOAT:
1106 case uno::TypeClass_DOUBLE:
1107 {
1108 double fVal(0.0);
1109 rElement >>= fVal;
1110 rDoc.SetValue(aPos, fVal);
1111 }
1112 break;
1113
1114 case uno::TypeClass_STRING:
1115 {
1116 OUString aUStr;
1117 rElement >>= aUStr;
1118 if ( !aUStr.isEmpty() )
1119 {
1120 // tdf#146454 - check for a multiline string since setting an edit
1121 // or string cell is in magnitudes slower than setting a plain string
1122 if (ScStringUtil::isMultiline(aUStr))
1123 {
1124 rEngine.SetTextCurrentDefaults(aUStr);
1125 rDoc.SetEditText(aPos, rEngine.CreateTextObject());
1126 }
1127 else
1128 {
1129 ScSetStringParam aParam;
1130 aParam.setTextInput();
1131 rDoc.SetString(aPos, aUStr, &aParam);
1132 }
1133 }
1134 }
1135 break;
1136
1137 // accept Sequence<FormulaToken> for formula cells
1138 case uno::TypeClass_SEQUENCE:
1139 {
1140 uno::Sequence< sheet::FormulaToken > aTokens;
1141 if ( rElement >>= aTokens )
1142 {
1143 ScTokenArray aTokenArray(rDoc);
1144 ScTokenConversion::ConvertToTokenArray( rDoc, aTokenArray, aTokens );
1145 rDoc.SetFormula(aPos, aTokenArray);
1146 }
1147 else
1148 bError = true;
1149 }
1150 break;
1151
1152 default:
1153 bError = true; // invalid type
1154 }
1155 ++nDocCol;
1156 }
1157 }
1158 else
1159 bError = true; // wrong size
1160
1161 ++nDocRow;
1162 }
1163
1164 bool bHeight = rDocShell.AdjustRowHeight( nStartRow, nEndRow, nTab );
1165
1166 if ( pUndoDoc )
1167 {
1168 ScMarkData aDestMark(rDoc.GetSheetLimits());
1169 aDestMark.SelectOneTable( nTab );
1170 rDocShell.GetUndoManager()->AddUndoAction(
1171 std::make_unique<ScUndoPaste>(
1172 &rDocShell, ScRange(nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab),
1173 aDestMark, std::move(pUndoDoc), nullptr, InsertDeleteFlags::CONTENTS, nullptr, false));
1174 }
1175
1176 if (!bHeight)
1177 rDocShell.PostPaint( rRange, PaintPartFlags::Grid ); // AdjustRowHeight may have painted already
1178
1179 rDocShell.SetDocumentModified();
1180
1181 return !bError;
1182 }
1183
1184 static bool lcl_PutFormulaArray( ScDocShell& rDocShell, const ScRange& rRange,
1185 const uno::Sequence< uno::Sequence<OUString> >& aData,
1186 const formula::FormulaGrammar::Grammar eGrammar )
1187 {
1188 ScDocument& rDoc = rDocShell.GetDocument();
1189 SCTAB nTab = rRange.aStart.Tab();
1190 SCCOL nStartCol = rRange.aStart.Col();
1191 SCROW nStartRow = rRange.aStart.Row();
1192 SCCOL nEndCol = rRange.aEnd.Col();
1193 SCROW nEndRow = rRange.aEnd.Row();
1194 bool bUndo(rDoc.IsUndoEnabled());
1195
1196 if ( !rDoc.IsBlockEditable( nTab, nStartCol,nStartRow, nEndCol,nEndRow ) )
1197 {
1198 //! error message
1199 return false;
1200 }
1201
1202 sal_Int32 nCols = 0;
1203 sal_Int32 nRows = aData.getLength();
1204 if ( nRows )
1205 nCols = aData[0].getLength();
1206
1207 if ( nCols != nEndCol-nStartCol+1 || nRows != nEndRow-nStartRow+1 )
1208 {
1209 //! error message?
1210 return false;
1211 }
1212
1213 ScDocumentUniquePtr pUndoDoc;
1214 if ( bUndo )
1215 {
1216 pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
1217 pUndoDoc->InitUndo( rDoc, nTab, nTab );
1218 rDoc.CopyToDocument(rRange, InsertDeleteFlags::CONTENTS, false, *pUndoDoc);
1219 }
1220
1221 rDoc.DeleteAreaTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, InsertDeleteFlags::CONTENTS );
1222
1223 bool bError = false;
1224 SCROW nDocRow = nStartRow;
1225 for (const uno::Sequence<OUString>& rColSeq : aData)
1226 {
1227 if ( rColSeq.getLength() == nCols )
1228 {
1229 SCCOL nDocCol = nStartCol;
1230 for (const OUString& aText : rColSeq)
1231 {
1232 ScAddress aPos( nDocCol, nDocRow, nTab );
1233
1234 ScInputStringType aRes =
1235 ScStringUtil::parseInputString(
1236 rDoc.GetNonThreadedContext(), aText, LANGUAGE_ENGLISH_US);
1237 switch (aRes.meType)
1238 {
1239 case ScInputStringType::Formula:
1240 rDoc.SetFormula(aPos, aRes.maText, eGrammar);
1241 break;
1242 case ScInputStringType::Number:
1243 rDoc.SetValue(aPos, aRes.mfValue);
1244 break;
1245 case ScInputStringType::Text:
1246 rDoc.SetTextCell(aPos, aRes.maText);
1247 break;
1248 default:
1249 ;
1250 }
1251
1252 ++nDocCol;
1253 }
1254 }
1255 else
1256 bError = true; // wrong size
1257
1258 ++nDocRow;
1259 }
1260
1261 bool bHeight = rDocShell.AdjustRowHeight( nStartRow, nEndRow, nTab );
1262
1263 if ( pUndoDoc )
1264 {
1265 ScMarkData aDestMark(rDoc.GetSheetLimits());
1266 aDestMark.SelectOneTable( nTab );
1267 rDocShell.GetUndoManager()->AddUndoAction(
1268 std::make_unique<ScUndoPaste>( &rDocShell,
1269 ScRange(nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab), aDestMark,
1270 std::move(pUndoDoc), nullptr, InsertDeleteFlags::CONTENTS, nullptr, false));
1271 }
1272
1273 if (!bHeight)
1274 rDocShell.PostPaint( rRange, PaintPartFlags::Grid ); // AdjustRowHeight may have painted already
1275
1276 rDocShell.SetDocumentModified();
1277
1278 return !bError;
1279 }
1280
1281 // used in ScCellRangeObj::getFormulaArray and ScCellObj::GetInputString_Impl
1282 static OUString lcl_GetInputString( ScDocument& rDoc, const ScAddress& rPos, bool bEnglish )
1283 {
1284 ScRefCellValue aCell(rDoc, rPos);
1285 if (aCell.isEmpty())
1286 return OUString();
1287
1288 OUString aVal;
1289
1290 CellType eType = aCell.getType();
1291 if (eType == CELLTYPE_FORMULA)
1292 {
1293 ScFormulaCell* pForm = aCell.getFormula();
1294 return pForm->GetFormula( formula::FormulaGrammar::mapAPItoGrammar( bEnglish, false));
1295 }
1296
1297 // use an InterpreterContext, possibly with a different formatter, to uniformly use
1298 // ScCellFormat::GetInputString everywhere
1299 ScInterpreterContextGetterGuard aContextGetterGuard(rDoc, bEnglish ? ScGlobal::GetEnglishFormatter()
1300 : rDoc.GetFormatTable());
1301 ScInterpreterContext* pInterpreterContext = aContextGetterGuard.GetInterpreterContext();
1302
1303 // Since the English formatter was constructed with
1304 // LANGUAGE_ENGLISH_US the "General" format has index key 0,
1305 // we don't have to query.
1306 sal_uInt32 nNumFmt = bEnglish ? 0 : rDoc.GetNumberFormat(ScRange(rPos));
1307
1308 if (eType == CELLTYPE_EDIT)
1309 {
1310 // GetString on EditCell turns breaks into spaces,
1311 // but we need the breaks here
1312 const EditTextObject* pData = aCell.getEditText();
1313 if (pData)
1314 {
1315 EditEngine& rEngine = rDoc.GetEditEngine();
1316 rEngine.SetText(*pData);
1317 aVal = rEngine.GetText();
1318 }
1319 }
1320 else
1321 aVal = ScCellFormat::GetInputString(aCell, nNumFmt, pInterpreterContext, rDoc);
1322
1323 // if applicable, prepend ' like in ScTabViewShell::UpdateInputHandler
1324 if ( eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT )
1325 {
1326 double fDummy;
1327 OUString aTempString = aVal;
1328 bool bIsNumberFormat(pInterpreterContext->NFIsNumberFormat(aTempString, nNumFmt, fDummy));
1329 if ( bIsNumberFormat )
1330 aTempString = "'" + aTempString;
1331 else if ( aTempString.startsWith("'") )
1332 {
1333 // if the string starts with a "'", add another one because setFormula
1334 // strips one (like text input, except for "text" number formats)
1335 if ( bEnglish || ( pInterpreterContext->NFGetType(nNumFmt) != SvNumFormatType::TEXT ) )
1336 aTempString = "'" + aTempString;
1337 }
1338 aVal = aTempString;
1339 }
1340
1341 return aVal;
1342 }
1343
1344 ScCellRangesBase::ScCellRangesBase(ScDocShell* pDocSh, const ScRange& rR) :
1345 pPropSet(lcl_GetCellsPropertySet()),
1346 pDocShell( pDocSh ),
1347 nObjectId( 0 ),
1348 bChartColAsHdr( false ),
1349 bChartRowAsHdr( false ),
1350 bCursorOnly( false ),
1351 bGotDataChangedHint( false ),
1352 aValueListeners( 0 )
1353 {
1354 ScRange aCellRange(rR);
1355 aCellRange.PutInOrder();
1356 aRanges.push_back( aCellRange );
1357
1358 if (pDocShell) // Null if created with createInstance
1359 {
1360 ScDocument& rDoc = pDocShell->GetDocument();
1361 rDoc.AddUnoObject(*this);
1362 nObjectId = rDoc.GetNewUnoId();
1363 }
1364 }
1365
1366 ScCellRangesBase::ScCellRangesBase(ScDocShell* pDocSh, ScRangeList aR) :
1367 pPropSet(lcl_GetCellsPropertySet()),
1368 pDocShell( pDocSh ),
1369 aRanges(std::move( aR )),
1370 nObjectId( 0 ),
1371 bChartColAsHdr( false ),
1372 bChartRowAsHdr( false ),
1373 bCursorOnly( false ),
1374 bGotDataChangedHint( false ),
1375 aValueListeners( 0 )
1376 {
1377 if (pDocShell) // Null if created with createInstance
1378 {
1379 ScDocument& rDoc = pDocShell->GetDocument();
1380 rDoc.AddUnoObject(*this);
1381 nObjectId = rDoc.GetNewUnoId();
1382 }
1383 }
1384
1385 ScCellRangesBase::~ScCellRangesBase()
1386 {
1387 SolarMutexGuard g;
1388
1389 // call RemoveUnoObject first, so no notification can happen
1390 // during ForgetCurrentAttrs
1391
1392 if (pDocShell)
1393 pDocShell->GetDocument().RemoveUnoObject(*this);
1394
1395 ForgetCurrentAttrs();
1396 ForgetMarkData();
1397
1398 pValueListener.reset();
1399
1400 //! unregister XChartDataChangeEventListener ??
1401 //! (ChartCollection will then hold this object as well!)
1402 }
1403
1404 void ScCellRangesBase::ForgetCurrentAttrs()
1405 {
1406 pCurrentFlat.reset();
1407 pCurrentDeep.reset();
1408 moCurrentDataSet.reset();
1409 moNoDfltCurrentDataSet.reset();
1410
1411 // #i62483# pMarkData can remain unchanged, is deleted only if the range changes (RefChanged)
1412 }
1413
1414 void ScCellRangesBase::ForgetMarkData()
1415 {
1416 pMarkData.reset();
1417 }
1418
1419 const ScPatternAttr* ScCellRangesBase::GetCurrentAttrsFlat()
1420 {
1421 // get and cache direct cell attributes for this object's range
1422
1423 if ( !pCurrentFlat && pDocShell )
1424 {
1425 ScDocument& rDoc = pDocShell->GetDocument();
1426 pCurrentFlat = rDoc.CreateSelectionPattern( *GetMarkData(), false );
1427 }
1428 return pCurrentFlat.get();
1429 }
1430
1431 const ScPatternAttr* ScCellRangesBase::GetCurrentAttrsDeep()
1432 {
1433 // get and cache cell attributes (incl. styles) for this object's range
1434
1435 if ( !pCurrentDeep && pDocShell )
1436 {
1437 ScDocument& rDoc = pDocShell->GetDocument();
1438 pCurrentDeep = rDoc.CreateSelectionPattern( *GetMarkData() );
1439 }
1440 return pCurrentDeep.get();
1441 }
1442
1443 SfxItemSet* ScCellRangesBase::GetCurrentDataSet(bool bNoDflt)
1444 {
1445 if(!moCurrentDataSet)
1446 {
1447 const ScPatternAttr* pPattern = GetCurrentAttrsDeep();
1448 if ( pPattern )
1449 {
1450 // replace Dontcare with Default, so that we always have a reflection
1451 moCurrentDataSet.emplace( pPattern->GetItemSet() );
1452 moNoDfltCurrentDataSet.emplace( pPattern->GetItemSet() );
1453 moCurrentDataSet->ClearInvalidItems();
1454 }
1455 }
1456 if (bNoDflt)
1457 {
1458 if (moNoDfltCurrentDataSet)
1459 return &*moNoDfltCurrentDataSet;
1460 }
1461 else
1462 {
1463 if (moCurrentDataSet)
1464 return &*moCurrentDataSet;
1465 }
1466 return nullptr;
1467 }
1468
1469 const ScMarkData* ScCellRangesBase::GetMarkData()
1470 {
1471 if (!pMarkData)
1472 {
1473 pMarkData.reset( new ScMarkData(GetDocument()->GetSheetLimits(), aRanges) );
1474 }
1475 return pMarkData.get();
1476 }
1477
1478 void ScCellRangesBase::Notify( SfxBroadcaster&, const SfxHint& rHint )
1479 {
1480 const SfxHintId nId = rHint.GetId();
1481 if ( nId == SfxHintId::Dying )
1482 {
1483 // if the document dies, must reset to avoid crash in dtor!
1484 ForgetCurrentAttrs();
1485 pDocShell = nullptr; // invalid
1486
1487 // fdo#72695: if UNO object is already dead, don't revive it with event
1488 if ( m_refCount > 0 && !aValueListeners.empty() )
1489 {
1490 // dispose listeners
1491
1492 lang::EventObject aEvent;
1493 aEvent.Source = getXWeak();
1494 for (uno::Reference<util::XModifyListener> & xValueListener : aValueListeners)
1495 xValueListener->disposing( aEvent );
1496
1497 aValueListeners.clear();
1498
1499 // The listeners can't have the last ref to this, as it's still held
1500 // by the DocShell.
1501 }
1502 }
1503 else if ( nId == SfxHintId::DataChanged )
1504 {
1505 // document content changed -> forget cached attributes
1506 ForgetCurrentAttrs();
1507
1508 if ( bGotDataChangedHint && pDocShell )
1509 {
1510 // This object was notified of content changes, so one call
1511 // for each listener is generated now.
1512 // The calls can't be executed directly because the document's
1513 // UNO broadcaster list must not be modified.
1514 // Instead, add to the document's list of listener calls,
1515 // which will be executed directly after the broadcast of
1516 // SfxHintId::DataChanged.
1517
1518 lang::EventObject aEvent;
1519 aEvent.Source = getXWeak();
1520
1521 // the EventObject holds a Ref to this object until after the listener calls
1522
1523 ScDocument& rDoc = pDocShell->GetDocument();
1524 for (const uno::Reference<util::XModifyListener> & xValueListener : aValueListeners)
1525 rDoc.AddUnoListenerCall( xValueListener, aEvent );
1526
1527 bGotDataChangedHint = false;
1528 }
1529 }
1530 else if ( nId == SfxHintId::ScCalcAll )
1531 {
1532 // broadcast from DoHardRecalc - set bGotDataChangedHint
1533 // (SfxHintId::DataChanged follows separately)
1534
1535 if ( !aValueListeners.empty() )
1536 bGotDataChangedHint = true;
1537 }
1538 else if ( rHint.GetId() == SfxHintId::ScUpdateRef )
1539 {
1540 auto pRefHint = static_cast<const ScUpdateRefHint*>(&rHint);
1541 ScDocument& rDoc = pDocShell->GetDocument();
1542 std::unique_ptr<ScRangeList> pUndoRanges;
1543 if ( rDoc.HasUnoRefUndo() )
1544 pUndoRanges.reset(new ScRangeList( aRanges ));
1545
1546 if ( aRanges.UpdateReference( pRefHint->GetMode(), &rDoc, pRefHint->GetRange(),
1547 pRefHint->GetDx(), pRefHint->GetDy(), pRefHint->GetDz() ) )
1548 {
1549 if ( pRefHint->GetMode() == URM_INSDEL
1550 && aRanges.size() == 1
1551 && dynamic_cast<ScTableSheetObj*>(this)
1552 )
1553 {
1554 // #101755#; the range size of a sheet does not change
1555 ScRange & rR = aRanges.front();
1556 rR.aStart.SetCol(0);
1557 rR.aStart.SetRow(0);
1558 rR.aEnd.SetCol(rDoc.MaxCol());
1559 rR.aEnd.SetRow(rDoc.MaxRow());
1560 }
1561 RefChanged();
1562
1563 // any change of the range address is broadcast to value (modify) listeners
1564 if ( !aValueListeners.empty() )
1565 bGotDataChangedHint = true;
1566
1567 if ( pUndoRanges )
1568 rDoc.AddUnoRefChange( nObjectId, *pUndoRanges );
1569 }
1570 }
1571 else if ( rHint.GetId() == SfxHintId::ScUnoRefUndo )
1572 {
1573 auto pUndoHint = static_cast<const ScUnoRefUndoHint*>(&rHint);
1574 if ( pUndoHint->GetObjectId() == nObjectId )
1575 {
1576 // restore ranges from hint
1577
1578 aRanges = pUndoHint->GetRanges();
1579
1580 RefChanged();
1581 if ( !aValueListeners.empty() )
1582 bGotDataChangedHint = true; // need to broadcast the undo, too
1583 }
1584 }
1585 }
1586
1587 void ScCellRangesBase::RefChanged()
1588 {
1589 //! adjust XChartDataChangeEventListener
1590
1591 if ( pValueListener && !aValueListeners.empty() )
1592 {
1593 pValueListener->EndListeningAll();
1594
1595 ScDocument& rDoc = pDocShell->GetDocument();
1596 for ( size_t i = 0, nCount = aRanges.size(); i < nCount; ++i )
1597 rDoc.StartListeningArea( aRanges[ i ], false, pValueListener.get() );
1598 }
1599
1600 ForgetCurrentAttrs();
1601 ForgetMarkData();
1602 }
1603
1604 ScDocument* ScCellRangesBase::GetDocument() const
1605 {
1606 if (pDocShell)
1607 return &pDocShell->GetDocument();
1608 else
1609 return nullptr;
1610 }
1611
1612 void ScCellRangesBase::InitInsertRange(ScDocShell* pDocSh, const ScRange& rR)
1613 {
1614 if ( pDocShell || !pDocSh )
1615 return;
1616
1617 pDocShell = pDocSh;
1618
1619 ScRange aCellRange(rR);
1620 aCellRange.PutInOrder();
1621 aRanges.RemoveAll();
1622 aRanges.push_back( aCellRange );
1623
1624 pDocShell->GetDocument().AddUnoObject(*this);
1625
1626 RefChanged(); // adjust range in range object
1627 }
1628
1629 void ScCellRangesBase::AddRange(const ScRange& rRange, const bool bMergeRanges)
1630 {
1631 if (bMergeRanges)
1632 aRanges.Join(rRange);
1633 else
1634 aRanges.push_back(rRange);
1635 RefChanged();
1636 }
1637
1638 void ScCellRangesBase::SetNewRange(const ScRange& rNew)
1639 {
1640 ScRange aCellRange(rNew);
1641 aCellRange.PutInOrder();
1642
1643 aRanges.RemoveAll();
1644 aRanges.push_back( aCellRange );
1645 RefChanged();
1646 }
1647
1648 void ScCellRangesBase::SetNewRanges(const ScRangeList& rNew)
1649 {
1650 aRanges = rNew;
1651 RefChanged();
1652 }
1653
1654 void ScCellRangesBase::SetCursorOnly( bool bSet )
1655 {
1656 // set for a selection object that is created from the cursor position
1657 // without anything selected (may contain several sheets)
1658
1659 bCursorOnly = bSet;
1660 }
1661
1662 void ScCellRangesBase::PaintGridRanges_Impl( )
1663 {
1664 for (size_t i = 0, nCount = aRanges.size(); i < nCount; ++i)
1665 pDocShell->PostPaint( aRanges[ i ], PaintPartFlags::Grid );
1666 }
1667
1668 // XSheetOperation
1669
1670 double SAL_CALL ScCellRangesBase::computeFunction( sheet::GeneralFunction nFunction )
1671 {
1672 SolarMutexGuard aGuard;
1673 ScMarkData aMark(*GetMarkData());
1674 aMark.MarkToSimple();
1675 if (!aMark.IsMarked())
1676 aMark.SetMarkNegative(true); // so we can enter dummy position
1677
1678 ScAddress aDummy; // if not marked, ignored if it is negative
1679 double fVal;
1680 ScSubTotalFunc eFunc = ScDPUtil::toSubTotalFunc(static_cast<ScGeneralFunction>(nFunction));
1681 ScDocument& rDoc = pDocShell->GetDocument();
1682 if ( !rDoc.GetSelectionFunction( eFunc, aDummy, aMark, fVal ) )
1683 {
1684 throw uno::RuntimeException(); //! own exception?
1685 }
1686
1687 return fVal;
1688 }
1689
1690 void SAL_CALL ScCellRangesBase::clearContents( sal_Int32 nContentFlags )
1691 {
1692 SolarMutexGuard aGuard;
1693 if ( !aRanges.empty() )
1694 {
1695 // only for clearContents: EDITATTR is only used if no contents are deleted
1696 InsertDeleteFlags nDelFlags = static_cast<InsertDeleteFlags>(nContentFlags) & InsertDeleteFlags::ALL;
1697 if ( ( nDelFlags & InsertDeleteFlags::EDITATTR ) && ( nDelFlags & InsertDeleteFlags::CONTENTS ) == InsertDeleteFlags::NONE )
1698 nDelFlags |= InsertDeleteFlags::EDITATTR;
1699
1700 pDocShell->GetDocFunc().DeleteContents( *GetMarkData(), nDelFlags, true, true );
1701 }
1702 // otherwise nothing to do
1703 }
1704
1705 // XPropertyState
1706
1707 const SfxItemPropertyMap& ScCellRangesBase::GetItemPropertyMap()
1708 {
1709 return pPropSet->getPropertyMap();
1710 }
1711
1712 static void lcl_GetPropertyWhich( const SfxItemPropertyMapEntry* pEntry,
1713 sal_uInt16& rItemWhich )
1714 {
1715 // Which-ID of the affected items also when the item can't handle
1716 // the property by itself
1717 if ( !pEntry )
1718 return;
1719
1720 if ( IsScItemWid( pEntry->nWID ) )
1721 rItemWhich = pEntry->nWID;
1722 else
1723 switch ( pEntry->nWID )
1724 {
1725 case SC_WID_UNO_TBLBORD:
1726 case SC_WID_UNO_TBLBORD2:
1727 rItemWhich = ATTR_BORDER;
1728 break;
1729 case SC_WID_UNO_CONDFMT:
1730 case SC_WID_UNO_CONDLOC:
1731 case SC_WID_UNO_CONDXML:
1732 rItemWhich = ATTR_CONDITIONAL;
1733 break;
1734 case SC_WID_UNO_VALIDAT:
1735 case SC_WID_UNO_VALILOC:
1736 case SC_WID_UNO_VALIXML:
1737 rItemWhich = ATTR_VALIDDATA;
1738 break;
1739 }
1740
1741 }
1742
1743 beans::PropertyState ScCellRangesBase::GetOnePropertyState( sal_uInt16 nItemWhich, const SfxItemPropertyMapEntry* pEntry )
1744 {
1745 beans::PropertyState eRet = beans::PropertyState_DIRECT_VALUE;
1746 if ( nItemWhich ) // item wid (from map or special case)
1747 {
1748 // For items that contain several properties (like background),
1749 // "ambiguous" is returned too often here
1750
1751 // for PropertyState, don't look at styles
1752 const ScPatternAttr* pPattern = GetCurrentAttrsFlat();
1753 if ( pPattern )
1754 {
1755 SfxItemState eState = pPattern->GetItemSet().GetItemState( nItemWhich, false );
1756
1757 if ( nItemWhich == ATTR_VALUE_FORMAT && eState == SfxItemState::DEFAULT )
1758 eState = pPattern->GetItemSet().GetItemState( ATTR_LANGUAGE_FORMAT, false );
1759
1760 if ( eState == SfxItemState::SET )
1761 eRet = beans::PropertyState_DIRECT_VALUE;
1762 else if ( eState == SfxItemState::DEFAULT )
1763 eRet = beans::PropertyState_DEFAULT_VALUE;
1764 else if ( eState == SfxItemState::INVALID )
1765 eRet = beans::PropertyState_AMBIGUOUS_VALUE;
1766 else
1767 {
1768 OSL_FAIL("unknown ItemState");
1769 }
1770 }
1771 }
1772 else if ( pEntry )
1773 {
1774 if ( pEntry->nWID == SC_WID_UNO_CHCOLHDR || pEntry->nWID == SC_WID_UNO_CHROWHDR || pEntry->nWID == SC_WID_UNO_ABSNAME )
1775 eRet = beans::PropertyState_DIRECT_VALUE;
1776 else if ( pEntry->nWID == SC_WID_UNO_CELLSTYL )
1777 {
1778 // a style is always set, there's no default state
1779 const ScStyleSheet* pStyle = pDocShell->GetDocument().GetSelectionStyle(*GetMarkData());
1780 if (pStyle)
1781 eRet = beans::PropertyState_DIRECT_VALUE;
1782 else
1783 eRet = beans::PropertyState_AMBIGUOUS_VALUE;
1784 }
1785 else if ( pEntry->nWID == SC_WID_UNO_NUMRULES )
1786 eRet = beans::PropertyState_DEFAULT_VALUE; // numbering rules are always default
1787 }
1788 return eRet;
1789 }
1790
1791 beans::PropertyState SAL_CALL ScCellRangesBase::getPropertyState( const OUString& aPropertyName )
1792 {
1793 SolarMutexGuard aGuard;
1794 if ( aRanges.empty() )
1795 throw uno::RuntimeException();
1796
1797 const SfxItemPropertyMap& rMap = GetItemPropertyMap(); // from derived class
1798 sal_uInt16 nItemWhich = 0;
1799 const SfxItemPropertyMapEntry* pEntry = rMap.getByName( aPropertyName );
1800 lcl_GetPropertyWhich( pEntry, nItemWhich );
1801 return GetOnePropertyState( nItemWhich, pEntry );
1802 }
1803
1804 uno::Sequence<beans::PropertyState> SAL_CALL ScCellRangesBase::getPropertyStates(
1805 const uno::Sequence<OUString>& aPropertyNames )
1806 {
1807 SolarMutexGuard aGuard;
1808
1809 const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
1810
1811 uno::Sequence<beans::PropertyState> aRet(aPropertyNames.getLength());
1812 std::transform(aPropertyNames.begin(), aPropertyNames.end(), aRet.getArray(),
1813 [this, &rPropertyMap](const auto& rName) -> beans::PropertyState {
1814 sal_uInt16 nItemWhich = 0;
1815 const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( rName );
1816 lcl_GetPropertyWhich( pEntry, nItemWhich );
1817 return GetOnePropertyState(nItemWhich, pEntry);
1818 });
1819 return aRet;
1820 }
1821
1822 void SAL_CALL ScCellRangesBase::setPropertyToDefault( const OUString& aPropertyName )
1823 {
1824 SolarMutexGuard aGuard;
1825 if ( !pDocShell )
1826 return;
1827
1828 const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
1829 sal_uInt16 nItemWhich = 0;
1830 const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1831 lcl_GetPropertyWhich( pEntry, nItemWhich );
1832 if ( nItemWhich ) // item wid (from map or special case)
1833 {
1834 if ( !aRanges.empty() ) // empty = nothing to do
1835 {
1836 //! for items that have multiple properties (e.g. background)
1837 //! too much will be reset
1838 //! for ATTR_ROTATE_VALUE, reset ATTR_ORIENTATION as well?
1839
1840 sal_uInt16 aWIDs[3];
1841 aWIDs[0] = nItemWhich;
1842 if ( nItemWhich == ATTR_VALUE_FORMAT )
1843 {
1844 aWIDs[1] = ATTR_LANGUAGE_FORMAT; // language for number formats
1845 aWIDs[2] = 0;
1846 }
1847 else
1848 aWIDs[1] = 0;
1849 pDocShell->GetDocFunc().ClearItems( *GetMarkData(), aWIDs, true );
1850 }
1851 }
1852 else if ( pEntry )
1853 {
1854 if ( pEntry->nWID == SC_WID_UNO_CHCOLHDR )
1855 bChartColAsHdr = false;
1856 else if ( pEntry->nWID == SC_WID_UNO_CHROWHDR )
1857 bChartRowAsHdr = false;
1858 else if ( pEntry->nWID == SC_WID_UNO_CELLSTYL )
1859 {
1860 OUString aStyleName( ScResId( STR_STYLENAME_STANDARD ) );
1861 pDocShell->GetDocFunc().ApplyStyle( *GetMarkData(), aStyleName, true );
1862 }
1863 }
1864 }
1865
1866 uno::Any SAL_CALL ScCellRangesBase::getPropertyDefault( const OUString& aPropertyName )
1867 {
1868 //! bundle with getPropertyValue
1869
1870 SolarMutexGuard aGuard;
1871 uno::Any aAny;
1872
1873 if ( pDocShell )
1874 {
1875 ScDocument& rDoc = pDocShell->GetDocument();
1876 const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
1877 const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1878 if ( pEntry )
1879 {
1880 if ( IsScItemWid( pEntry->nWID ) )
1881 {
1882 const ScPatternAttr* pPattern(&rDoc.getCellAttributeHelper().getDefaultCellAttribute());
1883 if ( pPattern )
1884 {
1885 const SfxItemSet& rSet = pPattern->GetItemSet();
1886
1887 switch ( pEntry->nWID ) // for item-specific handling
1888 {
1889 case ATTR_VALUE_FORMAT:
1890 // default has no language set
1891 aAny <<= static_cast<sal_Int32>( static_cast<const SfxUInt32Item&>(rSet.Get(pEntry->nWID)).GetValue() );
1892 break;
1893 case ATTR_INDENT:
1894 aAny <<= static_cast<sal_Int16>( convertTwipToMm100(static_cast<const ScIndentItem&>(
1895 rSet.Get(pEntry->nWID)).GetValue()) );
1896 break;
1897 default:
1898 pPropSet->getPropertyValue(aPropertyName, rSet, aAny);
1899 }
1900 }
1901 }
1902 else
1903 switch ( pEntry->nWID )
1904 {
1905 case SC_WID_UNO_CHCOLHDR:
1906 case SC_WID_UNO_CHROWHDR:
1907 aAny <<= false;
1908 break;
1909 case SC_WID_UNO_CELLSTYL:
1910 aAny <<= ScStyleNameConversion::DisplayToProgrammaticName(
1911 ScResId(STR_STYLENAME_STANDARD), SfxStyleFamily::Para );
1912 break;
1913 case SC_WID_UNO_TBLBORD:
1914 case SC_WID_UNO_TBLBORD2:
1915 {
1916 const ScPatternAttr* pPattern(&rDoc.getCellAttributeHelper().getDefaultCellAttribute());
1917 if ( pPattern )
1918 {
1919 if (pEntry->nWID == SC_WID_UNO_TBLBORD2)
1920 ScHelperFunctions::AssignTableBorder2ToAny( aAny,
1921 pPattern->GetItem(ATTR_BORDER),
1922 pPattern->GetItem(ATTR_BORDER_INNER) );
1923 else
1924 ScHelperFunctions::AssignTableBorderToAny( aAny,
1925 pPattern->GetItem(ATTR_BORDER),
1926 pPattern->GetItem(ATTR_BORDER_INNER) );
1927 }
1928 }
1929 break;
1930 case SC_WID_UNO_CONDFMT:
1931 case SC_WID_UNO_CONDLOC:
1932 case SC_WID_UNO_CONDXML:
1933 {
1934 bool bEnglish = ( pEntry->nWID != SC_WID_UNO_CONDLOC );
1935 bool bXML = ( pEntry->nWID == SC_WID_UNO_CONDXML );
1936 formula::FormulaGrammar::Grammar eGrammar = (bXML ?
1937 rDoc.GetStorageGrammar() :
1938 formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
1939
1940 aAny <<= uno::Reference<sheet::XSheetConditionalEntries>(
1941 new ScTableConditionalFormat( &rDoc, 0, aRanges[0].aStart.Tab(), eGrammar ));
1942 }
1943 break;
1944 case SC_WID_UNO_VALIDAT:
1945 case SC_WID_UNO_VALILOC:
1946 case SC_WID_UNO_VALIXML:
1947 {
1948 bool bEnglish = ( pEntry->nWID != SC_WID_UNO_VALILOC );
1949 bool bXML = ( pEntry->nWID == SC_WID_UNO_VALIXML );
1950 formula::FormulaGrammar::Grammar eGrammar = (bXML ?
1951 rDoc.GetStorageGrammar() :
1952 formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
1953
1954 aAny <<= uno::Reference<beans::XPropertySet>(
1955 new ScTableValidationObj( rDoc, 0, eGrammar ));
1956 }
1957 break;
1958 case SC_WID_UNO_NUMRULES:
1959 {
1960 aAny <<= ScStyleObj::CreateEmptyNumberingRules();
1961 }
1962 break;
1963 }
1964 }
1965 }
1966
1967 return aAny;
1968 }
1969
1970 // XPropertySet
1971
1972 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCellRangesBase::getPropertySetInfo()
1973 {
1974 SolarMutexGuard aGuard;
1975 static uno::Reference<beans::XPropertySetInfo> aRef(
1976 new SfxItemPropertySetInfo( pPropSet->getPropertyMap() ));
1977 return aRef;
1978 }
1979
1980 static void lcl_SetCellProperty( const SfxItemPropertyMapEntry& rEntry, const uno::Any& rValue,
1981 ScPatternAttr& rPattern, const ScDocument &rDoc,
1982 sal_uInt16& rFirstItemId, sal_uInt16& rSecondItemId )
1983 {
1984 rFirstItemId = rEntry.nWID;
1985 rSecondItemId = 0;
1986
1987 SfxItemSet& rSet = rPattern.GetItemSet();
1988 switch ( rEntry.nWID )
1989 {
1990 case ATTR_VALUE_FORMAT:
1991 {
1992 // language for number formats
1993 SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
1994 sal_uLong nOldFormat = rSet.Get( ATTR_VALUE_FORMAT ).GetValue();
1995 LanguageType eOldLang = rSet.Get( ATTR_LANGUAGE_FORMAT ).GetLanguage();
1996 nOldFormat = pFormatter->GetFormatForLanguageIfBuiltIn( nOldFormat, eOldLang );
1997
1998 sal_Int32 nIntVal = 0;
1999 if ( !(rValue >>= nIntVal) )
2000 throw lang::IllegalArgumentException();
2001
2002 sal_uLong nNewFormat = static_cast<sal_uLong>(nIntVal);
2003 rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat ) );
2004
2005 const SvNumberformat* pNewEntry = pFormatter->GetEntry( nNewFormat );
2006 LanguageType eNewLang =
2007 pNewEntry ? pNewEntry->GetLanguage() : LANGUAGE_DONTKNOW;
2008 if ( eNewLang != eOldLang && eNewLang != LANGUAGE_DONTKNOW )
2009 {
2010 rSet.Put( SvxLanguageItem( eNewLang, ATTR_LANGUAGE_FORMAT ) );
2011
2012 // if only language is changed,
2013 // don't touch number format attribute
2014 sal_uLong nNewMod = nNewFormat % SV_COUNTRY_LANGUAGE_OFFSET;
2015 if ( nNewMod == ( nOldFormat % SV_COUNTRY_LANGUAGE_OFFSET ) &&
2016 nNewMod <= SV_MAX_COUNT_STANDARD_FORMATS )
2017 {
2018 rFirstItemId = 0; // don't use ATTR_VALUE_FORMAT value
2019 }
2020
2021 rSecondItemId = ATTR_LANGUAGE_FORMAT;
2022 }
2023
2024 }
2025 break;
2026 case ATTR_INDENT:
2027 {
2028 sal_Int16 nIntVal = 0;
2029 if ( !(rValue >>= nIntVal) )
2030 throw lang::IllegalArgumentException();
2031
2032 rSet.Put(ScIndentItem(o3tl::toTwips(nIntVal, o3tl::Length::mm100)));
2033
2034 }
2035 break;
2036 case ATTR_ROTATE_VALUE:
2037 {
2038 sal_Int32 nRotVal = 0;
2039 if ( !(rValue >>= nRotVal) )
2040 throw lang::IllegalArgumentException();
2041
2042 // stored value is always between 0 and 360 deg.
2043 nRotVal %= 36000;
2044 if ( nRotVal < 0 )
2045 nRotVal += 36000;
2046
2047 rSet.Put( ScRotateValueItem( Degree100(nRotVal) ) );
2048
2049 }
2050 break;
2051 case ATTR_STACKED:
2052 {
2053 table::CellOrientation eOrient;
2054 if( rValue >>= eOrient )
2055 {
2056 switch( eOrient )
2057 {
2058 case table::CellOrientation_STANDARD:
2059 rSet.Put( ScVerticalStackCell( false ) );
2060 break;
2061 case table::CellOrientation_TOPBOTTOM:
2062 rSet.Put( ScVerticalStackCell( false ) );
2063 rSet.Put( ScRotateValueItem( 27000_deg100 ) );
2064 rSecondItemId = ATTR_ROTATE_VALUE;
2065 break;
2066 case table::CellOrientation_BOTTOMTOP:
2067 rSet.Put( ScVerticalStackCell( false ) );
2068 rSet.Put( ScRotateValueItem( 9000_deg100 ) );
2069 rSecondItemId = ATTR_ROTATE_VALUE;
2070 break;
2071 case table::CellOrientation_STACKED:
2072 rSet.Put( ScVerticalStackCell( true ) );
2073 break;
2074 default:
2075 {
2076 // added to avoid warnings
2077 }
2078 }
2079 }
2080 }
2081 break;
2082 default:
2083 {
2084 SfxItemPropertySet::setPropertyValue(rEntry, rValue, rSet);
2085 }
2086 }
2087 }
2088
2089 void SAL_CALL ScCellRangesBase::setPropertyValue(
2090 const OUString& aPropertyName, const uno::Any& aValue )
2091 {
2092 SolarMutexGuard aGuard;
2093
2094 if ( !pDocShell || aRanges.empty() )
2095 throw uno::RuntimeException();
2096
2097 const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2098 const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyName );
2099 if ( !pEntry )
2100 throw beans::UnknownPropertyException(aPropertyName);
2101
2102 SetOnePropertyValue( pEntry, aValue );
2103 }
2104
2105 void ScCellRangesBase::SetOnePropertyValue( const SfxItemPropertyMapEntry* pEntry, const uno::Any& aValue )
2106 {
2107 if ( !pEntry )
2108 return;
2109
2110 if ( IsScItemWid( pEntry->nWID ) )
2111 {
2112 if ( !aRanges.empty() ) // empty = nothing to do
2113 {
2114 ScDocument& rDoc = pDocShell->GetDocument();
2115
2116 // For parts of compound items with multiple properties (e.g. background)
2117 // the old item has to be first fetched from the document.
2118 //! But we can't recognize this case here
2119 //! -> an extra flag in PropertyMap entry, or something like that???
2120 //! fetch the item directly from its position in the range?
2121 // ClearInvalidItems, so that in any case we have an item with the correct type
2122
2123 ScPatternAttr aPattern( *GetCurrentAttrsDeep() );
2124 SfxItemSet& rSet = aPattern.GetItemSet();
2125 rSet.ClearInvalidItems();
2126
2127 sal_uInt16 nFirstItem, nSecondItem;
2128 lcl_SetCellProperty( *pEntry, aValue, aPattern, rDoc, nFirstItem, nSecondItem );
2129
2130 for (sal_uInt16 nWhich = ATTR_PATTERN_START; nWhich <= ATTR_PATTERN_END; nWhich++)
2131 if ( nWhich != nFirstItem && nWhich != nSecondItem )
2132 rSet.ClearItem(nWhich);
2133
2134 pDocShell->GetDocFunc().ApplyAttributes( *GetMarkData(), aPattern, true );
2135 }
2136 }
2137 else // implemented here
2138 switch ( pEntry->nWID )
2139 {
2140 case EE_CHAR_ESCAPEMENT: // Specifically for xlsx import
2141 {
2142 sal_Int32 nValue = 0;
2143 aValue >>= nValue;
2144 if (nValue)
2145 {
2146 for (size_t i = 0, n = aRanges.size(); i < n; ++i)
2147 {
2148 ScRange const & rRange = aRanges[i];
2149
2150 /* TODO: Iterate through the range */
2151 ScAddress aAddr = rRange.aStart;
2152 ScDocument& rDoc = pDocShell->GetDocument();
2153 ScRefCellValue aCell(rDoc, aAddr);
2154
2155 OUString aStr = aCell.getString(&rDoc);
2156 EditEngine aEngine( rDoc.GetEnginePool() );
2157 aEngine.SetEditTextObjectPool(rDoc.GetEditPool());
2158
2159 /* EE_CHAR_ESCAPEMENT seems to be set on the cell _only_ when
2160 * there are no other attribs for the cell.
2161 * So, it is safe to overwrite the complete attribute set.
2162 * If there is a need - getting CellType and processing
2163 * the attributes could be considered.
2164 */
2165 SfxItemSet aAttr = aEngine.GetEmptyItemSet();
2166 aEngine.SetText(aStr);
2167 if( nValue < 0 ) // Subscript
2168 aAttr.Put( SvxEscapementItem( SvxEscapement::Subscript, EE_CHAR_ESCAPEMENT ) );
2169 else // Superscript
2170 aAttr.Put( SvxEscapementItem( SvxEscapement::Superscript, EE_CHAR_ESCAPEMENT ) );
2171 aEngine.QuickSetAttribs(aAttr, ESelection(0, 0, 0, aStr.getLength()));
2172
2173 // The cell will own the text object instance.
2174 rDoc.SetEditText(aRanges[0].aStart, aEngine.CreateTextObject());
2175 }
2176 }
2177 }
2178 break;
2179 case SC_WID_UNO_CHCOLHDR:
2180 // chart header flags are set for this object, not stored with document
2181 bChartColAsHdr = ScUnoHelpFunctions::GetBoolFromAny( aValue );
2182 break;
2183 case SC_WID_UNO_CHROWHDR:
2184 bChartRowAsHdr = ScUnoHelpFunctions::GetBoolFromAny( aValue );
2185 break;
2186 case SC_WID_UNO_CELLSTYL:
2187 {
2188 OUString aStrVal;
2189 aValue >>= aStrVal;
2190 OUString aString(ScStyleNameConversion::ProgrammaticToDisplayName(
2191 aStrVal, SfxStyleFamily::Para ));
2192 pDocShell->GetDocFunc().ApplyStyle( *GetMarkData(), aString, true );
2193 }
2194 break;
2195 case SC_WID_UNO_TBLBORD:
2196 {
2197 table::TableBorder aBorder;
2198 if ( !aRanges.empty() && ( aValue >>= aBorder ) ) // empty = nothing to do
2199 {
2200 SvxBoxItem aOuter(ATTR_BORDER);
2201 SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
2202 ScHelperFunctions::FillBoxItems( aOuter, aInner, aBorder );
2203
2204 ScHelperFunctions::ApplyBorder( pDocShell, aRanges, aOuter, aInner ); //! docfunc
2205 }
2206 }
2207 break;
2208 case SC_WID_UNO_TBLBORD2:
2209 {
2210 table::TableBorder2 aBorder2;
2211 if ( !aRanges.empty() && ( aValue >>= aBorder2 ) ) // empty = nothing to do
2212 {
2213 SvxBoxItem aOuter(ATTR_BORDER);
2214 SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
2215 ScHelperFunctions::FillBoxItems( aOuter, aInner, aBorder2 );
2216
2217 ScHelperFunctions::ApplyBorder( pDocShell, aRanges, aOuter, aInner ); //! docfunc
2218 }
2219 }
2220 break;
2221 case SC_WID_UNO_CONDFMT:
2222 case SC_WID_UNO_CONDLOC:
2223 case SC_WID_UNO_CONDXML:
2224 {
2225 uno::Reference<sheet::XSheetConditionalEntries> xInterface(aValue, uno::UNO_QUERY);
2226 if ( !aRanges.empty() && xInterface.is() ) // empty = nothing to do
2227 {
2228 ScTableConditionalFormat* pFormat =
2229 dynamic_cast<ScTableConditionalFormat*>( xInterface.get() );
2230 if (pFormat)
2231 {
2232 ScDocument& rDoc = pDocShell->GetDocument();
2233 bool bEnglish = ( pEntry->nWID != SC_WID_UNO_CONDLOC );
2234 bool bXML = ( pEntry->nWID == SC_WID_UNO_CONDXML );
2235 formula::FormulaGrammar::Grammar eGrammar = (bXML ?
2236 formula::FormulaGrammar::GRAM_UNSPECIFIED :
2237 formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
2238
2239 SCTAB nTab = aRanges.front().aStart.Tab();
2240 // To remove conditional formats for all cells in aRanges we need to:
2241 // Remove conditional format data from cells' attributes
2242 rDoc.RemoveCondFormatData( aRanges, nTab, 0 );
2243 // And also remove ranges from conditional formats list
2244 for (size_t i = 0; i < aRanges.size(); ++i)
2245 {
2246 rDoc.GetCondFormList( aRanges[i].aStart.Tab() )->DeleteArea(
2247 aRanges[i].aStart.Col(), aRanges[i].aStart.Row(),
2248 aRanges[i].aEnd.Col(), aRanges[i].aEnd.Row() );
2249 }
2250
2251 // Then we can apply new conditional format if there is one
2252 if (pFormat->getCount())
2253 {
2254 auto pNew = std::make_unique<ScConditionalFormat>( 0, &rDoc ); // Index will be set on inserting
2255 pFormat->FillFormat( *pNew, rDoc, eGrammar );
2256 pNew->SetRange( aRanges );
2257 pDocShell->GetDocFunc().ReplaceConditionalFormat( 0, std::move(pNew), nTab, aRanges );
2258 }
2259
2260 // and repaint
2261 for (size_t i = 0; i < aRanges.size(); ++i)
2262 pDocShell->PostPaint(aRanges[i], PaintPartFlags::Grid);
2263 pDocShell->SetDocumentModified();
2264 }
2265 }
2266 }
2267 break;
2268 case SC_WID_UNO_VALIDAT:
2269 case SC_WID_UNO_VALILOC:
2270 case SC_WID_UNO_VALIXML:
2271 {
2272 uno::Reference<beans::XPropertySet> xInterface(aValue, uno::UNO_QUERY);
2273 if ( !aRanges.empty() && xInterface.is() ) // empty = nothing to do
2274 {
2275 ScTableValidationObj* pValidObj =
2276 dynamic_cast<ScTableValidationObj*>( xInterface.get() );
2277 if (pValidObj)
2278 {
2279 ScDocument& rDoc = pDocShell->GetDocument();
2280 bool bEnglish = ( pEntry->nWID != SC_WID_UNO_VALILOC );
2281 bool bXML = ( pEntry->nWID == SC_WID_UNO_VALIXML );
2282 formula::FormulaGrammar::Grammar eGrammar = (bXML ?
2283 formula::FormulaGrammar::GRAM_UNSPECIFIED :
2284 formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
2285
2286 std::unique_ptr<ScValidationData> pNewData(
2287 pValidObj->CreateValidationData( rDoc, eGrammar ));
2288 sal_uInt32 nIndex = rDoc.AddValidationEntry( *pNewData );
2289 pNewData.reset();
2290
2291 ScPatternAttr aPattern(rDoc.getCellAttributeHelper());
2292 aPattern.GetItemSet().Put( SfxUInt32Item( ATTR_VALIDDATA, nIndex ) );
2293 pDocShell->GetDocFunc().ApplyAttributes( *GetMarkData(), aPattern, true );
2294 }
2295 }
2296 }
2297 break;
2298 // SC_WID_UNO_NUMRULES is ignored...
2299 }
2300 }
2301
2302 uno::Any SAL_CALL ScCellRangesBase::getPropertyValue( const OUString& aPropertyName )
2303 {
2304 SolarMutexGuard aGuard;
2305
2306 if ( !pDocShell || aRanges.empty() )
2307 throw uno::RuntimeException();
2308
2309 const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2310 const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyName );
2311 if ( !pEntry )
2312 throw beans::UnknownPropertyException(aPropertyName);
2313
2314 uno::Any aAny;
2315 GetOnePropertyValue( pEntry, aAny );
2316 return aAny;
2317 }
2318
2319 void ScCellRangesBase::GetOnePropertyValue( const SfxItemPropertyMapEntry* pEntry, uno::Any& rAny )
2320 {
2321 if ( !pEntry )
2322 return;
2323
2324 if ( IsScItemWid( pEntry->nWID ) )
2325 {
2326 SfxItemSet* pDataSet = GetCurrentDataSet();
2327 if ( pDataSet )
2328 {
2329 switch ( pEntry->nWID ) // for special handling of items
2330 {
2331 case ATTR_VALUE_FORMAT:
2332 {
2333 ScDocument& rDoc = pDocShell->GetDocument();
2334
2335 sal_uLong nOldFormat =
2336 pDataSet->Get( ATTR_VALUE_FORMAT ).GetValue();
2337 LanguageType eOldLang =
2338 pDataSet->Get( ATTR_LANGUAGE_FORMAT ).GetLanguage();
2339 nOldFormat = rDoc.GetFormatTable()->
2340 GetFormatForLanguageIfBuiltIn( nOldFormat, eOldLang );
2341 rAny <<= static_cast<sal_Int32>(nOldFormat);
2342 }
2343 break;
2344 case ATTR_INDENT:
2345 rAny <<= static_cast<sal_Int16>( convertTwipToMm100(static_cast<const ScIndentItem&>(
2346 pDataSet->Get(pEntry->nWID)).GetValue()) );
2347 break;
2348 case ATTR_STACKED:
2349 {
2350 Degree100 nRot = pDataSet->Get(ATTR_ROTATE_VALUE).GetValue();
2351 bool bStacked = static_cast<const ScVerticalStackCell&>(pDataSet->Get(pEntry->nWID)).GetValue();
2352 SvxOrientationItem( nRot, bStacked, TypedWhichId<SvxOrientationItem>(0) ).QueryValue( rAny );
2353 }
2354 break;
2355 default:
2356 SfxItemPropertySet::getPropertyValue(*pEntry, *pDataSet, rAny);
2357 }
2358 }
2359 }
2360 else // implemented here
2361 switch ( pEntry->nWID )
2362 {
2363 case SC_WID_UNO_CHCOLHDR:
2364 rAny <<= bChartColAsHdr;
2365 break;
2366 case SC_WID_UNO_CHROWHDR:
2367 rAny <<= bChartRowAsHdr;
2368 break;
2369 case SC_WID_UNO_CELLSTYL:
2370 {
2371 OUString aStyleName;
2372 const ScStyleSheet* pStyle = pDocShell->GetDocument().GetSelectionStyle(*GetMarkData());
2373 if (pStyle)
2374 aStyleName = pStyle->GetName();
2375 rAny <<= ScStyleNameConversion::DisplayToProgrammaticName(
2376 aStyleName, SfxStyleFamily::Para );
2377 }
2378 break;
2379 case SC_WID_UNO_TBLBORD:
2380 case SC_WID_UNO_TBLBORD2:
2381 {
2382 //! loop through all ranges
2383 if ( !aRanges.empty() )
2384 {
2385 const ScRange & rFirst = aRanges[ 0 ];
2386 SvxBoxItem aOuter(ATTR_BORDER);
2387 SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
2388
2389 ScDocument& rDoc = pDocShell->GetDocument();
2390 ScMarkData aMark(rDoc.GetSheetLimits());
2391 aMark.SetMarkArea( rFirst );
2392 aMark.SelectTable( rFirst.aStart.Tab(), true );
2393 rDoc.GetSelectionFrame( aMark, aOuter, aInner );
2394
2395 if (pEntry->nWID == SC_WID_UNO_TBLBORD2)
2396 ScHelperFunctions::AssignTableBorder2ToAny( rAny, aOuter, aInner);
2397 else
2398 ScHelperFunctions::AssignTableBorderToAny( rAny, aOuter, aInner);
2399 }
2400 }
2401 break;
2402 case SC_WID_UNO_CONDFMT:
2403 case SC_WID_UNO_CONDLOC:
2404 case SC_WID_UNO_CONDXML:
2405 {
2406 const ScPatternAttr* pPattern = GetCurrentAttrsDeep();
2407 if ( pPattern )
2408 {
2409 ScDocument& rDoc = pDocShell->GetDocument();
2410 bool bEnglish = ( pEntry->nWID != SC_WID_UNO_CONDLOC );
2411 bool bXML = ( pEntry->nWID == SC_WID_UNO_CONDXML );
2412 formula::FormulaGrammar::Grammar eGrammar = (bXML ?
2413 rDoc.GetStorageGrammar() :
2414 formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
2415 const ScCondFormatIndexes& rIndex =
2416 pPattern->GetItem(ATTR_CONDITIONAL).GetCondFormatData();
2417 sal_uLong nIndex = 0;
2418 if(!rIndex.empty())
2419 nIndex = rIndex[0];
2420 rAny <<= uno::Reference<sheet::XSheetConditionalEntries>(
2421 new ScTableConditionalFormat( &rDoc, nIndex, aRanges.front().aStart.Tab(), eGrammar ));
2422 }
2423 }
2424 break;
2425 case SC_WID_UNO_VALIDAT:
2426 case SC_WID_UNO_VALILOC:
2427 case SC_WID_UNO_VALIXML:
2428 {
2429 const ScPatternAttr* pPattern = GetCurrentAttrsDeep();
2430 if ( pPattern )
2431 {
2432 ScDocument& rDoc = pDocShell->GetDocument();
2433 bool bEnglish = ( pEntry->nWID != SC_WID_UNO_VALILOC );
2434 bool bXML = ( pEntry->nWID == SC_WID_UNO_VALIXML );
2435 formula::FormulaGrammar::Grammar eGrammar = (bXML ?
2436 rDoc.GetStorageGrammar() :
2437 formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
2438 sal_uLong nIndex =
2439 pPattern->GetItem(ATTR_VALIDDATA).GetValue();
2440 rAny <<= uno::Reference<beans::XPropertySet>(
2441 new ScTableValidationObj( rDoc, nIndex, eGrammar ));
2442 }
2443 }
2444 break;
2445 case SC_WID_UNO_NUMRULES:
2446 {
2447 // always return empty numbering rules object
2448 rAny <<= ScStyleObj::CreateEmptyNumberingRules();
2449 }
2450 break;
2451 case SC_WID_UNO_ABSNAME:
2452 {
2453 OUString sRet;
2454 aRanges.Format(sRet, ScRefFlags::RANGE_ABS_3D, pDocShell->GetDocument());
2455 rAny <<= sRet;
2456 }
2457 break;
2458 case SC_WID_UNO_FORMATID:
2459 {
2460 const ScPatternAttr* pPattern = GetCurrentAttrsFlat();
2461 rAny <<= pPattern->GetPAKey();
2462 }
2463 break;
2464 }
2465 }
2466
2467 void SAL_CALL ScCellRangesBase::addPropertyChangeListener( const OUString& /* aPropertyName */,
2468 const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
2469 {
2470 SolarMutexGuard aGuard;
2471 if ( aRanges.empty() )
2472 throw uno::RuntimeException();
2473
2474 OSL_FAIL("not implemented");
2475 }
2476
2477 void SAL_CALL ScCellRangesBase::removePropertyChangeListener( const OUString& /* aPropertyName */,
2478 const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
2479 {
2480 SolarMutexGuard aGuard;
2481 if ( aRanges.empty() )
2482 throw uno::RuntimeException();
2483
2484 OSL_FAIL("not implemented");
2485 }
2486
2487 void SAL_CALL ScCellRangesBase::addVetoableChangeListener( const OUString&,
2488 const uno::Reference<beans::XVetoableChangeListener>&)
2489 {
2490 OSL_FAIL("not implemented");
2491 }
2492
2493 void SAL_CALL ScCellRangesBase::removeVetoableChangeListener( const OUString&,
2494 const uno::Reference<beans::XVetoableChangeListener>&)
2495 {
2496 OSL_FAIL("not implemented");
2497 }
2498
2499 // XMultiPropertySet
2500
2501 void SAL_CALL ScCellRangesBase::setPropertyValues( const uno::Sequence< OUString >& aPropertyNames,
2502 const uno::Sequence< uno::Any >& aValues )
2503 {
2504 SolarMutexGuard aGuard;
2505
2506 sal_Int32 nCount(aPropertyNames.getLength());
2507 sal_Int32 nValues(aValues.getLength());
2508 if (nCount != nValues)
2509 throw lang::IllegalArgumentException();
2510
2511 if ( !(pDocShell && nCount) )
2512 return;
2513
2514 const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2515 const OUString* pNames = aPropertyNames.getConstArray();
2516 const uno::Any* pValues = aValues.getConstArray();
2517
2518 std::unique_ptr<const SfxItemPropertyMapEntry*[]> pEntryArray(new const SfxItemPropertyMapEntry*[nCount]);
2519
2520 sal_Int32 i;
2521 for(i = 0; i < nCount; i++)
2522 {
2523 // first loop: find all properties in map, but handle only CellStyle
2524 // (CellStyle must be set before any other cell properties)
2525
2526 const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( pNames[i] );
2527 pEntryArray[i] = pEntry;
2528 if (pEntry)
2529 {
2530 if ( pEntry->nWID == SC_WID_UNO_CELLSTYL )
2531 {
2532 try
2533 {
2534 SetOnePropertyValue( pEntry, pValues[i] );
2535 }
2536 catch ( lang::IllegalArgumentException& )
2537 {
2538 TOOLS_WARN_EXCEPTION( "sc", "exception when setting cell style"); // not supposed to happen
2539 }
2540 }
2541 }
2542 }
2543
2544 ScDocument& rDoc = pDocShell->GetDocument();
2545 std::unique_ptr<ScPatternAttr> pOldPattern;
2546 std::unique_ptr<ScPatternAttr> pNewPattern;
2547
2548 for(i = 0; i < nCount; i++)
2549 {
2550 // second loop: handle other properties
2551
2552 const SfxItemPropertyMapEntry* pEntry = pEntryArray[i];
2553 if ( pEntry )
2554 {
2555 if ( IsScItemWid( pEntry->nWID ) ) // can be handled by SfxItemPropertySet
2556 {
2557 if ( !pOldPattern )
2558 {
2559 pOldPattern.reset(new ScPatternAttr( *GetCurrentAttrsDeep() ));
2560 pOldPattern->GetItemSet().ClearInvalidItems();
2561 pNewPattern.reset(new ScPatternAttr(rDoc.getCellAttributeHelper()));
2562 }
2563
2564 // collect items in pNewPattern, apply with one call after the loop
2565
2566 sal_uInt16 nFirstItem, nSecondItem;
2567 lcl_SetCellProperty( *pEntry, pValues[i], *pOldPattern, rDoc, nFirstItem, nSecondItem );
2568
2569 // put only affected items into new set
2570 if ( nFirstItem )
2571 pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nFirstItem ) );
2572 if ( nSecondItem )
2573 pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nSecondItem ) );
2574 }
2575 else if ( pEntry->nWID != SC_WID_UNO_CELLSTYL ) // CellStyle is handled above
2576 {
2577 // call virtual method to set a single property
2578 SetOnePropertyValue( pEntry, pValues[i] );
2579 }
2580 }
2581 }
2582
2583 if ( pNewPattern && !aRanges.empty() )
2584 pDocShell->GetDocFunc().ApplyAttributes( *GetMarkData(), *pNewPattern, true );
2585 }
2586
2587 uno::Sequence<uno::Any> SAL_CALL ScCellRangesBase::getPropertyValues(
2588 const uno::Sequence< OUString >& aPropertyNames )
2589 {
2590 SolarMutexGuard aGuard;
2591
2592 const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2593
2594 uno::Sequence<uno::Any> aRet(aPropertyNames.getLength());
2595 uno::Any* pProperties = aRet.getArray();
2596 for(sal_Int32 i = 0; i < aPropertyNames.getLength(); i++)
2597 {
2598 const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyNames[i] );
2599 GetOnePropertyValue( pEntry, pProperties[i] );
2600 }
2601 return aRet;
2602 }
2603
2604 void SAL_CALL ScCellRangesBase::addPropertiesChangeListener( const uno::Sequence< OUString >& /* aPropertyNames */,
2605 const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ )
2606 {
2607 OSL_FAIL("not implemented");
2608 }
2609
2610 void SAL_CALL ScCellRangesBase::removePropertiesChangeListener( const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ )
2611 {
2612 OSL_FAIL("not implemented");
2613 }
2614
2615 void SAL_CALL ScCellRangesBase::firePropertiesChangeEvent( const uno::Sequence< OUString >& /* aPropertyNames */,
2616 const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ )
2617 {
2618 OSL_FAIL("not implemented");
2619 }
2620
2621 IMPL_LINK( ScCellRangesBase, ValueListenerHdl, const SfxHint&, rHint, void )
2622 {
2623 if ( pDocShell && (rHint.GetId() == SfxHintId::ScDataChanged))
2624 {
2625 // This may be called several times for a single change, if several formulas
2626 // in the range are notified. So only a flag is set that is checked when
2627 // SfxHintId::DataChanged is received.
2628
2629 bGotDataChangedHint = true;
2630 }
2631 }
2632
2633 // XTolerantMultiPropertySet
2634 uno::Sequence< beans::SetPropertyTolerantFailed > SAL_CALL ScCellRangesBase::setPropertyValuesTolerant( const uno::Sequence< OUString >& aPropertyNames,
2635 const uno::Sequence< uno::Any >& aValues )
2636 {
2637 SolarMutexGuard aGuard;
2638
2639 sal_Int32 nCount(aPropertyNames.getLength());
2640 sal_Int32 nValues(aValues.getLength());
2641 if (nCount != nValues)
2642 throw lang::IllegalArgumentException();
2643
2644 if ( pDocShell && nCount )
2645 {
2646 uno::Sequence < beans::SetPropertyTolerantFailed > aReturns(nCount);
2647 beans::SetPropertyTolerantFailed* pReturns = aReturns.getArray();
2648
2649 const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2650 const OUString* pNames = aPropertyNames.getConstArray();
2651 const uno::Any* pValues = aValues.getConstArray();
2652
2653 std::unique_ptr<const SfxItemPropertyMapEntry*[]> pMapArray(new const SfxItemPropertyMapEntry*[nCount]);
2654
2655 sal_Int32 i;
2656 for(i = 0; i < nCount; i++)
2657 {
2658 // first loop: find all properties in map, but handle only CellStyle
2659 // (CellStyle must be set before any other cell properties)
2660
2661 const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( pNames[i] );
2662 pMapArray[i] = pEntry;
2663 if (pEntry)
2664 {
2665 if ( pEntry->nWID == SC_WID_UNO_CELLSTYL )
2666 {
2667 try
2668 {
2669 SetOnePropertyValue( pEntry, pValues[i] );
2670 }
2671 catch ( lang::IllegalArgumentException& )
2672 {
2673 TOOLS_WARN_EXCEPTION( "sc", "exception when setting cell style"); // not supposed to happen
2674 }
2675 }
2676 }
2677 }
2678
2679 ScDocument& rDoc = pDocShell->GetDocument();
2680 std::unique_ptr<ScPatternAttr> pOldPattern;
2681 std::unique_ptr<ScPatternAttr> pNewPattern;
2682
2683 sal_Int32 nFailed(0);
2684 for(i = 0; i < nCount; i++)
2685 {
2686 // second loop: handle other properties
2687
2688 const SfxItemPropertyMapEntry* pEntry = pMapArray[i];
2689 if ( pEntry && ((pEntry->nFlags & beans::PropertyAttribute::READONLY) == 0))
2690 {
2691 if ( IsScItemWid( pEntry->nWID ) ) // can be handled by SfxItemPropertySet
2692 {
2693 if ( !pOldPattern )
2694 {
2695 pOldPattern.reset(new ScPatternAttr( *GetCurrentAttrsDeep() ));
2696 pOldPattern->GetItemSet().ClearInvalidItems();
2697 pNewPattern.reset(new ScPatternAttr(rDoc.getCellAttributeHelper()));
2698 }
2699
2700 // collect items in pNewPattern, apply with one call after the loop
2701 try
2702 {
2703 sal_uInt16 nFirstItem, nSecondItem;
2704 lcl_SetCellProperty( *pEntry, pValues[i], *pOldPattern, rDoc, nFirstItem, nSecondItem );
2705
2706 // put only affected items into new set
2707 if ( nFirstItem )
2708 pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nFirstItem ) );
2709 if ( nSecondItem )
2710 pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nSecondItem ) );
2711 }
2712 catch ( lang::IllegalArgumentException& )
2713 {
2714 pReturns[nFailed].Name = pNames[i];
2715 pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::ILLEGAL_ARGUMENT;
2716 }
2717 }
2718 else if ( pEntry->nWID != SC_WID_UNO_CELLSTYL ) // CellStyle is handled above
2719 {
2720 // call virtual method to set a single property
2721 try
2722 {
2723 SetOnePropertyValue( pEntry, pValues[i] );
2724 }
2725 catch ( lang::IllegalArgumentException& )
2726 {
2727 pReturns[nFailed].Name = pNames[i];
2728 pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::ILLEGAL_ARGUMENT;
2729 }
2730 }
2731 }
2732 else
2733 {
2734 pReturns[nFailed].Name = pNames[i];
2735 if (pEntry)
2736 pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::PROPERTY_VETO;
2737 else
2738 pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
2739 }
2740 }
2741
2742 if ( pNewPattern && !aRanges.empty() )
2743 pDocShell->GetDocFunc().ApplyAttributes( *GetMarkData(), *pNewPattern, true );
2744
2745 aReturns.realloc(nFailed);
2746
2747 return aReturns;
2748 }
2749 return uno::Sequence < beans::SetPropertyTolerantFailed >();
2750 }
2751
2752 uno::Sequence< beans::GetPropertyTolerantResult > SAL_CALL ScCellRangesBase::getPropertyValuesTolerant( const uno::Sequence< OUString >& aPropertyNames )
2753 {
2754 SolarMutexGuard aGuard;
2755
2756 sal_Int32 nCount(aPropertyNames.getLength());
2757 uno::Sequence < beans::GetPropertyTolerantResult > aReturns(nCount);
2758 beans::GetPropertyTolerantResult* pReturns = aReturns.getArray();
2759
2760 const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2761
2762 for(sal_Int32 i = 0; i < nCount; i++)
2763 {
2764 const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyNames[i] );
2765 if (!pEntry)
2766 {
2767 pReturns[i].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
2768 }
2769 else
2770 {
2771 sal_uInt16 nItemWhich = 0;
2772 lcl_GetPropertyWhich( pEntry, nItemWhich );
2773 pReturns[i].State = GetOnePropertyState( nItemWhich, pEntry );
2774 GetOnePropertyValue( pEntry, pReturns[i].Value );
2775 pReturns[i].Result = beans::TolerantPropertySetResultType::SUCCESS;
2776 }
2777 }
2778 return aReturns;
2779 }
2780
2781 uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL ScCellRangesBase::getDirectPropertyValuesTolerant( const uno::Sequence< OUString >& aPropertyNames )
2782 {
2783 SolarMutexGuard aGuard;
2784
2785 sal_Int32 nCount(aPropertyNames.getLength());
2786 uno::Sequence < beans::GetDirectPropertyTolerantResult > aReturns(nCount);
2787 beans::GetDirectPropertyTolerantResult* pReturns = aReturns.getArray();
2788
2789 const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2790
2791 sal_Int32 j = 0;
2792 for(sal_Int32 i = 0; i < nCount; i++)
2793 {
2794 const SfxItemPropertyMapEntry* pEntry = rPropertyMap.getByName( aPropertyNames[i] );
2795 if (!pEntry)
2796 {
2797 pReturns[i].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
2798 }
2799 else
2800 {
2801 sal_uInt16 nItemWhich = 0;
2802 lcl_GetPropertyWhich( pEntry, nItemWhich );
2803 pReturns[j].State = GetOnePropertyState( nItemWhich, pEntry );
2804 if (pReturns[j].State == beans::PropertyState_DIRECT_VALUE)
2805 {
2806 GetOnePropertyValue( pEntry, pReturns[j].Value );
2807 pReturns[j].Result = beans::TolerantPropertySetResultType::SUCCESS;
2808 pReturns[j].Name = aPropertyNames[i];
2809 ++j;
2810 }
2811 }
2812 }
2813 if (j < nCount)
2814 aReturns.realloc(j);
2815 return aReturns;
2816 }
2817
2818 // XIndent
2819
2820 void SAL_CALL ScCellRangesBase::decrementIndent()
2821 {
2822 SolarMutexGuard aGuard;
2823 if ( pDocShell && !aRanges.empty() )
2824 {
2825 //#97041#; put only MultiMarked ScMarkData in ChangeIndent
2826 ScMarkData aMarkData(*GetMarkData());
2827 aMarkData.MarkToMulti();
2828 pDocShell->GetDocFunc().ChangeIndent( aMarkData, false, true );
2829 }
2830 }
2831
2832 void SAL_CALL ScCellRangesBase::incrementIndent()
2833 {
2834 SolarMutexGuard aGuard;
2835 if ( pDocShell && !aRanges.empty() )
2836 {
2837 //#97041#; put only MultiMarked ScMarkData in ChangeIndent
2838 ScMarkData aMarkData(*GetMarkData());
2839 aMarkData.MarkToMulti();
2840 pDocShell->GetDocFunc().ChangeIndent( aMarkData, true, true );
2841 }
2842 }
2843
2844 // XChartData
2845
2846 std::unique_ptr<ScMemChart> ScCellRangesBase::CreateMemChart_Impl() const
2847 {
2848 if ( pDocShell && !aRanges.empty() )
2849 {
2850 ScRangeListRef xChartRanges;
2851 if ( aRanges.size() == 1 )
2852 {
2853 // set useful table limit (only occupied data area)
2854 // (only here - Listeners are registered for the whole area)
2855 //! check immediately if a ScTableSheetObj?
2856
2857 const ScDocument & rDoc = pDocShell->GetDocument();
2858 const ScRange & rRange = aRanges[0];
2859 if ( rRange.aStart.Col() == 0 && rRange.aEnd.Col() == rDoc.MaxCol() &&
2860 rRange.aStart.Row() == 0 && rRange.aEnd.Row() == rDoc.MaxRow() )
2861 {
2862 SCTAB nTab = rRange.aStart.Tab();
2863
2864 SCCOL nStartX;
2865 SCROW nStartY; // Get start
2866 if (!pDocShell->GetDocument().GetDataStart( nTab, nStartX, nStartY ))
2867 {
2868 nStartX = 0;
2869 nStartY = 0;
2870 }
2871
2872 SCCOL nEndX;
2873 SCROW nEndY; // Get end
2874 if (!pDocShell->GetDocument().GetTableArea( nTab, nEndX, nEndY ))
2875 {
2876 nEndX = 0;
2877 nEndY = 0;
2878 }
2879
2880 xChartRanges = new ScRangeList( ScRange( nStartX, nStartY, nTab, nEndX, nEndY, nTab ) );
2881 }
2882 }
2883 if (!xChartRanges.is()) // otherwise take Ranges directly
2884 xChartRanges = new ScRangeList(aRanges);
2885 ScChartArray aArr( pDocShell->GetDocument(), xChartRanges );
2886
2887 // RowAsHdr = ColHeaders and vice versa
2888 aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr );
2889
2890 return aArr.CreateMemChart();
2891 }
2892 return nullptr;
2893 }
2894
2895 uno::Sequence< uno::Sequence<double> > SAL_CALL ScCellRangesBase::getData()
2896 {
2897 SolarMutexGuard aGuard;
2898 std::unique_ptr<ScMemChart> pMemChart(CreateMemChart_Impl());
2899 if ( pMemChart )
2900 {
2901 sal_Int32 nColCount = pMemChart->GetColCount();
2902 sal_Int32 nRowCount = static_cast<sal_Int32>(pMemChart->GetRowCount());
2903
2904 uno::Sequence< uno::Sequence<double> > aRowSeq( nRowCount );
2905 uno::Sequence<double>* pRowAry = aRowSeq.getArray();
2906 for (sal_Int32 nRow = 0; nRow < nRowCount; nRow++)
2907 {
2908 uno::Sequence<double> aColSeq( nColCount );
2909 double* pColAry = aColSeq.getArray();
2910 for (sal_Int32 nCol = 0; nCol < nColCount; nCol++)
2911 pColAry[nCol] = pMemChart->GetData( nCol, nRow );
2912
2913 pRowAry[nRow] = std::move(aColSeq);
2914 }
2915
2916 return aRowSeq;
2917 }
2918
2919 return {};
2920 }
2921
2922 ScRangeListRef ScCellRangesBase::GetLimitedChartRanges_Impl( sal_Int32 nDataColumns, sal_Int32 nDataRows ) const
2923 {
2924 if ( aRanges.size() == 1 )
2925 {
2926 const ScDocument & rDoc = pDocShell->GetDocument();
2927 const ScRange & rRange = aRanges[0];
2928 if ( rRange.aStart.Col() == 0 && rRange.aEnd.Col() == rDoc.MaxCol() &&
2929 rRange.aStart.Row() == 0 && rRange.aEnd.Row() == rDoc.MaxRow() )
2930 {
2931 // if aRanges is a complete sheet, limit to given size
2932
2933 SCTAB nTab = rRange.aStart.Tab();
2934
2935 sal_Int32 nEndColumn = nDataColumns - 1 + ( bChartColAsHdr ? 1 : 0 );
2936 if ( nEndColumn < 0 )
2937 nEndColumn = 0;
2938 if ( nEndColumn > rDoc.MaxCol() )
2939 nEndColumn = rDoc.MaxCol();
2940
2941 sal_Int32 nEndRow = nDataRows - 1 + ( bChartRowAsHdr ? 1 : 0 );
2942 if ( nEndRow < 0 )
2943 nEndRow = 0;
2944 if ( nEndRow > rDoc.MaxRow() )
2945 nEndRow = rDoc.MaxRow();
2946
2947 ScRangeListRef xChartRanges = new ScRangeList( ScRange( 0, 0, nTab, static_cast<SCCOL>(nEndColumn), static_cast<SCROW>(nEndRow), nTab ) );
2948 return xChartRanges;
2949 }
2950 }
2951
2952 return new ScRangeList(aRanges); // as-is
2953 }
2954
2955 void SAL_CALL ScCellRangesBase::setData( const uno::Sequence< uno::Sequence<double> >& aData )
2956 {
2957 SolarMutexGuard aGuard;
2958 bool bDone = false;
2959 sal_Int32 nRowCount = aData.getLength();
2960 sal_Int32 nColCount = nRowCount ? aData[0].getLength() : 0;
2961 ScRangeListRef xChartRanges = GetLimitedChartRanges_Impl( nColCount, nRowCount );
2962 if ( pDocShell && xChartRanges.is() )
2963 {
2964 ScDocument& rDoc = pDocShell->GetDocument();
2965 ScChartArray aArr( rDoc, xChartRanges );
2966 aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr ); // RowAsHdr = ColHeaders
2967 const ScChartPositionMap* pPosMap = aArr.GetPositionMap();
2968 if (pPosMap)
2969 {
2970 if ( pPosMap->GetColCount() == static_cast<SCCOL>(nColCount) &&
2971 pPosMap->GetRowCount() == static_cast<SCROW>(nRowCount) )
2972 {
2973 for (sal_Int32 nRow=0; nRow<nRowCount; nRow++)
2974 {
2975 const uno::Sequence<double>& rRowSeq = aData[nRow];
2976 const double* pArray = rRowSeq.getConstArray();
2977 nColCount = rRowSeq.getLength();
2978 for (sal_Int32 nCol=0; nCol<nColCount; nCol++)
2979 {
2980 const ScAddress* pPos = pPosMap->GetPosition(
2981 sal::static_int_cast<SCCOL>(nCol),
2982 sal::static_int_cast<SCROW>(nRow) );
2983 if (pPos)
2984 {
2985 double fVal = pArray[nCol];
2986 if ( fVal == DBL_MIN )
2987 rDoc.SetEmptyCell(*pPos);
2988 else
2989 rDoc.SetValue(*pPos, pArray[nCol]);
2990 }
2991 }
2992 }
2993
2994 //! undo
2995 PaintGridRanges_Impl();
2996 pDocShell->SetDocumentModified();
2997 ForceChartListener_Impl(); // call listeners for this object synchronously
2998 bDone = true;
2999 }
3000 }
3001 }
3002
3003 if (!bDone)
3004 throw uno::RuntimeException();
3005 }
3006
3007 uno::Sequence<OUString> SAL_CALL ScCellRangesBase::getRowDescriptions()
3008 {
3009 SolarMutexGuard aGuard;
3010 std::unique_ptr<ScMemChart> pMemChart(CreateMemChart_Impl());
3011 if ( pMemChart )
3012 {
3013 sal_Int32 nRowCount = static_cast<sal_Int32>(pMemChart->GetRowCount());
3014 uno::Sequence<OUString> aSeq( nRowCount );
3015 OUString* pAry = aSeq.getArray();
3016 for (sal_Int32 nRow = 0; nRow < nRowCount; nRow++)
3017 pAry[nRow] = pMemChart->GetRowText(nRow);
3018
3019 return aSeq;
3020 }
3021 return {};
3022 }
3023
3024 void SAL_CALL ScCellRangesBase::setRowDescriptions(
3025 const uno::Sequence<OUString>& aRowDescriptions )
3026 {
3027 SolarMutexGuard aGuard;
3028 bool bDone = false;
3029 if ( bChartColAsHdr )
3030 {
3031 sal_Int32 nRowCount = aRowDescriptions.getLength();
3032 ScRangeListRef xChartRanges = GetLimitedChartRanges_Impl( 1, nRowCount );
3033 if ( pDocShell && xChartRanges.is() )
3034 {
3035 ScDocument& rDoc = pDocShell->GetDocument();
3036 ScChartArray aArr( rDoc, xChartRanges );
3037 aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr ); // RowAsHdr = ColHeaders
3038 const ScChartPositionMap* pPosMap = aArr.GetPositionMap();
3039 if (pPosMap)
3040 {
3041 if ( pPosMap->GetRowCount() == static_cast<SCROW>(nRowCount) )
3042 {
3043 const OUString* pArray = aRowDescriptions.getConstArray();
3044 for (sal_Int32 nRow=0; nRow<nRowCount; nRow++)
3045 {
3046 const ScAddress* pPos = pPosMap->GetRowHeaderPosition(
3047 static_cast<SCSIZE>(nRow) );
3048 if (pPos)
3049 {
3050 const OUString& aStr = pArray[nRow];
3051 if (aStr.isEmpty())
3052 rDoc.SetEmptyCell(*pPos);
3053 else
3054 {
3055 ScSetStringParam aParam;
3056 aParam.setTextInput();
3057 rDoc.SetString(*pPos, aStr, &aParam);
3058 }
3059 }
3060 }
3061
3062 //! undo
3063 PaintGridRanges_Impl();
3064 pDocShell->SetDocumentModified();
3065 ForceChartListener_Impl(); // call listeners for this object synchronously
3066 bDone = true;
3067 }
3068 }
3069 }
3070 }
3071
3072 if (!bDone)
3073 throw uno::RuntimeException();
3074 }
3075
3076 uno::Sequence<OUString> SAL_CALL ScCellRangesBase::getColumnDescriptions()
3077 {
3078 SolarMutexGuard aGuard;
3079 std::unique_ptr<ScMemChart> pMemChart(CreateMemChart_Impl());
3080 if ( pMemChart )
3081 {
3082 sal_Int32 nColCount = pMemChart->GetColCount();
3083 uno::Sequence<OUString> aSeq( nColCount );
3084 OUString* pAry = aSeq.getArray();
3085 for (sal_Int32 nCol = 0; nCol < nColCount; nCol++)
3086 pAry[nCol] = pMemChart->GetColText(nCol);
3087
3088 return aSeq;
3089 }
3090 return {};
3091 }
3092
3093 void SAL_CALL ScCellRangesBase::setColumnDescriptions(
3094 const uno::Sequence<OUString>& aColumnDescriptions )
3095 {
3096 SolarMutexGuard aGuard;
3097 bool bDone = false;
3098 if ( bChartRowAsHdr )
3099 {
3100 sal_Int32 nColCount = aColumnDescriptions.getLength();
3101 ScRangeListRef xChartRanges = GetLimitedChartRanges_Impl( nColCount, 1 );
3102 if ( pDocShell && xChartRanges.is() )
3103 {
3104 ScDocument& rDoc = pDocShell->GetDocument();
3105 ScChartArray aArr( rDoc, xChartRanges );
3106 aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr ); // RowAsHdr = ColHeaders
3107 const ScChartPositionMap* pPosMap = aArr.GetPositionMap();
3108 if (pPosMap)
3109 {
3110 if ( pPosMap->GetColCount() == static_cast<SCCOL>(nColCount) )
3111 {
3112 const OUString* pArray = aColumnDescriptions.getConstArray();
3113 for (sal_Int32 nCol=0; nCol<nColCount; nCol++)
3114 {
3115 const ScAddress* pPos = pPosMap->GetColHeaderPosition(
3116 sal::static_int_cast<SCCOL>(nCol) );
3117 if (pPos)
3118 {
3119 const OUString& aStr = pArray[nCol];
3120 if (aStr.isEmpty())
3121 rDoc.SetEmptyCell(*pPos);
3122 else
3123 {
3124 ScSetStringParam aParam;
3125 aParam.setTextInput();
3126 rDoc.SetString(*pPos, aStr, &aParam);
3127 }
3128 }
3129 }
3130
3131 //! undo
3132 PaintGridRanges_Impl();
3133 pDocShell->SetDocumentModified();
3134 ForceChartListener_Impl(); // call listeners for this object synchronously
3135 bDone = true;
3136 }
3137 }
3138 }
3139 }
3140
3141 if (!bDone)
3142 throw uno::RuntimeException();
3143 }
3144
3145 void ScCellRangesBase::ForceChartListener_Impl()
3146 {
3147 // call Update immediately so the caller to setData etc. can
3148 // recognize the listener call
3149
3150 if (!pDocShell)
3151 return;
3152
3153 ScChartListenerCollection* pColl = pDocShell->GetDocument().GetChartListenerCollection();
3154 if (!pColl)
3155 return;
3156
3157 ScChartListenerCollection::ListenersType& rListeners = pColl->getListeners();
3158 for (auto const& it : rListeners)
3159 {
3160 ScChartListener *const p = it.second.get();
3161 assert(p);
3162 if (p->GetUnoSource() == static_cast<chart::XChartData*>(this) && p->IsDirty())
3163 p->Update();
3164 }
3165 }
3166
3167 void SAL_CALL ScCellRangesBase::addChartDataChangeEventListener( const uno::Reference<
3168 chart::XChartDataChangeEventListener >& aListener )
3169 {
3170 SolarMutexGuard aGuard;
3171 if ( !pDocShell || aRanges.empty() )
3172 return;
3173
3174 //! test for duplicates ?
3175
3176 ScDocument& rDoc = pDocShell->GetDocument();
3177 ScRangeListRef aRangesRef( new ScRangeList(aRanges) );
3178 ScChartListenerCollection* pColl = rDoc.GetChartListenerCollection();
3179 OUString aName = pColl->getUniqueName(u"__Uno");
3180 if (aName.isEmpty())
3181 // failed to create unique name.
3182 return;
3183
3184 ScChartListener* pListener = new ScChartListener( aName, rDoc, aRangesRef );
3185 pListener->SetUno( aListener, this );
3186 pColl->insert( pListener );
3187 pListener->StartListeningTo();
3188 }
3189
3190 void SAL_CALL ScCellRangesBase::removeChartDataChangeEventListener( const uno::Reference<
3191 chart::XChartDataChangeEventListener >& aListener )
3192 {
3193 SolarMutexGuard aGuard;
3194 if ( pDocShell && !aRanges.empty() )
3195 {
3196 ScDocument& rDoc = pDocShell->GetDocument();
3197 ScChartListenerCollection* pColl = rDoc.GetChartListenerCollection();
3198 pColl->FreeUno( aListener, this );
3199 }
3200 }
3201
3202 double SAL_CALL ScCellRangesBase::getNotANumber()
3203 {
3204 // use DBL_MIN in ScChartArray, because Chart wants it so
3205 return DBL_MIN;
3206 }
3207
3208 sal_Bool SAL_CALL ScCellRangesBase::isNotANumber( double nNumber )
3209 {
3210 // use DBL_MIN in ScChartArray, because Chart wants it so
3211 return (nNumber == DBL_MIN);
3212 }
3213
3214 // XModifyBroadcaster
3215
3216 void SAL_CALL ScCellRangesBase::addModifyListener(const uno::Reference<util::XModifyListener>& aListener)
3217 {
3218 SolarMutexGuard aGuard;
3219 if ( aRanges.empty() )
3220 throw uno::RuntimeException();
3221
3222 aValueListeners.emplace_back( aListener );
3223
3224 if ( aValueListeners.size() == 1 )
3225 {
3226 if (!pValueListener)
3227 pValueListener.reset( new ScLinkListener( LINK( this, ScCellRangesBase, ValueListenerHdl ) ) );
3228
3229 ScDocument& rDoc = pDocShell->GetDocument();
3230 for ( size_t i = 0, nCount = aRanges.size(); i < nCount; i++)
3231 rDoc.StartListeningArea( aRanges[ i ], false, pValueListener.get() );
3232
3233 acquire(); // don't lose this object (one ref for all listeners)
3234 }
3235 }
3236
3237 void SAL_CALL ScCellRangesBase::removeModifyListener( const uno::Reference<util::XModifyListener>& aListener )
3238 {
3239
3240 SolarMutexGuard aGuard;
3241 if ( aRanges.empty() )
3242 throw uno::RuntimeException();
3243
3244 rtl::Reference<ScCellRangesBase> xSelfHold(this); // in case the listeners have the last ref
3245
3246 sal_uInt16 nCount = aValueListeners.size();
3247 for ( sal_uInt16 n=nCount; n--; )
3248 {
3249 uno::Reference<util::XModifyListener>& rObj = aValueListeners[n];
3250 if ( rObj == aListener )
3251 {
3252 aValueListeners.erase( aValueListeners.begin() + n );
3253
3254 if ( aValueListeners.empty() )
3255 {
3256 if (pValueListener)
3257 pValueListener->EndListeningAll();
3258
3259 release(); // release the ref for the listeners
3260 }
3261
3262 break;
3263 }
3264 }
3265 }
3266
3267 // XCellRangesQuery
3268
3269 uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryVisibleCells()
3270 {
3271 SolarMutexGuard aGuard;
3272 if (pDocShell)
3273 {
3274 //! Separate for all tables, if markings separated per table
3275 SCTAB nTab = lcl_FirstTab(aRanges);
3276
3277 ScMarkData aMarkData(*GetMarkData());
3278
3279 ScDocument& rDoc = pDocShell->GetDocument();
3280 SCCOL nCol = 0, nLastCol;
3281 while (nCol <= rDoc.MaxCol())
3282 {
3283 if (rDoc.ColHidden(nCol, nTab, nullptr, &nLastCol))
3284 // hidden columns. Deselect them.
3285 aMarkData.SetMultiMarkArea(ScRange(nCol, 0, nTab, nLastCol, rDoc.MaxRow(), nTab), false);
3286
3287 nCol = nLastCol + 1;
3288 }
3289
3290 SCROW nRow = 0, nLastRow;
3291 while (nRow <= rDoc.MaxRow())
3292 {
3293 if (rDoc.RowHidden(nRow, nTab, nullptr, &nLastRow))
3294 // These rows are hidden. Deselect them.
3295 aMarkData.SetMultiMarkArea(ScRange(0, nRow, nTab, rDoc.MaxCol(), nLastRow, nTab), false);
3296
3297 nRow = nLastRow + 1;
3298 }
3299
3300 ScRangeList aNewRanges;
3301 aMarkData.FillRangeListWithMarks( &aNewRanges, false );
3302 return new ScCellRangesObj( pDocShell, aNewRanges );
3303 }
3304
3305 return nullptr;
3306 }
3307
3308 uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryEmptyCells()
3309 {
3310 SolarMutexGuard aGuard;
3311 if (pDocShell)
3312 {
3313 ScDocument& rDoc = pDocShell->GetDocument();
3314
3315 ScMarkData aMarkData(*GetMarkData());
3316
3317 // mark occupied cells
3318 for (size_t i = 0, nCount = aRanges.size(); i < nCount; ++i)
3319 {
3320 ScRange const & rRange = aRanges[ i ];
3321
3322 ScCellIterator aIter(rDoc, rRange);
3323 for (bool bHasCell = aIter.first(); bHasCell; bHasCell = aIter.next())
3324 {
3325 // notes count as non-empty
3326 if (!aIter.isEmpty())
3327 aMarkData.SetMultiMarkArea(ScRange(aIter.GetPos()), false);
3328 }
3329 }
3330
3331 ScRangeList aNewRanges;
3332 // IsMultiMarked is not enough (will not be reset during deselecting)
3333 //if (aMarkData.HasAnyMultiMarks()) // #i20044# should be set for all empty range
3334 aMarkData.FillRangeListWithMarks( &aNewRanges, false );
3335
3336 return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges can be empty
3337 }
3338
3339 return nullptr;
3340 }
3341
3342 uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryContentCells(
3343 sal_Int16 nContentFlags )
3344 {
3345 SolarMutexGuard aGuard;
3346 if (pDocShell)
3347 {
3348 ScDocument& rDoc = pDocShell->GetDocument();
3349
3350 ScMarkData aMarkData(rDoc.GetSheetLimits());
3351
3352 // select matching cells
3353 for ( size_t i = 0, nCount = aRanges.size(); i < nCount; ++i )
3354 {
3355 ScRange const & rRange = aRanges[ i ];
3356
3357 ScCellIterator aIter(rDoc, rRange);
3358 for (bool bHasCell = aIter.first(); bHasCell; bHasCell = aIter.next())
3359 {
3360 bool bAdd = false;
3361 switch (aIter.getType())
3362 {
3363 case CELLTYPE_STRING:
3364 if ( nContentFlags & sheet::CellFlags::STRING )
3365 bAdd = true;
3366 break;
3367 case CELLTYPE_EDIT:
3368 if ( (nContentFlags & sheet::CellFlags::STRING) || (nContentFlags & sheet::CellFlags::FORMATTED) )
3369 bAdd = true;
3370 break;
3371 case CELLTYPE_FORMULA:
3372 if ( nContentFlags & sheet::CellFlags::FORMULA )
3373 bAdd = true;
3374 break;
3375 case CELLTYPE_VALUE:
3376 if ( (nContentFlags & (sheet::CellFlags::VALUE|sheet::CellFlags::DATETIME))
3377 == (sheet::CellFlags::VALUE|sheet::CellFlags::DATETIME) )
3378 bAdd = true;
3379 else
3380 {
3381 // date/time identification
3382
3383 sal_uLong nIndex = static_cast<sal_uLong>(rDoc.GetAttr(
3384 aIter.GetPos(), ATTR_VALUE_FORMAT)->GetValue());
3385 SvNumFormatType nTyp = rDoc.GetFormatTable()->GetType(nIndex);
3386 if ((nTyp == SvNumFormatType::DATE) || (nTyp == SvNumFormatType::TIME) ||
3387 (nTyp == SvNumFormatType::DATETIME))
3388 {
3389 if ( nContentFlags & sheet::CellFlags::DATETIME )
3390 bAdd = true;
3391 }
3392 else
3393 {
3394 if ( nContentFlags & sheet::CellFlags::VALUE )
3395 bAdd = true;
3396 }
3397 }
3398 break;
3399 default:
3400 {
3401 // added to avoid warnings
3402 }
3403 }
3404
3405 if (bAdd)
3406 aMarkData.SetMultiMarkArea(ScRange(aIter.GetPos()));
3407 }
3408 }
3409
3410 if (nContentFlags & sheet::CellFlags::ANNOTATION)
3411 {
3412 std::vector<sc::NoteEntry> aNotes;
3413 rDoc.GetNotesInRange(aRanges, aNotes);
3414
3415 for (const auto& i : aNotes)
3416 {
3417 aMarkData.SetMultiMarkArea(ScRange(i.maPos));
3418 }
3419 }
3420
3421 ScRangeList aNewRanges;
3422 if (aMarkData.IsMultiMarked())
3423 aMarkData.FillRangeListWithMarks( &aNewRanges, false );
3424
3425 return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges can be empty
3426 }
3427
3428 return nullptr;
3429 }
3430
3431 uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryFormulaCells(
3432 sal_Int32 nResultFlags )
3433 {
3434 SolarMutexGuard aGuard;
3435 if (pDocShell)
3436 {
3437 ScDocument& rDoc = pDocShell->GetDocument();
3438
3439 ScMarkData aMarkData(rDoc.GetSheetLimits());
3440
3441 // select matching cells
3442 for ( size_t i = 0, nCount = aRanges.size(); i < nCount; ++i )
3443 {
3444 ScRange const & rRange = aRanges[ i ];
3445
3446 ScCellIterator aIter(rDoc, rRange);
3447 for (bool bHasCell = aIter.first(); bHasCell; bHasCell = aIter.next())
3448 {
3449 if (aIter.getType() == CELLTYPE_FORMULA)
3450 {
3451 ScFormulaCell* pFCell = aIter.getFormulaCell();
3452 bool bAdd = false;
3453 if (pFCell->GetErrCode() != FormulaError::NONE)
3454 {
3455 if ( nResultFlags & sheet::FormulaResult::ERROR )
3456 bAdd = true;
3457 }
3458 else if (pFCell->IsValue())
3459 {
3460 if ( nResultFlags & sheet::FormulaResult::VALUE )
3461 bAdd = true;
3462 }
3463 else // String
3464 {
3465 if ( nResultFlags & sheet::FormulaResult::STRING )
3466 bAdd = true;
3467 }
3468
3469 if (bAdd)
3470 aMarkData.SetMultiMarkArea(ScRange(aIter.GetPos()));
3471 }
3472 }
3473 }
3474
3475 ScRangeList aNewRanges;
3476 if (aMarkData.IsMultiMarked())
3477 aMarkData.FillRangeListWithMarks( &aNewRanges, false );
3478
3479 return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges can be empty
3480 }
3481
3482 return nullptr;
3483 }
3484
3485 uno::Reference<sheet::XSheetCellRanges> ScCellRangesBase::QueryDifferences_Impl(
3486 const table::CellAddress& aCompare, bool bColumnDiff)
3487 {
3488 if (pDocShell)
3489 {
3490 size_t nRangeCount = aRanges.size();
3491 size_t i;
3492 ScDocument& rDoc = pDocShell->GetDocument();
3493 ScMarkData aMarkData(rDoc.GetSheetLimits());
3494
3495 SCCOLROW nCmpPos = bColumnDiff ? static_cast<SCCOLROW>(aCompare.Row) : static_cast<SCCOLROW>(aCompare.Column);
3496
3497 // first select everything, where at all something is in the comparison column
3498 // (in the second step the selection is cancelled for equal cells)
3499
3500 SCTAB nTab = lcl_FirstTab(aRanges); //! for all tables, if markings per table
3501 ScRange aCmpRange, aCellRange;
3502 if (bColumnDiff)
3503 aCmpRange = ScRange( 0,nCmpPos,nTab, rDoc.MaxCol(),nCmpPos,nTab );
3504 else
3505 aCmpRange = ScRange( static_cast<SCCOL>(nCmpPos),0,nTab, static_cast<SCCOL>(nCmpPos),rDoc.MaxRow(),nTab );
3506 ScCellIterator aCmpIter(rDoc, aCmpRange);
3507 for (bool bHasCell = aCmpIter.first(); bHasCell; bHasCell = aCmpIter.next())
3508 {
3509 SCCOLROW nCellPos = bColumnDiff ? static_cast<SCCOLROW>(aCmpIter.GetPos().Col()) : static_cast<SCCOLROW>(aCmpIter.GetPos().Row());
3510 if (bColumnDiff)
3511 aCellRange = ScRange( static_cast<SCCOL>(nCellPos),0,nTab,
3512 static_cast<SCCOL>(nCellPos),rDoc.MaxRow(),nTab );
3513 else
3514 aCellRange = ScRange( 0,nCellPos,nTab, rDoc.MaxCol(),nCellPos,nTab );
3515
3516 for (i=0; i<nRangeCount; i++)
3517 {
3518 ScRange aRange( aRanges[ i ] );
3519 if ( aRange.Intersects( aCellRange ) )
3520 {
3521 if (bColumnDiff)
3522 {
3523 aRange.aStart.SetCol(static_cast<SCCOL>(nCellPos));
3524 aRange.aEnd.SetCol(static_cast<SCCOL>(nCellPos));
3525 }
3526 else
3527 {
3528 aRange.aStart.SetRow(nCellPos);
3529 aRange.aEnd.SetRow(nCellPos);
3530 }
3531 aMarkData.SetMultiMarkArea( aRange );
3532 }
3533 }
3534 }
3535
3536 // compare all not empty cells with the comparison column and accordingly
3537 // select or cancel
3538
3539 ScAddress aCmpAddr;
3540 for (i=0; i<nRangeCount; i++)
3541 {
3542 ScRange const & rRange = aRanges[ i ];
3543
3544 ScCellIterator aIter( rDoc, rRange );
3545 for (bool bHasCell = aIter.first(); bHasCell; bHasCell = aIter.next())
3546 {
3547 if (bColumnDiff)
3548 aCmpAddr = ScAddress( aIter.GetPos().Col(), nCmpPos, aIter.GetPos().Tab() );
3549 else
3550 aCmpAddr = ScAddress( static_cast<SCCOL>(nCmpPos), aIter.GetPos().Row(), aIter.GetPos().Tab() );
3551
3552 ScRange aOneRange(aIter.GetPos());
3553 if (!aIter.equalsWithoutFormat(aCmpAddr))
3554 aMarkData.SetMultiMarkArea( aOneRange );
3555 else
3556 aMarkData.SetMultiMarkArea( aOneRange, false ); // deselect
3557 }
3558 }
3559
3560 ScRangeList aNewRanges;
3561 if (aMarkData.IsMultiMarked())
3562 aMarkData.FillRangeListWithMarks( &aNewRanges, false );
3563
3564 return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges can be empty
3565 }
3566 return nullptr;
3567 }
3568
3569 uno::Reference<sheet::XSheetCellRanges > SAL_CALL ScCellRangesBase::queryColumnDifferences(
3570 const table::CellAddress& aCompare )
3571 {
3572 SolarMutexGuard aGuard;
3573 return QueryDifferences_Impl( aCompare, true );
3574 }
3575
3576 uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryRowDifferences(
3577 const table::CellAddress& aCompare )
3578 {
3579 SolarMutexGuard aGuard;
3580 return QueryDifferences_Impl( aCompare, false );
3581 }
3582
3583 uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryIntersection(
3584 const table::CellRangeAddress& aRange )
3585 {
3586 SolarMutexGuard aGuard;
3587 ScRange aMask( static_cast<SCCOL>(aRange.StartColumn), static_cast<SCROW>(aRange.StartRow), aRange.Sheet,
3588 static_cast<SCCOL>(aRange.EndColumn), static_cast<SCROW>(aRange.EndRow), aRange.Sheet );
3589
3590 ScRangeList aNew;
3591 for ( size_t i = 0, nCount = aRanges.size(); i < nCount; ++i )
3592 {
3593 ScRange aTemp( aRanges[ i ] );
3594 if ( aTemp.Intersects( aMask ) )
3595 aNew.Join( ScRange( std::max( aTemp.aStart.Col(), aMask.aStart.Col() ),
3596 std::max( aTemp.aStart.Row(), aMask.aStart.Row() ),
3597 std::max( aTemp.aStart.Tab(), aMask.aStart.Tab() ),
3598 std::min( aTemp.aEnd.Col(), aMask.aEnd.Col() ),
3599 std::min( aTemp.aEnd.Row(), aMask.aEnd.Row() ),
3600 std::min( aTemp.aEnd.Tab(), aMask.aEnd.Tab() ) ) );
3601 }
3602
3603 return new ScCellRangesObj( pDocShell, aNew ); // can be empty
3604 }
3605
3606 // XFormulaQuery
3607
3608 uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryPrecedents(
3609 sal_Bool bRecursive )
3610 {
3611 SolarMutexGuard aGuard;
3612 if ( pDocShell )
3613 {
3614 ScDocument& rDoc = pDocShell->GetDocument();
3615
3616 ScRangeList aNewRanges(aRanges);
3617 bool bFound;
3618 do
3619 {
3620 bFound = false;
3621
3622 // aMarkData uses aNewRanges, not aRanges, so GetMarkData can't be used
3623 ScMarkData aMarkData(rDoc.GetSheetLimits());
3624 aMarkData.MarkFromRangeList( aNewRanges, false );
3625
3626 for (size_t nR = 0, nCount = aNewRanges.size(); nR<nCount; ++nR)
3627 {
3628 ScRange const & rRange = aNewRanges[ nR];
3629 ScCellIterator aIter(rDoc, rRange);
3630 for (bool bHasCell = aIter.first(); bHasCell; bHasCell = aIter.next())
3631 {
3632 if (aIter.getType() != CELLTYPE_FORMULA)
3633 continue;
3634
3635 ScDetectiveRefIter aRefIter(rDoc, aIter.getFormulaCell());
3636 ScRange aRefRange;
3637 while ( aRefIter.GetNextRef( aRefRange) )
3638 {
3639 if ( bRecursive && !bFound && !aMarkData.IsAllMarked( aRefRange ) )
3640 bFound = true;
3641 aMarkData.SetMultiMarkArea(aRefRange);
3642 }
3643 }
3644 }
3645
3646 aMarkData.FillRangeListWithMarks( &aNewRanges, true );
3647 }
3648 while ( bRecursive && bFound );
3649
3650 return new ScCellRangesObj( pDocShell, aNewRanges );
3651 }
3652
3653 return nullptr;
3654 }
3655
3656 uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryDependents(
3657 sal_Bool bRecursive )
3658 {
3659 SolarMutexGuard aGuard;
3660 if ( pDocShell )
3661 {
3662 ScDocument& rDoc = pDocShell->GetDocument();
3663
3664 ScRangeList aNewRanges(aRanges);
3665 bool bFound;
3666 do
3667 {
3668 bFound = false;
3669
3670 // aMarkData uses aNewRanges, not aRanges, so GetMarkData can't be used
3671 ScMarkData aMarkData(rDoc.GetSheetLimits());
3672 aMarkData.MarkFromRangeList( aNewRanges, false );
3673
3674 SCTAB nTab = lcl_FirstTab(aNewRanges); //! all tables
3675
3676 ScCellIterator aCellIter( rDoc, ScRange(0, 0, nTab, rDoc.MaxCol(), rDoc.MaxRow(), nTab) );
3677 for (bool bHasCell = aCellIter.first(); bHasCell; bHasCell = aCellIter.next())
3678 {
3679 if (aCellIter.getType() != CELLTYPE_FORMULA)
3680 continue;
3681
3682 bool bMark = false;
3683 ScDetectiveRefIter aIter(rDoc, aCellIter.getFormulaCell());
3684 ScRange aRefRange;
3685 while ( aIter.GetNextRef( aRefRange) && !bMark )
3686 {
3687 size_t nRangesCount = aNewRanges.size();
3688 for (size_t nR = 0; nR < nRangesCount; ++nR)
3689 {
3690 ScRange const & rRange = aNewRanges[ nR ];
3691 if (rRange.Intersects(aRefRange))
3692 {
3693 bMark = true; // depending on part of Range
3694 break;
3695 }
3696 }
3697 }
3698 if (bMark)
3699 {
3700 ScRange aCellRange(aCellIter.GetPos());
3701 if ( bRecursive && !bFound && !aMarkData.IsAllMarked( aCellRange ) )
3702 bFound = true;
3703 aMarkData.SetMultiMarkArea(aCellRange);
3704 }
3705 }
3706
3707 aMarkData.FillRangeListWithMarks( &aNewRanges, true );
3708 }
3709 while ( bRecursive && bFound );
3710
3711 return new ScCellRangesObj( pDocShell, aNewRanges );
3712 }
3713
3714 return nullptr;
3715 }
3716
3717 // XSearchable
3718
3719 uno::Reference<util::XSearchDescriptor> SAL_CALL ScCellRangesBase::createSearchDescriptor()
3720 {
3721 return new ScCellSearchObj;
3722 }
3723
3724 uno::Reference<container::XIndexAccess> SAL_CALL ScCellRangesBase::findAll(
3725 const uno::Reference<util::XSearchDescriptor>& xDesc )
3726 {
3727 SolarMutexGuard aGuard;
3728 // should we return Null if nothing is found(?)
3729 uno::Reference<container::XIndexAccess> xRet;
3730 if ( pDocShell && xDesc.is() )
3731 {
3732 ScCellSearchObj* pSearch = dynamic_cast<ScCellSearchObj*>( xDesc.get() );
3733 if (pSearch)
3734 {
3735 SvxSearchItem* pSearchItem = pSearch->GetSearchItem();
3736 if (pSearchItem)
3737 {
3738 ScDocument& rDoc = pDocShell->GetDocument();
3739 pSearchItem->SetCommand( SvxSearchCmd::FIND_ALL );
3740 // always only within this object
3741 pSearchItem->SetSelection( !lcl_WholeSheet(rDoc, aRanges) );
3742
3743 ScMarkData aMark(*GetMarkData());
3744
3745 OUString aDummyUndo;
3746 ScRangeList aMatchedRanges;
3747 SCCOL nCol = 0;
3748 SCROW nRow = 0;
3749 SCTAB nTab = 0;
3750 bool bMatchedRangesWereClamped = false;
3751 bool bFound = rDoc.SearchAndReplace(
3752 *pSearchItem, nCol, nRow, nTab, aMark, aMatchedRanges, aDummyUndo, nullptr, bMatchedRangesWereClamped);
3753 if (bFound)
3754 {
3755 // on findAll always CellRanges no matter how much has been found
3756 xRet.set(new ScCellRangesObj( pDocShell, aMatchedRanges ));
3757 }
3758 }
3759 }
3760 }
3761 return xRet;
3762 }
3763
3764 uno::Reference<uno::XInterface> ScCellRangesBase::Find_Impl(
3765 const uno::Reference<util::XSearchDescriptor>& xDesc,
3766 const ScAddress* pLastPos )
3767 {
3768 uno::Reference<uno::XInterface> xRet;
3769 if ( pDocShell && xDesc.is() )
3770 {
3771 ScCellSearchObj* pSearch = dynamic_cast<ScCellSearchObj*>( xDesc.get() );
3772 if (pSearch)
3773 {
3774 SvxSearchItem* pSearchItem = pSearch->GetSearchItem();
3775 if (pSearchItem)
3776 {
3777 ScDocument& rDoc = pDocShell->GetDocument();
3778 pSearchItem->SetCommand( SvxSearchCmd::FIND );
3779 // only always in this object
3780 pSearchItem->SetSelection( !lcl_WholeSheet(rDoc, aRanges) );
3781
3782 ScMarkData aMark(*GetMarkData());
3783
3784 SCCOL nCol;
3785 SCROW nRow;
3786 SCTAB nTab;
3787 if (pLastPos)
3788 pLastPos->GetVars( nCol, nRow, nTab );
3789 else
3790 {
3791 nTab = lcl_FirstTab(aRanges); //! multiple sheets?
3792 rDoc.GetSearchAndReplaceStart( *pSearchItem, nCol, nRow );
3793 }
3794
3795 OUString aDummyUndo;
3796 ScRangeList aMatchedRanges;
3797 bool bMatchedRangesWereClamped;
3798 bool bFound = rDoc.SearchAndReplace(
3799 *pSearchItem, nCol, nRow, nTab, aMark, aMatchedRanges, aDummyUndo, nullptr, bMatchedRangesWereClamped);
3800 if (bFound)
3801 {
3802 ScAddress aFoundPos( nCol, nRow, nTab );
3803 xRet.set(cppu::getXWeak(new ScCellObj( pDocShell, aFoundPos )));
3804 }
3805 }
3806 }
3807 }
3808 return xRet;
3809 }
3810
3811 uno::Reference<uno::XInterface> SAL_CALL ScCellRangesBase::findFirst(
3812 const uno::Reference<util::XSearchDescriptor>& xDesc )
3813 {
3814 SolarMutexGuard aGuard;
3815 return Find_Impl( xDesc, nullptr );
3816 }
3817
3818 uno::Reference<uno::XInterface> SAL_CALL ScCellRangesBase::findNext(
3819 const uno::Reference<uno::XInterface>& xStartAt,
3820 const uno::Reference<util::XSearchDescriptor >& xDesc )
3821 {
3822 SolarMutexGuard aGuard;
3823 if ( xStartAt.is() )
3824 {
3825 ScCellRangesBase* pRangesImp = dynamic_cast<ScCellRangesBase*>( xStartAt.get() );
3826 if ( pRangesImp && pRangesImp->GetDocShell() == pDocShell )
3827 {
3828 const ScRangeList& rStartRanges = pRangesImp->GetRangeList();
3829 if ( rStartRanges.size() == 1 )
3830 {
3831 ScAddress aStartPos = rStartRanges[ 0 ].aStart;
3832 return Find_Impl( xDesc, &aStartPos );
3833 }
3834 }
3835 }
3836 return nullptr;
3837 }
3838
3839 // XReplaceable
3840
3841 uno::Reference<util::XReplaceDescriptor> SAL_CALL ScCellRangesBase::createReplaceDescriptor()
3842 {
3843 return new ScCellSearchObj;
3844 }
3845
3846 sal_Int32 SAL_CALL ScCellRangesBase::replaceAll( const uno::Reference<util::XSearchDescriptor>& xDesc )
3847 {
3848 SolarMutexGuard aGuard;
3849 sal_uInt64 nReplaced = 0;
3850 if ( pDocShell && xDesc.is() )
3851 {
3852 ScCellSearchObj* pSearch = dynamic_cast<ScCellSearchObj*>( xDesc.get() );
3853 if (pSearch)
3854 {
3855 SvxSearchItem* pSearchItem = pSearch->GetSearchItem();
3856 if (pSearchItem)
3857 {
3858 ScDocument& rDoc = pDocShell->GetDocument();
3859 bool bUndo(rDoc.IsUndoEnabled());
3860 pSearchItem->SetCommand( SvxSearchCmd::REPLACE_ALL );
3861 // only always in this object
3862 pSearchItem->SetSelection( !lcl_WholeSheet(rDoc, aRanges) );
3863
3864 ScMarkData aMark(*GetMarkData());
3865
3866 SCTAB nTabCount = rDoc.GetTableCount();
3867 bool bProtected = !pDocShell->IsEditable();
3868 for (const auto& rTab : aMark)
3869 {
3870 if (rTab >= nTabCount)
3871 break;
3872 if ( rDoc.IsTabProtected(rTab) )
3873 bProtected = true;
3874 }
3875 if (bProtected)
3876 {
3877 //! Exception, or what?
3878 }
3879 else
3880 {
3881 SCTAB nTab = aMark.GetFirstSelected(); // do not use if SearchAndReplace
3882 SCCOL nCol = 0;
3883 SCROW nRow = 0;
3884
3885 OUString aUndoStr;
3886 ScDocumentUniquePtr pUndoDoc;
3887 if (bUndo)
3888 {
3889 pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
3890 pUndoDoc->InitUndo( rDoc, nTab, nTab );
3891 }
3892 for (const auto& rTab : aMark)
3893 {
3894 if (rTab >= nTabCount)
3895 break;
3896 if (rTab != nTab && bUndo)
3897 pUndoDoc->AddUndoTab( rTab, rTab );
3898 }
3899 std::unique_ptr<ScMarkData> pUndoMark;
3900 if (bUndo)
3901 pUndoMark.reset(new ScMarkData(aMark));
3902
3903 bool bFound = false;
3904 if (bUndo)
3905 {
3906 ScRangeList aMatchedRanges;
3907 bool bMatchedRangesWereClamped;
3908 bFound = rDoc.SearchAndReplace(
3909 *pSearchItem, nCol, nRow, nTab, aMark, aMatchedRanges, aUndoStr, pUndoDoc.get(), bMatchedRangesWereClamped );
3910 }
3911 if (bFound)
3912 {
3913 nReplaced = pUndoDoc->GetCellCount();
3914
3915 pDocShell->GetUndoManager()->AddUndoAction(
3916 std::make_unique<ScUndoReplace>( pDocShell, *pUndoMark, nCol, nRow, nTab,
3917 aUndoStr, std::move(pUndoDoc), pSearchItem ) );
3918
3919 pDocShell->PostPaintGridAll();
3920 pDocShell->SetDocumentModified();
3921 }
3922 }
3923 }
3924 }
3925 }
3926 return nReplaced;
3927 }
3928
3929 ScCellRangesObj::ScCellRangesObj(ScDocShell* pDocSh, const ScRangeList& rR)
3930 : ScCellRangesObj_BASE(pDocSh, rR)
3931 {
3932 }
3933
3934 ScCellRangesObj::~ScCellRangesObj()
3935 {
3936 }
3937
3938 void ScCellRangesObj::RefChanged()
3939 {
3940 ScCellRangesBase::RefChanged();
3941 }
3942
3943 // XCellRanges
3944
3945 rtl::Reference<ScCellRangeObj> ScCellRangesObj::GetObjectByIndex_Impl(sal_Int32 nIndex) const
3946 {
3947 ScDocShell* pDocSh = GetDocShell();
3948 const ScRangeList& rRanges = GetRangeList();
3949 if ( pDocSh && nIndex >= 0 && nIndex < sal::static_int_cast<sal_Int32>(rRanges.size()) )
3950 {
3951 ScRange const & rRange = rRanges[ nIndex ];
3952 if ( rRange.aStart == rRange.aEnd )
3953 return new ScCellObj( pDocSh, rRange.aStart );
3954 else
3955 return new ScCellRangeObj( pDocSh, rRange );
3956 }
3957
3958 return nullptr; // no DocShell or wrong index
3959 }
3960
3961 uno::Sequence<table::CellRangeAddress> SAL_CALL ScCellRangesObj::getRangeAddresses()
3962 {
3963 SolarMutexGuard aGuard;
3964 ScDocShell* pDocSh = GetDocShell();
3965 const ScRangeList& rRanges = GetRangeList();
3966 size_t nCount = rRanges.size();
3967 if ( pDocSh && nCount )
3968 {
3969 table::CellRangeAddress aRangeAddress;
3970 uno::Sequence<table::CellRangeAddress> aSeq(nCount);
3971 table::CellRangeAddress* pAry = aSeq.getArray();
3972 for ( size_t i=0; i < nCount; i++)
3973 {
3974 ScUnoConversion::FillApiRange( aRangeAddress, rRanges[ i ] );
3975 pAry[i] = aRangeAddress;
3976 }
3977 return aSeq;
3978 }
3979
3980 return {}; // can be empty
3981 }
3982
3983 uno::Reference<container::XEnumerationAccess> SAL_CALL ScCellRangesObj::getCells()
3984 {
3985 SolarMutexGuard aGuard;
3986
3987 // getCells with empty range list is possible (no exception),
3988 // the resulting enumeration just has no elements
3989 // (same behaviour as a valid range with no cells)
3990 // This is handled in ScCellsEnumeration ctor.
3991
3992 const ScRangeList& rRanges = GetRangeList();
3993 ScDocShell* pDocSh = GetDocShell();
3994 if (pDocSh)
3995 return new ScCellsObj( pDocSh, rRanges );
3996 return nullptr;
3997 }
3998
3999 OUString SAL_CALL ScCellRangesObj::getRangeAddressesAsString()
4000 {
4001 SolarMutexGuard aGuard;
4002 OUString aString;
4003 ScDocShell* pDocSh = GetDocShell();
4004 const ScRangeList& rRanges = GetRangeList();
4005 if (pDocSh)
4006 rRanges.Format( aString, ScRefFlags::VALID | ScRefFlags::TAB_3D, pDocSh->GetDocument() );
4007 return aString;
4008 }
4009
4010 // XSheetCellRangeContainer
4011
4012 void SAL_CALL ScCellRangesObj::addRangeAddress( const table::CellRangeAddress& rRange,
4013 sal_Bool bMergeRanges )
4014 {
4015 SolarMutexGuard aGuard;
4016 ScRange aRange(static_cast<SCCOL>(rRange.StartColumn),
4017 static_cast<SCROW>(rRange.StartRow),
4018 static_cast<SCTAB>(rRange.Sheet),
4019 static_cast<SCCOL>(rRange.EndColumn),
4020 static_cast<SCROW>(rRange.EndRow),
4021 static_cast<SCTAB>(rRange.Sheet));
4022 AddRange(aRange, bMergeRanges);
4023 }
4024
4025 static void lcl_RemoveNamedEntry( std::vector<ScCellRangesObj::ScNamedEntry>& rNamedEntries, const ScRange& rRange )
4026 {
4027 sal_uInt16 nCount = rNamedEntries.size();
4028 for ( sal_uInt16 n=nCount; n--; )
4029 if ( rNamedEntries[n].GetRange() == rRange )
4030 rNamedEntries.erase( rNamedEntries.begin() + n );
4031 }
4032
4033 void SAL_CALL ScCellRangesObj::removeRangeAddress( const table::CellRangeAddress& rRange )
4034 {
4035 SolarMutexGuard aGuard;
4036 const ScRangeList& rRanges = GetRangeList();
4037
4038 ScRangeList aSheetRanges;
4039 ScRangeList aNotSheetRanges;
4040 for (size_t i = 0; i < rRanges.size(); ++i)
4041 {
4042 if (rRanges[ i].aStart.Tab() == rRange.Sheet)
4043 {
4044 aSheetRanges.push_back( rRanges[ i ] );
4045 }
4046 else
4047 {
4048 aNotSheetRanges.push_back( rRanges[ i ] );
4049 }
4050 }
4051 ScMarkData aMarkData(GetDocument()->GetSheetLimits());
4052 aMarkData.MarkFromRangeList( aSheetRanges, false );
4053 ScRange aRange(static_cast<SCCOL>(rRange.StartColumn),
4054 static_cast<SCROW>(rRange.StartRow),
4055 static_cast<SCTAB>(rRange.Sheet),
4056 static_cast<SCCOL>(rRange.EndColumn),
4057 static_cast<SCROW>(rRange.EndRow),
4058 static_cast<SCTAB>(rRange.Sheet));
4059 if (aMarkData.GetTableSelect( aRange.aStart.Tab() ))
4060 {
4061 aMarkData.MarkToMulti();
4062 if (!aMarkData.IsAllMarked( aRange ) )
4063 throw container::NoSuchElementException();
4064
4065 aMarkData.SetMultiMarkArea( aRange, false );
4066 lcl_RemoveNamedEntry(m_aNamedEntries, aRange);
4067
4068 }
4069 SetNewRanges(aNotSheetRanges);
4070 ScRangeList aNew;
4071 aMarkData.FillRangeListWithMarks( &aNew, false );
4072 for ( size_t j = 0; j < aNew.size(); ++j)
4073 {
4074 AddRange(aNew[ j ], false);
4075 }
4076 }
4077
4078 void SAL_CALL ScCellRangesObj::addRangeAddresses( const uno::Sequence<table::CellRangeAddress >& rRanges,
4079 sal_Bool bMergeRanges )
4080 {
4081 SolarMutexGuard aGuard;
4082 for (const table::CellRangeAddress& rRange : rRanges)
4083 {
4084 ScRange aRange(static_cast<SCCOL>(rRange.StartColumn),
4085 static_cast<SCROW>(rRange.StartRow),
4086 static_cast<SCTAB>(rRange.Sheet),
4087 static_cast<SCCOL>(rRange.EndColumn),
4088 static_cast<SCROW>(rRange.EndRow),
4089 static_cast<SCTAB>(rRange.Sheet));
4090 AddRange(aRange, bMergeRanges);
4091 }
4092 }
4093
4094 void SAL_CALL ScCellRangesObj::removeRangeAddresses( const uno::Sequence<table::CellRangeAddress >& rRangeSeq )
4095 {
4096 // use sometimes a better/faster implementation
4097 for (const table::CellRangeAddress& rRange : rRangeSeq)
4098 {
4099 removeRangeAddress(rRange);
4100 }
4101 }
4102
4103 // XNameContainer
4104
4105 static void lcl_RemoveNamedEntry( std::vector<ScCellRangesObj::ScNamedEntry>& rNamedEntries, std::u16string_view rName )
4106 {
4107 sal_uInt16 nCount = rNamedEntries.size();
4108 for ( sal_uInt16 n=nCount; n--; )
4109 if ( rNamedEntries[n].GetName() == rName )
4110 rNamedEntries.erase( rNamedEntries.begin() + n );
4111 }
4112
4113 void SAL_CALL ScCellRangesObj::insertByName( const OUString& aName, const uno::Any& aElement )
4114 {
4115 SolarMutexGuard aGuard;
4116 ScDocShell* pDocSh = GetDocShell();
4117 bool bDone = false;
4118
4119 //! Type of aElement can be some specific interface instead of XInterface
4120
4121 uno::Reference<uno::XInterface> xInterface(aElement, uno::UNO_QUERY);
4122 if ( pDocSh && xInterface.is() )
4123 {
4124 ScCellRangesBase* pRangesImp = dynamic_cast<ScCellRangesBase*>( xInterface.get() );
4125 if ( pRangesImp && pRangesImp->GetDocShell() == pDocSh )
4126 {
4127 // if explicit name is given and already existing, throw exception
4128
4129 if ( !aName.isEmpty() )
4130 {
4131 size_t nNamedCount = m_aNamedEntries.size();
4132 for (size_t n = 0; n < nNamedCount; n++)
4133 {
4134 if (m_aNamedEntries[n].GetName() == aName)
4135 throw container::ElementExistException();
4136 }
4137 }
4138
4139 ScRangeList aNew(GetRangeList());
4140 const ScRangeList& rAddRanges = pRangesImp->GetRangeList();
4141 size_t nAddCount = rAddRanges.size();
4142 for ( size_t i = 0; i < nAddCount; i++ )
4143 aNew.Join( rAddRanges[ i ] );
4144 SetNewRanges(aNew);
4145 bDone = true;
4146
4147 if ( !aName.isEmpty() && nAddCount == 1 )
4148 {
4149 // if a name is given, also insert into list of named entries
4150 // (only possible for a single range)
4151 // name is not in m_aNamedEntries (tested above)
4152 m_aNamedEntries.emplace_back( ScNamedEntry{aName, rAddRanges[ 0 ]} );
4153 }
4154 }
4155 }
4156
4157 if (!bDone)
4158 {
4159 // invalid element - double names are handled above
4160 throw lang::IllegalArgumentException();
4161 }
4162 }
4163
4164 static bool lcl_FindRangeByName( const ScRangeList& rRanges, ScDocShell* pDocSh,
4165 std::u16string_view rName, size_t& rIndex )
4166 {
4167 if (pDocSh)
4168 {
4169 OUString aRangeStr;
4170 ScDocument& rDoc = pDocSh->GetDocument();
4171 for ( size_t i = 0, nCount = rRanges.size(); i < nCount; i++ )
4172 {
4173 aRangeStr = rRanges[ i ].Format(rDoc, ScRefFlags::VALID | ScRefFlags::TAB_3D);
4174 if ( aRangeStr == rName )
4175 {
4176 rIndex = i;
4177 return true;
4178 }
4179 }
4180 }
4181 return false;
4182 }
4183
4184 static bool lcl_FindRangeOrEntry( const std::vector<ScCellRangesObj::ScNamedEntry>& rNamedEntries,
4185 const ScRangeList& rRanges, ScDocShell* pDocSh,
4186 const OUString& rName, ScRange& rFound )
4187 {
4188 // exact range in list?
4189
4190 size_t nIndex = 0;
4191 if ( lcl_FindRangeByName( rRanges, pDocSh, rName, nIndex ) )
4192 {
4193 rFound = rRanges[ nIndex ];
4194 return true;
4195 }
4196
4197 // range contained in selection? (sheet must be specified)
4198
4199 ScRange aCellRange;
4200 ScRefFlags nParse = aCellRange.ParseAny( rName, pDocSh->GetDocument() );
4201 if ( (nParse & ( ScRefFlags::VALID | ScRefFlags::TAB_3D ))
4202 == ( ScRefFlags::VALID | ScRefFlags::TAB_3D ))
4203 {
4204 ScMarkData aMarkData(pDocSh->GetDocument().GetSheetLimits());
4205 aMarkData.MarkFromRangeList( rRanges, false );
4206 if ( aMarkData.IsAllMarked( aCellRange ) )
4207 {
4208 rFound = aCellRange;
4209 return true;
4210 }
4211 }
4212
4213 // named entry in this object?
4214
4215 for (const auto & rNamedEntry : rNamedEntries)
4216 if ( rNamedEntry.GetName() == rName )
4217 {
4218 // test if named entry is contained in rRanges
4219
4220 const ScRange& rComp = rNamedEntry.GetRange();
4221 ScMarkData aMarkData(pDocSh->GetDocument().GetSheetLimits());
4222 aMarkData.MarkFromRangeList( rRanges, false );
4223 if ( aMarkData.IsAllMarked( rComp ) )
4224 {
4225 rFound = rComp;
4226 return true;
4227 }
4228 }
4229
4230 return false; // not found
4231 }
4232
4233 void SAL_CALL ScCellRangesObj::removeByName( const OUString& aName )
4234 {
4235 SolarMutexGuard aGuard;
4236 bool bDone = false;
4237 ScDocShell* pDocSh = GetDocShell();
4238 const ScRangeList& rRanges = GetRangeList();
4239 size_t nIndex = 0;
4240 if ( lcl_FindRangeByName( rRanges, pDocSh, aName, nIndex ) )
4241 {
4242 // skip a single range
4243 ScRangeList aNew;
4244 for ( size_t i = 0, nCount = rRanges.size(); i < nCount; i++ )
4245 if (i != nIndex)
4246 aNew.push_back( rRanges[ i ] );
4247 SetNewRanges(aNew);
4248 bDone = true;
4249 }
4250 else if (pDocSh)
4251 {
4252 // deselect any ranges (parsed or named entry)
4253 ScRangeList aDiff;
4254 bool bValid = ( aDiff.Parse( aName, pDocSh->GetDocument() ) & ScRefFlags::VALID )
4255 == ScRefFlags::VALID;
4256 if (!bValid)
4257 {
4258 sal_uInt16 nCount = m_aNamedEntries.size();
4259 for (sal_uInt16 n=0; n<nCount && !bValid; n++)
4260 if (m_aNamedEntries[n].GetName() == aName)
4261 {
4262 aDiff.RemoveAll();
4263 aDiff.push_back(m_aNamedEntries[n].GetRange());
4264 bValid = true;
4265 }
4266 }
4267 if ( bValid )
4268 {
4269 ScMarkData aMarkData(GetDocument()->GetSheetLimits());
4270 aMarkData.MarkFromRangeList( rRanges, false );
4271
4272 for ( size_t i = 0, nDiffCount = aDiff.size(); i < nDiffCount; i++ )
4273 {
4274 ScRange const & rDiffRange = aDiff[ i ];
4275 if (aMarkData.GetTableSelect( rDiffRange.aStart.Tab() ))
4276 aMarkData.SetMultiMarkArea( rDiffRange, false );
4277 }
4278
4279 ScRangeList aNew;
4280 aMarkData.FillRangeListWithMarks( &aNew, false );
4281 SetNewRanges(aNew);
4282
4283 bDone = true; //! error if range was not selected before?
4284 }
4285 }
4286
4287 if (!m_aNamedEntries.empty())
4288 lcl_RemoveNamedEntry(m_aNamedEntries, aName);
4289
4290 if (!bDone)
4291 throw container::NoSuchElementException(); // not found
4292 }
4293
4294 // XNameReplace
4295
4296 void SAL_CALL ScCellRangesObj::replaceByName( const OUString& aName, const uno::Any& aElement )
4297 {
4298 SolarMutexGuard aGuard;
4299 //! combine?
4300 removeByName( aName );
4301 insertByName( aName, aElement );
4302 }
4303
4304 // XNameAccess
4305
4306 uno::Any SAL_CALL ScCellRangesObj::getByName( const OUString& aName )
4307 {
4308 SolarMutexGuard aGuard;
4309 uno::Any aRet;
4310
4311 ScDocShell* pDocSh = GetDocShell();
4312 const ScRangeList& rRanges = GetRangeList();
4313 ScRange aRange;
4314 if (!lcl_FindRangeOrEntry(m_aNamedEntries, rRanges,
4315 pDocSh, aName, aRange))
4316 throw container::NoSuchElementException();
4317
4318 uno::Reference<table::XCellRange> xRange;
4319 if ( aRange.aStart == aRange.aEnd )
4320 xRange.set(new ScCellObj( pDocSh, aRange.aStart ));
4321 else
4322 xRange.set(new ScCellRangeObj( pDocSh, aRange ));
4323 aRet <<= xRange;
4324
4325 return aRet;
4326 }
4327
4328 static bool lcl_FindEntryName( const std::vector<ScCellRangesObj::ScNamedEntry>& rNamedEntries,
4329 const ScRange& rRange, OUString& rName )
4330 {
4331 sal_uInt16 nCount = rNamedEntries.size();
4332 for (sal_uInt16 i=0; i<nCount; i++)
4333 if (rNamedEntries[i].GetRange() == rRange)
4334 {
4335 rName = rNamedEntries[i].GetName();
4336 return true;
4337 }
4338 return false;
4339 }
4340
4341 uno::Sequence<OUString> SAL_CALL ScCellRangesObj::getElementNames()
4342 {
4343 SolarMutexGuard aGuard;
4344
4345 ScDocShell* pDocSh = GetDocShell();
4346 const ScRangeList& rRanges = GetRangeList();
4347 if (pDocSh)
4348 {
4349 OUString aRangeStr;
4350 ScDocument& rDoc = pDocSh->GetDocument();
4351 size_t nCount = rRanges.size();
4352
4353 uno::Sequence<OUString> aSeq(nCount);
4354 OUString* pAry = aSeq.getArray();
4355 for (size_t i=0; i < nCount; i++)
4356 {
4357 // use given name if for exactly this range, otherwise just format
4358 ScRange const & rRange = rRanges[ i ];
4359 if (m_aNamedEntries.empty() ||
4360 !lcl_FindEntryName(m_aNamedEntries, rRange, aRangeStr))
4361 {
4362 aRangeStr = rRange.Format(rDoc, ScRefFlags::VALID | ScRefFlags::TAB_3D);
4363 }
4364 pAry[i] = aRangeStr;
4365 }
4366 return aSeq;
4367 }
4368 return {};
4369 }
4370
4371 sal_Bool SAL_CALL ScCellRangesObj::hasByName( const OUString& aName )
4372 {
4373 SolarMutexGuard aGuard;
4374 ScDocShell* pDocSh = GetDocShell();
4375 const ScRangeList& rRanges = GetRangeList();
4376 ScRange aRange;
4377 return lcl_FindRangeOrEntry(m_aNamedEntries, rRanges, pDocSh,
4378 aName, aRange);
4379 }
4380
4381 // XEnumerationAccess
4382
4383 uno::Reference<container::XEnumeration> SAL_CALL ScCellRangesObj::createEnumeration()
4384 {
4385 SolarMutexGuard aGuard;
4386 return new ScIndexEnumeration(this, u"com.sun.star.sheet.SheetCellRangesEnumeration"_ustr);
4387 }
4388
4389 // XIndexAccess
4390
4391 sal_Int32 SAL_CALL ScCellRangesObj::getCount()
4392 {
4393 SolarMutexGuard aGuard;
4394 const ScRangeList& rRanges = GetRangeList();
4395 return rRanges.size();
4396 }
4397
4398 uno::Any SAL_CALL ScCellRangesObj::getByIndex( sal_Int32 nIndex )
4399 {
4400 SolarMutexGuard aGuard;
4401 uno::Reference<table::XCellRange> xRange(GetObjectByIndex_Impl(nIndex));
4402 if (!xRange.is())
4403 throw lang::IndexOutOfBoundsException();
4404
4405 return uno::Any(xRange);
4406
4407 }
4408
4409 uno::Type SAL_CALL ScCellRangesObj::getElementType()
4410 {
4411 return cppu::UnoType<table::XCellRange>::get();
4412 }
4413
4414 sal_Bool SAL_CALL ScCellRangesObj::hasElements()
4415 {
4416 SolarMutexGuard aGuard;
4417 const ScRangeList& rRanges = GetRangeList();
4418 return !rRanges.empty();
4419 }
4420
4421 // XServiceInfo
4422 OUString SAL_CALL ScCellRangesObj::getImplementationName()
4423 {
4424 return u"ScCellRangesObj"_ustr;
4425 }
4426
4427 sal_Bool SAL_CALL ScCellRangesObj::supportsService( const OUString& rServiceName )
4428 {
4429 return cppu::supportsService(this, rServiceName);
4430 }
4431
4432 uno::Sequence<OUString> SAL_CALL ScCellRangesObj::getSupportedServiceNames()
4433 {
4434 return {SCSHEETCELLRANGES_SERVICE,
4435 SCCELLPROPERTIES_SERVICE,
4436 SCCHARPROPERTIES_SERVICE,
4437 SCPARAPROPERTIES_SERVICE};
4438 }
4439
4440 uno::Reference<table::XCellRange> ScCellRangeObj::CreateRangeFromDoc( const ScDocument& rDoc, const ScRange& rR )
4441 {
4442 if ( ScDocShell* pDocShell = rDoc.GetDocumentShell() )
4443 return new ScCellRangeObj( pDocShell, rR );
4444 return nullptr;
4445 }
4446
4447 ScCellRangeObj::ScCellRangeObj(ScDocShell* pDocSh, const ScRange& rR) :
4448 ScCellRangeObj_BASE( pDocSh, rR ),
4449 pRangePropSet( lcl_GetRangePropertySet() ),
4450 aRange( rR )
4451 {
4452 aRange.PutInOrder(); // beginning / end correct
4453 }
4454
4455 ScCellRangeObj::~ScCellRangeObj()
4456 {
4457 }
4458
4459 void ScCellRangeObj::RefChanged()
4460 {
4461 ScCellRangesBase::RefChanged();
4462
4463 const ScRangeList& rRanges = GetRangeList();
4464 OSL_ENSURE(rRanges.size() == 1, "What ranges ?!?!");
4465 if ( !rRanges.empty() )
4466 {
4467 const ScRange & rFirst = rRanges[0];
4468 aRange = rFirst;
4469 aRange.PutInOrder();
4470 }
4471 }
4472
4473 // XCellRange
4474
4475 // ColumnCount / RowCount vanished
4476 //! are used in Writer for tables ???
4477
4478 uno::Reference<table::XCell> ScCellRangeObj::GetCellByPosition_Impl(
4479 sal_Int32 nColumn, sal_Int32 nRow )
4480 {
4481 ScDocShell* pDocSh = GetDocShell();
4482 if (!pDocSh)
4483 throw uno::RuntimeException();
4484
4485 if ( nColumn >= 0 && nRow >= 0 )
4486 {
4487 sal_Int32 nPosX = aRange.aStart.Col() + nColumn;
4488 sal_Int32 nPosY = aRange.aStart.Row() + nRow;
4489
4490 if ( nPosX <= aRange.aEnd.Col() && nPosY <= aRange.aEnd.Row() )
4491 {
4492 ScAddress aNew( static_cast<SCCOL>(nPosX), static_cast<SCROW>(nPosY), aRange.aStart.Tab() );
4493 return new ScCellObj( pDocSh, aNew );
4494 }
4495 }
4496
4497 throw lang::IndexOutOfBoundsException();
4498 }
4499
4500 uno::Reference<table::XCell> SAL_CALL ScCellRangeObj::getCellByPosition(
4501 sal_Int32 nColumn, sal_Int32 nRow )
4502 {
4503 SolarMutexGuard aGuard;
4504
4505 return GetCellByPosition_Impl(nColumn, nRow);
4506 }
4507
4508 uno::Reference<table::XCellRange> SAL_CALL ScCellRangeObj::getCellRangeByPosition(
4509 sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom )
4510 {
4511 SolarMutexGuard aGuard;
4512
4513 ScDocShell* pDocSh = GetDocShell();
4514 if (!pDocSh)
4515 throw uno::RuntimeException();
4516
4517 if ( nLeft >= 0 && nTop >= 0 && nRight >= 0 && nBottom >= 0 )
4518 {
4519 sal_Int32 nStartX = aRange.aStart.Col() + nLeft;
4520 sal_Int32 nStartY = aRange.aStart.Row() + nTop;
4521 sal_Int32 nEndX = aRange.aStart.Col() + nRight;
4522 sal_Int32 nEndY = aRange.aStart.Row() + nBottom;
4523
4524 if ( nStartX <= nEndX && nEndX <= aRange.aEnd.Col() &&
4525 nStartY <= nEndY && nEndY <= aRange.aEnd.Row() )
4526 {
4527 ScRange aNew( static_cast<SCCOL>(nStartX), static_cast<SCROW>(nStartY), aRange.aStart.Tab(),
4528 static_cast<SCCOL>(nEndX), static_cast<SCROW>(nEndY), aRange.aEnd.Tab() );
4529 return new ScCellRangeObj( pDocSh, aNew );
4530 }
4531 }
4532
4533 throw lang::IndexOutOfBoundsException();
4534 }
4535
4536 uno::Reference<table::XCellRange> SAL_CALL ScCellRangeObj::getCellRangeByName(
4537 const OUString& aName )
4538 {
4539 return getCellRangeByName( aName, ScAddress::detailsOOOa1 );
4540 }
4541
4542 uno::Reference<table::XCellRange> ScCellRangeObj::getCellRangeByName(
4543 const OUString& aName, const ScAddress::Details& rDetails )
4544 {
4545 // name refers to the whole document (with the range's table as default),
4546 // valid only if the range is within this range
4547
4548 SolarMutexGuard aGuard;
4549 ScDocShell* pDocSh = GetDocShell();
4550 if ( pDocSh )
4551 {
4552 ScDocument& rDoc = pDocSh->GetDocument();
4553 SCTAB nTab = aRange.aStart.Tab();
4554
4555 ScRange aCellRange;
4556 bool bFound = false;
4557 ScRefFlags nParse = aCellRange.ParseAny( aName, rDoc, rDetails );
4558 if ( nParse & ScRefFlags::VALID )
4559 {
4560 if ( !(nParse & ScRefFlags::TAB_3D) ) // no sheet specified -> this sheet
4561 {
4562 aCellRange.aStart.SetTab(nTab);
4563 aCellRange.aEnd.SetTab(nTab);
4564 }
4565 bFound = true;
4566 }
4567 else
4568 {
4569 if ( ScRangeUtil::MakeRangeFromName( aName, rDoc, nTab, aCellRange, RUTL_NAMES, rDetails) ||
4570 ScRangeUtil::MakeRangeFromName( aName, rDoc, nTab, aCellRange, RUTL_DBASE, rDetails))
4571 bFound = true;
4572 }
4573
4574 if (bFound) // valid only if within this object's range
4575 {
4576 if (!aRange.Contains(aCellRange))
4577 bFound = false;
4578 }
4579
4580 if (bFound)
4581 {
4582 if ( aCellRange.aStart == aCellRange.aEnd )
4583 return new ScCellObj( pDocSh, aCellRange.aStart );
4584 else
4585 return new ScCellRangeObj( pDocSh, aCellRange );
4586 }
4587 }
4588
4589 throw uno::RuntimeException();
4590 }
4591
4592 // XColumnRowRange
4593
4594 uno::Reference<table::XTableColumns> SAL_CALL ScCellRangeObj::getColumns()
4595 {
4596 SolarMutexGuard aGuard;
4597 ScDocShell* pDocSh = GetDocShell();
4598 if (pDocSh)
4599 return new ScTableColumnsObj( pDocSh, aRange.aStart.Tab(),
4600 aRange.aStart.Col(), aRange.aEnd.Col() );
4601
4602 OSL_FAIL("Document invalid");
4603 return nullptr;
4604 }
4605
4606 uno::Reference<table::XTableRows> SAL_CALL ScCellRangeObj::getRows()
4607 {
4608 SolarMutexGuard aGuard;
4609 ScDocShell* pDocSh = GetDocShell();
4610 if (pDocSh)
4611 return new ScTableRowsObj( pDocSh, aRange.aStart.Tab(),
4612 aRange.aStart.Row(), aRange.aEnd.Row() );
4613
4614 OSL_FAIL("Document invalid");
4615 return nullptr;
4616 }
4617
4618 // XAddressableCellRange
4619
4620 table::CellRangeAddress SAL_CALL ScCellRangeObj::getRangeAddress()
4621 {
4622 SolarMutexGuard aGuard;
4623 table::CellRangeAddress aRet;
4624 ScUnoConversion::FillApiRange( aRet, aRange );
4625 return aRet;
4626 }
4627
4628 // XSheetCellRange
4629
4630 uno::Reference<sheet::XSpreadsheet> SAL_CALL ScCellRangeObj::getSpreadsheet()
4631 {
4632 SolarMutexGuard aGuard;
4633 ScDocShell* pDocSh = GetDocShell();
4634 if (pDocSh)
4635 return new ScTableSheetObj( pDocSh, aRange.aStart.Tab() );
4636
4637 OSL_FAIL("Document invalid");
4638 return nullptr;
4639 }
4640
4641 // XArrayFormulaRange
4642
4643 OUString SAL_CALL ScCellRangeObj::getArrayFormula()
4644 {
4645 SolarMutexGuard aGuard;
4646
4647 // Matrix formula if clearly part of a matrix (so when start and end of
4648 // the block belong to the same matrix) else empty string.
4649
4650 ScDocShell* pDocSh = GetDocShell();
4651 if (!pDocSh)
4652 return OUString();
4653
4654 ScDocument& rDoc = pDocSh->GetDocument();
4655 ScRefCellValue aCell1(rDoc, aRange.aStart);
4656 ScRefCellValue aCell2(rDoc, aRange.aEnd);
4657 if (aCell1.getType() == CELLTYPE_FORMULA && aCell2.getType() == CELLTYPE_FORMULA)
4658 {
4659 const ScFormulaCell* pFCell1 = aCell1.getFormula();
4660 const ScFormulaCell* pFCell2 = aCell2.getFormula();
4661 ScAddress aStart1;
4662 ScAddress aStart2;
4663 if (pFCell1->GetMatrixOrigin(rDoc, aStart1) && pFCell2->GetMatrixOrigin(rDoc, aStart2))
4664 {
4665 if (aStart1 == aStart2) // both the same matrix
4666 return pFCell1->GetFormula(); // it doesn't matter from which cell
4667 }
4668 }
4669 return OUString();
4670 }
4671
4672 void ScCellRangeObj::SetArrayFormula_Impl(const OUString& rFormula,
4673 const formula::FormulaGrammar::Grammar eGrammar)
4674 {
4675 ScDocShell* pDocSh = GetDocShell();
4676 if (!pDocSh)
4677 return;
4678
4679 if ( !rFormula.isEmpty() )
4680 {
4681 if ( dynamic_cast<ScTableSheetObj*>( this ) )
4682 {
4683 // don't set array formula for sheet object
4684 throw uno::RuntimeException();
4685 }
4686
4687 pDocSh->GetDocFunc().EnterMatrix( aRange, nullptr, nullptr, rFormula, true, true, OUString()/*rFormulaNmsp*/, eGrammar );
4688 }
4689 else
4690 {
4691 // empty string -> erase array formula
4692 ScMarkData aMark(GetDocument()->GetSheetLimits());
4693 aMark.SetMarkArea( aRange );
4694 aMark.SelectTable( aRange.aStart.Tab(), true );
4695 pDocSh->GetDocFunc().DeleteContents( aMark, InsertDeleteFlags::CONTENTS, true, true );
4696 }
4697 }
4698
4699 void SAL_CALL ScCellRangeObj::setArrayFormula( const OUString& aFormula )
4700 {
4701 SolarMutexGuard aGuard;
4702 // GRAM_API for API compatibility.
4703 SetArrayFormula_Impl( aFormula, formula::FormulaGrammar::GRAM_API);
4704 }
4705
4706 // XArrayFormulaTokens
4707 uno::Sequence<sheet::FormulaToken> SAL_CALL ScCellRangeObj::getArrayTokens()
4708 {
4709 SolarMutexGuard aGuard;
4710
4711 // same cell logic as in getArrayFormula
4712
4713 uno::Sequence<sheet::FormulaToken> aSequence;
4714 ScDocShell* pDocSh = GetDocShell();
4715 if (!pDocSh)
4716 return aSequence;
4717
4718 ScDocument& rDoc = pDocSh->GetDocument();
4719 ScRefCellValue aCell1(rDoc, aRange.aStart);
4720 ScRefCellValue aCell2(rDoc, aRange.aEnd);
4721 if (aCell1.getType() == CELLTYPE_FORMULA && aCell2.getType() == CELLTYPE_FORMULA)
4722 {
4723 const ScFormulaCell* pFCell1 = aCell1.getFormula();
4724 const ScFormulaCell* pFCell2 = aCell2.getFormula();
4725 ScAddress aStart1;
4726 ScAddress aStart2;
4727 if (pFCell1->GetMatrixOrigin(rDoc, aStart1) && pFCell2->GetMatrixOrigin(rDoc, aStart2))
4728 {
4729 if (aStart1 == aStart2)
4730 {
4731 const ScTokenArray* pTokenArray = pFCell1->GetCode();
4732 if (pTokenArray)
4733 ScTokenConversion::ConvertToTokenSequence(rDoc, aSequence, *pTokenArray);
4734 }
4735 }
4736 }
4737
4738 return aSequence;
4739 }
4740
4741 void SAL_CALL ScCellRangeObj::setArrayTokens( const uno::Sequence<sheet::FormulaToken>& rTokens )
4742 {
4743 SolarMutexGuard aGuard;
4744 ScDocShell* pDocSh = GetDocShell();
4745 if ( !pDocSh )
4746 return;
4747
4748 if ( rTokens.hasElements() )
4749 {
4750 if ( dynamic_cast<ScTableSheetObj*>( this ) )
4751 {
4752 throw uno::RuntimeException();
4753 }
4754
4755 ScDocument& rDoc = pDocSh->GetDocument();
4756 ScTokenArray aTokenArray(rDoc);
4757 (void)ScTokenConversion::ConvertToTokenArray( rDoc, aTokenArray, rTokens );
4758
4759 // Actually GRAM_API is a don't-care here because of the token
4760 // array being set, it fits with other API compatibility grammars
4761 // though.
4762 pDocSh->GetDocFunc().EnterMatrix( aRange, nullptr, &aTokenArray, OUString(), true, true, OUString(), formula::FormulaGrammar::GRAM_API );
4763 }
4764 else
4765 {
4766 // empty sequence -> erase array formula
4767 ScMarkData aMark(pDocSh->GetDocument().GetSheetLimits());
4768 aMark.SetMarkArea( aRange );
4769 aMark.SelectTable( aRange.aStart.Tab(), true );
4770 pDocSh->GetDocFunc().DeleteContents( aMark, InsertDeleteFlags::CONTENTS, true, true );
4771 }
4772 }
4773
4774 // XCellRangeData
4775
4776 uno::Sequence< uno::Sequence<uno::Any> > SAL_CALL ScCellRangeObj::getDataArray()
4777 {
4778 SolarMutexGuard aGuard;
4779
4780 if ( dynamic_cast<ScTableSheetObj*>( this ) )
4781 {
4782 // don't create a data array for the sheet
4783 throw uno::RuntimeException();
4784 }
4785
4786 ScDocShell* pDocSh = GetDocShell();
4787 if (pDocSh)
4788 {
4789 uno::Any aAny;
4790 // bAllowNV = TRUE: errors as void
4791 if ( ScRangeToSequence::FillMixedArray( aAny, pDocSh->GetDocument(), aRange, true ) )
4792 {
4793 uno::Sequence< uno::Sequence<uno::Any> > aSeq;
4794 if ( aAny >>= aSeq )
4795 return aSeq; // success
4796 }
4797 }
4798
4799 throw uno::RuntimeException(); // no other exceptions specified
4800 }
4801
4802 void SAL_CALL ScCellRangeObj::setDataArray(
4803 const uno::Sequence< uno::Sequence<uno::Any> >& aArray )
4804 {
4805 SolarMutexGuard aGuard;
4806
4807 bool bDone = false;
4808 ScDocShell* pDocSh = GetDocShell();
4809 if (pDocSh)
4810 {
4811 //! move lcl_PutDataArray to docfunc?
4812 bDone = lcl_PutDataArray( *pDocSh, aRange, aArray );
4813 }
4814
4815 if (!bDone)
4816 throw uno::RuntimeException(); // no other exceptions specified
4817 }
4818
4819 // XCellRangeFormula
4820
4821 uno::Sequence< uno::Sequence<OUString> > SAL_CALL ScCellRangeObj::getFormulaArray()
4822 {
4823 SolarMutexGuard aGuard;
4824
4825 if ( dynamic_cast<ScTableSheetObj*>( this ) )
4826 {
4827 // don't create a data array for the sheet
4828 throw uno::RuntimeException();
4829 }
4830
4831 ScDocShell* pDocSh = GetDocShell();
4832 if (pDocSh)
4833 {
4834 SCCOL nStartCol = aRange.aStart.Col();
4835 SCROW nStartRow = aRange.aStart.Row();
4836 SCCOL nEndCol = aRange.aEnd.Col();
4837 SCROW nEndRow = aRange.aEnd.Row();
4838 SCCOL nColCount = nEndCol + 1 - nStartCol;
4839 SCROW nRowCount = nEndRow + 1 - nStartRow;
4840 SCTAB nTab = aRange.aStart.Tab();
4841
4842 uno::Sequence< uno::Sequence<OUString> > aRowSeq( nRowCount );
4843 uno::Sequence<OUString>* pRowAry = aRowSeq.getArray();
4844 for (SCROW nRowIndex = 0; nRowIndex < nRowCount; nRowIndex++)
4845 {
4846 uno::Sequence<OUString> aColSeq( nColCount );
4847 OUString* pColAry = aColSeq.getArray();
4848 for (SCCOL nColIndex = 0; nColIndex < nColCount; nColIndex++)
4849 pColAry[nColIndex] = lcl_GetInputString( pDocSh->GetDocument(),
4850 ScAddress( nStartCol+nColIndex, nStartRow+nRowIndex, nTab ), true );
4851
4852 pRowAry[nRowIndex] = std::move(aColSeq);
4853 }
4854
4855 return aRowSeq;
4856 }
4857
4858 throw uno::RuntimeException(); // no other exceptions specified
4859 }
4860
4861 void SAL_CALL ScCellRangeObj::setFormulaArray(
4862 const uno::Sequence< uno::Sequence<OUString> >& aArray )
4863 {
4864 SolarMutexGuard aGuard;
4865
4866 bool bDone = false;
4867 ScDocShell* pDocSh = GetDocShell();
4868 if (pDocSh)
4869 {
4870 ScExternalRefManager::ApiGuard aExtRefGuard(pDocSh->GetDocument());
4871
4872 // GRAM_API for API compatibility.
4873 bDone = lcl_PutFormulaArray( *pDocSh, aRange, aArray, formula::FormulaGrammar::GRAM_API );
4874 }
4875
4876 if (!bDone)
4877 throw uno::RuntimeException(); // no other exceptions specified
4878 }
4879
4880 // XMultipleOperation
4881
4882 void SAL_CALL ScCellRangeObj::setTableOperation( const table::CellRangeAddress& aFormulaRange,
4883 sheet::TableOperationMode nMode,
4884 const table::CellAddress& aColumnCell,
4885 const table::CellAddress& aRowCell )
4886 {
4887 SolarMutexGuard aGuard;
4888 ScDocShell* pDocSh = GetDocShell();
4889 if (!pDocSh)
4890 return;
4891
4892 bool bError = false;
4893 ScTabOpParam aParam;
4894 aParam.aRefFormulaCell = ScRefAddress( static_cast<SCCOL>(aFormulaRange.StartColumn),
4895 static_cast<SCROW>(aFormulaRange.StartRow), aFormulaRange.Sheet );
4896 aParam.aRefFormulaEnd = ScRefAddress( static_cast<SCCOL>(aFormulaRange.EndColumn),
4897 static_cast<SCROW>(aFormulaRange.EndRow), aFormulaRange.Sheet );
4898 aParam.aRefRowCell = ScRefAddress( static_cast<SCCOL>(aRowCell.Column),
4899 static_cast<SCROW>(aRowCell.Row), aRowCell.Sheet );
4900 aParam.aRefColCell = ScRefAddress( static_cast<SCCOL>(aColumnCell.Column),
4901 static_cast<SCROW>(aColumnCell.Row), aColumnCell.Sheet );
4902
4903 switch (nMode)
4904 {
4905 case sheet::TableOperationMode_COLUMN:
4906 aParam.meMode = ScTabOpParam::Column;
4907 break;
4908 case sheet::TableOperationMode_ROW:
4909 aParam.meMode = ScTabOpParam::Row;
4910 break;
4911 case sheet::TableOperationMode_BOTH:
4912 aParam.meMode = ScTabOpParam::Both;
4913 break;
4914 default:
4915 bError = true;
4916 }
4917
4918 if (!bError)
4919 pDocSh->GetDocFunc().TabOp( aRange, nullptr, aParam, true, true );
4920 }
4921
4922 // XMergeable
4923
4924 void SAL_CALL ScCellRangeObj::merge( sal_Bool bMerge )
4925 {
4926 SolarMutexGuard aGuard;
4927 ScDocShell* pDocSh = GetDocShell();
4928 if ( !pDocSh )
4929 return;
4930
4931 ScCellMergeOption aMergeOption(
4932 aRange.aStart.Col(), aRange.aStart.Row(),
4933 aRange.aEnd.Col(), aRange.aEnd.Row(), false);
4934 aMergeOption.maTabs.insert(aRange.aStart.Tab());
4935 if ( bMerge )
4936 pDocSh->GetDocFunc().MergeCells( aMergeOption, false, true, true );
4937 else
4938 pDocSh->GetDocFunc().UnmergeCells( aMergeOption, true, nullptr );
4939
4940 //! Catch error?
4941 }
4942
4943 sal_Bool SAL_CALL ScCellRangeObj::getIsMerged()
4944 {
4945 SolarMutexGuard aGuard;
4946 ScDocShell* pDocSh = GetDocShell();
4947 return pDocSh && pDocSh->GetDocument().HasAttrib( aRange, HasAttrFlags::Merged );
4948 }
4949
4950 // XCellSeries
4951
4952 void SAL_CALL ScCellRangeObj::fillSeries( sheet::FillDirection nFillDirection,
4953 sheet::FillMode nFillMode, sheet::FillDateMode nFillDateMode,
4954 double fStep, double fEndValue )
4955 {
4956 SolarMutexGuard aGuard;
4957 ScDocShell* pDocSh = GetDocShell();
4958 if ( !pDocSh )
4959 return;
4960
4961 bool bError = false;
4962
4963 FillDir eDir = FILL_TO_BOTTOM;
4964 switch (nFillDirection)
4965 {
4966 case sheet::FillDirection_TO_BOTTOM:
4967 eDir = FILL_TO_BOTTOM;
4968 break;
4969 case sheet::FillDirection_TO_RIGHT:
4970 eDir = FILL_TO_RIGHT;
4971 break;
4972 case sheet::FillDirection_TO_TOP:
4973 eDir = FILL_TO_TOP;
4974 break;
4975 case sheet::FillDirection_TO_LEFT:
4976 eDir = FILL_TO_LEFT;
4977 break;
4978 default:
4979 bError = true;
4980 }
4981
4982 FillCmd eCmd = FILL_SIMPLE;
4983 switch ( nFillMode )
4984 {
4985 case sheet::FillMode_SIMPLE:
4986 eCmd = FILL_SIMPLE;
4987 break;
4988 case sheet::FillMode_LINEAR:
4989 eCmd = FILL_LINEAR;
4990 break;
4991 case sheet::FillMode_GROWTH:
4992 eCmd = FILL_GROWTH;
4993 break;
4994 case sheet::FillMode_DATE:
4995 eCmd = FILL_DATE;
4996 break;
4997 case sheet::FillMode_AUTO:
4998 eCmd = FILL_AUTO;
4999 break;
5000 default:
5001 bError = true;
5002 }
5003
5004 FillDateCmd eDateCmd = FILL_DAY;
5005 switch ( nFillDateMode )
5006 {
5007 case sheet::FillDateMode_FILL_DATE_DAY:
5008 eDateCmd = FILL_DAY;
5009 break;
5010 case sheet::FillDateMode_FILL_DATE_WEEKDAY:
5011 eDateCmd = FILL_WEEKDAY;
5012 break;
5013 case sheet::FillDateMode_FILL_DATE_MONTH:
5014 eDateCmd = FILL_MONTH;
5015 break;
5016 case sheet::FillDateMode_FILL_DATE_YEAR:
5017 eDateCmd = FILL_YEAR;
5018 break;
5019 default:
5020 bError = true;
5021 }
5022
5023 if (!bError)
5024 pDocSh->GetDocFunc().FillSeries( aRange, nullptr, eDir, eCmd, eDateCmd,
5025 MAXDOUBLE, fStep, fEndValue, true );
5026 }
5027
5028 void SAL_CALL ScCellRangeObj::fillAuto( sheet::FillDirection nFillDirection,
5029 sal_Int32 nSourceCount )
5030 {
5031 SolarMutexGuard aGuard;
5032 ScDocShell* pDocSh = GetDocShell();
5033 if ( !(pDocSh && nSourceCount) )
5034 return;
5035
5036 ScRange aSourceRange(aRange);
5037 SCCOLROW nCount = 0; // "Dest-Count"
5038 FillDir eDir = FILL_TO_BOTTOM;
5039 bool bError = false;
5040 switch (nFillDirection)
5041 {
5042 case sheet::FillDirection_TO_BOTTOM:
5043 aSourceRange.aEnd.SetRow( static_cast<SCROW>( aSourceRange.aStart.Row() + nSourceCount - 1 ) );
5044 nCount = aRange.aEnd.Row() - aSourceRange.aEnd.Row();
5045 eDir = FILL_TO_BOTTOM;
5046 break;
5047 case sheet::FillDirection_TO_RIGHT:
5048 aSourceRange.aEnd.SetCol( static_cast<SCCOL>( aSourceRange.aStart.Col() + nSourceCount - 1 ) );
5049 nCount = aRange.aEnd.Col() - aSourceRange.aEnd.Col();
5050 eDir = FILL_TO_RIGHT;
5051 break;
5052 case sheet::FillDirection_TO_TOP:
5053 aSourceRange.aStart.SetRow( static_cast<SCROW>( aSourceRange.aEnd.Row() - nSourceCount + 1 ) );
5054 nCount = aSourceRange.aStart.Row() - aRange.aStart.Row();
5055 eDir = FILL_TO_TOP;
5056 break;
5057 case sheet::FillDirection_TO_LEFT:
5058 aSourceRange.aStart.SetCol( static_cast<SCCOL>( aSourceRange.aEnd.Col() - nSourceCount + 1 ) );
5059 nCount = aSourceRange.aStart.Col() - aRange.aStart.Col();
5060 eDir = FILL_TO_LEFT;
5061 break;
5062 default:
5063 bError = true;
5064 }
5065 const ScDocument& rDoc = pDocSh->GetDocument();
5066 if (nCount < 0 || nCount > rDoc.MaxRow()) // overflow
5067 bError = true;
5068
5069 if (!bError)
5070 pDocSh->GetDocFunc().FillAuto( aSourceRange, nullptr, eDir, nCount, true );
5071 }
5072
5073 // XAutoFormattable
5074
5075 void SAL_CALL ScCellRangeObj::autoFormat( const OUString& aName )
5076 {
5077 SolarMutexGuard aGuard;
5078 ScDocShell* pDocSh = GetDocShell();
5079 if ( pDocSh )
5080 {
5081 ScAutoFormat* pAutoFormat = ScGlobal::GetOrCreateAutoFormat();
5082 ScAutoFormat::const_iterator it = pAutoFormat->find(aName);
5083 if (it == pAutoFormat->end())
5084 throw lang::IllegalArgumentException();
5085
5086 ScAutoFormat::const_iterator itBeg = pAutoFormat->begin();
5087 size_t nIndex = std::distance(itBeg, it);
5088 pDocSh->GetDocFunc().AutoFormat(aRange, nullptr, nIndex, true);
5089
5090 }
5091 }
5092
5093 // XSortable
5094
5095 uno::Sequence<beans::PropertyValue> SAL_CALL ScCellRangeObj::createSortDescriptor()
5096 {
5097 SolarMutexGuard aGuard;
5098 ScSortParam aParam;
5099 ScDocShell* pDocSh = GetDocShell();
5100 if ( pDocSh )
5101 {
5102 // create DB-Area only during execution; API always the exact area
5103 ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, ScGetDBSelection::ForceMark );
5104 if (pData)
5105 {
5106 pData->GetSortParam(aParam);
5107
5108 // SortDescriptor contains the counted fields inside the area
5109 ScRange aDBRange;
5110 pData->GetArea(aDBRange);
5111 SCCOLROW nFieldStart = aParam.bByRow ?
5112 static_cast<SCCOLROW>(aDBRange.aStart.Col()) :
5113 static_cast<SCCOLROW>(aDBRange.aStart.Row());
5114 for (sal_uInt16 i=0; i<aParam.GetSortKeyCount(); i++)
5115 if ( aParam.maKeyState[i].bDoSort && aParam.maKeyState[i].nField >= nFieldStart )
5116 aParam.maKeyState[i].nField -= nFieldStart;
5117 }
5118 }
5119
5120 uno::Sequence<beans::PropertyValue> aSeq( ScSortDescriptor::GetPropertyCount() );
5121 ScSortDescriptor::FillProperties( aSeq, aParam );
5122 return aSeq;
5123 }
5124
5125 void SAL_CALL ScCellRangeObj::sort( const uno::Sequence<beans::PropertyValue>& aDescriptor )
5126 {
5127 SolarMutexGuard aGuard;
5128 ScDocShell* pDocSh = GetDocShell();
5129 if (!pDocSh)
5130 return;
5131
5132 sal_uInt16 i;
5133 ScSortParam aParam;
5134 ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_MAKE, ScGetDBSelection::ForceMark ); // if needed create area
5135 if (pData)
5136 {
5137 // get old settings if not everything is set anew
5138 pData->GetSortParam(aParam);
5139 SCCOLROW nOldStart = aParam.bByRow ?
5140 static_cast<SCCOLROW>(aRange.aStart.Col()) :
5141 static_cast<SCCOLROW>(aRange.aStart.Row());
5142 for (i=0; i<aParam.GetSortKeyCount(); i++)
5143 if ( aParam.maKeyState[i].bDoSort && aParam.maKeyState[i].nField >= nOldStart )
5144 aParam.maKeyState[i].nField -= nOldStart;
5145 }
5146
5147 ScSortDescriptor::FillSortParam( aParam, aDescriptor );
5148
5149 // SortDescriptor contains the counted fields inside the area
5150 // ByRow can be changed during execution of FillSortParam
5151 SCCOLROW nFieldStart = aParam.bByRow ?
5152 static_cast<SCCOLROW>(aRange.aStart.Col()) :
5153 static_cast<SCCOLROW>(aRange.aStart.Row());
5154 SCCOLROW nFieldEnd = aParam.bByRow ?
5155 static_cast<SCCOLROW>(aRange.aEnd.Col()) :
5156 static_cast<SCCOLROW>(aRange.aEnd.Row());
5157 for (i=0; i<aParam.GetSortKeyCount(); i++)
5158 {
5159 aParam.maKeyState[i].nField += nFieldStart;
5160 // tdf#103632 - sanity check poorly behaved macros.
5161 if (aParam.maKeyState[i].nField > nFieldEnd)
5162 aParam.maKeyState[i].nField = nFieldEnd;
5163 }
5164
5165 SCTAB nTab = aRange.aStart.Tab();
5166 aParam.nCol1 = aRange.aStart.Col();
5167 aParam.nRow1 = aRange.aStart.Row();
5168 aParam.nCol2 = aRange.aEnd.Col();
5169 aParam.nRow2 = aRange.aEnd.Row();
5170
5171 pDocSh->GetDBData( aRange, SC_DB_MAKE, ScGetDBSelection::ForceMark ); // if needed create area
5172
5173 ScDBDocFunc aFunc(*pDocSh); // area must be created
5174 (void)aFunc.Sort( nTab, aParam, true, true, true );
5175 }
5176
5177 // XFilterable
5178
5179 uno::Reference<sheet::XSheetFilterDescriptor> SAL_CALL ScCellRangeObj::createFilterDescriptor(
5180 sal_Bool bEmpty )
5181 {
5182 SolarMutexGuard aGuard;
5183 ScDocShell* pDocSh = GetDocShell();
5184 rtl::Reference<ScFilterDescriptor> pNew = new ScFilterDescriptor(pDocSh);
5185 if ( !bEmpty && pDocSh )
5186 {
5187 // create DB-Area only during execution; API always the exact area
5188 ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, ScGetDBSelection::ForceMark );
5189 if (pData)
5190 {
5191 ScQueryParam aParam;
5192 pData->GetQueryParam(aParam);
5193 // FilterDescriptor contains the counted fields inside the area
5194 ScRange aDBRange;
5195 pData->GetArea(aDBRange);
5196 SCCOLROW nFieldStart = aParam.bByRow ?
5197 static_cast<SCCOLROW>(aDBRange.aStart.Col()) :
5198 static_cast<SCCOLROW>(aDBRange.aStart.Row());
5199 SCSIZE nCount = aParam.GetEntryCount();
5200 for (SCSIZE i=0; i<nCount; i++)
5201 {
5202 ScQueryEntry& rEntry = aParam.GetEntry(i);
5203 if (rEntry.bDoQuery && rEntry.nField >= nFieldStart)
5204 rEntry.nField -= nFieldStart;
5205 }
5206 pNew->SetParam(aParam);
5207 }
5208 }
5209 return pNew;
5210 }
5211
5212 void SAL_CALL ScCellRangeObj::filter( const uno::Reference<sheet::XSheetFilterDescriptor>& xDescriptor )
5213 {
5214 SolarMutexGuard aGuard;
5215
5216 if (!xDescriptor.is()) return;
5217
5218 // This could be theoretically an unknown object, so only use the
5219 // public XSheetFilterDescriptor interface to copy the data into a
5220 // ScFilterDescriptor object:
5221 //! if it already a ScFilterDescriptor is, direct via getImplementation?
5222
5223 ScDocShell* pDocSh = GetDocShell();
5224 rtl::Reference<ScFilterDescriptor> xImpl(new ScFilterDescriptor(pDocSh));
5225 uno::Reference< sheet::XSheetFilterDescriptor2 > xDescriptor2( xDescriptor, uno::UNO_QUERY );
5226 if ( xDescriptor2.is() )
5227 {
5228 xImpl->setFilterFields2( xDescriptor2->getFilterFields2() );
5229 }
5230 else
5231 {
5232 xImpl->setFilterFields( xDescriptor->getFilterFields() );
5233 }
5234 // the rest are now properties...
5235
5236 uno::Reference<beans::XPropertySet> xPropSet( xDescriptor, uno::UNO_QUERY );
5237 if (xPropSet.is())
5238 lcl_CopyProperties(*xImpl, *xPropSet);
5239
5240 if (!pDocSh)
5241 return;
5242
5243 ScQueryParam aParam = xImpl->GetParam();
5244 // FilterDescriptor contains the counted fields inside the area
5245 SCCOLROW nFieldStart = aParam.bByRow ?
5246 static_cast<SCCOLROW>(aRange.aStart.Col()) :
5247 static_cast<SCCOLROW>(aRange.aStart.Row());
5248 SCSIZE nCount = aParam.GetEntryCount();
5249 svl::SharedStringPool& rPool = pDocSh->GetDocument().GetSharedStringPool();
5250 for (SCSIZE i=0; i<nCount; i++)
5251 {
5252 ScQueryEntry& rEntry = aParam.GetEntry(i);
5253 if (rEntry.bDoQuery)
5254 {
5255 rEntry.nField += nFieldStart;
5256 // dialog always shows the string -> must match the value
5257 ScQueryEntry::QueryItemsType& rItems = rEntry.GetQueryItems();
5258 rItems.resize(1);
5259 ScQueryEntry::Item& rItem = rItems.front();
5260 if (rItem.meType != ScQueryEntry::ByString)
5261 {
5262 OUString aStr = pDocSh->GetDocument().GetFormatTable()->GetInputLineString(rItem.mfVal, 0);
5263 rItem.maString = rPool.intern(aStr);
5264 }
5265 }
5266 }
5267
5268 SCTAB nTab = aRange.aStart.Tab();
5269 aParam.nCol1 = aRange.aStart.Col();
5270 aParam.nRow1 = aRange.aStart.Row();
5271 aParam.nCol2 = aRange.aEnd.Col();
5272 aParam.nRow2 = aRange.aEnd.Row();
5273
5274 pDocSh->GetDBData( aRange, SC_DB_MAKE, ScGetDBSelection::ForceMark ); // if needed create area
5275
5276 //! keep source range in filter descriptor
5277 //! if created by createFilterDescriptorByObject ???
5278
5279 ScDBDocFunc aFunc(*pDocSh);
5280 aFunc.Query( nTab, aParam, nullptr, true, true ); // area must be created
5281 }
5282
5283 //! get/setAutoFilter as properties!!!
5284
5285 // XAdvancedFilterSource
5286
5287 uno::Reference<sheet::XSheetFilterDescriptor> SAL_CALL ScCellRangeObj::createFilterDescriptorByObject(
5288 const uno::Reference<sheet::XSheetFilterable>& xObject )
5289 {
5290 SolarMutexGuard aGuard;
5291
5292 // this here is not the area, which will be filtered, instead the area
5293 // with the query
5294
5295 uno::Reference<sheet::XCellRangeAddressable> xAddr( xObject, uno::UNO_QUERY );
5296
5297 ScDocShell* pDocSh = GetDocShell();
5298 if ( !pDocSh || !xAddr.is() )
5299 {
5300 OSL_FAIL("no document or no area");
5301 return nullptr;
5302 }
5303
5304 //! check if xObject is in the same document
5305
5306 rtl::Reference<ScFilterDescriptor> pNew(new ScFilterDescriptor(pDocSh)); //! instead from object?
5307
5308 ScQueryParam aParam = pNew->GetParam();
5309 aParam.bHasHeader = true;
5310
5311 table::CellRangeAddress aDataAddress(xAddr->getRangeAddress());
5312 aParam.nCol1 = static_cast<SCCOL>(aDataAddress.StartColumn);
5313 aParam.nRow1 = static_cast<SCROW>(aDataAddress.StartRow);
5314 aParam.nCol2 = static_cast<SCCOL>(aDataAddress.EndColumn);
5315 aParam.nRow2 = static_cast<SCROW>(aDataAddress.EndRow);
5316 aParam.nTab = aDataAddress.Sheet;
5317
5318 ScDocument& rDoc = pDocSh->GetDocument();
5319 if (!rDoc.CreateQueryParam(aRange, aParam))
5320 return nullptr;
5321
5322 // FilterDescriptor contains the counted fields inside the area
5323 SCCOLROW nFieldStart = aParam.bByRow ?
5324 static_cast<SCCOLROW>(aDataAddress.StartColumn) :
5325 static_cast<SCCOLROW>(aDataAddress.StartRow);
5326 SCSIZE nCount = aParam.GetEntryCount();
5327 for (SCSIZE i=0; i<nCount; i++)
5328 {
5329 ScQueryEntry& rEntry = aParam.GetEntry(i);
5330 if (rEntry.bDoQuery && rEntry.nField >= nFieldStart)
5331 rEntry.nField -= nFieldStart;
5332 }
5333
5334 pNew->SetParam( aParam );
5335 return pNew;
5336 }
5337
5338 // XSubTotalSource
5339
5340 uno::Reference<sheet::XSubTotalDescriptor> SAL_CALL ScCellRangeObj::createSubTotalDescriptor(
5341 sal_Bool bEmpty )
5342 {
5343 SolarMutexGuard aGuard;
5344 rtl::Reference<ScSubTotalDescriptor> pNew = new ScSubTotalDescriptor;
5345 ScDocShell* pDocSh = GetDocShell();
5346 if ( !bEmpty && pDocSh )
5347 {
5348 // create DB-Area only during execution; API always the exact area
5349 ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, ScGetDBSelection::ForceMark );
5350 if (pData)
5351 {
5352 ScSubTotalParam aParam;
5353 pData->GetSubTotalParam(aParam);
5354 // SubTotalDescriptor contains the counted fields inside the area
5355 ScRange aDBRange;
5356 pData->GetArea(aDBRange);
5357 SCCOL nFieldStart = aDBRange.aStart.Col();
5358 for (auto& group : aParam.aGroups)
5359 {
5360 if (group.bActive)
5361 {
5362 if (group.nField >= nFieldStart)
5363 group.nField -= nFieldStart;
5364 for (SCCOL j = 0; j < group.nSubTotals; j++)
5365 if (group.col(j) >= nFieldStart)
5366 group.col(j) -= nFieldStart;
5367 }
5368 }
5369 pNew->SetParam(aParam);
5370 }
5371 }
5372 return pNew;
5373 }
5374
5375 void SAL_CALL ScCellRangeObj::applySubTotals(
5376 const uno::Reference<sheet::XSubTotalDescriptor>& xDescriptor,
5377 sal_Bool bReplace)
5378 {
5379 SolarMutexGuard aGuard;
5380
5381 if (!xDescriptor.is()) return;
5382
5383 ScDocShell* pDocSh = GetDocShell();
5384 ScSubTotalDescriptorBase* pImp =
5385 dynamic_cast<ScSubTotalDescriptorBase*>( xDescriptor.get() );
5386
5387 if (!(pDocSh && pImp))
5388 return;
5389
5390 ScSubTotalParam aParam;
5391 pImp->GetData(aParam); // virtual method of base class
5392
5393 // SubTotalDescriptor contains the counted fields inside the area
5394 SCCOL nFieldStart = aRange.aStart.Col();
5395 for (auto& group : aParam.aGroups)
5396 {
5397 if (group.bActive)
5398 {
5399 group.nField += nFieldStart;
5400 for (SCCOL j = 0; j < group.nSubTotals; j++)
5401 group.col(j) += nFieldStart;
5402 }
5403 }
5404
5405 aParam.bReplace = bReplace;
5406
5407 SCTAB nTab = aRange.aStart.Tab();
5408 aParam.nCol1 = aRange.aStart.Col();
5409 aParam.nRow1 = aRange.aStart.Row();
5410 aParam.nCol2 = aRange.aEnd.Col();
5411 aParam.nRow2 = aRange.aEnd.Row();
5412
5413 pDocSh->GetDBData( aRange, SC_DB_MAKE, ScGetDBSelection::ForceMark ); // if needed create area
5414
5415 ScDBDocFunc aFunc(*pDocSh);
5416 aFunc.DoSubTotals( nTab, aParam, true, true ); // area must be created
5417 }
5418
5419 void SAL_CALL ScCellRangeObj::removeSubTotals()
5420 {
5421 SolarMutexGuard aGuard;
5422
5423 ScDocShell* pDocSh = GetDocShell();
5424 if (!pDocSh)
5425 return;
5426
5427 ScSubTotalParam aParam;
5428 ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, ScGetDBSelection::ForceMark );
5429 if (pData)
5430 pData->GetSubTotalParam(aParam); // also keep field entries during remove
5431
5432 aParam.bRemoveOnly = true;
5433
5434 SCTAB nTab = aRange.aStart.Tab();
5435 aParam.nCol1 = aRange.aStart.Col();
5436 aParam.nRow1 = aRange.aStart.Row();
5437 aParam.nCol2 = aRange.aEnd.Col();
5438 aParam.nRow2 = aRange.aEnd.Row();
5439
5440 pDocSh->GetDBData( aRange, SC_DB_MAKE, ScGetDBSelection::ForceMark ); // if needed create area
5441
5442 ScDBDocFunc aFunc(*pDocSh);
5443 aFunc.DoSubTotals( nTab, aParam, true, true ); // are must be created
5444 }
5445
5446 uno::Sequence<beans::PropertyValue> SAL_CALL ScCellRangeObj::createImportDescriptor( sal_Bool bEmpty )
5447 {
5448 SolarMutexGuard aGuard;
5449 ScImportParam aParam;
5450 ScDocShell* pDocSh = GetDocShell();
5451 if ( !bEmpty && pDocSh )
5452 {
5453 // create DB-Area only during execution; API always the exact area
5454 ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, ScGetDBSelection::ForceMark );
5455 if (pData)
5456 pData->GetImportParam(aParam);
5457 }
5458
5459 uno::Sequence<beans::PropertyValue> aSeq( ScImportDescriptor::GetPropertyCount() );
5460 ScImportDescriptor::FillProperties( aSeq, aParam );
5461 return aSeq;
5462 }
5463
5464 void SAL_CALL ScCellRangeObj::doImport( const uno::Sequence<beans::PropertyValue>& aDescriptor )
5465 {
5466 SolarMutexGuard aGuard;
5467 ScDocShell* pDocSh = GetDocShell();
5468 if (!pDocSh)
5469 return;
5470
5471 ScImportParam aParam;
5472 ScImportDescriptor::FillImportParam( aParam, aDescriptor );
5473
5474 SCTAB nTab = aRange.aStart.Tab();
5475 aParam.nCol1 = aRange.aStart.Col();
5476 aParam.nRow1 = aRange.aStart.Row();
5477 aParam.nCol2 = aRange.aEnd.Col();
5478 aParam.nRow2 = aRange.aEnd.Row();
5479
5480 //! TODO: could we get passed a valid result set by any means?
5481
5482 pDocSh->GetDBData( aRange, SC_DB_MAKE, ScGetDBSelection::ForceMark ); // if needed create area
5483
5484 ScDBDocFunc aFunc(*pDocSh); // are must be created
5485 aFunc.DoImport( nTab, aParam, nullptr ); //! Api-Flag as parameter
5486 }
5487
5488 // XCellFormatRangesSupplier
5489
5490 uno::Reference<container::XIndexAccess> SAL_CALL ScCellRangeObj::getCellFormatRanges()
5491 {
5492 SolarMutexGuard aGuard;
5493 ScDocShell* pDocSh = GetDocShell();
5494 if ( pDocSh )
5495 return new ScCellFormatsObj( pDocSh, aRange );
5496 return nullptr;
5497 }
5498
5499 // XUniqueCellFormatRangesSupplier
5500
5501 uno::Reference<container::XIndexAccess> SAL_CALL ScCellRangeObj::getUniqueCellFormatRanges()
5502 {
5503 SolarMutexGuard aGuard;
5504 ScDocShell* pDocSh = GetDocShell();
5505 if ( pDocSh )
5506 return new ScUniqueCellFormatsObj( pDocSh, aRange );
5507 return nullptr;
5508 }
5509
5510 // XPropertySet extended for Range-Properties
5511
5512 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCellRangeObj::getPropertySetInfo()
5513 {
5514 SolarMutexGuard aGuard;
5515 static uno::Reference<beans::XPropertySetInfo> aRef(
5516 new SfxItemPropertySetInfo( pRangePropSet->getPropertyMap() ));
5517 return aRef;
5518 }
5519
5520 void ScCellRangeObj::SetOnePropertyValue( const SfxItemPropertyMapEntry* pEntry, const uno::Any& aValue )
5521 {
5522 // Range has only Position and Size in addition to ScCellRangesBase, both are ReadOnly
5523 // -> nothing to do here
5524
5525 ScCellRangesBase::SetOnePropertyValue( pEntry, aValue );
5526 }
5527
5528 void ScCellRangeObj::GetOnePropertyValue( const SfxItemPropertyMapEntry* pEntry, uno::Any& rAny )
5529 {
5530 if ( !pEntry )
5531 return;
5532
5533 if ( pEntry->nWID == SC_WID_UNO_POS )
5534 {
5535 ScDocShell* pDocSh = GetDocShell();
5536 if (pDocSh)
5537 {
5538 // GetMMRect converts using HMM_PER_TWIPS, like the DrawingLayer
5539 tools::Rectangle aMMRect(pDocSh->GetDocument().GetMMRect(
5540 aRange.aStart.Col(), aRange.aStart.Row(),
5541 aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aStart.Tab() ));
5542 awt::Point aPos( aMMRect.Left(), aMMRect.Top() );
5543 rAny <<= aPos;
5544 }
5545 }
5546 else if ( pEntry->nWID == SC_WID_UNO_SIZE )
5547 {
5548 ScDocShell* pDocSh = GetDocShell();
5549 if (pDocSh)
5550 {
5551 // GetMMRect converts using HMM_PER_TWIPS, like the DrawingLayer
5552 tools::Rectangle aMMRect = pDocSh->GetDocument().GetMMRect(
5553 aRange.aStart.Col(), aRange.aStart.Row(),
5554 aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aStart.Tab() );
5555 Size aSize(aMMRect.GetSize());
5556 awt::Size aAwtSize( aSize.Width(), aSize.Height() );
5557 rAny <<= aAwtSize;
5558 }
5559 }
5560 else
5561 ScCellRangesBase::GetOnePropertyValue( pEntry, rAny );
5562 }
5563
5564 const SfxItemPropertyMap& ScCellRangeObj::GetItemPropertyMap()
5565 {
5566 return pRangePropSet->getPropertyMap();
5567 }
5568
5569 // XServiceInfo
5570
5571 OUString SAL_CALL ScCellRangeObj::getImplementationName()
5572 {
5573 return u"ScCellRangeObj"_ustr;
5574 }
5575
5576 sal_Bool SAL_CALL ScCellRangeObj::supportsService( const OUString& rServiceName )
5577 {
5578 return cppu::supportsService(this, rServiceName);
5579 }
5580
5581 uno::Sequence<OUString> SAL_CALL ScCellRangeObj::getSupportedServiceNames()
5582 {
5583 return {SCSHEETCELLRANGE_SERVICE,
5584 SCCELLRANGE_SERVICE,
5585 SCCELLPROPERTIES_SERVICE,
5586 SCCHARPROPERTIES_SERVICE,
5587 SCPARAPROPERTIES_SERVICE};
5588 }
5589
5590 const SvxItemPropertySet* ScCellObj::GetEditPropertySet()
5591 {
5592 return lcl_GetEditPropertySet();
5593 }
5594
5595 const SfxItemPropertyMap& ScCellObj::GetCellPropertyMap()
5596 {
5597 return lcl_GetCellPropertySet()->getPropertyMap();
5598 }
5599
5600 ScCellObj::ScCellObj(ScDocShell* pDocSh, const ScAddress& rP) :
5601 ScCellObj_BASE( pDocSh, ScRange(rP,rP) ),
5602 pCellPropSet( lcl_GetCellPropertySet() ),
5603 aCellPos( rP ),
5604 nActionLockCount( 0 )
5605 {
5606 // pUnoText is allocated on demand (GetUnoText)
5607 // can't be aggregated because getString/setString is handled here
5608 }
5609
5610 SvxUnoText& ScCellObj::GetUnoText()
5611 {
5612 if (!mxUnoText.is())
5613 {
5614 mxUnoText.set(new ScCellTextObj(GetDocShell(), aCellPos));
5615 if (nActionLockCount)
5616 {
5617 ScCellEditSource* pEditSource =
5618 static_cast<ScCellEditSource*> (mxUnoText->GetEditSource());
5619 if (pEditSource)
5620 pEditSource->SetDoUpdateData(false);
5621 }
5622 }
5623 return *mxUnoText;
5624 }
5625
5626 ScCellObj::~ScCellObj()
5627 {
5628 }
5629
5630 void ScCellObj::RefChanged()
5631 {
5632 ScCellRangeObj::RefChanged();
5633
5634 const ScRangeList& rRanges = GetRangeList();
5635 OSL_ENSURE(rRanges.size() == 1, "What ranges ?!?!");
5636 if ( !rRanges.empty() )
5637 {
5638 aCellPos = rRanges[ 0 ].aStart;
5639 }
5640 }
5641
5642 // helper methods
5643
5644 OUString ScCellObj::GetInputString_Impl(bool bEnglish) const // for getFormula / FormulaLocal
5645 {
5646 if (GetDocShell())
5647 return lcl_GetInputString( GetDocShell()->GetDocument(), aCellPos, bEnglish );
5648 return OUString();
5649 }
5650
5651 OUString ScCellObj::GetOutputString_Impl() const
5652 {
5653 ScDocShell* pDocSh = GetDocShell();
5654 OUString aVal;
5655 if ( pDocSh )
5656 {
5657 ScDocument& rDoc = pDocSh->GetDocument();
5658 ScRefCellValue aCell(rDoc, aCellPos);
5659
5660 aVal = ScCellFormat::GetOutputString(rDoc, aCellPos, aCell);
5661 }
5662 return aVal;
5663 }
5664
5665 void ScCellObj::SetString_Impl(const OUString& rString, bool bInterpret, bool bEnglish)
5666 {
5667 ScDocShell* pDocSh = GetDocShell();
5668 if ( pDocSh )
5669 {
5670 // GRAM_API for API compatibility.
5671 (void)pDocSh->GetDocFunc().SetCellText(
5672 aCellPos, rString, bInterpret, bEnglish, true, formula::FormulaGrammar::GRAM_API );
5673 }
5674 }
5675
5676 double ScCellObj::GetValue_Impl() const
5677 {
5678 ScDocShell* pDocSh = GetDocShell();
5679 if ( pDocSh )
5680 return pDocSh->GetDocument().GetValue( aCellPos );
5681
5682 return 0.0;
5683 }
5684
5685 void ScCellObj::SetValue_Impl(double fValue)
5686 {
5687 ScDocShell* pDocSh = GetDocShell();
5688 if ( pDocSh )
5689 pDocSh->GetDocFunc().SetValueCell(aCellPos, fValue, false);
5690 }
5691
5692 // only for XML import
5693
5694 void ScCellObj::InputEnglishString( const OUString& rText )
5695 {
5696 // This is like a mixture of setFormula and property FormulaLocal:
5697 // The cell's number format is checked for "text", a new cell format may be set,
5698 // but all parsing is in English.
5699
5700 ScDocShell* pDocSh = GetDocShell();
5701 if (!pDocSh)
5702 return;
5703
5704 ScDocument& rDoc = pDocSh->GetDocument();
5705 ScInterpreterContext& rContext = rDoc.GetNonThreadedContext();
5706 sal_uInt32 nOldFormat = rDoc.GetNumberFormat( ScRange(aCellPos) );
5707 if (rContext.NFGetType(nOldFormat) == SvNumFormatType::TEXT)
5708 {
5709 SetString_Impl(rText, false, false); // text cell
5710 return;
5711 }
5712
5713 ScDocFunc &rFunc = pDocSh->GetDocFunc();
5714
5715 ScInputStringType aRes =
5716 ScStringUtil::parseInputString(rContext, rText, LANGUAGE_ENGLISH_US);
5717
5718 if (aRes.meType != ScInputStringType::Unknown)
5719 {
5720 if ((nOldFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0 && aRes.mnFormatType != SvNumFormatType::ALL)
5721 {
5722 // apply a format for the recognized type and the old format's language
5723 sal_uInt32 nNewFormat = ScGlobal::GetStandardFormat(rContext, nOldFormat, aRes.mnFormatType);
5724 if (nNewFormat != nOldFormat)
5725 {
5726 ScPatternAttr aPattern(rDoc.getCellAttributeHelper());
5727 aPattern.GetItemSet().Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat ) );
5728 // ATTR_LANGUAGE_FORMAT remains unchanged
5729 rFunc.ApplyAttributes( *GetMarkData(), aPattern, true );
5730 }
5731 }
5732 }
5733 switch (aRes.meType)
5734 {
5735 case ScInputStringType::Formula:
5736 rFunc.SetFormulaCell(
5737 aCellPos,
5738 new ScFormulaCell(rDoc, aCellPos, aRes.maText, formula::FormulaGrammar::GRAM_API),
5739 false);
5740 break;
5741 case ScInputStringType::Number:
5742 rFunc.SetValueCell(aCellPos, aRes.mfValue, false);
5743 break;
5744 case ScInputStringType::Text:
5745 rFunc.SetStringOrEditCell(aCellPos, aRes.maText, false);
5746 break;
5747 default:
5748 SetString_Impl(rText, false, false); // probably empty string
5749 }
5750 }
5751
5752 // XText
5753
5754 uno::Reference<text::XTextCursor> SAL_CALL ScCellObj::createTextCursor()
5755 {
5756 SolarMutexGuard aGuard;
5757 return new ScCellTextCursor( *this );
5758 }
5759
5760 uno::Reference<text::XTextCursor> SAL_CALL ScCellObj::createTextCursorByRange(
5761 const uno::Reference<text::XTextRange>& aTextPosition )
5762 {
5763 SolarMutexGuard aGuard;
5764 rtl::Reference<SvxUnoTextCursor> pCursor = new ScCellTextCursor( *this );
5765
5766 SvxUnoTextRangeBase* pRange = comphelper::getFromUnoTunnel<SvxUnoTextRangeBase>( aTextPosition );
5767 if(pRange)
5768 pCursor->SetSelection( pRange->GetSelection() );
5769 else
5770 {
5771 ScCellTextCursor* pOther = comphelper::getFromUnoTunnel<ScCellTextCursor>( aTextPosition );
5772 if(!pOther)
5773 throw uno::RuntimeException();
5774
5775 pCursor->SetSelection( pOther->GetSelection() );
5776
5777 }
5778
5779 return pCursor;
5780 }
5781
5782 OUString SAL_CALL ScCellObj::getString()
5783 {
5784 SolarMutexGuard aGuard;
5785 return GetOutputString_Impl();
5786 }
5787
5788 void SAL_CALL ScCellObj::setString( const OUString& aText )
5789 {
5790 SolarMutexGuard aGuard;
5791 SetString_Impl(aText, false, false); // always text
5792
5793 // don't create pUnoText here if not there
5794 if (mxUnoText.is())
5795 mxUnoText->SetSelection(ESelection( 0,0, 0,aText.getLength() ));
5796 }
5797
5798 void SAL_CALL ScCellObj::insertString( const uno::Reference<text::XTextRange>& xRange,
5799 const OUString& aString, sal_Bool bAbsorb )
5800 {
5801 // special handling for ScCellTextCursor is no longer needed,
5802 // SvxUnoText::insertString checks for SvxUnoTextRangeBase instead of SvxUnoTextRange
5803
5804 SolarMutexGuard aGuard;
5805 GetUnoText().insertString(xRange, aString, bAbsorb);
5806 }
5807
5808 void SAL_CALL ScCellObj::insertControlCharacter( const uno::Reference<text::XTextRange>& xRange,
5809 sal_Int16 nControlCharacter, sal_Bool bAbsorb )
5810 {
5811 SolarMutexGuard aGuard;
5812 GetUnoText().insertControlCharacter(xRange, nControlCharacter, bAbsorb);
5813 }
5814
5815 void SAL_CALL ScCellObj::insertTextContent( const uno::Reference<text::XTextRange >& xRange,
5816 const uno::Reference<text::XTextContent >& xContent,
5817 sal_Bool bAbsorb )
5818 {
5819 SolarMutexGuard aGuard;
5820 ScDocShell* pDocSh = GetDocShell();
5821 if ( pDocSh && xContent.is() )
5822 {
5823 ScEditFieldObj* pCellField = dynamic_cast<ScEditFieldObj*>(xContent.get());
5824 SvxUnoTextRangeBase* pTextRange = comphelper::getFromUnoTunnel<ScCellTextCursor>( xRange );
5825
5826 if ( pCellField && !pCellField->IsInserted() && pTextRange )
5827 {
5828 SvxEditSource* pEditSource = pTextRange->GetEditSource();
5829 ESelection aSelection(pTextRange->GetSelection());
5830
5831 if (!bAbsorb)
5832 {
5833 // do not replace -> append
5834 aSelection.Adjust();
5835 aSelection.CollapseToEnd();
5836 }
5837
5838 if (pCellField->GetFieldType() == text::textfield::Type::TABLE)
5839 pCellField->setPropertyValue(SC_UNONAME_TABLEPOS, uno::Any(sal_Int32(aCellPos.Tab())));
5840
5841 SvxFieldItem aItem = pCellField->CreateFieldItem();
5842 SvxTextForwarder* pForwarder = pEditSource->GetTextForwarder();
5843 pForwarder->QuickInsertField( aItem, aSelection );
5844 pEditSource->UpdateData();
5845
5846 // new selection: a digit
5847 aSelection.Adjust();
5848 aSelection.end.nPara = aSelection.start.nPara;
5849 aSelection.end.nIndex = aSelection.start.nIndex + 1;
5850 uno::Reference<text::XTextRange> xParent(this);
5851 pCellField->InitDoc(
5852 xParent, std::make_unique<ScCellEditSource>(pDocSh, aCellPos), aSelection);
5853
5854 // for bAbsorb=FALSE, the new selection must be behind the inserted content
5855 // (the xml filter relies on this)
5856 if (!bAbsorb)
5857 aSelection.start.nIndex = aSelection.end.nIndex;
5858
5859 pTextRange->SetSelection( aSelection );
5860
5861 return;
5862 }
5863 }
5864 GetUnoText().insertTextContent(xRange, xContent, bAbsorb);
5865 }
5866
5867 void SAL_CALL ScCellObj::removeTextContent( const uno::Reference<text::XTextContent>& xContent )
5868 {
5869 SolarMutexGuard aGuard;
5870 if ( xContent.is() )
5871 {
5872 ScEditFieldObj* pCellField = dynamic_cast<ScEditFieldObj*>(xContent.get());
5873 if ( pCellField && pCellField->IsInserted() )
5874 {
5875 //! Check if field is in this cell
5876 pCellField->DeleteField();
5877 return;
5878 }
5879 }
5880 GetUnoText().removeTextContent(xContent);
5881 }
5882
5883 uno::Reference<text::XText> SAL_CALL ScCellObj::getText()
5884 {
5885 return this;
5886 }
5887
5888 uno::Reference<text::XTextRange> SAL_CALL ScCellObj::getStart()
5889 {
5890 SolarMutexGuard aGuard;
5891 return GetUnoText().getStart();
5892 }
5893
5894 uno::Reference<text::XTextRange> SAL_CALL ScCellObj::getEnd()
5895 {
5896 SolarMutexGuard aGuard;
5897 return GetUnoText().getEnd();
5898 }
5899
5900 uno::Reference<container::XEnumeration> SAL_CALL ScCellObj::createEnumeration()
5901 {
5902 SolarMutexGuard aGuard;
5903 return GetUnoText().createEnumeration();
5904 }
5905
5906 uno::Type SAL_CALL ScCellObj::getElementType()
5907 {
5908 SolarMutexGuard aGuard;
5909 return GetUnoText().getElementType();
5910 }
5911
5912 sal_Bool SAL_CALL ScCellObj::hasElements()
5913 {
5914 SolarMutexGuard aGuard;
5915 return GetUnoText().hasElements();
5916 }
5917
5918 // XCell
5919
5920 OUString SAL_CALL ScCellObj::getFormula()
5921 {
5922 SolarMutexGuard aGuard;
5923 return GetInputString_Impl( true /* English */ );
5924 }
5925
5926 void SAL_CALL ScCellObj::setFormula( const OUString& aFormula )
5927 {
5928 SolarMutexGuard aGuard;
5929 SetString_Impl(aFormula, true, true); // Interpret as English
5930 }
5931
5932 double SAL_CALL ScCellObj::getValue()
5933 {
5934 SolarMutexGuard aGuard;
5935 return GetValue_Impl();
5936 }
5937
5938 void SAL_CALL ScCellObj::setValue( double nValue )
5939 {
5940 SolarMutexGuard aGuard;
5941 SetValue_Impl(nValue);
5942 }
5943
5944 void SAL_CALL ScCellObj::setFormulaString( const OUString& aFormula)
5945 {
5946 SolarMutexGuard aGuard;
5947 ScDocShell *pDocSh = GetDocShell();
5948 if( pDocSh )
5949 {
5950 ScFormulaCell* pCell = new ScFormulaCell( pDocSh->GetDocument(), aCellPos );
5951 pCell->SetHybridFormula( aFormula, formula::FormulaGrammar::GRAM_NATIVE );
5952 pDocSh->GetDocFunc().SetFormulaCell(aCellPos, pCell, false);
5953 }
5954 }
5955 void SAL_CALL ScCellObj::setFormulaResult( double nValue )
5956 {
5957 SolarMutexGuard aGuard;
5958 ScDocShell* pDocSh = GetDocShell();
5959 if (pDocSh)
5960 {
5961 ScRefCellValue aCell(pDocSh->GetDocument(), aCellPos);
5962 if (aCell.getType() == CELLTYPE_FORMULA)
5963 {
5964 ScFormulaCell* pCell = aCell.getFormula();
5965 pCell->SetHybridDouble( nValue );
5966 pCell->ResetDirty();
5967 pCell->SetChanged(false);
5968 }
5969 }
5970 }
5971
5972 table::CellContentType SAL_CALL ScCellObj::getType()
5973 {
5974 SolarMutexGuard aGuard;
5975 table::CellContentType eRet = table::CellContentType_EMPTY;
5976 ScDocShell* pDocSh = GetDocShell();
5977 if (pDocSh)
5978 {
5979 CellType eCalcType = pDocSh->GetDocument().GetCellType( aCellPos );
5980 switch (eCalcType)
5981 {
5982 case CELLTYPE_VALUE:
5983 eRet = table::CellContentType_VALUE;
5984 break;
5985 case CELLTYPE_STRING:
5986 case CELLTYPE_EDIT:
5987 eRet = table::CellContentType_TEXT;
5988 break;
5989 case CELLTYPE_FORMULA:
5990 eRet = table::CellContentType_FORMULA;
5991 break;
5992 default:
5993 eRet = table::CellContentType_EMPTY;
5994 }
5995 }
5996 else
5997 {
5998 OSL_FAIL("no DocShell"); //! Exception or so?
5999 }
6000
6001 return eRet;
6002 }
6003
6004 sal_Int32 ScCellObj::GetResultType_Impl() const
6005 {
6006 SolarMutexGuard aGuard;
6007 sal_Int32 eRet = sheet::FormulaResult::STRING;
6008 ScDocShell* pDocSh = GetDocShell();
6009 if (pDocSh)
6010 {
6011 if (pDocSh->GetDocument().GetCellType(aCellPos) == CELLTYPE_FORMULA)
6012 {
6013 ScFormulaCell* pFCell = pDocSh->GetDocument().GetFormulaCell(aCellPos);
6014 if (!pFCell)
6015 {
6016 // should throw instead of default string?
6017 }
6018 else if (pFCell->GetErrCode() != FormulaError::NONE )
6019 {
6020 eRet = sheet::FormulaResult::ERROR;
6021 }
6022 else if (pFCell->IsValue())
6023 {
6024 eRet = sheet::FormulaResult::VALUE;
6025 }
6026 else
6027 {
6028 eRet = sheet::FormulaResult::STRING;
6029 }
6030 }
6031 }
6032 else
6033 {
6034 OSL_FAIL("no DocShell");
6035 }
6036
6037 return eRet;
6038 }
6039
6040 table::CellContentType ScCellObj::GetContentType_Impl()
6041 {
6042 ScDocShell* pDocSh = GetDocShell();
6043 if ( pDocSh )
6044 {
6045 ScRefCellValue aCell(pDocSh->GetDocument(), aCellPos);
6046 if (aCell.getType() == CELLTYPE_FORMULA)
6047 {
6048 bool bValue = aCell.getFormula()->IsValue();
6049 return bValue ? table::CellContentType_VALUE : table::CellContentType_TEXT;
6050 }
6051 }
6052 return getType();
6053 }
6054
6055 sal_Int32 SAL_CALL ScCellObj::getError()
6056 {
6057 SolarMutexGuard aGuard;
6058 ScDocShell* pDocSh = GetDocShell();
6059 if (!pDocSh)
6060 {
6061 OSL_FAIL("no DocShell"); //! Exception or so?
6062 return 0;
6063 }
6064
6065 FormulaError nError = FormulaError::NONE;
6066 ScRefCellValue aCell(pDocSh->GetDocument(), aCellPos);
6067 if (aCell.getType() == CELLTYPE_FORMULA)
6068 nError = aCell.getFormula()->GetErrCode();
6069
6070 return static_cast<sal_Int32>(nError);
6071 }
6072
6073 // XFormulaTokens
6074
6075 uno::Sequence<sheet::FormulaToken> SAL_CALL ScCellObj::getTokens()
6076 {
6077 SolarMutexGuard aGuard;
6078 uno::Sequence<sheet::FormulaToken> aSequence;
6079 ScDocShell* pDocSh = GetDocShell();
6080 if (!pDocSh)
6081 return aSequence;
6082
6083 ScDocument& rDoc = pDocSh->GetDocument();
6084 ScRefCellValue aCell(rDoc, aCellPos);
6085 if (aCell.getType() == CELLTYPE_FORMULA)
6086 {
6087 ScTokenArray* pTokenArray = aCell.getFormula()->GetCode();
6088 if (pTokenArray)
6089 ScTokenConversion::ConvertToTokenSequence(rDoc, aSequence, *pTokenArray);
6090 }
6091 return aSequence;
6092 }
6093
6094 void SAL_CALL ScCellObj::setTokens( const uno::Sequence<sheet::FormulaToken>& rTokens )
6095 {
6096 SolarMutexGuard aGuard;
6097 ScDocShell* pDocSh = GetDocShell();
6098 if ( pDocSh )
6099 {
6100 ScDocument& rDoc = pDocSh->GetDocument();
6101 ScTokenArray aTokenArray(rDoc);
6102 (void)ScTokenConversion::ConvertToTokenArray( rDoc, aTokenArray, rTokens );
6103
6104 ScFormulaCell* pNewCell = new ScFormulaCell(rDoc, aCellPos, aTokenArray);
6105 (void)pDocSh->GetDocFunc().SetFormulaCell(aCellPos, pNewCell, false);
6106 }
6107 }
6108
6109 // XCellAddressable
6110
6111 table::CellAddress SAL_CALL ScCellObj::getCellAddress()
6112 {
6113 SolarMutexGuard aGuard;
6114 table::CellAddress aAdr;
6115 aAdr.Sheet = aCellPos.Tab();
6116 aAdr.Column = aCellPos.Col();
6117 aAdr.Row = aCellPos.Row();
6118 return aAdr;
6119 }
6120
6121 // XSheetAnnotationAnchor
6122
6123 uno::Reference<sheet::XSheetAnnotation> SAL_CALL ScCellObj::getAnnotation()
6124 {
6125 SolarMutexGuard aGuard;
6126 ScDocShell* pDocSh = GetDocShell();
6127 if ( pDocSh )
6128 return new ScAnnotationObj( pDocSh, aCellPos );
6129
6130 OSL_FAIL("getAnnotation without DocShell");
6131 return nullptr;
6132 }
6133
6134 // XFieldTypesSupplier
6135
6136 uno::Reference<container::XEnumerationAccess> SAL_CALL ScCellObj::getTextFields()
6137 {
6138 SolarMutexGuard aGuard;
6139 ScDocShell* pDocSh = GetDocShell();
6140 if ( pDocSh )
6141 {
6142 uno::Reference<text::XTextRange> xContent(this);
6143 return new ScCellFieldsObj(xContent, pDocSh, aCellPos);
6144 }
6145
6146 return nullptr;
6147 }
6148
6149 uno::Reference<container::XNameAccess> SAL_CALL ScCellObj::getTextFieldMasters()
6150 {
6151 // there is no such thing in Calc (?)
6152 return nullptr;
6153 }
6154
6155 // XPropertySet extended for Cell-Properties
6156
6157 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCellObj::getPropertySetInfo()
6158 {
6159 SolarMutexGuard aGuard;
6160 static uno::Reference<beans::XPropertySetInfo> aRef(
6161 new SfxItemPropertySetInfo( pCellPropSet->getPropertyMap() ));
6162 return aRef;
6163 }
6164
6165 void ScCellObj::SetOnePropertyValue( const SfxItemPropertyMapEntry* pEntry, const uno::Any& aValue )
6166 {
6167 if ( !pEntry )
6168 return;
6169
6170 if ( pEntry->nWID == SC_WID_UNO_FORMLOC )
6171 {
6172 OUString aStrVal;
6173 aValue >>= aStrVal;
6174 SetString_Impl(aStrVal, true, false); // interpret locally
6175 }
6176 else if ( pEntry->nWID == SC_WID_UNO_FORMRT || pEntry->nWID == SC_WID_UNO_FORMRT2
6177 || pEntry->nWID == SC_WID_UNO_CELLCONTENTTYPE )
6178 {
6179 // Read-Only
6180 //! Exception or so...
6181 }
6182 else
6183 ScCellRangeObj::SetOnePropertyValue( pEntry, aValue );
6184 }
6185
6186 void ScCellObj::GetOnePropertyValue( const SfxItemPropertyMapEntry* pEntry, uno::Any& rAny )
6187 {
6188 if ( !pEntry )
6189 return;
6190
6191 if ( pEntry->nWID == SC_WID_UNO_FORMLOC )
6192 {
6193 // sal_False = local
6194 rAny <<= GetInputString_Impl(false);
6195 }
6196 else if ( pEntry->nWID == SC_WID_UNO_FORMRT2 )
6197 {
6198 sal_Int32 eType = GetResultType_Impl();
6199 rAny <<= eType;
6200 }
6201 else if ( pEntry->nWID == SC_WID_UNO_CELLCONTENTTYPE || pEntry->nWID == SC_WID_UNO_FORMRT )
6202 {
6203 table::CellContentType eType = GetContentType_Impl();
6204 rAny <<= eType;
6205 }
6206 else
6207 ScCellRangeObj::GetOnePropertyValue(pEntry, rAny);
6208 }
6209
6210 const SfxItemPropertyMap& ScCellObj::GetItemPropertyMap()
6211 {
6212 return pCellPropSet->getPropertyMap();
6213 }
6214
6215 // XServiceInfo
6216
6217 OUString SAL_CALL ScCellObj::getImplementationName()
6218 {
6219 return u"ScCellObj"_ustr;
6220 }
6221
6222 sal_Bool SAL_CALL ScCellObj::supportsService( const OUString& rServiceName )
6223 {
6224 return cppu::supportsService(this, rServiceName);
6225 }
6226
6227 uno::Sequence<OUString> SAL_CALL ScCellObj::getSupportedServiceNames()
6228 {
6229 return {SCSHEETCELL_SERVICE,
6230 SCCELL_SERVICE,
6231 SCCELLPROPERTIES_SERVICE,
6232 SCCHARPROPERTIES_SERVICE,
6233 SCPARAPROPERTIES_SERVICE,
6234 SCSHEETCELLRANGE_SERVICE,
6235 SCCELLRANGE_SERVICE};
6236 }
6237
6238 // XActionLockable
6239
6240 sal_Bool SAL_CALL ScCellObj::isActionLocked()
6241 {
6242 SolarMutexGuard aGuard;
6243 return nActionLockCount != 0;
6244 }
6245
6246 void SAL_CALL ScCellObj::addActionLock()
6247 {
6248 SolarMutexGuard aGuard;
6249 if (!nActionLockCount)
6250 {
6251 if (mxUnoText.is())
6252 {
6253 ScCellEditSource* pEditSource =
6254 static_cast<ScCellEditSource*> (mxUnoText->GetEditSource());
6255 if (pEditSource)
6256 pEditSource->SetDoUpdateData(false);
6257 }
6258 }
6259 nActionLockCount++;
6260 }
6261
6262 void SAL_CALL ScCellObj::removeActionLock()
6263 {
6264 SolarMutexGuard aGuard;
6265 if (nActionLockCount <= 0)
6266 return;
6267
6268 nActionLockCount--;
6269 if (nActionLockCount)
6270 return;
6271
6272 if (mxUnoText.is())
6273 {
6274 ScCellEditSource* pEditSource =
6275 static_cast<ScCellEditSource*> (mxUnoText->GetEditSource());
6276 if (pEditSource)
6277 {
6278 pEditSource->SetDoUpdateData(true);
6279 if (pEditSource->IsDirty())
6280 pEditSource->UpdateData();
6281 }
6282 }
6283 }
6284
6285 void SAL_CALL ScCellObj::setActionLocks( sal_Int16 nLock )
6286 {
6287 SolarMutexGuard aGuard;
6288 if (mxUnoText.is())
6289 {
6290 ScCellEditSource* pEditSource =
6291 static_cast<ScCellEditSource*> (mxUnoText->GetEditSource());
6292 if (pEditSource)
6293 {
6294 pEditSource->SetDoUpdateData(nLock == 0);
6295 if ((nActionLockCount > 0) && (nLock == 0) && pEditSource->IsDirty())
6296 pEditSource->UpdateData();
6297 }
6298 }
6299 nActionLockCount = nLock;
6300 }
6301
6302 sal_Int16 SAL_CALL ScCellObj::resetActionLocks()
6303 {
6304 SolarMutexGuard aGuard;
6305 sal_uInt16 nRet(nActionLockCount);
6306 if (mxUnoText.is())
6307 {
6308 ScCellEditSource* pEditSource =
6309 static_cast<ScCellEditSource*> (mxUnoText->GetEditSource());
6310 if (pEditSource)
6311 {
6312 pEditSource->SetDoUpdateData(true);
6313 if (pEditSource->IsDirty())
6314 pEditSource->UpdateData();
6315 }
6316 }
6317 nActionLockCount = 0;
6318 return nRet;
6319 }
6320
6321 static ScRange MaxDocRange(ScDocShell* pDocSh, SCTAB nTab)
6322 {
6323 const SCCOL nMaxcol = pDocSh ? pDocSh->GetDocument().MaxCol() : MAXCOL;
6324 const SCROW nMaxRow = pDocSh ? pDocSh->GetDocument().MaxRow() : MAXROW;
6325 return ScRange(0, 0, nTab, nMaxcol, nMaxRow, nTab);
6326 }
6327
6328 ScTableSheetObj::ScTableSheetObj( ScDocShell* pDocSh, SCTAB nTab ) :
6329 ScTableSheetObj_BASE( pDocSh, MaxDocRange(pDocSh, nTab) ),
6330 pSheetPropSet(lcl_GetSheetPropertySet())
6331 {
6332 }
6333
6334 ScTableSheetObj::~ScTableSheetObj()
6335 {
6336 }
6337
6338 void ScTableSheetObj::InitInsertSheet(ScDocShell* pDocSh, SCTAB nTab)
6339 {
6340 ScDocument& rDoc = pDocSh->GetDocument();
6341 InitInsertRange( pDocSh, ScRange(0,0,nTab, rDoc.MaxCol(),rDoc.MaxRow(),nTab) );
6342 }
6343
6344 // Helper functions
6345
6346 SCTAB ScTableSheetObj::GetTab_Impl() const
6347 {
6348 const ScRangeList& rRanges = GetRangeList();
6349 OSL_ENSURE(rRanges.size() == 1, "What ranges ?!?!");
6350 if ( !rRanges.empty() )
6351 {
6352 return rRanges[ 0 ].aStart.Tab();
6353 }
6354 return 0;
6355 }
6356
6357 // former XSheet
6358
6359 uno::Reference<table::XTableCharts> SAL_CALL ScTableSheetObj::getCharts()
6360 {
6361 SolarMutexGuard aGuard;
6362 ScDocShell* pDocSh = GetDocShell();
6363 if ( pDocSh )
6364 return new ScChartsObj( pDocSh, GetTab_Impl() );
6365
6366 OSL_FAIL("no document");
6367 return nullptr;
6368 }
6369
6370 uno::Reference<table::XTablePivotCharts> SAL_CALL ScTableSheetObj::getPivotCharts()
6371 {
6372 SolarMutexGuard aGuard;
6373 ScDocShell* pDocSh = GetDocShell();
6374 if (pDocSh)
6375 return new sc::TablePivotCharts(pDocSh, GetTab_Impl());
6376
6377 OSL_FAIL("no document");
6378 return nullptr;
6379 }
6380
6381 uno::Reference<sheet::XDataPilotTables> SAL_CALL ScTableSheetObj::getDataPilotTables()
6382 {
6383 SolarMutexGuard aGuard;
6384 ScDocShell* pDocSh = GetDocShell();
6385 if ( pDocSh )
6386 return new ScDataPilotTablesObj(*pDocSh, GetTab_Impl());
6387
6388 OSL_FAIL("no document");
6389 return nullptr;
6390 }
6391
6392 uno::Reference<sheet::XScenarios> SAL_CALL ScTableSheetObj::getScenarios()
6393 {
6394 SolarMutexGuard aGuard;
6395 ScDocShell* pDocSh = GetDocShell();
6396
6397 if ( pDocSh )
6398 return new ScScenariosObj( pDocSh, GetTab_Impl() );
6399
6400 OSL_FAIL("no document");
6401 return nullptr;
6402 }
6403
6404 uno::Reference<sheet::XSheetAnnotations> SAL_CALL ScTableSheetObj::getAnnotations()
6405 {
6406 SolarMutexGuard aGuard;
6407 ScDocShell* pDocSh = GetDocShell();
6408
6409 if ( pDocSh )
6410 return new ScAnnotationsObj( pDocSh, GetTab_Impl() );
6411
6412 OSL_FAIL("no document");
6413 return nullptr;
6414 }
6415
6416 uno::Reference<table::XCellRange> SAL_CALL ScTableSheetObj::getCellRangeByName(
6417 const OUString& rRange )
6418 {
6419 SolarMutexGuard aGuard;
6420 return ScCellRangeObj::getCellRangeByName( rRange );
6421 }
6422
6423 uno::Reference<sheet::XSheetCellCursor> SAL_CALL ScTableSheetObj::createCursor()
6424 {
6425 SolarMutexGuard aGuard;
6426 ScDocShell* pDocSh = GetDocShell();
6427 if ( pDocSh )
6428 {
6429 //! single cell or whole table??????
6430 const ScDocument& rDoc = pDocSh->GetDocument();
6431 SCTAB nTab = GetTab_Impl();
6432 return new ScCellCursorObj( pDocSh, ScRange( 0,0,nTab, rDoc.MaxCol(),rDoc.MaxRow(),nTab ) );
6433 }
6434 return nullptr;
6435 }
6436
6437 uno::Reference<sheet::XSheetCellCursor> SAL_CALL ScTableSheetObj::createCursorByRange(
6438 const uno::Reference<sheet::XSheetCellRange>& xCellRange )
6439 {
6440 SolarMutexGuard aGuard;
6441 ScDocShell* pDocSh = GetDocShell();
6442 if ( pDocSh && xCellRange.is() )
6443 {
6444 ScCellRangesBase* pRangesImp = dynamic_cast<ScCellRangesBase*>( xCellRange.get() );
6445 if (pRangesImp)
6446 {
6447 const ScRangeList& rRanges = pRangesImp->GetRangeList();
6448 SAL_WARN_IF( rRanges.size() != 1, "sc", "ScTableSheetObj::createCursorByRange: Range? Ranges?");
6449 if (rRanges.empty())
6450 return nullptr;
6451 return new ScCellCursorObj( pDocSh, rRanges[ 0 ] );
6452 }
6453 }
6454 return nullptr;
6455 }
6456
6457 // XSheetCellRange
6458
6459 uno::Reference<sheet::XSpreadsheet> SAL_CALL ScTableSheetObj::getSpreadsheet()
6460 {
6461 return this; //!???
6462 }
6463
6464 // XCellRange
6465
6466 uno::Reference<table::XCell> SAL_CALL ScTableSheetObj::getCellByPosition(
6467 sal_Int32 nColumn, sal_Int32 nRow )
6468 {
6469 SolarMutexGuard aGuard;
6470 return ScCellRangeObj::GetCellByPosition_Impl(nColumn, nRow);
6471 }
6472
6473 uno::Reference<table::XCellRange> SAL_CALL ScTableSheetObj::getCellRangeByPosition(
6474 sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom )
6475 {
6476 SolarMutexGuard aGuard;
6477 return ScCellRangeObj::getCellRangeByPosition(nLeft,nTop,nRight,nBottom);
6478 }
6479
6480 uno::Sequence<sheet::TablePageBreakData> SAL_CALL ScTableSheetObj::getColumnPageBreaks()
6481 {
6482 SolarMutexGuard aGuard;
6483 ScDocShell* pDocSh = GetDocShell();
6484 if ( pDocSh )
6485 {
6486 ScDocument& rDoc = pDocSh->GetDocument();
6487 SCTAB nTab = GetTab_Impl();
6488
6489 Size aSize(rDoc.GetPageSize( nTab ));
6490 if (aSize.Width() && aSize.Height()) // effective size already set?
6491 rDoc.UpdatePageBreaks( nTab );
6492 else
6493 {
6494 // update breaks like in ScDocShell::PageStyleModified:
6495 ScPrintFunc aPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab );
6496 aPrintFunc.UpdatePages();
6497 }
6498
6499 SCCOL nCount = 0;
6500 for (SCCOL nCol : rDoc.GetColumnsRange(nTab, 0, rDoc.MaxCol()))
6501 if (rDoc.HasColBreak(nCol, nTab) != ScBreakType::NONE)
6502 ++nCount;
6503
6504 sheet::TablePageBreakData aData;
6505 uno::Sequence<sheet::TablePageBreakData> aSeq(nCount);
6506 sheet::TablePageBreakData* pAry = aSeq.getArray();
6507 sal_uInt16 nPos = 0;
6508 for (SCCOL nCol : rDoc.GetColumnsRange(nTab, 0, rDoc.MaxCol()))
6509 {
6510 ScBreakType nBreak = rDoc.HasColBreak(nCol, nTab);
6511 if (nBreak != ScBreakType::NONE)
6512 {
6513 aData.Position = nCol;
6514 aData.ManualBreak = bool(nBreak & ScBreakType::Manual);
6515 pAry[nPos] = aData;
6516 ++nPos;
6517 }
6518 }
6519 return aSeq;
6520 }
6521 return {};
6522 }
6523
6524 uno::Sequence<sheet::TablePageBreakData> SAL_CALL ScTableSheetObj::getRowPageBreaks()
6525 {
6526 SolarMutexGuard aGuard;
6527 ScDocShell* pDocSh = GetDocShell();
6528 if ( pDocSh )
6529 {
6530 ScDocument& rDoc = pDocSh->GetDocument();
6531 SCTAB nTab = GetTab_Impl();
6532
6533 Size aSize(rDoc.GetPageSize( nTab ));
6534 if (aSize.Width() && aSize.Height()) // effective size already set?
6535 rDoc.UpdatePageBreaks( nTab );
6536 else
6537 {
6538 // update breaks like in ScDocShell::PageStyleModified:
6539 ScPrintFunc aPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab );
6540 aPrintFunc.UpdatePages();
6541 }
6542 return rDoc.GetRowBreakData(nTab);
6543 }
6544 return {};
6545 }
6546
6547 void SAL_CALL ScTableSheetObj::removeAllManualPageBreaks()
6548 {
6549 SolarMutexGuard aGuard;
6550 ScDocShell* pDocSh = GetDocShell();
6551 if ( !pDocSh )
6552 return;
6553
6554 //! DocFunc function, also for ScViewFunc::RemoveManualBreaks
6555
6556 ScDocument& rDoc = pDocSh->GetDocument();
6557 bool bUndo (rDoc.IsUndoEnabled());
6558 SCTAB nTab = GetTab_Impl();
6559
6560 if (bUndo)
6561 {
6562 ScDocumentUniquePtr pUndoDoc(new ScDocument( SCDOCMODE_UNDO ));
6563 pUndoDoc->InitUndo( rDoc, nTab, nTab, true, true );
6564 rDoc.CopyToDocument(0,0,nTab, rDoc.MaxCol(),rDoc.MaxRow(),nTab, InsertDeleteFlags::NONE, false, *pUndoDoc);
6565 pDocSh->GetUndoManager()->AddUndoAction(
6566 std::make_unique<ScUndoRemoveBreaks>( pDocSh, nTab, std::move(pUndoDoc) ) );
6567 }
6568
6569 rDoc.RemoveManualBreaks(nTab);
6570 rDoc.UpdatePageBreaks(nTab);
6571
6572 //? UpdatePageBreakData( sal_True );
6573 pDocSh->SetDocumentModified();
6574 pDocSh->PostPaint(ScRange(0, 0, nTab, rDoc.MaxCol(), rDoc.MaxRow(), nTab), PaintPartFlags::Grid);
6575 }
6576
6577 // XNamed
6578
6579 OUString SAL_CALL ScTableSheetObj::getName()
6580 {
6581 SolarMutexGuard aGuard;
6582 OUString aName;
6583 ScDocShell* pDocSh = GetDocShell();
6584 if ( pDocSh )
6585 pDocSh->GetDocument().GetName( GetTab_Impl(), aName );
6586 return aName;
6587 }
6588
6589 void SAL_CALL ScTableSheetObj::setName( const OUString& aNewName )
6590 {
6591 SolarMutexGuard aGuard;
6592 ScDocShell* pDocSh = GetDocShell();
6593 if ( pDocSh )
6594 {
6595 pDocSh->GetDocFunc().RenameTable( GetTab_Impl(), aNewName, true, true );
6596 }
6597 }
6598
6599 // XDrawPageSupplier
6600
6601 uno::Reference<drawing::XDrawPage> SAL_CALL ScTableSheetObj::getDrawPage()
6602 {
6603 SolarMutexGuard aGuard;
6604 ScDocShell* pDocSh = GetDocShell();
6605 if ( pDocSh )
6606 {
6607 ScDrawLayer* pDrawLayer = pDocSh->MakeDrawLayer();
6608 OSL_ENSURE(pDrawLayer,"Cannot create Draw-Layer");
6609
6610 SCTAB nTab = GetTab_Impl();
6611 SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
6612 OSL_ENSURE(pPage,"Draw-Page not found");
6613 if (pPage)
6614 return uno::Reference<drawing::XDrawPage> (pPage->getUnoPage(), uno::UNO_QUERY);
6615
6616 // The DrawPage object will register itself as a Listener at SdrModel
6617 // and should receive all action from there
6618 }
6619 return nullptr;
6620 }
6621
6622 // XCellMovement
6623
6624 void SAL_CALL ScTableSheetObj::insertCells( const table::CellRangeAddress& rRangeAddress,
6625 sheet::CellInsertMode nMode )
6626 {
6627 SolarMutexGuard aGuard;
6628 ScDocShell* pDocSh = GetDocShell();
6629 if ( !pDocSh )
6630 return;
6631
6632 bool bDo = true;
6633 InsCellCmd eCmd = INS_NONE;
6634 switch (nMode)
6635 {
6636 case sheet::CellInsertMode_NONE: bDo = false; break;
6637 case sheet::CellInsertMode_DOWN: eCmd = INS_CELLSDOWN; break;
6638 case sheet::CellInsertMode_RIGHT: eCmd = INS_CELLSRIGHT; break;
6639 case sheet::CellInsertMode_ROWS: eCmd = INS_INSROWS_BEFORE; break;
6640 case sheet::CellInsertMode_COLUMNS: eCmd = INS_INSCOLS_BEFORE; break;
6641 default:
6642 OSL_FAIL("insertCells: wrong mode");
6643 bDo = false;
6644 }
6645
6646 if (bDo)
6647 {
6648 OSL_ENSURE( rRangeAddress.Sheet == GetTab_Impl(), "wrong table in CellRangeAddress" );
6649 ScRange aScRange;
6650 ScUnoConversion::FillScRange( aScRange, rRangeAddress );
6651 (void)pDocSh->GetDocFunc().InsertCells( aScRange, nullptr, eCmd, true, true );
6652 }
6653 }
6654
6655 void SAL_CALL ScTableSheetObj::removeRange( const table::CellRangeAddress& rRangeAddress,
6656 sheet::CellDeleteMode nMode )
6657 {
6658 SolarMutexGuard aGuard;
6659 ScDocShell* pDocSh = GetDocShell();
6660 if ( !pDocSh )
6661 return;
6662
6663 bool bDo = true;
6664 DelCellCmd eCmd = DelCellCmd::NONE;
6665 switch (nMode)
6666 {
6667 case sheet::CellDeleteMode_NONE: bDo = false; break;
6668 case sheet::CellDeleteMode_UP: eCmd = DelCellCmd::CellsUp; break;
6669 case sheet::CellDeleteMode_LEFT: eCmd = DelCellCmd::CellsLeft; break;
6670 case sheet::CellDeleteMode_ROWS: eCmd = DelCellCmd::Rows; break;
6671 case sheet::CellDeleteMode_COLUMNS: eCmd = DelCellCmd::Cols; break;
6672 default:
6673 OSL_FAIL("deleteCells: wrong mode");
6674 bDo = false;
6675 }
6676
6677 if (bDo)
6678 {
6679 OSL_ENSURE( rRangeAddress.Sheet == GetTab_Impl(), "wrong table in CellRangeAddress" );
6680 ScRange aScRange;
6681 ScUnoConversion::FillScRange( aScRange, rRangeAddress );
6682 (void)pDocSh->GetDocFunc().DeleteCells( aScRange, nullptr, eCmd, true );
6683 }
6684 }
6685
6686 void SAL_CALL ScTableSheetObj::moveRange( const table::CellAddress& aDestination,
6687 const table::CellRangeAddress& aSource )
6688 {
6689 SolarMutexGuard aGuard;
6690 ScDocShell* pDocSh = GetDocShell();
6691 if ( pDocSh )
6692 {
6693 OSL_ENSURE( aSource.Sheet == GetTab_Impl(), "wrong table in CellRangeAddress" );
6694 ScRange aSourceRange;
6695 ScUnoConversion::FillScRange( aSourceRange, aSource );
6696 ScAddress aDestPos( static_cast<SCCOL>(aDestination.Column), static_cast<SCROW>(aDestination.Row), aDestination.Sheet );
6697 (void)pDocSh->GetDocFunc().MoveBlock( aSourceRange, aDestPos, true, true, true, true );
6698 }
6699 }
6700
6701 void SAL_CALL ScTableSheetObj::copyRange( const table::CellAddress& aDestination,
6702 const table::CellRangeAddress& aSource )
6703 {
6704 SolarMutexGuard aGuard;
6705 ScDocShell* pDocSh = GetDocShell();
6706 if ( pDocSh )
6707 {
6708 OSL_ENSURE( aSource.Sheet == GetTab_Impl(), "wrong table in CellRangeAddress" );
6709 ScRange aSourceRange;
6710 ScUnoConversion::FillScRange( aSourceRange, aSource );
6711 ScAddress aDestPos( static_cast<SCCOL>(aDestination.Column), static_cast<SCROW>(aDestination.Row), aDestination.Sheet );
6712 (void)pDocSh->GetDocFunc().MoveBlock( aSourceRange, aDestPos, false, true, true, true );
6713 }
6714 }
6715
6716 // XPrintAreas
6717
6718 void ScTableSheetObj::PrintAreaUndo_Impl( std::unique_ptr<ScPrintRangeSaver> pOldRanges )
6719 {
6720 // page break and undo
6721 ScDocShell* pDocSh = GetDocShell();
6722
6723 if(!pDocSh)
6724 return;
6725
6726 ScDocument& rDoc = pDocSh->GetDocument();
6727 const bool bUndo(rDoc.IsUndoEnabled());
6728 const SCTAB nTab(GetTab_Impl());
6729
6730 if(bUndo)
6731 {
6732 pDocSh->GetUndoManager()->AddUndoAction(
6733 std::make_unique<ScUndoPrintRange>(
6734 pDocSh,
6735 nTab,
6736 std::move(pOldRanges),
6737 rDoc.CreatePrintRangeSaver())); // create new ranges
6738 }
6739
6740 ScPrintFunc(pDocSh, pDocSh->GetPrinter(), nTab).UpdatePages();
6741 SfxBindings* pBindings = pDocSh->GetViewBindings();
6742
6743 if(pBindings)
6744 {
6745 pBindings->Invalidate(SID_DELETE_PRINTAREA);
6746 }
6747
6748 pDocSh->SetDocumentModified();
6749 }
6750
6751 uno::Sequence<table::CellRangeAddress> SAL_CALL ScTableSheetObj::getPrintAreas()
6752 {
6753 SolarMutexGuard aGuard;
6754 ScDocShell* pDocSh = GetDocShell();
6755 if ( pDocSh )
6756 {
6757 ScDocument& rDoc = pDocSh->GetDocument();
6758 SCTAB nTab = GetTab_Impl();
6759 sal_uInt16 nCount = rDoc.GetPrintRangeCount( nTab );
6760
6761 table::CellRangeAddress aRangeAddress;
6762 uno::Sequence<table::CellRangeAddress> aSeq(nCount);
6763 table::CellRangeAddress* pAry = aSeq.getArray();
6764 for (sal_uInt16 i=0; i<nCount; i++)
6765 {
6766 const ScRange* pRange = rDoc.GetPrintRange( nTab, i );
6767 OSL_ENSURE(pRange,"where is the printing area");
6768 if (pRange)
6769 {
6770 ScUnoConversion::FillApiRange( aRangeAddress, *pRange );
6771 aRangeAddress.Sheet = nTab; // core does not care about sheet index
6772 pAry[i] = aRangeAddress;
6773 }
6774 }
6775 return aSeq;
6776 }
6777 return uno::Sequence<table::CellRangeAddress>();
6778 }
6779
6780 void SAL_CALL ScTableSheetObj::setPrintAreas(
6781 const uno::Sequence<table::CellRangeAddress>& aPrintAreas )
6782 {
6783 SolarMutexGuard aGuard;
6784 ScDocShell* pDocSh = GetDocShell();
6785 if ( !pDocSh )
6786 return;
6787
6788 std::unique_ptr<ScPrintRangeSaver> pOldRanges;
6789 ScDocument& rDoc = pDocSh->GetDocument();
6790 SCTAB nTab = GetTab_Impl();
6791
6792 if ( rDoc.IsUndoEnabled() )
6793 pOldRanges = rDoc.CreatePrintRangeSaver();
6794
6795 sal_uInt16 nCount = static_cast<sal_uInt16>(aPrintAreas.getLength());
6796 rDoc.ClearPrintRanges( nTab );
6797 if (nCount)
6798 {
6799 ScRange aPrintRange;
6800 for (const table::CellRangeAddress& rPrintArea : aPrintAreas)
6801 {
6802 ScUnoConversion::FillScRange( aPrintRange, rPrintArea );
6803 rDoc.AddPrintRange( nTab, aPrintRange );
6804 }
6805 }
6806
6807 if ( rDoc.IsUndoEnabled() )
6808 PrintAreaUndo_Impl( std::move(pOldRanges) ); // Undo, Page Breaks, Modified etc.
6809 }
6810
6811 sal_Bool SAL_CALL ScTableSheetObj::getPrintTitleColumns()
6812 {
6813 SolarMutexGuard aGuard;
6814 ScDocShell* pDocSh = GetDocShell();
6815 if ( pDocSh )
6816 {
6817 ScDocument& rDoc = pDocSh->GetDocument();
6818 SCTAB nTab = GetTab_Impl();
6819 return rDoc.GetRepeatColRange(nTab).has_value();
6820 }
6821 return false;
6822 }
6823
6824 void SAL_CALL ScTableSheetObj::setPrintTitleColumns( sal_Bool bPrintTitleColumns )
6825 {
6826 SolarMutexGuard aGuard;
6827 ScDocShell* pDocSh = GetDocShell();
6828 if ( !pDocSh )
6829 return;
6830
6831 ScDocument& rDoc = pDocSh->GetDocument();
6832 SCTAB nTab = GetTab_Impl();
6833
6834 std::unique_ptr<ScPrintRangeSaver> pOldRanges = rDoc.CreatePrintRangeSaver();
6835
6836 if ( bPrintTitleColumns )
6837 {
6838 if ( !rDoc.GetRepeatColRange( nTab ) ) // do not change existing area
6839 {
6840 rDoc.SetRepeatColRange( nTab, ScRange( 0, 0, nTab, 0, 0, nTab ) ); // enable
6841 }
6842 }
6843 else
6844 rDoc.SetRepeatColRange( nTab, std::nullopt ); // disable
6845
6846 PrintAreaUndo_Impl( std::move(pOldRanges) ); // undo, page break, modified etc.
6847
6848 //! save last set area during switch off and recreate during switch on ???
6849 }
6850
6851 table::CellRangeAddress SAL_CALL ScTableSheetObj::getTitleColumns()
6852 {
6853 SolarMutexGuard aGuard;
6854 table::CellRangeAddress aRet;
6855 ScDocShell* pDocSh = GetDocShell();
6856 if ( pDocSh )
6857 {
6858 ScDocument& rDoc = pDocSh->GetDocument();
6859 SCTAB nTab = GetTab_Impl();
6860 std::optional<ScRange> oRange = rDoc.GetRepeatColRange(nTab);
6861 if (oRange)
6862 {
6863 ScUnoConversion::FillApiRange( aRet, *oRange );
6864 aRet.Sheet = nTab; // core does not care about sheet index
6865 }
6866 }
6867 return aRet;
6868 }
6869
6870 void SAL_CALL ScTableSheetObj::setTitleColumns( const table::CellRangeAddress& aTitleColumns )
6871 {
6872 SolarMutexGuard aGuard;
6873 ScDocShell* pDocSh = GetDocShell();
6874 if ( !pDocSh )
6875 return;
6876
6877 ScDocument& rDoc = pDocSh->GetDocument();
6878 SCTAB nTab = GetTab_Impl();
6879
6880 std::unique_ptr<ScPrintRangeSaver> pOldRanges = rDoc.CreatePrintRangeSaver();
6881
6882 ScRange aNew;
6883 ScUnoConversion::FillScRange( aNew, aTitleColumns );
6884 rDoc.SetRepeatColRange( nTab, std::move(aNew) ); // also always enable
6885
6886 PrintAreaUndo_Impl( std::move(pOldRanges) ); // undo, page breaks, modified etc.
6887 }
6888
6889 sal_Bool SAL_CALL ScTableSheetObj::getPrintTitleRows()
6890 {
6891 SolarMutexGuard aGuard;
6892 ScDocShell* pDocSh = GetDocShell();
6893 if ( pDocSh )
6894 {
6895 ScDocument& rDoc = pDocSh->GetDocument();
6896 SCTAB nTab = GetTab_Impl();
6897 return rDoc.GetRepeatRowRange(nTab).has_value();
6898 }
6899 return false;
6900 }
6901
6902 void SAL_CALL ScTableSheetObj::setPrintTitleRows( sal_Bool bPrintTitleRows )
6903 {
6904 SolarMutexGuard aGuard;
6905 ScDocShell* pDocSh = GetDocShell();
6906 if ( !pDocSh )
6907 return;
6908
6909 ScDocument& rDoc = pDocSh->GetDocument();
6910 SCTAB nTab = GetTab_Impl();
6911
6912 std::unique_ptr<ScPrintRangeSaver> pOldRanges = rDoc.CreatePrintRangeSaver();
6913
6914 if ( bPrintTitleRows )
6915 {
6916 if ( !rDoc.GetRepeatRowRange( nTab ) ) // do not change existing area
6917 {
6918 rDoc.SetRepeatRowRange( nTab, ScRange(0, 0, nTab, 0, 0, nTab) ); // enable
6919 }
6920 }
6921 else
6922 rDoc.SetRepeatRowRange( nTab, std::nullopt ); // disable
6923
6924 PrintAreaUndo_Impl( std::move(pOldRanges) ); // undo, page breaks, modified etc.
6925
6926 //! save last set area during switch off and recreate during switch on ???
6927 }
6928
6929 table::CellRangeAddress SAL_CALL ScTableSheetObj::getTitleRows()
6930 {
6931 SolarMutexGuard aGuard;
6932 table::CellRangeAddress aRet;
6933 ScDocShell* pDocSh = GetDocShell();
6934 if ( pDocSh )
6935 {
6936 ScDocument& rDoc = pDocSh->GetDocument();
6937 SCTAB nTab = GetTab_Impl();
6938 std::optional<ScRange> oRange = rDoc.GetRepeatRowRange(nTab);
6939 if (oRange)
6940 {
6941 ScUnoConversion::FillApiRange( aRet, *oRange );
6942 aRet.Sheet = nTab; // core does not care about sheet index
6943 }
6944 }
6945 return aRet;
6946 }
6947
6948 void SAL_CALL ScTableSheetObj::setTitleRows( const table::CellRangeAddress& aTitleRows )
6949 {
6950 SolarMutexGuard aGuard;
6951 ScDocShell* pDocSh = GetDocShell();
6952 if ( !pDocSh )
6953 return;
6954
6955 ScDocument& rDoc = pDocSh->GetDocument();
6956 SCTAB nTab = GetTab_Impl();
6957
6958 std::unique_ptr<ScPrintRangeSaver> pOldRanges = rDoc.CreatePrintRangeSaver();
6959
6960 ScRange aNew;
6961 ScUnoConversion::FillScRange( aNew, aTitleRows );
6962 rDoc.SetRepeatRowRange( nTab, std::move(aNew) ); // also always enable
6963
6964 PrintAreaUndo_Impl( std::move(pOldRanges) ); // Undo, page breaks, modified etc.
6965 }
6966
6967 // XSheetLinkable
6968
6969 sheet::SheetLinkMode SAL_CALL ScTableSheetObj::getLinkMode()
6970 {
6971 SolarMutexGuard aGuard;
6972 sheet::SheetLinkMode eRet = sheet::SheetLinkMode_NONE;
6973 ScDocShell* pDocSh = GetDocShell();
6974 if ( pDocSh )
6975 {
6976 ScLinkMode nMode = pDocSh->GetDocument().GetLinkMode( GetTab_Impl() );
6977 if ( nMode == ScLinkMode::NORMAL )
6978 eRet = sheet::SheetLinkMode_NORMAL;
6979 else if ( nMode == ScLinkMode::VALUE )
6980 eRet = sheet::SheetLinkMode_VALUE;
6981 }
6982 return eRet;
6983 }
6984
6985 void SAL_CALL ScTableSheetObj::setLinkMode( sheet::SheetLinkMode nLinkMode )
6986 {
6987 SolarMutexGuard aGuard;
6988
6989 //! search for filter and options in old link
6990
6991 OUString aUrl(getLinkUrl());
6992 OUString aSheet(getLinkSheetName());
6993
6994 link( aUrl, aSheet, u""_ustr, u""_ustr, nLinkMode );
6995 }
6996
6997 OUString SAL_CALL ScTableSheetObj::getLinkUrl()
6998 {
6999 SolarMutexGuard aGuard;
7000 OUString aFile;
7001 ScDocShell* pDocSh = GetDocShell();
7002 if ( pDocSh )
7003 aFile = pDocSh->GetDocument().GetLinkDoc( GetTab_Impl() );
7004 return aFile;
7005 }
7006
7007 void SAL_CALL ScTableSheetObj::setLinkUrl( const OUString& aLinkUrl )
7008 {
7009 SolarMutexGuard aGuard;
7010
7011 //! search for filter and options in old link
7012
7013 sheet::SheetLinkMode eMode = getLinkMode();
7014 OUString aSheet(getLinkSheetName());
7015
7016 link( aLinkUrl, aSheet, u""_ustr, u""_ustr, eMode );
7017 }
7018
7019 OUString SAL_CALL ScTableSheetObj::getLinkSheetName()
7020 {
7021 SolarMutexGuard aGuard;
7022 OUString aSheet;
7023 ScDocShell* pDocSh = GetDocShell();
7024 if ( pDocSh )
7025 aSheet = pDocSh->GetDocument().GetLinkTab( GetTab_Impl() );
7026 return aSheet;
7027 }
7028
7029 void SAL_CALL ScTableSheetObj::setLinkSheetName( const OUString& aLinkSheetName )
7030 {
7031 SolarMutexGuard aGuard;
7032
7033 //! search for filter and options in old link
7034
7035 sheet::SheetLinkMode eMode = getLinkMode();
7036 OUString aUrl(getLinkUrl());
7037
7038 link( aUrl, aLinkSheetName, u""_ustr, u""_ustr, eMode );
7039 }
7040
7041 void SAL_CALL ScTableSheetObj::link( const OUString& aUrl, const OUString& aSheetName,
7042 const OUString& aFilterName, const OUString& aFilterOptions,
7043 sheet::SheetLinkMode nMode )
7044 {
7045 SolarMutexGuard aGuard;
7046 ScDocShell* pDocSh = GetDocShell();
7047 if ( !pDocSh )
7048 return;
7049
7050 ScDocument& rDoc = pDocSh->GetDocument();
7051 SCTAB nTab = GetTab_Impl();
7052
7053 OUString aFileString = aUrl;
7054 OUString aFilterString = aFilterName;
7055 OUString aOptString = aFilterOptions;
7056
7057 aFileString = ScGlobal::GetAbsDocName( aFileString, pDocSh );
7058 if (aFilterString.isEmpty())
7059 ScDocumentLoader::GetFilterName( aFileString, aFilterString, aOptString, true, false );
7060
7061 // remove application prefix from filter name here, so the filter options
7062 // aren't reset when the filter name is changed in ScTableLink::DataChanged
7063 ScDocumentLoader::RemoveAppPrefix( aFilterString );
7064
7065 ScLinkMode nLinkMode = ScLinkMode::NONE;
7066 if ( nMode == sheet::SheetLinkMode_NORMAL )
7067 nLinkMode = ScLinkMode::NORMAL;
7068 else if ( nMode == sheet::SheetLinkMode_VALUE )
7069 nLinkMode = ScLinkMode::VALUE;
7070
7071 rDoc.SetLink( nTab, nLinkMode, aFileString, aFilterString, aOptString, aSheetName, 0/*nRefresh*/ );
7072
7073 pDocSh->UpdateLinks(); // if needed add or delete link
7074 SfxBindings* pBindings = pDocSh->GetViewBindings();
7075 if (pBindings)
7076 pBindings->Invalidate(SID_LINKS);
7077
7078 //! undo of link data on the table
7079
7080 if ( !(nLinkMode != ScLinkMode::NONE && rDoc.IsExecuteLinkEnabled()) ) // update link
7081 return;
7082
7083 // Always update link also if already exists
7084 //! update only on the affected table???
7085
7086 sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
7087 sal_uInt16 nCount = pLinkManager->GetLinks().size();
7088 for ( sal_uInt16 i=0; i<nCount; i++ )
7089 {
7090 ::sfx2::SvBaseLink* pBase = pLinkManager->GetLinks()[i].get();
7091 if (auto pTabLink = dynamic_cast<ScTableLink*>( pBase))
7092 {
7093 if ( aFileString == pTabLink->GetFileName() )
7094 pTabLink->Update(); // include Paint&Undo
7095
7096 //! The file name should only exists once (?)
7097 }
7098 }
7099
7100 //! notify ScSheetLinkObj objects!!!
7101 }
7102
7103 // XSheetAuditing
7104
7105 sal_Bool SAL_CALL ScTableSheetObj::hideDependents( const table::CellAddress& aPosition )
7106 {
7107 SolarMutexGuard aGuard;
7108 ScDocShell* pDocSh = GetDocShell();
7109 if ( pDocSh )
7110 {
7111 SCTAB nTab = GetTab_Impl();
7112 OSL_ENSURE( aPosition.Sheet == nTab, "wrong table in CellAddress" );
7113 ScAddress aPos( static_cast<SCCOL>(aPosition.Column), static_cast<SCROW>(aPosition.Row), nTab );
7114 return pDocSh->GetDocFunc().DetectiveDelSucc( aPos );
7115 }
7116 return false;
7117 }
7118
7119 sal_Bool SAL_CALL ScTableSheetObj::hidePrecedents( const table::CellAddress& aPosition )
7120 {
7121 SolarMutexGuard aGuard;
7122 ScDocShell* pDocSh = GetDocShell();
7123 if ( pDocSh )
7124 {
7125 SCTAB nTab = GetTab_Impl();
7126 OSL_ENSURE( aPosition.Sheet == nTab, "wrong table in CellAddress" );
7127 ScAddress aPos( static_cast<SCCOL>(aPosition.Column), static_cast<SCROW>(aPosition.Row), nTab );
7128 return pDocSh->GetDocFunc().DetectiveDelPred( aPos );
7129 }
7130 return false;
7131 }
7132
7133 sal_Bool SAL_CALL ScTableSheetObj::showDependents( const table::CellAddress& aPosition )
7134 {
7135 SolarMutexGuard aGuard;
7136 ScDocShell* pDocSh = GetDocShell();
7137 if ( pDocSh )
7138 {
7139 SCTAB nTab = GetTab_Impl();
7140 OSL_ENSURE( aPosition.Sheet == nTab, "wrong table in CellAddress" );
7141 ScAddress aPos( static_cast<SCCOL>(aPosition.Column), static_cast<SCROW>(aPosition.Row), nTab );
7142 return pDocSh->GetDocFunc().DetectiveAddSucc( aPos );
7143 }
7144 return false;
7145 }
7146
7147 sal_Bool SAL_CALL ScTableSheetObj::showPrecedents( const table::CellAddress& aPosition )
7148 {
7149 SolarMutexGuard aGuard;
7150 ScDocShell* pDocSh = GetDocShell();
7151 if ( pDocSh )
7152 {
7153 SCTAB nTab = GetTab_Impl();
7154 OSL_ENSURE( aPosition.Sheet == nTab, "wrong table in CellAddress" );
7155 ScAddress aPos( static_cast<SCCOL>(aPosition.Column), static_cast<SCROW>(aPosition.Row), nTab );
7156 return pDocSh->GetDocFunc().DetectiveAddPred( aPos );
7157 }
7158 return false;
7159 }
7160
7161 sal_Bool SAL_CALL ScTableSheetObj::showErrors( const table::CellAddress& aPosition )
7162 {
7163 SolarMutexGuard aGuard;
7164 ScDocShell* pDocSh = GetDocShell();
7165 if ( pDocSh )
7166 {
7167 SCTAB nTab = GetTab_Impl();
7168 OSL_ENSURE( aPosition.Sheet == nTab, "wrong table in CellAddress" );
7169 ScAddress aPos( static_cast<SCCOL>(aPosition.Column), static_cast<SCROW>(aPosition.Row), nTab );
7170 return pDocSh->GetDocFunc().DetectiveAddError( aPos );
7171 }
7172 return false;
7173 }
7174
7175 sal_Bool SAL_CALL ScTableSheetObj::showInvalid()
7176 {
7177 SolarMutexGuard aGuard;
7178 ScDocShell* pDocSh = GetDocShell();
7179 if ( pDocSh )
7180 return pDocSh->GetDocFunc().DetectiveMarkInvalid( GetTab_Impl() );
7181 return false;
7182 }
7183
7184 void SAL_CALL ScTableSheetObj::clearArrows()
7185 {
7186 SolarMutexGuard aGuard;
7187 ScDocShell* pDocSh = GetDocShell();
7188 if ( pDocSh )
7189 pDocSh->GetDocFunc().DetectiveDelAll( GetTab_Impl() );
7190 }
7191
7192 // XSheetOutline
7193
7194 void SAL_CALL ScTableSheetObj::group( const table::CellRangeAddress& rGroupRange,
7195 table::TableOrientation nOrientation )
7196 {
7197 SolarMutexGuard aGuard;
7198 ScDocShell* pDocSh = GetDocShell();
7199 if ( pDocSh )
7200 {
7201 bool bColumns = ( nOrientation == table::TableOrientation_COLUMNS );
7202 ScRange aGroupRange;
7203 ScUnoConversion::FillScRange( aGroupRange, rGroupRange );
7204 ScOutlineDocFunc aFunc(*pDocSh);
7205 aFunc.MakeOutline( aGroupRange, bColumns, true, true );
7206 }
7207 }
7208
7209 void SAL_CALL ScTableSheetObj::ungroup( const table::CellRangeAddress& rGroupRange,
7210 table::TableOrientation nOrientation )
7211 {
7212 SolarMutexGuard aGuard;
7213 ScDocShell* pDocSh = GetDocShell();
7214 if ( pDocSh )
7215 {
7216 bool bColumns = ( nOrientation == table::TableOrientation_COLUMNS );
7217 ScRange aGroupRange;
7218 ScUnoConversion::FillScRange( aGroupRange, rGroupRange );
7219 ScOutlineDocFunc aFunc(*pDocSh);
7220 aFunc.RemoveOutline( aGroupRange, bColumns, true, true );
7221 }
7222 }
7223
7224 void SAL_CALL ScTableSheetObj::autoOutline( const table::CellRangeAddress& rCellRange )
7225 {
7226 SolarMutexGuard aGuard;
7227 ScDocShell* pDocSh = GetDocShell();
7228 if ( pDocSh )
7229 {
7230 ScRange aFormulaRange;
7231 ScUnoConversion::FillScRange( aFormulaRange, rCellRange );
7232 ScOutlineDocFunc aFunc(*pDocSh);
7233 aFunc.AutoOutline( aFormulaRange, true );
7234 }
7235 }
7236
7237 void SAL_CALL ScTableSheetObj::clearOutline()
7238 {
7239 SolarMutexGuard aGuard;
7240 ScDocShell* pDocSh = GetDocShell();
7241 if ( pDocSh )
7242 {
7243 SCTAB nTab = GetTab_Impl();
7244 ScOutlineDocFunc aFunc(*pDocSh);
7245 aFunc.RemoveAllOutlines( nTab, true );
7246 }
7247 }
7248
7249 void SAL_CALL ScTableSheetObj::hideDetail( const table::CellRangeAddress& rCellRange )
7250 {
7251 SolarMutexGuard aGuard;
7252 ScDocShell* pDocSh = GetDocShell();
7253 if ( pDocSh )
7254 {
7255 ScRange aMarkRange;
7256 ScUnoConversion::FillScRange( aMarkRange, rCellRange );
7257 ScOutlineDocFunc aFunc(*pDocSh);
7258 aFunc.HideMarkedOutlines( aMarkRange, true );
7259 }
7260 }
7261
7262 void SAL_CALL ScTableSheetObj::showDetail( const table::CellRangeAddress& rCellRange )
7263 {
7264 SolarMutexGuard aGuard;
7265 ScDocShell* pDocSh = GetDocShell();
7266 if ( pDocSh )
7267 {
7268 ScRange aMarkRange;
7269 ScUnoConversion::FillScRange( aMarkRange, rCellRange );
7270 ScOutlineDocFunc aFunc(*pDocSh);
7271 aFunc.ShowMarkedOutlines( aMarkRange, true );
7272 }
7273 }
7274
7275 void SAL_CALL ScTableSheetObj::showLevel( sal_Int16 nLevel, table::TableOrientation nOrientation )
7276 {
7277 SolarMutexGuard aGuard;
7278 ScDocShell* pDocSh = GetDocShell();
7279 if ( pDocSh )
7280 {
7281 bool bColumns = ( nOrientation == table::TableOrientation_COLUMNS );
7282 SCTAB nTab = GetTab_Impl();
7283 ScOutlineDocFunc aFunc(*pDocSh);
7284 aFunc.SelectLevel( nTab, bColumns, nLevel, true, true );
7285 }
7286 }
7287
7288 // XProtectable
7289
7290 void SAL_CALL ScTableSheetObj::protect( const OUString& aPassword )
7291 {
7292 SolarMutexGuard aGuard;
7293 ScDocShell* pDocSh = GetDocShell();
7294 // #i108245# if already protected, don't change anything
7295 if ( pDocSh && !pDocSh->GetDocument().IsTabProtected( GetTab_Impl() ) )
7296 {
7297 pDocSh->GetDocFunc().Protect( GetTab_Impl(), aPassword );
7298 }
7299 }
7300
7301 void SAL_CALL ScTableSheetObj::unprotect( const OUString& aPassword )
7302 {
7303 SolarMutexGuard aGuard;
7304 ScDocShell* pDocSh = GetDocShell();
7305 if ( pDocSh )
7306 {
7307 bool bDone = pDocSh->GetDocFunc().Unprotect( GetTab_Impl(), aPassword, true );
7308 if (!bDone)
7309 throw lang::IllegalArgumentException();
7310 }
7311 }
7312
7313 sal_Bool SAL_CALL ScTableSheetObj::isProtected()
7314 {
7315 SolarMutexGuard aGuard;
7316 ScDocShell* pDocSh = GetDocShell();
7317 if ( pDocSh )
7318 return pDocSh->GetDocument().IsTabProtected( GetTab_Impl() );
7319
7320 OSL_FAIL("no DocShell"); //! Exception or so?
7321 return false;
7322 }
7323
7324 // XScenario
7325
7326 sal_Bool SAL_CALL ScTableSheetObj::getIsScenario()
7327 {
7328 SolarMutexGuard aGuard;
7329 ScDocShell* pDocSh = GetDocShell();
7330 if ( pDocSh )
7331 return pDocSh->GetDocument().IsScenario( GetTab_Impl() );
7332
7333 return false;
7334 }
7335
7336 OUString SAL_CALL ScTableSheetObj::getScenarioComment()
7337 {
7338 SolarMutexGuard aGuard;
7339 ScDocShell* pDocSh = GetDocShell();
7340 if ( pDocSh )
7341 {
7342 OUString aComment;
7343 Color aColor;
7344 ScScenarioFlags nFlags;
7345 pDocSh->GetDocument().GetScenarioData( GetTab_Impl(), aComment, aColor, nFlags );
7346 return aComment;
7347 }
7348 return OUString();
7349 }
7350
7351 void SAL_CALL ScTableSheetObj::setScenarioComment( const OUString& aScenarioComment )
7352 {
7353 SolarMutexGuard aGuard;
7354 ScDocShell* pDocSh = GetDocShell();
7355 if ( !pDocSh )
7356 return;
7357
7358 ScDocument& rDoc = pDocSh->GetDocument();
7359 SCTAB nTab = GetTab_Impl();
7360
7361 OUString aName;
7362 OUString aComment;
7363 Color aColor;
7364 ScScenarioFlags nFlags;
7365 rDoc.GetName( nTab, aName );
7366 rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
7367
7368 aComment = aScenarioComment;
7369
7370 pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
7371 }
7372
7373 void SAL_CALL ScTableSheetObj::addRanges( const uno::Sequence<table::CellRangeAddress>& rScenRanges )
7374 {
7375 SolarMutexGuard aGuard;
7376 ScDocShell* pDocSh = GetDocShell();
7377 if ( !pDocSh )
7378 return;
7379
7380 ScDocument& rDoc = pDocSh->GetDocument();
7381 SCTAB nTab = GetTab_Impl();
7382
7383 if (!rDoc.IsScenario(nTab))
7384 return;
7385
7386 ScMarkData aMarkData(rDoc.GetSheetLimits());
7387 aMarkData.SelectTable( nTab, true );
7388
7389 for (const table::CellRangeAddress& rRange : rScenRanges)
7390 {
7391 OSL_ENSURE( rRange.Sheet == nTab, "addRanges with wrong Tab" );
7392 ScRange aOneRange( static_cast<SCCOL>(rRange.StartColumn), static_cast<SCROW>(rRange.StartRow), nTab,
7393 static_cast<SCCOL>(rRange.EndColumn), static_cast<SCROW>(rRange.EndRow), nTab );
7394
7395 aMarkData.SetMultiMarkArea( aOneRange );
7396 }
7397
7398 // Scenario ranges are tagged with attribute
7399 ScPatternAttr aPattern(rDoc.getCellAttributeHelper());
7400 aPattern.GetItemSet().Put( ScMergeFlagAttr( ScMF::Scenario ) );
7401 aPattern.GetItemSet().Put( ScProtectionAttr( true ) );
7402 pDocSh->GetDocFunc().ApplyAttributes( aMarkData, aPattern, true );
7403 }
7404
7405 void SAL_CALL ScTableSheetObj::apply()
7406 {
7407 SolarMutexGuard aGuard;
7408 ScDocShell* pDocSh = GetDocShell();
7409 if ( !pDocSh )
7410 return;
7411
7412 ScDocument& rDoc = pDocSh->GetDocument();
7413 SCTAB nTab = GetTab_Impl();
7414 OUString aName;
7415 rDoc.GetName( nTab, aName ); // scenario name
7416
7417 SCTAB nDestTab = nTab;
7418 while ( nDestTab > 0 && rDoc.IsScenario(nDestTab) )
7419 --nDestTab;
7420
7421 if ( !rDoc.IsScenario(nDestTab) )
7422 pDocSh->UseScenario( nDestTab, aName );
7423
7424 //! otherwise error or so
7425 }
7426
7427 // XScenarioEnhanced
7428
7429 uno::Sequence< table::CellRangeAddress > SAL_CALL ScTableSheetObj::getRanges( )
7430 {
7431 SolarMutexGuard aGuard;
7432 ScDocShell* pDocSh = GetDocShell();
7433 if ( pDocSh )
7434 {
7435 ScDocument& rDoc = pDocSh->GetDocument();
7436 SCTAB nTab = GetTab_Impl();
7437 const ScRangeList* pRangeList = rDoc.GetScenarioRanges(nTab);
7438 if (pRangeList)
7439 {
7440 size_t nCount = pRangeList->size();
7441 uno::Sequence< table::CellRangeAddress > aRetRanges( nCount );
7442 table::CellRangeAddress* pAry = aRetRanges.getArray();
7443 for( size_t nIndex = 0; nIndex < nCount; nIndex++ )
7444 {
7445 const ScRange & rRange = (*pRangeList)[nIndex];
7446 pAry->StartColumn = rRange.aStart.Col();
7447 pAry->StartRow = rRange.aStart.Row();
7448 pAry->EndColumn = rRange.aEnd.Col();
7449 pAry->EndRow = rRange.aEnd.Row();
7450 pAry->Sheet = rRange.aStart.Tab();
7451 ++pAry;
7452 }
7453 return aRetRanges;
7454 }
7455 }
7456 return uno::Sequence< table::CellRangeAddress > ();
7457 }
7458
7459 // XExternalSheetName
7460
7461 void ScTableSheetObj::setExternalName( const OUString& aUrl, const OUString& aSheetName )
7462 {
7463 SolarMutexGuard aGuard;
7464 ScDocShell* pDocSh = GetDocShell();
7465 if ( pDocSh )
7466 {
7467 ScDocument& rDoc = pDocSh->GetDocument();
7468 const SCTAB nTab = GetTab_Impl();
7469 const OUString aAbsDocName( ScGlobal::GetAbsDocName( aUrl, pDocSh ) );
7470 const OUString aDocTabName( ScGlobal::GetDocTabName( aAbsDocName, aSheetName ) );
7471 if ( !rDoc.RenameTab( nTab, aDocTabName, true /*bExternalDocument*/ ) )
7472 {
7473 throw container::ElementExistException( OUString(), *this );
7474 }
7475 }
7476 }
7477
7478 // XEventsSupplier
7479
7480 uno::Reference<container::XNameReplace> SAL_CALL ScTableSheetObj::getEvents()
7481 {
7482 SolarMutexGuard aGuard;
7483 ScDocShell* pDocSh = GetDocShell();
7484 if ( pDocSh )
7485 return new ScSheetEventsObj( pDocSh, GetTab_Impl() );
7486
7487 return nullptr;
7488 }
7489
7490 // XPropertySet extended for Sheet-Properties
7491
7492 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTableSheetObj::getPropertySetInfo()
7493 {
7494 SolarMutexGuard aGuard;
7495 static uno::Reference<beans::XPropertySetInfo> aRef(
7496 new SfxItemPropertySetInfo( pSheetPropSet->getPropertyMap() ));
7497 return aRef;
7498 }
7499
7500 void ScTableSheetObj::SetOnePropertyValue( const SfxItemPropertyMapEntry* pEntry, const uno::Any& aValue )
7501 {
7502 if ( !pEntry )
7503 return;
7504
7505 if ( IsScItemWid( pEntry->nWID ) )
7506 {
7507 // for Item WIDs, call ScCellRangesBase directly
7508 ScCellRangesBase::SetOnePropertyValue(pEntry, aValue);
7509 return;
7510 }
7511
7512 // own properties
7513
7514 ScDocShell* pDocSh = GetDocShell();
7515 if (!pDocSh)
7516 return; //! Exception or so?
7517 ScDocument& rDoc = pDocSh->GetDocument();
7518 SCTAB nTab = GetTab_Impl();
7519 ScDocFunc &rFunc = pDocSh->GetDocFunc();
7520
7521 if ( pEntry->nWID == SC_WID_UNO_PAGESTL )
7522 {
7523 OUString aStrVal;
7524 aValue >>= aStrVal;
7525 OUString aNewStr(ScStyleNameConversion::ProgrammaticToDisplayName(
7526 aStrVal, SfxStyleFamily::Page ));
7527
7528 //! Undo? (also if SID_STYLE_APPLY on View)
7529
7530 if ( rDoc.GetPageStyle( nTab ) != aNewStr )
7531 {
7532 rDoc.SetPageStyle( nTab, aNewStr );
7533 if (!rDoc.IsImportingXML())
7534 {
7535 ScPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab ).UpdatePages();
7536
7537 SfxBindings* pBindings = pDocSh->GetViewBindings();
7538 if (pBindings)
7539 {
7540 pBindings->Invalidate( SID_STYLE_FAMILY4 );
7541 pBindings->Invalidate( SID_STATUS_PAGESTYLE );
7542 pBindings->Invalidate( FID_RESET_PRINTZOOM );
7543 pBindings->Invalidate( SID_ATTR_PARA_LEFT_TO_RIGHT );
7544 pBindings->Invalidate( SID_ATTR_PARA_RIGHT_TO_LEFT );
7545 }
7546 }
7547 pDocSh->SetDocumentModified();
7548 }
7549 }
7550 else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
7551 {
7552 bool bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue );
7553 rFunc.SetTableVisible( nTab, bVis, true );
7554 }
7555 else if ( pEntry->nWID == SC_WID_UNO_ISACTIVE )
7556 {
7557 if (rDoc.IsScenario(nTab))
7558 rDoc.SetActiveScenario( nTab, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
7559 }
7560 else if ( pEntry->nWID == SC_WID_UNO_BORDCOL )
7561 {
7562 if (rDoc.IsScenario(nTab))
7563 {
7564 Color aColor;
7565 if (aValue >>= aColor)
7566 {
7567 OUString aName;
7568 OUString aComment;
7569 ScScenarioFlags nFlags;
7570 Color aTmp;
7571 rDoc.GetName( nTab, aName );
7572 rDoc.GetScenarioData( nTab, aComment, aTmp, nFlags );
7573
7574 pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
7575 }
7576 }
7577 }
7578 else if ( pEntry->nWID == SC_WID_UNO_PROTECT )
7579 {
7580 if (rDoc.IsScenario(nTab))
7581 {
7582 OUString aName;
7583 OUString aComment;
7584 Color aColor;
7585 ScScenarioFlags nFlags;
7586 rDoc.GetName( nTab, aName );
7587 rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
7588 bool bModify(false);
7589
7590 if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
7591 {
7592 if (!(nFlags & ScScenarioFlags::Protected))
7593 {
7594 nFlags |= ScScenarioFlags::Protected;
7595 bModify = true;
7596 }
7597 }
7598 else
7599 {
7600 if (nFlags & ScScenarioFlags::Protected)
7601 {
7602 nFlags &= ~ScScenarioFlags::Protected;
7603 bModify = true;
7604 }
7605 }
7606
7607 if (bModify)
7608 pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
7609 }
7610 }
7611 else if ( pEntry->nWID == SC_WID_UNO_SHOWBORD )
7612 {
7613 if (rDoc.IsScenario(nTab))
7614 {
7615 OUString aName;
7616 OUString aComment;
7617 Color aColor;
7618 ScScenarioFlags nFlags;
7619 rDoc.GetName( nTab, aName );
7620 rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
7621 bool bModify(false);
7622
7623 if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
7624 {
7625 if (!(nFlags & ScScenarioFlags::ShowFrame))
7626 {
7627 nFlags |= ScScenarioFlags::ShowFrame;
7628 bModify = true;
7629 }
7630 }
7631 else
7632 {
7633 if (nFlags & ScScenarioFlags::ShowFrame)
7634 {
7635 nFlags &= ~ScScenarioFlags::ShowFrame;
7636 bModify = true;
7637 }
7638 }
7639
7640 if (bModify)
7641 pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
7642 }
7643 }
7644 else if ( pEntry->nWID == SC_WID_UNO_PRINTBORD )
7645 {
7646 if (rDoc.IsScenario(nTab))
7647 {
7648 OUString aName;
7649 OUString aComment;
7650 Color aColor;
7651 ScScenarioFlags nFlags;
7652 rDoc.GetName( nTab, aName );
7653 rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
7654 bool bModify(false);
7655
7656 if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
7657 {
7658 if (!(nFlags & ScScenarioFlags::PrintFrame))
7659 {
7660 nFlags |= ScScenarioFlags::PrintFrame;
7661 bModify = true;
7662 }
7663 }
7664 else
7665 {
7666 if (nFlags & ScScenarioFlags::PrintFrame)
7667 {
7668 nFlags &= ~ScScenarioFlags::PrintFrame;
7669 bModify = true;
7670 }
7671 }
7672
7673 if (bModify)
7674 pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
7675 }
7676 }
7677 else if ( pEntry->nWID == SC_WID_UNO_COPYBACK )
7678 {
7679 if (rDoc.IsScenario(nTab))
7680 {
7681 OUString aName;
7682 OUString aComment;
7683 Color aColor;
7684 ScScenarioFlags nFlags;
7685 rDoc.GetName( nTab, aName );
7686 rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
7687 bool bModify(false);
7688
7689 if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
7690 {
7691 if (!(nFlags & ScScenarioFlags::TwoWay))
7692 {
7693 nFlags |= ScScenarioFlags::TwoWay;
7694 bModify = true;
7695 }
7696 }
7697 else
7698 {
7699 if (nFlags & ScScenarioFlags::TwoWay)
7700 {
7701 nFlags &= ~ScScenarioFlags::TwoWay;
7702 bModify = true;
7703 }
7704 }
7705
7706 if (bModify)
7707 pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
7708 }
7709 }
7710 else if ( pEntry->nWID == SC_WID_UNO_COPYSTYL )
7711 {
7712 if (rDoc.IsScenario(nTab))
7713 {
7714 OUString aName;
7715 OUString aComment;
7716 Color aColor;
7717 ScScenarioFlags nFlags;
7718 rDoc.GetName( nTab, aName );
7719 rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
7720 bool bModify(false);
7721
7722 if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
7723 {
7724 if (!(nFlags & ScScenarioFlags::Attrib))
7725 {
7726 nFlags |= ScScenarioFlags::Attrib;
7727 bModify = true;
7728 }
7729 }
7730 else
7731 {
7732 if (nFlags & ScScenarioFlags::Attrib)
7733 {
7734 nFlags &= ~ScScenarioFlags::Attrib;
7735 bModify = true;
7736 }
7737 }
7738
7739 if (bModify)
7740 pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
7741 }
7742 }
7743 else if ( pEntry->nWID == SC_WID_UNO_COPYFORM )
7744 {
7745 if (rDoc.IsScenario(nTab))
7746 {
7747 OUString aName;
7748 OUString aComment;
7749 Color aColor;
7750 ScScenarioFlags nFlags;
7751 rDoc.GetName( nTab, aName );
7752 rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
7753 bool bModify(false);
7754
7755 if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
7756 {
7757 if (nFlags & ScScenarioFlags::Value)
7758 {
7759 nFlags &= ~ScScenarioFlags::Value;
7760 bModify = true;
7761 }
7762 }
7763 else
7764 {
7765 if (!(nFlags & ScScenarioFlags::Value))
7766 {
7767 nFlags |= ScScenarioFlags::Value;
7768 bModify = true;
7769 }
7770 }
7771
7772 if (bModify)
7773 pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
7774 }
7775 }
7776 else if ( pEntry->nWID == SC_WID_UNO_TABLAYOUT )
7777 {
7778 sal_Int16 nValue = 0;
7779 if (aValue >>= nValue)
7780 {
7781 if (nValue == css::text::WritingMode2::RL_TB)
7782 rFunc.SetLayoutRTL(nTab, true);
7783 else
7784 rFunc.SetLayoutRTL(nTab, false);
7785 }
7786 }
7787 else if ( pEntry->nWID == SC_WID_UNO_AUTOPRINT )
7788 {
7789 bool bAutoPrint = ScUnoHelpFunctions::GetBoolFromAny( aValue );
7790 if (bAutoPrint)
7791 rDoc.SetPrintEntireSheet( nTab ); // clears all print ranges
7792 else
7793 {
7794 if (rDoc.IsPrintEntireSheet( nTab ))
7795 rDoc.ClearPrintRanges( nTab ); // if this flag is true, there are no PrintRanges, so Clear clears only the flag.
7796 }
7797 }
7798 else if ( pEntry->nWID == SC_WID_UNO_TABCOLOR )
7799 {
7800 Color aColor = COL_AUTO;
7801 if ( aValue >>= aColor )
7802 {
7803 if ( rDoc.GetTabBgColor( nTab ) != aColor )
7804 rFunc.SetTabBgColor( nTab, aColor, true, true );
7805 }
7806 }
7807 else if ( pEntry->nWID == SC_WID_UNO_CODENAME )
7808 {
7809 OUString aCodeName;
7810 if (aValue >>= aCodeName)
7811 {
7812 pDocSh->GetDocument().SetCodeName( GetTab_Impl(), aCodeName );
7813 }
7814 }
7815 else if (pEntry->nWID == SC_WID_UNO_CONDFORMAT)
7816 {
7817 uno::Reference<sheet::XConditionalFormats> xCondFormat;
7818 if (aValue >>= xCondFormat)
7819 {
7820 // how to set the format correctly
7821 }
7822 }
7823 else if (pEntry->nWID == SC_WID_UNO_TOTALBELOW)
7824 {
7825 bool bTotalsRowBelow = ScUnoHelpFunctions::GetBoolFromAny(aValue);
7826 rDoc.SetTotalsRowBelow(nTab, bTotalsRowBelow);
7827 }
7828 else
7829 ScCellRangeObj::SetOnePropertyValue(pEntry, aValue); // base class, no Item WID
7830 }
7831
7832 void ScTableSheetObj::GetOnePropertyValue( const SfxItemPropertyMapEntry* pEntry,
7833 uno::Any& rAny )
7834 {
7835 if ( !pEntry )
7836 return;
7837
7838 ScDocShell* pDocSh = GetDocShell();
7839 if (!pDocSh)
7840 throw uno::RuntimeException();
7841 ScDocument& rDoc = pDocSh->GetDocument();
7842 SCTAB nTab = GetTab_Impl();
7843
7844 if ( pEntry->nWID == SC_WID_UNO_NAMES )
7845 {
7846 rAny <<= uno::Reference<sheet::XNamedRanges>(new ScLocalNamedRangesObj(pDocSh, this));
7847 }
7848 else if ( pEntry->nWID == SC_WID_UNO_PAGESTL )
7849 {
7850 rAny <<= ScStyleNameConversion::DisplayToProgrammaticName(
7851 rDoc.GetPageStyle( nTab ), SfxStyleFamily::Page );
7852 }
7853 else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
7854 {
7855 bool bVis = rDoc.IsVisible( nTab );
7856 rAny <<= bVis;
7857 }
7858 else if ( pEntry->nWID == SC_WID_UNO_LINKDISPBIT )
7859 {
7860 // no target bitmaps for individual entries (would be all equal)
7861 // ScLinkTargetTypeObj::SetLinkTargetBitmap( aAny, SC_LINKTARGETTYPE_SHEET );
7862 }
7863 else if ( pEntry->nWID == SC_WID_UNO_LINKDISPNAME )
7864 {
7865 // LinkDisplayName for hyperlink dialog
7866 rAny <<= getName(); // sheet name
7867 }
7868 else if ( pEntry->nWID == SC_WID_UNO_ISACTIVE )
7869 {
7870 if (rDoc.IsScenario(nTab))
7871 rAny <<= rDoc.IsActiveScenario( nTab );
7872 }
7873 else if ( pEntry->nWID == SC_WID_UNO_BORDCOL )
7874 {
7875 if (rDoc.IsScenario(nTab))
7876 {
7877 OUString aComment;
7878 Color aColor;
7879 ScScenarioFlags nFlags;
7880 rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
7881
7882 rAny <<= aColor;
7883 }
7884 }
7885 else if ( pEntry->nWID == SC_WID_UNO_PROTECT )
7886 {
7887 if (rDoc.IsScenario(nTab))
7888 {
7889 ScScenarioFlags nFlags;
7890 rDoc.GetScenarioFlags(nTab, nFlags);
7891
7892 rAny <<= ((nFlags & ScScenarioFlags::Protected) != ScScenarioFlags::NONE);
7893 }
7894 }
7895 else if ( pEntry->nWID == SC_WID_UNO_SHOWBORD )
7896 {
7897 if (rDoc.IsScenario(nTab))
7898 {
7899 ScScenarioFlags nFlags;
7900 rDoc.GetScenarioFlags(nTab, nFlags);
7901
7902 rAny <<= ((nFlags & ScScenarioFlags::ShowFrame) != ScScenarioFlags::NONE);
7903 }
7904 }
7905 else if ( pEntry->nWID == SC_WID_UNO_PRINTBORD )
7906 {
7907 if (rDoc.IsScenario(nTab))
7908 {
7909 ScScenarioFlags nFlags;
7910 rDoc.GetScenarioFlags(nTab, nFlags);
7911
7912 rAny <<= ((nFlags & ScScenarioFlags::PrintFrame) != ScScenarioFlags::NONE);
7913 }
7914 }
7915 else if ( pEntry->nWID == SC_WID_UNO_COPYBACK )
7916 {
7917 if (rDoc.IsScenario(nTab))
7918 {
7919 ScScenarioFlags nFlags;
7920 rDoc.GetScenarioFlags(nTab, nFlags);
7921
7922 rAny <<= ((nFlags & ScScenarioFlags::TwoWay) != ScScenarioFlags::NONE);
7923 }
7924 }
7925 else if ( pEntry->nWID == SC_WID_UNO_COPYSTYL )
7926 {
7927 if (rDoc.IsScenario(nTab))
7928 {
7929 ScScenarioFlags nFlags;
7930 rDoc.GetScenarioFlags(nTab, nFlags);
7931
7932 rAny <<= ((nFlags & ScScenarioFlags::Attrib) != ScScenarioFlags::NONE);
7933 }
7934 }
7935 else if ( pEntry->nWID == SC_WID_UNO_COPYFORM )
7936 {
7937 if (rDoc.IsScenario(nTab))
7938 {
7939 ScScenarioFlags nFlags;
7940 rDoc.GetScenarioFlags(nTab, nFlags);
7941
7942 rAny <<= !(nFlags & ScScenarioFlags::Value);
7943 }
7944 }
7945 else if ( pEntry->nWID == SC_WID_UNO_TABLAYOUT )
7946 {
7947 if (rDoc.IsLayoutRTL(nTab))
7948 rAny <<= sal_Int16(css::text::WritingMode2::RL_TB);
7949 else
7950 rAny <<= sal_Int16(css::text::WritingMode2::LR_TB);
7951 }
7952 else if ( pEntry->nWID == SC_WID_UNO_AUTOPRINT )
7953 {
7954 bool bAutoPrint = rDoc.IsPrintEntireSheet( nTab );
7955 rAny <<= bAutoPrint;
7956 }
7957 else if ( pEntry->nWID == SC_WID_UNO_TABCOLOR )
7958 {
7959 rAny <<= rDoc.GetTabBgColor(nTab);
7960 }
7961 else if ( pEntry->nWID == SC_WID_UNO_CODENAME )
7962 {
7963 OUString aCodeName;
7964 pDocSh->GetDocument().GetCodeName(GetTab_Impl(), aCodeName);
7965 rAny <<= aCodeName;
7966 }
7967 else if (pEntry->nWID == SC_WID_UNO_CONDFORMAT)
7968 {
7969 rAny <<= uno::Reference<sheet::XConditionalFormats>(new ScCondFormatsObj(pDocSh, nTab));
7970 }
7971 else if (pEntry->nWID == SC_WID_UNO_SOLVERSETTINGS)
7972 {
7973 rAny <<= uno::Reference<sheet::XSolverSettings>(new ScSolverSettings(pDocSh, this));
7974 }
7975 else
7976 ScCellRangeObj::GetOnePropertyValue(pEntry, rAny);
7977 }
7978
7979 const SfxItemPropertyMap& ScTableSheetObj::GetItemPropertyMap()
7980 {
7981 return pSheetPropSet->getPropertyMap();
7982 }
7983
7984 // XServiceInfo
7985
7986 OUString SAL_CALL ScTableSheetObj::getImplementationName()
7987 {
7988 return u"ScTableSheetObj"_ustr;
7989 }
7990
7991 sal_Bool SAL_CALL ScTableSheetObj::supportsService( const OUString& rServiceName )
7992 {
7993 return cppu::supportsService(this, rServiceName);
7994 }
7995
7996 uno::Sequence<OUString> SAL_CALL ScTableSheetObj::getSupportedServiceNames()
7997 {
7998 return {SCSPREADSHEET_SERVICE,
7999 SCSHEETCELLRANGE_SERVICE,
8000 SCCELLRANGE_SERVICE,
8001 SCCELLPROPERTIES_SERVICE,
8002 SCCHARPROPERTIES_SERVICE,
8003 SCPARAPROPERTIES_SERVICE,
8004 SCLINKTARGET_SERVICE};
8005 }
8006
8007 ScTableColumnObj::ScTableColumnObj( ScDocShell* pDocSh, SCCOL nCol, SCTAB nTab ) :
8008 ScTableColumnObj_BASE( pDocSh, ScRange(nCol,0,nTab, nCol, pDocSh->GetDocument().MaxRow(),nTab) ),
8009 pColPropSet(lcl_GetColumnPropertySet())
8010 {
8011 }
8012
8013 ScTableColumnObj::~ScTableColumnObj()
8014 {
8015 }
8016
8017 // XNamed
8018
8019 OUString SAL_CALL ScTableColumnObj::getName()
8020 {
8021 SolarMutexGuard aGuard;
8022
8023 const ScRange& rRange = GetRange();
8024 OSL_ENSURE(rRange.aStart.Col() == rRange.aEnd.Col(), "too many columns");
8025 SCCOL nCol = rRange.aStart.Col();
8026
8027 return ScColToAlpha( nCol ); // from global.hxx
8028 }
8029
8030 void SAL_CALL ScTableColumnObj::setName( const OUString& /* aNewName */ )
8031 {
8032 throw uno::RuntimeException(); // read-only
8033 }
8034
8035 // XPropertySet extended for Column-Properties
8036
8037 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTableColumnObj::getPropertySetInfo()
8038 {
8039 SolarMutexGuard aGuard;
8040 static uno::Reference<beans::XPropertySetInfo> aRef(
8041 new SfxItemPropertySetInfo( pColPropSet->getPropertyMap() ));
8042 return aRef;
8043 }
8044
8045 void ScTableColumnObj::SetOnePropertyValue(const SfxItemPropertyMapEntry* pEntry, const uno::Any& aValue)
8046 {
8047 if ( !pEntry )
8048 return;
8049
8050 if ( IsScItemWid( pEntry->nWID ) )
8051 {
8052 // for Item WIDs, call ScCellRangesBase directly
8053 ScCellRangesBase::SetOnePropertyValue(pEntry, aValue);
8054 return;
8055 }
8056
8057 // own properties
8058
8059 ScDocShell* pDocSh = GetDocShell();
8060 if (!pDocSh)
8061 return; //! Exception or so?
8062 const ScRange& rRange = GetRange();
8063 OSL_ENSURE(rRange.aStart.Col() == rRange.aEnd.Col(), "Too many columns");
8064 SCCOL nCol = rRange.aStart.Col();
8065 SCTAB nTab = rRange.aStart.Tab();
8066 ScDocFunc &rFunc = pDocSh->GetDocFunc();
8067
8068 std::vector<sc::ColRowSpan> aColArr(1, sc::ColRowSpan(nCol,nCol));
8069
8070 if ( pEntry->nWID == SC_WID_UNO_CELLWID )
8071 {
8072 sal_Int32 nNewWidth = 0;
8073 if ( aValue >>= nNewWidth )
8074 {
8075 // property is 1/100mm, column width is twips
8076 nNewWidth = o3tl::toTwips(nNewWidth, o3tl::Length::mm100);
8077 rFunc.SetWidthOrHeight(
8078 true, aColArr, nTab, SC_SIZE_ORIGINAL, nNewWidth, true, true);
8079 }
8080 }
8081 else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
8082 {
8083 bool bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8084 ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT;
8085 rFunc.SetWidthOrHeight(true, aColArr, nTab, eMode, 0, true, true);
8086 // SC_SIZE_DIRECT with size 0 will hide
8087 }
8088 else if ( pEntry->nWID == SC_WID_UNO_OWIDTH )
8089 {
8090 bool bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8091 if (bOpt)
8092 rFunc.SetWidthOrHeight(
8093 true, aColArr, nTab, SC_SIZE_OPTIMAL, STD_EXTRA_WIDTH, true, true);
8094 // sal_False on columns currently without effect
8095 }
8096 else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE || pEntry->nWID == SC_WID_UNO_MANPAGE )
8097 {
8098 bool bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8099 if (bSet)
8100 rFunc.InsertPageBreak( true, rRange.aStart, true, true );
8101 else
8102 rFunc.RemovePageBreak( true, rRange.aStart, true, true );
8103 }
8104 else
8105 ScCellRangeObj::SetOnePropertyValue(pEntry, aValue); // base class, no Item WID
8106 }
8107
8108 void ScTableColumnObj::GetOnePropertyValue( const SfxItemPropertyMapEntry* pEntry, uno::Any& rAny )
8109 {
8110 if ( !pEntry )
8111 return;
8112
8113 ScDocShell* pDocSh = GetDocShell();
8114 if (!pDocSh)
8115 throw uno::RuntimeException();
8116
8117 ScDocument& rDoc = pDocSh->GetDocument();
8118 const ScRange& rRange = GetRange();
8119 OSL_ENSURE(rRange.aStart.Col() == rRange.aEnd.Col(), "too many columns");
8120 SCCOL nCol = rRange.aStart.Col();
8121 SCTAB nTab = rRange.aStart.Tab();
8122
8123 if ( pEntry->nWID == SC_WID_UNO_CELLWID )
8124 {
8125 // for hidden column, return original height
8126 sal_uInt16 nWidth = rDoc.GetOriginalWidth( nCol, nTab );
8127 // property is 1/100mm, column width is twips
8128 rAny <<= static_cast<sal_Int32>(convertTwipToMm100(nWidth));
8129 }
8130 else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
8131 {
8132 bool bHidden = rDoc.ColHidden(nCol, nTab);
8133 rAny <<= !bHidden;
8134 }
8135 else if ( pEntry->nWID == SC_WID_UNO_OWIDTH )
8136 {
8137 //! at the moment always set ??!?!
8138 bool bOpt = !(rDoc.GetColFlags( nCol, nTab ) & CRFlags::ManualSize);
8139 rAny <<= bOpt;
8140 }
8141 else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE )
8142 {
8143 ScBreakType nBreak = rDoc.HasColBreak(nCol, nTab);
8144 rAny <<= nBreak != ScBreakType::NONE;
8145 }
8146 else if ( pEntry->nWID == SC_WID_UNO_MANPAGE )
8147 {
8148 ScBreakType nBreak = rDoc.HasColBreak(nCol, nTab);
8149 rAny <<= bool(nBreak & ScBreakType::Manual);
8150 }
8151 else
8152 ScCellRangeObj::GetOnePropertyValue(pEntry, rAny);
8153 }
8154
8155 const SfxItemPropertyMap& ScTableColumnObj::GetItemPropertyMap()
8156 {
8157 return pColPropSet->getPropertyMap();
8158 }
8159
8160 ScTableRowObj::ScTableRowObj(ScDocShell* pDocSh, SCROW nRow, SCTAB nTab) :
8161 ScCellRangeObj( pDocSh, ScRange(0,nRow,nTab, pDocSh->GetDocument().MaxCol(),nRow,nTab) ),
8162 pRowPropSet(lcl_GetRowPropertySet())
8163 {
8164 }
8165
8166 ScTableRowObj::~ScTableRowObj()
8167 {
8168 }
8169
8170 // XPropertySet extended for Row-Properties
8171
8172 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTableRowObj::getPropertySetInfo()
8173 {
8174 SolarMutexGuard aGuard;
8175 static uno::Reference<beans::XPropertySetInfo> aRef(
8176 new SfxItemPropertySetInfo( pRowPropSet->getPropertyMap() ));
8177 return aRef;
8178 }
8179
8180 void ScTableRowObj::SetOnePropertyValue( const SfxItemPropertyMapEntry* pEntry, const uno::Any& aValue )
8181 {
8182 if ( !pEntry )
8183 return;
8184
8185 if ( IsScItemWid( pEntry->nWID ) )
8186 {
8187 // for Item WIDs, call ScCellRangesBase directly
8188 ScCellRangesBase::SetOnePropertyValue(pEntry, aValue);
8189 return;
8190 }
8191
8192 // own properties
8193
8194 ScDocShell* pDocSh = GetDocShell();
8195 if (!pDocSh)
8196 return; //! Exception or so?
8197 ScDocument& rDoc = pDocSh->GetDocument();
8198 const ScRange& rRange = GetRange();
8199 OSL_ENSURE(rRange.aStart.Row() == rRange.aEnd.Row(), "too many rows");
8200 SCROW nRow = rRange.aStart.Row();
8201 SCTAB nTab = rRange.aStart.Tab();
8202 ScDocFunc &rFunc = pDocSh->GetDocFunc();
8203
8204 std::vector<sc::ColRowSpan> aRowArr(1, sc::ColRowSpan(nRow,nRow));
8205
8206 if ( pEntry->nWID == SC_WID_UNO_CELLHGT )
8207 {
8208 sal_Int32 nNewHeight = 0;
8209 if ( aValue >>= nNewHeight )
8210 {
8211 // property is 1/100mm, row height is twips
8212 nNewHeight = o3tl::toTwips(nNewHeight, o3tl::Length::mm100);
8213 rFunc.SetWidthOrHeight(
8214 false, aRowArr, nTab, SC_SIZE_ORIGINAL, nNewHeight, true, true);
8215 }
8216 }
8217 else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
8218 {
8219 bool bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8220 ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT;
8221 rFunc.SetWidthOrHeight(false, aRowArr, nTab, eMode, 0, true, true);
8222 // SC_SIZE_DIRECT with size zero will hide
8223 }
8224 else if ( pEntry->nWID == SC_WID_UNO_CELLFILT )
8225 {
8226 bool bFil = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8227 // SC_SIZE_DIRECT with size zero will hide
8228 rDoc.SetRowFiltered(nRow, nRow, nTab, bFil);
8229 }
8230 else if ( pEntry->nWID == SC_WID_UNO_OHEIGHT )
8231 {
8232 bool bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8233 if (bOpt)
8234 rFunc.SetWidthOrHeight(false, aRowArr, nTab, SC_SIZE_OPTIMAL, 0, true, true);
8235 else
8236 {
8237 // set current height again manually
8238 sal_uInt16 nHeight = rDoc.GetOriginalHeight( nRow, nTab );
8239 rFunc.SetWidthOrHeight(false, aRowArr, nTab, SC_SIZE_ORIGINAL, nHeight, true, true);
8240 }
8241 }
8242 else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE || pEntry->nWID == SC_WID_UNO_MANPAGE )
8243 {
8244 bool bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8245 if (bSet)
8246 rFunc.InsertPageBreak( false, rRange.aStart, true, true );
8247 else
8248 rFunc.RemovePageBreak( false, rRange.aStart, true, true );
8249 }
8250 else
8251 ScCellRangeObj::SetOnePropertyValue(pEntry, aValue); // base class, no Item WID
8252 }
8253
8254 void ScTableRowObj::GetOnePropertyValue( const SfxItemPropertyMapEntry* pEntry, uno::Any& rAny )
8255 {
8256 if ( !pEntry )
8257 return;
8258
8259 ScDocShell* pDocSh = GetDocShell();
8260 if (!pDocSh)
8261 throw uno::RuntimeException();
8262 ScDocument& rDoc = pDocSh->GetDocument();
8263 const ScRange& rRange = GetRange();
8264 OSL_ENSURE(rRange.aStart.Row() == rRange.aEnd.Row(), "too many rows");
8265 SCROW nRow = rRange.aStart.Row();
8266 SCTAB nTab = rRange.aStart.Tab();
8267
8268 if ( pEntry->nWID == SC_WID_UNO_CELLHGT )
8269 {
8270 // for hidden row, return original height
8271 sal_uInt16 nHeight = rDoc.GetOriginalHeight( nRow, nTab );
8272 // property is 1/100mm, row height is twips
8273 rAny <<= static_cast<sal_Int32>(convertTwipToMm100(nHeight));
8274 }
8275 else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
8276 {
8277 bool bHidden = rDoc.RowHidden(nRow, nTab);
8278 rAny <<= !bHidden;
8279 }
8280 else if ( pEntry->nWID == SC_WID_UNO_CELLFILT )
8281 {
8282 bool bVis = rDoc.RowFiltered(nRow, nTab);
8283 rAny <<= bVis;
8284 }
8285 else if ( pEntry->nWID == SC_WID_UNO_OHEIGHT )
8286 {
8287 bool bOpt = !(rDoc.GetRowFlags( nRow, nTab ) & CRFlags::ManualSize);
8288 rAny <<= bOpt;
8289 }
8290 else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE )
8291 {
8292 ScBreakType nBreak = rDoc.HasRowBreak(nRow, nTab);
8293 rAny <<= (nBreak != ScBreakType::NONE);
8294 }
8295 else if ( pEntry->nWID == SC_WID_UNO_MANPAGE )
8296 {
8297 bool bBreak(rDoc.HasRowBreak(nRow, nTab) & ScBreakType::Manual);
8298 rAny <<= bBreak;
8299 }
8300 else
8301 ScCellRangeObj::GetOnePropertyValue(pEntry, rAny);
8302 }
8303
8304 const SfxItemPropertyMap& ScTableRowObj::GetItemPropertyMap()
8305 {
8306 return pRowPropSet->getPropertyMap();
8307 }
8308
8309 ScCellsObj::ScCellsObj(ScDocShell* pDocSh, ScRangeList aR) :
8310 pDocShell( pDocSh ),
8311 aRanges(std::move( aR ))
8312 {
8313 pDocShell->GetDocument().AddUnoObject(*this);
8314 }
8315
8316 ScCellsObj::~ScCellsObj()
8317 {
8318 SolarMutexGuard g;
8319
8320 if (pDocShell)
8321 pDocShell->GetDocument().RemoveUnoObject(*this);
8322 }
8323
8324 void ScCellsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
8325 {
8326 if ( rHint.GetId() == SfxHintId::ScUpdateRef )
8327 {
8328 auto pRefHint = static_cast<const ScUpdateRefHint*>(&rHint);
8329 aRanges.UpdateReference( pRefHint->GetMode(), &pDocShell->GetDocument(), pRefHint->GetRange(),
8330 pRefHint->GetDx(), pRefHint->GetDy(), pRefHint->GetDz() );
8331 }
8332 else if ( rHint.GetId() == SfxHintId::Dying )
8333 {
8334 pDocShell = nullptr;
8335 }
8336 }
8337
8338 // XEnumerationAccess
8339
8340 uno::Reference<container::XEnumeration> SAL_CALL ScCellsObj::createEnumeration()
8341 {
8342 SolarMutexGuard aGuard;
8343 if (pDocShell)
8344 return new ScCellsEnumeration( pDocShell, aRanges );
8345 return nullptr;
8346 }
8347
8348 uno::Type SAL_CALL ScCellsObj::getElementType()
8349 {
8350 return cppu::UnoType<table::XCell>::get();
8351 }
8352
8353 sal_Bool SAL_CALL ScCellsObj::hasElements()
8354 {
8355 SolarMutexGuard aGuard;
8356 bool bHas = false;
8357 if ( pDocShell )
8358 {
8359 //! faster if test ourself?
8360
8361 uno::Reference<container::XEnumeration> xEnum(new ScCellsEnumeration( pDocShell, aRanges ));
8362 bHas = xEnum->hasMoreElements();
8363 }
8364 return bHas;
8365 }
8366
8367 ScCellsEnumeration::ScCellsEnumeration(ScDocShell* pDocSh, ScRangeList aR) :
8368 pDocShell( pDocSh ),
8369 aRanges(std::move( aR )),
8370 bAtEnd( false )
8371 {
8372 ScDocument& rDoc = pDocShell->GetDocument();
8373 rDoc.AddUnoObject(*this);
8374
8375 if ( aRanges.empty() )
8376 bAtEnd = true;
8377 else
8378 {
8379 SCTAB nTab = aRanges[ 0 ].aStart.Tab();
8380 aPos = ScAddress(0,0,nTab);
8381 CheckPos_Impl(); // set aPos on first matching cell
8382 }
8383 }
8384
8385 void ScCellsEnumeration::CheckPos_Impl()
8386 {
8387 if (!pDocShell)
8388 return;
8389
8390 bool bFound = false;
8391 ScDocument& rDoc = pDocShell->GetDocument();
8392 ScRefCellValue aCell(rDoc, aPos);
8393 if (!aCell.isEmpty())
8394 {
8395 if (!pMark)
8396 {
8397 pMark.reset( new ScMarkData(rDoc.GetSheetLimits()) );
8398 pMark->MarkFromRangeList(aRanges, false);
8399 pMark->MarkToMulti(); // needed for GetNextMarkedCell
8400 }
8401 bFound = pMark->IsCellMarked(aPos.Col(), aPos.Row());
8402 }
8403 if (!bFound)
8404 Advance_Impl();
8405 }
8406
8407 ScCellsEnumeration::~ScCellsEnumeration()
8408 {
8409 SolarMutexGuard g;
8410
8411 if (pDocShell)
8412 pDocShell->GetDocument().RemoveUnoObject(*this);
8413 pMark.reset();
8414 }
8415
8416 void ScCellsEnumeration::Advance_Impl()
8417 {
8418 OSL_ENSURE(!bAtEnd,"too much Advance_Impl");
8419 if (!pMark)
8420 {
8421 pMark.reset( new ScMarkData(pDocShell->GetDocument().GetSheetLimits()) );
8422 pMark->MarkFromRangeList( aRanges, false );
8423 pMark->MarkToMulti(); // needed for GetNextMarkedCell
8424 }
8425
8426 SCCOL nCol = aPos.Col();
8427 SCROW nRow = aPos.Row();
8428 SCTAB nTab = aPos.Tab();
8429 bool bFound = pDocShell->GetDocument().GetNextMarkedCell( nCol, nRow, nTab, *pMark );
8430 if (bFound)
8431 aPos.Set( nCol, nRow, nTab );
8432 else
8433 bAtEnd = true; // nothing will follow
8434 }
8435
8436 void ScCellsEnumeration::Notify( SfxBroadcaster&, const SfxHint& rHint )
8437 {
8438 if ( rHint.GetId() == SfxHintId::ScUpdateRef )
8439 {
8440 const ScUpdateRefHint* pRefHint = static_cast<const ScUpdateRefHint*>(&rHint);
8441 if (pDocShell)
8442 {
8443 aRanges.UpdateReference( pRefHint->GetMode(), &pDocShell->GetDocument(), pRefHint->GetRange(),
8444 pRefHint->GetDx(), pRefHint->GetDy(), pRefHint->GetDz() );
8445
8446 pMark.reset(); // recreate from moved area
8447
8448 if (!bAtEnd) // adjust aPos
8449 {
8450 ScRangeList aNew { ScRange(aPos) };
8451 aNew.UpdateReference( pRefHint->GetMode(), &pDocShell->GetDocument(), pRefHint->GetRange(),
8452 pRefHint->GetDx(), pRefHint->GetDy(), pRefHint->GetDz() );
8453 if (aNew.size()==1)
8454 {
8455 aPos = aNew[ 0 ].aStart;
8456 CheckPos_Impl();
8457 }
8458 }
8459 }
8460 }
8461 else if ( rHint.GetId() == SfxHintId::Dying )
8462 {
8463 pDocShell = nullptr;
8464 }
8465 }
8466
8467 // XEnumeration
8468
8469 sal_Bool SAL_CALL ScCellsEnumeration::hasMoreElements()
8470 {
8471 SolarMutexGuard aGuard;
8472 return !bAtEnd;
8473 }
8474
8475 uno::Any SAL_CALL ScCellsEnumeration::nextElement()
8476 {
8477 SolarMutexGuard aGuard;
8478 if (pDocShell && !bAtEnd)
8479 {
8480 // interface must match ScCellsObj::getElementType
8481
8482 ScAddress aTempPos(aPos);
8483 Advance_Impl();
8484 return uno::Any(uno::Reference<table::XCell>(new ScCellObj( pDocShell, aTempPos )));
8485 }
8486
8487 throw container::NoSuchElementException(); // no more elements
8488 }
8489
8490 ScCellFormatsObj::ScCellFormatsObj(ScDocShell* pDocSh, const ScRange& rRange) :
8491 pDocShell( pDocSh ),
8492 aTotalRange( rRange )
8493 {
8494 ScDocument& rDoc = pDocShell->GetDocument();
8495 rDoc.AddUnoObject(*this);
8496
8497 OSL_ENSURE( aTotalRange.aStart.Tab() == aTotalRange.aEnd.Tab(), "different tables" );
8498 }
8499
8500 ScCellFormatsObj::~ScCellFormatsObj()
8501 {
8502 SolarMutexGuard g;
8503
8504 if (pDocShell)
8505 pDocShell->GetDocument().RemoveUnoObject(*this);
8506 }
8507
8508 void ScCellFormatsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
8509 {
8510 if ( rHint.GetId() == SfxHintId::ScUpdateRef )
8511 {
8512 //! aTotalRange...
8513 }
8514 else if ( rHint.GetId() == SfxHintId::Dying )
8515 {
8516 pDocShell = nullptr;
8517 }
8518 }
8519
8520 rtl::Reference<ScCellRangeObj> ScCellFormatsObj::GetObjectByIndex_Impl(tools::Long nIndex) const
8521 {
8522 //! access the AttrArrays directly !!!!
8523
8524 if (pDocShell)
8525 {
8526 ScDocument& rDoc = pDocShell->GetDocument();
8527 tools::Long nPos = 0;
8528 ScAttrRectIterator aIter( rDoc, aTotalRange.aStart.Tab(),
8529 aTotalRange.aStart.Col(), aTotalRange.aStart.Row(),
8530 aTotalRange.aEnd.Col(), aTotalRange.aEnd.Row() );
8531 SCCOL nCol1, nCol2;
8532 SCROW nRow1, nRow2;
8533 while ( aIter.GetNext( nCol1, nCol2, nRow1, nRow2 ) )
8534 {
8535 if ( nPos == nIndex )
8536 {
8537 SCTAB nTab = aTotalRange.aStart.Tab();
8538 ScRange aNext( nCol1, nRow1, nTab, nCol2, nRow2, nTab );
8539
8540 if ( aNext.aStart == aNext.aEnd )
8541 return new ScCellObj( pDocShell, aNext.aStart );
8542 else
8543 return new ScCellRangeObj( pDocShell, aNext );
8544 }
8545 ++nPos;
8546 }
8547 }
8548 return {};
8549 }
8550
8551 // XIndexAccess
8552
8553 sal_Int32 SAL_CALL ScCellFormatsObj::getCount()
8554 {
8555 SolarMutexGuard aGuard;
8556
8557 //! access the AttrArrays directly !!!!
8558
8559 tools::Long nCount = 0;
8560 if (pDocShell)
8561 {
8562 ScDocument& rDoc = pDocShell->GetDocument();
8563 ScAttrRectIterator aIter( rDoc, aTotalRange.aStart.Tab(),
8564 aTotalRange.aStart.Col(), aTotalRange.aStart.Row(),
8565 aTotalRange.aEnd.Col(), aTotalRange.aEnd.Row() );
8566 SCCOL nCol1, nCol2;
8567 SCROW nRow1, nRow2;
8568 while ( aIter.GetNext( nCol1, nCol2, nRow1, nRow2 ) )
8569 ++nCount;
8570 }
8571 return nCount;
8572 }
8573
8574 uno::Any SAL_CALL ScCellFormatsObj::getByIndex( sal_Int32 nIndex )
8575 {
8576 SolarMutexGuard aGuard;
8577
8578 uno::Reference<table::XCellRange> xRange(GetObjectByIndex_Impl(nIndex));
8579 if (!xRange.is())
8580 throw lang::IndexOutOfBoundsException();
8581
8582 return uno::Any(xRange);
8583
8584 }
8585
8586 uno::Type SAL_CALL ScCellFormatsObj::getElementType()
8587 {
8588 return cppu::UnoType<table::XCellRange>::get();
8589 }
8590
8591 sal_Bool SAL_CALL ScCellFormatsObj::hasElements()
8592 {
8593 SolarMutexGuard aGuard;
8594 return ( getCount() != 0 ); //! always greater than zero ??
8595 }
8596
8597 // XEnumerationAccess
8598
8599 uno::Reference<container::XEnumeration> SAL_CALL ScCellFormatsObj::createEnumeration()
8600 {
8601 SolarMutexGuard aGuard;
8602 if (pDocShell)
8603 return new ScCellFormatsEnumeration( pDocShell, aTotalRange );
8604 return nullptr;
8605 }
8606
8607 ScCellFormatsEnumeration::ScCellFormatsEnumeration(ScDocShell* pDocSh, const ScRange& rRange) :
8608 pDocShell( pDocSh ),
8609 nTab( rRange.aStart.Tab() ),
8610 bAtEnd( false ),
8611 bDirty( false )
8612 {
8613 ScDocument& rDoc = pDocShell->GetDocument();
8614 rDoc.AddUnoObject(*this);
8615
8616 OSL_ENSURE( rRange.aStart.Tab() == rRange.aEnd.Tab(),
8617 "CellFormatsEnumeration: different tables" );
8618
8619 pIter.reset( new ScAttrRectIterator( rDoc, nTab,
8620 rRange.aStart.Col(), rRange.aStart.Row(),
8621 rRange.aEnd.Col(), rRange.aEnd.Row() ) );
8622 Advance_Impl();
8623 }
8624
8625 ScCellFormatsEnumeration::~ScCellFormatsEnumeration()
8626 {
8627 SolarMutexGuard g;
8628
8629 if (pDocShell)
8630 pDocShell->GetDocument().RemoveUnoObject(*this);
8631 }
8632
8633 void ScCellFormatsEnumeration::Advance_Impl()
8634 {
8635 OSL_ENSURE(!bAtEnd,"too many Advance_Impl");
8636
8637 if ( pIter )
8638 {
8639 if ( bDirty )
8640 {
8641 pIter->DataChanged(); // new search for AttrArray-Index
8642 bDirty = false;
8643 }
8644
8645 SCCOL nCol1, nCol2;
8646 SCROW nRow1, nRow2;
8647 if ( pIter->GetNext( nCol1, nCol2, nRow1, nRow2 ) )
8648 aNext = ScRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab );
8649 else
8650 bAtEnd = true;
8651 }
8652 else
8653 bAtEnd = true; // document vanished or so
8654 }
8655
8656 rtl::Reference<ScCellRangeObj> ScCellFormatsEnumeration::NextObject_Impl()
8657 {
8658 rtl::Reference<ScCellRangeObj> pRet;
8659 if (pDocShell && !bAtEnd)
8660 {
8661 if ( aNext.aStart == aNext.aEnd )
8662 pRet = new ScCellObj( pDocShell, aNext.aStart );
8663 else
8664 pRet = new ScCellRangeObj( pDocShell, aNext );
8665 Advance_Impl();
8666 }
8667 return pRet;
8668 }
8669
8670 void ScCellFormatsEnumeration::Notify( SfxBroadcaster&, const SfxHint& rHint )
8671 {
8672 if ( rHint.GetId() == SfxHintId::ScUpdateRef )
8673 {
8674 //! and now???
8675 }
8676 else
8677 {
8678 const SfxHintId nId = rHint.GetId();
8679 if ( nId == SfxHintId::Dying )
8680 {
8681 pDocShell = nullptr;
8682 pIter.reset();
8683 }
8684 else if ( nId == SfxHintId::DataChanged )
8685 {
8686 bDirty = true; // AttrArray-Index possibly invalid
8687 }
8688 }
8689 }
8690
8691 // XEnumeration
8692
8693 sal_Bool SAL_CALL ScCellFormatsEnumeration::hasMoreElements()
8694 {
8695 SolarMutexGuard aGuard;
8696 return !bAtEnd;
8697 }
8698
8699 uno::Any SAL_CALL ScCellFormatsEnumeration::nextElement()
8700 {
8701 SolarMutexGuard aGuard;
8702
8703 if ( bAtEnd || !pDocShell )
8704 throw container::NoSuchElementException(); // no more elements
8705
8706 // interface must match ScCellFormatsObj::getElementType
8707
8708 return uno::Any(uno::Reference<table::XCellRange> (NextObject_Impl()));
8709 }
8710
8711 ScUniqueCellFormatsObj::~ScUniqueCellFormatsObj()
8712 {
8713 SolarMutexGuard g;
8714
8715 if (pDocShell)
8716 pDocShell->GetDocument().RemoveUnoObject(*this);
8717 }
8718
8719 void ScUniqueCellFormatsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
8720 {
8721 if ( rHint.GetId() == SfxHintId::ScUpdateRef )
8722 {
8723 //! aTotalRange...
8724 }
8725 else
8726 {
8727 if ( rHint.GetId() == SfxHintId::Dying )
8728 pDocShell = nullptr;
8729 }
8730 }
8731
8732 // Fill the list of formats from the document
8733
8734 namespace {
8735
8736 // hash code to access the range lists by ScPatternAttr pointer
8737 struct ScPatternHashCode
8738 {
8739 size_t operator()( const ScPatternAttr* pPattern ) const
8740 {
8741 return reinterpret_cast<size_t>(pPattern);
8742 }
8743 };
8744
8745 }
8746
8747 // Hash map to find a range by its start row
8748 typedef std::unordered_map< SCROW, ScRange > ScRowRangeHashMap;
8749
8750 namespace {
8751
8752 // Hash map entry.
8753 // The Join method depends on the column-wise order of ScAttrRectIterator
8754 class ScUniqueFormatsEntry
8755 {
8756 enum EntryState { STATE_EMPTY, STATE_SINGLE, STATE_COMPLEX };
8757
8758 EntryState eState;
8759 ScRange aSingleRange;
8760 ScRowRangeHashMap aJoinedRanges; // "active" ranges to be merged
8761 std::vector<ScRange> aCompletedRanges; // ranges that will no longer be touched
8762 ScRangeListRef aReturnRanges; // result as ScRangeList for further use
8763
8764 public:
8765 ScUniqueFormatsEntry() : eState( STATE_EMPTY ) {}
8766
8767 void Join( const ScRange& rNewRange );
8768 const ScRangeList& GetRanges();
8769 void Clear() { aReturnRanges.clear(); } // aJoinedRanges and aCompletedRanges are cleared in GetRanges
8770 };
8771
8772 }
8773
8774 void ScUniqueFormatsEntry::Join( const ScRange& rNewRange )
8775 {
8776 // Special-case handling for single range
8777
8778 if ( eState == STATE_EMPTY )
8779 {
8780 aSingleRange = rNewRange;
8781 eState = STATE_SINGLE;
8782 return;
8783 }
8784 if ( eState == STATE_SINGLE )
8785 {
8786 if ( aSingleRange.aStart.Row() == rNewRange.aStart.Row() &&
8787 aSingleRange.aEnd.Row() == rNewRange.aEnd.Row() &&
8788 aSingleRange.aEnd.Col() + 1 == rNewRange.aStart.Col() )
8789 {
8790 aSingleRange.aEnd.SetCol( rNewRange.aEnd.Col() );
8791 return; // still a single range
8792 }
8793
8794 SCROW nSingleRow = aSingleRange.aStart.Row();
8795 aJoinedRanges.emplace( nSingleRow, aSingleRange );
8796 eState = STATE_COMPLEX;
8797 // continue normally
8798 }
8799
8800 // This is called in the order of ScAttrRectIterator results.
8801 // rNewRange can only be joined with an existing entry if it's the same rows, starting in the next column.
8802 // If the old entry for the start row extends to a different end row, or ends in a different column, it
8803 // can be moved to aCompletedRanges because it can't be joined with following iterator results.
8804 // Everything happens within one sheet, so Tab can be ignored.
8805
8806 SCROW nStartRow = rNewRange.aStart.Row();
8807 ScRowRangeHashMap::iterator aIter( aJoinedRanges.find( nStartRow ) ); // find the active entry for the start row
8808 if ( aIter != aJoinedRanges.end() )
8809 {
8810 ScRange& rOldRange = aIter->second;
8811 if ( rOldRange.aEnd.Row() == rNewRange.aEnd.Row() &&
8812 rOldRange.aEnd.Col() + 1 == rNewRange.aStart.Col() )
8813 {
8814 // extend existing range
8815 rOldRange.aEnd.SetCol( rNewRange.aEnd.Col() );
8816 }
8817 else
8818 {
8819 // move old range to aCompletedRanges, keep rNewRange for joining
8820 aCompletedRanges.push_back( rOldRange );
8821 rOldRange = rNewRange; // replace in hash map
8822 }
8823 }
8824 else
8825 {
8826 // keep rNewRange for joining
8827 aJoinedRanges.emplace( nStartRow, rNewRange );
8828 }
8829 }
8830
8831 const ScRangeList& ScUniqueFormatsEntry::GetRanges()
8832 {
8833 if ( eState == STATE_SINGLE )
8834 {
8835 aReturnRanges = new ScRangeList( aSingleRange );
8836 return *aReturnRanges;
8837 }
8838
8839 // move remaining entries from aJoinedRanges to aCompletedRanges
8840
8841 for ( const auto& rEntry : aJoinedRanges )
8842 aCompletedRanges.push_back( rEntry.second );
8843 aJoinedRanges.clear();
8844
8845 // sort all ranges for a predictable API result
8846
8847 std::sort( aCompletedRanges.begin(), aCompletedRanges.end() );
8848
8849 // fill and return ScRangeList
8850
8851 aReturnRanges = new ScRangeList;
8852 aReturnRanges->insert( aReturnRanges->end(), aCompletedRanges.begin(), aCompletedRanges.end() );
8853 aCompletedRanges.clear();
8854
8855 return *aReturnRanges;
8856 }
8857
8858 namespace {
8859
8860 // function object to sort the range lists by start of first range
8861 struct ScUniqueFormatsOrder
8862 {
8863 bool operator()( const ScRangeList& rList1, const ScRangeList& rList2 ) const
8864 {
8865 // all range lists have at least one entry
8866 OSL_ENSURE( !rList1.empty() && !rList2.empty(), "ScUniqueFormatsOrder: empty list" );
8867
8868 // compare start positions using ScAddress comparison operator
8869 return ( rList1[ 0 ].aStart < rList2[ 0 ].aStart );
8870 }
8871 };
8872
8873 }
8874
8875 ScUniqueCellFormatsObj::ScUniqueCellFormatsObj(ScDocShell* pDocSh, const ScRange& rTotalRange) :
8876 pDocShell( pDocSh )
8877 {
8878 pDocShell->GetDocument().AddUnoObject(*this);
8879
8880 OSL_ENSURE( rTotalRange.aStart.Tab() == rTotalRange.aEnd.Tab(), "different tables" );
8881
8882 ScDocument& rDoc = pDocShell->GetDocument();
8883 SCTAB nTab = rTotalRange.aStart.Tab();
8884 ScAttrRectIterator aIter( rDoc, nTab,
8885 rTotalRange.aStart.Col(), rTotalRange.aStart.Row(),
8886 rTotalRange.aEnd.Col(), rTotalRange.aEnd.Row() );
8887 SCCOL nCol1, nCol2;
8888 SCROW nRow1, nRow2;
8889
8890 // Collect the ranges for each format in a hash map, to avoid nested loops
8891
8892 std::unordered_map< const ScPatternAttr*, ScUniqueFormatsEntry, ScPatternHashCode > aHashMap;
8893 while (aIter.GetNext( nCol1, nCol2, nRow1, nRow2 ) )
8894 {
8895 ScRange aRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab );
8896 const ScPatternAttr* pPattern = rDoc.GetPattern(nCol1, nRow1, nTab);
8897 aHashMap[pPattern].Join( aRange );
8898 }
8899
8900 // Fill the vector aRangeLists with the range lists from the hash map
8901
8902 aRangeLists.reserve( aHashMap.size() );
8903 for ( auto& rMapEntry : aHashMap )
8904 {
8905 ScUniqueFormatsEntry& rEntry = rMapEntry.second;
8906 const ScRangeList& rRanges = rEntry.GetRanges();
8907 aRangeLists.push_back( rRanges ); // copy ScRangeList
8908 rEntry.Clear(); // free memory, don't hold both copies of all ranges
8909 }
8910
8911 // Sort the vector by first range's start position, to avoid random shuffling
8912 // due to using the ScPatterAttr pointers
8913
8914 ::std::sort( aRangeLists.begin(), aRangeLists.end(), ScUniqueFormatsOrder() );
8915 }
8916
8917
8918 // XIndexAccess
8919
8920 sal_Int32 SAL_CALL ScUniqueCellFormatsObj::getCount()
8921 {
8922 SolarMutexGuard aGuard;
8923
8924 return aRangeLists.size();
8925 }
8926
8927 uno::Any SAL_CALL ScUniqueCellFormatsObj::getByIndex( sal_Int32 nIndex )
8928 {
8929 SolarMutexGuard aGuard;
8930
8931 if(o3tl::make_unsigned(nIndex) >= aRangeLists.size())
8932 throw lang::IndexOutOfBoundsException();
8933
8934 return uno::Any(uno::Reference<sheet::XSheetCellRangeContainer>(new ScCellRangesObj(pDocShell, aRangeLists[nIndex])));
8935
8936 }
8937
8938 uno::Type SAL_CALL ScUniqueCellFormatsObj::getElementType()
8939 {
8940 return cppu::UnoType<sheet::XSheetCellRangeContainer>::get();
8941 }
8942
8943 sal_Bool SAL_CALL ScUniqueCellFormatsObj::hasElements()
8944 {
8945 SolarMutexGuard aGuard;
8946 return ( !aRangeLists.empty() );
8947 }
8948
8949 // XEnumerationAccess
8950
8951 uno::Reference<container::XEnumeration> SAL_CALL ScUniqueCellFormatsObj::createEnumeration()
8952 {
8953 SolarMutexGuard aGuard;
8954 if (pDocShell)
8955 return new ScUniqueCellFormatsEnumeration( pDocShell, std::vector(aRangeLists) );
8956 return nullptr;
8957 }
8958
8959 ScUniqueCellFormatsEnumeration::ScUniqueCellFormatsEnumeration(ScDocShell* pDocSh, std::vector<ScRangeList>&& rRangeLists) :
8960 aRangeLists(std::move(rRangeLists)),
8961 pDocShell( pDocSh ),
8962 nCurrentPosition(0)
8963 {
8964 pDocShell->GetDocument().AddUnoObject(*this);
8965 }
8966
8967 ScUniqueCellFormatsEnumeration::~ScUniqueCellFormatsEnumeration()
8968 {
8969 SolarMutexGuard g;
8970
8971 if (pDocShell)
8972 pDocShell->GetDocument().RemoveUnoObject(*this);
8973 }
8974
8975 void ScUniqueCellFormatsEnumeration::Notify( SfxBroadcaster&, const SfxHint& rHint )
8976 {
8977 if ( rHint.GetId() == SfxHintId::ScUpdateRef )
8978 {
8979 //! and now ???
8980 }
8981 else
8982 {
8983 if ( rHint.GetId() == SfxHintId::Dying )
8984 pDocShell = nullptr;
8985 }
8986 }
8987
8988 // XEnumeration
8989
8990 sal_Bool SAL_CALL ScUniqueCellFormatsEnumeration::hasMoreElements()
8991 {
8992 SolarMutexGuard aGuard;
8993 return o3tl::make_unsigned(nCurrentPosition) < aRangeLists.size();
8994 }
8995
8996 uno::Any SAL_CALL ScUniqueCellFormatsEnumeration::nextElement()
8997 {
8998 SolarMutexGuard aGuard;
8999
9000 if ( !hasMoreElements() || !pDocShell )
9001 throw container::NoSuchElementException(); // no more elements
9002
9003 // interface type must match ScCellFormatsObj::getElementType
9004
9005 return uno::Any(uno::Reference<sheet::XSheetCellRangeContainer>(new ScCellRangesObj(pDocShell, aRangeLists[nCurrentPosition++])));
9006 }
9007
9008 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE