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