Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <vcl/svapp.hxx>
21 : #include "scitems.hxx"
22 : #include <svx/algitem.hxx>
23 : #include <editeng/brushitem.hxx>
24 : #include <editeng/editobj.hxx>
25 : #include <editeng/scripttypeitem.hxx>
26 : #include <svl/srchitem.hxx>
27 : #include <editeng/langitem.hxx>
28 : #include <sfx2/docfile.hxx>
29 : #include <sfx2/dispatch.hxx>
30 : #include <sfx2/objsh.hxx>
31 : #include <sfx2/viewfrm.hxx>
32 : #include <sfx2/viewsh.hxx>
33 : #include <svl/stritem.hxx>
34 : #include <svl/zforlist.hxx>
35 : #include <svl/zformat.hxx>
36 : #include <vcl/image.hxx>
37 : #include <vcl/virdev.hxx>
38 : #include <sal/macros.h>
39 : #include <tools/rcid.h>
40 : #include <unotools/charclass.hxx>
41 : #include <unotools/securityoptions.hxx>
42 : #include <stdlib.h>
43 : #include <time.h>
44 : #include <ctype.h>
45 : #include <numeric>
46 :
47 :
48 : #include <i18nlangtag/mslangid.hxx>
49 : #include <com/sun/star/lang/Locale.hpp>
50 : #include <comphelper/processfactory.hxx>
51 : #include <comphelper/string.hxx>
52 : #include <unotools/calendarwrapper.hxx>
53 : #include <unotools/collatorwrapper.hxx>
54 : #include <com/sun/star/i18n/CollatorOptions.hpp>
55 : #include <unotools/intlwrapper.hxx>
56 : #include <unotools/syslocale.hxx>
57 : #include <unotools/transliterationwrapper.hxx>
58 :
59 : #include "global.hxx"
60 : #include "scresid.hxx"
61 : #include "autoform.hxx"
62 : #include "document.hxx"
63 : #include "patattr.hxx"
64 : #include "addincol.hxx"
65 : #include "adiasync.hxx"
66 : #include "userlist.hxx"
67 : #include "interpre.hxx"
68 : #include "strload.hxx"
69 : #include "docpool.hxx"
70 : #include "unitconv.hxx"
71 : #include "compiler.hxx"
72 : #include "parclass.hxx"
73 : #include "funcdesc.hxx"
74 : #include "globstr.hrc"
75 : #include "scfuncs.hrc"
76 : #include "sc.hrc"
77 : #include "scmod.hxx"
78 : #include "appoptio.hxx"
79 : #include "random.hxx"
80 :
81 : // -----------------------------------------------------------------------
82 :
83 :
84 : ScDocShellRef* ScGlobal::pDrawClipDocShellRef = NULL;
85 : SvxSearchItem* ScGlobal::pSearchItem = NULL;
86 : ScAutoFormat* ScGlobal::pAutoFormat = NULL;
87 : FuncCollection* ScGlobal::pFuncCollection = NULL;
88 : ScUnoAddInCollection* ScGlobal::pAddInCollection = NULL;
89 : ScUserList* ScGlobal::pUserList = NULL;
90 : OUString** ScGlobal::ppRscString = NULL;
91 : LanguageType ScGlobal::eLnge = LANGUAGE_SYSTEM;
92 : ::com::sun::star::lang::Locale* ScGlobal::pLocale = NULL;
93 : SvtSysLocale* ScGlobal::pSysLocale = NULL;
94 : const CharClass* ScGlobal::pCharClass = NULL;
95 : const LocaleDataWrapper* ScGlobal::pLocaleData = NULL;
96 : CalendarWrapper* ScGlobal::pCalendar = NULL;
97 : CollatorWrapper* ScGlobal::pCollator = NULL;
98 : CollatorWrapper* ScGlobal::pCaseCollator = NULL;
99 : ::utl::TransliterationWrapper* ScGlobal::pTransliteration = NULL;
100 : ::utl::TransliterationWrapper* ScGlobal::pCaseTransliteration = NULL;
101 31 : ::com::sun::star::uno::Reference< ::com::sun::star::i18n::XOrdinalSuffix> ScGlobal::xOrdinalSuffix = NULL;
102 : IntlWrapper* ScGlobal::pScIntlWrapper = NULL;
103 : sal_Unicode ScGlobal::cListDelimiter = ',';
104 : String* ScGlobal::pEmptyString = NULL;
105 : OUString* ScGlobal::pEmptyOUString = NULL;
106 : String* ScGlobal::pStrClipDocName = NULL;
107 :
108 : SvxBrushItem* ScGlobal::pEmptyBrushItem = NULL;
109 : SvxBrushItem* ScGlobal::pButtonBrushItem = NULL;
110 : SvxBrushItem* ScGlobal::pEmbeddedBrushItem = NULL;
111 : SvxBrushItem* ScGlobal::pProtectedBrushItem = NULL;
112 :
113 : ImageList* ScGlobal::pOutlineBitmaps = NULL;
114 :
115 : ScFunctionList* ScGlobal::pStarCalcFunctionList = NULL;
116 : ScFunctionMgr* ScGlobal::pStarCalcFunctionMgr = NULL;
117 :
118 : ScUnitConverter* ScGlobal::pUnitConverter = NULL;
119 : SvNumberFormatter* ScGlobal::pEnglishFormatter = NULL;
120 :
121 : double ScGlobal::nScreenPPTX = 96.0;
122 : double ScGlobal::nScreenPPTY = 96.0;
123 :
124 : sal_uInt16 ScGlobal::nDefFontHeight = 225;
125 : sal_uInt16 ScGlobal::nStdRowHeight = 256;
126 :
127 : long ScGlobal::nLastRowHeightExtra = 0;
128 : long ScGlobal::nLastColWidthExtra = STD_EXTRA_WIDTH;
129 :
130 : static sal_uInt16 nPPTZoom = 0; // ScreenZoom used to determine nScreenPPTX/Y
131 :
132 :
133 : class SfxViewShell;
134 : SfxViewShell* pScActiveViewShell = NULL; //! als Member !!!!!
135 : sal_uInt16 nScClickMouseModifier = 0; //! dito
136 : sal_uInt16 nScFillModeMouseModifier = 0; //! dito
137 :
138 : // Hack: ScGlobal::GetUserList() muss InitAppOptions in der UI aufrufen,
139 : // damit UserList aus Cfg geladen wird
140 :
141 : void global_InitAppOptions();
142 :
143 : //========================================================================
144 : //
145 : // statische Funktionen
146 : //
147 : //========================================================================
148 :
149 2649945 : sal_Bool ScGlobal::HasAttrChanged( const SfxItemSet& rNewAttrs,
150 : const SfxItemSet& rOldAttrs,
151 : const sal_uInt16 nWhich )
152 : {
153 2649945 : sal_Bool bInvalidate = false;
154 2649945 : const SfxItemState eNewState = rNewAttrs.GetItemState( nWhich );
155 2649945 : const SfxItemState eOldState = rOldAttrs.GetItemState( nWhich );
156 :
157 : //----------------------------------------------------------
158 :
159 2649945 : if ( eNewState == eOldState )
160 : {
161 : // beide Items gesetzt
162 : // PoolItems, d.h. Pointer-Vergleich zulaessig
163 2641227 : if ( SFX_ITEM_SET == eOldState )
164 459636 : bInvalidate = (&rNewAttrs.Get( nWhich ) != &rOldAttrs.Get( nWhich ));
165 : }
166 : else
167 : {
168 : // ein Default-Item dabei
169 : // PoolItems, d.h. Item-Vergleich noetig
170 :
171 : const SfxPoolItem& rOldItem = ( SFX_ITEM_SET == eOldState )
172 1311 : ? rOldAttrs.Get( nWhich )
173 10029 : : rOldAttrs.GetPool()->GetDefaultItem( nWhich );
174 :
175 : const SfxPoolItem& rNewItem = ( SFX_ITEM_SET == eNewState )
176 7407 : ? rNewAttrs.Get( nWhich )
177 16125 : : rNewAttrs.GetPool()->GetDefaultItem( nWhich );
178 :
179 8718 : bInvalidate = sal::static_int_cast<sal_Bool>(rNewItem != rOldItem);
180 : }
181 :
182 2649945 : return bInvalidate;
183 : }
184 :
185 796 : sal_uLong ScGlobal::GetStandardFormat( SvNumberFormatter& rFormatter,
186 : sal_uLong nFormat, short nType )
187 : {
188 796 : const SvNumberformat* pFormat = rFormatter.GetEntry( nFormat );
189 796 : if ( pFormat )
190 796 : return rFormatter.GetStandardFormat( nFormat, nType, pFormat->GetLanguage() );
191 0 : return rFormatter.GetStandardFormat( nType, eLnge );
192 : }
193 :
194 0 : sal_uLong ScGlobal::GetStandardFormat( double fNumber, SvNumberFormatter& rFormatter,
195 : sal_uLong nFormat, short nType )
196 : {
197 0 : const SvNumberformat* pFormat = rFormatter.GetEntry( nFormat );
198 0 : if ( pFormat )
199 : return rFormatter.GetStandardFormat( fNumber, nFormat, nType,
200 0 : pFormat->GetLanguage() );
201 0 : return rFormatter.GetStandardFormat( nType, eLnge );
202 : }
203 :
204 :
205 44 : SvNumberFormatter* ScGlobal::GetEnglishFormatter()
206 : {
207 44 : if ( !pEnglishFormatter )
208 : {
209 : pEnglishFormatter = new SvNumberFormatter(
210 2 : ::comphelper::getProcessComponentContext(), LANGUAGE_ENGLISH_US );
211 2 : pEnglishFormatter->SetEvalDateFormat( NF_EVALDATEFORMAT_INTL_FORMAT );
212 : }
213 44 : return pEnglishFormatter;
214 : }
215 :
216 :
217 : //------------------------------------------------------------------------
218 :
219 113582 : sal_Bool ScGlobal::CheckWidthInvalidate( bool& bNumFormatChanged,
220 : const SfxItemSet& rNewAttrs,
221 : const SfxItemSet& rOldAttrs )
222 : {
223 : // Ueberpruefen, ob Attributaenderungen in rNewAttrs gegnueber
224 : // rOldAttrs die Textbreite an einer Zelle ungueltig machen
225 :
226 : bNumFormatChanged =
227 113582 : HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_VALUE_FORMAT );
228 : return ( bNumFormatChanged
229 112290 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_LANGUAGE_FORMAT )
230 112290 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT )
231 111910 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT )
232 111599 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT )
233 111420 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_HEIGHT )
234 111395 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT_HEIGHT )
235 111340 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT_HEIGHT )
236 111297 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_WEIGHT )
237 110231 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT_WEIGHT )
238 110206 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT_WEIGHT )
239 110181 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_POSTURE )
240 110112 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT_POSTURE )
241 110087 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT_POSTURE )
242 110062 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_UNDERLINE )
243 109991 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_OVERLINE )
244 109961 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_CROSSEDOUT )
245 109912 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_CONTOUR )
246 109888 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_SHADOWED )
247 109864 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_STACKED )
248 108118 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_ROTATE_VALUE )
249 108099 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_ROTATE_MODE )
250 108099 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_LINEBREAK )
251 221593 : || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_MARGIN )
252 113582 : );
253 : }
254 :
255 18 : const SvxSearchItem& ScGlobal::GetSearchItem()
256 : {
257 18 : if (!pSearchItem)
258 : {
259 1 : pSearchItem = new SvxSearchItem( SID_SEARCH_ITEM );
260 1 : pSearchItem->SetAppFlag( SVX_SEARCHAPP_CALC );
261 : }
262 18 : return *pSearchItem;
263 : }
264 :
265 18 : void ScGlobal::SetSearchItem( const SvxSearchItem& rNew )
266 : {
267 : // Hier waere ein Zuweisungsoperator ganz nett:
268 18 : delete pSearchItem;
269 18 : pSearchItem = (SvxSearchItem*)rNew.Clone();
270 :
271 18 : pSearchItem->SetWhich( SID_SEARCH_ITEM );
272 18 : pSearchItem->SetAppFlag( SVX_SEARCHAPP_CALC );
273 18 : }
274 :
275 0 : void ScGlobal::ClearAutoFormat()
276 : {
277 0 : if (pAutoFormat!=NULL)
278 : {
279 0 : delete pAutoFormat;
280 0 : pAutoFormat=NULL;
281 : }
282 0 : }
283 :
284 25 : ScAutoFormat* ScGlobal::GetAutoFormat()
285 : {
286 25 : return pAutoFormat;
287 : }
288 :
289 432 : ScAutoFormat* ScGlobal::GetOrCreateAutoFormat()
290 : {
291 432 : if ( !pAutoFormat )
292 : {
293 1 : pAutoFormat = new ScAutoFormat;
294 1 : pAutoFormat->Load();
295 : }
296 :
297 432 : return pAutoFormat;
298 : }
299 :
300 2101 : FuncCollection* ScGlobal::GetFuncCollection()
301 : {
302 2101 : if (!pFuncCollection)
303 9 : pFuncCollection = new FuncCollection();
304 2101 : return pFuncCollection;
305 : }
306 :
307 2134 : ScUnoAddInCollection* ScGlobal::GetAddInCollection()
308 : {
309 2134 : if (!pAddInCollection)
310 23 : pAddInCollection = new ScUnoAddInCollection();
311 2134 : return pAddInCollection;
312 : }
313 :
314 12 : ScUserList* ScGlobal::GetUserList()
315 : {
316 : // Hack: Cfg-Item an der App ggF. laden
317 :
318 12 : global_InitAppOptions();
319 :
320 12 : if (!pUserList)
321 0 : pUserList = new ScUserList();
322 12 : return pUserList;
323 : }
324 :
325 31 : void ScGlobal::SetUserList( const ScUserList* pNewList )
326 : {
327 31 : if ( pNewList )
328 : {
329 31 : if ( !pUserList )
330 31 : pUserList = new ScUserList( *pNewList );
331 : else
332 0 : *pUserList = *pNewList;
333 : }
334 : else
335 : {
336 0 : delete pUserList;
337 0 : pUserList = NULL;
338 : }
339 31 : }
340 :
341 28567 : const OUString& ScGlobal::GetRscString( sal_uInt16 nIndex )
342 : {
343 : OSL_ENSURE( nIndex < STR_COUNT, "ScGlobal::GetRscString - invalid string index");
344 28567 : if( !ppRscString[ nIndex ] )
345 : {
346 609 : OpCode eOp = ocNone;
347 : // Map former globstr.src strings moved to compiler.src
348 609 : switch (nIndex)
349 : {
350 : case STR_NULL_ERROR:
351 0 : eOp = ocErrNull;
352 0 : break;
353 : case STR_DIV_ZERO:
354 2 : eOp = ocErrDivZero;
355 2 : break;
356 : case STR_NO_VALUE:
357 3 : eOp = ocErrValue;
358 3 : break;
359 : case STR_NOREF_STR:
360 0 : eOp = ocErrRef;
361 0 : break;
362 : case STR_NO_NAME_REF:
363 0 : eOp = ocErrName;
364 0 : break;
365 : case STR_NUM_ERROR:
366 1 : eOp = ocErrNum;
367 1 : break;
368 : case STR_NV_STR:
369 2 : eOp = ocErrNA;
370 2 : break;
371 : default:
372 : ; // nothing
373 : }
374 609 : if (eOp != ocNone)
375 8 : ppRscString[ nIndex ] = new OUString(
376 16 : ScCompiler::GetNativeSymbol( eOp));
377 : else
378 601 : ppRscString[ nIndex ] = new OUString(
379 1202 : ScRscStrLoader( RID_GLOBSTR, nIndex ).GetString());
380 : }
381 28567 : return *ppRscString[ nIndex ];
382 : }
383 :
384 138 : String ScGlobal::GetErrorString(sal_uInt16 nErrNumber)
385 : {
386 138 : String sResStr;
387 138 : switch (nErrNumber)
388 : {
389 18 : case NOTAVAILABLE : nErrNumber = STR_NV_STR; break;
390 8 : case errNoRef : nErrNumber = STR_NO_REF_TABLE; break;
391 0 : case errNoName : nErrNumber = STR_NO_NAME_REF; break;
392 0 : case errNoAddin : nErrNumber = STR_NO_ADDIN; break;
393 0 : case errNoMacro : nErrNumber = STR_NO_MACRO; break;
394 : case errDoubleRef :
395 12 : case errNoValue : nErrNumber = STR_NO_VALUE; break;
396 0 : case errNoCode : nErrNumber = STR_NULL_ERROR; break;
397 5 : case errDivisionByZero : nErrNumber = STR_DIV_ZERO; break;
398 55 : case errIllegalFPOperation : nErrNumber = STR_NUM_ERROR; break;
399 :
400 40 : default : sResStr = GetRscString(STR_ERROR_STR) + OUString::number( nErrNumber );
401 40 : nErrNumber = 0;
402 40 : break;
403 : }
404 138 : if( nErrNumber )
405 98 : sResStr = GetRscString( nErrNumber );
406 138 : return sResStr;
407 : }
408 :
409 0 : String ScGlobal::GetLongErrorString(sal_uInt16 nErrNumber)
410 : {
411 0 : switch (nErrNumber)
412 : {
413 : case 0:
414 0 : break;
415 : case 1:
416 : case errIllegalArgument:
417 0 : nErrNumber = STR_LONG_ERR_ILL_ARG;
418 0 : break;
419 : case 2:
420 : case 3:
421 : case 4:
422 : case 5:
423 : case errIllegalFPOperation:
424 0 : nErrNumber = STR_LONG_ERR_ILL_FPO;
425 0 : break;
426 : case errIllegalChar:
427 0 : nErrNumber = STR_LONG_ERR_ILL_CHAR;
428 0 : break;
429 : case errIllegalParameter:
430 0 : nErrNumber = STR_LONG_ERR_ILL_PAR;
431 0 : break;
432 : case errSeparator:
433 0 : nErrNumber = STR_LONG_ERR_ILL_SEP;
434 0 : break;
435 : case errPair:
436 : case errPairExpected:
437 0 : nErrNumber = STR_LONG_ERR_PAIR;
438 0 : break;
439 : case errOperatorExpected:
440 0 : nErrNumber = STR_LONG_ERR_OP_EXP;
441 0 : break;
442 : case errVariableExpected:
443 : case errParameterExpected:
444 0 : nErrNumber = STR_LONG_ERR_VAR_EXP;
445 0 : break;
446 : case errCodeOverflow:
447 0 : nErrNumber = STR_LONG_ERR_CODE_OVF;
448 0 : break;
449 : case errStringOverflow:
450 0 : nErrNumber = STR_LONG_ERR_STR_OVF;
451 0 : break;
452 : case errStackOverflow:
453 : case errInterpOverflow:
454 0 : nErrNumber = STR_LONG_ERR_STACK_OVF;
455 0 : break;
456 : case errIllegalJump:
457 : case errUnknownState:
458 : case errUnknownVariable:
459 : case errUnknownOpCode:
460 : case errUnknownStackVariable:
461 : case errUnknownToken:
462 : case errNoCode:
463 : case errDoubleRef:
464 0 : nErrNumber = STR_LONG_ERR_SYNTAX;
465 0 : break;
466 : case errCircularReference:
467 0 : nErrNumber = STR_LONG_ERR_CIRC_REF;
468 0 : break;
469 : case errNoConvergence:
470 0 : nErrNumber = STR_LONG_ERR_NO_CONV;
471 0 : break;
472 : case errNoRef:
473 0 : nErrNumber = STR_LONG_ERR_NO_REF;
474 0 : break;
475 : case errNoName:
476 0 : nErrNumber = STR_LONG_ERR_NO_NAME;
477 0 : break;
478 : case errNoAddin:
479 0 : nErrNumber = STR_LONG_ERR_NO_ADDIN;
480 0 : break;
481 : case errNoMacro:
482 0 : nErrNumber = STR_LONG_ERR_NO_MACRO;
483 0 : break;
484 : case errDivisionByZero:
485 0 : nErrNumber = STR_LONG_ERR_DIV_ZERO;
486 0 : break;
487 : case errNestedArray:
488 0 : nErrNumber = STR_ERR_LONG_NESTED_ARRAY;
489 0 : break;
490 : case errNoValue:
491 0 : nErrNumber = STR_LONG_ERR_NO_VALUE;
492 0 : break;
493 : case NOTAVAILABLE:
494 0 : nErrNumber = STR_LONG_ERR_NV;
495 0 : break;
496 : default:
497 0 : nErrNumber = STR_ERROR_STR;
498 0 : break;
499 : }
500 0 : String aRes( GetRscString( nErrNumber ) );
501 0 : return aRes;
502 : }
503 :
504 0 : SvxBrushItem* ScGlobal::GetButtonBrushItem()
505 : {
506 0 : pButtonBrushItem->SetColor( Application::GetSettings().GetStyleSettings().GetFaceColor() );
507 0 : return pButtonBrushItem;
508 : }
509 :
510 55250 : const String& ScGlobal::GetEmptyString()
511 : {
512 55250 : return *pEmptyString;
513 : }
514 :
515 8108 : const OUString& ScGlobal::GetEmptyOUString()
516 : {
517 8108 : return *pEmptyOUString;
518 : }
519 :
520 5 : ImageList* ScGlobal::GetOutlineSymbols()
521 : {
522 5 : ImageList*& rpImageList = pOutlineBitmaps;
523 5 : if( !rpImageList )
524 3 : rpImageList = new ImageList( ScResId( RID_OUTLINEBITMAPS ) );
525 5 : return rpImageList;
526 : }
527 :
528 31 : void ScGlobal::Init()
529 : {
530 31 : pEmptyString = new String;
531 31 : pEmptyOUString = new OUString;
532 :
533 : // Die Default-Sprache fuer Zahlenformate (ScGlobal::eLnge)
534 : // muss immer LANGUAGE_SYSTEM sein
535 : //! Dann kann auch die Variable raus
536 31 : eLnge = LANGUAGE_SYSTEM;
537 :
538 : //! Wenn Sortierung etc. von der Sprache der installierten Offfice-Version
539 : //! abhaengen sollen, hier "Application::GetSettings().GetUILanguage()"
540 31 : pSysLocale = new SvtSysLocale;
541 31 : pCharClass = pSysLocale->GetCharClassPtr();
542 31 : pLocaleData = pSysLocale->GetLocaleDataPtr();
543 :
544 31 : ppRscString = new OUString *[ STR_COUNT ];
545 31 : for( sal_uInt16 nC = 0 ; nC < STR_COUNT ; nC++ ) ppRscString[ nC ] = NULL;
546 :
547 31 : pEmptyBrushItem = new SvxBrushItem( Color( COL_TRANSPARENT ), ATTR_BACKGROUND );
548 31 : pButtonBrushItem = new SvxBrushItem( Color(), ATTR_BACKGROUND );
549 31 : pEmbeddedBrushItem = new SvxBrushItem( Color( COL_LIGHTCYAN ), ATTR_BACKGROUND );
550 31 : pProtectedBrushItem = new SvxBrushItem( Color( COL_LIGHTGRAY ), ATTR_BACKGROUND );
551 :
552 31 : UpdatePPT(NULL);
553 : //ScCompiler::InitSymbolsNative();
554 : // ScParameterClassification _after_ Compiler, needs function resources if
555 : // arguments are to be merged in, which in turn need strings of function
556 : // names from the compiler.
557 31 : ScParameterClassification::Init();
558 31 : srand( (unsigned) time( NULL ) ); // Random Seed Init fuer Interpreter
559 31 : sc::rng::seed( time( NULL ) ); // seed for libc rand() replacement
560 :
561 31 : InitAddIns();
562 :
563 31 : pStrClipDocName = new String( ScResId( SCSTR_NONAME ) );
564 31 : *pStrClipDocName += '1';
565 :
566 : // ScDocumentPool::InitVersionMaps() ist schon vorher gerufen worden
567 31 : }
568 :
569 31 : void ScGlobal::UpdatePPT( OutputDevice* pDev )
570 : {
571 31 : sal_uInt16 nCurrentZoom = Application::GetSettings().GetStyleSettings().GetScreenZoom();
572 31 : if ( nCurrentZoom != nPPTZoom )
573 : {
574 : // Screen PPT values must be updated when ScreenZoom has changed.
575 : // If called from Window::DataChanged, the window is passed as pDev,
576 : // to make sure LogicToPixel uses a device which already uses the new zoom.
577 : // For the initial settings, NULL is passed and GetDefaultDevice used.
578 :
579 31 : if ( !pDev )
580 31 : pDev = Application::GetDefaultDevice();
581 31 : Point aPix1000 = pDev->LogicToPixel( Point(1000,1000), MAP_TWIP );
582 31 : nScreenPPTX = aPix1000.X() / 1000.0;
583 31 : nScreenPPTY = aPix1000.Y() / 1000.0;
584 31 : nPPTZoom = nCurrentZoom;
585 : }
586 31 : }
587 :
588 0 : const String& ScGlobal::GetClipDocName()
589 : {
590 0 : return *pStrClipDocName;
591 : }
592 :
593 11 : void ScGlobal::SetClipDocName( const String& rNew )
594 : {
595 11 : *pStrClipDocName = rNew;
596 11 : }
597 :
598 :
599 31 : void ScGlobal::InitTextHeight(SfxItemPool* pPool)
600 : {
601 31 : if (!pPool)
602 : {
603 : OSL_FAIL("ScGlobal::InitTextHeight: No Pool");
604 0 : return;
605 : }
606 :
607 31 : const ScPatternAttr* pPattern = (const ScPatternAttr*)&pPool->GetDefaultItem(ATTR_PATTERN);
608 31 : if (!pPattern)
609 : {
610 : OSL_FAIL("ScGlobal::InitTextHeight: No default pattern");
611 0 : return;
612 : }
613 :
614 31 : OutputDevice* pDefaultDev = Application::GetDefaultDevice();
615 31 : VirtualDevice aVirtWindow( *pDefaultDev );
616 31 : aVirtWindow.SetMapMode(MAP_PIXEL);
617 62 : Font aDefFont;
618 31 : pPattern->GetFont(aDefFont, SC_AUTOCOL_BLACK, &aVirtWindow); // font color doesn't matter here
619 31 : aVirtWindow.SetFont(aDefFont);
620 : sal_uInt16 nTest = static_cast<sal_uInt16>(
621 31 : aVirtWindow.PixelToLogic(Size(0, aVirtWindow.GetTextHeight()), MAP_TWIP).Height());
622 :
623 31 : if (nTest > nDefFontHeight)
624 0 : nDefFontHeight = nTest;
625 :
626 31 : const SvxMarginItem* pMargin = (const SvxMarginItem*)&pPattern->GetItem(ATTR_MARGIN);
627 :
628 : nTest = static_cast<sal_uInt16>(
629 31 : nDefFontHeight + pMargin->GetTopMargin() + pMargin->GetBottomMargin() - STD_ROWHEIGHT_DIFF);
630 :
631 31 : if (nTest > nStdRowHeight)
632 31 : nStdRowHeight = nTest;
633 : }
634 :
635 9 : void ScGlobal::Clear()
636 : {
637 : // asyncs _vor_ ExitExternalFunc zerstoeren!
638 9 : for( ScAddInAsyncs::iterator it = theAddInAsyncTbl.begin(); it != theAddInAsyncTbl.end(); ++it )
639 : {
640 0 : delete *it;
641 : }
642 9 : theAddInAsyncTbl.clear();
643 9 : ExitExternalFunc();
644 9 : DELETEZ(pAutoFormat);
645 9 : DELETEZ(pSearchItem);
646 9 : DELETEZ(pFuncCollection);
647 9 : DELETEZ(pAddInCollection);
648 9 : DELETEZ(pUserList);
649 :
650 4986 : for( sal_uInt16 nC = 0 ; nC < STR_COUNT ; nC++ )
651 4977 : if( ppRscString ) delete ppRscString[ nC ];
652 9 : delete[] ppRscString;
653 9 : ppRscString = NULL;
654 :
655 9 : DELETEZ(pStarCalcFunctionList); // vor ResMgr zerstoeren!
656 9 : DELETEZ(pStarCalcFunctionMgr);
657 9 : ScParameterClassification::Exit();
658 9 : ScCompiler::DeInit();
659 9 : ScInterpreter::GlobalExit(); // statischen Stack loeschen
660 :
661 9 : DELETEZ(pEmptyBrushItem);
662 9 : DELETEZ(pButtonBrushItem);
663 9 : DELETEZ(pEmbeddedBrushItem);
664 9 : DELETEZ(pProtectedBrushItem);
665 9 : DELETEZ(pOutlineBitmaps);
666 9 : DELETEZ(pEnglishFormatter);
667 9 : DELETEZ(pCaseTransliteration);
668 9 : DELETEZ(pTransliteration);
669 9 : DELETEZ(pCaseCollator);
670 9 : DELETEZ(pCollator);
671 9 : DELETEZ(pCalendar);
672 : //! do NOT delete pCharClass since it is a pointer to the single SvtSysLocale instance
673 9 : pCharClass = NULL;
674 : //! do NOT delete pLocaleData since it is a pointer to the single SvtSysLocale instance
675 9 : pLocaleData = NULL;
676 9 : DELETEZ(pSysLocale);
677 9 : DELETEZ(pLocale);
678 9 : DELETEZ(pScIntlWrapper);
679 9 : DELETEZ(pStrClipDocName);
680 :
681 9 : DELETEZ(pUnitConverter);
682 :
683 9 : ScDocumentPool::DeleteVersionMaps();
684 :
685 9 : DELETEZ(pEmptyString);
686 9 : DELETEZ(pEmptyOUString);
687 9 : }
688 :
689 : //------------------------------------------------------------------------
690 :
691 2 : CharSet ScGlobal::GetCharsetValue( const String& rCharSet )
692 : {
693 : // new TextEncoding values
694 2 : if ( CharClass::isAsciiNumeric( rCharSet ) )
695 : {
696 0 : sal_Int32 nVal = rCharSet.ToInt32();
697 0 : if ( !nVal || nVal == RTL_TEXTENCODING_DONTKNOW )
698 0 : return osl_getThreadTextEncoding();
699 0 : return (CharSet) nVal;
700 : }
701 : // old CharSet values for compatibility
702 2 : else if (rCharSet.EqualsIgnoreCaseAscii("ANSI") ) return RTL_TEXTENCODING_MS_1252;
703 1 : else if (rCharSet.EqualsIgnoreCaseAscii("MAC") ) return RTL_TEXTENCODING_APPLE_ROMAN;
704 1 : else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC") ) return RTL_TEXTENCODING_IBM_850;
705 1 : else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_437")) return RTL_TEXTENCODING_IBM_437;
706 0 : else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_850")) return RTL_TEXTENCODING_IBM_850;
707 0 : else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_860")) return RTL_TEXTENCODING_IBM_860;
708 0 : else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_861")) return RTL_TEXTENCODING_IBM_861;
709 0 : else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_863")) return RTL_TEXTENCODING_IBM_863;
710 0 : else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_865")) return RTL_TEXTENCODING_IBM_865;
711 0 : else return osl_getThreadTextEncoding();
712 : }
713 :
714 : //------------------------------------------------------------------------
715 :
716 2 : String ScGlobal::GetCharsetString( CharSet eVal )
717 : {
718 : const sal_Char* pChar;
719 2 : switch ( eVal )
720 : {
721 : // old CharSet strings for compatibility
722 1 : case RTL_TEXTENCODING_MS_1252: pChar = "ANSI"; break;
723 0 : case RTL_TEXTENCODING_APPLE_ROMAN: pChar = "MAC"; break;
724 : // IBMPC == IBMPC_850
725 1 : case RTL_TEXTENCODING_IBM_437: pChar = "IBMPC_437"; break;
726 0 : case RTL_TEXTENCODING_IBM_850: pChar = "IBMPC_850"; break;
727 0 : case RTL_TEXTENCODING_IBM_860: pChar = "IBMPC_860"; break;
728 0 : case RTL_TEXTENCODING_IBM_861: pChar = "IBMPC_861"; break;
729 0 : case RTL_TEXTENCODING_IBM_863: pChar = "IBMPC_863"; break;
730 0 : case RTL_TEXTENCODING_IBM_865: pChar = "IBMPC_865"; break;
731 0 : case RTL_TEXTENCODING_DONTKNOW: pChar = "SYSTEM"; break;
732 : // new string of TextEncoding value
733 : default:
734 0 : return OUString::number( eVal );
735 : }
736 2 : return OUString::createFromAscii(pChar);
737 : }
738 :
739 : //------------------------------------------------------------------------
740 :
741 0 : bool ScGlobal::HasStarCalcFunctionList()
742 : {
743 0 : return ( pStarCalcFunctionList != NULL );
744 : }
745 :
746 846 : ScFunctionList* ScGlobal::GetStarCalcFunctionList()
747 : {
748 846 : if ( !pStarCalcFunctionList )
749 3 : pStarCalcFunctionList = new ScFunctionList;
750 :
751 846 : return pStarCalcFunctionList;
752 : }
753 :
754 : //------------------------------------------------------------------------
755 :
756 1 : ScFunctionMgr* ScGlobal::GetStarCalcFunctionMgr()
757 : {
758 1 : if ( !pStarCalcFunctionMgr )
759 1 : pStarCalcFunctionMgr = new ScFunctionMgr;
760 :
761 1 : return pStarCalcFunctionMgr;
762 : }
763 :
764 313 : void ScGlobal::ResetFunctionList()
765 : {
766 : // FunctionMgr has pointers into FunctionList, must also be updated
767 :
768 313 : DELETEZ( pStarCalcFunctionMgr );
769 313 : DELETEZ( pStarCalcFunctionList );
770 313 : }
771 :
772 : //------------------------------------------------------------------------
773 :
774 0 : ScUnitConverter* ScGlobal::GetUnitConverter()
775 : {
776 0 : if ( !pUnitConverter )
777 0 : pUnitConverter = new ScUnitConverter;
778 :
779 0 : return pUnitConverter;
780 : }
781 :
782 :
783 : //------------------------------------------------------------------------
784 :
785 5142 : const sal_Unicode* ScGlobal::UnicodeStrChr( const sal_Unicode* pStr,
786 : sal_Unicode c )
787 : {
788 5142 : if ( !pStr )
789 0 : return NULL;
790 15560 : while ( *pStr )
791 : {
792 6610 : if ( *pStr == c )
793 1334 : return pStr;
794 5276 : pStr++;
795 : }
796 3808 : return NULL;
797 : }
798 :
799 : // ----------------------------------------------------------------------------
800 :
801 42 : OUString ScGlobal::addToken(const OUString& rTokenList, const OUString& rToken,
802 : sal_Unicode cSep, sal_Int32 nSepCount, bool bForceSep)
803 : {
804 42 : OUStringBuffer aBuf(rTokenList);
805 42 : if( bForceSep || (!rToken.isEmpty() && !rTokenList.isEmpty()) )
806 0 : comphelper::string::padToLength(aBuf, aBuf.getLength() + nSepCount, cSep);
807 42 : aBuf.append(rToken);
808 42 : return aBuf.makeStringAndClear();
809 : }
810 :
811 0 : bool ScGlobal::IsQuoted( const String& rString, sal_Unicode cQuote )
812 : {
813 0 : return (rString.Len() >= 2) && (rString.GetChar( 0 ) == cQuote) && (rString.GetChar( rString.Len() - 1 ) == cQuote);
814 : }
815 :
816 0 : void ScGlobal::AddQuotes( OUString& rString, sal_Unicode cQuote, bool bEscapeEmbedded )
817 : {
818 0 : if (bEscapeEmbedded)
819 : {
820 : sal_Unicode pQ[3];
821 0 : pQ[0] = pQ[1] = cQuote;
822 0 : pQ[2] = 0;
823 0 : OUString aQuotes( pQ );
824 0 : rString = rString.replaceAll( OUString(cQuote), aQuotes);
825 : }
826 0 : rString = OUString( cQuote ) + OUString( cQuote );
827 0 : }
828 :
829 0 : void ScGlobal::EraseQuotes( OUString& rString, sal_Unicode cQuote, bool bUnescapeEmbedded )
830 : {
831 0 : if ( IsQuoted( rString, cQuote ) )
832 : {
833 0 : rString = rString.copy( 1, rString.getLength() - 2 );
834 0 : if (bUnescapeEmbedded)
835 : {
836 : sal_Unicode pQ[3];
837 0 : pQ[0] = pQ[1] = cQuote;
838 0 : pQ[2] = 0;
839 0 : OUString aQuotes( pQ );
840 0 : rString = rString.replaceAll( aQuotes, OUString(cQuote));
841 : }
842 : }
843 0 : }
844 :
845 3698 : xub_StrLen ScGlobal::FindUnquoted( const String& rString, sal_Unicode cChar, xub_StrLen nStart, sal_Unicode cQuote )
846 : {
847 3698 : const sal_Unicode* const pStart = rString.GetBuffer();
848 3698 : const sal_Unicode* const pStop = pStart + rString.Len();
849 3698 : const sal_Unicode* p = pStart + nStart;
850 3698 : bool bQuoted = false;
851 27773 : while (p < pStop)
852 : {
853 21973 : if (*p == cChar && !bQuoted)
854 1596 : return sal::static_int_cast< xub_StrLen >( p - pStart );
855 20377 : else if (*p == cQuote)
856 : {
857 180 : if (!bQuoted)
858 90 : bQuoted = true;
859 90 : else if (p < pStop-1 && *(p+1) == cQuote)
860 0 : ++p;
861 : else
862 90 : bQuoted = false;
863 : }
864 20377 : ++p;
865 : }
866 2102 : return STRING_NOTFOUND;
867 : }
868 :
869 6388 : const sal_Unicode* ScGlobal::FindUnquoted( const sal_Unicode* pString, sal_Unicode cChar, sal_Unicode cQuote )
870 : {
871 6388 : const sal_Unicode* p = pString;
872 6388 : bool bQuoted = false;
873 51896 : while (*p)
874 : {
875 43035 : if (*p == cChar && !bQuoted)
876 3915 : return p;
877 39120 : else if (*p == cQuote)
878 : {
879 698 : if (!bQuoted)
880 349 : bQuoted = true;
881 349 : else if (*(p+1) == cQuote)
882 0 : ++p;
883 : else
884 349 : bQuoted = false;
885 : }
886 39120 : ++p;
887 : }
888 2473 : return NULL;
889 : }
890 :
891 : //------------------------------------------------------------------------
892 :
893 6216 : sal_Bool ScGlobal::EETextObjEqual( const EditTextObject* pObj1,
894 : const EditTextObject* pObj2 )
895 : {
896 6216 : if ( pObj1 == pObj2 ) // both empty or the same object
897 1346 : return sal_True;
898 :
899 4870 : if ( pObj1 && pObj2 )
900 : {
901 : // first test for equal text content
902 2291 : sal_Int32 nParCount = pObj1->GetParagraphCount();
903 2291 : if ( nParCount != pObj2->GetParagraphCount() )
904 2213 : return false;
905 3529 : for (sal_Int32 nPar=0; nPar<nParCount; nPar++)
906 2289 : if ( pObj1->GetText(nPar) != pObj2->GetText(nPar) )
907 1049 : return false;
908 :
909 1240 : SvMemoryStream aStream1;
910 1320 : SvMemoryStream aStream2;
911 1240 : pObj1->Store( aStream1 );
912 1240 : pObj2->Store( aStream2 );
913 1240 : sal_uLong nSize = aStream1.Tell();
914 1240 : if ( aStream2.Tell() == nSize )
915 1172 : if ( !memcmp( aStream1.GetData(), aStream2.GetData(), (sal_uInt16) nSize ) )
916 1240 : return sal_True;
917 : }
918 :
919 2659 : return false;
920 : }
921 :
922 0 : void ScGlobal::OpenURL( const String& rURL, const String& rTarget )
923 : {
924 : // OpenURL wird immer ueber irgendwelche Umwege durch Mausklicks im GridWindow
925 : // aufgerufen, darum stimmen pScActiveViewShell und nScClickMouseModifier.
926 : //SvtSecurityOptions to access Libreoffice global security parameters
927 0 : SvtSecurityOptions aSecOpt;
928 0 : bool bCtrlClickHappened = (nScClickMouseModifier & KEY_MOD1);
929 0 : bool bCtrlClickSecOption = aSecOpt.IsOptionSet( SvtSecurityOptions::E_CTRLCLICK_HYPERLINK );
930 0 : if( bCtrlClickHappened && !( bCtrlClickSecOption ) )
931 : {
932 : //return since ctrl+click happened when the
933 : //ctrl+click security option was disabled, link should not open
934 0 : return;
935 : }
936 0 : else if( !( bCtrlClickHappened ) && bCtrlClickSecOption )
937 : {
938 : //ctrl+click did not happen; only click happened maybe with some
939 : //other key combo. and security option is set, so return
940 0 : return;
941 : }
942 0 : SfxStringItem aUrl( SID_FILE_NAME, rURL );
943 0 : SfxStringItem aTarget( SID_TARGETNAME, rTarget );
944 0 : aTarget.SetValue(OUString("_blank"));
945 0 : SfxViewFrame* pFrame = NULL;
946 0 : String aReferName;
947 0 : if ( pScActiveViewShell )
948 : {
949 0 : pFrame = pScActiveViewShell->GetViewFrame();
950 0 : SfxMedium* pMed = pFrame->GetObjectShell()->GetMedium();
951 0 : if (pMed)
952 0 : aReferName = pMed->GetName();
953 : }
954 :
955 0 : SfxFrameItem aFrm( SID_DOCFRAME, pFrame );
956 0 : SfxStringItem aReferer( SID_REFERER, aReferName );
957 :
958 0 : SfxBoolItem aNewView( SID_OPEN_NEW_VIEW, false );
959 0 : SfxBoolItem aBrowsing( SID_BROWSE, sal_True );
960 :
961 : // kein SID_SILENT mehr
962 :
963 0 : SfxViewFrame* pViewFrm = SfxViewFrame::Current();
964 0 : if (pViewFrm)
965 : pViewFrm->GetDispatcher()->Execute( SID_OPENDOC,
966 : SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
967 : &aUrl, &aTarget,
968 : &aFrm, &aReferer,
969 : &aNewView, &aBrowsing,
970 0 : 0L );
971 : }
972 :
973 : //------------------------------------------------------------------------
974 :
975 1255 : sal_Bool ScGlobal::IsSystemRTL()
976 : {
977 1255 : return MsLangId::isRightToLeft( Application::GetSettings().GetLanguageTag().getLanguageType() );
978 : }
979 :
980 784968 : sal_uInt8 ScGlobal::GetDefaultScriptType()
981 : {
982 : // Used when text contains only WEAK characters.
983 : // Script type of office language is used then (same as GetEditDefaultLanguage,
984 : // to get consistent behavior of text in simple cells and EditEngine,
985 : // also same as GetAppLanguage() in Writer)
986 :
987 784968 : return (sal_uInt8) SvtLanguageOptions::GetScriptTypeOfLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() );
988 : }
989 :
990 6150 : LanguageType ScGlobal::GetEditDefaultLanguage()
991 : {
992 : // used for EditEngine::SetDefaultLanguage
993 :
994 6150 : return Application::GetSettings().GetLanguageTag().getLanguageType();
995 : }
996 :
997 0 : sal_uInt16 ScGlobal::GetScriptedWhichID( sal_uInt8 nScriptType, sal_uInt16 nWhich )
998 : {
999 0 : switch ( nScriptType )
1000 : {
1001 : case SCRIPTTYPE_LATIN:
1002 : case SCRIPTTYPE_ASIAN:
1003 : case SCRIPTTYPE_COMPLEX:
1004 0 : break; // take exact matches
1005 : default: // prefer one, first COMPLEX, then ASIAN
1006 0 : if ( nScriptType & SCRIPTTYPE_COMPLEX )
1007 0 : nScriptType = SCRIPTTYPE_COMPLEX;
1008 0 : else if ( nScriptType & SCRIPTTYPE_ASIAN )
1009 0 : nScriptType = SCRIPTTYPE_ASIAN;
1010 : }
1011 0 : switch ( nScriptType )
1012 : {
1013 : case SCRIPTTYPE_COMPLEX:
1014 : {
1015 0 : switch ( nWhich )
1016 : {
1017 : case ATTR_FONT:
1018 : case ATTR_CJK_FONT:
1019 0 : nWhich = ATTR_CTL_FONT;
1020 0 : break;
1021 : case ATTR_FONT_HEIGHT:
1022 : case ATTR_CJK_FONT_HEIGHT:
1023 0 : nWhich = ATTR_CTL_FONT_HEIGHT;
1024 0 : break;
1025 : case ATTR_FONT_WEIGHT:
1026 : case ATTR_CJK_FONT_WEIGHT:
1027 0 : nWhich = ATTR_CTL_FONT_WEIGHT;
1028 0 : break;
1029 : case ATTR_FONT_POSTURE:
1030 : case ATTR_CJK_FONT_POSTURE:
1031 0 : nWhich = ATTR_CTL_FONT_POSTURE;
1032 0 : break;
1033 : }
1034 : }
1035 0 : break;
1036 : case SCRIPTTYPE_ASIAN:
1037 : {
1038 0 : switch ( nWhich )
1039 : {
1040 : case ATTR_FONT:
1041 : case ATTR_CTL_FONT:
1042 0 : nWhich = ATTR_CJK_FONT;
1043 0 : break;
1044 : case ATTR_FONT_HEIGHT:
1045 : case ATTR_CTL_FONT_HEIGHT:
1046 0 : nWhich = ATTR_CJK_FONT_HEIGHT;
1047 0 : break;
1048 : case ATTR_FONT_WEIGHT:
1049 : case ATTR_CTL_FONT_WEIGHT:
1050 0 : nWhich = ATTR_CJK_FONT_WEIGHT;
1051 0 : break;
1052 : case ATTR_FONT_POSTURE:
1053 : case ATTR_CTL_FONT_POSTURE:
1054 0 : nWhich = ATTR_CJK_FONT_POSTURE;
1055 0 : break;
1056 : }
1057 : }
1058 0 : break;
1059 : default:
1060 : {
1061 0 : switch ( nWhich )
1062 : {
1063 : case ATTR_CTL_FONT:
1064 : case ATTR_CJK_FONT:
1065 0 : nWhich = ATTR_FONT;
1066 0 : break;
1067 : case ATTR_CTL_FONT_HEIGHT:
1068 : case ATTR_CJK_FONT_HEIGHT:
1069 0 : nWhich = ATTR_FONT_HEIGHT;
1070 0 : break;
1071 : case ATTR_CTL_FONT_WEIGHT:
1072 : case ATTR_CJK_FONT_WEIGHT:
1073 0 : nWhich = ATTR_FONT_WEIGHT;
1074 0 : break;
1075 : case ATTR_CTL_FONT_POSTURE:
1076 : case ATTR_CJK_FONT_POSTURE:
1077 0 : nWhich = ATTR_FONT_POSTURE;
1078 0 : break;
1079 : }
1080 : }
1081 : }
1082 0 : return nWhich;
1083 : }
1084 :
1085 : //------------------------------------------------------------------------
1086 :
1087 576 : void ScGlobal::AddLanguage( SfxItemSet& rSet, SvNumberFormatter& rFormatter )
1088 : {
1089 : OSL_ENSURE( rSet.GetItemState( ATTR_LANGUAGE_FORMAT, false ) == SFX_ITEM_DEFAULT,
1090 : "ScGlobal::AddLanguage - language already added");
1091 :
1092 : const SfxPoolItem* pHardItem;
1093 576 : if ( rSet.GetItemState( ATTR_VALUE_FORMAT, false, &pHardItem ) == SFX_ITEM_SET )
1094 : {
1095 : const SvNumberformat* pHardFormat = rFormatter.GetEntry(
1096 576 : ((const SfxUInt32Item*)pHardItem)->GetValue() );
1097 :
1098 576 : sal_uLong nParentFmt = 0; // pool default
1099 576 : const SfxItemSet* pParent = rSet.GetParent();
1100 576 : if ( pParent )
1101 0 : nParentFmt = ((const SfxUInt32Item&)pParent->Get( ATTR_VALUE_FORMAT )).GetValue();
1102 576 : const SvNumberformat* pParFormat = rFormatter.GetEntry( nParentFmt );
1103 :
1104 1152 : if ( pHardFormat && pParFormat &&
1105 576 : (pHardFormat->GetLanguage() != pParFormat->GetLanguage()) )
1106 32 : rSet.Put( SvxLanguageItem( pHardFormat->GetLanguage(), ATTR_LANGUAGE_FORMAT ) );
1107 : }
1108 576 : }
1109 :
1110 :
1111 : //--------------------------------------------------------------------
1112 :
1113 :
1114 :
1115 : //------------------------------------------------------------------------
1116 :
1117 2201 : utl::TransliterationWrapper* ScGlobal::GetpTransliteration()
1118 : {
1119 2201 : if ( !pTransliteration )
1120 : {
1121 21 : const LanguageType eOfficeLanguage = Application::GetSettings().GetLanguageTag().getLanguageType();
1122 : pTransliteration = new ::utl::TransliterationWrapper(
1123 21 : ::comphelper::getProcessComponentContext(), SC_TRANSLITERATION_IGNORECASE );
1124 21 : pTransliteration->loadModuleIfNeeded( eOfficeLanguage );
1125 : }
1126 : OSL_ENSURE(
1127 : pTransliteration,
1128 : "ScGlobal::GetpTransliteration() called before ScGlobal::Init()");
1129 2201 : return pTransliteration;
1130 : }
1131 :
1132 505 : const LocaleDataWrapper* ScGlobal::GetpLocaleData()
1133 : {
1134 : OSL_ENSURE(
1135 : pLocaleData,
1136 : "ScGlobal::GetpLocaleData() called before ScGlobal::Init()");
1137 505 : return pLocaleData;
1138 : }
1139 10 : CalendarWrapper* ScGlobal::GetCalendar()
1140 : {
1141 10 : if ( !pCalendar )
1142 : {
1143 1 : pCalendar = new CalendarWrapper( ::comphelper::getProcessComponentContext() );
1144 1 : pCalendar->loadDefaultCalendar( *GetLocale() );
1145 : }
1146 10 : return pCalendar;
1147 : }
1148 2252 : CollatorWrapper* ScGlobal::GetCollator()
1149 : {
1150 2252 : if ( !pCollator )
1151 : {
1152 9 : pCollator = new CollatorWrapper( ::comphelper::getProcessComponentContext() );
1153 9 : pCollator->loadDefaultCollator( *GetLocale(), SC_COLLATOR_IGNORES );
1154 : }
1155 2252 : return pCollator;
1156 : }
1157 2926 : CollatorWrapper* ScGlobal::GetCaseCollator()
1158 : {
1159 2926 : if ( !pCaseCollator )
1160 : {
1161 2 : pCaseCollator = new CollatorWrapper( ::comphelper::getProcessComponentContext() );
1162 2 : pCaseCollator->loadDefaultCollator( *GetLocale(), 0 );
1163 : }
1164 2926 : return pCaseCollator;
1165 : }
1166 0 : ::utl::TransliterationWrapper* ScGlobal::GetCaseTransliteration()
1167 : {
1168 0 : if ( !pCaseTransliteration )
1169 : {
1170 0 : const LanguageType eOfficeLanguage = Application::GetSettings().GetLanguageTag().getLanguageType();
1171 0 : pCaseTransliteration = new ::utl::TransliterationWrapper(::comphelper::getProcessComponentContext(), SC_TRANSLITERATION_CASESENSE );
1172 0 : pCaseTransliteration->loadModuleIfNeeded( eOfficeLanguage );
1173 : }
1174 0 : return pCaseTransliteration;
1175 : }
1176 0 : IntlWrapper* ScGlobal::GetScIntlWrapper()
1177 : {
1178 0 : if ( !pScIntlWrapper )
1179 : {
1180 0 : pScIntlWrapper = new IntlWrapper( LanguageTag( *GetLocale()) );
1181 : }
1182 0 : return pScIntlWrapper;
1183 : }
1184 142 : ::com::sun::star::lang::Locale* ScGlobal::GetLocale()
1185 : {
1186 142 : if ( !pLocale )
1187 : {
1188 30 : pLocale = new ::com::sun::star::lang::Locale( Application::GetSettings().GetLanguageTag().getLocale());
1189 : }
1190 142 : return pLocale;
1191 93 : }
1192 :
1193 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
