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 _SVDMODEL_HXX 25 #define _SVDMODEL_HXX 26 27 #include <com/sun/star/uno/Sequence.hxx> 28 #include <cppuhelper/weakref.hxx> 29 #include <sot/storage.hxx> 30 #include <tools/link.hxx> 31 #include <tools/contnr.hxx> 32 #include <tools/weakbase.hxx> 33 #include <vcl/mapmod.hxx> 34 #include <svl/brdcst.hxx> 35 #include <tools/string.hxx> 36 #include <tools/datetime.hxx> 37 #include <svl/hint.hxx> 38 39 #include <svl/style.hxx> 40 #include <svx/pageitem.hxx> 41 #include <vcl/field.hxx> 42 43 #include <boost/shared_ptr.hpp> 44 45 class OutputDevice; 46 #include <svx/svdtypes.hxx> // fuer enum RepeatFuncts 47 #include <vcl/field.hxx> 48 #include "svx/svxdllapi.h" 49 50 #include <vos/ref.hxx> 51 52 #if defined(UNX) || defined(WNT) 53 #define DEGREE_CHAR ((sal_Unicode)176) /* 0xB0 = Ansi */ 54 #endif 55 56 #if defined(OS2) 57 #define DEGREE_CHAR ((sal_Unicode)248) /* 0xF8 = IBM PC (Erw. ASCII) */ 58 #endif 59 60 #ifndef DEGREE_CHAR 61 #error unbekannte Plattrorm 62 #endif 63 64 class SdrOutliner; 65 class SdrLayerAdmin; 66 class SdrObjList; 67 class SdrObject; 68 class SdrPage; 69 class SdrPageView; 70 class SdrTextObj; 71 class SdrUndoAction; 72 class SdrUndoGroup; 73 class AutoTimer; 74 class SfxItemPool; 75 class SfxItemSet; 76 class SfxRepeatTarget; 77 class SfxStyleSheet; 78 class SfxUndoAction; 79 class SfxUndoManager; 80 class XBitmapList; 81 class XBitmapTable; 82 class XColorTable; 83 class XDashList; 84 class XDashTable; 85 class XGradientList; 86 class XGradientTable; 87 class XHatchList; 88 class XHatchTable; 89 class XLineEndList; 90 class XLineEndTable; 91 class SvxForbiddenCharactersTable; 92 class SvNumberFormatter; 93 class SotStorage; 94 class SdrOutlinerCache; 95 class SotStorageRef; 96 class SdrUndoFactory; 97 namespace comphelper{ 98 class IEmbeddedHelper; 99 } 100 namespace sfx2{ 101 class LinkManager; 102 } 103 //////////////////////////////////////////////////////////////////////////////////////////////////// 104 105 #define SDR_SWAPGRAPHICSMODE_NONE 0x00000000 106 #define SDR_SWAPGRAPHICSMODE_TEMP 0x00000001 107 #define SDR_SWAPGRAPHICSMODE_DOC 0x00000002 108 #define SDR_SWAPGRAPHICSMODE_PURGE 0x00000100 109 #define SDR_SWAPGRAPHICSMODE_DEFAULT (SDR_SWAPGRAPHICSMODE_TEMP|SDR_SWAPGRAPHICSMODE_DOC|SDR_SWAPGRAPHICSMODE_PURGE) 110 111 //////////////////////////////////////////////////////////////////////////////////////////////////// 112 113 enum SdrHintKind 114 { 115 HINT_UNKNOWN, // Unbekannt 116 HINT_LAYERCHG, // Layerdefinition geaendert 117 HINT_LAYERORDERCHG, // Layerreihenfolge geaendert (Insert/Remove/ChangePos) 118 HINT_PAGEORDERCHG, // Reihenfolge der Seiten (Zeichenseiten oder Masterpages) geaendert (Insert/Remove/ChangePos) 119 HINT_OBJCHG, // Objekt geaendert 120 HINT_OBJINSERTED, // Neues Zeichenobjekt eingefuegt 121 HINT_OBJREMOVED, // Zeichenobjekt aus Liste entfernt 122 HINT_MODELCLEARED, // gesamtes Model geloescht (keine Pages mehr da). not impl. 123 HINT_REFDEVICECHG, // RefDevice geaendert 124 HINT_DEFAULTTABCHG, // Default Tabulatorweite geaendert 125 HINT_DEFFONTHGTCHG, // Default FontHeight geaendert 126 HINT_MODELSAVED, // Dokument wurde gesichert 127 HINT_SWITCHTOPAGE, // #94278# UNDO/REDO at an object evtl. on another page 128 HINT_BEGEDIT, // Is called after the object has entered text edit mode 129 HINT_ENDEDIT // Is called after the object has left text edit mode 130 }; 131 132 class SVX_DLLPUBLIC SdrHint: public SfxHint 133 { 134 public: 135 Rectangle maRectangle; 136 const SdrPage* mpPage; 137 const SdrObject* mpObj; 138 const SdrObjList* mpObjList; 139 SdrHintKind meHint; 140 141 public: 142 TYPEINFO(); 143 144 SdrHint(); 145 SdrHint(SdrHintKind eNewHint); 146 SdrHint(const SdrObject& rNewObj); 147 SdrHint(const SdrObject& rNewObj, const Rectangle& rRect); 148 149 void SetPage(const SdrPage* pNewPage); 150 void SetObjList(const SdrObjList* pNewOL); 151 void SetObject(const SdrObject* pNewObj); 152 void SetKind(SdrHintKind eNewKind); 153 void SetRect(const Rectangle& rNewRect); 154 155 const SdrPage* GetPage() const; 156 const SdrObjList* GetObjList() const; 157 const SdrObject* GetObject() const; 158 SdrHintKind GetKind() const; 159 const Rectangle& GetRect() const; 160 }; 161 162 //////////////////////////////////////////////////////////////////////////////////////////////////// 163 164 // Flag um nach dem Laden des Pools Aufzuraeumen (d.h. die RefCounts 165 // neu zu bestimmen und unbenutztes wegzuwerfen). sal_False == aktiv 166 #define LOADREFCOUNTS (sal_False) 167 168 struct SdrDocumentStreamInfo 169 { 170 FASTBOOL mbDeleteAfterUse; 171 String maUserData; 172 com::sun::star::uno::Reference < com::sun::star::embed::XStorage > mxStorageRef; 173 sal_Bool mbDummy1 : 1; 174 }; 175 176 struct SdrModelImpl; 177 178 class SVX_DLLPUBLIC SdrModel : public SfxBroadcaster, public tools::WeakBase< SdrModel > 179 { 180 protected: 181 DateTime aReadDate; // Datum des Einstreamens 182 Container maMaPag; // StammSeiten (Masterpages) 183 Container maPages; 184 Link aUndoLink; // Link fuer einen NotifyUndo-Handler 185 Link aIOProgressLink; 186 String aTablePath; 187 Size aMaxObjSize; // z.B. fuer Autogrowing Text 188 Fraction aObjUnit; // Beschreibung der Koordinateneinheiten fuer ClipBoard, Drag&Drop, ... 189 MapUnit eObjUnit; // see above 190 FieldUnit eUIUnit; // Masseinheit, Masstab (z.B. 1/1000) fuer die UI (Statuszeile) wird von ImpSetUIUnit() gesetzt 191 Fraction aUIScale; // see above 192 String aUIUnitStr; // see above 193 Fraction aUIUnitFact; // see above 194 int nUIUnitKomma; // see above 195 FASTBOOL bUIOnlyKomma; // see above 196 197 SdrLayerAdmin* pLayerAdmin; 198 SfxItemPool* pItemPool; 199 FASTBOOL bMyPool; // zum Aufraeumen von pMyPool ab 303a 200 comphelper::IEmbeddedHelper* 201 m_pEmbeddedHelper; // helper for embedded objects to get rid of the SfxObjectShell 202 SdrOutliner* pDrawOutliner; // ein Outliner zur Textausgabe 203 SdrOutliner* pHitTestOutliner;// ein Outliner fuer den HitTest 204 sal_uIntPtr nDefTextHgt; // Default Texthoehe in logischen Einheiten 205 OutputDevice* pRefOutDev; // ReferenzDevice fuer die EditEngine 206 sal_uIntPtr nProgressAkt; // fuer den 207 sal_uIntPtr nProgressMax; // ProgressBar- 208 sal_uIntPtr nProgressOfs; // -Handler 209 rtl::Reference< SfxStyleSheetBasePool > mxStyleSheetPool; 210 SfxStyleSheet* pDefaultStyleSheet; 211 sfx2::LinkManager* pLinkManager; // LinkManager 212 Container* pUndoStack; 213 Container* pRedoStack; 214 SdrUndoGroup* pAktUndoGroup; // Fuer mehrstufige 215 sal_uInt16 nUndoLevel; // Undo-Klammerung 216 bool mbUndoEnabled; // If false no undo is recorded or we are during the execution of an undo action 217 sal_uInt16 nProgressPercent; // fuer den ProgressBar-Handler 218 sal_uInt16 nLoadVersion; // Versionsnummer der geladenen Datei 219 FASTBOOL bExtColorTable; // Keinen eigenen ColorTable 220 sal_Bool mbChanged; 221 FASTBOOL bInfoChanged; 222 FASTBOOL bPagNumsDirty; 223 FASTBOOL bMPgNumsDirty; 224 FASTBOOL bPageNotValid; // sal_True=Doc ist nur ObjektTraeger. Page ist nicht gueltig. 225 FASTBOOL bSavePortable; // Metafiles portabel speichern 226 FASTBOOL bNoBitmapCaching; // Bitmaps fuer Screenoutput cachen 227 FASTBOOL bReadOnly; 228 FASTBOOL bTransparentTextFrames; 229 FASTBOOL bSaveCompressed; 230 FASTBOOL bSwapGraphics; 231 FASTBOOL bPasteResize; // Objekte werden gerade resized wegen Paste mit anderem MapMode 232 FASTBOOL bSaveOLEPreview; // save preview metafile of OLE objects 233 sal_uInt16 nStreamCompressMode; // Komprimiert schreiben? 234 sal_uInt16 nStreamNumberFormat; 235 sal_uInt16 nDefaultTabulator; 236 sal_uInt32 nMaxUndoCount; 237 FASTBOOL bSaveNative; 238 sal_Bool bStarDrawPreviewMode; 239 240 241 ////////////////////////////////////////////////////////////////////////////// 242 // sdr::Comment interface 243 private: 244 // the next unique comment ID, used for counting added comments. Initialized 245 // to 0. UI shows one more due to the fact that 0 is a no-no for users. 246 sal_uInt32 mnUniqueCommentID; 247 248 public: 249 // create a new, unique comment ID 250 sal_uInt32 GetNextUniqueCommentID(); 251 252 // get the author name 253 ::rtl::OUString GetDocumentAuthorName() const; 254 255 // for export 256 sal_uInt32 GetUniqueCommentID() const { return mnUniqueCommentID; } 257 258 // for import 259 void SetUniqueCommentID(sal_uInt32 nNewID) { if(nNewID != mnUniqueCommentID) { mnUniqueCommentID = nNewID; } } 260 /** cl: added this for OJ to complete his reporting engine, does not work 261 correctly so only enable it for his model */ 262 bool IsAllowShapePropertyChangeListener() const; 263 void SetAllowShapePropertyChangeListener( bool bAllow ); 264 265 sal_uInt16 nStarDrawPreviewMasterPageNum; 266 // Reserven fuer kompatible Erweiterungen 267 //-/ SfxItemPool* pUndoItemPool; 268 SotStorage* pModelStorage; 269 SvxForbiddenCharactersTable* mpForbiddenCharactersTable; 270 sal_uIntPtr nSwapGraphicsMode; 271 272 SdrOutlinerCache* mpOutlinerCache; 273 SdrModelImpl* mpImpl; 274 sal_uInt16 mnCharCompressType; 275 sal_uInt16 mnHandoutPageCount; 276 sal_uInt16 nReserveUInt6; 277 sal_uInt16 nReserveUInt7; 278 FASTBOOL mbModelLocked; 279 FASTBOOL mbKernAsianPunctuation; 280 FASTBOOL mbAddExtLeading; 281 FASTBOOL mbInDestruction; 282 283 // Zeiger auf Paletten, Listen und Tabellen 284 XColorTable* pColorTable; 285 XDashList* pDashList; 286 XLineEndList* pLineEndList; 287 XHatchList* pHatchList; 288 XGradientList* pGradientList; 289 XBitmapList* pBitmapList; 290 291 // New src638: NumberFormatter for drawing layer and 292 // method for getting it. It is constructed on demand 293 // and destroyed when destroying the SdrModel. 294 SvNumberFormatter* mpNumberFormatter; 295 public: 296 const SvNumberFormatter& GetNumberFormatter() const; 297 298 sal_uInt16 getHandoutPageCount() const { return mnHandoutPageCount; } 299 void setHandoutPageCount( sal_uInt16 nHandoutPageCount ) { mnHandoutPageCount = nHandoutPageCount; } 300 301 protected: 302 303 virtual ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > createUnoModel(); 304 305 private: 306 // Nicht implementiert: 307 SVX_DLLPRIVATE SdrModel(const SdrModel& rSrcModel); 308 SVX_DLLPRIVATE void operator=(const SdrModel& rSrcModel); 309 SVX_DLLPRIVATE FASTBOOL operator==(const SdrModel& rCmpModel) const; 310 //#if 0 // _SOLAR__PRIVATE 311 SVX_DLLPRIVATE void ImpPostUndoAction(SdrUndoAction* pUndo); 312 SVX_DLLPRIVATE void ImpSetUIUnit(); 313 SVX_DLLPRIVATE void ImpSetOutlinerDefaults( SdrOutliner* pOutliner, sal_Bool bInit = sal_False ); 314 SVX_DLLPRIVATE void ImpReformatAllTextObjects(); 315 SVX_DLLPRIVATE void ImpReformatAllEdgeObjects(); // #103122# 316 SVX_DLLPRIVATE void ImpCreateTables(); 317 SVX_DLLPRIVATE void ImpCtor(SfxItemPool* pPool, ::comphelper::IEmbeddedHelper* pPers, bool bUseExtColorTable, 318 bool bLoadRefCounts = true); 319 320 //#endif // __PRIVATE 321 322 // this is a weak reference to a possible living api wrapper for this model 323 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > mxUnoModel; 324 325 public: 326 //#if 0 // _SOLAR__PRIVATE 327 FASTBOOL IsPasteResize() const { return bPasteResize; } 328 void SetPasteResize(FASTBOOL bOn) { bPasteResize=bOn; } 329 //#endif // __PRIVATE 330 TYPEINFO(); 331 // Steckt man hier seinen eigenen Pool rein, so wird die Klasse auch 332 // Aktionen an ihm vornehmen (Put(),Remove()). Bei Zerstoerung von 333 // SdrModel wird dieser Pool ver delete geloescht! 334 // Gibt man den Konstruktor stattdessen eine NULL mit, so macht sich 335 // die Klasse einen eigenen Pool (SdrItemPool), den sie dann auch im 336 // Destruktor zerstoert. 337 // Bei Verwendung eines eigenen Pools ist darauf zu achten, dass dieser 338 // von SdrItemPool abgeleitet ist, falls man von SdrAttrObj abgeleitete 339 // Zeichenobjekte verwenden moechte. Setzt man degegen nur vom abstrakten 340 // Basisobjekt SdrObject abgeleitete Objekte ein, so ist man frei in der 341 // Wahl des Pools. 342 SdrModel(SfxItemPool* pPool=NULL, ::comphelper::IEmbeddedHelper* pPers=NULL, sal_Bool bLoadRefCounts = LOADREFCOUNTS); 343 SdrModel(const String& rPath, SfxItemPool* pPool=NULL, ::comphelper::IEmbeddedHelper* pPers=NULL, sal_Bool bLoadRefCounts = LOADREFCOUNTS); 344 SdrModel(SfxItemPool* pPool, ::comphelper::IEmbeddedHelper* pPers, FASTBOOL bUseExtColorTable, sal_Bool bLoadRefCounts = LOADREFCOUNTS); 345 SdrModel(const String& rPath, SfxItemPool* pPool, ::comphelper::IEmbeddedHelper* pPers, FASTBOOL bUseExtColorTable, sal_Bool bLoadRefCounts = LOADREFCOUNTS); 346 virtual ~SdrModel(); 347 void ClearModel(sal_Bool bCalledFromDestructor); 348 349 // Hier kann man erfragen, ob das Model gerade eingrstreamt wird 350 FASTBOOL IsLoading() const { return sal_False /*BFS01 bLoading */; } 351 // Muss z.B. ueberladen werden, um das Swappen/LoadOnDemand von Grafiken 352 // zu ermoeglichen. Wird rbDeleteAfterUse auf sal_True gesetzt, so wird 353 // die SvStream-Instanz vom Aufrufer nach Gebrauch destruiert. 354 // Wenn diese Methode NULL liefert, wird zum Swappen eine temporaere 355 // Datei angelegt. 356 // Geliefert werden muss der Stream, aus dem das Model geladen wurde 357 // bzw. in den es zuletzt gespeichert wurde. 358 virtual SvStream* GetDocumentStream( SdrDocumentStreamInfo& rStreamInfo ) const; 359 // Die Vorlagenattribute der Zeichenobjekte in harte Attribute verwandeln. 360 void BurnInStyleSheetAttributes(); 361 // Wer sich von SdrPage ableitet muss sich auch von SdrModel ableiten 362 // und diese beiden VM AllocPage() und AllocModel() ueberladen... 363 virtual SdrPage* AllocPage(FASTBOOL bMasterPage); 364 virtual SdrModel* AllocModel() const; 365 366 // Aenderungen an den Layern setzen das Modified-Flag und broadcasten am Model! 367 const SdrLayerAdmin& GetLayerAdmin() const { return *pLayerAdmin; } 368 SdrLayerAdmin& GetLayerAdmin() { return *pLayerAdmin; } 369 370 const SfxItemPool& GetItemPool() const { return *pItemPool; } 371 SfxItemPool& GetItemPool() { return *pItemPool; } 372 373 SdrOutliner& GetDrawOutliner(const SdrTextObj* pObj=NULL) const; 374 375 /** returns a new created and non shared outliner. 376 The outliner will not get updated when the SdrModel is changed. 377 */ 378 boost::shared_ptr< SdrOutliner > CreateDrawOutliner(const SdrTextObj* pObj=NULL); 379 380 SdrOutliner& GetHitTestOutliner() const { return *pHitTestOutliner; } 381 const SdrTextObj* GetFormattingTextObj() const; 382 // Die TextDefaults (Font,Hoehe,Farbe) in ein Set putten 383 void SetTextDefaults() const; 384 static void SetTextDefaults( SfxItemPool* pItemPool, sal_uIntPtr nDefTextHgt ); 385 386 // ReferenzDevice fuer die EditEngine 387 void SetRefDevice(OutputDevice* pDev); 388 OutputDevice* GetRefDevice() const { return pRefOutDev; } 389 // Wenn ein neuer MapMode am RefDevice gesetzt wird o.ae. 390 void RefDeviceChanged(); // noch nicht implementiert 391 // Default-Schrifthoehe in logischen Einheiten 392 void SetDefaultFontHeight(sal_uIntPtr nVal); 393 sal_uIntPtr GetDefaultFontHeight() const { return nDefTextHgt; } 394 // Default-Tabulatorweite fuer die EditEngine 395 void SetDefaultTabulator(sal_uInt16 nVal); 396 sal_uInt16 GetDefaultTabulator() const { return nDefaultTabulator; } 397 398 // Der DefaultStyleSheet wird jedem Zeichenobjekt verbraten das in diesem 399 // Model eingefuegt wird und kein StyleSheet gesetzt hat. 400 SfxStyleSheet* GetDefaultStyleSheet() const { return pDefaultStyleSheet; } 401 void SetDefaultStyleSheet(SfxStyleSheet* pDefSS) { pDefaultStyleSheet = pDefSS; } 402 403 sfx2::LinkManager* GetLinkManager() { return pLinkManager; } 404 void SetLinkManager( sfx2::LinkManager* pLinkMgr ) { pLinkManager = pLinkMgr; } 405 406 ::comphelper::IEmbeddedHelper* GetPersist() const { return m_pEmbeddedHelper; } 407 void ClearPersist() { m_pEmbeddedHelper = 0; } 408 void SetPersist( ::comphelper::IEmbeddedHelper *p ) { m_pEmbeddedHelper = p; } 409 410 // Masseinheit fuer die Zeichenkoordinaten. 411 // Default ist 1 logische Einheit = 1/100mm (Unit=MAP_100TH_MM, Fract=(1,1)). 412 // Beispiele: 413 // MAP_POINT, Fraction(72,1) : 1 log Einh = 72 Point = 1 Inch 414 // MAP_POINT, Fraction(1,20) : 1 log Einh = 1/20 Point = 1 Twip 415 // MAP_TWIP, Fraction(1,1) : 1 log Einh = 1 Twip 416 // MAP_100TH_MM, Fraction(1,10) : 1 log Einh = 1/1000mm 417 // MAP_MM, Fraction(1000,1) : 1 log Einh = 1000mm = 1m 418 // MAP_CM, Fraction(100,1) : 1 log Einh = 100cm = 1m 419 // MAP_CM, Fraction(100,1) : 1 log Einh = 100cm = 1m 420 // MAP_CM, Fraction(100000,1): 1 log Einh = 100000cm = 1km 421 // (PS: Lichtjahre sind somit also nicht darstellbar). 422 // Die Skalierungseinheit wird benoetigt, damit die Engine das Clipboard 423 // mit den richtigen Groessen beliefern kann. 424 MapUnit GetScaleUnit() const { return eObjUnit; } 425 void SetScaleUnit(MapUnit eMap); 426 const Fraction& GetScaleFraction() const { return aObjUnit; } 427 void SetScaleFraction(const Fraction& rFrac); 428 // Beides gleichzeitig setzen ist etwas performanter 429 void SetScaleUnit(MapUnit eMap, const Fraction& rFrac); 430 431 // Maximale Groesse z.B. fuer Autogrowing-Texte 432 const Size& GetMaxObjSize() const { return aMaxObjSize; } 433 void SetMaxObjSize(const Size& rSiz) { aMaxObjSize=rSiz; } 434 435 // Damit die View! in der Statuszeile vernuenftige Zahlen anzeigen kann: 436 // Default ist mm. 437 void SetUIUnit(FieldUnit eUnit); 438 FieldUnit GetUIUnit() const { return eUIUnit; } 439 // Der Masstab der Zeichnung. Default 1/1. 440 void SetUIScale(const Fraction& rScale); 441 const Fraction& GetUIScale() const { return aUIScale; } 442 // Beides gleichzeitig setzen ist etwas performanter 443 void SetUIUnit(FieldUnit eUnit, const Fraction& rScale); 444 445 const Fraction& GetUIUnitFact() const { return aUIUnitFact; } 446 const String& GetUIUnitStr() const { return aUIUnitStr; } 447 int GetUIUnitKomma() const { return nUIUnitKomma; } 448 FASTBOOL IsUIOnlyKomma() const { return bUIOnlyKomma; } 449 450 static void TakeUnitStr(FieldUnit eUnit, String& rStr); 451 void TakeMetricStr(long nVal, String& rStr, FASTBOOL bNoUnitChars=sal_False, sal_Int32 nNumDigits = -1) const; 452 void TakeWinkStr(long nWink, String& rStr, FASTBOOL bNoDegChar=sal_False) const; 453 void TakePercentStr(const Fraction& rVal, String& rStr, FASTBOOL bNoPercentChar=sal_False) const; 454 455 // RecalcPageNums wird idR. nur von der Page gerufen. 456 FASTBOOL IsPagNumsDirty() const { return bPagNumsDirty; }; 457 FASTBOOL IsMPgNumsDirty() const { return bMPgNumsDirty; }; 458 void RecalcPageNums(FASTBOOL bMaster); 459 // Nach dem Insert gehoert die Page dem SdrModel. 460 virtual void InsertPage(SdrPage* pPage, sal_uInt16 nPos=0xFFFF); 461 virtual void DeletePage(sal_uInt16 nPgNum); 462 // Remove bedeutet Eigentumsuebereignung an den Aufrufer (Gegenteil von Insert) 463 virtual SdrPage* RemovePage(sal_uInt16 nPgNum); 464 virtual void MovePage(sal_uInt16 nPgNum, sal_uInt16 nNewPos); 465 const SdrPage* GetPage(sal_uInt16 nPgNum) const; 466 SdrPage* GetPage(sal_uInt16 nPgNum); 467 sal_uInt16 GetPageCount() const; 468 // #109538# 469 virtual void PageListChanged(); 470 471 // Masterpages 472 virtual void InsertMasterPage(SdrPage* pPage, sal_uInt16 nPos=0xFFFF); 473 virtual void DeleteMasterPage(sal_uInt16 nPgNum); 474 // Remove bedeutet Eigentumsuebereignung an den Aufrufer (Gegenteil von Insert) 475 virtual SdrPage* RemoveMasterPage(sal_uInt16 nPgNum); 476 virtual void MoveMasterPage(sal_uInt16 nPgNum, sal_uInt16 nNewPos); 477 const SdrPage* GetMasterPage(sal_uInt16 nPgNum) const; 478 SdrPage* GetMasterPage(sal_uInt16 nPgNum); 479 sal_uInt16 GetMasterPageCount() const; 480 // #109538# 481 virtual void MasterPageListChanged(); 482 483 // Modified-Flag. Wird automatisch gesetzt, wenn an den Pages oder 484 // Zeichenobjekten was geaendert wird. Zuruecksetzen muss man es 485 // jedoch selbst (z.B. bei Save() ...). 486 sal_Bool IsChanged() const { return mbChanged; } 487 virtual void SetChanged(sal_Bool bFlg = sal_True); 488 489 // PageNotValid bedeutet, dass das Model lediglich Objekte traegt die zwar 490 // auf einer Page verankert sind, die Page aber nicht gueltig ist. Diese 491 // Kennzeichnung wird fuers Clipboard/Drag&Drop benoetigt. 492 FASTBOOL IsPageNotValid() const { return bPageNotValid; } 493 void SetPageNotValid(FASTBOOL bJa=sal_True) { bPageNotValid=bJa; } 494 495 // Schaltet man dieses Flag auf sal_True, so werden Grafikobjekte 496 // portabel gespeichert. Es findet dann beim Speichern ggf. 497 // eine implizite Wandlung von Metafiles statt. 498 // Default=FALSE. Flag ist nicht persistent. 499 FASTBOOL IsSavePortable() const { return bSavePortable; } 500 void SetSavePortable(FASTBOOL bJa=sal_True) { bSavePortable=bJa; } 501 502 // Schaltet man dieses Flag auf sal_True, so werden 503 // Pixelobjekte (stark) komprimiert gespeichert. 504 // Default=FALSE. Flag ist nicht persistent. 505 FASTBOOL IsSaveCompressed() const { return bSaveCompressed; } 506 void SetSaveCompressed(FASTBOOL bJa=sal_True) { bSaveCompressed=bJa; } 507 508 // Schaltet man dieses Flag auf sal_True, so werden 509 // Grafikobjekte mit gesetztem Native-Link 510 // native gespeichert. 511 // Default=FALSE. Flag ist nicht persistent. 512 FASTBOOL IsSaveNative() const { return bSaveNative; } 513 void SetSaveNative(FASTBOOL bJa=sal_True) { bSaveNative=bJa; } 514 515 // Schaltet man dieses Flag auf sal_True, so werden die Grafiken 516 // von Grafikobjekten: 517 // - beim Laden eines Dokuments nicht sofort mitgeladen, 518 // sondern erst wenn sie gebraucht (z.B. angezeigt) werden. 519 // - ggf. wieder aus dem Speicher geworfen, falls Sie gerade 520 // nicht benoetigt werden. 521 // Damit das funktioniert, muss die virtuelle Methode 522 // GetDocumentStream() ueberladen werden. 523 // Default=FALSE. Flag ist nicht persistent. 524 FASTBOOL IsSwapGraphics() const { return bSwapGraphics; } 525 void SetSwapGraphics(FASTBOOL bJa=sal_True); 526 void SetSwapGraphicsMode(sal_uIntPtr nMode) { nSwapGraphicsMode = nMode; } 527 sal_uIntPtr GetSwapGraphicsMode() const { return nSwapGraphicsMode; } 528 529 FASTBOOL IsSaveOLEPreview() const { return bSaveOLEPreview; } 530 void SetSaveOLEPreview( FASTBOOL bSet) { bSaveOLEPreview = bSet; } 531 532 // Damit die Bildschirmausgabe von Bitmaps (insbesondere bei gedrehten) 533 // etwas schneller wird, werden sie gecachet. Diesen Cache kann man mit 534 // diesem Flag ein-/ausschalten. Beim naechsten Paint wird an den Objekten 535 // dann ggf. ein Image gemerkt bzw. freigegeben. Wandert ein Bitmapobjekt 536 // in's Undo, so wird der Cache fuer dieses Objekt sofort ausgeschaltet 537 // (Speicher sparen). 538 // Default=Cache eingeschaltet. Flag ist nicht persistent. 539 FASTBOOL IsBitmapCaching() const { return !bNoBitmapCaching; } 540 void SetBitmapCaching(FASTBOOL bJa=sal_True) { bNoBitmapCaching=!bJa; } 541 542 // Defaultmaessig (sal_False) kann man Textrahmen ohne Fuellung durch 543 // Mausklick selektieren. Nach Aktivierung dieses Flags trifft man sie 544 // nur noch in dem Bereich, wo sich auch tatsaechlich Text befindet. 545 FASTBOOL IsPickThroughTransparentTextFrames() const { return bTransparentTextFrames; } 546 void SetPickThroughTransparentTextFrames(FASTBOOL bOn) { bTransparentTextFrames=bOn; } 547 548 // Darf denn das Model ueberhaupt veraendert werden? 549 // Wird nur von den Possibility-Methoden der View ausgewerdet. 550 // Direkte Manipulationen am Model, ... berueksichtigen dieses Flag nicht. 551 // Sollte ueberladen werden und entsprechend des ReadOnly-Status des Files 552 // sal_True oder sal_False liefern (Methode wird oeffters gerufen, also ein Flag 553 // verwenden!). 554 virtual FASTBOOL IsReadOnly() const; 555 virtual void SetReadOnly(FASTBOOL bYes); 556 557 // Vermischen zweier SdrModel. Zu beachten sei, dass rSourceModel nicht 558 // const ist. Die Pages werden beim einfuegen nicht kopiert, sondern gemoved. 559 // rSourceModel ist anschliessend u.U. weitgehend leer. 560 // nFirstPageNum,nLastPageNum: Die aus rSourceModel zu uebernehmenden Seiten 561 // nDestPos..................: Einfuegeposition 562 // bMergeMasterPages.........: sal_True =benoetigte MasterPages werden aus 563 // rSourceModel ebenfalls uebernommen 564 // sal_False=Die MasterPageDescriptoren der Seiten 565 // aus rSourceModel werden auf die 566 // vorhandenen MasterPages gemappt. 567 // bUndo.....................: Fuer das Merging wird eine UndoAction generiert. 568 // Undo ist nur fuer das ZielModel, nicht fuer 569 // rSourceModel. 570 // bTreadSourceAsConst.......: sal_True=Das SourceModel wird nicht veraendert,. 571 // d.h die Seiten werden kopiert. 572 virtual void Merge(SdrModel& rSourceModel, 573 sal_uInt16 nFirstPageNum=0, sal_uInt16 nLastPageNum=0xFFFF, 574 sal_uInt16 nDestPos=0xFFFF, 575 FASTBOOL bMergeMasterPages=sal_False, FASTBOOL bAllMasterPages=sal_False, 576 FASTBOOL bUndo=sal_True, FASTBOOL bTreadSourceAsConst=sal_False); 577 578 // Ist wie Merge(SourceModel=DestModel,nFirst,nLast,nDest,sal_False,sal_False,bUndo,!bMoveNoCopy); 579 void CopyPages(sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum, 580 sal_uInt16 nDestPos, 581 FASTBOOL bUndo=sal_True, FASTBOOL bMoveNoCopy=sal_False); 582 583 // Mit BegUndo() / EndUndo() ist es moeglich beliebig viele UndoActions 584 // beliebig tief zu klammern. Als Kommentar der 585 // UndoAction wird der des ersten BegUndo(String) aller Klammerungen 586 // verwendet. Der NotifyUndoActionHdl wird in diesem Fall erst beim letzten 587 // EndUndo() gerufen. Bei einer leeren Klammerung wird keine UndoAction 588 // generiert. 589 // Alle direkten Aktionen am SdrModel erzeugen keine UndoActions, die 590 // Aktionen an der SdrView dagegen generieren solche. 591 void BegUndo(); // Undo-Klammerung auf 592 void BegUndo(const String& rComment); // Undo-Klammerung auf 593 void BegUndo(const String& rComment, const String& rObjDescr, SdrRepeatFunc eFunc=SDRREPFUNC_OBJ_NONE); // Undo-Klammerung auf 594 void BegUndo(SdrUndoGroup* pUndoGrp); // Undo-Klammerung auf 595 void EndUndo(); // Undo-Klammerung zu 596 void AddUndo(SdrUndoAction* pUndo); 597 sal_uInt16 GetUndoBracketLevel() const { return nUndoLevel; } 598 const SdrUndoGroup* GetAktUndoGroup() const { return pAktUndoGroup; } 599 // nur nach dem 1. BegUndo oder vor dem letzten EndUndo: 600 void SetUndoComment(const String& rComment); 601 void SetUndoComment(const String& rComment, const String& rObjDescr); 602 603 // Das Undo-Managment findet nur statt, wenn kein NotifyUndoAction-Handler 604 // gesetzt ist. 605 // Default ist 16. Minimaler MaxUndoActionCount ist 1! 606 void SetMaxUndoActionCount(sal_uIntPtr nAnz); 607 sal_uIntPtr GetMaxUndoActionCount() const { return nMaxUndoCount; } 608 void ClearUndoBuffer(); 609 // UndoAction(0) ist die aktuelle (also die zuletzt eingegangene) 610 sal_uIntPtr GetUndoActionCount() const { return pUndoStack!=NULL ? pUndoStack->Count() : 0; } 611 const SfxUndoAction* GetUndoAction(sal_uIntPtr nNum) const { return (SfxUndoAction*)(pUndoStack!=NULL ? pUndoStack->GetObject(nNum) : NULL); } 612 // RedoAction(0) ist die aktuelle (also die des letzten Undo) 613 sal_uIntPtr GetRedoActionCount() const { return pRedoStack!=NULL ? pRedoStack->Count() : 0; } 614 const SfxUndoAction* GetRedoAction(sal_uIntPtr nNum) const { return (SfxUndoAction*)(pRedoStack!=NULL ? pRedoStack->GetObject(nNum) : NULL); } 615 616 FASTBOOL Undo(); 617 FASTBOOL Redo(); 618 FASTBOOL Repeat(SfxRepeatTarget&); 619 620 // Hier kann die Applikation einen Handler setzen, der die auflaufenden 621 // UndoActions einsammelt. Der Handler hat folgendes Aussehen: 622 // void __EXPORT NotifyUndoActionHdl(SfxUndoAction* pUndoAction); 623 // Beim Aufruf des Handlers findet eine Eigentumsuebereignung statt; die 624 // UndoAction gehoert somit dem Handler, nicht mehr dem SdrModel. 625 void SetNotifyUndoActionHdl(const Link& rLink) { aUndoLink=rLink; } 626 const Link& GetNotifyUndoActionHdl() const { return aUndoLink; } 627 628 /** application can set it's own undo manager, BegUndo, EndUndo and AddUndoAction 629 calls are routet to this interface if given */ 630 void SetSdrUndoManager( SfxUndoManager* pUndoManager ); 631 SfxUndoManager* GetSdrUndoManager() const; 632 633 /** applications can set their own undo factory to overide creation of 634 undo actions. The SdrModel will become owner of the given SdrUndoFactory 635 and delete it upon its destruction. */ 636 void SetSdrUndoFactory( SdrUndoFactory* pUndoFactory ); 637 638 /** returns the models undo factory. This must be used to create 639 undo actions for this model. */ 640 SdrUndoFactory& GetSdrUndoFactory() const; 641 642 // Hier kann man einen Handler setzen der beim Streamen mehrfach gerufen 643 // wird und ungefaehre Auskunft ueber den Fortschreitungszustand der 644 // Funktion gibt. Der Handler muss folgendes Aussehen haben: 645 // void __EXPORT class::IOProgressHdl(const sal_uInt16& nPercent); 646 // Der erste Aufruf des Handlers erfolgt grundsaetzlich mit 0, der letzte 647 // mit 100. Dazwischen erfolgen maximal 99 Aufrufe mit Werten 1...99. 648 // Man kann also durchaus bei 0 den Progressbar Initiallisieren und bei 649 // 100 wieder schliessen. Zu beachten sei, dass der Handler auch gerufen 650 // wird, wenn die App Draw-Daten im officeweiten Draw-Exchange-Format 651 // bereitstellt, denn dies geschieht durch streamen in einen MemoryStream. 652 void SetIOProgressHdl(const Link& rLink) { aIOProgressLink=rLink; } 653 const Link& GetIOProgressHdl() const { return aIOProgressLink; } 654 655 // Zugriffsmethoden fuer Paletten, Listen und Tabellen 656 void SetColorTable(XColorTable* pTable) { pColorTable=pTable; } 657 XColorTable* GetColorTable() const { return pColorTable; } 658 void SetDashList(XDashList* pList) { pDashList=pList; } 659 XDashList* GetDashList() const { return pDashList; } 660 void SetLineEndList(XLineEndList* pList) { pLineEndList=pList; } 661 XLineEndList* GetLineEndList() const { return pLineEndList; } 662 void SetHatchList(XHatchList* pList) { pHatchList=pList; } 663 XHatchList* GetHatchList() const { return pHatchList; } 664 void SetGradientList(XGradientList* pList) { pGradientList=pList; } 665 XGradientList* GetGradientList() const { return pGradientList; } 666 void SetBitmapList(XBitmapList* pList) { pBitmapList=pList; } 667 XBitmapList* GetBitmapList() const { return pBitmapList; } 668 669 // Der StyleSheetPool wird der DrawingEngine nur bekanntgemacht. 670 // Zu loeschen hat ihn schliesslich der, der ihn auch konstruiert hat. 671 SfxStyleSheetBasePool* GetStyleSheetPool() const { return mxStyleSheetPool.get(); } 672 void SetStyleSheetPool(SfxStyleSheetBasePool* pPool) { mxStyleSheetPool=pPool; } 673 674 // Diese Methode fuert einen Konsistenzcheck auf die Struktur des Models 675 // durch. Geprueft wird insbesondere die Verkettung von Verschachtelten 676 // Gruppenobjekten, aber auch Stati wie bInserted sowie Model* und Page* 677 // der Objects, SubLists und Pages. Bei korrekter Struktur liefert die 678 // Methode sal_True, andernfalls FALSE. 679 // Dieser Check steht nur zur Verfuegung, wenn die Engine mit DBG_UTIL 680 // uebersetzt wurde. Andernfalls liefert die Methode immer TRUE. (ni) 681 FASTBOOL CheckConsistence() const; 682 683 void SetStarDrawPreviewMode(sal_Bool bPreview); 684 sal_Bool IsStarDrawPreviewMode() { return bStarDrawPreviewMode; } 685 686 SotStorage* GetModelStorage() const { return pModelStorage; } 687 void SetModelStorage( SotStorage* pStor ) { pModelStorage = pStor; } 688 689 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > getUnoModel(); 690 void setUnoModel( ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xModel ); 691 692 // these functions are used by the api to disable repaints during a 693 // set of api calls. 694 sal_Bool isLocked() const { return (sal_Bool)mbModelLocked; } 695 void setLock( sal_Bool bLock ); 696 697 void SetForbiddenCharsTable( vos::ORef<SvxForbiddenCharactersTable> xForbiddenChars ); 698 vos::ORef<SvxForbiddenCharactersTable> GetForbiddenCharsTable() const; 699 700 void SetCharCompressType( sal_uInt16 nType ); 701 sal_uInt16 GetCharCompressType() const { return mnCharCompressType; } 702 703 void SetKernAsianPunctuation( sal_Bool bEnabled ); 704 sal_Bool IsKernAsianPunctuation() const { return (sal_Bool)mbKernAsianPunctuation; } 705 706 void SetAddExtLeading( sal_Bool bEnabled ); 707 sal_Bool IsAddExtLeading() const { return (sal_Bool)mbAddExtLeading; } 708 709 void ReformatAllTextObjects(); 710 711 FASTBOOL HasTransparentObjects( sal_Bool bCheckForAlphaChannel = sal_False ) const; 712 713 SdrOutliner* createOutliner( sal_uInt16 nOutlinerMode ); 714 void disposeOutliner( SdrOutliner* pOutliner ); 715 716 sal_Bool IsWriter() const { return !bMyPool; } 717 718 /** returns the numbering type that is used to format page fields in drawing shapes */ 719 virtual SvxNumType GetPageNumType() const; 720 721 /** copies the items from the source set to the destination set. Both sets must have 722 same ranges but can have different pools. If pNewModel is optional. If it is null, 723 this model is used. */ 724 725 void MigrateItemSet( const SfxItemSet* pSourceSet, SfxItemSet* pDestSet, SdrModel* pNewModel ); 726 727 bool IsInDestruction() const; 728 729 static const ::com::sun::star::uno::Sequence< sal_Int8 >& getUnoTunnelImplementationId(); 730 731 /** enables (true) or disables (false) recording of undo actions 732 If undo actions are added while undo is disabled, they are deleted. 733 Disabling undo does not clear the current undo buffer! */ 734 void EnableUndo( bool bEnable ); 735 736 /** returns true if undo is currently enabled 737 This returns false if undo was disabled using EnableUndo( false ) and 738 also during the runtime of the Undo() and Redo() methods. */ 739 bool IsUndoEnabled() const; 740 741 void SetDrawingLayerPoolDefaults(); 742 }; 743 744 typedef tools::WeakReference< SdrModel > SdrModelWeakRef; 745 746 //////////////////////////////////////////////////////////////////////////////////////////////////// 747 748 #endif //_SVDMODEL_HXX 749 750 /* ///////////////////////////////////////////////////////////////////////////////////////////////// 751 +-----------+ 752 | SdrModel | 753 +--+------+-+ 754 | +-----------+ 755 +----+-----+ | 756 | ... | | 757 +----+---+ +----+---+ +-----+--------+ 758 |SdrPage | |SdrPage | |SdrLayerAdmin | 759 +---+----+ +-+--+--++ +---+-------+--+ 760 | | | | | +-------------------+ 761 +----+----+ +-----+-----+ +-------+-------+ 762 | ... | | ... | | ... | 763 +---+---+ +---+---+ +----+----+ +----+----+ +-----+------+ +------+-----+ 764 |SdrObj | |SdrObj | |SdrLayer | |SdrLayer | |SdrLayerSet | |SdrLayerSet | 765 +-------+ +-------+ +---------+ +---------+ +------------+ +------------+ 766 Die Klasse SdrModel ist der Kopf des Datenmodells der StarView Drawing-Engine. 767 768 ///////////////////////////////////////////////////////////////////////////////////////////////// */ 769 770