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