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