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