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