GsDefs.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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-2024 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 __GSDEFS_H_INCLUDED_
#define __GSDEFS_H_INCLUDED_
 
#include "TD_PackPush.h"
#include "OdRound.h"
#include "Ge/GePoint2d.h"
 
//****************************************************************************
// Helper classes
//****************************************************************************
 
// copied(with modification) from limits.h to avoid extra #includes
 
#define SCALAR_MIN    (-2147483647 - 1)  // minimum(signed) int32 value
#define SCALAR_MAX       2147483647      // maximum(signed) int32 value

class OdGsDCPoint
{
public:
  enum MaxFlag { Maximum };
  enum MinFlag { Minimum };
  
  OdGsDCPoint() : x(0), y(0) { }
    
  //FELIX_CHANGE_BEGIN
  /*
  OdGsDCPoint(long xx, long yy) : x(xx), y(yy) { }
  */
  OdGsDCPoint(OdInt32 xx, OdInt32 yy) : x(xx), y(yy) { }
  //FELIX_CHANGE_END
  
  OdGsDCPoint(MaxFlag) { x = SCALAR_MAX; y = SCALAR_MAX; }
  
  OdGsDCPoint(MinFlag) { x = SCALAR_MIN; y = SCALAR_MIN; }
  
  void operator=(MaxFlag) { x = SCALAR_MAX; y = SCALAR_MAX; }
    
  void operator=(MinFlag) { x = SCALAR_MIN; y = SCALAR_MIN; }
  
  OdGsDCPoint& operator=(const OdGsDCPoint& dcPoint) = default;
  
  bool operator==(const OdGsDCPoint& dcPoint) const { return x == dcPoint.x && y == dcPoint.y; }
  
  bool operator!=(const OdGsDCPoint& dcPoint) const { return x != dcPoint.x || y != dcPoint.y; }
  
  inline long operator[](unsigned int i) const { return *(&x + i); }
 
  //FELIX_CHANGE_BEGIN
  OdInt32 x;  // X-coordinate.
  OdInt32 y;  // Y-coordinate.
  //FELIX_CHANGE_END
};

class OdGsDCRect
{
public:
  enum NullFlag { Null };
  OdGsDCRect() { }
  
  OdGsDCRect(const OdGsDCPoint& minPoint, const OdGsDCPoint& maxPoint) : m_min(minPoint), m_max(maxPoint) { }
  
  OdGsDCRect(long xMin, long xMax, long yMin, long yMax) : m_min(xMin,yMin), m_max(xMax,yMax) { }
  
  OdGsDCRect(NullFlag) { set_null(); }
  
  OdGsDCRect& operator=(const OdGsDCRect& dcRect) = default; 
  
  void operator|=(const OdGsDCRect& dcRect)
  {
    if(m_min.x > dcRect.m_min.x) 
      m_min.x = dcRect.m_min.x; 
    if(m_max.x < dcRect.m_max.x) 
      m_max.x = dcRect.m_max.x;
    
    if(m_min.y > dcRect.m_min.y)
      m_min.y = dcRect.m_min.y;
    if(m_max.y < dcRect.m_max.y)
      m_max.y = dcRect.m_max.y;
  }
  
  void operator&=(const OdGsDCRect& dcRect)
  {
    intersectWith(dcRect);
  }
  
  bool operator==(const OdGsDCRect& dcRect) const
  {
    return m_min == dcRect.m_min && m_max == dcRect.m_max; 
  }
  
  bool operator!=(const OdGsDCRect& dcRect) const
  {
    return !(*this == dcRect);
  }

  void set_null()
  { 
    m_min = OdGsDCPoint::Maximum; 
    m_max = OdGsDCPoint::Minimum; 
  } 
  
  bool is_null() const
  {
    ODA_ASSERT((m_min.x <= m_max.x && m_min.y <= m_max.y) ||
     (m_min == OdGsDCPoint::Maximum && m_max == OdGsDCPoint::Minimum));
    return m_min.x > m_max.x;
  }
  
  bool within(const OdGsDCRect& dcRect) const
  {
    ODA_ASSERT(!is_null()); 
    return m_min.x >= dcRect.m_min.x && 
      m_min.y >= dcRect.m_min.y && 
      m_max.x <= dcRect.m_max.x &&
      m_max.y <= dcRect.m_max.y;
  }

  void offset(long x, long y)
  {
    m_min.x += x;
    m_max.x += x;
    m_min.y += y;
    m_max.y += y;
  }

  void intersectWith(const OdGsDCRect& dcRect, bool bValidate = true)
  {
    if(m_min.x < dcRect.m_min.x)
      m_min.x = dcRect.m_min.x; 
    if(m_max.x > dcRect.m_max.x) 
      m_max.x = dcRect.m_max.x;
 
    if(m_min.y < dcRect.m_min.y)
      m_min.y = dcRect.m_min.y;
    if(m_max.y > dcRect.m_max.y)
      m_max.y = dcRect.m_max.y;
 
    if(bValidate && (m_min.x > m_max.x || m_min.y > m_max.y))
      *this = Null;
  }

  void normalize()
  {
    long tmp;
    if (m_max.x < m_min.x)
      tmp = m_max.x, m_max.x = m_min.x, m_min.x = tmp;
    if (m_max.y < m_min.y)
      tmp = m_max.y, m_max.y = m_min.y, m_min.y = tmp;
  }

  bool isDisjoint(const OdGsDCRect& r) const
  {
    return (r.m_min.x > m_max.x || r.m_min.y > m_max.y ||
            m_min.x > r.m_max.x || m_min.y > r.m_max.y);
  }

  OdGsDCPoint m_min;
  OdGsDCPoint m_max;
};

class OdGsDCRectDouble
{
public:
  OdGsDCRectDouble() { }

  OdGsDCRectDouble(const OdGePoint2d& minPoint, const OdGePoint2d& maxPoint)
    : m_min(minPoint), m_max(maxPoint) { }

  OdGsDCRectDouble(double xMin, double xMax, double yMin, double yMax)
    : m_min(xMin,yMin), m_max(xMax,yMax) { }

  explicit OdGsDCRectDouble(const OdGsDCRect& rc)
    : m_min(rc.m_min.x, rc.m_min.y), m_max(rc.m_max.x,rc.m_max.y) { }

  OdGsDCRectDouble& operator=(const OdGsDCRect& dcRect)
  {
    m_min.x = dcRect.m_min.x;
    m_min.y = dcRect.m_min.y;
    m_max.x = dcRect.m_max.x;
    m_max.y = dcRect.m_max.y;
    return *this;
  }

  bool operator==(const OdGsDCRectDouble& dcRect) const
  {
    return m_min == dcRect.m_min && m_max == dcRect.m_max; 
  }
  
  bool operator!=(const OdGsDCRectDouble& dcRect) const
  {
    return !(*this == dcRect);
  }

  OdGsDCRect round() const
  {
    return OdGsDCRect(OdGsDCRect(
        OdTruncateToLong(m_min.x),
        OdTruncateToLong(m_max.x),
        OdTruncateToLong(m_min.y),
        OdTruncateToLong(m_max.y)));
  }

  OdGePoint2d m_min;
  OdGePoint2d m_max;
};
 
//FELIX_CHANGE_BEGIN
template <class TRect>
void intersectWith(TRect& dcRectThis, const TRect& dcRect, bool bValidate = true)
{
    if(dcRectThis.m_min.x < dcRect.m_min.x)
        dcRectThis.m_min.x = dcRect.m_min.x; 
    if(dcRectThis.m_max.x > dcRect.m_max.x) 
        dcRectThis.m_max.x = dcRect.m_max.x;
 
    if(dcRectThis.m_min.y < dcRect.m_min.y)
        dcRectThis.m_min.y = dcRect.m_min.y;
    if(dcRectThis.m_max.y > dcRect.m_max.y)
        dcRectThis.m_max.y = dcRect.m_max.y;
 
    if(bValidate && (dcRectThis.m_min.x > dcRectThis.m_max.x || dcRectThis.m_min.y > dcRectThis.m_max.y))
    {
        dcRectThis.m_min.x = SCALAR_MAX;
        dcRectThis.m_min.y = SCALAR_MAX;
        dcRectThis.m_max.x = SCALAR_MIN;
        dcRectThis.m_max.y = SCALAR_MIN;
    }
};
 
template <class TRect, class T>
void offset(TRect& dcRectThis, T x, T y)
{
    dcRectThis.m_min.x += x;
    dcRectThis.m_max.x += x;
    dcRectThis.m_min.y += y;
    dcRectThis.m_max.y += y;
};
//FELIX_CHANGE_END

typedef void* OdGsWindowingSystemID; 

enum EMetafilePlayMode
{
  kMfUndefined,
  kMfDisplay,
  kMfSelect,
  kMfNested,
  kMfExtents
};
 
// Negative GETBIT
#ifndef GETBITNEG
#define GETBITNEG(flags, bit) (((flags) & (bit)) != (bit))
#endif
 
#include "TD_PackPop.h"
 
#endif // __GSDEFS_H_INCLUDED_