?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge the formfield patch from ooo-build
[ooovba.git] / sc / source / core / data / global.cxx
blob4a7e08615443c26c33553688657ec4b8bf0b06cf
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: global.cxx,v $
10 * $Revision: 1.56.102.1 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33
34
35
36 // INCLUDE ---------------------------------------------------------------
37 #include <vcl/svapp.hxx>
38 #include "scitems.hxx"
39 #include <svx/algitem.hxx>
40 #include <svx/brshitem.hxx>
41 #include <svx/editobj.hxx>
42 #include <svx/scripttypeitem.hxx>
43 #include <svx/srchitem.hxx>
44 #include <svx/langitem.hxx>
45 #include <sfx2/docfile.hxx>
46 #include <sfx2/dispatch.hxx>
47 #include <sfx2/objsh.hxx>
48 #include <sfx2/viewfrm.hxx>
49 #include <sfx2/viewsh.hxx>
50 #include <svtools/stritem.hxx>
51 #include <svtools/zforlist.hxx>
52 #include <svtools/zformat.hxx>
53 #include <vcl/image.hxx>
54 #include <vcl/virdev.hxx>
55 #include <tools/rcid.h>
56 #include <unotools/charclass.hxx>
57 #include <stdlib.h>
58 #include <time.h>
59 #include <ctype.h>
60 #include <numeric>
61
62
63 #include <i18npool/mslangid.hxx>
64 #include <com/sun/star/lang/Locale.hpp>
65 #include <comphelper/processfactory.hxx>
66 #include <unotools/calendarwrapper.hxx>
67 #include <unotools/collatorwrapper.hxx>
68 #include <com/sun/star/i18n/CollatorOptions.hpp>
69 #include <unotools/intlwrapper.hxx>
70 #include <svtools/syslocale.hxx>
71 #include <unotools/transliterationwrapper.hxx>
72
73 #include "global.hxx"
74 #include "scresid.hxx"
75 #include "autoform.hxx"
76 #include "document.hxx"
77 #include "patattr.hxx"
78 #include "addincol.hxx"
79 #include "adiasync.hxx"
80 #include "userlist.hxx"
81 #include "interpre.hxx"
82 #include "strload.hxx"
83 #include "docpool.hxx"
84 #include "unitconv.hxx"
85 #include "compiler.hxx"
86 #include "parclass.hxx"
87 #include "funcdesc.hxx"
88 #include "globstr.hrc"
89 #include "scfuncs.hrc"
90 #include "sc.hrc"
91 #include "scmod.hxx"
92 #include "appoptio.hxx"
93
94 // -----------------------------------------------------------------------
95
96 #define CLIPST_AVAILABLE 0
97 #define CLIPST_CAPTURED 1
98 #define CLIPST_DELETE 2
99 #define CLIPST_DRAW 3
100
101 ScDocShellRef* ScGlobal::pDrawClipDocShellRef = NULL;
102 SvxSearchItem* ScGlobal::pSearchItem = NULL;
103 ScAutoFormat* ScGlobal::pAutoFormat = NULL;
104 FuncCollection* ScGlobal::pFuncCollection = NULL;
105 ScUnoAddInCollection* ScGlobal::pAddInCollection = NULL;
106 ScUserList* ScGlobal::pUserList = NULL;
107 String** ScGlobal::ppRscString = NULL;
108 LanguageType ScGlobal::eLnge = LANGUAGE_SYSTEM;
109 ::com::sun::star::lang::Locale* ScGlobal::pLocale = NULL;
110 SvtSysLocale* ScGlobal::pSysLocale = NULL;
111 const CharClass* ScGlobal::pCharClass = NULL;
112 const LocaleDataWrapper* ScGlobal::pLocaleData = NULL;
113 CalendarWrapper* ScGlobal::pCalendar = NULL;
114 CollatorWrapper* ScGlobal::pCollator = NULL;
115 CollatorWrapper* ScGlobal::pCaseCollator = NULL;
116 ::utl::TransliterationWrapper* ScGlobal::pTransliteration = NULL;
117 ::utl::TransliterationWrapper* ScGlobal::pCaseTransliteration = NULL;
118 ::com::sun::star::uno::Reference< ::com::sun::star::i18n::XOrdinalSuffix> ScGlobal::xOrdinalSuffix = NULL;
119 IntlWrapper* ScGlobal::pScIntlWrapper = NULL;
120 sal_Unicode ScGlobal::cListDelimiter = ',';
121 String* ScGlobal::pEmptyString = NULL;
122 String* ScGlobal::pStrClipDocName = NULL;
123
124 SvxBrushItem* ScGlobal::pEmptyBrushItem = NULL;
125 SvxBrushItem* ScGlobal::pButtonBrushItem = NULL;
126 SvxBrushItem* ScGlobal::pEmbeddedBrushItem = NULL;
127 SvxBrushItem* ScGlobal::pProtectedBrushItem = NULL;
128
129 ImageList* ScGlobal::pOutlineBitmaps = NULL;
130 ImageList* ScGlobal::pOutlineBitmapsHC = NULL;
131
132 ScFunctionList* ScGlobal::pStarCalcFunctionList = NULL;
133 ScFunctionMgr* ScGlobal::pStarCalcFunctionMgr = NULL;
134
135 ScUnitConverter* ScGlobal::pUnitConverter = NULL;
136 SvNumberFormatter* ScGlobal::pEnglishFormatter = NULL;
137
138 double ScGlobal::nScreenPPTX = 96.0;
139 double ScGlobal::nScreenPPTY = 96.0;
140
141 USHORT ScGlobal::nDefFontHeight = 240;
142 USHORT ScGlobal::nStdRowHeight = 257;
143
144 long ScGlobal::nLastRowHeightExtra = 0;
145 long ScGlobal::nLastColWidthExtra = STD_EXTRA_WIDTH;
146
147 static USHORT nPPTZoom = 0; // ScreenZoom used to determine nScreenPPTX/Y
148
149
150 // ... oder so?
151
152 BOOL bOderSo;
153
154 bool SC_DLLPUBLIC ScGetWriteTeamInfo()
155 {
156 return bOderSo;
157 }
158
159 class SfxViewShell;
160 SfxViewShell* pScActiveViewShell = NULL; //! als Member !!!!!
161 USHORT nScClickMouseModifier = 0; //! dito
162 USHORT nScFillModeMouseModifier = 0; //! dito
163
164 // Hack: ScGlobal::GetUserList() muss InitAppOptions in der UI aufrufen,
165 // damit UserList aus Cfg geladen wird
166
167 void global_InitAppOptions();
168
169 //========================================================================
170 //
171 // statische Funktionen
172 //
173 //========================================================================
174
175 BOOL ScGlobal::HasAttrChanged( const SfxItemSet& rNewAttrs,
176 const SfxItemSet& rOldAttrs,
177 const USHORT nWhich )
178 {
179 BOOL bInvalidate = FALSE;
180 const SfxItemState eNewState = rNewAttrs.GetItemState( nWhich );
181 const SfxItemState eOldState = rOldAttrs.GetItemState( nWhich );
182
183 //----------------------------------------------------------
184
185 if ( eNewState == eOldState )
186 {
187 // beide Items gesetzt
188 // PoolItems, d.h. Pointer-Vergleich zulaessig
189 if ( SFX_ITEM_SET == eOldState )
190 bInvalidate = (&rNewAttrs.Get( nWhich ) != &rOldAttrs.Get( nWhich ));
191 }
192 else
193 {
194 // ein Default-Item dabei
195 // PoolItems, d.h. Item-Vergleich noetig
196
197 const SfxPoolItem& rOldItem = ( SFX_ITEM_SET == eOldState )
198 ? rOldAttrs.Get( nWhich )
199 : rOldAttrs.GetPool()->GetDefaultItem( nWhich );
200
201 const SfxPoolItem& rNewItem = ( SFX_ITEM_SET == eNewState )
202 ? rNewAttrs.Get( nWhich )
203 : rNewAttrs.GetPool()->GetDefaultItem( nWhich );
204
205 bInvalidate = sal::static_int_cast<BOOL>(rNewItem != rOldItem);
206 }
207
208 return bInvalidate;
209 }
210
211 ULONG ScGlobal::GetStandardFormat( SvNumberFormatter& rFormatter,
212 ULONG nFormat, short nType )
213 {
214 const SvNumberformat* pFormat = rFormatter.GetEntry( nFormat );
215 if ( pFormat )
216 return rFormatter.GetStandardFormat( nFormat, nType, pFormat->GetLanguage() );
217 return rFormatter.GetStandardFormat( nType, eLnge );
218 }
219
220 ULONG ScGlobal::GetStandardFormat( double fNumber, SvNumberFormatter& rFormatter,
221 ULONG nFormat, short nType )
222 {
223 const SvNumberformat* pFormat = rFormatter.GetEntry( nFormat );
224 if ( pFormat )
225 return rFormatter.GetStandardFormat( fNumber, nFormat, nType,
226 pFormat->GetLanguage() );
227 return rFormatter.GetStandardFormat( nType, eLnge );
228 }
229
230
231 // static
232 SvNumberFormatter* ScGlobal::GetEnglishFormatter()
233 {
234 if ( !pEnglishFormatter )
235 {
236 pEnglishFormatter = new SvNumberFormatter(
237 ::comphelper::getProcessServiceFactory(), LANGUAGE_ENGLISH_US );
238 pEnglishFormatter->SetEvalDateFormat( NF_EVALDATEFORMAT_INTL_FORMAT );
239 }
240 return pEnglishFormatter;
241 }
242
243
244 //------------------------------------------------------------------------
245
246 BOOL ScGlobal::CheckWidthInvalidate( BOOL& bNumFormatChanged,
247 const SfxItemSet& rNewAttrs,
248 const SfxItemSet& rOldAttrs )
249 {
250 // Ueberpruefen, ob Attributaenderungen in rNewAttrs gegnueber
251 // rOldAttrs die Textbreite an einer Zelle ungueltig machen
252
253 bNumFormatChanged =
254 HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_VALUE_FORMAT );
255 return ( bNumFormatChanged
256 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_LANGUAGE_FORMAT )
257 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT )
258 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT )
259 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT )
260 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_HEIGHT )
261 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT_HEIGHT )
262 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT_HEIGHT )
263 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_WEIGHT )
264 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT_WEIGHT )
265 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT_WEIGHT )
266 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_POSTURE )
267 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CJK_FONT_POSTURE )
268 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_CTL_FONT_POSTURE )
269 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_UNDERLINE )
270 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_OVERLINE )
271 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_CROSSEDOUT )
272 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_CONTOUR )
273 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_FONT_SHADOWED )
274 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_STACKED )
275 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_ROTATE_VALUE )
276 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_ROTATE_MODE )
277 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_LINEBREAK )
278 || HasAttrChanged( rNewAttrs, rOldAttrs, ATTR_MARGIN )
279 );
280 }
281
282 const SvxSearchItem& ScGlobal::GetSearchItem()
283 {
284 if (!pSearchItem)
285 {
286 pSearchItem = new SvxSearchItem( SID_SEARCH_ITEM );
287 pSearchItem->SetAppFlag( SVX_SEARCHAPP_CALC );
288 }
289 return *pSearchItem;
290 }
291
292 void ScGlobal::SetSearchItem( const SvxSearchItem& rNew )
293 {
294 // Hier waere ein Zuweisungsoperator ganz nett:
295 delete pSearchItem;
296 pSearchItem = (SvxSearchItem*)rNew.Clone();
297
298 pSearchItem->SetWhich( SID_SEARCH_ITEM );
299 }
300
301 void ScGlobal::ClearAutoFormat()
302 {
303 if (pAutoFormat!=NULL)
304 {
305 delete pAutoFormat;
306 pAutoFormat=NULL;
307 }
308 }
309
310 ScAutoFormat* ScGlobal::GetAutoFormat()
311 {
312 if ( !pAutoFormat )
313 {
314 pAutoFormat = new ScAutoFormat;
315 pAutoFormat->Load();
316 }
317
318 return pAutoFormat;
319 }
320
321 FuncCollection* ScGlobal::GetFuncCollection()
322 {
323 if (!pFuncCollection)
324 pFuncCollection = new FuncCollection();
325 return pFuncCollection;
326 }
327
328 ScUnoAddInCollection* ScGlobal::GetAddInCollection()
329 {
330 if (!pAddInCollection)
331 pAddInCollection = new ScUnoAddInCollection();
332 return pAddInCollection;
333 }
334
335 ScUserList* ScGlobal::GetUserList()
336 {
337 // Hack: Cfg-Item an der App ggF. laden
338
339 global_InitAppOptions();
340
341 if (!pUserList)
342 pUserList = new ScUserList();
343 return pUserList;
344 }
345
346 void ScGlobal::SetUserList( const ScUserList* pNewList )
347 {
348 if ( pNewList )
349 {
350 if ( !pUserList )
351 pUserList = new ScUserList( *pNewList );
352 else
353 *pUserList = *pNewList;
354 }
355 else
356 {
357 delete pUserList;
358 pUserList = NULL;
359 }
360 }
361
362 const String& ScGlobal::GetRscString( USHORT nIndex )
363 {
364 DBG_ASSERT( nIndex < STR_COUNT, "ScGlobal::GetRscString - invalid string index");
365 if( !ppRscString[ nIndex ] )
366 {
367 OpCode eOp = ocNone;
368 // Map former globstr.src strings moved to compiler.src
369 switch (nIndex)
370 {
371 case STR_NULL_ERROR:
372 eOp = ocErrNull;
373 break;
374 case STR_DIV_ZERO:
375 eOp = ocErrDivZero;
376 break;
377 case STR_NO_VALUE:
378 eOp = ocErrValue;
379 break;
380 case STR_NOREF_STR:
381 eOp = ocErrRef;
382 break;
383 case STR_NO_NAME_REF:
384 eOp = ocErrName;
385 break;
386 case STR_NUM_ERROR:
387 eOp = ocErrNum;
388 break;
389 case STR_NV_STR:
390 eOp = ocErrNA;
391 break;
392 default:
393 ; // nothing
394 }
395 if (eOp != ocNone)
396 ppRscString[ nIndex ] = new String(
397 ScCompiler::GetNativeSymbol( eOp));
398 else
399 ppRscString[ nIndex ] = new String(
400 ScRscStrLoader( RID_GLOBSTR, nIndex ).GetString());
401 }
402 return *ppRscString[ nIndex ];
403 }
404
405 String ScGlobal::GetErrorString(USHORT nErrNumber)
406 {
407 String sResStr;
408 switch (nErrNumber)
409 {
410 case NOTAVAILABLE : nErrNumber = STR_NV_STR; break;
411 case errNoRef : nErrNumber = STR_NO_REF_TABLE; break;
412 case errNoName : nErrNumber = STR_NO_NAME_REF; break;
413 case errNoAddin : nErrNumber = STR_NO_ADDIN; break;
414 case errNoMacro : nErrNumber = STR_NO_MACRO; break;
415 case errDoubleRef :
416 case errNoValue : nErrNumber = STR_NO_VALUE; break;
417 case errNoCode : nErrNumber = STR_NULL_ERROR; break;
418 case errDivisionByZero : nErrNumber = STR_DIV_ZERO; break;
419 case errIllegalFPOperation : nErrNumber = STR_NUM_ERROR; break;
420
421 default : sResStr = GetRscString(STR_ERROR_STR);
422 sResStr += String::CreateFromInt32( nErrNumber );
423 nErrNumber = 0;
424 break;
425 }
426 if( nErrNumber )
427 sResStr = GetRscString( nErrNumber );
428 return sResStr;
429 }
430
431 String ScGlobal::GetLongErrorString(USHORT nErrNumber)
432 {
433 switch (nErrNumber)
434 {
435 case 0:
436 break;
437 case 1:
438 case errIllegalArgument:
439 nErrNumber = STR_LONG_ERR_ILL_ARG;
440 break;
441 case 2:
442 case 3:
443 case 4:
444 case 5:
445 case errIllegalFPOperation:
446 nErrNumber = STR_LONG_ERR_ILL_FPO;
447 break;
448 case errIllegalChar:
449 nErrNumber = STR_LONG_ERR_ILL_CHAR;
450 break;
451 case errIllegalParameter:
452 nErrNumber = STR_LONG_ERR_ILL_PAR;
453 break;
454 case errSeparator:
455 nErrNumber = STR_LONG_ERR_ILL_SEP;
456 break;
457 case errPair:
458 case errPairExpected:
459 nErrNumber = STR_LONG_ERR_PAIR;
460 break;
461 case errOperatorExpected:
462 nErrNumber = STR_LONG_ERR_OP_EXP;
463 break;
464 case errVariableExpected:
465 case errParameterExpected:
466 nErrNumber = STR_LONG_ERR_VAR_EXP;
467 break;
468 case errCodeOverflow:
469 nErrNumber = STR_LONG_ERR_CODE_OVF;
470 break;
471 case errStringOverflow:
472 nErrNumber = STR_LONG_ERR_STR_OVF;
473 break;
474 case errStackOverflow:
475 case errInterpOverflow:
476 nErrNumber = STR_LONG_ERR_STACK_OVF;
477 break;
478 case errIllegalJump:
479 case errUnknownState:
480 case errUnknownVariable:
481 case errUnknownOpCode:
482 case errUnknownStackVariable:
483 case errUnknownToken:
484 case errNoCode:
485 case errDoubleRef:
486 nErrNumber = STR_LONG_ERR_SYNTAX;
487 break;
488 case errCircularReference:
489 nErrNumber = STR_LONG_ERR_CIRC_REF;
490 break;
491 case errNoConvergence:
492 nErrNumber = STR_LONG_ERR_NO_CONV;
493 break;
494 case errNoRef:
495 nErrNumber = STR_LONG_ERR_NO_REF;
496 break;
497 case errNoName:
498 nErrNumber = STR_LONG_ERR_NO_NAME;
499 break;
500 case errNoAddin:
501 nErrNumber = STR_LONG_ERR_NO_ADDIN;
502 break;
503 case errNoMacro:
504 nErrNumber = STR_LONG_ERR_NO_MACRO;
505 break;
506 case errDivisionByZero:
507 nErrNumber = STR_LONG_ERR_DIV_ZERO;
508 break;
509 case errNestedArray:
510 nErrNumber = STR_ERR_LONG_NESTED_ARRAY;
511 break;
512 case errNoValue:
513 nErrNumber = STR_LONG_ERR_NO_VALUE;
514 break;
515 case NOTAVAILABLE:
516 nErrNumber = STR_LONG_ERR_NV;
517 break;
518 default:
519 nErrNumber = STR_ERROR_STR;
520 break;
521 }
522 String aRes( GetRscString( nErrNumber ) );
523 if( bOderSo )
524 {
525 String aOderSo( GetRscString( STR_ODER_SO ) );
526 aOderSo.SearchAndReplace( String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("%s")), aRes );
527 aRes = aOderSo;
528 }
529 return aRes;
530 }
531
532 SvxBrushItem* ScGlobal::GetButtonBrushItem()
533 {
534 pButtonBrushItem->SetColor( Application::GetSettings().GetStyleSettings().GetFaceColor() );
535 return pButtonBrushItem;
536 }
537
538 const String& ScGlobal::GetEmptyString()
539 {
540 return *pEmptyString;
541 }
542
543 ImageList* ScGlobal::GetOutlineSymbols( bool bHC )
544 {
545 ImageList*& rpImageList = bHC ? pOutlineBitmapsHC : pOutlineBitmaps;
546 if( !rpImageList )
547 rpImageList = new ImageList( ScResId( bHC ? RID_OUTLINEBITMAPS_H : RID_OUTLINEBITMAPS ) );
548 return rpImageList;
549 }
550
551 void ScGlobal::Init()
552 {
553 pEmptyString = new String;
554
555 // Die Default-Sprache fuer Zahlenformate (ScGlobal::eLnge)
556 // muss immer LANGUAGE_SYSTEM sein
557 //! Dann kann auch die Variable raus
558 eLnge = LANGUAGE_SYSTEM;
559
560 //! Wenn Sortierung etc. von der Sprache der installierten Offfice-Version
561 //! abhaengen sollen, hier "Application::GetSettings().GetUILanguage()"
562 pSysLocale = new SvtSysLocale;
563 pCharClass = pSysLocale->GetCharClassPtr();
564 pLocaleData = pSysLocale->GetLocaleDataPtr();
565
566 ppRscString = new String *[ STR_COUNT ];
567 for( USHORT nC = 0 ; nC < STR_COUNT ; nC++ ) ppRscString[ nC ] = NULL;
568
569 pEmptyBrushItem = new SvxBrushItem( Color( COL_TRANSPARENT ), ATTR_BACKGROUND );
570 pButtonBrushItem = new SvxBrushItem( Color(), ATTR_BACKGROUND );
571 pEmbeddedBrushItem = new SvxBrushItem( Color( COL_LIGHTCYAN ), ATTR_BACKGROUND );
572 pProtectedBrushItem = new SvxBrushItem( Color( COL_LIGHTGRAY ), ATTR_BACKGROUND );
573
574 UpdatePPT(NULL);
575 //ScCompiler::InitSymbolsNative();
576 // ScParameterClassification _after_ Compiler, needs function resources if
577 // arguments are to be merged in, which in turn need strings of function
578 // names from the compiler.
579 ScParameterClassification::Init();
580 srand( (unsigned) time( NULL ) ); // Random Seed Init fuer Interpreter
581
582 InitAddIns();
583
584 pStrClipDocName = new String( ScResId( SCSTR_NONAME ) );
585 *pStrClipDocName += '1';
586
587 // ScDocumentPool::InitVersionMaps() ist schon vorher gerufen worden
588 }
589
590 void ScGlobal::UpdatePPT( OutputDevice* pDev )
591 {
592 USHORT nCurrentZoom = Application::GetSettings().GetStyleSettings().GetScreenZoom();
593 if ( nCurrentZoom != nPPTZoom )
594 {
595 // Screen PPT values must be updated when ScreenZoom has changed.
596 // If called from Window::DataChanged, the window is passed as pDev,
597 // to make sure LogicToPixel uses a device which already uses the new zoom.
598 // For the initial settings, NULL is passed and GetDefaultDevice used.
599
600 if ( !pDev )
601 pDev = Application::GetDefaultDevice();
602 Point aPix1000 = pDev->LogicToPixel( Point(1000,1000), MAP_TWIP );
603 nScreenPPTX = aPix1000.X() / 1000.0;
604 nScreenPPTY = aPix1000.Y() / 1000.0;
605 nPPTZoom = nCurrentZoom;
606 }
607 }
608
609 const String& ScGlobal::GetClipDocName()
610 {
611 return *pStrClipDocName;
612 }
613
614 void ScGlobal::SetClipDocName( const String& rNew )
615 {
616 *pStrClipDocName = rNew;
617 }
618
619
620 void ScGlobal::InitTextHeight(SfxItemPool* pPool)
621 {
622 if (!pPool)
623 {
624 DBG_ERROR("kein Pool bei ScGlobal::InitTextHeight");
625 return;
626 }
627
628 const ScPatternAttr* pPattern = (const ScPatternAttr*)&pPool->GetDefaultItem(ATTR_PATTERN);
629 if (!pPattern)
630 {
631 DBG_ERROR("kein Default-Pattern bei ScGlobal::InitTextHeight");
632 return;
633 }
634
635 // String aTestString('X');
636 OutputDevice* pDefaultDev = Application::GetDefaultDevice();
637 VirtualDevice aVirtWindow( *pDefaultDev );
638 aVirtWindow.SetMapMode(MAP_PIXEL);
639 Font aDefFont;
640 pPattern->GetFont(aDefFont, SC_AUTOCOL_BLACK, &aVirtWindow); // font color doesn't matter here
641 aVirtWindow.SetFont(aDefFont);
642 nDefFontHeight = (USHORT) aVirtWindow.PixelToLogic(Size(0, aVirtWindow.GetTextHeight()),
643 MAP_TWIP).Height();
644
645 const SvxMarginItem* pMargin = (const SvxMarginItem*)&pPattern->GetItem(ATTR_MARGIN);
646
647 nStdRowHeight = (USHORT) ( nDefFontHeight +
648 pMargin->GetTopMargin() + pMargin->GetBottomMargin()
649 - STD_ROWHEIGHT_DIFF );
650 }
651
652 void ScGlobal::Clear()
653 {
654 // asyncs _vor_ ExitExternalFunc zerstoeren!
655 theAddInAsyncTbl.DeleteAndDestroy( 0, theAddInAsyncTbl.Count() );
656 ExitExternalFunc();
657 DELETEZ(pAutoFormat);
658 DELETEZ(pSearchItem);
659 DELETEZ(pFuncCollection);
660 DELETEZ(pAddInCollection);
661 DELETEZ(pUserList);
662
663 for( USHORT nC = 0 ; nC < STR_COUNT ; nC++ )
664 if( ppRscString ) delete ppRscString[ nC ];
665 delete[] ppRscString;
666 ppRscString = NULL;
667
668 DELETEZ(pStarCalcFunctionList); // vor ResMgr zerstoeren!
669 DELETEZ(pStarCalcFunctionMgr);
670 ScParameterClassification::Exit();
671 ScCompiler::DeInit();
672 ScInterpreter::GlobalExit(); // statischen Stack loeschen
673
674 DELETEZ(pEmptyBrushItem);
675 DELETEZ(pButtonBrushItem);
676 DELETEZ(pEmbeddedBrushItem);
677 DELETEZ(pProtectedBrushItem);
678 DELETEZ(pOutlineBitmaps);
679 DELETEZ(pOutlineBitmapsHC);
680 // DELETEZ(pAnchorBitmap);
681 // DELETEZ(pGrayAnchorBitmap);
682 DELETEZ(pEnglishFormatter);
683 DELETEZ(pCaseTransliteration);
684 DELETEZ(pTransliteration);
685 DELETEZ(pCaseCollator);
686 DELETEZ(pCollator);
687 DELETEZ(pCalendar);
688 //! do NOT delete pCharClass since it is a pointer to the single SvtSysLocale instance
689 pCharClass = NULL;
690 //! do NOT delete pLocaleData since it is a pointer to the single SvtSysLocale instance
691 pLocaleData = NULL;
692 DELETEZ(pSysLocale);
693 DELETEZ(pLocale);
694 DELETEZ(pScIntlWrapper);
695 DELETEZ(pStrClipDocName);
696
697 DELETEZ(pUnitConverter);
698
699 ScDocumentPool::DeleteVersionMaps();
700
701 DELETEZ(pEmptyString);
702 }
703
704 //------------------------------------------------------------------------
705
706 // static
707 CharSet ScGlobal::GetCharsetValue( const String& rCharSet )
708 {
709 // new TextEncoding values
710 if ( CharClass::isAsciiNumeric( rCharSet ) )
711 {
712 sal_Int32 nVal = rCharSet.ToInt32();
713 if ( !nVal || nVal == RTL_TEXTENCODING_DONTKNOW )
714 return gsl_getSystemTextEncoding();
715 return (CharSet) nVal;
716 }
717 // old CharSet values for compatibility
718 else if (rCharSet.EqualsIgnoreCaseAscii("ANSI") ) return RTL_TEXTENCODING_MS_1252;
719 else if (rCharSet.EqualsIgnoreCaseAscii("MAC") ) return RTL_TEXTENCODING_APPLE_ROMAN;
720 else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC") ) return RTL_TEXTENCODING_IBM_850;
721 else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_437")) return RTL_TEXTENCODING_IBM_437;
722 else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_850")) return RTL_TEXTENCODING_IBM_850;
723 else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_860")) return RTL_TEXTENCODING_IBM_860;
724 else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_861")) return RTL_TEXTENCODING_IBM_861;
725 else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_863")) return RTL_TEXTENCODING_IBM_863;
726 else if (rCharSet.EqualsIgnoreCaseAscii("IBMPC_865")) return RTL_TEXTENCODING_IBM_865;
727 // else if (rCharSet.EqualsIgnoreCaseAscii("SYSTEM") ) return gsl_getSystemTextEncoding();
728 else return gsl_getSystemTextEncoding();
729 }
730
731 //------------------------------------------------------------------------
732
733 // static
734 String ScGlobal::GetCharsetString( CharSet eVal )
735 {
736 const sal_Char* pChar;
737 switch ( eVal )
738 {
739 // old CharSet strings for compatibility
740 case RTL_TEXTENCODING_MS_1252: pChar = "ANSI"; break;
741 case RTL_TEXTENCODING_APPLE_ROMAN: pChar = "MAC"; break;
742 // IBMPC == IBMPC_850
743 case RTL_TEXTENCODING_IBM_437: pChar = "IBMPC_437"; break;
744 case RTL_TEXTENCODING_IBM_850: pChar = "IBMPC_850"; break;
745 case RTL_TEXTENCODING_IBM_860: pChar = "IBMPC_860"; break;
746 case RTL_TEXTENCODING_IBM_861: pChar = "IBMPC_861"; break;
747 case RTL_TEXTENCODING_IBM_863: pChar = "IBMPC_863"; break;
748 case RTL_TEXTENCODING_IBM_865: pChar = "IBMPC_865"; break;
749 case RTL_TEXTENCODING_DONTKNOW: pChar = "SYSTEM"; break;
750 // new string of TextEncoding value
751 default:
752 return String::CreateFromInt32( eVal );
753 }
754 return String::CreateFromAscii(pChar);
755 }
756
757 //------------------------------------------------------------------------
758
759 bool ScGlobal::HasStarCalcFunctionList()
760 {
761 return ( pStarCalcFunctionList != NULL );
762 }
763
764 ScFunctionList* ScGlobal::GetStarCalcFunctionList()
765 {
766 if ( !pStarCalcFunctionList )
767 pStarCalcFunctionList = new ScFunctionList;
768
769 return pStarCalcFunctionList;
770 }
771
772 //------------------------------------------------------------------------
773
774 ScFunctionMgr* ScGlobal::GetStarCalcFunctionMgr()
775 {
776 if ( !pStarCalcFunctionMgr )
777 pStarCalcFunctionMgr = new ScFunctionMgr;
778
779 return pStarCalcFunctionMgr;
780 }
781
782 void ScGlobal::ResetFunctionList()
783 {
784 // FunctionMgr has pointers into FunctionList, must also be updated
785
786 DELETEZ( pStarCalcFunctionMgr );
787 DELETEZ( pStarCalcFunctionList );
788 }
789
790 //------------------------------------------------------------------------
791
792 // static
793 ScUnitConverter* ScGlobal::GetUnitConverter()
794 {
795 if ( !pUnitConverter )
796 pUnitConverter = new ScUnitConverter;
797
798 return pUnitConverter;
799 }
800
801
802 //------------------------------------------------------------------------
803
804 // static
805 const sal_Unicode* ScGlobal::UnicodeStrChr( const sal_Unicode* pStr,
806 sal_Unicode c )
807 {
808 if ( !pStr )
809 return NULL;
810 while ( *pStr )
811 {
812 if ( *pStr == c )
813 return pStr;
814 pStr++;
815 }
816 return NULL;
817 }
818
819 // ----------------------------------------------------------------------------
820
821 void ScGlobal::AddToken( String& rTokenList, const String& rToken, sal_Unicode cSep, xub_StrLen nSepCount, bool bForceSep )
822 {
823 if( bForceSep || (rToken.Len() && rTokenList.Len()) )
824 rTokenList.Expand( rTokenList.Len() + nSepCount, cSep );
825 rTokenList.Append( rToken );
826 }
827
828 bool ScGlobal::IsQuoted( const String& rString, sal_Unicode cQuote )
829 {
830 return (rString.Len() >= 2) && (rString.GetChar( 0 ) == cQuote) && (rString.GetChar( rString.Len() - 1 ) == cQuote);
831 }
832
833 void ScGlobal::AddQuotes( String& rString, sal_Unicode cQuote, bool bEscapeEmbedded )
834 {
835 if (bEscapeEmbedded)
836 {
837 sal_Unicode pQ[3];
838 pQ[0] = pQ[1] = cQuote;
839 pQ[2] = 0;
840 String aQuotes( pQ );
841 rString.SearchAndReplaceAll( cQuote, aQuotes);
842 }
843 rString.Insert( cQuote, 0 ).Append( cQuote );
844 }
845
846 void ScGlobal::EraseQuotes( String& rString, sal_Unicode cQuote, bool bUnescapeEmbedded )
847 {
848 if ( IsQuoted( rString, cQuote ) )
849 {
850 rString.Erase( rString.Len() - 1 ).Erase( 0, 1 );
851 if (bUnescapeEmbedded)
852 {
853 sal_Unicode pQ[3];
854 pQ[0] = pQ[1] = cQuote;
855 pQ[2] = 0;
856 String aQuotes( pQ );
857 rString.SearchAndReplaceAll( aQuotes, cQuote);
858 }
859 }
860 }
861
862 xub_StrLen ScGlobal::FindUnquoted( const String& rString, sal_Unicode cChar, xub_StrLen nStart, sal_Unicode cQuote )
863 {
864 const sal_Unicode* const pStart = rString.GetBuffer();
865 const sal_Unicode* const pStop = pStart + rString.Len();
866 const sal_Unicode* p = pStart + nStart;
867 bool bQuoted = false;
868 while (p < pStop)
869 {
870 if (*p == cChar && !bQuoted)
871 return sal::static_int_cast< xub_StrLen >( p - pStart );
872 else if (*p == cQuote)
873 {
874 if (!bQuoted)
875 bQuoted = true;
876 else if (p < pStop-1 && *(p+1) == cQuote)
877 ++p;
878 else
879 bQuoted = false;
880 }
881 ++p;
882 }
883 return STRING_NOTFOUND;
884 }
885
886 const sal_Unicode* ScGlobal::FindUnquoted( const sal_Unicode* pString, sal_Unicode cChar, sal_Unicode cQuote )
887 {
888 const sal_Unicode* p = pString;
889 bool bQuoted = false;
890 while (*p)
891 {
892 if (*p == cChar && !bQuoted)
893 return p;
894 else if (*p == cQuote)
895 {
896 if (!bQuoted)
897 bQuoted = true;
898 else if (*(p+1) == cQuote)
899 ++p;
900 else
901 bQuoted = false;
902 }
903 ++p;
904 }
905 return NULL;
906 }
907
908 //------------------------------------------------------------------------
909
910 BOOL ScGlobal::EETextObjEqual( const EditTextObject* pObj1,
911 const EditTextObject* pObj2 )
912 {
913 if ( pObj1 == pObj2 ) // both empty or the same object
914 return TRUE;
915
916 if ( pObj1 && pObj2 )
917 {
918 // first test for equal text content
919 USHORT nParCount = pObj1->GetParagraphCount();
920 if ( nParCount != pObj2->GetParagraphCount() )
921 return FALSE;
922 for (USHORT nPar=0; nPar<nParCount; nPar++)
923 if ( pObj1->GetText(nPar) != pObj2->GetText(nPar) )
924 return FALSE;
925
926 SvMemoryStream aStream1;
927 SvMemoryStream aStream2;
928 pObj1->Store( aStream1 );
929 pObj2->Store( aStream2 );
930 ULONG nSize = aStream1.Tell();
931 if ( aStream2.Tell() == nSize )
932 if ( !memcmp( aStream1.GetData(), aStream2.GetData(), (USHORT) nSize ) )
933 return TRUE;
934 }
935
936 return FALSE;
937 }
938
939 void ScGlobal::OpenURL( const String& rURL, const String& rTarget )
940 {
941 // OpenURL wird immer ueber irgendwelche Umwege durch Mausklicks im GridWindow
942 // aufgerufen, darum stimmen pScActiveViewShell und nScClickMouseModifier.
943
944 SfxStringItem aUrl( SID_FILE_NAME, rURL );
945 SfxStringItem aTarget( SID_TARGETNAME, rTarget );
946
947 if ( nScClickMouseModifier & KEY_MOD1 ) // control-click -> into new window
948 aTarget.SetValue(
949 String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("_blank")) );
950
951 SfxViewFrame* pFrame = NULL;
952 String aReferName;
953 if ( pScActiveViewShell )
954 {
955 pFrame = pScActiveViewShell->GetViewFrame();
956 SfxMedium* pMed = pFrame->GetObjectShell()->GetMedium();
957 if (pMed)
958 aReferName = pMed->GetName();
959 }
960
961 SfxFrameItem aFrm( SID_DOCFRAME, pFrame );
962 SfxStringItem aReferer( SID_REFERER, aReferName );
963
964 SfxBoolItem aNewView( SID_OPEN_NEW_VIEW, FALSE );
965 SfxBoolItem aBrowsing( SID_BROWSE, TRUE );
966
967 // kein SID_SILENT mehr wegen Bug #42525# (war angeblich sowieso falsch)
968
969 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
970 if (pViewFrm)
971 pViewFrm->GetDispatcher()->Execute( SID_OPENDOC,
972 SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
973 &aUrl, &aTarget,
974 &aFrm, &aReferer,
975 &aNewView, &aBrowsing,
976 0L );
977 }
978
979 //------------------------------------------------------------------------
980
981 BOOL ScGlobal::IsSystemRTL()
982 {
983 return MsLangId::isRightToLeft( Application::GetSettings().GetLanguage() );
984 }
985
986 BYTE ScGlobal::GetDefaultScriptType()
987 {
988 // Used when text contains only WEAK characters.
989 // Script type of office language is used then (same as GetEditDefaultLanguage,
990 // to get consistent behavior of text in simple cells and EditEngine,
991 // also same as GetAppLanguage() in Writer)
992
993 return (BYTE) SvtLanguageOptions::GetScriptTypeOfLanguage( Application::GetSettings().GetLanguage() );
994 }
995
996 LanguageType ScGlobal::GetEditDefaultLanguage()
997 {
998 // used for EditEngine::SetDefaultLanguage
999
1000 return Application::GetSettings().GetLanguage();
1001 }
1002
1003 USHORT ScGlobal::GetScriptedWhichID( BYTE nScriptType, USHORT nWhich )
1004 {
1005 switch ( nScriptType )
1006 {
1007 case SCRIPTTYPE_LATIN:
1008 case SCRIPTTYPE_ASIAN:
1009 case SCRIPTTYPE_COMPLEX:
1010 break; // take exact matches
1011 default: // prefer one, first COMPLEX, then ASIAN
1012 if ( nScriptType & SCRIPTTYPE_COMPLEX )
1013 nScriptType = SCRIPTTYPE_COMPLEX;
1014 else if ( nScriptType & SCRIPTTYPE_ASIAN )
1015 nScriptType = SCRIPTTYPE_ASIAN;
1016 }
1017 switch ( nScriptType )
1018 {
1019 case SCRIPTTYPE_COMPLEX:
1020 {
1021 switch ( nWhich )
1022 {
1023 case ATTR_FONT:
1024 case ATTR_CJK_FONT:
1025 nWhich = ATTR_CTL_FONT;
1026 break;
1027 case ATTR_FONT_HEIGHT:
1028 case ATTR_CJK_FONT_HEIGHT:
1029 nWhich = ATTR_CTL_FONT_HEIGHT;
1030 break;
1031 case ATTR_FONT_WEIGHT:
1032 case ATTR_CJK_FONT_WEIGHT:
1033 nWhich = ATTR_CTL_FONT_WEIGHT;
1034 break;
1035 case ATTR_FONT_POSTURE:
1036 case ATTR_CJK_FONT_POSTURE:
1037 nWhich = ATTR_CTL_FONT_POSTURE;
1038 break;
1039 }
1040 }
1041 break;
1042 case SCRIPTTYPE_ASIAN:
1043 {
1044 switch ( nWhich )
1045 {
1046 case ATTR_FONT:
1047 case ATTR_CTL_FONT:
1048 nWhich = ATTR_CJK_FONT;
1049 break;
1050 case ATTR_FONT_HEIGHT:
1051 case ATTR_CTL_FONT_HEIGHT:
1052 nWhich = ATTR_CJK_FONT_HEIGHT;
1053 break;
1054 case ATTR_FONT_WEIGHT:
1055 case ATTR_CTL_FONT_WEIGHT:
1056 nWhich = ATTR_CJK_FONT_WEIGHT;
1057 break;
1058 case ATTR_FONT_POSTURE:
1059 case ATTR_CTL_FONT_POSTURE:
1060 nWhich = ATTR_CJK_FONT_POSTURE;
1061 break;
1062 }
1063 }
1064 break;
1065 default:
1066 {
1067 switch ( nWhich )
1068 {
1069 case ATTR_CTL_FONT:
1070 case ATTR_CJK_FONT:
1071 nWhich = ATTR_FONT;
1072 break;
1073 case ATTR_CTL_FONT_HEIGHT:
1074 case ATTR_CJK_FONT_HEIGHT:
1075 nWhich = ATTR_FONT_HEIGHT;
1076 break;
1077 case ATTR_CTL_FONT_WEIGHT:
1078 case ATTR_CJK_FONT_WEIGHT:
1079 nWhich = ATTR_FONT_WEIGHT;
1080 break;
1081 case ATTR_CTL_FONT_POSTURE:
1082 case ATTR_CJK_FONT_POSTURE:
1083 nWhich = ATTR_FONT_POSTURE;
1084 break;
1085 }
1086 }
1087 }
1088 return nWhich;
1089 }
1090
1091 //------------------------------------------------------------------------
1092
1093 void ScGlobal::AddLanguage( SfxItemSet& rSet, SvNumberFormatter& rFormatter )
1094 {
1095 DBG_ASSERT( rSet.GetItemState( ATTR_LANGUAGE_FORMAT, FALSE ) == SFX_ITEM_DEFAULT,
1096 "ScGlobal::AddLanguage - language already added");
1097
1098 const SfxPoolItem* pHardItem;
1099 if ( rSet.GetItemState( ATTR_VALUE_FORMAT, FALSE, &pHardItem ) == SFX_ITEM_SET )
1100 {
1101 const SvNumberformat* pHardFormat = rFormatter.GetEntry(
1102 ((const SfxUInt32Item*)pHardItem)->GetValue() );
1103
1104 ULONG nParentFmt = 0; // pool default
1105 const SfxItemSet* pParent = rSet.GetParent();
1106 if ( pParent )
1107 nParentFmt = ((const SfxUInt32Item&)pParent->Get( ATTR_VALUE_FORMAT )).GetValue();
1108 const SvNumberformat* pParFormat = rFormatter.GetEntry( nParentFmt );
1109
1110 if ( pHardFormat && pParFormat &&
1111 (pHardFormat->GetLanguage() != pParFormat->GetLanguage()) )
1112 rSet.Put( SvxLanguageItem( pHardFormat->GetLanguage(), ATTR_LANGUAGE_FORMAT ) );
1113 }
1114 }
1115
1116
1117
1118
1119
1120 //===================================================================
1121 // class ScFunctionList:
1122 //===================================================================
1123
1124 //===================================================================
1125 // class ScFuncRes
1126 // fuer temporaere Objekte zum Holen der Resourcen
1127
1128 class ScFuncRes : public Resource
1129 {
1130 public:
1131 ScFuncRes( ResId&, ScFuncDesc*, bool & rbSuppressed );
1132
1133 private:
1134 USHORT GetNum();
1135 };
1136
1137 //--------------------------------------------------------------------
1138
1139 ScFuncRes::ScFuncRes( ResId &aRes, ScFuncDesc* pDesc, bool & rbSuppressed )
1140 : Resource(aRes)
1141 {
1142 rbSuppressed = (bool)GetNum();
1143 pDesc->nCategory = GetNum();
1144 pDesc->nHelpId = GetNum() + 32768; //! Hack, see scfuncs.src
1145 pDesc->nArgCount = GetNum();
1146 USHORT nArgs = pDesc->nArgCount;
1147 if (nArgs >= VAR_ARGS)
1148 nArgs -= VAR_ARGS - 1;
1149 if (nArgs)
1150 {
1151 pDesc->pDefArgFlags = new ScFuncDesc::ParameterFlags[nArgs];
1152 for (USHORT i = 0; i < nArgs; i++)
1153 {
1154 pDesc->pDefArgFlags[i].bOptional = (bool)GetNum();
1155 }
1156 }
1157 // Need to read the value from the resource even if nArgs==0 to advance the
1158 // resource position pointer, so this can't be in the if(nArgs) block above.
1159 USHORT nSuppressed = GetNum();
1160 if (nSuppressed)
1161 {
1162 if (nSuppressed > nArgs)
1163 {
1164 DBG_ERROR3( "ScFuncRes: suppressed parameters count mismatch on OpCode %u: suppressed %d > params %d",
1165 aRes.GetId(), (int)nSuppressed, (int)nArgs);
1166 nSuppressed = nArgs; // sanitize
1167 }
1168 for (USHORT i=0; i < nSuppressed; ++i)
1169 {
1170 USHORT nParam = GetNum();
1171 if (nParam < nArgs)
1172 {
1173 if (pDesc->nArgCount >= VAR_ARGS && nParam == nArgs-1)
1174 {
1175 DBG_ERROR3( "ScFuncRes: VAR_ARGS parameters can't be suppressed, on OpCode %u: param %d == arg %d-1",
1176 aRes.GetId(), (int)nParam, (int)nArgs);
1177 }
1178 else
1179 {
1180 pDesc->pDefArgFlags[nParam].bSuppress = true;
1181 pDesc->bHasSuppressedArgs = true;
1182 }
1183 }
1184 else
1185 {
1186 DBG_ERROR3( "ScFuncRes: suppressed parameter exceeds count on OpCode %u: param %d >= args %d",
1187 aRes.GetId(), (int)nParam, (int)nArgs);
1188 }
1189 }
1190 }
1191
1192 pDesc->pFuncName = new String( ScCompiler::GetNativeSymbol( static_cast<OpCode>( aRes.GetId())));
1193 pDesc->pFuncDesc = new String(ScResId(1));
1194
1195 if (nArgs)
1196 {
1197 pDesc->ppDefArgNames = new String*[nArgs];
1198 pDesc->ppDefArgDescs = new String*[nArgs];
1199 for (USHORT i = 0; i < nArgs; i++)
1200 {
1201 pDesc->ppDefArgNames[i] = new String(ScResId(2*(i+1) ));
1202 pDesc->ppDefArgDescs[i] = new String(ScResId(2*(i+1)+1));
1203 }
1204 }
1205
1206 FreeResource();
1207 }
1208
1209 //------------------------------------------------------------------------
1210
1211 USHORT ScFuncRes::GetNum()
1212 {
1213 return ReadShortRes();
1214 }
1215
1216 //=========================================================================
1217
1218 // um an die protected von Resource ranzukommen
1219 class ScResourcePublisher : public Resource
1220 {
1221 private:
1222 void FreeResource() { Resource::FreeResource(); }
1223 public:
1224 ScResourcePublisher( const ScResId& rId ) : Resource( rId ) {}
1225 ~ScResourcePublisher() { FreeResource(); }
1226 BOOL IsAvailableRes( const ResId& rId ) const
1227 { return Resource::IsAvailableRes( rId ); }
1228
1229 };
1230
1231
1232 ScFunctionList::ScFunctionList() :
1233 nMaxFuncNameLen ( 0 )
1234 {
1235 ScFuncDesc* pDesc = NULL;
1236 xub_StrLen nStrLen = 0;
1237 FuncCollection* pFuncColl;
1238 USHORT i,j;
1239 USHORT nDescBlock[] =
1240 {
1241 RID_SC_FUNCTION_DESCRIPTIONS1,
1242 RID_SC_FUNCTION_DESCRIPTIONS2
1243 };
1244 const USHORT nBlocks = sizeof(nDescBlock) / sizeof(USHORT);
1245
1246 aFunctionList.Clear();
1247
1248 for ( USHORT k = 0; k < nBlocks; k++ )
1249 {
1250 ::std::auto_ptr<ScResourcePublisher> pBlock( new ScResourcePublisher( ScResId( nDescBlock[k] ) ) );
1251 // Browse for all possible OpCodes. This is not the fastest method, but
1252 // otherwise the sub resources within the resource blocks and the
1253 // resource blocks themselfs would had to be ordered according to
1254 // OpCodes, which is utopian..
1255 for (i = 0; i <= SC_OPCODE_LAST_OPCODE_ID; i++)
1256 {
1257 ScResId aRes(i);
1258 aRes.SetRT(RSC_RESOURCE);
1259 // Sub resource of OpCode available?
1260 if (pBlock->IsAvailableRes(aRes))
1261 {
1262 pDesc = new ScFuncDesc;
1263 bool bSuppressed = false;
1264 ScFuncRes aSubRes( aRes, pDesc, bSuppressed);
1265 // Instead of dealing with this exceptional case at 1001 places
1266 // we simply don't add an entirely suppressed function to the
1267 // list and delete it.
1268 if (bSuppressed)
1269 delete pDesc;
1270 else
1271 {
1272 pDesc->nFIndex = i;
1273 aFunctionList.Insert( pDesc, LIST_APPEND );
1274
1275 nStrLen = (*(pDesc->pFuncName)).Len();
1276 if (nStrLen > nMaxFuncNameLen)
1277 nMaxFuncNameLen = nStrLen;
1278 }
1279 }
1280 }
1281 }
1282
1283 USHORT nNextId = SC_OPCODE_LAST_OPCODE_ID + 1; // FuncID for AddIn functions
1284
1285 // Auswertung AddIn-Liste
1286 String aDefArgNameValue(RTL_CONSTASCII_STRINGPARAM("value"));
1287 String aDefArgNameString(RTL_CONSTASCII_STRINGPARAM("string"));
1288 String aDefArgNameValues(RTL_CONSTASCII_STRINGPARAM("values"));
1289 String aDefArgNameStrings(RTL_CONSTASCII_STRINGPARAM("strings"));
1290 String aDefArgNameCells(RTL_CONSTASCII_STRINGPARAM("cells"));
1291 String aDefArgNameNone(RTL_CONSTASCII_STRINGPARAM("none"));
1292 String aDefArgDescValue(RTL_CONSTASCII_STRINGPARAM("a value"));
1293 String aDefArgDescString(RTL_CONSTASCII_STRINGPARAM("a string"));
1294 String aDefArgDescValues(RTL_CONSTASCII_STRINGPARAM("array of values"));
1295 String aDefArgDescStrings(RTL_CONSTASCII_STRINGPARAM("array of strings"));
1296 String aDefArgDescCells(RTL_CONSTASCII_STRINGPARAM("range of cells"));
1297 String aDefArgDescNone(RTL_CONSTASCII_STRINGPARAM("none"));
1298 String aArgName, aArgDesc;
1299 pFuncColl = ScGlobal::GetFuncCollection();
1300 for (i = 0; i < pFuncColl->GetCount(); i++)
1301 {
1302 pDesc = new ScFuncDesc;
1303 FuncData *pAddInFuncData = (FuncData*)pFuncColl->At(i);
1304 USHORT nArgs = pAddInFuncData->GetParamCount() - 1;
1305 pAddInFuncData->GetParamDesc( aArgName, aArgDesc, 0 );
1306 pDesc->nFIndex = nNextId++; // ??? OpCode vergeben
1307 pDesc->nCategory = ID_FUNCTION_GRP_ADDINS;
1308 pDesc->pFuncName = new String(pAddInFuncData->GetInternalName());
1309 pDesc->pFuncName->ToUpperAscii();
1310 pDesc->pFuncDesc = new String( aArgDesc );
1311 *(pDesc->pFuncDesc) += '\n';
1312 pDesc->pFuncDesc->AppendAscii(RTL_CONSTASCII_STRINGPARAM( "( AddIn: " ));
1313 *(pDesc->pFuncDesc) += pAddInFuncData->GetModuleName();
1314 pDesc->pFuncDesc->AppendAscii(RTL_CONSTASCII_STRINGPARAM( " )" ));
1315 pDesc->nArgCount = nArgs;
1316 if (nArgs)
1317 {
1318 pDesc->pDefArgFlags = new ScFuncDesc::ParameterFlags[nArgs];
1319 pDesc->ppDefArgNames = new String*[nArgs];
1320 pDesc->ppDefArgDescs = new String*[nArgs];
1321 for (j = 0; j < nArgs; j++)
1322 {
1323 pDesc->pDefArgFlags[j].bOptional = false;
1324 pDesc->pDefArgFlags[j].bSuppress = false;
1325 pAddInFuncData->GetParamDesc( aArgName, aArgDesc, j+1 );
1326 if ( aArgName.Len() )
1327 pDesc->ppDefArgNames[j] = new String( aArgName );
1328 else
1329 {
1330 switch (pAddInFuncData->GetParamType(j+1))
1331 {
1332 case PTR_DOUBLE:
1333 pDesc->ppDefArgNames[j] = new String( aDefArgNameValue );
1334 break;
1335 case PTR_STRING:
1336 pDesc->ppDefArgNames[j] = new String( aDefArgNameString );
1337 break;
1338 case PTR_DOUBLE_ARR:
1339 pDesc->ppDefArgNames[j] = new String( aDefArgNameValues );
1340 break;
1341 case PTR_STRING_ARR:
1342 pDesc->ppDefArgNames[j] = new String( aDefArgNameStrings );
1343 break;
1344 case PTR_CELL_ARR:
1345 pDesc->ppDefArgNames[j] = new String( aDefArgNameCells );
1346 break;
1347 default:
1348 pDesc->ppDefArgNames[j] = new String( aDefArgNameNone );
1349 break;
1350 }
1351 }
1352 if ( aArgDesc.Len() )
1353 pDesc->ppDefArgDescs[j] = new String( aArgDesc );
1354 else
1355 {
1356 switch (pAddInFuncData->GetParamType(j+1))
1357 {
1358 case PTR_DOUBLE:
1359 pDesc->ppDefArgDescs[j] = new String( aDefArgDescValue );
1360 break;
1361 case PTR_STRING:
1362 pDesc->ppDefArgDescs[j] = new String( aDefArgDescString );
1363 break;
1364 case PTR_DOUBLE_ARR:
1365 pDesc->ppDefArgDescs[j] = new String( aDefArgDescValues );
1366 break;
1367 case PTR_STRING_ARR:
1368 pDesc->ppDefArgDescs[j] = new String( aDefArgDescStrings );
1369 break;
1370 case PTR_CELL_ARR:
1371 pDesc->ppDefArgDescs[j] = new String( aDefArgDescCells );
1372 break;
1373 default:
1374 pDesc->ppDefArgDescs[j] = new String( aDefArgDescNone );
1375 break;
1376 }
1377 }
1378 }
1379 }
1380 // pDesc->nHelpId = 0;
1381
1382 aFunctionList.Insert(pDesc, LIST_APPEND);
1383 nStrLen = (*(pDesc->pFuncName)).Len();
1384 if ( nStrLen > nMaxFuncNameLen)
1385 nMaxFuncNameLen = nStrLen;
1386 }
1387
1388 // StarOne AddIns
1389
1390 ScUnoAddInCollection* pUnoAddIns = ScGlobal::GetAddInCollection();
1391 long nUnoCount = pUnoAddIns->GetFuncCount();
1392 for (long nFunc=0; nFunc<nUnoCount; nFunc++)
1393 {
1394 pDesc = new ScFuncDesc;
1395 pDesc->nFIndex = nNextId++;
1396
1397 if ( pUnoAddIns->FillFunctionDesc( nFunc, *pDesc ) )
1398 {
1399 aFunctionList.Insert(pDesc, LIST_APPEND);
1400 nStrLen = (*(pDesc->pFuncName)).Len();
1401 if (nStrLen > nMaxFuncNameLen)
1402 nMaxFuncNameLen = nStrLen;
1403 }
1404 else
1405 delete pDesc;
1406 }
1407 }
1408
1409 //------------------------------------------------------------------------
1410
1411 ScFunctionList::~ScFunctionList()
1412 {
1413 const ScFuncDesc* pDesc = First();
1414 while (pDesc)
1415 {
1416 delete pDesc;
1417 pDesc = Next();
1418 }
1419 }
1420
1421
1422 //========================================================================
1423 // class ScFuncDesc:
1424
1425 ScFuncDesc::ScFuncDesc() :
1426 pFuncName (NULL),
1427 pFuncDesc (NULL),
1428 ppDefArgNames (NULL),
1429 ppDefArgDescs (NULL),
1430 pDefArgFlags (NULL),
1431 nFIndex (0),
1432 nCategory (0),
1433 nArgCount (0),
1434 nHelpId (0),
1435 bIncomplete (false),
1436 bHasSuppressedArgs(false)
1437 {}
1438
1439 //------------------------------------------------------------------------
1440
1441 ScFuncDesc::~ScFuncDesc()
1442 {
1443 Clear();
1444 }
1445
1446 //------------------------------------------------------------------------
1447
1448 void ScFuncDesc::Clear()
1449 {
1450 USHORT nArgs = nArgCount;
1451 if (nArgs >= VAR_ARGS) nArgs -= VAR_ARGS-1;
1452 if (nArgs)
1453 {
1454 for (USHORT i=0; i<nArgs; i++ )
1455 {
1456 delete ppDefArgNames[i];
1457 delete ppDefArgDescs[i];
1458 }
1459 delete [] ppDefArgNames;
1460 delete [] ppDefArgDescs;
1461 delete [] pDefArgFlags;
1462 }
1463 nArgCount = 0;
1464 ppDefArgNames = NULL;
1465 ppDefArgDescs = NULL;
1466 pDefArgFlags = NULL;
1467
1468 delete pFuncName;
1469 pFuncName = NULL;
1470
1471 delete pFuncDesc;
1472 pFuncDesc = NULL;
1473
1474 nFIndex = 0;
1475 nCategory = 0;
1476 nHelpId = 0;
1477 bIncomplete = false;
1478 bHasSuppressedArgs = false;
1479 }
1480
1481 //------------------------------------------------------------------------
1482
1483 String ScFuncDesc::GetParamList() const
1484 {
1485 const String& sep = ScCompiler::GetNativeSymbol(ocSep);
1486
1487 String aSig;
1488
1489 if ( nArgCount > 0 )
1490 {
1491 if ( nArgCount < VAR_ARGS )
1492 {
1493 USHORT nLastSuppressed = nArgCount;
1494 USHORT nLastAdded = nArgCount;
1495 for ( USHORT i=0; i<nArgCount; i++ )
1496 {
1497 if (pDefArgFlags[i].bSuppress)
1498 nLastSuppressed = i;
1499 else
1500 {
1501 nLastAdded = i;
1502 aSig += *(ppDefArgNames[i]);
1503 if ( i != nArgCount-1 )
1504 {
1505 aSig.Append(sep);
1506 aSig.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " " ));
1507 }
1508 }
1509 }
1510 // If only suppressed parameters follow the last added parameter,
1511 // remove one "; "
1512 if (nLastSuppressed < nArgCount && nLastAdded < nLastSuppressed &&
1513 aSig.Len() >= 2)
1514 aSig.Erase( aSig.Len() - 2 );
1515 }
1516 else
1517 {
1518 USHORT nFix = nArgCount - VAR_ARGS;
1519 for ( USHORT nArg = 0; nArg < nFix; nArg++ )
1520 {
1521 if (!pDefArgFlags[nArg].bSuppress)
1522 {
1523 aSig += *(ppDefArgNames[nArg]);
1524 aSig.Append(sep);
1525 aSig.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " " ));
1526 }
1527 }
1528 /* NOTE: Currently there are no suppressed var args parameters. If
1529 * there were, we'd have to cope with it here and above for the fix
1530 * parameters. For now parameters are always added, so no special
1531 * treatment of a trailing "; " necessary. */
1532 aSig += *(ppDefArgNames[nFix]);
1533 aSig += '1';
1534 aSig.Append(sep);
1535 aSig.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " " ));
1536 aSig += *(ppDefArgNames[nFix]);
1537 aSig += '2';
1538 aSig.Append(sep);
1539 aSig.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " ... " ));
1540 }
1541 }
1542
1543 return aSig;
1544 }
1545
1546 //------------------------------------------------------------------------
1547
1548 String ScFuncDesc::GetSignature() const
1549 {
1550 String aSig;
1551
1552 if(pFuncName)
1553 {
1554 aSig = *pFuncName;
1555
1556 String aParamList( GetParamList() );
1557 if( aParamList.Len() )
1558 {
1559 aSig.AppendAscii(RTL_CONSTASCII_STRINGPARAM( "( " ));
1560 aSig.Append( aParamList );
1561 // U+00A0 (NBSP) prevents automatic line break
1562 aSig.Append( static_cast< sal_Unicode >(0xA0) ).Append( ')' );
1563 }
1564 else
1565 aSig.AppendAscii(RTL_CONSTASCII_STRINGPARAM( "()" ));
1566 }
1567 return aSig;
1568 }
1569
1570 //------------------------------------------------------------------------
1571
1572 ::rtl::OUString ScFuncDesc::getFormula( const ::std::vector< ::rtl::OUString >& _aArguments ) const
1573 {
1574 const String& sep = ScCompiler::GetNativeSymbol(ocSep);
1575
1576 ::rtl::OUStringBuffer aFormula;
1577
1578 if(pFuncName)
1579 {
1580 aFormula.append( *pFuncName );
1581
1582 aFormula.appendAscii( "(" );
1583 ::std::vector< ::rtl::OUString >::const_iterator aIter = _aArguments.begin();
1584 ::std::vector< ::rtl::OUString >::const_iterator aEnd = _aArguments.end();
1585
1586 if ( nArgCount > 0 && aIter != aEnd )
1587 {
1588 BOOL bLastArg = ( aIter->getLength() == 0 );
1589
1590 while( aIter != aEnd && !bLastArg )
1591 {
1592 aFormula.append( *(aIter) );
1593 if ( aIter != (aEnd-1) )
1594 {
1595 bLastArg = !( (aIter+1)->getLength() > 0 );
1596 if ( !bLastArg )
1597 aFormula.append( sep );
1598 }
1599
1600 ++aIter;
1601 }
1602 }
1603
1604 aFormula.appendAscii( ")" );
1605 }
1606 return aFormula.makeStringAndClear();
1607 }
1608
1609 //------------------------------------------------------------------------
1610
1611 USHORT ScFuncDesc::GetSuppressedArgCount() const
1612 {
1613 if (!bHasSuppressedArgs || !pDefArgFlags)
1614 return nArgCount;
1615
1616 USHORT nArgs = nArgCount;
1617 if (nArgs >= VAR_ARGS)
1618 nArgs -= VAR_ARGS - 1;
1619 USHORT nCount = nArgs;
1620 for (USHORT i=0; i < nArgs; ++i)
1621 {
1622 if (pDefArgFlags[i].bSuppress)
1623 --nCount;
1624 }
1625 if (nArgCount >= VAR_ARGS)
1626 nCount += VAR_ARGS - 1;
1627 return nCount;
1628 }
1629
1630 //------------------------------------------------------------------------
1631
1632 ::rtl::OUString ScFuncDesc::getFunctionName() const
1633 {
1634 ::rtl::OUString sRet;
1635 if ( pFuncName )
1636 sRet = *pFuncName;
1637 return sRet;
1638 }
1639 // -----------------------------------------------------------------------------
1640 const formula::IFunctionCategory* ScFuncDesc::getCategory() const
1641 {
1642 return ScGlobal::GetStarCalcFunctionMgr()->getCategory(nCategory);
1643 }
1644 // -----------------------------------------------------------------------------
1645 ::rtl::OUString ScFuncDesc::getDescription() const
1646 {
1647 ::rtl::OUString sRet;
1648 if ( pFuncDesc )
1649 sRet = *pFuncDesc;
1650 return sRet;
1651 }
1652 // -----------------------------------------------------------------------------
1653 // GetSuppressedArgCount
1654 xub_StrLen ScFuncDesc::getSuppressedArgumentCount() const
1655 {
1656 return GetSuppressedArgCount();
1657 }
1658 // -----------------------------------------------------------------------------
1659 //
1660 void ScFuncDesc::fillVisibleArgumentMapping(::std::vector<USHORT>& _rArguments) const
1661 {
1662 if (!bHasSuppressedArgs || !pDefArgFlags)
1663 {
1664 _rArguments.resize( nArgCount);
1665 ::std::iota( _rArguments.begin(), _rArguments.end(), 0);
1666 }
1667
1668 _rArguments.reserve( nArgCount);
1669 USHORT nArgs = nArgCount;
1670 if (nArgs >= VAR_ARGS)
1671 nArgs -= VAR_ARGS - 1;
1672 for (USHORT i=0; i < nArgs; ++i)
1673 {
1674 if (!pDefArgFlags[i].bSuppress)
1675 _rArguments.push_back(i);
1676 }
1677 }
1678 // -----------------------------------------------------------------------------
1679 void ScFuncDesc::initArgumentInfo() const
1680 {
1681 // get the full argument description
1682 // (add-in has to be instantiated to get the type information)
1683
1684 if ( bIncomplete && pFuncName )
1685 {
1686 ScUnoAddInCollection& rAddIns = *ScGlobal::GetAddInCollection();
1687 String aIntName = rAddIns.FindFunction( *pFuncName, TRUE ); // pFuncName is upper-case
1688
1689 if ( aIntName.Len() )
1690 {
1691 // GetFuncData with bComplete=true loads the component and updates
1692 // the global function list if needed.
1693
1694 rAddIns.GetFuncData( aIntName, true );
1695 }
1696
1697 if ( bIncomplete )
1698 {
1699 DBG_ERRORFILE( "couldn't initialize add-in function" );
1700 const_cast<ScFuncDesc*>(this)->bIncomplete = FALSE; // even if there was an error, don't try again
1701 }
1702 }
1703 }
1704 // -----------------------------------------------------------------------------
1705 ::rtl::OUString ScFuncDesc::getSignature() const
1706 {
1707 return GetSignature();
1708 }
1709 // -----------------------------------------------------------------------------
1710 long ScFuncDesc::getHelpId() const
1711 {
1712 return nHelpId;
1713 }
1714 // -----------------------------------------------------------------------------
1715
1716 // parameter
1717 sal_uInt32 ScFuncDesc::getParameterCount() const
1718 {
1719 return nArgCount;
1720 }
1721 // -----------------------------------------------------------------------------
1722 ::rtl::OUString ScFuncDesc::getParameterName(sal_uInt32 _nPos) const
1723 {
1724 return *(ppDefArgNames[_nPos]);
1725 }
1726 // -----------------------------------------------------------------------------
1727 ::rtl::OUString ScFuncDesc::getParameterDescription(sal_uInt32 _nPos) const
1728 {
1729 return *(ppDefArgDescs[_nPos]);
1730 }
1731 // -----------------------------------------------------------------------------
1732 bool ScFuncDesc::isParameterOptional(sal_uInt32 _nPos) const
1733 {
1734 return pDefArgFlags[_nPos].bOptional;
1735 }
1736 // -----------------------------------------------------------------------------
1737 //========================================================================
1738 // class ScFunctionMgr:
1739
1740 ScFunctionMgr::ScFunctionMgr()
1741 : pFuncList ( ScGlobal::GetStarCalcFunctionList() ),
1742 pCurCatList ( NULL )
1743 {
1744 DBG_ASSERT( pFuncList, "Funktionsliste nicht gefunden." );
1745 ULONG nCount = pFuncList->GetCount();
1746 const ScFuncDesc* pDesc;
1747 List* pRootList;
1748 ULONG n;
1749
1750 for ( USHORT i=0; i<MAX_FUNCCAT; i++ ) // Kategorie-Listen erstellen
1751 aCatLists[i] = new List;
1752
1753 pRootList = aCatLists[0]; // Gesamtliste ("Alle") erstellen
1754 CollatorWrapper* pCaseCollator = ScGlobal::GetCaseCollator();
1755 for ( n=0; n<nCount; n++ )
1756 {
1757 ULONG nTmpCnt=0;
1758 pDesc = pFuncList->GetFunction(n);
1759 for (nTmpCnt = 0; nTmpCnt < n; nTmpCnt++)
1760 {
1761 // ist zwar case-sensitiv, aber Umlaute muessen richtig einsortiert werden
1762
1763 const ScFuncDesc* pTmpDesc = (const ScFuncDesc*)pRootList->GetObject(nTmpCnt);
1764 if ( pCaseCollator->compareString(*pDesc->pFuncName, *pTmpDesc->pFuncName ) == COMPARE_LESS )
1765 break;
1766 }
1767 pRootList->Insert((void*)pDesc, nTmpCnt); // Einsortieren
1768 }
1769
1770 for ( n=0; n<nCount; n++ ) // in Gruppenlisten kopieren
1771 {
1772 pDesc = (const ScFuncDesc*)pRootList->GetObject(n);
1773 DBG_ASSERT((pDesc->nCategory) < MAX_FUNCCAT, "Unbekannte Kategorie");
1774 if ((pDesc->nCategory) < MAX_FUNCCAT)
1775 aCatLists[pDesc->nCategory]->Insert((void*)pDesc, LIST_APPEND);
1776 }
1777 }
1778
1779 //------------------------------------------------------------------------
1780
1781 ScFunctionMgr::~ScFunctionMgr()
1782 {
1783 for (USHORT i = 0; i < MAX_FUNCCAT; i++)
1784 delete aCatLists[i];
1785 // delete pFuncList; // Macht spaeter die App
1786 }
1787
1788 //------------------------------------------------------------------------
1789
1790 const ScFuncDesc* ScFunctionMgr::Get( const String& rFName ) const
1791 {
1792 const ScFuncDesc* pDesc = NULL;
1793 if (rFName.Len() <= pFuncList->GetMaxFuncNameLen())
1794 for (pDesc = First(0); pDesc; pDesc = Next())
1795 if (rFName.EqualsIgnoreCaseAscii(*(pDesc->pFuncName)))
1796 break;
1797 return pDesc;
1798 }
1799
1800 //------------------------------------------------------------------------
1801
1802 const ScFuncDesc* ScFunctionMgr::Get( USHORT nFIndex ) const
1803 {
1804 const ScFuncDesc* pDesc;
1805 for (pDesc = First(0); pDesc; pDesc = Next())
1806 if (pDesc->nFIndex == nFIndex)
1807 break;
1808 return pDesc;
1809 }
1810
1811 //------------------------------------------------------------------------
1812
1813 const ScFuncDesc* ScFunctionMgr::First( USHORT nCategory ) const
1814 {
1815 DBG_ASSERT( nCategory < MAX_FUNCCAT, "Unbekannte Kategorie" );
1816
1817 if ( nCategory < MAX_FUNCCAT )
1818 {
1819 pCurCatList = aCatLists[nCategory];
1820 return (const ScFuncDesc*)pCurCatList->First();
1821 }
1822 else
1823 {
1824 pCurCatList = NULL;
1825 return NULL;
1826 }
1827 }
1828
1829 //------------------------------------------------------------------------
1830
1831 const ScFuncDesc* ScFunctionMgr::Next() const
1832 {
1833 if ( pCurCatList )
1834 return (const ScFuncDesc*)pCurCatList->Next();
1835 else
1836 return NULL;
1837 }
1838 sal_uInt32 ScFunctionMgr::getCount() const
1839 {
1840 return MAX_FUNCCAT - 1;
1841 }
1842 const formula::IFunctionCategory* ScFunctionMgr::getCategory(sal_uInt32 nCategory) const
1843 {
1844 formula::IFunctionCategory* pRet = NULL;
1845 if ( nCategory < (MAX_FUNCCAT-1) )
1846 {
1847 pRet = new ScFunctionCategory(const_cast<ScFunctionMgr*>(this),aCatLists[nCategory+1],nCategory); // aCatLists[0] is "all"
1848 }
1849 return pRet;
1850 }
1851 // -----------------------------------------------------------------------------
1852 const formula::IFunctionDescription* ScFunctionMgr::getFunctionByName(const ::rtl::OUString& _sFunctionName) const
1853 {
1854 return Get(_sFunctionName);
1855 }
1856 // -----------------------------------------------------------------------------
1857 void ScFunctionMgr::fillLastRecentlyUsedFunctions(::std::vector< const formula::IFunctionDescription*>& _rLastRUFunctions) const
1858 {
1859 #define LRU_MAX 10
1860
1861 const ScAppOptions& rAppOpt = SC_MOD()->GetAppOptions();
1862 USHORT nLRUFuncCount = Min( rAppOpt.GetLRUFuncListCount(), (USHORT)LRU_MAX );
1863 USHORT* pLRUListIds = rAppOpt.GetLRUFuncList();
1864
1865 if ( pLRUListIds )
1866 {
1867 for ( USHORT i=0; i<nLRUFuncCount; i++ )
1868 _rLastRUFunctions.push_back( Get( pLRUListIds[i] ) );
1869 }
1870 }
1871 // -----------------------------------------------------------------------------
1872 String ScFunctionMgr::GetCategoryName(sal_uInt32 _nCategoryNumber )
1873 {
1874 if ( _nCategoryNumber > SC_FUNCGROUP_COUNT )
1875 {
1876 DBG_ERROR("Invalid category number!");
1877 return String();
1878 } // if ( _nCategoryNumber >= SC_FUNCGROUP_COUNT )
1879
1880 ::std::auto_ptr<ScResourcePublisher> pCategories( new ScResourcePublisher( ScResId( RID_FUNCTION_CATEGORIES ) ) );
1881 return String(ScResId((USHORT)_nCategoryNumber));
1882 }
1883 sal_Unicode ScFunctionMgr::getSingleToken(const formula::IFunctionManager::EToken _eToken) const
1884 {
1885 switch(_eToken)
1886 {
1887 case eOk:
1888 return ScCompiler::GetNativeSymbol(ocOpen).GetChar(0);
1889 case eClose:
1890 return ScCompiler::GetNativeSymbol(ocClose).GetChar(0);
1891 case eSep:
1892 return ScCompiler::GetNativeSymbol(ocSep).GetChar(0);
1893 case eArrayOpen:
1894 return ScCompiler::GetNativeSymbol(ocArrayOpen).GetChar(0);
1895 case eArrayClose:
1896 return ScCompiler::GetNativeSymbol(ocArrayClose).GetChar(0);
1897 } // switch(_eToken)
1898 return 0;
1899 }
1900 // -----------------------------------------------------------------------------
1901 sal_uInt32 ScFunctionCategory::getCount() const
1902 {
1903 return m_pCategory->Count();
1904 }
1905 // -----------------------------------------------------------------------------
1906 const formula::IFunctionManager* ScFunctionCategory::getFunctionManager() const
1907 {
1908 return m_pMgr;
1909 }
1910 // -----------------------------------------------------------------------------
1911 ::rtl::OUString ScFunctionCategory::getName() const
1912 {
1913 if ( !m_sName.getLength() )
1914 m_sName = ScFunctionMgr::GetCategoryName(m_nCategory+1);
1915 return m_sName;
1916 }
1917 // -----------------------------------------------------------------------------
1918 const formula::IFunctionDescription* ScFunctionCategory::getFunction(sal_uInt32 _nPos) const
1919 {
1920 const ScFuncDesc* pDesc = NULL;
1921 sal_uInt32 i = 0;
1922 for (pDesc = (const ScFuncDesc*)m_pCategory->First(); i < _nPos && pDesc; pDesc = (const ScFuncDesc*)m_pCategory->Next(),++i)
1923 ;
1924 return pDesc;
1925 }
1926 // -----------------------------------------------------------------------------
1927 sal_uInt32 ScFunctionCategory::getNumber() const
1928 {
1929 return m_nCategory;
1930 }
1931 // -----------------------------------------------------------------------------
1932
1933 //------------------------------------------------------------------------
1934
1935 utl::TransliterationWrapper* ScGlobal::GetpTransliteration() //add by CHINA001
1936 {
1937 if ( !pTransliteration )
1938 {
1939 const LanguageType eOfficeLanguage = Application::GetSettings().GetLanguage();
1940 pTransliteration = new ::utl::TransliterationWrapper(
1941 ::comphelper::getProcessServiceFactory(), SC_TRANSLITERATION_IGNORECASE );
1942 pTransliteration->loadModuleIfNeeded( eOfficeLanguage );
1943 }
1944 DBG_ASSERT(
1945 pTransliteration,
1946 "ScGlobal::GetpTransliteration() called before ScGlobal::Init()");
1947 return pTransliteration;
1948 }
1949
1950 const LocaleDataWrapper* ScGlobal::GetpLocaleData()
1951 {
1952 DBG_ASSERT(
1953 pLocaleData,
1954 "ScGlobal::GetpLocaleData() called before ScGlobal::Init()");
1955 return pLocaleData;
1956 }
1957 CalendarWrapper* ScGlobal::GetCalendar()
1958 {
1959 if ( !pCalendar )
1960 {
1961 pCalendar = new CalendarWrapper( ::comphelper::getProcessServiceFactory() );
1962 pCalendar->loadDefaultCalendar( *GetLocale() );
1963 }
1964 return pCalendar;
1965 }
1966 CollatorWrapper* ScGlobal::GetCollator()
1967 {
1968 if ( !pCollator )
1969 {
1970 pCollator = new CollatorWrapper( ::comphelper::getProcessServiceFactory() );
1971 pCollator->loadDefaultCollator( *GetLocale(), SC_COLLATOR_IGNORES );
1972 } // if ( !pCollator )
1973 return pCollator;
1974 }
1975 CollatorWrapper* ScGlobal::GetCaseCollator()
1976 {
1977 if ( !pCaseCollator )
1978 {
1979 pCaseCollator = new CollatorWrapper( ::comphelper::getProcessServiceFactory() );
1980 pCaseCollator->loadDefaultCollator( *GetLocale(), 0 );
1981 } // if ( !pCaseCollator )
1982 return pCaseCollator;
1983 }
1984 ::utl::TransliterationWrapper* ScGlobal::GetCaseTransliteration()
1985 {
1986 if ( !pCaseTransliteration )
1987 {
1988 const LanguageType eOfficeLanguage = Application::GetSettings().GetLanguage();
1989 pCaseTransliteration = new ::utl::TransliterationWrapper(::comphelper::getProcessServiceFactory(), SC_TRANSLITERATION_CASESENSE );
1990 pCaseTransliteration->loadModuleIfNeeded( eOfficeLanguage );
1991 } // if ( !pCaseTransliteration )
1992 return pCaseTransliteration;
1993 }
1994 IntlWrapper* ScGlobal::GetScIntlWrapper()
1995 {
1996 if ( !pScIntlWrapper )
1997 {
1998 pScIntlWrapper = new IntlWrapper( ::comphelper::getProcessServiceFactory(), *GetLocale() );
1999 }
2000 return pScIntlWrapper;
2001 }
2002 ::com::sun::star::lang::Locale* ScGlobal::GetLocale()
2003 {
2004 if ( !pLocale )
2005 {
2006 pLocale = new ::com::sun::star::lang::Locale( Application::GetSettings().GetLocale());
2007 }
2008 return pLocale;
2009 }
2010
vba interoperability for OOo