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