Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 : #include "vbaformat.hxx"
20 : #include <ooo/vba/excel/XStyle.hpp>
21 : #include <ooo/vba/excel/XlVAlign.hpp>
22 : #include <ooo/vba/excel/XlHAlign.hpp>
23 : #include <ooo/vba/excel/XlOrientation.hpp>
24 : #include <ooo/vba/excel/Constants.hpp>
25 : #include <ooo/vba/excel/XRange.hpp>
26 : #include <com/sun/star/table/CellVertJustify2.hpp>
27 : #include <com/sun/star/table/CellHoriJustify.hpp>
28 : #include <com/sun/star/table/CellOrientation.hpp>
29 : #include <com/sun/star/table/XCellRange.hpp>
30 : #include <com/sun/star/text/WritingMode.hpp>
31 : #include <com/sun/star/util/CellProtection.hpp>
32 :
33 : #include <rtl/math.hxx>
34 :
35 : #include "excelvbahelper.hxx"
36 : #include "vbaborders.hxx"
37 : #include "vbapalette.hxx"
38 : #include "vbafont.hxx"
39 : #include "vbainterior.hxx"
40 :
41 : #include <unonames.hxx>
42 : #include <cellsuno.hxx>
43 : #include <scitems.hxx>
44 : #include <attrib.hxx>
45 :
46 : using namespace ::ooo::vba;
47 : using namespace ::com::sun::star;
48 :
49 : #define FORMATSTRING "FormatString"
50 : #define LOCALE "Locale"
51 :
52 : template< typename Ifc1 >
53 3589 : ScVbaFormat< Ifc1 >::ScVbaFormat( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext > & xContext, const uno::Reference< beans::XPropertySet >& _xPropertySet, const uno::Reference< frame::XModel >& xModel, bool bCheckAmbiguoity ) throw ( script::BasicErrorException ) : ScVbaFormat_BASE( xParent, xContext ), m_aDefaultLocale( OUString("en"), OUString( "US"), OUString() ), mxPropertySet( _xPropertySet ), mxModel( xModel ), mbCheckAmbiguoity( bCheckAmbiguoity ), mbAddIndent( false )
54 : {
55 : try
56 : {
57 3589 : if ( !mxModel.is() )
58 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString( "XModel Interface could not be retrieved") );
59 : // mxServiceInfo is unused,
60 : // mxNumberFormatsSupplier is initialized when needed in initializeNumberFormats.
61 : }
62 0 : catch (const uno::Exception& )
63 : {
64 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString() );
65 : }
66 3589 : }
67 :
68 : template< typename Ifc1 >
69 : void SAL_CALL
70 9 : ScVbaFormat<Ifc1>::setVerticalAlignment( const uno::Any& _oAlignment) throw (script::BasicErrorException, uno::RuntimeException)
71 : {
72 : try
73 : {
74 9 : uno::Any aVal;
75 9 : sal_Int32 nAlignment = 0;
76 9 : if ( !(_oAlignment >>= nAlignment ))
77 0 : throw uno::RuntimeException();
78 9 : switch (nAlignment)
79 : {
80 : case excel::XlVAlign::xlVAlignBottom :
81 2 : aVal = uno::makeAny( table::CellVertJustify2::BOTTOM );
82 2 : break;
83 : case excel::XlVAlign::xlVAlignCenter :
84 2 : aVal = uno::makeAny( table::CellVertJustify2::CENTER );
85 2 : break;
86 : case excel::XlVAlign::xlVAlignDistributed:
87 : case excel::XlVAlign::xlVAlignJustify:
88 2 : aVal = uno::makeAny( table::CellVertJustify2::STANDARD );
89 2 : break;
90 :
91 : case excel::XlVAlign::xlVAlignTop:
92 3 : aVal = uno::makeAny( table::CellVertJustify2::TOP);
93 3 : break;
94 : default:
95 0 : aVal = uno::makeAny( table::CellVertJustify2::STANDARD );
96 0 : break;
97 : }
98 9 : mxPropertySet->setPropertyValue( OUString( SC_UNONAME_CELLVJUS ), aVal );
99 : }
100 0 : catch (const uno::Exception&)
101 : {
102 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
103 : }
104 9 : }
105 :
106 : template< typename Ifc1 >
107 : uno::Any SAL_CALL
108 42 : ScVbaFormat<Ifc1>::getVerticalAlignment( ) throw (script::BasicErrorException, uno::RuntimeException)
109 : {
110 42 : uno::Any aResult = aNULL();
111 : try
112 : {
113 42 : if (!isAmbiguous( OUString( SC_UNONAME_CELLVJUS ) ) )
114 : {
115 41 : sal_Int32 aAPIAlignment = table::CellVertJustify2::STANDARD;
116 41 : mxPropertySet->getPropertyValue( OUString( SC_UNONAME_CELLVJUS ) ) >>= aAPIAlignment;
117 41 : switch( aAPIAlignment )
118 : {
119 : case table::CellVertJustify2::BOTTOM:
120 11 : aResult = uno::makeAny( excel::XlVAlign::xlVAlignBottom );
121 11 : break;
122 : case table::CellVertJustify2::CENTER:
123 11 : aResult = uno::makeAny( excel::XlVAlign::xlVAlignCenter );
124 11 : break;
125 : case table::CellVertJustify2::STANDARD:
126 8 : aResult = uno::makeAny( excel::XlVAlign::xlVAlignBottom );
127 8 : break;
128 : case table::CellVertJustify2::TOP:
129 11 : aResult = uno::makeAny( excel::XlVAlign::xlVAlignTop );
130 11 : break;
131 : default:
132 0 : break;
133 : }
134 : }
135 : }
136 0 : catch (const uno::Exception& )
137 : {
138 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
139 : }
140 42 : return aResult;
141 : }
142 :
143 : template< typename Ifc1 >
144 : void SAL_CALL
145 11 : ScVbaFormat<Ifc1>::setHorizontalAlignment( const uno::Any& HorizontalAlignment ) throw (script::BasicErrorException, uno::RuntimeException)
146 : {
147 : try
148 : {
149 11 : uno::Any aVal;
150 11 : sal_Int32 nAlignment = 0;
151 11 : if ( !( HorizontalAlignment >>= nAlignment ) )
152 0 : throw uno::RuntimeException();
153 11 : switch ( nAlignment )
154 : {
155 : case excel::XlHAlign::xlHAlignJustify:
156 2 : aVal = uno::makeAny( table::CellHoriJustify_BLOCK);
157 2 : break;
158 : case excel::XlHAlign::xlHAlignCenter:
159 2 : aVal = uno::makeAny( table::CellHoriJustify_CENTER );
160 2 : break;
161 : case excel::XlHAlign::xlHAlignDistributed:
162 0 : aVal = uno::makeAny( table::CellHoriJustify_BLOCK);
163 0 : break;
164 : case excel::XlHAlign::xlHAlignLeft:
165 4 : aVal = uno::makeAny( table::CellHoriJustify_LEFT);
166 4 : break;
167 : case excel::XlHAlign::xlHAlignRight:
168 3 : aVal = uno::makeAny( table::CellHoriJustify_RIGHT);
169 3 : break;
170 : }
171 : // #FIXME what about the default case above?
172 : // shouldn't need the test below
173 11 : if ( aVal.hasValue() )
174 11 : mxPropertySet->setPropertyValue( OUString( SC_UNONAME_CELLHJUS ), aVal );
175 : }
176 0 : catch (const uno::Exception& )
177 : {
178 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString() );
179 : }
180 :
181 11 : }
182 :
183 : template< typename Ifc1 >
184 : uno::Any SAL_CALL
185 49 : ScVbaFormat<Ifc1>::getHorizontalAlignment( ) throw (script::BasicErrorException, uno::RuntimeException)
186 : {
187 49 : uno::Any NRetAlignment = aNULL();
188 : try
189 : {
190 49 : OUString sHoriJust( SC_UNONAME_CELLHJUS );
191 49 : if (!isAmbiguous(sHoriJust))
192 : {
193 48 : table::CellHoriJustify aAPIAlignment = table::CellHoriJustify_BLOCK;
194 :
195 48 : if ( mxPropertySet->getPropertyValue(sHoriJust) >>= aAPIAlignment )
196 : {
197 48 : switch( aAPIAlignment )
198 : {
199 : case table::CellHoriJustify_BLOCK:
200 11 : NRetAlignment = uno::makeAny( excel::XlHAlign::xlHAlignJustify );
201 11 : break;
202 : case table::CellHoriJustify_CENTER:
203 11 : NRetAlignment = uno::makeAny( excel::XlHAlign::xlHAlignCenter );
204 11 : break;
205 : case table::CellHoriJustify_LEFT:
206 15 : NRetAlignment = uno::makeAny( excel::XlHAlign::xlHAlignLeft );
207 15 : break;
208 : case table::CellHoriJustify_RIGHT:
209 11 : NRetAlignment = uno::makeAny( excel::XlHAlign::xlHAlignRight );
210 11 : break;
211 : default: // handle those other cases with a NULL return
212 0 : break;
213 : }
214 : }
215 49 : }
216 : }
217 0 : catch (const uno::Exception& )
218 : {
219 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString() );
220 : }
221 49 : return NRetAlignment;
222 : }
223 :
224 : template< typename Ifc1 >
225 : void SAL_CALL
226 4 : ScVbaFormat<Ifc1>::setOrientation( const uno::Any& _aOrientation ) throw (script::BasicErrorException, uno::RuntimeException)
227 : {
228 : try
229 : {
230 4 : sal_Int32 nOrientation = 0;
231 4 : if ( !( _aOrientation >>= nOrientation ) )
232 0 : throw uno::RuntimeException();
233 4 : uno::Any aVal;
234 4 : switch( nOrientation )
235 : {
236 : case excel::XlOrientation::xlDownward:
237 1 : aVal = uno::makeAny( table::CellOrientation_TOPBOTTOM);
238 1 : break;
239 : case excel::XlOrientation::xlHorizontal:
240 1 : aVal = uno::makeAny( table::CellOrientation_STANDARD );
241 1 : mxPropertySet->setPropertyValue( OUString( SC_UNONAME_ROTANG ), uno::makeAny( sal_Int32(0) ) );
242 1 : break;
243 : case excel::XlOrientation::xlUpward:
244 1 : aVal = uno::makeAny( table::CellOrientation_BOTTOMTOP);
245 1 : break;
246 : case excel::XlOrientation::xlVertical:
247 1 : aVal = uno::makeAny( table::CellOrientation_STACKED);
248 1 : break;
249 : }
250 : // #FIXME what about the default case above?
251 : // shouldn't need the test below
252 4 : if ( aVal.hasValue() )
253 4 : mxPropertySet->setPropertyValue( OUString( SC_UNONAME_CELLORI ), aVal );
254 :
255 : }
256 0 : catch (const uno::Exception& )
257 : {
258 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString() );
259 : }
260 4 : }
261 : template< typename Ifc1 >
262 : uno::Any SAL_CALL
263 40 : ScVbaFormat<Ifc1>::getOrientation( ) throw (script::BasicErrorException, uno::RuntimeException)
264 : {
265 40 : uno::Any NRetOrientation = aNULL();
266 : try
267 : {
268 40 : if (!isAmbiguous(OUString( SC_UNONAME_CELLORI )))
269 : {
270 40 : table::CellOrientation aOrientation = table::CellOrientation_STANDARD;
271 40 : if ( !( mxPropertySet->getPropertyValue( OUString( SC_UNONAME_CELLORI ) ) >>= aOrientation ) )
272 0 : throw uno::RuntimeException();
273 :
274 40 : switch(aOrientation)
275 : {
276 : case table::CellOrientation_STANDARD:
277 13 : NRetOrientation = uno::makeAny( excel::XlOrientation::xlHorizontal );
278 13 : break;
279 : case table::CellOrientation_BOTTOMTOP:
280 9 : NRetOrientation = uno::makeAny( excel::XlOrientation::xlUpward );
281 9 : break;
282 : case table::CellOrientation_TOPBOTTOM:
283 9 : NRetOrientation = uno::makeAny( excel::XlOrientation::xlDownward );
284 9 : break;
285 : case table::CellOrientation_STACKED:
286 9 : NRetOrientation = uno::makeAny( excel::XlOrientation::xlVertical );
287 9 : break;
288 : default:
289 0 : NRetOrientation = uno::makeAny( excel::XlOrientation::xlHorizontal );
290 : }
291 : }
292 : }
293 0 : catch (const uno::Exception& )
294 : {
295 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
296 : }
297 40 : return NRetOrientation;
298 : }
299 :
300 : template< typename Ifc1 >
301 : void SAL_CALL
302 0 : ScVbaFormat<Ifc1>::setWrapText( const uno::Any& _aWrapText ) throw (script::BasicErrorException, uno::RuntimeException)
303 : {
304 : try
305 : {
306 0 : mxPropertySet->setPropertyValue( OUString( SC_UNONAME_WRAP ), _aWrapText);
307 : }
308 0 : catch (const uno::Exception& )
309 : {
310 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString() );
311 : }
312 0 : }
313 :
314 : template< typename Ifc1 >
315 : uno::Any SAL_CALL
316 0 : ScVbaFormat<Ifc1>::getWrapText( ) throw (script::BasicErrorException, uno::RuntimeException)
317 : {
318 0 : uno::Any aWrap = aNULL();
319 : try
320 : {
321 0 : OUString aPropName( SC_UNONAME_WRAP );
322 0 : if (!isAmbiguous( aPropName ))
323 : {
324 0 : aWrap = mxPropertySet->getPropertyValue(aPropName);
325 0 : }
326 : }
327 0 : catch (const uno::Exception&)
328 : {
329 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString() );
330 : }
331 0 : return aWrap;
332 : }
333 :
334 : template< typename Ifc1 >
335 : uno::Any SAL_CALL
336 0 : ScVbaFormat<Ifc1>::Borders( const uno::Any& Index ) throw (script::BasicErrorException, uno::RuntimeException )
337 : {
338 0 : ScVbaPalette aPalette( excel::getDocShell( mxModel ) );
339 0 : uno::Reference< XCollection > xColl = new ScVbaBorders( thisHelperIface(), ScVbaFormat_BASE::mxContext, uno::Reference< table::XCellRange >( mxPropertySet, uno::UNO_QUERY_THROW ), aPalette );
340 :
341 0 : if ( Index.hasValue() )
342 : {
343 0 : return xColl->Item( Index, uno::Any() );
344 : }
345 0 : return uno::makeAny( xColl );
346 : }
347 :
348 : template< typename Ifc1 >
349 : uno::Reference< excel::XFont > SAL_CALL
350 0 : ScVbaFormat<Ifc1>::Font( ) throw (script::BasicErrorException, uno::RuntimeException)
351 : {
352 0 : ScVbaPalette aPalette( excel::getDocShell( mxModel ) );
353 0 : return new ScVbaFont( thisHelperIface(), ScVbaFormat_BASE::mxContext, aPalette, mxPropertySet );
354 : }
355 :
356 : template< typename Ifc1 >
357 : uno::Reference< excel::XInterior > SAL_CALL
358 0 : ScVbaFormat<Ifc1>::Interior( ) throw (script::BasicErrorException, uno::RuntimeException)
359 : {
360 0 : return new ScVbaInterior( thisHelperIface(), ScVbaFormat_BASE::mxContext, mxPropertySet );
361 : }
362 :
363 : template< typename Ifc1 >
364 : uno::Any SAL_CALL
365 0 : ScVbaFormat<Ifc1>::getNumberFormatLocal( ) throw (script::BasicErrorException, uno::RuntimeException)
366 : {
367 0 : uno::Any aRet = uno::makeAny( OUString() );
368 : try
369 : {
370 0 : OUString sPropName( SC_UNO_DP_NUMBERFO );
371 0 : if (!isAmbiguous( sPropName ))
372 : {
373 :
374 0 : initializeNumberFormats();
375 :
376 0 : sal_Int32 nFormat = 0;
377 0 : if ( ! (mxPropertySet->getPropertyValue( sPropName ) >>= nFormat ) )
378 0 : throw uno::RuntimeException();
379 :
380 0 : OUString sFormat;
381 0 : xNumberFormats->getByKey(nFormat)->getPropertyValue( OUString( FORMATSTRING )) >>= sFormat;
382 0 : aRet = uno::makeAny( sFormat.toAsciiLowerCase() );
383 :
384 0 : }
385 : }
386 0 : catch (const uno::Exception&)
387 : {
388 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
389 : }
390 0 : return aRet;
391 :
392 : }
393 :
394 : template< typename Ifc1 >
395 : void SAL_CALL
396 0 : ScVbaFormat<Ifc1>::setNumberFormatLocal( const uno::Any& _oLocalFormatString ) throw (script::BasicErrorException, uno::RuntimeException)
397 : {
398 : try
399 : {
400 0 : OUString sLocalFormatString;
401 0 : sal_Int32 nFormat = -1;
402 0 : OUString sNumFormat( SC_UNO_DP_NUMBERFO );
403 0 : if ( !(_oLocalFormatString >>= sLocalFormatString )
404 0 : || !( mxPropertySet->getPropertyValue(sNumFormat) >>= nFormat ) )
405 0 : throw uno::RuntimeException();
406 :
407 0 : sLocalFormatString = sLocalFormatString.toAsciiUpperCase();
408 0 : initializeNumberFormats();
409 0 : lang::Locale aRangeLocale;
410 0 : xNumberFormats->getByKey(nFormat)->getPropertyValue( OUString( LOCALE ) ) >>= aRangeLocale;
411 0 : sal_Int32 nNewFormat = xNumberFormats->queryKey(sLocalFormatString, aRangeLocale, sal_True);
412 :
413 0 : if (nNewFormat == -1)
414 0 : nNewFormat = xNumberFormats->addNew(sLocalFormatString, aRangeLocale);
415 0 : mxPropertySet->setPropertyValue(sNumFormat, uno::makeAny( nNewFormat ));
416 : }
417 0 : catch (const uno::Exception& )
418 : {
419 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString() );
420 : }
421 0 : }
422 :
423 : template< typename Ifc1 >
424 : void SAL_CALL
425 0 : ScVbaFormat<Ifc1>::setNumberFormat( const uno::Any& _oFormatString ) throw (script::BasicErrorException, uno::RuntimeException)
426 : {
427 : try
428 : {
429 0 : OUString sFormatString;
430 0 : if ( !( _oFormatString >>= sFormatString ) )
431 0 : throw uno::RuntimeException();
432 :
433 0 : sFormatString = sFormatString.toAsciiUpperCase();
434 :
435 0 : lang::Locale aDefaultLocale = m_aDefaultLocale;
436 0 : initializeNumberFormats();
437 0 : sal_Int32 nFormat = xNumberFormats->queryKey(sFormatString, aDefaultLocale, sal_True);
438 :
439 0 : if (nFormat == -1)
440 0 : nFormat = xNumberFormats->addNew(sFormatString, aDefaultLocale);
441 :
442 0 : lang::Locale aRangeLocale;
443 0 : xNumberFormats->getByKey(nFormat)->getPropertyValue( OUString( LOCALE ) ) >>= aRangeLocale;
444 0 : sal_Int32 nNewFormat = xNumberFormatTypes->getFormatForLocale(nFormat, aRangeLocale);
445 0 : mxPropertySet->setPropertyValue( OUString( SC_UNO_DP_NUMBERFO ), uno::makeAny( nNewFormat));
446 : }
447 0 : catch (const uno::Exception& )
448 : {
449 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
450 : }
451 :
452 0 : }
453 :
454 : template< typename Ifc1 >
455 : void SAL_CALL
456 2 : ScVbaFormat<Ifc1>::setIndentLevel( const uno::Any& _aLevel ) throw (script::BasicErrorException, uno::RuntimeException)
457 : {
458 : try
459 : {
460 2 : sal_Int32 nLevel = 0;
461 2 : if ( !(_aLevel >>= nLevel ) )
462 0 : throw uno::RuntimeException();
463 2 : table::CellHoriJustify aAPIAlignment = table::CellHoriJustify_STANDARD;
464 :
465 2 : OUString sHoriJust( SC_UNONAME_CELLHJUS );
466 2 : if ( !( mxPropertySet->getPropertyValue(sHoriJust) >>= aAPIAlignment ) )
467 0 : throw uno::RuntimeException();
468 2 : if (aAPIAlignment == table::CellHoriJustify_STANDARD)
469 0 : mxPropertySet->setPropertyValue( sHoriJust, uno::makeAny( table::CellHoriJustify_LEFT) ) ;
470 2 : mxPropertySet->setPropertyValue( OUString( SC_UNONAME_PINDENT ), uno::makeAny( sal_Int16(nLevel * 352.8) ) );
471 : }
472 0 : catch (const uno::Exception&)
473 : {
474 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
475 : }
476 2 : }
477 :
478 : template< typename Ifc1 >
479 : uno::Any SAL_CALL
480 15 : ScVbaFormat<Ifc1>::getIndentLevel( ) throw (script::BasicErrorException, uno::RuntimeException)
481 : {
482 15 : uno::Any NRetIndentLevel = aNULL();
483 : try
484 : {
485 15 : OUString sParaIndent( SC_UNONAME_PINDENT );
486 15 : if (!isAmbiguous(sParaIndent))
487 : {
488 15 : sal_Int16 IndentLevel = 0;
489 15 : if ( ( mxPropertySet->getPropertyValue(sParaIndent) >>= IndentLevel ) )
490 15 : NRetIndentLevel = uno::makeAny( sal_Int32( rtl::math::round(static_cast<double>( IndentLevel ) / 352.8)) );
491 : else
492 0 : NRetIndentLevel = uno::makeAny( sal_Int32(0) );
493 15 : }
494 : }
495 0 : catch (const uno::Exception&)
496 : {
497 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
498 : }
499 15 : return NRetIndentLevel;
500 : }
501 :
502 : template< typename Ifc1 >
503 : void SAL_CALL
504 0 : ScVbaFormat<Ifc1>::setLocked( const uno::Any& _aLocked ) throw (script::BasicErrorException, uno::RuntimeException)
505 : {
506 : try
507 : {
508 0 : bool bIsLocked = false;
509 0 : if ( !( _aLocked >>= bIsLocked ) )
510 0 : throw uno::RuntimeException();
511 0 : util::CellProtection aCellProtection;
512 0 : OUString sCellProt( SC_UNONAME_CELLPRO );
513 0 : mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
514 0 : aCellProtection.IsLocked = bIsLocked;
515 0 : mxPropertySet->setPropertyValue(sCellProt, uno::makeAny( aCellProtection ) );
516 : }
517 0 : catch (const uno::Exception&)
518 : {
519 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString() );
520 : }
521 0 : }
522 :
523 : template< typename Ifc1 >
524 : void SAL_CALL
525 0 : ScVbaFormat<Ifc1>::setFormulaHidden( const uno::Any& FormulaHidden ) throw (script::BasicErrorException, uno::RuntimeException)
526 : {
527 : try
528 : {
529 0 : bool bIsFormulaHidden = false;
530 0 : FormulaHidden >>= bIsFormulaHidden;
531 0 : util::CellProtection aCellProtection;
532 0 : OUString sCellProt( SC_UNONAME_CELLPRO );
533 0 : mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
534 0 : aCellProtection.IsFormulaHidden = bIsFormulaHidden;
535 0 : mxPropertySet->setPropertyValue(sCellProt,uno::makeAny(aCellProtection));
536 : }
537 0 : catch (const uno::Exception&)
538 : {
539 0 : DebugHelper::basicexception( SbERR_METHOD_FAILED, OUString() );
540 : }
541 0 : }
542 :
543 : template< typename Ifc1 >
544 : uno::Any SAL_CALL
545 0 : ScVbaFormat<Ifc1>::getLocked( ) throw (script::BasicErrorException, uno::RuntimeException)
546 : {
547 0 : uno::Any aCellProtection = aNULL();
548 : try
549 : {
550 0 : OUString sCellProt( SC_UNONAME_CELLPRO );
551 :
552 0 : if (!isAmbiguous(sCellProt))
553 : {
554 0 : SfxItemSet* pDataSet = getCurrentDataSet();
555 0 : if ( pDataSet )
556 : {
557 0 : const ScProtectionAttr& rProtAttr = static_cast<const ScProtectionAttr &>( pDataSet->Get(ATTR_PROTECTION, true) );
558 0 : SfxItemState eState = pDataSet->GetItemState(ATTR_PROTECTION, true, NULL);
559 0 : if(eState != SfxItemState::DONTCARE)
560 0 : aCellProtection = uno::makeAny(rProtAttr.GetProtection());
561 : }
562 : else // fallback to propertyset
563 : {
564 0 : util::CellProtection cellProtection;
565 0 : mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
566 0 : aCellProtection = uno::makeAny( cellProtection.IsLocked );
567 : }
568 0 : }
569 : }
570 0 : catch (const uno::Exception&)
571 : {
572 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
573 : }
574 0 : return aCellProtection;
575 : }
576 :
577 : template< typename Ifc1 >
578 : uno::Any SAL_CALL
579 0 : ScVbaFormat<Ifc1>::getFormulaHidden( ) throw (script::BasicErrorException, uno::RuntimeException)
580 : {
581 0 : uno::Any aBoolRet = aNULL();
582 : try
583 : {
584 0 : OUString sCellProt( SC_UNONAME_CELLPRO );
585 0 : if (!isAmbiguous(sCellProt))
586 : {
587 0 : SfxItemSet* pDataSet = getCurrentDataSet();
588 0 : if ( pDataSet )
589 : {
590 0 : const ScProtectionAttr& rProtAttr = static_cast<const ScProtectionAttr &>( pDataSet->Get(ATTR_PROTECTION, true) );
591 0 : SfxItemState eState = pDataSet->GetItemState(ATTR_PROTECTION, true, NULL);
592 0 : if(eState != SfxItemState::DONTCARE)
593 0 : aBoolRet = uno::makeAny(rProtAttr.GetHideFormula());
594 : }
595 : else
596 : {
597 0 : util::CellProtection aCellProtection;
598 0 : mxPropertySet->getPropertyValue(sCellProt) >>= aCellProtection;
599 0 : aBoolRet = uno::makeAny( aCellProtection.IsFormulaHidden );
600 : }
601 0 : }
602 : }
603 0 : catch (const uno::Exception&)
604 : {
605 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
606 : }
607 0 : return aBoolRet;
608 : }
609 :
610 : template< typename Ifc1 >
611 : void SAL_CALL
612 0 : ScVbaFormat<Ifc1>::setShrinkToFit( const uno::Any& ShrinkToFit ) throw (script::BasicErrorException, uno::RuntimeException)
613 : {
614 : try
615 : {
616 0 : mxPropertySet->setPropertyValue(OUString( SC_UNONAME_SHRINK_TO_FIT ), ShrinkToFit);
617 : }
618 0 : catch (const uno::Exception& )
619 : {
620 0 : DebugHelper::basicexception(SbERR_NOT_IMPLEMENTED, OUString() );
621 : }
622 :
623 0 : }
624 :
625 : template< typename Ifc1 >
626 : uno::Any SAL_CALL
627 0 : ScVbaFormat<Ifc1>::getShrinkToFit( ) throw (script::BasicErrorException, uno::RuntimeException)
628 : {
629 0 : uno::Any aRet = aNULL();
630 : try
631 : {
632 0 : OUString sShrinkToFit( SC_UNONAME_SHRINK_TO_FIT );
633 0 : if (!isAmbiguous(sShrinkToFit))
634 0 : aRet = mxPropertySet->getPropertyValue(sShrinkToFit);
635 : }
636 0 : catch (const uno::Exception& )
637 : {
638 0 : DebugHelper::basicexception(SbERR_NOT_IMPLEMENTED, OUString());
639 : }
640 0 : return aRet;
641 : }
642 :
643 : template< typename Ifc1 >
644 : void SAL_CALL
645 0 : ScVbaFormat<Ifc1>::setReadingOrder( const uno::Any& ReadingOrder ) throw (script::BasicErrorException, uno::RuntimeException)
646 : {
647 : try
648 : {
649 0 : sal_Int32 nReadingOrder = 0;
650 0 : if ( !(ReadingOrder >>= nReadingOrder ))
651 0 : throw uno::RuntimeException();
652 0 : uno::Any aVal;
653 0 : switch(nReadingOrder)
654 : {
655 : case excel::Constants::xlLTR:
656 0 : aVal = uno::makeAny( text::WritingMode_LR_TB );
657 0 : break;
658 : case excel::Constants::xlRTL:
659 0 : aVal = uno::makeAny( text::WritingMode_RL_TB );
660 0 : break;
661 : case excel::Constants::xlContext:
662 0 : DebugHelper::basicexception(SbERR_NOT_IMPLEMENTED, OUString());
663 0 : break;
664 : default:
665 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
666 : }
667 0 : mxPropertySet->setPropertyValue( OUString( SC_UNONAME_WRITING ), aVal );
668 : }
669 0 : catch (const uno::Exception& )
670 : {
671 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
672 : }
673 :
674 0 : }
675 :
676 : template< typename Ifc1 >
677 : uno::Any SAL_CALL
678 0 : ScVbaFormat<Ifc1>::getReadingOrder( ) throw (script::BasicErrorException, uno::RuntimeException)
679 : {
680 0 : uno::Any NRetReadingOrder = aNULL();
681 : try
682 : {
683 0 : OUString sWritingMode( SC_UNONAME_WRITING );
684 0 : if (!isAmbiguous(sWritingMode))
685 : {
686 0 : text::WritingMode aWritingMode = text::WritingMode_LR_TB;
687 0 : if ( ( mxPropertySet->getPropertyValue(sWritingMode) ) >>= aWritingMode )
688 0 : switch (aWritingMode){
689 : case text::WritingMode_LR_TB:
690 0 : NRetReadingOrder = uno::makeAny(excel::Constants::xlLTR);
691 0 : break;
692 : case text::WritingMode_RL_TB:
693 0 : NRetReadingOrder = uno::makeAny(excel::Constants::xlRTL);
694 0 : break;
695 : default:
696 0 : NRetReadingOrder = uno::makeAny(excel::Constants::xlRTL);
697 : }
698 0 : }
699 : }
700 0 : catch (const uno::Exception& )
701 : {
702 0 : DebugHelper::basicexception(SbERR_NOT_IMPLEMENTED, OUString());
703 : }
704 0 : return NRetReadingOrder;
705 :
706 : }
707 :
708 : template< typename Ifc1 >
709 : uno::Any SAL_CALL
710 0 : ScVbaFormat< Ifc1 >::getNumberFormat( ) throw (script::BasicErrorException, uno::RuntimeException)
711 : {
712 0 : uno::Any aFormat = aNULL();
713 : try
714 : {
715 0 : sal_Int32 nFormat = -1;
716 0 : OUString sNumFormat( SC_UNO_DP_NUMBERFO );
717 0 : if (!isAmbiguous(sNumFormat) &&
718 0 : ( mxPropertySet->getPropertyValue(sNumFormat) >>= nFormat) )
719 : {
720 0 : initializeNumberFormats();
721 :
722 0 : sal_Int32 nNewFormat = xNumberFormatTypes->getFormatForLocale(nFormat, getDefaultLocale() );
723 0 : OUString sFormat;
724 0 : xNumberFormats->getByKey(nNewFormat)->getPropertyValue( OUString( FORMATSTRING )) >>= sFormat;
725 0 : aFormat = uno::makeAny( sFormat );
726 0 : }
727 : }
728 0 : catch (const uno::Exception& )
729 : {
730 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
731 : }
732 0 : return aFormat;
733 : }
734 :
735 : template< typename Ifc1 >
736 : bool
737 146 : ScVbaFormat<Ifc1>::isAmbiguous(const OUString& _sPropertyName) throw ( script::BasicErrorException )
738 : {
739 146 : bool bResult = false;
740 : try
741 : {
742 146 : if (mbCheckAmbiguoity)
743 146 : bResult = ( getXPropertyState()->getPropertyState(_sPropertyName) == beans::PropertyState_AMBIGUOUS_VALUE );
744 : }
745 0 : catch (const uno::Exception& )
746 : {
747 0 : DebugHelper::basicexception(SbERR_METHOD_FAILED, OUString());
748 : }
749 146 : return bResult;
750 : }
751 :
752 : template< typename Ifc1 >
753 : void
754 0 : ScVbaFormat<Ifc1>::initializeNumberFormats() throw ( script::BasicErrorException, uno::RuntimeException )
755 : {
756 0 : if ( !xNumberFormats.is() )
757 : {
758 0 : mxNumberFormatsSupplier.set( mxModel, uno::UNO_QUERY_THROW );
759 0 : xNumberFormats = mxNumberFormatsSupplier->getNumberFormats();
760 0 : xNumberFormatTypes.set( xNumberFormats, uno::UNO_QUERY ); // _THROW?
761 : }
762 0 : }
763 :
764 : template< typename Ifc1 >
765 : uno::Reference< beans::XPropertyState >
766 146 : ScVbaFormat<Ifc1>::getXPropertyState() throw ( uno::RuntimeException )
767 : {
768 146 : if ( !xPropertyState.is() )
769 74 : xPropertyState.set( mxPropertySet, uno::UNO_QUERY_THROW );
770 146 : return xPropertyState;
771 : }
772 :
773 : template< typename Ifc1 >
774 : OUString
775 0 : ScVbaFormat<Ifc1>::getServiceImplName()
776 : {
777 0 : return OUString("ScVbaFormat");
778 : }
779 :
780 : template< typename Ifc1 >
781 : uno::Sequence< OUString >
782 0 : ScVbaFormat<Ifc1>::getServiceNames()
783 : {
784 0 : static uno::Sequence< OUString > aServiceNames;
785 0 : if ( aServiceNames.getLength() == 0 )
786 : {
787 0 : aServiceNames.realloc( 1 );
788 0 : aServiceNames[ 0 ] = "ooo.vba.excel.Format";
789 : }
790 0 : return aServiceNames;
791 : }
792 :
793 : template< typename Ifc1 >
794 : ScCellRangesBase*
795 0 : ScVbaFormat<Ifc1>::getCellRangesBase() throw ( ::uno::RuntimeException )
796 : {
797 0 : return ScCellRangesBase::getImplementation( mxPropertySet );
798 : }
799 :
800 : template< typename Ifc1 >
801 : SfxItemSet*
802 0 : ScVbaFormat<Ifc1>::getCurrentDataSet( ) throw ( uno::RuntimeException )
803 : {
804 0 : SfxItemSet* pDataSet = excel::ScVbaCellRangeAccess::GetDataSet( getCellRangesBase() );
805 0 : if ( !pDataSet )
806 0 : throw uno::RuntimeException("Can't access Itemset for XPropertySet" );
807 0 : return pDataSet;
808 : }
809 :
810 : template class ScVbaFormat< excel::XStyle >;
811 9 : template class ScVbaFormat< excel::XRange >;
812 :
813 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
