binfilter/inc/bf_svx/svdobj.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: svdobj.hxx,v $
  10  * $Revision: 1.11 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef _SVDOBJ_HXX
  32 #define _SVDOBJ_HXX
  33
  34 #include <memory>
  35
  36 #ifndef _CPPUHELPER_WEAKREF_HXX_
  37 #include <cppuhelper/weakref.hxx>
  38 #endif
  39
  40 #ifndef _MAPMOD_HXX //autogen
  41 #include <vcl/mapmod.hxx>
  42 #endif
  43
  44 #ifndef _SFXLSTNER_HXX //autogen
  45 #include <bf_svtools/lstner.hxx>
  46 #endif
  47
  48 #ifndef _SV_TIMER_HXX
  49 #include <vcl/timer.hxx>
  50 #endif
  51
  52 #ifndef _SVDSOB_HXX //autogen
  53 #include <bf_svx/svdsob.hxx>
  54 #endif
  55
  56 #ifndef _SVDTYPES_HXX
  57 #include <bf_svx/svdtypes.hxx> // fuer SdrLayerID
  58 #endif
  59
  60 #ifndef _SVDGLUE_HXX
  61 #include <bf_svx/svdglue.hxx> // Klebepunkte
  62 #endif
  63
  64 #ifndef _SVX_XDASH_HXX
  65 #include <bf_svx/xdash.hxx>
  66 #endif
  67
  68 #ifndef _XPOLY_HXX
  69 #include <bf_svx/xpoly.hxx>
  70 #endif
  71
  72 #ifndef _POLY3D_HXX
  73 #include <bf_svx/poly3d.hxx>
  74 #endif
  75
  76 #ifndef _XENUM_HXX
  77 #include <bf_svx/xenum.hxx>
  78 #endif
  79
  80 #ifndef _TOOLS_COLOR_HXX
  81 #include <tools/color.hxx>
  82 #endif
  83
  84 class Pointer;
  85 class AutoTimer;
  86 class PolyPolygon;
  87 namespace binfilter {
  88
  89 class SfxBroadcaster;
  90 class SfxItemSet;
  91 class SfxSetItem;
  92 class SfxStyleSheet;
  93 class SfxUndoAction;
  94 class SfxItemPool;
  95 class SfxPoolItem;
  96
  97 //************************************************************
  98 //   Vorausdeklarationen
  99 //************************************************************
 100
 101 class ExtOutputDevice;
 102 //class ImpSdrMtfAnimator;
 103 class OutlinerParaObject;
 104 class SdrOutliner;
 105 class SdrDragStat;
 106 class SdrHdl;
 107 class SdrHdlList;
 108 class SdrItemPool;
 109 class SdrMiscSetItem;
 110 class SdrModel;
 111 class SdrObjIOHeader;
 112 class SdrObjList;
 113 class SdrObject;
 114 class SdrOutlinerSetItem;
 115 class SdrPage;
 116 class SdrPageView;
 117 class SdrShadowSetItem;
 118 class SdrView;
 119 class SdrVirtObj;
 120 class XFillAttrSetItem;
 121 class XLineAttrSetItem;
 122 class XPolyPolygon;
 123 class XPolygon;
 124 class XTextAttrSetItem;
 125 class SdrLineGeometry;
 126
 127 //************************************************************
 128 //   Defines
 129 //************************************************************
 130
 131 enum SdrObjKind {OBJ_NONE       = 0,  // Abstraktes Objekt (SdrObject)
 132                  OBJ_GRUP       = 1,  // Objektgruppe
 133                  OBJ_LINE       = 2,  // Strecke
 134                  OBJ_RECT       = 3,  // Rechteck ww. mit runden Ecken
 135                  OBJ_CIRC       = 4,  // Kreis, Ellipse
 136                  OBJ_SECT       = 5,  // Kreissektor
 137                  OBJ_CARC       = 6,  // Kreisbogen
 138                  OBJ_CCUT       = 7,  // Kreisabschnitt
 139                  OBJ_POLY       = 8,  // Polygon, PolyPolygon
 140                  OBJ_PLIN       = 9,  // PolyLine
 141                  OBJ_PATHLINE   =10,  // Offene Bezierkurve
 142                  OBJ_PATHFILL   =11,  // Geschlossene Bezierkurve
 143                  OBJ_FREELINE   =12,  // Offene Freihandlinie
 144                  OBJ_FREEFILL   =13,  // Geschlossene Freihandlinie
 145                  OBJ_SPLNLINE   =14,  // Natuerlicher kubischer Spline          (ni)
 146                  OBJ_SPLNFILL   =15,  // Periodischer kubischer Spline          (ni)
 147                  OBJ_TEXT       =16,  // Textobjekt
 148                  OBJ_TEXTEXT    =17,  // Texterweiterungsrahmen                 (ni)
 149                  OBJ_wegFITTEXT,      // FitToSize-Text (alle Zeilen gleich)
 150                  OBJ_wegFITALLTEXT,   // FitToSize-Text (Zeilenweise)           (ni)
 151                  OBJ_TITLETEXT  =20,  // Titeltext. Spezial-Textobjekt fuer StarDraw
 152                  OBJ_OUTLINETEXT=21,  // OutlineText. Spezial-Textobjekt fuer StarDraw
 153                  OBJ_GRAF       =22,  // Fremdgrafik - (StarView Graphic)
 154                  OBJ_OLE2       =23,  // OLE-Objekt
 155                  OBJ_EDGE       =24,  // Verbindungsobjekt fuer Konnektoren
 156                  OBJ_CAPTION    =25,  // Legendenobjekt
 157                  OBJ_PATHPOLY   =26,  // Polygon/PolyPolygon dargestellt durch SdrPathObj
 158                  OBJ_PATHPLIN   =27,  // Polyline dargestellt durch SdrPathObj
 159                  OBJ_PAGE       =28,  // Objekt, das eine SdrPage darstellt
 160                  OBJ_MEASURE    =29,  // Bemassungsobjekt
 161                  OBJ_DUMMY      =30,  // Dummyobjekt zum speichern von Luecken (zur anschliessenden Wiederherstellung der Surrogate)
 162                  OBJ_FRAME      =31,  // staendig aktives OLE (PlugIn-Frame oder sowas)
 163                  OBJ_UNO        =32,  // Universal Network Object im SvDraw-Obj eingepackt
 164                  OBJ_MAXI};
 165
 166 // Paintmodes, die den SdrObject::Paint-Methoden mitgegeben werden.
 167 #define SDRPAINTMODE_MASTERPAGE         0x0001 /* Obj gehoert zur eingeblendeten Masterpage */
 168 #define SDRPAINTMODE_TEXTEDIT           0x0002 /* An diesem Objekt ist z.Zt. TextEdit aktiv */
 169 #define SDRPAINTMODE_DRAFTTEXT          0x0004 /* Entwurfsmodus, Text weglassen bzw. nur andeuten (Ersatzdarstellung) */
 170 #define SDRPAINTMODE_DRAFTGRAF          0x0008 /* Entwurfsmodus, Grafiken nur andeuten (Ersatzdarstellung) */
 171 #define SDRPAINTMODE_GLUEPOINTS         0x0010 /* Klebepunkte anzeigen */
 172 #define SDRPAINTMODE_ANILIKEPRN         0x0020 /* Animationen so malen, als ob gedruckt wird (z.B. fuer Laufschrift im SdrPageObj) */
 173 #define SDRPAINTMODE_HIDEDRAFTGRAF  0x0040 /* Entwurfsmodus, angedeutete Grafiken nicht darstellen */
 174 #define SDRPAINTMODE_DRAFTLINE          0x0080 /* draftmode for LINE */
 175 #define SDRPAINTMODE_DRAFTFILL          0x0100 /* draftmode for FILL */
 176                                        /* ... to be continued */
 177 enum SdrUserCallType {SDRUSERCALL_MOVEONLY,             // Nur verschoben, Groesse unveraendert
 178                       SDRUSERCALL_RESIZE,               // Groesse und evtl. auch Pos veraendert
 179                       SDRUSERCALL_CHGATTR,              // Attribute veraendert. Moeglicherweise neue Groesse wg. Linienbreite
 180                       SDRUSERCALL_DELETE,               // Obj gibt es gleich nicht mehr. Schon keine Attr mehr.
 181                       SDRUSERCALL_COPY,                 // Zuweisungsoperator gerufen. Kann alles geaendert sein
 182                       SDRUSERCALL_INSERTED,             // In eine Objektliste (z.B. Page) eingefuegt
 183                       SDRUSERCALL_REMOVED,              // Aus der Objektliste entfernt
 184                       SDRUSERCALL_CHILD_MOVEONLY,       // Ein Child einer Gruppe hat sich veraendert
 185                       SDRUSERCALL_CHILD_RESIZE,         // Ein Child einer Gruppe hat sich veraendert
 186                       SDRUSERCALL_CHILD_CHGATTR,        // Ein Child einer Gruppe hat sich veraendert
 187                       SDRUSERCALL_CHILD_DELETE,         // Ein Child einer Gruppe hat sich veraendert
 188                       SDRUSERCALL_CHILD_COPY,           // Ein Child einer Gruppe hat sich veraendert
 189                       SDRUSERCALL_CHILD_INSERTED,       // Ein Child einer Gruppe hat sich veraendert
 190                       SDRUSERCALL_CHILD_REMOVED};       // Ein Child einer Gruppe hat sich veraendert
 191
 192 /* nur voruebergehend, weil sonst MUSS-Aenderung */
 193 #define nLayerID nLayerId
 194
 195 //************************************************************
 196 //   Hilfsklasse SdrObjUserCall
 197 //************************************************************
 198
 199 class SdrObjUserCall
 200 {
 201 public:
 202     TYPEINFO();
 203     virtual ~SdrObjUserCall();
 204     virtual void Changed(const SdrObject& rObj, SdrUserCallType eType, const Rectangle& rOldBoundRect);
 205 };
 206
 207 //************************************************************
 208 //   Hilfsklasse SdrObjMacroHitRec
 209 //************************************************************
 210
 211 class SdrObjMacroHitRec
 212 {
 213 public:
 214     Point                                               aPos;
 215     Point                                               aDownPos;
 216     OutputDevice*                               pOut;
 217     const SetOfByte*                    pVisiLayer;
 218     const SdrPageView*                  pPageView;
 219     USHORT                                              nTol;
 220     FASTBOOL                                    bDown;
 221
 222 public:
 223     SdrObjMacroHitRec()
 224     :   pOut(NULL),
 225         pVisiLayer(NULL),
 226         pPageView(NULL),
 227         nTol(0),
 228         bDown(FALSE)
 229     {}
 230 };
 231
 232 //************************************************************
 233 //   Hilfsklasse SdrObjUserData
 234 //
 235 // Anwenderdaten an einem Zeichenobjekt, z.B. applikationsspezifische Daten.
 236 // Jedes Zeichenobjekt kann beliebig viele dieser Records haben (SV-Liste).
 237 // Wer hier Daten halten will, muss sich ableiten und auch an der Factory
 238 // einen entsprechenden Link setzen.
 239 //
 240 //************************************************************
 241
 242 class SdrObjUserData
 243 {
 244 protected:
 245     UINT32                                              nInventor;
 246     UINT16                                              nIdentifier;
 247     UINT16                                              nVersion;
 248
 249 private:
 250     void operator=(const SdrObjUserData& rData);        // nicht implementiert
 251     FASTBOOL operator==(const SdrObjUserData& rData) const; // nicht implementiert
 252     FASTBOOL operator!=(const SdrObjUserData& rData) const; // nicht implementiert
 253
 254 public:
 255     TYPEINFO();
 256
 257     SdrObjUserData(UINT32 nInv, UINT16 nId, UINT16 nVer)
 258     :   nInventor(nInv),
 259         nIdentifier(nId),
 260         nVersion(nVer)
 261     {}
 262     SdrObjUserData(const SdrObjUserData& rData)
 263     :   nInventor(rData.nInventor),
 264         nIdentifier(rData.nIdentifier),
 265         nVersion(rData.nVersion)
 266     {}
 267     virtual ~SdrObjUserData();
 268
 269     virtual SdrObjUserData* Clone(SdrObject* pObj1) const = 0; // #i71039# NULL -> 0
 270     UINT32  GetInventor() const { return nInventor; }
 271     UINT16  GetId() const { return nIdentifier; }
 272     virtual void WriteData(SvStream& rOut);
 273     virtual void ReadData(SvStream& rIn);
 274
 275     // z.B. fuer die Wiederherstellung von Surrogaten.
 276     // Siehe auch SdrObject::AfterRead().
 277     virtual void AfterRead();
 278
 279     virtual FASTBOOL HasMacro (const SdrObject* pObj) const;
 280 };
 281
 282 //************************************************************
 283 //   Hilfsklasse SdrObjUserDataList
 284 //************************************************************
 285
 286 class SdrObjUserDataList
 287 {
 288     Container                                   aList;
 289
 290 public:
 291     SdrObjUserDataList()
 292     :   aList(1024,4,4)
 293     {}
 294     ~SdrObjUserDataList() { Clear(); }
 295
 296     void Clear();
 297     USHORT GetUserDataCount() const { return USHORT(aList.Count()); }
 298     SdrObjUserData* GetUserData(USHORT nNum) const { return (SdrObjUserData*)aList.GetObject(nNum); }
 299     void InsertUserData(SdrObjUserData* pData, USHORT nPos=0xFFFF) { aList.Insert(pData,nPos); }
 300     SdrObjUserData* RemoveUserData(USHORT nNum) { return (SdrObjUserData*)aList.Remove(nNum);}
 301     void DeleteUserData(USHORT nNum) { delete RemoveUserData(nNum); }
 302 };
 303
 304 //************************************************************
 305 //   Hilfsklasse SdrObjGeoData
 306 //
 307 // Alle geometrischen Daten eines beliebigen Objektes zur Übergabe an's Undo/Redo
 308 //
 309 //************************************************************
 310
 311 class SdrObjGeoData
 312 {
 313 public:
 314     Rectangle                                   aBoundRect;
 315     Point                                               aAnchor;
 316     SdrGluePointList*                   pGPL;
 317     BOOL                                                bMovProt;
 318     BOOL                                                bSizProt;
 319     BOOL                                                bNoPrint;
 320     BOOL                                                bClosedObj;
 321     UINT16                                              nLayerId;
 322
 323 public:
 324     SdrObjGeoData();
 325     virtual ~SdrObjGeoData();
 326 };
 327
 328 //************************************************************
 329 //   Hilfsklasse SdrObjPlusData
 330 //
 331 // Bitsack fuer DrawObjekte
 332 //
 333 //************************************************************
 334
 335 class SdrObjPlusData
 336 {
 337     friend class                                SdrObject;
 338
 339 public:
 340     SfxBroadcaster*                             pBroadcast;    // Broadcaster, falls dieses Obj referenziert wird (bVirtObj=TRUE). Auch fuer Konnektoren etc.
 341     SdrObjUserDataList*                 pUserDataList; // applikationsspeziefische Daten
 342     SdrGluePointList*                   pGluePoints;   // Klebepunkte zum Ankleben von Objektverbindern
 343 //      ImpSdrMtfAnimator*                      pAnimator;     // Fuer Laufschrift und blinkenden Text
 344     AutoTimer*                                  pAutoTimer;
 345     XubString                                   aObjName;      // Jedes Objekt soll nun einen Namen haben
 346
 347     // Name to be used by applications
 348     XubString                                   aHTMLName;
 349
 350 public:
 351     TYPEINFO();
 352     SdrObjPlusData();
 353     virtual ~SdrObjPlusData();
 354     // Keine Streamoperatoren. Jede Obj streamt seinen Teil in Obj::WriteData().
 355 };
 356
 357 //************************************************************
 358 //   Hilfsklasse SdrObjTransformInfoRec
 359 //
 360 // gibt Auskunft ueber verschiedene Eigenschaften eines ZObjects
 361 //
 362 //************************************************************
 363
 364 class SdrObjTransformInfoRec
 365 {
 366 public:
 367     unsigned                                    bSelectAllowed : 1;     // FALSE=Obj kann nicht selektiert werden
 368     unsigned                                    bMoveAllowed : 1;       // FALSE=Obj kann nicht verschoben werden
 369     unsigned                                    bResizeFreeAllowed : 1; // FALSE=Obj kann nicht frei resized werden
 370     unsigned                                    bResizePropAllowed : 1; // FALSE=Obj kann nichtmal proportional resized werden
 371     unsigned                                    bRotateFreeAllowed : 1; // FALSE=Obj kann nicht frei gedreht werden
 372     unsigned                                    bRotate90Allowed : 1;   // FALSE=Obj kann nichtmal im 90deg Raster gedreht werden
 373     unsigned                                    bMirrorFreeAllowed : 1; // FALSE=Obj kann nicht frei gespiegelt werden
 374     unsigned                                    bMirror45Allowed : 1;   // FALSE=Obj kann nichtmal ueber Achse im 45deg Raster gespiegelt werden
 375     unsigned                                    bMirror90Allowed : 1;   // FALSE=Obj kann ebenfalls nicht ueber Achse im 90deg Raster gespiegelt werden
 376     unsigned                                    bTransparenceAllowed : 1; // FALSE=Obj does not have an interactive transparence control
 377     unsigned                                    bGradientAllowed : 1; // FALSE=Obj dooes not have an interactive gradient control
 378     unsigned                                    bShearAllowed : 1;      // FALSE=Obj kann nicht verzerrt werden
 379     unsigned                                    bEdgeRadiusAllowed : 1;
 380     unsigned                                    bNoOrthoDesired : 1;    // TRUE bei Rect; ... FALSE bei BMP,MTF;
 381     unsigned                                    bNoContortion : 1;      // FALSE=Kein verzerren (bei Crook) moeglich (nur TRUE bei PathObj und Gruppierten PathObjs)
 382     unsigned                                    bCanConvToPath : 1;     // FALSE=Keine Konvertierung in PathObj moeglich
 383     unsigned                                    bCanConvToPoly : 1;     // FALSE=Keine Konvertierung in PolyObj moeglich
 384     unsigned                                    bCanConvToContour : 1;     // FALSE=no conversion down to whole contour possible
 385     unsigned                                    bCanConvToPathLineToArea : 1; // FALSE=Keine Konvertierung in PathObj moeglich mit Wandlung von LineToArea
 386     unsigned                                    bCanConvToPolyLineToArea : 1; // FALSE=Keine Konvertierung in PolyObj moeglich mit Wandlung von LineToArea
 387
 388 public:
 389     SdrObjTransformInfoRec()
 390     :   bSelectAllowed(TRUE),
 391         bMoveAllowed(TRUE),
 392         bResizeFreeAllowed(TRUE),
 393         bResizePropAllowed(TRUE),
 394         bRotateFreeAllowed(TRUE),
 395         bRotate90Allowed(TRUE),
 396         bMirrorFreeAllowed(TRUE),
 397         bMirror45Allowed(TRUE),
 398         bMirror90Allowed(TRUE),
 399         bTransparenceAllowed(TRUE),
 400         bGradientAllowed(TRUE),
 401         bShearAllowed(TRUE),
 402         bEdgeRadiusAllowed(TRUE),
 403         bNoOrthoDesired(TRUE),
 404         bNoContortion(TRUE),
 405         bCanConvToPath(TRUE),
 406         bCanConvToPoly(TRUE),
 407         bCanConvToContour(FALSE),
 408         bCanConvToPathLineToArea(TRUE),
 409         bCanConvToPolyLineToArea(TRUE)
 410     {}
 411 };
 412
 413 //************************************************************
 414 //   Hilfsklasse SdrObjTransformInfoRec
 415 //************************************************************
 416
 417 class SdrPaintInfoRec
 418 {
 419 public:
 420     SetOfByte                                   aPaintLayer;
 421     Rectangle                                   aDirtyRect;
 422     Rectangle                                   aCheckRect;
 423     const SdrPageView*                  pPV;  // Die PageView wird u.a. vom TextObj benoetigt fuer Paint wenn TextEdit
 424     const Link*                                 pPaintProc;
 425     const SdrObjList*                   pAktList; // falls GroupEntered oder GluePoints nur auf flacher Ebene (ni)
 426     USHORT                                              nBrkEvent;
 427     USHORT                                              nPaintMode;
 428     UINT32                                              nOriginalDrawMode;
 429
 430     BOOL                                                bPrinter;
 431     BOOL                                                bNotActive;
 432     BOOL                                                bOriginalDrawModeSet;
 433
 434 public:
 435     SdrPaintInfoRec()
 436     :   aPaintLayer(TRUE),
 437         pPV(NULL),
 438         pPaintProc(NULL),
 439         pAktList(NULL),
 440         nBrkEvent(0),
 441         nPaintMode(0),
 442         nOriginalDrawMode(0L),
 443         bPrinter(FALSE),
 444         bNotActive(TRUE),
 445         bOriginalDrawModeSet(FALSE)
 446     {}
 447 };
 448
 449 ////////////////////////////////////////////////////////////////////////////////////////////////////
 450 // class to remember broadcast start positions
 451
 452 class SdrBroadcastItemChange
 453 {
 454     sal_uInt32                                  mnCount;
 455     void*                                               mpData;
 456
 457 public:
 458     SdrBroadcastItemChange(const SdrObject& rObj);
 459     ~SdrBroadcastItemChange();
 460
 461     sal_uInt32 GetRectangleCount() const { return mnCount; }
 462     const Rectangle& GetRectangle(sal_uInt32 nIndex) const;
 463 };
 464
 465 ////////////////////////////////////////////////////////////////////////////////////////////////////
 466 //
 467 //   @@@@  @@@@@  @@@@@@ @@@@@  @@@@  @@@@@@
 468 //  @@  @@ @@  @@     @@ @@    @@  @@   @@
 469 //  @@  @@ @@  @@     @@ @@    @@       @@
 470 //  @@  @@ @@@@@      @@ @@@@  @@       @@
 471 //  @@  @@ @@  @@     @@ @@    @@       @@
 472 //  @@  @@ @@  @@ @@  @@ @@    @@  @@   @@
 473 //   @@@@  @@@@@   @@@@  @@@@@  @@@@    @@
 474 //
 475 // Abstraktes DrawObject
 476 //
 477 ////////////////////////////////////////////////////////////////////////////////////////////////////
 478
 479 class SdrObject: public SfxListener
 480 {
 481     friend class                                SdrObjListIter;
 482     friend class                                SdrVirtObj;
 483     friend class                                SdrRectObj;
 484
 485     static SfxItemSet*                  mpEmptyItemSet;
 486
 487 protected:
 488     Rectangle                                   aOutRect;     // umschliessendes Rechteck fuer Paint (inkl. LineWdt, ...)
 489     Point                                               aAnchor;      // Ankerposition (Writer)
 490     SdrObjList*                                 pObjList;     // Liste, in dem das Obj eingefuegt ist.
 491     SdrPage*                                    pPage;
 492     SdrModel*                                   pModel;
 493     SdrObjUserCall*                             pUserCall;
 494     SdrObjPlusData*                             pPlusData;    // Broadcaster, UserData, Konnektoren, ... (Das ist der Bitsack)
 495
 496     UINT32                                              nOrdNum;      // Rangnummer des Obj in der Liste
 497     UINT16                                              nLayerId;
 498
 499     // Objekt zeigt nur auf ein Anderes
 500     BOOL                                                bVirtObj : 1;
 501     BOOL                                                bBoundRectDirty : 1;
 502     BOOL                                                bSnapRectDirty : 1;
 503     BOOL                                                bNetLock : 1;   // ni
 504     BOOL                                                bInserted : 1;  // nur wenn TRUE gibt's RepaintBroadcast & SetModify
 505     BOOL                                                bGrouped : 1;   // Member eines GroupObjektes?
 506
 507     // Die folgende Flags werden gestreamt
 508     BOOL                                                bMovProt : 1; // Position geschuetzt
 509     BOOL                                                bSizProt : 1; // Groesse geschuetzt
 510     BOOL                                                bNoPrint : 1; // Nicht drucken
 511
 512     // Wenn bEmptyPresObj TRUE ist, handelt es sich um ein
 513     // Praesentationsobjekt, dem noch kein Inhalt zugewiesen
 514     // wurde. Default ist das Flag auf FALSE. Die Verwaltung
 515     // uebernimmt die Applikation. Im Zuweisungsoperator sowie
 516     // beim Clone wird das Flag nicht mitkopiert!
 517     // Das Flag ist persistent.
 518     BOOL                                                bEmptyPresObj : 1;     // Leeres Praesentationsobjekt (Draw)
 519     BOOL                                                bNotPersistent : 1;    // TRUE= Obj wird nicht gestreamt (Writer)
 520     BOOL                                                bNeedColorRestore : 1; // TRUE= Obj benoetigt ColorRestore vor Paint-Aufruf (Writer)
 521
 522     // TRUE=Objekt ist als Objekt der MasterPage nicht sichtbar
 523     BOOL                                                bNotVisibleAsMaster : 1;
 524
 525     // TRUE=Es handelt sich hierbei um ein geschlossenes Objekt, also nicht Linie oder Kreisbogen ...
 526     BOOL                                                bClosedObj : 1;
 527     BOOL                                                bWriterFlyFrame : 1;   // Special fuer den Writer
 528     BOOL                                                bIsEdge : 1;
 529     BOOL                                                bIs3DObj : 1;
 530     BOOL                                                bMarkProt : 1;  // Markieren verboten. Persistent
 531     BOOL                                                bIsUnoObj : 1;
 532     BOOL                                                bNotMasterCachable : 1;
 533
 534     // global static ItemPool for not-yet-insetred items
 535 private:
 536     static SdrItemPool*                 mpGlobalItemPool;
 537 public:
 538     static SdrItemPool* GetGlobalDrawObjectItemPool();
 539 private:
 540
 541 protected:
 542     void ImpDeleteUserData();
 543     SdrObjUserData* ImpGetMacroUserData() const;
 544
 545     // Fuer GetDragComment
 546
 547     void ImpForcePlusData() { if (pPlusData==NULL) pPlusData=NewPlusData(); }
 548 //      ImpSdrMtfAnimator* ImpGetMtfAnimator() const { return pPlusData!=NULL ? pPlusData->pAnimator : NULL; }
 549
 550
 551     // bNotMyself=TRUE bedeutet: Nur die ObjList auf Dirty setzen, nicht mich.
 552     // Wird z.B. benoetigt fuer NbcMove, denn da movt man SnapRect und aOutRect
 553     // i.d.R. gleich mit um die Neuberechnung zu sparen.
 554     virtual void SetRectsDirty(FASTBOOL bNotMyself=FALSE);
 555
 556     // ueberladen, wenn man sich von SdrObjPlusData abgeleitet hat:
 557     virtual SdrObjPlusData* NewPlusData() const;
 558
 559     // this is a weak reference to a possible living api wrapper for this shape
 560     ::com::sun::star::uno::WeakReference< ::com::sun::star::uno::XInterface > mxUnoShape;
 561
 562 protected:
 563     // Diese 3 Methoden muss ein abgeleitetes Objekt ueberladen, wenn es eigene
 564     // geometrische Daten besitzt, die fuer den Undo-Fall gesichert werden
 565     // sollen. NewGeoData() erzeugt lediglich eine leere Instanz auf eine von
 566     // SdrObjGeoData abgeleitete Klasse.
 567     virtual SdrObjGeoData* NewGeoData() const;
 568     virtual void SaveGeoData(SdrObjGeoData& rGeo) const;
 569     virtual void RestGeoData(const SdrObjGeoData& rGeo);
 570
 571 public:
 572     TYPEINFO();
 573     SdrObject();
 574     virtual ~SdrObject();
 575
 576     virtual void SetObjList(SdrObjList* pNewObjList);
 577     SdrObjList* GetObjList() const { return pObjList; }
 578
 579     virtual void SetPage(SdrPage* pNewPage);
 580     SdrPage* GetPage() const { return pPage; }
 581
 582     virtual void SetModel(SdrModel* pNewModel);
 583     SdrModel* GetModel() const { return pModel; }
 584     SdrItemPool* GetItemPool() const;
 585
 586     void AddListener(SfxListener& rListener);
 587     void RemoveListener(SfxListener& rListener);
 588     const SfxBroadcaster* GetBroadcaster() const { return pPlusData!=NULL ? pPlusData->pBroadcast : NULL; }
 589
 590     virtual void AddReference(SdrVirtObj& rVrtObj);
 591     virtual void DelReference(SdrVirtObj& rVrtObj);
 592     virtual UINT32 GetObjInventor() const;
 593     virtual UINT16 GetObjIdentifier() const;
 594     virtual SdrLayerID GetLayer() const;
 595
 596     // Layer muss vorher leer sein!
 597     virtual void   GetLayer(SetOfByte& rSet) const;
 598     virtual void   NbcSetLayer(SdrLayerID nLayer);
 599     virtual void   SetLayer(SdrLayerID nLayer);
 600     void SetUserCall(SdrObjUserCall* pUser) { pUserCall=pUser; }
 601     SdrObjUserCall* GetUserCall() const { return pUserCall; }
 602     void SendUserCall(SdrUserCallType eUserCall, const Rectangle& rBoundRect);
 603
 604     // Ein solcher Referenzpunkt ist z.B. der Punkt eines Symbols, der
 605     // der beim Einfuegen des Symbols auf das Raster gefangen werden soll
 606     // oder der Fixpunkt eines Bildes innerhalb eines Animationsobjektes.
 607
 608     // Ein Objekt kann auch einen individuellen (vom Anwender zu vergebenden)
 609     // Namen tragen (z.B. Symbol oder Gruppenobjekt, OLE2, ... )
 610     virtual void SetName(const String& rStr);
 611     virtual String GetName() const;
 612
 613     // support for HTMLName
 614
 615     // Fuer Gruppenobjekte
 616     FASTBOOL IsGroupObject() const { return GetSubList()!=NULL; }
 617     virtual SdrObjList* GetSubList() const;
 618     SdrObject* GetUpGroup() const;
 619
 620     // Ueber die Objekt-Ordnungsnummer kann man feststellen, ob ein Objekt vor
 621     // oder hinter einem anderen liegt. Objekte mit kleinen Ordnungsnummern werden
 622     // zuerst gezeichnet, Objekte mit grossen Ordnungsnummern zuletzt.
 623     // Wird die Reihenfolge der Objekte in der Liste veraendert, so wird ein
 624     // Dirty-Flag gesetzt (an der Page). Beim naechsten SdrObject::GetOrdNum()
 625     // werden die Ordnungsnummer aller Objekte der Liste neu bestimmt.
 626     UINT32 GetOrdNum() const;
 627
 628     // Diese Methode sollte nur verwendet werden, wenn man ganz  genau weiss,
 629     // was man macht:
 630     UINT32 GetOrdNumDirect() const { return nOrdNum; }
 631
 632     // Das Setzen der Ordnungsnummer sollte nur vom Model bzw. von der Page
 633     // geschehen.
 634     void SetOrdNum(UINT32 nNum) { nOrdNum=nNum; }
 635
 636     const AutoTimer* GetAutoTimer() const { return pPlusData!=NULL ? pPlusData->pAutoTimer : NULL; }
 637     AutoTimer* GetAutoTimer() { return pPlusData!=NULL ? pPlusData->pAutoTimer : NULL; }
 638
 639     // Das BoundRect wird benoetigt fuer:
 640     //    Redraw: Nur noetig, wenn Obj im sichtbaren Bereich
 641     //    Redraw: Bei geaenderten ObjAttributen wird dieser Bereich invalidiert
 642     //    Selektion (HitTest), 1. Stufe
 643     //    Obj nach vorn/hinten: Nur Objs im gleichen Bereich werden beruecksichtigt.
 644     virtual const Rectangle& GetBoundRect() const;
 645     virtual void RecalcBoundRect();
 646     void SendRepaintBroadcast(BOOL bNoPaintNeeded = FALSE) const;
 647     void SendRepaintBroadcast(const Rectangle& rRect) const;
 648
 649     // Modified-Flag am Model setzen
 650     virtual void SetChanged();
 651
 652     // Liefert Paint ein FALSE, so wurde das Paint durch einen Event abgebrochen.
 653     // nBrkEvent bestimmt, wodurch das Paint unterbrochen werden darf.
 654     // => pApp->AnyInput(nBrkEvent);
 655     // Der Parameter nPaintMode wurde Writer-speziefisch eingebaut. Beim InitRedraw
 656     // an der View kann ein USHORT mitgegeben werden, der dann bis hier zum Objekt
 657     // durchgereicht wird. rDirtyRect beschreibt den Bereich, der am OutputDevice
 658     // Invalidiert wurde. rDirtyRect kann groesser sein als das Objekt selbst.
 659     // Wird ein leeres Rectangle uebergeben, so soll stattdessen ein unendlich
 660     // grosses Rechteck gelten.
 661     virtual FASTBOOL Paint(ExtOutputDevice& rXOut, const SdrPaintInfoRec& rInfoRec) const;
 662
 663     /** Line geometry creation and output (used during Paint())
 664
 665         @attention Not intended for use outside SVX. Therefore,
 666         SdrLineGeometry is opaque here.
 667
 668         This method sets up some attributes and then delegates to
 669         CreateLinePoly().
 670
 671         @param rXOut
 672         Output device that specifies required resolution
 673
 674         @param rSet
 675         Item set attributing the line style
 676
 677         @param bIsLineDraft
 678         Set to TRUE, if fast draft mode is requested (prevents thick lines)
 679
 680         @return the generated line geometry. Ownership of the pointer
 681         transfers to the caller.
 682      */
 683     ::std::auto_ptr< SdrLineGeometry > ImpPrepareLineGeometry(ExtOutputDevice& rXOut, const SfxItemSet& rSet, BOOL bIsLineDraft = FALSE) const;
 684     void ImpDrawLineGeometry(   ExtOutputDevice&        rXOut,
 685                                 Color&              rColor,
 686                                 sal_uInt16              nTransparence,
 687                                 SdrLineGeometry&    rLineGeometry,
 688                                 sal_Int32               nDX=0,
 689                                 sal_Int32               nDY=0                   ) const;
 690     void ImpDrawColorLineGeometry(ExtOutputDevice& rXOut, const SfxItemSet& rSet, SdrLineGeometry& rLineGeometry) const;
 691     /** Line geometry creation and output (used during Paint())
 692
 693         @attention Not intended for use outside SVX. Therefore,
 694         SdrLineGeometry is opaque here.
 695
 696         @param rOut
 697         Output device that specifies required resolution
 698
 699         @param bForceOnePixel
 700         Force generated line geometry to be a hair line of one pixel width (in device resolution)
 701
 702         @param bForceTwoPixel
 703         Force generated line geometry to be a hair line of two pixel
 704         width (in device resolution). This is achieved by outputting a
 705         one pixel hair line four times.
 706
 707         @param bIsLineDraft
 708         Set to TRUE, if fast draft mode is requested (prevents thick lines)
 709
 710         @return the generated line geometry. Ownership of the pointer
 711         transfers to the caller.
 712      */
 713     virtual ::std::auto_ptr< SdrLineGeometry > CreateLinePoly( OutputDevice&    rOut,
 714                                                                BOOL                     bForceOnePixel,
 715                                                                BOOL                     bForceTwoPixel,
 716                                                                BOOL                     bIsLineDraft    ) const;
 717
 718     // HitTest, 2. Stufe. nTol ist die zulaessige Toleranz in logischen Einheiten.
 719     // rVisiLayer ist hauptsaechlich fuer Gruppenobjekte gedacht, die ja Objekte
 720     // mit unterschiedlichen Layerzuordnungen beinhalten koennen.
 721     virtual SdrObject* CheckHit(const Point& rPnt, USHORT nTol, const SetOfByte* pVisiLayer) const;
 722     SdrObject* CheckHit(const Point& rPnt, USHORT nTol) const { return CheckHit(rPnt,nTol,NULL); }
 723     FASTBOOL IsHit(const Point& rPnt, USHORT nTol, const SetOfByte* pVisiLayer) const { return CheckHit(rPnt,nTol,pVisiLayer)!=NULL; }
 724     FASTBOOL IsHit(const Point& rPnt, USHORT nTol) const { return CheckHit(rPnt,nTol,NULL)!=NULL; }
 725
 726     // Clone() soll eine komplette Kopie des Objektes erzeugen.
 727     virtual SdrObject* Clone() const;
 728     virtual SdrObject* Clone(SdrPage* pPage, SdrModel* pModel) const;
 729     virtual void operator=(const SdrObject& rObj);
 730
 731     // TakeObjName...() ist fuer die Anzeige in der UI, z.B. "3 Rahmen selektiert".
 732
 733     // Das Xor-Polygon wird von der View zu Draggen des Objektes benoetigt.
 734     // Alle XPolygone innerhalb des XPolyPolygon werden als PolyLine interpretiert.
 735     // Moechte man ein XPolygon, so muss man es explizit schliessen.
 736     virtual void TakeXorPoly(XPolyPolygon& rPoly, FASTBOOL bDetail) const;
 737
 738     // Die Kontur fuer TextToContour
 739     virtual void TakeContour(XPolyPolygon& rPoly) const;
 740     virtual void TakeContour(XPolyPolygon& rXPoly, SdrContourType eType) const;
 741
 742     // Ueber GetHdlCount gibt ein Objekt die Anzahl seiner Handles preis.
 743     // Im Normalfall werden dies 8 sein, bei einer Strecke 2. Bei Polygonobjekten
 744     // (Polygon,Spline,Bezier) kann die Handleanzahl wesentlich groesser werden.
 745     // Polygonobjekten wird ausserdem die Moeglichkeit eingeraeumt einen Punkt
 746     // eines selektierten Objekts zu selektieren. Das Handle dieses Punktes wird
 747     // dann durch einen Satz neuer Handles ausgetauscht (PlusHdl). Bei einem
 748     // Polygon wird das wohl ein einfacher Selektionshandle sein, bei einer
 749     // Bezierkurve dagegen koennen das schon bis zu 3 Handles werden (inkl Gewichte).
 750     // GetHdl() und GetPlusHdl() muessen Handleinstanzen mit new erzeugen!
 751     // Ein Objekt, das bei HasSpacialDrag() TRUE liefert muss diese Methoden
 752     // zur Verfuegung stellen (inkl. FillHdlList).
 753
 754     // Die Standardtransformationen (Move,Resize,Rotate,Mirror,Shear) werden von der
 755     // View uebernommen (TakeXorPoly(),...).
 756     // Objektspeziefisches draggen wie z.B. Eckenradius bei Rechtecken,
 757     // Stuetzstellen bei Splines, Gewichte bei Bezierkurven und Pointer von
 758     // Labelobjekten muss vom Objekt selbst gehandled werden. Um das Model
 759     // Statusfrei zu halten werden die Statusdaten an der View gehalten und dem
 760     // Objekt dann uebergeben. EndDrag liefrt im Normalfall TRUE fuer Erfolg.
 761     // FALSE kann zurueckgegeben werden, wenn das Dragging das Objekt nicht
 762     // veraendert hat, wobei dir evtl. Tatsache das die Maus nicht bewegt wurde
 763     // bereits von der View abgefangen wird.
 764
 765     // Jedes Objekt muss in der Lage sein sich selbst interaktiv zu erzeugen.
 766     // Beim MausDown wird zunaechst ein neues Objekt erzeugt und dann seine
 767     // BegCreate()-Methode gerufen. Bei jedem MausMode wird dann MovCreate
 768     // gerufen. BrkCreate() bedeutet, dass der User die interaktive Objekt-
 769     // erzeugung abgebrochen hat. EndCreate() wird gerufen beim MouseUp-Event.
 770     // Liefert EndCreate() ein TRUE, so ist die Objekterzeugung abgeschlossen;
 771     // das Objekt wird in die entsprechende Liste eingefuegt. Andernfalls
 772     // (EndCreate()==FALSE) gehe ich davon aus, dass weitere Punkte zur
 773     // Objekterzeugung notwendig sind (Polygon,...). Der Parameter eCmd
 774     // enthaelt die Anzahl der Mausklicks (so die App diese durchreicht).
 775     // BckCreate() -> Letztes EndCreate() rueckgaengig machen (z.B. letzten
 776     // Polygonpunkt wieder loeschen).
 777     // RetrunCode: TRUE=Weiter gehts, FALSE=Create dadurch abgebrochen.
 778
 779     // damit holt man sich den Pointer, der das Createn dieses Objekts symbolisiert
 780     virtual Pointer GetCreatePointer() const;
 781
 782     // Polygon das waehrend des Erzeugens aufgezogen wird
 783
 784     // Die Methoden Move, Resize, Rotate, Mirror, Shear, SetSnapRect und
 785     // SetLogicRect rufen jeweils die entsprechenden Nbc-Methoden, versenden einen
 786     // Repaint-Broadcast und setzen den Modified-Status am Model. Abgeleitete
 787     // Objekte sollten i.d.R. nur die Nbc-Methoden ueberladen.
 788     // Nbc bedeutet: 'NoBroadcast'.
 789     virtual void NbcMove  (const Size& rSiz);
 790 /*N*/   virtual void NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact);
 791 /*N*/   virtual void NbcRotate(const Point& rRef, long nWink, double sn, double cs);
 792 /*N*/   virtual void NbcMirror(const Point& rRef1, const Point& rRef2);
 793 /*N*/   virtual void NbcShear (const Point& rRef, long nWink, double tn, FASTBOOL bVShear);
 794
 795     virtual void Move  (const Size& rSiz);
 796     virtual void Resize(const Point& rRef, const Fraction& xFact, const Fraction& yFact);
 797     virtual void Rotate(const Point& rRef, long nWink, double sn, double cs);
 798     virtual void Shear (const Point& rRef, long nWink, double tn, FASTBOOL bVShear);
 799
 800     // Die relative Position eines Zeichenobjektes ist die Entfernung der
 801     // linken oberen Eche des logisch umschliessenden Rechtecks (SnapRect)
 802     // zum Anker.
 803     virtual void NbcSetRelativePos(const Point& rPnt);
 804     virtual void SetRelativePos(const Point& rPnt);
 805     virtual Point GetRelativePos() const;
 806     void ImpSetAnchorPos(const Point& rPnt) { aAnchor=rPnt; }
 807     virtual void NbcSetAnchorPos(const Point& rPnt);
 808     virtual void SetAnchorPos(const Point& rPnt);
 809     virtual const Point& GetAnchorPos() const;
 810
 811     // Snap wird nicht auf dem BoundRect ausgefuehrt, sondern nach Moeglichkeit auf
 812     // logischen Koordinaten (also ohne Beruecksichtigung von Strichstaerke, ... ).
 813     // SetSnapRect() versucht das Objekt so hinzusizen, dass es in das uebergebene
 814     // Rect passt (ohne Strichstaerke, ...)
 815     virtual void RecalcSnapRect();
 816     virtual const Rectangle& GetSnapRect() const;
 817     virtual void SetSnapRect(const Rectangle& rRect);
 818     virtual void NbcSetSnapRect(const Rectangle& rRect);
 819
 820     // Logic Rect: Beim Rect z.B. ohne Beruecksichtigung des Drehwinkels, Shear, ...
 821     virtual const Rectangle& GetLogicRect() const;
 822     virtual void SetLogicRect(const Rectangle& rRect);
 823     virtual void NbcSetLogicRect(const Rectangle& rRect);
 824
 825     // Drehwinkel und Shear
 826     virtual long GetRotateAngle() const;
 827     virtual long GetShearAngle(FASTBOOL bVertical=FALSE) const;
 828
 829     // Zum Fangen von/auf ausgezeichneten Punkten eines Obj (Polygonpunkte,
 830     // Kreismittelpunkt, ...)
 831
 832     // Fuer Objekte, bei denen jeder einzelne Punkt verschoben werden kann,
 833     // z.B. Polygone, Polylines, Linien, ... . Bei diesen Objekten werden
 834     // Punkte selektiert (ggf. Mehrfachselektion), geloescht, eingefuegt,
 835     // als Mehrfachselektion verschoben und gedreht, ...
 836     // Nur solche Objekte koennen PlusHandles haben (z.B. die Gewichte an den
 837     // Bezierkurven.
 838     virtual FASTBOOL IsPolyObj() const;
 839     virtual USHORT GetPointCount() const;
 840     virtual const Point& GetPoint(USHORT i) const;
 841     virtual void SetPoint(const Point& rPnt, USHORT i);
 842     virtual void NbcSetPoint(const Point& rPnt, USHORT i);
 843
 844     // Einfuegen eines neuen Polygonpunktes. Ret muss die Nummer des passenden
 845     // Hdl sein. 0xFFFF= einfuegen nicht moeglich.
 846     // Is bHideHim=TRUE, dann ist interaktives Ins angesagt. Der Punkt ist dann
 847     // geographisch so zu platzieren, dass er nicht auffaellt (z.B. identische
 848     // Pos wie ein Nachbarpunkt).
 849     // bNewObj=TRUE => Ein PolyPolygonObj soll nach Moeglichkeit ein neues
 850     // Polygon beginnen.
 851     // Ueber rInsNextAfter kann ein Flag zurueckgegeben werden, ob weitere
 852     // Punkte vor oder hinter dem gerade Eingefuegten eingefuegt werden sollten
 853     // (z.B. fuer Polylines Punkte anhaengen am Anfang/Ende).
 854     // => Beim einfuegen neuer Punkte ueber die View wird zunaechst die Methode
 855     // ohne Indexparameter gerufen. Diese stellt dann fest wo der Neue hinkommt
 856     // und ob Folgepunkte, vor oder hinter diesem eingefuegt werden sollen.
 857     // Ist das einfuegen diese Punktes an der View abgeschlossen wird dort
 858     // automatisch das einfuegen eines weiteren Punktes gestartet. Am Obj wird
 859     // dafuer die InsPoint-Methode mit Indexparameter gerufen (der Index
 860     // entspricht genau der Handlenummer, die im letzten Aufruf zurueckgegeben
 861     // wurde). Der Parameter bInsAfter enthaelt genau den Wert, den der 1.
 862     // Aufruf (InsPoint ohne Indexparameter) zurueckgab.
 863
 864     // Neuen Punkt an (bInsAfter?nach:vor) einem bestimmten Index einfuegen.
 865
 866     // Loeschen eines Punktes. Ret=FALSE -> Obj besser loeschen
 867
 868     // Wenn Objektspaltung, dann Ret=NeuesObj, sonst Ret=NULL.
 869     // Bei Objektspaltung das Ursprungsobjekt die Punkte mit den niedrigen
 870     // Handlenummern behalten und den oberen Teil an das neue Objekt uebergeben.
 871     // Wenn sich beim Rip die Handlezuordnungen aendern muss das Objekt dies
 872     // ueber den Rueckgabeparameter rNewPt0Index bekanntgeben. Das passiert z.B.
 873     // wenn ein Polygon aufgetrennt wird und dadurch eine Polyline entsteht.
 874     // Das Zeichenobjekt muss in den Parameter rNewPt0Index (default=0) dann
 875     // die Handlenummer (=Index) schreiben, unter der der Punkt, der vorher mit
 876     // Index 0 ansprechbar war, nun erreichbar ist.
 877     // Das ist zwingend notwendig, wenn an der View Auftrennen bei
 878     // Mehrfachpunktselektion vollzogen wird.
 879
 880     // Objekt schliessen (z.B. Polyline->Polygon)
 881
 882     // Alle geometrischen Daten holen fuer's Undo/Redo
 883     virtual SdrObjGeoData* GetGeoData() const;
 884
 885     // ItemSet access
 886     virtual const SfxItemSet& GetItemSet() const;
 887     virtual SfxItemSet* CreateNewItemSet(SfxItemPool& rPool);
 888     virtual void SetItem(const SfxPoolItem& rItem);
 889     virtual void ClearItem(const sal_uInt16 nWhich = 0);
 890     virtual void SetItemSet(const SfxItemSet& rSet);
 891     virtual void BroadcastItemChange(const SdrBroadcastItemChange& rChange);
 892     virtual void ItemSetChanged(const SfxItemSet& rSet);
 893
 894     // syntactical sugar for ItemSet accesses
 895     void SetItemSetAndBroadcast(const SfxItemSet& rSet);
 896     const SfxPoolItem& GetItem(const sal_uInt16 nWhich) const;
 897
 898     // private support routines for ItemSet access. NULL pointer means clear item.
 899     virtual BOOL AllowItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem = 0) const;
 900     virtual void ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem = 0);
 901     virtual void PostItemChange(const sal_uInt16 nWhich);
 902
 903     // pre- and postprocessing for objects for saving
 904     virtual void PreSave();
 905     virtual void PostSave();
 906
 907     // NotPersistAttr fuer Layer, ObjName, geometrische Transformationen, ...
 908     void TakeNotPersistAttr(SfxItemSet& rAttr, FASTBOOL bMerge) const;
 909     void ApplyNotPersistAttr(const SfxItemSet& rAttr);
 910
 911     // bDontRemoveHardAttr=FALSE: alle in der Vorlage gesetzten Attribute werden am
 912     // Zeichenobjekt auf Default gesetzt; TRUE: alle harten Attribute bleiben erhalten.
 913     virtual void SetStyleSheet(SfxStyleSheet* pNewStyleSheet, FASTBOOL bDontRemoveHardAttr);
 914     virtual void NbcSetStyleSheet(SfxStyleSheet* pNewStyleSheet, FASTBOOL bDontRemoveHardAttr);
 915     virtual SfxStyleSheet* GetStyleSheet() const;
 916
 917     // TextEdit
 918     virtual FASTBOOL HasTextEdit() const;
 919     virtual SdrObject* CheckTextEditHit(const Point& rPnt, USHORT nTol, const SetOfByte* pVisiLayer) const;
 920     SdrObject* CheckTextEditHit(const Point& rPnt, USHORT nTol) const { return CheckTextEditHit(rPnt,nTol,NULL); }
 921     FASTBOOL IsTextEditHit(const Point& rPnt, USHORT nTol, const SetOfByte* pVisiLayer) const { return CheckTextEditHit(rPnt,nTol,pVisiLayer)!=NULL; }
 922     FASTBOOL IsTextEditHit(const Point& rPnt, USHORT nTol) const { return CheckTextEditHit(rPnt,nTol,NULL)!=NULL; }
 923
 924     // Return==TRUE: TextEditMode gestartet
 925     virtual FASTBOOL BegTextEdit(SdrOutliner& rOutl);
 926     virtual void EndTextEdit(SdrOutliner& rOutl);
 927
 928     // Text wird im Format des Outliners gehalten
 929     // SetOutlinerParaObject: Eigentumsuebereignung von *pTextObject!
 930     virtual void SetOutlinerParaObject(OutlinerParaObject* pTextObject);
 931     virtual void NbcSetOutlinerParaObject(OutlinerParaObject* pTextObject);
 932     virtual OutlinerParaObject* GetOutlinerParaObject() const;
 933     virtual void NbcReformatText();
 934     virtual void ReformatText();
 935
 936     // Animations-Iterationscounter Resetten. Neustart der Animation
 937     // beim naechsten Paint. pPageView=NULL: Alle PageViews.
 938     virtual void RestartAnimation(SdrPageView* pPageView) const;
 939
 940     // Macrofaehigkeit, z.B. ein Rechteck als PushButton.
 941     virtual FASTBOOL HasMacro() const;
 942
 943     // Konnektoren. (siehe auch Dokumentation in SvdoEdge.HXX, SdrEdgeObj
 944     //               sowie SvdGlue.HXX und SvdGlEV.HXX)
 945     // Es gibt Knoten und Kanten. Eine Kante kann theoretisch auch Knoten
 946     // sein, das ist jedoch in dieser Version noch nicht implementiert.
 947     // Ein Knoten hat eine Anzahl von Klebepunkten, wo Kanten angeklebt
 948     // werden koennen.
 949     // Eine Kante kann
 950     // - ohne Verbindungen sein
 951     // - an einem Ende auf der Wiese stehen und am anderen Ende an
 952     //   genau einem Knoten gebunden sein
 953     // - an beiden Enden mit jeweils genau einem Knoten verbunden sein.
 954     // Die Kante ist Listener bei seinen bis zu 2 Knoten.
 955     // Wird der Knoten verschoben oder Resized, folgen alle angebundenen
 956     // Kanten. Ebenso bei SetGluePoint()... am Knoten.
 957     // Beim Verschieben/Resizen der Kante wird dagegen die Verbindung
 958     // geloesst.
 959     // Objekt ist ein Knoten?
 960     virtual FASTBOOL IsNode() const;
 961
 962     // Automatische Klebepunkte:
 963     // je 4 Scheitelpunkt- und Eckpositionen muss ein Knotenobjekt liefern
 964     // i.d.R. 0=oben, 1=rechts, 2=unten, 3=links
 965     virtual SdrGluePoint GetVertexGluePoint(USHORT nNum) const;
 966
 967     // i.d.R. 0=linksoben, 1=rechtsoben, 2=rechtsunten, 3=linksunten
 968
 969     // Liste aller Klebepunkte. Kann NULL sein.
 970     virtual SdrGluePointList* GetGluePointList();
 971
 972     // Nach veraendern der GluePointList muss man am Obj SendRepaintBroadcast rufen!
 973     virtual SdrGluePointList* ForceGluePointList();
 974
 975     // Temporaer zu setzen fuer Transformationen am Bezugsobjekt
 976     void SetGlueReallyAbsolute(FASTBOOL bOn);
 977     void NbcRotateGluePoints(const Point& rRef, long nWink, double sn, double cs);
 978     void NbcMirrorGluePoints(const Point& rRef1, const Point& rRef2);
 979     void NbcShearGluePoints (const Point& rRef, long nWink, double tn, FASTBOOL bVShear);
 980
 981     // Objekt ist eine Kante?
 982
 983     // Xor-Darstellung der Kante beim Draggen einer der beiden Knoten
 984
 985     // bTail1=TRUE: Linienanfang, sonst LinienEnde
 986     // pObj=NULL: Disconnect
 987     virtual void ConnectToNode(FASTBOOL bTail1, SdrObject* pObj);
 988     virtual void DisconnectFromNode(FASTBOOL bTail1);
 989
 990     // Wenn ein Objekt in der Lage ist, sich in ein Polygon oder in eine
 991     // Bezierkurve (oder beides) zu verwandeln, dann sollten die folgenden
 992     // Methoden ueberladen werden.
 993     // Z.B. Ein RectObj mit Strichstaerke 10, SOLID_PEN in Polygon wandeln:
 994     // Im Modus bLineToArea=FALSE soll ein PolyObj mit 4 Stuetzstellen,
 995     // Strichstaerke 10 und SOLiD_PEN erzeugt werden.
 996     // Im Modus bLineToArea=TRUE dagegen soll das generierte Obj immer ein
 997     // LinienAttribut NULL_PEN haben, und die Linie (auch Linienmuster) selbst
 998     // durch Polygonflaechen emuliert werden, die dadurch anschliessend vom
 999     // Anwender manipuliert werden koennen. Das RectObj kann sich somit also
1000     // nur korrekt konvertieren, wenn es als Flaechenattribut NULL_BRUSH
1001     // besitzt. Es muesste in diesem Fall dann:
1002     // - SOLID_BRUSH mit der Farbe des gesetzten Pen setzen
1003     // - NULL_PEN setzen
1004     // - PolyPolygon mit 2 Polygonen zu je 4 Stuetzstellen generieren.
1005     // Der Returnwert ist jeweils ein SdrObject*, da als Rueckgabe zur Not
1006     // auch Gruppenobjekte erlaubt sind (z.B. fuer SdrTextObj).
1007     // Bei der Konvertierung von TextObj nach PathObj wird es wohl so sein,
1008     // dass beide Modi (bLineToArea=TRUE/FALSE) identisch sind.
1009     // Defaulted sind diese Methoden auf "Ich kann das nicht" (FALSE/NULL).
1010     virtual SdrObject* DoConvertToPolyObj(BOOL bBezier) const;
1011     SdrObject* ConvertToPolyObj(BOOL bBezier, BOOL bLineToArea) const;
1012
1013     // convert this path object to contour object; bForceLineDash converts even
1014     // when there is no filled new polygon created from line-to-polygon conversion,
1015     // specially used for XLINE_DASH and 3D conversion
1016
1017     // Schreiben in einen Stream: Der Operator << schreibt zunaest den 28 Bytes
1018     //   langen SdrObjIOHeader in den Stream und ruft anschliessend die vMethode
1019     //   WriteData() auf. Zum Schluss wird noch das vorerst auf 0 initiallisierte
1020     //   Feld nByteAnz des SdrObjIOHeader gefuellt. Die geerbte Methode WriteData
1021     //   ist in ueberlagerten Methoden stets am Anfang zu rufen.
1022     virtual void WriteData(SvStream& rOut) const;
1023
1024     // Lesen aus einem Stream: Zunaest wird der SdrIOHeader von einem Reader am
1025     //   SdrModel gelesen (Read und SeekBack). Der Reader versucht dann eine
1026     //   Instanz der entsprechenden Klasse entweder selbst zu erzeugen oder bei
1027     //   durch Aufruf eines Links erzeugen zu lassen. Anschliessend wird vom
1028     //   Reader der Operator >> aufgerufen der wiederum die vMethode ReadData()
1029     //   ruft. Der Parameter aHead in ReadData() erlaubt eine Versionskontrolle
1030     //   der zu lesenden Daten.
1031     virtual void ReadData(const SdrObjIOHeader& rHead, SvStream& rIn);
1032
1033     // AfterRead wird gerufen, nachdem das gesamte Model eingestreamt
1034     // worden ist. Damit ist ein PostProcessing moeglich um beispielsweise
1035     // Objektverknuepfungen ueber Surrogate herzustellen o.ae.
1036     // Anwendungsbeispiel hierfuer SdrEdgeObj (Objektverbinder)
1037     virtual void AfterRead();
1038
1039     friend SvStream& operator<<(SvStream& rOut, const SdrObject& rObj);
1040     friend SvStream& operator>>(SvStream& rIn, SdrObject& rObj);
1041
1042     // TRUE: Referenz auf ein Obj
1043     FASTBOOL IsVirtualObj() const { return bVirtObj; }
1044
1045     // TRUE=Obj kann warsch. gefuellt werden; FALSE=Obj kann warsch. Linienenden haben.
1046     // ungueltig, wenn es sich um ein GroupObj handelt.
1047     FASTBOOL IsClosedObj() const { return bClosedObj; }
1048     FASTBOOL IsWriterFlyFrame() const { return bWriterFlyFrame; }
1049     FASTBOOL IsEdgeObj() const { return bIsEdge; }
1050     FASTBOOL Is3DObj() const { return bIs3DObj; }
1051     FASTBOOL IsUnoObj() const { return bIsUnoObj; }
1052     FASTBOOL IsMasterCachable() const { return !bNotMasterCachable; }
1053     FASTBOOL ShareLock() { FASTBOOL r=!bNetLock; bNetLock=TRUE; return r; }
1054     void ShareUnlock() { bNetLock=FALSE; }
1055     FASTBOOL IsShareLock() const { return bNetLock; }
1056     void SetMarkProtect(FASTBOOL bProt) { bMarkProt=bProt; }
1057     FASTBOOL IsMarkProtect() const { return bMarkProt; }
1058     void SetInserted(FASTBOOL bIns);
1059     FASTBOOL IsInserted() const { return bInserted; }
1060     void SetGrouped(FASTBOOL bGrp) { bGrouped=bGrp; }
1061     FASTBOOL IsGrouped() const { return bGrouped; }
1062     void SetMoveProtect(FASTBOOL bProt);
1063     FASTBOOL IsMoveProtect() const { return bMovProt; }
1064     void SetResizeProtect(FASTBOOL bProt);
1065     FASTBOOL IsResizeProtect() const { return bSizProt; }
1066     void SetPrintable(FASTBOOL bPrn);
1067     FASTBOOL IsPrintable() const { return !bNoPrint; }
1068     void SetEmptyPresObj(FASTBOOL bEpt) { bEmptyPresObj=bEpt; }
1069     FASTBOOL IsEmptyPresObj() const { return bEmptyPresObj; }
1070     FASTBOOL IsNotPersistent() const { return bNotPersistent; }
1071     FASTBOOL IsNeedColorRestore() const { return bNeedColorRestore; }
1072     void SetNotVisibleAsMaster(FASTBOOL bFlg) { bNotVisibleAsMaster=bFlg; }
1073     FASTBOOL IsNotVisibleAsMaster() const { return bNotVisibleAsMaster; }
1074
1075     // applikationsspeziefische Daten
1076     USHORT GetUserDataCount() const;
1077     SdrObjUserData* GetUserData(USHORT nNum) const;
1078
1079     // Insert uebernimmt den auf dem Heap angelegten Record in den Besitz
1080     // des Zeichenobjekts
1081     void InsertUserData(SdrObjUserData* pData, USHORT nPos=0xFFFF);
1082
1083     // Delete entfernt den Record aus der Liste und ruft
1084     // ein delete (FreeMem+Dtor).
1085
1086     // ItemPool fuer dieses Objekt wechseln
1087     virtual void MigrateItemPool(SfxItemPool* pSrcPool, SfxItemPool* pDestPool, SdrModel* pNewModel = NULL );
1088
1089     ////////////////////////////////////////////////////////////////////////////////////////////////////
1090     // access to the UNO representation of the shape
1091     ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > getUnoShape();
1092     ::com::sun::star::uno::WeakReference< ::com::sun::star::uno::XInterface > getWeakUnoShape() { return mxUnoShape; }
1093
1094     // helper struct for granting access exclusive to SvxShape
1095     struct GrantXShapeAccess
1096     {
1097         friend class SvxShape;
1098     private:
1099         GrantXShapeAccess() { }
1100     };
1101
1102     // setting the UNO representation is allowed for the UNO representation itself only!
1103     void setUnoShape(
1104         const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _rxUnoShape,
1105         GrantXShapeAccess aGrant
1106     )
1107     {
1108         mxUnoShape = _rxUnoShape;
1109     }
1110
1111     ////////////////////////////////////////////////////////////////////////////////////////////////////
1112     //
1113     // transformation interface for StarOfficeAPI. This implements support for
1114     // homogen 3x3 matrices containing the transformation of the SdrObject. At the
1115     // moment it contains a shearX, rotation and translation, but for setting all linear
1116     // transforms like Scale, ShearX, ShearY, Rotate and Translate are supported.
1117     //
1118     // gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon
1119     // with the base geometry and returns TRUE. Otherwise it returns FALSE.
1120     virtual BOOL TRGetBaseGeometry(Matrix3D& rMat, XPolyPolygon& rPolyPolygon) const;
1121     // sets the base geometry of the object using infos contained in the homogen 3x3 matrix.
1122     // If it's an SdrPathObj it will use the provided geometry information. The Polygon has
1123     // to use (0,0) as upper left and will be scaled to the given size in the matrix.
1124     virtual void TRSetBaseGeometry(const Matrix3D& rMat, const XPolyPolygon& rPolyPolygon);
1125
1126 };
1127
1128 //************************************************************
1129 //   SdrDummyObj
1130 //
1131 // Wer sich eigene Objekte schafft muss einen Link in der Klasse
1132 // SdrObjFactory setzen. Der Handler hat folgendes aussehen:
1133 //    void Hdl(SdrObjFactory*)
1134 // Er muss sich aus der uebergebenen Instanz die Werte nInventor und
1135 // nIdentifier ansehen und entsprechend mit new eine Zeichenobjektinstanz
1136 // erzeugen. Einen Zeiger auf diese Instanz hat er in der Membervariablen
1137 // pNewObj zu hinterlassen.
1138 //
1139 //************************************************************
1140
1141 class SdrObjFactory
1142 {
1143 public:
1144     UINT32                                              nInventor;
1145     UINT16                                              nIdentifier;
1146
1147     // fuer MakeNewObj():
1148     SdrPage*                                    pPage;
1149     SdrModel*                                   pModel;
1150     SdrObject*                                  pNewObj;
1151
1152     // fuer MakeNewObjUserData():
1153     SdrObject*                                  pObj;
1154     SdrObjUserData*                             pNewData;
1155
1156 private:
1157     SdrObjFactory(UINT32 nInvent, UINT16 nIdent, SdrPage* pNewPage, SdrModel* pNewModel) { nInventor=nInvent; nIdentifier=nIdent; pNewObj=NULL; pPage=pNewPage; pModel=pNewModel; pObj=NULL; pNewData=NULL; }
1158     SdrObjFactory(UINT32 nInvent, UINT16 nIdent, SdrObject* pObj1) { nInventor=nInvent; nIdentifier=nIdent; pNewObj=NULL; pPage=NULL; pModel=NULL; pObj=pObj1; pNewData=NULL; }
1159
1160 public:
1161     static SdrObject* MakeNewObject(UINT32 nInvent, UINT16 nIdent, SdrPage* pPage, SdrModel* pModel=NULL);
1162     static void InsertMakeObjectHdl(const Link& rLink);
1163     static void RemoveMakeObjectHdl(const Link& rLink);
1164     static SdrObjUserData* MakeNewObjUserData(UINT32 nInvent, UINT16 nIdent, SdrObject* pObj);
1165     static void InsertMakeUserDataHdl(const Link& rLink);
1166     static void RemoveMakeUserDataHdl(const Link& rLink);
1167 };
1168
1169 }//end of namespace binfilter
1170 #endif //_SVDOBJ_HXX
1171