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