?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 4.1.6.2
[LibreOffice.git] / sc / source / ui / vba / vbarange.cxx
bloba2470f125552aec9addb548fdacb7c3a96cecbbb
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 "vbarange.hxx"
21
22 #include <vbahelper/helperdecl.hxx>
23
24 #include <comphelper/unwrapargs.hxx>
25 #include <comphelper/processfactory.hxx>
26 #include <sfx2/objsh.hxx>
27
28 #include <com/sun/star/script/ArrayWrapper.hpp>
29 #include <com/sun/star/script/vba/VBAEventId.hpp>
30 #include <com/sun/star/script/vba/XVBAEventProcessor.hpp>
31 #include <com/sun/star/sheet/XDatabaseRange.hpp>
32 #include <com/sun/star/sheet/XUnnamedDatabaseRanges.hpp>
33 #include <com/sun/star/sheet/XGoalSeek.hpp>
34 #include <com/sun/star/sheet/XSheetOperation.hpp>
35 #include <com/sun/star/sheet/CellFlags.hpp>
36 #include <com/sun/star/table/XColumnRowRange.hpp>
37 #include <com/sun/star/sheet/XCellAddressable.hpp>
38 #include <com/sun/star/table/CellContentType.hpp>
39 #include <com/sun/star/sheet/XCellSeries.hpp>
40 #include <com/sun/star/text/XTextRange.hpp>
41 #include <com/sun/star/sheet/XCellRangeAddressable.hpp>
42 #include <com/sun/star/table/CellAddress.hpp>
43 #include <com/sun/star/table/CellRangeAddress.hpp>
44 #include <com/sun/star/sheet/XSpreadsheetView.hpp>
45 #include <com/sun/star/sheet/XCellRangeReferrer.hpp>
46 #include <com/sun/star/sheet/XSheetCellRange.hpp>
47 #include <com/sun/star/sheet/XSpreadsheet.hpp>
48 #include <com/sun/star/sheet/XSheetCellCursor.hpp>
49 #include <com/sun/star/sheet/XArrayFormulaRange.hpp>
50 #include <com/sun/star/sheet/XNamedRange.hpp>
51 #include <com/sun/star/sheet/XPrintAreas.hpp>
52 #include <com/sun/star/sheet/XCellRangesQuery.hpp>
53 #include <com/sun/star/beans/XPropertySet.hpp>
54 #include <com/sun/star/sheet/XFunctionAccess.hpp>
55 #include <com/sun/star/frame/XModel.hpp>
56 #include <com/sun/star/view/XSelectionSupplier.hpp>
57 #include <com/sun/star/table/XCellCursor.hpp>
58 #include <com/sun/star/table/XTableRows.hpp>
59 #include <com/sun/star/table/XTableColumns.hpp>
60 #include <com/sun/star/table/TableSortField.hpp>
61 #include <com/sun/star/util/XMergeable.hpp>
62 #include <com/sun/star/uno/XComponentContext.hpp>
63 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
64 #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
65 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
66 #include <com/sun/star/util/XNumberFormats.hpp>
67 #include <com/sun/star/util/NumberFormat.hpp>
68 #include <com/sun/star/util/XNumberFormatTypes.hpp>
69 #include <com/sun/star/util/XReplaceable.hpp>
70 #include <com/sun/star/util/XSortable.hpp>
71 #include <com/sun/star/sheet/XCellRangeMovement.hpp>
72 #include <com/sun/star/sheet/XCellRangeData.hpp>
73 #include <com/sun/star/sheet/FormulaResult.hpp>
74 #include <com/sun/star/sheet/FilterOperator2.hpp>
75 #include <com/sun/star/sheet/TableFilterField.hpp>
76 #include <com/sun/star/sheet/TableFilterField2.hpp>
77 #include <com/sun/star/sheet/XSheetFilterDescriptor2.hpp>
78 #include <com/sun/star/sheet/XSheetFilterable.hpp>
79 #include <com/sun/star/sheet/FilterConnection.hpp>
80 #include <com/sun/star/util/CellProtection.hpp>
81 #include <com/sun/star/util/TriState.hpp>
82
83 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
84 #include <com/sun/star/awt/XDevice.hpp>
85
86 #include <com/sun/star/sheet/XSubTotalCalculatable.hpp>
87 #include <com/sun/star/sheet/XSubTotalDescriptor.hpp>
88 #include <com/sun/star/sheet/GeneralFunction.hpp>
89
90 #include <com/sun/star/sheet/XSheetAnnotationsSupplier.hpp>
91 #include <com/sun/star/sheet/XSheetAnnotations.hpp>
92
93 #include <ooo/vba/excel/XlPasteSpecialOperation.hpp>
94 #include <ooo/vba/excel/XlPasteType.hpp>
95 #include <ooo/vba/excel/Constants.hpp>
96 #include <ooo/vba/excel/XlFindLookIn.hpp>
97 #include <ooo/vba/excel/XlLookAt.hpp>
98 #include <ooo/vba/excel/XlSearchOrder.hpp>
99 #include <ooo/vba/excel/XlSortOrder.hpp>
100 #include <ooo/vba/excel/XlYesNoGuess.hpp>
101 #include <ooo/vba/excel/XlSortOrientation.hpp>
102 #include <ooo/vba/excel/XlSortMethod.hpp>
103 #include <ooo/vba/excel/XlDirection.hpp>
104 #include <ooo/vba/excel/XlSortDataOption.hpp>
105 #include <ooo/vba/excel/XlDeleteShiftDirection.hpp>
106 #include <ooo/vba/excel/XlInsertShiftDirection.hpp>
107 #include <ooo/vba/excel/XlReferenceStyle.hpp>
108 #include <ooo/vba/excel/XlBordersIndex.hpp>
109 #include <ooo/vba/excel/XlPageBreak.hpp>
110 #include <ooo/vba/excel/XlAutoFilterOperator.hpp>
111 #include <ooo/vba/excel/XlAutoFillType.hpp>
112 #include <ooo/vba/excel/XlTextParsingType.hpp>
113 #include <ooo/vba/excel/XlTextQualifier.hpp>
114 #include <ooo/vba/excel/XlCellType.hpp>
115 #include <ooo/vba/excel/XlSpecialCellsValue.hpp>
116 #include <ooo/vba/excel/XlConsolidationFunction.hpp>
117 #include <ooo/vba/excel/XlSearchDirection.hpp>
118
119 #include <scitems.hxx>
120 #include <svl/srchitem.hxx>
121 #include <cellsuno.hxx>
122 #include <dbdata.hxx>
123 #include "docfunc.hxx"
124 #include <docuno.hxx>
125
126 #include <sfx2/dispatch.hxx>
127 #include <sfx2/app.hxx>
128 #include <sfx2/bindings.hxx>
129 #include <sfx2/request.hxx>
130 #include <sfx2/viewfrm.hxx>
131 #include <sfx2/itemwrapper.hxx>
132 #include <sc.hrc>
133 #include <globstr.hrc>
134 #include <unonames.hxx>
135
136 #include "vbaapplication.hxx"
137 #include "vbafont.hxx"
138 #include "vbacomment.hxx"
139 #include "vbainterior.hxx"
140 #include "vbacharacters.hxx"
141 #include "vbaborders.hxx"
142 #include "vbaworksheet.hxx"
143 #include "vbavalidation.hxx"
144 #include "vbahyperlinks.hxx"
145
146 #include "tabvwsh.hxx"
147 #include "rangelst.hxx"
148 #include "convuno.hxx"
149 #include "compiler.hxx"
150 #include "attrib.hxx"
151 #include "undodat.hxx"
152 #include "dbdocfun.hxx"
153 #include "patattr.hxx"
154 #include "olinetab.hxx"
155 #include "transobj.hxx"
156 #include "queryentry.hxx"
157 #include "markdata.hxx"
158 #include <comphelper/anytostring.hxx>
159
160 #include <global.hxx>
161
162 #include "vbaglobals.hxx"
163 #include "vbastyle.hxx"
164 #include "vbaname.hxx"
165 #include <vector>
166 #include <vbahelper/vbacollectionimpl.hxx>
167 // begin test includes
168 #include <com/sun/star/sheet/FunctionArgument.hpp>
169 // end test includes
170
171 #include <ooo/vba/excel/Range.hpp>
172 #include <com/sun/star/bridge/oleautomation/Date.hpp>
173
174 using namespace ::ooo::vba;
175 using namespace ::com::sun::star;
176 using ::std::vector;
177
178 // difference between VBA and file format width, in character units
179 const double fExtraWidth = 182.0 / 256.0;
180
181 // * 1 point = 1/72 inch = 20 twips
182 // * 1 inch = 72 points = 1440 twips
183 // * 1 cm = 567 twips
184 static double lcl_hmmToPoints( double nVal ) { return ( (double)((nVal /1000 ) * 567 ) / 20 ); }
185
186 static const sal_Int16 supportedIndexTable[] = { excel::XlBordersIndex::xlEdgeLeft, excel::XlBordersIndex::xlEdgeTop, excel::XlBordersIndex::xlEdgeBottom, excel::XlBordersIndex::xlEdgeRight, excel::XlBordersIndex::xlDiagonalDown, excel::XlBordersIndex::xlDiagonalUp, excel::XlBordersIndex::xlInsideVertical, excel::XlBordersIndex::xlInsideHorizontal };
187
188 static sal_uInt16 lcl_pointsToTwips( double nVal )
189 {
190 nVal = nVal * static_cast<double>(20);
191 short nTwips = static_cast<short>(nVal);
192 return nTwips;
193 }
194 static double lcl_TwipsToPoints( sal_uInt16 nVal )
195 {
196 double nPoints = nVal;
197 return nPoints / 20;
198 }
199
200 static double lcl_Round2DecPlaces( double nVal )
201 {
202 nVal = (nVal * (double)100);
203 long tmp = static_cast<long>(nVal);
204 if ( ( ( nVal - tmp ) >= 0.5 ) )
205 ++tmp;
206 nVal = tmp;
207 nVal = nVal/100;
208 return nVal;
209 }
210
211 static uno::Any lcl_makeRange( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Any aAny, bool bIsRows, bool bIsColumns )
212 {
213 uno::Reference< table::XCellRange > xCellRange( aAny, uno::UNO_QUERY_THROW );
214 return uno::makeAny( uno::Reference< excel::XRange >( new ScVbaRange( xParent, xContext, xCellRange, bIsRows, bIsColumns ) ) );
215 }
216
217 static uno::Reference< excel::XRange > lcl_makeXRangeFromSheetCellRanges( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< sheet::XSheetCellRanges >& xLocSheetCellRanges, ScDocShell* pDoc )
218 {
219 uno::Reference< excel::XRange > xRange;
220 uno::Sequence< table::CellRangeAddress > sAddresses = xLocSheetCellRanges->getRangeAddresses();
221 ScRangeList aCellRanges;
222 sal_Int32 nLen = sAddresses.getLength();
223 if ( nLen )
224 {
225 for ( sal_Int32 index = 0; index < nLen; ++index )
226 {
227 ScRange refRange;
228 ScUnoConversion::FillScRange( refRange, sAddresses[ index ] );
229 aCellRanges.Append( refRange );
230 }
231 // Single range
232 if ( aCellRanges.size() == 1 )
233 {
234 uno::Reference< table::XCellRange > xTmpRange( new ScCellRangeObj( pDoc, *aCellRanges.front() ) );
235 xRange = new ScVbaRange( xParent, xContext, xTmpRange );
236 }
237 else
238 {
239 uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( pDoc, aCellRanges ) );
240 xRange = new ScVbaRange( xParent, xContext, xRanges );
241 }
242 }
243 return xRange;
244 }
245
246 ScCellRangesBase* ScVbaRange::getCellRangesBase() throw ( uno::RuntimeException )
247 {
248 if( mxRanges.is() )
249 return ScCellRangesBase::getImplementation( mxRanges );
250 if( mxRange.is() )
251 return ScCellRangesBase::getImplementation( mxRange );
252 throw uno::RuntimeException( OUString("General Error creating range - Unknown" ), uno::Reference< uno::XInterface >() );
253 }
254
255 ScCellRangeObj* ScVbaRange::getCellRangeObj() throw ( uno::RuntimeException )
256 {
257 return dynamic_cast< ScCellRangeObj* >( getCellRangesBase() );
258 }
259
260 SfxItemSet* ScVbaRange::getCurrentDataSet( ) throw ( uno::RuntimeException )
261 {
262 SfxItemSet* pDataSet = excel::ScVbaCellRangeAccess::GetDataSet( getCellRangesBase() );
263 if ( !pDataSet )
264 throw uno::RuntimeException( OUString( "Can't access Itemset for range" ), uno::Reference< uno::XInterface >() );
265 return pDataSet;
266 }
267
268 void ScVbaRange::fireChangeEvent()
269 {
270 if( ScVbaApplication::getDocumentEventsEnabled() )
271 {
272 if( ScDocument* pDoc = getScDocument() )
273 {
274 uno::Reference< script::vba::XVBAEventProcessor > xVBAEvents = pDoc->GetVbaEventProcessor();
275 if( xVBAEvents.is() ) try
276 {
277 uno::Sequence< uno::Any > aArgs( 1 );
278 aArgs[ 0 ] <<= uno::Reference< excel::XRange >( this );
279 xVBAEvents->processVbaEvent( script::vba::VBAEventId::WORKSHEET_CHANGE, aArgs );
280 }
281 catch( uno::Exception& )
282 {
283 }
284 }
285 }
286 }
287
288 class SingleRangeEnumeration : public EnumerationHelper_BASE
289 {
290 uno::Reference< XHelperInterface > m_xParent;
291 uno::Reference< table::XCellRange > m_xRange;
292 uno::Reference< uno::XComponentContext > mxContext;
293 bool bHasMore;
294 public:
295
296 SingleRangeEnumeration( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< css::uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException ) : m_xParent( xParent ), m_xRange( xRange ), mxContext( xContext ), bHasMore( true ) { }
297 virtual ::sal_Bool SAL_CALL hasMoreElements( ) throw (uno::RuntimeException) { return bHasMore; }
298 virtual uno::Any SAL_CALL nextElement( ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
299 {
300 if ( !bHasMore )
301 throw container::NoSuchElementException();
302 bHasMore = false;
303 return uno::makeAny( m_xRange );
304 }
305 };
306
307 // very simple class to pass to ScVbaCollectionBaseImpl containing
308 // just one item
309 typedef ::cppu::WeakImplHelper2< container::XIndexAccess, container::XEnumerationAccess > SingleRange_BASE;
310
311 class SingleRangeIndexAccess : public SingleRange_BASE
312 {
313 private:
314 uno::Reference< XHelperInterface > mxParent;
315 uno::Reference< table::XCellRange > m_xRange;
316 uno::Reference< uno::XComponentContext > mxContext;
317 SingleRangeIndexAccess(); // not defined
318 public:
319 SingleRangeIndexAccess( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange ):mxParent( xParent ), m_xRange( xRange ), mxContext( xContext ) {}
320 // XIndexAccess
321 virtual ::sal_Int32 SAL_CALL getCount() throw (::uno::RuntimeException) { return 1; }
322 virtual uno::Any SAL_CALL getByIndex( ::sal_Int32 Index ) throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
323 {
324 if ( Index != 0 )
325 throw lang::IndexOutOfBoundsException();
326 return uno::makeAny( m_xRange );
327 }
328 // XElementAccess
329 virtual uno::Type SAL_CALL getElementType() throw (uno::RuntimeException){ return table::XCellRange::static_type(0); }
330
331 virtual ::sal_Bool SAL_CALL hasElements() throw (uno::RuntimeException) { return sal_True; }
332 // XEnumerationAccess
333 virtual uno::Reference< container::XEnumeration > SAL_CALL createEnumeration() throw (uno::RuntimeException) { return new SingleRangeEnumeration( mxParent, mxContext, m_xRange ); }
334
335 };
336
337
338
339 class RangesEnumerationImpl : public EnumerationHelperImpl
340 {
341 bool mbIsRows;
342 bool mbIsColumns;
343 public:
344
345 RangesEnumerationImpl( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration, bool bIsRows, bool bIsColumns ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xParent, xContext, xEnumeration ), mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) {}
346 virtual uno::Any SAL_CALL nextElement( ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
347 {
348 return lcl_makeRange( m_xParent, m_xContext, m_xEnumeration->nextElement(), mbIsRows, mbIsColumns );
349 }
350 };
351
352
353 class ScVbaRangeAreas : public ScVbaCollectionBaseImpl
354 {
355 bool mbIsRows;
356 bool mbIsColumns;
357 public:
358 ScVbaRangeAreas( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XIndexAccess >& xIndexAccess, bool bIsRows, bool bIsColumns ) : ScVbaCollectionBaseImpl( xParent, xContext, xIndexAccess ), mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) {}
359
360 // XEnumerationAccess
361 virtual uno::Reference< container::XEnumeration > SAL_CALL createEnumeration() throw (uno::RuntimeException);
362
363 // XElementAccess
364 virtual uno::Type SAL_CALL getElementType() throw (uno::RuntimeException){ return excel::XRange::static_type(0); }
365
366 virtual uno::Any createCollectionObject( const uno::Any& aSource );
367
368 virtual OUString getServiceImplName() { return OUString(); }
369
370 virtual uno::Sequence< OUString > getServiceNames() { return uno::Sequence< OUString >(); }
371
372 };
373
374 uno::Reference< container::XEnumeration > SAL_CALL
375 ScVbaRangeAreas::createEnumeration() throw (uno::RuntimeException)
376 {
377 uno::Reference< container::XEnumerationAccess > xEnumAccess( m_xIndexAccess, uno::UNO_QUERY_THROW );
378 return new RangesEnumerationImpl( mxParent, mxContext, xEnumAccess->createEnumeration(), mbIsRows, mbIsColumns );
379 }
380
381 uno::Any
382 ScVbaRangeAreas::createCollectionObject( const uno::Any& aSource )
383 {
384 return lcl_makeRange( mxParent, mxContext, aSource, mbIsRows, mbIsColumns );
385 }
386
387 // assume that xIf is infact a ScCellRangesBase
388 ScDocShell*
389 getDocShellFromIf( const uno::Reference< uno::XInterface >& xIf ) throw ( uno::RuntimeException )
390 {
391 ScCellRangesBase* pUno = ScCellRangesBase::getImplementation( xIf );
392 if ( !pUno )
393 throw uno::RuntimeException( OUString( "Failed to access underlying uno range object" ), uno::Reference< uno::XInterface >() );
394 return pUno->GetDocShell();
395 }
396
397 ScDocShell*
398 getDocShellFromRange( const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException )
399 {
400 // need the ScCellRangesBase to get docshell
401 uno::Reference< uno::XInterface > xIf( xRange );
402 return getDocShellFromIf(xIf );
403 }
404
405 ScDocShell*
406 getDocShellFromRanges( const uno::Reference< sheet::XSheetCellRangeContainer >& xRanges ) throw ( uno::RuntimeException )
407 {
408 // need the ScCellRangesBase to get docshell
409 uno::Reference< uno::XInterface > xIf( xRanges );
410 return getDocShellFromIf(xIf );
411 }
412
413 uno::Reference< frame::XModel > getModelFromXIf( const uno::Reference< uno::XInterface >& xIf ) throw ( uno::RuntimeException )
414 {
415 ScDocShell* pDocShell = getDocShellFromIf(xIf );
416 return pDocShell->GetModel();
417 }
418
419 uno::Reference< frame::XModel > getModelFromRange( const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException )
420 {
421 // the XInterface for getImplementation can be any derived interface, no need for queryInterface
422 uno::Reference< uno::XInterface > xIf( xRange );
423 return getModelFromXIf( xIf );
424 }
425
426 ScDocument*
427 getDocumentFromRange( const uno::Reference< table::XCellRange >& xRange )
428 {
429 ScDocShell* pDocShell = getDocShellFromRange( xRange );
430 if ( !pDocShell )
431 throw uno::RuntimeException( OUString( "Failed to access underlying docshell from uno range object" ), uno::Reference< uno::XInterface >() );
432 ScDocument* pDoc = pDocShell->GetDocument();
433 return pDoc;
434 }
435
436 ScDocument*
437 ScVbaRange::getScDocument() throw (uno::RuntimeException)
438 {
439 if ( mxRanges.is() )
440 {
441 uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY_THROW );
442 uno::Reference< table::XCellRange > xRange( xIndex->getByIndex( 0 ), uno::UNO_QUERY_THROW );
443 return getDocumentFromRange( xRange );
444 }
445 return getDocumentFromRange( mxRange );
446 }
447
448 ScDocShell*
449 ScVbaRange::getScDocShell() throw (uno::RuntimeException)
450 {
451 if ( mxRanges.is() )
452 {
453 uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY_THROW );
454 uno::Reference< table::XCellRange > xRange( xIndex->getByIndex( 0 ), uno::UNO_QUERY_THROW );
455 return getDocShellFromRange( xRange );
456 }
457 return getDocShellFromRange( mxRange );
458 }
459
460 ScVbaRange* ScVbaRange::getImplementation( const uno::Reference< excel::XRange >& rxRange )
461 {
462 // FIXME: always save to use dynamic_cast? Or better to (implement and) use XTunnel?
463 return dynamic_cast< ScVbaRange* >( rxRange.get() );
464 }
465
466 uno::Reference< frame::XModel > ScVbaRange::getUnoModel() throw (uno::RuntimeException)
467 {
468 if( ScDocShell* pDocShell = getScDocShell() )
469 return pDocShell->GetModel();
470 throw uno::RuntimeException();
471 }
472
473 uno::Reference< frame::XModel > ScVbaRange::getUnoModel( const uno::Reference< excel::XRange >& rxRange ) throw (uno::RuntimeException)
474 {
475 if( ScVbaRange* pScVbaRange = getImplementation( rxRange ) )
476 return pScVbaRange->getUnoModel();
477 throw uno::RuntimeException();
478 }
479
480 const ScRangeList& ScVbaRange::getScRangeList() throw (uno::RuntimeException)
481 {
482 if( ScCellRangesBase* pScRangesBase = getCellRangesBase() )
483 return pScRangesBase->GetRangeList();
484 throw uno::RuntimeException( OUString( "Cannot obtain UNO range implementation object" ), uno::Reference< uno::XInterface >() );
485 }
486
487 const ScRangeList& ScVbaRange::getScRangeList( const uno::Reference< excel::XRange >& rxRange ) throw (uno::RuntimeException)
488 {
489 if( ScVbaRange* pScVbaRange = getImplementation( rxRange ) )
490 return pScVbaRange->getScRangeList();
491 throw uno::RuntimeException( OUString( "Cannot obtain VBA range implementation object" ), uno::Reference< uno::XInterface >() );
492 }
493
494
495 class NumFormatHelper
496 {
497 uno::Reference< util::XNumberFormatsSupplier > mxSupplier;
498 uno::Reference< beans::XPropertySet > mxRangeProps;
499 uno::Reference< util::XNumberFormats > mxFormats;
500 public:
501 NumFormatHelper( const uno::Reference< table::XCellRange >& xRange )
502 {
503 mxSupplier.set( getModelFromRange( xRange ), uno::UNO_QUERY_THROW );
504 mxRangeProps.set( xRange, uno::UNO_QUERY_THROW);
505 mxFormats = mxSupplier->getNumberFormats();
506 }
507 uno::Reference< beans::XPropertySet > getNumberProps()
508 {
509 long nIndexKey = 0;
510 uno::Any aValue = mxRangeProps->getPropertyValue( "NumberFormat" );
511 aValue >>= nIndexKey;
512
513 if ( mxFormats.is() )
514 return mxFormats->getByKey( nIndexKey );
515 return uno::Reference< beans::XPropertySet > ();
516 }
517
518 bool isBooleanType()
519 {
520
521 if ( getNumberFormat() & util::NumberFormat::LOGICAL )
522 return true;
523 return false;
524 }
525
526 bool isDateType()
527 {
528 sal_Int16 nType = getNumberFormat();
529 if(( nType & util::NumberFormat::DATETIME ))
530 {
531 return true;
532 }
533 return false;
534 }
535
536 OUString getNumberFormatString()
537 {
538 uno::Reference< uno::XInterface > xIf( mxRangeProps, uno::UNO_QUERY_THROW );
539 ScCellRangesBase* pUnoCellRange = ScCellRangesBase::getImplementation( xIf );
540 if ( pUnoCellRange )
541 {
542
543 SfxItemSet* pDataSet = excel::ScVbaCellRangeAccess::GetDataSet( pUnoCellRange );
544 SfxItemState eState = pDataSet->GetItemState( ATTR_VALUE_FORMAT, true, NULL);
545 // one of the cells in the range is not like the other ;-)
546 // so return a zero length format to indicate that
547 if ( eState == SFX_ITEM_DONTCARE )
548 return OUString();
549 }
550
551
552 uno::Reference< beans::XPropertySet > xNumberProps( getNumberProps(), uno::UNO_QUERY_THROW );
553 OUString aFormatString;
554 uno::Any aString = xNumberProps->getPropertyValue( "FormatString" );
555 aString >>= aFormatString;
556 return aFormatString;
557 }
558
559 sal_Int16 getNumberFormat()
560 {
561 uno::Reference< beans::XPropertySet > xNumberProps = getNumberProps();
562 sal_Int16 nType = ::comphelper::getINT16(
563 xNumberProps->getPropertyValue( "Type" ) );
564 return nType;
565 }
566
567 bool setNumberFormat( const OUString& rFormat )
568 {
569 // #163288# treat "General" as "Standard" format
570 sal_Int32 nNewIndex = 0;
571 if( !rFormat.equalsIgnoreAsciiCase( "General" ) )
572 {
573 lang::Locale aLocale;
574 uno::Reference< beans::XPropertySet > xNumProps = getNumberProps();
575 xNumProps->getPropertyValue( "Locale" ) >>= aLocale;
576 nNewIndex = mxFormats->queryKey( rFormat, aLocale, false );
577 if ( nNewIndex == -1 ) // format not defined
578 nNewIndex = mxFormats->addNew( rFormat, aLocale );
579 }
580 mxRangeProps->setPropertyValue( "NumberFormat", uno::makeAny( nNewIndex ) );
581 return true;
582 }
583
584 bool setNumberFormat( sal_Int16 nType )
585 {
586 uno::Reference< beans::XPropertySet > xNumberProps = getNumberProps();
587 lang::Locale aLocale;
588 xNumberProps->getPropertyValue( "Locale" ) >>= aLocale;
589 uno::Reference<util::XNumberFormatTypes> xTypes( mxFormats, uno::UNO_QUERY );
590 if ( xTypes.is() )
591 {
592 sal_Int32 nNewIndex = xTypes->getStandardFormat( nType, aLocale );
593 mxRangeProps->setPropertyValue( "NumberFormat", uno::makeAny( nNewIndex ) );
594 return true;
595 }
596 return false;
597 }
598
599 };
600
601 struct CellPos
602 {
603 CellPos():m_nRow(-1), m_nCol(-1), m_nArea(0) {};
604 CellPos( sal_Int32 nRow, sal_Int32 nCol, sal_Int32 nArea ):m_nRow(nRow), m_nCol(nCol), m_nArea( nArea ) {};
605 sal_Int32 m_nRow;
606 sal_Int32 m_nCol;
607 sal_Int32 m_nArea;
608 };
609
610 typedef ::cppu::WeakImplHelper1< container::XEnumeration > CellsEnumeration_BASE;
611 typedef ::std::vector< CellPos > vCellPos;
612
613 // #FIXME - QUICK
614 // we could probably could and should modify CellsEnumeration below
615 // to handle rows and columns ( but I do this separately for now
616 // and.. this class only handles singe areas ( does it have to handle
617 // multi area ranges?? )
618 class ColumnsRowEnumeration: public CellsEnumeration_BASE
619 {
620 uno::Reference< uno::XComponentContext > mxContext;
621 uno::Reference< excel::XRange > mxRange;
622 sal_Int32 mMaxElems;
623 sal_Int32 mCurElem;
624
625 public:
626 ColumnsRowEnumeration( const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< excel::XRange >& xRange, sal_Int32 nElems ) : mxContext( xContext ), mxRange( xRange ), mMaxElems( nElems ), mCurElem( 0 )
627 {
628 }
629
630 virtual ::sal_Bool SAL_CALL hasMoreElements() throw (::uno::RuntimeException){ return mCurElem < mMaxElems; }
631
632 virtual uno::Any SAL_CALL nextElement() throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
633 {
634 if ( !hasMoreElements() )
635 throw container::NoSuchElementException();
636 sal_Int32 vbaIndex = 1 + mCurElem++;
637 return uno::makeAny( mxRange->Item( uno::makeAny( vbaIndex ), uno::Any() ) );
638 }
639 };
640
641 class CellsEnumeration : public CellsEnumeration_BASE
642 {
643 uno::WeakReference< XHelperInterface > mxParent;
644 uno::Reference< uno::XComponentContext > mxContext;
645 uno::Reference< XCollection > m_xAreas;
646 vCellPos m_CellPositions;
647 vCellPos::const_iterator m_it;
648
649 uno::Reference< table::XCellRange > getArea( sal_Int32 nVBAIndex ) throw ( uno::RuntimeException )
650 {
651 if ( nVBAIndex < 1 || nVBAIndex > m_xAreas->getCount() )
652 throw uno::RuntimeException();
653 uno::Reference< excel::XRange > xRange( m_xAreas->Item( uno::makeAny(nVBAIndex), uno::Any() ), uno::UNO_QUERY_THROW );
654 uno::Reference< table::XCellRange > xCellRange( ScVbaRange::getCellRange( xRange ), uno::UNO_QUERY_THROW );
655 return xCellRange;
656 }
657
658 void populateArea( sal_Int32 nVBAIndex )
659 {
660 uno::Reference< table::XCellRange > xRange = getArea( nVBAIndex );
661 uno::Reference< table::XColumnRowRange > xColumnRowRange(xRange, uno::UNO_QUERY_THROW );
662 sal_Int32 nRowCount = xColumnRowRange->getRows()->getCount();
663 sal_Int32 nColCount = xColumnRowRange->getColumns()->getCount();
664 for ( sal_Int32 i=0; i<nRowCount; ++i )
665 {
666 for ( sal_Int32 j=0; j<nColCount; ++j )
667 m_CellPositions.push_back( CellPos( i,j,nVBAIndex ) );
668 }
669 }
670 public:
671 CellsEnumeration( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< XCollection >& xAreas ): mxParent( xParent ), mxContext( xContext ), m_xAreas( xAreas )
672 {
673 sal_Int32 nItems = m_xAreas->getCount();
674 for ( sal_Int32 index=1; index <= nItems; ++index )
675 {
676 populateArea( index );
677 }
678 m_it = m_CellPositions.begin();
679 }
680 virtual ::sal_Bool SAL_CALL hasMoreElements() throw (::uno::RuntimeException){ return m_it != m_CellPositions.end(); }
681
682 virtual uno::Any SAL_CALL nextElement() throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
683 {
684 if ( !hasMoreElements() )
685 throw container::NoSuchElementException();
686 CellPos aPos = *(m_it)++;
687
688 uno::Reference< table::XCellRange > xRangeArea = getArea( aPos.m_nArea );
689 uno::Reference< table::XCellRange > xCellRange( xRangeArea->getCellByPosition( aPos.m_nCol, aPos.m_nRow ), uno::UNO_QUERY_THROW );
690 return uno::makeAny( uno::Reference< excel::XRange >( new ScVbaRange( mxParent, mxContext, xCellRange ) ) );
691
692 }
693 };
694
695
696 const static OUString ISVISIBLE( "IsVisible");
697 const static OUString POSITION( "Position");
698 const static OUString EQUALS( "=" );
699 const static OUString NOTEQUALS( "<>" );
700 const static OUString GREATERTHAN( ">" );
701 const static OUString GREATERTHANEQUALS( ">=" );
702 const static OUString LESSTHAN( "<" );
703 const static OUString LESSTHANEQUALS( "<=" );
704 const static OUString CONTS_HEADER( "ContainsHeader" );
705 const static OUString INSERTPAGEBREAKS( "InsertPageBreaks" );
706 const static OUString STR_ERRORMESSAGE_APPLIESTOSINGLERANGEONLY( "The command you chose cannot be performed with multiple selections.\nSelect a single range and click the command again" );
707 const static OUString STR_ERRORMESSAGE_NOCELLSWEREFOUND( "No cells were found" );
708 const static OUString CELLSTYLE( "CellStyle" );
709
710 class CellValueSetter : public ValueSetter
711 {
712 protected:
713 uno::Any maValue;
714 uno::TypeClass mTypeClass;
715 public:
716 CellValueSetter( const uno::Any& aValue );
717 virtual bool processValue( const uno::Any& aValue, const uno::Reference< table::XCell >& xCell );
718 virtual void visitNode( sal_Int32 x, sal_Int32 y, const uno::Reference< table::XCell >& xCell );
719
720 };
721
722 CellValueSetter::CellValueSetter( const uno::Any& aValue ): maValue( aValue ), mTypeClass( aValue.getValueTypeClass() ) {}
723
724 void
725 CellValueSetter::visitNode( sal_Int32 /*i*/, sal_Int32 /*j*/, const uno::Reference< table::XCell >& xCell )
726 {
727 processValue( maValue, xCell );
728 }
729
730 bool
731 CellValueSetter::processValue( const uno::Any& aValue, const uno::Reference< table::XCell >& xCell )
732 {
733
734 bool isExtracted = false;
735 switch ( aValue.getValueTypeClass() )
736 {
737 case uno::TypeClass_BOOLEAN:
738 {
739 sal_Bool bState = false;
740 if ( aValue >>= bState )
741 {
742 uno::Reference< table::XCellRange > xRange( xCell, uno::UNO_QUERY_THROW );
743 if ( bState )
744 xCell->setValue( (double) 1 );
745 else
746 xCell->setValue( (double) 0 );
747 NumFormatHelper cellNumFormat( xRange );
748 cellNumFormat.setNumberFormat( util::NumberFormat::LOGICAL );
749 }
750 break;
751 }
752 case uno::TypeClass_STRING:
753 {
754 OUString aString;
755 if ( aValue >>= aString )
756 {
757 // The required behavior for a string value is:
758 // 1. If the first character is a single quote, use the rest as a string cell, regardless of the cell's number format.
759 // 2. Otherwise, if the cell's number format is "text", use the string value as a string cell.
760 // 3. Otherwise, parse the string value in English locale, and apply a corresponding number format with the cell's locale
761 // if the cell's number format was "General".
762 // Case 1 is handled here, the rest in ScCellObj::InputEnglishString
763
764 if ( aString.toChar() == '\'' ) // case 1 - handle with XTextRange
765 {
766 OUString aRemainder( aString.copy(1) ); // strip the quote
767 uno::Reference< text::XTextRange > xTextRange( xCell, uno::UNO_QUERY_THROW );
768 xTextRange->setString( aRemainder );
769 }
770 else
771 {
772 // call implementation method InputEnglishString
773 ScCellObj* pCellObj = dynamic_cast< ScCellObj* >( xCell.get() );
774 if ( pCellObj )
775 pCellObj->InputEnglishString( aString );
776 }
777 }
778 else
779 isExtracted = false;
780 break;
781 }
782 default:
783 {
784 double nDouble = 0.0;
785 if ( aValue >>= nDouble )
786 {
787 uno::Reference< table::XCellRange > xRange( xCell, uno::UNO_QUERY_THROW );
788 NumFormatHelper cellFormat( xRange );
789 // If we are setting a number and the cell types was logical
790 // then we need to reset the logical format. ( see case uno::TypeClass_BOOLEAN:
791 // handling above )
792 if ( cellFormat.isBooleanType() )
793 cellFormat.setNumberFormat("General");
794 xCell->setValue( nDouble );
795 }
796 else
797 isExtracted = false;
798 break;
799 }
800 }
801 return isExtracted;
802
803 }
804
805
806 class CellValueGetter : public ValueGetter
807 {
808 protected:
809 uno::Any maValue;
810 uno::TypeClass mTypeClass;
811 public:
812 CellValueGetter() {}
813 virtual void visitNode( sal_Int32 x, sal_Int32 y, const uno::Reference< table::XCell >& xCell );
814 virtual void processValue( sal_Int32 x, sal_Int32 y, const uno::Any& aValue );
815 const uno::Any& getValue() const { return maValue; }
816
817 };
818
819 void
820 CellValueGetter::processValue( sal_Int32 /*x*/, sal_Int32 /*y*/, const uno::Any& aValue )
821 {
822 maValue = aValue;
823 }
824 void CellValueGetter::visitNode( sal_Int32 x, sal_Int32 y, const uno::Reference< table::XCell >& xCell )
825 {
826 uno::Any aValue;
827 table::CellContentType eType = xCell->getType();
828 if( eType == table::CellContentType_VALUE || eType == table::CellContentType_FORMULA )
829 {
830 if ( eType == table::CellContentType_FORMULA )
831 {
832
833 OUString sFormula = xCell->getFormula();
834 if ( sFormula == "=TRUE()" )
835 aValue <<= sal_True;
836 else if ( sFormula == "=FALSE()" )
837 aValue <<= false;
838 else
839 {
840 uno::Reference< beans::XPropertySet > xProp( xCell, uno::UNO_QUERY_THROW );
841
842 table::CellContentType eFormulaType = table::CellContentType_VALUE;
843 // some formulas give textual results
844 xProp->getPropertyValue( "FormulaResultType" ) >>= eFormulaType;
845
846 if ( eFormulaType == table::CellContentType_TEXT )
847 {
848 uno::Reference< text::XTextRange > xTextRange(xCell, ::uno::UNO_QUERY_THROW);
849 aValue <<= xTextRange->getString();
850 }
851 else
852 aValue <<= xCell->getValue();
853 }
854 }
855 else
856 {
857 uno::Reference< table::XCellRange > xRange( xCell, uno::UNO_QUERY_THROW );
858 NumFormatHelper cellFormat( xRange );
859 if ( cellFormat.isBooleanType() )
860 aValue = uno::makeAny( ( xCell->getValue() != 0.0 ) );
861 else if ( cellFormat.isDateType() )
862 aValue = uno::makeAny( bridge::oleautomation::Date( xCell->getValue() ) );
863 else
864 aValue <<= xCell->getValue();
865 }
866 }
867 if( eType == table::CellContentType_TEXT )
868 {
869 uno::Reference< text::XTextRange > xTextRange(xCell, ::uno::UNO_QUERY_THROW);
870 aValue <<= xTextRange->getString();
871 }
872 processValue( x,y,aValue );
873 }
874
875 class CellFormulaValueSetter : public CellValueSetter
876 {
877 private:
878 ScDocument* m_pDoc;
879 formula::FormulaGrammar::Grammar m_eGrammar;
880 public:
881 CellFormulaValueSetter( const uno::Any& aValue, ScDocument* pDoc, formula::FormulaGrammar::Grammar eGram ):CellValueSetter( aValue ), m_pDoc( pDoc ), m_eGrammar( eGram ){}
882 protected:
883 bool processValue( const uno::Any& aValue, const uno::Reference< table::XCell >& xCell )
884 {
885 OUString sFormula;
886 double aDblValue = 0.0;
887 if ( aValue >>= sFormula )
888 {
889 // convert to GRAM_PODF_A1 style grammar because XCell::setFormula
890 // always compile it in that grammar. Perhaps
891 // css.sheet.FormulaParser should be used in future to directly
892 // pass formula tokens when that API stabilizes.
893 if ( m_eGrammar != formula::FormulaGrammar::GRAM_PODF_A1 && ( sFormula.trim().indexOf('=') == 0 ) )
894 {
895 uno::Reference< uno::XInterface > xIf( xCell, uno::UNO_QUERY_THROW );
896 ScCellRangesBase* pUnoRangesBase = dynamic_cast< ScCellRangesBase* >( xIf.get() );
897 if ( pUnoRangesBase )
898 {
899 ScRangeList aCellRanges = pUnoRangesBase->GetRangeList();
900 ScCompiler aCompiler( m_pDoc, aCellRanges.front()->aStart );
901 aCompiler.SetGrammar(m_eGrammar);
902 // compile the string in the format passed in
903 aCompiler.CompileString( sFormula );
904 // set desired convention to that of the document
905 aCompiler.SetGrammar( formula::FormulaGrammar::GRAM_PODF_A1 );
906 String sConverted;
907 aCompiler.CreateStringFromTokenArray(sConverted);
908 sFormula = EQUALS + sConverted;
909 }
910 }
911
912 xCell->setFormula( sFormula );
913 return true;
914 }
915 else if ( aValue >>= aDblValue )
916 {
917 xCell->setValue( aDblValue );
918 return true;
919 }
920 return false;
921 }
922
923 };
924
925 class CellFormulaValueGetter : public CellValueGetter
926 {
927 private:
928 ScDocument* m_pDoc;
929 formula::FormulaGrammar::Grammar m_eGrammar;
930 public:
931 CellFormulaValueGetter(ScDocument* pDoc, formula::FormulaGrammar::Grammar eGram ) : CellValueGetter( ), m_pDoc( pDoc ), m_eGrammar( eGram ) {}
932 virtual void visitNode( sal_Int32 x, sal_Int32 y, const uno::Reference< table::XCell >& xCell )
933 {
934 uno::Any aValue;
935 aValue <<= xCell->getFormula();
936 OUString sVal;
937 aValue >>= sVal;
938 uno::Reference< uno::XInterface > xIf( xCell, uno::UNO_QUERY_THROW );
939 ScCellRangesBase* pUnoRangesBase = dynamic_cast< ScCellRangesBase* >( xIf.get() );
940 if ( ( xCell->getType() == table::CellContentType_FORMULA ) &&
941 pUnoRangesBase )
942 {
943 ScRangeList aCellRanges = pUnoRangesBase->GetRangeList();
944 ScCompiler aCompiler( m_pDoc, aCellRanges.front()->aStart );
945 aCompiler.SetGrammar(formula::FormulaGrammar::GRAM_DEFAULT);
946 aCompiler.CompileString( sVal );
947 // set desired convention
948 aCompiler.SetGrammar( m_eGrammar );
949 String sConverted;
950 aCompiler.CreateStringFromTokenArray(sConverted);
951 sVal = EQUALS + sConverted;
952 aValue <<= sVal;
953 }
954
955 processValue( x,y,aValue );
956 }
957
958 };
959
960
961 class Dim2ArrayValueGetter : public ArrayVisitor
962 {
963 protected:
964 uno::Any maValue;
965 ValueGetter& mValueGetter;
966 virtual void processValue( sal_Int32 x, sal_Int32 y, const uno::Any& aValue )
967 {
968 uno::Sequence< uno::Sequence< uno::Any > >& aMatrix = *( uno::Sequence< uno::Sequence< uno::Any > >* )( maValue.getValue() );
969 aMatrix[x][y] = aValue;
970 }
971
972 public:
973 Dim2ArrayValueGetter(sal_Int32 nRowCount, sal_Int32 nColCount, ValueGetter& rValueGetter ): mValueGetter(rValueGetter)
974 {
975 uno::Sequence< uno::Sequence< uno::Any > > aMatrix;
976 aMatrix.realloc( nRowCount );
977 for ( sal_Int32 index = 0; index < nRowCount; ++index )
978 aMatrix[index].realloc( nColCount );
979 maValue <<= aMatrix;
980 }
981 void visitNode( sal_Int32 x, sal_Int32 y, const uno::Reference< table::XCell >& xCell )
982
983 {
984 mValueGetter.visitNode( x, y, xCell );
985 processValue( x, y, mValueGetter.getValue() );
986 }
987 const uno::Any& getValue() const { return maValue; }
988
989 };
990
991 const static OUString sNA("#N/A");
992
993 class Dim1ArrayValueSetter : public ArrayVisitor
994 {
995 uno::Sequence< uno::Any > aMatrix;
996 sal_Int32 nColCount;
997 ValueSetter& mCellValueSetter;
998 public:
999 Dim1ArrayValueSetter( const uno::Any& aValue, ValueSetter& rCellValueSetter ):mCellValueSetter( rCellValueSetter )
1000 {
1001 aValue >>= aMatrix;
1002 nColCount = aMatrix.getLength();
1003 }
1004 virtual void visitNode( sal_Int32 /*x*/, sal_Int32 y, const uno::Reference< table::XCell >& xCell )
1005 {
1006 if ( y < nColCount )
1007 mCellValueSetter.processValue( aMatrix[ y ], xCell );
1008 else
1009 mCellValueSetter.processValue( uno::makeAny( sNA ), xCell );
1010 }
1011 };
1012
1013
1014
1015 class Dim2ArrayValueSetter : public ArrayVisitor
1016 {
1017 uno::Sequence< uno::Sequence< uno::Any > > aMatrix;
1018 ValueSetter& mCellValueSetter;
1019 sal_Int32 nRowCount;
1020 sal_Int32 nColCount;
1021 public:
1022 Dim2ArrayValueSetter( const uno::Any& aValue, ValueSetter& rCellValueSetter ) : mCellValueSetter( rCellValueSetter )
1023 {
1024 aValue >>= aMatrix;
1025 nRowCount = aMatrix.getLength();
1026 nColCount = aMatrix[0].getLength();
1027 }
1028
1029 virtual void visitNode( sal_Int32 x, sal_Int32 y, const uno::Reference< table::XCell >& xCell )
1030 {
1031 if ( x < nRowCount && y < nColCount )
1032 mCellValueSetter.processValue( aMatrix[ x ][ y ], xCell );
1033 else
1034 mCellValueSetter.processValue( uno::makeAny( sNA ), xCell );
1035
1036 }
1037 };
1038
1039 class RangeProcessor
1040 {
1041 public:
1042 virtual void process( const uno::Reference< excel::XRange >& xRange ) = 0;
1043
1044 protected:
1045 ~RangeProcessor() {}
1046 };
1047
1048 class RangeValueProcessor : public RangeProcessor
1049 {
1050 const uno::Any& m_aVal;
1051 public:
1052 RangeValueProcessor( const uno::Any& rVal ):m_aVal( rVal ) {}
1053 virtual ~RangeValueProcessor() {}
1054 virtual void process( const uno::Reference< excel::XRange >& xRange )
1055 {
1056 xRange->setValue( m_aVal );
1057 }
1058 };
1059
1060 class RangeFormulaProcessor : public RangeProcessor
1061 {
1062 const uno::Any& m_aVal;
1063 public:
1064 RangeFormulaProcessor( const uno::Any& rVal ):m_aVal( rVal ) {}
1065 virtual ~RangeFormulaProcessor() {}
1066 virtual void process( const uno::Reference< excel::XRange >& xRange )
1067 {
1068 xRange->setFormula( m_aVal );
1069 }
1070 };
1071
1072 class RangeCountProcessor : public RangeProcessor
1073 {
1074 sal_Int32 nCount;
1075 public:
1076 RangeCountProcessor():nCount(0){}
1077 virtual ~RangeCountProcessor() {}
1078 virtual void process( const uno::Reference< excel::XRange >& xRange )
1079 {
1080 nCount = nCount + xRange->getCount();
1081 }
1082 sal_Int32 value() { return nCount; }
1083 };
1084 class AreasVisitor
1085 {
1086 private:
1087 uno::Reference< XCollection > m_Areas;
1088 public:
1089 AreasVisitor( const uno::Reference< XCollection >& rAreas ):m_Areas( rAreas ){}
1090
1091 void visit( RangeProcessor& processor )
1092 {
1093 if ( m_Areas.is() )
1094 {
1095 sal_Int32 nItems = m_Areas->getCount();
1096 for ( sal_Int32 index=1; index <= nItems; ++index )
1097 {
1098 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
1099 processor.process( xRange );
1100 }
1101 }
1102 }
1103 };
1104
1105 class RangeHelper
1106 {
1107 uno::Reference< table::XCellRange > m_xCellRange;
1108
1109 public:
1110 RangeHelper( const uno::Reference< table::XCellRange >& xCellRange ) throw (uno::RuntimeException) : m_xCellRange( xCellRange )
1111 {
1112 if ( !m_xCellRange.is() )
1113 throw uno::RuntimeException();
1114 }
1115 RangeHelper( const uno::Any aCellRange ) throw (uno::RuntimeException)
1116 {
1117 m_xCellRange.set( aCellRange, uno::UNO_QUERY_THROW );
1118 }
1119 uno::Reference< sheet::XSheetCellRange > getSheetCellRange() throw (uno::RuntimeException)
1120 {
1121 return uno::Reference< sheet::XSheetCellRange >(m_xCellRange, uno::UNO_QUERY_THROW);
1122 }
1123 uno::Reference< sheet::XSpreadsheet > getSpreadSheet() throw (uno::RuntimeException)
1124 {
1125 return getSheetCellRange()->getSpreadsheet();
1126 }
1127
1128 uno::Reference< table::XCellRange > getCellRangeFromSheet() throw (uno::RuntimeException)
1129 {
1130 return uno::Reference< table::XCellRange >(getSpreadSheet(), uno::UNO_QUERY_THROW );
1131 }
1132
1133 uno::Reference< sheet::XCellRangeAddressable > getCellRangeAddressable() throw (uno::RuntimeException)
1134 {
1135 return uno::Reference< sheet::XCellRangeAddressable >(m_xCellRange, ::uno::UNO_QUERY_THROW);
1136
1137 }
1138
1139 uno::Reference< sheet::XSheetCellCursor > getSheetCellCursor() throw ( uno::RuntimeException )
1140 {
1141 return uno::Reference< sheet::XSheetCellCursor >( getSpreadSheet()->createCursorByRange( getSheetCellRange() ), uno::UNO_QUERY_THROW );
1142 }
1143
1144 static uno::Reference< excel::XRange > createRangeFromRange( const uno::Reference< XHelperInterface >& xParent, const uno::Reference<uno::XComponentContext >& xContext,
1145 const uno::Reference< table::XCellRange >& xRange, const uno::Reference< sheet::XCellRangeAddressable >& xCellRangeAddressable,
1146 sal_Int32 nStartColOffset = 0, sal_Int32 nStartRowOffset = 0, sal_Int32 nEndColOffset = 0, sal_Int32 nEndRowOffset = 0 )
1147 {
1148 return uno::Reference< excel::XRange >( new ScVbaRange( xParent, xContext,
1149 xRange->getCellRangeByPosition(
1150 xCellRangeAddressable->getRangeAddress().StartColumn + nStartColOffset,
1151 xCellRangeAddressable->getRangeAddress().StartRow + nStartRowOffset,
1152 xCellRangeAddressable->getRangeAddress().EndColumn + nEndColOffset,
1153 xCellRangeAddressable->getRangeAddress().EndRow + nEndRowOffset ) ) );
1154 }
1155
1156 };
1157
1158 bool
1159 ScVbaRange::getCellRangesForAddress( sal_uInt16& rResFlags, const OUString& sAddress, ScDocShell* pDocSh, ScRangeList& rCellRanges, formula::FormulaGrammar::AddressConvention& eConv, char cDelimiter )
1160 {
1161
1162 ScDocument* pDoc = NULL;
1163 if ( pDocSh )
1164 {
1165 pDoc = pDocSh->GetDocument();
1166 sal_uInt16 nMask = SCA_VALID;
1167 rResFlags = rCellRanges.Parse( sAddress, pDoc, nMask, eConv, 0, cDelimiter );
1168 if ( rResFlags & SCA_VALID )
1169 {
1170 return true;
1171 }
1172 }
1173 return false;
1174 }
1175
1176 bool getScRangeListForAddress( const OUString& sName, ScDocShell* pDocSh, ScRange& refRange, ScRangeList& aCellRanges, formula::FormulaGrammar::AddressConvention aConv = formula::FormulaGrammar::CONV_XL_A1 ) throw ( uno::RuntimeException )
1177 {
1178 // see if there is a match with a named range
1179 uno::Reference< beans::XPropertySet > xProps( pDocSh->GetModel(), uno::UNO_QUERY_THROW );
1180 uno::Reference< container::XNameAccess > xNameAccess( xProps->getPropertyValue( "NamedRanges" ), uno::UNO_QUERY_THROW );
1181 // Strangly enough you can have Range( "namedRange1, namedRange2, etc," )
1182 // loop around each ',' separated name
1183 std::vector< OUString > vNames;
1184 sal_Int32 nIndex = 0;
1185 do
1186 {
1187 OUString aToken = sName.getToken( 0, ',', nIndex );
1188 vNames.push_back( aToken );
1189 } while ( nIndex >= 0 );
1190
1191 if ( vNames.empty() )
1192 vNames.push_back( sName );
1193
1194 std::vector< OUString >::iterator it = vNames.begin();
1195 std::vector< OUString >::iterator it_end = vNames.end();
1196 for ( ; it != it_end; ++it )
1197 {
1198
1199 formula::FormulaGrammar::AddressConvention eConv = aConv;
1200 // spaces are illegal ( but the user of course can enter them )
1201 OUString sAddress = (*it).trim();
1202 // if a local name ( on the active sheet ) exists this will
1203 // take precedence over a global with the same name
1204 bool bLocalName = false;
1205 if ( !xNameAccess->hasByName( sAddress ) && pDocSh )
1206 {
1207 // try a local name
1208 ScDocument* pDoc = pDocSh->GetDocument();
1209 if ( pDoc )
1210 {
1211 SCTAB nCurTab = pDocSh->GetCurTab();
1212 ScRangeName* pRangeName = pDoc->GetRangeName(nCurTab);
1213 if (pRangeName)
1214 {
1215 bLocalName = pRangeName->findByUpperName(ScGlobal::pCharClass->uppercase(sAddress)) != NULL;
1216 // TODO: Handle local names correctly.
1217 (void)bLocalName;
1218 }
1219 }
1220 }
1221 char aChar = 0;
1222 if ( xNameAccess->hasByName( sAddress ) )
1223 {
1224 uno::Reference< sheet::XNamedRange > xNamed( xNameAccess->getByName( sAddress ), uno::UNO_QUERY_THROW );
1225 sAddress = xNamed->getContent();
1226 // As the address comes from OOO, the addressing
1227 // style is may not be XL_A1
1228 eConv = pDocSh->GetDocument()->GetAddressConvention();
1229 aChar = ';';
1230 }
1231
1232 sal_uInt16 nFlags = 0;
1233 if ( !ScVbaRange::getCellRangesForAddress( nFlags, sAddress, pDocSh, aCellRanges, eConv, aChar ) )
1234 return false;
1235
1236 bool bTabFromReferrer = !( nFlags & SCA_TAB_3D );
1237
1238 for ( size_t i = 0, nRanges = aCellRanges.size(); i < nRanges; ++i )
1239 {
1240 ScRange* pRange = aCellRanges[ i ];
1241 pRange->aStart.SetCol( refRange.aStart.Col() + pRange->aStart.Col() );
1242 pRange->aStart.SetRow( refRange.aStart.Row() + pRange->aStart.Row() );
1243 pRange->aStart.SetTab( bTabFromReferrer ? refRange.aStart.Tab() : pRange->aStart.Tab() );
1244 pRange->aEnd.SetCol( refRange.aStart.Col() + pRange->aEnd.Col() );
1245 pRange->aEnd.SetRow( refRange.aStart.Row() + pRange->aEnd.Row() );
1246 pRange->aEnd.SetTab( bTabFromReferrer ? refRange.aEnd.Tab() : pRange->aEnd.Tab() );
1247 }
1248 }
1249 return true;
1250 }
1251
1252
1253 ScVbaRange*
1254 getRangeForName( const uno::Reference< uno::XComponentContext >& xContext, const OUString& sName, ScDocShell* pDocSh, table::CellRangeAddress& pAddr, formula::FormulaGrammar::AddressConvention eConv = formula::FormulaGrammar::CONV_XL_A1 ) throw ( uno::RuntimeException )
1255 {
1256 ScRangeList aCellRanges;
1257 ScRange refRange;
1258 ScUnoConversion::FillScRange( refRange, pAddr );
1259 if ( !getScRangeListForAddress ( sName, pDocSh, refRange, aCellRanges, eConv ) )
1260 throw uno::RuntimeException();
1261 // Single range
1262 if ( aCellRanges.size() == 1 )
1263 {
1264 uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( pDocSh, *aCellRanges.front() ) );
1265 uno::Reference< XHelperInterface > xFixThisParent = excel::getUnoSheetModuleObj( xRange );
1266 return new ScVbaRange( xFixThisParent, xContext, xRange );
1267 }
1268 uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( pDocSh, aCellRanges ) );
1269
1270 uno::Reference< XHelperInterface > xFixThisParent = excel::getUnoSheetModuleObj( xRanges );
1271 return new ScVbaRange( xFixThisParent, xContext, xRanges );
1272 }
1273
1274 // ----------------------------------------------------------------------------
1275
1276 namespace {
1277
1278 template< typename RangeType >
1279 inline table::CellRangeAddress lclGetRangeAddress( const uno::Reference< RangeType >& rxCellRange ) throw (uno::RuntimeException)
1280 {
1281 return uno::Reference< sheet::XCellRangeAddressable >( rxCellRange, uno::UNO_QUERY_THROW )->getRangeAddress();
1282 }
1283
1284 void lclClearRange( const uno::Reference< table::XCellRange >& rxCellRange ) throw (uno::RuntimeException)
1285 {
1286 using namespace ::com::sun::star::sheet::CellFlags;
1287 sal_Int32 nFlags = VALUE | DATETIME | STRING | ANNOTATION | FORMULA | HARDATTR | STYLES | EDITATTR | FORMATTED;
1288 uno::Reference< sheet::XSheetOperation > xSheetOperation( rxCellRange, uno::UNO_QUERY_THROW );
1289 xSheetOperation->clearContents( nFlags );
1290 }
1291
1292 uno::Reference< sheet::XSheetCellRange > lclExpandToMerged( const uno::Reference< table::XCellRange >& rxCellRange, bool bRecursive ) throw (uno::RuntimeException)
1293 {
1294 uno::Reference< sheet::XSheetCellRange > xNewCellRange( rxCellRange, uno::UNO_QUERY_THROW );
1295 uno::Reference< sheet::XSpreadsheet > xSheet( xNewCellRange->getSpreadsheet(), uno::UNO_SET_THROW );
1296 table::CellRangeAddress aNewAddress = lclGetRangeAddress( xNewCellRange );
1297 table::CellRangeAddress aOldAddress;
1298 // expand as long as there are new merged ranges included
1299 do
1300 {
1301 aOldAddress = aNewAddress;
1302 uno::Reference< sheet::XSheetCellCursor > xCursor( xSheet->createCursorByRange( xNewCellRange ), uno::UNO_SET_THROW );
1303 xCursor->collapseToMergedArea();
1304 xNewCellRange.set( xCursor, uno::UNO_QUERY_THROW );
1305 aNewAddress = lclGetRangeAddress( xNewCellRange );
1306 }
1307 while( bRecursive && (aOldAddress != aNewAddress) );
1308 return xNewCellRange;
1309 }
1310
1311 uno::Reference< sheet::XSheetCellRangeContainer > lclExpandToMerged( const uno::Reference< sheet::XSheetCellRangeContainer >& rxCellRanges, bool bRecursive ) throw (uno::RuntimeException)
1312 {
1313 if( !rxCellRanges.is() )
1314 throw uno::RuntimeException( OUString( "Missing cell ranges object" ), uno::Reference< uno::XInterface >() );
1315 sal_Int32 nCount = rxCellRanges->getCount();
1316 if( nCount < 1 )
1317 throw uno::RuntimeException( OUString( "Missing cell ranges object" ), uno::Reference< uno::XInterface >() );
1318
1319 ScRangeList aScRanges;
1320 for( sal_Int32 nIndex = 0; nIndex < nCount; ++nIndex )
1321 {
1322 uno::Reference< table::XCellRange > xRange( rxCellRanges->getByIndex( nIndex ), uno::UNO_QUERY_THROW );
1323 table::CellRangeAddress aRangeAddr = lclGetRangeAddress( lclExpandToMerged( xRange, bRecursive ) );
1324 ScRange aScRange;
1325 ScUnoConversion::FillScRange( aScRange, aRangeAddr );
1326 aScRanges.Append( aScRange );
1327 }
1328 return new ScCellRangesObj( getDocShellFromRanges( rxCellRanges ), aScRanges );
1329 }
1330
1331 void lclExpandAndMerge( const uno::Reference< table::XCellRange >& rxCellRange, bool bMerge ) throw (uno::RuntimeException)
1332 {
1333 uno::Reference< util::XMergeable > xMerge( lclExpandToMerged( rxCellRange, true ), uno::UNO_QUERY_THROW );
1334 // Calc cannot merge over merged ranges, always unmerge first
1335 xMerge->merge( false );
1336 if( bMerge )
1337 {
1338 // clear all contents of the covered cells (not the top-left cell)
1339 table::CellRangeAddress aRangeAddr = lclGetRangeAddress( rxCellRange );
1340 sal_Int32 nLastColIdx = aRangeAddr.EndColumn - aRangeAddr.StartColumn;
1341 sal_Int32 nLastRowIdx = aRangeAddr.EndRow - aRangeAddr.StartRow;
1342 // clear cells of top row, right of top-left cell
1343 if( nLastColIdx > 0 )
1344 lclClearRange( rxCellRange->getCellRangeByPosition( 1, 0, nLastColIdx, 0 ) );
1345 // clear all rows below top row
1346 if( nLastRowIdx > 0 )
1347 lclClearRange( rxCellRange->getCellRangeByPosition( 0, 1, nLastColIdx, nLastRowIdx ) );
1348 // merge the range
1349 xMerge->merge( sal_True );
1350 }
1351 }
1352
1353 util::TriState lclGetMergedState( const uno::Reference< table::XCellRange >& rxCellRange ) throw (uno::RuntimeException)
1354 {
1355 /* 1) Check if range is completely inside one single merged range. To do
1356 this, try to extend from top-left cell only (not from entire range).
1357 This will exclude cases where this range consists of several merged
1358 ranges (or parts of them). */
1359 table::CellRangeAddress aRangeAddr = lclGetRangeAddress( rxCellRange );
1360 uno::Reference< table::XCellRange > xTopLeft( rxCellRange->getCellRangeByPosition( 0, 0, 0, 0 ), uno::UNO_SET_THROW );
1361 uno::Reference< sheet::XSheetCellRange > xExpanded( lclExpandToMerged( xTopLeft, false ), uno::UNO_SET_THROW );
1362 table::CellRangeAddress aExpAddr = lclGetRangeAddress( xExpanded );
1363 // check that expanded range has more than one cell (really merged)
1364 if( ((aExpAddr.StartColumn < aExpAddr.EndColumn) || (aExpAddr.StartRow < aExpAddr.EndRow)) && ScUnoConversion::Contains( aExpAddr, aRangeAddr ) )
1365 return util::TriState_YES;
1366
1367 /* 2) Check if this range contains any merged cells (completely or
1368 partly). This seems to be hardly possible via API, as
1369 XMergeable::getIsMerged() returns only true, if the top-left cell of a
1370 merged range is part of this range, so cases where just the lower part
1371 of a merged range is part of this range are not covered. */
1372 ScRange aScRange;
1373 ScUnoConversion::FillScRange( aScRange, aRangeAddr );
1374 bool bHasMerged = getDocumentFromRange( rxCellRange )->HasAttrib( aScRange, HASATTR_MERGED | HASATTR_OVERLAPPED );
1375 return bHasMerged ? util::TriState_INDETERMINATE : util::TriState_NO;
1376 }
1377
1378 } // namespace
1379
1380 // ----------------------------------------------------------------------------
1381
1382 css::uno::Reference< excel::XRange >
1383 ScVbaRange::getRangeObjectForName(
1384 const uno::Reference< uno::XComponentContext >& xContext, const OUString& sRangeName,
1385 ScDocShell* pDocSh, formula::FormulaGrammar::AddressConvention eConv ) throw ( uno::RuntimeException )
1386 {
1387 table::CellRangeAddress refAddr;
1388 return getRangeForName( xContext, sRangeName, pDocSh, refAddr, eConv );
1389 }
1390
1391 table::CellRangeAddress getCellRangeAddressForVBARange( const uno::Any& aParam, ScDocShell* pDocSh, formula::FormulaGrammar::AddressConvention aConv = formula::FormulaGrammar::CONV_XL_A1) throw ( uno::RuntimeException )
1392 {
1393 uno::Reference< table::XCellRange > xRangeParam;
1394 switch ( aParam.getValueTypeClass() )
1395 {
1396 case uno::TypeClass_STRING:
1397 {
1398 OUString rString;
1399 aParam >>= rString;
1400 ScRangeList aCellRanges;
1401 ScRange refRange;
1402 if ( getScRangeListForAddress ( rString, pDocSh, refRange, aCellRanges, aConv ) )
1403 {
1404 if ( aCellRanges.size() == 1 )
1405 {
1406 table::CellRangeAddress aRangeAddress;
1407 ScUnoConversion::FillApiRange( aRangeAddress, *aCellRanges.front() );
1408 return aRangeAddress;
1409 }
1410 }
1411 }
1412 case uno::TypeClass_INTERFACE:
1413 {
1414 uno::Reference< excel::XRange > xRange;
1415 aParam >>= xRange;
1416 if ( xRange.is() )
1417 xRange->getCellRange() >>= xRangeParam;
1418 break;
1419 }
1420 default:
1421 throw uno::RuntimeException( OUString( "Can't extact CellRangeAddress from type" ), uno::Reference< uno::XInterface >() );
1422 }
1423 return lclGetRangeAddress( xRangeParam );
1424 }
1425
1426 static uno::Reference< XCollection >
1427 lcl_setupBorders( const uno::Reference< excel::XRange >& xParentRange, const uno::Reference<uno::XComponentContext>& xContext, const uno::Reference< table::XCellRange >& xRange ) throw( uno::RuntimeException )
1428 {
1429 uno::Reference< XHelperInterface > xParent( xParentRange, uno::UNO_QUERY_THROW );
1430 ScDocument* pDoc = getDocumentFromRange(xRange);
1431 if ( !pDoc )
1432 throw uno::RuntimeException( OUString( "Failed to access document from shell" ), uno::Reference< uno::XInterface >() );
1433 ScVbaPalette aPalette( pDoc->GetDocumentShell() );
1434 uno::Reference< XCollection > borders( new ScVbaBorders( xParent, xContext, xRange, aPalette ) );
1435 return borders;
1436 }
1437
1438 ScVbaRange::ScVbaRange( uno::Sequence< uno::Any> const & args,
1439 uno::Reference< uno::XComponentContext> const & xContext ) throw ( lang::IllegalArgumentException ) : ScVbaRange_BASE( getXSomethingFromArgs< XHelperInterface >( args, 0 ), xContext, getXSomethingFromArgs< beans::XPropertySet >( args, 1, false ), getModelFromXIf( getXSomethingFromArgs< uno::XInterface >( args, 1 ) ), true ), mbIsRows( false ), mbIsColumns( false )
1440 {
1441 mxRange.set( mxPropertySet, uno::UNO_QUERY );
1442 mxRanges.set( mxPropertySet, uno::UNO_QUERY );
1443 uno::Reference< container::XIndexAccess > xIndex;
1444 if ( mxRange.is() )
1445 {
1446 xIndex = new SingleRangeIndexAccess( mxParent, mxContext, mxRange );
1447 }
1448 else if ( mxRanges.is() )
1449 {
1450 xIndex.set( mxRanges, uno::UNO_QUERY_THROW );
1451 }
1452 m_Areas = new ScVbaRangeAreas( mxParent, mxContext, xIndex, mbIsRows, mbIsColumns );
1453 }
1454
1455 ScVbaRange::ScVbaRange( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange, sal_Bool bIsRows, sal_Bool bIsColumns ) throw( lang::IllegalArgumentException )
1456 : ScVbaRange_BASE( xParent, xContext, uno::Reference< beans::XPropertySet >( xRange, uno::UNO_QUERY_THROW ), getModelFromRange( xRange), true ), mxRange( xRange ),
1457 mbIsRows( bIsRows ),
1458 mbIsColumns( bIsColumns )
1459 {
1460 if ( !xContext.is() )
1461 throw lang::IllegalArgumentException( OUString( "context is not set " ), uno::Reference< uno::XInterface >() , 1 );
1462 if ( !xRange.is() )
1463 throw lang::IllegalArgumentException( OUString( "range is not set " ), uno::Reference< uno::XInterface >() , 1 );
1464
1465 uno::Reference< container::XIndexAccess > xIndex( new SingleRangeIndexAccess( mxParent, mxContext, xRange ) );
1466 m_Areas = new ScVbaRangeAreas( mxParent, mxContext, xIndex, mbIsRows, mbIsColumns );
1467
1468 }
1469
1470 ScVbaRange::ScVbaRange( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< sheet::XSheetCellRangeContainer >& xRanges, sal_Bool bIsRows, sal_Bool bIsColumns ) throw ( lang::IllegalArgumentException )
1471 : ScVbaRange_BASE( xParent, xContext, uno::Reference< beans::XPropertySet >( xRanges, uno::UNO_QUERY_THROW ), getModelFromXIf( uno::Reference< uno::XInterface >( xRanges, uno::UNO_QUERY_THROW ) ), true ), mxRanges( xRanges ),mbIsRows( bIsRows ), mbIsColumns( bIsColumns )
1472
1473 {
1474 uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY_THROW );
1475 m_Areas = new ScVbaRangeAreas( xParent, mxContext, xIndex, mbIsRows, mbIsColumns );
1476
1477 }
1478
1479 ScVbaRange::~ScVbaRange()
1480 {
1481 }
1482
1483 uno::Reference< XCollection >& ScVbaRange::getBorders()
1484 {
1485 if ( !m_Borders.is() )
1486 {
1487 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32(1) ), uno::Any() ), uno::UNO_QUERY_THROW );
1488 m_Borders = lcl_setupBorders( this, mxContext, uno::Reference< table::XCellRange >( xRange->getCellRange(), uno::UNO_QUERY_THROW ) );
1489 }
1490 return m_Borders;
1491 }
1492
1493 void
1494 ScVbaRange::visitArray( ArrayVisitor& visitor )
1495 {
1496 table::CellRangeAddress aRangeAddr = lclGetRangeAddress( mxRange );
1497 sal_Int32 nRowCount = aRangeAddr.EndRow - aRangeAddr.StartRow + 1;
1498 sal_Int32 nColCount = aRangeAddr.EndColumn - aRangeAddr.StartColumn + 1;
1499 for ( sal_Int32 i=0; i<nRowCount; ++i )
1500 {
1501 for ( sal_Int32 j=0; j<nColCount; ++j )
1502 {
1503 uno::Reference< table::XCell > xCell( mxRange->getCellByPosition( j, i ), uno::UNO_QUERY_THROW );
1504
1505 visitor.visitNode( i, j, xCell );
1506 }
1507 }
1508 }
1509
1510 uno::Any
1511 ScVbaRange::getValue( ValueGetter& valueGetter) throw (uno::RuntimeException)
1512 {
1513 uno::Reference< table::XColumnRowRange > xColumnRowRange(mxRange, uno::UNO_QUERY_THROW );
1514 // single cell range
1515 if ( isSingleCellRange() )
1516 {
1517 visitArray( valueGetter );
1518 return valueGetter.getValue();
1519 }
1520 sal_Int32 nRowCount = xColumnRowRange->getRows()->getCount();
1521 sal_Int32 nColCount = xColumnRowRange->getColumns()->getCount();
1522 // multi cell range ( return array )
1523 Dim2ArrayValueGetter arrayGetter( nRowCount, nColCount, valueGetter );
1524 visitArray( arrayGetter );
1525 return uno::makeAny( script::ArrayWrapper( false, arrayGetter.getValue() ) );
1526 }
1527
1528 uno::Any SAL_CALL
1529 ScVbaRange::getValue() throw (uno::RuntimeException)
1530 {
1531 // #TODO code within the test below "if ( m_Areas.... " can be removed
1532 // Test is performed only because m_xRange is NOT set to be
1533 // the first range in m_Areas ( to force failure while
1534 // the implementations for each method are being updated )
1535 if ( m_Areas->getCount() > 1 )
1536 {
1537 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
1538 return xRange->getValue();
1539 }
1540
1541 CellValueGetter valueGetter;
1542 return getValue( valueGetter );
1543
1544 }
1545
1546
1547 void
1548 ScVbaRange::setValue( const uno::Any& aValue, ValueSetter& valueSetter, bool bFireEvent ) throw (uno::RuntimeException)
1549 {
1550 uno::TypeClass aClass = aValue.getValueTypeClass();
1551 if ( aClass == uno::TypeClass_SEQUENCE )
1552 {
1553 uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( mxContext );
1554 uno::Any aConverted;
1555 try
1556 {
1557 // test for single dimension, could do
1558 // with a better test than this
1559 if ( aValue.getValueTypeName().indexOf('[') == aValue.getValueTypeName().lastIndexOf('[') )
1560 {
1561 aConverted = xConverter->convertTo( aValue, getCppuType((uno::Sequence< uno::Any >*)0) );
1562 Dim1ArrayValueSetter setter( aConverted, valueSetter );
1563 visitArray( setter );
1564 }
1565 else
1566 {
1567 aConverted = xConverter->convertTo( aValue, getCppuType((uno::Sequence< uno::Sequence< uno::Any > >*)0) );
1568 Dim2ArrayValueSetter setter( aConverted, valueSetter );
1569 visitArray( setter );
1570 }
1571 }
1572 catch ( const uno::Exception& e )
1573 {
1574 OSL_TRACE("Bahhh, caught exception %s",
1575 OUStringToOString( e.Message,
1576 RTL_TEXTENCODING_UTF8 ).getStr() );
1577 }
1578 }
1579 else
1580 {
1581 visitArray( valueSetter );
1582 }
1583 if( bFireEvent ) fireChangeEvent();
1584 }
1585
1586 void SAL_CALL
1587 ScVbaRange::setValue( const uno::Any &aValue ) throw (uno::RuntimeException)
1588 {
1589 // If this is a multiple selection apply setValue over all areas
1590 if ( m_Areas->getCount() > 1 )
1591 {
1592 AreasVisitor aVisitor( m_Areas );
1593 RangeValueProcessor valueProcessor( aValue );
1594 aVisitor.visit( valueProcessor );
1595 return;
1596 }
1597 CellValueSetter valueSetter( aValue );
1598 setValue( aValue, valueSetter, true );
1599 }
1600
1601 void SAL_CALL
1602 ScVbaRange::Clear() throw (uno::RuntimeException)
1603 {
1604 using namespace ::com::sun::star::sheet::CellFlags;
1605 sal_Int32 nFlags = VALUE | DATETIME | STRING | FORMULA | HARDATTR | EDITATTR | FORMATTED;
1606 ClearContents( nFlags, true );
1607 }
1608
1609 //helper ClearContent
1610 void
1611 ScVbaRange::ClearContents( sal_Int32 nFlags, bool bFireEvent ) throw (uno::RuntimeException)
1612 {
1613 // #TODO code within the test below "if ( m_Areas.... " can be removed
1614 // Test is performed only because m_xRange is NOT set to be
1615 // the first range in m_Areas ( to force failure while
1616 // the implementations for each method are being updated )
1617 if ( m_Areas->getCount() > 1 )
1618 {
1619 sal_Int32 nItems = m_Areas->getCount();
1620 for ( sal_Int32 index=1; index <= nItems; ++index )
1621 {
1622 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
1623 ScVbaRange* pRange = getImplementation( xRange );
1624 if ( pRange )
1625 pRange->ClearContents( nFlags, false ); // do not fire for single ranges
1626 }
1627 // fire change event for the entire range list
1628 if( bFireEvent ) fireChangeEvent();
1629 return;
1630 }
1631
1632
1633 uno::Reference< sheet::XSheetOperation > xSheetOperation(mxRange, uno::UNO_QUERY_THROW);
1634 xSheetOperation->clearContents( nFlags );
1635 if( bFireEvent ) fireChangeEvent();
1636 }
1637
1638 void SAL_CALL
1639 ScVbaRange::ClearComments() throw (uno::RuntimeException)
1640 {
1641 ClearContents( sheet::CellFlags::ANNOTATION, false );
1642 }
1643
1644 void SAL_CALL
1645 ScVbaRange::ClearContents() throw (uno::RuntimeException)
1646 {
1647 using namespace ::com::sun::star::sheet::CellFlags;
1648 sal_Int32 nFlags = VALUE | DATETIME | STRING | FORMULA;
1649 ClearContents( nFlags, true );
1650 }
1651
1652 void SAL_CALL
1653 ScVbaRange::ClearFormats() throw (uno::RuntimeException)
1654 {
1655 // FIXME: need to check if we need to combine FORMATTED
1656 using namespace ::com::sun::star::sheet::CellFlags;
1657 sal_Int32 nFlags = HARDATTR | FORMATTED | EDITATTR;
1658 ClearContents( nFlags, false );
1659 }
1660
1661 void
1662 ScVbaRange::setFormulaValue( const uno::Any& rFormula, formula::FormulaGrammar::Grammar eGram, bool bFireEvent ) throw (uno::RuntimeException)
1663 {
1664 // If this is a multiple selection apply setFormula over all areas
1665 if ( m_Areas->getCount() > 1 )
1666 {
1667 AreasVisitor aVisitor( m_Areas );
1668 RangeFormulaProcessor valueProcessor( rFormula );
1669 aVisitor.visit( valueProcessor );
1670 return;
1671 }
1672 CellFormulaValueSetter formulaValueSetter( rFormula, getScDocument(), eGram );
1673 setValue( rFormula, formulaValueSetter, bFireEvent );
1674 }
1675
1676 uno::Any
1677 ScVbaRange::getFormulaValue( formula::FormulaGrammar::Grammar eGram ) throw (uno::RuntimeException)
1678 {
1679 // #TODO code within the test below "if ( m_Areas.... " can be removed
1680 // Test is performed only because m_xRange is NOT set to be
1681 // the first range in m_Areas ( to force failure while
1682 // the implementations for each method are being updated )
1683 if ( m_Areas->getCount() > 1 )
1684 {
1685 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
1686 return xRange->getFormula();
1687 }
1688 CellFormulaValueGetter valueGetter( getScDocument(), eGram );
1689 return getValue( valueGetter );
1690
1691 }
1692
1693 void
1694 ScVbaRange::setFormula(const uno::Any &rFormula ) throw (uno::RuntimeException)
1695 {
1696 // #FIXME converting "=$a$1" e.g. CONV_XL_A1 -> CONV_OOO // results in "=$a$1:a1", temporalily disable conversion
1697 setFormulaValue( rFormula,formula::FormulaGrammar::GRAM_NATIVE_XL_A1, true );
1698 }
1699
1700 uno::Any
1701 ScVbaRange::getFormulaR1C1() throw (::com::sun::star::uno::RuntimeException)
1702 {
1703 return getFormulaValue( formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1 );
1704 }
1705
1706 void
1707 ScVbaRange::setFormulaR1C1(const uno::Any& rFormula ) throw (uno::RuntimeException)
1708 {
1709 setFormulaValue( rFormula,formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1, true );
1710 }
1711
1712 uno::Any
1713 ScVbaRange::getFormula() throw (::com::sun::star::uno::RuntimeException)
1714 {
1715 return getFormulaValue( formula::FormulaGrammar::GRAM_NATIVE_XL_A1 );
1716 }
1717
1718 sal_Int32
1719 ScVbaRange::getCount() throw (uno::RuntimeException)
1720 {
1721 // If this is a multiple selection apply setValue over all areas
1722 if ( m_Areas->getCount() > 1 )
1723 {
1724 AreasVisitor aVisitor( m_Areas );
1725 RangeCountProcessor valueProcessor;
1726 aVisitor.visit( valueProcessor );
1727 return valueProcessor.value();
1728 }
1729 sal_Int32 rowCount = 0;
1730 sal_Int32 colCount = 0;
1731 uno::Reference< table::XColumnRowRange > xColumnRowRange(mxRange, uno::UNO_QUERY_THROW );
1732 rowCount = xColumnRowRange->getRows()->getCount();
1733 colCount = xColumnRowRange->getColumns()->getCount();
1734
1735 if( IsRows() )
1736 return rowCount;
1737 if( IsColumns() )
1738 return colCount;
1739 return rowCount * colCount;
1740 }
1741
1742 sal_Int32
1743 ScVbaRange::getRow() throw (uno::RuntimeException)
1744 {
1745 // #TODO code within the test below "if ( m_Areas.... " can be removed
1746 // Test is performed only because m_xRange is NOT set to be
1747 // the first range in m_Areas ( to force failure while
1748 // the implementations for each method are being updated )
1749 if ( m_Areas->getCount() > 1 )
1750 {
1751 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
1752 return xRange->getRow();
1753 }
1754 uno::Reference< sheet::XCellAddressable > xCellAddressable(mxRange->getCellByPosition(0, 0), uno::UNO_QUERY_THROW );
1755 return xCellAddressable->getCellAddress().Row + 1; // Zero value indexing
1756 }
1757
1758 sal_Int32
1759 ScVbaRange::getColumn() throw (uno::RuntimeException)
1760 {
1761 // #TODO code within the test below "if ( m_Areas.... " can be removed
1762 // Test is performed only because m_xRange is NOT set to be
1763 // the first range in m_Areas ( to force failure while
1764 // the implementations for each method are being updated )
1765 if ( m_Areas->getCount() > 1 )
1766 {
1767 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
1768 return xRange->getColumn();
1769 }
1770 uno::Reference< sheet::XCellAddressable > xCellAddressable(mxRange->getCellByPosition(0, 0), uno::UNO_QUERY_THROW );
1771 return xCellAddressable->getCellAddress().Column + 1; // Zero value indexing
1772 }
1773
1774 uno::Any
1775 ScVbaRange::HasFormula() throw (uno::RuntimeException)
1776 {
1777 if ( m_Areas->getCount() > 1 )
1778 {
1779 sal_Int32 nItems = m_Areas->getCount();
1780 uno::Any aResult = aNULL();
1781 for ( sal_Int32 index=1; index <= nItems; ++index )
1782 {
1783 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
1784 // if the HasFormula for any area is different to another
1785 // return null
1786 if ( index > 1 )
1787 if ( aResult != xRange->HasFormula() )
1788 return aNULL();
1789 aResult = xRange->HasFormula();
1790 if ( aNULL() == aResult )
1791 return aNULL();
1792 }
1793 return aResult;
1794 }
1795 uno::Reference< uno::XInterface > xIf( mxRange, uno::UNO_QUERY_THROW );
1796 ScCellRangesBase* pThisRanges = dynamic_cast< ScCellRangesBase * > ( xIf.get() );
1797 if ( pThisRanges )
1798 {
1799 uno::Reference<uno::XInterface> xRanges( pThisRanges->queryFormulaCells( ( sheet::FormulaResult::ERROR | sheet::FormulaResult::VALUE | sheet::FormulaResult::STRING ) ), uno::UNO_QUERY_THROW );
1800 ScCellRangesBase* pFormulaRanges = dynamic_cast< ScCellRangesBase * > ( xRanges.get() );
1801 // check if there are no formula cell, return false
1802 if ( pFormulaRanges->GetRangeList().empty() )
1803 return uno::makeAny(sal_False);
1804
1805 // chech if there are holes (where some cells are not formulas)
1806 // or returned range is not equal to this range
1807 if ( ( pFormulaRanges->GetRangeList().size() > 1 )
1808 || ( pFormulaRanges->GetRangeList().front()->aStart != pThisRanges->GetRangeList().front()->aStart )
1809 || ( pFormulaRanges->GetRangeList().front()->aEnd != pThisRanges->GetRangeList().front()->aEnd )
1810 )
1811 return aNULL(); // should return aNULL;
1812 }
1813 return uno::makeAny( sal_True );
1814 }
1815 void
1816 ScVbaRange::fillSeries( sheet::FillDirection nFillDirection, sheet::FillMode nFillMode, sheet::FillDateMode nFillDateMode, double fStep, double fEndValue ) throw( uno::RuntimeException )
1817 {
1818 if ( m_Areas->getCount() > 1 )
1819 {
1820 // Multi-Area Range
1821 uno::Reference< XCollection > xCollection( m_Areas, uno::UNO_QUERY_THROW );
1822 for ( sal_Int32 index = 1; index <= xCollection->getCount(); ++index )
1823 {
1824 uno::Reference< excel::XRange > xRange( xCollection->Item( uno::makeAny( index ), uno::Any() ), uno::UNO_QUERY_THROW );
1825 ScVbaRange* pThisRange = getImplementation( xRange );
1826 pThisRange->fillSeries( nFillDirection, nFillMode, nFillDateMode, fStep, fEndValue );
1827
1828 }
1829 return;
1830 }
1831
1832 uno::Reference< sheet::XCellSeries > xCellSeries(mxRange, uno::UNO_QUERY_THROW );
1833 xCellSeries->fillSeries( nFillDirection, nFillMode, nFillDateMode, fStep, fEndValue );
1834 }
1835
1836 void
1837 ScVbaRange::FillLeft() throw (uno::RuntimeException)
1838 {
1839 fillSeries(sheet::FillDirection_TO_LEFT,
1840 sheet::FillMode_SIMPLE, sheet::FillDateMode_FILL_DATE_DAY, 0, 0x7FFFFFFF);
1841 }
1842
1843 void
1844 ScVbaRange::FillRight() throw (uno::RuntimeException)
1845 {
1846 fillSeries(sheet::FillDirection_TO_RIGHT,
1847 sheet::FillMode_SIMPLE, sheet::FillDateMode_FILL_DATE_DAY, 0, 0x7FFFFFFF);
1848 }
1849
1850 void
1851 ScVbaRange::FillUp() throw (uno::RuntimeException)
1852 {
1853 fillSeries(sheet::FillDirection_TO_TOP,
1854 sheet::FillMode_SIMPLE, sheet::FillDateMode_FILL_DATE_DAY, 0, 0x7FFFFFFF);
1855 }
1856
1857 void
1858 ScVbaRange::FillDown() throw (uno::RuntimeException)
1859 {
1860 fillSeries(sheet::FillDirection_TO_BOTTOM,
1861 sheet::FillMode_SIMPLE, sheet::FillDateMode_FILL_DATE_DAY, 0, 0x7FFFFFFF);
1862 }
1863
1864 OUString
1865 ScVbaRange::getText() throw (uno::RuntimeException)
1866 {
1867 // #TODO code within the test below "if ( m_Areas.... " can be removed
1868 // Test is performed only because m_xRange is NOT set to be
1869 // the first range in m_Areas ( to force failure while
1870 // the implementations for each method are being updated )
1871 if ( m_Areas->getCount() > 1 )
1872 {
1873 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
1874 return xRange->getText();
1875 }
1876 uno::Reference< text::XTextRange > xTextRange(mxRange->getCellByPosition(0,0), uno::UNO_QUERY_THROW );
1877 return xTextRange->getString();
1878 }
1879
1880 uno::Reference< excel::XRange >
1881 ScVbaRange::Offset( const ::uno::Any &nRowOff, const uno::Any &nColOff ) throw (uno::RuntimeException)
1882 {
1883 SCROW nRowOffset = 0;
1884 SCCOL nColOffset = 0;
1885 sal_Bool bIsRowOffset = ( nRowOff >>= nRowOffset );
1886 sal_Bool bIsColumnOffset = ( nColOff >>= nColOffset );
1887 ScCellRangesBase* pUnoRangesBase = getCellRangesBase();
1888
1889 ScRangeList aCellRanges = pUnoRangesBase->GetRangeList();
1890
1891
1892 for ( size_t i = 0, nRanges = aCellRanges.size(); i < nRanges; ++i )
1893 {
1894 ScRange* pRange = aCellRanges[ i ];
1895 if ( bIsColumnOffset )
1896 {
1897 pRange->aStart.SetCol( pRange->aStart.Col() + nColOffset );
1898 pRange->aEnd.SetCol( pRange->aEnd.Col() + nColOffset );
1899 }
1900 if ( bIsRowOffset )
1901 {
1902 pRange->aStart.SetRow( pRange->aStart.Row() + nRowOffset );
1903 pRange->aEnd.SetRow( pRange->aEnd.Row() + nRowOffset );
1904 }
1905 }
1906
1907 if ( aCellRanges.size() > 1 ) // Multi-Area
1908 {
1909 uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( pUnoRangesBase->GetDocShell(), aCellRanges ) );
1910 return new ScVbaRange( mxParent, mxContext, xRanges );
1911 }
1912 // normal range
1913 uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( pUnoRangesBase->GetDocShell(), *aCellRanges.front() ) );
1914 return new ScVbaRange( mxParent, mxContext, xRange );
1915 }
1916
1917 uno::Reference< excel::XRange >
1918 ScVbaRange::CurrentRegion() throw (uno::RuntimeException)
1919 {
1920 // #TODO code within the test below "if ( m_Areas.... " can be removed
1921 // Test is performed only because m_xRange is NOT set to be
1922 // the first range in m_Areas ( to force failure while
1923 // the implementations for each method are being updated )
1924 if ( m_Areas->getCount() > 1 )
1925 {
1926 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
1927 return xRange->CurrentRegion();
1928 }
1929
1930 RangeHelper helper( mxRange );
1931 uno::Reference< sheet::XSheetCellCursor > xSheetCellCursor =
1932 helper.getSheetCellCursor();
1933 xSheetCellCursor->collapseToCurrentRegion();
1934 uno::Reference< sheet::XCellRangeAddressable > xCellRangeAddressable(xSheetCellCursor, uno::UNO_QUERY_THROW);
1935 return RangeHelper::createRangeFromRange( mxParent, mxContext, helper.getCellRangeFromSheet(), xCellRangeAddressable );
1936 }
1937
1938 uno::Reference< excel::XRange >
1939 ScVbaRange::CurrentArray() throw (uno::RuntimeException)
1940 {
1941 // #TODO code within the test below "if ( m_Areas.... " can be removed
1942 // Test is performed only because m_xRange is NOT set to be
1943 // the first range in m_Areas ( to force failure while
1944 // the implementations for each method are being updated )
1945 if ( m_Areas->getCount() > 1 )
1946 {
1947 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
1948 return xRange->CurrentArray();
1949 }
1950 RangeHelper helper( mxRange );
1951 uno::Reference< sheet::XSheetCellCursor > xSheetCellCursor =
1952 helper.getSheetCellCursor();
1953 xSheetCellCursor->collapseToCurrentArray();
1954 uno::Reference< sheet::XCellRangeAddressable > xCellRangeAddressable(xSheetCellCursor, uno::UNO_QUERY_THROW);
1955 return RangeHelper::createRangeFromRange( mxParent, mxContext, helper.getCellRangeFromSheet(), xCellRangeAddressable );
1956 }
1957
1958 uno::Any
1959 ScVbaRange::getFormulaArray() throw (uno::RuntimeException)
1960 {
1961 // #TODO code within the test below "if ( m_Areas.... " can be removed
1962 // Test is performed only because m_xRange is NOT set to be
1963 // the first range in m_Areas ( to force failure while
1964 // the implementations for each method are being updated )
1965 if ( m_Areas->getCount() > 1 )
1966 {
1967 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
1968 return xRange->getFormulaArray();
1969 }
1970
1971 uno::Reference< sheet::XCellRangeFormula> xCellRangeFormula( mxRange, uno::UNO_QUERY_THROW );
1972 uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( mxContext );
1973 uno::Any aSingleValueOrMatrix;
1974 // When dealing with a single element ( embedded in the sequence of sequence ) unwrap and return
1975 // that value
1976 uno::Sequence< uno::Sequence<rtl::OUString> > aTmpSeq = xCellRangeFormula->getFormulaArray();
1977 if ( aTmpSeq.getLength() == 1 )
1978 {
1979 if ( aTmpSeq[ 0 ].getLength() == 1 )
1980 aSingleValueOrMatrix <<= aTmpSeq[ 0 ][ 0 ];
1981 }
1982 else
1983 aSingleValueOrMatrix = xConverter->convertTo( uno::makeAny( aTmpSeq ) , getCppuType((uno::Sequence< uno::Sequence< uno::Any > >*)0) ) ;
1984 return aSingleValueOrMatrix;
1985 }
1986
1987 void
1988 ScVbaRange::setFormulaArray(const uno::Any& rFormula) throw (uno::RuntimeException)
1989 {
1990 // #TODO code within the test below "if ( m_Areas.... " can be removed
1991 // Test is performed only because m_xRange is NOT set to be
1992 // the first range in m_Areas ( to force failure while
1993 // the implementations for each method are being updated )
1994 if ( m_Areas->getCount() > 1 )
1995 {
1996 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
1997 return xRange->setFormulaArray( rFormula );
1998 }
1999 // #TODO need to distinguish between getFormula and getFormulaArray e.g. (R1C1)
2000 // but for the moment its just easier to treat them the same for setting
2001
2002 setFormula( rFormula );
2003 }
2004
2005 OUString
2006 ScVbaRange::Characters(const uno::Any& Start, const uno::Any& Length) throw (uno::RuntimeException)
2007 {
2008 // #TODO code within the test below "if ( m_Areas.... " can be removed
2009 // Test is performed only because m_xRange is NOT set to be
2010 // the first range in m_Areas ( to force failure while
2011 // the implementations for each method are being updated )
2012 if ( m_Areas->getCount() > 1 )
2013 {
2014 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
2015 return xRange->Characters( Start, Length );
2016 }
2017
2018 long nIndex = 0, nCount = 0;
2019 OUString rString;
2020 uno::Reference< text::XTextRange > xTextRange(mxRange, ::uno::UNO_QUERY_THROW );
2021 rString = xTextRange->getString();
2022 if( !( Start >>= nIndex ) && !( Length >>= nCount ) )
2023 return rString;
2024 if(!( Start >>= nIndex ) )
2025 nIndex = 1;
2026 if(!( Length >>= nCount ) )
2027 nIndex = rString.getLength();
2028 return rString.copy( --nIndex, nCount ); // Zero value indexing
2029 }
2030
2031 OUString
2032 ScVbaRange::Address( const uno::Any& RowAbsolute, const uno::Any& ColumnAbsolute, const uno::Any& ReferenceStyle, const uno::Any& External, const uno::Any& RelativeTo ) throw (uno::RuntimeException)
2033 {
2034 if ( m_Areas->getCount() > 1 )
2035 {
2036 // Multi-Area Range
2037 OUString sAddress;
2038 uno::Reference< XCollection > xCollection( m_Areas, uno::UNO_QUERY_THROW );
2039 uno::Any aExternalCopy = External;
2040 for ( sal_Int32 index = 1; index <= xCollection->getCount(); ++index )
2041 {
2042 uno::Reference< excel::XRange > xRange( xCollection->Item( uno::makeAny( index ), uno::Any() ), uno::UNO_QUERY_THROW );
2043 if ( index > 1 )
2044 {
2045 sAddress += OUString( ',' );
2046 // force external to be false
2047 // only first address should have the
2048 // document and sheet specifications
2049 aExternalCopy = uno::makeAny(sal_False);
2050 }
2051 sAddress += xRange->Address( RowAbsolute, ColumnAbsolute, ReferenceStyle, aExternalCopy, RelativeTo );
2052 }
2053 return sAddress;
2054
2055 }
2056 ScAddress::Details dDetails( formula::FormulaGrammar::CONV_XL_A1, 0, 0 );
2057 if ( ReferenceStyle.hasValue() )
2058 {
2059 sal_Int32 refStyle = excel::XlReferenceStyle::xlA1;
2060 ReferenceStyle >>= refStyle;
2061 if ( refStyle == excel::XlReferenceStyle::xlR1C1 )
2062 dDetails = ScAddress::Details( formula::FormulaGrammar::CONV_XL_R1C1, 0, 0 );
2063 }
2064 sal_uInt16 nFlags = SCA_VALID;
2065 ScDocShell* pDocShell = getScDocShell();
2066 ScDocument* pDoc = pDocShell->GetDocument();
2067
2068 RangeHelper thisRange( mxRange );
2069 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
2070 ScRange aRange( static_cast< SCCOL >( thisAddress.StartColumn ), static_cast< SCROW >( thisAddress.StartRow ), static_cast< SCTAB >( thisAddress.Sheet ), static_cast< SCCOL >( thisAddress.EndColumn ), static_cast< SCROW >( thisAddress.EndRow ), static_cast< SCTAB >( thisAddress.Sheet ) );
2071 String sRange;
2072 sal_uInt16 ROW_ABSOLUTE = ( SCA_ROW_ABSOLUTE | SCA_ROW2_ABSOLUTE );
2073 sal_uInt16 COL_ABSOLUTE = ( SCA_COL_ABSOLUTE | SCA_COL2_ABSOLUTE );
2074 // default
2075 nFlags |= ( SCA_TAB_ABSOLUTE | SCA_COL_ABSOLUTE | SCA_ROW_ABSOLUTE | SCA_TAB2_ABSOLUTE | SCA_COL2_ABSOLUTE | SCA_ROW2_ABSOLUTE );
2076 if ( RowAbsolute.hasValue() )
2077 {
2078 sal_Bool bVal = sal_True;
2079 RowAbsolute >>= bVal;
2080 if ( !bVal )
2081 nFlags &= ~ROW_ABSOLUTE;
2082 }
2083 if ( ColumnAbsolute.hasValue() )
2084 {
2085 sal_Bool bVal = sal_True;
2086 ColumnAbsolute >>= bVal;
2087 if ( !bVal )
2088 nFlags &= ~COL_ABSOLUTE;
2089 }
2090 sal_Bool bLocal = false;
2091 if ( External.hasValue() )
2092 {
2093 External >>= bLocal;
2094 if ( bLocal )
2095 nFlags |= SCA_TAB_3D | SCA_FORCE_DOC;
2096 }
2097 if ( RelativeTo.hasValue() )
2098 {
2099 // #TODO should I throw an error if R1C1 is not set?
2100
2101 table::CellRangeAddress refAddress = getCellRangeAddressForVBARange( RelativeTo, pDocShell );
2102 dDetails = ScAddress::Details( formula::FormulaGrammar::CONV_XL_R1C1, static_cast< SCROW >( refAddress.StartRow ), static_cast< SCCOL >( refAddress.StartColumn ) );
2103 }
2104 aRange.Format( sRange, nFlags, pDoc, dDetails );
2105 return sRange;
2106 }
2107
2108 uno::Reference < excel::XFont >
2109 ScVbaRange::Font() throw ( script::BasicErrorException, uno::RuntimeException)
2110 {
2111 uno::Reference< beans::XPropertySet > xProps(mxRange, ::uno::UNO_QUERY );
2112 ScDocument* pDoc = getScDocument();
2113 if ( mxRange.is() )
2114 xProps.set(mxRange, ::uno::UNO_QUERY );
2115 else if ( mxRanges.is() )
2116 xProps.set(mxRanges, ::uno::UNO_QUERY );
2117 if ( !pDoc )
2118 throw uno::RuntimeException( OUString( "Failed to access document from shell" ), uno::Reference< uno::XInterface >() );
2119
2120 ScVbaPalette aPalette( pDoc->GetDocumentShell() );
2121 ScCellRangeObj* pRangeObj = NULL;
2122 try
2123 {
2124 pRangeObj = getCellRangeObj();
2125 }
2126 catch( uno::Exception& )
2127 {
2128 }
2129 return new ScVbaFont( this, mxContext, aPalette, xProps, pRangeObj );
2130 }
2131
2132 uno::Reference< excel::XRange >
2133 ScVbaRange::Cells( const uno::Any &nRowIndex, const uno::Any &nColumnIndex ) throw(uno::RuntimeException)
2134 {
2135 // #TODO code within the test below "if ( m_Areas.... " can be removed
2136 // Test is performed only because m_xRange is NOT set to be
2137 // the first range in m_Areas ( to force failure while
2138 // the implementations for each method are being updated )
2139 if ( m_Areas->getCount() > 1 )
2140 {
2141 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
2142 return xRange->Cells( nRowIndex, nColumnIndex );
2143 }
2144
2145 // Performance: Use a common helper method for ScVbaRange::Cells and ScVbaWorksheet::Cells,
2146 // instead of creating a new ScVbaRange object in often-called ScVbaWorksheet::Cells
2147 return CellsHelper( mxParent, mxContext, mxRange, nRowIndex, nColumnIndex );
2148 }
2149
2150 // static
2151 uno::Reference< excel::XRange >
2152 ScVbaRange::CellsHelper( const uno::Reference< ov::XHelperInterface >& xParent,
2153 const uno::Reference< uno::XComponentContext >& xContext,
2154 const uno::Reference< css::table::XCellRange >& xRange,
2155 const uno::Any &nRowIndex, const uno::Any &nColumnIndex ) throw(uno::RuntimeException)
2156 {
2157 sal_Int32 nRow = 0, nColumn = 0;
2158
2159 sal_Bool bIsIndex = nRowIndex.hasValue();
2160 sal_Bool bIsColumnIndex = nColumnIndex.hasValue();
2161
2162 // Sometimes we might get a float or a double or whatever
2163 // set in the Any, we should convert as appropriate
2164 // #FIXME - perhaps worth turning this into some sort of
2165 // convertion routine e.g. bSuccess = getValueFromAny( nRow, nRowIndex, getCppuType((sal_Int32*)0) )
2166 uno::Any aRowIndexAny = nRowIndex;
2167 if ( aRowIndexAny.hasValue() && !( aRowIndexAny >>= nRow ) )
2168 {
2169 uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( xContext );
2170 uno::Any aConverted;
2171 try
2172 {
2173 aConverted = xConverter->convertTo( aRowIndexAny, getCppuType((sal_Int32*)0) );
2174 bIsIndex = ( aConverted >>= nRow );
2175 }
2176 catch( uno::Exception& ) {} // silence any errors
2177 }
2178
2179 uno::Any aColumnAny = nColumnIndex;
2180
2181 if ( bIsColumnIndex )
2182 {
2183 // Column index can be a col address e.g Cells( 1, "B" ) etc.
2184 OUString sCol;
2185 if ( nColumnIndex >>= sCol )
2186 {
2187 ScAddress::Details dDetails( formula::FormulaGrammar::CONV_XL_A1, 0, 0 );
2188 ScRange tmpRange;
2189 sal_uInt16 flags = tmpRange.ParseCols( sCol, getDocumentFromRange( xRange ), dDetails );
2190 if ( ( flags & 0x200 ) != 0x200 )
2191 throw uno::RuntimeException();
2192 nColumn = tmpRange.aStart.Col() + 1;
2193 }
2194 else
2195 {
2196 if ( !( aColumnAny >>= nColumn ) )
2197 {
2198 uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( xContext );
2199 uno::Any aConverted;
2200 try
2201 {
2202 aConverted = xConverter->convertTo( aColumnAny, getCppuType((sal_Int32*)0) );
2203 bIsColumnIndex = ( aConverted >>= nColumn );
2204 }
2205 catch( uno::Exception& ) {} // silence any errors
2206 }
2207 }
2208 }
2209 RangeHelper thisRange( xRange );
2210 table::CellRangeAddress thisRangeAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
2211 uno::Reference< table::XCellRange > xSheetRange = thisRange.getCellRangeFromSheet();
2212 if( !bIsIndex && !bIsColumnIndex ) // .Cells
2213 // #FIXE needs proper parent ( Worksheet )
2214 return uno::Reference< excel::XRange >( new ScVbaRange( xParent, xContext, xRange ) );
2215
2216 sal_Int32 nIndex = --nRow;
2217 if( bIsIndex && !bIsColumnIndex ) // .Cells(n)
2218 {
2219 uno::Reference< table::XColumnRowRange > xColumnRowRange(xRange, ::uno::UNO_QUERY_THROW);
2220 sal_Int32 nColCount = xColumnRowRange->getColumns()->getCount();
2221
2222 if ( !nIndex || nIndex < 0 )
2223 nRow = 0;
2224 else
2225 nRow = nIndex / nColCount;
2226 nColumn = nIndex % nColCount;
2227 }
2228 else
2229 --nColumn;
2230 nRow = nRow + thisRangeAddress.StartRow;
2231 nColumn = nColumn + thisRangeAddress.StartColumn;
2232 return new ScVbaRange( xParent, xContext, xSheetRange->getCellRangeByPosition( nColumn, nRow, nColumn, nRow ) );
2233 }
2234
2235 void
2236 ScVbaRange::Select() throw (uno::RuntimeException)
2237 {
2238 ScCellRangesBase* pUnoRangesBase = getCellRangesBase();
2239 if ( !pUnoRangesBase )
2240 throw uno::RuntimeException( OUString( "Failed to access underlying uno range object" ), uno::Reference< uno::XInterface >() );
2241 ScDocShell* pShell = pUnoRangesBase->GetDocShell();
2242 if ( pShell )
2243 {
2244 uno::Reference< frame::XModel > xModel( pShell->GetModel(), uno::UNO_QUERY_THROW );
2245 uno::Reference< view::XSelectionSupplier > xSelection( xModel->getCurrentController(), uno::UNO_QUERY_THROW );
2246 if ( mxRanges.is() )
2247 xSelection->select( uno::Any( lclExpandToMerged( mxRanges, true ) ) );
2248 else
2249 xSelection->select( uno::Any( lclExpandToMerged( mxRange, true ) ) );
2250 // set focus on document e.g.
2251 // ThisComponent.CurrentController.Frame.getContainerWindow.SetFocus
2252 try
2253 {
2254 uno::Reference< frame::XController > xController( xModel->getCurrentController(), uno::UNO_QUERY_THROW );
2255 uno::Reference< frame::XFrame > xFrame( xController->getFrame(), uno::UNO_QUERY_THROW );
2256 uno::Reference< awt::XWindow > xWin( xFrame->getContainerWindow(), uno::UNO_QUERY_THROW );
2257 xWin->setFocus();
2258 }
2259 catch( uno::Exception& )
2260 {
2261 }
2262 }
2263 }
2264
2265 bool cellInRange( const table::CellRangeAddress& rAddr, const sal_Int32& nCol, const sal_Int32& nRow )
2266 {
2267 if ( nCol >= rAddr.StartColumn && nCol <= rAddr.EndColumn &&
2268 nRow >= rAddr.StartRow && nRow <= rAddr.EndRow )
2269 return true;
2270 return false;
2271 }
2272
2273 void setCursor( const SCCOL& nCol, const SCROW& nRow, const uno::Reference< frame::XModel >& xModel, bool bInSel = true )
2274 {
2275 ScTabViewShell* pShell = excel::getBestViewShell( xModel );
2276 if ( pShell )
2277 {
2278 if ( bInSel )
2279 pShell->SetCursor( nCol, nRow );
2280 else
2281 pShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_NONE, false, false, sal_True, false );
2282 }
2283 }
2284
2285 void
2286 ScVbaRange::Activate() throw (uno::RuntimeException)
2287 {
2288 // get first cell of current range
2289 uno::Reference< table::XCellRange > xCellRange;
2290 if ( mxRanges.is() )
2291 {
2292 uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY_THROW );
2293 xCellRange.set( xIndex->getByIndex( 0 ), uno::UNO_QUERY_THROW );
2294 }
2295 else
2296 xCellRange.set( mxRange, uno::UNO_QUERY_THROW );
2297
2298 RangeHelper thisRange( xCellRange );
2299 uno::Reference< sheet::XCellRangeAddressable > xThisRangeAddress = thisRange.getCellRangeAddressable();
2300 table::CellRangeAddress thisRangeAddress = xThisRangeAddress->getRangeAddress();
2301 uno::Reference< frame::XModel > xModel;
2302 ScDocShell* pShell = getScDocShell();
2303
2304 if ( pShell )
2305 xModel = pShell->GetModel();
2306
2307 if ( !xModel.is() )
2308 throw uno::RuntimeException();
2309
2310 // get current selection
2311 uno::Reference< sheet::XCellRangeAddressable > xRange( xModel->getCurrentSelection(), ::uno::UNO_QUERY);
2312
2313 uno::Reference< sheet::XSheetCellRanges > xRanges( xModel->getCurrentSelection(), ::uno::UNO_QUERY);
2314
2315 if ( xRanges.is() )
2316 {
2317 uno::Sequence< table::CellRangeAddress > nAddrs = xRanges->getRangeAddresses();
2318 for ( sal_Int32 index = 0; index < nAddrs.getLength(); ++index )
2319 {
2320 if ( cellInRange( nAddrs[index], thisRangeAddress.StartColumn, thisRangeAddress.StartRow ) )
2321 {
2322 setCursor( static_cast< SCCOL >( thisRangeAddress.StartColumn ), static_cast< SCROW >( thisRangeAddress.StartRow ), xModel );
2323 return;
2324 }
2325
2326 }
2327 }
2328
2329 if ( xRange.is() && cellInRange( xRange->getRangeAddress(), thisRangeAddress.StartColumn, thisRangeAddress.StartRow ) )
2330 setCursor( static_cast< SCCOL >( thisRangeAddress.StartColumn ), static_cast< SCROW >( thisRangeAddress.StartRow ), xModel );
2331 else
2332 {
2333 // if this range is multi cell select the range other
2334 // wise just position the cell at this single range position
2335 if ( isSingleCellRange() )
2336 // This top-leftmost cell of this Range is not in the current
2337 // selection so just select this range
2338 setCursor( static_cast< SCCOL >( thisRangeAddress.StartColumn ), static_cast< SCROW >( thisRangeAddress.StartRow ), xModel, false );
2339 else
2340 Select();
2341 }
2342
2343 }
2344
2345 uno::Reference< excel::XRange >
2346 ScVbaRange::Rows(const uno::Any& aIndex ) throw (uno::RuntimeException)
2347 {
2348 OUString sAddress;
2349
2350 if ( aIndex.hasValue() )
2351 {
2352 sal_Int32 nValue = 0;
2353 ScCellRangesBase* pUnoRangesBase = getCellRangesBase();
2354 ScRangeList aCellRanges = pUnoRangesBase->GetRangeList();
2355
2356 ScRange aRange = *aCellRanges.front();
2357 if( aIndex >>= nValue )
2358 {
2359 aRange.aStart.SetRow( aRange.aStart.Row() + --nValue );
2360 aRange.aEnd.SetRow( aRange.aStart.Row() );
2361 }
2362 else if ( aIndex >>= sAddress )
2363 {
2364 ScAddress::Details dDetails( formula::FormulaGrammar::CONV_XL_A1, 0, 0 );
2365 ScRange tmpRange;
2366 tmpRange.ParseRows( sAddress, getDocumentFromRange( mxRange ), dDetails );
2367 SCROW nStartRow = tmpRange.aStart.Row();
2368 SCROW nEndRow = tmpRange.aEnd.Row();
2369
2370 aRange.aStart.SetRow( aRange.aStart.Row() + nStartRow );
2371 aRange.aEnd.SetRow( aRange.aStart.Row() + ( nEndRow - nStartRow ));
2372 }
2373 else
2374 throw uno::RuntimeException( OUString( "Illegal param" ), uno::Reference< uno::XInterface >() );
2375
2376 if ( aRange.aStart.Row() < 0 || aRange.aEnd.Row() < 0 )
2377 throw uno::RuntimeException( OUString("Internal failure, illegal param"), uno::Reference< uno::XInterface >() );
2378 // return a normal range ( even for multi-selection
2379 uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( pUnoRangesBase->GetDocShell(), aRange ) );
2380 return new ScVbaRange( mxParent, mxContext, xRange, true );
2381 }
2382 // Rows() - no params
2383 if ( m_Areas->getCount() > 1 )
2384 return new ScVbaRange( mxParent, mxContext, mxRanges, true );
2385 return new ScVbaRange( mxParent, mxContext, mxRange, true );
2386 }
2387
2388 uno::Reference< excel::XRange >
2389 ScVbaRange::Columns(const uno::Any& aIndex ) throw (uno::RuntimeException)
2390 {
2391 OUString sAddress;
2392
2393 ScCellRangesBase* pUnoRangesBase = getCellRangesBase();
2394 ScRangeList aCellRanges = pUnoRangesBase->GetRangeList();
2395
2396 ScRange aRange = *aCellRanges.front();
2397 if ( aIndex.hasValue() )
2398 {
2399 sal_Int32 nValue = 0;
2400 if ( aIndex >>= nValue )
2401 {
2402 aRange.aStart.SetCol( aRange.aStart.Col() + static_cast< SCCOL > ( --nValue ) );
2403 aRange.aEnd.SetCol( aRange.aStart.Col() );
2404 }
2405
2406 else if ( aIndex >>= sAddress )
2407 {
2408 ScAddress::Details dDetails( formula::FormulaGrammar::CONV_XL_A1, 0, 0 );
2409 ScRange tmpRange;
2410 tmpRange.ParseCols( sAddress, getDocumentFromRange( mxRange ), dDetails );
2411 SCCOL nStartCol = tmpRange.aStart.Col();
2412 SCCOL nEndCol = tmpRange.aEnd.Col();
2413
2414 aRange.aStart.SetCol( aRange.aStart.Col() + nStartCol );
2415 aRange.aEnd.SetCol( aRange.aStart.Col() + ( nEndCol - nStartCol ));
2416 }
2417 else
2418 throw uno::RuntimeException( OUString( "Illegal param" ), uno::Reference< uno::XInterface >() );
2419
2420 if ( aRange.aStart.Col() < 0 || aRange.aEnd.Col() < 0 )
2421 throw uno::RuntimeException( OUString("Internal failure, illegal param"), uno::Reference< uno::XInterface >() );
2422 }
2423 // Columns() - no params
2424 uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( pUnoRangesBase->GetDocShell(), aRange ) );
2425 return new ScVbaRange( mxParent, mxContext, xRange, false, true );
2426 }
2427
2428 void
2429 ScVbaRange::setMergeCells( const uno::Any& aIsMerged ) throw (script::BasicErrorException, uno::RuntimeException)
2430 {
2431 bool bMerge = extractBoolFromAny( aIsMerged );
2432
2433 if( mxRanges.is() )
2434 {
2435 sal_Int32 nCount = mxRanges->getCount();
2436
2437 // VBA does nothing (no error) if the own ranges overlap somehow
2438 ::std::vector< table::CellRangeAddress > aList;
2439 for( sal_Int32 nIndex = 0; nIndex < nCount; ++nIndex )
2440 {
2441 uno::Reference< sheet::XCellRangeAddressable > xRangeAddr( mxRanges->getByIndex( nIndex ), uno::UNO_QUERY_THROW );
2442 table::CellRangeAddress aAddress = xRangeAddr->getRangeAddress();
2443 for( ::std::vector< table::CellRangeAddress >::const_iterator aIt = aList.begin(), aEnd = aList.end(); aIt != aEnd; ++aIt )
2444 if( ScUnoConversion::Intersects( *aIt, aAddress ) )
2445 return;
2446 aList.push_back( aAddress );
2447 }
2448
2449 // (un)merge every range after it has been extended to intersecting merged ranges from sheet
2450 for( sal_Int32 nIndex = 0; nIndex < nCount; ++nIndex )
2451 {
2452 uno::Reference< table::XCellRange > xRange( mxRanges->getByIndex( nIndex ), uno::UNO_QUERY_THROW );
2453 lclExpandAndMerge( xRange, bMerge );
2454 }
2455 return;
2456 }
2457
2458 // otherwise, merge single range
2459 lclExpandAndMerge( mxRange, bMerge );
2460 }
2461
2462 uno::Any
2463 ScVbaRange::getMergeCells() throw (script::BasicErrorException, uno::RuntimeException)
2464 {
2465 if( mxRanges.is() )
2466 {
2467 sal_Int32 nCount = mxRanges->getCount();
2468 for( sal_Int32 nIndex = 0; nIndex < nCount; ++nIndex )
2469 {
2470 uno::Reference< table::XCellRange > xRange( mxRanges->getByIndex( nIndex ), uno::UNO_QUERY_THROW );
2471 util::TriState eMerged = lclGetMergedState( xRange );
2472 /* Excel always returns NULL, if one range of the range list is
2473 partly or completely merged. Even if all ranges are completely
2474 merged, the return value is still NULL. */
2475 if( eMerged != util::TriState_NO )
2476 return aNULL();
2477 }
2478 // no range is merged anyhow, return false
2479 return uno::Any( false );
2480 }
2481
2482 // otherwise, check single range
2483 switch( lclGetMergedState( mxRange ) )
2484 {
2485 case util::TriState_YES: return uno::Any( true );
2486 case util::TriState_NO: return uno::Any( false );
2487 default: return aNULL();
2488 }
2489 }
2490
2491 void
2492 ScVbaRange::Copy(const ::uno::Any& Destination) throw (uno::RuntimeException)
2493 {
2494 if ( m_Areas->getCount() > 1 )
2495 throw uno::RuntimeException( OUString("That command cannot be used on multiple selections" ), uno::Reference< uno::XInterface >() );
2496 if ( Destination.hasValue() )
2497 {
2498 uno::Reference< excel::XRange > xRange( Destination, uno::UNO_QUERY_THROW );
2499 uno::Any aRange = xRange->getCellRange();
2500 uno::Reference< table::XCellRange > xCellRange;
2501 aRange >>= xCellRange;
2502 uno::Reference< sheet::XSheetCellRange > xSheetCellRange(xCellRange, ::uno::UNO_QUERY_THROW);
2503 uno::Reference< sheet::XSpreadsheet > xSheet = xSheetCellRange->getSpreadsheet();
2504 uno::Reference< table::XCellRange > xDest( xSheet, uno::UNO_QUERY_THROW );
2505 uno::Reference< sheet::XCellRangeMovement > xMover( xSheet, uno::UNO_QUERY_THROW);
2506 uno::Reference< sheet::XCellAddressable > xDestination( xDest->getCellByPosition(
2507 xRange->getColumn()-1,xRange->getRow()-1), uno::UNO_QUERY_THROW );
2508 uno::Reference< sheet::XCellRangeAddressable > xSource( mxRange, uno::UNO_QUERY);
2509 xMover->copyRange( xDestination->getCellAddress(), xSource->getRangeAddress() );
2510 if ( ScVbaRange* pRange = getImplementation( xRange ) )
2511 pRange->fireChangeEvent();
2512 }
2513 else
2514 {
2515 uno::Reference< frame::XModel > xModel = getModelFromRange( mxRange );
2516 Select();
2517 excel::implnCopy( xModel );
2518 }
2519 }
2520
2521 void
2522 ScVbaRange::Cut(const ::uno::Any& Destination) throw (uno::RuntimeException)
2523 {
2524 if ( m_Areas->getCount() > 1 )
2525 throw uno::RuntimeException( OUString( "That command cannot be used on multiple selections" ), uno::Reference< uno::XInterface >() );
2526 if (Destination.hasValue())
2527 {
2528 uno::Reference< excel::XRange > xRange( Destination, uno::UNO_QUERY_THROW );
2529 uno::Reference< table::XCellRange > xCellRange( xRange->getCellRange(), uno::UNO_QUERY_THROW );
2530 uno::Reference< sheet::XSheetCellRange > xSheetCellRange(xCellRange, ::uno::UNO_QUERY_THROW );
2531 uno::Reference< sheet::XSpreadsheet > xSheet = xSheetCellRange->getSpreadsheet();
2532 uno::Reference< table::XCellRange > xDest( xSheet, uno::UNO_QUERY_THROW );
2533 uno::Reference< sheet::XCellRangeMovement > xMover( xSheet, uno::UNO_QUERY_THROW);
2534 uno::Reference< sheet::XCellAddressable > xDestination( xDest->getCellByPosition(
2535 xRange->getColumn()-1,xRange->getRow()-1), uno::UNO_QUERY);
2536 uno::Reference< sheet::XCellRangeAddressable > xSource( mxRange, uno::UNO_QUERY);
2537 xMover->moveRange( xDestination->getCellAddress(), xSource->getRangeAddress() );
2538 }
2539 else
2540 {
2541 uno::Reference< frame::XModel > xModel = getModelFromRange( mxRange );
2542 Select();
2543 excel::implnCut( xModel );
2544 }
2545 }
2546
2547 void
2548 ScVbaRange::setNumberFormat( const uno::Any& aFormat ) throw ( script::BasicErrorException, uno::RuntimeException)
2549 {
2550 OUString sFormat;
2551 aFormat >>= sFormat;
2552 if ( m_Areas->getCount() > 1 )
2553 {
2554 sal_Int32 nItems = m_Areas->getCount();
2555 for ( sal_Int32 index=1; index <= nItems; ++index )
2556 {
2557 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
2558 xRange->setNumberFormat( aFormat );
2559 }
2560 return;
2561 }
2562 NumFormatHelper numFormat( mxRange );
2563 numFormat.setNumberFormat( sFormat );
2564 }
2565
2566 uno::Any
2567 ScVbaRange::getNumberFormat() throw ( script::BasicErrorException, uno::RuntimeException)
2568 {
2569
2570 if ( m_Areas->getCount() > 1 )
2571 {
2572 sal_Int32 nItems = m_Areas->getCount();
2573 uno::Any aResult = aNULL();
2574 for ( sal_Int32 index=1; index <= nItems; ++index )
2575 {
2576 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
2577 // if the numberformat of one area is different to another
2578 // return null
2579 if ( index > 1 )
2580 if ( aResult != xRange->getNumberFormat() )
2581 return aNULL();
2582 aResult = xRange->getNumberFormat();
2583 if ( aNULL() == aResult )
2584 return aNULL();
2585 }
2586 return aResult;
2587 }
2588 NumFormatHelper numFormat( mxRange );
2589 OUString sFormat = numFormat.getNumberFormatString();
2590 if ( !sFormat.isEmpty() )
2591 return uno::makeAny( sFormat );
2592 return aNULL();
2593 }
2594
2595 uno::Reference< excel::XRange >
2596 ScVbaRange::Resize( const uno::Any &RowSize, const uno::Any &ColumnSize ) throw (uno::RuntimeException)
2597 {
2598 long nRowSize = 0, nColumnSize = 0;
2599 sal_Bool bIsRowChanged = ( RowSize >>= nRowSize ), bIsColumnChanged = ( ColumnSize >>= nColumnSize );
2600 uno::Reference< table::XColumnRowRange > xColumnRowRange(mxRange, ::uno::UNO_QUERY_THROW);
2601 uno::Reference< sheet::XSheetCellRange > xSheetRange(mxRange, ::uno::UNO_QUERY_THROW);
2602 uno::Reference< sheet::XSheetCellCursor > xCursor( xSheetRange->getSpreadsheet()->createCursorByRange(xSheetRange), ::uno::UNO_QUERY_THROW );
2603
2604 if( !bIsRowChanged )
2605 nRowSize = xColumnRowRange->getRows()->getCount();
2606 if( !bIsColumnChanged )
2607 nColumnSize = xColumnRowRange->getColumns()->getCount();
2608
2609 xCursor->collapseToSize( nColumnSize, nRowSize );
2610 uno::Reference< sheet::XCellRangeAddressable > xCellRangeAddressable(xCursor, ::uno::UNO_QUERY_THROW );
2611 uno::Reference< table::XCellRange > xRange( xSheetRange->getSpreadsheet(), ::uno::UNO_QUERY_THROW );
2612 return new ScVbaRange( mxParent, mxContext,xRange->getCellRangeByPosition(
2613 xCellRangeAddressable->getRangeAddress().StartColumn,
2614 xCellRangeAddressable->getRangeAddress().StartRow,
2615 xCellRangeAddressable->getRangeAddress().EndColumn,
2616 xCellRangeAddressable->getRangeAddress().EndRow ) );
2617 }
2618
2619 void
2620 ScVbaRange::setWrapText( const uno::Any& aIsWrapped ) throw (script::BasicErrorException, uno::RuntimeException)
2621 {
2622 if ( m_Areas->getCount() > 1 )
2623 {
2624 sal_Int32 nItems = m_Areas->getCount();
2625 uno::Any aResult;
2626 for ( sal_Int32 index=1; index <= nItems; ++index )
2627 {
2628 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
2629 xRange->setWrapText( aIsWrapped );
2630 }
2631 return;
2632 }
2633
2634 uno::Reference< beans::XPropertySet > xProps(mxRange, ::uno::UNO_QUERY_THROW );
2635 bool bIsWrapped = extractBoolFromAny( aIsWrapped );
2636 xProps->setPropertyValue( "IsTextWrapped", uno::Any( bIsWrapped ) );
2637 }
2638
2639 uno::Any
2640 ScVbaRange::getWrapText() throw (script::BasicErrorException, uno::RuntimeException)
2641 {
2642 if ( m_Areas->getCount() > 1 )
2643 {
2644 sal_Int32 nItems = m_Areas->getCount();
2645 uno::Any aResult;
2646 for ( sal_Int32 index=1; index <= nItems; ++index )
2647 {
2648 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
2649 if ( index > 1 )
2650 if ( aResult != xRange->getWrapText() )
2651 return aNULL();
2652 aResult = xRange->getWrapText();
2653 }
2654 return aResult;
2655 }
2656
2657 SfxItemSet* pDataSet = getCurrentDataSet();
2658
2659 SfxItemState eState = pDataSet->GetItemState( ATTR_LINEBREAK, true, NULL);
2660 if ( eState == SFX_ITEM_DONTCARE )
2661 return aNULL();
2662
2663 uno::Reference< beans::XPropertySet > xProps(mxRange, ::uno::UNO_QUERY_THROW );
2664 uno::Any aValue = xProps->getPropertyValue( "IsTextWrapped" );
2665 return aValue;
2666 }
2667
2668 uno::Reference< excel::XInterior > ScVbaRange::Interior( ) throw ( script::BasicErrorException, uno::RuntimeException)
2669 {
2670 uno::Reference< beans::XPropertySet > xProps( mxRange, uno::UNO_QUERY_THROW );
2671 return new ScVbaInterior ( this, mxContext, xProps, getScDocument() );
2672 }
2673 uno::Reference< excel::XRange >
2674 ScVbaRange::Range( const uno::Any &Cell1, const uno::Any &Cell2 ) throw (uno::RuntimeException)
2675 {
2676 return Range( Cell1, Cell2, false );
2677 }
2678 uno::Reference< excel::XRange >
2679 ScVbaRange::Range( const uno::Any &Cell1, const uno::Any &Cell2, bool bForceUseInpuRangeTab ) throw (uno::RuntimeException)
2680
2681 {
2682 uno::Reference< table::XCellRange > xCellRange = mxRange;
2683
2684 if ( m_Areas->getCount() > 1 )
2685 {
2686 uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY_THROW );
2687 xCellRange.set( xIndex->getByIndex( 0 ), uno::UNO_QUERY_THROW );
2688 }
2689 else
2690 xCellRange.set( mxRange );
2691
2692 RangeHelper thisRange( xCellRange );
2693 uno::Reference< table::XCellRange > xRanges = thisRange.getCellRangeFromSheet();
2694 uno::Reference< sheet::XCellRangeAddressable > xAddressable( xRanges, uno::UNO_QUERY_THROW );
2695
2696 uno::Reference< table::XCellRange > xReferrer =
2697 xRanges->getCellRangeByPosition( getColumn()-1, getRow()-1,
2698 xAddressable->getRangeAddress().EndColumn,
2699 xAddressable->getRangeAddress().EndRow );
2700 // xAddressable now for this range
2701 xAddressable.set( xReferrer, uno::UNO_QUERY_THROW );
2702
2703 if( !Cell1.hasValue() )
2704 throw uno::RuntimeException(
2705 OUString( " Invalid Argument " ),
2706 uno::Reference< XInterface >() );
2707
2708 table::CellRangeAddress resultAddress;
2709 table::CellRangeAddress parentRangeAddress = xAddressable->getRangeAddress();
2710
2711 ScRange aRange;
2712 // Cell1 defined only
2713 if ( !Cell2.hasValue() )
2714 {
2715 OUString sName;
2716 Cell1 >>= sName;
2717 RangeHelper referRange( xReferrer );
2718 table::CellRangeAddress referAddress = referRange.getCellRangeAddressable()->getRangeAddress();
2719 return getRangeForName( mxContext, sName, getScDocShell(), referAddress );
2720
2721 }
2722 else
2723 {
2724 table::CellRangeAddress cell1, cell2;
2725 cell1 = getCellRangeAddressForVBARange( Cell1, getScDocShell() );
2726 // Cell1 & Cell2 defined
2727 // Excel seems to combine the range as the range defined by
2728 // the combination of Cell1 & Cell2
2729
2730 cell2 = getCellRangeAddressForVBARange( Cell2, getScDocShell() );
2731
2732 resultAddress.StartColumn = ( cell1.StartColumn < cell2.StartColumn ) ? cell1.StartColumn : cell2.StartColumn;
2733 resultAddress.StartRow = ( cell1.StartRow < cell2.StartRow ) ? cell1.StartRow : cell2.StartRow;
2734 resultAddress.EndColumn = ( cell1.EndColumn > cell2.EndColumn ) ? cell1.EndColumn : cell2.EndColumn;
2735 resultAddress.EndRow = ( cell1.EndRow > cell2.EndRow ) ? cell1.EndRow : cell2.EndRow;
2736 if ( bForceUseInpuRangeTab )
2737 {
2738 // this is a call from Application.Range( x,y )
2739 // its possiblefor x or y to specify a different sheet from
2740 // the current or active on ( but they must be the same )
2741 if ( cell1.Sheet != cell2.Sheet )
2742 throw uno::RuntimeException();
2743 parentRangeAddress.Sheet = cell1.Sheet;
2744 }
2745 else
2746 {
2747 // this is not a call from Application.Range( x,y )
2748 // if a different sheet from this range is specified it's
2749 // an error
2750 if ( parentRangeAddress.Sheet != cell1.Sheet
2751 || parentRangeAddress.Sheet != cell2.Sheet
2752 )
2753 throw uno::RuntimeException();
2754
2755 }
2756 ScUnoConversion::FillScRange( aRange, resultAddress );
2757 }
2758 ScRange parentAddress;
2759 ScUnoConversion::FillScRange( parentAddress, parentRangeAddress);
2760 if ( aRange.aStart.Col() >= 0 && aRange.aStart.Row() >= 0 && aRange.aEnd.Col() >= 0 && aRange.aEnd.Row() >= 0 )
2761 {
2762 sal_Int32 nStartX = parentAddress.aStart.Col() + aRange.aStart.Col();
2763 sal_Int32 nStartY = parentAddress.aStart.Row() + aRange.aStart.Row();
2764 sal_Int32 nEndX = parentAddress.aStart.Col() + aRange.aEnd.Col();
2765 sal_Int32 nEndY = parentAddress.aStart.Row() + aRange.aEnd.Row();
2766
2767 if ( nStartX <= nEndX && nEndX <= parentAddress.aEnd.Col() &&
2768 nStartY <= nEndY && nEndY <= parentAddress.aEnd.Row() )
2769 {
2770 ScRange aNew( (SCCOL)nStartX, (SCROW)nStartY, parentAddress.aStart.Tab(),
2771 (SCCOL)nEndX, (SCROW)nEndY, parentAddress.aEnd.Tab() );
2772 xCellRange = new ScCellRangeObj( getScDocShell(), aNew );
2773 }
2774 }
2775
2776 return new ScVbaRange( mxParent, mxContext, xCellRange );
2777
2778 }
2779
2780 // Allow access to underlying openoffice uno api ( useful for debugging
2781 // with openoffice basic )
2782 uno::Any SAL_CALL ScVbaRange::getCellRange( ) throw (uno::RuntimeException)
2783 {
2784 uno::Any aAny;
2785 if ( mxRanges.is() )
2786 aAny <<= mxRanges;
2787 else if ( mxRange.is() )
2788 aAny <<= mxRange;
2789 return aAny;
2790 }
2791
2792 uno::Any ScVbaRange::getCellRange( const uno::Reference< excel::XRange >& rxRange ) throw (uno::RuntimeException)
2793 {
2794 if( ScVbaRange* pVbaRange = getImplementation( rxRange ) )
2795 return pVbaRange->getCellRange();
2796 throw uno::RuntimeException();
2797 }
2798
2799 static sal_uInt16
2800 getPasteFlags (sal_Int32 Paste)
2801 {
2802 sal_uInt16 nFlags = IDF_NONE;
2803 switch (Paste) {
2804 case excel::XlPasteType::xlPasteComments:
2805 nFlags = IDF_NOTE;break;
2806 case excel::XlPasteType::xlPasteFormats:
2807 nFlags = IDF_ATTRIB;break;
2808 case excel::XlPasteType::xlPasteFormulas:
2809 nFlags = IDF_FORMULA;break;
2810 case excel::XlPasteType::xlPasteFormulasAndNumberFormats :
2811 case excel::XlPasteType::xlPasteValues:
2812 nFlags = ( IDF_VALUE | IDF_DATETIME | IDF_STRING | IDF_SPECIAL_BOOLEAN ); break;
2813 case excel::XlPasteType::xlPasteValuesAndNumberFormats:
2814 nFlags = IDF_VALUE | IDF_ATTRIB; break;
2815 case excel::XlPasteType::xlPasteColumnWidths:
2816 case excel::XlPasteType::xlPasteValidation:
2817 nFlags = IDF_NONE;break;
2818 case excel::XlPasteType::xlPasteAll:
2819 case excel::XlPasteType::xlPasteAllExceptBorders:
2820 default:
2821 nFlags = IDF_ALL;break;
2822 };
2823 return nFlags;
2824 }
2825
2826 static sal_uInt16
2827 getPasteFormulaBits( sal_Int32 Operation)
2828 {
2829 sal_uInt16 nFormulaBits = PASTE_NOFUNC ;
2830 switch (Operation)
2831 {
2832 case excel::XlPasteSpecialOperation::xlPasteSpecialOperationAdd:
2833 nFormulaBits = PASTE_ADD;break;
2834 case excel::XlPasteSpecialOperation::xlPasteSpecialOperationSubtract:
2835 nFormulaBits = PASTE_SUB;break;
2836 case excel::XlPasteSpecialOperation::xlPasteSpecialOperationMultiply:
2837 nFormulaBits = PASTE_MUL;break;
2838 case excel::XlPasteSpecialOperation::xlPasteSpecialOperationDivide:
2839 nFormulaBits = PASTE_DIV;break;
2840
2841 case excel::XlPasteSpecialOperation::xlPasteSpecialOperationNone:
2842 default:
2843 nFormulaBits = PASTE_NOFUNC; break;
2844 };
2845
2846 return nFormulaBits;
2847 }
2848 void SAL_CALL
2849 ScVbaRange::PasteSpecial( const uno::Any& Paste, const uno::Any& Operation, const uno::Any& SkipBlanks, const uno::Any& Transpose ) throw (::com::sun::star::uno::RuntimeException)
2850 {
2851 if ( m_Areas->getCount() > 1 )
2852 throw uno::RuntimeException( OUString( "That command cannot be used on multiple selections" ), uno::Reference< uno::XInterface >() );
2853 ScDocShell* pShell = getScDocShell();
2854
2855 uno::Reference< frame::XModel > xModel( ( pShell ? pShell->GetModel() : NULL ), uno::UNO_QUERY_THROW );
2856 uno::Reference< view::XSelectionSupplier > xSelection( xModel->getCurrentController(), uno::UNO_QUERY_THROW );
2857 // select this range
2858 xSelection->select( uno::makeAny( mxRange ) );
2859 // set up defaults
2860 sal_Int32 nPaste = excel::XlPasteType::xlPasteAll;
2861 sal_Int32 nOperation = excel::XlPasteSpecialOperation::xlPasteSpecialOperationNone;
2862 sal_Bool bTranspose = false;
2863 sal_Bool bSkipBlanks = false;
2864
2865 if ( Paste.hasValue() )
2866 Paste >>= nPaste;
2867 if ( Operation.hasValue() )
2868 Operation >>= nOperation;
2869 if ( SkipBlanks.hasValue() )
2870 SkipBlanks >>= bSkipBlanks;
2871 if ( Transpose.hasValue() )
2872 Transpose >>= bTranspose;
2873
2874 sal_uInt16 nFlags = getPasteFlags(nPaste);
2875 sal_uInt16 nFormulaBits = getPasteFormulaBits(nOperation);
2876 excel::implnPasteSpecial(pShell->GetModel(), nFlags,nFormulaBits,bSkipBlanks,bTranspose);
2877 }
2878
2879 uno::Reference< excel::XRange >
2880 ScVbaRange::getEntireColumnOrRow( bool bColumn ) throw (uno::RuntimeException)
2881 {
2882 ScCellRangesBase* pUnoRangesBase = getCellRangesBase();
2883 // copy the range list
2884 ScRangeList aCellRanges = pUnoRangesBase->GetRangeList();
2885
2886 for ( size_t i = 0, nRanges = aCellRanges.size(); i < nRanges; ++i )
2887 {
2888 ScRange* pRange = aCellRanges[ i ];
2889 if ( bColumn )
2890 {
2891 pRange->aStart.SetRow( 0 );
2892 pRange->aEnd.SetRow( MAXROW );
2893 }
2894 else
2895 {
2896 pRange->aStart.SetCol( 0 );
2897 pRange->aEnd.SetCol( MAXCOL );
2898 }
2899 }
2900 if ( aCellRanges.size() > 1 ) // Multi-Area
2901 {
2902 uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( pUnoRangesBase->GetDocShell(), aCellRanges ) );
2903
2904 return new ScVbaRange( mxParent, mxContext, xRanges, !bColumn, bColumn );
2905 }
2906 uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( pUnoRangesBase->GetDocShell(), *aCellRanges.front() ) );
2907 return new ScVbaRange( mxParent, mxContext, xRange, !bColumn, bColumn );
2908 }
2909
2910 uno::Reference< excel::XRange > SAL_CALL
2911 ScVbaRange::getEntireRow() throw (uno::RuntimeException)
2912 {
2913 return getEntireColumnOrRow(false);
2914 }
2915
2916 uno::Reference< excel::XRange > SAL_CALL
2917 ScVbaRange::getEntireColumn() throw (uno::RuntimeException)
2918 {
2919 return getEntireColumnOrRow();
2920 }
2921
2922 uno::Reference< excel::XComment > SAL_CALL
2923 ScVbaRange::AddComment( const uno::Any& Text ) throw (uno::RuntimeException)
2924 {
2925 // if there is already a comment in the top-left cell then throw
2926 if( getComment().is() )
2927 throw uno::RuntimeException();
2928
2929 // workaround: Excel allows to create empty comment, Calc does not
2930 OUString aNoteText;
2931 if( Text.hasValue() && !(Text >>= aNoteText) )
2932 throw uno::RuntimeException();
2933 if( aNoteText.isEmpty() )
2934 aNoteText = OUString( sal_Unicode( ' ' ) );
2935
2936 // try to create a new annotation
2937 table::CellRangeAddress aRangePos = lclGetRangeAddress( mxRange );
2938 table::CellAddress aNotePos( aRangePos.Sheet, aRangePos.StartColumn, aRangePos.StartRow );
2939 uno::Reference< sheet::XSheetCellRange > xCellRange( mxRange, uno::UNO_QUERY_THROW );
2940 uno::Reference< sheet::XSheetAnnotationsSupplier > xAnnosSupp( xCellRange->getSpreadsheet(), uno::UNO_QUERY_THROW );
2941 uno::Reference< sheet::XSheetAnnotations > xAnnos( xAnnosSupp->getAnnotations(), uno::UNO_SET_THROW );
2942 xAnnos->insertNew( aNotePos, aNoteText );
2943 return new ScVbaComment( this, mxContext, getUnoModel(), mxRange );
2944 }
2945
2946 uno::Reference< excel::XComment > SAL_CALL
2947 ScVbaRange::getComment() throw (uno::RuntimeException)
2948 {
2949 // intentional behavior to return a null object if no
2950 // comment defined
2951 uno::Reference< excel::XComment > xComment( new ScVbaComment( this, mxContext, getUnoModel(), mxRange ) );
2952 if ( xComment->Text( uno::Any(), uno::Any(), uno::Any() ).isEmpty() )
2953 return NULL;
2954 return xComment;
2955
2956 }
2957
2958 uno::Reference< beans::XPropertySet >
2959 getRowOrColumnProps( const uno::Reference< table::XCellRange >& xCellRange, bool bRows ) throw ( uno::RuntimeException )
2960 {
2961 uno::Reference< table::XColumnRowRange > xColRow( xCellRange, uno::UNO_QUERY_THROW );
2962 uno::Reference< beans::XPropertySet > xProps;
2963 if ( bRows )
2964 xProps.set( xColRow->getRows(), uno::UNO_QUERY_THROW );
2965 else
2966 xProps.set( xColRow->getColumns(), uno::UNO_QUERY_THROW );
2967 return xProps;
2968 }
2969
2970 uno::Any SAL_CALL
2971 ScVbaRange::getHidden() throw (uno::RuntimeException)
2972 {
2973 // if multi-area result is the result of the
2974 // first area
2975 if ( m_Areas->getCount() > 1 )
2976 {
2977 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(sal_Int32(1)), uno::Any() ), uno::UNO_QUERY_THROW );
2978 return xRange->getHidden();
2979 }
2980 bool bIsVisible = false;
2981 try
2982 {
2983 uno::Reference< beans::XPropertySet > xProps = getRowOrColumnProps( mxRange, mbIsRows );
2984 if ( !( xProps->getPropertyValue( ISVISIBLE ) >>= bIsVisible ) )
2985 throw uno::RuntimeException( OUString( "Failed to get IsVisible property"), uno::Reference< uno::XInterface >() );
2986 }
2987 catch( const uno::Exception& e )
2988 {
2989 throw uno::RuntimeException( e.Message, uno::Reference< uno::XInterface >() );
2990 }
2991 return uno::makeAny( !bIsVisible );
2992 }
2993
2994 void SAL_CALL
2995 ScVbaRange::setHidden( const uno::Any& _hidden ) throw (uno::RuntimeException)
2996 {
2997 if ( m_Areas->getCount() > 1 )
2998 {
2999 sal_Int32 nItems = m_Areas->getCount();
3000 for ( sal_Int32 index=1; index <= nItems; ++index )
3001 {
3002 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
3003 xRange->setHidden( _hidden );
3004 }
3005 return;
3006 }
3007
3008 bool bHidden = extractBoolFromAny( _hidden );
3009 try
3010 {
3011 uno::Reference< beans::XPropertySet > xProps = getRowOrColumnProps( mxRange, mbIsRows );
3012 xProps->setPropertyValue( ISVISIBLE, uno::Any( !bHidden ) );
3013 }
3014 catch( const uno::Exception& e )
3015 {
3016 throw uno::RuntimeException( e.Message, uno::Reference< uno::XInterface >() );
3017 }
3018 }
3019
3020 ::sal_Bool SAL_CALL
3021 ScVbaRange::Replace( const OUString& What, const OUString& Replacement, const uno::Any& LookAt, const uno::Any& SearchOrder, const uno::Any& MatchCase, const uno::Any& MatchByte, const uno::Any& SearchFormat, const uno::Any& ReplaceFormat ) throw (uno::RuntimeException)
3022 {
3023 if ( m_Areas->getCount() > 1 )
3024 {
3025 for ( sal_Int32 index = 1; index <= m_Areas->getCount(); ++index )
3026 {
3027 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( index ), uno::Any() ), uno::UNO_QUERY_THROW );
3028 xRange->Replace( What, Replacement, LookAt, SearchOrder, MatchCase, MatchByte, SearchFormat, ReplaceFormat );
3029 }
3030 return sal_True; // seems to return true always ( or at least I haven't found the trick of
3031 }
3032
3033 // sanity check required params
3034 if ( What.isEmpty() )
3035 throw uno::RuntimeException( OUString( "Range::Replace, missing params" ) , uno::Reference< uno::XInterface >() );
3036 OUString sWhat = VBAToRegexp( What);
3037 // #TODO #FIXME SearchFormat & ReplacesFormat are not processed
3038 // What do we do about MatchByte.. we don't seem to support that
3039 const SvxSearchItem& globalSearchOptions = ScGlobal::GetSearchItem();
3040 SvxSearchItem newOptions( globalSearchOptions );
3041
3042 sal_Int16 nLook = globalSearchOptions.GetWordOnly() ? excel::XlLookAt::xlPart : excel::XlLookAt::xlWhole;
3043 sal_Int16 nSearchOrder = globalSearchOptions.GetRowDirection() ? excel::XlSearchOrder::xlByRows : excel::XlSearchOrder::xlByColumns;
3044
3045 sal_Bool bMatchCase = false;
3046 uno::Reference< util::XReplaceable > xReplace( mxRange, uno::UNO_QUERY );
3047 if ( xReplace.is() )
3048 {
3049 uno::Reference< util::XReplaceDescriptor > xDescriptor =
3050 xReplace->createReplaceDescriptor();
3051
3052 xDescriptor->setSearchString( sWhat);
3053 xDescriptor->setPropertyValue( SC_UNO_SRCHREGEXP, uno::makeAny( sal_True ) );
3054 xDescriptor->setReplaceString( Replacement);
3055 if ( LookAt.hasValue() )
3056 {
3057 // sets SearchWords ( true is Cell match )
3058 nLook = ::comphelper::getINT16( LookAt );
3059 sal_Bool bSearchWords = false;
3060 if ( nLook == excel::XlLookAt::xlPart )
3061 bSearchWords = false;
3062 else if ( nLook == excel::XlLookAt::xlWhole )
3063 bSearchWords = sal_True;
3064 else
3065 throw uno::RuntimeException( OUString( "Range::Replace, illegal value for LookAt" ) , uno::Reference< uno::XInterface >() );
3066 // set global search props ( affects the find dialog
3067 // and of course the defaults for this method
3068 newOptions.SetWordOnly( bSearchWords );
3069 xDescriptor->setPropertyValue( SC_UNO_SRCHWORDS, uno::makeAny( bSearchWords ) );
3070 }
3071 // sets SearchByRow ( true for Rows )
3072 if ( SearchOrder.hasValue() )
3073 {
3074 nSearchOrder = ::comphelper::getINT16( SearchOrder );
3075 sal_Bool bSearchByRow = false;
3076 if ( nSearchOrder == excel::XlSearchOrder::xlByColumns )
3077 bSearchByRow = false;
3078 else if ( nSearchOrder == excel::XlSearchOrder::xlByRows )
3079 bSearchByRow = sal_True;
3080 else
3081 throw uno::RuntimeException( OUString( "Range::Replace, illegal value for SearchOrder" ) , uno::Reference< uno::XInterface >() );
3082
3083 newOptions.SetRowDirection( bSearchByRow );
3084 xDescriptor->setPropertyValue( SC_UNO_SRCHBYROW, uno::makeAny( bSearchByRow ) );
3085 }
3086 if ( MatchCase.hasValue() )
3087 {
3088 // SearchCaseSensitive
3089 MatchCase >>= bMatchCase;
3090 xDescriptor->setPropertyValue( SC_UNO_SRCHCASE, uno::makeAny( bMatchCase ) );
3091 }
3092
3093 ScGlobal::SetSearchItem( newOptions );
3094 // ignore MatchByte for the moment, its not supported in
3095 // OOo.org afaik
3096
3097 uno::Reference< util::XSearchDescriptor > xSearch( xDescriptor, uno::UNO_QUERY );
3098 xReplace->replaceAll( xSearch );
3099 }
3100 return sal_True; // always
3101 }
3102
3103 uno::Reference< excel::XRange > SAL_CALL
3104 ScVbaRange::Find( const uno::Any& What, const uno::Any& After, const uno::Any& LookIn, const uno::Any& LookAt, const uno::Any& SearchOrder, const uno::Any& SearchDirection, const uno::Any& MatchCase, const uno::Any& /*MatchByte*/, const uno::Any& /*SearchFormat*/ ) throw (uno::RuntimeException)
3105 {
3106 // return a Range object that represents the first cell where that information is found.
3107 OUString sWhat;
3108 sal_Int32 nWhat = 0;
3109 double fWhat = 0.0;
3110
3111 // string.
3112 if( What >>= sWhat )
3113 {
3114 if( sWhat.isEmpty() )
3115 throw uno::RuntimeException( OUString( "Range::Find, missing params" ) , uno::Reference< uno::XInterface >() );
3116 }
3117 else if( What >>= nWhat )
3118 {
3119 sWhat = OUString::valueOf( nWhat );
3120 }
3121 else if( What >>= fWhat )
3122 {
3123 sWhat = OUString::valueOf( fWhat );
3124 }
3125 else
3126 throw uno::RuntimeException( OUString( "Range::Find, missing params" ) , uno::Reference< uno::XInterface >() );
3127
3128 OUString sSearch = VBAToRegexp( sWhat );
3129
3130 const SvxSearchItem& globalSearchOptions = ScGlobal::GetSearchItem();
3131 SvxSearchItem newOptions( globalSearchOptions );
3132
3133 sal_Int16 nLookAt = globalSearchOptions.GetWordOnly() ? excel::XlLookAt::xlPart : excel::XlLookAt::xlWhole;
3134 sal_Int16 nSearchOrder = globalSearchOptions.GetRowDirection() ? excel::XlSearchOrder::xlByRows : excel::XlSearchOrder::xlByColumns;
3135
3136 uno::Reference< util::XSearchable > xSearch( mxRange, uno::UNO_QUERY );
3137 if( xSearch.is() )
3138 {
3139 uno::Reference< util::XSearchDescriptor > xDescriptor = xSearch->createSearchDescriptor();
3140 xDescriptor->setSearchString( sSearch );
3141 xDescriptor->setPropertyValue( SC_UNO_SRCHREGEXP, uno::Any( true ) );
3142
3143 uno::Reference< excel::XRange > xAfterRange;
3144 uno::Reference< table::XCellRange > xStartCell;
3145 if( After >>= xAfterRange )
3146 {
3147 // After must be a single cell in the range
3148 if( xAfterRange->getCount() > 1 )
3149 throw uno::RuntimeException( OUString( "After must be a single cell." ) , uno::Reference< uno::XInterface >() );
3150 uno::Reference< excel::XRange > xCell( Cells( uno::makeAny( xAfterRange->getRow() ), uno::makeAny( xAfterRange->getColumn() ) ), uno::UNO_QUERY );
3151 if( !xCell.is() )
3152 throw uno::RuntimeException( OUString( "After must be in range." ) , uno::Reference< uno::XInterface >() );
3153 xStartCell.set( xAfterRange->getCellRange(), uno::UNO_QUERY_THROW );
3154 }
3155
3156 // LookIn
3157 if( LookIn.hasValue() )
3158 {
3159 sal_Int32 nLookIn = 0;
3160 if( LookIn >>= nLookIn )
3161 {
3162 sal_Int16 nSearchType = 0;
3163 switch( nLookIn )
3164 {
3165 case excel::XlFindLookIn::xlComments :
3166 nSearchType = SVX_SEARCHIN_NOTE; // Notes
3167 break;
3168 case excel::XlFindLookIn::xlFormulas :
3169 nSearchType = SVX_SEARCHIN_FORMULA;
3170 break;
3171 case excel::XlFindLookIn::xlValues :
3172 nSearchType = SVX_SEARCHIN_VALUE;
3173 break;
3174 default:
3175 throw uno::RuntimeException( OUString( "Range::Replace, illegal value for LookIn." ) , uno::Reference< uno::XInterface >() );
3176 }
3177 newOptions.SetCellType( nSearchType );
3178 xDescriptor->setPropertyValue( "SearchType", uno::makeAny( nSearchType ) );
3179 }
3180 }
3181
3182 // LookAt
3183 if ( LookAt.hasValue() )
3184 {
3185 nLookAt = ::comphelper::getINT16( LookAt );
3186 sal_Bool bSearchWords = false;
3187 if ( nLookAt == excel::XlLookAt::xlPart )
3188 bSearchWords = false;
3189 else if ( nLookAt == excel::XlLookAt::xlWhole )
3190 bSearchWords = sal_True;
3191 else
3192 throw uno::RuntimeException( OUString( "Range::Replace, illegal value for LookAt" ) , uno::Reference< uno::XInterface >() );
3193 newOptions.SetWordOnly( bSearchWords );
3194 xDescriptor->setPropertyValue( SC_UNO_SRCHWORDS, uno::makeAny( bSearchWords ) );
3195 }
3196
3197 // SearchOrder
3198 if ( SearchOrder.hasValue() )
3199 {
3200 nSearchOrder = ::comphelper::getINT16( SearchOrder );
3201 sal_Bool bSearchByRow = false;
3202 if ( nSearchOrder == excel::XlSearchOrder::xlByColumns )
3203 bSearchByRow = false;
3204 else if ( nSearchOrder == excel::XlSearchOrder::xlByRows )
3205 bSearchByRow = sal_True;
3206 else
3207 throw uno::RuntimeException( OUString( "Range::Replace, illegal value for SearchOrder" ) , uno::Reference< uno::XInterface >() );
3208
3209 newOptions.SetRowDirection( bSearchByRow );
3210 xDescriptor->setPropertyValue( SC_UNO_SRCHBYROW, uno::makeAny( bSearchByRow ) );
3211 }
3212
3213 // SearchDirection
3214 if ( SearchDirection.hasValue() )
3215 {
3216 sal_Int32 nSearchDirection = 0;
3217 if( SearchDirection >>= nSearchDirection )
3218 {
3219 sal_Bool bSearchBackwards = false;
3220 if ( nSearchDirection == excel::XlSearchDirection::xlNext )
3221 bSearchBackwards = false;
3222 else if( nSearchDirection == excel::XlSearchDirection::xlPrevious )
3223 bSearchBackwards = sal_True;
3224 else
3225 throw uno::RuntimeException( OUString( "Range::Replace, illegal value for SearchDirection" ) , uno::Reference< uno::XInterface >() );
3226 newOptions.SetBackward( bSearchBackwards );
3227 xDescriptor->setPropertyValue( "SearchBackwards", uno::makeAny( bSearchBackwards ) );
3228 }
3229 }
3230
3231 // MatchCase
3232 sal_Bool bMatchCase = false;
3233 if ( MatchCase.hasValue() )
3234 {
3235 // SearchCaseSensitive
3236 if( !( MatchCase >>= bMatchCase ) )
3237 throw uno::RuntimeException( OUString( "Range::Replace, illegal value for MatchCase" ) , uno::Reference< uno::XInterface >() );
3238 }
3239 xDescriptor->setPropertyValue( SC_UNO_SRCHCASE, uno::makeAny( bMatchCase ) );
3240
3241 // MatchByte
3242 // SearchFormat
3243 // ignore
3244
3245 ScGlobal::SetSearchItem( newOptions );
3246
3247 uno::Reference< uno::XInterface > xInterface = xStartCell.is() ? xSearch->findNext( xStartCell, xDescriptor) : xSearch->findFirst( xDescriptor );
3248 uno::Reference< table::XCellRange > xCellRange( xInterface, uno::UNO_QUERY );
3249 // if we are searching from a starting cell and failed to find a match
3250 // then try from the beginning
3251 if ( !xCellRange.is() && xStartCell.is() )
3252 {
3253 xInterface = xSearch->findFirst( xDescriptor );
3254 xCellRange.set( xInterface, uno::UNO_QUERY );
3255 }
3256 if ( xCellRange.is() )
3257 {
3258 uno::Reference< excel::XRange > xResultRange = new ScVbaRange( mxParent, mxContext, xCellRange );
3259 if( xResultRange.is() )
3260 {
3261 xResultRange->Select();
3262 return xResultRange;
3263 }
3264 }
3265
3266 }
3267
3268 return uno::Reference< excel::XRange >();
3269 }
3270
3271 uno::Reference< table::XCellRange > processKey( const uno::Any& Key, uno::Reference< uno::XComponentContext >& xContext, ScDocShell* pDocSh )
3272 {
3273 uno::Reference< excel::XRange > xKeyRange;
3274 if ( Key.getValueType() == excel::XRange::static_type() )
3275 {
3276 xKeyRange.set( Key, uno::UNO_QUERY_THROW );
3277 }
3278 else if ( Key.getValueType() == ::getCppuType( static_cast< const OUString* >(0) ) )
3279
3280 {
3281 OUString sRangeName = ::comphelper::getString( Key );
3282 table::CellRangeAddress aRefAddr;
3283 if ( !pDocSh )
3284 throw uno::RuntimeException( OUString("Range::Sort no docshell to calculate key param"), uno::Reference< uno::XInterface >() );
3285 xKeyRange = getRangeForName( xContext, sRangeName, pDocSh, aRefAddr );
3286 }
3287 else
3288 throw uno::RuntimeException( OUString("Range::Sort illegal type value for key param"), uno::Reference< uno::XInterface >() );
3289 uno::Reference< table::XCellRange > xKey;
3290 xKey.set( xKeyRange->getCellRange(), uno::UNO_QUERY_THROW );
3291 return xKey;
3292 }
3293
3294 // helper method for Sort
3295 sal_Int32 findSortPropertyIndex( const uno::Sequence< beans::PropertyValue >& props,
3296 const OUString& sPropName ) throw( uno::RuntimeException )
3297 {
3298 const beans::PropertyValue* pProp = props.getConstArray();
3299 sal_Int32 nItems = props.getLength();
3300
3301 sal_Int32 count=0;
3302 for ( ; count < nItems; ++count, ++pProp )
3303 if ( pProp->Name.equals( sPropName ) )
3304 return count;
3305 if ( count == nItems )
3306 throw uno::RuntimeException( OUString("Range::Sort unknown sort property"), uno::Reference< uno::XInterface >() );
3307 return -1; //should never reach here ( satisfy compiler )
3308 }
3309
3310 // helper method for Sort
3311 void updateTableSortField( const uno::Reference< table::XCellRange >& xParentRange,
3312 const uno::Reference< table::XCellRange >& xColRowKey, sal_Int16 nOrder,
3313 table::TableSortField& aTableField, sal_Bool bIsSortColumn, sal_Bool bMatchCase ) throw ( uno::RuntimeException )
3314 {
3315 RangeHelper parentRange( xParentRange );
3316 RangeHelper colRowRange( xColRowKey );
3317
3318 table::CellRangeAddress parentRangeAddress = parentRange.getCellRangeAddressable()->getRangeAddress();
3319
3320 table::CellRangeAddress colRowKeyAddress = colRowRange.getCellRangeAddressable()->getRangeAddress();
3321
3322 // make sure that upper left poing of key range is within the
3323 // parent range
3324 if ( ( !bIsSortColumn && colRowKeyAddress.StartColumn >= parentRangeAddress.StartColumn &&
3325 colRowKeyAddress.StartColumn <= parentRangeAddress.EndColumn ) || ( bIsSortColumn &&
3326 colRowKeyAddress.StartRow >= parentRangeAddress.StartRow &&
3327 colRowKeyAddress.StartRow <= parentRangeAddress.EndRow ) )
3328 {
3329 //determine col/row index
3330 if ( bIsSortColumn )
3331 aTableField.Field = colRowKeyAddress.StartRow - parentRangeAddress.StartRow;
3332 else
3333 aTableField.Field = colRowKeyAddress.StartColumn - parentRangeAddress.StartColumn;
3334 aTableField.IsCaseSensitive = bMatchCase;
3335
3336 if ( nOrder == excel::XlSortOrder::xlAscending )
3337 aTableField.IsAscending = sal_True;
3338 else
3339 aTableField.IsAscending = false;
3340 }
3341 else
3342 throw uno::RuntimeException( OUString( "Illegal Key param" ), uno::Reference< uno::XInterface >() );
3343
3344
3345 }
3346
3347 void SAL_CALL
3348 ScVbaRange::Sort( const uno::Any& Key1, const uno::Any& Order1, const uno::Any& Key2, const uno::Any& /*Type*/, const uno::Any& Order2, const uno::Any& Key3, const uno::Any& Order3, const uno::Any& Header, const uno::Any& OrderCustom, const uno::Any& MatchCase, const uno::Any& Orientation, const uno::Any& SortMethod, const uno::Any& DataOption1, const uno::Any& DataOption2, const uno::Any& DataOption3 ) throw (uno::RuntimeException)
3349 {
3350 // #TODO# #FIXME# can we do something with Type
3351 if ( m_Areas->getCount() > 1 )
3352 throw uno::RuntimeException( OUString( "That command cannot be used on multiple selections" ), uno::Reference< uno::XInterface >() );
3353
3354 sal_Int16 nDataOption1 = excel::XlSortDataOption::xlSortNormal;
3355 sal_Int16 nDataOption2 = excel::XlSortDataOption::xlSortNormal;
3356 sal_Int16 nDataOption3 = excel::XlSortDataOption::xlSortNormal;
3357
3358 ScDocument* pDoc = getScDocument();
3359 if ( !pDoc )
3360 throw uno::RuntimeException( OUString( "Failed to access document from shell" ), uno::Reference< uno::XInterface >() );
3361
3362 RangeHelper thisRange( mxRange );
3363 table::CellRangeAddress thisRangeAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
3364 ScSortParam aSortParam;
3365 SCTAB nTab = thisRangeAddress.Sheet;
3366 pDoc->GetSortParam( aSortParam, nTab );
3367
3368 if ( DataOption1.hasValue() )
3369 DataOption1 >>= nDataOption1;
3370 if ( DataOption2.hasValue() )
3371 DataOption2 >>= nDataOption2;
3372 if ( DataOption3.hasValue() )
3373 DataOption3 >>= nDataOption3;
3374
3375 // 1) #TODO #FIXME need to process DataOption[1..3] not used currently
3376 // 2) #TODO #FIXME need to refactor this ( below ) into a IsSingleCell() method
3377 uno::Reference< table::XColumnRowRange > xColumnRowRange(mxRange, uno::UNO_QUERY_THROW );
3378
3379 // set up defaults
3380
3381 sal_Int16 nOrder1 = aSortParam.maKeyState[1].bAscending ? excel::XlSortOrder::xlAscending : excel::XlSortOrder::xlDescending;
3382 sal_Int16 nOrder2 = aSortParam.maKeyState[2].bAscending ? excel::XlSortOrder::xlAscending : excel::XlSortOrder::xlDescending;
3383 sal_Int16 nOrder3 = aSortParam.maKeyState[3].bAscending ? excel::XlSortOrder::xlAscending : excel::XlSortOrder::xlDescending;
3384
3385 sal_Int16 nCustom = aSortParam.nUserIndex;
3386 sal_Int16 nSortMethod = excel::XlSortMethod::xlPinYin;
3387 sal_Bool bMatchCase = aSortParam.bCaseSens;
3388
3389 // seems to work opposite to expected, see below
3390 sal_Int16 nOrientation = aSortParam.bByRow ? excel::XlSortOrientation::xlSortColumns : excel::XlSortOrientation::xlSortRows;
3391
3392 if ( Orientation.hasValue() )
3393 {
3394 // Documentation says xlSortRows is default but that doesn't appear to be
3395 // the case. Also it appears that xlSortColumns is the default which
3396 // strangely enough sorts by Row
3397 nOrientation = ::comphelper::getINT16( Orientation );
3398 // persist new option to be next calls default
3399 if ( nOrientation == excel::XlSortOrientation::xlSortRows )
3400 aSortParam.bByRow = false;
3401 else
3402 aSortParam.bByRow = sal_True;
3403
3404 }
3405
3406 sal_Bool bIsSortColumns=false; // sort by row
3407
3408 if ( nOrientation == excel::XlSortOrientation::xlSortRows )
3409 bIsSortColumns = sal_True;
3410 sal_Int16 nHeader = 0;
3411 nHeader = aSortParam.nCompatHeader;
3412 sal_Bool bContainsHeader = false;
3413
3414 if ( Header.hasValue() )
3415 {
3416 nHeader = ::comphelper::getINT16( Header );
3417 aSortParam.nCompatHeader = nHeader;
3418 }
3419
3420 if ( nHeader == excel::XlYesNoGuess::xlGuess )
3421 {
3422 bool bHasColHeader = pDoc->HasColHeader( static_cast< SCCOL >( thisRangeAddress.StartColumn ), static_cast< SCROW >( thisRangeAddress.StartRow ), static_cast< SCCOL >( thisRangeAddress.EndColumn ), static_cast< SCROW >( thisRangeAddress.EndRow ), static_cast< SCTAB >( thisRangeAddress.Sheet ));
3423 bool bHasRowHeader = pDoc->HasRowHeader( static_cast< SCCOL >( thisRangeAddress.StartColumn ), static_cast< SCROW >( thisRangeAddress.StartRow ), static_cast< SCCOL >( thisRangeAddress.EndColumn ), static_cast< SCROW >( thisRangeAddress.EndRow ), static_cast< SCTAB >( thisRangeAddress.Sheet ) );
3424 if ( bHasColHeader || bHasRowHeader )
3425 nHeader = excel::XlYesNoGuess::xlYes;
3426 else
3427 nHeader = excel::XlYesNoGuess::xlNo;
3428 aSortParam.nCompatHeader = nHeader;
3429 }
3430
3431 if ( nHeader == excel::XlYesNoGuess::xlYes )
3432 bContainsHeader = sal_True;
3433
3434 if ( SortMethod.hasValue() )
3435 {
3436 nSortMethod = ::comphelper::getINT16( SortMethod );
3437 }
3438
3439 if ( OrderCustom.hasValue() )
3440 {
3441 OrderCustom >>= nCustom;
3442 --nCustom; // 0-based in OOo
3443 aSortParam.nUserIndex = nCustom;
3444 }
3445
3446 if ( MatchCase.hasValue() )
3447 {
3448 MatchCase >>= bMatchCase;
3449 aSortParam.bCaseSens = bMatchCase;
3450 }
3451
3452 if ( Order1.hasValue() )
3453 {
3454 nOrder1 = ::comphelper::getINT16(Order1);
3455 if ( nOrder1 == excel::XlSortOrder::xlAscending )
3456 aSortParam.maKeyState[0].bAscending = true;
3457 else
3458 aSortParam.maKeyState[0].bAscending = false;
3459
3460 }
3461 if ( Order2.hasValue() )
3462 {
3463 nOrder2 = ::comphelper::getINT16(Order2);
3464 if ( nOrder2 == excel::XlSortOrder::xlAscending )
3465 aSortParam.maKeyState[1].bAscending = true;
3466 else
3467 aSortParam.maKeyState[1].bAscending = false;
3468 }
3469 if ( Order3.hasValue() )
3470 {
3471 nOrder3 = ::comphelper::getINT16(Order3);
3472 if ( nOrder3 == excel::XlSortOrder::xlAscending )
3473 aSortParam.maKeyState[2].bAscending = true;
3474 else
3475 aSortParam.maKeyState[2].bAscending = false;
3476 }
3477
3478 uno::Reference< table::XCellRange > xKey1;
3479 uno::Reference< table::XCellRange > xKey2;
3480 uno::Reference< table::XCellRange > xKey3;
3481 ScDocShell* pDocShell = getScDocShell();
3482 xKey1 = processKey( Key1, mxContext, pDocShell );
3483 if ( !xKey1.is() )
3484 throw uno::RuntimeException( OUString("Range::Sort needs a key1 param"), uno::Reference< uno::XInterface >() );
3485
3486 if ( Key2.hasValue() )
3487 xKey2 = processKey( Key2, mxContext, pDocShell );
3488 if ( Key3.hasValue() )
3489 xKey3 = processKey( Key3, mxContext, pDocShell );
3490
3491 uno::Reference< util::XSortable > xSort( mxRange, uno::UNO_QUERY_THROW );
3492 uno::Sequence< beans::PropertyValue > sortDescriptor = xSort->createSortDescriptor();
3493 sal_Int32 nTableSortFieldIndex = findSortPropertyIndex( sortDescriptor, OUString( "SortFields" ) );
3494
3495 uno::Sequence< table::TableSortField > sTableFields(1);
3496 sal_Int32 nTableIndex = 0;
3497 updateTableSortField( mxRange, xKey1, nOrder1, sTableFields[ nTableIndex++ ], bIsSortColumns, bMatchCase );
3498
3499 if ( xKey2.is() )
3500 {
3501 sTableFields.realloc( sTableFields.getLength() + 1 );
3502 updateTableSortField( mxRange, xKey2, nOrder2, sTableFields[ nTableIndex++ ], bIsSortColumns, bMatchCase );
3503 }
3504 if ( xKey3.is() )
3505 {
3506 sTableFields.realloc( sTableFields.getLength() + 1 );
3507 updateTableSortField( mxRange, xKey3, nOrder3, sTableFields[ nTableIndex++ ], bIsSortColumns, bMatchCase );
3508 }
3509 sortDescriptor[ nTableSortFieldIndex ].Value <<= sTableFields;
3510
3511 sal_Int32 nIndex = findSortPropertyIndex( sortDescriptor, OUString("IsSortColumns") );
3512 sortDescriptor[ nIndex ].Value <<= bIsSortColumns;
3513
3514 nIndex = findSortPropertyIndex( sortDescriptor, CONTS_HEADER );
3515 sortDescriptor[ nIndex ].Value <<= bContainsHeader;
3516
3517 pDoc->SetSortParam( aSortParam, nTab );
3518 xSort->sort( sortDescriptor );
3519
3520 // #FIXME #TODO
3521 // The SortMethod param is not processed ( not sure what its all about, need to
3522 (void)nSortMethod;
3523 }
3524
3525 uno::Reference< excel::XRange > SAL_CALL
3526 ScVbaRange::End( ::sal_Int32 Direction ) throw (uno::RuntimeException)
3527 {
3528 if ( m_Areas->getCount() > 1 )
3529 {
3530 uno::Reference< excel::XRange > xRange( getArea( 0 ), uno::UNO_QUERY_THROW );
3531 return xRange->End( Direction );
3532 }
3533
3534 // #FIXME #TODO
3535 // euch! found my orig implementation sucked, so
3536 // trying this even suckier one ( really need to use/expose code in
3537 // around ScTabView::MoveCursorArea(), thats the bit that calcutes
3538 // where the cursor should go )
3539 // Main problem with this method is the ultra hacky attempt to preserve
3540 // the ActiveCell, there should be no need to go to these extreems
3541
3542 // Save ActiveCell pos ( to restore later )
3543 uno::Any aDft;
3544 uno::Reference< excel::XApplication > xApplication( Application(), uno::UNO_QUERY_THROW );
3545 OUString sActiveCell = xApplication->getActiveCell()->Address(aDft, aDft, aDft, aDft, aDft );
3546
3547 // position current cell upper left of this range
3548 Cells( uno::makeAny( (sal_Int32) 1 ), uno::makeAny( (sal_Int32) 1 ) )->Select();
3549
3550 uno::Reference< frame::XModel > xModel = getModelFromRange( mxRange );
3551
3552 SfxViewFrame* pViewFrame = excel::getViewFrame( xModel );
3553 if ( pViewFrame )
3554 {
3555 SfxAllItemSet aArgs( SFX_APP()->GetPool() );
3556 // Hoping this will make sure this slot is called
3557 // synchronously
3558 SfxBoolItem sfxAsync( SID_ASYNCHRON, sal_False );
3559 aArgs.Put( sfxAsync, sfxAsync.Which() );
3560 SfxDispatcher* pDispatcher = pViewFrame->GetDispatcher();
3561
3562 sal_uInt16 nSID = 0;
3563
3564 switch( Direction )
3565 {
3566 case excel::XlDirection::xlDown:
3567 nSID = SID_CURSORBLKDOWN;
3568 break;
3569 case excel::XlDirection::xlUp:
3570 nSID = SID_CURSORBLKUP;
3571 break;
3572 case excel::XlDirection::xlToLeft:
3573 nSID = SID_CURSORBLKLEFT;
3574 break;
3575 case excel::XlDirection::xlToRight:
3576 nSID = SID_CURSORBLKRIGHT;
3577 break;
3578 default:
3579 throw uno::RuntimeException( OUString( ": Invalid ColumnIndex" ), uno::Reference< uno::XInterface >() );
3580 }
3581 if ( pDispatcher )
3582 {
3583 pDispatcher->Execute( nSID, (SfxCallMode)SFX_CALLMODE_SYNCHRON, aArgs );
3584 }
3585 }
3586
3587 // result is the ActiveCell
3588 OUString sMoved = xApplication->getActiveCell()->Address(aDft, aDft, aDft, aDft, aDft );
3589
3590 // restore old ActiveCell
3591 uno::Any aVoid;
3592
3593 uno::Reference< excel::XRange > xOldActiveCell( xApplication->getActiveSheet()->Range( uno::makeAny( sActiveCell ), aVoid ), uno::UNO_QUERY_THROW );
3594 xOldActiveCell->Select();
3595
3596 uno::Reference< excel::XRange > resultCell;
3597 resultCell.set( xApplication->getActiveSheet()->Range( uno::makeAny( sMoved ), aVoid ), uno::UNO_QUERY_THROW );
3598
3599 // return result
3600 return resultCell;
3601 }
3602
3603 bool
3604 ScVbaRange::isSingleCellRange()
3605 {
3606 uno::Reference< sheet::XCellRangeAddressable > xAddressable( mxRange, uno::UNO_QUERY );
3607 if ( xAddressable.is() )
3608 {
3609 table::CellRangeAddress aRangeAddr = xAddressable->getRangeAddress();
3610 return ( aRangeAddr.EndColumn == aRangeAddr.StartColumn && aRangeAddr.EndRow == aRangeAddr.StartRow );
3611 }
3612 return false;
3613 }
3614
3615 uno::Reference< excel::XCharacters > SAL_CALL
3616 ScVbaRange::characters( const uno::Any& Start, const uno::Any& Length ) throw (uno::RuntimeException)
3617 {
3618 if ( !isSingleCellRange() )
3619 throw uno::RuntimeException( OUString( "Can't create Characters property for multicell range " ), uno::Reference< uno::XInterface >() );
3620 uno::Reference< text::XSimpleText > xSimple(mxRange->getCellByPosition(0,0) , uno::UNO_QUERY_THROW );
3621 ScDocument* pDoc = getDocumentFromRange(mxRange);
3622 if ( !pDoc )
3623 throw uno::RuntimeException( OUString( "Failed to access document from shell" ), uno::Reference< uno::XInterface >() );
3624
3625 ScVbaPalette aPalette( pDoc->GetDocumentShell() );
3626 return new ScVbaCharacters( this, mxContext, aPalette, xSimple, Start, Length );
3627 }
3628
3629 void SAL_CALL
3630 ScVbaRange::Delete( const uno::Any& Shift ) throw (uno::RuntimeException)
3631 {
3632 if ( m_Areas->getCount() > 1 )
3633 {
3634 sal_Int32 nItems = m_Areas->getCount();
3635 for ( sal_Int32 index=1; index <= nItems; ++index )
3636 {
3637 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
3638 xRange->Delete( Shift );
3639 }
3640 return;
3641 }
3642 sheet::CellDeleteMode mode = sheet::CellDeleteMode_NONE ;
3643 RangeHelper thisRange( mxRange );
3644 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
3645 if ( Shift.hasValue() )
3646 {
3647 sal_Int32 nShift = 0;
3648 Shift >>= nShift;
3649 switch ( nShift )
3650 {
3651 case excel::XlDeleteShiftDirection::xlShiftUp:
3652 mode = sheet::CellDeleteMode_UP;
3653 break;
3654 case excel::XlDeleteShiftDirection::xlShiftToLeft:
3655 mode = sheet::CellDeleteMode_LEFT;
3656 break;
3657 default:
3658 throw uno::RuntimeException( OUString( "Illegal parameter " ), uno::Reference< uno::XInterface >() );
3659 }
3660 }
3661 else
3662 {
3663 bool bFullRow = ( thisAddress.StartColumn == 0 && thisAddress.EndColumn == MAXCOL );
3664 sal_Int32 nCols = thisAddress.EndColumn - thisAddress.StartColumn;
3665 sal_Int32 nRows = thisAddress.EndRow - thisAddress.StartRow;
3666 if ( mbIsRows || bFullRow || ( nCols >= nRows ) )
3667 mode = sheet::CellDeleteMode_UP;
3668 else
3669 mode = sheet::CellDeleteMode_LEFT;
3670 }
3671 uno::Reference< sheet::XCellRangeMovement > xCellRangeMove( thisRange.getSpreadSheet(), uno::UNO_QUERY_THROW );
3672 xCellRangeMove->removeRange( thisAddress, mode );
3673
3674 }
3675
3676 //XElementAccess
3677 sal_Bool SAL_CALL
3678 ScVbaRange::hasElements() throw (uno::RuntimeException)
3679 {
3680 uno::Reference< table::XColumnRowRange > xColumnRowRange(mxRange, uno::UNO_QUERY );
3681 if ( xColumnRowRange.is() )
3682 if ( xColumnRowRange->getRows()->getCount() ||
3683 xColumnRowRange->getColumns()->getCount() )
3684 return sal_True;
3685 return false;
3686 }
3687
3688 // XEnumerationAccess
3689 uno::Reference< container::XEnumeration > SAL_CALL
3690 ScVbaRange::createEnumeration() throw (uno::RuntimeException)
3691 {
3692 if ( mbIsColumns || mbIsRows )
3693 {
3694 uno::Reference< table::XColumnRowRange > xColumnRowRange(mxRange, uno::UNO_QUERY );
3695 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32(1) ), uno::Any() ), uno::UNO_QUERY_THROW );
3696 sal_Int32 nElems = 0;
3697 if ( mbIsColumns )
3698 nElems = xColumnRowRange->getColumns()->getCount();
3699 else
3700 nElems = xColumnRowRange->getRows()->getCount();
3701 return new ColumnsRowEnumeration( mxContext, xRange, nElems );
3702
3703 }
3704 return new CellsEnumeration( mxParent, mxContext, m_Areas );
3705 }
3706
3707 OUString SAL_CALL
3708 ScVbaRange::getDefaultMethodName( ) throw (uno::RuntimeException)
3709 {
3710 const static OUString sName( "Item" );
3711 return sName;
3712 }
3713
3714 // returns calc internal col. width ( in points )
3715 double
3716 ScVbaRange::getCalcColWidth( const table::CellRangeAddress& rAddress) throw (uno::RuntimeException)
3717 {
3718 ScDocument* pDoc = getScDocument();
3719 sal_uInt16 nWidth = pDoc->GetOriginalWidth( static_cast< SCCOL >( rAddress.StartColumn ), static_cast< SCTAB >( rAddress.Sheet ) );
3720 double nPoints = lcl_TwipsToPoints( nWidth );
3721 nPoints = lcl_Round2DecPlaces( nPoints );
3722 return nPoints;
3723 }
3724
3725 double
3726 ScVbaRange::getCalcRowHeight( const table::CellRangeAddress& rAddress ) throw (uno::RuntimeException)
3727 {
3728 ScDocument* pDoc = getDocumentFromRange( mxRange );
3729 sal_uInt16 nWidth = pDoc->GetOriginalHeight( rAddress.StartRow, rAddress.Sheet );
3730 double nPoints = lcl_TwipsToPoints( nWidth );
3731 nPoints = lcl_Round2DecPlaces( nPoints );
3732 return nPoints;
3733 }
3734
3735 // return Char Width in points
3736 double getDefaultCharWidth( ScDocShell* pDocShell )
3737 {
3738 ScDocument* pDoc = pDocShell->GetDocument();
3739 OutputDevice* pRefDevice = pDoc->GetRefDevice();
3740 ScPatternAttr* pAttr = pDoc->GetDefPattern();
3741 ::Font aDefFont;
3742 pAttr->GetFont( aDefFont, SC_AUTOCOL_BLACK, pRefDevice );
3743 pRefDevice->SetFont( aDefFont );
3744 long nCharWidth = pRefDevice->GetTextWidth( String( '0' ) ); // 1/100th mm
3745 return lcl_hmmToPoints( nCharWidth );
3746 }
3747
3748 uno::Any SAL_CALL
3749 ScVbaRange::getColumnWidth() throw (uno::RuntimeException)
3750 {
3751 sal_Int32 nLen = m_Areas->getCount();
3752 if ( nLen > 1 )
3753 {
3754 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32(1) ), uno::Any() ), uno::UNO_QUERY_THROW );
3755 return xRange->getColumnWidth();
3756 }
3757
3758 double nColWidth = 0;
3759 ScDocShell* pShell = getScDocShell();
3760 if ( pShell )
3761 {
3762 double defaultCharWidth = getDefaultCharWidth( pShell );
3763 RangeHelper thisRange( mxRange );
3764 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
3765 sal_Int32 nStartCol = thisAddress.StartColumn;
3766 sal_Int32 nEndCol = thisAddress.EndColumn;
3767 sal_uInt16 nColTwips = 0;
3768 for( sal_Int32 nCol = nStartCol ; nCol <= nEndCol; ++nCol )
3769 {
3770 thisAddress.StartColumn = nCol;
3771 sal_uInt16 nCurTwips = pShell->GetDocument()->GetOriginalWidth( static_cast< SCCOL >( thisAddress.StartColumn ), static_cast< SCTAB >( thisAddress.Sheet ) );
3772 if ( nCol == nStartCol )
3773 nColTwips = nCurTwips;
3774 if ( nColTwips != nCurTwips )
3775 return aNULL();
3776 }
3777 nColWidth = lcl_TwipsToPoints( nColTwips );
3778 if ( nColWidth != 0.0 )
3779 nColWidth = ( nColWidth / defaultCharWidth ) - fExtraWidth;
3780 }
3781 nColWidth = lcl_Round2DecPlaces( nColWidth );
3782 return uno::makeAny( nColWidth );
3783 }
3784
3785 void SAL_CALL
3786 ScVbaRange::setColumnWidth( const uno::Any& _columnwidth ) throw (uno::RuntimeException)
3787 {
3788 sal_Int32 nLen = m_Areas->getCount();
3789 if ( nLen > 1 )
3790 {
3791 for ( sal_Int32 index = 1; index != nLen; ++index )
3792 {
3793 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32(index) ), uno::Any() ), uno::UNO_QUERY_THROW );
3794 xRange->setColumnWidth( _columnwidth );
3795 }
3796 return;
3797 }
3798 double nColWidth = 0;
3799 _columnwidth >>= nColWidth;
3800 nColWidth = lcl_Round2DecPlaces( nColWidth );
3801 ScDocShell* pDocShell = getScDocShell();
3802 if ( pDocShell )
3803 {
3804 if ( nColWidth != 0.0 )
3805 nColWidth = ( nColWidth + fExtraWidth ) * getDefaultCharWidth( pDocShell );
3806 RangeHelper thisRange( mxRange );
3807 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
3808 sal_uInt16 nTwips = lcl_pointsToTwips( nColWidth );
3809
3810 SCCOLROW nColArr[2];
3811 nColArr[0] = thisAddress.StartColumn;
3812 nColArr[1] = thisAddress.EndColumn;
3813 // #163561# use mode SC_SIZE_DIRECT: hide for width 0, show for other values
3814 pDocShell->GetDocFunc().SetWidthOrHeight( true, 1, nColArr, thisAddress.Sheet,
3815 SC_SIZE_DIRECT, nTwips, true, true );
3816
3817 }
3818 }
3819
3820 uno::Any SAL_CALL
3821 ScVbaRange::getWidth() throw (uno::RuntimeException)
3822 {
3823 if ( m_Areas->getCount() > 1 )
3824 {
3825 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32(1) ), uno::Any() ), uno::UNO_QUERY_THROW );
3826 return xRange->getWidth();
3827 }
3828 uno::Reference< table::XColumnRowRange > xColRowRange( mxRange, uno::UNO_QUERY_THROW );
3829 uno::Reference< container::XIndexAccess > xIndexAccess( xColRowRange->getColumns(), uno::UNO_QUERY_THROW );
3830 sal_Int32 nElems = xIndexAccess->getCount();
3831 double nWidth = 0;
3832 for ( sal_Int32 index=0; index<nElems; ++index )
3833 {
3834 uno::Reference< sheet::XCellRangeAddressable > xAddressable( xIndexAccess->getByIndex( index ), uno::UNO_QUERY_THROW );
3835 double nTmpWidth = getCalcColWidth( xAddressable->getRangeAddress() );
3836 nWidth += nTmpWidth;
3837 }
3838 return uno::makeAny( nWidth );
3839 }
3840
3841 uno::Any SAL_CALL
3842 ScVbaRange::Areas( const uno::Any& item) throw (uno::RuntimeException)
3843 {
3844 if ( !item.hasValue() )
3845 return uno::makeAny( m_Areas );
3846 return m_Areas->Item( item, uno::Any() );
3847 }
3848
3849 uno::Reference< excel::XRange >
3850 ScVbaRange::getArea( sal_Int32 nIndex ) throw( css::uno::RuntimeException )
3851 {
3852 if ( !m_Areas.is() )
3853 throw uno::RuntimeException( OUString("No areas available"), uno::Reference< uno::XInterface >() );
3854 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( ++nIndex ), uno::Any() ), uno::UNO_QUERY_THROW );
3855 return xRange;
3856 }
3857
3858 uno::Any
3859 ScVbaRange::Borders( const uno::Any& item ) throw( script::BasicErrorException, uno::RuntimeException )
3860 {
3861 if ( !item.hasValue() )
3862 return uno::makeAny( getBorders() );
3863 return getBorders()->Item( item, uno::Any() );
3864 }
3865
3866 uno::Any SAL_CALL
3867 ScVbaRange::BorderAround( const css::uno::Any& LineStyle, const css::uno::Any& Weight,
3868 const css::uno::Any& ColorIndex, const css::uno::Any& Color ) throw (css::uno::RuntimeException)
3869 {
3870 sal_Int32 nCount = getBorders()->getCount();
3871
3872 for( sal_Int32 i = 0; i < nCount; i++ )
3873 {
3874 const sal_Int32 nLineType = supportedIndexTable[i];
3875 switch( nLineType )
3876 {
3877 case excel::XlBordersIndex::xlEdgeLeft:
3878 case excel::XlBordersIndex::xlEdgeTop:
3879 case excel::XlBordersIndex::xlEdgeBottom:
3880 case excel::XlBordersIndex::xlEdgeRight:
3881 {
3882 uno::Reference< excel::XBorder > xBorder( m_Borders->Item( uno::makeAny( nLineType ), uno::Any() ), uno::UNO_QUERY_THROW );
3883 if( LineStyle.hasValue() )
3884 {
3885 xBorder->setLineStyle( LineStyle );
3886 }
3887 if( Weight.hasValue() )
3888 {
3889 xBorder->setWeight( Weight );
3890 }
3891 if( ColorIndex.hasValue() )
3892 {
3893 xBorder->setColorIndex( ColorIndex );
3894 }
3895 if( Color.hasValue() )
3896 {
3897 xBorder->setColor( Color );
3898 }
3899 break;
3900 }
3901 case excel::XlBordersIndex::xlInsideVertical:
3902 case excel::XlBordersIndex::xlInsideHorizontal:
3903 case excel::XlBordersIndex::xlDiagonalDown:
3904 case excel::XlBordersIndex::xlDiagonalUp:
3905 break;
3906 default:
3907 return uno::makeAny( false );
3908 }
3909 }
3910 return uno::makeAny( sal_True );
3911 }
3912
3913 uno::Any SAL_CALL
3914 ScVbaRange::getRowHeight() throw (uno::RuntimeException)
3915 {
3916 sal_Int32 nLen = m_Areas->getCount();
3917 if ( nLen > 1 )
3918 {
3919 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32(1) ), uno::Any() ), uno::UNO_QUERY_THROW );
3920 return xRange->getRowHeight();
3921 }
3922
3923 // if any row's RowHeight in the
3924 // range is different from any other then return NULL
3925 RangeHelper thisRange( mxRange );
3926 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
3927
3928 sal_Int32 nStartRow = thisAddress.StartRow;
3929 sal_Int32 nEndRow = thisAddress.EndRow;
3930 sal_uInt16 nRowTwips = 0;
3931 // #TODO probably possible to use the SfxItemSet ( and see if
3932 // SFX_ITEM_DONTCARE is set ) to improve performance
3933 // #CHECKME looks like this is general behaviour not just row Range specific
3934 // if ( mbIsRows )
3935 ScDocShell* pShell = getScDocShell();
3936 if ( pShell )
3937 {
3938 for ( sal_Int32 nRow = nStartRow ; nRow <= nEndRow; ++nRow )
3939 {
3940 thisAddress.StartRow = nRow;
3941 sal_uInt16 nCurTwips = pShell->GetDocument()->GetOriginalHeight( thisAddress.StartRow, thisAddress.Sheet );
3942 if ( nRow == nStartRow )
3943 nRowTwips = nCurTwips;
3944 if ( nRowTwips != nCurTwips )
3945 return aNULL();
3946 }
3947 }
3948 double nHeight = lcl_Round2DecPlaces( lcl_TwipsToPoints( nRowTwips ) );
3949 return uno::makeAny( nHeight );
3950 }
3951
3952 void SAL_CALL
3953 ScVbaRange::setRowHeight( const uno::Any& _rowheight) throw (uno::RuntimeException)
3954 {
3955 sal_Int32 nLen = m_Areas->getCount();
3956 if ( nLen > 1 )
3957 {
3958 for ( sal_Int32 index = 1; index != nLen; ++index )
3959 {
3960 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32(index) ), uno::Any() ), uno::UNO_QUERY_THROW );
3961 xRange->setRowHeight( _rowheight );
3962 }
3963 return;
3964 }
3965 double nHeight = 0; // Incomming height is in points
3966 _rowheight >>= nHeight;
3967 nHeight = lcl_Round2DecPlaces( nHeight );
3968 RangeHelper thisRange( mxRange );
3969 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
3970 sal_uInt16 nTwips = lcl_pointsToTwips( nHeight );
3971
3972 ScDocShell* pDocShell = getDocShellFromRange( mxRange );
3973 SCCOLROW nRowArr[2];
3974 nRowArr[0] = thisAddress.StartRow;
3975 nRowArr[1] = thisAddress.EndRow;
3976 pDocShell->GetDocFunc().SetWidthOrHeight( false, 1, nRowArr, thisAddress.Sheet, SC_SIZE_ORIGINAL,
3977 nTwips, true, true );
3978 }
3979
3980 uno::Any SAL_CALL
3981 ScVbaRange::getPageBreak() throw (uno::RuntimeException)
3982 {
3983 sal_Int32 nPageBreak = excel::XlPageBreak::xlPageBreakNone;
3984 ScDocShell* pShell = getDocShellFromRange( mxRange );
3985 if ( pShell )
3986 {
3987 RangeHelper thisRange( mxRange );
3988 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
3989 sal_Bool bColumn = false;
3990
3991 if (thisAddress.StartRow==0)
3992 bColumn = true;
3993
3994 uno::Reference< frame::XModel > xModel = pShell->GetModel();
3995 if ( xModel.is() )
3996 {
3997 ScDocument* pDoc = getDocumentFromRange( mxRange );
3998
3999 ScBreakType nBreak = BREAK_NONE;
4000 if ( !bColumn )
4001 nBreak = pDoc->HasRowBreak(thisAddress.StartRow, thisAddress.Sheet);
4002 else
4003 nBreak = pDoc->HasColBreak(thisAddress.StartColumn, thisAddress.Sheet);
4004
4005 if (nBreak & BREAK_PAGE)
4006 nPageBreak = excel::XlPageBreak::xlPageBreakAutomatic;
4007
4008 if (nBreak & BREAK_MANUAL)
4009 nPageBreak = excel::XlPageBreak::xlPageBreakManual;
4010 }
4011 }
4012
4013 return uno::makeAny( nPageBreak );
4014 }
4015
4016 void SAL_CALL
4017 ScVbaRange::setPageBreak( const uno::Any& _pagebreak) throw (uno::RuntimeException)
4018 {
4019 sal_Int32 nPageBreak = 0;
4020 _pagebreak >>= nPageBreak;
4021
4022 ScDocShell* pShell = getDocShellFromRange( mxRange );
4023 if ( pShell )
4024 {
4025 RangeHelper thisRange( mxRange );
4026 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
4027 if ((thisAddress.StartColumn==0) && (thisAddress.StartRow==0))
4028 return;
4029 sal_Bool bColumn = false;
4030
4031 if (thisAddress.StartRow==0)
4032 bColumn = true;
4033
4034 ScAddress aAddr( static_cast<SCCOL>(thisAddress.StartColumn), thisAddress.StartRow, thisAddress.Sheet );
4035 uno::Reference< frame::XModel > xModel = pShell->GetModel();
4036 if ( xModel.is() )
4037 {
4038 ScTabViewShell* pViewShell = excel::getBestViewShell( xModel );
4039 if ( nPageBreak == excel::XlPageBreak::xlPageBreakManual )
4040 pViewShell->InsertPageBreak( bColumn, sal_True, &aAddr);
4041 else if ( nPageBreak == excel::XlPageBreak::xlPageBreakNone )
4042 pViewShell->DeletePageBreak( bColumn, sal_True, &aAddr);
4043 }
4044 }
4045 }
4046
4047 uno::Any SAL_CALL
4048 ScVbaRange::getHeight() throw (uno::RuntimeException)
4049 {
4050 if ( m_Areas->getCount() > 1 )
4051 {
4052 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32(1) ), uno::Any() ), uno::UNO_QUERY_THROW );
4053 return xRange->getHeight();
4054 }
4055
4056 uno::Reference< table::XColumnRowRange > xColRowRange( mxRange, uno::UNO_QUERY_THROW );
4057 uno::Reference< container::XIndexAccess > xIndexAccess( xColRowRange->getRows(), uno::UNO_QUERY_THROW );
4058 sal_Int32 nElems = xIndexAccess->getCount();
4059 double nHeight = 0;
4060 for ( sal_Int32 index=0; index<nElems; ++index )
4061 {
4062 uno::Reference< sheet::XCellRangeAddressable > xAddressable( xIndexAccess->getByIndex( index ), uno::UNO_QUERY_THROW );
4063 nHeight += getCalcRowHeight(xAddressable->getRangeAddress() );
4064 }
4065 return uno::makeAny( nHeight );
4066 }
4067
4068 awt::Point
4069 ScVbaRange::getPosition() throw ( uno::RuntimeException )
4070 {
4071 awt::Point aPoint;
4072 uno::Reference< beans::XPropertySet > xProps;
4073 if ( mxRange.is() )
4074 xProps.set( mxRange, uno::UNO_QUERY_THROW );
4075 else
4076 xProps.set( mxRanges, uno::UNO_QUERY_THROW );
4077 xProps->getPropertyValue( POSITION ) >>= aPoint;
4078 return aPoint;
4079 }
4080 uno::Any SAL_CALL
4081 ScVbaRange::getLeft() throw (uno::RuntimeException)
4082 {
4083 // helperapi returns the first ranges left ( and top below )
4084 if ( m_Areas->getCount() > 1 )
4085 return getArea( 0 )->getLeft();
4086 awt::Point aPoint = getPosition();
4087 return uno::makeAny( lcl_hmmToPoints( aPoint.X ) );
4088 }
4089
4090
4091 uno::Any SAL_CALL
4092 ScVbaRange::getTop() throw (uno::RuntimeException)
4093 {
4094 // helperapi returns the first ranges top
4095 if ( m_Areas->getCount() > 1 )
4096 return getArea( 0 )->getTop();
4097 awt::Point aPoint= getPosition();
4098 return uno::makeAny( lcl_hmmToPoints( aPoint.Y ) );
4099 }
4100
4101
4102 uno::Reference< sheet::XCellRangeReferrer > getNamedRange( const uno::Reference< uno::XInterface >& xIf, const uno::Reference< table::XCellRange >& thisRange )
4103 {
4104 uno::Reference< beans::XPropertySet > xProps( xIf, uno::UNO_QUERY_THROW );
4105 uno::Reference< container::XNameAccess > xNameAccess( xProps->getPropertyValue( "NamedRanges" ), uno::UNO_QUERY_THROW );
4106
4107 uno::Sequence< OUString > sNames = xNameAccess->getElementNames();
4108 // uno::Reference< table::XCellRange > thisRange( getCellRange(), uno::UNO_QUERY_THROW );
4109 uno::Reference< sheet::XCellRangeReferrer > xNamedRange;
4110 for ( sal_Int32 i=0; i < sNames.getLength(); ++i )
4111 {
4112 uno::Reference< sheet::XCellRangeReferrer > xName( xNameAccess->getByName( sNames[ i ] ), uno::UNO_QUERY );
4113 if ( xName.is() )
4114 {
4115 if ( thisRange == xName->getReferredCells() )
4116 {
4117 xNamedRange = xName;
4118 break;
4119 }
4120 }
4121 }
4122 return xNamedRange;
4123 }
4124
4125 uno::Reference< excel::XName >
4126 ScVbaRange::getName() throw (uno::RuntimeException)
4127 {
4128 uno::Reference< beans::XPropertySet > xProps( getUnoModel(), uno::UNO_QUERY );
4129 uno::Reference< table::XCellRange > thisRange( getCellRange(), uno::UNO_QUERY_THROW );
4130 // Application range
4131 uno::Reference< sheet::XCellRangeReferrer > xNamedRange = getNamedRange( xProps, thisRange );
4132
4133 if ( !xNamedRange.is() )
4134 {
4135 // not in application range then assume it might be in
4136 // sheet namedranges
4137 RangeHelper aRange( thisRange );
4138 uno::Reference< sheet::XSpreadsheet > xSheet = aRange.getSpreadSheet();
4139 xProps.set( xSheet, uno::UNO_QUERY );
4140 // impl here
4141 xNamedRange = getNamedRange( xProps, thisRange );
4142 }
4143 if ( xProps.is() && xNamedRange.is() )
4144 {
4145 uno::Reference< sheet::XNamedRanges > xNamedRanges( xProps, uno::UNO_QUERY_THROW );
4146 uno::Reference< sheet::XNamedRange > xName( xNamedRange, uno::UNO_QUERY_THROW );
4147 return new ScVbaName( mxParent, mxContext, xName, xNamedRanges, getUnoModel() );
4148 }
4149 return uno::Reference< excel::XName >();
4150 }
4151
4152 uno::Reference< excel::XWorksheet >
4153 ScVbaRange::getWorksheet() throw (uno::RuntimeException)
4154 {
4155 // #TODO #FIXME parent should always be set up ( currently thats not
4156 // the case )
4157 uno::Reference< excel::XWorksheet > xSheet( getParent(), uno::UNO_QUERY );
4158 if ( !xSheet.is() )
4159 {
4160 uno::Reference< table::XCellRange > xRange = mxRange;
4161
4162 if ( mxRanges.is() ) // assign xRange to first range
4163 {
4164 uno::Reference< container::XIndexAccess > xIndex( mxRanges, uno::UNO_QUERY_THROW );
4165 xRange.set( xIndex->getByIndex( 0 ), uno::UNO_QUERY_THROW );
4166 }
4167 ScDocShell* pDocShell = getDocShellFromRange(xRange);
4168 RangeHelper rHelper(xRange);
4169 // parent should be Thisworkbook
4170 xSheet.set( new ScVbaWorksheet( uno::Reference< XHelperInterface >(), mxContext,rHelper.getSpreadSheet(),pDocShell->GetModel()) );
4171 }
4172 return xSheet;
4173 }
4174
4175 // #TODO remove this ugly application processing
4176 // Process an application Range request e.g. 'Range("a1,b2,a4:b6")
4177 uno::Reference< excel::XRange >
4178 ScVbaRange::ApplicationRange( const uno::Reference< uno::XComponentContext >& xContext, const css::uno::Any &Cell1, const css::uno::Any &Cell2 ) throw (css::uno::RuntimeException)
4179 {
4180 // Althought the documentation seems clear that Range without a
4181 // qualifier then its a shortcut for ActiveSheet.Range
4182 // however, similarly Application.Range is apparently also a
4183 // shortcut for ActiveSheet.Range
4184 // The is however a subtle behavioural difference I've come across
4185 // wrt to named ranges.
4186 // If a named range "test" exists { Sheet1!$A1 } and the active sheet
4187 // is Sheet2 then the following will fail
4188 // msgbox ActiveSheet.Range("test").Address ' failes
4189 // msgbox WorkSheets("Sheet2").Range("test").Address
4190 // but !!!
4191 // msgbox Range("test").Address ' works
4192 // msgbox Application.Range("test").Address ' works
4193
4194 // Single param Range
4195 OUString sRangeName;
4196 Cell1 >>= sRangeName;
4197 if ( Cell1.hasValue() && !Cell2.hasValue() && !sRangeName.isEmpty() )
4198 {
4199 const static OUString sNamedRanges( "NamedRanges");
4200 uno::Reference< beans::XPropertySet > xPropSet( getCurrentExcelDoc(xContext), uno::UNO_QUERY_THROW );
4201
4202 uno::Reference< container::XNameAccess > xNamed( xPropSet->getPropertyValue( sNamedRanges ), uno::UNO_QUERY_THROW );
4203 uno::Reference< sheet::XCellRangeReferrer > xReferrer;
4204 try
4205 {
4206 xReferrer.set ( xNamed->getByName( sRangeName ), uno::UNO_QUERY );
4207 }
4208 catch( uno::Exception& /*e*/ )
4209 {
4210 // do nothing
4211 }
4212 if ( xReferrer.is() )
4213 {
4214 uno::Reference< table::XCellRange > xRange = xReferrer->getReferredCells();
4215 if ( xRange.is() )
4216 {
4217 uno::Reference< excel::XRange > xVbRange = new ScVbaRange( excel::getUnoSheetModuleObj( xRange ), xContext, xRange );
4218 return xVbRange;
4219 }
4220 }
4221 }
4222
4223 uno::Reference< sheet::XSpreadsheetView > xView( getCurrentExcelDoc(xContext)->getCurrentController(), uno::UNO_QUERY );
4224 uno::Reference< table::XCellRange > xSheetRange( xView->getActiveSheet(), uno::UNO_QUERY_THROW );
4225 ScVbaRange* pRange = new ScVbaRange( excel::getUnoSheetModuleObj( xSheetRange ), xContext, xSheetRange );
4226 uno::Reference< excel::XRange > xVbSheetRange( pRange );
4227 return pRange->Range( Cell1, Cell2, true );
4228 }
4229
4230 // Helper functions for AutoFilter
4231 static ScDBData* lcl_GetDBData_Impl( ScDocShell* pDocShell, sal_Int16 nSheet )
4232 {
4233 ScDBData* pRet = NULL;
4234 if (pDocShell)
4235 {
4236 pRet = pDocShell->GetDocument()->GetAnonymousDBData(nSheet);
4237 }
4238 return pRet;
4239 }
4240
4241 static void lcl_SelectAll( ScDocShell* pDocShell, ScQueryParam& aParam )
4242 {
4243 if ( pDocShell )
4244 {
4245 ScViewData* pViewData = pDocShell->GetViewData();
4246 if ( pViewData )
4247 {
4248 OSL_TRACE("Pushing out SelectAll query");
4249 pViewData->GetView()->Query( aParam, NULL, sal_True );
4250 }
4251 }
4252 }
4253
4254 static ScQueryParam lcl_GetQueryParam( ScDocShell* pDocShell, sal_Int16 nSheet )
4255 {
4256 ScDBData* pDBData = lcl_GetDBData_Impl( pDocShell, nSheet );
4257 ScQueryParam aParam;
4258 if (pDBData)
4259 {
4260 pDBData->GetQueryParam( aParam );
4261 }
4262 return aParam;
4263 }
4264
4265 static void lcl_SetAllQueryForField( ScDocShell* pDocShell, SCCOLROW nField, sal_Int16 nSheet )
4266 {
4267 ScQueryParam aParam = lcl_GetQueryParam( pDocShell, nSheet );
4268 aParam.RemoveEntryByField(nField);
4269 lcl_SelectAll( pDocShell, aParam );
4270 }
4271
4272 // Modifies sCriteria, and nOp depending on the value of sCriteria
4273 static void lcl_setTableFieldsFromCriteria( OUString& sCriteria1, uno::Reference< beans::XPropertySet >& xDescProps, sheet::TableFilterField2& rFilterField )
4274 {
4275 // #TODO make this more efficient and cycle through
4276 // sCriteria1 character by character to pick up <,<>,=, * etc.
4277 // right now I am more concerned with just getting it to work right
4278
4279 sCriteria1 = sCriteria1.trim();
4280 // table of translation of criteria text to FilterOperators
4281 // <>searchtext - NOT_EQUAL
4282 // =searchtext - EQUAL
4283 // *searchtext - startwith
4284 // <>*searchtext - doesn't startwith
4285 // *searchtext* - contains
4286 // <>*searchtext* - doesn't contain
4287 // [>|>=|<=|...]searchtext for GREATER_value, GREATER_EQUAL_value etc.
4288 sal_Int32 nPos = 0;
4289 bool bIsNumeric = false;
4290 if ( ( nPos = sCriteria1.indexOf( EQUALS ) ) == 0 )
4291 {
4292 if ( sCriteria1.getLength() == EQUALS.getLength() )
4293 rFilterField.Operator = sheet::FilterOperator2::EMPTY;
4294 else
4295 {
4296 rFilterField.Operator = sheet::FilterOperator2::EQUAL;
4297 sCriteria1 = sCriteria1.copy( EQUALS.getLength() );
4298 sCriteria1 = VBAToRegexp( sCriteria1 );
4299 // UseRegularExpressions
4300 if ( xDescProps.is() )
4301 xDescProps->setPropertyValue( "UseRegularExpressions", uno::Any( sal_True ) );
4302 }
4303
4304 }
4305 else if ( ( nPos = sCriteria1.indexOf( NOTEQUALS ) ) == 0 )
4306 {
4307 if ( sCriteria1.getLength() == NOTEQUALS.getLength() )
4308 rFilterField.Operator = sheet::FilterOperator2::NOT_EMPTY;
4309 else
4310 {
4311 rFilterField.Operator = sheet::FilterOperator2::NOT_EQUAL;
4312 sCriteria1 = sCriteria1.copy( NOTEQUALS.getLength() );
4313 sCriteria1 = VBAToRegexp( sCriteria1 );
4314 // UseRegularExpressions
4315 if ( xDescProps.is() )
4316 xDescProps->setPropertyValue( "UseRegularExpressions", uno::Any( sal_True ) );
4317 }
4318 }
4319 else if ( ( nPos = sCriteria1.indexOf( GREATERTHAN ) ) == 0 )
4320 {
4321 bIsNumeric = true;
4322 if ( ( nPos = sCriteria1.indexOf( GREATERTHANEQUALS ) ) == 0 )
4323 {
4324 sCriteria1 = sCriteria1.copy( GREATERTHANEQUALS.getLength() );
4325 rFilterField.Operator = sheet::FilterOperator2::GREATER_EQUAL;
4326 }
4327 else
4328 {
4329 sCriteria1 = sCriteria1.copy( GREATERTHAN.getLength() );
4330 rFilterField.Operator = sheet::FilterOperator2::GREATER;
4331 }
4332
4333 }
4334 else if ( ( nPos = sCriteria1.indexOf( LESSTHAN ) ) == 0 )
4335 {
4336 bIsNumeric = true;
4337 if ( ( nPos = sCriteria1.indexOf( LESSTHANEQUALS ) ) == 0 )
4338 {
4339 sCriteria1 = sCriteria1.copy( LESSTHANEQUALS.getLength() );
4340 rFilterField.Operator = sheet::FilterOperator2::LESS_EQUAL;
4341 }
4342 else
4343 {
4344 sCriteria1 = sCriteria1.copy( LESSTHAN.getLength() );
4345 rFilterField.Operator = sheet::FilterOperator2::LESS;
4346 }
4347
4348 }
4349 else
4350 rFilterField.Operator = sheet::FilterOperator2::EQUAL;
4351
4352 if ( bIsNumeric )
4353 {
4354 rFilterField.IsNumeric= sal_True;
4355 rFilterField.NumericValue = sCriteria1.toDouble();
4356 }
4357 rFilterField.StringValue = sCriteria1;
4358 }
4359
4360 void SAL_CALL
4361 ScVbaRange::AutoFilter( const uno::Any& aField, const uno::Any& Criteria1, const uno::Any& Operator, const uno::Any& Criteria2, const uno::Any& VisibleDropDown ) throw (uno::RuntimeException)
4362 {
4363 // Is there an existing autofilter
4364 RangeHelper thisRange( mxRange );
4365 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
4366 sal_Int16 nSheet = thisAddress.Sheet;
4367 ScDocShell* pShell = getScDocShell();
4368 sal_Bool bHasAuto = false;
4369 uno::Reference< sheet::XDatabaseRange > xDataBaseRange = excel::GetAutoFiltRange( pShell, nSheet );
4370 if ( xDataBaseRange.is() )
4371 bHasAuto = true;
4372
4373 uno::Reference< table::XCellRange > xFilterRange;
4374 if ( !bHasAuto )
4375 {
4376 if ( m_Areas->getCount() > 1 )
4377 throw uno::RuntimeException( STR_ERRORMESSAGE_APPLIESTOSINGLERANGEONLY, uno::Reference< uno::XInterface >() );
4378
4379 table::CellRangeAddress autoFiltAddress;
4380 //CurrentRegion()
4381 if ( isSingleCellRange() )
4382 {
4383 uno::Reference< excel::XRange > xCurrent( CurrentRegion() );
4384 if ( xCurrent.is() )
4385 {
4386 ScVbaRange* pRange = getImplementation( xCurrent );
4387 if ( pRange )
4388 {
4389 if ( pRange->isSingleCellRange() )
4390 throw uno::RuntimeException( OUString( "Can't create AutoFilter" ), uno::Reference< uno::XInterface >() );
4391 RangeHelper currentRegion( pRange->mxRange );
4392 autoFiltAddress = currentRegion.getCellRangeAddressable()->getRangeAddress();
4393 }
4394 }
4395 }
4396 else // multi-cell range
4397 {
4398 RangeHelper multiCellRange( mxRange );
4399 autoFiltAddress = multiCellRange.getCellRangeAddressable()->getRangeAddress();
4400 // #163530# Filter box shows only entry of first row
4401 ScDocument* pDocument = ( pShell ? pShell->GetDocument() : NULL );
4402 if ( pDocument )
4403 {
4404 SCCOL nStartCol = autoFiltAddress.StartColumn;
4405 SCROW nStartRow = autoFiltAddress.StartRow;
4406 SCCOL nEndCol = autoFiltAddress.EndColumn;
4407 SCROW nEndRow = autoFiltAddress.EndRow;
4408 pDocument->GetDataArea( autoFiltAddress.Sheet, nStartCol, nStartRow, nEndCol, nEndRow, true, true );
4409 autoFiltAddress.StartColumn = nStartCol;
4410 autoFiltAddress.StartRow = nStartRow;
4411 autoFiltAddress.EndColumn = nEndCol;
4412 autoFiltAddress.EndRow = nEndRow;
4413 }
4414 }
4415
4416 uno::Reference< sheet::XUnnamedDatabaseRanges > xDBRanges = excel::GetUnnamedDataBaseRanges( pShell );
4417 if ( xDBRanges.is() )
4418 {
4419 OSL_TRACE("Going to add new autofilter range.. sheet %i", nSheet );
4420 if ( !xDBRanges->hasByTable( nSheet ) )
4421 xDBRanges->setByTable( autoFiltAddress );
4422 xDataBaseRange.set( xDBRanges->getByTable(nSheet ), uno::UNO_QUERY_THROW );
4423 }
4424 if ( !xDataBaseRange.is() )
4425 throw uno::RuntimeException( OUString( "Failed to find the autofilter placeholder range" ), uno::Reference< uno::XInterface >() );
4426
4427 uno::Reference< beans::XPropertySet > xDBRangeProps( xDataBaseRange, uno::UNO_QUERY_THROW );
4428 // set autofilt
4429 xDBRangeProps->setPropertyValue( "AutoFilter", uno::Any(sal_True) );
4430 // set header (autofilter always need column headers)
4431 uno::Reference< beans::XPropertySet > xFiltProps( xDataBaseRange->getFilterDescriptor(), uno::UNO_QUERY_THROW );
4432 sal_Bool bHasColHeader = false;
4433 ScDocument* pDoc = pShell ? pShell->GetDocument() : NULL;
4434
4435 bHasColHeader = pDoc->HasColHeader( static_cast< SCCOL >( autoFiltAddress.StartColumn ), static_cast< SCROW >( autoFiltAddress.StartRow ), static_cast< SCCOL >( autoFiltAddress.EndColumn ), static_cast< SCROW >( autoFiltAddress.EndRow ), static_cast< SCTAB >( autoFiltAddress.Sheet ) ) ? sal_True : false;
4436 xFiltProps->setPropertyValue( "ContainsHeader", uno::Any( bHasColHeader ) );
4437 }
4438
4439
4440 sal_Int32 nField = 0; // *IS* 1 based
4441 OUString sCriteria1;
4442 sal_Int32 nOperator = excel::XlAutoFilterOperator::xlAnd;
4443
4444 sal_Bool bVisible = sal_True;
4445 VisibleDropDown >>= bVisible;
4446
4447 if ( bVisible == bHasAuto ) // dropdown is displayed/notdisplayed as required
4448 bVisible = false;
4449 sheet::FilterConnection nConn = sheet::FilterConnection_AND;
4450 double nCriteria1 = 0;
4451
4452 bool bHasCritValue = Criteria1.hasValue();
4453 bool bCritHasNumericValue = false; // not sure if a numeric criteria is possible
4454 if ( bHasCritValue )
4455 bCritHasNumericValue = ( Criteria1 >>= nCriteria1 );
4456
4457 if ( !aField.hasValue() && ( Criteria1.hasValue() || Operator.hasValue() || Criteria2.hasValue() ) )
4458 throw uno::RuntimeException();
4459 bool bAll = false;
4460 uno::Any Field( aField );
4461 if ( !( Field >>= nField ) )
4462 {
4463 uno::Reference< script::XTypeConverter > xConverter = getTypeConverter( mxContext );
4464 try
4465 {
4466 Field = xConverter->convertTo( aField, getCppuType( (sal_Int32*)0 ) );
4467 }
4468 catch( uno::Exception& )
4469 {
4470 }
4471 }
4472 // Use the normal uno api, sometimes e.g. when you want to use ALL as the filter
4473 // we can't use refresh as the uno interface doesn't have a concept of ALL
4474 // in this case we just call the core calc functionality -
4475 if ( ( Field >>= nField ) )
4476 {
4477 uno::Reference< sheet::XSheetFilterDescriptor2 > xDesc(
4478 xDataBaseRange->getFilterDescriptor(), uno::UNO_QUERY );
4479 if ( xDesc.is() )
4480 {
4481 uno::Sequence< sheet::TableFilterField2 > sTabFilts;
4482 uno::Reference< beans::XPropertySet > xDescProps( xDesc, uno::UNO_QUERY_THROW );
4483 if ( Criteria1.hasValue() )
4484 {
4485 sTabFilts.realloc( 1 );
4486 sTabFilts[0].Operator = sheet::FilterOperator2::EQUAL;// sensible default
4487 if ( !bCritHasNumericValue )
4488 {
4489 Criteria1 >>= sCriteria1;
4490 sTabFilts[0].IsNumeric = bCritHasNumericValue;
4491 if ( bHasCritValue && !sCriteria1.isEmpty() )
4492 lcl_setTableFieldsFromCriteria( sCriteria1, xDescProps, sTabFilts[0] );
4493 else
4494 bAll = true;
4495 }
4496 else // numeric
4497 {
4498 sTabFilts[0].IsNumeric = sal_True;
4499 sTabFilts[0].NumericValue = nCriteria1;
4500 }
4501 }
4502 else // no value specified
4503 bAll = true;
4504 // not sure what the relationship between Criteria1 and Operator is,
4505 // e.g. can you have a Operator without a Criteria ? in openoffice it
4506 if ( Operator.hasValue() && ( Operator >>= nOperator ) )
4507 {
4508 // if its a bottom/top Ten(Percent/Value) and there
4509 // is no value specified for criteria1 set it to 10
4510 if ( !bCritHasNumericValue && sCriteria1.isEmpty() && ( nOperator != excel::XlAutoFilterOperator::xlOr ) && ( nOperator != excel::XlAutoFilterOperator::xlAnd ) )
4511 {
4512 sTabFilts[0].IsNumeric = sal_True;
4513 sTabFilts[0].NumericValue = 10;
4514 bAll = false;
4515 }
4516 switch ( nOperator )
4517 {
4518 case excel::XlAutoFilterOperator::xlBottom10Items:
4519 sTabFilts[0].Operator = sheet::FilterOperator2::BOTTOM_VALUES;
4520 break;
4521 case excel::XlAutoFilterOperator::xlBottom10Percent:
4522 sTabFilts[0].Operator = sheet::FilterOperator2::BOTTOM_PERCENT;
4523 break;
4524 case excel::XlAutoFilterOperator::xlTop10Items:
4525 sTabFilts[0].Operator = sheet::FilterOperator2::TOP_VALUES;
4526 break;
4527 case excel::XlAutoFilterOperator::xlTop10Percent:
4528 sTabFilts[0].Operator = sheet::FilterOperator2::TOP_PERCENT;
4529 break;
4530 case excel::XlAutoFilterOperator::xlOr:
4531 nConn = sheet::FilterConnection_OR;
4532 break;
4533 case excel::XlAutoFilterOperator::xlAnd:
4534 nConn = sheet::FilterConnection_AND;
4535 break;
4536 default:
4537 throw uno::RuntimeException( OUString( "UnknownOption" ), uno::Reference< uno::XInterface >() );
4538
4539 }
4540
4541 }
4542 if ( !bAll )
4543 {
4544 sTabFilts[0].Connection = sheet::FilterConnection_AND;
4545 sTabFilts[0].Field = (nField - 1);
4546
4547 OUString sCriteria2;
4548 if ( Criteria2.hasValue() ) // there is a Criteria2
4549 {
4550 sTabFilts.realloc(2);
4551 sTabFilts[1].Field = sTabFilts[0].Field;
4552 sTabFilts[1].Connection = nConn;
4553
4554 if ( Criteria2 >>= sCriteria2 )
4555 {
4556 if ( !sCriteria2.isEmpty() )
4557 {
4558 uno::Reference< beans::XPropertySet > xProps;
4559 lcl_setTableFieldsFromCriteria( sCriteria2, xProps, sTabFilts[1] );
4560 sTabFilts[1].IsNumeric = false;
4561 }
4562 }
4563 else // numeric
4564 {
4565 Criteria2 >>= sTabFilts[1].NumericValue;
4566 sTabFilts[1].IsNumeric = sal_True;
4567 sTabFilts[1].Operator = sheet::FilterOperator2::EQUAL;
4568 }
4569 }
4570 }
4571
4572 xDesc->setFilterFields2( sTabFilts );
4573 if ( !bAll )
4574 {
4575 xDataBaseRange->refresh();
4576 }
4577 else
4578 // was 0 based now seems to be 1
4579 lcl_SetAllQueryForField( pShell, nField, nSheet );
4580 }
4581 }
4582 else
4583 {
4584 // this is just to toggle autofilter on and off ( not to be confused with
4585 // a VisibleDropDown option combined with a field, in that case just the
4586 // button should be disabled ) - currently we don't support that
4587 uno::Reference< beans::XPropertySet > xDBRangeProps( xDataBaseRange, uno::UNO_QUERY_THROW );
4588 if ( bHasAuto )
4589 {
4590 // find the any field with the query and select all
4591 ScQueryParam aParam = lcl_GetQueryParam( pShell, nSheet );
4592 for (SCSIZE i = 0; i< aParam.GetEntryCount(); ++i)
4593 {
4594 ScQueryEntry& rEntry = aParam.GetEntry(i);
4595 if ( rEntry.bDoQuery )
4596 lcl_SetAllQueryForField( pShell, rEntry.nField, nSheet );
4597 }
4598 // remove exising filters
4599 uno::Reference< sheet::XSheetFilterDescriptor2 > xSheetFilterDescriptor(
4600 xDataBaseRange->getFilterDescriptor(), uno::UNO_QUERY );
4601 if( xSheetFilterDescriptor.is() )
4602 xSheetFilterDescriptor->setFilterFields2( uno::Sequence< sheet::TableFilterField2 >() );
4603 }
4604 xDBRangeProps->setPropertyValue( "AutoFilter", uno::Any(!bHasAuto) );
4605
4606 }
4607 }
4608
4609 void SAL_CALL
4610 ScVbaRange::Insert( const uno::Any& Shift, const uno::Any& /*CopyOrigin*/ ) throw (uno::RuntimeException)
4611 {
4612 // It appears ( from the web ) that the undocumented CopyOrigin
4613 // param should contain member of enum XlInsertFormatOrigin
4614 // which can have values xlFormatFromLeftOrAbove or xlFormatFromRightOrBelow
4615 // #TODO investigate resultant behaviour using these constants
4616 // currently just processing Shift
4617
4618 sheet::CellInsertMode mode = sheet::CellInsertMode_NONE;
4619 if ( Shift.hasValue() )
4620 {
4621 sal_Int32 nShift = 0;
4622 Shift >>= nShift;
4623 switch ( nShift )
4624 {
4625 case excel::XlInsertShiftDirection::xlShiftToRight:
4626 mode = sheet::CellInsertMode_RIGHT;
4627 break;
4628 case excel::XlInsertShiftDirection::xlShiftDown:
4629 mode = sheet::CellInsertMode_DOWN;
4630 break;
4631 default:
4632 throw uno::RuntimeException( OUString( "Illegal parameter " ), uno::Reference< uno::XInterface >() );
4633 }
4634 }
4635 else
4636 {
4637 if ( getRow() >= getColumn() )
4638 mode = sheet::CellInsertMode_DOWN;
4639 else
4640 mode = sheet::CellInsertMode_RIGHT;
4641 }
4642 RangeHelper thisRange( mxRange );
4643 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
4644 uno::Reference< sheet::XCellRangeMovement > xCellRangeMove( thisRange.getSpreadSheet(), uno::UNO_QUERY_THROW );
4645 xCellRangeMove->insertCells( thisAddress, mode );
4646
4647 // Paste from clipboard only if the clipboard content was copied via VBA, and not already pasted via VBA again.
4648 // "Insert" behavior should not depend on random clipboard content previously copied by the user.
4649 ScTransferObj* pClipObj = ScTransferObj::GetOwnClipboard( NULL );
4650 if ( pClipObj && pClipObj->GetUseInApi() )
4651 {
4652 // After the insert ( this range ) actually has moved
4653 ScRange aRange( static_cast< SCCOL >( thisAddress.StartColumn ), static_cast< SCROW >( thisAddress.StartRow ), static_cast< SCTAB >( thisAddress.Sheet ), static_cast< SCCOL >( thisAddress.EndColumn ), static_cast< SCROW >( thisAddress.EndRow ), static_cast< SCTAB >( thisAddress.Sheet ) );
4654 uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( getDocShellFromRange( mxRange ) , aRange ) );
4655 uno::Reference< excel::XRange > xVbaRange( new ScVbaRange( mxParent, mxContext, xRange, mbIsRows, mbIsColumns ) );
4656 xVbaRange->PasteSpecial( uno::Any(), uno::Any(), uno::Any(), uno::Any() );
4657 }
4658 }
4659
4660 void SAL_CALL
4661 ScVbaRange::Autofit() throw (uno::RuntimeException)
4662 {
4663 sal_Int32 nLen = m_Areas->getCount();
4664 if ( nLen > 1 )
4665 {
4666 for ( sal_Int32 index = 1; index != nLen; ++index )
4667 {
4668 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32(index) ), uno::Any() ), uno::UNO_QUERY_THROW );
4669 xRange->Autofit();
4670 }
4671 return;
4672 }
4673 // if the range is a not a row or column range autofit will
4674 // throw an error
4675
4676 if ( !( mbIsColumns || mbIsRows ) )
4677 DebugHelper::exception(SbERR_METHOD_FAILED, OUString());
4678 ScDocShell* pDocShell = getDocShellFromRange( mxRange );
4679 if ( pDocShell )
4680 {
4681 RangeHelper thisRange( mxRange );
4682 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
4683
4684 SCCOLROW nColArr[2];
4685 nColArr[0] = thisAddress.StartColumn;
4686 nColArr[1] = thisAddress.EndColumn;
4687 sal_Bool bDirection = sal_True;
4688 if ( mbIsRows )
4689 {
4690 bDirection = false;
4691 nColArr[0] = thisAddress.StartRow;
4692 nColArr[1] = thisAddress.EndRow;
4693 }
4694 pDocShell->GetDocFunc().SetWidthOrHeight( bDirection, 1, nColArr, thisAddress.Sheet,
4695 SC_SIZE_OPTIMAL, 0, true, true );
4696 }
4697 }
4698
4699 uno::Any SAL_CALL
4700 ScVbaRange::Hyperlinks( const uno::Any& aIndex ) throw (uno::RuntimeException)
4701 {
4702 /* The range object always returns a new Hyperlinks object containing a
4703 fixed list of existing hyperlinks in the range.
4704 See vbahyperlinks.hxx for more details. */
4705
4706 // get the global hyperlink object of the sheet (sheet should always be the parent of a Range object)
4707 uno::Reference< excel::XWorksheet > xWorksheet( getParent(), uno::UNO_QUERY_THROW );
4708 uno::Reference< excel::XHyperlinks > xSheetHlinks( xWorksheet->Hyperlinks( uno::Any() ), uno::UNO_QUERY_THROW );
4709 ScVbaHyperlinksRef xScSheetHlinks( dynamic_cast< ScVbaHyperlinks* >( xSheetHlinks.get() ) );
4710 if( !xScSheetHlinks.is() )
4711 throw uno::RuntimeException( OUString( "Cannot obtain hyperlinks implementation object" ), uno::Reference< uno::XInterface >() );
4712
4713 // create a new local hyperlinks object based on the sheet hyperlinks
4714 ScVbaHyperlinksRef xHlinks( new ScVbaHyperlinks( getParent(), mxContext, xScSheetHlinks, getScRangeList() ) );
4715 if( aIndex.hasValue() )
4716 return xHlinks->Item( aIndex, uno::Any() );
4717 return uno::Any( uno::Reference< excel::XHyperlinks >( xHlinks.get() ) );
4718 }
4719
4720 css::uno::Reference< excel::XValidation > SAL_CALL
4721 ScVbaRange::getValidation() throw (css::uno::RuntimeException)
4722 {
4723 if ( !m_xValidation.is() )
4724 m_xValidation = new ScVbaValidation( this, mxContext, mxRange );
4725 return m_xValidation;
4726 }
4727
4728 namespace {
4729
4730 sal_Unicode lclGetPrefixChar( const uno::Reference< table::XCell >& rxCell ) throw (uno::RuntimeException)
4731 {
4732 /* TODO/FIXME: We need an apostroph-prefix property at the cell to
4733 implement this correctly. For now, return an apostroph for every text
4734 cell.
4735
4736 TODO/FIXME: When Application.TransitionNavigKeys is supported and true,
4737 this function needs to inspect the cell formatting and return different
4738 prefixes according to the horizontal cell alignment.
4739 */
4740 return (rxCell->getType() == table::CellContentType_TEXT) ? '\'' : 0;
4741 }
4742
4743 sal_Unicode lclGetPrefixChar( const uno::Reference< table::XCellRange >& rxRange ) throw (uno::RuntimeException)
4744 {
4745 /* This implementation is able to handle different prefixes (needed if
4746 Application.TransitionNavigKeys is true). The function lclGetPrefixChar
4747 for single cells called from here may return any prefix. If that
4748 function returns an empty prefix (NUL character) or different non-empty
4749 prefixes for two cells, this function returns 0.
4750 */
4751 sal_Unicode cCurrPrefix = 0;
4752 table::CellRangeAddress aRangeAddr = lclGetRangeAddress( rxRange );
4753 sal_Int32 nEndCol = aRangeAddr.EndColumn - aRangeAddr.StartColumn;
4754 sal_Int32 nEndRow = aRangeAddr.EndRow - aRangeAddr.StartRow;
4755 for( sal_Int32 nRow = 0; nRow <= nEndRow; ++nRow )
4756 {
4757 for( sal_Int32 nCol = 0; nCol <= nEndCol; ++nCol )
4758 {
4759 uno::Reference< table::XCell > xCell( rxRange->getCellByPosition( nCol, nRow ), uno::UNO_SET_THROW );
4760 sal_Unicode cNewPrefix = lclGetPrefixChar( xCell );
4761 if( (cNewPrefix == 0) || ((cCurrPrefix != 0) && (cNewPrefix != cCurrPrefix)) )
4762 return 0;
4763 cCurrPrefix = cNewPrefix;
4764 }
4765 }
4766 // all cells contain the same prefix - return it
4767 return cCurrPrefix;
4768 }
4769
4770 sal_Unicode lclGetPrefixChar( const uno::Reference< sheet::XSheetCellRangeContainer >& rxRanges ) throw (uno::RuntimeException)
4771 {
4772 sal_Unicode cCurrPrefix = 0;
4773 uno::Reference< container::XEnumerationAccess > xRangesEA( rxRanges, uno::UNO_QUERY_THROW );
4774 uno::Reference< container::XEnumeration > xRangesEnum( xRangesEA->createEnumeration(), uno::UNO_SET_THROW );
4775 while( xRangesEnum->hasMoreElements() )
4776 {
4777 uno::Reference< table::XCellRange > xRange( xRangesEnum->nextElement(), uno::UNO_QUERY_THROW );
4778 sal_Unicode cNewPrefix = lclGetPrefixChar( xRange );
4779 if( (cNewPrefix == 0) || ((cCurrPrefix != 0) && (cNewPrefix != cCurrPrefix)) )
4780 return 0;
4781 cCurrPrefix = cNewPrefix;
4782 }
4783 // all ranges contain the same prefix - return it
4784 return cCurrPrefix;
4785 }
4786
4787 inline uno::Any lclGetPrefixVariant( sal_Unicode cPrefixChar )
4788 {
4789 return uno::Any( (cPrefixChar == 0) ? OUString() : OUString( cPrefixChar ) );
4790 }
4791
4792 } // namespace
4793
4794 uno::Any SAL_CALL ScVbaRange::getPrefixCharacter() throw (uno::RuntimeException)
4795 {
4796 /* (1) If Application.TransitionNavigKeys is false, this function returns
4797 an apostroph character if the text cell begins with an apostroph
4798 character (formula return values are not taken into account); otherwise
4799 an empty string.
4800
4801 (2) If Application.TransitionNavigKeys is true, this function returns
4802 an apostroph character, if the cell is left-aligned; a double-quote
4803 character, if the cell is right-aligned; a circumflex character, if the
4804 cell is centered; a backslash character, if the cell is set to filled;
4805 or an empty string, if nothing of the above.
4806
4807 If a range or a list of ranges contains texts with leading apostroph
4808 character as well as other cells, this function returns an empty
4809 string.
4810 */
4811
4812 if( mxRange.is() )
4813 return lclGetPrefixVariant( lclGetPrefixChar( mxRange ) );
4814 if( mxRanges.is() )
4815 return lclGetPrefixVariant( lclGetPrefixChar( mxRanges ) );
4816 throw uno::RuntimeException( OUString( "Unexpected empty Range object" ), uno::Reference< uno::XInterface >() );
4817 }
4818
4819 uno::Any ScVbaRange::getShowDetail() throw ( css::uno::RuntimeException)
4820 {
4821 // #FIXME, If the specified range is in a PivotTable report
4822
4823 // In MSO VBA, the specified range must be a single summary column or row in an outline. otherwise throw exception
4824 if( m_Areas->getCount() > 1 )
4825 throw uno::RuntimeException( OUString( "Can not get Range.ShowDetail attribute "), uno::Reference< uno::XInterface >() );
4826
4827 sal_Bool bShowDetail = false;
4828
4829 RangeHelper helper( mxRange );
4830 uno::Reference< sheet::XSheetCellCursor > xSheetCellCursor = helper.getSheetCellCursor();
4831 xSheetCellCursor->collapseToCurrentRegion();
4832 uno::Reference< sheet::XCellRangeAddressable > xCellRangeAddressable(xSheetCellCursor, uno::UNO_QUERY_THROW);
4833 table::CellRangeAddress aOutlineAddress = xCellRangeAddressable->getRangeAddress();
4834
4835 // check if the specified range is a single summary column or row.
4836 table::CellRangeAddress thisAddress = helper.getCellRangeAddressable()->getRangeAddress();
4837 if( (thisAddress.StartRow == thisAddress.EndRow && thisAddress.EndRow == aOutlineAddress.EndRow ) ||
4838 (thisAddress.StartColumn == thisAddress.EndColumn && thisAddress.EndColumn == aOutlineAddress.EndColumn ))
4839 {
4840 sal_Bool bColumn =thisAddress.StartRow == thisAddress.EndRow ? false:sal_True;
4841 ScDocument* pDoc = getDocumentFromRange( mxRange );
4842 ScOutlineTable* pOutlineTable = pDoc->GetOutlineTable(static_cast<SCTAB>(thisAddress.Sheet), sal_True);
4843 const ScOutlineArray* pOutlineArray = bColumn ? pOutlineTable->GetColArray(): pOutlineTable->GetRowArray();
4844 if( pOutlineArray )
4845 {
4846 SCCOLROW nPos = bColumn ? (SCCOLROW)(thisAddress.EndColumn-1):(SCCOLROW)(thisAddress.EndRow-1);
4847 const ScOutlineEntry* pEntry = pOutlineArray->GetEntryByPos( 0, nPos );
4848 if( pEntry )
4849 {
4850 bShowDetail = !pEntry->IsHidden();
4851 return uno::makeAny( bShowDetail );
4852 }
4853 }
4854 }
4855 else
4856 {
4857 throw uno::RuntimeException( OUString( "Can not set Range.ShowDetail attribute "), uno::Reference< uno::XInterface >() );
4858 }
4859 return aNULL();
4860 }
4861
4862 void ScVbaRange::setShowDetail(const uno::Any& aShowDetail) throw ( css::uno::RuntimeException)
4863 {
4864 // #FIXME, If the specified range is in a PivotTable report
4865
4866 // In MSO VBA, the specified range must be a single summary column or row in an outline. otherwise throw exception
4867 if( m_Areas->getCount() > 1 )
4868 throw uno::RuntimeException( OUString( "Can not set Range.ShowDetail attribute "), uno::Reference< uno::XInterface >() );
4869
4870 bool bShowDetail = extractBoolFromAny( aShowDetail );
4871
4872 RangeHelper helper( mxRange );
4873 uno::Reference< sheet::XSheetCellCursor > xSheetCellCursor = helper.getSheetCellCursor();
4874 xSheetCellCursor->collapseToCurrentRegion();
4875 uno::Reference< sheet::XCellRangeAddressable > xCellRangeAddressable(xSheetCellCursor, uno::UNO_QUERY_THROW);
4876 table::CellRangeAddress aOutlineAddress = xCellRangeAddressable->getRangeAddress();
4877
4878 // check if the specified range is a single summary column or row.
4879 table::CellRangeAddress thisAddress = helper.getCellRangeAddressable()->getRangeAddress();
4880 if( (thisAddress.StartRow == thisAddress.EndRow && thisAddress.EndRow == aOutlineAddress.EndRow ) ||
4881 (thisAddress.StartColumn == thisAddress.EndColumn && thisAddress.EndColumn == aOutlineAddress.EndColumn ))
4882 {
4883 // #FIXME, seems there is a different behavior between MSO and OOo.
4884 // In OOo, the showDetail will show all the level entrys, while only show the first level entry in MSO
4885 uno::Reference< sheet::XSheetOutline > xSheetOutline( helper.getSpreadSheet(), uno::UNO_QUERY_THROW );
4886 if( bShowDetail )
4887 xSheetOutline->showDetail( aOutlineAddress );
4888 else
4889 xSheetOutline->hideDetail( aOutlineAddress );
4890 }
4891 else
4892 {
4893 throw uno::RuntimeException( OUString( "Can not set Range.ShowDetail attribute "), uno::Reference< uno::XInterface >() );
4894 }
4895 }
4896
4897 uno::Reference< excel::XRange > SAL_CALL
4898 ScVbaRange::MergeArea() throw (script::BasicErrorException, uno::RuntimeException)
4899 {
4900 uno::Reference< sheet::XSheetCellRange > xMergeShellCellRange(mxRange->getCellRangeByPosition(0,0,0,0), uno::UNO_QUERY_THROW);
4901 uno::Reference< sheet::XSheetCellCursor > xMergeSheetCursor(xMergeShellCellRange->getSpreadsheet()->createCursorByRange( xMergeShellCellRange ), uno::UNO_QUERY_THROW);
4902 if( xMergeSheetCursor.is() )
4903 {
4904 xMergeSheetCursor->collapseToMergedArea();
4905 uno::Reference<sheet::XCellRangeAddressable> xMergeCellAddress(xMergeSheetCursor, uno::UNO_QUERY_THROW);
4906 if( xMergeCellAddress.is() )
4907 {
4908 table::CellRangeAddress aCellAddress = xMergeCellAddress->getRangeAddress();
4909 if( aCellAddress.StartColumn ==0 && aCellAddress.EndColumn==0 &&
4910 aCellAddress.StartRow==0 && aCellAddress.EndRow==0)
4911 {
4912 return new ScVbaRange( mxParent,mxContext,mxRange );
4913 }
4914 else
4915 {
4916 ScRange refRange( static_cast< SCCOL >( aCellAddress.StartColumn ), static_cast< SCROW >( aCellAddress.StartRow ), static_cast< SCTAB >( aCellAddress.Sheet ),
4917 static_cast< SCCOL >( aCellAddress.EndColumn ), static_cast< SCROW >( aCellAddress.EndRow ), static_cast< SCTAB >( aCellAddress.Sheet ) );
4918 uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( getScDocShell() , refRange ) );
4919 return new ScVbaRange( mxParent, mxContext,xRange );
4920 }
4921 }
4922 }
4923 return new ScVbaRange( mxParent, mxContext, mxRange );
4924 }
4925
4926 void SAL_CALL
4927 ScVbaRange::PrintOut( const uno::Any& From, const uno::Any& To, const uno::Any& Copies, const uno::Any& Preview, const uno::Any& ActivePrinter, const uno::Any& PrintToFile, const uno::Any& Collate, const uno::Any& PrToFileName ) throw (uno::RuntimeException)
4928 {
4929 ScDocShell* pShell = NULL;
4930
4931 sal_Int32 nItems = m_Areas->getCount();
4932 uno::Sequence< table::CellRangeAddress > printAreas( nItems );
4933 uno::Reference< sheet::XPrintAreas > xPrintAreas;
4934 for ( sal_Int32 index=1; index <= nItems; ++index )
4935 {
4936 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
4937
4938 RangeHelper thisRange( xRange->getCellRange() );
4939 table::CellRangeAddress rangeAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
4940 if ( index == 1 )
4941 {
4942 ScVbaRange* pRange = getImplementation( xRange );
4943 // initialise the doc shell and the printareas
4944 pShell = getDocShellFromRange( pRange->mxRange );
4945 xPrintAreas.set( thisRange.getSpreadSheet(), uno::UNO_QUERY_THROW );
4946 }
4947 printAreas[ index - 1 ] = rangeAddress;
4948 }
4949 if ( pShell )
4950 {
4951 if ( xPrintAreas.is() )
4952 {
4953 xPrintAreas->setPrintAreas( printAreas );
4954 uno::Reference< frame::XModel > xModel = pShell->GetModel();
4955 PrintOutHelper( excel::getBestViewShell( xModel ), From, To, Copies, Preview, ActivePrinter, PrintToFile, Collate, PrToFileName, sal_True );
4956 }
4957 }
4958 }
4959
4960 void SAL_CALL
4961 ScVbaRange::AutoFill( const uno::Reference< excel::XRange >& Destination, const uno::Any& Type ) throw (uno::RuntimeException)
4962 {
4963 uno::Reference< excel::XRange > xDest( Destination, uno::UNO_QUERY_THROW );
4964 ScVbaRange* pRange = getImplementation( xDest );
4965 RangeHelper destRangeHelper( pRange->mxRange );
4966 table::CellRangeAddress destAddress = destRangeHelper.getCellRangeAddressable()->getRangeAddress();
4967
4968 RangeHelper thisRange( mxRange );
4969 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
4970 ScRange sourceRange;
4971 ScRange destRange;
4972
4973 ScUnoConversion::FillScRange( destRange, destAddress );
4974 ScUnoConversion::FillScRange( sourceRange, thisAddress );
4975
4976 FillDir eDir = FILL_TO_BOTTOM;
4977 double fStep = 1.0;
4978
4979 ScRange aRange( destRange );
4980 ScRange aSourceRange( destRange );
4981
4982 // default to include the number of Rows in the source range;
4983 SCCOLROW nSourceCount = ( sourceRange.aEnd.Row() - sourceRange.aStart.Row() ) + 1;
4984 SCCOLROW nCount = 0;
4985
4986 if ( sourceRange != destRange )
4987 {
4988 // Find direction of fill, vertical or horizontal
4989 if ( sourceRange.aStart == destRange.aStart )
4990 {
4991 if ( sourceRange.aEnd.Row() == destRange.aEnd.Row() )
4992 {
4993 nSourceCount = ( sourceRange.aEnd.Col() - sourceRange.aStart.Col() + 1 );
4994 aSourceRange.aEnd.SetCol( static_cast<SCCOL>( aSourceRange.aStart.Col() + nSourceCount - 1 ) );
4995 eDir = FILL_TO_RIGHT;
4996 nCount = aRange.aEnd.Col() - aSourceRange.aEnd.Col();
4997 }
4998 else if ( sourceRange.aEnd.Col() == destRange.aEnd.Col() )
4999 {
5000 aSourceRange.aEnd.SetRow( static_cast<SCROW>( aSourceRange.aStart.Row() + nSourceCount ) - 1 );
5001 nCount = aRange.aEnd.Row() - aSourceRange.aEnd.Row();
5002 eDir = FILL_TO_BOTTOM;
5003 }
5004 }
5005
5006 else if ( aSourceRange.aEnd == destRange.aEnd )
5007 {
5008 if ( sourceRange.aStart.Col() == destRange.aStart.Col() )
5009 {
5010 aSourceRange.aStart.SetRow( static_cast<SCROW>( aSourceRange.aEnd.Row() - nSourceCount + 1 ) );
5011 nCount = aSourceRange.aStart.Row() - aRange.aStart.Row();
5012 eDir = FILL_TO_TOP;
5013 fStep = -fStep;
5014 }
5015 else if ( sourceRange.aStart.Row() == destRange.aStart.Row() )
5016 {
5017 nSourceCount = ( sourceRange.aEnd.Col() - sourceRange.aStart.Col() ) + 1;
5018 aSourceRange.aStart.SetCol( static_cast<SCCOL>( aSourceRange.aEnd.Col() - nSourceCount + 1 ) );
5019 nCount = aSourceRange.aStart.Col() - aRange.aStart.Col();
5020 eDir = FILL_TO_LEFT;
5021 fStep = -fStep;
5022 }
5023 }
5024 }
5025
5026 FillCmd eCmd = FILL_AUTO;
5027 FillDateCmd eDateCmd = FILL_DAY;
5028
5029 if ( Type.hasValue() )
5030 {
5031 sal_Int16 nFillType = excel::XlAutoFillType::xlFillDefault;
5032 Type >>= nFillType;
5033 switch ( nFillType )
5034 {
5035 case excel::XlAutoFillType::xlFillCopy:
5036 eCmd = FILL_SIMPLE;
5037 fStep = 0.0;
5038 break;
5039 case excel::XlAutoFillType::xlFillDays:
5040 eCmd = FILL_DATE;
5041 break;
5042 case excel::XlAutoFillType::xlFillMonths:
5043 eCmd = FILL_DATE;
5044 eDateCmd = FILL_MONTH;
5045 break;
5046 case excel::XlAutoFillType::xlFillWeekdays:
5047 eCmd = FILL_DATE;
5048 eDateCmd = FILL_WEEKDAY;
5049 break;
5050 case excel::XlAutoFillType::xlFillYears:
5051 eCmd = FILL_DATE;
5052 eDateCmd = FILL_YEAR;
5053 break;
5054 case excel::XlAutoFillType::xlGrowthTrend:
5055 eCmd = FILL_GROWTH;
5056 break;
5057 case excel::XlAutoFillType::xlFillFormats:
5058 throw uno::RuntimeException( OUString( "xlFillFormat not supported for AutoFill" ), uno::Reference< uno::XInterface >() );
5059 case excel::XlAutoFillType::xlFillValues:
5060 case excel::XlAutoFillType::xlFillSeries:
5061 case excel::XlAutoFillType::xlLinearTrend:
5062 eCmd = FILL_LINEAR;
5063 break;
5064 case excel::XlAutoFillType::xlFillDefault:
5065 default:
5066 eCmd = FILL_AUTO;
5067 break;
5068 }
5069 }
5070 double fEndValue = MAXDOUBLE;
5071 ScDocShell* pDocSh = getDocShellFromRange( mxRange );
5072 pDocSh->GetDocFunc().FillAuto( aSourceRange, NULL, eDir, eCmd, eDateCmd,
5073 nCount, fStep, fEndValue, sal_True, sal_True );
5074 }
5075 sal_Bool SAL_CALL
5076 ScVbaRange::GoalSeek( const uno::Any& Goal, const uno::Reference< excel::XRange >& ChangingCell ) throw (uno::RuntimeException)
5077 {
5078 ScDocShell* pDocShell = getScDocShell();
5079 sal_Bool bRes = sal_True;
5080 ScVbaRange* pRange = static_cast< ScVbaRange* >( ChangingCell.get() );
5081 if ( pDocShell && pRange )
5082 {
5083 uno::Reference< sheet::XGoalSeek > xGoalSeek( pDocShell->GetModel(), uno::UNO_QUERY_THROW );
5084 RangeHelper thisRange( mxRange );
5085 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
5086 RangeHelper changingCellRange( pRange->mxRange );
5087 table::CellRangeAddress changingCellAddr = changingCellRange.getCellRangeAddressable()->getRangeAddress();
5088 OUString sGoal = getAnyAsString( Goal );
5089 table::CellAddress thisCell( thisAddress.Sheet, thisAddress.StartColumn, thisAddress.StartRow );
5090 table::CellAddress changingCell( changingCellAddr.Sheet, changingCellAddr.StartColumn, changingCellAddr.StartRow );
5091 sheet::GoalResult res = xGoalSeek->seekGoal( thisCell, changingCell, sGoal );
5092 ChangingCell->setValue( uno::makeAny( res.Result ) );
5093
5094 // openoffice behaves differently, result is 0 if the divergence is too great
5095 // but... if it detects 0 is the value it requires then it will use that
5096 // e.g. divergence & result both = 0.0 does NOT mean there is an error
5097 if ( ( res.Divergence != 0.0 ) && ( res.Result == 0.0 ) )
5098 bRes = false;
5099 }
5100 else
5101 bRes = false;
5102 return bRes;
5103 }
5104
5105 void
5106 ScVbaRange::Calculate( ) throw (script::BasicErrorException, uno::RuntimeException)
5107 {
5108 getWorksheet()->Calculate();
5109 }
5110
5111 uno::Reference< excel::XRange > SAL_CALL
5112 ScVbaRange::Item( const uno::Any& row, const uno::Any& column ) throw (script::BasicErrorException, uno::RuntimeException)
5113 {
5114 if ( mbIsRows || mbIsColumns )
5115 {
5116 if ( column.hasValue() )
5117 DebugHelper::exception(SbERR_BAD_PARAMETER, OUString() );
5118 uno::Reference< excel::XRange > xRange;
5119 if ( mbIsColumns )
5120 xRange = Columns( row );
5121 else
5122 xRange = Rows( row );
5123 return xRange;
5124 }
5125 return Cells( row, column );
5126 }
5127
5128 void
5129 ScVbaRange::AutoOutline( ) throw (script::BasicErrorException, uno::RuntimeException)
5130 {
5131 // #TODO #FIXME needs to check for summary row/col ( whatever they are )
5132 // not valid for multi Area Addresses
5133 if ( m_Areas->getCount() > 1 )
5134 DebugHelper::exception(SbERR_METHOD_FAILED, STR_ERRORMESSAGE_APPLIESTOSINGLERANGEONLY);
5135 // So needs to either span an entire Row or a just be a single cell
5136 // ( that contains a summary RowColumn )
5137 // also the Single cell cause doesn't seem to be handled specially in
5138 // this code ( ported from the helperapi RangeImpl.java,
5139 // RangeRowsImpl.java, RangesImpl.java, RangeSingleCellImpl.java
5140 RangeHelper thisRange( mxRange );
5141 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
5142
5143 if ( isSingleCellRange() || mbIsRows )
5144 {
5145 uno::Reference< sheet::XSheetOutline > xSheetOutline( thisRange.getSpreadSheet(), uno::UNO_QUERY_THROW );
5146 xSheetOutline->autoOutline( thisAddress );
5147 }
5148 else
5149 DebugHelper::exception(SbERR_METHOD_FAILED, OUString());
5150 }
5151
5152 void SAL_CALL
5153 ScVbaRange:: ClearOutline( ) throw (script::BasicErrorException, uno::RuntimeException)
5154 {
5155 if ( m_Areas->getCount() > 1 )
5156 {
5157 sal_Int32 nItems = m_Areas->getCount();
5158 for ( sal_Int32 index=1; index <= nItems; ++index )
5159 {
5160 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
5161 xRange->ClearOutline();
5162 }
5163 return;
5164 }
5165 RangeHelper thisRange( mxRange );
5166 uno::Reference< sheet::XSheetOutline > xSheetOutline( thisRange.getSpreadSheet(), uno::UNO_QUERY_THROW );
5167 xSheetOutline->clearOutline();
5168 }
5169
5170 void
5171 ScVbaRange::groupUnGroup( bool bUnGroup ) throw ( script::BasicErrorException, uno::RuntimeException )
5172 {
5173 if ( m_Areas->getCount() > 1 )
5174 DebugHelper::exception(SbERR_METHOD_FAILED, STR_ERRORMESSAGE_APPLIESTOSINGLERANGEONLY);
5175 table::TableOrientation nOrient = table::TableOrientation_ROWS;
5176 if ( mbIsColumns )
5177 nOrient = table::TableOrientation_COLUMNS;
5178 RangeHelper thisRange( mxRange );
5179 table::CellRangeAddress thisAddress = thisRange.getCellRangeAddressable()->getRangeAddress();
5180 uno::Reference< sheet::XSheetOutline > xSheetOutline( thisRange.getSpreadSheet(), uno::UNO_QUERY_THROW );
5181 if ( bUnGroup )
5182 xSheetOutline->ungroup( thisAddress, nOrient );
5183 else
5184 xSheetOutline->group( thisAddress, nOrient );
5185 }
5186
5187 void SAL_CALL
5188 ScVbaRange::Group( ) throw (script::BasicErrorException, uno::RuntimeException)
5189 {
5190 groupUnGroup();
5191 }
5192 void SAL_CALL
5193 ScVbaRange::Ungroup( ) throw (script::BasicErrorException, uno::RuntimeException)
5194 {
5195 groupUnGroup(true);
5196 }
5197
5198 static void lcl_mergeCellsOfRange( const uno::Reference< table::XCellRange >& xCellRange, sal_Bool _bMerge = sal_True ) throw ( uno::RuntimeException )
5199 {
5200 uno::Reference< util::XMergeable > xMergeable( xCellRange, uno::UNO_QUERY_THROW );
5201 xMergeable->merge(_bMerge);
5202 }
5203 void SAL_CALL
5204 ScVbaRange::Merge( const uno::Any& Across ) throw (script::BasicErrorException, uno::RuntimeException)
5205 {
5206 if ( m_Areas->getCount() > 1 )
5207 {
5208 sal_Int32 nItems = m_Areas->getCount();
5209 for ( sal_Int32 index=1; index <= nItems; ++index )
5210 {
5211 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
5212 xRange->Merge(Across);
5213 }
5214 return;
5215 }
5216 uno::Reference< table::XCellRange > oCellRange;
5217 sal_Bool bAcross = false;
5218 Across >>= bAcross;
5219 if ( !bAcross )
5220 lcl_mergeCellsOfRange( mxRange );
5221 else
5222 {
5223 uno::Reference< excel::XRange > oRangeRowsImpl = Rows( uno::Any() );
5224 // #TODO #FIXME this seems incredibly lame, this can't be right
5225 for (sal_Int32 i=1; i <= oRangeRowsImpl->getCount();i++)
5226 {
5227 oRangeRowsImpl->Cells( uno::makeAny( i ), uno::Any() )->Merge( uno::makeAny( false ) );
5228 }
5229 }
5230 }
5231
5232 void SAL_CALL
5233 ScVbaRange::UnMerge( ) throw (script::BasicErrorException, uno::RuntimeException)
5234 {
5235 if ( m_Areas->getCount() > 1 )
5236 {
5237 sal_Int32 nItems = m_Areas->getCount();
5238 for ( sal_Int32 index=1; index <= nItems; ++index )
5239 {
5240 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
5241 xRange->UnMerge();
5242 }
5243 return;
5244 }
5245 lcl_mergeCellsOfRange( mxRange, false);
5246 }
5247
5248 uno::Any SAL_CALL
5249 ScVbaRange::getStyle() throw (uno::RuntimeException)
5250 {
5251 if ( m_Areas->getCount() > 1 )
5252 {
5253 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32( 1 ) ), uno::Any() ), uno::UNO_QUERY_THROW );
5254 return xRange->getStyle();
5255 }
5256 uno::Reference< beans::XPropertySet > xProps( mxRange, uno::UNO_QUERY_THROW );
5257 OUString sStyleName;
5258 xProps->getPropertyValue( CELLSTYLE ) >>= sStyleName;
5259 ScDocShell* pShell = getScDocShell();
5260 uno::Reference< frame::XModel > xModel( pShell->GetModel() );
5261 uno::Reference< excel::XStyle > xStyle = new ScVbaStyle( this, mxContext, sStyleName, xModel );
5262 return uno::makeAny( xStyle );
5263 }
5264 void SAL_CALL
5265 ScVbaRange::setStyle( const uno::Any& _style ) throw (uno::RuntimeException)
5266 {
5267 if ( m_Areas->getCount() > 1 )
5268 {
5269 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32( 1 ) ), uno::Any() ), uno::UNO_QUERY_THROW );
5270 xRange->setStyle( _style );
5271 return;
5272 }
5273 uno::Reference< beans::XPropertySet > xProps( mxRange, uno::UNO_QUERY_THROW );
5274 uno::Reference< excel::XStyle > xStyle;
5275 _style >>= xStyle;
5276 xProps->setPropertyValue( CELLSTYLE, uno::makeAny( xStyle->getName() ) );
5277 }
5278
5279 uno::Reference< excel::XRange >
5280 ScVbaRange::PreviousNext( bool bIsPrevious )
5281 {
5282 ScMarkData markedRange;
5283 ScRange refRange;
5284 RangeHelper thisRange( mxRange );
5285
5286 ScUnoConversion::FillScRange( refRange, thisRange.getCellRangeAddressable()->getRangeAddress());
5287 markedRange. SetMarkArea( refRange );
5288 short nMove = bIsPrevious ? -1 : 1;
5289
5290 SCCOL nNewX = refRange.aStart.Col();
5291 SCROW nNewY = refRange.aStart.Row();
5292 SCTAB nTab = refRange.aStart.Tab();
5293
5294 ScDocument* pDoc = getScDocument();
5295 pDoc->GetNextPos( nNewX,nNewY, nTab, nMove,0, true,true, markedRange );
5296 refRange.aStart.SetCol( nNewX );
5297 refRange.aStart.SetRow( nNewY );
5298 refRange.aStart.SetTab( nTab );
5299 refRange.aEnd.SetCol( nNewX );
5300 refRange.aEnd.SetRow( nNewY );
5301 refRange.aEnd.SetTab( nTab );
5302
5303 uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( getScDocShell() , refRange ) );
5304
5305 return new ScVbaRange( mxParent, mxContext, xRange );
5306 }
5307
5308 uno::Reference< excel::XRange > SAL_CALL
5309 ScVbaRange::Next() throw (script::BasicErrorException, uno::RuntimeException)
5310 {
5311 if ( m_Areas->getCount() > 1 )
5312 {
5313 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32( 1 ) ), uno::Any() ) , uno::UNO_QUERY_THROW );
5314 return xRange->Next();
5315 }
5316 return PreviousNext( false );
5317 }
5318
5319 uno::Reference< excel::XRange > SAL_CALL
5320 ScVbaRange::Previous() throw (script::BasicErrorException, uno::RuntimeException)
5321 {
5322 if ( m_Areas->getCount() > 1 )
5323 {
5324 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny( sal_Int32( 1 ) ), uno::Any() ), uno::UNO_QUERY_THROW );
5325 return xRange->Previous();
5326 }
5327 return PreviousNext( true );
5328 }
5329
5330 uno::Reference< excel::XRange > SAL_CALL
5331 ScVbaRange::SpecialCells( const uno::Any& _oType, const uno::Any& _oValue) throw ( script::BasicErrorException )
5332 {
5333 bool bIsSingleCell = isSingleCellRange();
5334 bool bIsMultiArea = ( m_Areas->getCount() > 1 );
5335 ScVbaRange* pRangeToUse = this;
5336 uno::Reference< excel::XRange > xUsedRange( getWorksheet()->getUsedRange() );
5337 sal_Int32 nType = 0;
5338 if ( !( _oType >>= nType ) )
5339 DebugHelper::exception(SbERR_BAD_PARAMETER, OUString() );
5340 switch(nType)
5341 {
5342 case excel::XlCellType::xlCellTypeSameFormatConditions:
5343 case excel::XlCellType::xlCellTypeAllValidation:
5344 case excel::XlCellType::xlCellTypeSameValidation:
5345 DebugHelper::exception(SbERR_NOT_IMPLEMENTED, OUString());
5346 break;
5347 case excel::XlCellType::xlCellTypeBlanks:
5348 case excel::XlCellType::xlCellTypeComments:
5349 case excel::XlCellType::xlCellTypeConstants:
5350 case excel::XlCellType::xlCellTypeFormulas:
5351 case excel::XlCellType::xlCellTypeVisible:
5352 case excel::XlCellType::xlCellTypeLastCell:
5353 {
5354 if ( bIsMultiArea )
5355 {
5356 // need to process each area, gather the results and
5357 // create a new range from those
5358 std::vector< table::CellRangeAddress > rangeResults;
5359 sal_Int32 nItems = ( m_Areas->getCount() + 1 );
5360 for ( sal_Int32 index=1; index <= nItems; ++index )
5361 {
5362 uno::Reference< excel::XRange > xRange( m_Areas->Item( uno::makeAny(index), uno::Any() ), uno::UNO_QUERY_THROW );
5363 xRange = xRange->SpecialCells( _oType, _oValue);
5364 ScVbaRange* pRange = getImplementation( xRange );
5365 if ( xRange.is() && pRange )
5366 {
5367 sal_Int32 nElems = ( pRange->m_Areas->getCount() + 1 );
5368 for ( sal_Int32 nArea = 1; nArea < nElems; ++nArea )
5369 {
5370 uno::Reference< excel::XRange > xTmpRange( m_Areas->Item( uno::makeAny( nArea ), uno::Any() ), uno::UNO_QUERY_THROW );
5371 RangeHelper rHelper( xTmpRange->getCellRange() );
5372 rangeResults.push_back( rHelper.getCellRangeAddressable()->getRangeAddress() );
5373 }
5374 }
5375 }
5376 ScRangeList aCellRanges;
5377 std::vector< table::CellRangeAddress >::iterator it = rangeResults.begin();
5378 std::vector< table::CellRangeAddress >::iterator it_end = rangeResults.end();
5379 for ( ; it != it_end; ++ it )
5380 {
5381 ScRange refRange;
5382 ScUnoConversion::FillScRange( refRange, *it );
5383 aCellRanges.Append( refRange );
5384 }
5385 // Single range
5386 if ( aCellRanges.size() == 1 )
5387 {
5388 uno::Reference< table::XCellRange > xRange( new ScCellRangeObj( getScDocShell(), *aCellRanges.front() ) );
5389 return new ScVbaRange( mxParent, mxContext, xRange );
5390 }
5391 uno::Reference< sheet::XSheetCellRangeContainer > xRanges( new ScCellRangesObj( getScDocShell(), aCellRanges ) );
5392
5393 return new ScVbaRange( mxParent, mxContext, xRanges );
5394 }
5395 else if ( bIsSingleCell )
5396 {
5397 pRangeToUse = static_cast< ScVbaRange* >( xUsedRange.get() );
5398 }
5399
5400 break;
5401 }
5402 default:
5403 DebugHelper::exception(SbERR_BAD_PARAMETER, OUString() );
5404 break;
5405 }
5406 if ( !pRangeToUse )
5407 DebugHelper::exception(SbERR_METHOD_FAILED, OUString() );
5408 return pRangeToUse->SpecialCellsImpl( nType, _oValue );
5409 }
5410
5411 static sal_Int32 lcl_getFormulaResultFlags(const uno::Any& aType) throw ( script::BasicErrorException )
5412 {
5413 sal_Int32 nType = excel::XlSpecialCellsValue::xlNumbers;
5414 aType >>= nType;
5415 sal_Int32 nRes = sheet::FormulaResult::VALUE;
5416
5417 switch(nType)
5418 {
5419 case excel::XlSpecialCellsValue::xlErrors:
5420 nRes= sheet::FormulaResult::ERROR;
5421 break;
5422 case excel::XlSpecialCellsValue::xlLogical:
5423 //TODO bc93774: ask NN if this is really an appropriate substitute
5424 nRes = sheet::FormulaResult::VALUE;
5425 break;
5426 case excel::XlSpecialCellsValue::xlNumbers:
5427 nRes = sheet::FormulaResult::VALUE;
5428 break;
5429 case excel::XlSpecialCellsValue::xlTextValues:
5430 nRes = sheet::FormulaResult::STRING;
5431 break;
5432 default:
5433 DebugHelper::exception(SbERR_BAD_PARAMETER, OUString() );
5434 }
5435 return nRes;
5436 }
5437
5438 uno::Reference< excel::XRange >
5439 ScVbaRange::SpecialCellsImpl( sal_Int32 nType, const uno::Any& _oValue) throw ( script::BasicErrorException )
5440 {
5441 uno::Reference< excel::XRange > xRange;
5442 try
5443 {
5444 uno::Reference< sheet::XCellRangesQuery > xQuery( mxRange, uno::UNO_QUERY_THROW );
5445 uno::Reference< excel::XRange > oLocRangeImpl;
5446 uno::Reference< sheet::XSheetCellRanges > xLocSheetCellRanges;
5447 switch(nType)
5448 {
5449 case excel::XlCellType::xlCellTypeAllFormatConditions:
5450 case excel::XlCellType::xlCellTypeSameFormatConditions:
5451 case excel::XlCellType::xlCellTypeAllValidation:
5452 case excel::XlCellType::xlCellTypeSameValidation:
5453 // Shouldn't get here ( should be filtered out by
5454 // ScVbaRange::SpecialCells()
5455 DebugHelper::exception(SbERR_NOT_IMPLEMENTED, OUString());
5456 break;
5457 case excel::XlCellType::xlCellTypeBlanks:
5458 xLocSheetCellRanges = xQuery->queryEmptyCells();
5459 break;
5460 case excel::XlCellType::xlCellTypeComments:
5461 xLocSheetCellRanges = xQuery->queryContentCells(sheet::CellFlags::ANNOTATION);
5462 break;
5463 case excel::XlCellType::xlCellTypeConstants:
5464 xLocSheetCellRanges = xQuery->queryContentCells(23);
5465 break;
5466 case excel::XlCellType::xlCellTypeFormulas:
5467 {
5468 sal_Int32 nFormulaResult = lcl_getFormulaResultFlags(_oValue);
5469 xLocSheetCellRanges = xQuery->queryFormulaCells(nFormulaResult);
5470 break;
5471 }
5472 case excel::XlCellType::xlCellTypeLastCell:
5473 xRange = Cells( uno::makeAny( getCount() ), uno::Any() );
5474 case excel::XlCellType::xlCellTypeVisible:
5475 xLocSheetCellRanges = xQuery->queryVisibleCells();
5476 break;
5477 default:
5478 DebugHelper::exception(SbERR_BAD_PARAMETER, OUString() );
5479 break;
5480 }
5481 if (xLocSheetCellRanges.is())
5482 {
5483 xRange = lcl_makeXRangeFromSheetCellRanges( getParent(), mxContext, xLocSheetCellRanges, getScDocShell() );
5484 }
5485 }
5486 catch (uno::Exception& )
5487 {
5488 DebugHelper::exception(SbERR_METHOD_FAILED, STR_ERRORMESSAGE_NOCELLSWEREFOUND);
5489 }
5490 return xRange;
5491 }
5492
5493 void SAL_CALL
5494 ScVbaRange::RemoveSubtotal( ) throw (script::BasicErrorException, uno::RuntimeException)
5495 {
5496 uno::Reference< sheet::XSubTotalCalculatable > xSub( mxRange, uno::UNO_QUERY_THROW );
5497 xSub->removeSubTotals();
5498 }
5499
5500 void SAL_CALL
5501 ScVbaRange::Subtotal( ::sal_Int32 _nGroupBy, ::sal_Int32 _nFunction, const uno::Sequence< ::sal_Int32 >& _nTotalList, const uno::Any& aReplace, const uno::Any& PageBreaks, const uno::Any& /*SummaryBelowData*/ ) throw (script::BasicErrorException, uno::RuntimeException)
5502 {
5503 try
5504 {
5505 sal_Bool bDoReplace = false;
5506 aReplace >>= bDoReplace;
5507 sal_Bool bAddPageBreaks = false;
5508 PageBreaks >>= bAddPageBreaks;
5509
5510 uno::Reference< sheet::XSubTotalCalculatable> xSub(mxRange, uno::UNO_QUERY_THROW );
5511 uno::Reference< sheet::XSubTotalDescriptor > xSubDesc = xSub->createSubTotalDescriptor(sal_True);
5512 uno::Reference< beans::XPropertySet > xSubDescPropertySet( xSubDesc, uno::UNO_QUERY_THROW );
5513 xSubDescPropertySet->setPropertyValue(INSERTPAGEBREAKS, uno::makeAny( bAddPageBreaks));
5514 sal_Int32 nLen = _nTotalList.getLength();
5515 uno::Sequence< sheet::SubTotalColumn > aColumns( nLen );
5516 for (int i = 0; i < nLen; i++)
5517 {
5518 aColumns[i].Column = _nTotalList[i] - 1;
5519 switch (_nFunction)
5520 {
5521 case excel::XlConsolidationFunction::xlAverage:
5522 aColumns[i].Function = sheet::GeneralFunction_AVERAGE;
5523 break;
5524 case excel::XlConsolidationFunction::xlCount:
5525 aColumns[i].Function = sheet::GeneralFunction_COUNT;
5526 break;
5527 case excel::XlConsolidationFunction::xlCountNums:
5528 aColumns[i].Function = sheet::GeneralFunction_COUNTNUMS;
5529 break;
5530 case excel::XlConsolidationFunction::xlMax:
5531 aColumns[i].Function = sheet::GeneralFunction_MAX;
5532 break;
5533 case excel::XlConsolidationFunction::xlMin:
5534 aColumns[i].Function = sheet::GeneralFunction_MIN;
5535 break;
5536 case excel::XlConsolidationFunction::xlProduct:
5537 aColumns[i].Function = sheet::GeneralFunction_PRODUCT;
5538 break;
5539 case excel::XlConsolidationFunction::xlStDev:
5540 aColumns[i].Function = sheet::GeneralFunction_STDEV;
5541 break;
5542 case excel::XlConsolidationFunction::xlStDevP:
5543 aColumns[i].Function = sheet::GeneralFunction_STDEVP;
5544 break;
5545 case excel::XlConsolidationFunction::xlSum:
5546 aColumns[i].Function = sheet::GeneralFunction_SUM;
5547 break;
5548 case excel::XlConsolidationFunction::xlUnknown:
5549 aColumns[i].Function = sheet::GeneralFunction_NONE;
5550 break;
5551 case excel::XlConsolidationFunction::xlVar:
5552 aColumns[i].Function = sheet::GeneralFunction_VAR;
5553 break;
5554 case excel::XlConsolidationFunction::xlVarP:
5555 aColumns[i].Function = sheet::GeneralFunction_VARP;
5556 break;
5557 default:
5558 DebugHelper::exception(SbERR_BAD_PARAMETER, OUString()) ;
5559 return;
5560 }
5561 }
5562 xSubDesc->addNew(aColumns, _nGroupBy - 1);
5563 xSub->applySubTotals(xSubDesc, bDoReplace);
5564 }
5565 catch (uno::Exception& )
5566 {
5567 DebugHelper::exception(SbERR_METHOD_FAILED, OUString());
5568 }
5569 }
5570
5571 OUString
5572 ScVbaRange::getServiceImplName()
5573 {
5574 return OUString("ScVbaRange");
5575 }
5576
5577 uno::Sequence< OUString >
5578 ScVbaRange::getServiceNames()
5579 {
5580 static uno::Sequence< OUString > aServiceNames;
5581 if ( aServiceNames.getLength() == 0 )
5582 {
5583 aServiceNames.realloc( 1 );
5584 aServiceNames[ 0 ] = OUString( "ooo.vba.excel.Range" );
5585 }
5586 return aServiceNames;
5587 }
5588
5589 sal_Bool SAL_CALL
5590 ScVbaRange::hasError() throw (uno::RuntimeException)
5591 {
5592 double dResult = false;
5593 uno::Reference< excel::XApplication > xApplication( Application(), uno::UNO_QUERY_THROW );
5594 uno::Reference< script::XInvocation > xInvoc( xApplication->WorksheetFunction(), uno::UNO_QUERY_THROW );
5595
5596 static OUString FunctionName( "IsError" );
5597 uno::Sequence< uno::Any > Params(1);
5598 uno::Reference< excel::XRange > aRange( this );
5599 Params[0] = uno::makeAny( aRange );
5600 uno::Sequence< sal_Int16 > OutParamIndex;
5601 uno::Sequence< uno::Any > OutParam;
5602 xInvoc->invoke( FunctionName, Params, OutParamIndex, OutParam ) >>= dResult;
5603 if ( dResult > 0.0 )
5604 return sal_True;
5605 return false;
5606 }
5607
5608 namespace range
5609 {
5610 namespace sdecl = comphelper::service_decl;
5611 sdecl::vba_service_class_<ScVbaRange, sdecl::with_args<true> > serviceImpl;
5612 extern sdecl::ServiceDecl const serviceDecl(
5613 serviceImpl,
5614 "SvVbaRange",
5615 "ooo.vba.excel.Range" );
5616 }
5617
5618 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE