Line data Source code
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 <svx/svdpool.hxx>
23 :
24 : #include <svx/algitem.hxx>
25 : #include <editeng/boxitem.hxx>
26 : #include <editeng/brushitem.hxx>
27 : #include <editeng/editeng.hxx>
28 : #include <editeng/flditem.hxx>
29 : #include <editeng/justifyitem.hxx>
30 : #include <editeng/editobj.hxx>
31 : #include <svx/fmdpage.hxx>
32 : #include <editeng/langitem.hxx>
33 : #include <sfx2/linkmgr.hxx>
34 : #include <svl/srchitem.hxx>
35 : #include <svl/sharedstringpool.hxx>
36 : #include <svx/unomid.hxx>
37 : #include <editeng/unoprnms.hxx>
38 : #include <editeng/unotext.hxx>
39 : #include <svx/svdpage.hxx>
40 : #include <sfx2/bindings.hxx>
41 : #include <svl/zforlist.hxx>
42 : #include <svl/zformat.hxx>
43 : #include <comphelper/servicehelper.hxx>
44 : #include <cppuhelper/supportsservice.hxx>
45 : #include <float.h>
46 :
47 : #include <com/sun/star/awt/XBitmap.hpp>
48 : #include <com/sun/star/util/CellProtection.hpp>
49 : #include <com/sun/star/table/CellHoriJustify.hpp>
50 : #include <com/sun/star/table/CellOrientation.hpp>
51 : #include <com/sun/star/table/CellVertJustify2.hpp>
52 : #include <com/sun/star/table/ShadowFormat.hpp>
53 : #include <com/sun/star/table/TableBorder.hpp>
54 : #include <com/sun/star/table/BorderLineStyle.hpp>
55 : #include <com/sun/star/sheet/CellFlags.hpp>
56 : #include <com/sun/star/sheet/FormulaResult.hpp>
57 : #include <com/sun/star/beans/PropertyAttribute.hpp>
58 : #include <com/sun/star/lang/Locale.hpp>
59 : #include <com/sun/star/beans/TolerantPropertySetResultType.hpp>
60 : #include <com/sun/star/beans/SetPropertyTolerantFailed.hpp>
61 : #include <com/sun/star/text/WritingMode2.hpp>
62 : #include <com/sun/star/text/textfield/Type.hpp>
63 : #include <com/sun/star/sheet/XConditionalFormats.hpp>
64 :
65 : #include "autoform.hxx"
66 : #include "cellmergeoption.hxx"
67 : #include "cellsuno.hxx"
68 : #include "cursuno.hxx"
69 : #include "textuno.hxx"
70 : #include "editsrc.hxx"
71 : #include "notesuno.hxx"
72 : #include "fielduno.hxx"
73 : #include "docuno.hxx"
74 : #include "datauno.hxx"
75 : #include "dapiuno.hxx"
76 : #include "chartuno.hxx"
77 : #include "fmtuno.hxx"
78 : #include "miscuno.hxx"
79 : #include "convuno.hxx"
80 : #include "srchuno.hxx"
81 : #include "nameuno.hxx"
82 : #include "targuno.hxx"
83 : #include "tokenuno.hxx"
84 : #include "eventuno.hxx"
85 : #include "docsh.hxx"
86 : #include "markdata.hxx"
87 : #include "patattr.hxx"
88 : #include "docpool.hxx"
89 : #include "docfunc.hxx"
90 : #include "dbdocfun.hxx"
91 : #include "olinefun.hxx"
92 : #include "hints.hxx"
93 : #include "formulacell.hxx"
94 : #include "undocell.hxx"
95 : #include "undotab.hxx"
96 : #include "undoblk.hxx"
97 : #include "stlsheet.hxx"
98 : #include "dbdata.hxx"
99 : #include "attrib.hxx"
100 : #include "chartarr.hxx"
101 : #include "chartlis.hxx"
102 : #include "drwlayer.hxx"
103 : #include "printfun.hxx"
104 : #include "prnsave.hxx"
105 : #include "tablink.hxx"
106 : #include "dociter.hxx"
107 : #include "rangeutl.hxx"
108 : #include "conditio.hxx"
109 : #include "validat.hxx"
110 : #include "sc.hrc"
111 : #include "brdcst.hxx"
112 : #include "cellform.hxx"
113 : #include "globstr.hrc"
114 : #include "unonames.hxx"
115 : #include "styleuno.hxx"
116 : #include "rangeseq.hxx"
117 : #include "unowids.hxx"
118 : #include "paramisc.hxx"
119 : #include "queryentry.hxx"
120 : #include <formula/errorcodes.hxx>
121 : #include "unoreflist.hxx"
122 : #include <formula/grammar.hxx>
123 : #include <editeng/escapementitem.hxx>
124 : #include "stringutil.hxx"
125 : #include "formulaiter.hxx"
126 : #include "tokenarray.hxx"
127 : #include "stylehelper.hxx"
128 : #include "dputil.hxx"
129 : #include <sortparam.hxx>
130 : #include "condformatuno.hxx"
131 :
132 : #include <list>
133 : #include <boost/scoped_array.hpp>
134 : #include <boost/scoped_ptr.hpp>
135 :
136 : using namespace com::sun::star;
137 :
138 35 : class ScNamedEntry
139 : {
140 : OUString aName;
141 : ScRange aRange;
142 :
143 : public:
144 35 : ScNamedEntry(const OUString& rN, const ScRange& rR) :
145 35 : aName(rN), aRange(rR) {}
146 :
147 144 : const OUString& GetName() const { return aName; }
148 79 : const ScRange& GetRange() const { return aRange; }
149 : };
150 :
151 : // The names in the maps must be sorted according to strcmp!
152 : //! Instead of Which-ID 0 use special IDs and do not compare via names!
153 :
154 : // Left/Right/Top/BottomBorder are mapped directly to the core items,
155 : // not collected/applied to the borders of a range -> ATTR_BORDER can be used directly
156 :
157 48577 : static const SfxItemPropertySet* lcl_GetCellsPropertySet()
158 : {
159 : static const SfxItemPropertyMapEntry aCellsPropertyMap_Impl[] =
160 : {
161 43 : {OUString(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
162 43 : {OUString(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
163 43 : {OUString(SC_UNONAME_BOTTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
164 43 : {OUString(SC_UNONAME_BOTTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
165 43 : {OUString(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, cppu::UnoType<sal_Int32>::get(), 0, MID_BACK_COLOR },
166 43 : {OUString(SC_UNONAME_CELLPRO), ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
167 43 : {OUString(SC_UNONAME_CELLSTYL), SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
168 43 : {OUString(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, cppu::UnoType<sal_Int32>::get(), 0, 0 },
169 43 : {OUString(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
170 43 : {OUString(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
171 43 : {OUString(SC_UNONAME_CEMPHAS), ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
172 43 : {OUString(SC_UNONAME_CFONT), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
173 43 : {OUString(SC_UNONAME_CFCHARS), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
174 43 : {OUString(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
175 43 : {OUString(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
176 43 : {OUString(SC_UNONAME_CFFAMIL), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
177 43 : {OUString(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
178 43 : {OUString(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
179 43 : {OUString(SC_UNONAME_CFNAME), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
180 43 : {OUString(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
181 43 : {OUString(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
182 43 : {OUString(SC_UNONAME_CFPITCH), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
183 43 : {OUString(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
184 43 : {OUString(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
185 43 : {OUString(SC_UNONAME_CFSTYLE), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
186 43 : {OUString(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
187 43 : {OUString(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
188 43 : {OUString(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
189 43 : {OUString(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
190 43 : {OUString(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
191 43 : {OUString(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
192 43 : {OUString(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
193 43 : {OUString(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
194 43 : {OUString(SC_UNONAME_COVER), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
195 43 : {OUString(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
196 43 : {OUString(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
197 43 : {OUString(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
198 43 : {OUString(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
199 43 : {OUString(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
200 43 : {OUString(SC_UNONAME_CRELIEF), ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
201 43 : {OUString(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
202 43 : {OUString(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
203 43 : {OUString(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
204 43 : {OUString(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
205 43 : {OUString(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
206 43 : {OUString(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
207 43 : {OUString(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
208 43 : {OUString(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
209 43 : {OUString(SC_UNONAME_CWORDMOD), ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
210 43 : {OUString(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
211 43 : {OUString(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
212 43 : {OUString(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
213 43 : {OUString(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
214 43 : {OUString(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
215 43 : {OUString(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
216 43 : {OUString(SC_UNONAME_DIAGONAL_BLTR2), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
217 43 : {OUString(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
218 43 : {OUString(SC_UNONAME_DIAGONAL_TLBR2), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
219 43 : {OUString(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
220 43 : {OUString(SC_UNONAME_CELLHJUS_METHOD), ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
221 43 : {OUString(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
222 43 : {OUString(SC_UNONAME_WRAP), ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
223 43 : {OUString(SC_UNONAME_LEFTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
224 43 : {OUString(SC_UNONAME_LEFTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
225 43 : {OUString(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
226 43 : {OUString(SC_UNONAME_NUMRULES), SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
227 43 : {OUString(SC_UNONAME_CELLORI), ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
228 43 : {OUString(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
229 43 : {OUString(SC_UNONAME_PBMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
230 43 : {OUString(SC_UNONAME_PINDENT), ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
231 43 : {OUString(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
232 43 : {OUString(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
233 43 : {OUString(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
234 43 : {OUString(SC_UNONAME_PISHYPHEN),ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
235 43 : {OUString(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
236 43 : {OUString(SC_UNONAME_PLMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
237 43 : {OUString(SC_UNONAME_PRMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
238 43 : {OUString(SC_UNONAME_PTMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
239 43 : {OUString(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
240 43 : {OUString(SC_UNONAME_RIGHTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
241 43 : {OUString(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
242 43 : {OUString(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
243 43 : {OUString(SC_UNONAME_SHADOW), ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
244 43 : {OUString(SC_UNONAME_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
245 43 : {OUString(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
246 43 : {OUString(SC_UNONAME_TBLBORD2), SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
247 43 : {OUString(SC_UNONAME_TOPBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
248 43 : {OUString(SC_UNONAME_TOPBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
249 43 : {OUString(SC_UNONAME_USERDEF), ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
250 43 : {OUString(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
251 43 : {OUString(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
252 43 : {OUString(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
253 43 : {OUString(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
254 43 : {OUString(SC_UNONAME_CELLVJUS_METHOD), ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
255 43 : {OUString(SC_UNONAME_WRITING), ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
256 43 : {OUString(SC_UNONAME_HYPERLINK), ATTR_HYPERLINK, cppu::UnoType<OUString>::get(), 0, 0 },
257 : { OUString(), 0, css::uno::Type(), 0, 0 }
258 52748 : };
259 48577 : static SfxItemPropertySet aCellsPropertySet( aCellsPropertyMap_Impl );
260 48577 : return &aCellsPropertySet;
261 : }
262 :
263 : // CellRange enthaelt alle Eintraege von Cells, zusaetzlich eigene Eintraege
264 : // mit Which-ID 0 (werden nur fuer getPropertySetInfo benoetigt).
265 :
266 31978 : static const SfxItemPropertySet* lcl_GetRangePropertySet()
267 : {
268 : static const SfxItemPropertyMapEntry aRangePropertyMap_Impl[] =
269 : {
270 43 : {OUString(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
271 43 : {OUString(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
272 43 : {OUString(SC_UNONAME_BOTTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
273 43 : {OUString(SC_UNONAME_BOTTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
274 43 : {OUString(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, cppu::UnoType<sal_Int32>::get(), 0, MID_BACK_COLOR },
275 43 : {OUString(SC_UNONAME_CELLPRO), ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
276 43 : {OUString(SC_UNONAME_CELLSTYL), SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
277 43 : {OUString(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, cppu::UnoType<sal_Int32>::get(), 0, 0 },
278 43 : {OUString(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
279 43 : {OUString(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
280 43 : {OUString(SC_UNONAME_CEMPHAS), ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
281 43 : {OUString(SC_UNONAME_CFONT), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
282 43 : {OUString(SC_UNONAME_CFCHARS), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
283 43 : {OUString(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
284 43 : {OUString(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
285 43 : {OUString(SC_UNONAME_CFFAMIL), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
286 43 : {OUString(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
287 43 : {OUString(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
288 43 : {OUString(SC_UNONAME_CFNAME), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
289 43 : {OUString(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
290 43 : {OUString(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
291 43 : {OUString(SC_UNONAME_CFPITCH), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
292 43 : {OUString(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
293 43 : {OUString(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
294 43 : {OUString(SC_UNONAME_CFSTYLE), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
295 43 : {OUString(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
296 43 : {OUString(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
297 43 : {OUString(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
298 43 : {OUString(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
299 43 : {OUString(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
300 43 : {OUString(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
301 43 : {OUString(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
302 43 : {OUString(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
303 43 : {OUString(SC_UNONAME_COVER), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
304 43 : {OUString(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
305 43 : {OUString(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
306 43 : {OUString(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
307 43 : {OUString(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
308 43 : {OUString(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
309 43 : {OUString(SC_UNONAME_CRELIEF), ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
310 43 : {OUString(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
311 43 : {OUString(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
312 43 : {OUString(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
313 43 : {OUString(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
314 43 : {OUString(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
315 43 : {OUString(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
316 43 : {OUString(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
317 43 : {OUString(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
318 43 : {OUString(SC_UNONAME_CWORDMOD), ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
319 43 : {OUString(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
320 43 : {OUString(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
321 43 : {OUString(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
322 43 : {OUString(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
323 43 : {OUString(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
324 43 : {OUString(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
325 43 : {OUString(SC_UNONAME_DIAGONAL_BLTR2), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
326 43 : {OUString(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
327 43 : {OUString(SC_UNONAME_DIAGONAL_TLBR2), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
328 43 : {OUString(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
329 43 : {OUString(SC_UNONAME_CELLHJUS_METHOD), ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
330 43 : {OUString(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
331 43 : {OUString(SC_UNONAME_WRAP), ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
332 43 : {OUString(SC_UNONAME_LEFTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
333 43 : {OUString(SC_UNONAME_LEFTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
334 43 : {OUString(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
335 43 : {OUString(SC_UNONAME_NUMRULES), SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
336 43 : {OUString(SC_UNONAME_CELLORI), ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
337 43 : {OUString(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
338 43 : {OUString(SC_UNONAME_PBMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
339 43 : {OUString(SC_UNONAME_PINDENT), ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
340 43 : {OUString(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
341 43 : {OUString(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
342 43 : {OUString(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
343 43 : {OUString(SC_UNONAME_PISHYPHEN),ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
344 43 : {OUString(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
345 43 : {OUString(SC_UNONAME_PLMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
346 43 : {OUString(SC_UNONAME_PRMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
347 43 : {OUString(SC_UNONAME_PTMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
348 43 : {OUString(SC_UNONAME_POS), SC_WID_UNO_POS, cppu::UnoType<awt::Point>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
349 43 : {OUString(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
350 43 : {OUString(SC_UNONAME_RIGHTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
351 43 : {OUString(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
352 43 : {OUString(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
353 43 : {OUString(SC_UNONAME_SHADOW), ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
354 43 : {OUString(SC_UNONAME_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
355 43 : {OUString(SC_UNONAME_SIZE), SC_WID_UNO_SIZE, cppu::UnoType<awt::Size>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
356 43 : {OUString(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
357 43 : {OUString(SC_UNONAME_TBLBORD2), SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
358 43 : {OUString(SC_UNONAME_TOPBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
359 43 : {OUString(SC_UNONAME_TOPBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
360 43 : {OUString(SC_UNONAME_USERDEF), ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
361 43 : {OUString(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
362 43 : {OUString(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
363 43 : {OUString(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
364 43 : {OUString(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
365 43 : {OUString(SC_UNONAME_CELLVJUS_METHOD), ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
366 43 : {OUString(SC_UNONAME_WRITING), ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
367 : { OUString(), 0, css::uno::Type(), 0, 0 }
368 36192 : };
369 31978 : static SfxItemPropertySet aRangePropertySet( aRangePropertyMap_Impl );
370 31978 : return &aRangePropertySet;
371 : }
372 :
373 : // Cell enthaelt alle Eintraege von CellRange, zusaetzlich eigene Eintraege
374 : // mit Which-ID 0 (werden nur fuer getPropertySetInfo benoetigt).
375 :
376 16640 : static const SfxItemPropertySet* lcl_GetCellPropertySet()
377 : {
378 : static const SfxItemPropertyMapEntry aCellPropertyMap_Impl[] =
379 : {
380 29 : {OUString(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
381 29 : {OUString(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
382 29 : {OUString(SC_UNONAME_BOTTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
383 29 : {OUString(SC_UNONAME_BOTTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
384 29 : {OUString(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, cppu::UnoType<sal_Int32>::get(), 0, MID_BACK_COLOR },
385 29 : {OUString(SC_UNONAME_CELLPRO), ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
386 29 : {OUString(SC_UNONAME_CELLSTYL), SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
387 29 : {OUString(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, cppu::UnoType<sal_Int32>::get(), 0, 0 },
388 29 : {OUString(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
389 29 : {OUString(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
390 29 : {OUString(SC_UNONAME_CEMPHAS), ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
391 29 : {OUString(SC_UNONAME_CFONT), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
392 29 : {OUString(SC_UNONAME_CFCHARS), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
393 29 : {OUString(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
394 29 : {OUString(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
395 29 : {OUString(SC_UNONAME_CFFAMIL), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
396 29 : {OUString(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
397 29 : {OUString(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
398 29 : {OUString(SC_UNONAME_CFNAME), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
399 29 : {OUString(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
400 29 : {OUString(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
401 29 : {OUString(SC_UNONAME_CFPITCH), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
402 29 : {OUString(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
403 29 : {OUString(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
404 29 : {OUString(SC_UNONAME_CFSTYLE), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
405 29 : {OUString(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
406 29 : {OUString(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
407 29 : {OUString(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
408 29 : {OUString(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
409 29 : {OUString(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
410 29 : {OUString(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
411 29 : {OUString(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
412 29 : {OUString(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
413 29 : {OUString(SC_UNONAME_COVER), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
414 29 : {OUString(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
415 29 : {OUString(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
416 29 : {OUString(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
417 29 : {OUString(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
418 29 : {OUString(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
419 29 : {OUString(SC_UNONAME_CRELIEF), ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
420 29 : {OUString(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
421 29 : {OUString(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
422 29 : {OUString(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
423 29 : {OUString(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
424 29 : {OUString(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
425 29 : {OUString(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
426 29 : {OUString(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
427 29 : {OUString(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
428 29 : {OUString(SC_UNONAME_CWORDMOD), ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
429 29 : {OUString(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
430 29 : {OUString(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
431 29 : {OUString(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
432 29 : {OUString(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
433 29 : {OUString(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
434 29 : {OUString(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
435 29 : {OUString(SC_UNONAME_DIAGONAL_BLTR2), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
436 29 : {OUString(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
437 29 : {OUString(SC_UNONAME_DIAGONAL_TLBR2), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
438 29 : {OUString(SC_UNONAME_FORMLOC), SC_WID_UNO_FORMLOC, cppu::UnoType<OUString>::get(), 0, 0 },
439 29 : {OUString(SC_UNONAME_FORMRT), SC_WID_UNO_FORMRT, cppu::UnoType<table::CellContentType>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
440 29 : {OUString(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
441 29 : {OUString(SC_UNONAME_CELLHJUS_METHOD), ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
442 29 : {OUString(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
443 29 : {OUString(SC_UNONAME_WRAP), ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
444 29 : {OUString(SC_UNONAME_LEFTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
445 29 : {OUString(SC_UNONAME_LEFTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
446 29 : {OUString(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
447 29 : {OUString(SC_UNONAME_NUMRULES), SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
448 29 : {OUString(SC_UNONAME_CELLORI), ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
449 29 : {OUString(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
450 29 : {OUString(SC_UNONAME_PBMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
451 29 : {OUString(SC_UNONAME_PINDENT), ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
452 29 : {OUString(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
453 29 : {OUString(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
454 29 : {OUString(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
455 29 : {OUString(SC_UNONAME_PISHYPHEN),ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
456 29 : {OUString(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
457 29 : {OUString(SC_UNONAME_PLMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
458 29 : {OUString(SC_UNONAME_PRMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
459 29 : {OUString(SC_UNONAME_PTMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
460 29 : {OUString(SC_UNONAME_POS), SC_WID_UNO_POS, cppu::UnoType<awt::Point>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
461 29 : {OUString(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
462 29 : {OUString(SC_UNONAME_RIGHTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
463 29 : {OUString(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
464 29 : {OUString(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
465 29 : {OUString(SC_UNONAME_SHADOW), ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
466 29 : {OUString(SC_UNONAME_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
467 29 : {OUString(SC_UNONAME_SIZE), SC_WID_UNO_SIZE, cppu::UnoType<awt::Size>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
468 29 : {OUString(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
469 29 : {OUString(SC_UNONAME_TBLBORD2), SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
470 29 : {OUString(SC_UNONAME_TOPBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
471 29 : {OUString(SC_UNONAME_TOPBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
472 29 : {OUString(SC_UNONAME_USERDEF), ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
473 29 : {OUString(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
474 29 : {OUString(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
475 29 : {OUString(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
476 29 : {OUString(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
477 29 : {OUString(SC_UNONAME_CELLVJUS_METHOD), ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
478 29 : {OUString(SC_UNONAME_WRITING), ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
479 29 : {OUString(UNO_NAME_EDIT_CHAR_ESCAPEMENT), EE_CHAR_ESCAPEMENT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
480 29 : {OUString(SC_UNONAME_HYPERLINK), ATTR_HYPERLINK, cppu::UnoType<OUString>::get(), 0, 0 },
481 : { OUString(), 0, css::uno::Type(), 0, 0 }
482 19598 : };
483 16640 : static SfxItemPropertySet aCellPropertySet( aCellPropertyMap_Impl );
484 16640 : return &aCellPropertySet;
485 : }
486 :
487 : // Column und Row enthalten alle Eintraege von CellRange, zusaetzlich eigene Eintraege
488 : // mit Which-ID 0 (werden nur fuer getPropertySetInfo benoetigt).
489 :
490 1099 : static const SfxItemPropertySet* lcl_GetColumnPropertySet()
491 : {
492 : static const SfxItemPropertyMapEntry aColumnPropertyMap_Impl[] =
493 : {
494 9 : {OUString(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
495 9 : {OUString(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
496 9 : {OUString(SC_UNONAME_BOTTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
497 9 : {OUString(SC_UNONAME_BOTTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
498 9 : {OUString(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, cppu::UnoType<sal_Int32>::get(), 0, MID_BACK_COLOR },
499 9 : {OUString(SC_UNONAME_CELLPRO), ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
500 9 : {OUString(SC_UNONAME_CELLSTYL), SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
501 9 : {OUString(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, cppu::UnoType<sal_Int32>::get(), 0, 0 },
502 9 : {OUString(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
503 9 : {OUString(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
504 9 : {OUString(SC_UNONAME_CEMPHAS), ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
505 9 : {OUString(SC_UNONAME_CFONT), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
506 9 : {OUString(SC_UNONAME_CFCHARS), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
507 9 : {OUString(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
508 9 : {OUString(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
509 9 : {OUString(SC_UNONAME_CFFAMIL), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
510 9 : {OUString(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
511 9 : {OUString(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
512 9 : {OUString(SC_UNONAME_CFNAME), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
513 9 : {OUString(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
514 9 : {OUString(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
515 9 : {OUString(SC_UNONAME_CFPITCH), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
516 9 : {OUString(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
517 9 : {OUString(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
518 9 : {OUString(SC_UNONAME_CFSTYLE), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
519 9 : {OUString(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
520 9 : {OUString(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
521 9 : {OUString(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
522 9 : {OUString(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
523 9 : {OUString(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
524 9 : {OUString(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
525 9 : {OUString(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
526 9 : {OUString(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
527 9 : {OUString(SC_UNONAME_COVER), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
528 9 : {OUString(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
529 9 : {OUString(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
530 9 : {OUString(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
531 9 : {OUString(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
532 9 : {OUString(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
533 9 : {OUString(SC_UNONAME_CRELIEF), ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
534 9 : {OUString(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
535 9 : {OUString(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
536 9 : {OUString(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
537 9 : {OUString(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
538 9 : {OUString(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
539 9 : {OUString(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
540 9 : {OUString(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
541 9 : {OUString(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
542 9 : {OUString(SC_UNONAME_CWORDMOD), ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
543 9 : {OUString(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
544 9 : {OUString(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
545 9 : {OUString(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
546 9 : {OUString(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
547 9 : {OUString(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
548 9 : {OUString(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
549 9 : {OUString(SC_UNONAME_DIAGONAL_BLTR2), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
550 9 : {OUString(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
551 9 : {OUString(SC_UNONAME_DIAGONAL_TLBR2), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
552 9 : {OUString(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
553 9 : {OUString(SC_UNONAME_CELLHJUS_METHOD), ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
554 9 : {OUString(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
555 9 : {OUString(SC_UNONAME_MANPAGE), SC_WID_UNO_MANPAGE, cppu::UnoType<bool>::get(), 0, 0 },
556 9 : {OUString(SC_UNONAME_NEWPAGE), SC_WID_UNO_NEWPAGE, cppu::UnoType<bool>::get(), 0, 0 },
557 9 : {OUString(SC_UNONAME_WRAP), ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
558 9 : {OUString(SC_UNONAME_CELLVIS), SC_WID_UNO_CELLVIS, cppu::UnoType<bool>::get(), 0, 0 },
559 9 : {OUString(SC_UNONAME_LEFTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
560 9 : {OUString(SC_UNONAME_LEFTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
561 9 : {OUString(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
562 9 : {OUString(SC_UNONAME_NUMRULES), SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
563 9 : {OUString(SC_UNONAME_OWIDTH), SC_WID_UNO_OWIDTH, cppu::UnoType<bool>::get(), 0, 0 },
564 9 : {OUString(SC_UNONAME_CELLORI), ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
565 9 : {OUString(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
566 9 : {OUString(SC_UNONAME_PBMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
567 9 : {OUString(SC_UNONAME_PINDENT), ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
568 9 : {OUString(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
569 9 : {OUString(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
570 9 : {OUString(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
571 9 : {OUString(SC_UNONAME_PISHYPHEN),ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
572 9 : {OUString(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
573 9 : {OUString(SC_UNONAME_PLMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
574 9 : {OUString(SC_UNONAME_PRMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
575 9 : {OUString(SC_UNONAME_PTMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
576 9 : {OUString(SC_UNONAME_POS), SC_WID_UNO_POS, cppu::UnoType<awt::Point>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
577 9 : {OUString(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
578 9 : {OUString(SC_UNONAME_RIGHTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
579 9 : {OUString(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
580 9 : {OUString(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
581 9 : {OUString(SC_UNONAME_SHADOW), ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
582 9 : {OUString(SC_UNONAME_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
583 9 : {OUString(SC_UNONAME_SIZE), SC_WID_UNO_SIZE, cppu::UnoType<awt::Size>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
584 9 : {OUString(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
585 9 : {OUString(SC_UNONAME_TBLBORD2), SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
586 9 : {OUString(SC_UNONAME_TOPBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
587 9 : {OUString(SC_UNONAME_TOPBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
588 9 : {OUString(SC_UNONAME_USERDEF), ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
589 9 : {OUString(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
590 9 : {OUString(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
591 9 : {OUString(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
592 9 : {OUString(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
593 9 : {OUString(SC_UNONAME_CELLVJUS_METHOD), ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
594 9 : {OUString(SC_UNONAME_CELLWID), SC_WID_UNO_CELLWID, cppu::UnoType<sal_Int32>::get(), 0, 0 },
595 9 : {OUString(SC_UNONAME_WRITING), ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
596 : { OUString(), 0, css::uno::Type(), 0, 0 }
597 2026 : };
598 1099 : static SfxItemPropertySet aColumnPropertySet( aColumnPropertyMap_Impl );
599 1099 : return &aColumnPropertySet;
600 : }
601 :
602 120 : static const SfxItemPropertySet* lcl_GetRowPropertySet()
603 : {
604 : static const SfxItemPropertyMapEntry aRowPropertyMap_Impl[] =
605 : {
606 9 : {OUString(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
607 9 : {OUString(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
608 9 : {OUString(SC_UNONAME_BOTTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
609 9 : {OUString(SC_UNONAME_BOTTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
610 9 : {OUString(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, cppu::UnoType<sal_Int32>::get(), 0, MID_BACK_COLOR },
611 9 : {OUString(SC_UNONAME_CELLPRO), ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
612 9 : {OUString(SC_UNONAME_CELLSTYL), SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
613 9 : {OUString(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, cppu::UnoType<sal_Int32>::get(), 0, 0 },
614 9 : {OUString(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
615 9 : {OUString(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
616 9 : {OUString(SC_UNONAME_CEMPHAS), ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
617 9 : {OUString(SC_UNONAME_CFONT), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
618 9 : {OUString(SC_UNONAME_CFCHARS), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
619 9 : {OUString(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
620 9 : {OUString(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
621 9 : {OUString(SC_UNONAME_CFFAMIL), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
622 9 : {OUString(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
623 9 : {OUString(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
624 9 : {OUString(SC_UNONAME_CFNAME), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
625 9 : {OUString(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
626 9 : {OUString(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
627 9 : {OUString(SC_UNONAME_CFPITCH), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
628 9 : {OUString(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
629 9 : {OUString(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
630 9 : {OUString(SC_UNONAME_CFSTYLE), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
631 9 : {OUString(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
632 9 : {OUString(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
633 9 : {OUString(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
634 9 : {OUString(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
635 9 : {OUString(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
636 9 : {OUString(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
637 9 : {OUString(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
638 9 : {OUString(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
639 9 : {OUString(SC_UNONAME_COVER), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
640 9 : {OUString(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
641 9 : {OUString(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
642 9 : {OUString(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
643 9 : {OUString(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
644 9 : {OUString(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
645 9 : {OUString(SC_UNONAME_CRELIEF), ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
646 9 : {OUString(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
647 9 : {OUString(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
648 9 : {OUString(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
649 9 : {OUString(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
650 9 : {OUString(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
651 9 : {OUString(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
652 9 : {OUString(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
653 9 : {OUString(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
654 9 : {OUString(SC_UNONAME_CWORDMOD), ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
655 9 : {OUString(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
656 9 : {OUString(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
657 9 : {OUString(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
658 9 : {OUString(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
659 9 : {OUString(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
660 9 : {OUString(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
661 9 : {OUString(SC_UNONAME_DIAGONAL_BLTR2), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
662 9 : {OUString(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
663 9 : {OUString(SC_UNONAME_DIAGONAL_TLBR2), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
664 9 : {OUString(SC_UNONAME_CELLHGT), SC_WID_UNO_CELLHGT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
665 9 : {OUString(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
666 9 : {OUString(SC_UNONAME_CELLHJUS_METHOD), ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
667 9 : {OUString(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
668 9 : {OUString(SC_UNONAME_CELLFILT), SC_WID_UNO_CELLFILT,cppu::UnoType<bool>::get(), 0, 0 },
669 9 : {OUString(SC_UNONAME_MANPAGE), SC_WID_UNO_MANPAGE, cppu::UnoType<bool>::get(), 0, 0 },
670 9 : {OUString(SC_UNONAME_NEWPAGE), SC_WID_UNO_NEWPAGE, cppu::UnoType<bool>::get(), 0, 0 },
671 9 : {OUString(SC_UNONAME_WRAP), ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
672 9 : {OUString(SC_UNONAME_CELLVIS), SC_WID_UNO_CELLVIS, cppu::UnoType<bool>::get(), 0, 0 },
673 9 : {OUString(SC_UNONAME_LEFTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
674 9 : {OUString(SC_UNONAME_LEFTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
675 9 : {OUString(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
676 9 : {OUString(SC_UNONAME_NUMRULES), SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
677 9 : {OUString(SC_UNONAME_OHEIGHT), SC_WID_UNO_OHEIGHT, cppu::UnoType<bool>::get(), 0, 0 },
678 9 : {OUString(SC_UNONAME_CELLORI), ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
679 9 : {OUString(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
680 9 : {OUString(SC_UNONAME_PBMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
681 9 : {OUString(SC_UNONAME_PINDENT), ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
682 9 : {OUString(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
683 9 : {OUString(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
684 9 : {OUString(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
685 9 : {OUString(SC_UNONAME_PISHYPHEN),ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
686 9 : {OUString(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
687 9 : {OUString(SC_UNONAME_PLMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
688 9 : {OUString(SC_UNONAME_PRMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
689 9 : {OUString(SC_UNONAME_PTMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
690 9 : {OUString(SC_UNONAME_POS), SC_WID_UNO_POS, cppu::UnoType<awt::Point>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
691 9 : {OUString(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
692 9 : {OUString(SC_UNONAME_RIGHTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
693 9 : {OUString(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
694 9 : {OUString(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
695 9 : {OUString(SC_UNONAME_SHADOW), ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
696 9 : {OUString(SC_UNONAME_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
697 9 : {OUString(SC_UNONAME_SIZE), SC_WID_UNO_SIZE, cppu::UnoType<awt::Size>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
698 9 : {OUString(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
699 9 : {OUString(SC_UNONAME_TBLBORD2), SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
700 9 : {OUString(SC_UNONAME_TOPBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
701 9 : {OUString(SC_UNONAME_TOPBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
702 9 : {OUString(SC_UNONAME_USERDEF), ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
703 9 : {OUString(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
704 9 : {OUString(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
705 9 : {OUString(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
706 9 : {OUString(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
707 9 : {OUString(SC_UNONAME_CELLVJUS_METHOD), ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
708 9 : {OUString(SC_UNONAME_WRITING), ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
709 : { OUString(), 0, css::uno::Type(), 0, 0 }
710 1056 : };
711 120 : static SfxItemPropertySet aRowPropertySet( aRowPropertyMap_Impl );
712 120 : return &aRowPropertySet;
713 : }
714 :
715 4593 : static const SfxItemPropertySet* lcl_GetSheetPropertySet()
716 : {
717 : static const SfxItemPropertyMapEntry aSheetPropertyMap_Impl[] =
718 : {
719 43 : {OUString(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
720 43 : {OUString(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,cppu::UnoType<bool>::get(), 0, 0 },
721 43 : {OUString(SC_UNONAME_AUTOPRINT),SC_WID_UNO_AUTOPRINT,cppu::UnoType<bool>::get(), 0, 0 },
722 43 : {OUString(SC_UNONAME_BORDCOL), SC_WID_UNO_BORDCOL, cppu::UnoType<sal_Int32>::get(), 0, 0 },
723 43 : {OUString(SC_UNONAME_BOTTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
724 43 : {OUString(SC_UNONAME_BOTTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, BOTTOM_BORDER | CONVERT_TWIPS },
725 43 : {OUString(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, cppu::UnoType<sal_Int32>::get(), 0, MID_BACK_COLOR },
726 43 : {OUString(SC_UNONAME_CELLPRO), ATTR_PROTECTION, cppu::UnoType<util::CellProtection>::get(), 0, 0 },
727 43 : {OUString(SC_UNONAME_CELLSTYL), SC_WID_UNO_CELLSTYL,cppu::UnoType<OUString>::get(), 0, 0 },
728 43 : {OUString(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, cppu::UnoType<sal_Int32>::get(), 0, 0 },
729 43 : {OUString(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, cppu::UnoType<bool>::get(), 0, 0 },
730 43 : {OUString(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,cppu::UnoType<bool>::get(), 0, MID_CROSSED_OUT },
731 43 : {OUString(SC_UNONAME_CEMPHAS), ATTR_FONT_EMPHASISMARK,cppu::UnoType<sal_Int16>::get(), 0, MID_EMPHASIS },
732 43 : {OUString(SC_UNONAME_CFONT), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
733 43 : {OUString(SC_UNONAME_CFCHARS), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
734 43 : {OUString(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
735 43 : {OUString(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_CHAR_SET },
736 43 : {OUString(SC_UNONAME_CFFAMIL), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
737 43 : {OUString(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
738 43 : {OUString(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_FAMILY },
739 43 : {OUString(SC_UNONAME_CFNAME), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
740 43 : {OUString(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
741 43 : {OUString(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_FAMILY_NAME },
742 43 : {OUString(SC_UNONAME_CFPITCH), ATTR_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
743 43 : {OUString(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
744 43 : {OUString(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, cppu::UnoType<sal_Int16>::get(), 0, MID_FONT_PITCH },
745 43 : {OUString(SC_UNONAME_CFSTYLE), ATTR_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
746 43 : {OUString(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
747 43 : {OUString(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, cppu::UnoType<OUString>::get(), 0, MID_FONT_STYLE_NAME },
748 43 : {OUString(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
749 43 : {OUString(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
750 43 : {OUString(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,cppu::UnoType<float>::get(), 0, MID_FONTHEIGHT | CONVERT_TWIPS },
751 43 : {OUString(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
752 43 : {OUString(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
753 43 : {OUString(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,cppu::UnoType<lang::Locale>::get(), 0, MID_LANG_LOCALE },
754 43 : {OUString(SC_UNONAME_COVER), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
755 43 : {OUString(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
756 43 : {OUString(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
757 43 : {OUString(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
758 43 : {OUString(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
759 43 : {OUString(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,cppu::UnoType<awt::FontSlant>::get(), 0, MID_POSTURE },
760 43 : {OUString(SC_UNONAME_CRELIEF), ATTR_FONT_RELIEF, cppu::UnoType<sal_Int16>::get(), 0, MID_RELIEF },
761 43 : {OUString(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, cppu::UnoType<bool>::get(), 0, 0 },
762 43 : {OUString(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,cppu::UnoType<sal_Int16>::get(), 0, MID_CROSS_OUT },
763 43 : {OUString(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int16>::get(), 0, MID_TL_STYLE },
764 43 : {OUString(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,cppu::UnoType<sal_Int32>::get(), 0, MID_TL_COLOR },
765 43 : {OUString(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,cppu::UnoType<bool>::get(), 0, MID_TL_HASCOLOR },
766 43 : {OUString(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, cppu::UnoType<float>::get(), 0, MID_WEIGHT },
767 43 : {OUString(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
768 43 : {OUString(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,cppu::UnoType<float>::get(), 0, MID_WEIGHT },
769 43 : {OUString(SC_UNONAME_CWORDMOD), ATTR_FONT_WORDLINE, cppu::UnoType<bool>::get(), 0, 0 },
770 43 : {OUString(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,cppu::UnoType<bool>::get(), 0, 0 },
771 43 : {OUString(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,cppu::UnoType<bool>::get(), 0, 0 },
772 43 : {OUString(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
773 43 : {OUString(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
774 43 : {OUString(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, cppu::UnoType<sheet::XSheetConditionalEntries>::get(), 0, 0 },
775 43 : {OUString(SC_UNONAME_COPYBACK), SC_WID_UNO_COPYBACK,cppu::UnoType<bool>::get(), 0, 0 },
776 43 : {OUString(SC_UNONAME_COPYFORM), SC_WID_UNO_COPYFORM,cppu::UnoType<bool>::get(), 0, 0 },
777 43 : {OUString(SC_UNONAME_COPYSTYL), SC_WID_UNO_COPYSTYL,cppu::UnoType<bool>::get(), 0, 0 },
778 43 : {OUString(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
779 43 : {OUString(SC_UNONAME_DIAGONAL_BLTR2), ATTR_BORDER_BLTR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
780 43 : {OUString(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine>::get(), 0, 0 | CONVERT_TWIPS },
781 43 : {OUString(SC_UNONAME_DIAGONAL_TLBR2), ATTR_BORDER_TLBR, ::cppu::UnoType<table::BorderLine2>::get(), 0, 0 | CONVERT_TWIPS },
782 43 : {OUString(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, cppu::UnoType<table::CellHoriJustify>::get(), 0, MID_HORJUST_HORJUST },
783 43 : {OUString(SC_UNONAME_CELLHJUS_METHOD), ATTR_HOR_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
784 43 : {OUString(SC_UNONAME_ISACTIVE), SC_WID_UNO_ISACTIVE,cppu::UnoType<bool>::get(), 0, 0 },
785 43 : {OUString(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
786 43 : {OUString(SC_UNONAME_WRAP), ATTR_LINEBREAK, cppu::UnoType<bool>::get(), 0, 0 },
787 43 : {OUString(SC_UNONAME_CELLVIS), SC_WID_UNO_CELLVIS, cppu::UnoType<bool>::get(), 0, 0 },
788 43 : {OUString(SC_UNONAME_LEFTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
789 43 : {OUString(SC_UNONAME_LEFTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, LEFT_BORDER | CONVERT_TWIPS },
790 43 : {OUString(SC_UNO_LINKDISPBIT), SC_WID_UNO_LINKDISPBIT,cppu::UnoType<awt::XBitmap>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
791 43 : {OUString(SC_UNO_LINKDISPNAME), SC_WID_UNO_LINKDISPNAME,cppu::UnoType<OUString>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
792 43 : {OUString(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, cppu::UnoType<sal_Int32>::get(), 0, 0 },
793 43 : {OUString(SC_UNONAME_NUMRULES), SC_WID_UNO_NUMRULES,cppu::UnoType<container::XIndexReplace>::get(), 0, 0 },
794 43 : {OUString(SC_UNONAME_CELLORI), ATTR_STACKED, cppu::UnoType<table::CellOrientation>::get(), 0, 0 },
795 43 : {OUString(SC_UNONAME_PAGESTL), SC_WID_UNO_PAGESTL, cppu::UnoType<OUString>::get(), 0, 0 },
796 43 : {OUString(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
797 43 : {OUString(SC_UNONAME_PBMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS },
798 43 : {OUString(SC_UNONAME_PINDENT), ATTR_INDENT, cppu::UnoType<sal_Int16>::get(), 0, 0 }, //! CONVERT_TWIPS
799 43 : {OUString(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, cppu::UnoType<bool>::get(), 0, 0 },
800 43 : {OUString(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,cppu::UnoType<bool>::get(), 0, 0 },
801 43 : {OUString(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,cppu::UnoType<bool>::get(), 0, 0 },
802 43 : {OUString(SC_UNONAME_PISHYPHEN),ATTR_HYPHENATE, cppu::UnoType<bool>::get(), 0, 0 },
803 43 : {OUString(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, ::cppu::UnoType<sal_Int16>::get(), 0, MID_HORJUST_ADJUST },
804 43 : {OUString(SC_UNONAME_PLMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS },
805 43 : {OUString(SC_UNONAME_PRMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS },
806 43 : {OUString(SC_UNONAME_PTMARGIN), ATTR_MARGIN, cppu::UnoType<sal_Int32>::get(), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS },
807 43 : {OUString(SC_UNONAME_POS), SC_WID_UNO_POS, cppu::UnoType<awt::Point>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
808 43 : {OUString(SC_UNONAME_PRINTBORD),SC_WID_UNO_PRINTBORD,cppu::UnoType<bool>::get(), 0, 0 },
809 43 : {OUString(SC_UNONAME_PROTECT), SC_WID_UNO_PROTECT, cppu::UnoType<bool>::get(), 0, 0 },
810 43 : {OUString(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
811 43 : {OUString(SC_UNONAME_RIGHTBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, RIGHT_BORDER | CONVERT_TWIPS },
812 43 : {OUString(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
813 43 : {OUString(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, cppu::UnoType<sal_Int32>::get(), 0, 0 },
814 43 : {OUString(SC_UNONAME_SHADOW), ATTR_SHADOW, cppu::UnoType<table::ShadowFormat>::get(), 0, 0 | CONVERT_TWIPS },
815 43 : {OUString(SC_UNONAME_SHOWBORD), SC_WID_UNO_SHOWBORD,cppu::UnoType<bool>::get(), 0, 0 },
816 43 : {OUString(SC_UNONAME_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, cppu::UnoType<bool>::get(), 0, 0 },
817 43 : {OUString(SC_UNONAME_SIZE), SC_WID_UNO_SIZE, cppu::UnoType<awt::Size>::get(), 0 | beans::PropertyAttribute::READONLY, 0 },
818 43 : {OUString(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, cppu::UnoType<table::TableBorder>::get(), 0, 0 | CONVERT_TWIPS },
819 43 : {OUString(SC_UNONAME_TBLBORD2), SC_WID_UNO_TBLBORD2, cppu::UnoType<table::TableBorder2>::get(), 0, 0 | CONVERT_TWIPS },
820 43 : {OUString(SC_UNONAME_TABLAYOUT),SC_WID_UNO_TABLAYOUT,cppu::UnoType<sal_Int16>::get(), 0, 0 },
821 43 : {OUString(SC_UNONAME_CONDFORMAT), SC_WID_UNO_CONDFORMAT, cppu::UnoType<sheet::XConditionalFormats>::get(), 0, 0},
822 43 : {OUString(SC_UNONAME_TOPBORDER),ATTR_BORDER, ::cppu::UnoType<table::BorderLine>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
823 43 : {OUString(SC_UNONAME_TOPBORDER2),ATTR_BORDER, ::cppu::UnoType<table::BorderLine2>::get(), 0, TOP_BORDER | CONVERT_TWIPS },
824 43 : {OUString(SC_UNONAME_USERDEF), ATTR_USERDEF, cppu::UnoType<container::XNameContainer>::get(), 0, 0 },
825 43 : {OUString(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
826 43 : {OUString(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
827 43 : {OUString(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, cppu::UnoType<beans::XPropertySet>::get(), 0, 0 },
828 43 : {OUString(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, cppu::UnoType<sal_Int32>::get(), 0, 0 },
829 43 : {OUString(SC_UNONAME_CELLVJUS_METHOD), ATTR_VER_JUSTIFY_METHOD, ::cppu::UnoType<sal_Int32>::get(), 0, 0 },
830 43 : {OUString(SC_UNONAME_WRITING), ATTR_WRITINGDIR, cppu::UnoType<sal_Int16>::get(), 0, 0 },
831 43 : {OUString(SC_UNONAME_TABCOLOR), SC_WID_UNO_TABCOLOR, cppu::UnoType<sal_Int32>::get(), 0, 0 },
832 43 : {OUString(SC_UNO_CODENAME), SC_WID_UNO_CODENAME, cppu::UnoType<OUString>::get(), 0, 0},
833 43 : {OUString(SC_UNO_NAMEDRANGES), SC_WID_UNO_NAMES, cppu::UnoType<sheet::XNamedRanges>::get(), 0, 0 },
834 : { OUString(), 0, css::uno::Type(), 0, 0 }
835 9581 : };
836 4593 : static SfxItemPropertySet aSheetPropertySet( aSheetPropertyMap_Impl );
837 4593 : return &aSheetPropertySet;
838 : }
839 :
840 4 : static const SfxItemPropertyMapEntry* lcl_GetEditPropertyMap()
841 : {
842 : static const SfxItemPropertyMapEntry aEditPropertyMap_Impl[] =
843 : {
844 200 : SVX_UNOEDIT_CHAR_PROPERTIES,
845 4 : SVX_UNOEDIT_FONT_PROPERTIES,
846 56 : SVX_UNOEDIT_PARA_PROPERTIES,
847 8 : SVX_UNOEDIT_NUMBERING_PROPERTIE, // for completeness of service ParagraphProperties
848 4 : {OUString(SC_UNONAME_TEXTUSER), EE_CHAR_XMLATTRIBS, cppu::UnoType<container::XNameContainer>::get(), 0, 0},
849 4 : {OUString(SC_UNONAME_USERDEF), EE_PARA_XMLATTRIBS, cppu::UnoType<container::XNameContainer>::get(), 0, 0},
850 : { OUString(), 0, css::uno::Type(), 0, 0 }
851 284 : };
852 4 : return aEditPropertyMap_Impl;
853 : }
854 10 : static const SvxItemPropertySet* lcl_GetEditPropertySet()
855 : {
856 10 : static SvxItemPropertySet aEditPropertySet( lcl_GetEditPropertyMap(), SdrObject::GetGlobalDrawObjectItemPool() );
857 10 : return &aEditPropertySet;
858 : }
859 :
860 : using sc::HMMToTwips;
861 : using sc::TwipsToHMM;
862 :
863 : #define SCCHARPROPERTIES_SERVICE "com.sun.star.style.CharacterProperties"
864 : #define SCPARAPROPERTIES_SERVICE "com.sun.star.style.ParagraphProperties"
865 : #define SCCELLPROPERTIES_SERVICE "com.sun.star.table.CellProperties"
866 : #define SCCELLRANGE_SERVICE "com.sun.star.table.CellRange"
867 : #define SCCELL_SERVICE "com.sun.star.table.Cell"
868 : #define SCSHEETCELLRANGES_SERVICE "com.sun.star.sheet.SheetCellRanges"
869 : #define SCSHEETCELLRANGE_SERVICE "com.sun.star.sheet.SheetCellRange"
870 : #define SCSPREADSHEET_SERVICE "com.sun.star.sheet.Spreadsheet"
871 : #define SCSHEETCELL_SERVICE "com.sun.star.sheet.SheetCell"
872 :
873 0 : SC_SIMPLE_SERVICE_INFO( ScCellFormatsEnumeration, "ScCellFormatsEnumeration", "com.sun.star.sheet.CellFormatRangesEnumeration" )
874 0 : SC_SIMPLE_SERVICE_INFO( ScCellFormatsObj, "ScCellFormatsObj", "com.sun.star.sheet.CellFormatRanges" )
875 1 : SC_SIMPLE_SERVICE_INFO( ScUniqueCellFormatsEnumeration, "ScUniqueCellFormatsEnumeration", "com.sun.star.sheet.UniqueCellFormatRangesEnumeration" )
876 1 : SC_SIMPLE_SERVICE_INFO( ScUniqueCellFormatsObj, "ScUniqueCellFormatsObj", "com.sun.star.sheet.UniqueCellFormatRanges" )
877 0 : SC_SIMPLE_SERVICE_INFO( ScCellRangesBase, "ScCellRangesBase", "stardiv.unknown" )
878 0 : SC_SIMPLE_SERVICE_INFO( ScCellsEnumeration, "ScCellsEnumeration", "com.sun.star.sheet.CellsEnumeration" )
879 0 : SC_SIMPLE_SERVICE_INFO( ScCellsObj, "ScCellsObj", "com.sun.star.sheet.Cells" )
880 0 : SC_SIMPLE_SERVICE_INFO( ScTableColumnObj, "ScTableColumnObj", "com.sun.star.table.TableColumn" )
881 0 : SC_SIMPLE_SERVICE_INFO( ScTableRowObj, "ScTableRowObj", "com.sun.star.table.TableRow" )
882 :
883 : //! ScLinkListener in anderes File verschieben !!!
884 :
885 8226 : ScLinkListener::~ScLinkListener()
886 : {
887 8226 : }
888 :
889 593 : void ScLinkListener::Notify( const SfxHint& rHint )
890 : {
891 593 : aLink.Call( const_cast<SfxHint*>(&rHint) );
892 593 : }
893 :
894 1 : static void lcl_CopyProperties( beans::XPropertySet& rDest, beans::XPropertySet& rSource )
895 : {
896 1 : uno::Reference<beans::XPropertySetInfo> xInfo(rSource.getPropertySetInfo());
897 1 : if (xInfo.is())
898 : {
899 1 : uno::Sequence<beans::Property> aSeq(xInfo->getProperties());
900 1 : const beans::Property* pAry = aSeq.getConstArray();
901 1 : sal_uLong nCount = aSeq.getLength();
902 10 : for (sal_uLong i=0; i<nCount; i++)
903 : {
904 9 : OUString aName(pAry[i].Name);
905 9 : rDest.setPropertyValue( aName, rSource.getPropertyValue( aName ) );
906 10 : }
907 1 : }
908 1 : }
909 :
910 61 : static SCTAB lcl_FirstTab( const ScRangeList& rRanges )
911 : {
912 : OSL_ENSURE(rRanges.size() >= 1, "was fuer Ranges ?!?!");
913 61 : const ScRange* pFirst = rRanges[ 0 ];
914 61 : if (pFirst)
915 61 : return pFirst->aStart.Tab();
916 :
917 0 : return 0; // soll nicht sein
918 : }
919 :
920 79 : static bool lcl_WholeSheet( const ScRangeList& rRanges )
921 : {
922 79 : if ( rRanges.size() == 1 )
923 : {
924 72 : const ScRange* pRange = rRanges[0];
925 156 : if ( pRange && pRange->aStart.Col() == 0 && pRange->aEnd.Col() == MAXCOL &&
926 96 : pRange->aStart.Row() == 0 && pRange->aEnd.Row() == MAXROW )
927 12 : return true;
928 : }
929 67 : return false;
930 : }
931 :
932 : namespace {
933 : template<typename BorderLineType>
934 36 : const ::editeng::SvxBorderLine* lcl_getBorderLine(
935 : ::editeng::SvxBorderLine& rLine, const BorderLineType& rStruct )
936 : {
937 : // Convert from 1/100mm to Twips.
938 36 : if (!SvxBoxItem::LineToSvxLine( rStruct, rLine, true))
939 36 : return NULL;
940 :
941 0 : if ( rLine.GetOutWidth() || rLine.GetInWidth() || rLine.GetDistance() )
942 0 : return &rLine;
943 : else
944 0 : return NULL;
945 : }
946 : }
947 :
948 36 : const ::editeng::SvxBorderLine* ScHelperFunctions::GetBorderLine(
949 : ::editeng::SvxBorderLine& rLine, const table::BorderLine& rStruct )
950 : {
951 36 : return lcl_getBorderLine( rLine, rStruct);
952 : }
953 :
954 0 : const ::editeng::SvxBorderLine* ScHelperFunctions::GetBorderLine(
955 : ::editeng::SvxBorderLine& rLine, const table::BorderLine2& rStruct )
956 : {
957 0 : return lcl_getBorderLine( rLine, rStruct);
958 : }
959 :
960 : namespace {
961 : template<typename TableBorderType>
962 6 : void lcl_fillBoxItems( SvxBoxItem& rOuter, SvxBoxInfoItem& rInner, const TableBorderType& rBorder )
963 : {
964 6 : ::editeng::SvxBorderLine aLine;
965 6 : rOuter.SetDistance( static_cast<sal_uInt16>(HMMToTwips( rBorder.Distance )) );
966 6 : rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.TopLine ), SvxBoxItemLine::TOP );
967 6 : rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.BottomLine ), SvxBoxItemLine::BOTTOM );
968 6 : rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.LeftLine ), SvxBoxItemLine::LEFT );
969 6 : rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.RightLine ), SvxBoxItemLine::RIGHT );
970 6 : rInner.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.HorizontalLine ), SvxBoxInfoItemLine::HORI );
971 6 : rInner.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.VerticalLine ), SvxBoxInfoItemLine::VERT );
972 6 : rInner.SetValid( SvxBoxInfoItemValidFlags::TOP, rBorder.IsTopLineValid );
973 6 : rInner.SetValid( SvxBoxInfoItemValidFlags::BOTTOM, rBorder.IsBottomLineValid );
974 6 : rInner.SetValid( SvxBoxInfoItemValidFlags::LEFT, rBorder.IsLeftLineValid );
975 6 : rInner.SetValid( SvxBoxInfoItemValidFlags::RIGHT, rBorder.IsRightLineValid );
976 6 : rInner.SetValid( SvxBoxInfoItemValidFlags::HORI, rBorder.IsHorizontalLineValid );
977 6 : rInner.SetValid( SvxBoxInfoItemValidFlags::VERT, rBorder.IsVerticalLineValid );
978 6 : rInner.SetValid( SvxBoxInfoItemValidFlags::DISTANCE, rBorder.IsDistanceValid );
979 6 : rInner.SetTable( true );
980 6 : }
981 : }
982 :
983 6 : void ScHelperFunctions::FillBoxItems( SvxBoxItem& rOuter, SvxBoxInfoItem& rInner, const table::TableBorder& rBorder )
984 : {
985 6 : lcl_fillBoxItems( rOuter, rInner, rBorder);
986 6 : }
987 :
988 0 : void ScHelperFunctions::FillBoxItems( SvxBoxItem& rOuter, SvxBoxInfoItem& rInner, const table::TableBorder2& rBorder )
989 : {
990 0 : lcl_fillBoxItems( rOuter, rInner, rBorder);
991 0 : }
992 :
993 186 : void ScHelperFunctions::FillBorderLine( table::BorderLine& rStruct, const ::editeng::SvxBorderLine* pLine )
994 : {
995 : // Convert from Twips to 1/100mm.
996 186 : table::BorderLine2 aStruct( SvxBoxItem::SvxLineToLine( pLine, true));
997 186 : rStruct = aStruct;
998 186 : }
999 :
1000 90 : void ScHelperFunctions::FillBorderLine( table::BorderLine2& rStruct, const ::editeng::SvxBorderLine* pLine )
1001 : {
1002 90 : rStruct = SvxBoxItem::SvxLineToLine( pLine, true);
1003 90 : }
1004 :
1005 : namespace {
1006 : template<typename TableBorderItem>
1007 46 : void lcl_fillTableBorder( TableBorderItem& rBorder, const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner,
1008 : bool bInvalidateHorVerDist )
1009 : {
1010 46 : ScHelperFunctions::FillBorderLine( rBorder.TopLine, rOuter.GetTop() );
1011 46 : ScHelperFunctions::FillBorderLine( rBorder.BottomLine, rOuter.GetBottom() );
1012 46 : ScHelperFunctions::FillBorderLine( rBorder.LeftLine, rOuter.GetLeft() );
1013 46 : ScHelperFunctions::FillBorderLine( rBorder.RightLine, rOuter.GetRight() );
1014 46 : ScHelperFunctions::FillBorderLine( rBorder.HorizontalLine, rInner.GetHori() );
1015 46 : ScHelperFunctions::FillBorderLine( rBorder.VerticalLine, rInner.GetVert() );
1016 :
1017 46 : rBorder.Distance = rOuter.GetDistance();
1018 46 : rBorder.IsTopLineValid = rInner.IsValid(SvxBoxInfoItemValidFlags::TOP);
1019 46 : rBorder.IsBottomLineValid = rInner.IsValid(SvxBoxInfoItemValidFlags::BOTTOM);
1020 46 : rBorder.IsLeftLineValid = rInner.IsValid(SvxBoxInfoItemValidFlags::LEFT);
1021 46 : rBorder.IsRightLineValid = rInner.IsValid(SvxBoxInfoItemValidFlags::RIGHT);
1022 46 : rBorder.IsHorizontalLineValid = !bInvalidateHorVerDist && rInner.IsValid(SvxBoxInfoItemValidFlags::HORI);
1023 46 : rBorder.IsVerticalLineValid = !bInvalidateHorVerDist && rInner.IsValid(SvxBoxInfoItemValidFlags::VERT);
1024 46 : rBorder.IsDistanceValid = !bInvalidateHorVerDist && rInner.IsValid(SvxBoxInfoItemValidFlags::DISTANCE);
1025 46 : }
1026 : }
1027 :
1028 31 : void ScHelperFunctions::AssignTableBorderToAny( uno::Any& rAny,
1029 : const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner, bool bInvalidateHorVerDist )
1030 : {
1031 31 : table::TableBorder aBorder;
1032 31 : lcl_fillTableBorder( aBorder, rOuter, rInner, bInvalidateHorVerDist);
1033 31 : rAny <<= aBorder;
1034 31 : }
1035 :
1036 15 : void ScHelperFunctions::AssignTableBorder2ToAny( uno::Any& rAny,
1037 : const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner, bool bInvalidateHorVerDist )
1038 : {
1039 15 : table::TableBorder2 aBorder;
1040 15 : lcl_fillTableBorder( aBorder, rOuter, rInner, bInvalidateHorVerDist);
1041 15 : rAny <<= aBorder;
1042 15 : }
1043 :
1044 : //! lcl_ApplyBorder nach docfunc verschieben!
1045 :
1046 4 : void ScHelperFunctions::ApplyBorder( ScDocShell* pDocShell, const ScRangeList& rRanges,
1047 : const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner )
1048 : {
1049 4 : ScDocument& rDoc = pDocShell->GetDocument();
1050 4 : bool bUndo(rDoc.IsUndoEnabled());
1051 4 : ScDocument* pUndoDoc = NULL;
1052 4 : if (bUndo)
1053 4 : pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1054 4 : size_t nCount = rRanges.size();
1055 8 : for (size_t i = 0; i < nCount; ++i)
1056 : {
1057 4 : ScRange aRange( *rRanges[ i ] );
1058 4 : SCTAB nTab = aRange.aStart.Tab();
1059 :
1060 4 : if (bUndo)
1061 : {
1062 4 : if ( i==0 )
1063 4 : pUndoDoc->InitUndo( &rDoc, nTab, nTab );
1064 : else
1065 0 : pUndoDoc->AddUndoTab( nTab, nTab );
1066 4 : rDoc.CopyToDocument( aRange, IDF_ATTRIB, false, pUndoDoc );
1067 : }
1068 :
1069 4 : ScMarkData aMark;
1070 4 : aMark.SetMarkArea( aRange );
1071 4 : aMark.SelectTable( nTab, true );
1072 :
1073 4 : rDoc.ApplySelectionFrame( aMark, &rOuter, &rInner );
1074 : // RowHeight bei Umrandung alleine nicht noetig
1075 4 : }
1076 :
1077 4 : if (bUndo)
1078 : {
1079 4 : pDocShell->GetUndoManager()->AddUndoAction(
1080 4 : new ScUndoBorder( pDocShell, rRanges, pUndoDoc, rOuter, rInner ) );
1081 : }
1082 :
1083 8 : for (size_t i = 0; i < nCount; ++i )
1084 4 : pDocShell->PostPaint( *rRanges[ i ], PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
1085 :
1086 4 : pDocShell->SetDocumentModified();
1087 4 : }
1088 :
1089 : //! move lcl_PutDataArray to docfunc?
1090 : //! merge loop with ScFunctionAccess::callFunction
1091 :
1092 8 : static bool lcl_PutDataArray( ScDocShell& rDocShell, const ScRange& rRange,
1093 : const uno::Sequence< uno::Sequence<uno::Any> >& aData )
1094 : {
1095 8 : ScDocument& rDoc = rDocShell.GetDocument();
1096 8 : SCTAB nTab = rRange.aStart.Tab();
1097 8 : SCCOL nStartCol = rRange.aStart.Col();
1098 8 : SCROW nStartRow = rRange.aStart.Row();
1099 8 : SCCOL nEndCol = rRange.aEnd.Col();
1100 8 : SCROW nEndRow = rRange.aEnd.Row();
1101 8 : bool bUndo(rDoc.IsUndoEnabled());
1102 :
1103 8 : if ( !rDoc.IsBlockEditable( nTab, nStartCol,nStartRow, nEndCol,nEndRow ) )
1104 : {
1105 : //! error message
1106 0 : return false;
1107 : }
1108 :
1109 8 : long nCols = 0;
1110 8 : long nRows = aData.getLength();
1111 8 : const uno::Sequence<uno::Any>* pArray = aData.getConstArray();
1112 8 : if ( nRows )
1113 8 : nCols = pArray[0].getLength();
1114 :
1115 8 : if ( nCols != nEndCol-nStartCol+1 || nRows != nEndRow-nStartRow+1 )
1116 : {
1117 : //! error message?
1118 0 : return false;
1119 : }
1120 :
1121 8 : ScDocument* pUndoDoc = NULL;
1122 8 : if ( bUndo )
1123 : {
1124 8 : pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1125 8 : pUndoDoc->InitUndo( &rDoc, nTab, nTab );
1126 8 : rDoc.CopyToDocument( rRange, IDF_CONTENTS|IDF_NOCAPTIONS, false, pUndoDoc );
1127 : }
1128 :
1129 8 : rDoc.DeleteAreaTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, IDF_CONTENTS );
1130 :
1131 8 : bool bError = false;
1132 8 : SCROW nDocRow = nStartRow;
1133 416 : for (long nRow=0; nRow<nRows; nRow++)
1134 : {
1135 408 : const uno::Sequence<uno::Any>& rColSeq = pArray[nRow];
1136 408 : if ( rColSeq.getLength() == nCols )
1137 : {
1138 408 : SCCOL nDocCol = nStartCol;
1139 408 : const uno::Any* pColArr = rColSeq.getConstArray();
1140 20440 : for (long nCol=0; nCol<nCols; nCol++)
1141 : {
1142 20032 : ScAddress aPos(nDocCol, nDocRow, nTab);
1143 :
1144 20032 : const uno::Any& rElement = pColArr[nCol];
1145 20032 : switch( rElement.getValueTypeClass() )
1146 : {
1147 : case uno::TypeClass_VOID:
1148 : {
1149 : // void = "no value"
1150 0 : rDoc.SetError( nDocCol, nDocRow, nTab, NOTAVAILABLE );
1151 : }
1152 0 : break;
1153 :
1154 : // #87871# accept integer types because Basic passes a floating point
1155 : // variable as byte, short or long if it's an integer number.
1156 : case uno::TypeClass_BYTE:
1157 : case uno::TypeClass_SHORT:
1158 : case uno::TypeClass_UNSIGNED_SHORT:
1159 : case uno::TypeClass_LONG:
1160 : case uno::TypeClass_UNSIGNED_LONG:
1161 : case uno::TypeClass_FLOAT:
1162 : case uno::TypeClass_DOUBLE:
1163 : {
1164 20032 : double fVal(0.0);
1165 20032 : rElement >>= fVal;
1166 20032 : rDoc.SetValue(aPos, fVal);
1167 : }
1168 20032 : break;
1169 :
1170 : case uno::TypeClass_STRING:
1171 : {
1172 0 : OUString aUStr;
1173 0 : rElement >>= aUStr;
1174 0 : if ( !aUStr.isEmpty() )
1175 : {
1176 0 : ScSetStringParam aParam;
1177 0 : aParam.setTextInput();
1178 0 : rDoc.SetString(aPos, aUStr, &aParam);
1179 0 : }
1180 : }
1181 0 : break;
1182 :
1183 : // accept Sequence<FormulaToken> for formula cells
1184 : case uno::TypeClass_SEQUENCE:
1185 : {
1186 0 : uno::Sequence< sheet::FormulaToken > aTokens;
1187 0 : if ( rElement >>= aTokens )
1188 : {
1189 0 : ScTokenArray aTokenArray;
1190 0 : ScTokenConversion::ConvertToTokenArray( rDoc, aTokenArray, aTokens );
1191 0 : rDoc.SetFormula(aPos, aTokenArray);
1192 : }
1193 : else
1194 0 : bError = true;
1195 : }
1196 0 : break;
1197 :
1198 : default:
1199 0 : bError = true; // invalid type
1200 : }
1201 20032 : ++nDocCol;
1202 : }
1203 : }
1204 : else
1205 0 : bError = true; // wrong size
1206 :
1207 408 : ++nDocRow;
1208 : }
1209 :
1210 8 : bool bHeight = rDocShell.AdjustRowHeight( nStartRow, nEndRow, nTab );
1211 :
1212 8 : if ( pUndoDoc )
1213 : {
1214 8 : ScMarkData aDestMark;
1215 8 : aDestMark.SelectOneTable( nTab );
1216 8 : rDocShell.GetUndoManager()->AddUndoAction(
1217 : new ScUndoPaste(
1218 : &rDocShell, ScRange(nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab),
1219 8 : aDestMark, pUndoDoc, NULL, IDF_CONTENTS, NULL, false));
1220 : }
1221 :
1222 8 : if (!bHeight)
1223 8 : rDocShell.PostPaint( rRange, PAINT_GRID ); // AdjustRowHeight may have painted already
1224 :
1225 8 : rDocShell.SetDocumentModified();
1226 :
1227 8 : return !bError;
1228 : }
1229 :
1230 2 : static bool lcl_PutFormulaArray( ScDocShell& rDocShell, const ScRange& rRange,
1231 : const uno::Sequence< uno::Sequence<OUString> >& aData,
1232 : const formula::FormulaGrammar::Grammar eGrammar )
1233 : {
1234 2 : ScDocument& rDoc = rDocShell.GetDocument();
1235 2 : SCTAB nTab = rRange.aStart.Tab();
1236 2 : SCCOL nStartCol = rRange.aStart.Col();
1237 2 : SCROW nStartRow = rRange.aStart.Row();
1238 2 : SCCOL nEndCol = rRange.aEnd.Col();
1239 2 : SCROW nEndRow = rRange.aEnd.Row();
1240 2 : bool bUndo(rDoc.IsUndoEnabled());
1241 :
1242 2 : if ( !rDoc.IsBlockEditable( nTab, nStartCol,nStartRow, nEndCol,nEndRow ) )
1243 : {
1244 : //! error message
1245 0 : return false;
1246 : }
1247 :
1248 2 : long nCols = 0;
1249 2 : long nRows = aData.getLength();
1250 2 : const uno::Sequence<OUString>* pArray = aData.getConstArray();
1251 2 : if ( nRows )
1252 2 : nCols = pArray[0].getLength();
1253 :
1254 2 : if ( nCols != nEndCol-nStartCol+1 || nRows != nEndRow-nStartRow+1 )
1255 : {
1256 : //! error message?
1257 0 : return false;
1258 : }
1259 :
1260 2 : ScDocument* pUndoDoc = NULL;
1261 2 : if ( bUndo )
1262 : {
1263 2 : pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1264 2 : pUndoDoc->InitUndo( &rDoc, nTab, nTab );
1265 2 : rDoc.CopyToDocument( rRange, IDF_CONTENTS, false, pUndoDoc );
1266 : }
1267 :
1268 2 : rDoc.DeleteAreaTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, IDF_CONTENTS );
1269 :
1270 2 : bool bError = false;
1271 2 : SCROW nDocRow = nStartRow;
1272 12 : for (long nRow=0; nRow<nRows; nRow++)
1273 : {
1274 10 : const uno::Sequence<OUString>& rColSeq = pArray[nRow];
1275 10 : if ( rColSeq.getLength() == nCols )
1276 : {
1277 10 : SCCOL nDocCol = nStartCol;
1278 10 : const OUString* pColArr = rColSeq.getConstArray();
1279 50 : for (long nCol=0; nCol<nCols; nCol++)
1280 : {
1281 40 : OUString aText(pColArr[nCol]);
1282 40 : ScAddress aPos( nDocCol, nDocRow, nTab );
1283 :
1284 : ScInputStringType aRes =
1285 : ScStringUtil::parseInputString(
1286 80 : *rDoc.GetFormatTable(), aText, LANGUAGE_ENGLISH_US);
1287 40 : switch (aRes.meType)
1288 : {
1289 : case ScInputStringType::Formula:
1290 0 : rDoc.SetFormula(aPos, aRes.maText, eGrammar);
1291 0 : break;
1292 : case ScInputStringType::Number:
1293 0 : rDoc.SetValue(aPos, aRes.mfValue);
1294 0 : break;
1295 : case ScInputStringType::Text:
1296 1 : rDoc.SetTextCell(aPos, aRes.maText);
1297 1 : break;
1298 : default:
1299 : ;
1300 : }
1301 :
1302 40 : ++nDocCol;
1303 40 : }
1304 : }
1305 : else
1306 0 : bError = true; // wrong size
1307 :
1308 10 : ++nDocRow;
1309 : }
1310 :
1311 2 : bool bHeight = rDocShell.AdjustRowHeight( nStartRow, nEndRow, nTab );
1312 :
1313 2 : if ( pUndoDoc )
1314 : {
1315 2 : ScMarkData aDestMark;
1316 2 : aDestMark.SelectOneTable( nTab );
1317 2 : rDocShell.GetUndoManager()->AddUndoAction(
1318 : new ScUndoPaste( &rDocShell,
1319 : ScRange(nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab), aDestMark,
1320 2 : pUndoDoc, NULL, IDF_CONTENTS, NULL, false));
1321 : }
1322 :
1323 2 : if (!bHeight)
1324 2 : rDocShell.PostPaint( rRange, PAINT_GRID ); // AdjustRowHeight may have painted already
1325 :
1326 2 : rDocShell.SetDocumentModified();
1327 :
1328 2 : return !bError;
1329 : }
1330 :
1331 : // used in ScCellRangeObj::getFormulaArray and ScCellObj::GetInputString_Impl
1332 226 : static OUString lcl_GetInputString( ScDocument& rDoc, const ScAddress& rPos, bool bEnglish )
1333 : {
1334 226 : ScRefCellValue aCell;
1335 226 : aCell.assign(rDoc, rPos);
1336 226 : if (aCell.isEmpty())
1337 111 : return EMPTY_OUSTRING;
1338 :
1339 230 : OUString aVal;
1340 :
1341 115 : CellType eType = aCell.meType;
1342 115 : if (eType == CELLTYPE_FORMULA)
1343 : {
1344 61 : ScFormulaCell* pForm = aCell.mpFormula;
1345 61 : pForm->GetFormula( aVal, formula::FormulaGrammar::mapAPItoGrammar( bEnglish, false));
1346 61 : return aVal;
1347 : }
1348 :
1349 : SvNumberFormatter* pFormatter = bEnglish ? ScGlobal::GetEnglishFormatter() :
1350 54 : rDoc.GetFormatTable();
1351 : // Since the English formatter was constructed with
1352 : // LANGUAGE_ENGLISH_US the "General" format has index key 0,
1353 : // we don't have to query.
1354 54 : sal_uInt32 nNumFmt = bEnglish ? 0 : rDoc.GetNumberFormat(rPos);
1355 :
1356 54 : if (eType == CELLTYPE_EDIT)
1357 : {
1358 : // GetString an der EditCell macht Leerzeichen aus Umbruechen,
1359 : // hier werden die Umbrueche aber gebraucht
1360 0 : const EditTextObject* pData = aCell.mpEditText;
1361 0 : if (pData)
1362 : {
1363 0 : EditEngine& rEngine = rDoc.GetEditEngine();
1364 0 : rEngine.SetText(*pData);
1365 0 : aVal = rEngine.GetText(LINEEND_LF);
1366 : }
1367 : }
1368 : else
1369 54 : ScCellFormat::GetInputString(aCell, nNumFmt, aVal, *pFormatter, &rDoc);
1370 :
1371 : // ggf. ein ' davorhaengen wie in ScTabViewShell::UpdateInputHandler
1372 54 : if ( eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT )
1373 : {
1374 : double fDummy;
1375 24 : OUString aTempString = aVal;
1376 24 : bool bIsNumberFormat(pFormatter->IsNumberFormat(aTempString, nNumFmt, fDummy));
1377 24 : if ( bIsNumberFormat )
1378 0 : aTempString = "'" + aTempString;
1379 24 : else if ( aTempString.startsWith("'") )
1380 : {
1381 : // if the string starts with a "'", add another one because setFormula
1382 : // strips one (like text input, except for "text" number formats)
1383 0 : if ( bEnglish || ( pFormatter->GetType(nNumFmt) != css::util::NumberFormat::TEXT ) )
1384 0 : aTempString = "'" + aTempString;
1385 : }
1386 24 : aVal = aTempString;
1387 : }
1388 280 : return aVal;
1389 : }
1390 :
1391 31978 : ScCellRangesBase::ScCellRangesBase(ScDocShell* pDocSh, const ScRange& rR) :
1392 31978 : pPropSet(lcl_GetCellsPropertySet()),
1393 : pDocShell( pDocSh ),
1394 : pValueListener( NULL ),
1395 : pCurrentFlat( NULL ),
1396 : pCurrentDeep( NULL ),
1397 : pCurrentDataSet( NULL ),
1398 : pNoDfltCurrentDataSet( NULL ),
1399 : pMarkData( NULL ),
1400 : nObjectId( 0 ),
1401 : bChartColAsHdr( false ),
1402 : bChartRowAsHdr( false ),
1403 : bCursorOnly( false ),
1404 : bGotDataChangedHint( false ),
1405 63956 : aValueListeners( 0 )
1406 : {
1407 : // this is a hack to get m_wThis initialized; ideally there would be
1408 : // factory functions doing this but there are so many subclasses of this...
1409 31978 : ++m_refCount;
1410 : {
1411 63956 : m_wThis = uno::Reference<uno::XInterface>(
1412 31978 : static_cast<cppu::OWeakObject*>(this));
1413 : }
1414 31978 : --m_refCount;
1415 :
1416 31978 : ScRange aCellRange(rR);
1417 31978 : aCellRange.Justify();
1418 31978 : aRanges.Append( aCellRange );
1419 :
1420 31978 : if (pDocShell) // Null if created with createInstance
1421 : {
1422 31977 : ScDocument& rDoc = pDocShell->GetDocument();
1423 31977 : rDoc.AddUnoObject(*this);
1424 31977 : nObjectId = rDoc.GetNewUnoId();
1425 : }
1426 31978 : }
1427 :
1428 2042 : ScCellRangesBase::ScCellRangesBase(ScDocShell* pDocSh, const ScRangeList& rR) :
1429 2042 : pPropSet(lcl_GetCellsPropertySet()),
1430 : pDocShell( pDocSh ),
1431 : pValueListener( NULL ),
1432 : pCurrentFlat( NULL ),
1433 : pCurrentDeep( NULL ),
1434 : pCurrentDataSet( NULL ),
1435 : pNoDfltCurrentDataSet( NULL ),
1436 : pMarkData( NULL ),
1437 : aRanges( rR ),
1438 : nObjectId( 0 ),
1439 : bChartColAsHdr( false ),
1440 : bChartRowAsHdr( false ),
1441 : bCursorOnly( false ),
1442 : bGotDataChangedHint( false ),
1443 4084 : aValueListeners( 0 )
1444 : {
1445 : // this is a hack to get m_wThis initialized; ideally there would be
1446 : // factory functions doing this but there are so many subclasses of this...
1447 2042 : ++m_refCount;
1448 : {
1449 4084 : m_wThis = uno::Reference<uno::XInterface>(
1450 2042 : static_cast<cppu::OWeakObject*>(this));
1451 : }
1452 2042 : --m_refCount;
1453 :
1454 2042 : if (pDocShell) // Null if created with createInstance
1455 : {
1456 2042 : ScDocument& rDoc = pDocShell->GetDocument();
1457 2042 : rDoc.AddUnoObject(*this);
1458 2042 : nObjectId = rDoc.GetNewUnoId();
1459 : }
1460 2042 : }
1461 :
1462 67816 : ScCellRangesBase::~ScCellRangesBase()
1463 : {
1464 33908 : SolarMutexGuard g;
1465 :
1466 : // call RemoveUnoObject first, so no notification can happen
1467 : // during ForgetCurrentAttrs
1468 :
1469 33908 : if (pDocShell)
1470 30274 : pDocShell->GetDocument().RemoveUnoObject(*this);
1471 :
1472 33908 : ForgetCurrentAttrs();
1473 33908 : ForgetMarkData();
1474 :
1475 33908 : delete pValueListener;
1476 :
1477 : //! XChartDataChangeEventListener abmelden ??
1478 : //! (ChartCollection haelt dann auch dieses Objekt fest!)
1479 33908 : }
1480 :
1481 222946 : void ScCellRangesBase::ForgetCurrentAttrs()
1482 : {
1483 222946 : delete pCurrentFlat;
1484 222946 : delete pCurrentDeep;
1485 222946 : delete pCurrentDataSet;
1486 222946 : delete pNoDfltCurrentDataSet;
1487 222946 : pCurrentFlat = NULL;
1488 222946 : pCurrentDeep = NULL;
1489 222946 : pCurrentDataSet = NULL;
1490 222946 : pNoDfltCurrentDataSet = NULL;
1491 :
1492 : // #i62483# pMarkData can remain unchanged, is deleted only if the range changes (RefChanged)
1493 222946 : }
1494 :
1495 40276 : void ScCellRangesBase::ForgetMarkData()
1496 : {
1497 40276 : delete pMarkData;
1498 40276 : pMarkData = NULL;
1499 40276 : }
1500 :
1501 7895 : const ScPatternAttr* ScCellRangesBase::GetCurrentAttrsFlat()
1502 : {
1503 : // get and cache direct cell attributes for this object's range
1504 :
1505 7895 : if ( !pCurrentFlat && pDocShell )
1506 : {
1507 171 : ScDocument& rDoc = pDocShell->GetDocument();
1508 171 : pCurrentFlat = rDoc.CreateSelectionPattern( *GetMarkData(), false );
1509 : }
1510 7895 : return pCurrentFlat;
1511 : }
1512 :
1513 7718 : const ScPatternAttr* ScCellRangesBase::GetCurrentAttrsDeep()
1514 : {
1515 : // get and cache cell attributes (incl. styles) for this object's range
1516 :
1517 7718 : if ( !pCurrentDeep && pDocShell )
1518 : {
1519 7221 : ScDocument& rDoc = pDocShell->GetDocument();
1520 7221 : pCurrentDeep = rDoc.CreateSelectionPattern( *GetMarkData(), true );
1521 : }
1522 7718 : return pCurrentDeep;
1523 : }
1524 :
1525 9808 : SfxItemSet* ScCellRangesBase::GetCurrentDataSet(bool bNoDflt)
1526 : {
1527 9808 : if(!pCurrentDataSet)
1528 : {
1529 5662 : const ScPatternAttr* pPattern = GetCurrentAttrsDeep();
1530 5662 : if ( pPattern )
1531 : {
1532 : // Dontcare durch Default ersetzen, damit man immer eine Reflection hat
1533 5662 : pCurrentDataSet = new SfxItemSet( pPattern->GetItemSet() );
1534 5662 : pNoDfltCurrentDataSet = new SfxItemSet( pPattern->GetItemSet() );
1535 5662 : pCurrentDataSet->ClearInvalidItems();
1536 : }
1537 : }
1538 9808 : return bNoDflt ? pNoDfltCurrentDataSet : pCurrentDataSet;
1539 : }
1540 :
1541 11235 : const ScMarkData* ScCellRangesBase::GetMarkData()
1542 : {
1543 11235 : if (!pMarkData)
1544 : {
1545 6767 : pMarkData = new ScMarkData();
1546 6767 : pMarkData->MarkFromRangeList( aRanges, false );
1547 : }
1548 11235 : return pMarkData;
1549 : }
1550 :
1551 186441 : void ScCellRangesBase::Notify( SfxBroadcaster&, const SfxHint& rHint )
1552 : {
1553 186441 : uno::Reference<uno::XInterface> const xThis(m_wThis);
1554 186441 : if (!xThis.is())
1555 : { // fdo#72695: if UNO object is already dead, don't revive it with event
1556 0 : if (dynamic_cast<const SfxSimpleHint*>(&rHint) &&
1557 0 : SFX_HINT_DYING == static_cast<const SfxSimpleHint&>(rHint).GetId())
1558 : { // if the document dies, must reset to avoid crash in dtor!
1559 0 : ForgetCurrentAttrs();
1560 0 : pDocShell = nullptr;
1561 : }
1562 186441 : return;
1563 : }
1564 186441 : if ( dynamic_cast<const ScUpdateRefHint*>(&rHint) )
1565 : {
1566 1793 : const ScUpdateRefHint& rRef = static_cast<const ScUpdateRefHint&>(rHint);
1567 :
1568 1793 : ScDocument& rDoc = pDocShell->GetDocument();
1569 1793 : boost::scoped_ptr<ScRangeList> pUndoRanges;
1570 1793 : if ( rDoc.HasUnoRefUndo() )
1571 1085 : pUndoRanges.reset(new ScRangeList( aRanges ));
1572 :
1573 3586 : if ( aRanges.UpdateReference( rRef.GetMode(), &rDoc, rRef.GetRange(),
1574 3586 : rRef.GetDx(), rRef.GetDy(), rRef.GetDz() ) )
1575 : {
1576 3266 : if ( rRef.GetMode() == URM_INSDEL
1577 1632 : && aRanges.size() == 1
1578 3231 : && ScTableSheetObj::getImplementation(xThis)
1579 : )
1580 : {
1581 : // #101755#; the range size of a sheet does not change
1582 245 : ScRange* pR = aRanges.front();
1583 245 : if (pR)
1584 : {
1585 245 : pR->aStart.SetCol(0);
1586 245 : pR->aStart.SetRow(0);
1587 245 : pR->aEnd.SetCol(MAXCOL);
1588 245 : pR->aEnd.SetRow(MAXROW);
1589 : }
1590 : }
1591 1633 : RefChanged();
1592 :
1593 : // any change of the range address is broadcast to value (modify) listeners
1594 1633 : if ( !aValueListeners.empty() )
1595 0 : bGotDataChangedHint = true;
1596 :
1597 1633 : if ( pUndoRanges )
1598 981 : rDoc.AddUnoRefChange( nObjectId, *pUndoRanges );
1599 1793 : }
1600 : }
1601 184648 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) )
1602 : {
1603 182951 : sal_uLong nId = static_cast<const SfxSimpleHint&>(rHint).GetId();
1604 182951 : if ( nId == SFX_HINT_DYING )
1605 : {
1606 3745 : ForgetCurrentAttrs();
1607 3745 : pDocShell = NULL; // invalid
1608 :
1609 3745 : if ( !aValueListeners.empty() )
1610 : {
1611 : // dispose listeners
1612 :
1613 4 : lang::EventObject aEvent;
1614 4 : aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
1615 8 : for ( size_t n=0; n<aValueListeners.size(); n++ )
1616 4 : aValueListeners[n]->disposing( aEvent );
1617 :
1618 4 : aValueListeners.clear();
1619 :
1620 : // The listeners can't have the last ref to this, as it's still held
1621 : // by the DocShell.
1622 : }
1623 : }
1624 179206 : else if ( nId == SFX_HINT_DATACHANGED )
1625 : {
1626 : // document content changed -> forget cached attributes
1627 178925 : ForgetCurrentAttrs();
1628 :
1629 178925 : if ( bGotDataChangedHint && pDocShell )
1630 : {
1631 : // This object was notified of content changes, so one call
1632 : // for each listener is generated now.
1633 : // The calls can't be executed directly because the document's
1634 : // UNO broadcaster list must not be modified.
1635 : // Instead, add to the document's list of listener calls,
1636 : // which will be executed directly after the broadcast of
1637 : // SFX_HINT_DATACHANGED.
1638 :
1639 0 : lang::EventObject aEvent;
1640 0 : aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
1641 :
1642 : // the EventObject holds a Ref to this object until after the listener calls
1643 :
1644 0 : ScDocument& rDoc = pDocShell->GetDocument();
1645 0 : for ( size_t n=0; n<aValueListeners.size(); n++ )
1646 0 : rDoc.AddUnoListenerCall( aValueListeners[n], aEvent );
1647 :
1648 0 : bGotDataChangedHint = false;
1649 : }
1650 : }
1651 281 : else if ( nId == SC_HINT_CALCALL )
1652 : {
1653 : // broadcast from DoHardRecalc - set bGotDataChangedHint
1654 : // (SFX_HINT_DATACHANGED follows separately)
1655 :
1656 281 : if ( !aValueListeners.empty() )
1657 0 : bGotDataChangedHint = true;
1658 182951 : }
1659 : }
1660 1697 : else if ( dynamic_cast<const ScUnoRefUndoHint*>(&rHint) )
1661 : {
1662 0 : const ScUnoRefUndoHint& rUndoHint = static_cast<const ScUnoRefUndoHint&>(rHint);
1663 0 : if ( rUndoHint.GetObjectId() == nObjectId )
1664 : {
1665 : // restore ranges from hint
1666 :
1667 0 : aRanges = rUndoHint.GetRanges();
1668 :
1669 0 : RefChanged();
1670 0 : if ( !aValueListeners.empty() )
1671 0 : bGotDataChangedHint = true; // need to broadcast the undo, too
1672 : }
1673 186441 : }
1674 : }
1675 :
1676 6368 : void ScCellRangesBase::RefChanged()
1677 : {
1678 : //! adjust XChartDataChangeEventListener
1679 :
1680 6368 : if ( pValueListener && !aValueListeners.empty() )
1681 : {
1682 0 : pValueListener->EndListeningAll();
1683 :
1684 0 : ScDocument& rDoc = pDocShell->GetDocument();
1685 0 : for ( size_t i = 0, nCount = aRanges.size(); i < nCount; ++i )
1686 0 : rDoc.StartListeningArea( *aRanges[ i ], false, pValueListener );
1687 : }
1688 :
1689 6368 : ForgetCurrentAttrs();
1690 6368 : ForgetMarkData();
1691 6368 : }
1692 :
1693 0 : ScDocument* ScCellRangesBase::GetDocument() const
1694 : {
1695 0 : if (pDocShell)
1696 0 : return &pDocShell->GetDocument();
1697 : else
1698 0 : return NULL;
1699 : }
1700 :
1701 0 : void ScCellRangesBase::InitInsertRange(ScDocShell* pDocSh, const ScRange& rR)
1702 : {
1703 0 : if ( !pDocShell && pDocSh )
1704 : {
1705 0 : pDocShell = pDocSh;
1706 :
1707 0 : ScRange aCellRange(rR);
1708 0 : aCellRange.Justify();
1709 0 : aRanges.RemoveAll();
1710 0 : aRanges.Append( aCellRange );
1711 :
1712 0 : pDocShell->GetDocument().AddUnoObject(*this);
1713 :
1714 0 : RefChanged(); // Range im Range-Objekt anpassen
1715 : }
1716 0 : }
1717 :
1718 4107 : void ScCellRangesBase::AddRange(const ScRange& rRange, const bool bMergeRanges)
1719 : {
1720 4107 : if (bMergeRanges)
1721 0 : aRanges.Join(rRange);
1722 : else
1723 4107 : aRanges.Append(rRange);
1724 4107 : RefChanged();
1725 4107 : }
1726 :
1727 582 : void ScCellRangesBase::SetNewRange(const ScRange& rNew)
1728 : {
1729 582 : ScRange aCellRange(rNew);
1730 582 : aCellRange.Justify();
1731 :
1732 582 : aRanges.RemoveAll();
1733 582 : aRanges.Append( aCellRange );
1734 582 : RefChanged();
1735 582 : }
1736 :
1737 46 : void ScCellRangesBase::SetNewRanges(const ScRangeList& rNew)
1738 : {
1739 46 : aRanges = rNew;
1740 46 : RefChanged();
1741 46 : }
1742 :
1743 881 : void ScCellRangesBase::SetCursorOnly( bool bSet )
1744 : {
1745 : // set for a selection object that is created from the cursor position
1746 : // without anything selected (may contain several sheets)
1747 :
1748 881 : bCursorOnly = bSet;
1749 881 : }
1750 :
1751 264732 : uno::Any SAL_CALL ScCellRangesBase::queryInterface( const uno::Type& rType )
1752 : throw(uno::RuntimeException, std::exception)
1753 : {
1754 264732 : SC_QUERYINTERFACE( beans::XPropertySet )
1755 249079 : SC_QUERYINTERFACE( beans::XMultiPropertySet )
1756 246699 : SC_QUERYINTERFACE( beans::XTolerantMultiPropertySet )
1757 245061 : SC_QUERYINTERFACE( beans::XPropertyState )
1758 244985 : SC_QUERYINTERFACE( sheet::XSheetOperation )
1759 244908 : SC_QUERYINTERFACE( chart::XChartDataArray )
1760 244905 : SC_QUERYINTERFACE( chart::XChartData )
1761 244904 : SC_QUERYINTERFACE( util::XIndent )
1762 244901 : SC_QUERYINTERFACE( sheet::XCellRangesQuery )
1763 244821 : SC_QUERYINTERFACE( sheet::XFormulaQuery )
1764 244818 : SC_QUERYINTERFACE( util::XReplaceable )
1765 244794 : SC_QUERYINTERFACE( util::XSearchable )
1766 244782 : SC_QUERYINTERFACE( util::XModifyBroadcaster )
1767 244776 : SC_QUERYINTERFACE( lang::XServiceInfo )
1768 244744 : SC_QUERYINTERFACE( lang::XUnoTunnel )
1769 227227 : SC_QUERYINTERFACE( lang::XTypeProvider )
1770 :
1771 227219 : return OWeakObject::queryInterface( rType );
1772 : }
1773 :
1774 891829 : void SAL_CALL ScCellRangesBase::acquire() throw()
1775 : {
1776 891829 : OWeakObject::acquire();
1777 891829 : }
1778 :
1779 891717 : void SAL_CALL ScCellRangesBase::release() throw()
1780 : {
1781 891717 : OWeakObject::release();
1782 891717 : }
1783 :
1784 2 : uno::Sequence<uno::Type> SAL_CALL ScCellRangesBase::getTypes() throw(uno::RuntimeException, std::exception)
1785 : {
1786 2 : static uno::Sequence<uno::Type> aTypes;
1787 2 : if ( aTypes.getLength() == 0 )
1788 : {
1789 2 : aTypes.realloc(13);
1790 2 : uno::Type* pPtr = aTypes.getArray();
1791 2 : pPtr[0] = cppu::UnoType<beans::XPropertySet>::get();
1792 2 : pPtr[1] = cppu::UnoType<beans::XMultiPropertySet>::get();
1793 2 : pPtr[2] = cppu::UnoType<beans::XPropertyState>::get();
1794 2 : pPtr[3] = cppu::UnoType<sheet::XSheetOperation>::get();
1795 2 : pPtr[4] = cppu::UnoType<chart::XChartDataArray>::get();
1796 2 : pPtr[5] = cppu::UnoType<util::XIndent>::get();
1797 2 : pPtr[6] = cppu::UnoType<sheet::XCellRangesQuery>::get();
1798 2 : pPtr[7] = cppu::UnoType<sheet::XFormulaQuery>::get();
1799 2 : pPtr[8] = cppu::UnoType<util::XReplaceable>::get();
1800 2 : pPtr[9] = cppu::UnoType<util::XModifyBroadcaster>::get();
1801 2 : pPtr[10]= cppu::UnoType<lang::XServiceInfo>::get();
1802 2 : pPtr[11]= cppu::UnoType<lang::XUnoTunnel>::get();
1803 2 : pPtr[12]= cppu::UnoType<lang::XTypeProvider>::get();
1804 : }
1805 2 : return aTypes;
1806 : }
1807 :
1808 0 : uno::Sequence<sal_Int8> SAL_CALL ScCellRangesBase::getImplementationId()
1809 : throw(uno::RuntimeException, std::exception)
1810 : {
1811 0 : return css::uno::Sequence<sal_Int8>();
1812 : }
1813 :
1814 8 : void ScCellRangesBase::PaintRanges_Impl( sal_uInt16 nPart )
1815 : {
1816 31 : for (size_t i = 0, nCount = aRanges.size(); i < nCount; ++i)
1817 23 : pDocShell->PostPaint( *aRanges[ i ], nPart );
1818 8 : }
1819 :
1820 : // XSheetOperation
1821 :
1822 4 : double SAL_CALL ScCellRangesBase::computeFunction( sheet::GeneralFunction nFunction )
1823 : throw(uno::Exception, uno::RuntimeException, std::exception)
1824 : {
1825 4 : SolarMutexGuard aGuard;
1826 8 : ScMarkData aMark(*GetMarkData());
1827 4 : aMark.MarkToSimple();
1828 4 : if (!aMark.IsMarked())
1829 2 : aMark.SetMarkNegative(true); // um Dummy Position angeben zu koennen
1830 :
1831 4 : ScAddress aDummy; // wenn nicht Marked, ignoriert wegen Negative
1832 : double fVal;
1833 4 : ScSubTotalFunc eFunc = ScDPUtil::toSubTotalFunc(nFunction);
1834 4 : ScDocument& rDoc = pDocShell->GetDocument();
1835 4 : if ( !rDoc.GetSelectionFunction( eFunc, aDummy, aMark, fVal ) )
1836 : {
1837 0 : throw uno::RuntimeException(); //! own exception?
1838 : }
1839 :
1840 8 : return fVal;
1841 : }
1842 :
1843 77 : void SAL_CALL ScCellRangesBase::clearContents( sal_Int32 nContentFlags ) throw(uno::RuntimeException, std::exception)
1844 : {
1845 77 : SolarMutexGuard aGuard;
1846 77 : if ( !aRanges.empty() )
1847 : {
1848 : // only for clearContents: EDITATTR is only used if no contents are deleted
1849 77 : InsertDeleteFlags nDelFlags = InsertDeleteFlags::fromInt(nContentFlags) & IDF_ALL;
1850 77 : if ( ( nDelFlags & IDF_EDITATTR ) && ( nDelFlags & IDF_CONTENTS ) == IDF_NONE )
1851 0 : nDelFlags |= IDF_EDITATTR;
1852 :
1853 77 : pDocShell->GetDocFunc().DeleteContents( *GetMarkData(), nDelFlags, true, true );
1854 77 : }
1855 : // sonst ist nichts zu tun
1856 77 : }
1857 :
1858 : // XPropertyState
1859 :
1860 2696 : const SfxItemPropertyMap& ScCellRangesBase::GetItemPropertyMap()
1861 : {
1862 2696 : return pPropSet->getPropertyMap();
1863 : }
1864 :
1865 8545 : static void lcl_GetPropertyWhich( const SfxItemPropertySimpleEntry* pEntry,
1866 : sal_uInt16& rItemWhich )
1867 : {
1868 : // Which-ID des betroffenen Items, auch wenn das Item die Property
1869 : // nicht alleine behandeln kann
1870 8545 : if ( pEntry )
1871 : {
1872 8545 : if ( IsScItemWid( pEntry->nWID ) )
1873 7609 : rItemWhich = pEntry->nWID;
1874 : else
1875 936 : switch ( pEntry->nWID )
1876 : {
1877 : case SC_WID_UNO_TBLBORD:
1878 : case SC_WID_UNO_TBLBORD2:
1879 30 : rItemWhich = ATTR_BORDER;
1880 30 : break;
1881 : case SC_WID_UNO_CONDFMT:
1882 : case SC_WID_UNO_CONDLOC:
1883 : case SC_WID_UNO_CONDXML:
1884 128 : rItemWhich = ATTR_CONDITIONAL;
1885 128 : break;
1886 : case SC_WID_UNO_VALIDAT:
1887 : case SC_WID_UNO_VALILOC:
1888 : case SC_WID_UNO_VALIXML:
1889 128 : rItemWhich = ATTR_VALIDDATA;
1890 128 : break;
1891 : }
1892 : }
1893 :
1894 8545 : }
1895 :
1896 8545 : beans::PropertyState ScCellRangesBase::GetOnePropertyState( sal_uInt16 nItemWhich, const SfxItemPropertySimpleEntry* pEntry )
1897 : {
1898 8545 : beans::PropertyState eRet = beans::PropertyState_DIRECT_VALUE;
1899 8545 : if ( nItemWhich ) // item wid (from map or special case)
1900 : {
1901 : // For items that contain several properties (like background),
1902 : // "ambiguous" is returned too often here
1903 :
1904 : // for PropertyState, don't look at styles
1905 7895 : const ScPatternAttr* pPattern = GetCurrentAttrsFlat();
1906 7895 : if ( pPattern )
1907 : {
1908 7895 : SfxItemState eState = pPattern->GetItemSet().GetItemState( nItemWhich, false );
1909 :
1910 7895 : if ( nItemWhich == ATTR_VALUE_FORMAT && eState == SfxItemState::DEFAULT )
1911 76 : eState = pPattern->GetItemSet().GetItemState( ATTR_LANGUAGE_FORMAT, false );
1912 :
1913 7895 : if ( eState == SfxItemState::SET )
1914 1013 : eRet = beans::PropertyState_DIRECT_VALUE;
1915 6882 : else if ( eState == SfxItemState::DEFAULT )
1916 6880 : eRet = beans::PropertyState_DEFAULT_VALUE;
1917 2 : else if ( eState == SfxItemState::DONTCARE )
1918 2 : eRet = beans::PropertyState_AMBIGUOUS_VALUE;
1919 : else
1920 : {
1921 : OSL_FAIL("unbekannter ItemState");
1922 : }
1923 : }
1924 : }
1925 650 : else if ( pEntry )
1926 : {
1927 650 : if ( pEntry->nWID == SC_WID_UNO_CHCOLHDR || pEntry->nWID == SC_WID_UNO_CHROWHDR || pEntry->nWID == SC_WID_UNO_ABSNAME )
1928 45 : eRet = beans::PropertyState_DIRECT_VALUE;
1929 605 : else if ( pEntry->nWID == SC_WID_UNO_CELLSTYL )
1930 : {
1931 : // a style is always set, there's no default state
1932 98 : const ScStyleSheet* pStyle = pDocShell->GetDocument().GetSelectionStyle(*GetMarkData());
1933 98 : if (pStyle)
1934 98 : eRet = beans::PropertyState_DIRECT_VALUE;
1935 : else
1936 0 : eRet = beans::PropertyState_AMBIGUOUS_VALUE;
1937 : }
1938 507 : else if ( pEntry->nWID == SC_WID_UNO_NUMRULES )
1939 15 : eRet = beans::PropertyState_DEFAULT_VALUE; // numbering rules are always default
1940 : }
1941 8545 : return eRet;
1942 : }
1943 :
1944 344 : beans::PropertyState SAL_CALL ScCellRangesBase::getPropertyState( const OUString& aPropertyName )
1945 : throw(beans::UnknownPropertyException, uno::RuntimeException, std::exception)
1946 : {
1947 344 : SolarMutexGuard aGuard;
1948 344 : if ( aRanges.empty() )
1949 0 : throw uno::RuntimeException();
1950 :
1951 344 : const SfxItemPropertyMap& rMap = GetItemPropertyMap(); // from derived class
1952 344 : sal_uInt16 nItemWhich = 0;
1953 344 : const SfxItemPropertySimpleEntry* pEntry = rMap.getByName( aPropertyName );
1954 344 : lcl_GetPropertyWhich( pEntry, nItemWhich );
1955 344 : return GetOnePropertyState( nItemWhich, pEntry );
1956 : }
1957 :
1958 0 : uno::Sequence<beans::PropertyState> SAL_CALL ScCellRangesBase::getPropertyStates(
1959 : const uno::Sequence<OUString>& aPropertyNames )
1960 : throw(beans::UnknownPropertyException, uno::RuntimeException, std::exception)
1961 : {
1962 0 : SolarMutexGuard aGuard;
1963 :
1964 0 : const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
1965 :
1966 0 : uno::Sequence<beans::PropertyState> aRet(aPropertyNames.getLength());
1967 0 : beans::PropertyState* pStates = aRet.getArray();
1968 0 : for(sal_Int32 i = 0; i < aPropertyNames.getLength(); i++)
1969 : {
1970 0 : sal_uInt16 nItemWhich = 0;
1971 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyNames[i] );
1972 0 : lcl_GetPropertyWhich( pEntry, nItemWhich );
1973 0 : pStates[i] = GetOnePropertyState(nItemWhich, pEntry);
1974 : }
1975 0 : return aRet;
1976 : }
1977 :
1978 0 : void SAL_CALL ScCellRangesBase::setPropertyToDefault( const OUString& aPropertyName )
1979 : throw(beans::UnknownPropertyException, uno::RuntimeException, std::exception)
1980 : {
1981 0 : SolarMutexGuard aGuard;
1982 0 : if ( pDocShell )
1983 : {
1984 0 : const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
1985 0 : sal_uInt16 nItemWhich = 0;
1986 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1987 0 : lcl_GetPropertyWhich( pEntry, nItemWhich );
1988 0 : if ( nItemWhich ) // item wid (from map or special case)
1989 : {
1990 0 : if ( !aRanges.empty() ) // leer = nichts zu tun
1991 : {
1992 : //! Bei Items, die mehrere Properties enthalten (z.B. Hintergrund)
1993 : //! wird hier zuviel zurueckgesetzt
1994 : //! for ATTR_ROTATE_VALUE, also reset ATTR_ORIENTATION?
1995 :
1996 : sal_uInt16 aWIDs[3];
1997 0 : aWIDs[0] = nItemWhich;
1998 0 : if ( nItemWhich == ATTR_VALUE_FORMAT )
1999 : {
2000 0 : aWIDs[1] = ATTR_LANGUAGE_FORMAT; // language for number formats
2001 0 : aWIDs[2] = 0;
2002 : }
2003 : else
2004 0 : aWIDs[1] = 0;
2005 0 : pDocShell->GetDocFunc().ClearItems( *GetMarkData(), aWIDs, true );
2006 : }
2007 : }
2008 0 : else if ( pEntry )
2009 : {
2010 0 : if ( pEntry->nWID == SC_WID_UNO_CHCOLHDR )
2011 0 : bChartColAsHdr = false;
2012 0 : else if ( pEntry->nWID == SC_WID_UNO_CHROWHDR )
2013 0 : bChartRowAsHdr = false;
2014 0 : else if ( pEntry->nWID == SC_WID_UNO_CELLSTYL )
2015 : {
2016 0 : OUString aStyleName( ScGlobal::GetRscString( STR_STYLENAME_STANDARD ) );
2017 0 : pDocShell->GetDocFunc().ApplyStyle( *GetMarkData(), aStyleName, true, true );
2018 : }
2019 : }
2020 0 : }
2021 0 : }
2022 :
2023 0 : uno::Any SAL_CALL ScCellRangesBase::getPropertyDefault( const OUString& aPropertyName )
2024 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
2025 : uno::RuntimeException, std::exception)
2026 : {
2027 : //! mit getPropertyValue zusammenfassen
2028 :
2029 0 : SolarMutexGuard aGuard;
2030 0 : uno::Any aAny;
2031 :
2032 0 : if ( pDocShell )
2033 : {
2034 0 : ScDocument& rDoc = pDocShell->GetDocument();
2035 0 : const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2036 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
2037 0 : if ( pEntry )
2038 : {
2039 0 : if ( IsScItemWid( pEntry->nWID ) )
2040 : {
2041 0 : const ScPatternAttr* pPattern = rDoc.GetDefPattern();
2042 0 : if ( pPattern )
2043 : {
2044 0 : const SfxItemSet& rSet = pPattern->GetItemSet();
2045 :
2046 0 : switch ( pEntry->nWID ) // fuer Item-Spezial-Behandlungen
2047 : {
2048 : case ATTR_VALUE_FORMAT:
2049 : // default has no language set
2050 0 : aAny <<= (sal_Int32)( static_cast<const SfxUInt32Item&>(rSet.Get(pEntry->nWID)).GetValue() );
2051 0 : break;
2052 : case ATTR_INDENT:
2053 0 : aAny <<= (sal_Int16)( TwipsToHMM(static_cast<const SfxUInt16Item&>(
2054 0 : rSet.Get(pEntry->nWID)).GetValue()) );
2055 0 : break;
2056 : default:
2057 0 : pPropSet->getPropertyValue(aPropertyName, rSet, aAny);
2058 : }
2059 : }
2060 : }
2061 : else
2062 0 : switch ( pEntry->nWID )
2063 : {
2064 : case SC_WID_UNO_CHCOLHDR:
2065 : case SC_WID_UNO_CHROWHDR:
2066 0 : ScUnoHelpFunctions::SetBoolInAny( aAny, false );
2067 0 : break;
2068 : case SC_WID_UNO_CELLSTYL:
2069 0 : aAny <<= OUString( ScStyleNameConversion::DisplayToProgrammaticName(
2070 0 : ScGlobal::GetRscString(STR_STYLENAME_STANDARD), SFX_STYLE_FAMILY_PARA ) );
2071 0 : break;
2072 : case SC_WID_UNO_TBLBORD:
2073 : case SC_WID_UNO_TBLBORD2:
2074 : {
2075 0 : const ScPatternAttr* pPattern = rDoc.GetDefPattern();
2076 0 : if ( pPattern )
2077 : {
2078 0 : if (pEntry->nWID == SC_WID_UNO_TBLBORD2)
2079 : ScHelperFunctions::AssignTableBorder2ToAny( aAny,
2080 0 : static_cast<const SvxBoxItem&>(pPattern->GetItem(ATTR_BORDER)),
2081 0 : static_cast<const SvxBoxInfoItem&>(pPattern->GetItem(ATTR_BORDER_INNER)) );
2082 : else
2083 : ScHelperFunctions::AssignTableBorderToAny( aAny,
2084 0 : static_cast<const SvxBoxItem&>(pPattern->GetItem(ATTR_BORDER)),
2085 0 : static_cast<const SvxBoxInfoItem&>(pPattern->GetItem(ATTR_BORDER_INNER)) );
2086 : }
2087 : }
2088 0 : break;
2089 : case SC_WID_UNO_CONDFMT:
2090 : case SC_WID_UNO_CONDLOC:
2091 : case SC_WID_UNO_CONDXML:
2092 : {
2093 0 : bool bEnglish = ( pEntry->nWID != SC_WID_UNO_CONDLOC );
2094 0 : bool bXML = ( pEntry->nWID == SC_WID_UNO_CONDXML );
2095 : formula::FormulaGrammar::Grammar eGrammar = (bXML ?
2096 : rDoc.GetStorageGrammar() :
2097 0 : formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
2098 :
2099 0 : aAny <<= uno::Reference<sheet::XSheetConditionalEntries>(
2100 0 : new ScTableConditionalFormat( &rDoc, 0, aRanges[0]->aStart.Tab(), eGrammar ));
2101 : }
2102 0 : break;
2103 : case SC_WID_UNO_VALIDAT:
2104 : case SC_WID_UNO_VALILOC:
2105 : case SC_WID_UNO_VALIXML:
2106 : {
2107 0 : bool bEnglish = ( pEntry->nWID != SC_WID_UNO_VALILOC );
2108 0 : bool bXML = ( pEntry->nWID == SC_WID_UNO_VALIXML );
2109 : formula::FormulaGrammar::Grammar eGrammar = (bXML ?
2110 : rDoc.GetStorageGrammar() :
2111 0 : formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
2112 :
2113 0 : aAny <<= uno::Reference<beans::XPropertySet>(
2114 0 : new ScTableValidationObj( &rDoc, 0, eGrammar ));
2115 : }
2116 0 : break;
2117 : case SC_WID_UNO_NUMRULES:
2118 : {
2119 0 : aAny <<= uno::Reference<container::XIndexReplace>(ScStyleObj::CreateEmptyNumberingRules());
2120 : }
2121 0 : break;
2122 : }
2123 : }
2124 : }
2125 :
2126 0 : return aAny;
2127 : }
2128 :
2129 : // XPropertySet
2130 :
2131 252 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCellRangesBase::getPropertySetInfo()
2132 : throw(uno::RuntimeException, std::exception)
2133 : {
2134 252 : SolarMutexGuard aGuard;
2135 : static uno::Reference<beans::XPropertySetInfo> aRef(
2136 252 : new SfxItemPropertySetInfo( pPropSet->getPropertyMap() ));
2137 252 : return aRef;
2138 : }
2139 :
2140 15177 : static void lcl_SetCellProperty( const SfxItemPropertySimpleEntry& rEntry, const uno::Any& rValue,
2141 : ScPatternAttr& rPattern, ScDocument &rDoc,
2142 : sal_uInt16& rFirstItemId, sal_uInt16& rSecondItemId )
2143 : {
2144 15177 : rFirstItemId = rEntry.nWID;
2145 15177 : rSecondItemId = 0;
2146 :
2147 15177 : SfxItemSet& rSet = rPattern.GetItemSet();
2148 15177 : switch ( rEntry.nWID )
2149 : {
2150 : case ATTR_VALUE_FORMAT:
2151 : {
2152 : // language for number formats
2153 435 : SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
2154 435 : sal_uLong nOldFormat = static_cast<const SfxUInt32Item&>(rSet.Get( ATTR_VALUE_FORMAT )).GetValue();
2155 435 : LanguageType eOldLang = static_cast<const SvxLanguageItem&>(rSet.Get( ATTR_LANGUAGE_FORMAT )).GetLanguage();
2156 435 : nOldFormat = pFormatter->GetFormatForLanguageIfBuiltIn( nOldFormat, eOldLang );
2157 :
2158 435 : sal_Int32 nIntVal = 0;
2159 435 : if ( rValue >>= nIntVal )
2160 : {
2161 435 : sal_uLong nNewFormat = (sal_uLong)nIntVal;
2162 435 : rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat ) );
2163 :
2164 435 : const SvNumberformat* pNewEntry = pFormatter->GetEntry( nNewFormat );
2165 : LanguageType eNewLang =
2166 435 : pNewEntry ? pNewEntry->GetLanguage() : LANGUAGE_DONTKNOW;
2167 435 : if ( eNewLang != eOldLang && eNewLang != LANGUAGE_DONTKNOW )
2168 : {
2169 14 : rSet.Put( SvxLanguageItem( eNewLang, ATTR_LANGUAGE_FORMAT ) );
2170 :
2171 : // if only language is changed,
2172 : // don't touch number format attribute
2173 14 : sal_uLong nNewMod = nNewFormat % SV_COUNTRY_LANGUAGE_OFFSET;
2174 14 : if ( nNewMod == ( nOldFormat % SV_COUNTRY_LANGUAGE_OFFSET ) &&
2175 : nNewMod <= SV_MAX_ANZ_STANDARD_FORMATE )
2176 : {
2177 0 : rFirstItemId = 0; // don't use ATTR_VALUE_FORMAT value
2178 : }
2179 :
2180 14 : rSecondItemId = ATTR_LANGUAGE_FORMAT;
2181 : }
2182 : }
2183 : else
2184 0 : throw lang::IllegalArgumentException();
2185 : }
2186 435 : break;
2187 : case ATTR_INDENT:
2188 : {
2189 130 : sal_Int16 nIntVal = 0;
2190 130 : if ( rValue >>= nIntVal )
2191 130 : rSet.Put( SfxUInt16Item( rEntry.nWID, (sal_uInt16)HMMToTwips(nIntVal) ) );
2192 : else
2193 0 : throw lang::IllegalArgumentException();
2194 : }
2195 130 : break;
2196 : case ATTR_ROTATE_VALUE:
2197 : {
2198 26 : sal_Int32 nRotVal = 0;
2199 26 : if ( rValue >>= nRotVal )
2200 : {
2201 : // stored value is always between 0 and 360 deg.
2202 26 : nRotVal %= 36000;
2203 26 : if ( nRotVal < 0 )
2204 0 : nRotVal += 36000;
2205 :
2206 26 : rSet.Put( SfxInt32Item( ATTR_ROTATE_VALUE, nRotVal ) );
2207 : }
2208 : else
2209 0 : throw lang::IllegalArgumentException();
2210 : }
2211 26 : break;
2212 : case ATTR_STACKED:
2213 : {
2214 : table::CellOrientation eOrient;
2215 29 : if( rValue >>= eOrient )
2216 : {
2217 29 : switch( eOrient )
2218 : {
2219 : case table::CellOrientation_STANDARD:
2220 22 : rSet.Put( SfxBoolItem( ATTR_STACKED, false ) );
2221 22 : break;
2222 : case table::CellOrientation_TOPBOTTOM:
2223 5 : rSet.Put( SfxBoolItem( ATTR_STACKED, false ) );
2224 5 : rSet.Put( SfxInt32Item( ATTR_ROTATE_VALUE, 27000 ) );
2225 5 : rSecondItemId = ATTR_ROTATE_VALUE;
2226 5 : break;
2227 : case table::CellOrientation_BOTTOMTOP:
2228 1 : rSet.Put( SfxBoolItem( ATTR_STACKED, false ) );
2229 1 : rSet.Put( SfxInt32Item( ATTR_ROTATE_VALUE, 9000 ) );
2230 1 : rSecondItemId = ATTR_ROTATE_VALUE;
2231 1 : break;
2232 : case table::CellOrientation_STACKED:
2233 1 : rSet.Put( SfxBoolItem( ATTR_STACKED, true ) );
2234 1 : break;
2235 : default:
2236 : {
2237 : // added to avoid warnings
2238 : }
2239 : }
2240 : }
2241 : }
2242 29 : break;
2243 : default:
2244 : {
2245 14557 : lcl_GetCellsPropertySet()->setPropertyValue(rEntry, rValue, rSet);
2246 : }
2247 : }
2248 15114 : }
2249 :
2250 2287 : void SAL_CALL ScCellRangesBase::setPropertyValue(
2251 : const OUString& aPropertyName, const uno::Any& aValue )
2252 : throw(beans::UnknownPropertyException, beans::PropertyVetoException,
2253 : lang::IllegalArgumentException, lang::WrappedTargetException,
2254 : uno::RuntimeException, std::exception)
2255 : {
2256 2287 : SolarMutexGuard aGuard;
2257 :
2258 2287 : if ( !pDocShell || aRanges.empty() )
2259 0 : throw uno::RuntimeException();
2260 :
2261 2287 : const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2262 2287 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
2263 2287 : if ( !pEntry )
2264 0 : throw beans::UnknownPropertyException();
2265 :
2266 2308 : SetOnePropertyValue( pEntry, aValue );
2267 2266 : }
2268 :
2269 2482 : void ScCellRangesBase::SetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue )
2270 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
2271 : {
2272 2482 : if ( pEntry )
2273 : {
2274 2482 : if ( IsScItemWid( pEntry->nWID ) )
2275 : {
2276 842 : if ( !aRanges.empty() ) // leer = nichts zu tun
2277 : {
2278 842 : ScDocument& rDoc = pDocShell->GetDocument();
2279 :
2280 : // Fuer Teile von zusammengesetzten Items mit mehreren Properties (z.B. Hintergrund)
2281 : // muss vorher das alte Item aus dem Dokument geholt werden
2282 : //! Das kann hier aber nicht erkannt werden
2283 : //! -> eigenes Flag im PropertyMap-Eintrag, oder was ???
2284 : //! Item direkt von einzelner Position im Bereich holen?
2285 : // ClearInvalidItems, damit auf jeden Fall ein Item vom richtigen Typ da ist
2286 :
2287 842 : ScPatternAttr aPattern( *GetCurrentAttrsDeep() );
2288 842 : SfxItemSet& rSet = aPattern.GetItemSet();
2289 842 : rSet.ClearInvalidItems();
2290 :
2291 : sal_uInt16 nFirstItem, nSecondItem;
2292 842 : lcl_SetCellProperty( *pEntry, aValue, aPattern, rDoc, nFirstItem, nSecondItem );
2293 :
2294 46797 : for (sal_uInt16 nWhich = ATTR_PATTERN_START; nWhich <= ATTR_PATTERN_END; nWhich++)
2295 45976 : if ( nWhich != nFirstItem && nWhich != nSecondItem )
2296 45144 : rSet.ClearItem(nWhich);
2297 :
2298 842 : pDocShell->GetDocFunc().ApplyAttributes( *GetMarkData(), aPattern, true, true );
2299 : }
2300 : }
2301 : else // implemented here
2302 1640 : switch ( pEntry->nWID )
2303 : {
2304 : case EE_CHAR_ESCAPEMENT: // Specifically for xlsx import
2305 : {
2306 1 : sal_Int32 nValue = 0;
2307 1 : aValue >>= nValue;
2308 1 : if (nValue)
2309 : {
2310 0 : for (size_t i = 0, n = aRanges.size(); i < n; ++i)
2311 : {
2312 0 : ScRange aRange = *aRanges[i];
2313 :
2314 : /* TODO: Iterate through the range */
2315 0 : ScAddress aAddr = aRange.aStart;
2316 0 : ScDocument& rDoc = pDocShell->GetDocument();
2317 0 : ScRefCellValue aCell;
2318 0 : aCell.assign(rDoc, aAddr);
2319 :
2320 0 : OUString aStr = aCell.getString(&rDoc);
2321 0 : EditEngine aEngine( rDoc.GetEnginePool() );
2322 0 : aEngine.SetEditTextObjectPool(rDoc.GetEditPool());
2323 :
2324 : /* EE_CHAR_ESCAPEMENT seems to be set on the cell _only_ when
2325 : * there are no other attribs for the cell.
2326 : * So, it is safe to overwrite the complete attribute set.
2327 : * If there is a need - getting CellType and processing
2328 : * the attributes could be considered.
2329 : */
2330 0 : SfxItemSet aAttr = aEngine.GetEmptyItemSet();
2331 0 : aEngine.SetText(aStr);
2332 0 : if( nValue < 0 ) // Subscript
2333 0 : aAttr.Put( SvxEscapementItem( SVX_ESCAPEMENT_SUBSCRIPT, EE_CHAR_ESCAPEMENT ) );
2334 : else // Superscript
2335 0 : aAttr.Put( SvxEscapementItem( SVX_ESCAPEMENT_SUPERSCRIPT, EE_CHAR_ESCAPEMENT ) );
2336 0 : aEngine.QuickSetAttribs(aAttr, ESelection(0, 0, 0, aStr.getLength()));
2337 :
2338 : // The cell will own the text object instance.
2339 0 : rDoc.SetEditText(aRanges[0]->aStart, aEngine.CreateTextObject());
2340 0 : }
2341 : }
2342 : }
2343 1 : break;
2344 : case SC_WID_UNO_CHCOLHDR:
2345 : // chart header flags are set for this object, not stored with document
2346 6 : bChartColAsHdr = ScUnoHelpFunctions::GetBoolFromAny( aValue );
2347 6 : break;
2348 : case SC_WID_UNO_CHROWHDR:
2349 6 : bChartRowAsHdr = ScUnoHelpFunctions::GetBoolFromAny( aValue );
2350 6 : break;
2351 : case SC_WID_UNO_CELLSTYL:
2352 : {
2353 1577 : OUString aStrVal;
2354 1577 : aValue >>= aStrVal;
2355 : OUString aString(ScStyleNameConversion::ProgrammaticToDisplayName(
2356 3154 : aStrVal, SFX_STYLE_FAMILY_PARA ));
2357 3154 : pDocShell->GetDocFunc().ApplyStyle( *GetMarkData(), aString, true, true );
2358 : }
2359 1577 : break;
2360 : case SC_WID_UNO_TBLBORD:
2361 : {
2362 4 : table::TableBorder aBorder;
2363 4 : if ( !aRanges.empty() && ( aValue >>= aBorder ) ) // empty = nothing to do
2364 : {
2365 4 : SvxBoxItem aOuter(ATTR_BORDER);
2366 8 : SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
2367 4 : ScHelperFunctions::FillBoxItems( aOuter, aInner, aBorder );
2368 :
2369 8 : ScHelperFunctions::ApplyBorder( pDocShell, aRanges, aOuter, aInner ); //! docfunc
2370 : }
2371 : }
2372 4 : break;
2373 : case SC_WID_UNO_TBLBORD2:
2374 : {
2375 2 : table::TableBorder2 aBorder2;
2376 2 : if ( !aRanges.empty() && ( aValue >>= aBorder2 ) ) // empty = nothing to do
2377 : {
2378 0 : SvxBoxItem aOuter(ATTR_BORDER);
2379 0 : SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
2380 0 : ScHelperFunctions::FillBoxItems( aOuter, aInner, aBorder2 );
2381 :
2382 0 : ScHelperFunctions::ApplyBorder( pDocShell, aRanges, aOuter, aInner ); //! docfunc
2383 : }
2384 : }
2385 2 : break;
2386 : case SC_WID_UNO_CONDFMT:
2387 : case SC_WID_UNO_CONDLOC:
2388 : case SC_WID_UNO_CONDXML:
2389 : {
2390 16 : uno::Reference<sheet::XSheetConditionalEntries> xInterface(aValue, uno::UNO_QUERY);
2391 16 : if ( !aRanges.empty() && xInterface.is() ) // leer = nichts zu tun
2392 : {
2393 : ScTableConditionalFormat* pFormat =
2394 10 : ScTableConditionalFormat::getImplementation( xInterface );
2395 10 : if (pFormat)
2396 : {
2397 10 : ScDocument& rDoc = pDocShell->GetDocument();
2398 10 : bool bEnglish = ( pEntry->nWID != SC_WID_UNO_CONDLOC );
2399 10 : bool bXML = ( pEntry->nWID == SC_WID_UNO_CONDXML );
2400 : formula::FormulaGrammar::Grammar eGrammar = (bXML ?
2401 : formula::FormulaGrammar::GRAM_UNSPECIFIED :
2402 10 : formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
2403 :
2404 10 : SCTAB nTab = aRanges.front()->aStart.Tab();
2405 : // To remove conditional formats for all cells in aRanges we need to:
2406 : // Remove conditional format data from cells' attributes
2407 10 : rDoc.RemoveCondFormatData( aRanges, nTab, 0 );
2408 : // And also remove ranges from conditional formats list
2409 20 : for (size_t i = 0; i < aRanges.size(); ++i)
2410 : {
2411 10 : rDoc.GetCondFormList( aRanges[i]->aStart.Tab() )->DeleteArea(
2412 20 : aRanges[i]->aStart.Col(), aRanges[i]->aStart.Row(),
2413 40 : aRanges[i]->aEnd.Col(), aRanges[i]->aEnd.Row() );
2414 : }
2415 :
2416 : // Then we can apply new conditional format if there is one
2417 10 : if (pFormat->getCount())
2418 : {
2419 3 : ScConditionalFormat* pNew = new ScConditionalFormat( 0, &rDoc ); // Index wird beim Einfuegen gesetzt
2420 3 : pFormat->FillFormat( *pNew, &rDoc, eGrammar );
2421 3 : pNew->SetRange( aRanges );
2422 3 : pDocShell->GetDocFunc().ReplaceConditionalFormat( 0, pNew, nTab, aRanges );
2423 : }
2424 :
2425 : // and repaint
2426 20 : for (size_t i = 0; i < aRanges.size(); ++i)
2427 10 : pDocShell->PostPaint(*aRanges[i], PAINT_GRID);
2428 10 : pDocShell->SetDocumentModified();
2429 : }
2430 16 : }
2431 : }
2432 16 : break;
2433 : case SC_WID_UNO_VALIDAT:
2434 : case SC_WID_UNO_VALILOC:
2435 : case SC_WID_UNO_VALIXML:
2436 : {
2437 22 : uno::Reference<beans::XPropertySet> xInterface(aValue, uno::UNO_QUERY);
2438 22 : if ( !aRanges.empty() && xInterface.is() ) // leer = nichts zu tun
2439 : {
2440 : ScTableValidationObj* pValidObj =
2441 16 : ScTableValidationObj::getImplementation( xInterface );
2442 16 : if (pValidObj)
2443 : {
2444 16 : ScDocument& rDoc = pDocShell->GetDocument();
2445 16 : bool bEnglish = ( pEntry->nWID != SC_WID_UNO_VALILOC );
2446 16 : bool bXML = ( pEntry->nWID == SC_WID_UNO_VALIXML );
2447 : formula::FormulaGrammar::Grammar eGrammar = (bXML ?
2448 : formula::FormulaGrammar::GRAM_UNSPECIFIED :
2449 16 : formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
2450 :
2451 : boost::scoped_ptr<ScValidationData> pNewData(
2452 16 : pValidObj->CreateValidationData( &rDoc, eGrammar ));
2453 16 : sal_uLong nIndex = rDoc.AddValidationEntry( *pNewData );
2454 16 : pNewData.reset();
2455 :
2456 32 : ScPatternAttr aPattern( rDoc.GetPool() );
2457 16 : aPattern.GetItemSet().Put( SfxUInt32Item( ATTR_VALIDDATA, nIndex ) );
2458 32 : pDocShell->GetDocFunc().ApplyAttributes( *GetMarkData(), aPattern, true, true );
2459 : }
2460 22 : }
2461 : }
2462 22 : break;
2463 : // SC_WID_UNO_NUMRULES is ignored...
2464 : }
2465 : }
2466 2461 : }
2467 :
2468 13010 : uno::Any SAL_CALL ScCellRangesBase::getPropertyValue( const OUString& aPropertyName )
2469 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
2470 : uno::RuntimeException, std::exception)
2471 : {
2472 13010 : SolarMutexGuard aGuard;
2473 :
2474 13010 : if ( !pDocShell || aRanges.empty() )
2475 0 : throw uno::RuntimeException();
2476 :
2477 13010 : const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2478 13010 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
2479 13010 : if ( !pEntry )
2480 4 : throw beans::UnknownPropertyException();
2481 :
2482 13006 : uno::Any aAny;
2483 13006 : GetOnePropertyValue( pEntry, aAny );
2484 13010 : return aAny;
2485 : }
2486 :
2487 10118 : void ScCellRangesBase::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, uno::Any& rAny )
2488 : throw(uno::RuntimeException, std::exception)
2489 : {
2490 10118 : if ( pEntry )
2491 : {
2492 10118 : if ( IsScItemWid( pEntry->nWID ) )
2493 : {
2494 9736 : SfxItemSet* pDataSet = GetCurrentDataSet();
2495 9736 : if ( pDataSet )
2496 : {
2497 9736 : switch ( pEntry->nWID ) // fuer Item-Spezial-Behandlungen
2498 : {
2499 : case ATTR_VALUE_FORMAT:
2500 : {
2501 7785 : ScDocument& rDoc = pDocShell->GetDocument();
2502 :
2503 : sal_uLong nOldFormat = static_cast<const SfxUInt32Item&>(
2504 7785 : pDataSet->Get( ATTR_VALUE_FORMAT )).GetValue();
2505 : LanguageType eOldLang = static_cast<const SvxLanguageItem&>(
2506 7785 : pDataSet->Get( ATTR_LANGUAGE_FORMAT )).GetLanguage();
2507 : nOldFormat = rDoc.GetFormatTable()->
2508 7785 : GetFormatForLanguageIfBuiltIn( nOldFormat, eOldLang );
2509 7785 : rAny <<= (sal_Int32)( nOldFormat );
2510 : }
2511 7785 : break;
2512 : case ATTR_INDENT:
2513 98 : rAny <<= (sal_Int16)( TwipsToHMM(static_cast<const SfxUInt16Item&>(
2514 98 : pDataSet->Get(pEntry->nWID)).GetValue()) );
2515 49 : break;
2516 : case ATTR_STACKED:
2517 : {
2518 58 : sal_Int32 nRot = static_cast<const SfxInt32Item&>(pDataSet->Get(ATTR_ROTATE_VALUE)).GetValue();
2519 58 : bool bStacked = static_cast<const SfxBoolItem&>(pDataSet->Get(pEntry->nWID)).GetValue();
2520 58 : SvxOrientationItem( nRot, bStacked, 0 ).QueryValue( rAny );
2521 : }
2522 58 : break;
2523 : default:
2524 1844 : pPropSet->getPropertyValue(*pEntry, *pDataSet, rAny);
2525 : }
2526 : }
2527 : }
2528 : else // implemented here
2529 382 : switch ( pEntry->nWID )
2530 : {
2531 : case SC_WID_UNO_CHCOLHDR:
2532 22 : ScUnoHelpFunctions::SetBoolInAny( rAny, bChartColAsHdr );
2533 22 : break;
2534 : case SC_WID_UNO_CHROWHDR:
2535 22 : ScUnoHelpFunctions::SetBoolInAny( rAny, bChartRowAsHdr );
2536 22 : break;
2537 : case SC_WID_UNO_CELLSTYL:
2538 : {
2539 102 : OUString aStyleName;
2540 102 : const ScStyleSheet* pStyle = pDocShell->GetDocument().GetSelectionStyle(*GetMarkData());
2541 102 : if (pStyle)
2542 102 : aStyleName = pStyle->GetName();
2543 204 : rAny <<= OUString( ScStyleNameConversion::DisplayToProgrammaticName(
2544 204 : aStyleName, SFX_STYLE_FAMILY_PARA ) );
2545 : }
2546 102 : break;
2547 : case SC_WID_UNO_TBLBORD:
2548 : case SC_WID_UNO_TBLBORD2:
2549 : {
2550 : //! loop throgh all ranges
2551 40 : if ( !aRanges.empty() )
2552 : {
2553 40 : const ScRange* pFirst = aRanges[ 0 ];
2554 40 : SvxBoxItem aOuter(ATTR_BORDER);
2555 80 : SvxBoxInfoItem aInner(ATTR_BORDER_INNER);
2556 :
2557 40 : ScDocument& rDoc = pDocShell->GetDocument();
2558 80 : ScMarkData aMark;
2559 40 : aMark.SetMarkArea( *pFirst );
2560 40 : aMark.SelectTable( pFirst->aStart.Tab(), true );
2561 40 : rDoc.GetSelectionFrame( aMark, aOuter, aInner );
2562 :
2563 40 : if (pEntry->nWID == SC_WID_UNO_TBLBORD2)
2564 14 : ScHelperFunctions::AssignTableBorder2ToAny( rAny, aOuter, aInner);
2565 : else
2566 66 : ScHelperFunctions::AssignTableBorderToAny( rAny, aOuter, aInner);
2567 : }
2568 : }
2569 40 : break;
2570 : case SC_WID_UNO_CONDFMT:
2571 : case SC_WID_UNO_CONDLOC:
2572 : case SC_WID_UNO_CONDXML:
2573 : {
2574 84 : const ScPatternAttr* pPattern = GetCurrentAttrsDeep();
2575 84 : if ( pPattern )
2576 : {
2577 84 : ScDocument& rDoc = pDocShell->GetDocument();
2578 84 : bool bEnglish = ( pEntry->nWID != SC_WID_UNO_CONDLOC );
2579 84 : bool bXML = ( pEntry->nWID == SC_WID_UNO_CONDXML );
2580 : formula::FormulaGrammar::Grammar eGrammar = (bXML ?
2581 : rDoc.GetStorageGrammar() :
2582 84 : formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
2583 : const std::vector<sal_uInt32>& rIndex = static_cast<const ScCondFormatItem&>(
2584 84 : pPattern->GetItem(ATTR_CONDITIONAL)).GetCondFormatData();
2585 84 : sal_uLong nIndex = 0;
2586 84 : if(!rIndex.empty())
2587 24 : nIndex = rIndex[0];
2588 168 : rAny <<= uno::Reference<sheet::XSheetConditionalEntries>(
2589 168 : new ScTableConditionalFormat( &rDoc, nIndex, aRanges.front()->aStart.Tab(), eGrammar ));
2590 : }
2591 : }
2592 84 : break;
2593 : case SC_WID_UNO_VALIDAT:
2594 : case SC_WID_UNO_VALILOC:
2595 : case SC_WID_UNO_VALIXML:
2596 : {
2597 75 : const ScPatternAttr* pPattern = GetCurrentAttrsDeep();
2598 75 : if ( pPattern )
2599 : {
2600 75 : ScDocument& rDoc = pDocShell->GetDocument();
2601 75 : bool bEnglish = ( pEntry->nWID != SC_WID_UNO_VALILOC );
2602 75 : bool bXML = ( pEntry->nWID == SC_WID_UNO_VALIXML );
2603 : formula::FormulaGrammar::Grammar eGrammar = (bXML ?
2604 : rDoc.GetStorageGrammar() :
2605 75 : formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML));
2606 : sal_uLong nIndex = static_cast<const SfxUInt32Item&>(
2607 75 : pPattern->GetItem(ATTR_VALIDDATA)).GetValue();
2608 150 : rAny <<= uno::Reference<beans::XPropertySet>(
2609 150 : new ScTableValidationObj( &rDoc, nIndex, eGrammar ));
2610 : }
2611 : }
2612 75 : break;
2613 : case SC_WID_UNO_NUMRULES:
2614 : {
2615 : // always return empty numbering rules object
2616 14 : rAny <<= uno::Reference<container::XIndexReplace>(ScStyleObj::CreateEmptyNumberingRules());
2617 : }
2618 14 : break;
2619 : case SC_WID_UNO_ABSNAME:
2620 : {
2621 15 : OUString sRet;
2622 15 : aRanges.Format(sRet, SCR_ABS_3D, &pDocShell->GetDocument());
2623 15 : rAny <<= sRet;
2624 : }
2625 : }
2626 : }
2627 10118 : }
2628 :
2629 0 : void SAL_CALL ScCellRangesBase::addPropertyChangeListener( const OUString& /* aPropertyName */,
2630 : const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
2631 : throw(beans::UnknownPropertyException,
2632 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2633 : {
2634 0 : SolarMutexGuard aGuard;
2635 0 : if ( aRanges.empty() )
2636 0 : throw uno::RuntimeException();
2637 :
2638 0 : OSL_FAIL("not implemented");
2639 0 : }
2640 :
2641 0 : void SAL_CALL ScCellRangesBase::removePropertyChangeListener( const OUString& /* aPropertyName */,
2642 : const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
2643 : throw(beans::UnknownPropertyException,
2644 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2645 : {
2646 0 : SolarMutexGuard aGuard;
2647 0 : if ( aRanges.empty() )
2648 0 : throw uno::RuntimeException();
2649 :
2650 0 : OSL_FAIL("not implemented");
2651 0 : }
2652 :
2653 0 : void SAL_CALL ScCellRangesBase::addVetoableChangeListener( const OUString&,
2654 : const uno::Reference<beans::XVetoableChangeListener>&)
2655 : throw(beans::UnknownPropertyException,
2656 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2657 : {
2658 : OSL_FAIL("not implemented");
2659 0 : }
2660 :
2661 0 : void SAL_CALL ScCellRangesBase::removeVetoableChangeListener( const OUString&,
2662 : const uno::Reference<beans::XVetoableChangeListener>&)
2663 : throw(beans::UnknownPropertyException,
2664 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2665 : {
2666 : OSL_FAIL("not implemented");
2667 0 : }
2668 :
2669 : // XMultiPropertySet
2670 :
2671 51 : void SAL_CALL ScCellRangesBase::setPropertyValues( const uno::Sequence< OUString >& aPropertyNames,
2672 : const uno::Sequence< uno::Any >& aValues )
2673 : throw (beans::PropertyVetoException,
2674 : lang::IllegalArgumentException,
2675 : lang::WrappedTargetException,
2676 : uno::RuntimeException, std::exception)
2677 : {
2678 51 : SolarMutexGuard aGuard;
2679 :
2680 51 : sal_Int32 nCount(aPropertyNames.getLength());
2681 51 : sal_Int32 nValues(aValues.getLength());
2682 51 : if (nCount != nValues)
2683 0 : throw lang::IllegalArgumentException();
2684 :
2685 51 : if ( pDocShell && nCount )
2686 : {
2687 51 : const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2688 51 : const OUString* pNames = aPropertyNames.getConstArray();
2689 51 : const uno::Any* pValues = aValues.getConstArray();
2690 :
2691 51 : boost::scoped_array<const SfxItemPropertySimpleEntry*> pEntryArray(new const SfxItemPropertySimpleEntry*[nCount]);
2692 :
2693 : sal_Int32 i;
2694 664 : for(i = 0; i < nCount; i++)
2695 : {
2696 : // first loop: find all properties in map, but handle only CellStyle
2697 : // (CellStyle must be set before any other cell properties)
2698 :
2699 613 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( pNames[i] );
2700 613 : pEntryArray[i] = pEntry;
2701 613 : if (pEntry)
2702 : {
2703 613 : if ( pEntry->nWID == SC_WID_UNO_CELLSTYL )
2704 : {
2705 : try
2706 : {
2707 50 : SetOnePropertyValue( pEntry, pValues[i] );
2708 : }
2709 0 : catch ( lang::IllegalArgumentException& )
2710 : {
2711 : OSL_FAIL("exception when setting cell style"); // not supposed to happen
2712 : }
2713 : }
2714 : }
2715 : }
2716 :
2717 51 : ScDocument& rDoc = pDocShell->GetDocument();
2718 102 : boost::scoped_ptr<ScPatternAttr> pOldPattern;
2719 102 : boost::scoped_ptr<ScPatternAttr> pNewPattern;
2720 :
2721 534 : for(i = 0; i < nCount; i++)
2722 : {
2723 : // second loop: handle other properties
2724 :
2725 503 : const SfxItemPropertySimpleEntry* pEntry = pEntryArray[i];
2726 503 : if ( pEntry )
2727 : {
2728 503 : if ( IsScItemWid( pEntry->nWID ) ) // can be handled by SfxItemPropertySet
2729 : {
2730 453 : if ( !pOldPattern )
2731 : {
2732 51 : pOldPattern.reset(new ScPatternAttr( *GetCurrentAttrsDeep() ));
2733 51 : pOldPattern->GetItemSet().ClearInvalidItems();
2734 51 : pNewPattern.reset(new ScPatternAttr( rDoc.GetPool() ));
2735 : }
2736 :
2737 : // collect items in pNewPattern, apply with one call after the loop
2738 :
2739 : sal_uInt16 nFirstItem, nSecondItem;
2740 453 : lcl_SetCellProperty( *pEntry, pValues[i], *pOldPattern, rDoc, nFirstItem, nSecondItem );
2741 :
2742 : // put only affected items into new set
2743 433 : if ( nFirstItem )
2744 433 : pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nFirstItem ) );
2745 433 : if ( nSecondItem )
2746 0 : pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nSecondItem ) );
2747 : }
2748 50 : else if ( pEntry->nWID != SC_WID_UNO_CELLSTYL ) // CellStyle is handled above
2749 : {
2750 : // call virtual method to set a single property
2751 0 : SetOnePropertyValue( pEntry, pValues[i] );
2752 : }
2753 : }
2754 : }
2755 :
2756 31 : if ( pNewPattern && !aRanges.empty() )
2757 82 : pDocShell->GetDocFunc().ApplyAttributes( *GetMarkData(), *pNewPattern, true, true );
2758 51 : }
2759 31 : }
2760 :
2761 0 : uno::Sequence<uno::Any> SAL_CALL ScCellRangesBase::getPropertyValues(
2762 : const uno::Sequence< OUString >& aPropertyNames )
2763 : throw (uno::RuntimeException, std::exception)
2764 : {
2765 0 : SolarMutexGuard aGuard;
2766 :
2767 0 : const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2768 :
2769 0 : uno::Sequence<uno::Any> aRet(aPropertyNames.getLength());
2770 0 : uno::Any* pProperties = aRet.getArray();
2771 0 : for(sal_Int32 i = 0; i < aPropertyNames.getLength(); i++)
2772 : {
2773 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyNames[i] );
2774 0 : GetOnePropertyValue( pEntry, pProperties[i] );
2775 : }
2776 0 : return aRet;
2777 : }
2778 :
2779 0 : void SAL_CALL ScCellRangesBase::addPropertiesChangeListener( const uno::Sequence< OUString >& /* aPropertyNames */,
2780 : const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ )
2781 : throw (uno::RuntimeException, std::exception)
2782 : {
2783 : OSL_FAIL("not implemented");
2784 0 : }
2785 :
2786 0 : void SAL_CALL ScCellRangesBase::removePropertiesChangeListener( const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ )
2787 : throw (uno::RuntimeException, std::exception)
2788 : {
2789 : OSL_FAIL("not implemented");
2790 0 : }
2791 :
2792 0 : void SAL_CALL ScCellRangesBase::firePropertiesChangeEvent( const uno::Sequence< OUString >& /* aPropertyNames */,
2793 : const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ )
2794 : throw (uno::RuntimeException, std::exception)
2795 : {
2796 : OSL_FAIL("not implemented");
2797 0 : }
2798 :
2799 8 : IMPL_LINK( ScCellRangesBase, ValueListenerHdl, SfxHint*, pHint )
2800 : {
2801 8 : if ( pDocShell && pHint && dynamic_cast<const SfxSimpleHint*>(pHint) &&
2802 4 : (static_cast<const SfxSimpleHint*>(pHint)->GetId() & SC_HINT_DATACHANGED))
2803 : {
2804 : // This may be called several times for a single change, if several formulas
2805 : // in the range are notified. So only a flag is set that is checked when
2806 : // SFX_HINT_DATACHANGED is received.
2807 :
2808 0 : bGotDataChangedHint = true;
2809 : }
2810 4 : return 0;
2811 : }
2812 :
2813 : // XTolerantMultiPropertySet
2814 1420 : uno::Sequence< beans::SetPropertyTolerantFailed > SAL_CALL ScCellRangesBase::setPropertyValuesTolerant( const uno::Sequence< OUString >& aPropertyNames,
2815 : const uno::Sequence< uno::Any >& aValues )
2816 : throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception)
2817 : {
2818 1420 : SolarMutexGuard aGuard;
2819 :
2820 1420 : sal_Int32 nCount(aPropertyNames.getLength());
2821 1420 : sal_Int32 nValues(aValues.getLength());
2822 1420 : if (nCount != nValues)
2823 0 : throw lang::IllegalArgumentException();
2824 :
2825 1420 : if ( pDocShell && nCount )
2826 : {
2827 1420 : uno::Sequence < beans::SetPropertyTolerantFailed > aReturns(nCount);
2828 1420 : beans::SetPropertyTolerantFailed* pReturns = aReturns.getArray();
2829 :
2830 1420 : const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2831 1420 : const OUString* pNames = aPropertyNames.getConstArray();
2832 1420 : const uno::Any* pValues = aValues.getConstArray();
2833 :
2834 2840 : boost::scoped_array<const SfxItemPropertySimpleEntry*> pMapArray(new const SfxItemPropertySimpleEntry*[nCount]);
2835 :
2836 : sal_Int32 i;
2837 17428 : for(i = 0; i < nCount; i++)
2838 : {
2839 : // first loop: find all properties in map, but handle only CellStyle
2840 : // (CellStyle must be set before any other cell properties)
2841 :
2842 16008 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( pNames[i] );
2843 16008 : pMapArray[i] = pEntry;
2844 16008 : if (pEntry)
2845 : {
2846 15948 : if ( pEntry->nWID == SC_WID_UNO_CELLSTYL )
2847 : {
2848 : try
2849 : {
2850 1089 : SetOnePropertyValue( pEntry, pValues[i] );
2851 : }
2852 0 : catch ( lang::IllegalArgumentException& )
2853 : {
2854 : OSL_FAIL("exception when setting cell style"); // not supposed to happen
2855 : }
2856 : }
2857 : }
2858 : }
2859 :
2860 1420 : ScDocument& rDoc = pDocShell->GetDocument();
2861 2840 : boost::scoped_ptr<ScPatternAttr> pOldPattern;
2862 2840 : boost::scoped_ptr<ScPatternAttr> pNewPattern;
2863 :
2864 1420 : sal_Int32 nFailed(0);
2865 17428 : for(i = 0; i < nCount; i++)
2866 : {
2867 : // second loop: handle other properties
2868 :
2869 16008 : const SfxItemPropertySimpleEntry* pEntry = pMapArray[i];
2870 16008 : if ( pEntry && ((pEntry->nFlags & beans::PropertyAttribute::READONLY) == 0))
2871 : {
2872 15941 : if ( IsScItemWid( pEntry->nWID ) ) // can be handled by SfxItemPropertySet
2873 : {
2874 13882 : if ( !pOldPattern )
2875 : {
2876 1004 : pOldPattern.reset(new ScPatternAttr( *GetCurrentAttrsDeep() ));
2877 1004 : pOldPattern->GetItemSet().ClearInvalidItems();
2878 1004 : pNewPattern.reset(new ScPatternAttr( rDoc.GetPool() ));
2879 : }
2880 :
2881 : // collect items in pNewPattern, apply with one call after the loop
2882 :
2883 : sal_uInt16 nFirstItem, nSecondItem;
2884 : try
2885 : {
2886 13882 : lcl_SetCellProperty( *pEntry, pValues[i], *pOldPattern, rDoc, nFirstItem, nSecondItem );
2887 :
2888 : // put only affected items into new set
2889 13860 : if ( nFirstItem )
2890 13860 : pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nFirstItem ) );
2891 13860 : if ( nSecondItem )
2892 9 : pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nSecondItem ) );
2893 : }
2894 44 : catch ( lang::IllegalArgumentException& )
2895 : {
2896 22 : pReturns[nFailed].Name = pNames[i];
2897 22 : pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::ILLEGAL_ARGUMENT;
2898 : }
2899 : }
2900 2059 : else if ( pEntry->nWID != SC_WID_UNO_CELLSTYL ) // CellStyle is handled above
2901 : {
2902 : // call virtual method to set a single property
2903 : try
2904 : {
2905 970 : SetOnePropertyValue( pEntry, pValues[i] );
2906 : }
2907 0 : catch ( lang::IllegalArgumentException& )
2908 : {
2909 0 : pReturns[nFailed].Name = pNames[i];
2910 0 : pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::ILLEGAL_ARGUMENT;
2911 : }
2912 15941 : }
2913 : }
2914 : else
2915 : {
2916 67 : pReturns[nFailed].Name = pNames[i];
2917 67 : if (pEntry)
2918 7 : pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::PROPERTY_VETO;
2919 : else
2920 60 : pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
2921 : }
2922 : }
2923 :
2924 1420 : if ( pNewPattern && !aRanges.empty() )
2925 1004 : pDocShell->GetDocFunc().ApplyAttributes( *GetMarkData(), *pNewPattern, true, true );
2926 :
2927 1420 : aReturns.realloc(nFailed);
2928 :
2929 2840 : return aReturns;
2930 : }
2931 0 : return uno::Sequence < beans::SetPropertyTolerantFailed >();
2932 : }
2933 :
2934 11 : uno::Sequence< beans::GetPropertyTolerantResult > SAL_CALL ScCellRangesBase::getPropertyValuesTolerant( const uno::Sequence< OUString >& aPropertyNames )
2935 : throw (uno::RuntimeException, std::exception)
2936 : {
2937 11 : SolarMutexGuard aGuard;
2938 :
2939 11 : sal_Int32 nCount(aPropertyNames.getLength());
2940 11 : uno::Sequence < beans::GetPropertyTolerantResult > aReturns(nCount);
2941 11 : beans::GetPropertyTolerantResult* pReturns = aReturns.getArray();
2942 :
2943 11 : const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2944 :
2945 1102 : for(sal_Int32 i = 0; i < nCount; i++)
2946 : {
2947 1091 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyNames[i] );
2948 1091 : if (!pEntry)
2949 : {
2950 0 : pReturns[i].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
2951 : }
2952 : else
2953 : {
2954 1091 : sal_uInt16 nItemWhich = 0;
2955 1091 : lcl_GetPropertyWhich( pEntry, nItemWhich );
2956 1091 : pReturns[i].State = GetOnePropertyState( nItemWhich, pEntry );
2957 1091 : GetOnePropertyValue( pEntry, pReturns[i].Value );
2958 1091 : pReturns[i].Result = beans::TolerantPropertySetResultType::SUCCESS;
2959 : }
2960 : }
2961 11 : return aReturns;
2962 : }
2963 :
2964 220 : uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL ScCellRangesBase::getDirectPropertyValuesTolerant( const uno::Sequence< OUString >& aPropertyNames )
2965 : throw (uno::RuntimeException, std::exception)
2966 : {
2967 220 : SolarMutexGuard aGuard;
2968 :
2969 220 : sal_Int32 nCount(aPropertyNames.getLength());
2970 220 : uno::Sequence < beans::GetDirectPropertyTolerantResult > aReturns(nCount);
2971 220 : beans::GetDirectPropertyTolerantResult* pReturns = aReturns.getArray();
2972 :
2973 220 : const SfxItemPropertyMap& rPropertyMap = GetItemPropertyMap(); // from derived class
2974 :
2975 220 : sal_Int32 j = 0;
2976 7330 : for(sal_Int32 i = 0; i < nCount; i++)
2977 : {
2978 7110 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyNames[i] );
2979 7110 : if (!pEntry)
2980 : {
2981 0 : pReturns[i].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY;
2982 : }
2983 : else
2984 : {
2985 7110 : sal_uInt16 nItemWhich = 0;
2986 7110 : lcl_GetPropertyWhich( pEntry, nItemWhich );
2987 7110 : pReturns[j].State = GetOnePropertyState( nItemWhich, pEntry );
2988 7110 : if (pReturns[j].State == beans::PropertyState_DIRECT_VALUE)
2989 : {
2990 620 : GetOnePropertyValue( pEntry, pReturns[j].Value );
2991 620 : pReturns[j].Result = beans::TolerantPropertySetResultType::SUCCESS;
2992 620 : pReturns[j].Name = aPropertyNames[i];
2993 620 : ++j;
2994 : }
2995 : }
2996 : }
2997 220 : if (j < nCount)
2998 85 : aReturns.realloc(j);
2999 220 : return aReturns;
3000 : }
3001 :
3002 : // XIndent
3003 :
3004 3 : void SAL_CALL ScCellRangesBase::decrementIndent() throw(::com::sun::star::uno::RuntimeException, std::exception)
3005 : {
3006 3 : SolarMutexGuard aGuard;
3007 3 : if ( pDocShell && !aRanges.empty() ) // leer = nichts zu tun
3008 : {
3009 : //#97041#; put only MultiMarked ScMarkData in ChangeIndent
3010 3 : ScMarkData aMarkData(*GetMarkData());
3011 3 : aMarkData.MarkToMulti();
3012 3 : pDocShell->GetDocFunc().ChangeIndent( aMarkData, false, true );
3013 3 : }
3014 3 : }
3015 :
3016 3 : void SAL_CALL ScCellRangesBase::incrementIndent() throw(::com::sun::star::uno::RuntimeException, std::exception)
3017 : {
3018 3 : SolarMutexGuard aGuard;
3019 3 : if ( pDocShell && !aRanges.empty() ) // leer = nichts zu tun
3020 : {
3021 : //#97041#; put only MultiMarked ScMarkData in ChangeIndent
3022 3 : ScMarkData aMarkData(*GetMarkData());
3023 3 : aMarkData.MarkToMulti();
3024 3 : pDocShell->GetDocFunc().ChangeIndent( aMarkData, true, true );
3025 3 : }
3026 3 : }
3027 :
3028 : // XChartData
3029 :
3030 18 : ScMemChart* ScCellRangesBase::CreateMemChart_Impl() const
3031 : {
3032 18 : if ( pDocShell && !aRanges.empty() )
3033 : {
3034 18 : ScRangeListRef xChartRanges;
3035 18 : if ( aRanges.size() == 1 )
3036 : {
3037 : // ganze Tabelle sinnvoll begrenzen (auf belegten Datenbereich)
3038 : // (nur hier, Listener werden auf den ganzen Bereich angemeldet)
3039 : //! direkt testen, ob es ein ScTableSheetObj ist?
3040 :
3041 8 : const ScRange* pRange = aRanges[0];
3042 24 : if ( pRange->aStart.Col() == 0 && pRange->aEnd.Col() == MAXCOL &&
3043 8 : pRange->aStart.Row() == 0 && pRange->aEnd.Row() == MAXROW )
3044 : {
3045 0 : SCTAB nTab = pRange->aStart.Tab();
3046 :
3047 : SCCOL nStartX;
3048 : SCROW nStartY; // Anfang holen
3049 0 : if (!pDocShell->GetDocument().GetDataStart( nTab, nStartX, nStartY ))
3050 : {
3051 0 : nStartX = 0;
3052 0 : nStartY = 0;
3053 : }
3054 :
3055 : SCCOL nEndX;
3056 : SCROW nEndY; // Ende holen
3057 0 : if (!pDocShell->GetDocument().GetTableArea( nTab, nEndX, nEndY ))
3058 : {
3059 0 : nEndX = 0;
3060 0 : nEndY = 0;
3061 : }
3062 :
3063 0 : xChartRanges = new ScRangeList;
3064 0 : xChartRanges->Append( ScRange( nStartX, nStartY, nTab, nEndX, nEndY, nTab ) );
3065 : }
3066 : }
3067 18 : if (!xChartRanges.Is()) // sonst Ranges direkt uebernehmen
3068 18 : xChartRanges = new ScRangeList(aRanges);
3069 36 : ScChartArray aArr( &pDocShell->GetDocument(), xChartRanges, OUString() );
3070 :
3071 : // RowAsHdr = ColHeaders und umgekehrt
3072 18 : aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr );
3073 :
3074 36 : return aArr.CreateMemChart();
3075 : }
3076 0 : return NULL;
3077 : }
3078 :
3079 6 : uno::Sequence< uno::Sequence<double> > SAL_CALL ScCellRangesBase::getData()
3080 : throw(uno::RuntimeException, std::exception)
3081 : {
3082 6 : SolarMutexGuard aGuard;
3083 12 : boost::scoped_ptr<ScMemChart> pMemChart(CreateMemChart_Impl());
3084 6 : if ( pMemChart )
3085 : {
3086 6 : sal_Int32 nColCount = pMemChart->GetColCount();
3087 6 : sal_Int32 nRowCount = static_cast<sal_Int32>(pMemChart->GetRowCount());
3088 :
3089 6 : uno::Sequence< uno::Sequence<double> > aRowSeq( nRowCount );
3090 6 : uno::Sequence<double>* pRowAry = aRowSeq.getArray();
3091 60 : for (sal_Int32 nRow = 0; nRow < nRowCount; nRow++)
3092 : {
3093 54 : uno::Sequence<double> aColSeq( nColCount );
3094 54 : double* pColAry = aColSeq.getArray();
3095 148 : for (sal_Int32 nCol = 0; nCol < nColCount; nCol++)
3096 94 : pColAry[nCol] = pMemChart->GetData( nCol, nRow );
3097 :
3098 54 : pRowAry[nRow] = aColSeq;
3099 54 : }
3100 :
3101 6 : return aRowSeq;
3102 : }
3103 :
3104 6 : return uno::Sequence< uno::Sequence<double> >(0);
3105 : }
3106 :
3107 8 : ScRangeListRef ScCellRangesBase::GetLimitedChartRanges_Impl( long nDataColumns, long nDataRows ) const
3108 : {
3109 8 : if ( aRanges.size() == 1 )
3110 : {
3111 3 : const ScRange* pRange = aRanges[0];
3112 9 : if ( pRange->aStart.Col() == 0 && pRange->aEnd.Col() == MAXCOL &&
3113 3 : pRange->aStart.Row() == 0 && pRange->aEnd.Row() == MAXROW )
3114 : {
3115 : // if aRanges is a complete sheet, limit to given size
3116 :
3117 0 : SCTAB nTab = pRange->aStart.Tab();
3118 :
3119 0 : long nEndColumn = nDataColumns - 1 + ( bChartColAsHdr ? 1 : 0 );
3120 0 : if ( nEndColumn < 0 )
3121 0 : nEndColumn = 0;
3122 0 : if ( nEndColumn > MAXCOL )
3123 0 : nEndColumn = MAXCOL;
3124 :
3125 0 : long nEndRow = nDataRows - 1 + ( bChartRowAsHdr ? 1 : 0 );
3126 0 : if ( nEndRow < 0 )
3127 0 : nEndRow = 0;
3128 0 : if ( nEndRow > MAXROW )
3129 0 : nEndRow = MAXROW;
3130 :
3131 0 : ScRangeListRef xChartRanges = new ScRangeList;
3132 0 : xChartRanges->Append( ScRange( 0, 0, nTab, (SCCOL)nEndColumn, (SCROW)nEndRow, nTab ) );
3133 0 : return xChartRanges;
3134 : }
3135 : }
3136 :
3137 8 : return new ScRangeList(aRanges); // as-is
3138 : }
3139 :
3140 4 : void SAL_CALL ScCellRangesBase::setData( const uno::Sequence< uno::Sequence<double> >& aData )
3141 : throw(uno::RuntimeException, std::exception)
3142 : {
3143 4 : SolarMutexGuard aGuard;
3144 4 : bool bDone = false;
3145 4 : long nRowCount = aData.getLength();
3146 4 : long nColCount = nRowCount ? aData[0].getLength() : 0;
3147 8 : ScRangeListRef xChartRanges = GetLimitedChartRanges_Impl( nColCount, nRowCount );
3148 4 : if ( pDocShell && xChartRanges.Is() )
3149 : {
3150 4 : ScDocument& rDoc = pDocShell->GetDocument();
3151 4 : ScChartArray aArr( &rDoc, xChartRanges, OUString() );
3152 4 : aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr ); // RowAsHdr = ColHeaders
3153 4 : const ScChartPositionMap* pPosMap = aArr.GetPositionMap();
3154 4 : if (pPosMap)
3155 : {
3156 8 : if ( pPosMap->GetColCount() == static_cast<SCCOL>(nColCount) &&
3157 4 : pPosMap->GetRowCount() == static_cast<SCROW>(nRowCount) )
3158 : {
3159 43 : for (long nRow=0; nRow<nRowCount; nRow++)
3160 : {
3161 39 : const uno::Sequence<double>& rRowSeq = aData[nRow];
3162 39 : const double* pArray = rRowSeq.getConstArray();
3163 39 : nColCount = rRowSeq.getLength();
3164 110 : for (long nCol=0; nCol<nColCount; nCol++)
3165 : {
3166 : const ScAddress* pPos = pPosMap->GetPosition(
3167 71 : sal::static_int_cast<SCCOL>(nCol),
3168 142 : sal::static_int_cast<SCROW>(nRow) );
3169 71 : if (pPos)
3170 : {
3171 71 : double fVal = pArray[nCol];
3172 71 : if ( fVal == DBL_MIN )
3173 38 : rDoc.SetEmptyCell(*pPos);
3174 : else
3175 33 : rDoc.SetValue(*pPos, pArray[nCol]);
3176 : }
3177 : }
3178 : }
3179 :
3180 : //! undo
3181 4 : PaintRanges_Impl( PAINT_GRID );
3182 4 : pDocShell->SetDocumentModified();
3183 4 : ForceChartListener_Impl(); // call listeners for this object synchronously
3184 4 : bDone = true;
3185 : }
3186 4 : }
3187 : }
3188 :
3189 4 : if (!bDone)
3190 4 : throw uno::RuntimeException();
3191 4 : }
3192 :
3193 6 : uno::Sequence<OUString> SAL_CALL ScCellRangesBase::getRowDescriptions()
3194 : throw(uno::RuntimeException, std::exception)
3195 : {
3196 6 : SolarMutexGuard aGuard;
3197 12 : boost::scoped_ptr<ScMemChart> pMemChart(CreateMemChart_Impl());
3198 6 : if ( pMemChart )
3199 : {
3200 6 : sal_Int32 nRowCount = static_cast<sal_Int32>(pMemChart->GetRowCount());
3201 6 : uno::Sequence<OUString> aSeq( nRowCount );
3202 6 : OUString* pAry = aSeq.getArray();
3203 51 : for (sal_Int32 nRow = 0; nRow < nRowCount; nRow++)
3204 45 : pAry[nRow] = pMemChart->GetRowText(nRow);
3205 :
3206 6 : return aSeq;
3207 : }
3208 6 : return uno::Sequence<OUString>(0);
3209 : }
3210 :
3211 2 : void SAL_CALL ScCellRangesBase::setRowDescriptions(
3212 : const uno::Sequence<OUString>& aRowDescriptions )
3213 : throw(uno::RuntimeException, std::exception)
3214 : {
3215 2 : SolarMutexGuard aGuard;
3216 2 : bool bDone = false;
3217 2 : if ( bChartColAsHdr )
3218 : {
3219 2 : long nRowCount = aRowDescriptions.getLength();
3220 2 : ScRangeListRef xChartRanges = GetLimitedChartRanges_Impl( 1, nRowCount );
3221 2 : if ( pDocShell && xChartRanges.Is() )
3222 : {
3223 2 : ScDocument& rDoc = pDocShell->GetDocument();
3224 2 : ScChartArray aArr( &rDoc, xChartRanges, OUString() );
3225 2 : aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr ); // RowAsHdr = ColHeaders
3226 2 : const ScChartPositionMap* pPosMap = aArr.GetPositionMap();
3227 2 : if (pPosMap)
3228 : {
3229 2 : if ( pPosMap->GetRowCount() == static_cast<SCROW>(nRowCount) )
3230 : {
3231 2 : const OUString* pArray = aRowDescriptions.getConstArray();
3232 17 : for (long nRow=0; nRow<nRowCount; nRow++)
3233 : {
3234 : const ScAddress* pPos = pPosMap->GetRowHeaderPosition(
3235 15 : static_cast<SCSIZE>(nRow) );
3236 15 : if (pPos)
3237 : {
3238 15 : const OUString& aStr = pArray[nRow];
3239 15 : if (aStr.isEmpty())
3240 0 : rDoc.SetEmptyCell(*pPos);
3241 : else
3242 : {
3243 15 : ScSetStringParam aParam;
3244 15 : aParam.setTextInput();
3245 15 : rDoc.SetString(*pPos, aStr, &aParam);
3246 : }
3247 : }
3248 : }
3249 :
3250 : //! undo
3251 2 : PaintRanges_Impl( PAINT_GRID );
3252 2 : pDocShell->SetDocumentModified();
3253 2 : ForceChartListener_Impl(); // call listeners for this object synchronously
3254 2 : bDone = true;
3255 : }
3256 2 : }
3257 2 : }
3258 : }
3259 :
3260 2 : if (!bDone)
3261 0 : throw uno::RuntimeException();
3262 2 : }
3263 :
3264 6 : uno::Sequence<OUString> SAL_CALL ScCellRangesBase::getColumnDescriptions()
3265 : throw(uno::RuntimeException, std::exception)
3266 : {
3267 6 : SolarMutexGuard aGuard;
3268 12 : boost::scoped_ptr<ScMemChart> pMemChart(CreateMemChart_Impl());
3269 6 : if ( pMemChart )
3270 : {
3271 6 : sal_Int32 nColCount = pMemChart->GetColCount();
3272 6 : uno::Sequence<OUString> aSeq( nColCount );
3273 6 : OUString* pAry = aSeq.getArray();
3274 18 : for (sal_Int32 nCol = 0; nCol < nColCount; nCol++)
3275 12 : pAry[nCol] = pMemChart->GetColText(nCol);
3276 :
3277 6 : return aSeq;
3278 : }
3279 6 : return uno::Sequence<OUString>(0);
3280 : }
3281 :
3282 2 : void SAL_CALL ScCellRangesBase::setColumnDescriptions(
3283 : const uno::Sequence<OUString>& aColumnDescriptions )
3284 : throw(uno::RuntimeException, std::exception)
3285 : {
3286 2 : SolarMutexGuard aGuard;
3287 2 : bool bDone = false;
3288 2 : if ( bChartRowAsHdr )
3289 : {
3290 2 : long nColCount = aColumnDescriptions.getLength();
3291 2 : ScRangeListRef xChartRanges = GetLimitedChartRanges_Impl( nColCount, 1 );
3292 2 : if ( pDocShell && xChartRanges.Is() )
3293 : {
3294 2 : ScDocument& rDoc = pDocShell->GetDocument();
3295 2 : ScChartArray aArr( &rDoc, xChartRanges, OUString() );
3296 2 : aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr ); // RowAsHdr = ColHeaders
3297 2 : const ScChartPositionMap* pPosMap = aArr.GetPositionMap();
3298 2 : if (pPosMap)
3299 : {
3300 2 : if ( pPosMap->GetColCount() == static_cast<SCCOL>(nColCount) )
3301 : {
3302 2 : const OUString* pArray = aColumnDescriptions.getConstArray();
3303 6 : for (long nCol=0; nCol<nColCount; nCol++)
3304 : {
3305 : const ScAddress* pPos = pPosMap->GetColHeaderPosition(
3306 4 : sal::static_int_cast<SCCOL>(nCol) );
3307 4 : if (pPos)
3308 : {
3309 4 : const OUString& aStr = pArray[nCol];
3310 4 : if (aStr.isEmpty())
3311 0 : rDoc.SetEmptyCell(*pPos);
3312 : else
3313 : {
3314 4 : ScSetStringParam aParam;
3315 4 : aParam.setTextInput();
3316 4 : rDoc.SetString(*pPos, aStr, &aParam);
3317 : }
3318 : }
3319 : }
3320 :
3321 : //! undo
3322 2 : PaintRanges_Impl( PAINT_GRID );
3323 2 : pDocShell->SetDocumentModified();
3324 2 : ForceChartListener_Impl(); // call listeners for this object synchronously
3325 2 : bDone = true;
3326 : }
3327 2 : }
3328 2 : }
3329 : }
3330 :
3331 2 : if (!bDone)
3332 0 : throw uno::RuntimeException();
3333 2 : }
3334 :
3335 8 : void ScCellRangesBase::ForceChartListener_Impl()
3336 : {
3337 : // call Update immediately so the caller to setData etc. can
3338 : // regognize the listener call
3339 :
3340 8 : if (!pDocShell)
3341 0 : return;
3342 :
3343 8 : ScChartListenerCollection* pColl = pDocShell->GetDocument().GetChartListenerCollection();
3344 8 : if (!pColl)
3345 0 : return;
3346 :
3347 8 : ScChartListenerCollection::ListenersType& rListeners = pColl->getListeners();
3348 8 : ScChartListenerCollection::ListenersType::iterator it = rListeners.begin(), itEnd = rListeners.end();
3349 11 : for (; it != itEnd; ++it)
3350 : {
3351 3 : ScChartListener* p = it->second;
3352 : OSL_ASSERT(p);
3353 3 : if (p->GetUnoSource() == static_cast<chart::XChartData*>(this) && p->IsDirty())
3354 3 : p->Update();
3355 : }
3356 : }
3357 :
3358 2 : void SAL_CALL ScCellRangesBase::addChartDataChangeEventListener( const uno::Reference<
3359 : chart::XChartDataChangeEventListener >& aListener )
3360 : throw(uno::RuntimeException, std::exception)
3361 : {
3362 2 : SolarMutexGuard aGuard;
3363 2 : if ( pDocShell && !aRanges.empty() )
3364 : {
3365 : //! auf doppelte testen?
3366 :
3367 2 : ScDocument& rDoc = pDocShell->GetDocument();
3368 2 : ScRangeListRef aRangesRef( new ScRangeList(aRanges) );
3369 2 : ScChartListenerCollection* pColl = rDoc.GetChartListenerCollection();
3370 4 : OUString aName = pColl->getUniqueName(OUString("__Uno"));
3371 2 : if (aName.isEmpty())
3372 : // failed to create unique name.
3373 2 : return;
3374 :
3375 2 : ScChartListener* pListener = new ScChartListener( aName, &rDoc, aRangesRef );
3376 2 : pListener->SetUno( aListener, this );
3377 2 : pColl->insert( pListener );
3378 4 : pListener->StartListeningTo();
3379 2 : }
3380 : }
3381 :
3382 2 : void SAL_CALL ScCellRangesBase::removeChartDataChangeEventListener( const uno::Reference<
3383 : chart::XChartDataChangeEventListener >& aListener )
3384 : throw (uno::RuntimeException, std::exception)
3385 : {
3386 2 : SolarMutexGuard aGuard;
3387 2 : if ( pDocShell && !aRanges.empty() )
3388 : {
3389 2 : ScDocument& rDoc = pDocShell->GetDocument();
3390 2 : ScChartListenerCollection* pColl = rDoc.GetChartListenerCollection();
3391 2 : pColl->FreeUno( aListener, this );
3392 2 : }
3393 2 : }
3394 :
3395 1 : double SAL_CALL ScCellRangesBase::getNotANumber() throw(::com::sun::star::uno::RuntimeException, std::exception)
3396 : {
3397 : // im ScChartArray wird DBL_MIN verwendet, weil das Chart es so will
3398 1 : return DBL_MIN;
3399 : }
3400 :
3401 2 : sal_Bool SAL_CALL ScCellRangesBase::isNotANumber( double nNumber ) throw(uno::RuntimeException, std::exception)
3402 : {
3403 : // im ScChartArray wird DBL_MIN verwendet, weil das Chart es so will
3404 2 : return (nNumber == DBL_MIN);
3405 : }
3406 :
3407 : // XModifyBroadcaster
3408 :
3409 6 : void SAL_CALL ScCellRangesBase::addModifyListener(const uno::Reference<util::XModifyListener>& aListener)
3410 : throw (uno::RuntimeException, std::exception)
3411 : {
3412 6 : SolarMutexGuard aGuard;
3413 6 : if ( aRanges.empty() )
3414 0 : throw uno::RuntimeException();
3415 :
3416 : uno::Reference<util::XModifyListener> *pObj =
3417 6 : new uno::Reference<util::XModifyListener>( aListener );
3418 6 : aValueListeners.push_back( pObj );
3419 :
3420 6 : if ( aValueListeners.size() == 1 )
3421 : {
3422 6 : if (!pValueListener)
3423 6 : pValueListener = new ScLinkListener( LINK( this, ScCellRangesBase, ValueListenerHdl ) );
3424 :
3425 6 : ScDocument& rDoc = pDocShell->GetDocument();
3426 12 : for ( size_t i = 0, nCount = aRanges.size(); i < nCount; i++)
3427 6 : rDoc.StartListeningArea( *aRanges[ i ], false, pValueListener );
3428 :
3429 6 : acquire(); // don't lose this object (one ref for all listeners)
3430 6 : }
3431 6 : }
3432 :
3433 2 : void SAL_CALL ScCellRangesBase::removeModifyListener( const uno::Reference<util::XModifyListener>& aListener )
3434 : throw(uno::RuntimeException, std::exception)
3435 : {
3436 :
3437 2 : SolarMutexGuard aGuard;
3438 2 : if ( aRanges.empty() )
3439 0 : throw uno::RuntimeException();
3440 :
3441 2 : acquire(); // in case the listeners have the last ref - released below
3442 :
3443 2 : sal_uInt16 nCount = aValueListeners.size();
3444 4 : for ( sal_uInt16 n=nCount; n--; )
3445 : {
3446 2 : uno::Reference<util::XModifyListener>& rObj = aValueListeners[n];
3447 2 : if ( rObj == aListener )
3448 : {
3449 2 : aValueListeners.erase( aValueListeners.begin() + n );
3450 :
3451 2 : if ( aValueListeners.empty() )
3452 : {
3453 2 : if (pValueListener)
3454 2 : pValueListener->EndListeningAll();
3455 :
3456 2 : release(); // release the ref for the listeners
3457 : }
3458 :
3459 2 : break;
3460 : }
3461 : }
3462 :
3463 2 : release(); // might delete this object
3464 2 : }
3465 :
3466 : // XCellRangesQuery
3467 :
3468 25 : uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryVisibleCells()
3469 : throw(uno::RuntimeException, std::exception)
3470 : {
3471 25 : SolarMutexGuard aGuard;
3472 25 : if (pDocShell)
3473 : {
3474 : //! fuer alle Tabellen getrennt, wenn Markierungen pro Tabelle getrennt sind!
3475 25 : SCTAB nTab = lcl_FirstTab(aRanges);
3476 :
3477 25 : ScMarkData aMarkData(*GetMarkData());
3478 :
3479 25 : ScDocument& rDoc = pDocShell->GetDocument();
3480 25 : SCCOL nCol = 0, nLastCol;
3481 107 : while (nCol <= MAXCOL)
3482 : {
3483 57 : if (rDoc.ColHidden(nCol, nTab, NULL, &nLastCol))
3484 : // hidden columns. Unselect them.
3485 18 : aMarkData.SetMultiMarkArea(ScRange(nCol, 0, nTab, nLastCol, MAXROW, nTab), false);
3486 :
3487 57 : nCol = nLastCol + 1;
3488 : }
3489 :
3490 25 : SCROW nRow = 0, nLastRow;
3491 104 : while (nRow <= MAXROW)
3492 : {
3493 54 : if (rDoc.RowHidden(nRow, nTab, NULL, &nLastRow))
3494 : // These rows are hidden. Unselect them.
3495 15 : aMarkData.SetMultiMarkArea(ScRange(0, nRow, nTab, MAXCOL, nLastRow, nTab), false);
3496 :
3497 54 : nRow = nLastRow + 1;
3498 : }
3499 :
3500 50 : ScRangeList aNewRanges;
3501 25 : aMarkData.FillRangeListWithMarks( &aNewRanges, false );
3502 50 : return new ScCellRangesObj( pDocShell, aNewRanges );
3503 : }
3504 :
3505 0 : return NULL;
3506 : }
3507 :
3508 3 : uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryEmptyCells()
3509 : throw(uno::RuntimeException, std::exception)
3510 : {
3511 3 : SolarMutexGuard aGuard;
3512 3 : if (pDocShell)
3513 : {
3514 3 : ScDocument& rDoc = pDocShell->GetDocument();
3515 :
3516 3 : ScMarkData aMarkData(*GetMarkData());
3517 :
3518 : // belegte Zellen wegmarkieren
3519 9 : for (size_t i = 0, nCount = aRanges.size(); i < nCount; ++i)
3520 : {
3521 6 : ScRange aRange = *aRanges[ i ];
3522 :
3523 6 : ScCellIterator aIter( &rDoc, aRange );
3524 35 : for (bool bHasCell = aIter.first(); bHasCell; bHasCell = aIter.next())
3525 : {
3526 : // Notizen zaehlen als nicht-leer
3527 29 : if (!aIter.isEmpty())
3528 29 : aMarkData.SetMultiMarkArea(aIter.GetPos(), false);
3529 : }
3530 6 : }
3531 :
3532 6 : ScRangeList aNewRanges;
3533 : // IsMultiMarked reicht hier nicht (wird beim deselektieren nicht zurueckgesetzt)
3534 : //if (aMarkData.HasAnyMultiMarks()) // #i20044# should be set for all empty range
3535 3 : aMarkData.FillRangeListWithMarks( &aNewRanges, false );
3536 :
3537 6 : return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein
3538 : }
3539 :
3540 0 : return NULL;
3541 : }
3542 :
3543 27 : uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryContentCells(
3544 : sal_Int16 nContentFlags )
3545 : throw(uno::RuntimeException, std::exception)
3546 : {
3547 27 : SolarMutexGuard aGuard;
3548 27 : if (pDocShell)
3549 : {
3550 27 : ScDocument& rDoc = pDocShell->GetDocument();
3551 :
3552 27 : ScMarkData aMarkData;
3553 :
3554 : // passende Zellen selektieren
3555 57 : for ( size_t i = 0, nCount = aRanges.size(); i < nCount; ++i )
3556 : {
3557 30 : ScRange aRange = *aRanges[ i ];
3558 :
3559 30 : ScCellIterator aIter( &rDoc, aRange );
3560 64 : for (bool bHasCell = aIter.first(); bHasCell; bHasCell = aIter.next())
3561 : {
3562 34 : bool bAdd = false;
3563 34 : switch (aIter.getType())
3564 : {
3565 : case CELLTYPE_STRING:
3566 22 : if ( nContentFlags & sheet::CellFlags::STRING )
3567 2 : bAdd = true;
3568 22 : break;
3569 : case CELLTYPE_EDIT:
3570 0 : if ( (nContentFlags & sheet::CellFlags::STRING) || (nContentFlags & sheet::CellFlags::FORMATTED) )
3571 0 : bAdd = true;
3572 0 : break;
3573 : case CELLTYPE_FORMULA:
3574 2 : if ( nContentFlags & sheet::CellFlags::FORMULA )
3575 0 : bAdd = true;
3576 2 : break;
3577 : case CELLTYPE_VALUE:
3578 10 : if ( (nContentFlags & (sheet::CellFlags::VALUE|sheet::CellFlags::DATETIME))
3579 : == (sheet::CellFlags::VALUE|sheet::CellFlags::DATETIME) )
3580 0 : bAdd = true;
3581 : else
3582 : {
3583 : // Date/Time Erkennung
3584 :
3585 : sal_uLong nIndex = (sal_uLong)static_cast<const SfxUInt32Item*>(rDoc.GetAttr(
3586 10 : aIter.GetPos(), ATTR_VALUE_FORMAT))->GetValue();
3587 10 : short nTyp = rDoc.GetFormatTable()->GetType(nIndex);
3588 10 : if ((nTyp == css::util::NumberFormat::DATE) || (nTyp == css::util::NumberFormat::TIME) ||
3589 : (nTyp == css::util::NumberFormat::DATETIME))
3590 : {
3591 0 : if ( nContentFlags & sheet::CellFlags::DATETIME )
3592 0 : bAdd = true;
3593 : }
3594 : else
3595 : {
3596 10 : if ( nContentFlags & sheet::CellFlags::VALUE )
3597 6 : bAdd = true;
3598 : }
3599 : }
3600 10 : break;
3601 : default:
3602 : {
3603 : // added to avoid warnings
3604 : }
3605 : }
3606 :
3607 34 : if (bAdd)
3608 8 : aMarkData.SetMultiMarkArea(aIter.GetPos(), true);
3609 : }
3610 :
3611 30 : }
3612 :
3613 27 : ScRangeList aNewRanges;
3614 27 : if (aMarkData.IsMultiMarked())
3615 3 : aMarkData.FillRangeListWithMarks( &aNewRanges, false );
3616 :
3617 27 : return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein
3618 : }
3619 :
3620 0 : return NULL;
3621 : }
3622 :
3623 49 : uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryFormulaCells(
3624 : sal_Int32 nResultFlags )
3625 : throw(uno::RuntimeException, std::exception)
3626 : {
3627 49 : SolarMutexGuard aGuard;
3628 49 : if (pDocShell)
3629 : {
3630 49 : ScDocument& rDoc = pDocShell->GetDocument();
3631 :
3632 49 : ScMarkData aMarkData;
3633 :
3634 : // passende Zellen selektieren
3635 101 : for ( size_t i = 0, nCount = aRanges.size(); i < nCount; ++i )
3636 : {
3637 52 : ScRange aRange = *aRanges[ i ];
3638 :
3639 52 : ScCellIterator aIter( &rDoc, aRange );
3640 472 : for (bool bHasCell = aIter.first(); bHasCell; bHasCell = aIter.next())
3641 : {
3642 420 : if (aIter.getType() == CELLTYPE_FORMULA)
3643 : {
3644 180 : ScFormulaCell* pFCell = aIter.getFormulaCell();
3645 180 : bool bAdd = false;
3646 180 : if (pFCell->GetErrCode())
3647 : {
3648 0 : if ( nResultFlags & sheet::FormulaResult::ERROR )
3649 0 : bAdd = true;
3650 : }
3651 180 : else if (pFCell->IsValue())
3652 : {
3653 180 : if ( nResultFlags & sheet::FormulaResult::VALUE )
3654 180 : bAdd = true;
3655 : }
3656 : else // String
3657 : {
3658 0 : if ( nResultFlags & sheet::FormulaResult::STRING )
3659 0 : bAdd = true;
3660 : }
3661 :
3662 180 : if (bAdd)
3663 180 : aMarkData.SetMultiMarkArea(aIter.GetPos(), true);
3664 : }
3665 : }
3666 52 : }
3667 :
3668 98 : ScRangeList aNewRanges;
3669 49 : if (aMarkData.IsMultiMarked())
3670 10 : aMarkData.FillRangeListWithMarks( &aNewRanges, false );
3671 :
3672 98 : return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein
3673 : }
3674 :
3675 0 : return NULL;
3676 : }
3677 :
3678 8 : uno::Reference<sheet::XSheetCellRanges> ScCellRangesBase::QueryDifferences_Impl(
3679 : const table::CellAddress& aCompare, bool bColumnDiff)
3680 : {
3681 8 : if (pDocShell)
3682 : {
3683 8 : size_t nRangeCount = aRanges.size();
3684 : size_t i;
3685 8 : ScDocument& rDoc = pDocShell->GetDocument();
3686 8 : ScMarkData aMarkData;
3687 :
3688 8 : SCCOLROW nCmpPos = bColumnDiff ? (SCCOLROW)aCompare.Row : (SCCOLROW)aCompare.Column;
3689 :
3690 : // zuerst alles selektieren, wo ueberhaupt etwas in der Vergleichsspalte steht
3691 : // (fuer gleiche Zellen wird die Selektion im zweiten Schritt aufgehoben)
3692 :
3693 8 : SCTAB nTab = lcl_FirstTab(aRanges); //! fuer alle Tabellen, wenn Markierungen pro Tabelle!
3694 8 : ScRange aCmpRange, aCellRange;
3695 8 : if (bColumnDiff)
3696 4 : aCmpRange = ScRange( 0,nCmpPos,nTab, MAXCOL,nCmpPos,nTab );
3697 : else
3698 4 : aCmpRange = ScRange( static_cast<SCCOL>(nCmpPos),0,nTab, static_cast<SCCOL>(nCmpPos),MAXROW,nTab );
3699 16 : ScCellIterator aCmpIter( &rDoc, aCmpRange );
3700 41 : for (bool bHasCell = aCmpIter.first(); bHasCell; bHasCell = aCmpIter.next())
3701 : {
3702 33 : SCCOLROW nCellPos = bColumnDiff ? static_cast<SCCOLROW>(aCmpIter.GetPos().Col()) : static_cast<SCCOLROW>(aCmpIter.GetPos().Row());
3703 33 : if (bColumnDiff)
3704 32 : aCellRange = ScRange( static_cast<SCCOL>(nCellPos),0,nTab,
3705 16 : static_cast<SCCOL>(nCellPos),MAXROW,nTab );
3706 : else
3707 17 : aCellRange = ScRange( 0,nCellPos,nTab, MAXCOL,nCellPos,nTab );
3708 :
3709 126 : for (i=0; i<nRangeCount; i++)
3710 : {
3711 93 : ScRange aRange( *aRanges[ i ] );
3712 93 : if ( aRange.Intersects( aCellRange ) )
3713 : {
3714 29 : if (bColumnDiff)
3715 : {
3716 12 : aRange.aStart.SetCol(static_cast<SCCOL>(nCellPos));
3717 12 : aRange.aEnd.SetCol(static_cast<SCCOL>(nCellPos));
3718 : }
3719 : else
3720 : {
3721 17 : aRange.aStart.SetRow(nCellPos);
3722 17 : aRange.aEnd.SetRow(nCellPos);
3723 : }
3724 29 : aMarkData.SetMultiMarkArea( aRange );
3725 : }
3726 : }
3727 : }
3728 :
3729 : // alle nichtleeren Zellen mit der Vergleichsspalte vergleichen und entsprechend
3730 : // selektieren oder aufheben
3731 :
3732 8 : ScAddress aCmpAddr;
3733 22 : for (i=0; i<nRangeCount; i++)
3734 : {
3735 14 : ScRange aRange( *aRanges[ i ] );
3736 :
3737 14 : ScCellIterator aIter( &rDoc, aRange );
3738 72 : for (bool bHasCell = aIter.first(); bHasCell; bHasCell = aIter.next())
3739 : {
3740 58 : if (bColumnDiff)
3741 29 : aCmpAddr = ScAddress( aIter.GetPos().Col(), nCmpPos, aIter.GetPos().Tab() );
3742 : else
3743 29 : aCmpAddr = ScAddress( static_cast<SCCOL>(nCmpPos), aIter.GetPos().Row(), aIter.GetPos().Tab() );
3744 :
3745 58 : ScRange aOneRange(aIter.GetPos());
3746 58 : if (!aIter.equalsWithoutFormat(aCmpAddr))
3747 13 : aMarkData.SetMultiMarkArea( aOneRange );
3748 : else
3749 45 : aMarkData.SetMultiMarkArea( aOneRange, false ); // deselect
3750 : }
3751 14 : }
3752 :
3753 16 : ScRangeList aNewRanges;
3754 8 : if (aMarkData.IsMultiMarked())
3755 8 : aMarkData.FillRangeListWithMarks( &aNewRanges, false );
3756 :
3757 16 : return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein
3758 : }
3759 0 : return NULL;
3760 : }
3761 :
3762 4 : uno::Reference<sheet::XSheetCellRanges > SAL_CALL ScCellRangesBase::queryColumnDifferences(
3763 : const table::CellAddress& aCompare ) throw(uno::RuntimeException, std::exception)
3764 : {
3765 4 : SolarMutexGuard aGuard;
3766 4 : return QueryDifferences_Impl( aCompare, true );
3767 : }
3768 :
3769 4 : uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryRowDifferences(
3770 : const table::CellAddress& aCompare ) throw(uno::RuntimeException, std::exception)
3771 : {
3772 4 : SolarMutexGuard aGuard;
3773 4 : return QueryDifferences_Impl( aCompare, false );
3774 : }
3775 :
3776 25 : uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryIntersection(
3777 : const table::CellRangeAddress& aRange ) throw(uno::RuntimeException, std::exception)
3778 : {
3779 25 : SolarMutexGuard aGuard;
3780 : ScRange aMask( (SCCOL)aRange.StartColumn, (SCROW)aRange.StartRow, aRange.Sheet,
3781 25 : (SCCOL)aRange.EndColumn, (SCROW)aRange.EndRow, aRange.Sheet );
3782 :
3783 50 : ScRangeList aNew;
3784 53 : for ( size_t i = 0, nCount = aRanges.size(); i < nCount; ++i )
3785 : {
3786 28 : ScRange aTemp( *aRanges[ i ] );
3787 28 : if ( aTemp.Intersects( aMask ) )
3788 52 : aNew.Join( ScRange( std::max( aTemp.aStart.Col(), aMask.aStart.Col() ),
3789 52 : std::max( aTemp.aStart.Row(), aMask.aStart.Row() ),
3790 52 : std::max( aTemp.aStart.Tab(), aMask.aStart.Tab() ),
3791 52 : std::min( aTemp.aEnd.Col(), aMask.aEnd.Col() ),
3792 52 : std::min( aTemp.aEnd.Row(), aMask.aEnd.Row() ),
3793 182 : std::min( aTemp.aEnd.Tab(), aMask.aEnd.Tab() ) ) );
3794 : }
3795 :
3796 50 : return new ScCellRangesObj( pDocShell, aNew ); // kann leer sein
3797 : }
3798 :
3799 : // XFormulaQuery
3800 :
3801 3 : uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryPrecedents(
3802 : sal_Bool bRecursive ) throw(uno::RuntimeException, std::exception)
3803 : {
3804 3 : SolarMutexGuard aGuard;
3805 3 : if ( pDocShell )
3806 : {
3807 3 : ScDocument& rDoc = pDocShell->GetDocument();
3808 :
3809 3 : ScRangeList aNewRanges(aRanges);
3810 : bool bFound;
3811 3 : do
3812 : {
3813 3 : bFound = false;
3814 :
3815 : // aMarkData uses aNewRanges, not aRanges, so GetMarkData can't be used
3816 3 : ScMarkData aMarkData;
3817 3 : aMarkData.MarkFromRangeList( aNewRanges, false );
3818 3 : aMarkData.MarkToMulti(); // needed for IsAllMarked
3819 :
3820 9 : for (size_t nR = 0, nCount = aNewRanges.size(); nR<nCount; ++nR)
3821 : {
3822 6 : ScRange aRange( *aNewRanges[ nR] );
3823 6 : ScCellIterator aIter( &rDoc, aRange );
3824 36 : for (bool bHasCell = aIter.first(); bHasCell; bHasCell = aIter.next())
3825 : {
3826 30 : if (aIter.getType() != CELLTYPE_FORMULA)
3827 28 : continue;
3828 :
3829 2 : ScDetectiveRefIter aRefIter(aIter.getFormulaCell());
3830 2 : ScRange aRefRange;
3831 6 : while ( aRefIter.GetNextRef( aRefRange) )
3832 : {
3833 2 : if ( bRecursive && !bFound && !aMarkData.IsAllMarked( aRefRange ) )
3834 0 : bFound = true;
3835 2 : aMarkData.SetMultiMarkArea(aRefRange, true);
3836 : }
3837 : }
3838 6 : }
3839 :
3840 3 : aMarkData.FillRangeListWithMarks( &aNewRanges, true );
3841 : }
3842 0 : while ( bRecursive && bFound );
3843 :
3844 3 : return new ScCellRangesObj( pDocShell, aNewRanges );
3845 : }
3846 :
3847 0 : return NULL;
3848 : }
3849 :
3850 3 : uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryDependents(
3851 : sal_Bool bRecursive ) throw(uno::RuntimeException, std::exception)
3852 : {
3853 3 : SolarMutexGuard aGuard;
3854 3 : if ( pDocShell )
3855 : {
3856 3 : ScDocument& rDoc = pDocShell->GetDocument();
3857 :
3858 3 : ScRangeList aNewRanges(aRanges);
3859 : bool bFound;
3860 3 : do
3861 : {
3862 3 : bFound = false;
3863 :
3864 : // aMarkData uses aNewRanges, not aRanges, so GetMarkData can't be used
3865 3 : ScMarkData aMarkData;
3866 3 : aMarkData.MarkFromRangeList( aNewRanges, false );
3867 3 : aMarkData.MarkToMulti(); // needed for IsAllMarked
3868 :
3869 3 : SCTAB nTab = lcl_FirstTab(aNewRanges); //! alle Tabellen
3870 :
3871 6 : ScCellIterator aCellIter( &rDoc, ScRange(0, 0, nTab, MAXCOL, MAXROW, nTab) );
3872 114 : for (bool bHasCell = aCellIter.first(); bHasCell; bHasCell = aCellIter.next())
3873 : {
3874 111 : if (aCellIter.getType() != CELLTYPE_FORMULA)
3875 108 : continue;
3876 :
3877 3 : bool bMark = false;
3878 3 : ScDetectiveRefIter aIter(aCellIter.getFormulaCell());
3879 3 : ScRange aRefRange;
3880 9 : while ( aIter.GetNextRef( aRefRange) )
3881 : {
3882 3 : size_t nRangesCount = aNewRanges.size();
3883 9 : for (size_t nR = 0; nR < nRangesCount; ++nR)
3884 : {
3885 6 : ScRange aRange( *aNewRanges[ nR ] );
3886 6 : if (aRange.Intersects(aRefRange))
3887 2 : bMark = true; // von Teil des Ranges abhaengig
3888 : }
3889 : }
3890 3 : if (bMark)
3891 : {
3892 2 : ScRange aCellRange(aCellIter.GetPos());
3893 2 : if ( bRecursive && !bFound && !aMarkData.IsAllMarked( aCellRange ) )
3894 0 : bFound = true;
3895 2 : aMarkData.SetMultiMarkArea(aCellRange, true);
3896 : }
3897 : }
3898 :
3899 6 : aMarkData.FillRangeListWithMarks( &aNewRanges, true );
3900 : }
3901 0 : while ( bRecursive && bFound );
3902 :
3903 3 : return new ScCellRangesObj( pDocShell, aNewRanges );
3904 : }
3905 :
3906 0 : return NULL;
3907 : }
3908 :
3909 : // XSearchable
3910 :
3911 16 : uno::Reference<util::XSearchDescriptor> SAL_CALL ScCellRangesBase::createSearchDescriptor()
3912 : throw(uno::RuntimeException, std::exception)
3913 : {
3914 16 : SolarMutexGuard aGuard;
3915 16 : return new ScCellSearchObj;
3916 : }
3917 :
3918 22 : uno::Reference<container::XIndexAccess> SAL_CALL ScCellRangesBase::findAll(
3919 : const uno::Reference<util::XSearchDescriptor>& xDesc )
3920 : throw(uno::RuntimeException,
3921 : std::exception)
3922 : {
3923 22 : SolarMutexGuard aGuard;
3924 : // Wenn nichts gefunden wird, soll Null zurueckgegeben werden (?)
3925 22 : uno::Reference<container::XIndexAccess> xRet;
3926 22 : if ( pDocShell && xDesc.is() )
3927 : {
3928 22 : ScCellSearchObj* pSearch = ScCellSearchObj::getImplementation( xDesc );
3929 22 : if (pSearch)
3930 : {
3931 22 : SvxSearchItem* pSearchItem = pSearch->GetSearchItem();
3932 22 : if (pSearchItem)
3933 : {
3934 22 : ScDocument& rDoc = pDocShell->GetDocument();
3935 22 : pSearchItem->SetCommand( SvxSearchCmd::FIND_ALL );
3936 : // immer nur innerhalb dieses Objekts
3937 22 : pSearchItem->SetSelection( !lcl_WholeSheet(aRanges) );
3938 :
3939 22 : ScMarkData aMark(*GetMarkData());
3940 :
3941 44 : OUString aDummyUndo;
3942 44 : ScRangeList aMatchedRanges;
3943 22 : SCCOL nCol = 0;
3944 22 : SCROW nRow = 0;
3945 22 : SCTAB nTab = 0;
3946 : bool bFound = rDoc.SearchAndReplace(
3947 22 : *pSearchItem, nCol, nRow, nTab, aMark, aMatchedRanges, aDummyUndo, NULL);
3948 22 : if (bFound)
3949 : {
3950 : // bei findAll immer CellRanges, egal wieviel gefunden wurde
3951 18 : xRet.set(new ScCellRangesObj( pDocShell, aMatchedRanges ));
3952 22 : }
3953 : }
3954 : }
3955 : }
3956 22 : return xRet;
3957 : }
3958 :
3959 31 : uno::Reference<uno::XInterface> ScCellRangesBase::Find_Impl(
3960 : const uno::Reference<util::XSearchDescriptor>& xDesc,
3961 : const ScAddress* pLastPos )
3962 : {
3963 31 : uno::Reference<uno::XInterface> xRet;
3964 31 : if ( pDocShell && xDesc.is() )
3965 : {
3966 31 : ScCellSearchObj* pSearch = ScCellSearchObj::getImplementation( xDesc );
3967 31 : if (pSearch)
3968 : {
3969 31 : SvxSearchItem* pSearchItem = pSearch->GetSearchItem();
3970 31 : if (pSearchItem)
3971 : {
3972 31 : ScDocument& rDoc = pDocShell->GetDocument();
3973 31 : pSearchItem->SetCommand( SvxSearchCmd::FIND );
3974 : // immer nur innerhalb dieses Objekts
3975 31 : pSearchItem->SetSelection( !lcl_WholeSheet(aRanges) );
3976 :
3977 31 : ScMarkData aMark(*GetMarkData());
3978 :
3979 : SCCOL nCol;
3980 : SCROW nRow;
3981 : SCTAB nTab;
3982 31 : if (pLastPos)
3983 6 : pLastPos->GetVars( nCol, nRow, nTab );
3984 : else
3985 : {
3986 25 : nTab = lcl_FirstTab(aRanges); //! mehrere Tabellen?
3987 25 : ScDocument::GetSearchAndReplaceStart( *pSearchItem, nCol, nRow );
3988 : }
3989 :
3990 62 : OUString aDummyUndo;
3991 62 : ScRangeList aMatchedRanges;
3992 : bool bFound = rDoc.SearchAndReplace(
3993 31 : *pSearchItem, nCol, nRow, nTab, aMark, aMatchedRanges, aDummyUndo, NULL);
3994 31 : if (bFound)
3995 : {
3996 19 : ScAddress aFoundPos( nCol, nRow, nTab );
3997 19 : xRet.set(static_cast<cppu::OWeakObject*>(new ScCellObj( pDocShell, aFoundPos )));
3998 31 : }
3999 : }
4000 : }
4001 : }
4002 31 : return xRet;
4003 : }
4004 :
4005 25 : uno::Reference<uno::XInterface> SAL_CALL ScCellRangesBase::findFirst(
4006 : const uno::Reference<util::XSearchDescriptor>& xDesc )
4007 : throw(uno::RuntimeException, std::exception)
4008 : {
4009 25 : SolarMutexGuard aGuard;
4010 25 : return Find_Impl( xDesc, NULL );
4011 : }
4012 :
4013 6 : uno::Reference<uno::XInterface> SAL_CALL ScCellRangesBase::findNext(
4014 : const uno::Reference<uno::XInterface>& xStartAt,
4015 : const uno::Reference<util::XSearchDescriptor >& xDesc )
4016 : throw(uno::RuntimeException, std::exception)
4017 : {
4018 6 : SolarMutexGuard aGuard;
4019 6 : if ( xStartAt.is() )
4020 : {
4021 6 : ScCellRangesBase* pRangesImp = ScCellRangesBase::getImplementation( xStartAt );
4022 6 : if ( pRangesImp && pRangesImp->GetDocShell() == pDocShell )
4023 : {
4024 6 : const ScRangeList& rStartRanges = pRangesImp->GetRangeList();
4025 6 : if ( rStartRanges.size() == 1 )
4026 : {
4027 6 : ScAddress aStartPos = rStartRanges[ 0 ]->aStart;
4028 6 : return Find_Impl( xDesc, &aStartPos );
4029 : }
4030 : }
4031 : }
4032 0 : return NULL;
4033 : }
4034 :
4035 : // XReplaceable
4036 :
4037 24 : uno::Reference<util::XReplaceDescriptor> SAL_CALL ScCellRangesBase::createReplaceDescriptor()
4038 : throw(uno::RuntimeException, std::exception)
4039 : {
4040 24 : SolarMutexGuard aGuard;
4041 24 : return new ScCellSearchObj;
4042 : }
4043 :
4044 26 : sal_Int32 SAL_CALL ScCellRangesBase::replaceAll( const uno::Reference<util::XSearchDescriptor>& xDesc )
4045 : throw(uno::RuntimeException,
4046 : std::exception)
4047 : {
4048 26 : SolarMutexGuard aGuard;
4049 26 : sal_Int32 nReplaced = 0;
4050 26 : if ( pDocShell && xDesc.is() )
4051 : {
4052 26 : ScCellSearchObj* pSearch = ScCellSearchObj::getImplementation( xDesc );
4053 26 : if (pSearch)
4054 : {
4055 26 : SvxSearchItem* pSearchItem = pSearch->GetSearchItem();
4056 26 : if (pSearchItem)
4057 : {
4058 26 : ScDocument& rDoc = pDocShell->GetDocument();
4059 26 : bool bUndo(rDoc.IsUndoEnabled());
4060 26 : pSearchItem->SetCommand( SvxSearchCmd::REPLACE_ALL );
4061 : // immer nur innerhalb dieses Objekts
4062 26 : pSearchItem->SetSelection( !lcl_WholeSheet(aRanges) );
4063 :
4064 26 : ScMarkData aMark(*GetMarkData());
4065 :
4066 26 : SCTAB nTabCount = rDoc.GetTableCount();
4067 26 : bool bProtected = !pDocShell->IsEditable();
4068 26 : ScMarkData::iterator itr = aMark.begin(), itrEnd = aMark.end();
4069 52 : for (; itr != itrEnd && *itr < nTabCount; ++itr)
4070 26 : if ( rDoc.IsTabProtected(*itr) )
4071 0 : bProtected = true;
4072 26 : if (bProtected)
4073 : {
4074 : //! Exception, oder was?
4075 : }
4076 : else
4077 : {
4078 26 : SCTAB nTab = aMark.GetFirstSelected(); // bei SearchAndReplace nicht benutzt
4079 26 : SCCOL nCol = 0;
4080 26 : SCROW nRow = 0;
4081 :
4082 26 : OUString aUndoStr;
4083 26 : ScDocument* pUndoDoc = NULL;
4084 26 : if (bUndo)
4085 : {
4086 26 : pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
4087 26 : pUndoDoc->InitUndo( &rDoc, nTab, nTab );
4088 : }
4089 26 : itr = aMark.begin();
4090 52 : for (; itr != itrEnd && *itr < nTabCount; ++itr)
4091 26 : if ( *itr != nTab && bUndo)
4092 0 : pUndoDoc->AddUndoTab( *itr, *itr );
4093 52 : boost::scoped_ptr<ScMarkData> pUndoMark;
4094 26 : if (bUndo)
4095 26 : pUndoMark.reset(new ScMarkData(aMark));
4096 :
4097 26 : bool bFound = false;
4098 26 : if (bUndo)
4099 : {
4100 26 : ScRangeList aMatchedRanges;
4101 : bFound = rDoc.SearchAndReplace(
4102 26 : *pSearchItem, nCol, nRow, nTab, aMark, aMatchedRanges, aUndoStr, pUndoDoc );
4103 : }
4104 26 : if (bFound)
4105 : {
4106 22 : nReplaced = pUndoDoc->GetCellCount();
4107 :
4108 22 : pDocShell->GetUndoManager()->AddUndoAction(
4109 : new ScUndoReplace( pDocShell, *pUndoMark, nCol, nRow, nTab,
4110 22 : aUndoStr, pUndoDoc, pSearchItem ) );
4111 :
4112 22 : pDocShell->PostPaintGridAll();
4113 22 : pDocShell->SetDocumentModified();
4114 : }
4115 : else
4116 : {
4117 4 : delete pUndoDoc;
4118 : // nReplaced bleibt 0
4119 26 : }
4120 26 : }
4121 : }
4122 : }
4123 : }
4124 26 : return nReplaced;
4125 : }
4126 :
4127 : // XUnoTunnel
4128 :
4129 17272 : sal_Int64 SAL_CALL ScCellRangesBase::getSomething(
4130 : const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
4131 : {
4132 34544 : if ( rId.getLength() == 16 &&
4133 17272 : 0 == memcmp( getUnoTunnelId().getConstArray(),
4134 34544 : rId.getConstArray(), 16 ) )
4135 : {
4136 15896 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
4137 : }
4138 1376 : return 0;
4139 : }
4140 :
4141 : namespace
4142 : {
4143 : class theScCellRangesBaseUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScCellRangesBaseUnoTunnelId> {};
4144 : }
4145 :
4146 33170 : const uno::Sequence<sal_Int8>& ScCellRangesBase::getUnoTunnelId()
4147 : {
4148 33170 : return theScCellRangesBaseUnoTunnelId::get().getSeq();
4149 : }
4150 :
4151 15914 : ScCellRangesBase* ScCellRangesBase::getImplementation(const uno::Reference<uno::XInterface>& rObj)
4152 : {
4153 15914 : ScCellRangesBase* pRet = NULL;
4154 15914 : uno::Reference<lang::XUnoTunnel> xUT(rObj, uno::UNO_QUERY);
4155 15914 : if (xUT.is())
4156 15898 : pRet = reinterpret_cast<ScCellRangesBase*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
4157 15914 : return pRet;
4158 : }
4159 :
4160 : typedef boost::ptr_vector<ScNamedEntry> ScNamedEntryArr_Impl;
4161 :
4162 4083 : struct ScCellRangesObj::Impl
4163 : {
4164 : ScNamedEntryArr_Impl m_aNamedEntries;
4165 : };
4166 :
4167 2042 : ScCellRangesObj::ScCellRangesObj(ScDocShell* pDocSh, const ScRangeList& rR)
4168 : : ScCellRangesBase(pDocSh, rR)
4169 2042 : , m_pImpl(new Impl)
4170 : {
4171 2042 : }
4172 :
4173 4082 : ScCellRangesObj::~ScCellRangesObj()
4174 : {
4175 4082 : }
4176 :
4177 4155 : void ScCellRangesObj::RefChanged()
4178 : {
4179 4155 : ScCellRangesBase::RefChanged();
4180 :
4181 : // nix weiter...
4182 4155 : }
4183 :
4184 13224 : uno::Any SAL_CALL ScCellRangesObj::queryInterface( const uno::Type& rType )
4185 : throw(uno::RuntimeException, std::exception)
4186 : {
4187 13224 : SC_QUERYINTERFACE( sheet::XSheetCellRangeContainer )
4188 11505 : SC_QUERYINTERFACE( sheet::XSheetCellRanges )
4189 11338 : SC_QUERYINTERFACE( container::XIndexAccess )
4190 11238 : SC_QUERY_MULTIPLE( container::XElementAccess, container::XIndexAccess )
4191 11238 : SC_QUERYINTERFACE( container::XEnumerationAccess )
4192 11186 : SC_QUERYINTERFACE( container::XNameContainer )
4193 11178 : SC_QUERYINTERFACE( container::XNameReplace )
4194 11178 : SC_QUERYINTERFACE( container::XNameAccess )
4195 :
4196 11098 : return ScCellRangesBase::queryInterface( rType );
4197 : }
4198 :
4199 40502 : void SAL_CALL ScCellRangesObj::acquire() throw()
4200 : {
4201 40502 : ScCellRangesBase::acquire();
4202 40502 : }
4203 :
4204 40501 : void SAL_CALL ScCellRangesObj::release() throw()
4205 : {
4206 40501 : ScCellRangesBase::release();
4207 40501 : }
4208 :
4209 0 : uno::Sequence<uno::Type> SAL_CALL ScCellRangesObj::getTypes() throw(uno::RuntimeException, std::exception)
4210 : {
4211 0 : static uno::Sequence<uno::Type> aTypes;
4212 0 : if ( aTypes.getLength() == 0 )
4213 : {
4214 0 : uno::Sequence<uno::Type> aParentTypes(ScCellRangesBase::getTypes());
4215 0 : long nParentLen = aParentTypes.getLength();
4216 0 : const uno::Type* pParentPtr = aParentTypes.getConstArray();
4217 :
4218 0 : aTypes.realloc( nParentLen + 3 );
4219 0 : uno::Type* pPtr = aTypes.getArray();
4220 0 : pPtr[nParentLen + 0] = cppu::UnoType<sheet::XSheetCellRangeContainer>::get();
4221 0 : pPtr[nParentLen + 1] = cppu::UnoType<container::XNameContainer>::get();
4222 0 : pPtr[nParentLen + 2] = cppu::UnoType<container::XEnumerationAccess>::get();
4223 :
4224 0 : for (long i=0; i<nParentLen; i++)
4225 0 : pPtr[i] = pParentPtr[i]; // parent types first
4226 : }
4227 0 : return aTypes;
4228 : }
4229 :
4230 0 : uno::Sequence<sal_Int8> SAL_CALL ScCellRangesObj::getImplementationId()
4231 : throw(uno::RuntimeException, std::exception)
4232 : {
4233 0 : return css::uno::Sequence<sal_Int8>();
4234 : }
4235 :
4236 : // XCellRanges
4237 :
4238 479 : ScCellRangeObj* ScCellRangesObj::GetObjectByIndex_Impl(sal_Int32 nIndex) const
4239 : {
4240 479 : ScDocShell* pDocSh = GetDocShell();
4241 479 : const ScRangeList& rRanges = GetRangeList();
4242 479 : if ( pDocSh && nIndex >= 0 && nIndex < sal::static_int_cast<sal_Int32>(rRanges.size()) )
4243 : {
4244 477 : ScRange aRange( *rRanges[ nIndex ] );
4245 477 : if ( aRange.aStart == aRange.aEnd )
4246 10 : return new ScCellObj( pDocSh, aRange.aStart );
4247 : else
4248 467 : return new ScCellRangeObj( pDocSh, aRange );
4249 : }
4250 :
4251 2 : return NULL; // keine DocShell oder falscher Index
4252 : }
4253 :
4254 1196 : uno::Sequence<table::CellRangeAddress> SAL_CALL ScCellRangesObj::getRangeAddresses()
4255 : throw(uno::RuntimeException, std::exception)
4256 : {
4257 1196 : SolarMutexGuard aGuard;
4258 1196 : ScDocShell* pDocSh = GetDocShell();
4259 1196 : const ScRangeList& rRanges = GetRangeList();
4260 1196 : size_t nCount = rRanges.size();
4261 1196 : if ( pDocSh && nCount )
4262 : {
4263 1193 : table::CellRangeAddress aRangeAddress;
4264 1193 : uno::Sequence<table::CellRangeAddress> aSeq(nCount);
4265 1193 : table::CellRangeAddress* pAry = aSeq.getArray();
4266 3109 : for ( size_t i=0; i < nCount; i++)
4267 : {
4268 1916 : ScUnoConversion::FillApiRange( aRangeAddress, *rRanges[ i ] );
4269 1916 : pAry[i] = aRangeAddress;
4270 : }
4271 1193 : return aSeq;
4272 : }
4273 :
4274 3 : return uno::Sequence<table::CellRangeAddress>(0); // leer ist moeglich
4275 : }
4276 :
4277 27 : uno::Reference<container::XEnumerationAccess> SAL_CALL ScCellRangesObj::getCells()
4278 : throw(uno::RuntimeException, std::exception)
4279 : {
4280 27 : SolarMutexGuard aGuard;
4281 :
4282 : // getCells with empty range list is possible (no exception),
4283 : // the resulting enumeration just has no elements
4284 : // (same behaviour as a valid range with no cells)
4285 : // This is handled in ScCellsEnumeration ctor.
4286 :
4287 27 : const ScRangeList& rRanges = GetRangeList();
4288 27 : ScDocShell* pDocSh = GetDocShell();
4289 27 : if (pDocSh)
4290 27 : return new ScCellsObj( pDocSh, rRanges );
4291 0 : return NULL;
4292 : }
4293 :
4294 33 : OUString SAL_CALL ScCellRangesObj::getRangeAddressesAsString()
4295 : throw(uno::RuntimeException, std::exception)
4296 : {
4297 33 : SolarMutexGuard aGuard;
4298 33 : OUString aString;
4299 33 : ScDocShell* pDocSh = GetDocShell();
4300 33 : const ScRangeList& rRanges = GetRangeList();
4301 33 : if (pDocSh)
4302 33 : rRanges.Format( aString, SCA_VALID | SCA_TAB_3D, &pDocSh->GetDocument() );
4303 33 : return aString;
4304 : }
4305 :
4306 : // XSheetCellRangeContainer
4307 :
4308 4098 : void SAL_CALL ScCellRangesObj::addRangeAddress( const table::CellRangeAddress& rRange,
4309 : sal_Bool bMergeRanges )
4310 : throw(::com::sun::star::uno::RuntimeException, std::exception)
4311 : {
4312 4098 : SolarMutexGuard aGuard;
4313 : ScRange aRange(static_cast<SCCOL>(rRange.StartColumn),
4314 : static_cast<SCROW>(rRange.StartRow),
4315 : static_cast<SCTAB>(rRange.Sheet),
4316 : static_cast<SCCOL>(rRange.EndColumn),
4317 : static_cast<SCROW>(rRange.EndRow),
4318 4098 : static_cast<SCTAB>(rRange.Sheet));
4319 4098 : AddRange(aRange, bMergeRanges);
4320 4098 : }
4321 :
4322 8 : static void lcl_RemoveNamedEntry( ScNamedEntryArr_Impl& rNamedEntries, const ScRange& rRange )
4323 : {
4324 8 : sal_uInt16 nCount = rNamedEntries.size();
4325 26 : for ( sal_uInt16 n=nCount; n--; )
4326 10 : if ( rNamedEntries[n].GetRange() == rRange )
4327 4 : rNamedEntries.erase( rNamedEntries.begin() + n );
4328 8 : }
4329 :
4330 8 : void SAL_CALL ScCellRangesObj::removeRangeAddress( const table::CellRangeAddress& rRange )
4331 : throw(::com::sun::star::container::NoSuchElementException,
4332 : ::com::sun::star::uno::RuntimeException, std::exception)
4333 : {
4334 8 : SolarMutexGuard aGuard;
4335 8 : const ScRangeList& rRanges = GetRangeList();
4336 :
4337 16 : ScRangeList aSheetRanges;
4338 16 : ScRangeList aNotSheetRanges;
4339 25 : for (size_t i = 0; i < rRanges.size(); ++i)
4340 : {
4341 17 : if (rRanges[ i]->aStart.Tab() == rRange.Sheet)
4342 : {
4343 14 : aSheetRanges.Append( *rRanges[ i ] );
4344 : }
4345 : else
4346 : {
4347 3 : aNotSheetRanges.Append( *rRanges[ i ] );
4348 : }
4349 : }
4350 16 : ScMarkData aMarkData;
4351 8 : aMarkData.MarkFromRangeList( aSheetRanges, false );
4352 : ScRange aRange(static_cast<SCCOL>(rRange.StartColumn),
4353 : static_cast<SCROW>(rRange.StartRow),
4354 : static_cast<SCTAB>(rRange.Sheet),
4355 : static_cast<SCCOL>(rRange.EndColumn),
4356 : static_cast<SCROW>(rRange.EndRow),
4357 8 : static_cast<SCTAB>(rRange.Sheet));
4358 8 : if (aMarkData.GetTableSelect( aRange.aStart.Tab() ))
4359 : {
4360 8 : aMarkData.MarkToMulti();
4361 8 : if (aMarkData.IsAllMarked( aRange ) )
4362 : {
4363 8 : aMarkData.SetMultiMarkArea( aRange, false );
4364 8 : lcl_RemoveNamedEntry(m_pImpl->m_aNamedEntries, aRange);
4365 : }
4366 : else
4367 0 : throw container::NoSuchElementException();
4368 : }
4369 8 : SetNewRanges(aNotSheetRanges);
4370 16 : ScRangeList aNew;
4371 8 : aMarkData.FillRangeListWithMarks( &aNew, false );
4372 14 : for ( size_t j = 0; j < aNew.size(); ++j)
4373 : {
4374 6 : AddRange(*aNew[ j ], false);
4375 8 : }
4376 8 : }
4377 :
4378 1 : void SAL_CALL ScCellRangesObj::addRangeAddresses( const uno::Sequence<table::CellRangeAddress >& rRanges,
4379 : sal_Bool bMergeRanges )
4380 : throw(::com::sun::star::uno::RuntimeException, std::exception)
4381 : {
4382 1 : SolarMutexGuard aGuard;
4383 1 : sal_Int32 nCount(rRanges.getLength());
4384 1 : if (nCount)
4385 : {
4386 1 : const table::CellRangeAddress* pRanges = rRanges.getConstArray();
4387 4 : for (sal_Int32 i = 0; i < rRanges.getLength(); i++, pRanges++)
4388 : {
4389 : ScRange aRange(static_cast<SCCOL>(pRanges->StartColumn),
4390 : static_cast<SCROW>(pRanges->StartRow),
4391 : static_cast<SCTAB>(pRanges->Sheet),
4392 : static_cast<SCCOL>(pRanges->EndColumn),
4393 : static_cast<SCROW>(pRanges->EndRow),
4394 3 : static_cast<SCTAB>(pRanges->Sheet));
4395 3 : AddRange(aRange, bMergeRanges);
4396 : }
4397 1 : }
4398 1 : }
4399 :
4400 4 : void SAL_CALL ScCellRangesObj::removeRangeAddresses( const uno::Sequence<table::CellRangeAddress >& rRangeSeq )
4401 : throw(::com::sun::star::container::NoSuchElementException,
4402 : ::com::sun::star::uno::RuntimeException, std::exception)
4403 : {
4404 : // use sometimes a better/faster implementation
4405 4 : sal_uInt32 nCount(rRangeSeq.getLength());
4406 4 : if (nCount)
4407 : {
4408 2 : const table::CellRangeAddress* pRanges = rRangeSeq.getConstArray();
4409 9 : for (sal_uInt32 i=0; i < nCount; ++i, ++pRanges)
4410 : {
4411 7 : removeRangeAddress(*pRanges);
4412 : }
4413 : }
4414 4 : }
4415 :
4416 : // XNameContainer
4417 :
4418 4 : static void lcl_RemoveNamedEntry( ScNamedEntryArr_Impl& rNamedEntries, const OUString& rName )
4419 : {
4420 4 : sal_uInt16 nCount = rNamedEntries.size();
4421 25 : for ( sal_uInt16 n=nCount; n--; )
4422 17 : if ( rNamedEntries[n].GetName() == rName )
4423 3 : rNamedEntries.erase( rNamedEntries.begin() + n );
4424 4 : }
4425 :
4426 37 : void SAL_CALL ScCellRangesObj::insertByName( const OUString& aName, const uno::Any& aElement )
4427 : throw (lang::IllegalArgumentException, container::ElementExistException,
4428 : lang::WrappedTargetException, uno::RuntimeException,
4429 : std::exception)
4430 : {
4431 37 : SolarMutexGuard aGuard;
4432 37 : ScDocShell* pDocSh = GetDocShell();
4433 37 : bool bDone = false;
4434 :
4435 : //! Type of aElement can be some specific interface instead of XInterface
4436 :
4437 74 : uno::Reference<uno::XInterface> xInterface(aElement, uno::UNO_QUERY);
4438 37 : if ( pDocSh && xInterface.is() )
4439 : {
4440 36 : ScCellRangesBase* pRangesImp = ScCellRangesBase::getImplementation( xInterface );
4441 36 : if ( pRangesImp && pRangesImp->GetDocShell() == pDocSh )
4442 : {
4443 : // if explicit name is given and already existing, throw exception
4444 :
4445 36 : OUString aNamStr(aName);
4446 36 : if ( !aNamStr.isEmpty() )
4447 : {
4448 36 : size_t nNamedCount = m_pImpl->m_aNamedEntries.size();
4449 98 : for (size_t n = 0; n < nNamedCount; n++)
4450 : {
4451 63 : if (m_pImpl->m_aNamedEntries[n].GetName() == aNamStr)
4452 1 : throw container::ElementExistException();
4453 : }
4454 : }
4455 :
4456 70 : ScRangeList aNew(GetRangeList());
4457 35 : const ScRangeList& rAddRanges = pRangesImp->GetRangeList();
4458 35 : size_t nAddCount = rAddRanges.size();
4459 70 : for ( size_t i = 0; i < nAddCount; i++ )
4460 35 : aNew.Join( *rAddRanges[ i ] );
4461 35 : SetNewRanges(aNew);
4462 35 : bDone = true;
4463 :
4464 35 : if ( !aName.isEmpty() && nAddCount == 1 )
4465 : {
4466 : // if a name is given, also insert into list of named entries
4467 : // (only possible for a single range)
4468 : // name is not in m_pImpl->m_aNamedEntries (tested above)
4469 :
4470 35 : ScNamedEntry* pEntry = new ScNamedEntry( aNamStr, *rAddRanges[ 0 ] );
4471 35 : m_pImpl->m_aNamedEntries.push_back(pEntry);
4472 36 : }
4473 : }
4474 : }
4475 :
4476 36 : if (!bDone)
4477 : {
4478 : // invalid element - double names are handled above
4479 1 : throw lang::IllegalArgumentException();
4480 37 : }
4481 35 : }
4482 :
4483 13 : static bool lcl_FindRangeByName( const ScRangeList& rRanges, ScDocShell* pDocSh,
4484 : const OUString& rName, size_t& rIndex )
4485 : {
4486 13 : if (pDocSh)
4487 : {
4488 13 : OUString aRangeStr;
4489 13 : ScDocument& rDoc = pDocSh->GetDocument();
4490 67 : for ( size_t i = 0, nCount = rRanges.size(); i < nCount; i++ )
4491 : {
4492 54 : aRangeStr = rRanges[ i ]->Format(SCA_VALID | SCA_TAB_3D, &rDoc);
4493 54 : if ( aRangeStr == rName )
4494 : {
4495 0 : rIndex = i;
4496 0 : return true;
4497 : }
4498 13 : }
4499 : }
4500 13 : return false; // nicht gefunden
4501 : }
4502 :
4503 9 : static bool lcl_FindRangeOrEntry( const ScNamedEntryArr_Impl& rNamedEntries,
4504 : const ScRangeList& rRanges, ScDocShell* pDocSh,
4505 : const OUString& rName, ScRange& rFound )
4506 : {
4507 : // exact range in list?
4508 :
4509 9 : size_t nIndex = 0;
4510 9 : if ( lcl_FindRangeByName( rRanges, pDocSh, rName, nIndex ) )
4511 : {
4512 0 : rFound = *rRanges[ nIndex ];
4513 0 : return true;
4514 : }
4515 :
4516 : // range contained in selection? (sheet must be specified)
4517 :
4518 9 : ScRange aCellRange;
4519 9 : sal_uInt16 nParse = aCellRange.ParseAny( rName, &pDocSh->GetDocument() );
4520 9 : if ( ( nParse & ( SCA_VALID | SCA_TAB_3D ) ) == ( SCA_VALID | SCA_TAB_3D ) )
4521 : {
4522 0 : ScMarkData aMarkData;
4523 0 : aMarkData.MarkFromRangeList( rRanges, false );
4524 0 : aMarkData.MarkToMulti(); // needed for IsAllMarked
4525 0 : if ( aMarkData.IsAllMarked( aCellRange ) )
4526 : {
4527 0 : rFound = aCellRange;
4528 0 : return true;
4529 0 : }
4530 : }
4531 :
4532 : // named entry in this object?
4533 :
4534 9 : if ( !rNamedEntries.empty() )
4535 : {
4536 31 : for ( size_t n=0; n<rNamedEntries.size(); n++ )
4537 28 : if ( rNamedEntries[n].GetName() == rName )
4538 : {
4539 : // test if named entry is contained in rRanges
4540 :
4541 6 : const ScRange& rComp = rNamedEntries[n].GetRange();
4542 6 : ScMarkData aMarkData;
4543 6 : aMarkData.MarkFromRangeList( rRanges, false );
4544 6 : aMarkData.MarkToMulti(); // needed for IsAllMarked
4545 6 : if ( aMarkData.IsAllMarked( rComp ) )
4546 : {
4547 6 : rFound = rComp;
4548 6 : return true;
4549 0 : }
4550 : }
4551 : }
4552 :
4553 3 : return false; // not found
4554 : }
4555 :
4556 4 : void SAL_CALL ScCellRangesObj::removeByName( const OUString& aName )
4557 : throw(container::NoSuchElementException,
4558 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
4559 : {
4560 4 : SolarMutexGuard aGuard;
4561 4 : bool bDone = false;
4562 8 : OUString aNameStr(aName);
4563 4 : ScDocShell* pDocSh = GetDocShell();
4564 4 : const ScRangeList& rRanges = GetRangeList();
4565 4 : size_t nIndex = 0;
4566 4 : if ( lcl_FindRangeByName( rRanges, pDocSh, aNameStr, nIndex ) )
4567 : {
4568 : // einzelnen Range weglassen
4569 0 : ScRangeList aNew;
4570 0 : for ( size_t i = 0, nCount = rRanges.size(); i < nCount; i++ )
4571 0 : if (i != nIndex)
4572 0 : aNew.Append( *rRanges[ i ] );
4573 0 : SetNewRanges(aNew);
4574 0 : bDone = true;
4575 : }
4576 4 : else if (pDocSh)
4577 : {
4578 : // deselect any ranges (parsed or named entry)
4579 4 : ScRangeList aDiff;
4580 4 : bool bValid = ( aDiff.Parse( aNameStr, &pDocSh->GetDocument() ) & SCA_VALID ) != 0;
4581 4 : if (!bValid && !m_pImpl->m_aNamedEntries.empty())
4582 : {
4583 4 : sal_uInt16 nCount = m_pImpl->m_aNamedEntries.size();
4584 18 : for (sal_uInt16 n=0; n<nCount && !bValid; n++)
4585 14 : if (m_pImpl->m_aNamedEntries[n].GetName() == aNameStr)
4586 : {
4587 3 : aDiff.RemoveAll();
4588 3 : aDiff.Append(m_pImpl->m_aNamedEntries[n].GetRange());
4589 3 : bValid = true;
4590 : }
4591 : }
4592 4 : if ( bValid )
4593 : {
4594 3 : ScMarkData aMarkData;
4595 3 : aMarkData.MarkFromRangeList( rRanges, false );
4596 :
4597 6 : for ( size_t i = 0, nDiffCount = aDiff.size(); i < nDiffCount; i++ )
4598 : {
4599 3 : ScRange* pDiffRange = aDiff[ i ];
4600 3 : if (aMarkData.GetTableSelect( pDiffRange->aStart.Tab() ))
4601 3 : aMarkData.SetMultiMarkArea( *pDiffRange, false );
4602 : }
4603 :
4604 6 : ScRangeList aNew;
4605 3 : aMarkData.FillRangeListWithMarks( &aNew, false );
4606 3 : SetNewRanges(aNew);
4607 :
4608 6 : bDone = true; //! error if range was not selected before?
4609 4 : }
4610 : }
4611 :
4612 4 : if (!m_pImpl->m_aNamedEntries.empty())
4613 4 : lcl_RemoveNamedEntry(m_pImpl->m_aNamedEntries, aNameStr);
4614 :
4615 4 : if (!bDone)
4616 5 : throw container::NoSuchElementException(); // not found
4617 3 : }
4618 :
4619 : // XNameReplace
4620 :
4621 2 : void SAL_CALL ScCellRangesObj::replaceByName( const OUString& aName, const uno::Any& aElement )
4622 : throw(lang::IllegalArgumentException, container::NoSuchElementException,
4623 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
4624 : {
4625 2 : SolarMutexGuard aGuard;
4626 : //! zusammenfassen?
4627 2 : removeByName( aName );
4628 2 : insertByName( aName, aElement );
4629 2 : }
4630 :
4631 : // XNameAccess
4632 :
4633 5 : uno::Any SAL_CALL ScCellRangesObj::getByName( const OUString& aName )
4634 : throw(container::NoSuchElementException,
4635 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
4636 : {
4637 5 : SolarMutexGuard aGuard;
4638 5 : uno::Any aRet;
4639 :
4640 10 : OUString aNameStr(aName);
4641 5 : ScDocShell* pDocSh = GetDocShell();
4642 5 : const ScRangeList& rRanges = GetRangeList();
4643 5 : ScRange aRange;
4644 10 : if (lcl_FindRangeOrEntry(m_pImpl->m_aNamedEntries, rRanges,
4645 5 : pDocSh, aNameStr, aRange))
4646 : {
4647 4 : uno::Reference<table::XCellRange> xRange;
4648 4 : if ( aRange.aStart == aRange.aEnd )
4649 0 : xRange.set(new ScCellObj( pDocSh, aRange.aStart ));
4650 : else
4651 4 : xRange.set(new ScCellRangeObj( pDocSh, aRange ));
4652 4 : aRet <<= xRange;
4653 : }
4654 : else
4655 1 : throw container::NoSuchElementException();
4656 9 : return aRet;
4657 : }
4658 :
4659 22 : static bool lcl_FindEntryName( const ScNamedEntryArr_Impl& rNamedEntries,
4660 : const ScRange& rRange, OUString& rName )
4661 : {
4662 22 : sal_uInt16 nCount = rNamedEntries.size();
4663 60 : for (sal_uInt16 i=0; i<nCount; i++)
4664 60 : if (rNamedEntries[i].GetRange() == rRange)
4665 : {
4666 22 : rName = rNamedEntries[i].GetName();
4667 22 : return true;
4668 : }
4669 0 : return false;
4670 : }
4671 :
4672 5 : uno::Sequence<OUString> SAL_CALL ScCellRangesObj::getElementNames()
4673 : throw(uno::RuntimeException, std::exception)
4674 : {
4675 5 : SolarMutexGuard aGuard;
4676 :
4677 5 : ScDocShell* pDocSh = GetDocShell();
4678 5 : const ScRangeList& rRanges = GetRangeList();
4679 5 : if (pDocSh)
4680 : {
4681 5 : OUString aRangeStr;
4682 5 : ScDocument& rDoc = pDocSh->GetDocument();
4683 5 : size_t nCount = rRanges.size();
4684 :
4685 10 : uno::Sequence<OUString> aSeq(nCount);
4686 5 : OUString* pAry = aSeq.getArray();
4687 27 : for (size_t i=0; i < nCount; i++)
4688 : {
4689 : // use given name if for exactly this range, otherwise just format
4690 22 : ScRange aRange = *rRanges[ i ];
4691 44 : if (m_pImpl->m_aNamedEntries.empty() ||
4692 22 : !lcl_FindEntryName(m_pImpl->m_aNamedEntries, aRange, aRangeStr))
4693 : {
4694 0 : aRangeStr = aRange.Format(SCA_VALID | SCA_TAB_3D, &rDoc);
4695 : }
4696 22 : pAry[i] = aRangeStr;
4697 : }
4698 10 : return aSeq;
4699 : }
4700 0 : return uno::Sequence<OUString>(0);
4701 : }
4702 :
4703 4 : sal_Bool SAL_CALL ScCellRangesObj::hasByName( const OUString& aName )
4704 : throw(uno::RuntimeException, std::exception)
4705 : {
4706 4 : SolarMutexGuard aGuard;
4707 8 : OUString aNameStr(aName);
4708 4 : ScDocShell* pDocSh = GetDocShell();
4709 4 : const ScRangeList& rRanges = GetRangeList();
4710 4 : ScRange aRange;
4711 4 : return lcl_FindRangeOrEntry(m_pImpl->m_aNamedEntries, rRanges, pDocSh,
4712 8 : aNameStr, aRange);
4713 : }
4714 :
4715 : // XEnumerationAccess
4716 :
4717 52 : uno::Reference<container::XEnumeration> SAL_CALL ScCellRangesObj::createEnumeration()
4718 : throw(uno::RuntimeException, std::exception)
4719 : {
4720 52 : SolarMutexGuard aGuard;
4721 52 : return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.SheetCellRangesEnumeration"));
4722 : }
4723 :
4724 : // XIndexAccess
4725 :
4726 517 : sal_Int32 SAL_CALL ScCellRangesObj::getCount() throw(uno::RuntimeException, std::exception)
4727 : {
4728 517 : SolarMutexGuard aGuard;
4729 517 : const ScRangeList& rRanges = GetRangeList();
4730 517 : return rRanges.size();
4731 : }
4732 :
4733 479 : uno::Any SAL_CALL ScCellRangesObj::getByIndex( sal_Int32 nIndex )
4734 : throw(lang::IndexOutOfBoundsException,
4735 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
4736 : {
4737 479 : SolarMutexGuard aGuard;
4738 958 : uno::Reference<table::XCellRange> xRange(GetObjectByIndex_Impl(nIndex));
4739 479 : if (xRange.is())
4740 954 : return uno::makeAny(xRange);
4741 : else
4742 481 : throw lang::IndexOutOfBoundsException();
4743 : }
4744 :
4745 1 : uno::Type SAL_CALL ScCellRangesObj::getElementType() throw(uno::RuntimeException, std::exception)
4746 : {
4747 1 : SolarMutexGuard aGuard;
4748 1 : return cppu::UnoType<table::XCellRange>::get();
4749 : }
4750 :
4751 49 : sal_Bool SAL_CALL ScCellRangesObj::hasElements() throw(uno::RuntimeException, std::exception)
4752 : {
4753 49 : SolarMutexGuard aGuard;
4754 49 : const ScRangeList& rRanges = GetRangeList();
4755 49 : return !rRanges.empty();
4756 : }
4757 :
4758 : // XServiceInfo
4759 4 : OUString SAL_CALL ScCellRangesObj::getImplementationName() throw(uno::RuntimeException, std::exception)
4760 : {
4761 4 : return OUString( "ScCellRangesObj" );
4762 : }
4763 :
4764 12 : sal_Bool SAL_CALL ScCellRangesObj::supportsService( const OUString& rServiceName )
4765 : throw(uno::RuntimeException, std::exception)
4766 : {
4767 12 : return cppu::supportsService(this, rServiceName);
4768 : }
4769 :
4770 12 : uno::Sequence<OUString> SAL_CALL ScCellRangesObj::getSupportedServiceNames()
4771 : throw(uno::RuntimeException, std::exception)
4772 : {
4773 12 : uno::Sequence<OUString> aRet(4);
4774 12 : OUString* pArray = aRet.getArray();
4775 12 : pArray[0] = SCSHEETCELLRANGES_SERVICE;
4776 12 : pArray[1] = SCCELLPROPERTIES_SERVICE;
4777 12 : pArray[2] = SCCHARPROPERTIES_SERVICE;
4778 12 : pArray[3] = SCPARAPROPERTIES_SERVICE;
4779 12 : return aRet;
4780 : }
4781 :
4782 0 : uno::Reference<table::XCellRange> ScCellRangeObj::CreateRangeFromDoc( ScDocument* pDoc, const ScRange& rR )
4783 : {
4784 0 : SfxObjectShell* pObjSh = pDoc->GetDocumentShell();
4785 0 : if ( pObjSh && pObjSh->ISA(ScDocShell) )
4786 0 : return new ScCellRangeObj( static_cast<ScDocShell*>(pObjSh), rR );
4787 0 : return NULL;
4788 : }
4789 :
4790 31978 : ScCellRangeObj::ScCellRangeObj(ScDocShell* pDocSh, const ScRange& rR) :
4791 : ScCellRangesBase( pDocSh, rR ),
4792 31978 : pRangePropSet( lcl_GetRangePropertySet() ),
4793 63956 : aRange( rR )
4794 : {
4795 31978 : aRange.Justify(); // Anfang / Ende richtig
4796 31978 : }
4797 :
4798 40887 : ScCellRangeObj::~ScCellRangeObj()
4799 : {
4800 40887 : }
4801 :
4802 2213 : void ScCellRangeObj::RefChanged()
4803 : {
4804 2213 : ScCellRangesBase::RefChanged();
4805 :
4806 2213 : const ScRangeList& rRanges = GetRangeList();
4807 : OSL_ENSURE(rRanges.size() == 1, "was fuer Ranges ?!?!");
4808 2213 : if ( !rRanges.empty() )
4809 : {
4810 2187 : const ScRange* pFirst = rRanges[0];
4811 2187 : aRange = ScRange(*pFirst);
4812 2187 : aRange.Justify();
4813 : }
4814 2213 : }
4815 :
4816 245781 : uno::Any SAL_CALL ScCellRangeObj::queryInterface( const uno::Type& rType )
4817 : throw(uno::RuntimeException, std::exception)
4818 : {
4819 245781 : SC_QUERYINTERFACE( sheet::XCellRangeAddressable )
4820 238990 : SC_QUERYINTERFACE( table::XCellRange )
4821 229415 : SC_QUERYINTERFACE( sheet::XSheetCellRange )
4822 225781 : SC_QUERYINTERFACE( sheet::XArrayFormulaRange )
4823 225779 : SC_QUERYINTERFACE( sheet::XArrayFormulaTokens )
4824 225779 : SC_QUERYINTERFACE( sheet::XCellRangeData )
4825 225755 : SC_QUERYINTERFACE( sheet::XCellRangeFormula )
4826 225753 : SC_QUERYINTERFACE( sheet::XMultipleOperation )
4827 225752 : SC_QUERYINTERFACE( util::XMergeable )
4828 225744 : SC_QUERYINTERFACE( sheet::XCellSeries )
4829 225734 : SC_QUERYINTERFACE( table::XAutoFormattable )
4830 225734 : SC_QUERYINTERFACE( util::XSortable )
4831 225733 : SC_QUERYINTERFACE( sheet::XSheetFilterableEx )
4832 225732 : SC_QUERYINTERFACE( sheet::XSheetFilterable )
4833 225730 : SC_QUERYINTERFACE( sheet::XSubTotalCalculatable )
4834 225724 : SC_QUERYINTERFACE( table::XColumnRowRange )
4835 219656 : SC_QUERYINTERFACE( util::XImportable )
4836 219653 : SC_QUERYINTERFACE( sheet::XCellFormatRangesSupplier )
4837 219650 : SC_QUERYINTERFACE( sheet::XUniqueCellFormatRangesSupplier )
4838 :
4839 219614 : return ScCellRangesBase::queryInterface( rType );
4840 : }
4841 :
4842 783287 : void SAL_CALL ScCellRangeObj::acquire() throw()
4843 : {
4844 783287 : ScCellRangesBase::acquire();
4845 783287 : }
4846 :
4847 783176 : void SAL_CALL ScCellRangeObj::release() throw()
4848 : {
4849 783176 : ScCellRangesBase::release();
4850 783176 : }
4851 :
4852 5 : uno::Sequence<uno::Type> SAL_CALL ScCellRangeObj::getTypes() throw(uno::RuntimeException, std::exception)
4853 : {
4854 5 : static uno::Sequence<uno::Type> aTypes;
4855 5 : if ( aTypes.getLength() == 0 )
4856 : {
4857 2 : uno::Sequence<uno::Type> aParentTypes(ScCellRangesBase::getTypes());
4858 2 : long nParentLen = aParentTypes.getLength();
4859 2 : const uno::Type* pParentPtr = aParentTypes.getConstArray();
4860 :
4861 2 : aTypes.realloc( nParentLen + 17 );
4862 2 : uno::Type* pPtr = aTypes.getArray();
4863 2 : pPtr[nParentLen + 0] = cppu::UnoType<sheet::XCellRangeAddressable>::get();
4864 2 : pPtr[nParentLen + 1] = cppu::UnoType<sheet::XSheetCellRange>::get();
4865 2 : pPtr[nParentLen + 2] = cppu::UnoType<sheet::XArrayFormulaRange>::get();
4866 2 : pPtr[nParentLen + 3] = cppu::UnoType<sheet::XArrayFormulaTokens>::get();
4867 2 : pPtr[nParentLen + 4] = cppu::UnoType<sheet::XCellRangeData>::get();
4868 2 : pPtr[nParentLen + 5] = cppu::UnoType<sheet::XCellRangeFormula>::get();
4869 2 : pPtr[nParentLen + 6] = cppu::UnoType<sheet::XMultipleOperation>::get();
4870 2 : pPtr[nParentLen + 7] = cppu::UnoType<util::XMergeable>::get();
4871 2 : pPtr[nParentLen + 8] = cppu::UnoType<sheet::XCellSeries>::get();
4872 2 : pPtr[nParentLen + 9] = cppu::UnoType<table::XAutoFormattable>::get();
4873 2 : pPtr[nParentLen +10] = cppu::UnoType<util::XSortable>::get();
4874 2 : pPtr[nParentLen +11] = cppu::UnoType<sheet::XSheetFilterableEx>::get();
4875 2 : pPtr[nParentLen +12] = cppu::UnoType<sheet::XSubTotalCalculatable>::get();
4876 2 : pPtr[nParentLen +13] = cppu::UnoType<table::XColumnRowRange>::get();
4877 2 : pPtr[nParentLen +14] = cppu::UnoType<util::XImportable>::get();
4878 2 : pPtr[nParentLen +15] = cppu::UnoType<sheet::XCellFormatRangesSupplier>::get();
4879 2 : pPtr[nParentLen +16] = cppu::UnoType<sheet::XUniqueCellFormatRangesSupplier>::get();
4880 :
4881 28 : for (long i=0; i<nParentLen; i++)
4882 28 : pPtr[i] = pParentPtr[i]; // parent types first
4883 : }
4884 5 : return aTypes;
4885 : }
4886 :
4887 0 : uno::Sequence<sal_Int8> SAL_CALL ScCellRangeObj::getImplementationId()
4888 : throw(uno::RuntimeException, std::exception)
4889 : {
4890 0 : return css::uno::Sequence<sal_Int8>();
4891 : }
4892 :
4893 : // XCellRange
4894 :
4895 : // ColumnCount / RowCount sind weggefallen
4896 : //! werden im Writer fuer Tabellen noch gebraucht ???
4897 :
4898 15142 : uno::Reference<table::XCell> ScCellRangeObj::GetCellByPosition_Impl(
4899 : sal_Int32 nColumn, sal_Int32 nRow )
4900 : throw(lang::IndexOutOfBoundsException, uno::RuntimeException)
4901 : {
4902 15142 : ScDocShell* pDocSh = GetDocShell();
4903 15142 : if (!pDocSh)
4904 0 : throw uno::RuntimeException();
4905 :
4906 15142 : if ( nColumn >= 0 && nRow >= 0 )
4907 : {
4908 15141 : sal_Int32 nPosX = aRange.aStart.Col() + nColumn;
4909 15141 : sal_Int32 nPosY = aRange.aStart.Row() + nRow;
4910 :
4911 15141 : if ( nPosX <= aRange.aEnd.Col() && nPosY <= aRange.aEnd.Row() )
4912 : {
4913 15141 : ScAddress aNew( (SCCOL)nPosX, (SCROW)nPosY, aRange.aStart.Tab() );
4914 30282 : return new ScCellObj( pDocSh, aNew );
4915 : }
4916 : }
4917 :
4918 1 : throw lang::IndexOutOfBoundsException();
4919 : }
4920 :
4921 8544 : uno::Reference<table::XCell> SAL_CALL ScCellRangeObj::getCellByPosition(
4922 : sal_Int32 nColumn, sal_Int32 nRow )
4923 : throw(lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
4924 : {
4925 8544 : SolarMutexGuard aGuard;
4926 :
4927 8544 : return GetCellByPosition_Impl(nColumn, nRow);
4928 : }
4929 :
4930 7429 : uno::Reference<table::XCellRange> SAL_CALL ScCellRangeObj::getCellRangeByPosition(
4931 : sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom )
4932 : throw(lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
4933 : {
4934 7429 : SolarMutexGuard aGuard;
4935 :
4936 7429 : ScDocShell* pDocSh = GetDocShell();
4937 7429 : if (!pDocSh)
4938 0 : throw uno::RuntimeException();
4939 :
4940 7429 : if ( nLeft >= 0 && nTop >= 0 && nRight >= 0 && nBottom >= 0 )
4941 : {
4942 7428 : sal_Int32 nStartX = aRange.aStart.Col() + nLeft;
4943 7428 : sal_Int32 nStartY = aRange.aStart.Row() + nTop;
4944 7428 : sal_Int32 nEndX = aRange.aStart.Col() + nRight;
4945 7428 : sal_Int32 nEndY = aRange.aStart.Row() + nBottom;
4946 :
4947 14856 : if ( nStartX <= nEndX && nEndX <= aRange.aEnd.Col() &&
4948 14856 : nStartY <= nEndY && nEndY <= aRange.aEnd.Row() )
4949 : {
4950 7428 : ScRange aNew( (SCCOL)nStartX, (SCROW)nStartY, aRange.aStart.Tab(),
4951 14856 : (SCCOL)nEndX, (SCROW)nEndY, aRange.aEnd.Tab() );
4952 14856 : return new ScCellRangeObj( pDocSh, aNew );
4953 : }
4954 : }
4955 :
4956 7428 : throw lang::IndexOutOfBoundsException();
4957 : }
4958 :
4959 94 : uno::Reference<table::XCellRange> SAL_CALL ScCellRangeObj::getCellRangeByName(
4960 : const OUString& aName ) throw(uno::RuntimeException, std::exception)
4961 : {
4962 94 : return getCellRangeByName( aName, ScAddress::detailsOOOa1 );
4963 : }
4964 :
4965 94 : uno::Reference<table::XCellRange> ScCellRangeObj::getCellRangeByName(
4966 : const OUString& aName, const ScAddress::Details& rDetails ) throw(uno::RuntimeException)
4967 : {
4968 : // name refers to the whole document (with the range's table as default),
4969 : // valid only if the range is within this range
4970 :
4971 94 : SolarMutexGuard aGuard;
4972 94 : ScDocShell* pDocSh = GetDocShell();
4973 94 : if ( pDocSh )
4974 : {
4975 94 : ScDocument& rDoc = pDocSh->GetDocument();
4976 94 : SCTAB nTab = aRange.aStart.Tab();
4977 :
4978 94 : ScRange aCellRange;
4979 94 : bool bFound = false;
4980 94 : OUString aString(aName);
4981 94 : sal_uInt16 nParse = aCellRange.ParseAny( aString, &rDoc, rDetails );
4982 94 : if ( nParse & SCA_VALID )
4983 : {
4984 94 : if ( !(nParse & SCA_TAB_3D) ) // keine Tabelle angegeben -> auf dieser Tabelle
4985 : {
4986 61 : aCellRange.aStart.SetTab(nTab);
4987 61 : aCellRange.aEnd.SetTab(nTab);
4988 : }
4989 94 : bFound = true;
4990 : }
4991 : else
4992 : {
4993 0 : ScRangeUtil aRangeUtil;
4994 0 : if ( ScRangeUtil::MakeRangeFromName( aString, &rDoc, nTab, aCellRange, RUTL_NAMES ) ||
4995 0 : ScRangeUtil::MakeRangeFromName( aString, &rDoc, nTab, aCellRange, RUTL_DBASE ) )
4996 0 : bFound = true;
4997 : }
4998 :
4999 94 : if (bFound) // valid only if within this object's range
5000 : {
5001 94 : if (!aRange.In(aCellRange))
5002 0 : bFound = false;
5003 : }
5004 :
5005 94 : if (bFound)
5006 : {
5007 94 : if ( aCellRange.aStart == aCellRange.aEnd )
5008 4 : return new ScCellObj( pDocSh, aCellRange.aStart );
5009 : else
5010 90 : return new ScCellRangeObj( pDocSh, aCellRange );
5011 0 : }
5012 : }
5013 :
5014 94 : throw uno::RuntimeException();
5015 : }
5016 :
5017 : // XColumnRowRange
5018 :
5019 1508 : uno::Reference<table::XTableColumns> SAL_CALL ScCellRangeObj::getColumns() throw(uno::RuntimeException, std::exception)
5020 : {
5021 1508 : SolarMutexGuard aGuard;
5022 1508 : ScDocShell* pDocSh = GetDocShell();
5023 1508 : if (pDocSh)
5024 1508 : return new ScTableColumnsObj( pDocSh, aRange.aStart.Tab(),
5025 1508 : aRange.aStart.Col(), aRange.aEnd.Col() );
5026 :
5027 : OSL_FAIL("Dokument ungueltig");
5028 0 : return NULL;
5029 : }
5030 :
5031 4101 : uno::Reference<table::XTableRows> SAL_CALL ScCellRangeObj::getRows() throw(uno::RuntimeException, std::exception)
5032 : {
5033 4101 : SolarMutexGuard aGuard;
5034 4101 : ScDocShell* pDocSh = GetDocShell();
5035 4101 : if (pDocSh)
5036 4101 : return new ScTableRowsObj( pDocSh, aRange.aStart.Tab(),
5037 4101 : aRange.aStart.Row(), aRange.aEnd.Row() );
5038 :
5039 : OSL_FAIL("Dokument ungueltig");
5040 0 : return NULL;
5041 : }
5042 :
5043 : // XAddressableCellRange
5044 :
5045 7695 : table::CellRangeAddress SAL_CALL ScCellRangeObj::getRangeAddress() throw(uno::RuntimeException, std::exception)
5046 : {
5047 7695 : SolarMutexGuard aGuard;
5048 7695 : table::CellRangeAddress aRet;
5049 7695 : ScUnoConversion::FillApiRange( aRet, aRange );
5050 7695 : return aRet;
5051 : }
5052 :
5053 : // XSheetCellRange
5054 :
5055 1432 : uno::Reference<sheet::XSpreadsheet> SAL_CALL ScCellRangeObj::getSpreadsheet()
5056 : throw(uno::RuntimeException, std::exception)
5057 : {
5058 1432 : SolarMutexGuard aGuard;
5059 1432 : ScDocShell* pDocSh = GetDocShell();
5060 1432 : if (pDocSh)
5061 1432 : return new ScTableSheetObj( pDocSh, aRange.aStart.Tab() );
5062 :
5063 : OSL_FAIL("Dokument ungueltig");
5064 0 : return NULL;
5065 : }
5066 :
5067 : // XArrayFormulaRange
5068 :
5069 2 : OUString SAL_CALL ScCellRangeObj::getArrayFormula() throw(uno::RuntimeException, std::exception)
5070 : {
5071 2 : SolarMutexGuard aGuard;
5072 :
5073 : // Matrix-Formel, wenn eindeutig Teil einer Matrix,
5074 : // also wenn Anfang und Ende des Blocks zur selben Matrix gehoeren.
5075 : // Sonst Leerstring.
5076 :
5077 2 : ScDocShell* pDocSh = GetDocShell();
5078 2 : if (!pDocSh)
5079 0 : return EMPTY_OUSTRING;
5080 :
5081 4 : OUString aFormula;
5082 :
5083 2 : ScDocument& rDoc = pDocSh->GetDocument();
5084 4 : ScRefCellValue aCell1;
5085 4 : ScRefCellValue aCell2;
5086 2 : aCell1.assign(rDoc, aRange.aStart);
5087 2 : aCell2.assign(rDoc, aRange.aEnd);
5088 2 : if (aCell1.meType == CELLTYPE_FORMULA && aCell2.meType == CELLTYPE_FORMULA)
5089 : {
5090 1 : const ScFormulaCell* pFCell1 = aCell1.mpFormula;
5091 1 : const ScFormulaCell* pFCell2 = aCell2.mpFormula;
5092 1 : ScAddress aStart1;
5093 1 : ScAddress aStart2;
5094 1 : if (pFCell1->GetMatrixOrigin(aStart1) && pFCell2->GetMatrixOrigin(aStart2))
5095 : {
5096 1 : if (aStart1 == aStart2) // beides dieselbe Matrix
5097 1 : pFCell1->GetFormula(aFormula); // egal, von welcher Zelle
5098 : }
5099 : }
5100 4 : return aFormula;
5101 : }
5102 :
5103 1 : void ScCellRangeObj::SetArrayFormula_Impl(const OUString& rFormula,
5104 : const OUString& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar)
5105 : throw (uno::RuntimeException, std::exception)
5106 : {
5107 1 : ScDocShell* pDocSh = GetDocShell();
5108 1 : if (pDocSh)
5109 : {
5110 1 : if ( !rFormula.isEmpty() )
5111 : {
5112 1 : if ( ScTableSheetObj::getImplementation( static_cast<cppu::OWeakObject*>(this) ) )
5113 : {
5114 : // don't set array formula for sheet object
5115 0 : throw uno::RuntimeException();
5116 : }
5117 :
5118 1 : pDocSh->GetDocFunc().EnterMatrix( aRange, NULL, NULL, rFormula, true, true, rFormulaNmsp, eGrammar );
5119 : }
5120 : else
5121 : {
5122 : // empty string -> erase array formula
5123 0 : ScMarkData aMark;
5124 0 : aMark.SetMarkArea( aRange );
5125 0 : aMark.SelectTable( aRange.aStart.Tab(), true );
5126 0 : pDocSh->GetDocFunc().DeleteContents( aMark, IDF_CONTENTS, true, true );
5127 : }
5128 : }
5129 1 : }
5130 :
5131 1 : void SAL_CALL ScCellRangeObj::setArrayFormula( const OUString& aFormula )
5132 : throw(uno::RuntimeException, std::exception)
5133 : {
5134 1 : SolarMutexGuard aGuard;
5135 : // GRAM_PODF_A1 for API compatibility.
5136 1 : SetArrayFormula_Impl( aFormula, OUString(), formula::FormulaGrammar::GRAM_PODF_A1);
5137 1 : }
5138 :
5139 : // XArrayFormulaTokens
5140 0 : uno::Sequence<sheet::FormulaToken> SAL_CALL ScCellRangeObj::getArrayTokens()
5141 : throw (uno::RuntimeException, std::exception)
5142 : {
5143 0 : SolarMutexGuard aGuard;
5144 :
5145 : // same cell logic as in getArrayFormula
5146 :
5147 0 : uno::Sequence<sheet::FormulaToken> aSequence;
5148 0 : ScDocShell* pDocSh = GetDocShell();
5149 0 : if (!pDocSh)
5150 0 : return aSequence;
5151 :
5152 0 : ScDocument& rDoc = pDocSh->GetDocument();
5153 0 : ScRefCellValue aCell1;
5154 0 : ScRefCellValue aCell2;
5155 0 : aCell1.assign(rDoc, aRange.aStart);
5156 0 : aCell2.assign(rDoc, aRange.aEnd);
5157 0 : if (aCell1.meType == CELLTYPE_FORMULA && aCell2.meType == CELLTYPE_FORMULA)
5158 : {
5159 0 : const ScFormulaCell* pFCell1 = aCell1.mpFormula;
5160 0 : const ScFormulaCell* pFCell2 = aCell2.mpFormula;
5161 0 : ScAddress aStart1;
5162 0 : ScAddress aStart2;
5163 0 : if (pFCell1->GetMatrixOrigin(aStart1) && pFCell2->GetMatrixOrigin(aStart2))
5164 : {
5165 0 : if (aStart1 == aStart2)
5166 : {
5167 0 : const ScTokenArray* pTokenArray = pFCell1->GetCode();
5168 0 : if (pTokenArray)
5169 0 : (void)ScTokenConversion::ConvertToTokenSequence(rDoc, aSequence, *pTokenArray);
5170 : }
5171 : }
5172 : }
5173 :
5174 0 : return aSequence;
5175 : }
5176 :
5177 0 : void SAL_CALL ScCellRangeObj::setArrayTokens( const uno::Sequence<sheet::FormulaToken>& rTokens ) throw(uno::RuntimeException, std::exception)
5178 : {
5179 0 : SolarMutexGuard aGuard;
5180 0 : ScDocShell* pDocSh = GetDocShell();
5181 0 : if ( pDocSh )
5182 : {
5183 0 : if ( rTokens.getLength() )
5184 : {
5185 0 : if ( ScTableSheetObj::getImplementation( static_cast<cppu::OWeakObject*>(this) ) )
5186 : {
5187 0 : throw uno::RuntimeException();
5188 : }
5189 :
5190 0 : ScDocument& rDoc = pDocSh->GetDocument();
5191 0 : ScTokenArray aTokenArray;
5192 0 : (void)ScTokenConversion::ConvertToTokenArray( rDoc, aTokenArray, rTokens );
5193 :
5194 : // Actually GRAM_PODF_A1 is a don't-care here because of the token
5195 : // array being set, it fits with other API compatibility grammars
5196 : // though.
5197 0 : pDocSh->GetDocFunc().EnterMatrix( aRange, NULL, &aTokenArray, EMPTY_OUSTRING, true, true, EMPTY_OUSTRING, formula::FormulaGrammar::GRAM_PODF_A1 );
5198 : }
5199 : else
5200 : {
5201 : // empty sequence -> erase array formula
5202 0 : ScMarkData aMark;
5203 0 : aMark.SetMarkArea( aRange );
5204 0 : aMark.SelectTable( aRange.aStart.Tab(), true );
5205 0 : pDocSh->GetDocFunc().DeleteContents( aMark, IDF_CONTENTS, true, true );
5206 : }
5207 0 : }
5208 0 : }
5209 :
5210 : // XCellRangeData
5211 :
5212 17 : uno::Sequence< uno::Sequence<uno::Any> > SAL_CALL ScCellRangeObj::getDataArray()
5213 : throw(uno::RuntimeException, std::exception)
5214 : {
5215 17 : SolarMutexGuard aGuard;
5216 :
5217 17 : if ( ScTableSheetObj::getImplementation( static_cast<cppu::OWeakObject*>(this) ) )
5218 : {
5219 : // don't create a data array for the sheet
5220 0 : throw uno::RuntimeException();
5221 : }
5222 :
5223 17 : ScDocShell* pDocSh = GetDocShell();
5224 17 : if (pDocSh)
5225 : {
5226 17 : uno::Any aAny;
5227 : // bAllowNV = TRUE: errors as void
5228 17 : if ( ScRangeToSequence::FillMixedArray( aAny, &pDocSh->GetDocument(), aRange, true ) )
5229 : {
5230 17 : uno::Sequence< uno::Sequence<uno::Any> > aSeq;
5231 17 : if ( aAny >>= aSeq )
5232 34 : return aSeq; // success
5233 0 : }
5234 : }
5235 :
5236 17 : throw uno::RuntimeException(); // no other exceptions specified
5237 : }
5238 :
5239 8 : void SAL_CALL ScCellRangeObj::setDataArray(
5240 : const uno::Sequence< uno::Sequence<uno::Any> >& aArray )
5241 : throw(uno::RuntimeException, std::exception)
5242 : {
5243 8 : SolarMutexGuard aGuard;
5244 :
5245 8 : bool bDone = false;
5246 8 : ScDocShell* pDocSh = GetDocShell();
5247 8 : if (pDocSh)
5248 : {
5249 : //! move lcl_PutDataArray to docfunc?
5250 8 : bDone = lcl_PutDataArray( *pDocSh, aRange, aArray );
5251 : }
5252 :
5253 8 : if (!bDone)
5254 0 : throw uno::RuntimeException(); // no other exceptions specified
5255 8 : }
5256 :
5257 : // XCellRangeFormula
5258 :
5259 5 : uno::Sequence< uno::Sequence<OUString> > SAL_CALL ScCellRangeObj::getFormulaArray()
5260 : throw(uno::RuntimeException, std::exception)
5261 : {
5262 5 : SolarMutexGuard aGuard;
5263 :
5264 5 : if ( ScTableSheetObj::getImplementation( static_cast<cppu::OWeakObject*>(this) ) )
5265 : {
5266 : // don't create a data array for the sheet
5267 0 : throw uno::RuntimeException();
5268 : }
5269 :
5270 5 : ScDocShell* pDocSh = GetDocShell();
5271 5 : if (pDocSh)
5272 : {
5273 5 : SCCOL nStartCol = aRange.aStart.Col();
5274 5 : SCROW nStartRow = aRange.aStart.Row();
5275 5 : SCCOL nEndCol = aRange.aEnd.Col();
5276 5 : SCROW nEndRow = aRange.aEnd.Row();
5277 5 : SCCOL nColCount = nEndCol + 1 - nStartCol;
5278 5 : SCROW nRowCount = nEndRow + 1 - nStartRow;
5279 5 : SCTAB nTab = aRange.aStart.Tab();
5280 :
5281 5 : uno::Sequence< uno::Sequence<OUString> > aRowSeq( nRowCount );
5282 5 : uno::Sequence<OUString>* pRowAry = aRowSeq.getArray();
5283 30 : for (SCROW nRowIndex = 0; nRowIndex < nRowCount; nRowIndex++)
5284 : {
5285 25 : uno::Sequence<OUString> aColSeq( nColCount );
5286 25 : OUString* pColAry = aColSeq.getArray();
5287 120 : for (SCCOL nColIndex = 0; nColIndex < nColCount; nColIndex++)
5288 190 : pColAry[nColIndex] = lcl_GetInputString( pDocSh->GetDocument(),
5289 95 : ScAddress( nStartCol+nColIndex, nStartRow+nRowIndex, nTab ), true );
5290 :
5291 25 : pRowAry[nRowIndex] = aColSeq;
5292 25 : }
5293 :
5294 10 : return aRowSeq;
5295 : }
5296 :
5297 5 : throw uno::RuntimeException(); // no other exceptions specified
5298 : }
5299 :
5300 2 : void SAL_CALL ScCellRangeObj::setFormulaArray(
5301 : const uno::Sequence< uno::Sequence<OUString> >& aArray )
5302 : throw(uno::RuntimeException, std::exception)
5303 : {
5304 2 : SolarMutexGuard aGuard;
5305 :
5306 2 : bool bDone = false;
5307 2 : ScDocShell* pDocSh = GetDocShell();
5308 2 : if (pDocSh)
5309 : {
5310 2 : ScExternalRefManager::ApiGuard aExtRefGuard(&pDocSh->GetDocument());
5311 :
5312 : // GRAM_PODF_A1 for API compatibility.
5313 2 : bDone = lcl_PutFormulaArray( *pDocSh, aRange, aArray, formula::FormulaGrammar::GRAM_PODF_A1 );
5314 : }
5315 :
5316 2 : if (!bDone)
5317 0 : throw uno::RuntimeException(); // no other exceptions specified
5318 2 : }
5319 :
5320 : // XMultipleOperation
5321 :
5322 3 : void SAL_CALL ScCellRangeObj::setTableOperation( const table::CellRangeAddress& aFormulaRange,
5323 : sheet::TableOperationMode nMode,
5324 : const table::CellAddress& aColumnCell,
5325 : const table::CellAddress& aRowCell )
5326 : throw(uno::RuntimeException, std::exception)
5327 : {
5328 3 : SolarMutexGuard aGuard;
5329 3 : ScDocShell* pDocSh = GetDocShell();
5330 3 : if (pDocSh)
5331 : {
5332 3 : bool bError = false;
5333 3 : ScTabOpParam aParam;
5334 6 : aParam.aRefFormulaCell = ScRefAddress( (SCCOL)aFormulaRange.StartColumn,
5335 : (SCROW)aFormulaRange.StartRow, aFormulaRange.Sheet,
5336 3 : false, false, false );
5337 6 : aParam.aRefFormulaEnd = ScRefAddress( (SCCOL)aFormulaRange.EndColumn,
5338 : (SCROW)aFormulaRange.EndRow, aFormulaRange.Sheet,
5339 3 : false, false, false );
5340 6 : aParam.aRefRowCell = ScRefAddress( (SCCOL)aRowCell.Column,
5341 : (SCROW)aRowCell.Row, aRowCell.Sheet,
5342 3 : false, false, false );
5343 6 : aParam.aRefColCell = ScRefAddress( (SCCOL)aColumnCell.Column,
5344 : (SCROW)aColumnCell.Row, aColumnCell.Sheet,
5345 3 : false, false, false );
5346 :
5347 3 : switch (nMode)
5348 : {
5349 : case sheet::TableOperationMode_COLUMN:
5350 1 : aParam.meMode = ScTabOpParam::Column;
5351 1 : break;
5352 : case sheet::TableOperationMode_ROW:
5353 1 : aParam.meMode = ScTabOpParam::Row;
5354 1 : break;
5355 : case sheet::TableOperationMode_BOTH:
5356 1 : aParam.meMode = ScTabOpParam::Both;
5357 1 : break;
5358 : default:
5359 0 : bError = true;
5360 : }
5361 :
5362 3 : if (!bError)
5363 3 : pDocSh->GetDocFunc().TabOp( aRange, NULL, aParam, true, true );
5364 3 : }
5365 3 : }
5366 :
5367 : // XMergeable
5368 :
5369 10 : void SAL_CALL ScCellRangeObj::merge( sal_Bool bMerge ) throw(uno::RuntimeException, std::exception)
5370 : {
5371 10 : SolarMutexGuard aGuard;
5372 10 : ScDocShell* pDocSh = GetDocShell();
5373 10 : if ( pDocSh )
5374 : {
5375 : ScCellMergeOption aMergeOption(
5376 10 : aRange.aStart.Col(), aRange.aStart.Row(),
5377 20 : aRange.aEnd.Col(), aRange.aEnd.Row(), false);
5378 10 : aMergeOption.maTabs.insert(aRange.aStart.Tab());
5379 10 : if ( bMerge )
5380 5 : pDocSh->GetDocFunc().MergeCells( aMergeOption, false, true, true );
5381 : else
5382 5 : pDocSh->GetDocFunc().UnmergeCells( aMergeOption, true );
5383 :
5384 : //! Fehler abfangen?
5385 10 : }
5386 10 : }
5387 :
5388 4 : sal_Bool SAL_CALL ScCellRangeObj::getIsMerged() throw(uno::RuntimeException, std::exception)
5389 : {
5390 4 : SolarMutexGuard aGuard;
5391 4 : ScDocShell* pDocSh = GetDocShell();
5392 4 : return pDocSh && pDocSh->GetDocument().HasAttrib( aRange, HASATTR_MERGED );
5393 : }
5394 :
5395 : // XCellSeries
5396 :
5397 13 : void SAL_CALL ScCellRangeObj::fillSeries( sheet::FillDirection nFillDirection,
5398 : sheet::FillMode nFillMode, sheet::FillDateMode nFillDateMode,
5399 : double fStep, double fEndValue ) throw(uno::RuntimeException, std::exception)
5400 : {
5401 13 : SolarMutexGuard aGuard;
5402 13 : ScDocShell* pDocSh = GetDocShell();
5403 13 : if ( pDocSh )
5404 : {
5405 13 : bool bError = false;
5406 :
5407 13 : FillDir eDir = FILL_TO_BOTTOM;
5408 13 : switch (nFillDirection)
5409 : {
5410 : case sheet::FillDirection_TO_BOTTOM:
5411 4 : eDir = FILL_TO_BOTTOM;
5412 4 : break;
5413 : case sheet::FillDirection_TO_RIGHT:
5414 5 : eDir = FILL_TO_RIGHT;
5415 5 : break;
5416 : case sheet::FillDirection_TO_TOP:
5417 2 : eDir = FILL_TO_TOP;
5418 2 : break;
5419 : case sheet::FillDirection_TO_LEFT:
5420 2 : eDir = FILL_TO_LEFT;
5421 2 : break;
5422 : default:
5423 0 : bError = true;
5424 : }
5425 :
5426 13 : FillCmd eCmd = FILL_SIMPLE;
5427 13 : switch ( nFillMode )
5428 : {
5429 : case sheet::FillMode_SIMPLE:
5430 9 : eCmd = FILL_SIMPLE;
5431 9 : break;
5432 : case sheet::FillMode_LINEAR:
5433 2 : eCmd = FILL_LINEAR;
5434 2 : break;
5435 : case sheet::FillMode_GROWTH:
5436 2 : eCmd = FILL_GROWTH;
5437 2 : break;
5438 : case sheet::FillMode_DATE:
5439 0 : eCmd = FILL_DATE;
5440 0 : break;
5441 : case sheet::FillMode_AUTO:
5442 0 : eCmd = FILL_AUTO;
5443 0 : break;
5444 : default:
5445 0 : bError = true;
5446 : }
5447 :
5448 13 : FillDateCmd eDateCmd = FILL_DAY;
5449 13 : switch ( nFillDateMode )
5450 : {
5451 : case sheet::FillDateMode_FILL_DATE_DAY:
5452 13 : eDateCmd = FILL_DAY;
5453 13 : break;
5454 : case sheet::FillDateMode_FILL_DATE_WEEKDAY:
5455 0 : eDateCmd = FILL_WEEKDAY;
5456 0 : break;
5457 : case sheet::FillDateMode_FILL_DATE_MONTH:
5458 0 : eDateCmd = FILL_MONTH;
5459 0 : break;
5460 : case sheet::FillDateMode_FILL_DATE_YEAR:
5461 0 : eDateCmd = FILL_YEAR;
5462 0 : break;
5463 : default:
5464 0 : bError = true;
5465 : }
5466 :
5467 13 : if (!bError)
5468 13 : pDocSh->GetDocFunc().FillSeries( aRange, NULL, eDir, eCmd, eDateCmd,
5469 26 : MAXDOUBLE, fStep, fEndValue, true, true );
5470 13 : }
5471 13 : }
5472 :
5473 2 : void SAL_CALL ScCellRangeObj::fillAuto( sheet::FillDirection nFillDirection,
5474 : sal_Int32 nSourceCount ) throw(uno::RuntimeException, std::exception)
5475 : {
5476 2 : SolarMutexGuard aGuard;
5477 2 : ScDocShell* pDocSh = GetDocShell();
5478 2 : if ( pDocSh && nSourceCount )
5479 : {
5480 2 : ScRange aSourceRange(aRange);
5481 2 : SCsCOLROW nCount = 0; // "Dest-Count"
5482 2 : FillDir eDir = FILL_TO_BOTTOM;
5483 2 : bool bError = false;
5484 2 : switch (nFillDirection)
5485 : {
5486 : case sheet::FillDirection_TO_BOTTOM:
5487 1 : aSourceRange.aEnd.SetRow( static_cast<SCROW>( aSourceRange.aStart.Row() + nSourceCount - 1 ) );
5488 1 : nCount = aRange.aEnd.Row() - aSourceRange.aEnd.Row();
5489 1 : eDir = FILL_TO_BOTTOM;
5490 1 : break;
5491 : case sheet::FillDirection_TO_RIGHT:
5492 1 : aSourceRange.aEnd.SetCol( static_cast<SCCOL>( aSourceRange.aStart.Col() + nSourceCount - 1 ) );
5493 1 : nCount = aRange.aEnd.Col() - aSourceRange.aEnd.Col();
5494 1 : eDir = FILL_TO_RIGHT;
5495 1 : break;
5496 : case sheet::FillDirection_TO_TOP:
5497 0 : aSourceRange.aStart.SetRow( static_cast<SCROW>( aSourceRange.aEnd.Row() - nSourceCount + 1 ) );
5498 0 : nCount = aSourceRange.aStart.Row() - aRange.aStart.Row();
5499 0 : eDir = FILL_TO_TOP;
5500 0 : break;
5501 : case sheet::FillDirection_TO_LEFT:
5502 0 : aSourceRange.aStart.SetCol( static_cast<SCCOL>( aSourceRange.aEnd.Col() - nSourceCount + 1 ) );
5503 0 : nCount = aSourceRange.aStart.Col() - aRange.aStart.Col();
5504 0 : eDir = FILL_TO_LEFT;
5505 0 : break;
5506 : default:
5507 0 : bError = true;
5508 : }
5509 2 : if (nCount < 0 || nCount > MAXROW) // overflow
5510 0 : bError = true;
5511 :
5512 2 : if (!bError)
5513 2 : pDocSh->GetDocFunc().FillAuto( aSourceRange, NULL, eDir, nCount, true, true );
5514 2 : }
5515 2 : }
5516 :
5517 : // XAutoFormattable
5518 :
5519 0 : void SAL_CALL ScCellRangeObj::autoFormat( const OUString& aName )
5520 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
5521 : {
5522 0 : SolarMutexGuard aGuard;
5523 0 : ScDocShell* pDocSh = GetDocShell();
5524 0 : if ( pDocSh )
5525 : {
5526 0 : ScAutoFormat* pAutoFormat = ScGlobal::GetOrCreateAutoFormat();
5527 0 : ScAutoFormat::const_iterator it = pAutoFormat->find(aName);
5528 0 : if (it != pAutoFormat->end())
5529 : {
5530 0 : ScAutoFormat::const_iterator itBeg = pAutoFormat->begin();
5531 0 : size_t nIndex = std::distance(itBeg, it);
5532 0 : pDocSh->GetDocFunc().AutoFormat(aRange, NULL, nIndex, true, true);
5533 : }
5534 : else
5535 0 : throw lang::IllegalArgumentException();
5536 0 : }
5537 0 : }
5538 :
5539 : // XSortable
5540 :
5541 1 : uno::Sequence<beans::PropertyValue> SAL_CALL ScCellRangeObj::createSortDescriptor()
5542 : throw(uno::RuntimeException, std::exception)
5543 : {
5544 1 : SolarMutexGuard aGuard;
5545 2 : ScSortParam aParam;
5546 1 : ScDocShell* pDocSh = GetDocShell();
5547 1 : if ( pDocSh )
5548 : {
5549 : // DB-Bereich anlegen erst beim Ausfuehren, per API immer genau den Bereich
5550 1 : ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, SC_DBSEL_FORCE_MARK );
5551 1 : if (pData)
5552 : {
5553 0 : pData->GetSortParam(aParam);
5554 :
5555 : // im SortDescriptor sind die Fields innerhalb des Bereichs gezaehlt
5556 0 : ScRange aDBRange;
5557 0 : pData->GetArea(aDBRange);
5558 : SCCOLROW nFieldStart = aParam.bByRow ?
5559 0 : static_cast<SCCOLROW>(aDBRange.aStart.Col()) :
5560 0 : static_cast<SCCOLROW>(aDBRange.aStart.Row());
5561 0 : for (sal_uInt16 i=0; i<aParam.GetSortKeyCount(); i++)
5562 0 : if ( aParam.maKeyState[i].bDoSort && aParam.maKeyState[i].nField >= nFieldStart )
5563 0 : aParam.maKeyState[i].nField -= nFieldStart;
5564 : }
5565 : }
5566 :
5567 1 : uno::Sequence<beans::PropertyValue> aSeq( ScSortDescriptor::GetPropertyCount() );
5568 1 : ScSortDescriptor::FillProperties( aSeq, aParam );
5569 2 : return aSeq;
5570 : }
5571 :
5572 4 : void SAL_CALL ScCellRangeObj::sort( const uno::Sequence<beans::PropertyValue>& aDescriptor )
5573 : throw(uno::RuntimeException, std::exception)
5574 : {
5575 4 : SolarMutexGuard aGuard;
5576 4 : ScDocShell* pDocSh = GetDocShell();
5577 4 : if (pDocSh)
5578 : {
5579 : sal_uInt16 i;
5580 4 : ScSortParam aParam;
5581 4 : ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_MAKE, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen
5582 4 : if (pData)
5583 : {
5584 : // alten Einstellungen holen, falls nicht alles neu gesetzt wird
5585 4 : pData->GetSortParam(aParam);
5586 : SCCOLROW nOldStart = aParam.bByRow ?
5587 4 : static_cast<SCCOLROW>(aRange.aStart.Col()) :
5588 8 : static_cast<SCCOLROW>(aRange.aStart.Row());
5589 16 : for (i=0; i<aParam.GetSortKeyCount(); i++)
5590 12 : if ( aParam.maKeyState[i].bDoSort && aParam.maKeyState[i].nField >= nOldStart )
5591 3 : aParam.maKeyState[i].nField -= nOldStart;
5592 : }
5593 :
5594 4 : ScSortDescriptor::FillSortParam( aParam, aDescriptor );
5595 :
5596 : // im SortDescriptor sind die Fields innerhalb des Bereichs gezaehlt
5597 : // ByRow kann bei FillSortParam umgesetzt worden sein
5598 : SCCOLROW nFieldStart = aParam.bByRow ?
5599 4 : static_cast<SCCOLROW>(aRange.aStart.Col()) :
5600 8 : static_cast<SCCOLROW>(aRange.aStart.Row());
5601 16 : for (i=0; i<aParam.GetSortKeyCount(); i++)
5602 12 : aParam.maKeyState[i].nField += nFieldStart;
5603 :
5604 4 : SCTAB nTab = aRange.aStart.Tab();
5605 4 : aParam.nCol1 = aRange.aStart.Col();
5606 4 : aParam.nRow1 = aRange.aStart.Row();
5607 4 : aParam.nCol2 = aRange.aEnd.Col();
5608 4 : aParam.nRow2 = aRange.aEnd.Row();
5609 :
5610 4 : pDocSh->GetDBData( aRange, SC_DB_MAKE, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen
5611 :
5612 8 : ScDBDocFunc aFunc(*pDocSh); // Bereich muss angelegt sein
5613 8 : (void)aFunc.Sort( nTab, aParam, true, true, true );
5614 4 : }
5615 4 : }
5616 :
5617 : // XFilterable
5618 :
5619 2 : uno::Reference<sheet::XSheetFilterDescriptor> SAL_CALL ScCellRangeObj::createFilterDescriptor(
5620 : sal_Bool bEmpty ) throw(uno::RuntimeException, std::exception)
5621 : {
5622 2 : SolarMutexGuard aGuard;
5623 2 : ScDocShell* pDocSh = GetDocShell();
5624 2 : ScFilterDescriptor* pNew = new ScFilterDescriptor(pDocSh);
5625 2 : if ( !bEmpty && pDocSh )
5626 : {
5627 : // DB-Bereich anlegen erst beim Ausfuehren, per API immer genau den Bereich
5628 0 : ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, SC_DBSEL_FORCE_MARK );
5629 0 : if (pData)
5630 : {
5631 0 : ScQueryParam aParam;
5632 0 : pData->GetQueryParam(aParam);
5633 : // im FilterDescriptor sind die Fields innerhalb des Bereichs gezaehlt
5634 0 : ScRange aDBRange;
5635 0 : pData->GetArea(aDBRange);
5636 : SCCOLROW nFieldStart = aParam.bByRow ?
5637 0 : static_cast<SCCOLROW>(aDBRange.aStart.Col()) :
5638 0 : static_cast<SCCOLROW>(aDBRange.aStart.Row());
5639 0 : SCSIZE nCount = aParam.GetEntryCount();
5640 0 : for (SCSIZE i=0; i<nCount; i++)
5641 : {
5642 0 : ScQueryEntry& rEntry = aParam.GetEntry(i);
5643 0 : if (rEntry.bDoQuery && rEntry.nField >= nFieldStart)
5644 0 : rEntry.nField -= nFieldStart;
5645 : }
5646 0 : pNew->SetParam(aParam);
5647 : }
5648 : }
5649 2 : return pNew;
5650 : }
5651 :
5652 1 : void SAL_CALL ScCellRangeObj::filter( const uno::Reference<sheet::XSheetFilterDescriptor>& xDescriptor )
5653 : throw(uno::RuntimeException, std::exception)
5654 : {
5655 1 : SolarMutexGuard aGuard;
5656 :
5657 : // das koennte theoretisch ein fremdes Objekt sein, also nur das
5658 : // oeffentliche XSheetFilterDescriptor Interface benutzen, um
5659 : // die Daten in ein ScFilterDescriptor Objekt zu kopieren:
5660 : //! wenn es schon ein ScFilterDescriptor ist, direkt per getImplementation?
5661 :
5662 1 : ScDocShell* pDocSh = GetDocShell();
5663 2 : ScFilterDescriptor aImpl(pDocSh);
5664 2 : uno::Reference< sheet::XSheetFilterDescriptor2 > xDescriptor2( xDescriptor, uno::UNO_QUERY );
5665 1 : if ( xDescriptor2.is() )
5666 : {
5667 1 : aImpl.setFilterFields2( xDescriptor2->getFilterFields2() );
5668 : }
5669 : else
5670 : {
5671 0 : aImpl.setFilterFields( xDescriptor->getFilterFields() );
5672 : }
5673 : // Rest sind jetzt Properties...
5674 :
5675 2 : uno::Reference<beans::XPropertySet> xPropSet( xDescriptor, uno::UNO_QUERY );
5676 1 : if (xPropSet.is())
5677 1 : lcl_CopyProperties( aImpl, *xPropSet.get() );
5678 :
5679 : // ausfuehren...
5680 :
5681 1 : if (pDocSh)
5682 : {
5683 1 : ScQueryParam aParam = aImpl.GetParam();
5684 : // im FilterDescriptor sind die Fields innerhalb des Bereichs gezaehlt
5685 : SCCOLROW nFieldStart = aParam.bByRow ?
5686 1 : static_cast<SCCOLROW>(aRange.aStart.Col()) :
5687 2 : static_cast<SCCOLROW>(aRange.aStart.Row());
5688 1 : SCSIZE nCount = aParam.GetEntryCount();
5689 1 : svl::SharedStringPool& rPool = pDocSh->GetDocument().GetSharedStringPool();
5690 9 : for (SCSIZE i=0; i<nCount; i++)
5691 : {
5692 8 : ScQueryEntry& rEntry = aParam.GetEntry(i);
5693 8 : if (rEntry.bDoQuery)
5694 : {
5695 2 : rEntry.nField += nFieldStart;
5696 : // Im Dialog wird immer der String angezeigt -> muss zum Wert passen
5697 2 : ScQueryEntry::QueryItemsType& rItems = rEntry.GetQueryItems();
5698 2 : rItems.resize(1);
5699 2 : ScQueryEntry::Item& rItem = rItems.front();
5700 2 : if (rItem.meType != ScQueryEntry::ByString)
5701 : {
5702 1 : OUString aStr;
5703 1 : pDocSh->GetDocument().GetFormatTable()->GetInputLineString(rItem.mfVal, 0, aStr);
5704 1 : rItem.maString = rPool.intern(aStr);
5705 : }
5706 : }
5707 : }
5708 :
5709 1 : SCTAB nTab = aRange.aStart.Tab();
5710 1 : aParam.nCol1 = aRange.aStart.Col();
5711 1 : aParam.nRow1 = aRange.aStart.Row();
5712 1 : aParam.nCol2 = aRange.aEnd.Col();
5713 1 : aParam.nRow2 = aRange.aEnd.Row();
5714 :
5715 1 : pDocSh->GetDBData( aRange, SC_DB_MAKE, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen
5716 :
5717 : //! keep source range in filter descriptor
5718 : //! if created by createFilterDescriptorByObject ???
5719 :
5720 2 : ScDBDocFunc aFunc(*pDocSh);
5721 2 : aFunc.Query( nTab, aParam, NULL, true, true ); // Bereich muss angelegt sein
5722 1 : }
5723 1 : }
5724 :
5725 : //! get/setAutoFilter als Properties!!!
5726 :
5727 : // XAdvancedFilterSource
5728 :
5729 1 : uno::Reference<sheet::XSheetFilterDescriptor> SAL_CALL ScCellRangeObj::createFilterDescriptorByObject(
5730 : const uno::Reference<sheet::XSheetFilterable>& xObject )
5731 : throw(uno::RuntimeException, std::exception)
5732 : {
5733 1 : SolarMutexGuard aGuard;
5734 :
5735 : // this ist hier nicht der Bereich, der gefiltert wird, sondern der
5736 : // Bereich mit der Abfrage...
5737 :
5738 2 : uno::Reference<sheet::XCellRangeAddressable> xAddr( xObject, uno::UNO_QUERY );
5739 :
5740 1 : ScDocShell* pDocSh = GetDocShell();
5741 1 : if ( pDocSh && xAddr.is() )
5742 : {
5743 : //! Test, ob xObject im selben Dokument ist
5744 :
5745 1 : ScFilterDescriptor* pNew = new ScFilterDescriptor(pDocSh); //! stattdessen vom Objekt?
5746 :
5747 1 : ScQueryParam aParam = pNew->GetParam();
5748 1 : aParam.bHasHeader = true;
5749 :
5750 1 : table::CellRangeAddress aDataAddress(xAddr->getRangeAddress());
5751 1 : aParam.nCol1 = (SCCOL)aDataAddress.StartColumn;
5752 1 : aParam.nRow1 = (SCROW)aDataAddress.StartRow;
5753 1 : aParam.nCol2 = (SCCOL)aDataAddress.EndColumn;
5754 1 : aParam.nRow2 = (SCROW)aDataAddress.EndRow;
5755 1 : aParam.nTab = aDataAddress.Sheet;
5756 :
5757 1 : ScDocument& rDoc = pDocSh->GetDocument();
5758 : bool bOk = rDoc.CreateQueryParam(
5759 1 : aRange.aStart.Col(), aRange.aStart.Row(),
5760 1 : aRange.aEnd.Col(), aRange.aEnd.Row(),
5761 3 : aRange.aStart.Tab(), aParam );
5762 1 : if ( bOk )
5763 : {
5764 : // im FilterDescriptor sind die Fields innerhalb des Bereichs gezaehlt
5765 : SCCOLROW nFieldStart = aParam.bByRow ?
5766 : static_cast<SCCOLROW>(aDataAddress.StartColumn) :
5767 1 : static_cast<SCCOLROW>(aDataAddress.StartRow);
5768 1 : SCSIZE nCount = aParam.GetEntryCount();
5769 9 : for (SCSIZE i=0; i<nCount; i++)
5770 : {
5771 8 : ScQueryEntry& rEntry = aParam.GetEntry(i);
5772 8 : if (rEntry.bDoQuery && rEntry.nField >= nFieldStart)
5773 1 : rEntry.nField -= nFieldStart;
5774 : }
5775 :
5776 1 : pNew->SetParam( aParam );
5777 1 : return pNew;
5778 : }
5779 : else
5780 : {
5781 0 : delete pNew;
5782 0 : return NULL; // ungueltig -> null
5783 1 : }
5784 : }
5785 :
5786 : OSL_FAIL("kein Dokument oder kein Bereich");
5787 1 : return NULL;
5788 : }
5789 :
5790 : // XSubTotalSource
5791 :
5792 6 : uno::Reference<sheet::XSubTotalDescriptor> SAL_CALL ScCellRangeObj::createSubTotalDescriptor(
5793 : sal_Bool bEmpty ) throw(uno::RuntimeException, std::exception)
5794 : {
5795 6 : SolarMutexGuard aGuard;
5796 6 : ScSubTotalDescriptor* pNew = new ScSubTotalDescriptor;
5797 6 : ScDocShell* pDocSh = GetDocShell();
5798 6 : if ( !bEmpty && pDocSh )
5799 : {
5800 : // DB-Bereich anlegen erst beim Ausfuehren, per API immer genau den Bereich
5801 0 : ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, SC_DBSEL_FORCE_MARK );
5802 0 : if (pData)
5803 : {
5804 0 : ScSubTotalParam aParam;
5805 0 : pData->GetSubTotalParam(aParam);
5806 : // im SubTotalDescriptor sind die Fields innerhalb des Bereichs gezaehlt
5807 0 : ScRange aDBRange;
5808 0 : pData->GetArea(aDBRange);
5809 0 : SCCOL nFieldStart = aDBRange.aStart.Col();
5810 0 : for (sal_uInt16 i=0; i<MAXSUBTOTAL; i++)
5811 : {
5812 0 : if ( aParam.bGroupActive[i] )
5813 : {
5814 0 : if ( aParam.nField[i] >= nFieldStart )
5815 0 : aParam.nField[i] = sal::static_int_cast<SCCOL>( aParam.nField[i] - nFieldStart );
5816 0 : for (SCCOL j=0; j<aParam.nSubTotals[i]; j++)
5817 0 : if ( aParam.pSubTotals[i][j] >= nFieldStart )
5818 0 : aParam.pSubTotals[i][j] = sal::static_int_cast<SCCOL>( aParam.pSubTotals[i][j] - nFieldStart );
5819 : }
5820 : }
5821 0 : pNew->SetParam(aParam);
5822 : }
5823 : }
5824 6 : return pNew;
5825 : }
5826 :
5827 1 : void SAL_CALL ScCellRangeObj::applySubTotals(
5828 : const uno::Reference<sheet::XSubTotalDescriptor>& xDescriptor,
5829 : sal_Bool bReplace)
5830 : throw (uno::RuntimeException, std::exception)
5831 : {
5832 1 : SolarMutexGuard aGuard;
5833 :
5834 2 : if (!xDescriptor.is()) return;
5835 :
5836 1 : ScDocShell* pDocSh = GetDocShell();
5837 : ScSubTotalDescriptorBase* pImp =
5838 1 : ScSubTotalDescriptorBase::getImplementation( xDescriptor );
5839 :
5840 1 : if (pDocSh && pImp)
5841 : {
5842 1 : ScSubTotalParam aParam;
5843 1 : pImp->GetData(aParam); // virtuelle Methode der Basisklasse
5844 :
5845 : // im SubTotalDescriptor sind die Fields innerhalb des Bereichs gezaehlt
5846 1 : SCCOL nFieldStart = aRange.aStart.Col();
5847 4 : for (sal_uInt16 i=0; i<MAXSUBTOTAL; i++)
5848 : {
5849 3 : if ( aParam.bGroupActive[i] )
5850 : {
5851 1 : aParam.nField[i] = sal::static_int_cast<SCCOL>( aParam.nField[i] + nFieldStart );
5852 2 : for (SCCOL j=0; j<aParam.nSubTotals[i]; j++)
5853 1 : aParam.pSubTotals[i][j] = sal::static_int_cast<SCCOL>( aParam.pSubTotals[i][j] + nFieldStart );
5854 : }
5855 : }
5856 :
5857 1 : aParam.bReplace = bReplace;
5858 :
5859 1 : SCTAB nTab = aRange.aStart.Tab();
5860 1 : aParam.nCol1 = aRange.aStart.Col();
5861 1 : aParam.nRow1 = aRange.aStart.Row();
5862 1 : aParam.nCol2 = aRange.aEnd.Col();
5863 1 : aParam.nRow2 = aRange.aEnd.Row();
5864 :
5865 1 : pDocSh->GetDBData( aRange, SC_DB_MAKE, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen
5866 :
5867 1 : ScDBDocFunc aFunc(*pDocSh);
5868 1 : aFunc.DoSubTotals( nTab, aParam, NULL, true, true ); // Bereich muss angelegt sein
5869 1 : }
5870 : }
5871 :
5872 1 : void SAL_CALL ScCellRangeObj::removeSubTotals() throw(uno::RuntimeException, std::exception)
5873 : {
5874 1 : SolarMutexGuard aGuard;
5875 :
5876 1 : ScDocShell* pDocSh = GetDocShell();
5877 1 : if (pDocSh)
5878 : {
5879 1 : ScSubTotalParam aParam;
5880 1 : ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, SC_DBSEL_FORCE_MARK );
5881 1 : if (pData)
5882 0 : pData->GetSubTotalParam(aParam); // auch bei Remove die Feld-Eintraege behalten
5883 :
5884 1 : aParam.bRemoveOnly = true;
5885 :
5886 1 : SCTAB nTab = aRange.aStart.Tab();
5887 1 : aParam.nCol1 = aRange.aStart.Col();
5888 1 : aParam.nRow1 = aRange.aStart.Row();
5889 1 : aParam.nCol2 = aRange.aEnd.Col();
5890 1 : aParam.nRow2 = aRange.aEnd.Row();
5891 :
5892 1 : pDocSh->GetDBData( aRange, SC_DB_MAKE, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen
5893 :
5894 1 : ScDBDocFunc aFunc(*pDocSh);
5895 1 : aFunc.DoSubTotals( nTab, aParam, NULL, true, true ); // Bereich muss angelegt sein
5896 1 : }
5897 1 : }
5898 :
5899 4 : uno::Sequence<beans::PropertyValue> SAL_CALL ScCellRangeObj::createImportDescriptor( sal_Bool bEmpty )
5900 : throw(uno::RuntimeException, std::exception)
5901 : {
5902 4 : SolarMutexGuard aGuard;
5903 8 : ScImportParam aParam;
5904 4 : ScDocShell* pDocSh = GetDocShell();
5905 4 : if ( !bEmpty && pDocSh )
5906 : {
5907 : // DB-Bereich anlegen erst beim Ausfuehren, per API immer genau den Bereich
5908 3 : ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, SC_DBSEL_FORCE_MARK );
5909 3 : if (pData)
5910 0 : pData->GetImportParam(aParam);
5911 : }
5912 :
5913 4 : uno::Sequence<beans::PropertyValue> aSeq( ScImportDescriptor::GetPropertyCount() );
5914 4 : ScImportDescriptor::FillProperties( aSeq, aParam );
5915 8 : return aSeq;
5916 : }
5917 :
5918 4 : void SAL_CALL ScCellRangeObj::doImport( const uno::Sequence<beans::PropertyValue>& aDescriptor )
5919 : throw(uno::RuntimeException, std::exception)
5920 : {
5921 4 : SolarMutexGuard aGuard;
5922 4 : ScDocShell* pDocSh = GetDocShell();
5923 4 : if (pDocSh)
5924 : {
5925 4 : ScImportParam aParam;
5926 4 : ScImportDescriptor::FillImportParam( aParam, aDescriptor );
5927 :
5928 4 : SCTAB nTab = aRange.aStart.Tab();
5929 4 : aParam.nCol1 = aRange.aStart.Col();
5930 4 : aParam.nRow1 = aRange.aStart.Row();
5931 4 : aParam.nCol2 = aRange.aEnd.Col();
5932 4 : aParam.nRow2 = aRange.aEnd.Row();
5933 :
5934 : //! TODO: could we get passed a valid result set by any means?
5935 :
5936 4 : pDocSh->GetDBData( aRange, SC_DB_MAKE, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen
5937 :
5938 8 : ScDBDocFunc aFunc(*pDocSh); // Bereich muss angelegt sein
5939 8 : aFunc.DoImport( nTab, aParam, NULL, true ); //! Api-Flag as parameter
5940 4 : }
5941 4 : }
5942 :
5943 : // XCellFormatRangesSupplier
5944 :
5945 3 : uno::Reference<container::XIndexAccess> SAL_CALL ScCellRangeObj::getCellFormatRanges()
5946 : throw(uno::RuntimeException, std::exception)
5947 : {
5948 3 : SolarMutexGuard aGuard;
5949 3 : ScDocShell* pDocSh = GetDocShell();
5950 3 : if ( pDocSh )
5951 3 : return new ScCellFormatsObj( pDocSh, aRange );
5952 0 : return NULL;
5953 : }
5954 :
5955 : // XUniqueCellFormatRangesSupplier
5956 :
5957 36 : uno::Reference<container::XIndexAccess> SAL_CALL ScCellRangeObj::getUniqueCellFormatRanges()
5958 : throw(uno::RuntimeException, std::exception)
5959 : {
5960 36 : SolarMutexGuard aGuard;
5961 36 : ScDocShell* pDocSh = GetDocShell();
5962 36 : if ( pDocSh )
5963 36 : return new ScUniqueCellFormatsObj( pDocSh, aRange );
5964 0 : return NULL;
5965 : }
5966 :
5967 : // XPropertySet erweitert fuer Range-Properties
5968 :
5969 752 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCellRangeObj::getPropertySetInfo()
5970 : throw(uno::RuntimeException, std::exception)
5971 : {
5972 752 : SolarMutexGuard aGuard;
5973 : static uno::Reference<beans::XPropertySetInfo> aRef(
5974 752 : new SfxItemPropertySetInfo( pRangePropSet->getPropertyMap() ));
5975 752 : return aRef;
5976 : }
5977 :
5978 349 : void ScCellRangeObj::SetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue )
5979 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
5980 : {
5981 : // Range has only Position and Size in addition to ScCellRangesBase, both are ReadOnly
5982 : // -> nothing to do here
5983 :
5984 349 : ScCellRangesBase::SetOnePropertyValue( pEntry, aValue );
5985 348 : }
5986 :
5987 11117 : void ScCellRangeObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, uno::Any& rAny )
5988 : throw(uno::RuntimeException, std::exception)
5989 : {
5990 11117 : if ( pEntry )
5991 : {
5992 11117 : if ( pEntry->nWID == SC_WID_UNO_POS )
5993 : {
5994 1188 : ScDocShell* pDocSh = GetDocShell();
5995 1188 : if (pDocSh)
5996 : {
5997 : // GetMMRect converts using HMM_PER_TWIPS, like the DrawingLayer
5998 1188 : Rectangle aMMRect(pDocSh->GetDocument().GetMMRect(
5999 1188 : aRange.aStart.Col(), aRange.aStart.Row(),
6000 3564 : aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aStart.Tab() ));
6001 1188 : awt::Point aPos( aMMRect.Left(), aMMRect.Top() );
6002 1188 : rAny <<= aPos;
6003 : }
6004 : }
6005 9929 : else if ( pEntry->nWID == SC_WID_UNO_SIZE )
6006 : {
6007 433 : ScDocShell* pDocSh = GetDocShell();
6008 433 : if (pDocSh)
6009 : {
6010 : // GetMMRect converts using HMM_PER_TWIPS, like the DrawingLayer
6011 433 : Rectangle aMMRect = pDocSh->GetDocument().GetMMRect(
6012 433 : aRange.aStart.Col(), aRange.aStart.Row(),
6013 1299 : aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aStart.Tab() );
6014 433 : Size aSize(aMMRect.GetSize());
6015 433 : awt::Size aAwtSize( aSize.Width(), aSize.Height() );
6016 433 : rAny <<= aAwtSize;
6017 : }
6018 : }
6019 : else
6020 9496 : ScCellRangesBase::GetOnePropertyValue( pEntry, rAny );
6021 : }
6022 11117 : }
6023 :
6024 1943 : const SfxItemPropertyMap& ScCellRangeObj::GetItemPropertyMap()
6025 : {
6026 1943 : return pRangePropSet->getPropertyMap();
6027 : }
6028 :
6029 : // XServiceInfo
6030 :
6031 6 : OUString SAL_CALL ScCellRangeObj::getImplementationName() throw(uno::RuntimeException, std::exception)
6032 : {
6033 6 : return OUString( "ScCellRangeObj" );
6034 : }
6035 :
6036 10 : sal_Bool SAL_CALL ScCellRangeObj::supportsService( const OUString& rServiceName )
6037 : throw(uno::RuntimeException, std::exception)
6038 : {
6039 10 : return cppu::supportsService(this, rServiceName);
6040 : }
6041 :
6042 10 : uno::Sequence<OUString> SAL_CALL ScCellRangeObj::getSupportedServiceNames()
6043 : throw(uno::RuntimeException, std::exception)
6044 : {
6045 10 : uno::Sequence<OUString> aRet(5);
6046 10 : OUString* pArray = aRet.getArray();
6047 10 : pArray[0] = SCSHEETCELLRANGE_SERVICE;
6048 10 : pArray[1] = SCCELLRANGE_SERVICE;
6049 10 : pArray[2] = SCCELLPROPERTIES_SERVICE;
6050 10 : pArray[3] = SCCHARPROPERTIES_SERVICE;
6051 10 : pArray[4] = SCPARAPROPERTIES_SERVICE;
6052 10 : return aRet;
6053 : }
6054 :
6055 10 : const SvxItemPropertySet* ScCellObj::GetEditPropertySet()
6056 : {
6057 10 : return lcl_GetEditPropertySet();
6058 : }
6059 :
6060 0 : const SfxItemPropertyMap& ScCellObj::GetCellPropertyMap()
6061 : {
6062 0 : return lcl_GetCellPropertySet()->getPropertyMap();
6063 : }
6064 :
6065 16640 : ScCellObj::ScCellObj(ScDocShell* pDocSh, const ScAddress& rP) :
6066 : ScCellRangeObj( pDocSh, ScRange(rP,rP) ),
6067 16640 : pCellPropSet( lcl_GetCellPropertySet() ),
6068 : aCellPos( rP ),
6069 33280 : nActionLockCount( 0 )
6070 : {
6071 : // pUnoText is allocated on demand (GetUnoText)
6072 : // can't be aggregated because getString/setString is handled here
6073 16640 : }
6074 :
6075 23 : SvxUnoText& ScCellObj::GetUnoText()
6076 : {
6077 23 : if (!mxUnoText.is())
6078 : {
6079 10 : mxUnoText.set(new ScCellTextObj(GetDocShell(), aCellPos));
6080 10 : if (nActionLockCount)
6081 : {
6082 : ScCellEditSource* pEditSource =
6083 0 : static_cast<ScCellEditSource*> (mxUnoText->GetEditSource());
6084 0 : if (pEditSource)
6085 0 : pEditSource->SetDoUpdateData(false);
6086 : }
6087 : }
6088 23 : return *mxUnoText;
6089 : }
6090 :
6091 33228 : ScCellObj::~ScCellObj()
6092 : {
6093 33228 : }
6094 :
6095 838 : void ScCellObj::RefChanged()
6096 : {
6097 838 : ScCellRangeObj::RefChanged();
6098 :
6099 838 : const ScRangeList& rRanges = GetRangeList();
6100 : OSL_ENSURE(rRanges.size() == 1, "was fuer Ranges ?!?!");
6101 838 : if ( !rRanges.empty() )
6102 : {
6103 816 : const ScRange* pFirst = rRanges[ 0 ];
6104 816 : aCellPos = pFirst->aStart;
6105 : }
6106 838 : }
6107 :
6108 141353 : uno::Any SAL_CALL ScCellObj::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException, std::exception)
6109 : {
6110 141353 : SC_QUERYINTERFACE( table::XCell )
6111 133375 : SC_QUERYINTERFACE( table::XCell2 )
6112 133375 : SC_QUERYINTERFACE( sheet::XFormulaTokens )
6113 133375 : SC_QUERYINTERFACE( sheet::XCellAddressable )
6114 131509 : SC_QUERYINTERFACE( text::XText )
6115 130066 : SC_QUERYINTERFACE( text::XSimpleText )
6116 129975 : SC_QUERYINTERFACE( text::XTextRange )
6117 129802 : SC_QUERYINTERFACE( container::XEnumerationAccess )
6118 129800 : SC_QUERYINTERFACE( container::XElementAccess )
6119 129798 : SC_QUERYINTERFACE( sheet::XSheetAnnotationAnchor )
6120 129788 : SC_QUERYINTERFACE( text::XTextFieldsSupplier )
6121 129785 : SC_QUERYINTERFACE( document::XActionLockable )
6122 :
6123 129784 : return ScCellRangeObj::queryInterface( rType );
6124 : }
6125 :
6126 416705 : void SAL_CALL ScCellObj::acquire() throw()
6127 : {
6128 416705 : ScCellRangeObj::acquire();
6129 416705 : }
6130 :
6131 416679 : void SAL_CALL ScCellObj::release() throw()
6132 : {
6133 416679 : ScCellRangeObj::release();
6134 416679 : }
6135 :
6136 2 : uno::Sequence<uno::Type> SAL_CALL ScCellObj::getTypes() throw(uno::RuntimeException, std::exception)
6137 : {
6138 2 : static uno::Sequence<uno::Type> aTypes;
6139 2 : if ( aTypes.getLength() == 0 )
6140 : {
6141 1 : uno::Sequence<uno::Type> aParentTypes(ScCellRangeObj::getTypes());
6142 1 : long nParentLen = aParentTypes.getLength();
6143 1 : const uno::Type* pParentPtr = aParentTypes.getConstArray();
6144 :
6145 1 : aTypes.realloc( nParentLen + 9 );
6146 1 : uno::Type* pPtr = aTypes.getArray();
6147 1 : pPtr[nParentLen + 0] = cppu::UnoType<table::XCell>::get();
6148 1 : pPtr[nParentLen + 1] = cppu::UnoType<sheet::XCellAddressable>::get();
6149 1 : pPtr[nParentLen + 2] = cppu::UnoType<text::XText>::get();
6150 1 : pPtr[nParentLen + 3] = cppu::UnoType<container::XEnumerationAccess>::get();
6151 1 : pPtr[nParentLen + 4] = cppu::UnoType<sheet::XSheetAnnotationAnchor>::get();
6152 1 : pPtr[nParentLen + 5] = cppu::UnoType<text::XTextFieldsSupplier>::get();
6153 1 : pPtr[nParentLen + 6] = cppu::UnoType<document::XActionLockable>::get();
6154 1 : pPtr[nParentLen + 7] = cppu::UnoType<sheet::XFormulaTokens>::get();
6155 1 : pPtr[nParentLen + 8] = cppu::UnoType<table::XCell2>::get();
6156 :
6157 31 : for (long i=0; i<nParentLen; i++)
6158 31 : pPtr[i] = pParentPtr[i]; // parent types first
6159 : }
6160 2 : return aTypes;
6161 : }
6162 :
6163 0 : uno::Sequence<sal_Int8> SAL_CALL ScCellObj::getImplementationId() throw(uno::RuntimeException, std::exception)
6164 : {
6165 0 : return css::uno::Sequence<sal_Int8>();
6166 : }
6167 :
6168 : // Hilfsfunktionen
6169 :
6170 131 : OUString ScCellObj::GetInputString_Impl(bool bEnglish) const // fuer getFormula / FormulaLocal
6171 : {
6172 131 : if (GetDocShell())
6173 131 : return lcl_GetInputString( GetDocShell()->GetDocument(), aCellPos, bEnglish );
6174 0 : return OUString();
6175 : }
6176 :
6177 1682 : OUString ScCellObj::GetOutputString_Impl() const
6178 : {
6179 1682 : ScDocShell* pDocSh = GetDocShell();
6180 1682 : OUString aVal;
6181 1682 : if ( pDocSh )
6182 : {
6183 1682 : ScDocument& rDoc = pDocSh->GetDocument();
6184 1682 : ScRefCellValue aCell;
6185 1682 : aCell.assign(rDoc, aCellPos);
6186 :
6187 1682 : aVal = ScCellFormat::GetOutputString(rDoc, aCellPos, aCell);
6188 : }
6189 1682 : return aVal;
6190 : }
6191 :
6192 2046 : void ScCellObj::SetString_Impl(const OUString& rString, bool bInterpret, bool bEnglish)
6193 : {
6194 2046 : ScDocShell* pDocSh = GetDocShell();
6195 2046 : if ( pDocSh )
6196 : {
6197 : // GRAM_PODF_A1 for API compatibility.
6198 2046 : (void)pDocSh->GetDocFunc().SetCellText(
6199 4092 : aCellPos, rString, bInterpret, bEnglish, true, formula::FormulaGrammar::GRAM_PODF_A1 );
6200 : }
6201 2046 : }
6202 :
6203 2617 : double ScCellObj::GetValue_Impl() const
6204 : {
6205 2617 : ScDocShell* pDocSh = GetDocShell();
6206 2617 : if ( pDocSh )
6207 2617 : return pDocSh->GetDocument().GetValue( aCellPos );
6208 :
6209 0 : return 0.0;
6210 : }
6211 :
6212 3620 : void ScCellObj::SetValue_Impl(double fValue)
6213 : {
6214 3620 : ScDocShell* pDocSh = GetDocShell();
6215 3620 : if ( pDocSh )
6216 3620 : pDocSh->GetDocFunc().SetValueCell(aCellPos, fValue, false);
6217 3620 : }
6218 :
6219 : // only for XML import
6220 :
6221 1530 : void ScCellObj::InputEnglishString( const OUString& rText )
6222 : {
6223 : // This is like a mixture of setFormula and property FormulaLocal:
6224 : // The cell's number format is checked for "text", a new cell format may be set,
6225 : // but all parsing is in English.
6226 :
6227 1530 : ScDocShell* pDocSh = GetDocShell();
6228 1530 : if (!pDocSh)
6229 0 : return;
6230 :
6231 1530 : OUString aString(rText);
6232 1530 : ScDocument& rDoc = pDocSh->GetDocument();
6233 1530 : SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
6234 1530 : sal_uInt32 nOldFormat = rDoc.GetNumberFormat( aCellPos );
6235 1530 : if (pFormatter->GetType(nOldFormat) == css::util::NumberFormat::TEXT)
6236 : {
6237 0 : SetString_Impl(aString, false, false); // text cell
6238 0 : return;
6239 : }
6240 :
6241 1530 : ScDocFunc &rFunc = pDocSh->GetDocFunc();
6242 :
6243 : ScInputStringType aRes =
6244 3060 : ScStringUtil::parseInputString(*pFormatter, aString, LANGUAGE_ENGLISH_US);
6245 :
6246 1530 : if (aRes.meType != ScInputStringType::Unknown)
6247 : {
6248 386 : if ((nOldFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0 && aRes.mnFormatType)
6249 : {
6250 : // apply a format for the recognized type and the old format's language
6251 1 : sal_uInt32 nNewFormat = ScGlobal::GetStandardFormat(*pFormatter, nOldFormat, aRes.mnFormatType);
6252 1 : if (nNewFormat != nOldFormat)
6253 : {
6254 0 : ScPatternAttr aPattern( rDoc.GetPool() );
6255 0 : aPattern.GetItemSet().Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat ) );
6256 : // ATTR_LANGUAGE_FORMAT remains unchanged
6257 0 : rFunc.ApplyAttributes( *GetMarkData(), aPattern, true, true );
6258 : }
6259 : }
6260 : }
6261 1530 : switch (aRes.meType)
6262 : {
6263 : case ScInputStringType::Formula:
6264 : rFunc.SetFormulaCell(
6265 : aCellPos,
6266 1 : new ScFormulaCell(&rDoc, aCellPos, aRes.maText, formula::FormulaGrammar::GRAM_PODF_A1),
6267 2 : false);
6268 1 : break;
6269 : case ScInputStringType::Number:
6270 1 : rFunc.SetValueCell(aCellPos, aRes.mfValue, false);
6271 1 : break;
6272 : case ScInputStringType::Text:
6273 384 : rFunc.SetStringOrEditCell(aCellPos, aRes.maText, false);
6274 384 : break;
6275 : default:
6276 1144 : SetString_Impl(aString, false, false); // probably empty string
6277 1530 : }
6278 : }
6279 :
6280 : // XText
6281 :
6282 12 : uno::Reference<text::XTextCursor> SAL_CALL ScCellObj::createTextCursor()
6283 : throw(uno::RuntimeException, std::exception)
6284 : {
6285 12 : SolarMutexGuard aGuard;
6286 12 : return new ScCellTextCursor( *this );
6287 : }
6288 :
6289 1 : uno::Reference<text::XTextCursor> SAL_CALL ScCellObj::createTextCursorByRange(
6290 : const uno::Reference<text::XTextRange>& aTextPosition )
6291 : throw(uno::RuntimeException, std::exception)
6292 : {
6293 1 : SolarMutexGuard aGuard;
6294 1 : SvxUnoTextCursor* pCursor = new ScCellTextCursor( *this );
6295 1 : uno::Reference<text::XTextCursor> xCursor(pCursor);
6296 :
6297 1 : SvxUnoTextRangeBase* pRange = SvxUnoTextRangeBase::getImplementation( aTextPosition );
6298 1 : if(pRange)
6299 1 : pCursor->SetSelection( pRange->GetSelection() );
6300 : else
6301 : {
6302 0 : ScCellTextCursor* pOther = ScCellTextCursor::getImplementation( aTextPosition );
6303 0 : if(pOther)
6304 0 : pCursor->SetSelection( pOther->GetSelection() );
6305 : else
6306 0 : throw uno::RuntimeException();
6307 : }
6308 :
6309 1 : return xCursor;
6310 : }
6311 :
6312 1682 : OUString SAL_CALL ScCellObj::getString() throw(uno::RuntimeException, std::exception)
6313 : {
6314 1682 : SolarMutexGuard aGuard;
6315 1682 : return GetOutputString_Impl();
6316 : }
6317 :
6318 34 : void SAL_CALL ScCellObj::setString( const OUString& aText ) throw(uno::RuntimeException, std::exception)
6319 : {
6320 34 : SolarMutexGuard aGuard;
6321 68 : OUString aString(aText);
6322 34 : SetString_Impl(aString, false, false); // immer Text
6323 :
6324 : // don't create pUnoText here if not there
6325 34 : if (mxUnoText.is())
6326 40 : mxUnoText->SetSelection(ESelection( 0,0, 0,aString.getLength() ));
6327 34 : }
6328 :
6329 2 : void SAL_CALL ScCellObj::insertString( const uno::Reference<text::XTextRange>& xRange,
6330 : const OUString& aString, sal_Bool bAbsorb )
6331 : throw(uno::RuntimeException, std::exception)
6332 : {
6333 : // special handling for ScCellTextCursor is no longer needed,
6334 : // SvxUnoText::insertString checks for SvxUnoTextRangeBase instead of SvxUnoTextRange
6335 :
6336 2 : SolarMutexGuard aGuard;
6337 2 : GetUnoText().insertString(xRange, aString, bAbsorb);
6338 2 : }
6339 :
6340 2 : void SAL_CALL ScCellObj::insertControlCharacter( const uno::Reference<text::XTextRange>& xRange,
6341 : sal_Int16 nControlCharacter, sal_Bool bAbsorb )
6342 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
6343 : {
6344 2 : SolarMutexGuard aGuard;
6345 2 : GetUnoText().insertControlCharacter(xRange, nControlCharacter, bAbsorb);
6346 2 : }
6347 :
6348 7 : void SAL_CALL ScCellObj::insertTextContent( const uno::Reference<text::XTextRange >& xRange,
6349 : const uno::Reference<text::XTextContent >& xContent,
6350 : sal_Bool bAbsorb )
6351 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
6352 : {
6353 7 : SolarMutexGuard aGuard;
6354 7 : ScDocShell* pDocSh = GetDocShell();
6355 7 : if ( pDocSh && xContent.is() )
6356 : {
6357 6 : ScEditFieldObj* pCellField = ScEditFieldObj::getImplementation(xContent);
6358 6 : SvxUnoTextRangeBase* pTextRange = ScCellTextCursor::getImplementation( xRange );
6359 :
6360 6 : if ( pCellField && !pCellField->IsInserted() && pTextRange )
6361 : {
6362 6 : SvxEditSource* pEditSource = pTextRange->GetEditSource();
6363 6 : ESelection aSelection(pTextRange->GetSelection());
6364 :
6365 6 : if (!bAbsorb)
6366 : {
6367 : // nicht ersetzen -> hinten anhaengen
6368 2 : aSelection.Adjust();
6369 2 : aSelection.nStartPara = aSelection.nEndPara;
6370 2 : aSelection.nStartPos = aSelection.nEndPos;
6371 : }
6372 :
6373 6 : if (pCellField->GetFieldType() == text::textfield::Type::TABLE)
6374 0 : pCellField->setPropertyValue(SC_UNONAME_TABLEPOS, uno::makeAny<sal_Int32>(aCellPos.Tab()));
6375 :
6376 6 : SvxFieldItem aItem = pCellField->CreateFieldItem();
6377 6 : SvxTextForwarder* pForwarder = pEditSource->GetTextForwarder();
6378 6 : pForwarder->QuickInsertField( aItem, aSelection );
6379 6 : pEditSource->UpdateData();
6380 :
6381 : // neue Selektion: ein Zeichen
6382 6 : aSelection.Adjust();
6383 6 : aSelection.nEndPara = aSelection.nStartPara;
6384 6 : aSelection.nEndPos = aSelection.nStartPos + 1;
6385 12 : uno::Reference<text::XTextRange> xParent(this);
6386 : pCellField->InitDoc(
6387 6 : xParent, new ScCellEditSource(pDocSh, aCellPos), aSelection);
6388 :
6389 : // for bAbsorb=FALSE, the new selection must be behind the inserted content
6390 : // (the xml filter relies on this)
6391 6 : if (!bAbsorb)
6392 2 : aSelection.nStartPos = aSelection.nEndPos;
6393 :
6394 6 : pTextRange->SetSelection( aSelection );
6395 :
6396 18 : return;
6397 : }
6398 : }
6399 2 : GetUnoText().insertTextContent(xRange, xContent, bAbsorb);
6400 : }
6401 :
6402 1 : void SAL_CALL ScCellObj::removeTextContent( const uno::Reference<text::XTextContent>& xContent )
6403 : throw(container::NoSuchElementException, uno::RuntimeException, std::exception)
6404 : {
6405 1 : SolarMutexGuard aGuard;
6406 1 : if ( xContent.is() )
6407 : {
6408 1 : ScEditFieldObj* pCellField = ScEditFieldObj::getImplementation(xContent);
6409 1 : if ( pCellField && pCellField->IsInserted() )
6410 : {
6411 : //! Testen, ob das Feld in dieser Zelle ist
6412 1 : pCellField->DeleteField();
6413 2 : return;
6414 : }
6415 : }
6416 0 : GetUnoText().removeTextContent(xContent);
6417 : }
6418 :
6419 4 : uno::Reference<text::XText> SAL_CALL ScCellObj::getText() throw(uno::RuntimeException, std::exception)
6420 : {
6421 4 : SolarMutexGuard aGuard;
6422 4 : return this;
6423 : }
6424 :
6425 1 : uno::Reference<text::XTextRange> SAL_CALL ScCellObj::getStart() throw(uno::RuntimeException, std::exception)
6426 : {
6427 1 : SolarMutexGuard aGuard;
6428 1 : return GetUnoText().getStart();
6429 : }
6430 :
6431 1 : uno::Reference<text::XTextRange> SAL_CALL ScCellObj::getEnd() throw(uno::RuntimeException, std::exception)
6432 : {
6433 1 : SolarMutexGuard aGuard;
6434 1 : return GetUnoText().getEnd();
6435 : }
6436 :
6437 1 : uno::Reference<container::XEnumeration> SAL_CALL ScCellObj::createEnumeration()
6438 : throw(uno::RuntimeException, std::exception)
6439 : {
6440 1 : SolarMutexGuard aGuard;
6441 1 : return GetUnoText().createEnumeration();
6442 : }
6443 :
6444 1 : uno::Type SAL_CALL ScCellObj::getElementType() throw(uno::RuntimeException, std::exception)
6445 : {
6446 1 : SolarMutexGuard aGuard;
6447 1 : return GetUnoText().getElementType();
6448 : }
6449 :
6450 1 : sal_Bool SAL_CALL ScCellObj::hasElements() throw(uno::RuntimeException, std::exception)
6451 : {
6452 1 : SolarMutexGuard aGuard;
6453 1 : return GetUnoText().hasElements();
6454 : }
6455 :
6456 : // XCell
6457 :
6458 121 : OUString SAL_CALL ScCellObj::getFormula() throw(uno::RuntimeException, std::exception)
6459 : {
6460 121 : SolarMutexGuard aGuard;
6461 121 : return GetInputString_Impl( true /* English */ );
6462 : }
6463 :
6464 866 : void SAL_CALL ScCellObj::setFormula( const OUString& aFormula ) throw(uno::RuntimeException, std::exception)
6465 : {
6466 866 : SolarMutexGuard aGuard;
6467 1732 : OUString aString(aFormula);
6468 1732 : SetString_Impl(aString, true, true); // Interpret as English
6469 866 : }
6470 :
6471 2617 : double SAL_CALL ScCellObj::getValue() throw(uno::RuntimeException, std::exception)
6472 : {
6473 2617 : SolarMutexGuard aGuard;
6474 2617 : return GetValue_Impl();
6475 : }
6476 :
6477 3620 : void SAL_CALL ScCellObj::setValue( double nValue ) throw(uno::RuntimeException, std::exception)
6478 : {
6479 3620 : SolarMutexGuard aGuard;
6480 3620 : SetValue_Impl(nValue);
6481 3620 : }
6482 :
6483 0 : void SAL_CALL ScCellObj::setFormulaString( const OUString& aFormula) throw(uno::RuntimeException, std::exception)
6484 : {
6485 0 : SolarMutexGuard aGuard;
6486 0 : ScDocShell *pDocSh = GetDocShell();
6487 0 : if( pDocSh )
6488 : {
6489 0 : ScFormulaCell* pCell = new ScFormulaCell( &pDocSh->GetDocument(), aCellPos );
6490 0 : pCell->SetHybridFormula( aFormula, formula::FormulaGrammar::GRAM_NATIVE );
6491 0 : pDocSh->GetDocFunc().SetFormulaCell(aCellPos, pCell, false);
6492 0 : }
6493 0 : }
6494 0 : void SAL_CALL ScCellObj::setFormulaResult( double nValue ) throw(uno::RuntimeException, std::exception)
6495 : {
6496 0 : SolarMutexGuard aGuard;
6497 0 : ScDocShell* pDocSh = GetDocShell();
6498 0 : if ( pDocSh && pDocSh->GetDocument().GetCellType( aCellPos ) == CELLTYPE_FORMULA )
6499 : {
6500 0 : ScFormulaCell* pCell = pDocSh->GetDocument().GetFormulaCell(aCellPos);
6501 0 : if (!pCell)
6502 0 : return;
6503 0 : pCell->SetHybridDouble( nValue );
6504 0 : pCell->ResetDirty();
6505 0 : pCell->SetChanged(false);
6506 0 : }
6507 : }
6508 :
6509 5661 : table::CellContentType SAL_CALL ScCellObj::getType() throw(uno::RuntimeException, std::exception)
6510 : {
6511 5661 : SolarMutexGuard aGuard;
6512 5661 : table::CellContentType eRet = table::CellContentType_EMPTY;
6513 5661 : ScDocShell* pDocSh = GetDocShell();
6514 5661 : if (pDocSh)
6515 : {
6516 5661 : CellType eCalcType = pDocSh->GetDocument().GetCellType( aCellPos );
6517 5661 : switch (eCalcType)
6518 : {
6519 : case CELLTYPE_VALUE:
6520 2555 : eRet = table::CellContentType_VALUE;
6521 2555 : break;
6522 : case CELLTYPE_STRING:
6523 : case CELLTYPE_EDIT:
6524 1613 : eRet = table::CellContentType_TEXT;
6525 1613 : break;
6526 : case CELLTYPE_FORMULA:
6527 65 : eRet = table::CellContentType_FORMULA;
6528 65 : break;
6529 : default:
6530 1428 : eRet = table::CellContentType_EMPTY;
6531 : }
6532 : }
6533 : else
6534 : {
6535 : OSL_FAIL("keine DocShell"); //! Exception oder so?
6536 : }
6537 :
6538 5661 : return eRet;
6539 : }
6540 :
6541 49 : table::CellContentType ScCellObj::GetResultType_Impl()
6542 : {
6543 49 : ScDocShell* pDocSh = GetDocShell();
6544 49 : if ( pDocSh )
6545 : {
6546 49 : ScRefCellValue aCell;
6547 49 : aCell.assign(pDocSh->GetDocument(), aCellPos);
6548 49 : if (aCell.meType == CELLTYPE_FORMULA)
6549 : {
6550 39 : bool bValue = aCell.mpFormula->IsValue();
6551 39 : return bValue ? table::CellContentType_VALUE : table::CellContentType_TEXT;
6552 10 : }
6553 : }
6554 10 : return getType(); // wenn keine Formel
6555 : }
6556 :
6557 2 : sal_Int32 SAL_CALL ScCellObj::getError() throw(uno::RuntimeException, std::exception)
6558 : {
6559 2 : SolarMutexGuard aGuard;
6560 2 : ScDocShell* pDocSh = GetDocShell();
6561 2 : if (!pDocSh)
6562 : {
6563 : OSL_FAIL("keine DocShell"); //! Exception oder so?
6564 0 : return 0;
6565 : }
6566 :
6567 2 : sal_uInt16 nError = 0;
6568 4 : ScRefCellValue aCell;
6569 2 : aCell.assign(pDocSh->GetDocument(), aCellPos);
6570 2 : if (aCell.meType == CELLTYPE_FORMULA)
6571 1 : nError = aCell.mpFormula->GetErrCode();
6572 :
6573 4 : return nError;
6574 : }
6575 :
6576 : // XFormulaTokens
6577 :
6578 0 : uno::Sequence<sheet::FormulaToken> SAL_CALL ScCellObj::getTokens()
6579 : throw (uno::RuntimeException, std::exception)
6580 : {
6581 0 : SolarMutexGuard aGuard;
6582 0 : uno::Sequence<sheet::FormulaToken> aSequence;
6583 0 : ScDocShell* pDocSh = GetDocShell();
6584 0 : if (!pDocSh)
6585 0 : return aSequence;
6586 :
6587 0 : ScDocument& rDoc = pDocSh->GetDocument();
6588 0 : ScRefCellValue aCell;
6589 0 : aCell.assign(rDoc, aCellPos);
6590 0 : if (aCell.meType == CELLTYPE_FORMULA)
6591 : {
6592 0 : ScTokenArray* pTokenArray = aCell.mpFormula->GetCode();
6593 0 : if (pTokenArray)
6594 0 : ScTokenConversion::ConvertToTokenSequence(rDoc, aSequence, *pTokenArray);
6595 : }
6596 0 : return aSequence;
6597 : }
6598 :
6599 0 : void SAL_CALL ScCellObj::setTokens( const uno::Sequence<sheet::FormulaToken>& rTokens ) throw(uno::RuntimeException, std::exception)
6600 : {
6601 0 : SolarMutexGuard aGuard;
6602 0 : ScDocShell* pDocSh = GetDocShell();
6603 0 : if ( pDocSh )
6604 : {
6605 0 : ScDocument& rDoc = pDocSh->GetDocument();
6606 0 : ScTokenArray aTokenArray;
6607 0 : (void)ScTokenConversion::ConvertToTokenArray( rDoc, aTokenArray, rTokens );
6608 :
6609 0 : ScFormulaCell* pNewCell = new ScFormulaCell(&rDoc, aCellPos, aTokenArray);
6610 0 : (void)pDocSh->GetDocFunc().SetFormulaCell(aCellPos, pNewCell, false);
6611 0 : }
6612 0 : }
6613 :
6614 : // XCellAddressable
6615 :
6616 1869 : table::CellAddress SAL_CALL ScCellObj::getCellAddress() throw(uno::RuntimeException, std::exception)
6617 : {
6618 1869 : SolarMutexGuard aGuard;
6619 1869 : table::CellAddress aAdr;
6620 1869 : aAdr.Sheet = aCellPos.Tab();
6621 1869 : aAdr.Column = aCellPos.Col();
6622 1869 : aAdr.Row = aCellPos.Row();
6623 1869 : return aAdr;
6624 : }
6625 :
6626 : // XSheetAnnotationAnchor
6627 :
6628 10 : uno::Reference<sheet::XSheetAnnotation> SAL_CALL ScCellObj::getAnnotation()
6629 : throw(uno::RuntimeException, std::exception)
6630 : {
6631 10 : SolarMutexGuard aGuard;
6632 10 : ScDocShell* pDocSh = GetDocShell();
6633 10 : if ( pDocSh )
6634 10 : return new ScAnnotationObj( pDocSh, aCellPos );
6635 :
6636 : OSL_FAIL("getAnnotation ohne DocShell");
6637 0 : return NULL;
6638 : }
6639 :
6640 : // XFieldTypesSupplier
6641 :
6642 4 : uno::Reference<container::XEnumerationAccess> SAL_CALL ScCellObj::getTextFields()
6643 : throw(uno::RuntimeException, std::exception)
6644 : {
6645 4 : SolarMutexGuard aGuard;
6646 4 : ScDocShell* pDocSh = GetDocShell();
6647 4 : if ( pDocSh )
6648 : {
6649 4 : uno::Reference<text::XTextRange> xContent(this);
6650 4 : return new ScCellFieldsObj(xContent, pDocSh, aCellPos);
6651 : }
6652 :
6653 0 : return NULL;
6654 : }
6655 :
6656 0 : uno::Reference<container::XNameAccess> SAL_CALL ScCellObj::getTextFieldMasters()
6657 : throw(uno::RuntimeException, std::exception)
6658 : {
6659 : // sowas gibts nicht im Calc (?)
6660 0 : return NULL;
6661 : }
6662 :
6663 : // XPropertySet erweitert fuer Zell-Properties
6664 :
6665 1080 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCellObj::getPropertySetInfo()
6666 : throw(uno::RuntimeException, std::exception)
6667 : {
6668 1080 : SolarMutexGuard aGuard;
6669 : static uno::Reference<beans::XPropertySetInfo> aRef(
6670 1080 : new SfxItemPropertySetInfo( pCellPropSet->getPropertyMap() ));
6671 1080 : return aRef;
6672 : }
6673 :
6674 49 : void ScCellObj::SetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue )
6675 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
6676 : {
6677 49 : if ( pEntry )
6678 : {
6679 49 : if ( pEntry->nWID == SC_WID_UNO_FORMLOC )
6680 : {
6681 2 : OUString aStrVal;
6682 2 : aValue >>= aStrVal;
6683 4 : OUString aString(aStrVal);
6684 4 : SetString_Impl(aString, true, false); // lokal interpretieren
6685 : }
6686 47 : else if ( pEntry->nWID == SC_WID_UNO_FORMRT )
6687 : {
6688 : // Read-Only
6689 : //! Exception oder so...
6690 : }
6691 : else
6692 46 : ScCellRangeObj::SetOnePropertyValue( pEntry, aValue );
6693 : }
6694 49 : }
6695 :
6696 9260 : void ScCellObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, uno::Any& rAny )
6697 : throw(uno::RuntimeException, std::exception)
6698 : {
6699 9260 : if ( pEntry )
6700 : {
6701 9260 : if ( pEntry->nWID == SC_WID_UNO_FORMLOC )
6702 : {
6703 : // sal_False = lokal
6704 10 : rAny <<= OUString( GetInputString_Impl(false) );
6705 : }
6706 9250 : else if ( pEntry->nWID == SC_WID_UNO_FORMRT )
6707 : {
6708 49 : table::CellContentType eType = GetResultType_Impl();
6709 49 : rAny <<= eType;
6710 : }
6711 : else
6712 9201 : ScCellRangeObj::GetOnePropertyValue(pEntry, rAny);
6713 : }
6714 9260 : }
6715 :
6716 8785 : const SfxItemPropertyMap& ScCellObj::GetItemPropertyMap()
6717 : {
6718 8785 : return pCellPropSet->getPropertyMap();
6719 : }
6720 :
6721 : // XServiceInfo
6722 :
6723 13 : OUString SAL_CALL ScCellObj::getImplementationName() throw(uno::RuntimeException, std::exception)
6724 : {
6725 13 : return OUString( "ScCellObj" );
6726 : }
6727 :
6728 17 : sal_Bool SAL_CALL ScCellObj::supportsService( const OUString& rServiceName )
6729 : throw(uno::RuntimeException, std::exception)
6730 : {
6731 17 : return cppu::supportsService(this, rServiceName);
6732 : }
6733 :
6734 17 : uno::Sequence<OUString> SAL_CALL ScCellObj::getSupportedServiceNames()
6735 : throw(uno::RuntimeException, std::exception)
6736 : {
6737 17 : uno::Sequence<OUString> aRet(7);
6738 17 : OUString* pArray = aRet.getArray();
6739 17 : pArray[0] = SCSHEETCELL_SERVICE;
6740 17 : pArray[1] = SCCELL_SERVICE;
6741 17 : pArray[2] = SCCELLPROPERTIES_SERVICE;
6742 17 : pArray[3] = SCCHARPROPERTIES_SERVICE;
6743 17 : pArray[4] = SCPARAPROPERTIES_SERVICE;
6744 17 : pArray[5] = SCSHEETCELLRANGE_SERVICE;
6745 17 : pArray[6] = SCCELLRANGE_SERVICE;
6746 17 : return aRet;
6747 : }
6748 :
6749 : // XActionLockable
6750 :
6751 3 : sal_Bool SAL_CALL ScCellObj::isActionLocked() throw(uno::RuntimeException, std::exception)
6752 : {
6753 3 : SolarMutexGuard aGuard;
6754 3 : return nActionLockCount != 0;
6755 : }
6756 :
6757 2 : void SAL_CALL ScCellObj::addActionLock() throw(uno::RuntimeException, std::exception)
6758 : {
6759 2 : SolarMutexGuard aGuard;
6760 2 : if (!nActionLockCount)
6761 : {
6762 2 : if (mxUnoText.is())
6763 : {
6764 : ScCellEditSource* pEditSource =
6765 0 : static_cast<ScCellEditSource*> (mxUnoText->GetEditSource());
6766 0 : if (pEditSource)
6767 0 : pEditSource->SetDoUpdateData(false);
6768 : }
6769 : }
6770 2 : nActionLockCount++;
6771 2 : }
6772 :
6773 1 : void SAL_CALL ScCellObj::removeActionLock() throw(uno::RuntimeException, std::exception)
6774 : {
6775 1 : SolarMutexGuard aGuard;
6776 1 : if (nActionLockCount > 0)
6777 : {
6778 1 : nActionLockCount--;
6779 1 : if (!nActionLockCount)
6780 : {
6781 1 : if (mxUnoText.is())
6782 : {
6783 : ScCellEditSource* pEditSource =
6784 0 : static_cast<ScCellEditSource*> (mxUnoText->GetEditSource());
6785 0 : if (pEditSource)
6786 : {
6787 0 : pEditSource->SetDoUpdateData(true);
6788 0 : if (pEditSource->IsDirty())
6789 0 : pEditSource->UpdateData();
6790 : }
6791 : }
6792 : }
6793 1 : }
6794 1 : }
6795 :
6796 1 : void SAL_CALL ScCellObj::setActionLocks( sal_Int16 nLock ) throw(uno::RuntimeException, std::exception)
6797 : {
6798 1 : SolarMutexGuard aGuard;
6799 1 : if (mxUnoText.is())
6800 : {
6801 : ScCellEditSource* pEditSource =
6802 0 : static_cast<ScCellEditSource*> (mxUnoText->GetEditSource());
6803 0 : if (pEditSource)
6804 : {
6805 0 : pEditSource->SetDoUpdateData(nLock == 0);
6806 0 : if ((nActionLockCount > 0) && (nLock == 0) && pEditSource->IsDirty())
6807 0 : pEditSource->UpdateData();
6808 : }
6809 : }
6810 1 : nActionLockCount = nLock;
6811 1 : }
6812 :
6813 1 : sal_Int16 SAL_CALL ScCellObj::resetActionLocks() throw(uno::RuntimeException, std::exception)
6814 : {
6815 1 : SolarMutexGuard aGuard;
6816 1 : sal_uInt16 nRet(nActionLockCount);
6817 1 : if (mxUnoText.is())
6818 : {
6819 : ScCellEditSource* pEditSource =
6820 0 : static_cast<ScCellEditSource*> (mxUnoText->GetEditSource());
6821 0 : if (pEditSource)
6822 : {
6823 0 : pEditSource->SetDoUpdateData(true);
6824 0 : if (pEditSource->IsDirty())
6825 0 : pEditSource->UpdateData();
6826 : }
6827 : }
6828 1 : nActionLockCount = 0;
6829 1 : return nRet;
6830 : }
6831 :
6832 4593 : ScTableSheetObj::ScTableSheetObj( ScDocShell* pDocSh, SCTAB nTab ) :
6833 : ScCellRangeObj( pDocSh, ScRange(0,0,nTab, MAXCOL,MAXROW,nTab) ),
6834 4593 : pSheetPropSet(lcl_GetSheetPropertySet())
6835 : {
6836 4593 : }
6837 :
6838 9022 : ScTableSheetObj::~ScTableSheetObj()
6839 : {
6840 9022 : }
6841 :
6842 0 : void ScTableSheetObj::InitInsertSheet(ScDocShell* pDocSh, SCTAB nTab)
6843 : {
6844 0 : InitInsertRange( pDocSh, ScRange(0,0,nTab, MAXCOL,MAXROW,nTab) );
6845 0 : }
6846 :
6847 60083 : uno::Any SAL_CALL ScTableSheetObj::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException, std::exception)
6848 : {
6849 60083 : SC_QUERYINTERFACE( sheet::XSpreadsheet )
6850 58530 : SC_QUERYINTERFACE( container::XNamed )
6851 58026 : SC_QUERYINTERFACE( sheet::XSheetPageBreak )
6852 58023 : SC_QUERYINTERFACE( sheet::XCellRangeMovement )
6853 58017 : SC_QUERYINTERFACE( table::XTableChartsSupplier )
6854 57945 : SC_QUERYINTERFACE( sheet::XDataPilotTablesSupplier )
6855 57904 : SC_QUERYINTERFACE( sheet::XScenariosSupplier )
6856 57903 : SC_QUERYINTERFACE( sheet::XSheetAnnotationsSupplier )
6857 57890 : SC_QUERYINTERFACE( drawing::XDrawPageSupplier )
6858 57273 : SC_QUERYINTERFACE( sheet::XPrintAreas )
6859 57236 : SC_QUERYINTERFACE( sheet::XSheetAuditing )
6860 57235 : SC_QUERYINTERFACE( sheet::XSheetOutline )
6861 57214 : SC_QUERYINTERFACE( util::XProtectable )
6862 57181 : SC_QUERYINTERFACE( sheet::XScenario )
6863 57181 : SC_QUERYINTERFACE( sheet::XScenarioEnhanced )
6864 57181 : SC_QUERYINTERFACE( sheet::XSheetLinkable )
6865 57146 : SC_QUERYINTERFACE( sheet::XExternalSheetName )
6866 57146 : SC_QUERYINTERFACE( document::XEventsSupplier )
6867 :
6868 57146 : return ScCellRangeObj::queryInterface( rType );
6869 : }
6870 :
6871 185914 : void SAL_CALL ScTableSheetObj::acquire() throw()
6872 : {
6873 185914 : ScCellRangeObj::acquire();
6874 185914 : }
6875 :
6876 185832 : void SAL_CALL ScTableSheetObj::release() throw()
6877 : {
6878 185832 : ScCellRangeObj::release();
6879 185832 : }
6880 :
6881 4 : uno::Sequence<uno::Type> SAL_CALL ScTableSheetObj::getTypes() throw(uno::RuntimeException, std::exception)
6882 : {
6883 4 : static uno::Sequence<uno::Type> aTypes;
6884 4 : if ( aTypes.getLength() == 0 )
6885 : {
6886 2 : uno::Sequence<uno::Type> aParentTypes = ScCellRangeObj::getTypes();
6887 2 : long nParentLen = aParentTypes.getLength();
6888 2 : const uno::Type* pParentPtr = aParentTypes.getConstArray();
6889 :
6890 2 : aTypes.realloc( nParentLen + 18 );
6891 2 : uno::Type* pPtr = aTypes.getArray();
6892 2 : pPtr[nParentLen + 0] = cppu::UnoType<sheet::XSpreadsheet>::get();
6893 2 : pPtr[nParentLen + 1] = cppu::UnoType<container::XNamed>::get();
6894 2 : pPtr[nParentLen + 2] = cppu::UnoType<sheet::XSheetPageBreak>::get();
6895 2 : pPtr[nParentLen + 3] = cppu::UnoType<sheet::XCellRangeMovement>::get();
6896 2 : pPtr[nParentLen + 4] = cppu::UnoType<table::XTableChartsSupplier>::get();
6897 2 : pPtr[nParentLen + 5] = cppu::UnoType<sheet::XDataPilotTablesSupplier>::get();
6898 2 : pPtr[nParentLen + 6] = cppu::UnoType<sheet::XScenariosSupplier>::get();
6899 2 : pPtr[nParentLen + 7] = cppu::UnoType<sheet::XSheetAnnotationsSupplier>::get();
6900 2 : pPtr[nParentLen + 8] = cppu::UnoType<drawing::XDrawPageSupplier>::get();
6901 2 : pPtr[nParentLen + 9] = cppu::UnoType<sheet::XPrintAreas>::get();
6902 2 : pPtr[nParentLen +10] = cppu::UnoType<sheet::XSheetAuditing>::get();
6903 2 : pPtr[nParentLen +11] = cppu::UnoType<sheet::XSheetOutline>::get();
6904 2 : pPtr[nParentLen +12] = cppu::UnoType<util::XProtectable>::get();
6905 2 : pPtr[nParentLen +13] = cppu::UnoType<sheet::XScenario>::get();
6906 2 : pPtr[nParentLen +14] = cppu::UnoType<sheet::XScenarioEnhanced>::get();
6907 2 : pPtr[nParentLen +15] = cppu::UnoType<sheet::XSheetLinkable>::get();
6908 2 : pPtr[nParentLen +16] = cppu::UnoType<sheet::XExternalSheetName>::get();
6909 2 : pPtr[nParentLen +17] = cppu::UnoType<document::XEventsSupplier>::get();
6910 :
6911 62 : for (long i=0; i<nParentLen; i++)
6912 62 : pPtr[i] = pParentPtr[i]; // parent types first
6913 : }
6914 4 : return aTypes;
6915 : }
6916 :
6917 0 : uno::Sequence<sal_Int8> SAL_CALL ScTableSheetObj::getImplementationId() throw(uno::RuntimeException, std::exception)
6918 : {
6919 0 : return css::uno::Sequence<sal_Int8>();
6920 : }
6921 :
6922 : // Hilfsfunktionen
6923 :
6924 8781 : SCTAB ScTableSheetObj::GetTab_Impl() const
6925 : {
6926 8781 : const ScRangeList& rRanges = GetRangeList();
6927 : OSL_ENSURE(rRanges.size() == 1, "was fuer Ranges ?!?!");
6928 8781 : if ( !rRanges.empty() )
6929 : {
6930 8781 : const ScRange* pFirst = rRanges[ 0 ];
6931 8781 : return pFirst->aStart.Tab();
6932 : }
6933 0 : return 0; // soll nicht sein
6934 : }
6935 :
6936 : // former XSheet
6937 :
6938 72 : uno::Reference<table::XTableCharts> SAL_CALL ScTableSheetObj::getCharts() throw(uno::RuntimeException, std::exception)
6939 : {
6940 72 : SolarMutexGuard aGuard;
6941 72 : ScDocShell* pDocSh = GetDocShell();
6942 72 : if ( pDocSh )
6943 72 : return new ScChartsObj( pDocSh, GetTab_Impl() );
6944 :
6945 : OSL_FAIL("kein Dokument");
6946 0 : return NULL;
6947 : }
6948 :
6949 48 : uno::Reference<sheet::XDataPilotTables> SAL_CALL ScTableSheetObj::getDataPilotTables()
6950 : throw(uno::RuntimeException, std::exception)
6951 : {
6952 48 : SolarMutexGuard aGuard;
6953 48 : ScDocShell* pDocSh = GetDocShell();
6954 48 : if ( pDocSh )
6955 48 : return new ScDataPilotTablesObj( pDocSh, GetTab_Impl() );
6956 :
6957 : OSL_FAIL("kein Dokument");
6958 0 : return NULL;
6959 : }
6960 :
6961 2 : uno::Reference<sheet::XScenarios> SAL_CALL ScTableSheetObj::getScenarios() throw(uno::RuntimeException, std::exception)
6962 : {
6963 2 : SolarMutexGuard aGuard;
6964 2 : ScDocShell* pDocSh = GetDocShell();
6965 :
6966 2 : if ( pDocSh )
6967 2 : return new ScScenariosObj( pDocSh, GetTab_Impl() );
6968 :
6969 : OSL_FAIL("kein Dokument");
6970 0 : return NULL;
6971 : }
6972 :
6973 13 : uno::Reference<sheet::XSheetAnnotations> SAL_CALL ScTableSheetObj::getAnnotations()
6974 : throw(uno::RuntimeException, std::exception)
6975 : {
6976 13 : SolarMutexGuard aGuard;
6977 13 : ScDocShell* pDocSh = GetDocShell();
6978 :
6979 13 : if ( pDocSh )
6980 13 : return new ScAnnotationsObj( pDocSh, GetTab_Impl() );
6981 :
6982 : OSL_FAIL("kein Dokument");
6983 0 : return NULL;
6984 : }
6985 :
6986 93 : uno::Reference<table::XCellRange> SAL_CALL ScTableSheetObj::getCellRangeByName(
6987 : const OUString& rRange ) throw(uno::RuntimeException, std::exception)
6988 : {
6989 93 : SolarMutexGuard aGuard;
6990 93 : return ScCellRangeObj::getCellRangeByName( rRange );
6991 : }
6992 :
6993 83 : uno::Reference<sheet::XSheetCellCursor> SAL_CALL ScTableSheetObj::createCursor()
6994 : throw(uno::RuntimeException, std::exception)
6995 : {
6996 83 : SolarMutexGuard aGuard;
6997 83 : ScDocShell* pDocSh = GetDocShell();
6998 83 : if ( pDocSh )
6999 : {
7000 : //! einzelne Zelle oder ganze Tabelle???????
7001 83 : SCTAB nTab = GetTab_Impl();
7002 83 : return new ScCellCursorObj( pDocSh, ScRange( 0,0,nTab, MAXCOL,MAXROW,nTab ) );
7003 : }
7004 0 : return NULL;
7005 : }
7006 :
7007 420 : uno::Reference<sheet::XSheetCellCursor> SAL_CALL ScTableSheetObj::createCursorByRange(
7008 : const uno::Reference<sheet::XSheetCellRange>& xCellRange )
7009 : throw(uno::RuntimeException, std::exception)
7010 : {
7011 420 : SolarMutexGuard aGuard;
7012 420 : ScDocShell* pDocSh = GetDocShell();
7013 420 : if ( pDocSh && xCellRange.is() )
7014 : {
7015 420 : ScCellRangesBase* pRangesImp = ScCellRangesBase::getImplementation( xCellRange );
7016 420 : if (pRangesImp)
7017 : {
7018 420 : const ScRangeList& rRanges = pRangesImp->GetRangeList();
7019 : OSL_ENSURE( rRanges.size() == 1, "Range? Ranges?" );
7020 420 : return new ScCellCursorObj( pDocSh, *rRanges[ 0 ] );
7021 : }
7022 : }
7023 0 : return NULL;
7024 : }
7025 :
7026 : // XSheetCellRange
7027 :
7028 1786 : uno::Reference<sheet::XSpreadsheet> SAL_CALL ScTableSheetObj::getSpreadsheet()
7029 : throw(uno::RuntimeException, std::exception)
7030 : {
7031 1786 : SolarMutexGuard aGuard;
7032 1786 : return this; //!???
7033 : }
7034 :
7035 : // XCellRange
7036 :
7037 6598 : uno::Reference<table::XCell> SAL_CALL ScTableSheetObj::getCellByPosition(
7038 : sal_Int32 nColumn, sal_Int32 nRow )
7039 : throw(lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
7040 : {
7041 6598 : SolarMutexGuard aGuard;
7042 6598 : return ScCellRangeObj::GetCellByPosition_Impl(nColumn, nRow);
7043 : }
7044 :
7045 7379 : uno::Reference<table::XCellRange> SAL_CALL ScTableSheetObj::getCellRangeByPosition(
7046 : sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom )
7047 : throw(lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
7048 : {
7049 7379 : SolarMutexGuard aGuard;
7050 7379 : return ScCellRangeObj::getCellRangeByPosition(nLeft,nTop,nRight,nBottom);
7051 : }
7052 :
7053 6 : uno::Sequence<sheet::TablePageBreakData> SAL_CALL ScTableSheetObj::getColumnPageBreaks()
7054 : throw(uno::RuntimeException, std::exception)
7055 : {
7056 6 : SolarMutexGuard aGuard;
7057 6 : ScDocShell* pDocSh = GetDocShell();
7058 6 : if ( pDocSh )
7059 : {
7060 6 : ScDocument& rDoc = pDocSh->GetDocument();
7061 6 : SCTAB nTab = GetTab_Impl();
7062 :
7063 6 : Size aSize(rDoc.GetPageSize( nTab ));
7064 6 : if (aSize.Width() && aSize.Height()) // effektive Groesse schon gesetzt?
7065 6 : rDoc.UpdatePageBreaks( nTab );
7066 : else
7067 : {
7068 : // Umbrueche updaten wie in ScDocShell::PageStyleModified:
7069 0 : ScPrintFunc aPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab );
7070 0 : aPrintFunc.UpdatePages();
7071 : }
7072 :
7073 6 : SCCOL nCount = 0;
7074 : SCCOL nCol;
7075 6150 : for (nCol=0; nCol<=MAXCOL; nCol++)
7076 6144 : if (rDoc.HasColBreak(nCol, nTab))
7077 16 : ++nCount;
7078 :
7079 6 : sheet::TablePageBreakData aData;
7080 6 : uno::Sequence<sheet::TablePageBreakData> aSeq(nCount);
7081 6 : sheet::TablePageBreakData* pAry = aSeq.getArray();
7082 6 : sal_uInt16 nPos = 0;
7083 6150 : for (nCol=0; nCol<=MAXCOL; nCol++)
7084 : {
7085 6144 : ScBreakType nBreak = rDoc.HasColBreak(nCol, nTab);
7086 6144 : if (nBreak)
7087 : {
7088 16 : aData.Position = nCol;
7089 16 : aData.ManualBreak = (nBreak & BREAK_MANUAL);
7090 16 : pAry[nPos] = aData;
7091 16 : ++nPos;
7092 : }
7093 : }
7094 6 : return aSeq;
7095 : }
7096 0 : return uno::Sequence<sheet::TablePageBreakData>(0);
7097 : }
7098 :
7099 6 : uno::Sequence<sheet::TablePageBreakData> SAL_CALL ScTableSheetObj::getRowPageBreaks()
7100 : throw(uno::RuntimeException, std::exception)
7101 : {
7102 6 : SolarMutexGuard aGuard;
7103 6 : ScDocShell* pDocSh = GetDocShell();
7104 6 : if ( pDocSh )
7105 : {
7106 6 : ScDocument& rDoc = pDocSh->GetDocument();
7107 6 : SCTAB nTab = GetTab_Impl();
7108 :
7109 6 : Size aSize(rDoc.GetPageSize( nTab ));
7110 6 : if (aSize.Width() && aSize.Height()) // effektive Groesse schon gesetzt?
7111 5 : rDoc.UpdatePageBreaks( nTab );
7112 : else
7113 : {
7114 : // Umbrueche updaten wie in ScDocShell::PageStyleModified:
7115 1 : ScPrintFunc aPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab );
7116 1 : aPrintFunc.UpdatePages();
7117 : }
7118 6 : return rDoc.GetRowBreakData(nTab);
7119 : }
7120 0 : return uno::Sequence<sheet::TablePageBreakData>(0);
7121 : }
7122 :
7123 0 : void SAL_CALL ScTableSheetObj::removeAllManualPageBreaks() throw(uno::RuntimeException, std::exception)
7124 : {
7125 0 : SolarMutexGuard aGuard;
7126 0 : ScDocShell* pDocSh = GetDocShell();
7127 0 : if ( pDocSh )
7128 : {
7129 : //! docfunc Funktion, auch fuer ScViewFunc::RemoveManualBreaks
7130 :
7131 0 : ScDocument& rDoc = pDocSh->GetDocument();
7132 0 : bool bUndo (rDoc.IsUndoEnabled());
7133 0 : SCTAB nTab = GetTab_Impl();
7134 :
7135 0 : if (bUndo)
7136 : {
7137 0 : ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
7138 0 : pUndoDoc->InitUndo( &rDoc, nTab, nTab, true, true );
7139 0 : rDoc.CopyToDocument( 0,0,nTab, MAXCOL,MAXROW,nTab, IDF_NONE, false, pUndoDoc );
7140 0 : pDocSh->GetUndoManager()->AddUndoAction(
7141 0 : new ScUndoRemoveBreaks( pDocSh, nTab, pUndoDoc ) );
7142 : }
7143 :
7144 0 : rDoc.RemoveManualBreaks(nTab);
7145 0 : rDoc.UpdatePageBreaks(nTab);
7146 :
7147 : //? UpdatePageBreakData( sal_True );
7148 0 : pDocSh->SetDocumentModified();
7149 0 : pDocSh->PostPaint(ScRange(0, 0, nTab, MAXCOL, MAXROW, nTab), PAINT_GRID);
7150 0 : }
7151 0 : }
7152 :
7153 : // XNamed
7154 :
7155 502 : OUString SAL_CALL ScTableSheetObj::getName() throw(uno::RuntimeException, std::exception)
7156 : {
7157 502 : SolarMutexGuard aGuard;
7158 502 : OUString aName;
7159 502 : ScDocShell* pDocSh = GetDocShell();
7160 502 : if ( pDocSh )
7161 502 : pDocSh->GetDocument().GetName( GetTab_Impl(), aName );
7162 502 : return aName;
7163 : }
7164 :
7165 15 : void SAL_CALL ScTableSheetObj::setName( const OUString& aNewName )
7166 : throw(uno::RuntimeException, std::exception)
7167 : {
7168 15 : SolarMutexGuard aGuard;
7169 15 : ScDocShell* pDocSh = GetDocShell();
7170 15 : if ( pDocSh )
7171 : {
7172 15 : OUString aString(aNewName);
7173 15 : pDocSh->GetDocFunc().RenameTable( GetTab_Impl(), aString, true, true );
7174 15 : }
7175 15 : }
7176 :
7177 : // XDrawPageSupplier
7178 :
7179 617 : uno::Reference<drawing::XDrawPage> SAL_CALL ScTableSheetObj::getDrawPage()
7180 : throw(uno::RuntimeException, std::exception)
7181 : {
7182 617 : SolarMutexGuard aGuard;
7183 617 : ScDocShell* pDocSh = GetDocShell();
7184 617 : if ( pDocSh )
7185 : {
7186 617 : ScDrawLayer* pDrawLayer = pDocSh->MakeDrawLayer();
7187 : OSL_ENSURE(pDrawLayer,"kann Draw-Layer nicht anlegen");
7188 :
7189 617 : SCTAB nTab = GetTab_Impl();
7190 617 : SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
7191 : OSL_ENSURE(pPage,"Draw-Page nicht gefunden");
7192 617 : if (pPage)
7193 617 : return uno::Reference<drawing::XDrawPage> (pPage->getUnoPage(), uno::UNO_QUERY);
7194 :
7195 : // Das DrawPage-Objekt meldet sich als Listener am SdrModel an
7196 : // und sollte von dort alle Aktionen mitbekommen
7197 : }
7198 0 : return NULL;
7199 : }
7200 :
7201 : // XCellMovement
7202 :
7203 1 : void SAL_CALL ScTableSheetObj::insertCells( const table::CellRangeAddress& rRangeAddress,
7204 : sheet::CellInsertMode nMode ) throw(uno::RuntimeException, std::exception)
7205 : {
7206 1 : SolarMutexGuard aGuard;
7207 1 : ScDocShell* pDocSh = GetDocShell();
7208 1 : if ( pDocSh )
7209 : {
7210 1 : bool bDo = true;
7211 1 : InsCellCmd eCmd = INS_NONE;
7212 1 : switch (nMode)
7213 : {
7214 0 : case sheet::CellInsertMode_NONE: bDo = false; break;
7215 0 : case sheet::CellInsertMode_DOWN: eCmd = INS_CELLSDOWN; break;
7216 1 : case sheet::CellInsertMode_RIGHT: eCmd = INS_CELLSRIGHT; break;
7217 0 : case sheet::CellInsertMode_ROWS: eCmd = INS_INSROWS_BEFORE; break;
7218 0 : case sheet::CellInsertMode_COLUMNS: eCmd = INS_INSCOLS_BEFORE; break;
7219 : default:
7220 : OSL_FAIL("insertCells: falscher Mode");
7221 0 : bDo = false;
7222 : }
7223 :
7224 1 : if (bDo)
7225 : {
7226 : OSL_ENSURE( rRangeAddress.Sheet == GetTab_Impl(), "falsche Tabelle in CellRangeAddress" );
7227 1 : ScRange aScRange;
7228 1 : ScUnoConversion::FillScRange( aScRange, rRangeAddress );
7229 1 : pDocSh->GetDocFunc().InsertCells( aScRange, NULL, eCmd, true, true );
7230 : }
7231 1 : }
7232 1 : }
7233 :
7234 3 : void SAL_CALL ScTableSheetObj::removeRange( const table::CellRangeAddress& rRangeAddress,
7235 : sheet::CellDeleteMode nMode ) throw(uno::RuntimeException, std::exception)
7236 : {
7237 3 : SolarMutexGuard aGuard;
7238 3 : ScDocShell* pDocSh = GetDocShell();
7239 3 : if ( pDocSh )
7240 : {
7241 3 : bool bDo = true;
7242 3 : DelCellCmd eCmd = DEL_NONE;
7243 3 : switch (nMode)
7244 : {
7245 0 : case sheet::CellDeleteMode_NONE: bDo = false; break;
7246 1 : case sheet::CellDeleteMode_UP: eCmd = DEL_CELLSUP; break;
7247 2 : case sheet::CellDeleteMode_LEFT: eCmd = DEL_CELLSLEFT; break;
7248 0 : case sheet::CellDeleteMode_ROWS: eCmd = DEL_DELROWS; break;
7249 0 : case sheet::CellDeleteMode_COLUMNS: eCmd = DEL_DELCOLS; break;
7250 : default:
7251 : OSL_FAIL("deleteCells: falscher Mode");
7252 0 : bDo = false;
7253 : }
7254 :
7255 3 : if (bDo)
7256 : {
7257 : OSL_ENSURE( rRangeAddress.Sheet == GetTab_Impl(), "falsche Tabelle in CellRangeAddress" );
7258 3 : ScRange aScRange;
7259 3 : ScUnoConversion::FillScRange( aScRange, rRangeAddress );
7260 3 : pDocSh->GetDocFunc().DeleteCells( aScRange, NULL, eCmd, true, true );
7261 : }
7262 3 : }
7263 3 : }
7264 :
7265 1 : void SAL_CALL ScTableSheetObj::moveRange( const table::CellAddress& aDestination,
7266 : const table::CellRangeAddress& aSource )
7267 : throw(uno::RuntimeException, std::exception)
7268 : {
7269 1 : SolarMutexGuard aGuard;
7270 1 : ScDocShell* pDocSh = GetDocShell();
7271 1 : if ( pDocSh )
7272 : {
7273 : OSL_ENSURE( aSource.Sheet == GetTab_Impl(), "falsche Tabelle in CellRangeAddress" );
7274 1 : ScRange aSourceRange;
7275 1 : ScUnoConversion::FillScRange( aSourceRange, aSource );
7276 1 : ScAddress aDestPos( (SCCOL)aDestination.Column, (SCROW)aDestination.Row, aDestination.Sheet );
7277 1 : pDocSh->GetDocFunc().MoveBlock( aSourceRange, aDestPos, true, true, true, true );
7278 1 : }
7279 1 : }
7280 :
7281 1 : void SAL_CALL ScTableSheetObj::copyRange( const table::CellAddress& aDestination,
7282 : const table::CellRangeAddress& aSource )
7283 : throw(uno::RuntimeException, std::exception)
7284 : {
7285 1 : SolarMutexGuard aGuard;
7286 1 : ScDocShell* pDocSh = GetDocShell();
7287 1 : if ( pDocSh )
7288 : {
7289 : OSL_ENSURE( aSource.Sheet == GetTab_Impl(), "falsche Tabelle in CellRangeAddress" );
7290 1 : ScRange aSourceRange;
7291 1 : ScUnoConversion::FillScRange( aSourceRange, aSource );
7292 1 : ScAddress aDestPos( (SCCOL)aDestination.Column, (SCROW)aDestination.Row, aDestination.Sheet );
7293 1 : pDocSh->GetDocFunc().MoveBlock( aSourceRange, aDestPos, false, true, true, true );
7294 1 : }
7295 1 : }
7296 :
7297 : // XPrintAreas
7298 :
7299 6 : void ScTableSheetObj::PrintAreaUndo_Impl( ScPrintRangeSaver* pOldRanges )
7300 : {
7301 : // Umbrueche und Undo
7302 6 : ScDocShell* pDocSh = GetDocShell();
7303 :
7304 6 : if(pDocSh)
7305 : {
7306 6 : ScDocument& rDoc = pDocSh->GetDocument();
7307 6 : const bool bUndo(rDoc.IsUndoEnabled());
7308 6 : const SCTAB nTab(GetTab_Impl());
7309 :
7310 6 : if(bUndo)
7311 : {
7312 2 : pDocSh->GetUndoManager()->AddUndoAction(
7313 : new ScUndoPrintRange(
7314 : pDocSh,
7315 : nTab,
7316 : pOldRanges,
7317 2 : rDoc.CreatePrintRangeSaver())); // create new ranges
7318 :
7319 : // #i120105# ownership of old ranges has changed, mark as consumed
7320 2 : pOldRanges = 0;
7321 : }
7322 :
7323 6 : ScPrintFunc(pDocSh, pDocSh->GetPrinter(), nTab).UpdatePages();
7324 6 : SfxBindings* pBindings = pDocSh->GetViewBindings();
7325 :
7326 6 : if(pBindings)
7327 : {
7328 2 : pBindings->Invalidate(SID_DELETE_PRINTAREA);
7329 : }
7330 :
7331 6 : pDocSh->SetDocumentModified();
7332 : }
7333 :
7334 : // #i120105# pOldRanges not used, need to cleanup
7335 6 : delete pOldRanges;
7336 6 : }
7337 :
7338 33 : uno::Sequence<table::CellRangeAddress> SAL_CALL ScTableSheetObj::getPrintAreas()
7339 : throw(uno::RuntimeException, std::exception)
7340 : {
7341 33 : SolarMutexGuard aGuard;
7342 33 : ScDocShell* pDocSh = GetDocShell();
7343 33 : if ( pDocSh )
7344 : {
7345 33 : ScDocument& rDoc = pDocSh->GetDocument();
7346 33 : SCTAB nTab = GetTab_Impl();
7347 33 : sal_uInt16 nCount = rDoc.GetPrintRangeCount( nTab );
7348 :
7349 33 : table::CellRangeAddress aRangeAddress;
7350 33 : uno::Sequence<table::CellRangeAddress> aSeq(nCount);
7351 33 : table::CellRangeAddress* pAry = aSeq.getArray();
7352 33 : for (sal_uInt16 i=0; i<nCount; i++)
7353 : {
7354 0 : const ScRange* pRange = rDoc.GetPrintRange( nTab, i );
7355 : OSL_ENSURE(pRange,"wo ist der Druckbereich");
7356 0 : if (pRange)
7357 : {
7358 0 : ScUnoConversion::FillApiRange( aRangeAddress, *pRange );
7359 0 : aRangeAddress.Sheet = nTab; // core does not care about sheet index
7360 0 : pAry[i] = aRangeAddress;
7361 : }
7362 : }
7363 33 : return aSeq;
7364 : }
7365 0 : return uno::Sequence<table::CellRangeAddress>();
7366 : }
7367 :
7368 0 : void SAL_CALL ScTableSheetObj::setPrintAreas(
7369 : const uno::Sequence<table::CellRangeAddress>& aPrintAreas )
7370 : throw(uno::RuntimeException, std::exception)
7371 : {
7372 0 : SolarMutexGuard aGuard;
7373 0 : ScDocShell* pDocSh = GetDocShell();
7374 0 : if ( pDocSh )
7375 : {
7376 0 : ScPrintRangeSaver* pOldRanges = NULL;
7377 0 : ScDocument& rDoc = pDocSh->GetDocument();
7378 0 : SCTAB nTab = GetTab_Impl();
7379 :
7380 0 : if ( rDoc.IsUndoEnabled() )
7381 0 : pOldRanges = rDoc.CreatePrintRangeSaver();
7382 :
7383 0 : sal_uInt16 nCount = (sal_uInt16) aPrintAreas.getLength();
7384 0 : rDoc.ClearPrintRanges( nTab );
7385 0 : if (nCount)
7386 : {
7387 0 : ScRange aPrintRange;
7388 0 : const table::CellRangeAddress* pAry = aPrintAreas.getConstArray();
7389 0 : for (sal_uInt16 i=0; i<nCount; i++)
7390 : {
7391 0 : ScUnoConversion::FillScRange( aPrintRange, pAry[i] );
7392 0 : rDoc.AddPrintRange( nTab, aPrintRange );
7393 : }
7394 : }
7395 :
7396 0 : if ( rDoc.IsUndoEnabled() )
7397 0 : PrintAreaUndo_Impl( pOldRanges ); // Undo, Umbrueche, Modified etc.
7398 0 : }
7399 0 : }
7400 :
7401 34 : sal_Bool SAL_CALL ScTableSheetObj::getPrintTitleColumns() throw(uno::RuntimeException, std::exception)
7402 : {
7403 34 : SolarMutexGuard aGuard;
7404 34 : ScDocShell* pDocSh = GetDocShell();
7405 34 : if ( pDocSh )
7406 : {
7407 34 : ScDocument& rDoc = pDocSh->GetDocument();
7408 34 : SCTAB nTab = GetTab_Impl();
7409 34 : return ( rDoc.GetRepeatColRange(nTab) != NULL );
7410 : }
7411 0 : return false;
7412 : }
7413 :
7414 1 : void SAL_CALL ScTableSheetObj::setPrintTitleColumns( sal_Bool bPrintTitleColumns )
7415 : throw(uno::RuntimeException, std::exception)
7416 : {
7417 1 : SolarMutexGuard aGuard;
7418 1 : ScDocShell* pDocSh = GetDocShell();
7419 1 : if ( pDocSh )
7420 : {
7421 1 : ScDocument& rDoc = pDocSh->GetDocument();
7422 1 : SCTAB nTab = GetTab_Impl();
7423 :
7424 1 : ScPrintRangeSaver* pOldRanges = rDoc.CreatePrintRangeSaver();
7425 :
7426 1 : if ( bPrintTitleColumns )
7427 : {
7428 1 : if ( !rDoc.GetRepeatColRange( nTab ) ) // keinen bestehenden Bereich veraendern
7429 : {
7430 1 : ScRange aNew( 0, 0, nTab, 0, 0, nTab ); // Default
7431 1 : rDoc.SetRepeatColRange( nTab, &aNew ); // einschalten
7432 : }
7433 : }
7434 : else
7435 0 : rDoc.SetRepeatColRange( nTab, NULL ); // abschalten
7436 :
7437 1 : PrintAreaUndo_Impl( pOldRanges ); // Undo, Umbrueche, Modified etc.
7438 :
7439 : //! zuletzt gesetzten Bereich beim Abschalten merken und beim Einschalten wiederherstellen ???
7440 1 : }
7441 1 : }
7442 :
7443 33 : table::CellRangeAddress SAL_CALL ScTableSheetObj::getTitleColumns() throw(uno::RuntimeException, std::exception)
7444 : {
7445 33 : SolarMutexGuard aGuard;
7446 33 : table::CellRangeAddress aRet;
7447 33 : ScDocShell* pDocSh = GetDocShell();
7448 33 : if ( pDocSh )
7449 : {
7450 33 : ScDocument& rDoc = pDocSh->GetDocument();
7451 33 : SCTAB nTab = GetTab_Impl();
7452 33 : const ScRange* pRange = rDoc.GetRepeatColRange(nTab);
7453 33 : if (pRange)
7454 : {
7455 0 : ScUnoConversion::FillApiRange( aRet, *pRange );
7456 0 : aRet.Sheet = nTab; // core does not care about sheet index
7457 : }
7458 : }
7459 33 : return aRet;
7460 : }
7461 :
7462 0 : void SAL_CALL ScTableSheetObj::setTitleColumns( const table::CellRangeAddress& aTitleColumns )
7463 : throw(uno::RuntimeException, std::exception)
7464 : {
7465 0 : SolarMutexGuard aGuard;
7466 0 : ScDocShell* pDocSh = GetDocShell();
7467 0 : if ( pDocSh )
7468 : {
7469 0 : ScDocument& rDoc = pDocSh->GetDocument();
7470 0 : SCTAB nTab = GetTab_Impl();
7471 :
7472 0 : ScPrintRangeSaver* pOldRanges = rDoc.CreatePrintRangeSaver();
7473 :
7474 0 : ScRange aNew;
7475 0 : ScUnoConversion::FillScRange( aNew, aTitleColumns );
7476 0 : rDoc.SetRepeatColRange( nTab, &aNew ); // immer auch einschalten
7477 :
7478 0 : PrintAreaUndo_Impl( pOldRanges ); // Undo, Umbrueche, Modified etc.
7479 0 : }
7480 0 : }
7481 :
7482 36 : sal_Bool SAL_CALL ScTableSheetObj::getPrintTitleRows() throw(uno::RuntimeException, std::exception)
7483 : {
7484 36 : SolarMutexGuard aGuard;
7485 36 : ScDocShell* pDocSh = GetDocShell();
7486 36 : if ( pDocSh )
7487 : {
7488 36 : ScDocument& rDoc = pDocSh->GetDocument();
7489 36 : SCTAB nTab = GetTab_Impl();
7490 36 : return ( rDoc.GetRepeatRowRange(nTab) != NULL );
7491 : }
7492 0 : return false;
7493 : }
7494 :
7495 3 : void SAL_CALL ScTableSheetObj::setPrintTitleRows( sal_Bool bPrintTitleRows )
7496 : throw(uno::RuntimeException, std::exception)
7497 : {
7498 3 : SolarMutexGuard aGuard;
7499 3 : ScDocShell* pDocSh = GetDocShell();
7500 3 : if ( pDocSh )
7501 : {
7502 3 : ScDocument& rDoc = pDocSh->GetDocument();
7503 3 : SCTAB nTab = GetTab_Impl();
7504 :
7505 3 : ScPrintRangeSaver* pOldRanges = rDoc.CreatePrintRangeSaver();
7506 :
7507 3 : if ( bPrintTitleRows )
7508 : {
7509 3 : if ( !rDoc.GetRepeatRowRange( nTab ) ) // keinen bestehenden Bereich veraendern
7510 : {
7511 3 : ScRange aNew( 0, 0, nTab, 0, 0, nTab ); // Default
7512 3 : rDoc.SetRepeatRowRange( nTab, &aNew ); // einschalten
7513 : }
7514 : }
7515 : else
7516 0 : rDoc.SetRepeatRowRange( nTab, NULL ); // abschalten
7517 :
7518 3 : PrintAreaUndo_Impl( pOldRanges ); // Undo, Umbrueche, Modified etc.
7519 :
7520 : //! zuletzt gesetzten Bereich beim Abschalten merken und beim Einschalten wiederherstellen ???
7521 3 : }
7522 3 : }
7523 :
7524 33 : table::CellRangeAddress SAL_CALL ScTableSheetObj::getTitleRows() throw(uno::RuntimeException, std::exception)
7525 : {
7526 33 : SolarMutexGuard aGuard;
7527 33 : table::CellRangeAddress aRet;
7528 33 : ScDocShell* pDocSh = GetDocShell();
7529 33 : if ( pDocSh )
7530 : {
7531 33 : ScDocument& rDoc = pDocSh->GetDocument();
7532 33 : SCTAB nTab = GetTab_Impl();
7533 33 : const ScRange* pRange = rDoc.GetRepeatRowRange(nTab);
7534 33 : if (pRange)
7535 : {
7536 0 : ScUnoConversion::FillApiRange( aRet, *pRange );
7537 0 : aRet.Sheet = nTab; // core does not care about sheet index
7538 : }
7539 : }
7540 33 : return aRet;
7541 : }
7542 :
7543 2 : void SAL_CALL ScTableSheetObj::setTitleRows( const table::CellRangeAddress& aTitleRows )
7544 : throw(uno::RuntimeException, std::exception)
7545 : {
7546 2 : SolarMutexGuard aGuard;
7547 2 : ScDocShell* pDocSh = GetDocShell();
7548 2 : if ( pDocSh )
7549 : {
7550 2 : ScDocument& rDoc = pDocSh->GetDocument();
7551 2 : SCTAB nTab = GetTab_Impl();
7552 :
7553 2 : ScPrintRangeSaver* pOldRanges = rDoc.CreatePrintRangeSaver();
7554 :
7555 2 : ScRange aNew;
7556 2 : ScUnoConversion::FillScRange( aNew, aTitleRows );
7557 2 : rDoc.SetRepeatRowRange( nTab, &aNew ); // immer auch einschalten
7558 :
7559 2 : PrintAreaUndo_Impl( pOldRanges ); // Undo, Umbrueche, Modified etc.
7560 2 : }
7561 2 : }
7562 :
7563 : // XSheetLinkable
7564 :
7565 33 : sheet::SheetLinkMode SAL_CALL ScTableSheetObj::getLinkMode() throw(uno::RuntimeException, std::exception)
7566 : {
7567 33 : SolarMutexGuard aGuard;
7568 33 : sheet::SheetLinkMode eRet = sheet::SheetLinkMode_NONE;
7569 33 : ScDocShell* pDocSh = GetDocShell();
7570 33 : if ( pDocSh )
7571 : {
7572 33 : sal_uInt8 nMode = pDocSh->GetDocument().GetLinkMode( GetTab_Impl() );
7573 33 : if ( nMode == SC_LINK_NORMAL )
7574 0 : eRet = sheet::SheetLinkMode_NORMAL;
7575 33 : else if ( nMode == SC_LINK_VALUE )
7576 0 : eRet = sheet::SheetLinkMode_VALUE;
7577 : }
7578 33 : return eRet;
7579 : }
7580 :
7581 0 : void SAL_CALL ScTableSheetObj::setLinkMode( sheet::SheetLinkMode nLinkMode )
7582 : throw(uno::RuntimeException, std::exception)
7583 : {
7584 0 : SolarMutexGuard aGuard;
7585 :
7586 : //! Filter und Options aus altem Link suchen
7587 :
7588 0 : OUString aUrl(getLinkUrl());
7589 0 : OUString aSheet(getLinkSheetName());
7590 :
7591 0 : OUString aEmpty;
7592 0 : link( aUrl, aSheet, aEmpty, aEmpty, nLinkMode );
7593 0 : }
7594 :
7595 0 : OUString SAL_CALL ScTableSheetObj::getLinkUrl() throw(uno::RuntimeException, std::exception)
7596 : {
7597 0 : SolarMutexGuard aGuard;
7598 0 : OUString aFile;
7599 0 : ScDocShell* pDocSh = GetDocShell();
7600 0 : if ( pDocSh )
7601 0 : aFile = pDocSh->GetDocument().GetLinkDoc( GetTab_Impl() );
7602 0 : return aFile;
7603 : }
7604 :
7605 0 : void SAL_CALL ScTableSheetObj::setLinkUrl( const OUString& aLinkUrl )
7606 : throw(uno::RuntimeException, std::exception)
7607 : {
7608 0 : SolarMutexGuard aGuard;
7609 :
7610 : //! Filter und Options aus altem Link suchen
7611 :
7612 0 : sheet::SheetLinkMode eMode = getLinkMode();
7613 0 : OUString aSheet(getLinkSheetName());
7614 :
7615 0 : OUString aEmpty;
7616 0 : link( aLinkUrl, aSheet, aEmpty, aEmpty, eMode );
7617 0 : }
7618 :
7619 0 : OUString SAL_CALL ScTableSheetObj::getLinkSheetName() throw(uno::RuntimeException, std::exception)
7620 : {
7621 0 : SolarMutexGuard aGuard;
7622 0 : OUString aSheet;
7623 0 : ScDocShell* pDocSh = GetDocShell();
7624 0 : if ( pDocSh )
7625 0 : aSheet = pDocSh->GetDocument().GetLinkTab( GetTab_Impl() );
7626 0 : return aSheet;
7627 : }
7628 :
7629 0 : void SAL_CALL ScTableSheetObj::setLinkSheetName( const OUString& aLinkSheetName )
7630 : throw(uno::RuntimeException, std::exception)
7631 : {
7632 0 : SolarMutexGuard aGuard;
7633 :
7634 : //! Filter und Options aus altem Link suchen
7635 :
7636 0 : sheet::SheetLinkMode eMode = getLinkMode();
7637 0 : OUString aUrl(getLinkUrl());
7638 :
7639 0 : OUString aEmpty;
7640 0 : link( aUrl, aLinkSheetName, aEmpty, aEmpty, eMode );
7641 0 : }
7642 :
7643 2 : void SAL_CALL ScTableSheetObj::link( const OUString& aUrl, const OUString& aSheetName,
7644 : const OUString& aFilterName, const OUString& aFilterOptions,
7645 : sheet::SheetLinkMode nMode ) throw(uno::RuntimeException, std::exception)
7646 : {
7647 2 : SolarMutexGuard aGuard;
7648 2 : ScDocShell* pDocSh = GetDocShell();
7649 2 : if ( pDocSh )
7650 : {
7651 2 : ScDocument& rDoc = pDocSh->GetDocument();
7652 2 : SCTAB nTab = GetTab_Impl();
7653 :
7654 2 : OUString aFileString = aUrl;
7655 4 : OUString aFilterString = aFilterName;
7656 4 : OUString aOptString = aFilterOptions;
7657 4 : OUString aSheetString = aSheetName;
7658 :
7659 2 : aFileString = ScGlobal::GetAbsDocName( aFileString, pDocSh );
7660 2 : if (aFilterString.isEmpty())
7661 2 : ScDocumentLoader::GetFilterName( aFileString, aFilterString, aOptString, true, false );
7662 :
7663 : // remove application prefix from filter name here, so the filter options
7664 : // aren't reset when the filter name is changed in ScTableLink::DataChanged
7665 2 : ScDocumentLoader::RemoveAppPrefix( aFilterString );
7666 :
7667 2 : sal_uInt8 nLinkMode = SC_LINK_NONE;
7668 2 : if ( nMode == sheet::SheetLinkMode_NORMAL )
7669 0 : nLinkMode = SC_LINK_NORMAL;
7670 2 : else if ( nMode == sheet::SheetLinkMode_VALUE )
7671 2 : nLinkMode = SC_LINK_VALUE;
7672 :
7673 2 : sal_uLong nRefresh = 0;
7674 2 : rDoc.SetLink( nTab, nLinkMode, aFileString, aFilterString, aOptString, aSheetString, nRefresh );
7675 :
7676 2 : pDocSh->UpdateLinks(); // ggf. Link eintragen oder loeschen
7677 2 : SfxBindings* pBindings = pDocSh->GetViewBindings();
7678 2 : if (pBindings)
7679 2 : pBindings->Invalidate(SID_LINKS);
7680 :
7681 : //! Undo fuer Link-Daten an der Table
7682 :
7683 2 : if ( nLinkMode != SC_LINK_NONE && rDoc.IsExecuteLinkEnabled() ) // Link updaten
7684 : {
7685 : // Update immer, auch wenn der Link schon da war
7686 : //! Update nur fuer die betroffene Tabelle???
7687 :
7688 2 : sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
7689 2 : sal_uInt16 nCount = pLinkManager->GetLinks().size();
7690 4 : for ( sal_uInt16 i=0; i<nCount; i++ )
7691 : {
7692 2 : ::sfx2::SvBaseLink* pBase = *pLinkManager->GetLinks()[i];
7693 2 : if (pBase->ISA(ScTableLink))
7694 : {
7695 2 : ScTableLink* pTabLink = static_cast<ScTableLink*>(pBase);
7696 2 : if ( aFileString.equals(pTabLink->GetFileName()) )
7697 2 : pTabLink->Update(); // inkl. Paint&Undo
7698 :
7699 : //! Der Dateiname sollte nur einmal vorkommen (?)
7700 : }
7701 : }
7702 2 : }
7703 :
7704 : //! Notify fuer ScSheetLinkObj Objekte!!!
7705 2 : }
7706 2 : }
7707 :
7708 : // XSheetAuditing
7709 :
7710 0 : sal_Bool SAL_CALL ScTableSheetObj::hideDependents( const table::CellAddress& aPosition )
7711 : throw(uno::RuntimeException, std::exception)
7712 : {
7713 0 : SolarMutexGuard aGuard;
7714 0 : ScDocShell* pDocSh = GetDocShell();
7715 0 : if ( pDocSh )
7716 : {
7717 0 : SCTAB nTab = GetTab_Impl();
7718 : OSL_ENSURE( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" );
7719 0 : ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab );
7720 0 : return pDocSh->GetDocFunc().DetectiveDelSucc( aPos );
7721 : }
7722 0 : return false;
7723 : }
7724 :
7725 0 : sal_Bool SAL_CALL ScTableSheetObj::hidePrecedents( const table::CellAddress& aPosition )
7726 : throw(uno::RuntimeException, std::exception)
7727 : {
7728 0 : SolarMutexGuard aGuard;
7729 0 : ScDocShell* pDocSh = GetDocShell();
7730 0 : if ( pDocSh )
7731 : {
7732 0 : SCTAB nTab = GetTab_Impl();
7733 : OSL_ENSURE( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" );
7734 0 : ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab );
7735 0 : return pDocSh->GetDocFunc().DetectiveDelPred( aPos );
7736 : }
7737 0 : return false;
7738 : }
7739 :
7740 0 : sal_Bool SAL_CALL ScTableSheetObj::showDependents( const table::CellAddress& aPosition )
7741 : throw(uno::RuntimeException, std::exception)
7742 : {
7743 0 : SolarMutexGuard aGuard;
7744 0 : ScDocShell* pDocSh = GetDocShell();
7745 0 : if ( pDocSh )
7746 : {
7747 0 : SCTAB nTab = GetTab_Impl();
7748 : OSL_ENSURE( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" );
7749 0 : ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab );
7750 0 : return pDocSh->GetDocFunc().DetectiveAddSucc( aPos );
7751 : }
7752 0 : return false;
7753 : }
7754 :
7755 1 : sal_Bool SAL_CALL ScTableSheetObj::showPrecedents( const table::CellAddress& aPosition )
7756 : throw(uno::RuntimeException, std::exception)
7757 : {
7758 1 : SolarMutexGuard aGuard;
7759 1 : ScDocShell* pDocSh = GetDocShell();
7760 1 : if ( pDocSh )
7761 : {
7762 1 : SCTAB nTab = GetTab_Impl();
7763 : OSL_ENSURE( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" );
7764 1 : ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab );
7765 1 : return pDocSh->GetDocFunc().DetectiveAddPred( aPos );
7766 : }
7767 0 : return false;
7768 : }
7769 :
7770 0 : sal_Bool SAL_CALL ScTableSheetObj::showErrors( const table::CellAddress& aPosition )
7771 : throw(uno::RuntimeException, std::exception)
7772 : {
7773 0 : SolarMutexGuard aGuard;
7774 0 : ScDocShell* pDocSh = GetDocShell();
7775 0 : if ( pDocSh )
7776 : {
7777 0 : SCTAB nTab = GetTab_Impl();
7778 : OSL_ENSURE( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" );
7779 0 : ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab );
7780 0 : return pDocSh->GetDocFunc().DetectiveAddError( aPos );
7781 : }
7782 0 : return false;
7783 : }
7784 :
7785 0 : sal_Bool SAL_CALL ScTableSheetObj::showInvalid() throw(uno::RuntimeException, std::exception)
7786 : {
7787 0 : SolarMutexGuard aGuard;
7788 0 : ScDocShell* pDocSh = GetDocShell();
7789 0 : if ( pDocSh )
7790 0 : return pDocSh->GetDocFunc().DetectiveMarkInvalid( GetTab_Impl() );
7791 0 : return false;
7792 : }
7793 :
7794 0 : void SAL_CALL ScTableSheetObj::clearArrows() throw(uno::RuntimeException, std::exception)
7795 : {
7796 0 : SolarMutexGuard aGuard;
7797 0 : ScDocShell* pDocSh = GetDocShell();
7798 0 : if ( pDocSh )
7799 0 : pDocSh->GetDocFunc().DetectiveDelAll( GetTab_Impl() );
7800 0 : }
7801 :
7802 : // XSheetOutline
7803 :
7804 8 : void SAL_CALL ScTableSheetObj::group( const table::CellRangeAddress& rGroupRange,
7805 : table::TableOrientation nOrientation )
7806 : throw (uno::RuntimeException,
7807 : std::exception)
7808 : {
7809 8 : SolarMutexGuard aGuard;
7810 8 : ScDocShell* pDocSh = GetDocShell();
7811 8 : if ( pDocSh )
7812 : {
7813 8 : bool bColumns = ( nOrientation == table::TableOrientation_COLUMNS );
7814 8 : ScRange aGroupRange;
7815 8 : ScUnoConversion::FillScRange( aGroupRange, rGroupRange );
7816 8 : ScOutlineDocFunc aFunc(*pDocSh);
7817 8 : aFunc.MakeOutline( aGroupRange, bColumns, true, true );
7818 8 : }
7819 8 : }
7820 :
7821 4 : void SAL_CALL ScTableSheetObj::ungroup( const table::CellRangeAddress& rGroupRange,
7822 : table::TableOrientation nOrientation )
7823 : throw (uno::RuntimeException,
7824 : std::exception)
7825 : {
7826 4 : SolarMutexGuard aGuard;
7827 4 : ScDocShell* pDocSh = GetDocShell();
7828 4 : if ( pDocSh )
7829 : {
7830 4 : bool bColumns = ( nOrientation == table::TableOrientation_COLUMNS );
7831 4 : ScRange aGroupRange;
7832 4 : ScUnoConversion::FillScRange( aGroupRange, rGroupRange );
7833 4 : ScOutlineDocFunc aFunc(*pDocSh);
7834 4 : aFunc.RemoveOutline( aGroupRange, bColumns, true, true );
7835 4 : }
7836 4 : }
7837 :
7838 1 : void SAL_CALL ScTableSheetObj::autoOutline( const table::CellRangeAddress& rCellRange )
7839 : throw(uno::RuntimeException, std::exception)
7840 : {
7841 1 : SolarMutexGuard aGuard;
7842 1 : ScDocShell* pDocSh = GetDocShell();
7843 1 : if ( pDocSh )
7844 : {
7845 1 : ScRange aFormulaRange;
7846 1 : ScUnoConversion::FillScRange( aFormulaRange, rCellRange );
7847 1 : ScOutlineDocFunc aFunc(*pDocSh);
7848 1 : aFunc.AutoOutline( aFormulaRange, true );
7849 1 : }
7850 1 : }
7851 :
7852 7 : void SAL_CALL ScTableSheetObj::clearOutline()
7853 : throw(uno::RuntimeException, std::exception)
7854 : {
7855 7 : SolarMutexGuard aGuard;
7856 7 : ScDocShell* pDocSh = GetDocShell();
7857 7 : if ( pDocSh )
7858 : {
7859 7 : SCTAB nTab = GetTab_Impl();
7860 7 : ScOutlineDocFunc aFunc(*pDocSh);
7861 7 : aFunc.RemoveAllOutlines( nTab, true );
7862 7 : }
7863 7 : }
7864 :
7865 13 : void SAL_CALL ScTableSheetObj::hideDetail( const table::CellRangeAddress& rCellRange )
7866 : throw(uno::RuntimeException, std::exception)
7867 : {
7868 13 : SolarMutexGuard aGuard;
7869 13 : ScDocShell* pDocSh = GetDocShell();
7870 13 : if ( pDocSh )
7871 : {
7872 13 : ScRange aMarkRange;
7873 13 : ScUnoConversion::FillScRange( aMarkRange, rCellRange );
7874 13 : ScOutlineDocFunc aFunc(*pDocSh);
7875 13 : aFunc.HideMarkedOutlines( aMarkRange, true );
7876 13 : }
7877 13 : }
7878 :
7879 10 : void SAL_CALL ScTableSheetObj::showDetail( const table::CellRangeAddress& rCellRange )
7880 : throw(uno::RuntimeException, std::exception)
7881 : {
7882 10 : SolarMutexGuard aGuard;
7883 10 : ScDocShell* pDocSh = GetDocShell();
7884 10 : if ( pDocSh )
7885 : {
7886 10 : ScRange aMarkRange;
7887 10 : ScUnoConversion::FillScRange( aMarkRange, rCellRange );
7888 10 : ScOutlineDocFunc aFunc(*pDocSh);
7889 10 : aFunc.ShowMarkedOutlines( aMarkRange, true );
7890 10 : }
7891 10 : }
7892 :
7893 1 : void SAL_CALL ScTableSheetObj::showLevel( sal_Int16 nLevel, table::TableOrientation nOrientation )
7894 : throw(uno::RuntimeException, std::exception)
7895 : {
7896 1 : SolarMutexGuard aGuard;
7897 1 : ScDocShell* pDocSh = GetDocShell();
7898 1 : if ( pDocSh )
7899 : {
7900 1 : bool bColumns = ( nOrientation == table::TableOrientation_COLUMNS );
7901 1 : SCTAB nTab = GetTab_Impl();
7902 1 : ScOutlineDocFunc aFunc(*pDocSh);
7903 1 : aFunc.SelectLevel( nTab, bColumns, nLevel, true, true );
7904 1 : }
7905 1 : }
7906 :
7907 : // XProtectable
7908 :
7909 0 : void SAL_CALL ScTableSheetObj::protect( const OUString& aPassword )
7910 : throw(uno::RuntimeException, std::exception)
7911 : {
7912 0 : SolarMutexGuard aGuard;
7913 0 : ScDocShell* pDocSh = GetDocShell();
7914 : // #i108245# if already protected, don't change anything
7915 0 : if ( pDocSh && !pDocSh->GetDocument().IsTabProtected( GetTab_Impl() ) )
7916 : {
7917 0 : OUString aString(aPassword);
7918 0 : pDocSh->GetDocFunc().Protect( GetTab_Impl(), aString, true );
7919 0 : }
7920 0 : }
7921 :
7922 0 : void SAL_CALL ScTableSheetObj::unprotect( const OUString& aPassword )
7923 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
7924 : {
7925 0 : SolarMutexGuard aGuard;
7926 0 : ScDocShell* pDocSh = GetDocShell();
7927 0 : if ( pDocSh )
7928 : {
7929 0 : OUString aString(aPassword);
7930 0 : bool bDone = pDocSh->GetDocFunc().Unprotect( GetTab_Impl(), aString, true );
7931 0 : if (!bDone)
7932 0 : throw lang::IllegalArgumentException();
7933 0 : }
7934 0 : }
7935 :
7936 33 : sal_Bool SAL_CALL ScTableSheetObj::isProtected() throw(uno::RuntimeException, std::exception)
7937 : {
7938 33 : SolarMutexGuard aGuard;
7939 33 : ScDocShell* pDocSh = GetDocShell();
7940 33 : if ( pDocSh )
7941 33 : return pDocSh->GetDocument().IsTabProtected( GetTab_Impl() );
7942 :
7943 : OSL_FAIL("keine DocShell"); //! Exception oder so?
7944 0 : return false;
7945 : }
7946 :
7947 : // XScenario
7948 :
7949 0 : sal_Bool SAL_CALL ScTableSheetObj::getIsScenario() throw(uno::RuntimeException, std::exception)
7950 : {
7951 0 : SolarMutexGuard aGuard;
7952 0 : ScDocShell* pDocSh = GetDocShell();
7953 0 : if ( pDocSh )
7954 0 : return pDocSh->GetDocument().IsScenario( GetTab_Impl() );
7955 :
7956 0 : return false;
7957 : }
7958 :
7959 0 : OUString SAL_CALL ScTableSheetObj::getScenarioComment() throw(uno::RuntimeException, std::exception)
7960 : {
7961 0 : SolarMutexGuard aGuard;
7962 0 : ScDocShell* pDocSh = GetDocShell();
7963 0 : if ( pDocSh )
7964 : {
7965 0 : OUString aComment;
7966 0 : Color aColor;
7967 : sal_uInt16 nFlags;
7968 0 : pDocSh->GetDocument().GetScenarioData( GetTab_Impl(), aComment, aColor, nFlags );
7969 0 : return aComment;
7970 : }
7971 0 : return OUString();
7972 : }
7973 :
7974 0 : void SAL_CALL ScTableSheetObj::setScenarioComment( const OUString& aScenarioComment )
7975 : throw(uno::RuntimeException, std::exception)
7976 : {
7977 0 : SolarMutexGuard aGuard;
7978 0 : ScDocShell* pDocSh = GetDocShell();
7979 0 : if ( pDocSh )
7980 : {
7981 0 : ScDocument& rDoc = pDocSh->GetDocument();
7982 0 : SCTAB nTab = GetTab_Impl();
7983 :
7984 0 : OUString aName;
7985 0 : OUString aComment;
7986 0 : Color aColor;
7987 : sal_uInt16 nFlags;
7988 0 : rDoc.GetName( nTab, aName );
7989 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
7990 :
7991 0 : aComment = aScenarioComment;
7992 :
7993 0 : pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
7994 0 : }
7995 0 : }
7996 :
7997 0 : void SAL_CALL ScTableSheetObj::addRanges( const uno::Sequence<table::CellRangeAddress>& rScenRanges )
7998 : throw(uno::RuntimeException, std::exception)
7999 : {
8000 0 : SolarMutexGuard aGuard;
8001 0 : ScDocShell* pDocSh = GetDocShell();
8002 0 : if ( pDocSh )
8003 : {
8004 0 : ScDocument& rDoc = pDocSh->GetDocument();
8005 0 : SCTAB nTab = GetTab_Impl();
8006 :
8007 0 : if (rDoc.IsScenario(nTab))
8008 : {
8009 0 : ScMarkData aMarkData;
8010 0 : aMarkData.SelectTable( nTab, true );
8011 :
8012 0 : sal_uInt16 nRangeCount = (sal_uInt16)rScenRanges.getLength();
8013 0 : if (nRangeCount)
8014 : {
8015 0 : const table::CellRangeAddress* pAry = rScenRanges.getConstArray();
8016 0 : for (sal_uInt16 i=0; i<nRangeCount; i++)
8017 : {
8018 : OSL_ENSURE( pAry[i].Sheet == nTab, "addRanges mit falscher Tab" );
8019 0 : ScRange aOneRange( (SCCOL)pAry[i].StartColumn, (SCROW)pAry[i].StartRow, nTab,
8020 0 : (SCCOL)pAry[i].EndColumn, (SCROW)pAry[i].EndRow, nTab );
8021 :
8022 0 : aMarkData.SetMultiMarkArea( aOneRange );
8023 : }
8024 : }
8025 :
8026 : // Szenario-Ranges sind durch Attribut gekennzeichnet
8027 0 : ScPatternAttr aPattern( rDoc.GetPool() );
8028 0 : aPattern.GetItemSet().Put( ScMergeFlagAttr( SC_MF_SCENARIO ) );
8029 0 : aPattern.GetItemSet().Put( ScProtectionAttr( true ) );
8030 0 : pDocSh->GetDocFunc().ApplyAttributes( aMarkData, aPattern, true, true );
8031 : }
8032 0 : }
8033 0 : }
8034 :
8035 0 : void SAL_CALL ScTableSheetObj::apply() throw(uno::RuntimeException, std::exception)
8036 : {
8037 0 : SolarMutexGuard aGuard;
8038 0 : ScDocShell* pDocSh = GetDocShell();
8039 0 : if ( pDocSh )
8040 : {
8041 0 : ScDocument& rDoc = pDocSh->GetDocument();
8042 0 : SCTAB nTab = GetTab_Impl();
8043 0 : OUString aName;
8044 0 : rDoc.GetName( nTab, aName ); // Name dieses Szenarios
8045 :
8046 0 : SCTAB nDestTab = nTab;
8047 0 : while ( nDestTab > 0 && rDoc.IsScenario(nDestTab) )
8048 0 : --nDestTab;
8049 :
8050 0 : if ( !rDoc.IsScenario(nDestTab) )
8051 0 : pDocSh->UseScenario( nDestTab, aName );
8052 :
8053 : //! sonst Fehler oder so
8054 0 : }
8055 0 : }
8056 :
8057 : // XScenarioEnhanced
8058 :
8059 0 : uno::Sequence< table::CellRangeAddress > SAL_CALL ScTableSheetObj::getRanges( )
8060 : throw(uno::RuntimeException, std::exception)
8061 : {
8062 0 : SolarMutexGuard aGuard;
8063 0 : ScDocShell* pDocSh = GetDocShell();
8064 0 : if ( pDocSh )
8065 : {
8066 0 : ScDocument& rDoc = pDocSh->GetDocument();
8067 0 : SCTAB nTab = GetTab_Impl();
8068 0 : const ScRangeList* pRangeList = rDoc.GetScenarioRanges(nTab);
8069 0 : if (pRangeList)
8070 : {
8071 0 : size_t nCount = pRangeList->size();
8072 0 : uno::Sequence< table::CellRangeAddress > aRetRanges( nCount );
8073 0 : table::CellRangeAddress* pAry = aRetRanges.getArray();
8074 0 : for( size_t nIndex = 0; nIndex < nCount; nIndex++ )
8075 : {
8076 0 : const ScRange* pRange = (*pRangeList)[nIndex];
8077 0 : pAry->StartColumn = pRange->aStart.Col();
8078 0 : pAry->StartRow = pRange->aStart.Row();
8079 0 : pAry->EndColumn = pRange->aEnd.Col();
8080 0 : pAry->EndRow = pRange->aEnd.Row();
8081 0 : pAry->Sheet = pRange->aStart.Tab();
8082 0 : ++pAry;
8083 : }
8084 0 : return aRetRanges;
8085 : }
8086 : }
8087 0 : return uno::Sequence< table::CellRangeAddress > ();
8088 : }
8089 :
8090 : // XExternalSheetName
8091 :
8092 0 : void ScTableSheetObj::setExternalName( const OUString& aUrl, const OUString& aSheetName )
8093 : throw (container::ElementExistException, uno::RuntimeException, std::exception)
8094 : {
8095 0 : SolarMutexGuard aGuard;
8096 0 : ScDocShell* pDocSh = GetDocShell();
8097 0 : if ( pDocSh )
8098 : {
8099 0 : ScDocument& rDoc = pDocSh->GetDocument();
8100 0 : const SCTAB nTab = GetTab_Impl();
8101 0 : const OUString aAbsDocName( ScGlobal::GetAbsDocName( aUrl, pDocSh ) );
8102 0 : const OUString aDocTabName( ScGlobal::GetDocTabName( aAbsDocName, aSheetName ) );
8103 0 : if ( !rDoc.RenameTab( nTab, aDocTabName, false /*bUpdateRef*/, true /*bExternalDocument*/ ) )
8104 : {
8105 0 : throw container::ElementExistException( OUString(), *this );
8106 0 : }
8107 0 : }
8108 0 : }
8109 :
8110 : // XEventsSupplier
8111 :
8112 0 : uno::Reference<container::XNameReplace> SAL_CALL ScTableSheetObj::getEvents() throw (uno::RuntimeException, std::exception)
8113 : {
8114 0 : SolarMutexGuard aGuard;
8115 0 : ScDocShell* pDocSh = GetDocShell();
8116 0 : if ( pDocSh )
8117 0 : return new ScSheetEventsObj( pDocSh, GetTab_Impl() );
8118 :
8119 0 : return NULL;
8120 : }
8121 :
8122 : // XPropertySet erweitert fuer Sheet-Properties
8123 :
8124 729 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTableSheetObj::getPropertySetInfo()
8125 : throw(uno::RuntimeException, std::exception)
8126 : {
8127 729 : SolarMutexGuard aGuard;
8128 : static uno::Reference<beans::XPropertySetInfo> aRef(
8129 729 : new SfxItemPropertySetInfo( pSheetPropSet->getPropertyMap() ));
8130 729 : return aRef;
8131 : }
8132 :
8133 1905 : void ScTableSheetObj::SetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue )
8134 : throw(lang::IllegalArgumentException, uno::RuntimeException,
8135 : std::exception)
8136 : {
8137 1905 : if ( pEntry )
8138 : {
8139 1905 : if ( IsScItemWid( pEntry->nWID ) )
8140 : {
8141 : // for Item WIDs, call ScCellRangesBase directly
8142 0 : ScCellRangesBase::SetOnePropertyValue(pEntry, aValue);
8143 0 : return;
8144 : }
8145 :
8146 : // own properties
8147 :
8148 1905 : ScDocShell* pDocSh = GetDocShell();
8149 1905 : if (!pDocSh)
8150 0 : return; //! Exception oder so?
8151 1905 : ScDocument& rDoc = pDocSh->GetDocument();
8152 1905 : SCTAB nTab = GetTab_Impl();
8153 1905 : ScDocFunc &rFunc = pDocSh->GetDocFunc();
8154 :
8155 1905 : if ( pEntry->nWID == SC_WID_UNO_PAGESTL )
8156 : {
8157 328 : OUString aStrVal;
8158 328 : aValue >>= aStrVal;
8159 : OUString aNewStr(ScStyleNameConversion::ProgrammaticToDisplayName(
8160 656 : aStrVal, SFX_STYLE_FAMILY_PAGE ));
8161 :
8162 : //! Undo? (auch bei SID_STYLE_APPLY an der View)
8163 :
8164 328 : if ( rDoc.GetPageStyle( nTab ) != aNewStr )
8165 : {
8166 41 : rDoc.SetPageStyle( nTab, aNewStr );
8167 41 : if (!rDoc.IsImportingXML())
8168 : {
8169 2 : ScPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab ).UpdatePages();
8170 :
8171 2 : SfxBindings* pBindings = pDocSh->GetViewBindings();
8172 2 : if (pBindings)
8173 : {
8174 2 : pBindings->Invalidate( SID_STYLE_FAMILY4 );
8175 2 : pBindings->Invalidate( SID_STATUS_PAGESTYLE );
8176 2 : pBindings->Invalidate( FID_RESET_PRINTZOOM );
8177 2 : pBindings->Invalidate( SID_ATTR_PARA_LEFT_TO_RIGHT );
8178 2 : pBindings->Invalidate( SID_ATTR_PARA_RIGHT_TO_LEFT );
8179 : }
8180 : }
8181 41 : pDocSh->SetDocumentModified();
8182 328 : }
8183 : }
8184 1577 : else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
8185 : {
8186 747 : bool bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8187 747 : rFunc.SetTableVisible( nTab, bVis, true );
8188 : }
8189 830 : else if ( pEntry->nWID == SC_WID_UNO_ISACTIVE )
8190 : {
8191 0 : if (rDoc.IsScenario(nTab))
8192 0 : rDoc.SetActiveScenario( nTab, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
8193 : }
8194 830 : else if ( pEntry->nWID == SC_WID_UNO_BORDCOL )
8195 : {
8196 0 : if (rDoc.IsScenario(nTab))
8197 : {
8198 0 : sal_Int32 nNewColor = 0;
8199 0 : if (aValue >>= nNewColor)
8200 : {
8201 0 : OUString aName;
8202 0 : OUString aComment;
8203 0 : Color aColor;
8204 : sal_uInt16 nFlags;
8205 0 : rDoc.GetName( nTab, aName );
8206 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8207 :
8208 0 : aColor = Color(static_cast<sal_uInt32>(nNewColor));
8209 :
8210 0 : pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
8211 : }
8212 : }
8213 : }
8214 830 : else if ( pEntry->nWID == SC_WID_UNO_PROTECT )
8215 : {
8216 0 : if (rDoc.IsScenario(nTab))
8217 : {
8218 0 : OUString aName;
8219 0 : OUString aComment;
8220 0 : Color aColor;
8221 : sal_uInt16 nFlags;
8222 0 : rDoc.GetName( nTab, aName );
8223 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8224 0 : bool bModify(false);
8225 :
8226 0 : if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
8227 : {
8228 0 : if (!(nFlags & SC_SCENARIO_PROTECT))
8229 : {
8230 0 : nFlags |= SC_SCENARIO_PROTECT;
8231 0 : bModify = true;
8232 : }
8233 : }
8234 : else
8235 : {
8236 0 : if (nFlags & SC_SCENARIO_PROTECT)
8237 : {
8238 0 : nFlags -= SC_SCENARIO_PROTECT;
8239 0 : bModify = true;
8240 : }
8241 : }
8242 :
8243 0 : if (bModify)
8244 0 : pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
8245 : }
8246 : }
8247 830 : else if ( pEntry->nWID == SC_WID_UNO_SHOWBORD )
8248 : {
8249 0 : if (rDoc.IsScenario(nTab))
8250 : {
8251 0 : OUString aName;
8252 0 : OUString aComment;
8253 0 : Color aColor;
8254 : sal_uInt16 nFlags;
8255 0 : rDoc.GetName( nTab, aName );
8256 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8257 0 : bool bModify(false);
8258 :
8259 0 : if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
8260 : {
8261 0 : if (!(nFlags & SC_SCENARIO_SHOWFRAME))
8262 : {
8263 0 : nFlags |= SC_SCENARIO_SHOWFRAME;
8264 0 : bModify = true;
8265 : }
8266 : }
8267 : else
8268 : {
8269 0 : if (nFlags & SC_SCENARIO_SHOWFRAME)
8270 : {
8271 0 : nFlags -= SC_SCENARIO_SHOWFRAME;
8272 0 : bModify = true;
8273 : }
8274 : }
8275 :
8276 0 : if (bModify)
8277 0 : pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
8278 : }
8279 : }
8280 830 : else if ( pEntry->nWID == SC_WID_UNO_PRINTBORD )
8281 : {
8282 0 : if (rDoc.IsScenario(nTab))
8283 : {
8284 0 : OUString aName;
8285 0 : OUString aComment;
8286 0 : Color aColor;
8287 : sal_uInt16 nFlags;
8288 0 : rDoc.GetName( nTab, aName );
8289 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8290 0 : bool bModify(false);
8291 :
8292 0 : if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
8293 : {
8294 0 : if (!(nFlags & SC_SCENARIO_PRINTFRAME))
8295 : {
8296 0 : nFlags |= SC_SCENARIO_PRINTFRAME;
8297 0 : bModify = true;
8298 : }
8299 : }
8300 : else
8301 : {
8302 0 : if (nFlags & SC_SCENARIO_PRINTFRAME)
8303 : {
8304 0 : nFlags -= SC_SCENARIO_PRINTFRAME;
8305 0 : bModify = true;
8306 : }
8307 : }
8308 :
8309 0 : if (bModify)
8310 0 : pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
8311 : }
8312 : }
8313 830 : else if ( pEntry->nWID == SC_WID_UNO_COPYBACK )
8314 : {
8315 0 : if (rDoc.IsScenario(nTab))
8316 : {
8317 0 : OUString aName;
8318 0 : OUString aComment;
8319 0 : Color aColor;
8320 : sal_uInt16 nFlags;
8321 0 : rDoc.GetName( nTab, aName );
8322 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8323 0 : bool bModify(false);
8324 :
8325 0 : if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
8326 : {
8327 0 : if (!(nFlags & SC_SCENARIO_TWOWAY))
8328 : {
8329 0 : nFlags |= SC_SCENARIO_TWOWAY;
8330 0 : bModify = true;
8331 : }
8332 : }
8333 : else
8334 : {
8335 0 : if (nFlags & SC_SCENARIO_TWOWAY)
8336 : {
8337 0 : nFlags -= SC_SCENARIO_TWOWAY;
8338 0 : bModify = true;
8339 : }
8340 : }
8341 :
8342 0 : if (bModify)
8343 0 : pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
8344 : }
8345 : }
8346 830 : else if ( pEntry->nWID == SC_WID_UNO_COPYSTYL )
8347 : {
8348 0 : if (rDoc.IsScenario(nTab))
8349 : {
8350 0 : OUString aName;
8351 0 : OUString aComment;
8352 0 : Color aColor;
8353 : sal_uInt16 nFlags;
8354 0 : rDoc.GetName( nTab, aName );
8355 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8356 0 : bool bModify(false);
8357 :
8358 0 : if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
8359 : {
8360 0 : if (!(nFlags & SC_SCENARIO_ATTRIB))
8361 : {
8362 0 : nFlags |= SC_SCENARIO_ATTRIB;
8363 0 : bModify = true;
8364 : }
8365 : }
8366 : else
8367 : {
8368 0 : if (nFlags & SC_SCENARIO_ATTRIB)
8369 : {
8370 0 : nFlags -= SC_SCENARIO_ATTRIB;
8371 0 : bModify = true;
8372 : }
8373 : }
8374 :
8375 0 : if (bModify)
8376 0 : pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
8377 : }
8378 : }
8379 830 : else if ( pEntry->nWID == SC_WID_UNO_COPYFORM )
8380 : {
8381 0 : if (rDoc.IsScenario(nTab))
8382 : {
8383 0 : OUString aName;
8384 0 : OUString aComment;
8385 0 : Color aColor;
8386 : sal_uInt16 nFlags;
8387 0 : rDoc.GetName( nTab, aName );
8388 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8389 0 : bool bModify(false);
8390 :
8391 0 : if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
8392 : {
8393 0 : if (nFlags & SC_SCENARIO_VALUE)
8394 : {
8395 0 : nFlags -= SC_SCENARIO_VALUE;
8396 0 : bModify = true;
8397 : }
8398 : }
8399 : else
8400 : {
8401 0 : if (!(nFlags & SC_SCENARIO_VALUE))
8402 : {
8403 0 : nFlags |= SC_SCENARIO_VALUE;
8404 0 : bModify = true;
8405 : }
8406 : }
8407 :
8408 0 : if (bModify)
8409 0 : pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags );
8410 : }
8411 : }
8412 830 : else if ( pEntry->nWID == SC_WID_UNO_TABLAYOUT )
8413 : {
8414 291 : sal_Int16 nValue = 0;
8415 291 : if (aValue >>= nValue)
8416 : {
8417 291 : if (nValue == com::sun::star::text::WritingMode2::RL_TB)
8418 2 : rFunc.SetLayoutRTL(nTab, true, true);
8419 : else
8420 289 : rFunc.SetLayoutRTL(nTab, false, true);
8421 : }
8422 : }
8423 539 : else if ( pEntry->nWID == SC_WID_UNO_AUTOPRINT )
8424 : {
8425 0 : bool bAutoPrint = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8426 0 : if (bAutoPrint)
8427 0 : rDoc.SetPrintEntireSheet( nTab ); // clears all print ranges
8428 : else
8429 : {
8430 0 : if (rDoc.IsPrintEntireSheet( nTab ))
8431 0 : rDoc.ClearPrintRanges( nTab ); // if this flag is true, there are no PrintRanges, so Clear clears only the flag.
8432 : }
8433 : }
8434 539 : else if ( pEntry->nWID == SC_WID_UNO_TABCOLOR )
8435 : {
8436 268 : sal_Int32 nColor = COL_AUTO;
8437 268 : if ( aValue >>= nColor )
8438 : {
8439 268 : const Color aColor( static_cast< ColorData >( nColor ) );
8440 268 : if ( rDoc.GetTabBgColor( nTab ) != aColor )
8441 20 : rFunc.SetTabBgColor( nTab, aColor, true, true );
8442 : }
8443 : }
8444 271 : else if ( pEntry->nWID == SC_WID_UNO_CODENAME )
8445 : {
8446 269 : OUString aCodeName;
8447 269 : if ( pDocSh && ( aValue >>= aCodeName ) )
8448 : {
8449 269 : pDocSh->GetDocument().SetCodeName( GetTab_Impl(), aCodeName );
8450 269 : }
8451 : }
8452 2 : else if (pEntry->nWID == SC_WID_UNO_CONDFORMAT)
8453 : {
8454 0 : uno::Reference<sheet::XConditionalFormats> xCondFormat;
8455 0 : if (aValue >>= xCondFormat)
8456 : {
8457 : // how to set the format correctly
8458 0 : }
8459 : }
8460 : else
8461 2 : ScCellRangeObj::SetOnePropertyValue(pEntry, aValue); // base class, no Item WID
8462 : }
8463 : }
8464 :
8465 2605 : void ScTableSheetObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry,
8466 : uno::Any& rAny )
8467 : throw(uno::RuntimeException,
8468 : std::exception)
8469 : {
8470 2605 : if ( pEntry )
8471 : {
8472 2605 : ScDocShell* pDocSh = GetDocShell();
8473 2605 : if (!pDocSh)
8474 0 : throw uno::RuntimeException();
8475 2605 : ScDocument& rDoc = pDocSh->GetDocument();
8476 2605 : SCTAB nTab = GetTab_Impl();
8477 :
8478 2605 : if ( pEntry->nWID == SC_WID_UNO_NAMES )
8479 : {
8480 0 : rAny <<= uno::Reference<sheet::XNamedRanges>(new ScLocalNamedRangesObj(pDocSh, this));
8481 : }
8482 2605 : else if ( pEntry->nWID == SC_WID_UNO_PAGESTL )
8483 : {
8484 186 : rAny <<= OUString( ScStyleNameConversion::DisplayToProgrammaticName(
8485 93 : rDoc.GetPageStyle( nTab ), SFX_STYLE_FAMILY_PAGE ) );
8486 : }
8487 2512 : else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
8488 : {
8489 46 : bool bVis = rDoc.IsVisible( nTab );
8490 46 : ScUnoHelpFunctions::SetBoolInAny( rAny, bVis );
8491 : }
8492 2466 : else if ( pEntry->nWID == SC_WID_UNO_LINKDISPBIT )
8493 : {
8494 : // no target bitmaps for individual entries (would be all equal)
8495 : // ScLinkTargetTypeObj::SetLinkTargetBitmap( aAny, SC_LINKTARGETTYPE_SHEET );
8496 : }
8497 2466 : else if ( pEntry->nWID == SC_WID_UNO_LINKDISPNAME )
8498 : {
8499 : // LinkDisplayName for hyperlink dialog
8500 0 : rAny <<= getName(); // sheet name
8501 : }
8502 2466 : else if ( pEntry->nWID == SC_WID_UNO_ISACTIVE )
8503 : {
8504 0 : if (rDoc.IsScenario(nTab))
8505 0 : ScUnoHelpFunctions::SetBoolInAny( rAny, rDoc.IsActiveScenario( nTab ));
8506 : }
8507 2466 : else if ( pEntry->nWID == SC_WID_UNO_BORDCOL )
8508 : {
8509 0 : if (rDoc.IsScenario(nTab))
8510 : {
8511 0 : OUString aComment;
8512 0 : Color aColor;
8513 : sal_uInt16 nFlags;
8514 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8515 :
8516 0 : rAny <<= static_cast<sal_Int32>(aColor.GetColor());
8517 : }
8518 : }
8519 2466 : else if ( pEntry->nWID == SC_WID_UNO_PROTECT )
8520 : {
8521 0 : if (rDoc.IsScenario(nTab))
8522 : {
8523 0 : OUString aComment;
8524 0 : Color aColor;
8525 : sal_uInt16 nFlags;
8526 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8527 :
8528 0 : ScUnoHelpFunctions::SetBoolInAny( rAny, (nFlags & SC_SCENARIO_PROTECT) != 0 );
8529 : }
8530 : }
8531 2466 : else if ( pEntry->nWID == SC_WID_UNO_SHOWBORD )
8532 : {
8533 0 : if (rDoc.IsScenario(nTab))
8534 : {
8535 0 : OUString aComment;
8536 0 : Color aColor;
8537 : sal_uInt16 nFlags;
8538 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8539 :
8540 0 : ScUnoHelpFunctions::SetBoolInAny( rAny, (nFlags & SC_SCENARIO_SHOWFRAME) != 0 );
8541 : }
8542 : }
8543 2466 : else if ( pEntry->nWID == SC_WID_UNO_PRINTBORD )
8544 : {
8545 0 : if (rDoc.IsScenario(nTab))
8546 : {
8547 0 : OUString aComment;
8548 0 : Color aColor;
8549 : sal_uInt16 nFlags;
8550 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8551 :
8552 0 : ScUnoHelpFunctions::SetBoolInAny( rAny, (nFlags & SC_SCENARIO_PRINTFRAME) != 0 );
8553 : }
8554 : }
8555 2466 : else if ( pEntry->nWID == SC_WID_UNO_COPYBACK )
8556 : {
8557 0 : if (rDoc.IsScenario(nTab))
8558 : {
8559 0 : OUString aComment;
8560 0 : Color aColor;
8561 : sal_uInt16 nFlags;
8562 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8563 :
8564 0 : ScUnoHelpFunctions::SetBoolInAny( rAny, (nFlags & SC_SCENARIO_TWOWAY) != 0 );
8565 : }
8566 : }
8567 2466 : else if ( pEntry->nWID == SC_WID_UNO_COPYSTYL )
8568 : {
8569 0 : if (rDoc.IsScenario(nTab))
8570 : {
8571 0 : OUString aComment;
8572 0 : Color aColor;
8573 : sal_uInt16 nFlags;
8574 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8575 :
8576 0 : ScUnoHelpFunctions::SetBoolInAny( rAny, (nFlags & SC_SCENARIO_ATTRIB) != 0 );
8577 : }
8578 : }
8579 2466 : else if ( pEntry->nWID == SC_WID_UNO_COPYFORM )
8580 : {
8581 0 : if (rDoc.IsScenario(nTab))
8582 : {
8583 0 : OUString aComment;
8584 0 : Color aColor;
8585 : sal_uInt16 nFlags;
8586 0 : rDoc.GetScenarioData( nTab, aComment, aColor, nFlags );
8587 :
8588 0 : ScUnoHelpFunctions::SetBoolInAny( rAny, !(nFlags & SC_SCENARIO_VALUE));
8589 : }
8590 : }
8591 2466 : else if ( pEntry->nWID == SC_WID_UNO_TABLAYOUT )
8592 : {
8593 41 : if (rDoc.IsLayoutRTL(nTab))
8594 4 : rAny <<= sal_Int16(com::sun::star::text::WritingMode2::RL_TB);
8595 : else
8596 37 : rAny <<= sal_Int16(com::sun::star::text::WritingMode2::LR_TB);
8597 : }
8598 2425 : else if ( pEntry->nWID == SC_WID_UNO_AUTOPRINT )
8599 : {
8600 0 : bool bAutoPrint = rDoc.IsPrintEntireSheet( nTab );
8601 0 : ScUnoHelpFunctions::SetBoolInAny( rAny, bAutoPrint );
8602 : }
8603 2425 : else if ( pEntry->nWID == SC_WID_UNO_TABCOLOR )
8604 : {
8605 33 : rAny <<= sal_Int32(rDoc.GetTabBgColor(nTab).GetColor());
8606 : }
8607 2392 : else if ( pEntry->nWID == SC_WID_UNO_CODENAME )
8608 : {
8609 2380 : OUString aCodeName;
8610 2380 : if ( pDocSh )
8611 2380 : pDocSh->GetDocument().GetCodeName( GetTab_Impl(), aCodeName );
8612 2380 : rAny <<= OUString( aCodeName );
8613 : }
8614 12 : else if (pEntry->nWID == SC_WID_UNO_CONDFORMAT)
8615 : {
8616 7 : rAny <<= uno::Reference<sheet::XConditionalFormats>(new ScCondFormatsObj(pDocSh, nTab));
8617 : }
8618 : else
8619 5 : ScCellRangeObj::GetOnePropertyValue(pEntry, rAny);
8620 : }
8621 2605 : }
8622 :
8623 3796 : const SfxItemPropertyMap& ScTableSheetObj::GetItemPropertyMap()
8624 : {
8625 3796 : return pSheetPropSet->getPropertyMap();
8626 : }
8627 :
8628 : // XServiceInfo
8629 :
8630 0 : OUString SAL_CALL ScTableSheetObj::getImplementationName() throw(uno::RuntimeException, std::exception)
8631 : {
8632 0 : return OUString( "ScTableSheetObj" );
8633 : }
8634 :
8635 0 : sal_Bool SAL_CALL ScTableSheetObj::supportsService( const OUString& rServiceName )
8636 : throw(uno::RuntimeException, std::exception)
8637 : {
8638 0 : return cppu::supportsService(this, rServiceName);
8639 : }
8640 :
8641 0 : uno::Sequence<OUString> SAL_CALL ScTableSheetObj::getSupportedServiceNames()
8642 : throw(uno::RuntimeException, std::exception)
8643 : {
8644 0 : uno::Sequence<OUString> aRet(7);
8645 0 : OUString* pArray = aRet.getArray();
8646 0 : pArray[0] = SCSPREADSHEET_SERVICE;
8647 0 : pArray[1] = SCSHEETCELLRANGE_SERVICE;
8648 0 : pArray[2] = SCCELLRANGE_SERVICE;
8649 0 : pArray[3] = SCCELLPROPERTIES_SERVICE;
8650 0 : pArray[4] = SCCHARPROPERTIES_SERVICE;
8651 0 : pArray[5] = SCPARAPROPERTIES_SERVICE;
8652 0 : pArray[6] = SCLINKTARGET_SERVICE;
8653 0 : return aRet;
8654 : }
8655 :
8656 : // XUnoTunnel
8657 :
8658 4598 : sal_Int64 SAL_CALL ScTableSheetObj::getSomething(
8659 : const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
8660 : {
8661 9196 : if ( rId.getLength() == 16 &&
8662 4598 : 0 == memcmp( getUnoTunnelId().getConstArray(),
8663 9196 : rId.getConstArray(), 16 ) )
8664 : {
8665 245 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
8666 : }
8667 :
8668 4353 : return ScCellRangeObj::getSomething( rId );
8669 : }
8670 :
8671 : namespace
8672 : {
8673 : class theScTableSheetObjUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScTableSheetObjUnoTunnelId> {};
8674 : }
8675 :
8676 6219 : const uno::Sequence<sal_Int8>& ScTableSheetObj::getUnoTunnelId()
8677 : {
8678 6219 : return theScTableSheetObjUnoTunnelId::get().getSeq();
8679 : }
8680 :
8681 1621 : ScTableSheetObj* ScTableSheetObj::getImplementation(const uno::Reference<uno::XInterface>& rObj)
8682 : {
8683 1621 : ScTableSheetObj* pRet = NULL;
8684 1621 : uno::Reference<lang::XUnoTunnel> xUT(rObj, uno::UNO_QUERY);
8685 1621 : if (xUT.is())
8686 1621 : pRet = reinterpret_cast<ScTableSheetObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
8687 1621 : return pRet;
8688 : }
8689 :
8690 1099 : ScTableColumnObj::ScTableColumnObj( ScDocShell* pDocSh, SCCOL nCol, SCTAB nTab ) :
8691 : ScCellRangeObj( pDocSh, ScRange(nCol,0,nTab, nCol,MAXROW,nTab) ),
8692 1099 : pColPropSet(lcl_GetColumnPropertySet())
8693 : {
8694 1099 : }
8695 :
8696 2198 : ScTableColumnObj::~ScTableColumnObj()
8697 : {
8698 2198 : }
8699 :
8700 2333 : uno::Any SAL_CALL ScTableColumnObj::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException, std::exception)
8701 : {
8702 2333 : SC_QUERYINTERFACE( container::XNamed )
8703 :
8704 2333 : return ScCellRangeObj::queryInterface( rType );
8705 : }
8706 :
8707 10133 : void SAL_CALL ScTableColumnObj::acquire() throw()
8708 : {
8709 10133 : ScCellRangeObj::acquire();
8710 10133 : }
8711 :
8712 10133 : void SAL_CALL ScTableColumnObj::release() throw()
8713 : {
8714 10133 : ScCellRangeObj::release();
8715 10133 : }
8716 :
8717 0 : uno::Sequence<uno::Type> SAL_CALL ScTableColumnObj::getTypes() throw(uno::RuntimeException, std::exception)
8718 : {
8719 0 : static uno::Sequence<uno::Type> aTypes;
8720 0 : if ( aTypes.getLength() == 0 )
8721 : {
8722 0 : uno::Sequence<uno::Type> aParentTypes(ScCellRangeObj::getTypes());
8723 0 : long nParentLen = aParentTypes.getLength();
8724 0 : const uno::Type* pParentPtr = aParentTypes.getConstArray();
8725 :
8726 0 : aTypes.realloc( nParentLen + 1 );
8727 0 : uno::Type* pPtr = aTypes.getArray();
8728 0 : pPtr[nParentLen + 0] = cppu::UnoType<container::XNamed>::get();
8729 :
8730 0 : for (long i=0; i<nParentLen; i++)
8731 0 : pPtr[i] = pParentPtr[i]; // parent types first
8732 : }
8733 0 : return aTypes;
8734 : }
8735 :
8736 0 : uno::Sequence<sal_Int8> SAL_CALL ScTableColumnObj::getImplementationId() throw(uno::RuntimeException, std::exception)
8737 : {
8738 0 : return css::uno::Sequence<sal_Int8>();
8739 : }
8740 :
8741 : // XNamed
8742 :
8743 0 : OUString SAL_CALL ScTableColumnObj::getName() throw(uno::RuntimeException, std::exception)
8744 : {
8745 0 : SolarMutexGuard aGuard;
8746 :
8747 0 : const ScRange& rRange = GetRange();
8748 : OSL_ENSURE(rRange.aStart.Col() == rRange.aEnd.Col(), "too many columns");
8749 0 : SCCOL nCol = rRange.aStart.Col();
8750 :
8751 0 : return ScColToAlpha( nCol ); // from global.hxx
8752 : }
8753 :
8754 0 : void SAL_CALL ScTableColumnObj::setName( const OUString& /* aNewName */ )
8755 : throw(uno::RuntimeException, std::exception)
8756 : {
8757 0 : SolarMutexGuard aGuard;
8758 0 : throw uno::RuntimeException(); // read-only
8759 : }
8760 :
8761 : // XPropertySet erweitert fuer Spalten-Properties
8762 :
8763 40 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTableColumnObj::getPropertySetInfo()
8764 : throw(uno::RuntimeException, std::exception)
8765 : {
8766 40 : SolarMutexGuard aGuard;
8767 : static uno::Reference<beans::XPropertySetInfo> aRef(
8768 40 : new SfxItemPropertySetInfo( pColPropSet->getPropertyMap() ));
8769 40 : return aRef;
8770 : }
8771 :
8772 4 : void ScTableColumnObj::SetOnePropertyValue(const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue)
8773 : throw(lang::IllegalArgumentException, uno::RuntimeException,
8774 : std::exception)
8775 : {
8776 4 : if ( pEntry )
8777 : {
8778 4 : if ( IsScItemWid( pEntry->nWID ) )
8779 : {
8780 : // for Item WIDs, call ScCellRangesBase directly
8781 0 : ScCellRangesBase::SetOnePropertyValue(pEntry, aValue);
8782 0 : return;
8783 : }
8784 :
8785 : // own properties
8786 :
8787 4 : ScDocShell* pDocSh = GetDocShell();
8788 4 : if (!pDocSh)
8789 0 : return; //! Exception oder so?
8790 4 : const ScRange& rRange = GetRange();
8791 : OSL_ENSURE(rRange.aStart.Col() == rRange.aEnd.Col(), "zuviele Spalten");
8792 4 : SCCOL nCol = rRange.aStart.Col();
8793 4 : SCTAB nTab = rRange.aStart.Tab();
8794 4 : ScDocFunc &rFunc = pDocSh->GetDocFunc();
8795 :
8796 4 : std::vector<sc::ColRowSpan> aColArr(1, sc::ColRowSpan(nCol,nCol));
8797 :
8798 4 : if ( pEntry->nWID == SC_WID_UNO_CELLWID )
8799 : {
8800 0 : sal_Int32 nNewWidth = 0;
8801 0 : if ( aValue >>= nNewWidth )
8802 : {
8803 : // property is 1/100mm, column width is twips
8804 0 : nNewWidth = HMMToTwips(nNewWidth);
8805 : rFunc.SetWidthOrHeight(
8806 0 : true, aColArr, nTab, SC_SIZE_ORIGINAL, (sal_uInt16)nNewWidth, true, true);
8807 : }
8808 : }
8809 4 : else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
8810 : {
8811 0 : bool bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8812 0 : ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT;
8813 0 : rFunc.SetWidthOrHeight(true, aColArr, nTab, eMode, 0, true, true);
8814 : // SC_SIZE_DIRECT mit Groesse 0 blendet aus
8815 : }
8816 4 : else if ( pEntry->nWID == SC_WID_UNO_OWIDTH )
8817 : {
8818 2 : bool bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8819 2 : if (bOpt)
8820 : rFunc.SetWidthOrHeight(
8821 2 : true, aColArr, nTab, SC_SIZE_OPTIMAL, STD_EXTRA_WIDTH, true, true);
8822 : // sal_False bei Spalten momentan ohne Auswirkung
8823 : }
8824 2 : else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE || pEntry->nWID == SC_WID_UNO_MANPAGE )
8825 : {
8826 2 : bool bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8827 2 : if (bSet)
8828 1 : rFunc.InsertPageBreak( true, rRange.aStart, true, true, true );
8829 : else
8830 1 : rFunc.RemovePageBreak( true, rRange.aStart, true, true, true );
8831 : }
8832 : else
8833 0 : ScCellRangeObj::SetOnePropertyValue(pEntry, aValue); // base class, no Item WID
8834 : }
8835 : }
8836 :
8837 122 : void ScTableColumnObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, uno::Any& rAny )
8838 : throw(uno::RuntimeException, std::exception)
8839 : {
8840 122 : if ( pEntry )
8841 : {
8842 122 : ScDocShell* pDocSh = GetDocShell();
8843 122 : if (!pDocSh)
8844 0 : throw uno::RuntimeException();
8845 :
8846 122 : ScDocument& rDoc = pDocSh->GetDocument();
8847 122 : const ScRange& rRange = GetRange();
8848 : OSL_ENSURE(rRange.aStart.Col() == rRange.aEnd.Col(), "zuviele Spalten");
8849 122 : SCCOL nCol = rRange.aStart.Col();
8850 122 : SCTAB nTab = rRange.aStart.Tab();
8851 :
8852 122 : if ( pEntry->nWID == SC_WID_UNO_CELLWID )
8853 : {
8854 : // for hidden column, return original height
8855 40 : sal_uInt16 nWidth = rDoc.GetOriginalWidth( nCol, nTab );
8856 : // property is 1/100mm, column width is twips
8857 40 : nWidth = (sal_uInt16) TwipsToHMM(nWidth);
8858 40 : rAny <<= (sal_Int32)( nWidth );
8859 : }
8860 82 : else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
8861 : {
8862 40 : bool bHidden = rDoc.ColHidden(nCol, nTab);
8863 40 : ScUnoHelpFunctions::SetBoolInAny( rAny, !bHidden );
8864 : }
8865 42 : else if ( pEntry->nWID == SC_WID_UNO_OWIDTH )
8866 : {
8867 : //! momentan immer gesetzt ??!?!
8868 0 : bool bOpt = !(rDoc.GetColFlags( nCol, nTab ) & CR_MANUALSIZE);
8869 0 : ScUnoHelpFunctions::SetBoolInAny( rAny, bOpt );
8870 : }
8871 42 : else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE )
8872 : {
8873 2 : ScBreakType nBreak = rDoc.HasColBreak(nCol, nTab);
8874 2 : ScUnoHelpFunctions::SetBoolInAny( rAny, nBreak != BREAK_NONE );
8875 : }
8876 40 : else if ( pEntry->nWID == SC_WID_UNO_MANPAGE )
8877 : {
8878 40 : ScBreakType nBreak = rDoc.HasColBreak(nCol, nTab);
8879 40 : ScUnoHelpFunctions::SetBoolInAny(rAny, (nBreak & BREAK_MANUAL) != 0);
8880 : }
8881 : else
8882 0 : ScCellRangeObj::GetOnePropertyValue(pEntry, rAny);
8883 : }
8884 122 : }
8885 :
8886 46 : const SfxItemPropertyMap& ScTableColumnObj::GetItemPropertyMap()
8887 : {
8888 46 : return pColPropSet->getPropertyMap();
8889 : }
8890 :
8891 120 : ScTableRowObj::ScTableRowObj(ScDocShell* pDocSh, SCROW nRow, SCTAB nTab) :
8892 : ScCellRangeObj( pDocSh, ScRange(0,nRow,nTab, MAXCOL,nRow,nTab) ),
8893 120 : pRowPropSet(lcl_GetRowPropertySet())
8894 : {
8895 120 : }
8896 :
8897 240 : ScTableRowObj::~ScTableRowObj()
8898 : {
8899 240 : }
8900 :
8901 : // XPropertySet erweitert fuer Zeilen-Properties
8902 :
8903 62 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTableRowObj::getPropertySetInfo()
8904 : throw(uno::RuntimeException, std::exception)
8905 : {
8906 62 : SolarMutexGuard aGuard;
8907 : static uno::Reference<beans::XPropertySetInfo> aRef(
8908 62 : new SfxItemPropertySetInfo( pRowPropSet->getPropertyMap() ));
8909 62 : return aRef;
8910 : }
8911 :
8912 4 : void ScTableRowObj::SetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue )
8913 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
8914 : {
8915 4 : if ( pEntry )
8916 : {
8917 4 : if ( IsScItemWid( pEntry->nWID ) )
8918 : {
8919 : // for Item WIDs, call ScCellRangesBase directly
8920 0 : ScCellRangesBase::SetOnePropertyValue(pEntry, aValue);
8921 0 : return;
8922 : }
8923 :
8924 : // own properties
8925 :
8926 4 : ScDocShell* pDocSh = GetDocShell();
8927 4 : if (!pDocSh)
8928 0 : return; //! Exception oder so?
8929 4 : ScDocument& rDoc = pDocSh->GetDocument();
8930 4 : const ScRange& rRange = GetRange();
8931 : OSL_ENSURE(rRange.aStart.Row() == rRange.aEnd.Row(), "zuviele Zeilen");
8932 4 : SCROW nRow = rRange.aStart.Row();
8933 4 : SCTAB nTab = rRange.aStart.Tab();
8934 4 : ScDocFunc &rFunc = pDocSh->GetDocFunc();
8935 :
8936 4 : std::vector<sc::ColRowSpan> aRowArr(1, sc::ColRowSpan(nRow,nRow));
8937 :
8938 4 : if ( pEntry->nWID == SC_WID_UNO_CELLHGT )
8939 : {
8940 0 : sal_Int32 nNewHeight = 0;
8941 0 : if ( aValue >>= nNewHeight )
8942 : {
8943 : // property is 1/100mm, row height is twips
8944 0 : nNewHeight = HMMToTwips(nNewHeight);
8945 : rFunc.SetWidthOrHeight(
8946 0 : false, aRowArr, nTab, SC_SIZE_ORIGINAL, (sal_uInt16)nNewHeight, true, true);
8947 : }
8948 : }
8949 4 : else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
8950 : {
8951 2 : bool bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8952 2 : ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT;
8953 2 : rFunc.SetWidthOrHeight(false, aRowArr, nTab, eMode, 0, true, true);
8954 : // SC_SIZE_DIRECT mit Groesse 0 blendet aus
8955 : }
8956 2 : else if ( pEntry->nWID == SC_WID_UNO_CELLFILT )
8957 : {
8958 0 : bool bFil = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8959 : // SC_SIZE_DIRECT mit Groesse 0 blendet aus
8960 0 : rDoc.SetRowFiltered(nRow, nRow, nTab, bFil);
8961 : }
8962 2 : else if ( pEntry->nWID == SC_WID_UNO_OHEIGHT )
8963 : {
8964 0 : bool bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8965 0 : if (bOpt)
8966 0 : rFunc.SetWidthOrHeight(false, aRowArr, nTab, SC_SIZE_OPTIMAL, 0, true, true);
8967 : else
8968 : {
8969 : // set current height again manually
8970 0 : sal_uInt16 nHeight = rDoc.GetOriginalHeight( nRow, nTab );
8971 0 : rFunc.SetWidthOrHeight(false, aRowArr, nTab, SC_SIZE_ORIGINAL, nHeight, true, true);
8972 : }
8973 : }
8974 2 : else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE || pEntry->nWID == SC_WID_UNO_MANPAGE )
8975 : {
8976 2 : bool bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue );
8977 2 : if (bSet)
8978 1 : rFunc.InsertPageBreak( false, rRange.aStart, true, true, true );
8979 : else
8980 1 : rFunc.RemovePageBreak( false, rRange.aStart, true, true, true );
8981 : }
8982 : else
8983 0 : ScCellRangeObj::SetOnePropertyValue(pEntry, aValue); // base class, no Item WID
8984 : }
8985 : }
8986 :
8987 197 : void ScTableRowObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, uno::Any& rAny )
8988 : throw(uno::RuntimeException, std::exception)
8989 : {
8990 197 : if ( pEntry )
8991 : {
8992 197 : ScDocShell* pDocSh = GetDocShell();
8993 197 : if (!pDocSh)
8994 0 : throw uno::RuntimeException();
8995 197 : ScDocument& rDoc = pDocSh->GetDocument();
8996 197 : const ScRange& rRange = GetRange();
8997 : OSL_ENSURE(rRange.aStart.Row() == rRange.aEnd.Row(), "zuviele Zeilen");
8998 197 : SCROW nRow = rRange.aStart.Row();
8999 197 : SCTAB nTab = rRange.aStart.Tab();
9000 :
9001 197 : if ( pEntry->nWID == SC_WID_UNO_CELLHGT )
9002 : {
9003 : // for hidden row, return original height
9004 62 : sal_uInt16 nHeight = rDoc.GetOriginalHeight( nRow, nTab );
9005 : // property is 1/100mm, row height is twips
9006 62 : nHeight = (sal_uInt16) TwipsToHMM(nHeight);
9007 62 : rAny <<= (sal_Int32)( nHeight );
9008 : }
9009 135 : else if ( pEntry->nWID == SC_WID_UNO_CELLVIS )
9010 : {
9011 9 : bool bHidden = rDoc.RowHidden(nRow, nTab);
9012 9 : ScUnoHelpFunctions::SetBoolInAny( rAny, !bHidden );
9013 : }
9014 126 : else if ( pEntry->nWID == SC_WID_UNO_CELLFILT )
9015 : {
9016 0 : bool bVis = rDoc.RowFiltered(nRow, nTab);
9017 0 : ScUnoHelpFunctions::SetBoolInAny( rAny, bVis );
9018 : }
9019 126 : else if ( pEntry->nWID == SC_WID_UNO_OHEIGHT )
9020 : {
9021 62 : bool bOpt = !(rDoc.GetRowFlags( nRow, nTab ) & CR_MANUALSIZE);
9022 62 : ScUnoHelpFunctions::SetBoolInAny( rAny, bOpt );
9023 : }
9024 64 : else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE )
9025 : {
9026 2 : ScBreakType nBreak = rDoc.HasRowBreak(nRow, nTab);
9027 2 : ScUnoHelpFunctions::SetBoolInAny( rAny, nBreak != BREAK_NONE );
9028 : }
9029 62 : else if ( pEntry->nWID == SC_WID_UNO_MANPAGE )
9030 : {
9031 62 : bool bBreak = (rDoc.HasRowBreak(nRow, nTab) & BREAK_MANUAL) != 0;
9032 62 : ScUnoHelpFunctions::SetBoolInAny( rAny, bBreak );
9033 : }
9034 : else
9035 0 : ScCellRangeObj::GetOnePropertyValue(pEntry, rAny);
9036 : }
9037 197 : }
9038 :
9039 77 : const SfxItemPropertyMap& ScTableRowObj::GetItemPropertyMap()
9040 : {
9041 77 : return pRowPropSet->getPropertyMap();
9042 : }
9043 :
9044 27 : ScCellsObj::ScCellsObj(ScDocShell* pDocSh, const ScRangeList& rR) :
9045 : pDocShell( pDocSh ),
9046 27 : aRanges( rR )
9047 : {
9048 27 : pDocShell->GetDocument().AddUnoObject(*this);
9049 27 : }
9050 :
9051 81 : ScCellsObj::~ScCellsObj()
9052 : {
9053 27 : SolarMutexGuard g;
9054 :
9055 27 : if (pDocShell)
9056 23 : pDocShell->GetDocument().RemoveUnoObject(*this);
9057 54 : }
9058 :
9059 8 : void ScCellsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
9060 : {
9061 8 : if ( dynamic_cast<const ScUpdateRefHint*>(&rHint) )
9062 : {
9063 0 : const ScUpdateRefHint& rRef = static_cast<const ScUpdateRefHint&>(rHint);
9064 0 : aRanges.UpdateReference( rRef.GetMode(), &pDocShell->GetDocument(), rRef.GetRange(),
9065 0 : rRef.GetDx(), rRef.GetDy(), rRef.GetDz() );
9066 : }
9067 16 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) &&
9068 8 : static_cast<const SfxSimpleHint&>(rHint).GetId() == SFX_HINT_DYING )
9069 : {
9070 4 : pDocShell = NULL; // ungueltig geworden
9071 : }
9072 8 : }
9073 :
9074 : // XEnumerationAccess
9075 :
9076 26 : uno::Reference<container::XEnumeration> SAL_CALL ScCellsObj::createEnumeration()
9077 : throw(uno::RuntimeException, std::exception)
9078 : {
9079 26 : SolarMutexGuard aGuard;
9080 26 : if (pDocShell)
9081 26 : return new ScCellsEnumeration( pDocShell, aRanges );
9082 0 : return NULL;
9083 : }
9084 :
9085 1 : uno::Type SAL_CALL ScCellsObj::getElementType() throw(uno::RuntimeException, std::exception)
9086 : {
9087 1 : SolarMutexGuard aGuard;
9088 1 : return cppu::UnoType<table::XCell>::get();
9089 : }
9090 :
9091 1 : sal_Bool SAL_CALL ScCellsObj::hasElements() throw(uno::RuntimeException, std::exception)
9092 : {
9093 1 : SolarMutexGuard aGuard;
9094 1 : bool bHas = false;
9095 1 : if ( pDocShell )
9096 : {
9097 : //! schneller selber testen?
9098 :
9099 1 : uno::Reference<container::XEnumeration> xEnum(new ScCellsEnumeration( pDocShell, aRanges ));
9100 1 : bHas = xEnum->hasMoreElements();
9101 : }
9102 1 : return bHas;
9103 : }
9104 :
9105 27 : ScCellsEnumeration::ScCellsEnumeration(ScDocShell* pDocSh, const ScRangeList& rR) :
9106 : pDocShell( pDocSh ),
9107 : aRanges( rR ),
9108 : pMark( NULL ),
9109 27 : bAtEnd( false )
9110 : {
9111 27 : ScDocument& rDoc = pDocShell->GetDocument();
9112 27 : rDoc.AddUnoObject(*this);
9113 :
9114 27 : if ( aRanges.empty() )
9115 0 : bAtEnd = true;
9116 : else
9117 : {
9118 27 : SCTAB nTab = 0;
9119 27 : const ScRange* pFirst = aRanges[ 0 ];
9120 27 : if (pFirst)
9121 27 : nTab = pFirst->aStart.Tab();
9122 27 : aPos = ScAddress(0,0,nTab);
9123 27 : CheckPos_Impl(); // aPos auf erste passende Zelle setzen
9124 : }
9125 27 : }
9126 :
9127 27 : void ScCellsEnumeration::CheckPos_Impl()
9128 : {
9129 27 : if (!pDocShell)
9130 27 : return;
9131 :
9132 27 : bool bFound = false;
9133 27 : ScDocument& rDoc = pDocShell->GetDocument();
9134 27 : ScRefCellValue aCell;
9135 27 : aCell.assign(rDoc, aPos);
9136 27 : if (!aCell.isEmpty())
9137 : {
9138 27 : if (!pMark)
9139 : {
9140 27 : pMark = new ScMarkData;
9141 27 : pMark->MarkFromRangeList(aRanges, false);
9142 27 : pMark->MarkToMulti(); // needed for GetNextMarkedCell
9143 : }
9144 27 : bFound = pMark->IsCellMarked(aPos.Col(), aPos.Row());
9145 : }
9146 27 : if (!bFound)
9147 24 : Advance_Impl();
9148 : }
9149 :
9150 81 : ScCellsEnumeration::~ScCellsEnumeration()
9151 : {
9152 27 : SolarMutexGuard g;
9153 :
9154 27 : if (pDocShell)
9155 24 : pDocShell->GetDocument().RemoveUnoObject(*this);
9156 27 : delete pMark;
9157 54 : }
9158 :
9159 25 : void ScCellsEnumeration::Advance_Impl()
9160 : {
9161 : OSL_ENSURE(!bAtEnd,"zuviel Advance_Impl");
9162 25 : if (!pMark)
9163 : {
9164 0 : pMark = new ScMarkData;
9165 0 : pMark->MarkFromRangeList( aRanges, false );
9166 0 : pMark->MarkToMulti(); // needed for GetNextMarkedCell
9167 : }
9168 :
9169 25 : SCCOL nCol = aPos.Col();
9170 25 : SCROW nRow = aPos.Row();
9171 25 : SCTAB nTab = aPos.Tab();
9172 25 : bool bFound = pDocShell->GetDocument().GetNextMarkedCell( nCol, nRow, nTab, *pMark );
9173 25 : if (bFound)
9174 1 : aPos.Set( nCol, nRow, nTab );
9175 : else
9176 24 : bAtEnd = true; // kommt nix mehr
9177 25 : }
9178 :
9179 7 : void ScCellsEnumeration::Notify( SfxBroadcaster&, const SfxHint& rHint )
9180 : {
9181 7 : const ScUpdateRefHint* pRefHint = dynamic_cast<const ScUpdateRefHint*>(&rHint);
9182 7 : if ( pRefHint )
9183 : {
9184 0 : if (pDocShell)
9185 : {
9186 0 : aRanges.UpdateReference( pRefHint->GetMode(), &pDocShell->GetDocument(), pRefHint->GetRange(),
9187 0 : pRefHint->GetDx(), pRefHint->GetDy(), pRefHint->GetDz() );
9188 :
9189 0 : delete pMark; // aus verschobenen Bereichen neu erzeugen
9190 0 : pMark = NULL;
9191 :
9192 0 : if (!bAtEnd) // aPos anpassen
9193 : {
9194 0 : ScRangeList aNew;
9195 0 : aNew.Append(ScRange(aPos));
9196 0 : aNew.UpdateReference( pRefHint->GetMode(), &pDocShell->GetDocument(), pRefHint->GetRange(),
9197 0 : pRefHint->GetDx(), pRefHint->GetDy(), pRefHint->GetDz() );
9198 0 : if (aNew.size()==1)
9199 : {
9200 0 : aPos = aNew[ 0 ]->aStart;
9201 0 : CheckPos_Impl();
9202 0 : }
9203 : }
9204 : }
9205 : }
9206 14 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) &&
9207 7 : static_cast<const SfxSimpleHint&>(rHint).GetId() == SFX_HINT_DYING )
9208 : {
9209 3 : pDocShell = NULL; // ungueltig geworden
9210 : }
9211 7 : }
9212 :
9213 : // XEnumeration
9214 :
9215 27 : sal_Bool SAL_CALL ScCellsEnumeration::hasMoreElements() throw(uno::RuntimeException, std::exception)
9216 : {
9217 27 : SolarMutexGuard aGuard;
9218 27 : return !bAtEnd;
9219 : }
9220 :
9221 2 : uno::Any SAL_CALL ScCellsEnumeration::nextElement() throw(container::NoSuchElementException,
9222 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
9223 : {
9224 2 : SolarMutexGuard aGuard;
9225 2 : if (pDocShell && !bAtEnd)
9226 : {
9227 : // Interface-Typ muss zu ScCellsObj::getElementType passen
9228 :
9229 1 : ScAddress aTempPos(aPos);
9230 1 : Advance_Impl();
9231 2 : return uno::makeAny(uno::Reference<table::XCell>(new ScCellObj( pDocShell, aTempPos )));
9232 : }
9233 :
9234 1 : throw container::NoSuchElementException(); // no more elements
9235 : }
9236 :
9237 3 : ScCellFormatsObj::ScCellFormatsObj(ScDocShell* pDocSh, const ScRange& rRange) :
9238 : pDocShell( pDocSh ),
9239 3 : aTotalRange( rRange )
9240 : {
9241 3 : ScDocument& rDoc = pDocShell->GetDocument();
9242 3 : rDoc.AddUnoObject(*this);
9243 :
9244 : OSL_ENSURE( aTotalRange.aStart.Tab() == aTotalRange.aEnd.Tab(), "unterschiedliche Tabellen" );
9245 3 : }
9246 :
9247 9 : ScCellFormatsObj::~ScCellFormatsObj()
9248 : {
9249 3 : SolarMutexGuard g;
9250 :
9251 3 : if (pDocShell)
9252 0 : pDocShell->GetDocument().RemoveUnoObject(*this);
9253 6 : }
9254 :
9255 8 : void ScCellFormatsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
9256 : {
9257 8 : if ( dynamic_cast<const ScUpdateRefHint*>(&rHint) )
9258 : {
9259 : //! aTotalRange...
9260 : }
9261 14 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) &&
9262 8 : static_cast<const SfxSimpleHint&>(rHint).GetId() == SFX_HINT_DYING )
9263 : {
9264 3 : pDocShell = NULL; // ungueltig geworden
9265 : }
9266 8 : }
9267 :
9268 5 : ScCellRangeObj* ScCellFormatsObj::GetObjectByIndex_Impl(long nIndex) const
9269 : {
9270 : //! direkt auf die AttrArrays zugreifen !!!!
9271 :
9272 5 : ScCellRangeObj* pRet = NULL;
9273 5 : if (pDocShell)
9274 : {
9275 5 : ScDocument& rDoc = pDocShell->GetDocument();
9276 5 : long nPos = 0;
9277 5 : ScAttrRectIterator aIter( &rDoc, aTotalRange.aStart.Tab(),
9278 5 : aTotalRange.aStart.Col(), aTotalRange.aStart.Row(),
9279 15 : aTotalRange.aEnd.Col(), aTotalRange.aEnd.Row() );
9280 : SCCOL nCol1, nCol2;
9281 : SCROW nRow1, nRow2;
9282 15 : while ( aIter.GetNext( nCol1, nCol2, nRow1, nRow2 ) )
9283 : {
9284 5 : if ( nPos == nIndex )
9285 : {
9286 4 : SCTAB nTab = aTotalRange.aStart.Tab();
9287 4 : ScRange aNext( nCol1, nRow1, nTab, nCol2, nRow2, nTab );
9288 :
9289 4 : if ( aNext.aStart == aNext.aEnd )
9290 0 : pRet = new ScCellObj( pDocShell, aNext.aStart );
9291 : else
9292 4 : pRet = new ScCellRangeObj( pDocShell, aNext );
9293 : }
9294 5 : ++nPos;
9295 5 : }
9296 : }
9297 5 : return pRet;
9298 : }
9299 :
9300 : // XIndexAccess
9301 :
9302 3 : sal_Int32 SAL_CALL ScCellFormatsObj::getCount() throw(uno::RuntimeException, std::exception)
9303 : {
9304 3 : SolarMutexGuard aGuard;
9305 :
9306 : //! direkt auf die AttrArrays zugreifen !!!!
9307 :
9308 3 : long nCount = 0;
9309 3 : if (pDocShell)
9310 : {
9311 3 : ScDocument& rDoc = pDocShell->GetDocument();
9312 3 : ScAttrRectIterator aIter( &rDoc, aTotalRange.aStart.Tab(),
9313 3 : aTotalRange.aStart.Col(), aTotalRange.aStart.Row(),
9314 9 : aTotalRange.aEnd.Col(), aTotalRange.aEnd.Row() );
9315 : SCCOL nCol1, nCol2;
9316 : SCROW nRow1, nRow2;
9317 9 : while ( aIter.GetNext( nCol1, nCol2, nRow1, nRow2 ) )
9318 6 : ++nCount;
9319 : }
9320 3 : return nCount;
9321 : }
9322 :
9323 5 : uno::Any SAL_CALL ScCellFormatsObj::getByIndex( sal_Int32 nIndex )
9324 : throw(lang::IndexOutOfBoundsException,
9325 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
9326 : {
9327 5 : SolarMutexGuard aGuard;
9328 :
9329 10 : uno::Reference<table::XCellRange> xRange(GetObjectByIndex_Impl(nIndex));
9330 5 : if (xRange.is())
9331 8 : return uno::makeAny(xRange);
9332 : else
9333 6 : throw lang::IndexOutOfBoundsException();
9334 : }
9335 :
9336 1 : uno::Type SAL_CALL ScCellFormatsObj::getElementType() throw(uno::RuntimeException, std::exception)
9337 : {
9338 1 : SolarMutexGuard aGuard;
9339 1 : return cppu::UnoType<table::XCellRange>::get();
9340 : }
9341 :
9342 1 : sal_Bool SAL_CALL ScCellFormatsObj::hasElements() throw(uno::RuntimeException, std::exception)
9343 : {
9344 1 : SolarMutexGuard aGuard;
9345 1 : return ( getCount() != 0 ); //! immer groesser 0 ??
9346 : }
9347 :
9348 : // XEnumerationAccess
9349 :
9350 2 : uno::Reference<container::XEnumeration> SAL_CALL ScCellFormatsObj::createEnumeration()
9351 : throw(uno::RuntimeException, std::exception)
9352 : {
9353 2 : SolarMutexGuard aGuard;
9354 2 : if (pDocShell)
9355 2 : return new ScCellFormatsEnumeration( pDocShell, aTotalRange );
9356 0 : return NULL;
9357 : }
9358 :
9359 2 : ScCellFormatsEnumeration::ScCellFormatsEnumeration(ScDocShell* pDocSh, const ScRange& rRange) :
9360 : pDocShell( pDocSh ),
9361 2 : nTab( rRange.aStart.Tab() ),
9362 : pIter( NULL ),
9363 : bAtEnd( false ),
9364 4 : bDirty( false )
9365 : {
9366 2 : ScDocument& rDoc = pDocShell->GetDocument();
9367 2 : rDoc.AddUnoObject(*this);
9368 :
9369 : OSL_ENSURE( rRange.aStart.Tab() == rRange.aEnd.Tab(),
9370 : "CellFormatsEnumeration: unterschiedliche Tabellen" );
9371 :
9372 : pIter = new ScAttrRectIterator( &rDoc, nTab,
9373 4 : rRange.aStart.Col(), rRange.aStart.Row(),
9374 4 : rRange.aEnd.Col(), rRange.aEnd.Row() );
9375 2 : Advance_Impl();
9376 2 : }
9377 :
9378 6 : ScCellFormatsEnumeration::~ScCellFormatsEnumeration()
9379 : {
9380 2 : SolarMutexGuard g;
9381 :
9382 2 : if (pDocShell)
9383 0 : pDocShell->GetDocument().RemoveUnoObject(*this);
9384 2 : delete pIter;
9385 4 : }
9386 :
9387 3 : void ScCellFormatsEnumeration::Advance_Impl()
9388 : {
9389 : OSL_ENSURE(!bAtEnd,"zuviel Advance_Impl");
9390 :
9391 3 : if ( pIter )
9392 : {
9393 3 : if ( bDirty )
9394 : {
9395 0 : pIter->DataChanged(); // AttrArray-Index neu suchen
9396 0 : bDirty = false;
9397 : }
9398 :
9399 : SCCOL nCol1, nCol2;
9400 : SCROW nRow1, nRow2;
9401 3 : if ( pIter->GetNext( nCol1, nCol2, nRow1, nRow2 ) )
9402 2 : aNext = ScRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab );
9403 : else
9404 1 : bAtEnd = true; // kommt nix mehr
9405 : }
9406 : else
9407 0 : bAtEnd = true; // Dok weggekommen oder so
9408 3 : }
9409 :
9410 1 : ScCellRangeObj* ScCellFormatsEnumeration::NextObject_Impl()
9411 : {
9412 1 : ScCellRangeObj* pRet = NULL;
9413 1 : if (pDocShell && !bAtEnd)
9414 : {
9415 1 : if ( aNext.aStart == aNext.aEnd )
9416 0 : pRet = new ScCellObj( pDocShell, aNext.aStart );
9417 : else
9418 1 : pRet = new ScCellRangeObj( pDocShell, aNext );
9419 1 : Advance_Impl();
9420 : }
9421 1 : return pRet;
9422 : }
9423 :
9424 2 : void ScCellFormatsEnumeration::Notify( SfxBroadcaster&, const SfxHint& rHint )
9425 : {
9426 2 : if ( dynamic_cast<const ScUpdateRefHint*>(&rHint) )
9427 : {
9428 : //! und nun ???
9429 : }
9430 2 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) )
9431 : {
9432 2 : sal_uLong nId = static_cast<const SfxSimpleHint&>(rHint).GetId();
9433 2 : if ( nId == SFX_HINT_DYING )
9434 : {
9435 2 : pDocShell = NULL; // ungueltig geworden
9436 2 : delete pIter;
9437 2 : pIter = NULL;
9438 : }
9439 0 : else if ( nId == SFX_HINT_DATACHANGED )
9440 : {
9441 0 : bDirty = true; // AttrArray-Index evtl. ungueltig geworden
9442 : }
9443 : }
9444 2 : }
9445 :
9446 : // XEnumeration
9447 :
9448 2 : sal_Bool SAL_CALL ScCellFormatsEnumeration::hasMoreElements() throw(uno::RuntimeException, std::exception)
9449 : {
9450 2 : SolarMutexGuard aGuard;
9451 2 : return !bAtEnd;
9452 : }
9453 :
9454 2 : uno::Any SAL_CALL ScCellFormatsEnumeration::nextElement() throw(container::NoSuchElementException,
9455 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
9456 : {
9457 2 : SolarMutexGuard aGuard;
9458 :
9459 2 : if ( bAtEnd || !pDocShell )
9460 1 : throw container::NoSuchElementException(); // no more elements
9461 :
9462 : // Interface-Typ muss zu ScCellFormatsObj::getElementType passen
9463 :
9464 1 : return uno::makeAny(uno::Reference<table::XCellRange> (NextObject_Impl()));
9465 : }
9466 :
9467 36 : ScUniqueCellFormatsObj::ScUniqueCellFormatsObj(ScDocShell* pDocSh, const ScRange& rRange) :
9468 : pDocShell( pDocSh ),
9469 : aTotalRange( rRange ),
9470 36 : aRangeLists()
9471 : {
9472 36 : pDocShell->GetDocument().AddUnoObject(*this);
9473 :
9474 : OSL_ENSURE( aTotalRange.aStart.Tab() == aTotalRange.aEnd.Tab(), "unterschiedliche Tabellen" );
9475 :
9476 36 : GetObjects_Impl();
9477 36 : }
9478 :
9479 108 : ScUniqueCellFormatsObj::~ScUniqueCellFormatsObj()
9480 : {
9481 36 : SolarMutexGuard g;
9482 :
9483 36 : if (pDocShell)
9484 33 : pDocShell->GetDocument().RemoveUnoObject(*this);
9485 72 : }
9486 :
9487 3 : void ScUniqueCellFormatsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
9488 : {
9489 3 : if ( dynamic_cast<const ScUpdateRefHint*>(&rHint) )
9490 : {
9491 : //! aTotalRange...
9492 : }
9493 3 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) )
9494 : {
9495 3 : sal_uLong nId = static_cast<const SfxSimpleHint&>(rHint).GetId();
9496 3 : if ( nId == SFX_HINT_DYING )
9497 3 : pDocShell = NULL; // ungueltig geworden
9498 : }
9499 3 : }
9500 :
9501 : // Fill the list of formats from the document
9502 :
9503 : // hash code to access the range lists by ScPatternAttr pointer
9504 : struct ScPatternHashCode
9505 : {
9506 183 : size_t operator()( const ScPatternAttr* pPattern ) const
9507 : {
9508 183 : return reinterpret_cast<size_t>(pPattern);
9509 : }
9510 : };
9511 :
9512 : // Hash map to find a range by its start row
9513 : typedef std::unordered_map< SCROW, ScRange > ScRowRangeHashMap;
9514 :
9515 : typedef std::vector<ScRange> ScRangeVector;
9516 :
9517 : // Hash map entry.
9518 : // The Join method depends on the column-wise order of ScAttrRectIterator
9519 : class ScUniqueFormatsEntry
9520 : {
9521 : enum EntryState { STATE_EMPTY, STATE_SINGLE, STATE_COMPLEX };
9522 :
9523 : EntryState eState;
9524 : ScRange aSingleRange;
9525 : ScRowRangeHashMap aJoinedRanges; // "active" ranges to be merged
9526 : ScRangeVector aCompletedRanges; // ranges that will no longer be touched
9527 : ScRangeListRef aReturnRanges; // result as ScRangeList for further use
9528 :
9529 : public:
9530 92 : ScUniqueFormatsEntry() : eState( STATE_EMPTY ) {}
9531 92 : ~ScUniqueFormatsEntry() {}
9532 :
9533 : void Join( const ScRange& rNewRange );
9534 : const ScRangeList& GetRanges();
9535 92 : void Clear() { aReturnRanges.Clear(); } // aJoinedRanges and aCompletedRanges are cleared in GetRanges
9536 : };
9537 :
9538 183 : void ScUniqueFormatsEntry::Join( const ScRange& rNewRange )
9539 : {
9540 : // Special-case handling for single range
9541 :
9542 183 : if ( eState == STATE_EMPTY )
9543 : {
9544 92 : aSingleRange = rNewRange;
9545 92 : eState = STATE_SINGLE;
9546 197 : return;
9547 : }
9548 91 : if ( eState == STATE_SINGLE )
9549 : {
9550 78 : if ( aSingleRange.aStart.Row() == rNewRange.aStart.Row() &&
9551 43 : aSingleRange.aEnd.Row() == rNewRange.aEnd.Row() &&
9552 13 : aSingleRange.aEnd.Col() + 1 == rNewRange.aStart.Col() )
9553 : {
9554 13 : aSingleRange.aEnd.SetCol( rNewRange.aEnd.Col() );
9555 13 : return; // still a single range
9556 : }
9557 :
9558 17 : SCROW nSingleRow = aSingleRange.aStart.Row();
9559 17 : aJoinedRanges.insert( ScRowRangeHashMap::value_type( nSingleRow, aSingleRange ) );
9560 17 : eState = STATE_COMPLEX;
9561 : // continue normally
9562 : }
9563 :
9564 : // This is called in the order of ScAttrRectIterator results.
9565 : // rNewRange can only be joined with an existing entry if it's the same rows, starting in the next column.
9566 : // If the old entry for the start row extends to a different end row, or ends in a different column, it
9567 : // can be moved to aCompletedRanges because it can't be joined with following iterator results.
9568 : // Everything happens within one sheet, so Tab can be ignored.
9569 :
9570 78 : SCROW nStartRow = rNewRange.aStart.Row();
9571 78 : ScRowRangeHashMap::iterator aIter( aJoinedRanges.find( nStartRow ) ); // find the active entry for the start row
9572 78 : if ( aIter != aJoinedRanges.end() )
9573 : {
9574 58 : ScRange& rOldRange = aIter->second;
9575 72 : if ( rOldRange.aEnd.Row() == rNewRange.aEnd.Row() &&
9576 14 : rOldRange.aEnd.Col() + 1 == rNewRange.aStart.Col() )
9577 : {
9578 : // extend existing range
9579 1 : rOldRange.aEnd.SetCol( rNewRange.aEnd.Col() );
9580 : }
9581 : else
9582 : {
9583 : // move old range to aCompletedRanges, keep rNewRange for joining
9584 57 : aCompletedRanges.push_back( rOldRange );
9585 57 : rOldRange = rNewRange; // replace in hash map
9586 : }
9587 : }
9588 : else
9589 : {
9590 : // keep rNewRange for joining
9591 20 : aJoinedRanges.insert( ScRowRangeHashMap::value_type( nStartRow, rNewRange ) );
9592 : }
9593 : }
9594 :
9595 92 : const ScRangeList& ScUniqueFormatsEntry::GetRanges()
9596 : {
9597 92 : if ( eState == STATE_SINGLE )
9598 : {
9599 75 : aReturnRanges = new ScRangeList;
9600 75 : aReturnRanges->Append( aSingleRange );
9601 75 : return *aReturnRanges;
9602 : }
9603 :
9604 : // move remaining entries from aJoinedRanges to aCompletedRanges
9605 :
9606 17 : ScRowRangeHashMap::const_iterator aJoinedEnd = aJoinedRanges.end();
9607 54 : for ( ScRowRangeHashMap::const_iterator aJoinedIter = aJoinedRanges.begin(); aJoinedIter != aJoinedEnd; ++aJoinedIter )
9608 37 : aCompletedRanges.push_back( aJoinedIter->second );
9609 17 : aJoinedRanges.clear();
9610 :
9611 : // sort all ranges for a predictable API result
9612 :
9613 17 : std::sort( aCompletedRanges.begin(), aCompletedRanges.end() );
9614 :
9615 : // fill and return ScRangeList
9616 :
9617 17 : aReturnRanges = new ScRangeList;
9618 17 : ScRangeVector::const_iterator aCompEnd( aCompletedRanges.end() );
9619 111 : for ( ScRangeVector::const_iterator aCompIter( aCompletedRanges.begin() ); aCompIter != aCompEnd; ++aCompIter )
9620 94 : aReturnRanges->Append( *aCompIter );
9621 17 : aCompletedRanges.clear();
9622 :
9623 17 : return *aReturnRanges;
9624 : }
9625 :
9626 : typedef std::unordered_map< const ScPatternAttr*, ScUniqueFormatsEntry, ScPatternHashCode > ScUniqueFormatsHashMap;
9627 :
9628 : // function object to sort the range lists by start of first range
9629 : struct ScUniqueFormatsOrder
9630 : {
9631 135 : bool operator()( const ScRangeList& rList1, const ScRangeList& rList2 ) const
9632 : {
9633 : // all range lists have at least one entry
9634 : OSL_ENSURE( rList1.size() > 0 && rList2.size() > 0, "ScUniqueFormatsOrder: empty list" );
9635 :
9636 : // compare start positions using ScAddress comparison operator
9637 135 : return ( rList1[ 0 ]->aStart < rList2[ 0 ]->aStart );
9638 : }
9639 : };
9640 :
9641 36 : void ScUniqueCellFormatsObj::GetObjects_Impl()
9642 : {
9643 36 : if (pDocShell)
9644 : {
9645 36 : ScDocument& rDoc = pDocShell->GetDocument();
9646 36 : SCTAB nTab = aTotalRange.aStart.Tab();
9647 : ScAttrRectIterator aIter( &rDoc, nTab,
9648 36 : aTotalRange.aStart.Col(), aTotalRange.aStart.Row(),
9649 72 : aTotalRange.aEnd.Col(), aTotalRange.aEnd.Row() );
9650 : SCCOL nCol1, nCol2;
9651 : SCROW nRow1, nRow2;
9652 :
9653 : // Collect the ranges for each format in a hash map, to avoid nested loops
9654 :
9655 72 : ScUniqueFormatsHashMap aHashMap;
9656 255 : while (aIter.GetNext( nCol1, nCol2, nRow1, nRow2 ) )
9657 : {
9658 183 : ScRange aRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab );
9659 183 : const ScPatternAttr* pPattern = rDoc.GetPattern(nCol1, nRow1, nTab);
9660 183 : aHashMap[pPattern].Join( aRange );
9661 : }
9662 :
9663 : // Fill the vector aRangeLists with the range lists from the hash map
9664 :
9665 36 : aRangeLists.reserve( aHashMap.size() );
9666 36 : ScUniqueFormatsHashMap::iterator aMapIter( aHashMap.begin() );
9667 36 : ScUniqueFormatsHashMap::iterator aMapEnd( aHashMap.end() );
9668 164 : while ( aMapIter != aMapEnd )
9669 : {
9670 92 : ScUniqueFormatsEntry& rEntry = aMapIter->second;
9671 92 : const ScRangeList& rRanges = rEntry.GetRanges();
9672 92 : aRangeLists.push_back( rRanges ); // copy ScRangeList
9673 92 : rEntry.Clear(); // free memory, don't hold both copies of all ranges
9674 92 : ++aMapIter;
9675 : }
9676 :
9677 : // Sort the vector by first range's start position, to avoid random shuffling
9678 : // due to using the ScPatterAttr pointers
9679 :
9680 : ScUniqueFormatsOrder aComp;
9681 72 : ::std::sort( aRangeLists.begin(), aRangeLists.end(), aComp );
9682 : }
9683 36 : }
9684 :
9685 : // XIndexAccess
9686 :
9687 35 : sal_Int32 SAL_CALL ScUniqueCellFormatsObj::getCount() throw(uno::RuntimeException, std::exception)
9688 : {
9689 35 : SolarMutexGuard aGuard;
9690 :
9691 35 : return aRangeLists.size();
9692 : }
9693 :
9694 88 : uno::Any SAL_CALL ScUniqueCellFormatsObj::getByIndex( sal_Int32 nIndex )
9695 : throw(lang::IndexOutOfBoundsException,
9696 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
9697 : {
9698 88 : SolarMutexGuard aGuard;
9699 :
9700 88 : if(static_cast<sal_uInt32>(nIndex) < aRangeLists.size())
9701 174 : return uno::makeAny(uno::Reference<sheet::XSheetCellRangeContainer>(new ScCellRangesObj(pDocShell, aRangeLists[nIndex])));
9702 : else
9703 87 : throw lang::IndexOutOfBoundsException();
9704 : }
9705 :
9706 1 : uno::Type SAL_CALL ScUniqueCellFormatsObj::getElementType() throw(uno::RuntimeException, std::exception)
9707 : {
9708 1 : SolarMutexGuard aGuard;
9709 1 : return cppu::UnoType<sheet::XSheetCellRangeContainer>::get();
9710 : }
9711 :
9712 1 : sal_Bool SAL_CALL ScUniqueCellFormatsObj::hasElements() throw(uno::RuntimeException, std::exception)
9713 : {
9714 1 : SolarMutexGuard aGuard;
9715 1 : return ( aRangeLists.size() != 0 );
9716 : }
9717 :
9718 : // XEnumerationAccess
9719 :
9720 2 : uno::Reference<container::XEnumeration> SAL_CALL ScUniqueCellFormatsObj::createEnumeration()
9721 : throw(uno::RuntimeException, std::exception)
9722 : {
9723 2 : SolarMutexGuard aGuard;
9724 2 : if (pDocShell)
9725 2 : return new ScUniqueCellFormatsEnumeration( pDocShell, aRangeLists );
9726 0 : return NULL;
9727 : }
9728 :
9729 2 : ScUniqueCellFormatsEnumeration::ScUniqueCellFormatsEnumeration(ScDocShell* pDocSh, const ScMyRangeLists& rRangeLists) :
9730 : aRangeLists(rRangeLists),
9731 : pDocShell( pDocSh ),
9732 2 : nCurrentPosition(0)
9733 : {
9734 2 : pDocShell->GetDocument().AddUnoObject(*this);
9735 2 : }
9736 :
9737 6 : ScUniqueCellFormatsEnumeration::~ScUniqueCellFormatsEnumeration()
9738 : {
9739 2 : SolarMutexGuard g;
9740 :
9741 2 : if (pDocShell)
9742 0 : pDocShell->GetDocument().RemoveUnoObject(*this);
9743 4 : }
9744 :
9745 2 : void ScUniqueCellFormatsEnumeration::Notify( SfxBroadcaster&, const SfxHint& rHint )
9746 : {
9747 2 : if ( dynamic_cast<const ScUpdateRefHint*>(&rHint) )
9748 : {
9749 : //! und nun ???
9750 : }
9751 2 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) )
9752 : {
9753 2 : sal_uLong nId = static_cast<const SfxSimpleHint&>(rHint).GetId();
9754 2 : if ( nId == SFX_HINT_DYING )
9755 2 : pDocShell = NULL; // ungueltig geworden
9756 : }
9757 2 : }
9758 :
9759 : // XEnumeration
9760 :
9761 10 : sal_Bool SAL_CALL ScUniqueCellFormatsEnumeration::hasMoreElements() throw(uno::RuntimeException, std::exception)
9762 : {
9763 10 : SolarMutexGuard aGuard;
9764 10 : return static_cast<sal_uInt32>(nCurrentPosition) < aRangeLists.size();
9765 : }
9766 :
9767 5 : uno::Any SAL_CALL ScUniqueCellFormatsEnumeration::nextElement() throw(container::NoSuchElementException,
9768 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
9769 : {
9770 5 : SolarMutexGuard aGuard;
9771 :
9772 5 : if ( !hasMoreElements() || !pDocShell )
9773 1 : throw container::NoSuchElementException(); // no more elements
9774 :
9775 : // Interface-Typ muss zu ScCellFormatsObj::getElementType passen
9776 :
9777 4 : return uno::makeAny(uno::Reference<sheet::XSheetCellRangeContainer>(new ScCellRangesObj(pDocShell, aRangeLists[nCurrentPosition++])));
9778 156 : }
9779 :
9780 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
