DbLSSymbolReference.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 ODDGNLS_DBLSSYMBOLREFERENCE_H
#define ODDGNLS_DBLSSYMBOLREFERENCE_H
 
#include "OdaCommon.h"
#include "DbFiler.h"
 
#include "TD_PackPush.h"
 
struct OdDbLSSymbolReference
{
  enum VertexMask
  {
    kLSAtStroke    = 0,  // No vertex mask.
    kLSAtOrigin    = 4,  // Symbol at element origin.
    kLSAtEnd       = 8,  // Symbol at element end.
    kLSAtVertex    = 16  // Symbol on each element vertex.
  };
  enum Justify
  {
    kLSNoJustify     = 0, // No symbol justification (symbol on stroke)
    kLSJustifyLeft   = 1, // Symbol at left stroke side.
    kLSJustifyRight  = 2, // Symbol at right stroke side.
    kLSJustifyCenter = 3  // Symbol at center of stroke.
  };
  enum RotationType
  {
    kLSRelative    = 0, // Rotation relative to curve direction.
    kLSAbsolute    = 1, // Rotation in absolute coordinates of drawing.
    kLSAdjusted    = 2  // Rotation is adjusted left to right; mirror symbols if line is reversed.
  };
 
protected:
  bool m_bPartialStrokes; // Partial: Origin: true (projected: false), Projected: true (projected: true), None: false (projected: false)
  bool m_bClipPartial;
  bool m_bAllowStretch;
  bool m_bPartialProjected; // Look for m_bPartialStrokes
  bool m_bSymbolColor; // false - use line color, true - use element color
  bool m_bSymbolWeight; // false - use line lineweight, true - use element lineweight
  Justify m_Justify; // 0 for vertex symbols
  RotationType m_RotationType;
  OdInt16 m_nVertexMask; // 0 for stroke symbols
  double m_fXOffset;
  double m_fYOffset;
  double m_fAngle; // in radians
  OdInt32 m_nStroke; // -1 for vertex symbols
  OdDbHardPointerId m_SymbolComponent;
 
public:
  OdDbLSSymbolReference()
    : m_bPartialStrokes(true)
    , m_bClipPartial(false)
    , m_bAllowStretch(false)
    , m_bPartialProjected(false)
    , m_bSymbolColor(false)
    , m_bSymbolWeight(false)
    , m_Justify(kLSNoJustify)
    , m_RotationType(kLSRelative)
    , m_nVertexMask((OdInt16)kLSAtStroke)
    , m_fXOffset(0.0)
    , m_fYOffset(0.0)
    , m_fAngle(0.0)
    , m_nStroke(-1)
  {
  }
  
  bool partialStrokes() const { return m_bPartialStrokes; }
  void setPartialStrokes(bool bSet) { m_bPartialStrokes = bSet; }
 
  bool clipPartial() const { return m_bClipPartial; }
  void setClipPartial(bool bSet) { m_bClipPartial = bSet; }
 
  bool allowStretch() const { return m_bAllowStretch; }
  void setAllowStretch(bool bSet) { m_bAllowStretch = bSet; }
 
  bool partialProjected() const { return m_bPartialProjected; }
  void setPartialProjected(bool bSet) { m_bPartialProjected = bSet; }
 
  bool useSymbolColor() const { return m_bSymbolColor; }
  void setUseSymbolColor(bool bSet) { m_bSymbolColor = bSet; }
 
  bool useSymbolLineweight() const { return m_bSymbolWeight; }
  void setUseSymbolLineweight(bool bSet) { m_bSymbolWeight = bSet; }
 
  Justify justify() const { return m_Justify; }
  void setJustify(Justify nSet) { m_Justify = nSet; }
 
  RotationType rotationType() const { return m_RotationType; }
  void setRotationType(RotationType nSet) { m_RotationType = nSet; }
 
  OdUInt32 vertexMask() const { return (OdUInt32)m_nVertexMask; }
  void setVertexMask(OdUInt32 nVertexMask) { m_nVertexMask = (OdInt16)nVertexMask; }
 
  double xOffset() const { return m_fXOffset; }
  void setXOffset(double fOffset) { m_fXOffset = fOffset; }
 
  double yOffset() const { return m_fYOffset; }
  void setYOffset(double fOffset) { m_fYOffset = fOffset; }
 
  double angle() const { return m_fAngle; }
  void setAngle(double fAngle) { m_fAngle = fAngle; }
 
  OdInt32 strokeNumber() const { return m_nStroke; }
  void setStrokeNumber(OdInt32 nStroke) { m_nStroke = nStroke; }
 
  OdDbObjectId symbolComponent() const { return m_SymbolComponent; }
  void setSymbolComponent(const OdDbObjectId &id) { m_SymbolComponent = id; }
 
private:
  friend class OdDbLSPointComponentImpl;
 
  OdResult dwgInFields(OdDbDwgFiler *pFiler);
  void dwgOutFields(OdDbDwgFiler *pFiler) const;
  OdResult dxfInFields(OdDbDxfFiler *pFiler);
  void dxfOutFields(OdDbDxfFiler *pFiler) const;
 
#ifdef ODA_DIAGNOSTICS
  void trace(OdUInt32 nSymbol) const;
#endif
};
 
#include "TD_PackPop.h"
 
#endif // ODDGNLS_DBLSSYMBOLREFERENCE_H