1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2011 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 #ifndef SC_DOCUMENT_HXX 29 #define SC_DOCUMENT_HXX 30 31 32 #include <vcl/prntypes.hxx> 33 #include <vcl/timer.hxx> 34 #include <com/sun/star/uno/Reference.hxx> 35 #include <vos/ref.hxx> 36 #include "scdllapi.h" 37 #include "table.hxx" // FastGetRowHeight (inline) 38 #include "rangelst.hxx" 39 #include "brdcst.hxx" 40 #include "tabopparams.hxx" 41 #include "formula/grammar.hxx" 42 #include <com/sun/star/chart2/XChartDocument.hpp> 43 #include "scdllapi.h" 44 45 #include <memory> 46 #include <map> 47 #include <set> 48 49 // Wang Xu Ming -- 2009-8-17 50 // DataPilot Migration - Cache&&Performance 51 #include <list> 52 class ScDPTableDataCache; 53 // End Comments 54 55 class KeyEvent; 56 class OutputDevice; 57 class SdrObject; 58 class SfxBroadcaster; 59 class SfxListener; 60 class SfxHint; 61 class SfxItemSet; 62 class SfxObjectShell; 63 class SfxBindings; 64 class SfxPoolItem; 65 class SfxItemPool; 66 class SfxPrinter; 67 class SfxStatusBarManager; 68 class SfxStyleSheetBase; 69 class SvMemoryStream; 70 class SvNumberFormatter; 71 class SvxBorderLine; 72 class SvxBoxInfoItem; 73 class SvxBoxItem; 74 class SvxBrushItem; 75 class SvxForbiddenCharactersTable; 76 namespace sfx2 { 77 class LinkManager; 78 } 79 class SvxSearchItem; 80 class SvxShadowItem; 81 class Window; 82 class XColorTable; 83 class List; 84 85 class ScAutoFormatData; 86 class ScBaseCell; 87 class ScStringCell; 88 class ScBroadcastAreaSlotMachine; 89 class ScChangeViewSettings; 90 class ScChartCollection; 91 class ScChartListenerCollection; 92 class ScConditionalFormat; 93 class ScConditionalFormatList; 94 class ScDBCollection; 95 class ScDBData; 96 class ScDetOpData; 97 class ScDetOpList; 98 class ScDocOptions; 99 class ScDocProtection; 100 class ScDocumentPool; 101 class ScDrawLayer; 102 class ScExtDocOptions; 103 class ScExternalRefManager; 104 class ScFormulaCell; 105 class ScMarkData; 106 class ScOutlineTable; 107 class ScPatternAttr; 108 class ScPrintRangeSaver; 109 class ScRangeData; 110 class ScRangeName; 111 class ScStyleSheet; 112 class ScStyleSheetPool; 113 class ScTable; 114 class ScTableProtection; 115 class ScTokenArray; 116 class ScValidationData; 117 class ScValidationDataList; 118 class ScViewOptions; 119 class ScStrCollection; 120 class TypedScStrCollection; 121 class ScChangeTrack; 122 class ScEditEngineDefaulter; 123 class ScFieldEditEngine; 124 class ScNoteEditEngine; 125 struct ScConsolidateParam; 126 class ScDPObject; 127 class ScDPCollection; 128 class ScMatrix; 129 class ScScriptTypeData; 130 class ScPoolHelper; 131 struct ScSortParam; 132 class ScRefreshTimerControl; 133 class ScUnoListenerCalls; 134 class ScUnoRefList; 135 class ScRecursionHelper; 136 struct RowInfo; 137 struct ScTableInfo; 138 struct ScTabOpParam; 139 class VirtualDevice; 140 class ScAutoNameCache; 141 class ScTemporaryChartLock; 142 class ScLookupCache; 143 struct ScLookupCacheMapImpl; 144 class SfxUndoManager; 145 class ScFormulaParserPool; 146 struct ScClipParam; 147 struct ScClipRangeNameData; 148 class ScRowBreakIterator; 149 150 namespace com { namespace sun { namespace star { 151 namespace lang { 152 class XMultiServiceFactory; 153 struct EventObject; 154 } 155 namespace i18n { 156 class XBreakIterator; 157 } 158 namespace util { 159 class XModifyListener; 160 } 161 namespace embed { 162 class XEmbeddedObject; 163 } 164 namespace script { namespace vba { 165 class XVBAEventProcessor; 166 } } 167 namespace sheet { 168 struct TablePageBreakData; 169 } 170 } } } 171 172 #include <svl/zforlist.hxx> 173 /* 174 #ifdef _ZFORLIST_DECLARE_TABLE 175 class SvNumberFormatterIndexTable; 176 #else 177 class Table; 178 typedef Table SvNumberFormatterIndexTable; 179 #endif 180 */ 181 182 #define SC_DOC_NEW 0xFFFF 183 184 #define SC_MACROCALL_ALLOWED 0 185 #define SC_MACROCALL_NOTALLOWED 1 186 #define SC_MACROCALL_ASK 2 187 188 #define SC_ASIANCOMPRESSION_INVALID 0xff 189 #define SC_ASIANKERNING_INVALID 0xff 190 191 192 enum ScDocumentMode 193 { 194 SCDOCMODE_DOCUMENT, 195 SCDOCMODE_CLIP, 196 SCDOCMODE_UNDO 197 }; 198 199 200 struct ScDocStat 201 { 202 String aDocName; 203 SCTAB nTableCount; 204 sal_uLong nCellCount; 205 sal_uInt16 nPageCount; 206 }; 207 208 // The constant parameters to CopyBlockFromClip 209 struct ScCopyBlockFromClipParams 210 { 211 ScDocument* pRefUndoDoc; 212 ScDocument* pClipDoc; 213 sal_uInt16 nInsFlag; 214 SCTAB nTabStart; 215 SCTAB nTabEnd; 216 sal_Bool bAsLink; 217 sal_Bool bSkipAttrForEmpty; 218 }; 219 220 221 // for loading of binary file format symbol string cells which need font conversion 222 struct ScSymbolStringCellEntry 223 { 224 ScStringCell* pCell; 225 SCROW nRow; 226 }; 227 228 229 // ----------------------------------------------------------------------- 230 231 // DDE link modes 232 const sal_uInt8 SC_DDE_DEFAULT = 0; 233 const sal_uInt8 SC_DDE_ENGLISH = 1; 234 const sal_uInt8 SC_DDE_TEXT = 2; 235 const sal_uInt8 SC_DDE_IGNOREMODE = 255; /// For usage in FindDdeLink() only! 236 237 238 // ----------------------------------------------------------------------- 239 240 class ScDocument 241 { 242 friend class ScDocumentIterator; 243 friend class ScValueIterator; 244 friend class ScHorizontalValueIterator; 245 friend class ScDBQueryDataIterator; 246 friend class ScCellIterator; 247 friend class ScQueryCellIterator; 248 friend class ScHorizontalCellIterator; 249 friend class ScHorizontalAttrIterator; 250 friend class ScDocAttrIterator; 251 friend class ScAttrRectIterator; 252 friend class ScDocShell; 253 254 private: 255 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xServiceManager; 256 257 vos::ORef<ScPoolHelper> xPoolHelper; 258 259 SfxUndoManager* mpUndoManager; 260 ScFieldEditEngine* pEditEngine; // uses pEditPool from xPoolHelper 261 ScNoteEditEngine* pNoteEngine; // uses pEditPool from xPoolHelper 262 SfxItemPool* pNoteItemPool; // SfxItemPool to be used if pDrawLayer not created. 263 SfxObjectShell* pShell; 264 SfxPrinter* pPrinter; 265 VirtualDevice* pVirtualDevice_100th_mm; 266 ScDrawLayer* pDrawLayer; // SdrModel 267 XColorTable* pColorTable; 268 ScConditionalFormatList* pCondFormList; // bedingte Formate 269 ScValidationDataList* pValidationList; // Gueltigkeit 270 SvNumberFormatterIndexTable* pFormatExchangeList; // zum Umsetzen von Zahlenformaten 271 ScTable* pTab[MAXTABCOUNT]; 272 ScRangeName* pRangeName; 273 ScDBCollection* pDBCollection; 274 ScDPCollection* pDPCollection; 275 // Wang Xu Ming -- 2009-8-17 276 // DataPilot Migration - Cache&&Performance 277 std::list<ScDPTableDataCache*> m_listDPObjectsCaches; 278 // End Comments 279 ScChartCollection* pChartCollection; 280 std::auto_ptr< ScTemporaryChartLock > apTemporaryChartLock; 281 ScPatternAttr* pSelectionAttr; // Attribute eines Blocks 282 mutable sfx2::LinkManager* pLinkManager; 283 ScFormulaCell* pFormulaTree; // Berechnungsbaum Start 284 ScFormulaCell* pEOFormulaTree; // Berechnungsbaum Ende, letzte Zelle 285 ScFormulaCell* pFormulaTrack; // BroadcastTrack Start 286 ScFormulaCell* pEOFormulaTrack; // BrodcastTrack Ende, letzte Zelle 287 ScBroadcastAreaSlotMachine* pBASM; // BroadcastAreas 288 ScChartListenerCollection* pChartListenerCollection; 289 ScStrCollection* pOtherObjects; // non-chart OLE objects 290 SvMemoryStream* pClipData; 291 ScDetOpList* pDetOpList; 292 ScChangeTrack* pChangeTrack; 293 SfxBroadcaster* pUnoBroadcaster; 294 ScUnoListenerCalls* pUnoListenerCalls; 295 ScUnoRefList* pUnoRefUndoList; 296 ScChangeViewSettings* pChangeViewSettings; 297 ScScriptTypeData* pScriptTypeData; 298 ScRefreshTimerControl* pRefreshTimerControl; 299 vos::ORef<SvxForbiddenCharactersTable> xForbiddenCharacters; 300 301 ScFieldEditEngine* pCacheFieldEditEngine; 302 303 ::std::auto_ptr<ScDocProtection> pDocProtection; 304 ::std::auto_ptr<ScClipParam> mpClipParam; 305 306 ::std::auto_ptr<ScExternalRefManager> pExternalRefMgr; 307 308 // mutable for lazy construction 309 mutable ::std::auto_ptr< ScFormulaParserPool > 310 mxFormulaParserPool; /// Pool for all external formula parsers used by this document. 311 312 String aDocName; // opt: Dokumentname 313 String aDocCodeName; // opt: Dokumentname 314 ScRangePairListRef xColNameRanges; 315 ScRangePairListRef xRowNameRanges; 316 317 ScViewOptions* pViewOptions; // View-Optionen 318 ScDocOptions* pDocOptions; // Dokument-Optionen 319 ScExtDocOptions* pExtDocOptions; // fuer Import etc. 320 ScConsolidateParam* pConsolidateDlgData; 321 322 ScRecursionHelper* pRecursionHelper; // information for recursive and iterative cell formulas 323 324 ScAutoNameCache* pAutoNameCache; // for automatic name lookup during CompileXML 325 326 ScLookupCacheMapImpl* pLookupCacheMapImpl; // cache for lookups like VLOOKUP and MATCH 327 328 sal_Int64 nUnoObjectId; // counted up for UNO objects 329 330 sal_uInt32 nRangeOverflowType; // used in (xml) loading for overflow warnings 331 332 ScRange aEmbedRange; 333 ScAddress aCurTextWidthCalcPos; 334 ScAddress aOnlineSpellPos; // within whole document 335 ScRange aVisSpellRange; 336 ScAddress aVisSpellPos; // within aVisSpellRange (see nVisSpellState) 337 338 Timer aTrackTimer; 339 340 com::sun::star::uno::Reference< com::sun::star::script::vba::XVBAEventProcessor > 341 mxVbaEvents; 342 343 public: 344 ScTabOpList aTableOpList; // list of ScInterpreterTableOpParams currently in use 345 ScInterpreterTableOpParams aLastTableOpParams; // remember last params 346 private: 347 348 LanguageType eLanguage; // default language 349 LanguageType eCjkLanguage; // default language for asian text 350 LanguageType eCtlLanguage; // default language for complex text 351 CharSet eSrcSet; // Einlesen: Quell-Zeichensatz 352 353 /** The compiler grammar used in document storage. GRAM_PODF for ODF 1.1 354 documents, GRAM_ODFF for ODF 1.2 documents. */ 355 formula::FormulaGrammar::Grammar eStorageGrammar; 356 357 /** The compiler grammar used in ODF import after brackets had been 358 stripped (which they shouldn't, but until that's fixed) by the XML 359 importer. */ 360 formula::FormulaGrammar::Grammar eXmlImportGrammar; 361 362 sal_uLong nFormulaCodeInTree; // FormelRPN im Formelbaum 363 sal_uLong nXMLImportedFormulaCount; // progress count during XML import 364 sal_uInt16 nInterpretLevel; // >0 wenn im Interpreter 365 sal_uInt16 nMacroInterpretLevel; // >0 wenn Macro im Interpreter 366 sal_uInt16 nInterpreterTableOpLevel; // >0 if in Interpreter TableOp 367 SCTAB nMaxTableNumber; 368 sal_uInt16 nSrcVer; // Dateiversion (Laden/Speichern) 369 SCROW nSrcMaxRow; // Zeilenzahl zum Laden/Speichern 370 sal_uInt16 nFormulaTrackCount; 371 sal_uInt16 nHardRecalcState; // 0: soft, 1: hard-warn, 2: hard 372 SCTAB nVisibleTab; // fuer OLE etc. 373 374 ScLkUpdMode eLinkMode; 375 376 sal_Bool bAutoCalc; // Automatisch Berechnen 377 sal_Bool bAutoCalcShellDisabled; // in/von/fuer ScDocShell disabled 378 // ob noch ForcedFormulas berechnet werden muessen, 379 // im Zusammenspiel mit ScDocShell SetDocumentModified, 380 // AutoCalcShellDisabled und TrackFormulas 381 sal_Bool bForcedFormulaPending; 382 sal_Bool bCalculatingFormulaTree; 383 sal_Bool bIsClip; 384 sal_Bool bIsUndo; 385 sal_Bool bIsVisible; // set from view ctor 386 387 sal_Bool bIsEmbedded; // Embedded-Bereich anzeigen/anpassen ? 388 389 // kein SetDirty bei ScFormulaCell::CompileTokenArray sondern am Ende 390 // von ScDocument::CompileAll[WithFormats], CopyScenario, CopyBlockFromClip 391 sal_Bool bNoSetDirty; 392 // kein Broadcast, keine Listener aufbauen waehrend aus einem anderen 393 // Doc (per Filter o.ae.) inserted wird, erst bei CompileAll / CalcAfterLoad 394 sal_Bool bInsertingFromOtherDoc; 395 bool bLoadingMedium; 396 bool bImportingXML; // special handling of formula text 397 sal_Bool bXMLFromWrapper; // distinguish ScXMLImportWrapper from external component 398 sal_Bool bCalcingAfterLoad; // in CalcAfterLoad TRUE 399 // wenn temporaer keine Listener auf/abgebaut werden sollen 400 sal_Bool bNoListening; 401 sal_Bool bIdleDisabled; 402 sal_Bool bInLinkUpdate; // TableLink or AreaLink 403 sal_Bool bChartListenerCollectionNeedsUpdate; 404 // ob RC_FORCED Formelzellen im Dokument sind/waren (einmal an immer an) 405 sal_Bool bHasForcedFormulas; 406 // ob das Doc gerade zerstoert wird (kein Notify-Tracking etc. mehr) 407 sal_Bool bInDtorClear; 408 // ob bei Spalte/Zeile einfuegen am Rand einer Referenz die Referenz 409 // erweitert wird, wird in jedem UpdateReference aus InputOptions geholt, 410 // gesetzt und am Ende von UpdateReference zurueckgesetzt 411 sal_Bool bExpandRefs; 412 // fuer Detektiv-Update, wird bei jeder Aenderung an Formeln gesetzt 413 sal_Bool bDetectiveDirty; 414 415 sal_uInt8 nMacroCallMode; // Makros per Warnung-Dialog disabled? 416 sal_Bool bHasMacroFunc; // valid only after loading 417 418 sal_uInt8 nVisSpellState; 419 420 sal_uInt8 nAsianCompression; 421 sal_uInt8 nAsianKerning; 422 sal_Bool bSetDrawDefaults; 423 424 sal_Bool bPastingDrawFromOtherDoc; 425 426 sal_uInt8 nInDdeLinkUpdate; // originating DDE links (stacked bool) 427 428 sal_Bool bInUnoBroadcast; 429 sal_Bool bInUnoListenerCall; 430 formula::FormulaGrammar::Grammar eGrammar; 431 432 mutable sal_Bool bStyleSheetUsageInvalid; 433 434 bool mbUndoEnabled; 435 bool mbAdjustHeightEnabled; 436 bool mbExecuteLinkEnabled; 437 bool mbChangeReadOnlyEnabled; // allow changes in read-only document (for API import filters) 438 bool mbStreamValidLocked; 439 440 sal_Int16 mnNamedRangesLockCount; 441 442 public: 443 SC_DLLPUBLIC sal_uLong GetCellCount() const; // alle Zellen 444 SCSIZE GetCellCount(SCTAB nTab, SCCOL nCol) const; 445 sal_uLong GetWeightedCount() const; // Formeln und Edit staerker gewichtet 446 sal_uLong GetCodeCount() const; // RPN-Code in Formeln 447 DECL_LINK( GetUserDefinedColor, sal_uInt16 * ); 448 // Numberformatter 449 450 public: 451 SC_DLLPUBLIC ScDocument( ScDocumentMode eMode = SCDOCMODE_DOCUMENT, 452 SfxObjectShell* pDocShell = NULL ); 453 SC_DLLPUBLIC ~ScDocument(); 454 455 inline ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > 456 GetServiceManager() const { return xServiceManager; } 457 458 SC_DLLPUBLIC const String& GetName() const { return aDocName; } 459 void SetName( const String& r ) { aDocName = r; } 460 const String& GetCodeName() const { return aDocCodeName; } 461 void SetCodeName( const String& r ) { aDocCodeName = r; } 462 463 void GetDocStat( ScDocStat& rDocStat ); 464 465 SC_DLLPUBLIC void InitDrawLayer( SfxObjectShell* pDocShell = NULL ); 466 XColorTable* GetColorTable(); 467 468 SC_DLLPUBLIC sfx2::LinkManager* GetLinkManager() const; 469 470 SC_DLLPUBLIC const ScDocOptions& GetDocOptions() const; 471 SC_DLLPUBLIC void SetDocOptions( const ScDocOptions& rOpt ); 472 SC_DLLPUBLIC const ScViewOptions& GetViewOptions() const; 473 SC_DLLPUBLIC void SetViewOptions( const ScViewOptions& rOpt ); 474 void SetPrintOptions(); 475 476 ScExtDocOptions* GetExtDocOptions() { return pExtDocOptions; } 477 SC_DLLPUBLIC void SetExtDocOptions( ScExtDocOptions* pNewOptions ); 478 479 void GetLanguage( LanguageType& rLatin, LanguageType& rCjk, LanguageType& rCtl ) const; 480 void SetLanguage( LanguageType eLatin, LanguageType eCjk, LanguageType eCtl ); 481 482 void SetDrawDefaults(); 483 484 void SetConsolidateDlgData( const ScConsolidateParam* pData ); 485 const ScConsolidateParam* GetConsolidateDlgData() const { return pConsolidateDlgData; } 486 487 void Clear( sal_Bool bFromDestructor = sal_False ); 488 489 ScFieldEditEngine* CreateFieldEditEngine(); 490 void DisposeFieldEditEngine(ScFieldEditEngine*& rpEditEngine); 491 492 SC_DLLPUBLIC ScRangeName* GetRangeName(); 493 void SetRangeName( ScRangeName* pNewRangeName ); 494 SCTAB GetMaxTableNumber() { return nMaxTableNumber; } 495 void SetMaxTableNumber(SCTAB nNumber) { nMaxTableNumber = nNumber; } 496 497 ScRangePairList* GetColNameRanges() { return &xColNameRanges; } 498 ScRangePairList* GetRowNameRanges() { return &xRowNameRanges; } 499 ScRangePairListRef& GetColNameRangesRef() { return xColNameRanges; } 500 ScRangePairListRef& GetRowNameRangesRef() { return xRowNameRanges; } 501 502 SC_DLLPUBLIC ScDBCollection* GetDBCollection() const; 503 void SetDBCollection( ScDBCollection* pNewDBCollection, 504 sal_Bool bRemoveAutoFilter = sal_False ); 505 ScDBData* GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, 506 sal_Bool bStartOnly = sal_False) const; 507 ScDBData* GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const; 508 ScDBData* GetFilterDBAtTable(SCTAB nTab) const; 509 //UNUSED2008-05 ScRangeData* GetRangeAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, 510 //UNUSED2008-05 sal_Bool bStartOnly = sal_False) const; 511 SC_DLLPUBLIC ScRangeData* GetRangeAtBlock( const ScRange& rBlock, String* pName=NULL ) const; 512 513 SC_DLLPUBLIC ScDPCollection* GetDPCollection(); 514 ScDPObject* GetDPAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab) const; 515 ScDPObject* GetDPAtBlock( const ScRange& rBlock ) const; 516 // Wang Xu Ming -- 2009-8-17 517 // DataPilot Migration - Cache&&Performance 518 SC_DLLPUBLIC ScDPTableDataCache* GetDPObjectCache( long nID ); 519 SC_DLLPUBLIC ScDPTableDataCache* GetUsedDPObjectCache ( ScRange rRange ); 520 SC_DLLPUBLIC long AddDPObjectCache( ScDPTableDataCache* pData ); 521 SC_DLLPUBLIC void RemoveDPObjectCache( long nID ); 522 SC_DLLPUBLIC void RemoveUnusedDPObjectCaches(); 523 SC_DLLPUBLIC void GetUsedDPObjectCache( std::list<ScDPTableDataCache*>& usedlist ); 524 SC_DLLPUBLIC long GetNewDPObjectCacheId (); 525 // End Comments 526 527 SC_DLLPUBLIC ScChartCollection* GetChartCollection() const; 528 529 void StopTemporaryChartLock(); 530 531 void EnsureGraphicNames(); 532 533 SdrObject* GetObjectAtPoint( SCTAB nTab, const Point& rPos ); 534 sal_Bool HasChartAtPoint( SCTAB nTab, const Point& rPos, String* pName = NULL ); 535 536 ::com::sun::star::uno::Reference< ::com::sun::star::chart2::XChartDocument > GetChartByName( const String& rChartName ); 537 SC_DLLPUBLIC void GetChartRanges( const String& rChartName, ::std::vector< ScRangeList >& rRanges, ScDocument* pSheetNameDoc ); 538 void SetChartRanges( const String& rChartName, const ::std::vector< ScRangeList >& rRanges ); 539 540 void UpdateChartArea( const String& rChartName, const ScRange& rNewArea, 541 sal_Bool bColHeaders, sal_Bool bRowHeaders, sal_Bool bAdd ); 542 void UpdateChartArea( const String& rChartName, 543 const ScRangeListRef& rNewList, 544 sal_Bool bColHeaders, sal_Bool bRowHeaders, sal_Bool bAdd ); 545 void GetOldChartParameters( const String& rName, 546 ScRangeList& rRanges, sal_Bool& rColHeaders, sal_Bool& rRowHeaders ); 547 ::com::sun::star::uno::Reference< 548 ::com::sun::star::embed::XEmbeddedObject > 549 FindOleObjectByName( const String& rName ); 550 551 SC_DLLPUBLIC void MakeTable( SCTAB nTab,bool _bNeedsNameCheck = true ); 552 553 SCTAB GetVisibleTab() const { return nVisibleTab; } 554 SC_DLLPUBLIC void SetVisibleTab(SCTAB nTab) { nVisibleTab = nTab; } 555 556 SC_DLLPUBLIC sal_Bool HasTable( SCTAB nTab ) const; 557 SC_DLLPUBLIC sal_Bool GetName( SCTAB nTab, String& rName ) const; 558 SC_DLLPUBLIC sal_Bool GetCodeName( SCTAB nTab, String& rName ) const; 559 SC_DLLPUBLIC sal_Bool SetCodeName( SCTAB nTab, const String& rName ); 560 SC_DLLPUBLIC sal_Bool GetTable( const String& rName, SCTAB& rTab ) const; 561 SC_DLLPUBLIC inline SCTAB GetTableCount() const { return nMaxTableNumber; } 562 SvNumberFormatterIndexTable* GetFormatExchangeList() const { return pFormatExchangeList; } 563 564 SC_DLLPUBLIC ScDocProtection* GetDocProtection() const; 565 SC_DLLPUBLIC void SetDocProtection(const ScDocProtection* pProtect); 566 SC_DLLPUBLIC sal_Bool IsDocProtected() const; 567 sal_Bool IsDocEditable() const; 568 SC_DLLPUBLIC sal_Bool IsTabProtected( SCTAB nTab ) const; 569 SC_DLLPUBLIC ScTableProtection* GetTabProtection( SCTAB nTab ) const; 570 SC_DLLPUBLIC void SetTabProtection(SCTAB nTab, const ScTableProtection* pProtect); 571 void CopyTabProtection(SCTAB nTabSrc, SCTAB nTabDest); 572 573 void LockTable(SCTAB nTab); 574 void UnlockTable(SCTAB nTab); 575 576 sal_Bool IsBlockEditable( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, 577 SCCOL nEndCol, SCROW nEndRow, 578 sal_Bool* pOnlyNotBecauseOfMatrix = NULL ) const; 579 sal_Bool IsSelectionEditable( const ScMarkData& rMark, 580 sal_Bool* pOnlyNotBecauseOfMatrix = NULL ) const; 581 sal_Bool HasSelectedBlockMatrixFragment( SCCOL nStartCol, SCROW nStartRow, 582 SCCOL nEndCol, SCROW nEndRow, 583 const ScMarkData& rMark ) const; 584 585 sal_Bool GetMatrixFormulaRange( const ScAddress& rCellPos, ScRange& rMatrix ); 586 587 sal_Bool IsEmbedded() const; 588 void GetEmbedded( ScRange& rRange ) const; 589 void SetEmbedded( const ScRange& rRange ); 590 void ResetEmbedded(); 591 Rectangle GetEmbeddedRect() const; // 1/100 mm 592 void SetEmbedded( const Rectangle& rRect ); // aus VisArea (1/100 mm) 593 void SnapVisArea( Rectangle& rRect ) const; // 1/100 mm 594 595 SC_DLLPUBLIC sal_Bool ValidTabName( const String& rName ) const; 596 SC_DLLPUBLIC sal_Bool ValidNewTabName( const String& rName ) const; 597 SC_DLLPUBLIC void CreateValidTabName(String& rName) const; 598 SC_DLLPUBLIC sal_Bool InsertTab( SCTAB nPos, const String& rName, 599 sal_Bool bExternalDocument = sal_False ); 600 SC_DLLPUBLIC sal_Bool DeleteTab( SCTAB nTab, ScDocument* pRefUndoDoc = NULL ); 601 SC_DLLPUBLIC sal_Bool RenameTab( SCTAB nTab, const String& rName, 602 sal_Bool bUpdateRef = sal_True, 603 sal_Bool bExternalDocument = sal_False ); 604 sal_Bool MoveTab( SCTAB nOldPos, SCTAB nNewPos ); 605 sal_Bool CopyTab( SCTAB nOldPos, SCTAB nNewPos, 606 const ScMarkData* pOnlyMarked = NULL ); 607 SC_DLLPUBLIC sal_uLong TransferTab(ScDocument* pSrcDoc, SCTAB nSrcPos, SCTAB nDestPos, 608 sal_Bool bInsertNew = sal_True, 609 sal_Bool bResultsOnly = sal_False ); 610 SC_DLLPUBLIC void TransferDrawPage(ScDocument* pSrcDoc, SCTAB nSrcPos, SCTAB nDestPos); 611 SC_DLLPUBLIC void SetVisible( SCTAB nTab, sal_Bool bVisible ); 612 SC_DLLPUBLIC sal_Bool IsVisible( SCTAB nTab ) const; 613 sal_Bool IsStreamValid( SCTAB nTab ) const; 614 void SetStreamValid( SCTAB nTab, sal_Bool bSet, sal_Bool bIgnoreLock = sal_False ); 615 void LockStreamValid( bool bLock ); 616 bool IsStreamValidLocked() const { return mbStreamValidLocked; } 617 sal_Bool IsPendingRowHeights( SCTAB nTab ) const; 618 void SetPendingRowHeights( SCTAB nTab, sal_Bool bSet ); 619 SC_DLLPUBLIC void SetLayoutRTL( SCTAB nTab, sal_Bool bRTL ); 620 SC_DLLPUBLIC sal_Bool IsLayoutRTL( SCTAB nTab ) const; 621 sal_Bool IsNegativePage( SCTAB nTab ) const; 622 SC_DLLPUBLIC void SetScenario( SCTAB nTab, sal_Bool bFlag ); 623 SC_DLLPUBLIC sal_Bool IsScenario( SCTAB nTab ) const; 624 SC_DLLPUBLIC void GetScenarioData( SCTAB nTab, String& rComment, 625 Color& rColor, sal_uInt16& rFlags ) const; 626 SC_DLLPUBLIC void SetScenarioData( SCTAB nTab, const String& rComment, 627 const Color& rColor, sal_uInt16 nFlags ); 628 SC_DLLPUBLIC Color GetTabBgColor( SCTAB nTab ) const; 629 SC_DLLPUBLIC void SetTabBgColor( SCTAB nTab, const Color& rColor ); 630 SC_DLLPUBLIC bool IsDefaultTabBgColor( SCTAB nTab ) const; 631 void GetScenarioFlags( SCTAB nTab, sal_uInt16& rFlags ) const; 632 SC_DLLPUBLIC sal_Bool IsActiveScenario( SCTAB nTab ) const; 633 SC_DLLPUBLIC void SetActiveScenario( SCTAB nTab, sal_Bool bActive ); // nur fuer Undo etc. 634 SC_DLLPUBLIC formula::FormulaGrammar::AddressConvention GetAddressConvention() const; 635 SC_DLLPUBLIC formula::FormulaGrammar::Grammar GetGrammar() const; 636 void SetGrammar( formula::FormulaGrammar::Grammar eGram ); 637 SC_DLLPUBLIC sal_uInt8 GetLinkMode( SCTAB nTab ) const; 638 sal_Bool IsLinked( SCTAB nTab ) const; 639 SC_DLLPUBLIC const String& GetLinkDoc( SCTAB nTab ) const; 640 const String& GetLinkFlt( SCTAB nTab ) const; 641 const String& GetLinkOpt( SCTAB nTab ) const; 642 SC_DLLPUBLIC const String& GetLinkTab( SCTAB nTab ) const; 643 sal_uLong GetLinkRefreshDelay( SCTAB nTab ) const; 644 void SetLink( SCTAB nTab, sal_uInt8 nMode, const String& rDoc, 645 const String& rFilter, const String& rOptions, 646 const String& rTabName, sal_uLong nRefreshDelay ); 647 sal_Bool HasLink( const String& rDoc, 648 const String& rFilter, const String& rOptions ) const; 649 SC_DLLPUBLIC sal_Bool LinkExternalTab( SCTAB& nTab, const String& aDocTab, 650 const String& aFileName, 651 const String& aTabName ); 652 653 bool HasExternalRefManager() const { return pExternalRefMgr.get(); } 654 SC_DLLPUBLIC ScExternalRefManager* GetExternalRefManager() const; 655 bool IsInExternalReferenceMarking() const; 656 void MarkUsedExternalReferences(); 657 bool MarkUsedExternalReferences( ScTokenArray & rArr ); 658 659 /** Returns the pool containing external formula parsers. Creates the pool 660 on first call. */ 661 ScFormulaParserPool& GetFormulaParserPool() const; 662 663 sal_Bool HasDdeLinks() const; 664 sal_Bool HasAreaLinks() const; 665 void UpdateExternalRefLinks(); 666 void UpdateDdeLinks(); 667 void UpdateAreaLinks(); 668 669 // originating DDE links 670 void IncInDdeLinkUpdate() { if ( nInDdeLinkUpdate < 255 ) ++nInDdeLinkUpdate; } 671 void DecInDdeLinkUpdate() { if ( nInDdeLinkUpdate ) --nInDdeLinkUpdate; } 672 sal_Bool IsInDdeLinkUpdate() const { return nInDdeLinkUpdate != 0; } 673 674 SC_DLLPUBLIC void CopyDdeLinks( ScDocument* pDestDoc ) const; 675 void DisconnectDdeLinks(); 676 677 // Fuer StarOne Api: 678 sal_uInt16 GetDdeLinkCount() const; 679 sal_Bool UpdateDdeLink( const String& rAppl, const String& rTopic, const String& rItem ); 680 681 /** Tries to find a DDE link with the specified connection data. 682 @param rnDdePos (out-param) Returns the index of the DDE link (does not include other links from link manager). 683 @return true = DDE link found, rnDdePos valid. */ 684 SC_DLLPUBLIC bool FindDdeLink( const String& rAppl, const String& rTopic, const String& rItem, sal_uInt8 nMode, sal_uInt16& rnDdePos ); 685 686 /** Returns the connection data of the specified DDE link. 687 @param nDdePos Index of the DDE link (does not include other links from link manager). 688 @param rAppl (out-param) The application name. 689 @param rTopic (out-param) The DDE topic. 690 @param rItem (out-param) The DDE item. 691 @return true = DDE link found, out-parameters valid. */ 692 bool GetDdeLinkData( sal_uInt16 nDdePos, String& rAppl, String& rTopic, String& rItem ) const; 693 /** Returns the link mode of the specified DDE link. 694 @param nDdePos Index of the DDE link (does not include other links from link manager). 695 @param rnMode (out-param) The link mode of the specified DDE link. 696 @return true = DDE link found, rnMode valid. */ 697 bool GetDdeLinkMode( sal_uInt16 nDdePos, sal_uInt8& rnMode ) const; 698 /** Returns the result matrix of the specified DDE link. 699 @param nDdePos Index of the DDE link (does not include other links from link manager). 700 @return The result matrix, if the DDE link has been found, 0 otherwise. */ 701 SC_DLLPUBLIC const ScMatrix* GetDdeLinkResultMatrix( sal_uInt16 nDdePos ) const; 702 703 /** Tries to find a DDE link or creates a new, if not extant. 704 @param pResults If not 0, sets the matrix as as DDE link result matrix (also for existing links). 705 @return true = DDE link found; false = Unpredictable error occured, no DDE link created. */ 706 SC_DLLPUBLIC bool CreateDdeLink( const String& rAppl, const String& rTopic, const String& rItem, sal_uInt8 nMode, ScMatrix* pResults = NULL ); 707 /** Sets a result matrix for the specified DDE link. 708 @param nDdePos Index of the DDE link (does not include other links from link manager). 709 @param pResults The array containing all results of the DDE link (intrusive-ref-counted, do not delete). 710 @return true = DDE link found and matrix set. */ 711 bool SetDdeLinkResultMatrix( sal_uInt16 nDdePos, ScMatrix* pResults ); 712 713 714 SfxBindings* GetViewBindings(); 715 SfxObjectShell* GetDocumentShell() const { return pShell; } 716 ScDrawLayer* GetDrawLayer() { return pDrawLayer; } 717 SfxBroadcaster* GetDrawBroadcaster(); // zwecks Header-Vermeidung 718 void BeginDrawUndo(); 719 720 void BeginUnoRefUndo(); 721 bool HasUnoRefUndo() const { return ( pUnoRefUndoList != NULL ); } 722 ScUnoRefList* EndUnoRefUndo(); // must be deleted by caller! 723 sal_Int64 GetNewUnoId(); 724 void AddUnoRefChange( sal_Int64 nId, const ScRangeList& rOldRanges ); 725 726 // #109985# 727 sal_Bool IsChart( const SdrObject* pObject ); 728 729 SC_DLLPUBLIC void UpdateAllCharts(); 730 void UpdateChartRef( UpdateRefMode eUpdateRefMode, 731 SCCOL nCol1, SCROW nRow1, SCTAB nTab1, 732 SCCOL nCol2, SCROW nRow2, SCTAB nTab2, 733 SCsCOL nDx, SCsROW nDy, SCsTAB nDz ); 734 //! setzt nur die neue RangeList, keine ChartListener o.ae. 735 void SetChartRangeList( const String& rChartName, 736 const ScRangeListRef& rNewRangeListRef ); 737 738 sal_Bool HasControl( SCTAB nTab, const Rectangle& rMMRect ); 739 void InvalidateControls( Window* pWin, SCTAB nTab, const Rectangle& rMMRect ); 740 741 void StartAnimations( SCTAB nTab, Window* pWin ); 742 743 sal_Bool HasBackgroundDraw( SCTAB nTab, const Rectangle& rMMRect ); 744 sal_Bool HasAnyDraw( SCTAB nTab, const Rectangle& rMMRect ); 745 746 const ScSheetEvents* GetSheetEvents( SCTAB nTab ) const; 747 void SetSheetEvents( SCTAB nTab, const ScSheetEvents* pNew ); 748 bool HasSheetEventScript( SCTAB nTab, sal_Int32 nEvent, bool bWithVbaEvents = false ) const; 749 bool HasAnySheetEventScript( sal_Int32 nEvent, bool bWithVbaEvents = false ) const; // on any sheet 750 751 bool HasAnyCalcNotification() const; 752 sal_Bool HasCalcNotification( SCTAB nTab ) const; 753 void SetCalcNotification( SCTAB nTab ); 754 void ResetCalcNotifications(); 755 756 SC_DLLPUBLIC ScOutlineTable* GetOutlineTable( SCTAB nTab, sal_Bool bCreate = sal_False ); 757 sal_Bool SetOutlineTable( SCTAB nTab, const ScOutlineTable* pNewOutline ); 758 759 void DoAutoOutline( SCCOL nStartCol, SCROW nStartRow, 760 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab ); 761 762 sal_Bool DoSubTotals( SCTAB nTab, ScSubTotalParam& rParam ); 763 void RemoveSubTotals( SCTAB nTab, ScSubTotalParam& rParam ); 764 sal_Bool TestRemoveSubTotals( SCTAB nTab, const ScSubTotalParam& rParam ); 765 sal_Bool HasSubTotalCells( const ScRange& rRange ); 766 767 SC_DLLPUBLIC void PutCell( const ScAddress&, ScBaseCell* pCell, sal_Bool bForceTab = sal_False ); 768 //UNUSED2009-05 SC_DLLPUBLIC void PutCell( const ScAddress&, ScBaseCell* pCell, 769 //UNUSED2009-05 sal_uLong nFormatIndex, sal_Bool bForceTab = sal_False); 770 SC_DLLPUBLIC void PutCell( SCCOL nCol, SCROW nRow, SCTAB nTab, ScBaseCell* pCell, 771 sal_Bool bForceTab = sal_False ); 772 SC_DLLPUBLIC void PutCell(SCCOL nCol, SCROW nRow, SCTAB nTab, ScBaseCell* pCell, 773 sal_uLong nFormatIndex, sal_Bool bForceTab = sal_False); 774 // return sal_True = Zahlformat gesetzt 775 SC_DLLPUBLIC sal_Bool SetString( 776 SCCOL nCol, SCROW nRow, SCTAB nTab, const String& rString, 777 SvNumberFormatter* pFormatter = NULL, bool bDetectNumberFormat = true ); 778 SC_DLLPUBLIC void SetValue( SCCOL nCol, SCROW nRow, SCTAB nTab, const double& rVal ); 779 void SetError( SCCOL nCol, SCROW nRow, SCTAB nTab, const sal_uInt16 nError); 780 781 SC_DLLPUBLIC void InsertMatrixFormula(SCCOL nCol1, SCROW nRow1, 782 SCCOL nCol2, SCROW nRow2, 783 const ScMarkData& rMark, 784 const String& rFormula, 785 const ScTokenArray* p = NULL, 786 const formula::FormulaGrammar::Grammar = formula::FormulaGrammar::GRAM_DEFAULT ); 787 SC_DLLPUBLIC void InsertTableOp(const ScTabOpParam& rParam, // Mehrfachoperation 788 SCCOL nCol1, SCROW nRow1, 789 SCCOL nCol2, SCROW nRow2, const ScMarkData& rMark); 790 791 SC_DLLPUBLIC void GetString( SCCOL nCol, SCROW nRow, SCTAB nTab, String& rString ); 792 SC_DLLPUBLIC void GetInputString( SCCOL nCol, SCROW nRow, SCTAB nTab, String& rString ); 793 sal_uInt16 GetStringForFormula( const ScAddress& rPos, rtl::OUString& rString ); 794 SC_DLLPUBLIC double GetValue( const ScAddress& ); 795 SC_DLLPUBLIC void GetValue( SCCOL nCol, SCROW nRow, SCTAB nTab, double& rValue ); 796 SC_DLLPUBLIC double RoundValueAsShown( double fVal, sal_uLong nFormat ); 797 SC_DLLPUBLIC void GetNumberFormat( SCCOL nCol, SCROW nRow, SCTAB nTab, 798 sal_uInt32& rFormat ); 799 SC_DLLPUBLIC sal_uInt32 GetNumberFormat( const ScAddress& ) const; 800 /** If no number format attribute is set and the cell 801 pointer passed is of type formula cell, the calculated 802 number format of the formula cell is returned. pCell 803 may be NULL. */ 804 SC_DLLPUBLIC void GetNumberFormatInfo( short& nType, sal_uLong& nIndex, 805 const ScAddress& rPos, const ScBaseCell* pCell ) const; 806 void GetFormula( SCCOL nCol, SCROW nRow, SCTAB nTab, String& rFormula, 807 sal_Bool bAsciiExport = sal_False ) const; 808 SC_DLLPUBLIC void GetCellType( SCCOL nCol, SCROW nRow, SCTAB nTab, CellType& rCellType ) const; 809 SC_DLLPUBLIC CellType GetCellType( const ScAddress& rPos ) const; 810 SC_DLLPUBLIC void GetCell( SCCOL nCol, SCROW nRow, SCTAB nTab, ScBaseCell*& rpCell ) const; 811 SC_DLLPUBLIC ScBaseCell* GetCell( const ScAddress& rPos ) const; 812 813 //UNUSED2008-05 void RefreshNoteFlags(); 814 815 SC_DLLPUBLIC sal_Bool HasData( SCCOL nCol, SCROW nRow, SCTAB nTab ); 816 SC_DLLPUBLIC sal_Bool HasStringData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const; 817 SC_DLLPUBLIC sal_Bool HasValueData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const; 818 sal_Bool HasStringCells( const ScRange& rRange ) const; 819 820 /** Returns true, if there is any data to create a selection list for rPos. */ 821 sal_Bool HasSelectionData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const; 822 823 /** Returns the pointer to a cell note object at the passed cell address. */ 824 ScPostIt* GetNote( const ScAddress& rPos ); 825 /** Sets the passed note at the cell with the passed cell address. */ 826 void TakeNote( const ScAddress& rPos, ScPostIt*& rpNote ); 827 /** Returns and forgets the cell note object at the passed cell address. */ 828 ScPostIt* ReleaseNote( const ScAddress& rPos ); 829 /** Returns the pointer to an existing or created cell note object at the passed cell address. */ 830 SC_DLLPUBLIC ScPostIt* GetOrCreateNote( const ScAddress& rPos ); 831 /** Deletes the note at the passed cell address. */ 832 void DeleteNote( const ScAddress& rPos ); 833 /** Creates the captions of all uninitialized cell notes in the specified sheet. 834 @param bForced True = always create all captions, false = skip when Undo is disabled. */ 835 void InitializeNoteCaptions( SCTAB nTab, bool bForced = false ); 836 /** Creates the captions of all uninitialized cell notes in all sheets. 837 @param bForced True = always create all captions, false = skip when Undo is disabled. */ 838 void InitializeAllNoteCaptions( bool bForced = false ); 839 840 sal_Bool ExtendMergeSel( SCCOL nStartCol, SCROW nStartRow, 841 SCCOL& rEndCol, SCROW& rEndRow, const ScMarkData& rMark, 842 sal_Bool bRefresh = sal_False, sal_Bool bAttrs = sal_False ); 843 sal_Bool ExtendMerge( SCCOL nStartCol, SCROW nStartRow, 844 SCCOL& rEndCol, SCROW& rEndRow, SCTAB nTab, 845 sal_Bool bRefresh = sal_False, sal_Bool bAttrs = sal_False ); 846 sal_Bool ExtendMerge( ScRange& rRange, sal_Bool bRefresh = sal_False, sal_Bool bAttrs = sal_False ); 847 sal_Bool ExtendTotalMerge( ScRange& rRange ); 848 SC_DLLPUBLIC sal_Bool ExtendOverlapped( SCCOL& rStartCol, SCROW& rStartRow, 849 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab ); 850 SC_DLLPUBLIC sal_Bool ExtendOverlapped( ScRange& rRange ); 851 852 sal_Bool RefreshAutoFilter( SCCOL nStartCol, SCROW nStartRow, 853 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab ); 854 855 SC_DLLPUBLIC void DoMergeContents( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, 856 SCCOL nEndCol, SCROW nEndRow ); 857 // ohne Ueberpruefung: 858 SC_DLLPUBLIC void DoMerge( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, 859 SCCOL nEndCol, SCROW nEndRow, bool bDeleteCaptions = true ); 860 void RemoveMerge( SCCOL nCol, SCROW nRow, SCTAB nTab ); 861 862 sal_Bool IsBlockEmpty( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, 863 SCCOL nEndCol, SCROW nEndRow, bool bIgnoreNotes = false ) const; 864 sal_Bool IsPrintEmpty( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, 865 SCCOL nEndCol, SCROW nEndRow, 866 sal_Bool bLeftIsEmpty = sal_False, 867 ScRange* pLastRange = NULL, 868 Rectangle* pLastMM = NULL ) const; 869 870 sal_Bool IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const; 871 sal_Bool IsVerOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const; 872 873 SC_DLLPUBLIC bool HasAttrib( SCCOL nCol1, SCROW nRow1, SCTAB nTab1, 874 SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt16 nMask ); 875 SC_DLLPUBLIC bool HasAttrib( const ScRange& rRange, sal_uInt16 nMask ); 876 877 void GetBorderLines( SCCOL nCol, SCROW nRow, SCTAB nTab, 878 const SvxBorderLine** ppLeft, 879 const SvxBorderLine** ppTop, 880 const SvxBorderLine** ppRight, 881 const SvxBorderLine** ppBottom ) const; 882 883 void ResetChanged( const ScRange& rRange ); 884 885 void SetDirty(); 886 void SetDirty( const ScRange& ); 887 void SetTableOpDirty( const ScRange& ); // for Interpreter TableOp 888 void InterpretDirtyCells( const ScRangeList& rRanges ); 889 void CalcAll(); 890 SC_DLLPUBLIC void CalcAfterLoad(); 891 void CompileAll(); 892 void CompileXML(); 893 894 ScAutoNameCache* GetAutoNameCache() { return pAutoNameCache; } 895 896 /** Creates a ScLookupCache cache for the range if it 897 doesn't already exist. */ 898 ScLookupCache & GetLookupCache( const ScRange & rRange ); 899 /** Only ScLookupCache ctor uses AddLookupCache(), do not 900 use elsewhere! */ 901 void AddLookupCache( ScLookupCache & rCache ); 902 /** Only ScLookupCache dtor uses RemoveLookupCache(), do 903 not use elsewhere! */ 904 void RemoveLookupCache( ScLookupCache & rCache ); 905 /** Zap all caches. */ 906 void ClearLookupCaches(); 907 908 // Automatisch Berechnen 909 void SetAutoCalc( sal_Bool bNewAutoCalc ); 910 sal_Bool GetAutoCalc() const { return bAutoCalc; } 911 // Automatisch Berechnen in/von/fuer ScDocShell disabled 912 void SetAutoCalcShellDisabled( sal_Bool bNew ) { bAutoCalcShellDisabled = bNew; } 913 sal_Bool IsAutoCalcShellDisabled() const { return bAutoCalcShellDisabled; } 914 // ForcedFormulas zu berechnen 915 void SetForcedFormulaPending( sal_Bool bNew ) { bForcedFormulaPending = bNew; } 916 sal_Bool IsForcedFormulaPending() const { return bForcedFormulaPending; } 917 // if CalcFormulaTree() is currently running 918 sal_Bool IsCalculatingFormulaTree() { return bCalculatingFormulaTree; } 919 920 sal_uInt16 GetErrCode( const ScAddress& ) const; 921 922 /** Shrink a range to only include data area. 923 924 This is not the actually used area within the 925 selection, but the bounds of the sheet's data area 926 instead. 927 928 @returns True if the area passed intersected the data 929 area, false if not, in which case the values 930 obtained may be out of bounds, not in order or 931 unmodified. True does not mean that there 932 actually is any data within the selection. 933 */ 934 bool ShrinkToDataArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow ) const; 935 936 /** Shrink a range to only include used data area. 937 938 @param o_bShrunk 939 Out parameter, True if area was shrunk, false if not. 940 941 @returns True if there is any data, fakse if not. 942 */ 943 bool ShrinkToUsedDataArea( bool& o_bShrunk, 944 SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow, 945 SCCOL& rEndCol, SCROW& rEndRow, bool bColumnsOnly ) const; 946 947 SC_DLLPUBLIC void GetDataArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow, 948 SCCOL& rEndCol, SCROW& rEndRow, sal_Bool bIncludeOld, bool bOnlyDown ) const; 949 SC_DLLPUBLIC sal_Bool GetCellArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow ) const; 950 SC_DLLPUBLIC sal_Bool GetTableArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow ) const; 951 SC_DLLPUBLIC sal_Bool GetPrintArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow, 952 sal_Bool bNotes = sal_True ) const; 953 SC_DLLPUBLIC sal_Bool GetPrintAreaHor( SCTAB nTab, SCROW nStartRow, SCROW nEndRow, 954 SCCOL& rEndCol, sal_Bool bNotes = sal_True ) const; 955 SC_DLLPUBLIC sal_Bool GetPrintAreaVer( SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol, 956 SCROW& rEndRow, sal_Bool bNotes = sal_True ) const; 957 void InvalidateTableArea(); 958 959 960 SC_DLLPUBLIC sal_Bool GetDataStart( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow ) const; 961 962 /** 963 * Find the maximum column position that contains printable data for the 964 * specified row range. The final column position must be equal or less 965 * than the initial value of rEndCol. 966 */ 967 void ExtendPrintArea( OutputDevice* pDev, SCTAB nTab, 968 SCCOL nStartCol, SCROW nStartRow, 969 SCCOL& rEndCol, SCROW nEndRow ); 970 SC_DLLPUBLIC SCSIZE GetEmptyLinesInBlock( SCCOL nStartCol, SCROW nStartRow, SCTAB nStartTab, 971 SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab, 972 ScDirection eDir ); 973 974 void FindAreaPos( SCCOL& rCol, SCROW& rRow, SCTAB nTab, SCsCOL nMovX, SCsROW nMovY ); 975 SC_DLLPUBLIC void GetNextPos( SCCOL& rCol, SCROW& rRow, SCTAB nTab, SCsCOL nMovX, SCsROW nMovY, 976 sal_Bool bMarked, sal_Bool bUnprotected, const ScMarkData& rMark ); 977 978 sal_Bool GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, SCTAB nTab, 979 const ScMarkData& rMark ); 980 981 void LimitChartArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow, 982 SCCOL& rEndCol, SCROW& rEndRow ); 983 void LimitChartIfAll( ScRangeListRef& rRangeList ); 984 985 sal_Bool InsertRow( SCCOL nStartCol, SCTAB nStartTab, 986 SCCOL nEndCol, SCTAB nEndTab, 987 SCROW nStartRow, SCSIZE nSize, ScDocument* pRefUndoDoc = NULL, 988 const ScMarkData* pTabMark = NULL ); 989 SC_DLLPUBLIC sal_Bool InsertRow( const ScRange& rRange, ScDocument* pRefUndoDoc = NULL ); 990 void DeleteRow( SCCOL nStartCol, SCTAB nStartTab, 991 SCCOL nEndCol, SCTAB nEndTab, 992 SCROW nStartRow, SCSIZE nSize, 993 ScDocument* pRefUndoDoc = NULL, sal_Bool* pUndoOutline = NULL, 994 const ScMarkData* pTabMark = NULL ); 995 void DeleteRow( const ScRange& rRange, 996 ScDocument* pRefUndoDoc = NULL, sal_Bool* pUndoOutline = NULL ); 997 sal_Bool InsertCol( SCROW nStartRow, SCTAB nStartTab, 998 SCROW nEndRow, SCTAB nEndTab, 999 SCCOL nStartCol, SCSIZE nSize, ScDocument* pRefUndoDoc = NULL, 1000 const ScMarkData* pTabMark = NULL ); 1001 SC_DLLPUBLIC sal_Bool InsertCol( const ScRange& rRange, ScDocument* pRefUndoDoc = NULL ); 1002 void DeleteCol( SCROW nStartRow, SCTAB nStartTab, 1003 SCROW nEndRow, SCTAB nEndTab, 1004 SCCOL nStartCol, SCSIZE nSize, 1005 ScDocument* pRefUndoDoc = NULL, sal_Bool* pUndoOutline = NULL, 1006 const ScMarkData* pTabMark = NULL ); 1007 void DeleteCol( const ScRange& rRange, 1008 ScDocument* pRefUndoDoc = NULL, sal_Bool* pUndoOutline = NULL ); 1009 1010 sal_Bool CanInsertRow( const ScRange& rRange ) const; 1011 sal_Bool CanInsertCol( const ScRange& rRange ) const; 1012 1013 void FitBlock( const ScRange& rOld, const ScRange& rNew, sal_Bool bClear = sal_True ); 1014 sal_Bool CanFitBlock( const ScRange& rOld, const ScRange& rNew ); 1015 1016 sal_Bool IsClipOrUndo() const { return bIsClip || bIsUndo; } 1017 sal_Bool IsUndo() const { return bIsUndo; } 1018 sal_Bool IsClipboard() const { return bIsClip; } 1019 bool IsUndoEnabled() const { return mbUndoEnabled; } 1020 void EnableUndo( bool bVal ); 1021 1022 bool IsAdjustHeightEnabled() const { return mbAdjustHeightEnabled; } 1023 void EnableAdjustHeight( bool bVal ) { mbAdjustHeightEnabled = bVal; } 1024 bool IsExecuteLinkEnabled() const { return mbExecuteLinkEnabled; } 1025 void EnableExecuteLink( bool bVal ) { mbExecuteLinkEnabled = bVal; } 1026 bool IsChangeReadOnlyEnabled() const { return mbChangeReadOnlyEnabled; } 1027 void EnableChangeReadOnly( bool bVal ) { mbChangeReadOnlyEnabled = bVal; } 1028 SC_DLLPUBLIC sal_Int16 GetNamedRangesLockCount() const { return mnNamedRangesLockCount; } 1029 void SetNamedRangesLockCount( sal_Int16 nCount ) { mnNamedRangesLockCount = nCount; } 1030 SC_DLLPUBLIC void ResetClip( ScDocument* pSourceDoc, const ScMarkData* pMarks ); 1031 SC_DLLPUBLIC void ResetClip( ScDocument* pSourceDoc, SCTAB nTab ); 1032 void SetCutMode( sal_Bool bCut ); 1033 sal_Bool IsCutMode(); 1034 void SetClipArea( const ScRange& rArea, sal_Bool bCut = sal_False ); 1035 1036 SC_DLLPUBLIC sal_Bool IsDocVisible() const { return bIsVisible; } 1037 void SetDocVisible( sal_Bool bSet ); 1038 1039 sal_Bool HasOLEObjectsInArea( const ScRange& rRange, const ScMarkData* pTabMark = NULL ); 1040 1041 void DeleteObjectsInArea( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, 1042 const ScMarkData& rMark ); 1043 void DeleteObjectsInSelection( const ScMarkData& rMark ); 1044 1045 void DeleteArea(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, 1046 const ScMarkData& rMark, sal_uInt16 nDelFlag); 1047 void DeleteAreaTab(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, 1048 SCTAB nTab, sal_uInt16 nDelFlag); 1049 void DeleteAreaTab(const ScRange& rRange, sal_uInt16 nDelFlag); 1050 1051 void CopyToClip(const ScClipParam& rClipParam, ScDocument* pClipDoc, 1052 const ScMarkData* pMarks = NULL, bool bAllTabs = false, bool bKeepScenarioFlags = false, 1053 bool bIncludeObjects = false, bool bCloneNoteCaptions = true); 1054 1055 void CopyTabToClip(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, 1056 SCTAB nTab, ScDocument* pClipDoc = NULL); 1057 void CopyBlockFromClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, 1058 const ScMarkData& rMark, SCsCOL nDx, SCsROW nDy, 1059 const ScCopyBlockFromClipParams* pCBFCP ); 1060 void CopyNonFilteredFromClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, 1061 const ScMarkData& rMark, SCsCOL nDx, SCsROW nDy, 1062 const ScCopyBlockFromClipParams* pCBFCP, 1063 SCROW & rClipStartRow ); 1064 void StartListeningFromClip( SCCOL nCol1, SCROW nRow1, 1065 SCCOL nCol2, SCROW nRow2, 1066 const ScMarkData& rMark, sal_uInt16 nInsFlag ); 1067 void BroadcastFromClip( SCCOL nCol1, SCROW nRow1, 1068 SCCOL nCol2, SCROW nRow2, 1069 const ScMarkData& rMark, sal_uInt16 nInsFlag ); 1070 /** If pDestRanges is given it overrides rDestRange, rDestRange in this 1071 case is the overall encompassing range. */ 1072 void CopyFromClip( const ScRange& rDestRange, const ScMarkData& rMark, 1073 sal_uInt16 nInsFlag, 1074 ScDocument* pRefUndoDoc = NULL, 1075 ScDocument* pClipDoc = NULL, 1076 sal_Bool bResetCut = sal_True, 1077 sal_Bool bAsLink = sal_False, 1078 sal_Bool bIncludeFiltered = sal_True, 1079 sal_Bool bSkipAttrForEmpty = sal_False, 1080 const ScRangeList * pDestRanges = NULL ); 1081 1082 void CopyMultiRangeFromClip(const ScAddress& rDestPos, const ScMarkData& rMark, 1083 sal_uInt16 nInsFlag, ScDocument* pClipDoc, 1084 bool bResetCut = true, bool bAsLink = false, 1085 bool bIncludeFiltered = true, 1086 bool bSkipAttrForEmpty = false); 1087 1088 void GetClipArea(SCCOL& nClipX, SCROW& nClipY, sal_Bool bIncludeFiltered); 1089 void GetClipStart(SCCOL& nClipX, SCROW& nClipY); 1090 1091 sal_Bool HasClipFilteredRows(); 1092 1093 sal_Bool IsClipboardSource() const; 1094 1095 SC_DLLPUBLIC void TransposeClip( ScDocument* pTransClip, sal_uInt16 nFlags, sal_Bool bAsLink ); 1096 1097 ScClipParam& GetClipParam(); 1098 void SetClipParam(const ScClipParam& rParam); 1099 1100 void MixDocument( const ScRange& rRange, sal_uInt16 nFunction, sal_Bool bSkipEmpty, 1101 ScDocument* pSrcDoc ); 1102 1103 void FillTab( const ScRange& rSrcArea, const ScMarkData& rMark, 1104 sal_uInt16 nFlags, sal_uInt16 nFunction, 1105 sal_Bool bSkipEmpty, sal_Bool bAsLink ); 1106 void FillTabMarked( SCTAB nSrcTab, const ScMarkData& rMark, 1107 sal_uInt16 nFlags, sal_uInt16 nFunction, 1108 sal_Bool bSkipEmpty, sal_Bool bAsLink ); 1109 1110 void TransliterateText( const ScMarkData& rMultiMark, sal_Int32 nType ); 1111 1112 SC_DLLPUBLIC void InitUndo( ScDocument* pSrcDoc, SCTAB nTab1, SCTAB nTab2, 1113 sal_Bool bColInfo = sal_False, sal_Bool bRowInfo = sal_False ); 1114 void AddUndoTab( SCTAB nTab1, SCTAB nTab2, 1115 sal_Bool bColInfo = sal_False, sal_Bool bRowInfo = sal_False ); 1116 SC_DLLPUBLIC void InitUndoSelected( ScDocument* pSrcDoc, const ScMarkData& rTabSelection, 1117 sal_Bool bColInfo = sal_False, sal_Bool bRowInfo = sal_False ); 1118 1119 // nicht mehr benutzen: 1120 void CopyToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, 1121 SCCOL nCol2, SCROW nRow2, SCTAB nTab2, 1122 sal_uInt16 nFlags, sal_Bool bMarked, ScDocument* pDestDoc, 1123 const ScMarkData* pMarks = NULL, sal_Bool bColRowFlags = sal_True); 1124 void UndoToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, 1125 SCCOL nCol2, SCROW nRow2, SCTAB nTab2, 1126 sal_uInt16 nFlags, sal_Bool bMarked, ScDocument* pDestDoc, 1127 const ScMarkData* pMarks = NULL); 1128 1129 void CopyToDocument(const ScRange& rRange, 1130 sal_uInt16 nFlags, sal_Bool bMarked, ScDocument* pDestDoc, 1131 const ScMarkData* pMarks = NULL, sal_Bool bColRowFlags = sal_True); 1132 void UndoToDocument(const ScRange& rRange, 1133 sal_uInt16 nFlags, sal_Bool bMarked, ScDocument* pDestDoc, 1134 const ScMarkData* pMarks = NULL); 1135 1136 void CopyScenario( SCTAB nSrcTab, SCTAB nDestTab, sal_Bool bNewScenario = sal_False ); 1137 sal_Bool TestCopyScenario( SCTAB nSrcTab, SCTAB nDestTab ) const; 1138 void MarkScenario( SCTAB nSrcTab, SCTAB nDestTab, 1139 ScMarkData& rDestMark, sal_Bool bResetMark = sal_True, 1140 sal_uInt16 nNeededBits = 0 ) const; 1141 sal_Bool HasScenarioRange( SCTAB nTab, const ScRange& rRange ) const; 1142 SC_DLLPUBLIC const ScRangeList* GetScenarioRanges( SCTAB nTab ) const; 1143 1144 SC_DLLPUBLIC void CopyUpdated( ScDocument* pPosDoc, ScDocument* pDestDoc ); 1145 1146 void UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nRow1, SCTAB nTab1, 1147 SCCOL nCol2, SCROW nRow2, SCTAB nTab2, 1148 SCsCOL nDx, SCsROW nDy, SCsTAB nDz, 1149 ScDocument* pUndoDoc = NULL, sal_Bool bIncludeDraw = sal_True, 1150 bool bUpdateNoteCaptionPos = true ); 1151 1152 SC_DLLPUBLIC void UpdateTranspose( const ScAddress& rDestPos, ScDocument* pClipDoc, 1153 const ScMarkData& rMark, ScDocument* pUndoDoc = NULL ); 1154 1155 void UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY ); 1156 1157 void Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, 1158 const ScMarkData& rMark, 1159 sal_uLong nFillCount, FillDir eFillDir = FILL_TO_BOTTOM, 1160 FillCmd eFillCmd = FILL_LINEAR, FillDateCmd eFillDateCmd = FILL_DAY, 1161 double nStepValue = 1.0, double nMaxValue = 1E307); 1162 String GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY ); 1163 1164 sal_Bool GetSelectionFunction( ScSubTotalFunc eFunc, 1165 const ScAddress& rCursor, const ScMarkData& rMark, 1166 double& rResult ); 1167 1168 SC_DLLPUBLIC const SfxPoolItem* GetAttr( SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nWhich ) const; 1169 SC_DLLPUBLIC const ScPatternAttr* GetPattern( SCCOL nCol, SCROW nRow, SCTAB nTab ) const; 1170 SC_DLLPUBLIC const ScPatternAttr* GetMostUsedPattern( SCCOL nCol, SCROW nStartRow, SCROW nEndRow, SCTAB nTab ) const; 1171 const ScPatternAttr* GetSelectionPattern( const ScMarkData& rMark, sal_Bool bDeep = sal_True ); 1172 ScPatternAttr* CreateSelectionPattern( const ScMarkData& rMark, sal_Bool bDeep = sal_True ); 1173 1174 const ScConditionalFormat* GetCondFormat( SCCOL nCol, SCROW nRow, SCTAB nTab ) const; 1175 SC_DLLPUBLIC const SfxItemSet* GetCondResult( SCCOL nCol, SCROW nRow, SCTAB nTab ) const; 1176 const SfxPoolItem* GetEffItem( SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nWhich ) const; 1177 1178 SC_DLLPUBLIC const ::com::sun::star::uno::Reference< ::com::sun::star::i18n::XBreakIterator >& GetBreakIterator(); 1179 sal_Bool HasStringWeakCharacters( const String& rString ); 1180 SC_DLLPUBLIC sal_uInt8 GetStringScriptType( const String& rString ); 1181 SC_DLLPUBLIC sal_uInt8 GetCellScriptType( ScBaseCell* pCell, sal_uLong nNumberFormat ); 1182 SC_DLLPUBLIC sal_uInt8 GetScriptType( SCCOL nCol, SCROW nRow, SCTAB nTab, ScBaseCell* pCell = NULL ); 1183 1184 sal_Bool HasDetectiveOperations() const; 1185 void AddDetectiveOperation( const ScDetOpData& rData ); 1186 void ClearDetectiveOperations(); 1187 ScDetOpList* GetDetOpList() const { return pDetOpList; } 1188 void SetDetOpList(ScDetOpList* pNew); 1189 1190 sal_Bool HasDetectiveObjects(SCTAB nTab) const; 1191 1192 void GetSelectionFrame( const ScMarkData& rMark, 1193 SvxBoxItem& rLineOuter, 1194 SvxBoxInfoItem& rLineInner ); 1195 void ApplySelectionFrame( const ScMarkData& rMark, 1196 const SvxBoxItem* pLineOuter, 1197 const SvxBoxInfoItem* pLineInner ); 1198 void ApplyFrameAreaTab( const ScRange& rRange, 1199 const SvxBoxItem* pLineOuter, 1200 const SvxBoxInfoItem* pLineInner ); 1201 1202 void ClearSelectionItems( const sal_uInt16* pWhich, const ScMarkData& rMark ); 1203 void ChangeSelectionIndent( sal_Bool bIncrement, const ScMarkData& rMark ); 1204 1205 SC_DLLPUBLIC sal_uLong AddCondFormat( const ScConditionalFormat& rNew ); 1206 SC_DLLPUBLIC void FindConditionalFormat( sal_uLong nKey, ScRangeList& rRanges ); 1207 SC_DLLPUBLIC void FindConditionalFormat( sal_uLong nKey, ScRangeList& rRanges, SCTAB nTab ); 1208 void ConditionalChanged( sal_uLong nKey ); 1209 1210 SC_DLLPUBLIC sal_uLong AddValidationEntry( const ScValidationData& rNew ); 1211 1212 SC_DLLPUBLIC const ScValidationData* GetValidationEntry( sal_uLong nIndex ) const; 1213 1214 ScConditionalFormatList* GetCondFormList() const // Ref-Undo 1215 { return pCondFormList; } 1216 void SetCondFormList(ScConditionalFormatList* pNew); 1217 1218 ScValidationDataList* GetValidationList() const 1219 { return pValidationList; } 1220 1221 SC_DLLPUBLIC void ApplyAttr( SCCOL nCol, SCROW nRow, SCTAB nTab, 1222 const SfxPoolItem& rAttr ); 1223 SC_DLLPUBLIC void ApplyPattern( SCCOL nCol, SCROW nRow, SCTAB nTab, 1224 const ScPatternAttr& rAttr ); 1225 SC_DLLPUBLIC void ApplyPatternArea( SCCOL nStartCol, SCROW nStartRow, 1226 SCCOL nEndCol, SCROW nEndRow, 1227 const ScMarkData& rMark, const ScPatternAttr& rAttr ); 1228 SC_DLLPUBLIC void ApplyPatternAreaTab( SCCOL nStartCol, SCROW nStartRow, 1229 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, 1230 const ScPatternAttr& rAttr ); 1231 SC_DLLPUBLIC void ApplyPatternIfNumberformatIncompatible( 1232 const ScRange& rRange, const ScMarkData& rMark, 1233 const ScPatternAttr& rPattern, short nNewType ); 1234 1235 void ApplyStyle( SCCOL nCol, SCROW nRow, SCTAB nTab, 1236 const ScStyleSheet& rStyle); 1237 void ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow, 1238 SCCOL nEndCol, SCROW nEndRow, 1239 const ScMarkData& rMark, const ScStyleSheet& rStyle); 1240 SC_DLLPUBLIC void ApplyStyleAreaTab( SCCOL nStartCol, SCROW nStartRow, 1241 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, 1242 const ScStyleSheet& rStyle); 1243 1244 void ApplySelectionStyle( const ScStyleSheet& rStyle, const ScMarkData& rMark ); 1245 void ApplySelectionLineStyle( const ScMarkData& rMark, 1246 const SvxBorderLine* pLine, sal_Bool bColorOnly ); 1247 1248 const ScStyleSheet* GetStyle( SCCOL nCol, SCROW nRow, SCTAB nTab ) const; 1249 const ScStyleSheet* GetSelectionStyle( const ScMarkData& rMark ) const; 1250 1251 void StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, sal_Bool bRemoved, 1252 OutputDevice* pDev, 1253 double nPPTX, double nPPTY, 1254 const Fraction& rZoomX, const Fraction& rZoomY ); 1255 1256 sal_Bool IsStyleSheetUsed( const ScStyleSheet& rStyle, sal_Bool bGatherAllStyles ) const; 1257 1258 SC_DLLPUBLIC sal_Bool ApplyFlagsTab( SCCOL nStartCol, SCROW nStartRow, 1259 SCCOL nEndCol, SCROW nEndRow, 1260 SCTAB nTab, sal_Int16 nFlags ); 1261 sal_Bool RemoveFlagsTab( SCCOL nStartCol, SCROW nStartRow, 1262 SCCOL nEndCol, SCROW nEndRow, 1263 SCTAB nTab, sal_Int16 nFlags ); 1264 1265 SC_DLLPUBLIC void SetPattern( const ScAddress&, const ScPatternAttr& rAttr, 1266 sal_Bool bPutToPool = sal_False ); 1267 SC_DLLPUBLIC void SetPattern( SCCOL nCol, SCROW nRow, SCTAB nTab, const ScPatternAttr& rAttr, 1268 sal_Bool bPutToPool = sal_False ); 1269 void DeleteNumberFormat( const sal_uInt32* pDelKeys, sal_uInt32 nCount ); 1270 1271 void AutoFormat( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, 1272 sal_uInt16 nFormatNo, const ScMarkData& rMark ); 1273 void GetAutoFormatData( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, 1274 ScAutoFormatData& rData ); 1275 sal_Bool SearchAndReplace( const SvxSearchItem& rSearchItem, 1276 SCCOL& rCol, SCROW& rRow, SCTAB& rTab, 1277 ScMarkData& rMark, 1278 String& rUndoStr, ScDocument* pUndoDoc = NULL ); 1279 1280 // Col/Row von Folgeaufrufen bestimmen 1281 // (z.B. nicht gefunden von Anfang, oder folgende Tabellen) 1282 static void GetSearchAndReplaceStart( const SvxSearchItem& rSearchItem, 1283 SCCOL& rCol, SCROW& rRow ); 1284 1285 sal_Bool Solver(SCCOL nFCol, SCROW nFRow, SCTAB nFTab, 1286 SCCOL nVCol, SCROW nVRow, SCTAB nVTab, 1287 const String& sValStr, double& nX); 1288 1289 void ApplySelectionPattern( const ScPatternAttr& rAttr, const ScMarkData& rMark ); 1290 void DeleteSelection( sal_uInt16 nDelFlag, const ScMarkData& rMark ); 1291 void DeleteSelectionTab( SCTAB nTab, sal_uInt16 nDelFlag, const ScMarkData& rMark ); 1292 1293 SC_DLLPUBLIC void SetColWidth( SCCOL nCol, SCTAB nTab, sal_uInt16 nNewWidth ); 1294 SC_DLLPUBLIC void SetRowHeight( SCROW nRow, SCTAB nTab, sal_uInt16 nNewHeight ); 1295 SC_DLLPUBLIC void SetRowHeightRange( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, 1296 sal_uInt16 nNewHeight ); 1297 1298 SC_DLLPUBLIC void SetRowHeightOnly( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, 1299 sal_uInt16 nNewHeight ); 1300 void SetManualHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_Bool bManual ); 1301 1302 SC_DLLPUBLIC sal_uInt16 GetColWidth( SCCOL nCol, SCTAB nTab ) const; 1303 SC_DLLPUBLIC sal_uInt16 GetRowHeight( SCROW nRow, SCTAB nTab, bool bHiddenAsZero = true ) const; 1304 SC_DLLPUBLIC sal_uInt16 GetRowHeight( SCROW nRow, SCTAB nTab, SCROW* pStartRow, SCROW* pEndRow, bool bHiddenAsZero = true ) const; 1305 SC_DLLPUBLIC sal_uLong GetRowHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab ) const; 1306 SCROW GetRowForHeight( SCTAB nTab, sal_uLong nHeight ) const; 1307 sal_uLong GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, double fScale ) const; 1308 SC_DLLPUBLIC sal_uLong GetColOffset( SCCOL nCol, SCTAB nTab ) const; 1309 SC_DLLPUBLIC sal_uLong GetRowOffset( SCROW nRow, SCTAB nTab ) const; 1310 1311 SC_DLLPUBLIC sal_uInt16 GetOriginalWidth( SCCOL nCol, SCTAB nTab ) const; 1312 SC_DLLPUBLIC sal_uInt16 GetOriginalHeight( SCROW nRow, SCTAB nTab ) const; 1313 1314 sal_uInt16 GetCommonWidth( SCCOL nEndCol, SCTAB nTab ) const; 1315 1316 SCROW GetHiddenRowCount( SCROW nRow, SCTAB nTab ) const; 1317 1318 sal_uInt16 GetOptimalColWidth( SCCOL nCol, SCTAB nTab, OutputDevice* pDev, 1319 double nPPTX, double nPPTY, 1320 const Fraction& rZoomX, const Fraction& rZoomY, 1321 sal_Bool bFormula, 1322 const ScMarkData* pMarkData = NULL, 1323 sal_Bool bSimpleTextImport = sal_False ); 1324 SC_DLLPUBLIC sal_Bool SetOptimalHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt16 nExtra, 1325 OutputDevice* pDev, 1326 double nPPTX, double nPPTY, 1327 const Fraction& rZoomX, const Fraction& rZoomY, 1328 sal_Bool bShrink ); 1329 void UpdateAllRowHeights( OutputDevice* pDev, 1330 double nPPTX, double nPPTY, 1331 const Fraction& rZoomX, const Fraction& rZoomY, 1332 const ScMarkData* pTabMark = NULL ); 1333 long GetNeededSize( SCCOL nCol, SCROW nRow, SCTAB nTab, 1334 OutputDevice* pDev, 1335 double nPPTX, double nPPTY, 1336 const Fraction& rZoomX, const Fraction& rZoomY, 1337 sal_Bool bWidth, sal_Bool bTotalSize = sal_False ); 1338 1339 SC_DLLPUBLIC void ShowCol(SCCOL nCol, SCTAB nTab, sal_Bool bShow); 1340 SC_DLLPUBLIC void ShowRow(SCROW nRow, SCTAB nTab, sal_Bool bShow); 1341 SC_DLLPUBLIC void ShowRows(SCROW nRow1, SCROW nRow2, SCTAB nTab, sal_Bool bShow); 1342 SC_DLLPUBLIC void SetColFlags( SCCOL nCol, SCTAB nTab, sal_uInt8 nNewFlags ); 1343 SC_DLLPUBLIC void SetRowFlags( SCROW nRow, SCTAB nTab, sal_uInt8 nNewFlags ); 1344 SC_DLLPUBLIC void SetRowFlags( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt8 nNewFlags ); 1345 1346 SC_DLLPUBLIC sal_uInt8 GetColFlags( SCCOL nCol, SCTAB nTab ) const; 1347 SC_DLLPUBLIC sal_uInt8 GetRowFlags( SCROW nRow, SCTAB nTab ) const; 1348 1349 SC_DLLPUBLIC const ScBitMaskCompressedArray< SCROW, sal_uInt8> & GetRowFlagsArray( SCTAB nTab ) const; 1350 SC_DLLPUBLIC ScBitMaskCompressedArray< SCROW, sal_uInt8> & GetRowFlagsArrayModifiable( SCTAB nTab ); 1351 1352 SC_DLLPUBLIC void GetAllRowBreaks(::std::set<SCROW>& rBreaks, SCTAB nTab, bool bPage, bool bManual) const; 1353 SC_DLLPUBLIC void GetAllColBreaks(::std::set<SCCOL>& rBreaks, SCTAB nTab, bool bPage, bool bManual) const; 1354 SC_DLLPUBLIC ScBreakType HasRowBreak(SCROW nRow, SCTAB nTab) const; 1355 SC_DLLPUBLIC ScBreakType HasColBreak(SCCOL nCol, SCTAB nTab) const; 1356 SC_DLLPUBLIC void SetRowBreak(SCROW nRow, SCTAB nTab, bool bPage, bool bManual); 1357 SC_DLLPUBLIC void SetColBreak(SCCOL nCol, SCTAB nTab, bool bPage, bool bManual); 1358 void RemoveRowBreak(SCROW nRow, SCTAB nTab, bool bPage, bool bManual); 1359 void RemoveColBreak(SCCOL nCol, SCTAB nTab, bool bPage, bool bManual); 1360 ::com::sun::star::uno::Sequence< 1361 ::com::sun::star::sheet::TablePageBreakData> GetRowBreakData(SCTAB nTab) const; 1362 1363 SC_DLLPUBLIC bool RowHidden(SCROW nRow, SCTAB nTab, SCROW* pFirstRow = NULL, SCROW* pLastRow = NULL); 1364 SC_DLLPUBLIC bool RowHidden(SCROW nRow, SCTAB nTab, SCROW& rLastRow); 1365 SC_DLLPUBLIC bool HasHiddenRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab); 1366 SC_DLLPUBLIC bool ColHidden(SCCOL nCol, SCTAB nTab, SCCOL& rLastCol); 1367 SC_DLLPUBLIC bool ColHidden(SCCOL nCol, SCTAB nTab, SCCOL* pFirstCol = NULL, SCCOL* pLastCol = NULL); 1368 SC_DLLPUBLIC void SetRowHidden(SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bHidden); 1369 SC_DLLPUBLIC void SetColHidden(SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, bool bHidden); 1370 SC_DLLPUBLIC SCROW FirstVisibleRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab); 1371 SC_DLLPUBLIC SCROW LastVisibleRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab); 1372 SCROW CountVisibleRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab); 1373 1374 bool RowFiltered(SCROW nRow, SCTAB nTab, SCROW* pFirstRow = NULL, SCROW* pLastRow = NULL); 1375 bool HasFilteredRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab); 1376 bool ColFiltered(SCCOL nCol, SCTAB nTab, SCCOL* pFirstCol = NULL, SCCOL* pLastCol = NULL); 1377 SC_DLLPUBLIC void SetRowFiltered(SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bFiltered); 1378 SC_DLLPUBLIC void SetColFiltered(SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, bool bFiltered); 1379 SCROW FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab); 1380 SCROW LastNonFilteredRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab); 1381 SCROW CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab); 1382 1383 /** 1384 * Write all column row flags to table's flag data, because not all column 1385 * row attributes are stored in the flag data members. This is necessary 1386 * for ods export. 1387 */ 1388 void SyncColRowFlags(); 1389 1390 /// @return the index of the last row with any set flags (auto-pagebreak is ignored). 1391 SC_DLLPUBLIC SCROW GetLastFlaggedRow( SCTAB nTab ) const; 1392 1393 /// @return the index of the last changed column (flags and column width, auto pagebreak is ignored). 1394 SCCOL GetLastChangedCol( SCTAB nTab ) const; 1395 /// @return the index of the last changed row (flags and row height, auto pagebreak is ignored). 1396 SCROW GetLastChangedRow( SCTAB nTab ) const; 1397 1398 SCCOL GetNextDifferentChangedCol( SCTAB nTab, SCCOL nStart) const; 1399 1400 // #108550#; if bCareManualSize is set then the row 1401 // heights are compared only if the manual size flag for 1402 // the row is set. If the bCareManualSize is not set then 1403 // the row heights are always compared. 1404 SCROW GetNextDifferentChangedRow( SCTAB nTab, SCROW nStart, bool bCareManualSize = true) const; 1405 1406 // returns whether to export a Default style for this col/row or not 1407 // nDefault is setted to one possition in the current row/col where the Default style is 1408 sal_Bool GetColDefault( SCTAB nTab, SCCOL nCol, SCROW nLastRow, SCROW& nDefault); 1409 sal_Bool GetRowDefault( SCTAB nTab, SCROW nRow, SCCOL nLastCol, SCCOL& nDefault); 1410 1411 sal_Bool UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, sal_Bool bShow ); 1412 sal_Bool UpdateOutlineRow( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_Bool bShow ); 1413 1414 void StripHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2, SCTAB nTab ); 1415 void ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2, SCTAB nTab ); 1416 1417 SC_DLLPUBLIC ScPatternAttr* GetDefPattern() const; 1418 SC_DLLPUBLIC ScDocumentPool* GetPool(); 1419 SC_DLLPUBLIC ScStyleSheetPool* GetStyleSheetPool() const; 1420 1421 // PageStyle: 1422 SC_DLLPUBLIC const String& GetPageStyle( SCTAB nTab ) const; 1423 SC_DLLPUBLIC void SetPageStyle( SCTAB nTab, const String& rName ); 1424 Size GetPageSize( SCTAB nTab ) const; 1425 void SetPageSize( SCTAB nTab, const Size& rSize ); 1426 void SetRepeatArea( SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow ); 1427 void InvalidatePageBreaks(SCTAB nTab); 1428 void UpdatePageBreaks( SCTAB nTab, const ScRange* pUserArea = NULL ); 1429 void RemoveManualBreaks( SCTAB nTab ); 1430 sal_Bool HasManualBreaks( SCTAB nTab ) const; 1431 1432 sal_Bool IsPageStyleInUse( const String& rStrPageStyle, SCTAB* pInTab = NULL ); 1433 sal_Bool RemovePageStyleInUse( const String& rStrPageStyle ); 1434 sal_Bool RenamePageStyleInUse( const String& rOld, const String& rNew ); 1435 void ModifyStyleSheet( SfxStyleSheetBase& rPageStyle, 1436 const SfxItemSet& rChanges ); 1437 1438 void PageStyleModified( SCTAB nTab, const String& rNewName ); 1439 1440 SC_DLLPUBLIC sal_Bool NeedPageResetAfterTab( SCTAB nTab ) const; 1441 1442 // war vorher im PageStyle untergracht. Jetzt an jeder Tabelle: 1443 SC_DLLPUBLIC sal_Bool HasPrintRange(); 1444 SC_DLLPUBLIC sal_uInt16 GetPrintRangeCount( SCTAB nTab ); 1445 SC_DLLPUBLIC const ScRange* GetPrintRange( SCTAB nTab, sal_uInt16 nPos ); 1446 SC_DLLPUBLIC const ScRange* GetRepeatColRange( SCTAB nTab ); 1447 SC_DLLPUBLIC const ScRange* GetRepeatRowRange( SCTAB nTab ); 1448 /** Returns true, if the specified sheet is always printed. */ 1449 sal_Bool IsPrintEntireSheet( SCTAB nTab ) const; 1450 1451 /** Removes all print ranges. */ 1452 SC_DLLPUBLIC void ClearPrintRanges( SCTAB nTab ); 1453 /** Adds a new print ranges. */ 1454 SC_DLLPUBLIC void AddPrintRange( SCTAB nTab, const ScRange& rNew ); 1455 //UNUSED2009-05 /** Removes all old print ranges and sets the passed print ranges. */ 1456 //UNUSED2009-05 void SetPrintRange( SCTAB nTab, const ScRange& rNew ); 1457 /** Marks the specified sheet to be printed completely. Deletes old print ranges on the sheet! */ 1458 SC_DLLPUBLIC void SetPrintEntireSheet( SCTAB nTab ); 1459 SC_DLLPUBLIC void SetRepeatColRange( SCTAB nTab, const ScRange* pNew ); 1460 SC_DLLPUBLIC void SetRepeatRowRange( SCTAB nTab, const ScRange* pNew ); 1461 ScPrintRangeSaver* CreatePrintRangeSaver() const; 1462 void RestorePrintRanges( const ScPrintRangeSaver& rSaver ); 1463 1464 SC_DLLPUBLIC Rectangle GetMMRect( SCCOL nStartCol, SCROW nStartRow, 1465 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab ); 1466 SC_DLLPUBLIC ScRange GetRange( SCTAB nTab, const Rectangle& rMMRect ); 1467 1468 void UpdStlShtPtrsFrmNms(); 1469 void StylesToNames(); 1470 1471 SC_DLLPUBLIC void CopyStdStylesFrom( ScDocument* pSrcDoc ); 1472 1473 CharSet GetSrcCharSet() const { return eSrcSet; } 1474 sal_uLong GetSrcVersion() const { return nSrcVer; } 1475 SCROW GetSrcMaxRow() const { return nSrcMaxRow; } 1476 1477 void SetSrcCharSet( CharSet eNew ) { eSrcSet = eNew; } 1478 void UpdateFontCharSet(); 1479 1480 void FillInfo( ScTableInfo& rTabInfo, SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW nY2, 1481 SCTAB nTab, double nScaleX, double nScaleY, 1482 sal_Bool bPageMode, sal_Bool bFormulaMode, 1483 const ScMarkData* pMarkData = NULL ); 1484 1485 SC_DLLPUBLIC SvNumberFormatter* GetFormatTable() const; 1486 1487 void Sort( SCTAB nTab, const ScSortParam& rSortParam, sal_Bool bKeepQuery ); 1488 SCSIZE Query( SCTAB nTab, const ScQueryParam& rQueryParam, sal_Bool bKeepSub ); 1489 sal_Bool ValidQuery( SCROW nRow, SCTAB nTab, const ScQueryParam& rQueryParam, sal_Bool* pSpecial = NULL ); 1490 SC_DLLPUBLIC sal_Bool CreateQueryParam( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, 1491 SCTAB nTab, ScQueryParam& rQueryParam ); 1492 void GetUpperCellString(SCCOL nCol, SCROW nRow, SCTAB nTab, String& rStr); 1493 1494 sal_Bool GetFilterEntries( SCCOL nCol, SCROW nRow, SCTAB nTab, 1495 bool bFilter, TypedScStrCollection& rStrings, bool& rHasDates); 1496 SC_DLLPUBLIC sal_Bool GetFilterEntriesArea( SCCOL nCol, SCROW nStartRow, SCROW nEndRow, 1497 SCTAB nTab, TypedScStrCollection& rStrings, bool& rHasDates ); 1498 sal_Bool GetDataEntries( SCCOL nCol, SCROW nRow, SCTAB nTab, 1499 TypedScStrCollection& rStrings, sal_Bool bLimit = sal_False ); 1500 sal_Bool GetFormulaEntries( TypedScStrCollection& rStrings ); 1501 1502 sal_Bool HasAutoFilter( SCCOL nCol, SCROW nRow, SCTAB nTab ); 1503 1504 SC_DLLPUBLIC sal_Bool HasColHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, 1505 SCTAB nTab ); 1506 SC_DLLPUBLIC sal_Bool HasRowHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, 1507 SCTAB nTab ); 1508 1509 SfxPrinter* GetPrinter( sal_Bool bCreateIfNotExist = sal_True ); 1510 void SetPrinter( SfxPrinter* pNewPrinter ); 1511 VirtualDevice* GetVirtualDevice_100th_mm(); 1512 SC_DLLPUBLIC OutputDevice* GetRefDevice(); // WYSIWYG: Printer, otherwise VirtualDevice... 1513 1514 void EraseNonUsedSharedNames(sal_uInt16 nLevel); 1515 sal_Bool GetNextSpellingCell(SCCOL& nCol, SCROW& nRow, SCTAB nTab, 1516 sal_Bool bInSel, const ScMarkData& rMark) const; 1517 1518 sal_Bool ReplaceStyle(const SvxSearchItem& rSearchItem, 1519 SCCOL nCol, SCROW nRow, SCTAB nTab, 1520 ScMarkData& rMark, sal_Bool bIsUndo); 1521 1522 void DoColResize( SCTAB nTab, SCCOL nCol1, SCCOL nCol2, SCSIZE nAdd ); 1523 1524 void InvalidateTextWidth( const String& rStyleName ); 1525 void InvalidateTextWidth( SCTAB nTab ); 1526 void InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo, sal_Bool bNumFormatChanged ); 1527 1528 sal_Bool IdleCalcTextWidth(); 1529 sal_Bool IdleCheckLinks(); 1530 1531 sal_Bool ContinueOnlineSpelling(); // sal_True = etwas gefunden 1532 1533 void RepaintRange( const ScRange& rRange ); 1534 1535 sal_Bool IsIdleDisabled() const { return bIdleDisabled; } 1536 void DisableIdle(sal_Bool bDo) { bIdleDisabled = bDo; } 1537 1538 sal_Bool IsDetectiveDirty() const { return bDetectiveDirty; } 1539 void SetDetectiveDirty(sal_Bool bSet) { bDetectiveDirty = bSet; } 1540 1541 void RemoveAutoSpellObj(); 1542 void SetOnlineSpellPos( const ScAddress& rPos ); 1543 SC_DLLPUBLIC sal_Bool SetVisibleSpellRange( const ScRange& rRange ); // sal_True = changed 1544 1545 sal_uInt8 GetMacroCallMode() const { return nMacroCallMode; } 1546 void SetMacroCallMode(sal_uInt8 nNew) { nMacroCallMode = nNew; } 1547 1548 sal_Bool GetHasMacroFunc() const { return bHasMacroFunc; } 1549 void SetHasMacroFunc(sal_Bool bSet) { bHasMacroFunc = bSet; } 1550 1551 sal_Bool CheckMacroWarn(); 1552 1553 void SetRangeOverflowType(sal_uInt32 nType) { nRangeOverflowType = nType; } 1554 sal_Bool HasRangeOverflow() const { return nRangeOverflowType != 0; } 1555 SC_DLLPUBLIC sal_uInt32 GetRangeOverflowType() const { return nRangeOverflowType; } 1556 1557 // fuer Broadcasting/Listening 1558 void SetNoSetDirty( sal_Bool bVal ) { bNoSetDirty = bVal; } 1559 sal_Bool GetNoSetDirty() const { return bNoSetDirty; } 1560 void SetInsertingFromOtherDoc( sal_Bool bVal ) { bInsertingFromOtherDoc = bVal; } 1561 sal_Bool IsInsertingFromOtherDoc() const { return bInsertingFromOtherDoc; } 1562 void SetLoadingMedium( bool bVal ); 1563 void SetImportingXML( bool bVal ); 1564 bool IsImportingXML() const { return bImportingXML; } 1565 void SetXMLFromWrapper( sal_Bool bVal ); 1566 sal_Bool IsXMLFromWrapper() const { return bXMLFromWrapper; } 1567 void SetCalcingAfterLoad( sal_Bool bVal ) { bCalcingAfterLoad = bVal; } 1568 sal_Bool IsCalcingAfterLoad() const { return bCalcingAfterLoad; } 1569 void SetNoListening( sal_Bool bVal ) { bNoListening = bVal; } 1570 sal_Bool GetNoListening() const { return bNoListening; } 1571 ScBroadcastAreaSlotMachine* GetBASM() const { return pBASM; } 1572 1573 ScChartListenerCollection* GetChartListenerCollection() const 1574 { return pChartListenerCollection; } 1575 void SetChartListenerCollection( ScChartListenerCollection*, 1576 sal_Bool bSetChartRangeLists = sal_False ); 1577 void UpdateChart( const String& rName ); 1578 void RestoreChartListener( const String& rName ); 1579 SC_DLLPUBLIC void UpdateChartListenerCollection(); 1580 sal_Bool IsChartListenerCollectionNeedsUpdate() const 1581 { return bChartListenerCollectionNeedsUpdate; } 1582 void SetChartListenerCollectionNeedsUpdate( sal_Bool bFlg ) 1583 { bChartListenerCollectionNeedsUpdate = bFlg; } 1584 void AddOLEObjectToCollection(const String& rName); 1585 1586 ScChangeViewSettings* GetChangeViewSettings() const { return pChangeViewSettings; } 1587 SC_DLLPUBLIC void SetChangeViewSettings(const ScChangeViewSettings& rNew); 1588 1589 vos::ORef<SvxForbiddenCharactersTable> GetForbiddenCharacters(); 1590 void SetForbiddenCharacters( const vos::ORef<SvxForbiddenCharactersTable> xNew ); 1591 1592 sal_uInt8 GetAsianCompression() const; // CharacterCompressionType values 1593 sal_Bool IsValidAsianCompression() const; 1594 void SetAsianCompression(sal_uInt8 nNew); 1595 1596 sal_Bool GetAsianKerning() const; 1597 sal_Bool IsValidAsianKerning() const; 1598 void SetAsianKerning(sal_Bool bNew); 1599 1600 void ApplyAsianEditSettings(ScEditEngineDefaulter& rEngine); 1601 1602 sal_uInt8 GetEditTextDirection(SCTAB nTab) const; // EEHorizontalTextDirection values 1603 1604 SC_DLLPUBLIC ScLkUpdMode GetLinkMode() const { return eLinkMode ;} 1605 void SetLinkMode( ScLkUpdMode nSet ) { eLinkMode = nSet;} 1606 1607 1608 private: 1609 ScDocument(const ScDocument& r); // disabled with no definition 1610 1611 void FindMaxRotCol( SCTAB nTab, RowInfo* pRowInfo, SCSIZE nArrCount, 1612 SCCOL nX1, SCCOL nX2 ) const; 1613 1614 sal_uInt16 RowDifferences( SCROW nThisRow, SCTAB nThisTab, 1615 ScDocument& rOtherDoc, 1616 SCROW nOtherRow, SCTAB nOtherTab, 1617 SCCOL nMaxCol, SCCOLROW* pOtherCols ); 1618 sal_uInt16 ColDifferences( SCCOL nThisCol, SCTAB nThisTab, 1619 ScDocument& rOtherDoc, 1620 SCCOL nOtherCol, SCTAB nOtherTab, 1621 SCROW nMaxRow, SCCOLROW* pOtherRows ); 1622 void FindOrder( SCCOLROW* pOtherRows, SCCOLROW nThisEndRow, SCCOLROW nOtherEndRow, 1623 sal_Bool bColumns, 1624 ScDocument& rOtherDoc, SCTAB nThisTab, SCTAB nOtherTab, 1625 SCCOLROW nEndCol, SCCOLROW* pTranslate, 1626 ScProgress* pProgress, sal_uLong nProAdd ); 1627 sal_Bool OnlineSpellInRange( const ScRange& rSpellRange, ScAddress& rSpellPos, 1628 sal_uInt16 nMaxTest ); 1629 1630 DECL_LINK( TrackTimeHdl, Timer* ); 1631 1632 static ScRecursionHelper* CreateRecursionHelperInstance(); 1633 1634 public: 1635 void StartListeningArea( const ScRange& rRange, 1636 SvtListener* pListener ); 1637 void EndListeningArea( const ScRange& rRange, 1638 SvtListener* pListener ); 1639 /** Broadcast wrapper, calls 1640 SC_DLLPUBLIC rHint.GetCell()->Broadcast() and AreaBroadcast() 1641 and TrackFormulas() and conditional format list 1642 SourceChanged(). 1643 Preferred. 1644 */ 1645 void Broadcast( const ScHint& rHint ); 1646 /// deprecated 1647 void Broadcast( sal_uLong nHint, const ScAddress& rAddr, 1648 ScBaseCell* pCell ); 1649 /// only area, no cell broadcast 1650 void AreaBroadcast( const ScHint& rHint ); 1651 /// only areas in range, no cell broadcasts 1652 void AreaBroadcastInRange( const ScRange& rRange, 1653 const ScHint& rHint ); 1654 void DelBroadcastAreasInRange( const ScRange& rRange ); 1655 void UpdateBroadcastAreas( UpdateRefMode eUpdateRefMode, 1656 const ScRange& rRange, 1657 SCsCOL nDx, SCsROW nDy, SCsTAB nDz ); 1658 1659 1660 void StartListeningCell( const ScAddress& rAddress, 1661 SvtListener* pListener ); 1662 void EndListeningCell( const ScAddress& rAddress, 1663 SvtListener* pListener ); 1664 void PutInFormulaTree( ScFormulaCell* pCell ); 1665 void RemoveFromFormulaTree( ScFormulaCell* pCell ); 1666 void CalcFormulaTree( sal_Bool bOnlyForced = sal_False, 1667 sal_Bool bNoProgressBar = sal_False ); 1668 void ClearFormulaTree(); 1669 void AppendToFormulaTrack( ScFormulaCell* pCell ); 1670 void RemoveFromFormulaTrack( ScFormulaCell* pCell ); 1671 void TrackFormulas( sal_uLong nHintId = SC_HINT_DATACHANGED ); 1672 sal_uInt16 GetFormulaTrackCount() const { return nFormulaTrackCount; } 1673 sal_Bool IsInFormulaTree( ScFormulaCell* pCell ) const; 1674 sal_Bool IsInFormulaTrack( ScFormulaCell* pCell ) const; 1675 sal_uInt16 GetHardRecalcState() { return nHardRecalcState; } 1676 void SetHardRecalcState( sal_uInt16 nVal ) { nHardRecalcState = nVal; } 1677 void StartAllListeners(); 1678 const ScFormulaCell* GetFormulaTree() const { return pFormulaTree; } 1679 sal_Bool HasForcedFormulas() const { return bHasForcedFormulas; } 1680 void SetForcedFormulas( sal_Bool bVal ) { bHasForcedFormulas = bVal; } 1681 sal_uLong GetFormulaCodeInTree() const { return nFormulaCodeInTree; } 1682 sal_Bool IsInInterpreter() const { return nInterpretLevel != 0; } 1683 sal_uInt16 GetInterpretLevel() { return nInterpretLevel; } 1684 void IncInterpretLevel() 1685 { 1686 if ( nInterpretLevel < USHRT_MAX ) 1687 nInterpretLevel++; 1688 } 1689 void DecInterpretLevel() 1690 { 1691 if ( nInterpretLevel ) 1692 nInterpretLevel--; 1693 } 1694 sal_Bool IsInMacroInterpreter() const { return nMacroInterpretLevel != 0; } 1695 sal_uInt16 GetMacroInterpretLevel() { return nMacroInterpretLevel; } 1696 void IncMacroInterpretLevel() 1697 { 1698 if ( nMacroInterpretLevel < USHRT_MAX ) 1699 nMacroInterpretLevel++; 1700 } 1701 void DecMacroInterpretLevel() 1702 { 1703 if ( nMacroInterpretLevel ) 1704 nMacroInterpretLevel--; 1705 } 1706 sal_Bool IsInInterpreterTableOp() const { return nInterpreterTableOpLevel != 0; } 1707 sal_uInt16 GetInterpreterTableOpLevel() { return nInterpreterTableOpLevel; } 1708 void IncInterpreterTableOpLevel() 1709 { 1710 if ( nInterpreterTableOpLevel < USHRT_MAX ) 1711 nInterpreterTableOpLevel++; 1712 } 1713 void DecInterpreterTableOpLevel() 1714 { 1715 if ( nInterpreterTableOpLevel ) 1716 nInterpreterTableOpLevel--; 1717 } 1718 // add a formula to be remembered for TableOp broadcasts 1719 void AddTableOpFormulaCell( ScFormulaCell* ); 1720 void InvalidateLastTableOpParams() { aLastTableOpParams.bValid = sal_False; } 1721 ScRecursionHelper& GetRecursionHelper() 1722 { 1723 if (!pRecursionHelper) 1724 pRecursionHelper = CreateRecursionHelperInstance(); 1725 return *pRecursionHelper; 1726 } 1727 sal_Bool IsInDtorClear() const { return bInDtorClear; } 1728 void SetExpandRefs( sal_Bool bVal ) { bExpandRefs = bVal; } 1729 sal_Bool IsExpandRefs() { return bExpandRefs; } 1730 1731 SC_DLLPUBLIC void IncSizeRecalcLevel( SCTAB nTab ); 1732 SC_DLLPUBLIC void DecSizeRecalcLevel( SCTAB nTab, bool bUpdateNoteCaptionPos = true ); 1733 1734 sal_uLong GetXMLImportedFormulaCount() const { return nXMLImportedFormulaCount; } 1735 void IncXMLImportedFormulaCount( sal_uLong nVal ) 1736 { 1737 if ( nXMLImportedFormulaCount + nVal > nXMLImportedFormulaCount ) 1738 nXMLImportedFormulaCount += nVal; 1739 } 1740 void DecXMLImportedFormulaCount( sal_uLong nVal ) 1741 { 1742 if ( nVal <= nXMLImportedFormulaCount ) 1743 nXMLImportedFormulaCount -= nVal; 1744 else 1745 nXMLImportedFormulaCount = 0; 1746 } 1747 1748 void StartTrackTimer(); 1749 1750 void CompileDBFormula(); 1751 void CompileDBFormula( sal_Bool bCreateFormulaString ); 1752 void CompileNameFormula( sal_Bool bCreateFormulaString ); 1753 void CompileColRowNameFormula(); 1754 1755 /** Maximum string length of a column, e.g. for dBase export. 1756 @return String length in octets (!) of the destination encoding. In 1757 case of non-octet encodings (e.g. UCS2) the length in code 1758 points times sizeof(sal_Unicode) is returned. */ 1759 sal_Int32 GetMaxStringLen( SCTAB nTab, SCCOL nCol, 1760 SCROW nRowStart, SCROW nRowEnd, 1761 CharSet eCharSet ) const; 1762 /** Maximum string length of numerical cells of a column, e.g. for dBase export. 1763 @return String length in characters (!) including the decimal 1764 separator, and the decimal precision needed. */ 1765 xub_StrLen GetMaxNumberStringLen( sal_uInt16& nPrecision, 1766 SCTAB nTab, SCCOL nCol, 1767 SCROW nRowStart, SCROW nRowEnd ) const; 1768 1769 void KeyInput( const KeyEvent& rKEvt ); // TimerDelays etc. 1770 1771 ScChangeTrack* GetChangeTrack() const { return pChangeTrack; } 1772 1773 //! only for import filter, deletes any existing ChangeTrack via 1774 //! EndChangeTracking() and takes ownership of new ChangeTrack pTrack 1775 SC_DLLPUBLIC void SetChangeTrack( ScChangeTrack* pTrack ); 1776 1777 void StartChangeTracking(); 1778 void EndChangeTracking(); 1779 1780 SC_DLLPUBLIC void CompareDocument( ScDocument& rOtherDoc ); 1781 1782 void AddUnoObject( SfxListener& rObject ); 1783 void RemoveUnoObject( SfxListener& rObject ); 1784 void BroadcastUno( const SfxHint &rHint ); 1785 void AddUnoListenerCall( const ::com::sun::star::uno::Reference< 1786 ::com::sun::star::util::XModifyListener >& rListener, 1787 const ::com::sun::star::lang::EventObject& rEvent ); 1788 1789 void SetInLinkUpdate(sal_Bool bSet); // TableLink or AreaLink 1790 sal_Bool IsInLinkUpdate() const; // including DdeLink 1791 1792 SC_DLLPUBLIC SfxItemPool* GetEditPool() const; 1793 SC_DLLPUBLIC SfxItemPool* GetEnginePool() const; 1794 SC_DLLPUBLIC ScFieldEditEngine& GetEditEngine(); 1795 SC_DLLPUBLIC ScNoteEditEngine& GetNoteEngine(); 1796 1797 ScRefreshTimerControl* GetRefreshTimerControl() const 1798 { return pRefreshTimerControl; } 1799 ScRefreshTimerControl * const * GetRefreshTimerControlAddress() const 1800 { return &pRefreshTimerControl; } 1801 1802 void SetPastingDrawFromOtherDoc( sal_Bool bVal ) 1803 { bPastingDrawFromOtherDoc = bVal; } 1804 sal_Bool PastingDrawFromOtherDoc() const 1805 { return bPastingDrawFromOtherDoc; } 1806 1807 /// an ID unique to each document instance 1808 sal_uInt32 GetDocumentID() const; 1809 1810 void InvalidateStyleSheetUsage() 1811 { bStyleSheetUsageInvalid = sal_True; } 1812 void GetSortParam( ScSortParam& rParam, SCTAB nTab ); 1813 void SetSortParam( ScSortParam& rParam, SCTAB nTab ); 1814 1815 inline void SetVbaEventProcessor( const com::sun::star::uno::Reference< com::sun::star::script::vba::XVBAEventProcessor >& rxVbaEvents ) 1816 { mxVbaEvents = rxVbaEvents; } 1817 inline com::sun::star::uno::Reference< com::sun::star::script::vba::XVBAEventProcessor > 1818 GetVbaEventProcessor() const { return mxVbaEvents; } 1819 1820 /** Should only be GRAM_PODF or GRAM_ODFF. */ 1821 void SetStorageGrammar( formula::FormulaGrammar::Grammar eGrammar ); 1822 formula::FormulaGrammar::Grammar GetStorageGrammar() const 1823 { return eStorageGrammar; } 1824 1825 SfxUndoManager* GetUndoManager(); 1826 bool IsInVBAMode() const; 1827 ScRowBreakIterator* GetRowBreakIterator(SCTAB nTab) const; 1828 1829 private: // CLOOK-Impl-Methoden 1830 1831 /** 1832 * Use this class as a locale variable to merge number formatter from 1833 * another document, and set NULL pointer to pFormatExchangeList when 1834 * done. 1835 */ 1836 class NumFmtMergeHandler 1837 { 1838 public: 1839 explicit NumFmtMergeHandler(ScDocument* pDoc, ScDocument* pSrcDoc); 1840 ~NumFmtMergeHandler(); 1841 1842 private: 1843 ScDocument* mpDoc; 1844 }; 1845 1846 void MergeNumberFormatter(ScDocument* pSrcDoc); 1847 1848 void ImplCreateOptions(); // bei Gelegenheit auf on-demand umstellen? 1849 void ImplDeleteOptions(); 1850 1851 void DeleteDrawLayer(); 1852 void DeleteColorTable(); 1853 SC_DLLPUBLIC sal_Bool DrawGetPrintArea( ScRange& rRange, sal_Bool bSetHor, sal_Bool bSetVer ) const; 1854 void DrawMovePage( sal_uInt16 nOldPos, sal_uInt16 nNewPos ); 1855 void DrawCopyPage( sal_uInt16 nOldPos, sal_uInt16 nNewPos ); 1856 1857 void UpdateDrawPrinter(); 1858 void UpdateDrawLanguages(); 1859 void UpdateDrawDefaults(); 1860 SC_DLLPUBLIC void InitClipPtrs( ScDocument* pSourceDoc ); 1861 1862 void LoadDdeLinks(SvStream& rStream); 1863 void SaveDdeLinks(SvStream& rStream) const; 1864 1865 void DeleteAreaLinksOnTab( SCTAB nTab ); 1866 void UpdateRefAreaLinks( UpdateRefMode eUpdateRefMode, 1867 const ScRange& r, SCsCOL nDx, SCsROW nDy, SCsTAB nDz ); 1868 1869 void CopyRangeNamesToClip(ScDocument* pClipDoc, const ScRange& rClipRange, const ScMarkData* pMarks, bool bAllTabs); 1870 void CopyRangeNamesFromClip(ScDocument* pClipDoc, ScClipRangeNameData& rRangeNames); 1871 void UpdateRangeNamesInFormulas( 1872 ScClipRangeNameData& rRangeNames, const ScRangeList& rDestRanges, const ScMarkData& rMark, 1873 SCCOL nXw, SCROW nYw); 1874 1875 sal_Bool HasPartOfMerged( const ScRange& rRange ); 1876 1877 std::map< SCTAB, ScSortParam > mSheetSortParams; 1878 1879 }; 1880 inline void ScDocument::GetSortParam( ScSortParam& rParam, SCTAB nTab ) 1881 { 1882 rParam = mSheetSortParams[ nTab ]; 1883 } 1884 1885 inline void ScDocument::SetSortParam( ScSortParam& rParam, SCTAB nTab ) 1886 { 1887 mSheetSortParams[ nTab ] = rParam; 1888 } 1889 1890 #endif 1891 1892 1893