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