Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <config_features.h>
21 :
22 : #include "scitems.hxx"
23 : #include <editeng/editview.hxx>
24 : #include <editeng/outliner.hxx>
25 : #include <svx/fmdpage.hxx>
26 : #include <svx/fmview.hxx>
27 : #include <svx/svditer.hxx>
28 : #include <svx/svdpage.hxx>
29 : #include <svx/svxids.hrc>
30 : #include <svx/unoshape.hxx>
31 :
32 : #include <LibreOfficeKit/LibreOfficeKitEnums.h>
33 : #include <officecfg/Office/Common.hxx>
34 : #include <officecfg/Office/Calc.hxx>
35 : #include <svl/numuno.hxx>
36 : #include <svl/smplhint.hxx>
37 : #include <unotools/moduleoptions.hxx>
38 : #include <sfx2/printer.hxx>
39 : #include <sfx2/bindings.hxx>
40 : #include <vcl/pdfextoutdevdata.hxx>
41 : #include <vcl/waitobj.hxx>
42 : #include <unotools/charclass.hxx>
43 : #include <tools/multisel.hxx>
44 : #include <tools/resary.hxx>
45 : #include <toolkit/awt/vclxdevice.hxx>
46 :
47 : #include <ctype.h>
48 : #include <float.h>
49 :
50 : #include <com/sun/star/util/Date.hpp>
51 : #include <com/sun/star/sheet/XNamedRanges.hpp>
52 : #include <com/sun/star/sheet/XLabelRanges.hpp>
53 : #include <com/sun/star/sheet/XSelectedSheetsSupplier.hpp>
54 : #include <com/sun/star/sheet/XUnnamedDatabaseRanges.hpp>
55 : #include <com/sun/star/i18n/XForbiddenCharacters.hpp>
56 : #include <com/sun/star/script/XLibraryContainer.hpp>
57 : #include <com/sun/star/lang/XInitialization.hpp>
58 : #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
59 : #include <com/sun/star/document/XDocumentEventBroadcaster.hpp>
60 : #include <com/sun/star/document/IndexedPropertyValues.hpp>
61 : #include <com/sun/star/script/XInvocation.hpp>
62 : #include <com/sun/star/script/vba/XVBAEventProcessor.hpp>
63 : #include <comphelper/processfactory.hxx>
64 : #include <comphelper/servicehelper.hxx>
65 : #include <comphelper/string.hxx>
66 : #include <cppuhelper/supportsservice.hxx>
67 : #if HAVE_FEATURE_OPENCL
68 : #include <opencl/platforminfo.hxx>
69 : #endif
70 :
71 : #include "cellsuno.hxx"
72 : #include <columnspanset.hxx>
73 : #include "convuno.hxx"
74 : #include "datauno.hxx"
75 : #include "docfunc.hxx"
76 : #include "dociter.hxx"
77 : #include "docoptio.hxx"
78 : #include "docsh.hxx"
79 : #include "docuno.hxx"
80 : #include "drwlayer.hxx"
81 : #include "forbiuno.hxx"
82 : #include "formulacell.hxx"
83 : #include "formulagroup.hxx"
84 : #include "gridwin.hxx"
85 : #include "hints.hxx"
86 : #include <inputhdl.hxx>
87 : #include <inputopt.hxx>
88 : #include "interpre.hxx"
89 : #include "linkuno.hxx"
90 : #include "markdata.hxx"
91 : #include "miscuno.hxx"
92 : #include "nameuno.hxx"
93 : #include "notesuno.hxx"
94 : #include "optuno.hxx"
95 : #include "pfuncache.hxx"
96 : #include "postit.hxx"
97 : #include "printfun.hxx"
98 : #include "rangeutl.hxx"
99 : #include "scmod.hxx"
100 : #include "scresid.hxx"
101 : #include "servuno.hxx"
102 : #include "shapeuno.hxx"
103 : #include "sheetevents.hxx"
104 : #include "styleuno.hxx"
105 : #include "tabvwsh.hxx"
106 : #include "targuno.hxx"
107 : #include "unonames.hxx"
108 : #include "ViewSettingsSequenceDefines.hxx"
109 : #include "viewuno.hxx"
110 :
111 : #include "sc.hrc"
112 :
113 : using namespace com::sun::star;
114 :
115 : // #i111553# provides the name of the VBA constant for this document type (e.g. 'ThisExcelDoc' for Calc)
116 : #define SC_UNO_VBAGLOBNAME "VBAGlobalConstantName"
117 :
118 : // alles ohne Which-ID, Map nur fuer PropertySetInfo
119 :
120 : //! umbenennen, sind nicht mehr nur Options
121 1320 : static const SfxItemPropertyMapEntry* lcl_GetDocOptPropertyMap()
122 : {
123 : static const SfxItemPropertyMapEntry aDocOptPropertyMap_Impl[] =
124 : {
125 52 : {OUString(SC_UNO_APPLYFMDES), 0, cppu::UnoType<bool>::get(), 0, 0},
126 52 : {OUString(SC_UNO_AREALINKS), 0, cppu::UnoType<sheet::XAreaLinks>::get(), 0, 0},
127 52 : {OUString(SC_UNO_AUTOCONTFOC), 0, cppu::UnoType<bool>::get(), 0, 0},
128 52 : {OUString(SC_UNO_BASICLIBRARIES), 0, cppu::UnoType<script::XLibraryContainer>::get(), beans::PropertyAttribute::READONLY, 0},
129 52 : {OUString(SC_UNO_DIALOGLIBRARIES), 0, cppu::UnoType<script::XLibraryContainer>::get(), beans::PropertyAttribute::READONLY, 0},
130 52 : {OUString(SC_UNO_VBAGLOBNAME), 0, cppu::UnoType<OUString>::get(), beans::PropertyAttribute::READONLY, 0},
131 52 : {OUString(SC_UNO_CALCASSHOWN), PROP_UNO_CALCASSHOWN, cppu::UnoType<bool>::get(), 0, 0},
132 52 : {OUString(SC_UNONAME_CLOCAL), 0, cppu::UnoType<lang::Locale>::get(), 0, 0},
133 52 : {OUString(SC_UNO_CJK_CLOCAL), 0, cppu::UnoType<lang::Locale>::get(), 0, 0},
134 52 : {OUString(SC_UNO_CTL_CLOCAL), 0, cppu::UnoType<lang::Locale>::get(), 0, 0},
135 52 : {OUString(SC_UNO_COLLABELRNG), 0, cppu::UnoType<sheet::XLabelRanges>::get(), 0, 0},
136 52 : {OUString(SC_UNO_DDELINKS), 0, cppu::UnoType<container::XNameAccess>::get(), 0, 0},
137 52 : {OUString(SC_UNO_DEFTABSTOP), PROP_UNO_DEFTABSTOP, cppu::UnoType<sal_Int16>::get(), 0, 0},
138 52 : {OUString(SC_UNO_EXTERNALDOCLINKS), 0, cppu::UnoType<sheet::XExternalDocLinks>::get(), 0, 0},
139 52 : {OUString(SC_UNO_FORBIDDEN), 0, cppu::UnoType<i18n::XForbiddenCharacters>::get(), beans::PropertyAttribute::READONLY, 0},
140 52 : {OUString(SC_UNO_HASDRAWPAGES), 0, cppu::UnoType<bool>::get(), beans::PropertyAttribute::READONLY, 0},
141 52 : {OUString(SC_UNO_IGNORECASE), PROP_UNO_IGNORECASE, cppu::UnoType<bool>::get(), 0, 0},
142 52 : {OUString(SC_UNO_ITERENABLED), PROP_UNO_ITERENABLED, cppu::UnoType<bool>::get(), 0, 0},
143 52 : {OUString(SC_UNO_ITERCOUNT), PROP_UNO_ITERCOUNT, cppu::UnoType<sal_Int32>::get(), 0, 0},
144 52 : {OUString(SC_UNO_ITEREPSILON), PROP_UNO_ITEREPSILON, cppu::UnoType<double>::get(), 0, 0},
145 52 : {OUString(SC_UNO_LOOKUPLABELS), PROP_UNO_LOOKUPLABELS, cppu::UnoType<bool>::get(), 0, 0},
146 52 : {OUString(SC_UNO_MATCHWHOLE), PROP_UNO_MATCHWHOLE, cppu::UnoType<bool>::get(), 0, 0},
147 52 : {OUString(SC_UNO_NAMEDRANGES), 0, cppu::UnoType<sheet::XNamedRanges>::get(), 0, 0},
148 52 : {OUString(SC_UNO_DATABASERNG), 0, cppu::UnoType<sheet::XDatabaseRanges>::get(), 0, 0},
149 52 : {OUString(SC_UNO_NULLDATE), PROP_UNO_NULLDATE, cppu::UnoType<util::Date>::get(), 0, 0},
150 52 : {OUString(SC_UNO_ROWLABELRNG), 0, cppu::UnoType<sheet::XLabelRanges>::get(), 0, 0},
151 52 : {OUString(SC_UNO_SHEETLINKS), 0, cppu::UnoType<container::XNameAccess>::get(), 0, 0},
152 52 : {OUString(SC_UNO_SPELLONLINE), PROP_UNO_SPELLONLINE, cppu::UnoType<bool>::get(), 0, 0},
153 52 : {OUString(SC_UNO_STANDARDDEC), PROP_UNO_STANDARDDEC, cppu::UnoType<sal_Int16>::get(), 0, 0},
154 52 : {OUString(SC_UNO_REGEXENABLED), PROP_UNO_REGEXENABLED, cppu::UnoType<bool>::get(), 0, 0},
155 52 : {OUString(SC_UNO_RUNTIMEUID), 0, cppu::UnoType<OUString>::get(), beans::PropertyAttribute::READONLY, 0},
156 52 : {OUString(SC_UNO_HASVALIDSIGNATURES), 0, cppu::UnoType<bool>::get(), beans::PropertyAttribute::READONLY, 0},
157 52 : {OUString(SC_UNO_ISLOADED), 0, cppu::UnoType<bool>::get(), 0, 0},
158 52 : {OUString(SC_UNO_ISUNDOENABLED), 0, cppu::UnoType<bool>::get(), 0, 0},
159 52 : {OUString(SC_UNO_RECORDCHANGES), 0, cppu::UnoType<bool>::get(), 0, 0},
160 52 : {OUString(SC_UNO_ISRECORDCHANGESPROTECTED),0, cppu::UnoType<bool>::get(), beans::PropertyAttribute::READONLY, 0},
161 52 : {OUString(SC_UNO_ISADJUSTHEIGHTENABLED), 0, cppu::UnoType<bool>::get(), 0, 0},
162 52 : {OUString(SC_UNO_ISEXECUTELINKENABLED), 0, cppu::UnoType<bool>::get(), 0, 0},
163 52 : {OUString(SC_UNO_ISCHANGEREADONLYENABLED), 0, cppu::UnoType<bool>::get(), 0, 0},
164 52 : {OUString(SC_UNO_REFERENCEDEVICE), 0, cppu::UnoType<awt::XDevice>::get(), beans::PropertyAttribute::READONLY, 0},
165 52 : {OUString("BuildId"), 0, ::cppu::UnoType<OUString>::get(), 0, 0},
166 52 : {OUString(SC_UNO_CODENAME), 0, cppu::UnoType<OUString>::get(), 0, 0},
167 52 : {OUString(SC_UNO_INTEROPGRABBAG), 0, cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get(), 0, 0},
168 : { OUString(), 0, css::uno::Type(), 0, 0 }
169 3608 : };
170 1320 : return aDocOptPropertyMap_Impl;
171 : }
172 :
173 : //! StandardDecimals als Property und vom NumberFormatter ????????
174 :
175 33 : static const SfxItemPropertyMapEntry* lcl_GetColumnsPropertyMap()
176 : {
177 : static const SfxItemPropertyMapEntry aColumnsPropertyMap_Impl[] =
178 : {
179 33 : {OUString(SC_UNONAME_MANPAGE), 0, cppu::UnoType<bool>::get(), 0, 0 },
180 33 : {OUString(SC_UNONAME_NEWPAGE), 0, cppu::UnoType<bool>::get(), 0, 0 },
181 33 : {OUString(SC_UNONAME_CELLVIS), 0, cppu::UnoType<bool>::get(), 0, 0 },
182 33 : {OUString(SC_UNONAME_OWIDTH), 0, cppu::UnoType<bool>::get(), 0, 0 },
183 33 : {OUString(SC_UNONAME_CELLWID), 0, cppu::UnoType<sal_Int32>::get(), 0, 0 },
184 : { OUString(), 0, css::uno::Type(), 0, 0 }
185 231 : };
186 33 : return aColumnsPropertyMap_Impl;
187 : }
188 :
189 33 : static const SfxItemPropertyMapEntry* lcl_GetRowsPropertyMap()
190 : {
191 : static const SfxItemPropertyMapEntry aRowsPropertyMap_Impl[] =
192 : {
193 33 : {OUString(SC_UNONAME_CELLHGT), 0, cppu::UnoType<sal_Int32>::get(), 0, 0 },
194 33 : {OUString(SC_UNONAME_CELLFILT), 0, cppu::UnoType<bool>::get(), 0, 0 },
195 33 : {OUString(SC_UNONAME_OHEIGHT), 0, cppu::UnoType<bool>::get(), 0, 0 },
196 33 : {OUString(SC_UNONAME_MANPAGE), 0, cppu::UnoType<bool>::get(), 0, 0 },
197 33 : {OUString(SC_UNONAME_NEWPAGE), 0, cppu::UnoType<bool>::get(), 0, 0 },
198 33 : {OUString(SC_UNONAME_CELLVIS), 0, cppu::UnoType<bool>::get(), 0, 0 },
199 33 : {OUString(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, ::cppu::UnoType<sal_Int32>::get(), 0, MID_BACK_COLOR },
200 33 : {OUString(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, cppu::UnoType<bool>::get(), 0, MID_GRAPHIC_TRANSPARENT },
201 : // not sorted, not used with SfxItemPropertyMapEntry::GetByName
202 : { OUString(), 0, css::uno::Type(), 0, 0 }
203 330 : };
204 33 : return aRowsPropertyMap_Impl;
205 : }
206 :
207 : using sc::HMMToTwips;
208 : using sc::TwipsToHMM;
209 :
210 : #define SCMODELOBJ_SERVICE "com.sun.star.sheet.SpreadsheetDocument"
211 : #define SCDOCSETTINGS_SERVICE "com.sun.star.sheet.SpreadsheetDocumentSettings"
212 : #define SCDOC_SERVICE "com.sun.star.document.OfficeDocument"
213 :
214 0 : SC_SIMPLE_SERVICE_INFO( ScAnnotationsObj, "ScAnnotationsObj", "com.sun.star.sheet.CellAnnotations" )
215 0 : SC_SIMPLE_SERVICE_INFO( ScDrawPagesObj, "ScDrawPagesObj", "com.sun.star.drawing.DrawPages" )
216 0 : SC_SIMPLE_SERVICE_INFO( ScScenariosObj, "ScScenariosObj", "com.sun.star.sheet.Scenarios" )
217 0 : SC_SIMPLE_SERVICE_INFO( ScSpreadsheetSettingsObj, "ScSpreadsheetSettingsObj", "com.sun.star.sheet.SpreadsheetDocumentSettings" )
218 0 : SC_SIMPLE_SERVICE_INFO( ScTableColumnsObj, "ScTableColumnsObj", "com.sun.star.table.TableColumns" )
219 0 : SC_SIMPLE_SERVICE_INFO( ScTableRowsObj, "ScTableRowsObj", "com.sun.star.table.TableRows" )
220 0 : SC_SIMPLE_SERVICE_INFO( ScTableSheetsObj, "ScTableSheetsObj", "com.sun.star.sheet.Spreadsheets" )
221 :
222 0 : class ScPrintUIOptions : public vcl::PrinterOptionsHelper
223 : {
224 : public:
225 : ScPrintUIOptions();
226 : void SetDefaults();
227 : };
228 :
229 0 : ScPrintUIOptions::ScPrintUIOptions()
230 : {
231 0 : const ScPrintOptions& rPrintOpt = SC_MOD()->GetPrintOptions();
232 0 : sal_Int32 nContent = rPrintOpt.GetAllSheets() ? 0 : 1;
233 0 : bool bSuppress = rPrintOpt.GetSkipEmpty();
234 :
235 0 : ResStringArray aStrings( ScResId( SCSTR_PRINT_OPTIONS ) );
236 : OSL_ENSURE( aStrings.Count() >= 10, "resource incomplete" );
237 0 : if( aStrings.Count() < 10 ) // bad resource ?
238 0 : return;
239 :
240 0 : sal_Int32 nNumProps= 9, nIdx = 0;
241 :
242 0 : m_aUIProperties.realloc(nNumProps);
243 :
244 : // load the writer PrinterOptions into the custom tab
245 0 : m_aUIProperties[nIdx].Name = "OptionsUIFile";
246 0 : m_aUIProperties[nIdx++].Value <<= OUString("modules/scalc/ui/printeroptions.ui");
247 :
248 : // create Section for spreadsheet (results in an extra tab page in dialog)
249 0 : SvtModuleOptions aOpt;
250 0 : OUString aAppGroupname( aStrings.GetString( 9 ) );
251 0 : aAppGroupname = aAppGroupname.replaceFirst( "%s", aOpt.GetModuleName( SvtModuleOptions::EModule::CALC ) );
252 0 : m_aUIProperties[nIdx++].Value = setGroupControlOpt("tabcontrol-page2", aAppGroupname, OUString());
253 :
254 : // show subgroup for pages
255 0 : m_aUIProperties[nIdx++].Value = setSubgroupControlOpt("pages", OUString(aStrings.GetString(0)), OUString());
256 :
257 : // create a bool option for empty pages
258 0 : m_aUIProperties[nIdx++].Value = setBoolControlOpt("suppressemptypages", OUString( aStrings.GetString( 1 ) ),
259 : ".HelpID:vcl:PrintDialog:IsSuppressEmptyPages:CheckBox",
260 : "IsSuppressEmptyPages",
261 0 : bSuppress);
262 : // show Subgroup for print content
263 0 : vcl::PrinterOptionsHelper::UIControlOptions aPrintRangeOpt;
264 0 : aPrintRangeOpt.maGroupHint = "PrintRange";
265 0 : m_aUIProperties[nIdx++].Value = setSubgroupControlOpt("printrange", OUString(aStrings.GetString(2)),
266 : OUString(),
267 0 : aPrintRangeOpt);
268 :
269 : // create a choice for the content to create
270 0 : uno::Sequence< OUString > aChoices( 3 ), aHelpIds( 3 ), aWidgetIds( 3 );
271 0 : aChoices[0] = aStrings.GetString( 3 );
272 0 : aHelpIds[0] = ".HelpID:vcl:PrintDialog:PrintContent:RadioButton:0";
273 0 : aWidgetIds[0] = "printallsheets";
274 0 : aChoices[1] = aStrings.GetString( 4 );
275 0 : aHelpIds[1] = ".HelpID:vcl:PrintDialog:PrintContent:RadioButton:1";
276 0 : aWidgetIds[1] = "printselectedsheets";
277 0 : aChoices[2] = aStrings.GetString( 5 );
278 0 : aHelpIds[2] = ".HelpID:vcl:PrintDialog:PrintContent:RadioButton:2";
279 0 : aWidgetIds[2] = "printselectedcells";
280 0 : m_aUIProperties[nIdx++].Value = setChoiceRadiosControlOpt(aWidgetIds, OUString(),
281 : aHelpIds, "PrintContent",
282 0 : aChoices, nContent );
283 :
284 : // show Subgroup for print range
285 0 : aPrintRangeOpt.mbInternalOnly = true;
286 0 : m_aUIProperties[nIdx++].Value = setSubgroupControlOpt("fromwhich", OUString(aStrings.GetString(6)),
287 : OUString(),
288 0 : aPrintRangeOpt);
289 :
290 : // create a choice for the range to print
291 0 : OUString aPrintRangeName( "PrintRange" );
292 0 : aChoices.realloc( 2 );
293 0 : aHelpIds.realloc( 2 );
294 0 : aWidgetIds.realloc( 2 );
295 0 : aChoices[0] = aStrings.GetString( 7 );
296 0 : aHelpIds[0] = ".HelpID:vcl:PrintDialog:PrintRange:RadioButton:0";
297 0 : aWidgetIds[0] = "printallpages";
298 0 : aChoices[1] = aStrings.GetString( 8 );
299 0 : aHelpIds[1] = ".HelpID:vcl:PrintDialog:PrintRange:RadioButton:1";
300 0 : aWidgetIds[1] = "printpages";
301 0 : m_aUIProperties[nIdx++].Value = setChoiceRadiosControlOpt(aWidgetIds, OUString(),
302 : aHelpIds,
303 : aPrintRangeName,
304 : aChoices,
305 0 : 0 );
306 :
307 : // create a an Edit dependent on "Pages" selected
308 0 : vcl::PrinterOptionsHelper::UIControlOptions aPageRangeOpt( aPrintRangeName, 1, true );
309 0 : m_aUIProperties[nIdx++].Value = setEditControlOpt("pagerange", OUString(),
310 : ".HelpID:vcl:PrintDialog:PageRange:Edit",
311 0 : "PageRange", OUString(), aPageRangeOpt);
312 :
313 0 : assert(nIdx == nNumProps);
314 : }
315 :
316 0 : void ScPrintUIOptions::SetDefaults()
317 : {
318 : // re-initialize the default values from print options
319 :
320 0 : const ScPrintOptions& rPrintOpt = SC_MOD()->GetPrintOptions();
321 0 : sal_Int32 nContent = rPrintOpt.GetAllSheets() ? 0 : 1;
322 0 : bool bSuppress = rPrintOpt.GetSkipEmpty();
323 :
324 0 : for (sal_Int32 nUIPos=0; nUIPos<m_aUIProperties.getLength(); ++nUIPos)
325 : {
326 0 : uno::Sequence<beans::PropertyValue> aUIProp;
327 0 : if ( m_aUIProperties[nUIPos].Value >>= aUIProp )
328 : {
329 0 : for (sal_Int32 nPropPos=0; nPropPos<aUIProp.getLength(); ++nPropPos)
330 : {
331 0 : OUString aName = aUIProp[nPropPos].Name;
332 0 : if ( aName == "Property" )
333 : {
334 0 : beans::PropertyValue aPropertyValue;
335 0 : if ( aUIProp[nPropPos].Value >>= aPropertyValue )
336 : {
337 0 : if ( aPropertyValue.Name == "PrintContent" )
338 : {
339 0 : aPropertyValue.Value <<= nContent;
340 0 : aUIProp[nPropPos].Value <<= aPropertyValue;
341 : }
342 0 : else if ( aPropertyValue.Name == "IsSuppressEmptyPages" )
343 : {
344 0 : ScUnoHelpFunctions::SetBoolInAny( aPropertyValue.Value, bSuppress );
345 0 : aUIProp[nPropPos].Value <<= aPropertyValue;
346 : }
347 0 : }
348 : }
349 0 : }
350 0 : m_aUIProperties[nUIPos].Value <<= aUIProp;
351 : }
352 0 : }
353 0 : }
354 :
355 1320 : void ScModelObj::CreateAndSet(ScDocShell* pDocSh)
356 : {
357 1320 : if (pDocSh)
358 1320 : pDocSh->SetBaseModel( new ScModelObj(pDocSh) );
359 1320 : }
360 :
361 1320 : ScModelObj::ScModelObj( ScDocShell* pDocSh ) :
362 : SfxBaseModel( pDocSh ),
363 : aPropSet( lcl_GetDocOptPropertyMap() ),
364 : pDocShell( pDocSh ),
365 : pPrintFuncCache( NULL ),
366 : pPrinterOptions( NULL ),
367 1320 : maChangesListeners( m_aMutex )
368 : {
369 : // pDocShell may be NULL if this is the base of a ScDocOptionsObj
370 1320 : if ( pDocShell )
371 : {
372 1320 : pDocShell->GetDocument().AddUnoObject(*this); // SfxModel is derived from SfxListener
373 : }
374 1320 : }
375 :
376 3723 : ScModelObj::~ScModelObj()
377 : {
378 1241 : SolarMutexGuard g;
379 :
380 1241 : if (pDocShell)
381 0 : pDocShell->GetDocument().RemoveUnoObject(*this);
382 :
383 1241 : if (xNumberAgg.is())
384 374 : xNumberAgg->setDelegator(uno::Reference<uno::XInterface>());
385 :
386 1241 : delete pPrintFuncCache;
387 1241 : delete pPrinterOptions;
388 2482 : }
389 :
390 12316 : uno::Reference< uno::XAggregation> ScModelObj::GetFormatter()
391 : {
392 : // pDocShell may be NULL if this is the base of a ScDocOptionsObj
393 12316 : if ( !xNumberAgg.is() && pDocShell )
394 : {
395 : // setDelegator veraendert den RefCount, darum eine Referenz selber halten
396 : // (direkt am m_refCount, um sich beim release nicht selbst zu loeschen)
397 430 : osl_atomic_increment( &m_refCount );
398 : // waehrend des queryInterface braucht man ein Ref auf das
399 : // SvNumberFormatsSupplierObj, sonst wird es geloescht.
400 430 : uno::Reference<util::XNumberFormatsSupplier> xFormatter(new SvNumberFormatsSupplierObj(pDocShell->GetDocument().GetFormatTable() ));
401 : {
402 430 : xNumberAgg.set(uno::Reference<uno::XAggregation>( xFormatter, uno::UNO_QUERY ));
403 : // extra block to force deletion of the temporary before setDelegator
404 : }
405 :
406 : // beim setDelegator darf die zusaetzliche Ref nicht mehr existieren
407 430 : xFormatter = NULL;
408 :
409 430 : if (xNumberAgg.is())
410 430 : xNumberAgg->setDelegator( static_cast<cppu::OWeakObject*>(this) );
411 430 : osl_atomic_decrement( &m_refCount );
412 : } // if ( !xNumberAgg.is() )
413 12316 : return xNumberAgg;
414 : }
415 :
416 1115 : ScDocument* ScModelObj::GetDocument() const
417 : {
418 1115 : if (pDocShell)
419 1115 : return &pDocShell->GetDocument();
420 0 : return NULL;
421 : }
422 :
423 760 : SfxObjectShell* ScModelObj::GetEmbeddedObject() const
424 : {
425 760 : return pDocShell;
426 : }
427 :
428 3 : void ScModelObj::UpdateAllRowHeights()
429 : {
430 3 : if (pDocShell)
431 3 : pDocShell->UpdateAllRowHeights(NULL);
432 3 : }
433 :
434 31 : void ScModelObj::BeforeXMLLoading()
435 : {
436 31 : if (pDocShell)
437 31 : pDocShell->BeforeXMLLoading();
438 31 : }
439 :
440 31 : void ScModelObj::AfterXMLLoading(bool bRet)
441 : {
442 31 : if (pDocShell)
443 31 : pDocShell->AfterXMLLoading(bRet);
444 31 : }
445 :
446 5059 : ScSheetSaveData* ScModelObj::GetSheetSaveData()
447 : {
448 5059 : if (pDocShell)
449 5059 : return pDocShell->GetSheetSaveData();
450 0 : return NULL;
451 : }
452 :
453 171 : void ScModelObj::RepaintRange( const ScRange& rRange )
454 : {
455 171 : if (pDocShell)
456 171 : pDocShell->PostPaint( rRange, PAINT_GRID );
457 171 : }
458 :
459 0 : void ScModelObj::RepaintRange( const ScRangeList& rRange )
460 : {
461 0 : if (pDocShell)
462 0 : pDocShell->PostPaint( rRange, PAINT_GRID );
463 0 : }
464 :
465 0 : void ScModelObj::paintTile( VirtualDevice& rDevice,
466 : int nOutputWidth, int nOutputHeight,
467 : int nTilePosX, int nTilePosY,
468 : long nTileWidth, long nTileHeight )
469 : {
470 : // There seems to be no clear way of getting the grid window for this
471 : // particular document, hence we need to hope we get the right window.
472 0 : ScViewData* pViewData = ScDocShell::GetViewData();
473 0 : ScGridWindow* pGridWindow = pViewData->GetActiveWin();
474 :
475 : // update the size of the area we are painting
476 : // FIXME we want to use only the minimal necessary size, like the
477 : // following; but for the moment there is too many problems with that and
478 : // interaction with editeng used for the cell editing
479 : //Size aTileSize(nOutputWidth, nOutputHeight);
480 : //if (pGridWindow->GetOutputSizePixel() != aTileSize)
481 : // pGridWindow->SetOutputSizePixel(Size(nOutputWidth, nOutputHeight));
482 : // so instead for now, set the viewport size to document size
483 0 : Size aDocSize = getDocumentSize();
484 0 : pGridWindow->SetOutputSizePixel(Size(aDocSize.Width() * pViewData->GetPPTX(), aDocSize.Height() * pViewData->GetPPTY()));
485 :
486 : pGridWindow->PaintTile( rDevice, nOutputWidth, nOutputHeight,
487 0 : nTilePosX, nTilePosY, nTileWidth, nTileHeight );
488 0 : }
489 :
490 0 : void ScModelObj::setPart( int nPart )
491 : {
492 0 : ScViewData* pViewData = ScDocShell::GetViewData();
493 0 : pViewData->SetTabNo( nPart );
494 0 : }
495 :
496 0 : int ScModelObj::getParts()
497 : {
498 0 : ScDocument& rDoc = pDocShell->GetDocument();
499 0 : return rDoc.GetTableCount();
500 : }
501 :
502 0 : int ScModelObj::getPart()
503 : {
504 0 : ScViewData* pViewData = ScDocShell::GetViewData();
505 0 : return pViewData->GetTabNo();
506 : }
507 :
508 0 : Size ScModelObj::getDocumentSize()
509 : {
510 0 : Size aSize(10, 10); // minimum size
511 :
512 0 : const ScViewData* pViewData = ScDocShell::GetViewData();
513 0 : if (!pViewData)
514 0 : return aSize;
515 :
516 0 : SCTAB nTab = pViewData->GetTabNo();
517 0 : SCCOL nEndCol = 0;
518 0 : SCROW nEndRow = 0;
519 0 : const ScDocument& rDoc = pDocShell->GetDocument();
520 :
521 0 : if (!rDoc.GetPrintArea( nTab, nEndCol, nEndRow, false ))
522 0 : return aSize;
523 :
524 : // convert to twips
525 0 : aSize.setWidth(rDoc.GetColWidth(0, nEndCol, nTab, true));
526 0 : aSize.setHeight(rDoc.GetRowHeight(0, nEndRow, nTab, true));
527 :
528 0 : return aSize;
529 : }
530 :
531 0 : void ScModelObj::registerCallback(LibreOfficeKitCallback pCallback, void* pData)
532 : {
533 0 : SolarMutexGuard aGuard;
534 0 : pDocShell->GetDocument().GetDrawLayer()->registerLibreOfficeKitCallback(pCallback, pData);
535 0 : }
536 :
537 0 : void ScModelObj::postKeyEvent(int nType, int nCharCode, int nKeyCode)
538 : {
539 0 : SolarMutexGuard aGuard;
540 :
541 : // There seems to be no clear way of getting the grid window for this
542 : // particular document, hence we need to hope we get the right window.
543 0 : ScViewData* pViewData = ScDocShell::GetViewData();
544 0 : ScGridWindow* pGridWindow = pViewData->GetActiveWin();
545 :
546 0 : if (!pGridWindow)
547 0 : return;
548 :
549 0 : KeyEvent aEvent(nCharCode, nKeyCode, 0);
550 :
551 0 : switch (nType)
552 : {
553 : case LOK_KEYEVENT_KEYINPUT:
554 0 : pGridWindow->KeyInput(aEvent);
555 0 : break;
556 : case LOK_KEYEVENT_KEYUP:
557 0 : pGridWindow->KeyUp(aEvent);
558 0 : break;
559 : default:
560 : assert(false);
561 0 : break;
562 0 : }
563 : }
564 :
565 0 : void ScModelObj::postMouseEvent(int nType, int nX, int nY, int nCount)
566 : {
567 0 : SolarMutexGuard aGuard;
568 :
569 : // There seems to be no clear way of getting the grid window for this
570 : // particular document, hence we need to hope we get the right window.
571 0 : ScViewData* pViewData = ScDocShell::GetViewData();
572 0 : ScGridWindow* pGridWindow = pViewData->GetActiveWin();
573 :
574 0 : if (!pGridWindow)
575 0 : return;
576 :
577 : // update the aLogicMode in ScViewData to something predictable
578 0 : pViewData->SetZoom(Fraction(1, 1), Fraction(1, 1), true);
579 :
580 : // Calc operates in pixels...
581 0 : MouseEvent aEvent(Point(nX * pViewData->GetPPTX(), nY * pViewData->GetPPTY()), nCount, MouseEventModifiers::SIMPLECLICK, MOUSE_LEFT);
582 :
583 0 : switch (nType)
584 : {
585 : case LOK_MOUSEEVENT_MOUSEBUTTONDOWN:
586 0 : pGridWindow->MouseButtonDown(aEvent);
587 0 : break;
588 : case LOK_MOUSEEVENT_MOUSEBUTTONUP:
589 0 : pGridWindow->MouseButtonUp(aEvent);
590 :
591 : // sometimes MouseButtonDown captures mouse and starts tracking, and VCL
592 : // will not take care of releasing that with tiled rendering
593 0 : if (pGridWindow->IsTracking())
594 0 : pGridWindow->EndTracking(TrackingEventFlags::DontCallHdl);
595 :
596 0 : break;
597 : default:
598 : assert(false);
599 0 : break;
600 0 : }
601 : }
602 :
603 0 : void ScModelObj::setTextSelection(int nType, int nX, int nY)
604 : {
605 0 : SolarMutexGuard aGuard;
606 :
607 0 : ScViewData* pViewData = ScDocShell::GetViewData();
608 0 : ScTabViewShell* pViewShell = pViewData->GetViewShell();
609 0 : ScInputHandler* pInputHandler = SC_MOD()->GetInputHdl(pViewShell);
610 0 : ScDrawView* pDrawView = pViewData->GetScDrawView();
611 :
612 : // update the aLogicMode in ScViewData to something predictable
613 0 : pViewData->SetZoom(Fraction(1, 1), Fraction(1, 1), true);
614 :
615 0 : bool bHandled = false;
616 :
617 0 : if (pInputHandler && pInputHandler->IsInputMode())
618 : {
619 : // forwarding to editeng - we are editing the cell content
620 0 : EditView* pTableView = pInputHandler->GetTableView();
621 : assert(pTableView);
622 :
623 0 : Point aPoint(convertTwipToMm100(nX), convertTwipToMm100(nY));
624 :
625 0 : if (pTableView->GetOutputArea().IsInside(aPoint))
626 : {
627 0 : switch (nType)
628 : {
629 : case LOK_SETTEXTSELECTION_START:
630 0 : pTableView->SetCursorLogicPosition(aPoint, /*bPoint=*/false, /*bClearMark=*/false);
631 0 : break;
632 : case LOK_SETTEXTSELECTION_END:
633 0 : pTableView->SetCursorLogicPosition(aPoint, /*bPoint=*/true, /*bClearMark=*/false);
634 0 : break;
635 : case LOK_SETTEXTSELECTION_RESET:
636 0 : pTableView->SetCursorLogicPosition(aPoint, /*bPoint=*/true, /*bClearMark=*/true);
637 0 : break;
638 : default:
639 : assert(false);
640 0 : break;
641 : }
642 0 : bHandled = true;
643 : }
644 : }
645 0 : else if (pDrawView && pDrawView->IsTextEdit())
646 : {
647 : // forwarding to editeng - we are editing the text in shape
648 0 : OutlinerView* pOutlinerView = pDrawView->GetTextEditOutlinerView();
649 0 : EditView& rEditView = pOutlinerView->GetEditView();
650 :
651 0 : Point aPoint(convertTwipToMm100(nX), convertTwipToMm100(nY));
652 0 : switch (nType)
653 : {
654 : case LOK_SETTEXTSELECTION_START:
655 0 : rEditView.SetCursorLogicPosition(aPoint, /*bPoint=*/false, /*bClearMark=*/false);
656 0 : break;
657 : case LOK_SETTEXTSELECTION_END:
658 0 : rEditView.SetCursorLogicPosition(aPoint, /*bPoint=*/true, /*bClearMark=*/false);
659 0 : break;
660 : case LOK_SETTEXTSELECTION_RESET:
661 0 : rEditView.SetCursorLogicPosition(aPoint, /*bPoint=*/true, /*bClearMark=*/true);
662 0 : break;
663 : default:
664 : assert(false);
665 0 : break;
666 : }
667 0 : bHandled = true;
668 : }
669 :
670 0 : if (!bHandled)
671 : {
672 : // just update the cell selection
673 0 : ScGridWindow* pGridWindow = pViewData->GetActiveWin();
674 0 : if (!pGridWindow)
675 0 : return;
676 :
677 : // move the cell selection handles
678 0 : pGridWindow->SetCellSelectionPixel(nType, nX * pViewData->GetPPTX(), nY * pViewData->GetPPTY());
679 0 : }
680 : }
681 :
682 0 : void ScModelObj::setGraphicSelection(int nType, int nX, int nY)
683 : {
684 0 : SolarMutexGuard aGuard;
685 :
686 : // There seems to be no clear way of getting the grid window for this
687 : // particular document, hence we need to hope we get the right window.
688 0 : ScViewData* pViewData = ScDocShell::GetViewData();
689 0 : ScGridWindow* pGridWindow = pViewData->GetActiveWin();
690 :
691 : // update the aLogicMode in ScViewData to something predictable
692 0 : pViewData->SetZoom(Fraction(1, 1), Fraction(1, 1), true);
693 :
694 0 : int nPixelX = nX * pViewData->GetPPTX();
695 0 : int nPixelY = nY * pViewData->GetPPTY();
696 :
697 0 : switch (nType)
698 : {
699 : case LOK_SETGRAPHICSELECTION_START:
700 : {
701 0 : MouseEvent aClickEvent(Point(nPixelX, nPixelY), 1, MouseEventModifiers::SIMPLECLICK, MOUSE_LEFT);
702 0 : pGridWindow->MouseButtonDown(aClickEvent);
703 0 : MouseEvent aMoveEvent(Point(nPixelX, nPixelY), 0, MouseEventModifiers::SIMPLEMOVE, MOUSE_LEFT);
704 0 : pGridWindow->MouseMove(aMoveEvent);
705 : }
706 0 : break;
707 : case LOK_SETGRAPHICSELECTION_END:
708 : {
709 0 : MouseEvent aMoveEvent(Point(nPixelX, nPixelY), 0, MouseEventModifiers::SIMPLEMOVE, MOUSE_LEFT);
710 0 : pGridWindow->MouseMove(aMoveEvent);
711 0 : MouseEvent aClickEvent(Point(nPixelX, nPixelY), 1, MouseEventModifiers::SIMPLECLICK, MOUSE_LEFT);
712 0 : pGridWindow->MouseButtonUp(aClickEvent);
713 : }
714 0 : break;
715 : default:
716 : assert(false);
717 0 : break;
718 0 : }
719 0 : }
720 :
721 0 : void ScModelObj::resetSelection()
722 : {
723 0 : SolarMutexGuard aGuard;
724 :
725 0 : ScViewData* pViewData = ScDocShell::GetViewData();
726 0 : ScTabViewShell* pViewShell = pViewData->GetViewShell();
727 :
728 : // deselect the shapes & texts
729 0 : ScDrawView* pDrawView = pViewShell->GetScDrawView();
730 0 : if (pDrawView)
731 : {
732 0 : pDrawView->ScEndTextEdit();
733 0 : pDrawView->UnmarkAll();
734 : }
735 : else
736 0 : pViewShell->Unmark();
737 :
738 : // and hide the cell and text selection
739 0 : pDocShell->GetDocument().GetDrawLayer()->libreOfficeKitCallback(LOK_CALLBACK_TEXT_SELECTION, "");
740 0 : }
741 :
742 0 : void ScModelObj::initializeForTiledRendering()
743 : {
744 0 : SolarMutexGuard aGuard;
745 0 : pDocShell->GetDocument().GetDrawLayer()->setTiledRendering(true);
746 :
747 : // show us the text exactly
748 0 : ScInputOptions aInputOptions(SC_MOD()->GetInputOptions());
749 0 : aInputOptions.SetTextWysiwyg(true);
750 0 : SC_MOD()->SetInputOptions(aInputOptions);
751 0 : pDocShell->CalcOutputFactor();
752 0 : }
753 :
754 270252 : uno::Any SAL_CALL ScModelObj::queryInterface( const uno::Type& rType )
755 : throw(uno::RuntimeException, std::exception)
756 : {
757 270252 : SC_QUERYINTERFACE( sheet::XSpreadsheetDocument )
758 268679 : SC_QUERYINTERFACE( document::XActionLockable )
759 267317 : SC_QUERYINTERFACE( sheet::XCalculatable )
760 267155 : SC_QUERYINTERFACE( util::XProtectable )
761 267154 : SC_QUERYINTERFACE( drawing::XDrawPagesSupplier )
762 267130 : SC_QUERYINTERFACE( sheet::XGoalSeek )
763 267127 : SC_QUERYINTERFACE( sheet::XConsolidatable )
764 267125 : SC_QUERYINTERFACE( sheet::XDocumentAuditing )
765 267124 : SC_QUERYINTERFACE( style::XStyleFamiliesSupplier )
766 265047 : SC_QUERYINTERFACE( view::XRenderable )
767 265047 : SC_QUERYINTERFACE( document::XLinkTargetSupplier )
768 265046 : SC_QUERYINTERFACE( beans::XPropertySet )
769 257360 : SC_QUERYINTERFACE( lang::XMultiServiceFactory )
770 251519 : SC_QUERYINTERFACE( lang::XServiceInfo )
771 249995 : SC_QUERYINTERFACE( util::XChangesNotifier )
772 249968 : SC_QUERYINTERFACE( sheet::opencl::XOpenCLSelection )
773 :
774 249968 : uno::Any aRet(SfxBaseModel::queryInterface( rType ));
775 499936 : if ( !aRet.hasValue()
776 33981 : && rType != cppu::UnoType<com::sun::star::document::XDocumentEventBroadcaster>::get()
777 33981 : && rType != cppu::UnoType<com::sun::star::frame::XController>::get()
778 25606 : && rType != cppu::UnoType<com::sun::star::frame::XFrame>::get()
779 17231 : && rType != cppu::UnoType<com::sun::star::script::XInvocation>::get()
780 16476 : && rType != cppu::UnoType<com::sun::star::beans::XFastPropertySet>::get()
781 266401 : && rType != cppu::UnoType<com::sun::star::awt::XWindow>::get())
782 : {
783 10158 : GetFormatter();
784 10158 : if ( xNumberAgg.is() )
785 10158 : aRet = xNumberAgg->queryAggregation( rType );
786 : }
787 :
788 249968 : return aRet;
789 : }
790 :
791 1157762 : void SAL_CALL ScModelObj::acquire() throw()
792 : {
793 1157762 : SfxBaseModel::acquire();
794 1157762 : }
795 :
796 1157526 : void SAL_CALL ScModelObj::release() throw()
797 : {
798 1157526 : SfxBaseModel::release();
799 1157526 : }
800 :
801 1492 : uno::Sequence<uno::Type> SAL_CALL ScModelObj::getTypes() throw(uno::RuntimeException, std::exception)
802 : {
803 1492 : static uno::Sequence<uno::Type> aTypes;
804 1492 : if ( aTypes.getLength() == 0 )
805 : {
806 43 : uno::Sequence<uno::Type> aParentTypes(SfxBaseModel::getTypes());
807 43 : long nParentLen = aParentTypes.getLength();
808 43 : const uno::Type* pParentPtr = aParentTypes.getConstArray();
809 :
810 86 : uno::Sequence<uno::Type> aAggTypes;
811 43 : if ( GetFormatter().is() )
812 : {
813 43 : const uno::Type& rProvType = cppu::UnoType<lang::XTypeProvider>::get();
814 43 : uno::Any aNumProv(xNumberAgg->queryAggregation(rProvType));
815 43 : if(aNumProv.getValueType() == rProvType)
816 : {
817 : uno::Reference<lang::XTypeProvider> xNumProv(
818 43 : *static_cast<uno::Reference<lang::XTypeProvider> const *>(aNumProv.getValue()));
819 43 : aAggTypes = xNumProv->getTypes();
820 43 : }
821 : }
822 43 : long nAggLen = aAggTypes.getLength();
823 43 : const uno::Type* pAggPtr = aAggTypes.getConstArray();
824 :
825 43 : const long nThisLen = 16;
826 43 : aTypes.realloc( nParentLen + nAggLen + nThisLen );
827 43 : uno::Type* pPtr = aTypes.getArray();
828 43 : pPtr[nParentLen + 0] = cppu::UnoType<sheet::XSpreadsheetDocument>::get();
829 43 : pPtr[nParentLen + 1] = cppu::UnoType<document::XActionLockable>::get();
830 43 : pPtr[nParentLen + 2] = cppu::UnoType<sheet::XCalculatable>::get();
831 43 : pPtr[nParentLen + 3] = cppu::UnoType<util::XProtectable>::get();
832 43 : pPtr[nParentLen + 4] = cppu::UnoType<drawing::XDrawPagesSupplier>::get();
833 43 : pPtr[nParentLen + 5] = cppu::UnoType<sheet::XGoalSeek>::get();
834 43 : pPtr[nParentLen + 6] = cppu::UnoType<sheet::XConsolidatable>::get();
835 43 : pPtr[nParentLen + 7] = cppu::UnoType<sheet::XDocumentAuditing>::get();
836 43 : pPtr[nParentLen + 8] = cppu::UnoType<style::XStyleFamiliesSupplier>::get();
837 43 : pPtr[nParentLen + 9] = cppu::UnoType<view::XRenderable>::get();
838 43 : pPtr[nParentLen +10] = cppu::UnoType<document::XLinkTargetSupplier>::get();
839 43 : pPtr[nParentLen +11] = cppu::UnoType<beans::XPropertySet>::get();
840 43 : pPtr[nParentLen +12] = cppu::UnoType<lang::XMultiServiceFactory>::get();
841 43 : pPtr[nParentLen +13] = cppu::UnoType<lang::XServiceInfo>::get();
842 43 : pPtr[nParentLen +14] = cppu::UnoType<util::XChangesNotifier>::get();
843 43 : pPtr[nParentLen +15] = cppu::UnoType<sheet::opencl::XOpenCLSelection>::get();
844 :
845 : long i;
846 1505 : for (i=0; i<nParentLen; i++)
847 1462 : pPtr[i] = pParentPtr[i]; // parent types first
848 :
849 258 : for (i=0; i<nAggLen; i++)
850 258 : pPtr[nParentLen+nThisLen+i] = pAggPtr[i]; // aggregated types last
851 : }
852 1492 : return aTypes;
853 : }
854 :
855 0 : uno::Sequence<sal_Int8> SAL_CALL ScModelObj::getImplementationId()
856 : throw(uno::RuntimeException, std::exception)
857 : {
858 0 : return css::uno::Sequence<sal_Int8>();
859 : }
860 :
861 81751 : void ScModelObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
862 : {
863 : // Not interested in reference update hints here
864 :
865 81751 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
866 81751 : if ( pSimpleHint )
867 : {
868 56997 : sal_uLong nId = pSimpleHint->GetId();
869 56997 : if ( nId == SFX_HINT_DYING )
870 : {
871 1289 : pDocShell = NULL; // has become invalid
872 1289 : if (xNumberAgg.is())
873 : {
874 : SvNumberFormatsSupplierObj* pNumFmt =
875 : SvNumberFormatsSupplierObj::getImplementation(
876 422 : uno::Reference<util::XNumberFormatsSupplier>(xNumberAgg, uno::UNO_QUERY) );
877 422 : if ( pNumFmt )
878 422 : pNumFmt->SetNumberFormatter( NULL );
879 : }
880 :
881 1289 : DELETEZ( pPrintFuncCache ); // must be deleted because it has a pointer to the DocShell
882 : }
883 55708 : else if ( nId == SFX_HINT_DATACHANGED )
884 : {
885 : // cached data for rendering become invalid when contents change
886 : // (if a broadcast is added to SetDrawModified, is has to be tested here, too)
887 :
888 33539 : DELETEZ( pPrintFuncCache );
889 :
890 : // handle "OnCalculate" sheet events (search also for VBA event handlers)
891 33539 : if ( pDocShell )
892 : {
893 33539 : ScDocument& rDoc = pDocShell->GetDocument();
894 33539 : if ( rDoc.GetVbaEventProcessor().is() )
895 : {
896 : // If the VBA event processor is set, HasAnyCalcNotification is much faster than HasAnySheetEventScript
897 4356 : if ( rDoc.HasAnyCalcNotification() && rDoc.HasAnySheetEventScript( SC_SHEETEVENT_CALCULATE, true ) )
898 0 : HandleCalculateEvents();
899 : }
900 : else
901 : {
902 29183 : if ( rDoc.HasAnySheetEventScript( SC_SHEETEVENT_CALCULATE ) )
903 0 : HandleCalculateEvents();
904 : }
905 : }
906 : }
907 : }
908 24754 : else if ( dynamic_cast<const ScPointerChangedHint*>(&rHint) )
909 : {
910 0 : sal_uInt16 nFlags = static_cast<const ScPointerChangedHint&>(rHint).GetFlags();
911 0 : if (nFlags & SC_POINTERCHANGED_NUMFMT)
912 : {
913 : // NumberFormatter-Pointer am Uno-Objekt neu setzen
914 :
915 0 : if (GetFormatter().is())
916 : {
917 : SvNumberFormatsSupplierObj* pNumFmt =
918 : SvNumberFormatsSupplierObj::getImplementation(
919 0 : uno::Reference<util::XNumberFormatsSupplier>(xNumberAgg, uno::UNO_QUERY) );
920 0 : if ( pNumFmt && pDocShell )
921 0 : pNumFmt->SetNumberFormatter( pDocShell->GetDocument().GetFormatTable() );
922 : }
923 : }
924 : }
925 :
926 : // always call parent - SfxBaseModel might need to handle the same hints again
927 81751 : SfxBaseModel::Notify( rBC, rHint ); // SfxBaseModel is derived from SfxListener
928 81751 : }
929 :
930 : // XSpreadsheetDocument
931 :
932 2178 : uno::Reference<sheet::XSpreadsheets> SAL_CALL ScModelObj::getSheets() throw(uno::RuntimeException, std::exception)
933 : {
934 2178 : SolarMutexGuard aGuard;
935 2178 : if (pDocShell)
936 2178 : return new ScTableSheetsObj(pDocShell);
937 0 : return NULL;
938 : }
939 :
940 : // XStyleFamiliesSupplier
941 :
942 2079 : uno::Reference<container::XNameAccess> SAL_CALL ScModelObj::getStyleFamilies()
943 : throw(uno::RuntimeException, std::exception)
944 : {
945 2079 : SolarMutexGuard aGuard;
946 2079 : if (pDocShell)
947 2079 : return new ScStyleFamiliesObj(pDocShell);
948 0 : return NULL;
949 : }
950 :
951 : // XRenderable
952 :
953 0 : static OutputDevice* lcl_GetRenderDevice( const uno::Sequence<beans::PropertyValue>& rOptions )
954 : {
955 0 : OutputDevice* pRet = NULL;
956 0 : const beans::PropertyValue* pPropArray = rOptions.getConstArray();
957 0 : long nPropCount = rOptions.getLength();
958 0 : for (long i = 0; i < nPropCount; i++)
959 : {
960 0 : const beans::PropertyValue& rProp = pPropArray[i];
961 0 : OUString aPropName(rProp.Name);
962 :
963 0 : if (aPropName == SC_UNONAME_RENDERDEV)
964 : {
965 0 : uno::Reference<awt::XDevice> xRenderDevice(rProp.Value, uno::UNO_QUERY);
966 0 : if ( xRenderDevice.is() )
967 : {
968 0 : VCLXDevice* pDevice = VCLXDevice::GetImplementation( xRenderDevice );
969 0 : if ( pDevice )
970 : {
971 0 : pRet = pDevice->GetOutputDevice();
972 0 : pRet->SetDigitLanguage( SC_MOD()->GetOptDigitLanguage() );
973 : }
974 0 : }
975 : }
976 0 : }
977 0 : return pRet;
978 : }
979 :
980 0 : static bool lcl_ParseTarget( const OUString& rTarget, ScRange& rTargetRange, Rectangle& rTargetRect,
981 : bool& rIsSheet, ScDocument* pDoc, SCTAB nSourceTab )
982 : {
983 : // test in same order as in SID_CURRENTCELL execute
984 :
985 0 : ScAddress aAddress;
986 0 : ScRangeUtil aRangeUtil;
987 : SCTAB nNameTab;
988 0 : sal_Int32 nNumeric = 0;
989 :
990 0 : bool bRangeValid = false;
991 0 : bool bRectValid = false;
992 :
993 0 : if ( rTargetRange.Parse( rTarget, pDoc ) & SCA_VALID )
994 : {
995 0 : bRangeValid = true; // range reference
996 : }
997 0 : else if ( aAddress.Parse( rTarget, pDoc ) & SCA_VALID )
998 : {
999 0 : rTargetRange = aAddress;
1000 0 : bRangeValid = true; // cell reference
1001 : }
1002 0 : else if ( ScRangeUtil::MakeRangeFromName( rTarget, pDoc, nSourceTab, rTargetRange, RUTL_NAMES ) ||
1003 0 : ScRangeUtil::MakeRangeFromName( rTarget, pDoc, nSourceTab, rTargetRange, RUTL_DBASE ) )
1004 : {
1005 0 : bRangeValid = true; // named range or database range
1006 : }
1007 0 : else if ( comphelper::string::isdigitAsciiString(rTarget) &&
1008 0 : ( nNumeric = rTarget.toInt32() ) > 0 && nNumeric <= MAXROW+1 )
1009 : {
1010 : // row number is always mapped to cell A(row) on the same sheet
1011 0 : rTargetRange = ScAddress( 0, (SCROW)(nNumeric-1), nSourceTab ); // target row number is 1-based
1012 0 : bRangeValid = true; // row number
1013 : }
1014 0 : else if ( pDoc->GetTable( rTarget, nNameTab ) )
1015 : {
1016 0 : rTargetRange = ScAddress(0,0,nNameTab);
1017 0 : bRangeValid = true; // sheet name
1018 0 : rIsSheet = true; // needs special handling (first page of the sheet)
1019 : }
1020 : else
1021 : {
1022 : // look for named drawing object
1023 :
1024 0 : ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer();
1025 0 : if ( pDrawLayer )
1026 : {
1027 0 : SCTAB nTabCount = pDoc->GetTableCount();
1028 0 : for (SCTAB i=0; i<nTabCount && !bRangeValid; i++)
1029 : {
1030 0 : SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(i));
1031 : OSL_ENSURE(pPage,"Page ?");
1032 0 : if (pPage)
1033 : {
1034 0 : SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
1035 0 : SdrObject* pObject = aIter.Next();
1036 0 : while (pObject && !bRangeValid)
1037 : {
1038 0 : if ( ScDrawLayer::GetVisibleName( pObject ) == rTarget )
1039 : {
1040 0 : rTargetRect = pObject->GetLogicRect(); // 1/100th mm
1041 0 : rTargetRange = pDoc->GetRange( i, rTargetRect ); // underlying cells
1042 0 : bRangeValid = bRectValid = true; // rectangle is valid
1043 : }
1044 0 : pObject = aIter.Next();
1045 0 : }
1046 : }
1047 : }
1048 : }
1049 : }
1050 0 : if ( bRangeValid && !bRectValid )
1051 : {
1052 : // get rectangle for cell range
1053 0 : rTargetRect = pDoc->GetMMRect( rTargetRange.aStart.Col(), rTargetRange.aStart.Row(),
1054 0 : rTargetRange.aEnd.Col(), rTargetRange.aEnd.Row(),
1055 0 : rTargetRange.aStart.Tab() );
1056 : }
1057 :
1058 0 : return bRangeValid;
1059 : }
1060 :
1061 0 : bool ScModelObj::FillRenderMarkData( const uno::Any& aSelection,
1062 : const uno::Sequence< beans::PropertyValue >& rOptions,
1063 : ScMarkData& rMark,
1064 : ScPrintSelectionStatus& rStatus, OUString& rPagesStr ) const
1065 : {
1066 : OSL_ENSURE( !rMark.IsMarked() && !rMark.IsMultiMarked(), "FillRenderMarkData: MarkData must be empty" );
1067 : OSL_ENSURE( pDocShell, "FillRenderMarkData: DocShell must be set" );
1068 :
1069 0 : bool bDone = false;
1070 :
1071 0 : uno::Reference<frame::XController> xView;
1072 :
1073 : // defaults when no options are passed: all sheets, include empty pages
1074 0 : bool bSelectedSheetsOnly = false;
1075 0 : bool bSuppressEmptyPages = true;
1076 :
1077 0 : bool bHasPrintContent = false;
1078 0 : sal_Int32 nPrintContent = 0; // all sheets / selected sheets / selected cells
1079 0 : sal_Int32 nPrintRange = 0; // all pages / pages
1080 0 : OUString aPageRange; // "pages" edit value
1081 :
1082 0 : for( sal_Int32 i = 0, nLen = rOptions.getLength(); i < nLen; i++ )
1083 : {
1084 0 : if ( rOptions[i].Name == "IsOnlySelectedSheets" )
1085 : {
1086 0 : rOptions[i].Value >>= bSelectedSheetsOnly;
1087 : }
1088 0 : else if ( rOptions[i].Name == "IsSuppressEmptyPages" )
1089 : {
1090 0 : rOptions[i].Value >>= bSuppressEmptyPages;
1091 : }
1092 0 : else if ( rOptions[i].Name == "PageRange" )
1093 : {
1094 0 : rOptions[i].Value >>= aPageRange;
1095 : }
1096 0 : else if ( rOptions[i].Name == "PrintRange" )
1097 : {
1098 0 : rOptions[i].Value >>= nPrintRange;
1099 : }
1100 0 : else if ( rOptions[i].Name == "PrintContent" )
1101 : {
1102 0 : bHasPrintContent = true;
1103 0 : rOptions[i].Value >>= nPrintContent;
1104 : }
1105 0 : else if ( rOptions[i].Name == "View" )
1106 : {
1107 0 : rOptions[i].Value >>= xView;
1108 : }
1109 : }
1110 :
1111 : // "Print Content" selection wins over "Selected Sheets" option
1112 0 : if ( bHasPrintContent )
1113 0 : bSelectedSheetsOnly = ( nPrintContent != 0 );
1114 :
1115 0 : uno::Reference<uno::XInterface> xInterface(aSelection, uno::UNO_QUERY);
1116 0 : if ( xInterface.is() )
1117 : {
1118 0 : ScCellRangesBase* pSelObj = ScCellRangesBase::getImplementation( xInterface );
1119 0 : uno::Reference< drawing::XShapes > xShapes( xInterface, uno::UNO_QUERY );
1120 0 : if ( pSelObj && pSelObj->GetDocShell() == pDocShell )
1121 : {
1122 0 : bool bSheet = ( ScTableSheetObj::getImplementation( xInterface ) != NULL );
1123 0 : bool bCursor = pSelObj->IsCursorOnly();
1124 0 : const ScRangeList& rRanges = pSelObj->GetRangeList();
1125 :
1126 0 : rMark.MarkFromRangeList( rRanges, false );
1127 0 : rMark.MarkToSimple();
1128 :
1129 0 : if ( rMark.IsMultiMarked() )
1130 : {
1131 : // #i115266# copy behavior of old printing:
1132 : // treat multiple selection like a single selection with the enclosing range
1133 0 : ScRange aMultiMarkArea;
1134 0 : rMark.GetMultiMarkArea( aMultiMarkArea );
1135 0 : rMark.ResetMark();
1136 0 : rMark.SetMarkArea( aMultiMarkArea );
1137 : }
1138 :
1139 0 : if ( rMark.IsMarked() && !rMark.IsMultiMarked() )
1140 : {
1141 : // a sheet object is treated like an empty selection: print the used area of the sheet
1142 :
1143 0 : if ( bCursor || bSheet ) // nothing selected -> use whole tables
1144 : {
1145 0 : rMark.ResetMark(); // doesn't change table selection
1146 0 : rStatus.SetMode( SC_PRINTSEL_CURSOR );
1147 : }
1148 : else
1149 0 : rStatus.SetMode( SC_PRINTSEL_RANGE );
1150 :
1151 0 : rStatus.SetRanges( rRanges );
1152 0 : bDone = true;
1153 : }
1154 : // multi selection isn't supported
1155 : }
1156 0 : else if( xShapes.is() )
1157 : {
1158 : //print a selected ole object
1159 0 : uno::Reference< container::XIndexAccess > xIndexAccess( xShapes, uno::UNO_QUERY );
1160 0 : if( xIndexAccess.is() )
1161 : {
1162 : // multi selection isn't supported yet
1163 0 : uno::Reference< drawing::XShape > xShape( xIndexAccess->getByIndex(0), uno::UNO_QUERY );
1164 0 : SvxShape* pShape = SvxShape::getImplementation( xShape );
1165 0 : if( pShape )
1166 : {
1167 0 : SdrObject *pSdrObj = pShape->GetSdrObject();
1168 0 : if( pDocShell )
1169 : {
1170 0 : ScDocument& rDoc = pDocShell->GetDocument();
1171 0 : if( pSdrObj )
1172 : {
1173 0 : Rectangle aObjRect = pSdrObj->GetCurrentBoundRect();
1174 0 : SCTAB nCurrentTab = ScDocShell::GetCurTab();
1175 0 : ScRange aRange = rDoc.GetRange( nCurrentTab, aObjRect );
1176 0 : rMark.SetMarkArea( aRange );
1177 :
1178 0 : if( rMark.IsMarked() && !rMark.IsMultiMarked() )
1179 : {
1180 0 : rStatus.SetMode( SC_PRINTSEL_RANGE_EXCLUSIVELY_OLE_AND_DRAW_OBJECTS );
1181 0 : bDone = true;
1182 : }
1183 : }
1184 : }
1185 0 : }
1186 0 : }
1187 : }
1188 0 : else if ( ScModelObj::getImplementation( xInterface ) == this )
1189 : {
1190 : // render the whole document
1191 : // -> no selection, all sheets
1192 :
1193 0 : SCTAB nTabCount = pDocShell->GetDocument().GetTableCount();
1194 0 : for (SCTAB nTab = 0; nTab < nTabCount; nTab++)
1195 0 : rMark.SelectTable( nTab, true );
1196 0 : rStatus.SetMode( SC_PRINTSEL_DOCUMENT );
1197 0 : bDone = true;
1198 0 : }
1199 : // other selection types aren't supported
1200 : }
1201 :
1202 : // restrict to selected sheets if a view is available
1203 0 : uno::Reference<sheet::XSelectedSheetsSupplier> xSelectedSheets(xView, uno::UNO_QUERY);
1204 0 : if (bSelectedSheetsOnly && xSelectedSheets.is())
1205 : {
1206 0 : uno::Sequence<sal_Int32> aSelected = xSelectedSheets->getSelectedSheets();
1207 0 : ScMarkData::MarkedTabsType aSelectedTabs;
1208 0 : SCTAB nMaxTab = pDocShell->GetDocument().GetTableCount() -1;
1209 0 : for (sal_Int32 i = 0, n = aSelected.getLength(); i < n; ++i)
1210 : {
1211 0 : SCTAB nSelected = static_cast<SCTAB>(aSelected[i]);
1212 0 : if (ValidTab(nSelected, nMaxTab))
1213 0 : aSelectedTabs.insert(static_cast<SCTAB>(aSelected[i]));
1214 : }
1215 0 : rMark.SetSelectedTabs(aSelectedTabs);
1216 : }
1217 :
1218 0 : ScPrintOptions aNewOptions;
1219 0 : aNewOptions.SetSkipEmpty( bSuppressEmptyPages );
1220 0 : aNewOptions.SetAllSheets( !bSelectedSheetsOnly );
1221 0 : rStatus.SetOptions( aNewOptions );
1222 :
1223 : // "PrintRange" enables (1) or disables (0) the "PageRange" edit
1224 0 : if ( nPrintRange == 1 )
1225 0 : rPagesStr = aPageRange;
1226 : else
1227 0 : rPagesStr.clear();
1228 :
1229 0 : return bDone;
1230 : }
1231 :
1232 0 : sal_Int32 SAL_CALL ScModelObj::getRendererCount(const uno::Any& aSelection,
1233 : const uno::Sequence<beans::PropertyValue>& rOptions)
1234 : throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception)
1235 : {
1236 0 : SolarMutexGuard aGuard;
1237 0 : if (!pDocShell)
1238 : {
1239 : throw lang::DisposedException( OUString(),
1240 0 : static_cast< sheet::XSpreadsheetDocument* >(this) );
1241 : }
1242 :
1243 0 : ScMarkData aMark;
1244 0 : ScPrintSelectionStatus aStatus;
1245 0 : OUString aPagesStr;
1246 0 : if ( !FillRenderMarkData( aSelection, rOptions, aMark, aStatus, aPagesStr ) )
1247 0 : return 0;
1248 :
1249 : // The same ScPrintFuncCache object in pPrintFuncCache is used as long as
1250 : // the same selection is used (aStatus) and the document isn't changed
1251 : // (pPrintFuncCache is cleared in Notify handler)
1252 :
1253 0 : if ( !pPrintFuncCache || !pPrintFuncCache->IsSameSelection( aStatus ) )
1254 : {
1255 0 : delete pPrintFuncCache;
1256 0 : pPrintFuncCache = new ScPrintFuncCache( pDocShell, aMark, aStatus );
1257 : }
1258 0 : sal_Int32 nPages = pPrintFuncCache->GetPageCount();
1259 :
1260 0 : sal_Int32 nSelectCount = nPages;
1261 0 : if ( !aPagesStr.isEmpty() )
1262 : {
1263 0 : StringRangeEnumerator aRangeEnum( aPagesStr, 0, nPages-1 );
1264 0 : nSelectCount = aRangeEnum.size();
1265 : }
1266 0 : return (nSelectCount > 0) ? nSelectCount : 1;
1267 : }
1268 :
1269 0 : static sal_Int32 lcl_GetRendererNum( sal_Int32 nSelRenderer, const OUString& rPagesStr, sal_Int32 nTotalPages )
1270 : {
1271 0 : if ( rPagesStr.isEmpty() )
1272 0 : return nSelRenderer;
1273 :
1274 0 : StringRangeEnumerator aRangeEnum( rPagesStr, 0, nTotalPages-1 );
1275 0 : StringRangeEnumerator::Iterator aIter = aRangeEnum.begin();
1276 0 : StringRangeEnumerator::Iterator aEnd = aRangeEnum.end();
1277 0 : for ( ; nSelRenderer > 0 && aIter != aEnd; --nSelRenderer )
1278 0 : ++aIter;
1279 :
1280 0 : return *aIter; // returns -1 if reached the end
1281 : }
1282 :
1283 0 : uno::Sequence<beans::PropertyValue> SAL_CALL ScModelObj::getRenderer( sal_Int32 nSelRenderer,
1284 : const uno::Any& aSelection, const uno::Sequence<beans::PropertyValue>& rOptions )
1285 : throw (lang::IllegalArgumentException,
1286 : uno::RuntimeException,
1287 : std::exception)
1288 : {
1289 0 : SolarMutexGuard aGuard;
1290 0 : if (!pDocShell)
1291 : {
1292 : throw lang::DisposedException( OUString(),
1293 0 : static_cast< sheet::XSpreadsheetDocument* >(this) );
1294 : }
1295 :
1296 0 : ScMarkData aMark;
1297 0 : ScPrintSelectionStatus aStatus;
1298 0 : OUString aPagesStr;
1299 : // #i115266# if FillRenderMarkData fails, keep nTotalPages at 0, but still handle getRenderer(0) below
1300 0 : long nTotalPages = 0;
1301 0 : if ( FillRenderMarkData( aSelection, rOptions, aMark, aStatus, aPagesStr ) )
1302 : {
1303 0 : if ( !pPrintFuncCache || !pPrintFuncCache->IsSameSelection( aStatus ) )
1304 : {
1305 0 : delete pPrintFuncCache;
1306 0 : pPrintFuncCache = new ScPrintFuncCache( pDocShell, aMark, aStatus );
1307 : }
1308 0 : nTotalPages = pPrintFuncCache->GetPageCount();
1309 : }
1310 0 : sal_Int32 nRenderer = lcl_GetRendererNum( nSelRenderer, aPagesStr, nTotalPages );
1311 0 : if ( nRenderer < 0 )
1312 : {
1313 0 : if ( nSelRenderer == 0 )
1314 : {
1315 : // getRenderer(0) is used to query the settings, so it must always return something
1316 :
1317 0 : SCTAB nCurTab = 0; //! use current sheet from view?
1318 0 : ScPrintFunc aDefaultFunc( pDocShell, pDocShell->GetPrinter(), nCurTab );
1319 0 : Size aTwips = aDefaultFunc.GetPageSize();
1320 0 : awt::Size aPageSize( TwipsToHMM( aTwips.Width() ), TwipsToHMM( aTwips.Height() ) );
1321 :
1322 0 : uno::Sequence<beans::PropertyValue> aSequence(1);
1323 0 : beans::PropertyValue* pArray = aSequence.getArray();
1324 0 : pArray[0].Name = SC_UNONAME_PAGESIZE;
1325 0 : pArray[0].Value <<= aPageSize;
1326 :
1327 0 : if( ! pPrinterOptions )
1328 0 : pPrinterOptions = new ScPrintUIOptions;
1329 : else
1330 0 : pPrinterOptions->SetDefaults();
1331 0 : pPrinterOptions->appendPrintUIOptions( aSequence );
1332 0 : return aSequence;
1333 : }
1334 : else
1335 0 : throw lang::IllegalArgumentException();
1336 : }
1337 :
1338 : // printer is used as device (just for page layout), draw view is not needed
1339 :
1340 0 : SCTAB nTab = pPrintFuncCache->GetTabForPage( nRenderer );
1341 :
1342 0 : ScRange aRange;
1343 0 : const ScRange* pSelRange = NULL;
1344 0 : if ( aMark.IsMarked() )
1345 : {
1346 0 : aMark.GetMarkArea( aRange );
1347 0 : pSelRange = &aRange;
1348 : }
1349 : ScPrintFunc aFunc( pDocShell, pDocShell->GetPrinter(), nTab,
1350 0 : pPrintFuncCache->GetFirstAttr(nTab), nTotalPages, pSelRange, &aStatus.GetOptions() );
1351 0 : aFunc.SetRenderFlag( true );
1352 :
1353 0 : Range aPageRange( nRenderer+1, nRenderer+1 );
1354 0 : MultiSelection aPage( aPageRange );
1355 0 : aPage.SetTotalRange( Range(0,RANGE_MAX) );
1356 0 : aPage.Select( aPageRange );
1357 :
1358 0 : long nDisplayStart = pPrintFuncCache->GetDisplayStart( nTab );
1359 0 : long nTabStart = pPrintFuncCache->GetTabStart( nTab );
1360 :
1361 0 : (void)aFunc.DoPrint( aPage, nTabStart, nDisplayStart, false, NULL );
1362 :
1363 0 : ScRange aCellRange;
1364 0 : bool bWasCellRange = aFunc.GetLastSourceRange( aCellRange );
1365 0 : Size aTwips = aFunc.GetPageSize();
1366 0 : awt::Size aPageSize( TwipsToHMM( aTwips.Width() ), TwipsToHMM( aTwips.Height() ) );
1367 :
1368 0 : long nPropCount = bWasCellRange ? 3 : 2;
1369 0 : uno::Sequence<beans::PropertyValue> aSequence(nPropCount);
1370 0 : beans::PropertyValue* pArray = aSequence.getArray();
1371 0 : pArray[0].Name = SC_UNONAME_PAGESIZE;
1372 0 : pArray[0].Value <<= aPageSize;
1373 : // #i111158# all positions are relative to the whole page, including non-printable area
1374 0 : pArray[1].Name = SC_UNONAME_INC_NP_AREA;
1375 0 : pArray[1].Value = uno::makeAny( sal_True );
1376 0 : if ( bWasCellRange )
1377 : {
1378 : table::CellRangeAddress aRangeAddress( nTab,
1379 0 : aCellRange.aStart.Col(), aCellRange.aStart.Row(),
1380 0 : aCellRange.aEnd.Col(), aCellRange.aEnd.Row() );
1381 0 : pArray[2].Name = SC_UNONAME_SOURCERANGE;
1382 0 : pArray[2].Value <<= aRangeAddress;
1383 : }
1384 :
1385 0 : if( ! pPrinterOptions )
1386 0 : pPrinterOptions = new ScPrintUIOptions;
1387 : else
1388 0 : pPrinterOptions->SetDefaults();
1389 0 : pPrinterOptions->appendPrintUIOptions( aSequence );
1390 0 : return aSequence;
1391 : }
1392 :
1393 0 : void SAL_CALL ScModelObj::render( sal_Int32 nSelRenderer, const uno::Any& aSelection,
1394 : const uno::Sequence<beans::PropertyValue>& rOptions )
1395 : throw(lang::IllegalArgumentException,
1396 : uno::RuntimeException,
1397 : std::exception)
1398 : {
1399 0 : SolarMutexGuard aGuard;
1400 0 : if (!pDocShell)
1401 : {
1402 : throw lang::DisposedException( OUString(),
1403 0 : static_cast< sheet::XSpreadsheetDocument* >(this) );
1404 : }
1405 :
1406 0 : ScMarkData aMark;
1407 0 : ScPrintSelectionStatus aStatus;
1408 0 : OUString aPagesStr;
1409 0 : if ( !FillRenderMarkData( aSelection, rOptions, aMark, aStatus, aPagesStr ) )
1410 0 : throw lang::IllegalArgumentException();
1411 :
1412 0 : if ( !pPrintFuncCache || !pPrintFuncCache->IsSameSelection( aStatus ) )
1413 : {
1414 0 : delete pPrintFuncCache;
1415 0 : pPrintFuncCache = new ScPrintFuncCache( pDocShell, aMark, aStatus );
1416 : }
1417 0 : long nTotalPages = pPrintFuncCache->GetPageCount();
1418 0 : sal_Int32 nRenderer = lcl_GetRendererNum( nSelRenderer, aPagesStr, nTotalPages );
1419 0 : if ( nRenderer < 0 )
1420 0 : throw lang::IllegalArgumentException();
1421 :
1422 0 : OutputDevice* pDev = lcl_GetRenderDevice( rOptions );
1423 0 : if ( !pDev )
1424 0 : throw lang::IllegalArgumentException();
1425 :
1426 0 : SCTAB nTab = pPrintFuncCache->GetTabForPage( nRenderer );
1427 0 : ScDocument& rDoc = pDocShell->GetDocument();
1428 :
1429 0 : FmFormView* pDrawView = NULL;
1430 :
1431 : // #114135#
1432 0 : ScDrawLayer* pModel = rDoc.GetDrawLayer();
1433 :
1434 0 : if( pModel )
1435 : {
1436 0 : pDrawView = new FmFormView( pModel, pDev );
1437 0 : pDrawView->ShowSdrPage(pDrawView->GetModel()->GetPage(nTab));
1438 0 : pDrawView->SetPrintPreview( true );
1439 : }
1440 :
1441 0 : ScRange aRange;
1442 0 : const ScRange* pSelRange = NULL;
1443 0 : if ( aMark.IsMarked() )
1444 : {
1445 0 : aMark.GetMarkArea( aRange );
1446 0 : pSelRange = &aRange;
1447 : }
1448 :
1449 : // to increase performance, ScPrintState might be used here for subsequent
1450 : // pages of the same sheet
1451 :
1452 0 : ScPrintFunc aFunc( pDev, pDocShell, nTab, pPrintFuncCache->GetFirstAttr(nTab), nTotalPages, pSelRange, &aStatus.GetOptions() );
1453 0 : aFunc.SetDrawView( pDrawView );
1454 0 : aFunc.SetRenderFlag( true );
1455 0 : if( aStatus.GetMode() == SC_PRINTSEL_RANGE_EXCLUSIVELY_OLE_AND_DRAW_OBJECTS )
1456 0 : aFunc.SetExclusivelyDrawOleAndDrawObjects();
1457 :
1458 0 : Range aPageRange( nRenderer+1, nRenderer+1 );
1459 0 : MultiSelection aPage( aPageRange );
1460 0 : aPage.SetTotalRange( Range(0,RANGE_MAX) );
1461 0 : aPage.Select( aPageRange );
1462 :
1463 0 : long nDisplayStart = pPrintFuncCache->GetDisplayStart( nTab );
1464 0 : long nTabStart = pPrintFuncCache->GetTabStart( nTab );
1465 :
1466 0 : vcl::PDFExtOutDevData* pPDFData = PTR_CAST( vcl::PDFExtOutDevData, pDev->GetExtOutDevData() );
1467 0 : if ( nRenderer == nTabStart )
1468 : {
1469 : // first page of a sheet: add outline item for the sheet name
1470 :
1471 0 : if ( pPDFData && pPDFData->GetIsExportBookmarks() )
1472 : {
1473 : // the sheet starts at the top of the page
1474 0 : Rectangle aArea( pDev->PixelToLogic( Rectangle( 0,0,0,0 ) ) );
1475 0 : sal_Int32 nDestID = pPDFData->CreateDest( aArea );
1476 0 : OUString aTabName;
1477 0 : rDoc.GetName( nTab, aTabName );
1478 0 : sal_Int32 nParent = -1; // top-level
1479 0 : pPDFData->CreateOutlineItem( nParent, aTabName, nDestID );
1480 : }
1481 : // #i56629# add the named destination stuff
1482 0 : if( pPDFData && pPDFData->GetIsExportNamedDestinations() )
1483 : {
1484 0 : Rectangle aArea( pDev->PixelToLogic( Rectangle( 0,0,0,0 ) ) );
1485 0 : OUString aTabName;
1486 0 : rDoc.GetName( nTab, aTabName );
1487 : //need the PDF page number here
1488 0 : pPDFData->CreateNamedDest( aTabName, aArea );
1489 : }
1490 : }
1491 :
1492 0 : (void)aFunc.DoPrint( aPage, nTabStart, nDisplayStart, true, NULL );
1493 :
1494 : // resolve the hyperlinks for PDF export
1495 :
1496 0 : if ( pPDFData )
1497 : {
1498 : // iterate over the hyperlinks that were output for this page
1499 :
1500 0 : std::vector< vcl::PDFExtOutDevBookmarkEntry >& rBookmarks = pPDFData->GetBookmarks();
1501 0 : std::vector< vcl::PDFExtOutDevBookmarkEntry >::iterator aIter = rBookmarks.begin();
1502 0 : std::vector< vcl::PDFExtOutDevBookmarkEntry >::iterator aIEnd = rBookmarks.end();
1503 0 : while ( aIter != aIEnd )
1504 : {
1505 0 : OUString aBookmark = aIter->aBookmark;
1506 0 : if ( aBookmark.toChar() == (sal_Unicode) '#' )
1507 : {
1508 : // try to resolve internal link
1509 :
1510 0 : OUString aTarget( aBookmark.copy( 1 ) );
1511 :
1512 0 : ScRange aTargetRange;
1513 0 : Rectangle aTargetRect; // 1/100th mm
1514 0 : bool bIsSheet = false;
1515 0 : bool bValid = lcl_ParseTarget( aTarget, aTargetRange, aTargetRect, bIsSheet, &rDoc, nTab );
1516 :
1517 0 : if ( bValid )
1518 : {
1519 0 : sal_Int32 nPage = -1;
1520 0 : Rectangle aArea;
1521 0 : if ( bIsSheet )
1522 : {
1523 : // Get first page for sheet (if nothing from that sheet is printed,
1524 : // this page can show a different sheet)
1525 0 : nPage = pPrintFuncCache->GetTabStart( aTargetRange.aStart.Tab() );
1526 0 : aArea = pDev->PixelToLogic( Rectangle( 0,0,0,0 ) );
1527 : }
1528 : else
1529 : {
1530 0 : pPrintFuncCache->InitLocations( aMark, pDev ); // does nothing if already initialized
1531 :
1532 0 : ScPrintPageLocation aLocation;
1533 0 : if ( pPrintFuncCache->FindLocation( aTargetRange.aStart, aLocation ) )
1534 : {
1535 0 : nPage = aLocation.nPage;
1536 :
1537 : // get the rectangle of the page's cell range in 1/100th mm
1538 0 : ScRange aLocRange = aLocation.aCellRange;
1539 : Rectangle aLocationMM = rDoc.GetMMRect(
1540 0 : aLocRange.aStart.Col(), aLocRange.aStart.Row(),
1541 0 : aLocRange.aEnd.Col(), aLocRange.aEnd.Row(),
1542 0 : aLocRange.aStart.Tab() );
1543 0 : Rectangle aLocationPixel = aLocation.aRectangle;
1544 :
1545 : // Scale and move the target rectangle from aLocationMM to aLocationPixel,
1546 : // to get the target rectangle in pixels.
1547 :
1548 0 : Fraction aScaleX( aLocationPixel.GetWidth(), aLocationMM.GetWidth() );
1549 0 : Fraction aScaleY( aLocationPixel.GetHeight(), aLocationMM.GetHeight() );
1550 :
1551 0 : long nX1 = aLocationPixel.Left() + (long)
1552 0 : ( Fraction( aTargetRect.Left() - aLocationMM.Left(), 1 ) * aScaleX );
1553 0 : long nX2 = aLocationPixel.Left() + (long)
1554 0 : ( Fraction( aTargetRect.Right() - aLocationMM.Left(), 1 ) * aScaleX );
1555 0 : long nY1 = aLocationPixel.Top() + (long)
1556 0 : ( Fraction( aTargetRect.Top() - aLocationMM.Top(), 1 ) * aScaleY );
1557 0 : long nY2 = aLocationPixel.Top() + (long)
1558 0 : ( Fraction( aTargetRect.Bottom() - aLocationMM.Top(), 1 ) * aScaleY );
1559 :
1560 0 : if ( nX1 > aLocationPixel.Right() ) nX1 = aLocationPixel.Right();
1561 0 : if ( nX2 > aLocationPixel.Right() ) nX2 = aLocationPixel.Right();
1562 0 : if ( nY1 > aLocationPixel.Bottom() ) nY1 = aLocationPixel.Bottom();
1563 0 : if ( nY2 > aLocationPixel.Bottom() ) nY2 = aLocationPixel.Bottom();
1564 :
1565 : // The link target area is interpreted using the device's MapMode at
1566 : // the time of the CreateDest call, so PixelToLogic can be used here,
1567 : // regardless of the MapMode that is actually selected.
1568 :
1569 0 : aArea = pDev->PixelToLogic( Rectangle( nX1, nY1, nX2, nY2 ) );
1570 : }
1571 : }
1572 :
1573 0 : if ( nPage >= 0 )
1574 0 : pPDFData->SetLinkDest( aIter->nLinkId, pPDFData->CreateDest( aArea, nPage ) );
1575 0 : }
1576 : }
1577 : else
1578 : {
1579 : // external link, use as-is
1580 0 : pPDFData->SetLinkURL( aIter->nLinkId, aBookmark );
1581 : }
1582 0 : ++aIter;
1583 0 : }
1584 0 : rBookmarks.clear();
1585 : }
1586 :
1587 0 : if ( pDrawView )
1588 0 : pDrawView->HideSdrPage();
1589 0 : delete pDrawView;
1590 0 : }
1591 :
1592 : // XLinkTargetSupplier
1593 :
1594 1 : uno::Reference<container::XNameAccess> SAL_CALL ScModelObj::getLinks() throw(uno::RuntimeException, std::exception)
1595 : {
1596 1 : SolarMutexGuard aGuard;
1597 1 : if (pDocShell)
1598 1 : return new ScLinkTargetTypesObj(pDocShell);
1599 0 : return NULL;
1600 : }
1601 :
1602 : // XActionLockable
1603 :
1604 3 : sal_Bool SAL_CALL ScModelObj::isActionLocked() throw(uno::RuntimeException, std::exception)
1605 : {
1606 3 : SolarMutexGuard aGuard;
1607 3 : bool bLocked = false;
1608 3 : if (pDocShell)
1609 3 : bLocked = ( pDocShell->GetLockCount() != 0 );
1610 3 : return bLocked;
1611 : }
1612 :
1613 685 : void SAL_CALL ScModelObj::addActionLock() throw(uno::RuntimeException, std::exception)
1614 : {
1615 685 : SolarMutexGuard aGuard;
1616 685 : if (pDocShell)
1617 685 : pDocShell->LockDocument();
1618 685 : }
1619 :
1620 679 : void SAL_CALL ScModelObj::removeActionLock() throw(uno::RuntimeException, std::exception)
1621 : {
1622 679 : SolarMutexGuard aGuard;
1623 679 : if (pDocShell)
1624 679 : pDocShell->UnlockDocument();
1625 679 : }
1626 :
1627 1 : void SAL_CALL ScModelObj::setActionLocks( sal_Int16 nLock ) throw(uno::RuntimeException, std::exception)
1628 : {
1629 1 : SolarMutexGuard aGuard;
1630 1 : if (pDocShell)
1631 1 : pDocShell->SetLockCount(nLock);
1632 1 : }
1633 :
1634 1 : sal_Int16 SAL_CALL ScModelObj::resetActionLocks() throw(uno::RuntimeException, std::exception)
1635 : {
1636 1 : SolarMutexGuard aGuard;
1637 1 : sal_uInt16 nRet = 0;
1638 1 : if (pDocShell)
1639 : {
1640 1 : nRet = pDocShell->GetLockCount();
1641 1 : pDocShell->SetLockCount(0);
1642 : }
1643 1 : return nRet;
1644 : }
1645 :
1646 285 : void SAL_CALL ScModelObj::lockControllers() throw (::com::sun::star::uno::RuntimeException, std::exception)
1647 : {
1648 285 : SolarMutexGuard aGuard;
1649 285 : SfxBaseModel::lockControllers();
1650 285 : if (pDocShell)
1651 285 : pDocShell->LockPaint();
1652 285 : }
1653 :
1654 312 : void SAL_CALL ScModelObj::unlockControllers() throw (::com::sun::star::uno::RuntimeException, std::exception)
1655 : {
1656 312 : SolarMutexGuard aGuard;
1657 312 : if (hasControllersLocked())
1658 : {
1659 285 : SfxBaseModel::unlockControllers();
1660 285 : if (pDocShell)
1661 285 : pDocShell->UnlockPaint();
1662 312 : }
1663 312 : }
1664 :
1665 : // XCalculate
1666 :
1667 4 : void SAL_CALL ScModelObj::calculate() throw(uno::RuntimeException, std::exception)
1668 : {
1669 4 : SolarMutexGuard aGuard;
1670 4 : if (pDocShell)
1671 4 : pDocShell->DoRecalc(true);
1672 : else
1673 : {
1674 : OSL_FAIL("keine DocShell"); //! Exception oder so?
1675 4 : }
1676 4 : }
1677 :
1678 4 : void SAL_CALL ScModelObj::calculateAll() throw(uno::RuntimeException, std::exception)
1679 : {
1680 4 : SolarMutexGuard aGuard;
1681 4 : if (pDocShell)
1682 4 : pDocShell->DoHardRecalc(true);
1683 : else
1684 : {
1685 : OSL_FAIL("keine DocShell"); //! Exception oder so?
1686 4 : }
1687 4 : }
1688 :
1689 9 : sal_Bool SAL_CALL ScModelObj::isAutomaticCalculationEnabled() throw(uno::RuntimeException, std::exception)
1690 : {
1691 9 : SolarMutexGuard aGuard;
1692 9 : if (pDocShell)
1693 9 : return pDocShell->GetDocument().GetAutoCalc();
1694 :
1695 : OSL_FAIL("keine DocShell"); //! Exception oder so?
1696 0 : return false;
1697 : }
1698 :
1699 152 : void SAL_CALL ScModelObj::enableAutomaticCalculation( sal_Bool bEnabledIn )
1700 : throw(uno::RuntimeException, std::exception)
1701 : {
1702 152 : bool bEnabled(bEnabledIn);
1703 152 : SolarMutexGuard aGuard;
1704 152 : if (pDocShell)
1705 : {
1706 152 : ScDocument& rDoc = pDocShell->GetDocument();
1707 152 : if ( rDoc.GetAutoCalc() != bEnabled )
1708 : {
1709 6 : rDoc.SetAutoCalc( bEnabled );
1710 6 : pDocShell->SetDocumentModified();
1711 : }
1712 : }
1713 : else
1714 : {
1715 : OSL_FAIL("keine DocShell"); //! Exception oder so?
1716 152 : }
1717 152 : }
1718 :
1719 : // XProtectable
1720 :
1721 1 : void SAL_CALL ScModelObj::protect( const OUString& aPassword ) throw(uno::RuntimeException, std::exception)
1722 : {
1723 1 : SolarMutexGuard aGuard;
1724 : // #i108245# if already protected, don't change anything
1725 1 : if ( pDocShell && !pDocShell->GetDocument().IsDocProtected() )
1726 : {
1727 1 : OUString aString(aPassword);
1728 1 : pDocShell->GetDocFunc().Protect( TABLEID_DOC, aString, true );
1729 1 : }
1730 1 : }
1731 :
1732 2 : void SAL_CALL ScModelObj::unprotect( const OUString& aPassword )
1733 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
1734 : {
1735 2 : SolarMutexGuard aGuard;
1736 2 : if (pDocShell)
1737 : {
1738 2 : OUString aString(aPassword);
1739 2 : bool bDone = pDocShell->GetDocFunc().Unprotect( TABLEID_DOC, aString, true );
1740 2 : if (!bDone)
1741 1 : throw lang::IllegalArgumentException();
1742 2 : }
1743 1 : }
1744 :
1745 3 : sal_Bool SAL_CALL ScModelObj::isProtected() throw(uno::RuntimeException, std::exception)
1746 : {
1747 3 : SolarMutexGuard aGuard;
1748 3 : if (pDocShell)
1749 3 : return pDocShell->GetDocument().IsDocProtected();
1750 :
1751 : OSL_FAIL("keine DocShell"); //! Exception oder so?
1752 0 : return false;
1753 : }
1754 :
1755 : // XDrawPagesSupplier
1756 :
1757 25 : uno::Reference<drawing::XDrawPages> SAL_CALL ScModelObj::getDrawPages() throw(uno::RuntimeException, std::exception)
1758 : {
1759 25 : SolarMutexGuard aGuard;
1760 25 : if (pDocShell)
1761 25 : return new ScDrawPagesObj(pDocShell);
1762 :
1763 : OSL_FAIL("keine DocShell"); //! Exception oder so?
1764 0 : return NULL;
1765 : }
1766 :
1767 : // XGoalSeek
1768 :
1769 5 : sheet::GoalResult SAL_CALL ScModelObj::seekGoal(
1770 : const table::CellAddress& aFormulaPosition,
1771 : const table::CellAddress& aVariablePosition,
1772 : const OUString& aGoalValue )
1773 : throw (uno::RuntimeException,
1774 : std::exception)
1775 : {
1776 5 : SolarMutexGuard aGuard;
1777 5 : sheet::GoalResult aResult;
1778 5 : aResult.Divergence = DBL_MAX; // nichts gefunden
1779 5 : if (pDocShell)
1780 : {
1781 5 : WaitObject aWait( ScDocShell::GetActiveDialogParent() );
1782 10 : OUString aGoalString(aGoalValue);
1783 5 : ScDocument& rDoc = pDocShell->GetDocument();
1784 5 : double fValue = 0.0;
1785 : bool bFound = rDoc.Solver(
1786 : (SCCOL)aFormulaPosition.Column, (SCROW)aFormulaPosition.Row, aFormulaPosition.Sheet,
1787 : (SCCOL)aVariablePosition.Column, (SCROW)aVariablePosition.Row, aVariablePosition.Sheet,
1788 5 : aGoalString, fValue );
1789 5 : aResult.Result = fValue;
1790 5 : if (bFound)
1791 9 : aResult.Divergence = 0.0; //! das ist gelogen
1792 : }
1793 5 : return aResult;
1794 : }
1795 :
1796 : // XConsolidatable
1797 :
1798 2 : uno::Reference<sheet::XConsolidationDescriptor> SAL_CALL ScModelObj::createConsolidationDescriptor(
1799 : sal_Bool bEmpty ) throw(uno::RuntimeException, std::exception)
1800 : {
1801 2 : SolarMutexGuard aGuard;
1802 2 : ScConsolidationDescriptor* pNew = new ScConsolidationDescriptor;
1803 2 : if ( pDocShell && !bEmpty )
1804 : {
1805 0 : ScDocument& rDoc = pDocShell->GetDocument();
1806 0 : const ScConsolidateParam* pParam = rDoc.GetConsolidateDlgData();
1807 0 : if (pParam)
1808 0 : pNew->SetParam( *pParam );
1809 : }
1810 2 : return pNew;
1811 : }
1812 :
1813 1 : void SAL_CALL ScModelObj::consolidate(
1814 : const uno::Reference<sheet::XConsolidationDescriptor>& xDescriptor )
1815 : throw (uno::RuntimeException, std::exception)
1816 : {
1817 1 : SolarMutexGuard aGuard;
1818 : // das koennte theoretisch ein fremdes Objekt sein, also nur das
1819 : // oeffentliche XConsolidationDescriptor Interface benutzen, um
1820 : // die Daten in ein ScConsolidationDescriptor Objekt zu kopieren:
1821 : //! wenn es schon ein ScConsolidationDescriptor ist, direkt per getImplementation?
1822 :
1823 2 : ScConsolidationDescriptor aImpl;
1824 1 : aImpl.setFunction( xDescriptor->getFunction() );
1825 1 : aImpl.setSources( xDescriptor->getSources() );
1826 1 : aImpl.setStartOutputPosition( xDescriptor->getStartOutputPosition() );
1827 1 : aImpl.setUseColumnHeaders( xDescriptor->getUseColumnHeaders() );
1828 1 : aImpl.setUseRowHeaders( xDescriptor->getUseRowHeaders() );
1829 1 : aImpl.setInsertLinks( xDescriptor->getInsertLinks() );
1830 :
1831 1 : if (pDocShell)
1832 : {
1833 1 : const ScConsolidateParam& rParam = aImpl.GetParam();
1834 1 : pDocShell->DoConsolidate( rParam, true );
1835 1 : pDocShell->GetDocument().SetConsolidateDlgData( &rParam );
1836 1 : }
1837 1 : }
1838 :
1839 : // XDocumentAuditing
1840 :
1841 1 : void SAL_CALL ScModelObj::refreshArrows() throw(uno::RuntimeException, std::exception)
1842 : {
1843 1 : SolarMutexGuard aGuard;
1844 1 : if (pDocShell)
1845 1 : pDocShell->GetDocFunc().DetectiveRefresh();
1846 1 : }
1847 :
1848 : // XViewDataSupplier
1849 938 : uno::Reference< container::XIndexAccess > SAL_CALL ScModelObj::getViewData( )
1850 : throw (uno::RuntimeException, std::exception)
1851 : {
1852 938 : uno::Reference < container::XIndexAccess > xRet( SfxBaseModel::getViewData() );
1853 :
1854 938 : if( !xRet.is() )
1855 : {
1856 240 : SolarMutexGuard aGuard;
1857 240 : if (pDocShell && pDocShell->GetCreateMode() == SfxObjectCreateMode::EMBEDDED)
1858 : {
1859 24 : uno::Reference < container::XIndexContainer > xCont = document::IndexedPropertyValues::create( ::comphelper::getProcessComponentContext() );
1860 24 : xRet.set( xCont, uno::UNO_QUERY_THROW );
1861 :
1862 48 : uno::Sequence< beans::PropertyValue > aSeq;
1863 24 : aSeq.realloc(1);
1864 48 : OUString sName;
1865 24 : pDocShell->GetDocument().GetName( pDocShell->GetDocument().GetVisibleTab(), sName );
1866 48 : OUString sOUName(sName);
1867 24 : aSeq[0].Name = SC_ACTIVETABLE;
1868 24 : aSeq[0].Value <<= sOUName;
1869 48 : xCont->insertByIndex( 0, uno::makeAny( aSeq ) );
1870 240 : }
1871 : }
1872 :
1873 938 : return xRet;
1874 : }
1875 :
1876 : // XPropertySet (Doc-Optionen)
1877 : //! auch an der Applikation anbieten?
1878 :
1879 2793 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScModelObj::getPropertySetInfo()
1880 : throw(uno::RuntimeException, std::exception)
1881 : {
1882 2793 : SolarMutexGuard aGuard;
1883 : static uno::Reference<beans::XPropertySetInfo> aRef(
1884 2793 : new SfxItemPropertySetInfo( aPropSet.getPropertyMap() ));
1885 2793 : return aRef;
1886 : }
1887 :
1888 3846 : void SAL_CALL ScModelObj::setPropertyValue(
1889 : const OUString& aPropertyName, const uno::Any& aValue )
1890 : throw(beans::UnknownPropertyException, beans::PropertyVetoException,
1891 : lang::IllegalArgumentException, lang::WrappedTargetException,
1892 : uno::RuntimeException, std::exception)
1893 : {
1894 3846 : SolarMutexGuard aGuard;
1895 7692 : OUString aString(aPropertyName);
1896 :
1897 3846 : if (pDocShell)
1898 : {
1899 3846 : ScDocument& rDoc = pDocShell->GetDocument();
1900 3846 : const ScDocOptions& rOldOpt = rDoc.GetDocOptions();
1901 3846 : ScDocOptions aNewOpt = rOldOpt;
1902 : // Don't recalculate while loading XML, when the formula text is stored
1903 : // Recalculation after loading is handled separately.
1904 3846 : bool bHardRecalc = !rDoc.IsImportingXML();
1905 :
1906 3846 : bool bOpt = ScDocOptionsHelper::setPropertyValue( aNewOpt, aPropSet.getPropertyMap(), aPropertyName, aValue );
1907 3846 : if (bOpt)
1908 : {
1909 : // done...
1910 8667 : if ( aString == SC_UNO_IGNORECASE ||
1911 5314 : aString == SC_UNONAME_REGEXP ||
1912 2309 : aString == SC_UNO_LOOKUPLABELS )
1913 1044 : bHardRecalc = false;
1914 : }
1915 841 : else if ( aString == SC_UNONAME_CLOCAL )
1916 : {
1917 6 : lang::Locale aLocale;
1918 6 : if ( aValue >>= aLocale )
1919 : {
1920 : LanguageType eLatin, eCjk, eCtl;
1921 6 : rDoc.GetLanguage( eLatin, eCjk, eCtl );
1922 6 : eLatin = ScUnoConversion::GetLanguage(aLocale);
1923 6 : rDoc.SetLanguage( eLatin, eCjk, eCtl );
1924 6 : }
1925 : }
1926 835 : else if ( aString == SC_UNO_CODENAME )
1927 : {
1928 149 : OUString sCodeName;
1929 149 : if ( aValue >>= sCodeName )
1930 149 : rDoc.SetCodeName( sCodeName );
1931 : }
1932 686 : else if ( aString == SC_UNO_CJK_CLOCAL )
1933 : {
1934 6 : lang::Locale aLocale;
1935 6 : if ( aValue >>= aLocale )
1936 : {
1937 : LanguageType eLatin, eCjk, eCtl;
1938 6 : rDoc.GetLanguage( eLatin, eCjk, eCtl );
1939 6 : eCjk = ScUnoConversion::GetLanguage(aLocale);
1940 6 : rDoc.SetLanguage( eLatin, eCjk, eCtl );
1941 6 : }
1942 : }
1943 680 : else if ( aString == SC_UNO_CTL_CLOCAL )
1944 : {
1945 6 : lang::Locale aLocale;
1946 6 : if ( aValue >>= aLocale )
1947 : {
1948 : LanguageType eLatin, eCjk, eCtl;
1949 6 : rDoc.GetLanguage( eLatin, eCjk, eCtl );
1950 6 : eCtl = ScUnoConversion::GetLanguage(aLocale);
1951 6 : rDoc.SetLanguage( eLatin, eCjk, eCtl );
1952 6 : }
1953 : }
1954 674 : else if ( aString == SC_UNO_APPLYFMDES )
1955 : {
1956 : // model is created if not there
1957 120 : ScDrawLayer* pModel = pDocShell->MakeDrawLayer();
1958 120 : pModel->SetOpenInDesignMode( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1959 :
1960 120 : SfxBindings* pBindings = pDocShell->GetViewBindings();
1961 120 : if (pBindings)
1962 5 : pBindings->Invalidate( SID_FM_OPEN_READONLY );
1963 : }
1964 554 : else if ( aString == SC_UNO_AUTOCONTFOC )
1965 : {
1966 : // model is created if not there
1967 36 : ScDrawLayer* pModel = pDocShell->MakeDrawLayer();
1968 36 : pModel->SetAutoControlFocus( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1969 :
1970 36 : SfxBindings* pBindings = pDocShell->GetViewBindings();
1971 36 : if (pBindings)
1972 5 : pBindings->Invalidate( SID_FM_AUTOCONTROLFOCUS );
1973 : }
1974 518 : else if ( aString == SC_UNO_ISLOADED )
1975 : {
1976 4 : pDocShell->SetEmpty( !ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1977 : }
1978 514 : else if ( aString == SC_UNO_ISUNDOENABLED )
1979 : {
1980 4 : bool bUndoEnabled = ScUnoHelpFunctions::GetBoolFromAny( aValue );
1981 4 : rDoc.EnableUndo( bUndoEnabled );
1982 4 : pDocShell->GetUndoManager()->SetMaxUndoActionCount(
1983 : bUndoEnabled
1984 4 : ? officecfg::Office::Common::Undo::Steps::get() : 0);
1985 : }
1986 510 : else if ( aString == SC_UNO_RECORDCHANGES )
1987 : {
1988 6 : bool bRecordChangesEnabled = ScUnoHelpFunctions::GetBoolFromAny( aValue );
1989 :
1990 6 : bool bChangeAllowed = true;
1991 6 : if (!bRecordChangesEnabled)
1992 3 : bChangeAllowed = !pDocShell->HasChangeRecordProtection();
1993 :
1994 6 : if (bChangeAllowed)
1995 5 : pDocShell->SetChangeRecording(bRecordChangesEnabled);
1996 : }
1997 504 : else if ( aString == SC_UNO_ISADJUSTHEIGHTENABLED )
1998 : {
1999 4 : bool bOldAdjustHeightEnabled = rDoc.IsAdjustHeightEnabled();
2000 4 : bool bAdjustHeightEnabled = ScUnoHelpFunctions::GetBoolFromAny( aValue );
2001 4 : if( bOldAdjustHeightEnabled != bAdjustHeightEnabled )
2002 4 : rDoc.EnableAdjustHeight( bAdjustHeightEnabled );
2003 : }
2004 500 : else if ( aString == SC_UNO_ISEXECUTELINKENABLED )
2005 : {
2006 4 : rDoc.EnableExecuteLink( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
2007 : }
2008 496 : else if ( aString == SC_UNO_ISCHANGEREADONLYENABLED )
2009 : {
2010 4 : rDoc.EnableChangeReadOnly( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
2011 : }
2012 492 : else if ( aString == "BuildId" )
2013 : {
2014 172 : aValue >>= maBuildId;
2015 : }
2016 320 : else if ( aString == "SavedObject" ) // set from chart after saving
2017 : {
2018 5 : OUString aObjName;
2019 5 : aValue >>= aObjName;
2020 5 : if ( !aObjName.isEmpty() )
2021 5 : rDoc.RestoreChartListener( aObjName );
2022 : }
2023 315 : else if ( aString == SC_UNO_INTEROPGRABBAG )
2024 : {
2025 5 : setGrabBagItem(aValue);
2026 : }
2027 :
2028 3846 : if ( aNewOpt != rOldOpt )
2029 : {
2030 778 : rDoc.SetDocOptions( aNewOpt );
2031 : //! Recalc only for options that need it?
2032 778 : if ( bHardRecalc )
2033 237 : pDocShell->DoHardRecalc( true );
2034 778 : pDocShell->SetDocumentModified();
2035 3846 : }
2036 3846 : }
2037 3846 : }
2038 :
2039 6866 : uno::Any SAL_CALL ScModelObj::getPropertyValue( const OUString& aPropertyName )
2040 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
2041 : uno::RuntimeException, std::exception)
2042 : {
2043 6866 : SolarMutexGuard aGuard;
2044 13732 : OUString aString(aPropertyName);
2045 6866 : uno::Any aRet;
2046 :
2047 6866 : if (pDocShell)
2048 : {
2049 6866 : ScDocument& rDoc = pDocShell->GetDocument();
2050 6866 : const ScDocOptions& rOpt = rDoc.GetDocOptions();
2051 6866 : aRet = ScDocOptionsHelper::getPropertyValue( rOpt, aPropSet.getPropertyMap(), aPropertyName );
2052 6866 : if ( aRet.hasValue() )
2053 : {
2054 : // done...
2055 : }
2056 5446 : else if ( aString == SC_UNONAME_CLOCAL )
2057 : {
2058 : LanguageType eLatin, eCjk, eCtl;
2059 14 : rDoc.GetLanguage( eLatin, eCjk, eCtl );
2060 :
2061 14 : lang::Locale aLocale;
2062 14 : ScUnoConversion::FillLocale( aLocale, eLatin );
2063 14 : aRet <<= aLocale;
2064 : }
2065 5432 : else if ( aString == SC_UNO_CODENAME )
2066 : {
2067 689 : OUString sCodeName = rDoc.GetCodeName();
2068 689 : aRet <<= sCodeName;
2069 : }
2070 :
2071 4743 : else if ( aString == SC_UNO_CJK_CLOCAL )
2072 : {
2073 : LanguageType eLatin, eCjk, eCtl;
2074 14 : rDoc.GetLanguage( eLatin, eCjk, eCtl );
2075 :
2076 14 : lang::Locale aLocale;
2077 14 : ScUnoConversion::FillLocale( aLocale, eCjk );
2078 14 : aRet <<= aLocale;
2079 : }
2080 4729 : else if ( aString == SC_UNO_CTL_CLOCAL )
2081 : {
2082 : LanguageType eLatin, eCjk, eCtl;
2083 14 : rDoc.GetLanguage( eLatin, eCjk, eCtl );
2084 :
2085 14 : lang::Locale aLocale;
2086 14 : ScUnoConversion::FillLocale( aLocale, eCtl );
2087 14 : aRet <<= aLocale;
2088 : }
2089 4715 : else if ( aString == SC_UNO_NAMEDRANGES )
2090 : {
2091 1561 : aRet <<= uno::Reference<sheet::XNamedRanges>(new ScGlobalNamedRangesObj( pDocShell ));
2092 : }
2093 3154 : else if ( aString == SC_UNO_DATABASERNG )
2094 : {
2095 51 : aRet <<= uno::Reference<sheet::XDatabaseRanges>(new ScDatabaseRangesObj( pDocShell ));
2096 : }
2097 3103 : else if ( aString == SC_UNO_UNNAMEDDBRNG )
2098 : {
2099 13 : aRet <<= uno::Reference<sheet::XUnnamedDatabaseRanges>(new ScUnnamedDatabaseRangesObj(pDocShell));
2100 : }
2101 3090 : else if ( aString == SC_UNO_COLLABELRNG )
2102 : {
2103 36 : aRet <<= uno::Reference<sheet::XLabelRanges>(new ScLabelRangesObj( pDocShell, true ));
2104 : }
2105 3054 : else if ( aString == SC_UNO_ROWLABELRNG )
2106 : {
2107 33 : aRet <<= uno::Reference<sheet::XLabelRanges>(new ScLabelRangesObj( pDocShell, false ));
2108 : }
2109 3021 : else if ( aString == SC_UNO_AREALINKS )
2110 : {
2111 36 : aRet <<= uno::Reference<sheet::XAreaLinks>(new ScAreaLinksObj( pDocShell ));
2112 : }
2113 2985 : else if ( aString == SC_UNO_DDELINKS )
2114 : {
2115 36 : aRet <<= uno::Reference<container::XNameAccess>(new ScDDELinksObj( pDocShell ));
2116 : }
2117 2949 : else if ( aString == SC_UNO_EXTERNALDOCLINKS )
2118 : {
2119 3 : aRet <<= uno::Reference<sheet::XExternalDocLinks>(new ScExternalDocLinksObj(pDocShell));
2120 : }
2121 2946 : else if ( aString == SC_UNO_SHEETLINKS )
2122 : {
2123 6 : aRet <<= uno::Reference<container::XNameAccess>(new ScSheetLinksObj( pDocShell ));
2124 : }
2125 2940 : else if ( aString == SC_UNO_APPLYFMDES )
2126 : {
2127 : // default for no model is TRUE
2128 14 : ScDrawLayer* pModel = rDoc.GetDrawLayer();
2129 14 : bool bOpenInDesign = pModel == nullptr || pModel->GetOpenInDesignMode();
2130 14 : ScUnoHelpFunctions::SetBoolInAny( aRet, bOpenInDesign );
2131 : }
2132 2926 : else if ( aString == SC_UNO_AUTOCONTFOC )
2133 : {
2134 : // default for no model is FALSE
2135 14 : ScDrawLayer* pModel = rDoc.GetDrawLayer();
2136 14 : bool bAutoControlFocus = pModel && pModel->GetAutoControlFocus();
2137 14 : ScUnoHelpFunctions::SetBoolInAny( aRet, bAutoControlFocus );
2138 : }
2139 2912 : else if ( aString == SC_UNO_FORBIDDEN )
2140 : {
2141 4 : aRet <<= uno::Reference<i18n::XForbiddenCharacters>(new ScForbiddenCharsObj( pDocShell ));
2142 : }
2143 2908 : else if ( aString == SC_UNO_HASDRAWPAGES )
2144 : {
2145 4 : ScUnoHelpFunctions::SetBoolInAny( aRet, (pDocShell->GetDocument().GetDrawLayer() != 0) );
2146 : }
2147 2904 : else if ( aString == SC_UNO_BASICLIBRARIES )
2148 : {
2149 155 : aRet <<= pDocShell->GetBasicContainer();
2150 : }
2151 2749 : else if ( aString == SC_UNO_DIALOGLIBRARIES )
2152 : {
2153 2 : aRet <<= pDocShell->GetDialogContainer();
2154 : }
2155 2747 : else if ( aString == SC_UNO_VBAGLOBNAME )
2156 : {
2157 : /* #i111553# This property provides the name of the constant that
2158 : will be used to store this model in the global Basic manager.
2159 : That constant will be equivalent to 'ThisComponent' but for
2160 : each application, so e.g. a 'ThisExcelDoc' and a 'ThisWordDoc'
2161 : constant can co-exist, as required by VBA. */
2162 664 : aRet <<= OUString( "ThisExcelDoc" );
2163 : }
2164 2083 : else if ( aString == SC_UNO_RUNTIMEUID )
2165 : {
2166 1120 : aRet <<= getRuntimeUID();
2167 : }
2168 963 : else if ( aString == SC_UNO_HASVALIDSIGNATURES )
2169 : {
2170 0 : aRet <<= hasValidSignatures();
2171 : }
2172 963 : else if ( aString == SC_UNO_ISLOADED )
2173 : {
2174 10 : ScUnoHelpFunctions::SetBoolInAny( aRet, !pDocShell->IsEmpty() );
2175 : }
2176 953 : else if ( aString == SC_UNO_ISUNDOENABLED )
2177 : {
2178 10 : ScUnoHelpFunctions::SetBoolInAny( aRet, rDoc.IsUndoEnabled() );
2179 : }
2180 943 : else if ( aString == SC_UNO_RECORDCHANGES )
2181 : {
2182 14 : ScUnoHelpFunctions::SetBoolInAny( aRet, pDocShell->IsChangeRecording() );
2183 : }
2184 929 : else if ( aString == SC_UNO_ISRECORDCHANGESPROTECTED )
2185 : {
2186 3 : ScUnoHelpFunctions::SetBoolInAny( aRet, pDocShell->HasChangeRecordProtection() );
2187 : }
2188 926 : else if ( aString == SC_UNO_ISADJUSTHEIGHTENABLED )
2189 : {
2190 10 : ScUnoHelpFunctions::SetBoolInAny( aRet, rDoc.IsAdjustHeightEnabled() );
2191 : }
2192 916 : else if ( aString == SC_UNO_ISEXECUTELINKENABLED )
2193 : {
2194 10 : ScUnoHelpFunctions::SetBoolInAny( aRet, rDoc.IsExecuteLinkEnabled() );
2195 : }
2196 906 : else if ( aString == SC_UNO_ISCHANGEREADONLYENABLED )
2197 : {
2198 10 : ScUnoHelpFunctions::SetBoolInAny( aRet, rDoc.IsChangeReadOnlyEnabled() );
2199 : }
2200 896 : else if ( aString == SC_UNO_REFERENCEDEVICE )
2201 : {
2202 641 : VCLXDevice* pXDev = new VCLXDevice();
2203 641 : pXDev->SetOutputDevice( rDoc.GetRefDevice() );
2204 641 : aRet <<= uno::Reference< awt::XDevice >( pXDev );
2205 : }
2206 255 : else if ( aString == "BuildId" )
2207 : {
2208 10 : aRet <<= maBuildId;
2209 : }
2210 245 : else if ( aString == "InternalDocument" )
2211 : {
2212 0 : ScUnoHelpFunctions::SetBoolInAny( aRet, (pDocShell->GetCreateMode() == SfxObjectCreateMode::INTERNAL) );
2213 : }
2214 245 : else if ( aString == SC_UNO_INTEROPGRABBAG )
2215 : {
2216 12 : getGrabBagItem(aRet);
2217 : }
2218 : }
2219 :
2220 13732 : return aRet;
2221 : }
2222 :
2223 0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScModelObj )
2224 :
2225 : // XMultiServiceFactory
2226 :
2227 6960 : css::uno::Reference<css::uno::XInterface> ScModelObj::create(
2228 : OUString const & aServiceSpecifier,
2229 : css::uno::Sequence<css::uno::Any> const * arguments)
2230 : {
2231 6960 : uno::Reference<uno::XInterface> xRet;
2232 13920 : OUString aNameStr(aServiceSpecifier);
2233 6960 : sal_uInt16 nType = ScServiceProvider::GetProviderType(aNameStr);
2234 6960 : if ( nType != SC_SERVICE_INVALID )
2235 : {
2236 : // drawing layer tables must be kept as long as the model is alive
2237 : // return stored instance if already set
2238 6474 : switch ( nType )
2239 : {
2240 30 : case SC_SERVICE_GRADTAB: xRet.set(xDrawGradTab); break;
2241 30 : case SC_SERVICE_HATCHTAB: xRet.set(xDrawHatchTab); break;
2242 31 : case SC_SERVICE_BITMAPTAB: xRet.set(xDrawBitmapTab); break;
2243 30 : case SC_SERVICE_TRGRADTAB: xRet.set(xDrawTrGradTab); break;
2244 53 : case SC_SERVICE_MARKERTAB: xRet.set(xDrawMarkerTab); break;
2245 30 : case SC_SERVICE_DASHTAB: xRet.set(xDrawDashTab); break;
2246 153 : case SC_SERVICE_CHDATAPROV: xRet.set(xChartDataProv); break;
2247 33 : case SC_SERVICE_VBAOBJECTPROVIDER: xRet.set(xObjProvider); break;
2248 : }
2249 :
2250 : // #i64497# If a chart is in a temporary document during clipoard paste,
2251 : // there should be no data provider, so that own data is used
2252 : bool bCreate =
2253 : ! ( nType == SC_SERVICE_CHDATAPROV &&
2254 6474 : ( pDocShell->GetCreateMode() == SfxObjectCreateMode::INTERNAL ));
2255 : // this should never happen, i.e. the temporary document should never be
2256 : // loaded, because this unlinks the data
2257 : OSL_ASSERT( bCreate );
2258 :
2259 6474 : if ( !xRet.is() && bCreate )
2260 : {
2261 6415 : xRet.set(ScServiceProvider::MakeInstance( nType, pDocShell ));
2262 :
2263 : // store created instance
2264 6405 : switch ( nType )
2265 : {
2266 29 : case SC_SERVICE_GRADTAB: xDrawGradTab.set(xRet); break;
2267 29 : case SC_SERVICE_HATCHTAB: xDrawHatchTab.set(xRet); break;
2268 30 : case SC_SERVICE_BITMAPTAB: xDrawBitmapTab.set(xRet); break;
2269 29 : case SC_SERVICE_TRGRADTAB: xDrawTrGradTab.set(xRet); break;
2270 51 : case SC_SERVICE_MARKERTAB: xDrawMarkerTab.set(xRet); break;
2271 29 : case SC_SERVICE_DASHTAB: xDrawDashTab.set(xRet); break;
2272 101 : case SC_SERVICE_CHDATAPROV: xChartDataProv.set(xRet); break;
2273 28 : case SC_SERVICE_VBAOBJECTPROVIDER: xObjProvider.set(xRet); break;
2274 : }
2275 : }
2276 : }
2277 : else
2278 : {
2279 : // alles was ich nicht kenn, werf ich der SvxFmMSFactory an den Hals,
2280 : // da wird dann 'ne Exception geworfen, wenn's nicht passt...
2281 :
2282 : try
2283 : {
2284 870 : xRet = arguments == 0
2285 : ? SvxFmMSFactory::createInstance(aServiceSpecifier)
2286 : : SvxFmMSFactory::createInstanceWithArguments(
2287 384 : aServiceSpecifier, *arguments);
2288 : // extra block to force deletion of the temporary before ScShapeObj ctor (setDelegator)
2289 : }
2290 102 : catch ( lang::ServiceNotRegisteredException & )
2291 : {
2292 : }
2293 :
2294 : // if the drawing factory created a shape, a ScShapeObj has to be used
2295 : // to support own properties like ImageMap:
2296 :
2297 486 : uno::Reference<drawing::XShape> xShape( xRet, uno::UNO_QUERY );
2298 486 : if ( xShape.is() )
2299 : {
2300 334 : xRet.clear(); // for aggregation, xShape must be the object's only ref
2301 334 : new ScShapeObj( xShape ); // aggregates object and modifies xShape
2302 334 : xRet.set(xShape);
2303 486 : }
2304 : }
2305 13900 : return xRet;
2306 : }
2307 :
2308 6923 : uno::Reference<uno::XInterface> SAL_CALL ScModelObj::createInstance(
2309 : const OUString& aServiceSpecifier )
2310 : throw(uno::Exception, uno::RuntimeException, std::exception)
2311 : {
2312 6923 : SolarMutexGuard aGuard;
2313 6923 : return create(aServiceSpecifier, 0);
2314 : }
2315 :
2316 37 : uno::Reference<uno::XInterface> SAL_CALL ScModelObj::createInstanceWithArguments(
2317 : const OUString& ServiceSpecifier,
2318 : const uno::Sequence<uno::Any>& aArgs )
2319 : throw(uno::Exception, uno::RuntimeException, std::exception)
2320 : {
2321 : //! unterscheiden zwischen eigenen Services und denen vom Drawing-Layer?
2322 :
2323 37 : SolarMutexGuard aGuard;
2324 37 : uno::Reference<uno::XInterface> xInt(create(ServiceSpecifier, &aArgs));
2325 :
2326 37 : if ( aArgs.getLength() )
2327 : {
2328 : // used only for cell value binding so far - it can be initialized after creating
2329 :
2330 37 : uno::Reference<lang::XInitialization> xInit( xInt, uno::UNO_QUERY );
2331 37 : if ( xInit.is() )
2332 4 : xInit->initialize( aArgs );
2333 : }
2334 :
2335 37 : return xInt;
2336 : }
2337 :
2338 96 : uno::Sequence<OUString> SAL_CALL ScModelObj::getAvailableServiceNames()
2339 : throw(uno::RuntimeException, std::exception)
2340 : {
2341 96 : SolarMutexGuard aGuard;
2342 :
2343 : //! warum sind die Parameter bei concatServiceNames nicht const ???
2344 : //! return concatServiceNames( ScServiceProvider::GetAllServiceNames(),
2345 : //! SvxFmMSFactory::getAvailableServiceNames() );
2346 :
2347 192 : uno::Sequence<OUString> aMyServices(ScServiceProvider::GetAllServiceNames());
2348 192 : uno::Sequence<OUString> aDrawServices(SvxFmMSFactory::getAvailableServiceNames());
2349 :
2350 192 : return concatServiceNames( aMyServices, aDrawServices );
2351 : }
2352 :
2353 : // XServiceInfo
2354 1 : OUString SAL_CALL ScModelObj::getImplementationName() throw(uno::RuntimeException, std::exception)
2355 : {
2356 1 : return OUString( "com.sun.star.comp.Calc.SpreadsheetDocument" );
2357 : }
2358 :
2359 1242 : sal_Bool SAL_CALL ScModelObj::supportsService( const OUString& rServiceName )
2360 : throw(uno::RuntimeException, std::exception)
2361 : {
2362 1242 : return cppu::supportsService(this, rServiceName);
2363 : }
2364 :
2365 1700 : uno::Sequence<OUString> SAL_CALL ScModelObj::getSupportedServiceNames()
2366 : throw(uno::RuntimeException, std::exception)
2367 : {
2368 1700 : uno::Sequence<OUString> aRet(3);
2369 1700 : aRet[0] = SCMODELOBJ_SERVICE;
2370 1700 : aRet[1] = SCDOCSETTINGS_SERVICE;
2371 1700 : aRet[2] = SCDOC_SERVICE;
2372 1700 : return aRet;
2373 : }
2374 :
2375 : // XUnoTunnel
2376 :
2377 32648 : sal_Int64 SAL_CALL ScModelObj::getSomething(
2378 : const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
2379 : {
2380 65296 : if ( rId.getLength() == 16 &&
2381 32648 : 0 == memcmp( getUnoTunnelId().getConstArray(),
2382 65296 : rId.getConstArray(), 16 ) )
2383 : {
2384 6740 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
2385 : }
2386 :
2387 51816 : if ( rId.getLength() == 16 &&
2388 25908 : 0 == memcmp( SfxObjectShell::getUnoTunnelId().getConstArray(),
2389 51816 : rId.getConstArray(), 16 ) )
2390 : {
2391 765 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(pDocShell ));
2392 : }
2393 :
2394 : // aggregated number formats supplier has XUnoTunnel, too
2395 : // interface from aggregated object must be obtained via queryAggregation
2396 :
2397 25143 : sal_Int64 nRet = SfxBaseModel::getSomething( rId );
2398 25143 : if ( nRet )
2399 23028 : return nRet;
2400 :
2401 2115 : if ( GetFormatter().is() )
2402 : {
2403 2115 : const uno::Type& rTunnelType = cppu::UnoType<lang::XUnoTunnel>::get();
2404 2115 : uno::Any aNumTunnel(xNumberAgg->queryAggregation(rTunnelType));
2405 2115 : if(aNumTunnel.getValueType() == rTunnelType)
2406 : {
2407 : uno::Reference<lang::XUnoTunnel> xTunnelAgg(
2408 2115 : *static_cast<uno::Reference<lang::XUnoTunnel> const *>(aNumTunnel.getValue()));
2409 2115 : return xTunnelAgg->getSomething( rId );
2410 0 : }
2411 : }
2412 :
2413 0 : return 0;
2414 : }
2415 :
2416 : namespace
2417 : {
2418 : class theScModelObjUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScModelObjUnoTunnelId> {};
2419 : }
2420 :
2421 39388 : const uno::Sequence<sal_Int8>& ScModelObj::getUnoTunnelId()
2422 : {
2423 39388 : return theScModelObjUnoTunnelId::get().getSeq();
2424 : }
2425 :
2426 6740 : ScModelObj* ScModelObj::getImplementation(const uno::Reference<uno::XInterface>& rObj)
2427 : {
2428 6740 : ScModelObj* pRet = NULL;
2429 6740 : uno::Reference<lang::XUnoTunnel> xUT(rObj, uno::UNO_QUERY);
2430 6740 : if (xUT.is())
2431 6740 : pRet = reinterpret_cast<ScModelObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
2432 6740 : return pRet;
2433 : }
2434 :
2435 : // XChangesNotifier
2436 :
2437 27 : void ScModelObj::addChangesListener( const uno::Reference< util::XChangesListener >& aListener )
2438 : throw (uno::RuntimeException, std::exception)
2439 : {
2440 27 : SolarMutexGuard aGuard;
2441 27 : maChangesListeners.addInterface( aListener );
2442 27 : }
2443 :
2444 0 : void ScModelObj::removeChangesListener( const uno::Reference< util::XChangesListener >& aListener )
2445 : throw (uno::RuntimeException, std::exception)
2446 : {
2447 0 : SolarMutexGuard aGuard;
2448 0 : maChangesListeners.removeInterface( aListener );
2449 0 : }
2450 :
2451 22 : bool ScModelObj::HasChangesListeners() const
2452 : {
2453 22 : if ( maChangesListeners.getLength() > 0 )
2454 0 : return true;
2455 :
2456 : // "change" event set in any sheet?
2457 22 : return pDocShell && pDocShell->GetDocument().HasAnySheetEventScript(SC_SHEETEVENT_CHANGE);
2458 : }
2459 :
2460 0 : void ScModelObj::NotifyChanges( const OUString& rOperation, const ScRangeList& rRanges,
2461 : const uno::Sequence< beans::PropertyValue >& rProperties )
2462 : {
2463 0 : if ( pDocShell && HasChangesListeners() )
2464 : {
2465 0 : util::ChangesEvent aEvent;
2466 0 : aEvent.Source.set( static_cast< cppu::OWeakObject* >( this ) );
2467 0 : aEvent.Base <<= aEvent.Source;
2468 :
2469 0 : size_t nRangeCount = rRanges.size();
2470 0 : aEvent.Changes.realloc( static_cast< sal_Int32 >( nRangeCount ) );
2471 0 : for ( size_t nIndex = 0; nIndex < nRangeCount; ++nIndex )
2472 : {
2473 0 : uno::Reference< table::XCellRange > xRangeObj;
2474 :
2475 0 : ScRange aRange( *rRanges[ nIndex ] );
2476 0 : if ( aRange.aStart == aRange.aEnd )
2477 : {
2478 0 : xRangeObj.set( new ScCellObj( pDocShell, aRange.aStart ) );
2479 : }
2480 : else
2481 : {
2482 0 : xRangeObj.set( new ScCellRangeObj( pDocShell, aRange ) );
2483 : }
2484 :
2485 0 : util::ElementChange& rChange = aEvent.Changes[ static_cast< sal_Int32 >( nIndex ) ];
2486 0 : rChange.Accessor <<= rOperation;
2487 0 : rChange.Element <<= rProperties;
2488 0 : rChange.ReplacedElement <<= xRangeObj;
2489 0 : }
2490 :
2491 0 : ::cppu::OInterfaceIteratorHelper aIter( maChangesListeners );
2492 0 : while ( aIter.hasMoreElements() )
2493 : {
2494 : try
2495 : {
2496 0 : static_cast< util::XChangesListener* >( aIter.next() )->changesOccurred( aEvent );
2497 : }
2498 0 : catch( uno::Exception& )
2499 : {
2500 : }
2501 0 : }
2502 : }
2503 :
2504 : // handle sheet events
2505 : //! separate method with ScMarkData? Then change HasChangesListeners back.
2506 0 : if ( rOperation == "cell-change" && pDocShell )
2507 : {
2508 0 : ScMarkData aMarkData;
2509 0 : aMarkData.MarkFromRangeList( rRanges, false );
2510 0 : ScDocument& rDoc = pDocShell->GetDocument();
2511 0 : SCTAB nTabCount = rDoc.GetTableCount();
2512 0 : ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
2513 0 : for (; itr != itrEnd && *itr < nTabCount; ++itr)
2514 : {
2515 0 : SCTAB nTab = *itr;
2516 0 : const ScSheetEvents* pEvents = rDoc.GetSheetEvents(nTab);
2517 0 : if (pEvents)
2518 : {
2519 0 : const OUString* pScript = pEvents->GetScript(SC_SHEETEVENT_CHANGE);
2520 0 : if (pScript)
2521 : {
2522 0 : ScRangeList aTabRanges; // collect ranges on this sheet
2523 0 : size_t nRangeCount = rRanges.size();
2524 0 : for ( size_t nIndex = 0; nIndex < nRangeCount; ++nIndex )
2525 : {
2526 0 : ScRange aRange( *rRanges[ nIndex ] );
2527 0 : if ( aRange.aStart.Tab() == nTab )
2528 0 : aTabRanges.Append( aRange );
2529 : }
2530 0 : size_t nTabRangeCount = aTabRanges.size();
2531 0 : if ( nTabRangeCount > 0 )
2532 : {
2533 0 : uno::Reference<uno::XInterface> xTarget;
2534 0 : if ( nTabRangeCount == 1 )
2535 : {
2536 0 : ScRange aRange( *aTabRanges[ 0 ] );
2537 0 : if ( aRange.aStart == aRange.aEnd )
2538 0 : xTarget.set( static_cast<cppu::OWeakObject*>( new ScCellObj( pDocShell, aRange.aStart ) ) );
2539 : else
2540 0 : xTarget.set( static_cast<cppu::OWeakObject*>( new ScCellRangeObj( pDocShell, aRange ) ) );
2541 : }
2542 : else
2543 0 : xTarget.set( static_cast<cppu::OWeakObject*>( new ScCellRangesObj( pDocShell, aTabRanges ) ) );
2544 :
2545 0 : uno::Sequence<uno::Any> aParams(1);
2546 0 : aParams[0] <<= xTarget;
2547 :
2548 0 : uno::Any aRet;
2549 0 : uno::Sequence<sal_Int16> aOutArgsIndex;
2550 0 : uno::Sequence<uno::Any> aOutArgs;
2551 :
2552 0 : /*ErrCode eRet =*/ pDocShell->CallXScript( *pScript, aParams, aRet, aOutArgsIndex, aOutArgs );
2553 0 : }
2554 : }
2555 : }
2556 0 : }
2557 : }
2558 0 : }
2559 :
2560 0 : void ScModelObj::HandleCalculateEvents()
2561 : {
2562 0 : if (pDocShell)
2563 : {
2564 0 : ScDocument& rDoc = pDocShell->GetDocument();
2565 : // don't call events before the document is visible
2566 : // (might also set a flag on SFX_EVENT_LOADFINISHED and only disable while loading)
2567 0 : if ( rDoc.IsDocVisible() )
2568 : {
2569 0 : SCTAB nTabCount = rDoc.GetTableCount();
2570 0 : for (SCTAB nTab = 0; nTab < nTabCount; nTab++)
2571 : {
2572 0 : if (rDoc.HasCalcNotification(nTab))
2573 : {
2574 0 : if (const ScSheetEvents* pEvents = rDoc.GetSheetEvents( nTab ))
2575 : {
2576 0 : if (const OUString* pScript = pEvents->GetScript(SC_SHEETEVENT_CALCULATE))
2577 : {
2578 0 : uno::Any aRet;
2579 0 : uno::Sequence<uno::Any> aParams;
2580 0 : uno::Sequence<sal_Int16> aOutArgsIndex;
2581 0 : uno::Sequence<uno::Any> aOutArgs;
2582 0 : pDocShell->CallXScript( *pScript, aParams, aRet, aOutArgsIndex, aOutArgs );
2583 : }
2584 : }
2585 :
2586 : try
2587 : {
2588 0 : uno::Reference< script::vba::XVBAEventProcessor > xVbaEvents( rDoc.GetVbaEventProcessor(), uno::UNO_SET_THROW );
2589 0 : uno::Sequence< uno::Any > aArgs( 1 );
2590 0 : aArgs[ 0 ] <<= nTab;
2591 0 : xVbaEvents->processVbaEvent( ScSheetEvents::GetVbaSheetEventId( SC_SHEETEVENT_CALCULATE ), aArgs );
2592 : }
2593 0 : catch( uno::Exception& )
2594 : {
2595 : }
2596 : }
2597 : }
2598 : }
2599 0 : rDoc.ResetCalcNotifications();
2600 : }
2601 0 : }
2602 :
2603 : // XOpenCLSelection
2604 :
2605 0 : sal_Bool ScModelObj::isOpenCLEnabled()
2606 : throw (uno::RuntimeException, std::exception)
2607 : {
2608 0 : return officecfg::Office::Common::Misc::UseOpenCL::get();
2609 : }
2610 :
2611 0 : void ScModelObj::enableOpenCL(sal_Bool bEnable)
2612 : throw (uno::RuntimeException, std::exception)
2613 : {
2614 0 : std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
2615 0 : officecfg::Office::Common::Misc::UseOpenCL::set(bEnable, batch);
2616 0 : batch->commit();
2617 :
2618 0 : ScCalcConfig aConfig = ScInterpreter::GetGlobalConfig();
2619 0 : if (bEnable)
2620 0 : aConfig.setOpenCLConfigToDefault();
2621 0 : ScInterpreter::SetGlobalConfig(aConfig);
2622 0 : }
2623 :
2624 0 : void ScModelObj::enableAutomaticDeviceSelection(sal_Bool bForce)
2625 : throw (uno::RuntimeException, std::exception)
2626 : {
2627 0 : ScCalcConfig aConfig = ScInterpreter::GetGlobalConfig();
2628 0 : aConfig.mbOpenCLAutoSelect = true;
2629 0 : ScInterpreter::SetGlobalConfig(aConfig);
2630 0 : ScFormulaOptions aOptions = SC_MOD()->GetFormulaOptions();
2631 0 : aOptions.SetCalcConfig(aConfig);
2632 0 : SC_MOD()->SetFormulaOptions(aOptions);
2633 : #if !HAVE_FEATURE_OPENCL
2634 : (void) bForce;
2635 : #else
2636 0 : sc::FormulaGroupInterpreter::switchOpenCLDevice(OUString(), true, bForce);
2637 : #endif
2638 0 : }
2639 :
2640 0 : void ScModelObj::disableAutomaticDeviceSelection()
2641 : throw (uno::RuntimeException, std::exception)
2642 : {
2643 0 : ScCalcConfig aConfig = ScInterpreter::GetGlobalConfig();
2644 0 : aConfig.mbOpenCLAutoSelect = false;
2645 0 : ScInterpreter::SetGlobalConfig(aConfig);
2646 0 : ScFormulaOptions aOptions = SC_MOD()->GetFormulaOptions();
2647 0 : aOptions.SetCalcConfig(aConfig);
2648 0 : SC_MOD()->SetFormulaOptions(aOptions);
2649 0 : }
2650 :
2651 0 : void ScModelObj::selectOpenCLDevice( sal_Int32 nPlatform, sal_Int32 nDevice )
2652 : throw (uno::RuntimeException, std::exception)
2653 : {
2654 0 : if(nPlatform < 0 || nDevice < 0)
2655 0 : throw uno::RuntimeException();
2656 :
2657 : #if !HAVE_FEATURE_OPENCL
2658 : throw uno::RuntimeException();
2659 : #else
2660 0 : std::vector<OpenCLPlatformInfo> aPlatformInfo;
2661 0 : sc::FormulaGroupInterpreter::fillOpenCLInfo(aPlatformInfo);
2662 0 : if(size_t(nPlatform) >= aPlatformInfo.size())
2663 0 : throw uno::RuntimeException();
2664 :
2665 0 : if(size_t(nDevice) >= aPlatformInfo[nPlatform].maDevices.size())
2666 0 : throw uno::RuntimeException();
2667 :
2668 0 : OUString aDeviceString = aPlatformInfo[nPlatform].maVendor + " " + aPlatformInfo[nPlatform].maDevices[nDevice].maName;
2669 0 : sc::FormulaGroupInterpreter::switchOpenCLDevice(aDeviceString, false);
2670 : #endif
2671 0 : }
2672 :
2673 0 : sal_Int32 ScModelObj::getPlatformID()
2674 : throw (uno::RuntimeException, std::exception)
2675 : {
2676 : #if !HAVE_FEATURE_OPENCL
2677 : return -1;
2678 : #else
2679 : sal_Int32 nPlatformId;
2680 : sal_Int32 nDeviceId;
2681 0 : sc::FormulaGroupInterpreter::getOpenCLDeviceInfo(nDeviceId, nPlatformId);
2682 0 : return nPlatformId;
2683 : #endif
2684 : }
2685 :
2686 0 : sal_Int32 ScModelObj::getDeviceID()
2687 : throw (uno::RuntimeException, std::exception)
2688 : {
2689 : #if !HAVE_FEATURE_OPENCL
2690 : return -1;
2691 : #else
2692 : sal_Int32 nPlatformId;
2693 : sal_Int32 nDeviceId;
2694 0 : sc::FormulaGroupInterpreter::getOpenCLDeviceInfo(nDeviceId, nPlatformId);
2695 0 : return nDeviceId;
2696 : #endif
2697 : }
2698 :
2699 0 : uno::Sequence< sheet::opencl::OpenCLPlatform > ScModelObj::getOpenCLPlatforms()
2700 : throw (uno::RuntimeException, std::exception)
2701 : {
2702 : #if !HAVE_FEATURE_OPENCL
2703 : return uno::Sequence<sheet::opencl::OpenCLPlatform>();
2704 : #else
2705 0 : std::vector<OpenCLPlatformInfo> aPlatformInfo;
2706 0 : sc::FormulaGroupInterpreter::fillOpenCLInfo(aPlatformInfo);
2707 :
2708 0 : uno::Sequence<sheet::opencl::OpenCLPlatform> aRet(aPlatformInfo.size());
2709 0 : for(size_t i = 0; i < aPlatformInfo.size(); ++i)
2710 : {
2711 0 : aRet[i].Name = aPlatformInfo[i].maName;
2712 0 : aRet[i].Vendor = aPlatformInfo[i].maVendor;
2713 :
2714 0 : aRet[i].Devices.realloc(aPlatformInfo[i].maDevices.size());
2715 0 : for(size_t j = 0; j < aPlatformInfo[i].maDevices.size(); ++j)
2716 : {
2717 0 : const OpenCLDeviceInfo& rDevice = aPlatformInfo[i].maDevices[j];
2718 0 : aRet[i].Devices[j].Name = rDevice.maName;
2719 0 : aRet[i].Devices[j].Vendor = rDevice.maVendor;
2720 0 : aRet[i].Devices[j].Driver = rDevice.maDriver;
2721 : }
2722 : }
2723 :
2724 0 : return aRet;
2725 : #endif
2726 : }
2727 :
2728 : namespace {
2729 :
2730 0 : void setOpcodeSubsetTest(bool bFlag)
2731 : throw (uno::RuntimeException, std::exception)
2732 : {
2733 0 : std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
2734 0 : officecfg::Office::Calc::Formula::Calculation::OpenCLSubsetOnly::set(bFlag, batch);
2735 0 : batch->commit();
2736 0 : }
2737 :
2738 : }
2739 :
2740 0 : void ScModelObj::enableOpcodeSubsetTest()
2741 : throw (uno::RuntimeException, std::exception)
2742 : {
2743 0 : setOpcodeSubsetTest(true);
2744 0 : }
2745 :
2746 0 : void ScModelObj::disableOpcodeSubsetTest()
2747 : throw (uno::RuntimeException, std::exception)
2748 : {
2749 0 : setOpcodeSubsetTest(false);
2750 0 : }
2751 :
2752 0 : sal_Bool ScModelObj::isOpcodeSubsetTested()
2753 : throw (uno::RuntimeException, std::exception)
2754 : {
2755 0 : return officecfg::Office::Calc::Formula::Calculation::OpenCLSubsetOnly::get();
2756 : }
2757 :
2758 0 : void ScModelObj::setFormulaCellNumberLimit( sal_Int32 number )
2759 : throw (uno::RuntimeException, std::exception)
2760 : {
2761 0 : std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
2762 0 : officecfg::Office::Calc::Formula::Calculation::OpenCLMinimumDataSize::set(number, batch);
2763 0 : batch->commit();
2764 0 : }
2765 :
2766 0 : sal_Int32 ScModelObj::getFormulaCellNumberLimit()
2767 : throw (uno::RuntimeException, std::exception)
2768 : {
2769 0 : return officecfg::Office::Calc::Formula::Calculation::OpenCLMinimumDataSize::get().get();
2770 : }
2771 :
2772 25 : ScDrawPagesObj::ScDrawPagesObj(ScDocShell* pDocSh) :
2773 25 : pDocShell( pDocSh )
2774 : {
2775 25 : pDocShell->GetDocument().AddUnoObject(*this);
2776 25 : }
2777 :
2778 75 : ScDrawPagesObj::~ScDrawPagesObj()
2779 : {
2780 25 : SolarMutexGuard g;
2781 :
2782 25 : if (pDocShell)
2783 18 : pDocShell->GetDocument().RemoveUnoObject(*this);
2784 50 : }
2785 :
2786 61 : void ScDrawPagesObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
2787 : {
2788 : // Referenz-Update interessiert hier nicht
2789 :
2790 61 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
2791 61 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
2792 : {
2793 7 : pDocShell = NULL; // ungueltig geworden
2794 : }
2795 61 : }
2796 :
2797 58 : uno::Reference<drawing::XDrawPage> ScDrawPagesObj::GetObjectByIndex_Impl(sal_Int32 nIndex) const
2798 : {
2799 58 : if (pDocShell)
2800 : {
2801 58 : ScDrawLayer* pDrawLayer = pDocShell->MakeDrawLayer();
2802 : OSL_ENSURE(pDrawLayer,"kann Draw-Layer nicht anlegen");
2803 58 : if ( pDrawLayer && nIndex >= 0 && nIndex < pDocShell->GetDocument().GetTableCount() )
2804 : {
2805 57 : SdrPage* pPage = pDrawLayer->GetPage((sal_uInt16)nIndex);
2806 : OSL_ENSURE(pPage,"Draw-Page nicht gefunden");
2807 57 : if (pPage)
2808 : {
2809 57 : return uno::Reference<drawing::XDrawPage> (pPage->getUnoPage(), uno::UNO_QUERY);
2810 : }
2811 : }
2812 : }
2813 1 : return NULL;
2814 : }
2815 :
2816 : // XDrawPages
2817 :
2818 7 : uno::Reference<drawing::XDrawPage> SAL_CALL ScDrawPagesObj::insertNewByIndex( sal_Int32 nPos )
2819 : throw(uno::RuntimeException, std::exception)
2820 : {
2821 7 : SolarMutexGuard aGuard;
2822 7 : uno::Reference<drawing::XDrawPage> xRet;
2823 7 : if (pDocShell)
2824 : {
2825 7 : OUString aNewName;
2826 7 : pDocShell->GetDocument().CreateValidTabName(aNewName);
2827 7 : if ( pDocShell->GetDocFunc().InsertTable( static_cast<SCTAB>(nPos),
2828 7 : aNewName, true, true ) )
2829 7 : xRet.set(GetObjectByIndex_Impl( nPos ));
2830 : }
2831 7 : return xRet;
2832 : }
2833 :
2834 1 : void SAL_CALL ScDrawPagesObj::remove( const uno::Reference<drawing::XDrawPage>& xPage )
2835 : throw(uno::RuntimeException, std::exception)
2836 : {
2837 1 : SolarMutexGuard aGuard;
2838 1 : SvxDrawPage* pImp = SvxDrawPage::getImplementation( xPage );
2839 1 : if ( pDocShell && pImp )
2840 : {
2841 1 : SdrPage* pPage = pImp->GetSdrPage();
2842 1 : if (pPage)
2843 : {
2844 1 : SCTAB nPageNum = static_cast<SCTAB>(pPage->GetPageNum());
2845 1 : pDocShell->GetDocFunc().DeleteTable( nPageNum, true, true );
2846 : }
2847 1 : }
2848 1 : }
2849 :
2850 : // XIndexAccess
2851 :
2852 23 : sal_Int32 SAL_CALL ScDrawPagesObj::getCount() throw(uno::RuntimeException, std::exception)
2853 : {
2854 23 : SolarMutexGuard aGuard;
2855 23 : if (pDocShell)
2856 23 : return pDocShell->GetDocument().GetTableCount();
2857 0 : return 0;
2858 : }
2859 :
2860 51 : uno::Any SAL_CALL ScDrawPagesObj::getByIndex( sal_Int32 nIndex )
2861 : throw(lang::IndexOutOfBoundsException,
2862 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2863 : {
2864 51 : SolarMutexGuard aGuard;
2865 102 : uno::Reference<drawing::XDrawPage> xPage(GetObjectByIndex_Impl(nIndex));
2866 51 : if (xPage.is())
2867 100 : return uno::makeAny(xPage);
2868 : else
2869 52 : throw lang::IndexOutOfBoundsException();
2870 : }
2871 :
2872 1 : uno::Type SAL_CALL ScDrawPagesObj::getElementType() throw(uno::RuntimeException, std::exception)
2873 : {
2874 1 : SolarMutexGuard aGuard;
2875 1 : return cppu::UnoType<drawing::XDrawPage>::get();
2876 : }
2877 :
2878 1 : sal_Bool SAL_CALL ScDrawPagesObj::hasElements() throw(uno::RuntimeException, std::exception)
2879 : {
2880 1 : SolarMutexGuard aGuard;
2881 1 : return ( getCount() != 0 );
2882 : }
2883 :
2884 2178 : ScTableSheetsObj::ScTableSheetsObj(ScDocShell* pDocSh) :
2885 2178 : pDocShell( pDocSh )
2886 : {
2887 2178 : pDocShell->GetDocument().AddUnoObject(*this);
2888 2178 : }
2889 :
2890 6534 : ScTableSheetsObj::~ScTableSheetsObj()
2891 : {
2892 2178 : SolarMutexGuard g;
2893 :
2894 2178 : if (pDocShell)
2895 2069 : pDocShell->GetDocument().RemoveUnoObject(*this);
2896 4356 : }
2897 :
2898 3488 : void ScTableSheetsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
2899 : {
2900 : // Referenz-Update interessiert hier nicht
2901 :
2902 3488 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
2903 3488 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
2904 : {
2905 109 : pDocShell = NULL; // ungueltig geworden
2906 : }
2907 3488 : }
2908 :
2909 : // XSpreadsheets
2910 :
2911 1744 : ScTableSheetObj* ScTableSheetsObj::GetObjectByIndex_Impl(sal_Int32 nIndex) const
2912 : {
2913 1744 : if ( pDocShell && nIndex >= 0 && nIndex < pDocShell->GetDocument().GetTableCount() )
2914 1743 : return new ScTableSheetObj( pDocShell, static_cast<SCTAB>(nIndex) );
2915 :
2916 1 : return NULL;
2917 : }
2918 :
2919 437 : ScTableSheetObj* ScTableSheetsObj::GetObjectByName_Impl(const OUString& aName) const
2920 : {
2921 437 : if (pDocShell)
2922 : {
2923 : SCTAB nIndex;
2924 437 : if ( pDocShell->GetDocument().GetTable( aName, nIndex ) )
2925 437 : return new ScTableSheetObj( pDocShell, nIndex );
2926 : }
2927 0 : return NULL;
2928 : }
2929 :
2930 137 : void SAL_CALL ScTableSheetsObj::insertNewByName( const OUString& aName, sal_Int16 nPosition )
2931 : throw(uno::RuntimeException, std::exception)
2932 : {
2933 137 : SolarMutexGuard aGuard;
2934 137 : bool bDone = false;
2935 137 : if (pDocShell)
2936 : {
2937 137 : OUString aNamStr(aName);
2938 137 : bDone = pDocShell->GetDocFunc().InsertTable( nPosition, aNamStr, true, true );
2939 : }
2940 137 : if (!bDone)
2941 0 : throw uno::RuntimeException(); // no other exceptions specified
2942 137 : }
2943 :
2944 0 : void SAL_CALL ScTableSheetsObj::moveByName( const OUString& aName, sal_Int16 nDestination )
2945 : throw(uno::RuntimeException, std::exception)
2946 : {
2947 0 : SolarMutexGuard aGuard;
2948 0 : bool bDone = false;
2949 0 : if (pDocShell)
2950 : {
2951 : SCTAB nSource;
2952 0 : if ( pDocShell->GetDocument().GetTable( aName, nSource ) )
2953 0 : bDone = pDocShell->MoveTable( nSource, nDestination, false, true );
2954 : }
2955 0 : if (!bDone)
2956 0 : throw uno::RuntimeException(); // no other exceptions specified
2957 0 : }
2958 :
2959 0 : void SAL_CALL ScTableSheetsObj::copyByName( const OUString& aName,
2960 : const OUString& aCopy, sal_Int16 nDestination )
2961 : throw(uno::RuntimeException, std::exception)
2962 : {
2963 0 : SolarMutexGuard aGuard;
2964 0 : bool bDone = false;
2965 0 : if (pDocShell)
2966 : {
2967 0 : OUString aNewStr(aCopy);
2968 : SCTAB nSource;
2969 0 : if ( pDocShell->GetDocument().GetTable( aName, nSource ) )
2970 : {
2971 0 : bDone = pDocShell->MoveTable( nSource, nDestination, true, true );
2972 0 : if (bDone)
2973 : {
2974 : // #i92477# any index past the last sheet means "append" in MoveTable
2975 0 : SCTAB nResultTab = static_cast<SCTAB>(nDestination);
2976 0 : SCTAB nTabCount = pDocShell->GetDocument().GetTableCount(); // count after copying
2977 0 : if (nResultTab >= nTabCount)
2978 0 : nResultTab = nTabCount - 1;
2979 :
2980 0 : bDone = pDocShell->GetDocFunc().RenameTable( nResultTab, aNewStr,
2981 0 : true, true );
2982 : }
2983 0 : }
2984 : }
2985 0 : if (!bDone)
2986 0 : throw uno::RuntimeException(); // no other exceptions specified
2987 0 : }
2988 :
2989 0 : void SAL_CALL ScTableSheetsObj::insertByName( const OUString& aName, const uno::Any& aElement )
2990 : throw(lang::IllegalArgumentException, container::ElementExistException,
2991 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
2992 : {
2993 0 : SolarMutexGuard aGuard;
2994 0 : bool bDone = false;
2995 0 : bool bIllArg = false;
2996 :
2997 : //! Type of aElement can be some specific interface instead of XInterface
2998 :
2999 0 : if ( pDocShell )
3000 : {
3001 0 : uno::Reference<uno::XInterface> xInterface(aElement, uno::UNO_QUERY);
3002 0 : if ( xInterface.is() )
3003 : {
3004 0 : ScTableSheetObj* pSheetObj = ScTableSheetObj::getImplementation( xInterface );
3005 0 : if ( pSheetObj && !pSheetObj->GetDocShell() ) // noch nicht eingefuegt?
3006 : {
3007 0 : ScDocument& rDoc = pDocShell->GetDocument();
3008 0 : OUString aNamStr(aName);
3009 : SCTAB nDummy;
3010 0 : if ( rDoc.GetTable( aNamStr, nDummy ) )
3011 : {
3012 : // name already exists
3013 0 : throw container::ElementExistException();
3014 : }
3015 : else
3016 : {
3017 0 : SCTAB nPosition = rDoc.GetTableCount();
3018 0 : bDone = pDocShell->GetDocFunc().InsertTable( nPosition, aNamStr,
3019 0 : true, true );
3020 0 : if (bDone)
3021 0 : pSheetObj->InitInsertSheet( pDocShell, nPosition );
3022 : // Dokument und neuen Range am Objekt setzen
3023 0 : }
3024 : }
3025 : else
3026 0 : bIllArg = true;
3027 : }
3028 : else
3029 0 : bIllArg = true;
3030 : }
3031 :
3032 0 : if (!bDone)
3033 : {
3034 0 : if (bIllArg)
3035 0 : throw lang::IllegalArgumentException();
3036 : else
3037 0 : throw uno::RuntimeException(); // ElementExistException is handled above
3038 0 : }
3039 0 : }
3040 :
3041 0 : void SAL_CALL ScTableSheetsObj::replaceByName( const OUString& aName, const uno::Any& aElement )
3042 : throw(lang::IllegalArgumentException, container::NoSuchElementException,
3043 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3044 : {
3045 0 : SolarMutexGuard aGuard;
3046 0 : bool bDone = false;
3047 0 : bool bIllArg = false;
3048 :
3049 : //! Type of aElement can be some specific interface instead of XInterface
3050 :
3051 0 : if ( pDocShell )
3052 : {
3053 0 : uno::Reference<uno::XInterface> xInterface(aElement, uno::UNO_QUERY);
3054 0 : if ( xInterface.is() )
3055 : {
3056 0 : ScTableSheetObj* pSheetObj = ScTableSheetObj::getImplementation( xInterface );
3057 0 : if ( pSheetObj && !pSheetObj->GetDocShell() ) // noch nicht eingefuegt?
3058 : {
3059 : SCTAB nPosition;
3060 0 : if ( pDocShell->GetDocument().GetTable( aName, nPosition ) )
3061 : {
3062 0 : if ( pDocShell->GetDocFunc().DeleteTable( nPosition, true, true ) )
3063 : {
3064 : // InsertTable kann jetzt eigentlich nicht schiefgehen...
3065 0 : OUString aNamStr(aName);
3066 0 : bDone = pDocShell->GetDocFunc().InsertTable( nPosition, aNamStr, true, true );
3067 0 : if (bDone)
3068 0 : pSheetObj->InitInsertSheet( pDocShell, nPosition );
3069 : }
3070 : }
3071 : else
3072 : {
3073 : // not found
3074 0 : throw container::NoSuchElementException();
3075 : }
3076 : }
3077 : else
3078 0 : bIllArg = true;
3079 : }
3080 : else
3081 0 : bIllArg = true;
3082 : }
3083 :
3084 0 : if (!bDone)
3085 : {
3086 0 : if (bIllArg)
3087 0 : throw lang::IllegalArgumentException();
3088 : else
3089 0 : throw uno::RuntimeException(); // NoSuchElementException is handled above
3090 0 : }
3091 0 : }
3092 :
3093 18 : void SAL_CALL ScTableSheetsObj::removeByName( const OUString& aName )
3094 : throw(container::NoSuchElementException,
3095 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3096 : {
3097 18 : SolarMutexGuard aGuard;
3098 18 : bool bDone = false;
3099 18 : if (pDocShell)
3100 : {
3101 : SCTAB nIndex;
3102 18 : if ( pDocShell->GetDocument().GetTable( aName, nIndex ) )
3103 17 : bDone = pDocShell->GetDocFunc().DeleteTable( nIndex, true, true );
3104 : else // not found
3105 1 : throw container::NoSuchElementException();
3106 : }
3107 :
3108 17 : if (!bDone)
3109 0 : throw uno::RuntimeException(); // NoSuchElementException is handled above
3110 17 : }
3111 :
3112 10 : sal_Int32 ScTableSheetsObj::importSheet(
3113 : const uno::Reference < sheet::XSpreadsheetDocument > & xDocSrc,
3114 : const OUString& srcName, const sal_Int32 nDestPosition )
3115 : throw( lang::IllegalArgumentException, lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception )
3116 : {
3117 : //pDocShell is the destination
3118 10 : ScDocument& rDocDest = pDocShell->GetDocument();
3119 :
3120 : // Source document docShell
3121 10 : if ( !xDocSrc.is() )
3122 0 : throw uno::RuntimeException();
3123 10 : ScModelObj* pObj = ScModelObj::getImplementation(xDocSrc);
3124 10 : ScDocShell* pDocShellSrc = static_cast<ScDocShell*>(pObj->GetEmbeddedObject());
3125 :
3126 : // SourceSheet Position and does srcName exists ?
3127 : SCTAB nIndexSrc;
3128 10 : if ( !pDocShellSrc->GetDocument().GetTable( srcName, nIndexSrc ) )
3129 0 : throw lang::IllegalArgumentException();
3130 :
3131 : // Check the validity of destination index.
3132 10 : SCTAB nCount = rDocDest.GetTableCount();
3133 10 : SCTAB nIndexDest = static_cast<SCTAB>(nDestPosition);
3134 10 : if (nIndexDest > nCount || nIndexDest < 0)
3135 0 : throw lang::IndexOutOfBoundsException();
3136 :
3137 : // Transfert Tab
3138 10 : bool bInsertNew = true;
3139 10 : bool bNotifyAndPaint = true;
3140 : pDocShell->TransferTab(
3141 10 : *pDocShellSrc, nIndexSrc, nIndexDest, bInsertNew, bNotifyAndPaint );
3142 :
3143 10 : return nIndexDest;
3144 : }
3145 :
3146 : // XCellRangesAccess
3147 :
3148 0 : uno::Reference< table::XCell > SAL_CALL ScTableSheetsObj::getCellByPosition( sal_Int32 nColumn, sal_Int32 nRow, sal_Int32 nSheet )
3149 : throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
3150 : {
3151 0 : SolarMutexGuard aGuard;
3152 0 : uno::Reference<table::XCellRange> xSheet(static_cast<ScCellRangeObj*>(GetObjectByIndex_Impl((sal_uInt16)nSheet)));
3153 0 : if (! xSheet.is())
3154 0 : throw lang::IndexOutOfBoundsException();
3155 :
3156 0 : return xSheet->getCellByPosition(nColumn, nRow);
3157 : }
3158 :
3159 0 : uno::Reference< table::XCellRange > SAL_CALL ScTableSheetsObj::getCellRangeByPosition( sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom, sal_Int32 nSheet )
3160 : throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
3161 : {
3162 0 : SolarMutexGuard aGuard;
3163 0 : uno::Reference<table::XCellRange> xSheet(static_cast<ScCellRangeObj*>(GetObjectByIndex_Impl((sal_uInt16)nSheet)));
3164 0 : if (! xSheet.is())
3165 0 : throw lang::IndexOutOfBoundsException();
3166 :
3167 0 : return xSheet->getCellRangeByPosition(nLeft, nTop, nRight, nBottom);
3168 : }
3169 :
3170 0 : uno::Sequence < uno::Reference< table::XCellRange > > SAL_CALL ScTableSheetsObj::getCellRangesByName( const OUString& aRange )
3171 : throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception)
3172 : {
3173 0 : SolarMutexGuard aGuard;
3174 0 : uno::Sequence < uno::Reference < table::XCellRange > > xRet;
3175 :
3176 0 : ScRangeList aRangeList;
3177 0 : ScDocument& rDoc = pDocShell->GetDocument();
3178 0 : if (ScRangeStringConverter::GetRangeListFromString( aRangeList, aRange, &rDoc, ::formula::FormulaGrammar::CONV_OOO, ';' ))
3179 : {
3180 0 : size_t nCount = aRangeList.size();
3181 0 : if (nCount)
3182 : {
3183 0 : xRet.realloc(nCount);
3184 0 : for( size_t nIndex = 0; nIndex < nCount; nIndex++ )
3185 : {
3186 0 : const ScRange* pRange = aRangeList[ nIndex ];
3187 0 : if( pRange )
3188 0 : xRet[nIndex] = new ScCellRangeObj(pDocShell, *pRange);
3189 : }
3190 : }
3191 : else
3192 0 : throw lang::IllegalArgumentException();
3193 : }
3194 : else
3195 0 : throw lang::IllegalArgumentException();
3196 0 : return xRet;
3197 : }
3198 :
3199 : // XEnumerationAccess
3200 :
3201 2 : uno::Reference<container::XEnumeration> SAL_CALL ScTableSheetsObj::createEnumeration()
3202 : throw(uno::RuntimeException, std::exception)
3203 : {
3204 2 : SolarMutexGuard aGuard;
3205 2 : return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.SpreadsheetsEnumeration"));
3206 : }
3207 :
3208 : // XIndexAccess
3209 :
3210 530 : sal_Int32 SAL_CALL ScTableSheetsObj::getCount() throw(uno::RuntimeException, std::exception)
3211 : {
3212 530 : SolarMutexGuard aGuard;
3213 530 : if (pDocShell)
3214 530 : return pDocShell->GetDocument().GetTableCount();
3215 0 : return 0;
3216 : }
3217 :
3218 1744 : uno::Any SAL_CALL ScTableSheetsObj::getByIndex( sal_Int32 nIndex )
3219 : throw(lang::IndexOutOfBoundsException,
3220 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3221 : {
3222 1744 : SolarMutexGuard aGuard;
3223 3488 : uno::Reference<sheet::XSpreadsheet> xSheet(GetObjectByIndex_Impl(nIndex));
3224 1744 : if (xSheet.is())
3225 3486 : return uno::makeAny(xSheet);
3226 : else
3227 1745 : throw lang::IndexOutOfBoundsException();
3228 : // return uno::Any();
3229 : }
3230 :
3231 0 : uno::Type SAL_CALL ScTableSheetsObj::getElementType() throw(uno::RuntimeException, std::exception)
3232 : {
3233 0 : SolarMutexGuard aGuard;
3234 0 : return cppu::UnoType<sheet::XSpreadsheet>::get();
3235 : }
3236 :
3237 0 : sal_Bool SAL_CALL ScTableSheetsObj::hasElements() throw(uno::RuntimeException, std::exception)
3238 : {
3239 0 : SolarMutexGuard aGuard;
3240 0 : return ( getCount() != 0 );
3241 : }
3242 :
3243 : // XNameAccess
3244 :
3245 437 : uno::Any SAL_CALL ScTableSheetsObj::getByName( const OUString& aName )
3246 : throw(container::NoSuchElementException,
3247 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3248 : {
3249 437 : SolarMutexGuard aGuard;
3250 874 : uno::Reference<sheet::XSpreadsheet> xSheet(GetObjectByName_Impl(aName));
3251 437 : if (xSheet.is())
3252 874 : return uno::makeAny(xSheet);
3253 : else
3254 437 : throw container::NoSuchElementException();
3255 : }
3256 :
3257 25 : uno::Sequence<OUString> SAL_CALL ScTableSheetsObj::getElementNames()
3258 : throw(uno::RuntimeException, std::exception)
3259 : {
3260 25 : SolarMutexGuard aGuard;
3261 25 : if (pDocShell)
3262 : {
3263 25 : ScDocument& rDoc = pDocShell->GetDocument();
3264 25 : SCTAB nCount = rDoc.GetTableCount();
3265 25 : OUString aName;
3266 50 : uno::Sequence<OUString> aSeq(nCount);
3267 25 : OUString* pAry = aSeq.getArray();
3268 50 : for (SCTAB i=0; i<nCount; i++)
3269 : {
3270 25 : rDoc.GetName( i, aName );
3271 25 : pAry[i] = aName;
3272 : }
3273 50 : return aSeq;
3274 : }
3275 0 : return uno::Sequence<OUString>();
3276 : }
3277 :
3278 148 : sal_Bool SAL_CALL ScTableSheetsObj::hasByName( const OUString& aName )
3279 : throw(uno::RuntimeException, std::exception)
3280 : {
3281 148 : SolarMutexGuard aGuard;
3282 148 : if (pDocShell)
3283 : {
3284 : SCTAB nIndex;
3285 148 : if ( pDocShell->GetDocument().GetTable( aName, nIndex ) )
3286 10 : return sal_True;
3287 : }
3288 138 : return false;
3289 : }
3290 :
3291 1508 : ScTableColumnsObj::ScTableColumnsObj(ScDocShell* pDocSh, SCTAB nT, SCCOL nSC, SCCOL nEC) :
3292 : pDocShell( pDocSh ),
3293 : nTab ( nT ),
3294 : nStartCol( nSC ),
3295 1508 : nEndCol ( nEC )
3296 : {
3297 1508 : pDocShell->GetDocument().AddUnoObject(*this);
3298 1508 : }
3299 :
3300 4524 : ScTableColumnsObj::~ScTableColumnsObj()
3301 : {
3302 1508 : SolarMutexGuard g;
3303 :
3304 1508 : if (pDocShell)
3305 1501 : pDocShell->GetDocument().RemoveUnoObject(*this);
3306 3016 : }
3307 :
3308 2744 : void ScTableColumnsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
3309 : {
3310 2744 : if ( dynamic_cast<const ScUpdateRefHint*>(&rHint) )
3311 : {
3312 : //! Referenz-Update fuer Tab und Start/Ende
3313 : }
3314 5476 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) &&
3315 2738 : static_cast<const SfxSimpleHint&>(rHint).GetId() == SFX_HINT_DYING )
3316 : {
3317 7 : pDocShell = NULL; // ungueltig geworden
3318 : }
3319 2744 : }
3320 :
3321 : // XTableColumns
3322 :
3323 1100 : ScTableColumnObj* ScTableColumnsObj::GetObjectByIndex_Impl(sal_Int32 nIndex) const
3324 : {
3325 1100 : SCCOL nCol = static_cast<SCCOL>(nIndex) + nStartCol;
3326 1100 : if ( pDocShell && nCol <= nEndCol )
3327 1098 : return new ScTableColumnObj( pDocShell, nCol, nTab );
3328 :
3329 2 : return NULL; // falscher Index
3330 : }
3331 :
3332 2 : ScTableColumnObj* ScTableColumnsObj::GetObjectByName_Impl(const OUString& aName) const
3333 : {
3334 2 : SCCOL nCol = 0;
3335 2 : OUString aString(aName);
3336 2 : if ( ::AlphaToCol( nCol, aString) )
3337 1 : if ( pDocShell && nCol >= nStartCol && nCol <= nEndCol )
3338 1 : return new ScTableColumnObj( pDocShell, nCol, nTab );
3339 :
3340 1 : return NULL;
3341 : }
3342 :
3343 6 : void SAL_CALL ScTableColumnsObj::insertByIndex( sal_Int32 nPosition, sal_Int32 nCount )
3344 : throw(uno::RuntimeException, std::exception)
3345 : {
3346 6 : SolarMutexGuard aGuard;
3347 6 : bool bDone = false;
3348 9 : if ( pDocShell && nCount > 0 && nPosition >= 0 && nStartCol+nPosition <= nEndCol &&
3349 3 : nStartCol+nPosition+nCount-1 <= MAXCOL )
3350 : {
3351 : ScRange aRange( (SCCOL)(nStartCol+nPosition), 0, nTab,
3352 3 : (SCCOL)(nStartCol+nPosition+nCount-1), MAXROW, nTab );
3353 3 : bDone = pDocShell->GetDocFunc().InsertCells( aRange, NULL, INS_INSCOLS_BEFORE, true, true );
3354 : }
3355 6 : if (!bDone)
3356 3 : throw uno::RuntimeException(); // no other exceptions specified
3357 3 : }
3358 :
3359 6 : void SAL_CALL ScTableColumnsObj::removeByIndex( sal_Int32 nIndex, sal_Int32 nCount )
3360 : throw(uno::RuntimeException, std::exception)
3361 : {
3362 6 : SolarMutexGuard aGuard;
3363 6 : bool bDone = false;
3364 : // Der zu loeschende Bereich muss innerhalb des Objekts liegen
3365 6 : if ( pDocShell && nCount > 0 && nIndex >= 0 && nStartCol+nIndex+nCount-1 <= nEndCol )
3366 : {
3367 : ScRange aRange( (SCCOL)(nStartCol+nIndex), 0, nTab,
3368 3 : (SCCOL)(nStartCol+nIndex+nCount-1), MAXROW, nTab );
3369 3 : bDone = pDocShell->GetDocFunc().DeleteCells( aRange, NULL, DEL_DELCOLS, true, true );
3370 : }
3371 6 : if (!bDone)
3372 3 : throw uno::RuntimeException(); // no other exceptions specified
3373 3 : }
3374 :
3375 : // XEnumerationAccess
3376 :
3377 2 : uno::Reference<container::XEnumeration> SAL_CALL ScTableColumnsObj::createEnumeration()
3378 : throw(uno::RuntimeException, std::exception)
3379 : {
3380 2 : SolarMutexGuard aGuard;
3381 2 : return new ScIndexEnumeration(this, OUString("com.sun.star.table.TableColumnsEnumeration"));
3382 : }
3383 :
3384 : // XIndexAccess
3385 :
3386 1190 : sal_Int32 SAL_CALL ScTableColumnsObj::getCount() throw(uno::RuntimeException, std::exception)
3387 : {
3388 1190 : SolarMutexGuard aGuard;
3389 1190 : return nEndCol - nStartCol + 1;
3390 : }
3391 :
3392 1100 : uno::Any SAL_CALL ScTableColumnsObj::getByIndex( sal_Int32 nIndex )
3393 : throw(lang::IndexOutOfBoundsException,
3394 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3395 : {
3396 1100 : SolarMutexGuard aGuard;
3397 2200 : uno::Reference<table::XCellRange> xColumn(GetObjectByIndex_Impl(nIndex));
3398 1100 : if (xColumn.is())
3399 2196 : return uno::makeAny(xColumn);
3400 : else
3401 1102 : throw lang::IndexOutOfBoundsException();
3402 : }
3403 :
3404 1 : uno::Type SAL_CALL ScTableColumnsObj::getElementType() throw(uno::RuntimeException, std::exception)
3405 : {
3406 1 : SolarMutexGuard aGuard;
3407 1 : return cppu::UnoType<table::XCellRange>::get();
3408 : }
3409 :
3410 1 : sal_Bool SAL_CALL ScTableColumnsObj::hasElements() throw(uno::RuntimeException, std::exception)
3411 : {
3412 1 : SolarMutexGuard aGuard;
3413 1 : return ( getCount() != 0 );
3414 : }
3415 :
3416 2 : uno::Any SAL_CALL ScTableColumnsObj::getByName( const OUString& aName )
3417 : throw(container::NoSuchElementException,
3418 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3419 : {
3420 2 : SolarMutexGuard aGuard;
3421 4 : uno::Reference<table::XCellRange> xColumn(GetObjectByName_Impl(aName));
3422 2 : if (xColumn.is())
3423 2 : return uno::makeAny(xColumn);
3424 : else
3425 3 : throw container::NoSuchElementException();
3426 : }
3427 :
3428 1 : uno::Sequence<OUString> SAL_CALL ScTableColumnsObj::getElementNames()
3429 : throw(uno::RuntimeException, std::exception)
3430 : {
3431 1 : SolarMutexGuard aGuard;
3432 1 : SCCOL nCount = nEndCol - nStartCol + 1;
3433 1 : uno::Sequence<OUString> aSeq(nCount);
3434 1 : OUString* pAry = aSeq.getArray();
3435 1025 : for (SCCOL i=0; i<nCount; i++)
3436 1024 : pAry[i] = ::ScColToAlpha( nStartCol + i );
3437 :
3438 1 : return aSeq;
3439 : }
3440 :
3441 2 : sal_Bool SAL_CALL ScTableColumnsObj::hasByName( const OUString& aName )
3442 : throw(uno::RuntimeException, std::exception)
3443 : {
3444 2 : SolarMutexGuard aGuard;
3445 2 : SCCOL nCol = 0;
3446 4 : OUString aString(aName);
3447 2 : if ( ::AlphaToCol( nCol, aString) )
3448 1 : if ( pDocShell && nCol >= nStartCol && nCol <= nEndCol )
3449 1 : return sal_True;
3450 :
3451 3 : return false; // nicht gefunden
3452 : }
3453 :
3454 : // XPropertySet
3455 :
3456 1310 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTableColumnsObj::getPropertySetInfo()
3457 : throw(uno::RuntimeException, std::exception)
3458 : {
3459 1310 : SolarMutexGuard aGuard;
3460 : static uno::Reference<beans::XPropertySetInfo> aRef(
3461 1310 : new SfxItemPropertySetInfo( lcl_GetColumnsPropertyMap() ));
3462 1310 : return aRef;
3463 : }
3464 :
3465 3226 : void SAL_CALL ScTableColumnsObj::setPropertyValue(
3466 : const OUString& aPropertyName, const uno::Any& aValue )
3467 : throw(beans::UnknownPropertyException, beans::PropertyVetoException,
3468 : lang::IllegalArgumentException, lang::WrappedTargetException,
3469 : uno::RuntimeException, std::exception)
3470 : {
3471 3226 : SolarMutexGuard aGuard;
3472 3226 : if (!pDocShell)
3473 0 : throw uno::RuntimeException();
3474 :
3475 6452 : std::vector<sc::ColRowSpan> aColArr(1, sc::ColRowSpan(nStartCol,nEndCol));
3476 6452 : OUString aNameString(aPropertyName);
3477 3226 : ScDocFunc& rFunc = pDocShell->GetDocFunc();
3478 :
3479 3226 : if ( aNameString == SC_UNONAME_CELLWID )
3480 : {
3481 1310 : sal_Int32 nNewWidth = 0;
3482 1310 : if ( aValue >>= nNewWidth )
3483 : rFunc.SetWidthOrHeight(
3484 1310 : true, aColArr, nTab, SC_SIZE_ORIGINAL, (sal_uInt16)HMMToTwips(nNewWidth), true, true);
3485 : }
3486 1916 : else if ( aNameString == SC_UNONAME_CELLVIS )
3487 : {
3488 1318 : bool bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue );
3489 1318 : ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT;
3490 1318 : rFunc.SetWidthOrHeight(true, aColArr, nTab, eMode, 0, true, true);
3491 : // SC_SIZE_DIRECT with size 0: hide
3492 : }
3493 598 : else if ( aNameString == SC_UNONAME_OWIDTH )
3494 : {
3495 0 : bool bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue );
3496 0 : if (bOpt)
3497 : rFunc.SetWidthOrHeight(
3498 0 : true, aColArr, nTab, SC_SIZE_OPTIMAL, STD_EXTRA_WIDTH, true, true);
3499 : // sal_False for columns currently has no effect
3500 : }
3501 598 : else if ( aNameString == SC_UNONAME_NEWPAGE || aNameString == SC_UNONAME_MANPAGE )
3502 : {
3503 : //! single function to set/remove all breaks?
3504 598 : bool bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue );
3505 15386 : for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
3506 14788 : if (bSet)
3507 0 : rFunc.InsertPageBreak( true, ScAddress(nCol,0,nTab), true, true, true );
3508 : else
3509 14788 : rFunc.RemovePageBreak( true, ScAddress(nCol,0,nTab), true, true, true );
3510 3226 : }
3511 3226 : }
3512 :
3513 26 : uno::Any SAL_CALL ScTableColumnsObj::getPropertyValue( const OUString& aPropertyName )
3514 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
3515 : uno::RuntimeException, std::exception)
3516 : {
3517 26 : SolarMutexGuard aGuard;
3518 26 : if (!pDocShell)
3519 0 : throw uno::RuntimeException();
3520 :
3521 26 : ScDocument& rDoc = pDocShell->GetDocument();
3522 52 : OUString aNameString(aPropertyName);
3523 26 : uno::Any aAny;
3524 :
3525 : //! loop over all columns for current state?
3526 :
3527 26 : if ( aNameString == SC_UNONAME_CELLWID )
3528 : {
3529 : // for hidden column, return original height
3530 0 : sal_uInt16 nWidth = rDoc.GetOriginalWidth( nStartCol, nTab );
3531 0 : aAny <<= (sal_Int32)TwipsToHMM(nWidth);
3532 : }
3533 26 : else if ( aNameString == SC_UNONAME_CELLVIS )
3534 : {
3535 26 : bool bVis = !rDoc.ColHidden(nStartCol, nTab);
3536 26 : ScUnoHelpFunctions::SetBoolInAny( aAny, bVis );
3537 : }
3538 0 : else if ( aNameString == SC_UNONAME_OWIDTH )
3539 : {
3540 0 : bool bOpt = !(rDoc.GetColFlags( nStartCol, nTab ) & CR_MANUALSIZE);
3541 0 : ScUnoHelpFunctions::SetBoolInAny( aAny, bOpt );
3542 : }
3543 0 : else if ( aNameString == SC_UNONAME_NEWPAGE )
3544 : {
3545 0 : ScBreakType nBreak = rDoc.HasColBreak(nStartCol, nTab);
3546 0 : ScUnoHelpFunctions::SetBoolInAny( aAny, nBreak != BREAK_NONE );
3547 : }
3548 0 : else if ( aNameString == SC_UNONAME_MANPAGE )
3549 : {
3550 0 : ScBreakType nBreak = rDoc.HasColBreak(nStartCol, nTab);
3551 0 : ScUnoHelpFunctions::SetBoolInAny( aAny, (nBreak & BREAK_MANUAL) != 0 );
3552 : }
3553 :
3554 52 : return aAny;
3555 : }
3556 :
3557 0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScTableColumnsObj )
3558 :
3559 4101 : ScTableRowsObj::ScTableRowsObj(ScDocShell* pDocSh, SCTAB nT, SCROW nSR, SCROW nER) :
3560 : pDocShell( pDocSh ),
3561 : nTab ( nT ),
3562 : nStartRow( nSR ),
3563 4101 : nEndRow ( nER )
3564 : {
3565 4101 : pDocShell->GetDocument().AddUnoObject(*this);
3566 4101 : }
3567 :
3568 12303 : ScTableRowsObj::~ScTableRowsObj()
3569 : {
3570 4101 : SolarMutexGuard g;
3571 :
3572 4101 : if (pDocShell)
3573 4096 : pDocShell->GetDocument().RemoveUnoObject(*this);
3574 8202 : }
3575 :
3576 128 : void ScTableRowsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
3577 : {
3578 128 : if ( dynamic_cast<const ScUpdateRefHint*>(&rHint) )
3579 : {
3580 : //! Referenz-Update fuer Tab und Start/Ende
3581 : }
3582 252 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) &&
3583 126 : static_cast<const SfxSimpleHint&>(rHint).GetId() == SFX_HINT_DYING )
3584 : {
3585 5 : pDocShell = NULL; // ungueltig geworden
3586 : }
3587 128 : }
3588 :
3589 : // XTableRows
3590 :
3591 121 : ScTableRowObj* ScTableRowsObj::GetObjectByIndex_Impl(sal_Int32 nIndex) const
3592 : {
3593 121 : SCROW nRow = static_cast<SCROW>(nIndex) + nStartRow;
3594 121 : if ( pDocShell && nRow <= nEndRow )
3595 120 : return new ScTableRowObj( pDocShell, nRow, nTab );
3596 :
3597 1 : return NULL; // falscher Index
3598 : }
3599 :
3600 2 : void SAL_CALL ScTableRowsObj::insertByIndex( sal_Int32 nPosition, sal_Int32 nCount )
3601 : throw(uno::RuntimeException, std::exception)
3602 : {
3603 2 : SolarMutexGuard aGuard;
3604 2 : bool bDone = false;
3605 3 : if ( pDocShell && nCount > 0 && nPosition >= 0 && nStartRow+nPosition <= nEndRow &&
3606 1 : nStartRow+nPosition+nCount-1 <= MAXROW )
3607 : {
3608 : ScRange aRange( 0, (SCROW)(nStartRow+nPosition), nTab,
3609 1 : MAXCOL, (SCROW)(nStartRow+nPosition+nCount-1), nTab );
3610 1 : bDone = pDocShell->GetDocFunc().InsertCells( aRange, NULL, INS_INSROWS_BEFORE, true, true );
3611 : }
3612 2 : if (!bDone)
3613 1 : throw uno::RuntimeException(); // no other exceptions specified
3614 1 : }
3615 :
3616 2 : void SAL_CALL ScTableRowsObj::removeByIndex( sal_Int32 nIndex, sal_Int32 nCount )
3617 : throw(uno::RuntimeException, std::exception)
3618 : {
3619 2 : SolarMutexGuard aGuard;
3620 2 : bool bDone = false;
3621 : // Der zu loeschende Bereich muss innerhalb des Objekts liegen
3622 2 : if ( pDocShell && nCount > 0 && nIndex >= 0 && nStartRow+nIndex+nCount-1 <= nEndRow )
3623 : {
3624 : ScRange aRange( 0, (SCROW)(nStartRow+nIndex), nTab,
3625 1 : MAXCOL, (SCROW)(nStartRow+nIndex+nCount-1), nTab );
3626 1 : bDone = pDocShell->GetDocFunc().DeleteCells( aRange, NULL, DEL_DELROWS, true, true );
3627 : }
3628 2 : if (!bDone)
3629 1 : throw uno::RuntimeException(); // no other exceptions specified
3630 1 : }
3631 :
3632 : // XEnumerationAccess
3633 :
3634 1 : uno::Reference<container::XEnumeration> SAL_CALL ScTableRowsObj::createEnumeration()
3635 : throw(uno::RuntimeException, std::exception)
3636 : {
3637 1 : SolarMutexGuard aGuard;
3638 1 : return new ScIndexEnumeration(this, OUString("com.sun.star.table.TableRowsEnumeration"));
3639 : }
3640 :
3641 : // XIndexAccess
3642 :
3643 118 : sal_Int32 SAL_CALL ScTableRowsObj::getCount() throw(uno::RuntimeException, std::exception)
3644 : {
3645 118 : SolarMutexGuard aGuard;
3646 118 : return nEndRow - nStartRow + 1;
3647 : }
3648 :
3649 121 : uno::Any SAL_CALL ScTableRowsObj::getByIndex( sal_Int32 nIndex )
3650 : throw(lang::IndexOutOfBoundsException,
3651 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
3652 : {
3653 121 : SolarMutexGuard aGuard;
3654 242 : uno::Reference<table::XCellRange> xRow(GetObjectByIndex_Impl(nIndex));
3655 121 : if (xRow.is())
3656 240 : return uno::makeAny(xRow);
3657 : else
3658 122 : throw lang::IndexOutOfBoundsException();
3659 : }
3660 :
3661 1 : uno::Type SAL_CALL ScTableRowsObj::getElementType() throw(uno::RuntimeException, std::exception)
3662 : {
3663 1 : SolarMutexGuard aGuard;
3664 1 : return cppu::UnoType<table::XCellRange>::get();
3665 : }
3666 :
3667 1 : sal_Bool SAL_CALL ScTableRowsObj::hasElements() throw(uno::RuntimeException, std::exception)
3668 : {
3669 1 : SolarMutexGuard aGuard;
3670 1 : return ( getCount() != 0 );
3671 : }
3672 :
3673 : // XPropertySet
3674 :
3675 3887 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTableRowsObj::getPropertySetInfo()
3676 : throw(uno::RuntimeException, std::exception)
3677 : {
3678 3887 : SolarMutexGuard aGuard;
3679 : static uno::Reference<beans::XPropertySetInfo> aRef(
3680 3887 : new SfxItemPropertySetInfo( lcl_GetRowsPropertyMap() ));
3681 3887 : return aRef;
3682 : }
3683 :
3684 4155 : void SAL_CALL ScTableRowsObj::setPropertyValue(
3685 : const OUString& aPropertyName, const uno::Any& aValue )
3686 : throw(beans::UnknownPropertyException, beans::PropertyVetoException,
3687 : lang::IllegalArgumentException, lang::WrappedTargetException,
3688 : uno::RuntimeException, std::exception)
3689 : {
3690 4155 : SolarMutexGuard aGuard;
3691 4155 : if (!pDocShell)
3692 0 : throw uno::RuntimeException();
3693 :
3694 4155 : ScDocFunc& rFunc = pDocShell->GetDocFunc();
3695 4155 : ScDocument& rDoc = pDocShell->GetDocument();
3696 8310 : std::vector<sc::ColRowSpan> aRowArr(1, sc::ColRowSpan(nStartRow,nEndRow));
3697 8310 : OUString aNameString(aPropertyName);
3698 :
3699 4155 : if ( aNameString == SC_UNONAME_OHEIGHT )
3700 : {
3701 3798 : sal_Int32 nNewHeight = 0;
3702 3798 : if ( rDoc.IsImportingXML() && ( aValue >>= nNewHeight ) )
3703 : {
3704 : // used to set the stored row height for rows with optimal height when loading.
3705 :
3706 : // TODO: It's probably cleaner to use a different property name
3707 : // for this.
3708 3480 : rDoc.SetRowHeightOnly( nStartRow, nEndRow, nTab, (sal_uInt16)HMMToTwips(nNewHeight) );
3709 : }
3710 : else
3711 : {
3712 318 : bool bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue );
3713 318 : if (bOpt)
3714 0 : rFunc.SetWidthOrHeight(false, aRowArr, nTab, SC_SIZE_OPTIMAL, 0, true, true);
3715 : else
3716 : {
3717 : //! manually set old heights again?
3718 : }
3719 : }
3720 : }
3721 357 : else if ( aNameString == SC_UNONAME_CELLHGT )
3722 : {
3723 318 : sal_Int32 nNewHeight = 0;
3724 318 : if ( aValue >>= nNewHeight )
3725 : {
3726 318 : if (rDoc.IsImportingXML())
3727 : {
3728 : // TODO: This is a band-aid fix. Eventually we need to
3729 : // re-work ods' style import to get it to set styles to
3730 : // ScDocument directly.
3731 318 : rDoc.SetRowHeightOnly( nStartRow, nEndRow, nTab, (sal_uInt16)HMMToTwips(nNewHeight) );
3732 318 : rDoc.SetManualHeight( nStartRow, nEndRow, nTab, true );
3733 : }
3734 : else
3735 : rFunc.SetWidthOrHeight(
3736 0 : false, aRowArr, nTab, SC_SIZE_ORIGINAL, (sal_uInt16)HMMToTwips(nNewHeight), true, true);
3737 : }
3738 : }
3739 39 : else if ( aNameString == SC_UNONAME_CELLVIS )
3740 : {
3741 25 : bool bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue );
3742 25 : ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT;
3743 25 : rFunc.SetWidthOrHeight(false, aRowArr, nTab, eMode, 0, true, true);
3744 : // SC_SIZE_DIRECT with size 0: hide
3745 : }
3746 14 : else if ( aNameString == SC_UNONAME_VISFLAG )
3747 : {
3748 : // #i116460# Shortcut to only set the flag, without drawing layer update etc.
3749 : // Should only be used from import filters.
3750 0 : rDoc.SetRowHidden(nStartRow, nEndRow, nTab, !ScUnoHelpFunctions::GetBoolFromAny( aValue ));
3751 : }
3752 14 : else if ( aNameString == SC_UNONAME_CELLFILT )
3753 : {
3754 : //! undo etc.
3755 14 : if (ScUnoHelpFunctions::GetBoolFromAny( aValue ))
3756 14 : rDoc.SetRowFiltered(nStartRow, nEndRow, nTab, true);
3757 : else
3758 0 : rDoc.SetRowFiltered(nStartRow, nEndRow, nTab, false);
3759 : }
3760 0 : else if ( aNameString == SC_UNONAME_NEWPAGE || aNameString == SC_UNONAME_MANPAGE )
3761 : {
3762 : //! single function to set/remove all breaks?
3763 0 : bool bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue );
3764 0 : for (SCROW nRow=nStartRow; nRow<=nEndRow; nRow++)
3765 0 : if (bSet)
3766 0 : rFunc.InsertPageBreak( false, ScAddress(0,nRow,nTab), true, true, true );
3767 : else
3768 0 : rFunc.RemovePageBreak( false, ScAddress(0,nRow,nTab), true, true, true );
3769 : }
3770 0 : else if ( aNameString == SC_UNONAME_CELLBACK || aNameString == SC_UNONAME_CELLTRAN )
3771 : {
3772 : // #i57867# Background color is specified for row styles in the file format,
3773 : // so it has to be supported along with the row properties (import only).
3774 :
3775 : // Use ScCellRangeObj to set the property for all cells in the rows
3776 : // (this means, the "row attribute" must be set before individual cell attributes).
3777 :
3778 0 : ScRange aRange( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab );
3779 0 : uno::Reference<beans::XPropertySet> xRangeObj = new ScCellRangeObj( pDocShell, aRange );
3780 0 : xRangeObj->setPropertyValue( aPropertyName, aValue );
3781 4155 : }
3782 4155 : }
3783 :
3784 45 : uno::Any SAL_CALL ScTableRowsObj::getPropertyValue( const OUString& aPropertyName )
3785 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
3786 : uno::RuntimeException, std::exception)
3787 : {
3788 45 : SolarMutexGuard aGuard;
3789 45 : if (!pDocShell)
3790 0 : throw uno::RuntimeException();
3791 :
3792 45 : ScDocument& rDoc = pDocShell->GetDocument();
3793 90 : OUString aNameString(aPropertyName);
3794 45 : uno::Any aAny;
3795 :
3796 : //! loop over all rows for current state?
3797 :
3798 45 : if ( aNameString == SC_UNONAME_CELLHGT )
3799 : {
3800 : // for hidden row, return original height
3801 0 : sal_uInt16 nHeight = rDoc.GetOriginalHeight( nStartRow, nTab );
3802 0 : aAny <<= (sal_Int32)TwipsToHMM(nHeight);
3803 : }
3804 45 : else if ( aNameString == SC_UNONAME_CELLVIS )
3805 : {
3806 : SCROW nLastRow;
3807 45 : bool bVis = !rDoc.RowHidden(nStartRow, nTab, NULL, &nLastRow);
3808 45 : ScUnoHelpFunctions::SetBoolInAny( aAny, bVis );
3809 : }
3810 0 : else if ( aNameString == SC_UNONAME_CELLFILT )
3811 : {
3812 0 : bool bVis = rDoc.RowFiltered(nStartRow, nTab);
3813 0 : ScUnoHelpFunctions::SetBoolInAny( aAny, bVis );
3814 : }
3815 0 : else if ( aNameString == SC_UNONAME_OHEIGHT )
3816 : {
3817 0 : bool bOpt = !(rDoc.GetRowFlags( nStartRow, nTab ) & CR_MANUALSIZE);
3818 0 : ScUnoHelpFunctions::SetBoolInAny( aAny, bOpt );
3819 : }
3820 0 : else if ( aNameString == SC_UNONAME_NEWPAGE )
3821 : {
3822 0 : ScBreakType nBreak = rDoc.HasRowBreak(nStartRow, nTab);
3823 0 : ScUnoHelpFunctions::SetBoolInAny( aAny, nBreak != BREAK_NONE );
3824 : }
3825 0 : else if ( aNameString == SC_UNONAME_MANPAGE )
3826 : {
3827 0 : ScBreakType nBreak = rDoc.HasRowBreak(nStartRow, nTab);
3828 0 : ScUnoHelpFunctions::SetBoolInAny( aAny, (nBreak & BREAK_MANUAL) != 0 );
3829 : }
3830 0 : else if ( aNameString == SC_UNONAME_CELLBACK || aNameString == SC_UNONAME_CELLTRAN )
3831 : {
3832 : // Use ScCellRangeObj to get the property from the cell range
3833 : // (for completeness only, this is not used by the XML filter).
3834 :
3835 0 : ScRange aRange( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab );
3836 0 : uno::Reference<beans::XPropertySet> xRangeObj = new ScCellRangeObj( pDocShell, aRange );
3837 0 : aAny = xRangeObj->getPropertyValue( aPropertyName );
3838 : }
3839 :
3840 90 : return aAny;
3841 : }
3842 :
3843 0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScTableRowsObj )
3844 :
3845 0 : ScSpreadsheetSettingsObj::~ScSpreadsheetSettingsObj()
3846 : {
3847 0 : SolarMutexGuard g;
3848 :
3849 0 : if (pDocShell)
3850 0 : pDocShell->GetDocument().RemoveUnoObject(*this);
3851 0 : }
3852 :
3853 0 : void ScSpreadsheetSettingsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
3854 : {
3855 : // Referenz-Update interessiert hier nicht
3856 :
3857 0 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
3858 0 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
3859 : {
3860 0 : pDocShell = NULL; // ungueltig geworden
3861 : }
3862 0 : }
3863 :
3864 : // XPropertySet
3865 :
3866 0 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScSpreadsheetSettingsObj::getPropertySetInfo()
3867 : throw(uno::RuntimeException, std::exception)
3868 : {
3869 : //! muss noch
3870 0 : return NULL;
3871 : }
3872 :
3873 0 : void SAL_CALL ScSpreadsheetSettingsObj::setPropertyValue(
3874 : const OUString& /* aPropertyName */, const uno::Any& /* aValue */ )
3875 : throw(beans::UnknownPropertyException, beans::PropertyVetoException,
3876 : lang::IllegalArgumentException, lang::WrappedTargetException,
3877 : uno::RuntimeException, std::exception)
3878 : {
3879 : //! muss noch
3880 0 : }
3881 :
3882 0 : uno::Any SAL_CALL ScSpreadsheetSettingsObj::getPropertyValue( const OUString& /* aPropertyName */ )
3883 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
3884 : uno::RuntimeException, std::exception)
3885 : {
3886 : //! muss noch
3887 0 : return uno::Any();
3888 : }
3889 :
3890 0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScSpreadsheetSettingsObj )
3891 :
3892 13 : ScAnnotationsObj::ScAnnotationsObj(ScDocShell* pDocSh, SCTAB nT) :
3893 : pDocShell( pDocSh ),
3894 13 : nTab( nT )
3895 : {
3896 13 : pDocShell->GetDocument().AddUnoObject(*this);
3897 13 : }
3898 :
3899 39 : ScAnnotationsObj::~ScAnnotationsObj()
3900 : {
3901 13 : SolarMutexGuard g;
3902 :
3903 13 : if (pDocShell)
3904 11 : pDocShell->GetDocument().RemoveUnoObject(*this);
3905 26 : }
3906 :
3907 27 : void ScAnnotationsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
3908 : {
3909 : //! nTab bei Referenz-Update anpassen!!!
3910 :
3911 27 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
3912 27 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
3913 : {
3914 2 : pDocShell = NULL; // ungueltig geworden
3915 : }
3916 27 : }
3917 :
3918 7 : bool ScAnnotationsObj::GetAddressByIndex_Impl( sal_Int32 nIndex, ScAddress& rPos ) const
3919 : {
3920 7 : if (!pDocShell)
3921 0 : return false;
3922 :
3923 7 : ScDocument& rDoc = pDocShell->GetDocument();
3924 7 : rPos = rDoc.GetNotePosition(nIndex, nTab);
3925 7 : return rPos.IsValid();
3926 : }
3927 :
3928 5 : ScAnnotationObj* ScAnnotationsObj::GetObjectByIndex_Impl( sal_Int32 nIndex ) const
3929 : {
3930 5 : if (pDocShell)
3931 : {
3932 5 : ScAddress aPos;
3933 5 : if ( GetAddressByIndex_Impl( nIndex, aPos ) )
3934 4 : return new ScAnnotationObj( pDocShell, aPos );
3935 : }
3936 1 : return NULL;
3937 : }
3938 :
3939 : // XSheetAnnotations
3940 :
3941 17 : void SAL_CALL ScAnnotationsObj::insertNew(
3942 : const table::CellAddress& aPosition, const OUString& rText )
3943 : throw(uno::RuntimeException, std::exception)
3944 : {
3945 17 : SolarMutexGuard aGuard;
3946 17 : if (pDocShell)
3947 : {
3948 : OSL_ENSURE( aPosition.Sheet == nTab, "addAnnotation mit falschem Sheet" );
3949 17 : ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab );
3950 17 : pDocShell->GetDocFunc().ReplaceNote( aPos, rText, 0, 0, true );
3951 17 : }
3952 17 : }
3953 :
3954 2 : void SAL_CALL ScAnnotationsObj::removeByIndex( sal_Int32 nIndex ) throw(uno::RuntimeException, std::exception)
3955 : {
3956 2 : SolarMutexGuard aGuard;
3957 2 : if (pDocShell)
3958 : {
3959 2 : ScAddress aPos;
3960 2 : if ( GetAddressByIndex_Impl( nIndex, aPos ) )
3961 : {
3962 2 : ScMarkData aMarkData;
3963 2 : aMarkData.SelectTable( aPos.Tab(), true );
3964 2 : aMarkData.SetMultiMarkArea( ScRange(aPos) );
3965 :
3966 2 : pDocShell->GetDocFunc().DeleteContents( aMarkData, IDF_NOTE, true, true );
3967 : }
3968 2 : }
3969 2 : }
3970 :
3971 : // XEnumerationAccess
3972 :
3973 2 : uno::Reference<container::XEnumeration> SAL_CALL ScAnnotationsObj::createEnumeration()
3974 : throw(uno::RuntimeException, std::exception)
3975 : {
3976 : //! iterate directly (more efficiently)?
3977 :
3978 2 : SolarMutexGuard aGuard;
3979 2 : return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.CellAnnotationsEnumeration"));
3980 : }
3981 :
3982 : // XIndexAccess
3983 :
3984 12 : sal_Int32 SAL_CALL ScAnnotationsObj::getCount()
3985 : throw(uno::RuntimeException, std::exception)
3986 : {
3987 12 : SolarMutexGuard aGuard;
3988 12 : sal_Int32 nCount = 0;
3989 12 : if (pDocShell)
3990 : {
3991 12 : ScDocument& rDoc = pDocShell->GetDocument();
3992 12 : const ScRangeList aRangeList( ScRange( 0, 0, nTab, MAXCOL, MAXROW, nTab) );
3993 24 : std::vector<sc::NoteEntry> rNotes;
3994 12 : rDoc.GetNotesInRange(aRangeList, rNotes);
3995 24 : nCount = rNotes.size();
3996 : }
3997 12 : return nCount;
3998 : }
3999 :
4000 5 : uno::Any SAL_CALL ScAnnotationsObj::getByIndex( sal_Int32 nIndex )
4001 : throw(lang::IndexOutOfBoundsException,
4002 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
4003 : {
4004 5 : SolarMutexGuard aGuard;
4005 10 : uno::Reference<sheet::XSheetAnnotation> xAnnotation(GetObjectByIndex_Impl(nIndex));
4006 5 : if (xAnnotation.is())
4007 8 : return uno::makeAny(xAnnotation);
4008 : else
4009 6 : throw lang::IndexOutOfBoundsException();
4010 : }
4011 :
4012 0 : uno::Type SAL_CALL ScAnnotationsObj::getElementType() throw(uno::RuntimeException, std::exception)
4013 : {
4014 0 : SolarMutexGuard aGuard;
4015 0 : return cppu::UnoType<sheet::XSheetAnnotation>::get();
4016 : }
4017 :
4018 0 : sal_Bool SAL_CALL ScAnnotationsObj::hasElements() throw(uno::RuntimeException, std::exception)
4019 : {
4020 0 : SolarMutexGuard aGuard;
4021 0 : return ( getCount() != 0 );
4022 : }
4023 :
4024 2 : ScScenariosObj::ScScenariosObj(ScDocShell* pDocSh, SCTAB nT) :
4025 : pDocShell( pDocSh ),
4026 2 : nTab ( nT )
4027 : {
4028 2 : pDocShell->GetDocument().AddUnoObject(*this);
4029 2 : }
4030 :
4031 6 : ScScenariosObj::~ScScenariosObj()
4032 : {
4033 2 : SolarMutexGuard g;
4034 :
4035 2 : if (pDocShell)
4036 0 : pDocShell->GetDocument().RemoveUnoObject(*this);
4037 4 : }
4038 :
4039 3 : void ScScenariosObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
4040 : {
4041 3 : if ( dynamic_cast<const ScUpdateRefHint*>(&rHint) )
4042 : {
4043 : //! Referenz-Update fuer Tab und Start/Ende
4044 : }
4045 6 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) &&
4046 3 : static_cast<const SfxSimpleHint&>(rHint).GetId() == SFX_HINT_DYING )
4047 : {
4048 2 : pDocShell = NULL; // ungueltig geworden
4049 : }
4050 3 : }
4051 :
4052 : // XScenarios
4053 :
4054 0 : bool ScScenariosObj::GetScenarioIndex_Impl( const OUString& rName, SCTAB& rIndex )
4055 : {
4056 : //! Case-insensitiv ????
4057 :
4058 0 : if ( pDocShell )
4059 : {
4060 0 : OUString aTabName;
4061 0 : ScDocument& rDoc = pDocShell->GetDocument();
4062 0 : SCTAB nCount = (SCTAB)getCount();
4063 0 : for (SCTAB i=0; i<nCount; i++)
4064 0 : if (rDoc.GetName( nTab+i+1, aTabName ))
4065 0 : if (aTabName.equals(rName))
4066 : {
4067 0 : rIndex = i;
4068 0 : return true;
4069 0 : }
4070 : }
4071 :
4072 0 : return false;
4073 : }
4074 :
4075 2 : ScTableSheetObj* ScScenariosObj::GetObjectByIndex_Impl(sal_Int32 nIndex)
4076 : {
4077 2 : sal_uInt16 nCount = (sal_uInt16)getCount();
4078 2 : if ( pDocShell && nIndex >= 0 && nIndex < nCount )
4079 1 : return new ScTableSheetObj( pDocShell, nTab+static_cast<SCTAB>(nIndex)+1 );
4080 :
4081 1 : return NULL; // kein Dokument oder falscher Index
4082 : }
4083 :
4084 0 : ScTableSheetObj* ScScenariosObj::GetObjectByName_Impl(const OUString& aName)
4085 : {
4086 : SCTAB nIndex;
4087 0 : if ( pDocShell && GetScenarioIndex_Impl( aName, nIndex ) )
4088 0 : return new ScTableSheetObj( pDocShell, nTab+nIndex+1 );
4089 :
4090 0 : return NULL; // nicht gefunden
4091 : }
4092 :
4093 1 : void SAL_CALL ScScenariosObj::addNewByName( const OUString& aName,
4094 : const uno::Sequence<table::CellRangeAddress>& aRanges,
4095 : const OUString& aComment )
4096 : throw(uno::RuntimeException, std::exception)
4097 : {
4098 1 : SolarMutexGuard aGuard;
4099 1 : if ( pDocShell )
4100 : {
4101 1 : ScMarkData aMarkData;
4102 1 : aMarkData.SelectTable( nTab, true );
4103 :
4104 1 : sal_uInt16 nRangeCount = (sal_uInt16)aRanges.getLength();
4105 1 : if (nRangeCount)
4106 : {
4107 1 : const table::CellRangeAddress* pAry = aRanges.getConstArray();
4108 2 : for (sal_uInt16 i=0; i<nRangeCount; i++)
4109 : {
4110 : OSL_ENSURE( pAry[i].Sheet == nTab, "addScenario mit falscher Tab" );
4111 2 : ScRange aRange( (SCCOL)pAry[i].StartColumn, (SCROW)pAry[i].StartRow, nTab,
4112 3 : (SCCOL)pAry[i].EndColumn, (SCROW)pAry[i].EndRow, nTab );
4113 :
4114 1 : aMarkData.SetMultiMarkArea( aRange );
4115 : }
4116 : }
4117 :
4118 2 : OUString aNameStr(aName);
4119 2 : OUString aCommStr(aComment);
4120 :
4121 1 : Color aColor( COL_LIGHTGRAY ); // Default
4122 1 : sal_uInt16 nFlags = SC_SCENARIO_SHOWFRAME | SC_SCENARIO_PRINTFRAME | SC_SCENARIO_TWOWAY | SC_SCENARIO_PROTECT;
4123 :
4124 2 : pDocShell->MakeScenario( nTab, aNameStr, aCommStr, aColor, nFlags, aMarkData );
4125 1 : }
4126 1 : }
4127 :
4128 0 : void SAL_CALL ScScenariosObj::removeByName( const OUString& aName )
4129 : throw(uno::RuntimeException, std::exception)
4130 : {
4131 0 : SolarMutexGuard aGuard;
4132 : SCTAB nIndex;
4133 0 : if ( pDocShell && GetScenarioIndex_Impl( aName, nIndex ) )
4134 0 : pDocShell->GetDocFunc().DeleteTable( nTab+nIndex+1, true, true );
4135 0 : }
4136 :
4137 : // XEnumerationAccess
4138 :
4139 1 : uno::Reference<container::XEnumeration> SAL_CALL ScScenariosObj::createEnumeration()
4140 : throw(uno::RuntimeException, std::exception)
4141 : {
4142 1 : SolarMutexGuard aGuard;
4143 1 : return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.ScenariosEnumeration"));
4144 : }
4145 :
4146 : // XIndexAccess
4147 :
4148 4 : sal_Int32 SAL_CALL ScScenariosObj::getCount() throw(uno::RuntimeException, std::exception)
4149 : {
4150 4 : SolarMutexGuard aGuard;
4151 4 : SCTAB nCount = 0;
4152 4 : if ( pDocShell )
4153 : {
4154 4 : ScDocument& rDoc = pDocShell->GetDocument();
4155 4 : if (!rDoc.IsScenario(nTab))
4156 : {
4157 4 : SCTAB nTabCount = rDoc.GetTableCount();
4158 4 : SCTAB nNext = nTab + 1;
4159 12 : while (nNext < nTabCount && rDoc.IsScenario(nNext))
4160 : {
4161 4 : ++nCount;
4162 4 : ++nNext;
4163 : }
4164 : }
4165 : }
4166 4 : return nCount;
4167 : }
4168 :
4169 2 : uno::Any SAL_CALL ScScenariosObj::getByIndex( sal_Int32 nIndex )
4170 : throw(lang::IndexOutOfBoundsException,
4171 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
4172 : {
4173 2 : SolarMutexGuard aGuard;
4174 4 : uno::Reference<sheet::XScenario> xScen(GetObjectByIndex_Impl(nIndex));
4175 2 : if (xScen.is())
4176 2 : return uno::makeAny(xScen);
4177 : else
4178 3 : throw lang::IndexOutOfBoundsException();
4179 : }
4180 :
4181 0 : uno::Type SAL_CALL ScScenariosObj::getElementType() throw(uno::RuntimeException, std::exception)
4182 : {
4183 0 : SolarMutexGuard aGuard;
4184 0 : return cppu::UnoType<sheet::XScenario>::get();
4185 : }
4186 :
4187 0 : sal_Bool SAL_CALL ScScenariosObj::hasElements() throw(uno::RuntimeException, std::exception)
4188 : {
4189 0 : SolarMutexGuard aGuard;
4190 0 : return ( getCount() != 0 );
4191 : }
4192 :
4193 0 : uno::Any SAL_CALL ScScenariosObj::getByName( const OUString& aName )
4194 : throw(container::NoSuchElementException,
4195 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
4196 : {
4197 0 : SolarMutexGuard aGuard;
4198 0 : uno::Reference<sheet::XScenario> xScen(GetObjectByName_Impl(aName));
4199 0 : if (xScen.is())
4200 0 : return uno::makeAny(xScen);
4201 : else
4202 0 : throw container::NoSuchElementException();
4203 : }
4204 :
4205 0 : uno::Sequence<OUString> SAL_CALL ScScenariosObj::getElementNames()
4206 : throw(uno::RuntimeException, std::exception)
4207 : {
4208 0 : SolarMutexGuard aGuard;
4209 0 : SCTAB nCount = (SCTAB)getCount();
4210 0 : uno::Sequence<OUString> aSeq(nCount);
4211 :
4212 0 : if ( pDocShell ) // sonst ist auch Count = 0
4213 : {
4214 0 : OUString aTabName;
4215 0 : ScDocument& rDoc = pDocShell->GetDocument();
4216 0 : OUString* pAry = aSeq.getArray();
4217 0 : for (SCTAB i=0; i<nCount; i++)
4218 0 : if (rDoc.GetName( nTab+i+1, aTabName ))
4219 0 : pAry[i] = aTabName;
4220 : }
4221 :
4222 0 : return aSeq;
4223 : }
4224 :
4225 0 : sal_Bool SAL_CALL ScScenariosObj::hasByName( const OUString& aName )
4226 : throw(uno::RuntimeException, std::exception)
4227 : {
4228 0 : SolarMutexGuard aGuard;
4229 : SCTAB nIndex;
4230 0 : return GetScenarioIndex_Impl( aName, nIndex );
4231 156 : }
4232 :
4233 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
