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