DbHatch.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef OD_DBHATCH_H
#define OD_DBHATCH_H
 
#include "TD_PackPush.h"
 
#include "DbEntity.h"
#include "Ge/GePoint2dArray.h"
#include "IntArray.h"
//#include "Ge/GeVoidPointerArray.h"
#include "CmColorArray.h"
#include "HatchPattern.h"
#include "DwgDeclareMembers.h"
#include "DbRegion.h"
#include "UInt16Array.h"
 
#define HATCH_PATTERN_NAME_LENGTH 32
 
 
typedef OdArray<OdGeCurve2d*> EdgeArray;
 
 
class DBENT_EXPORT OdDbHatch : public OdDbEntity
{
public:
  DWGMAP_DECLARE_MEMBERS(OdDbHatch);
 
  OdDbHatch();
 
  enum HatchLoopType
  {
    kDefault             = 0,        // Not yet specified.
    kExternal            = 1,        // Defined by external entities.
    kPolyline            = 2,        // Defined by OdGe polyline.
    kDerived             = 4,        // Derived from a picked point.
    kTextbox             = 8,        // Defined by text.
    kOutermost           = 0x10,     // Outermost loop.
    kNotClosed           = 0x20,     // Open loop.
    kSelfIntersecting    = 0x40,     // Self-intersecting loop.
    kTextIsland          = 0x80,     // Text loop surrounded by an even number of loops.
    kDuplicate           = 0x100,    // Duplicate loop.
    kIsAnnotative        = 0x200,    // The bounding area is an annotative block.
    kDoesNotSupportScale = 0x400,    // The bounding type does not support scaling
    kForceAnnoAllVisible = 0x800,    // Forces all annotatives to be visible
    kOrientToPaper       = 0x1000,   // Orients hatch loop to paper
    kIsAnnotativeBlock   = 0x2000    // Describes if the hatch is an annotative block.
  };
 
  enum HatchEdgeType
  {
    kNone     = 0,  // Skip this segment.
    kLine     = 1,  // Linear.         
    kCirArc   = 2,  // Circular arc.
    kEllArc   = 3,  // Elliptical arc.
    kSpline   = 4   // Spline curve.
  };
 
  enum HatchPatternType
  {
    kUserDefined     = 0, // User-defined hatch.
    kPreDefined      = 1, // Defined in acad.pat and acadiso.pat. 
    kCustomDefined   = 2  // In its own PAT file.
  };
 
  enum HatchStyle
  {
    kNormal   = 0, // Hatch toggles on each boundary.
    kOuter    = 1, // Hatch turns off after first inner loop.
    kIgnore   = 2  // Hatch ignores inner loop
  };
 
  enum HatchObjectType 
  {
    kHatchObject      = 0, // Classic hatch
    kGradientObject   = 1  // Color gradient
  };
 
  enum GradientPatternType 
  {
    kPreDefinedGradient    = 0, // Predefined gradient pattern.
    kUserDefinedGradient   = 1  // User-defined gradient pattern.
  };
 
  double elevation() const;
 
  void setElevation(
    double elevation);
 
  OdGeVector3d normal() const;
  
  void setNormal(
    const OdGeVector3d& normal);
 
  virtual bool isPlanar() const { return true; }
 
  virtual OdResult getPlane(
    OdGePlane& plane, 
    OdDb::Planarity& planarity) const;
 
  int numLoops() const;
 
  OdInt32 loopTypeAt(
    int loopIndex) const;
 
  void getLoopAt(
    int loopIndex, 
    EdgeArray& edgePtrs) const;
 
  void getLoopAt(
    int loopIndex, 
    OdGePoint2dArray& vertices, 
    OdGeDoubleArray& bulges) const;
 
  void appendLoop(
    OdInt32 loopType,
    EdgeArray& edgePtrs);
 
  void appendLoop(
    OdInt32 loopType,
    const OdGePoint2dArray& vertices,
    const OdGeDoubleArray& bulges);
 
  void appendLoop(
    OdInt32 loopType, 
    const OdDbObjectIdArray& dbObjIds);
 
  void appendOrderedLoop(OdInt32 loopType, EdgeArray& edgePtrs);
 
  void insertLoopAt(
    int loopIndex, 
    OdInt32 loopType,
    EdgeArray& edgePtrs);
 
  void insertLoopAt(
    int loopIndex, 
    OdInt32 loopType,
    const OdGePoint2dArray& vertices,
    const OdGeDoubleArray& bulges);
 
  void insertLoopAt(
    int loopIndex, OdInt32 loopType,
    const OdDbObjectIdArray& dbObjIds);
 
  void removeLoopAt(
    int loopIndex);
 
  bool associative() const;
 
  void setAssociative(
    bool isAssociative);
 
  void getAssocObjIdsAt(
    int loopIndex, 
    OdDbObjectIdArray& dbObjIds) const;
 
  void getAssocObjIds(
    OdDbObjectIdArray& dbObjIds) const;
 
  void setAssocObjIdsAt(
    int loopIndex, 
    const OdDbObjectIdArray& dbObjIds);
 
  void removeAssocObjIds();
 
  OdDbHatch::HatchPatternType patternType() const;
 
  bool isSolidFill() const;
 
  
  OdString patternName() const;
 
  void setPattern(
    OdDbHatch::HatchPatternType patType, 
    const OdString& patName);
 
  void setPattern(
    OdDbHatch::HatchPatternType patType, 
    const OdString& patName,
    double angle, 
    double scale,
    const OdHatchPattern& pat,
    OdGePoint2d originPoint = OdGePoint2d());
 
  double patternAngle() const;
 
  void setPatternAngle(
    double angle);
 
  double patternSpace() const;
 
  void setPatternSpace(
    double space);
 
  double patternScale() const;
 
  void setPatternScale(
    double scale);
 
  bool patternDouble() const;
 
  void setPatternDouble(
    bool isDouble);
 
  int numPatternDefinitions() const;
 
  void getPatternDefinitionAt(
    int lineIndex, 
    double& lineAngle, 
    double& baseX,
    double& baseY, 
    double& offsetX, 
    double& offsetY,
    OdGeDoubleArray& dashes) const;
 
  void regeneratePattern(bool forceReload = true);
 
  OdDbHatch::HatchStyle hatchStyle() const;
 
  void setHatchStyle(
    OdDbHatch::HatchStyle hatchStyle);
 
  int numSeedPoints() const;
 
  const OdGePoint2d& getSeedPointAt(
    unsigned seedIndex) const;
 
  void setSeedPointAt(
    unsigned seedIndex, 
    const OdGePoint2d& point);
 
  void appendSeedPoint(const OdGePoint2d& point);
 
  void removeSeedPointAt(int seedPointIndex);
 
  double pixelSize() const;
 
  void setPixelSize(
    double pixelSize);
 
  virtual OdResult dwgInFields(
    OdDbDwgFiler* pFiler);
 
  virtual void dwgOutFields(
    OdDbDwgFiler* pFiler) const;
 
  virtual OdResult dxfInFields(
    OdDbDxfFiler* pFiler);
 
  virtual void dxfOutFields(
    OdDbDxfFiler* pFiler) const;
 
  virtual OdResult subGetClassID(
    void* pClsid) const;
 
  virtual bool subWorldDraw(
    OdGiWorldDraw* pWd) const;
 
  virtual void subViewportDraw(
    OdGiViewportDraw* pWd) const;
 
  virtual OdResult subTransformBy(
    const OdGeMatrix3d& xfm) ODRX_OVERRIDE;
 
  virtual OdResult subGetTransformedCopy(
    const OdGeMatrix3d& xfm, 
    OdDbEntityPtr& pCopy) const ODRX_OVERRIDE;
 
  OdDbObjectPtr decomposeForSave(
    OdDb::DwgVersion ver,
    OdDbObjectId& replaceId,
    bool& exchangeXData);
 
  void subSetDatabaseDefaults(
    OdDbDatabase *pDb,
    bool doSubents);
 
  OdResult evaluateHatch(
    bool bUnderestimateNumLines = false) const;
 
  int numHatchLines() const;
  
  void getHatchLineDataAt(
    int lineIndex, 
    OdGePoint2d& startPoint, 
    OdGePoint2d& endPoint) const;
  
  void getHatchLinesData(
    OdGePoint2dArray& startPoints, 
    OdGePoint2dArray& endPoints) const;
  
  virtual OdResult subExplode(
    OdRxObjectPtrArray& entitySet) const ODRX_OVERRIDE;
 
  virtual void openedForModify(
    const OdDbObject* pObject);
 
  virtual void modifiedGraphics(
    const OdDbObject* pObject);
 
  /* virtual void subSwapIdWith(OdDbObjectId otherId, bool swapXdata = false, bool swapExtDict = false);
  virtual void swapReferences(const OdDbIdMapping& idMap);*/
 
 
  OdDbHatch::HatchObjectType hatchObjectType() const;
 
  void setHatchObjectType(
    OdDbHatch::HatchObjectType hatchObjectType);
  
  virtual bool isGradient() const;
 
  virtual bool isHatch() const;
  
  OdDbHatch::GradientPatternType gradientType() const;
  
  OdString gradientName() const;
  
  void setGradient(
    OdDbHatch::GradientPatternType gradientType, 
    const OdString& gradientName);
  
  double gradientAngle() const;
 
  void setGradientAngle(double angle);
  
  void getGradientColors(
    OdCmColorArray& colors, 
    OdGeDoubleArray& values) const;
  
  void setGradientColors(
    OdUInt32 count, 
    const OdCmColor* colors, 
    const double* values);
  
  bool getGradientOneColorMode() const;
 
  void setGradientOneColorMode(
    bool oneColorMode);
  
  double getShadeTintValue() const;
  
  void setShadeTintValue(
    double luminance);
  
  double gradientShift() const;
  
  void setGradientShift(double gradientShift);
  
  void evaluateGradientColorAt(
    double value, 
    OdCmColor& color) const;
 
  void appendToOwner(
    OdDbIdPair& idPair, 
    OdDbObject* pOwnerObject , 
    OdDbIdMapping& ownerIdMap);
 
  void subClose();
 
  void setRawPattern(
    OdDbHatch::HatchPatternType patType, 
    const OdString& patName,
    double angle, 
    double scale,
    const OdHatchPattern& pat);
 
 
  OdHatchPattern getPattern() const;
 
 
  OdHatchPattern getRawPattern() const;
 
  void setOriginPoint(const OdGePoint2d& pt);
 
  OdGePoint2d originPoint() const;
 
  virtual OdResult explodeGeometry(OdRxObjectPtrArray& entitySet) const;
 
  virtual OdResult getArea(double& area) const;
 
  virtual OdDbRegionPtr getRegionArea() const;
 
  static OdResult makeClosedLoop(EdgeArray& edgePtrs, const OdDbObjectIdArray& dbObjIds, const OdGeTol& gapTolerance, const bool& isEdgeArrayConsistent);
 
  OdResult markModifiedLoop(const OdUInt16 loopIndex);
 
  OdResult markModifiedLoop(const OdDbHandle entityHandle);
 
  OdResult unmarkModifiedLoop(const OdUInt16 loopIndex);
 
  OdResult unmarkModifiedLoop(const OdDbHandle entityHandle);
 
  void getMarkedModifiedLoops(OdUInt16Array& indicesMarkedLoops) const;
 
  void clearMarkModifiedLoops();
 
  OdResult updateMarkedLoops();
  OdResult setShadeTintValueAndColor2(double value);
 
  virtual OdResult subGetSubentPathsAtGsMarker(OdDb::SubentType type, OdGsMarker gsMark, 
    const OdGePoint3d& pickPoint,const OdGeMatrix3d& xfm, 
    OdDbFullSubentPathArray& subentPaths, 
    const OdDbObjectIdArray* pEntAndInsertStack = 0) const;
  virtual OdResult subGetGsMarkersAtSubentPath( const OdDbFullSubentPath& subPath, 
    OdGsMarkerArray& gsMarkers) const;
  virtual OdDbEntityPtr subSubentPtr(const OdDbFullSubentPath& path) const;
 
  OdCmColor backgroundColor() const;
 
  void setBackgroundColor(const OdCmColor& color);
 
  OdGeMatrix3d getEcs( ) const;
};
typedef OdSmartPtr<OdDbHatch> OdDbHatchPtr;
 
DBENT_EXPORT EdgeArray oddbCreateEdgesFromEntity(const OdDbEntity* pEnt, const OdGePlane& hatchPlane, const bool bLeadToXAxis = false);
 
#include "TD_PackPop.h"
 
#endif /* OD_DBHATCH_H */