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