OCCT

// Created on: 1998-09-07
// Created by: Denis PASCAL
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <BRep_Builder.hxx>
#include <DBRep_DrawableShape.hxx>
#include <DDataStd_DrawDriver.hxx>
#include <Draw_Appli.hxx>
#include <Draw_Axis3D.hxx>
#include <Draw_Drawable3D.hxx>
#include <DrawDim_Angle.hxx>
#include <DrawDim_Distance.hxx>
#include <DrawDim_PlanarAngle.hxx>
#include <DrawDim_PlanarDiameter.hxx>
#include <DrawDim_PlanarDistance.hxx>
#include <DrawDim_PlanarRadius.hxx>
#include <DrawDim_Radius.hxx>
#include <Standard_Type.hxx>
#include <TDataStd_Real.hxx>
#include <TDataXtd_Axis.hxx>
#include <TDataXtd_Constraint.hxx>
#include <TDataXtd_Geometry.hxx>
#include <TDataXtd_GeometryEnum.hxx>
#include <TDataXtd_Plane.hxx>
#include <TDataXtd_Point.hxx>
#include <TDF_Label.hxx>
#include <TDF_Tool.hxx>
#include <TNaming_Tool.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>

IMPLEMENT_STANDARD_RTTIEXT(DDataStd_DrawDriver, Standard_Transient)

// attribut affichable
// drawable object
static int    DISCRET = 100;
static int    NBISOS  = 10;
static double THESIZE = 1000.;

static occ::handle<DDataStd_DrawDriver> DrawDriver;

occ::handle<DDataStd_DrawDriver> DDataStd_DrawDriver::Get()
{
  return DrawDriver;
}

void DDataStd_DrawDriver::Set(const occ::handle<DDataStd_DrawDriver>& DD)
{
  DrawDriver = DD;
}

//=================================================================================================

DDataStd_DrawDriver::DDataStd_DrawDriver() = default;

//=================================================================================================

static TopoDS_Shape Geometry(const occ::handle<TDataXtd_Constraint>& A,
                             const int                               i,
                             TopAbs_ShapeEnum                        T)
{
  TopoDS_Shape S = TNaming_Tool::GetShape(A->GetGeometry(i));
  if (!S.IsNull())
  {
    if (T != TopAbs_SHAPE && T != S.ShapeType())
    {
      S.Nullify();
    }
  }
  return S;
}

//=================================================================================================

occ::handle<Draw_Drawable3D> DDataStd_DrawDriver::Drawable(const TDF_Label& L) const
{
  // CONSTRAINT

  occ::handle<TDataXtd_Constraint> CTR;
  if (L.FindAttribute(TDataXtd_Constraint::GetID(), CTR))
  {
    return DrawableConstraint(CTR);
  }

  // OBJECT

  TopoDS_Shape s;

  // occ::handle<TDataStd_Object> OBJ;
  // if (L.FindAttribute(TDataStd_Object::GetID(),OBJ)) {
  //   return DrawableShape (L,Draw_vert);
  // }

  // DATUM

  occ::handle<TDataXtd_Point> POINT;
  if (L.FindAttribute(TDataXtd_Point::GetID(), POINT))
  {
    return DrawableShape(L, Draw_magenta, false);
  }

  occ::handle<TDataXtd_Axis> AXIS;
  if (L.FindAttribute(TDataXtd_Axis::GetID(), AXIS))
  {
    return DrawableShape(L, Draw_magenta, false);
  }

  occ::handle<TDataXtd_Plane> PLANE;
  if (L.FindAttribute(TDataXtd_Plane::GetID(), PLANE))
  {
    return DrawableShape(L, Draw_magenta, false);
  }

  // Standard GEOMETRY

  occ::handle<TDataXtd_Geometry> STD_GEOM;
  if (L.FindAttribute(TDataXtd_Geometry::GetID(), STD_GEOM))
  {
    switch (STD_GEOM->GetType())
    {
      case TDataXtd_POINT: {
        return DrawableShape(L, Draw_jaune, false);
      }
      case TDataXtd_LINE:
      case TDataXtd_CIRCLE:
      case TDataXtd_ELLIPSE:
      case TDataXtd_SPLINE: {
        return DrawableShape(L, Draw_cyan, false);
      }
      case TDataXtd_ANY_GEOM: {
        break;
      }
      default: {
        break;
      }
    }
  }

  // PURE SHAPE

  occ::handle<TNaming_NamedShape> NS;
  if (L.FindAttribute(TNaming_NamedShape::GetID(), NS))
  {
    return DrawableShape(NS->Label(), Draw_jaune);
  }

  occ::handle<Draw_Drawable3D> D3D;
  return D3D;
}

//=================================================================================================

occ::handle<Draw_Drawable3D> DDataStd_DrawDriver::DrawableConstraint(
  const occ::handle<TDataXtd_Constraint>& A) const
{
  occ::handle<DrawDim_Dimension> D;

  switch (A->GetType())
  {

    case TDataXtd_RADIUS: {
      if (A->IsPlanar())
      {
        D = new DrawDim_PlanarRadius(TNaming_Tool::GetShape(A->GetGeometry(1)));
      }
      else
      {
        TopoDS_Shape aLocalShape = Geometry(A, 1, TopAbs_FACE);
        TopoDS_Face  F1          = TopoDS::Face(aLocalShape);
        // TopoDS_Face F1 = TopoDS::Face(Geometry(A,1,TopAbs_FACE));
        if (!F1.IsNull())
        {
          D = new DrawDim_Radius(F1);
        }
      }
    }
    break;

    case TDataXtd_DIAMETER:
      if (A->IsPlanar())
      {
        D = new DrawDim_PlanarDiameter(TNaming_Tool::GetShape(A->GetGeometry(1)));
      }
      break;

    case TDataXtd_MINOR_RADIUS:
      break;

    case TDataXtd_MAJOR_RADIUS:
      break;

    case TDataXtd_TANGENT:
      break;

    case TDataXtd_PARALLEL:
      break;

    case TDataXtd_PERPENDICULAR:
      break;

    case TDataXtd_CONCENTRIC:
      break;

    case TDataXtd_COINCIDENT:
      break;

    case TDataXtd_DISTANCE: {
      if (A->IsPlanar())
      {
        D = new DrawDim_PlanarDistance(TNaming_Tool::GetShape(A->GetGeometry(1)),
                                       TNaming_Tool::GetShape(A->GetGeometry(2)));
      }
      break;
    }
    case TDataXtd_ANGLE: {
      if (A->IsPlanar())
      {
        occ::handle<DrawDim_PlanarAngle> DAng =
          new DrawDim_PlanarAngle(TNaming_Tool::GetShape(A->GetGeometry(1)),
                                  TNaming_Tool::GetShape(A->GetGeometry(2)));
        DAng->Sector(A->Reversed(), A->Inverted());
        TopoDS_Shape aLocalShape = TNaming_Tool::GetShape(A->GetPlane());
        DAng->SetPlane(TopoDS::Face(aLocalShape));
        //	DAng->SetPlane(TopoDS::Face(TNaming_Tool::GetShape(A->GetPlane())));
        D = DAng;
      }
      else
      {
        TopoDS_Shape aLocalShape = Geometry(A, 1, TopAbs_FACE);
        TopoDS_Face  F1          = TopoDS::Face(aLocalShape);
        aLocalShape              = Geometry(A, 2, TopAbs_FACE);
        TopoDS_Face F2           = TopoDS::Face(aLocalShape);
        //	TopoDS_Face F1 = TopoDS::Face(Geometry(A,1,TopAbs_FACE));
        //	TopoDS_Face F2 = TopoDS::Face(Geometry(A,2,TopAbs_FACE));
        if (!F1.IsNull() && !F2.IsNull())
        {
          D = new DrawDim_Angle(F1, F2);
        }
      }
    }
    break;

    case TDataXtd_EQUAL_RADIUS: {
    }

    break;

    case TDataXtd_SYMMETRY:
      break;

    case TDataXtd_MIDPOINT:
      break;

    case TDataXtd_EQUAL_DISTANCE:
      break;

    case TDataXtd_FIX:
      break;

    case TDataXtd_RIGID:
      break;

    case TDataXtd_FROM:
      break;

    case TDataXtd_AXIS:
      break;

    case TDataXtd_MATE: {
      TopoDS_Shape aLocalShape = Geometry(A, 1, TopAbs_FACE);
      TopoDS_Face  F1          = TopoDS::Face(aLocalShape);
      aLocalShape              = Geometry(A, 2, TopAbs_FACE);
      TopoDS_Face F2           = TopoDS::Face(aLocalShape);
      //      TopoDS_Face F1 = TopoDS::Face(Geometry(A,1,TopAbs_FACE));
      //      TopoDS_Face F2 = TopoDS::Face(Geometry(A,2,TopAbs_FACE));
      if (!F1.IsNull() && !F2.IsNull())
      {
        D = new DrawDim_Distance(F1, F2);
      }
    }
    break;

    case TDataXtd_ALIGN_FACES: {
      TopoDS_Shape aLocalShape = Geometry(A, 1, TopAbs_FACE);
      TopoDS_Face  F1          = TopoDS::Face(aLocalShape);
      aLocalShape              = Geometry(A, 2, TopAbs_FACE);
      TopoDS_Face F2           = TopoDS::Face(aLocalShape);
      //      TopoDS_Face F1 = TopoDS::Face(Geometry(A,1,TopAbs_FACE));
      //      TopoDS_Face F2 = TopoDS::Face(Geometry(A,2,TopAbs_FACE));
      if (!F1.IsNull() && !F2.IsNull())
      {
        D = new DrawDim_Distance(F1, F2);
      }
    }
    break;

    case TDataXtd_ALIGN_AXES:
      break;

    case TDataXtd_AXES_ANGLE:
      break;

    case TDataXtd_FACES_ANGLE:
      break;

    case TDataXtd_ROUND:
      break;

    case TDataXtd_OFFSET:
      break;
  }

  if (!D.IsNull())
  {
    if (!A->GetValue().IsNull())
    {
      double val = A->GetValue()->Get();
      Standard_DISABLE_DEPRECATION_WARNINGS if (A->GetValue()->GetDimension() == TDataStd_ANGULAR)
      {
        val = (180. * val) / M_PI;
      }
      Standard_ENABLE_DEPRECATION_WARNINGS D->SetValue(val);
    }
    // unverified constraints are red (default is white)
    if (!A->Verified())
    {
      D->TextColor(Draw_rouge);
    }
  }
  return D;
}

//=================================================================================================

occ::handle<Draw_Drawable3D> DDataStd_DrawDriver::DrawableShape(const TDF_Label&     L,
                                                                const Draw_ColorKind color,
                                                                const bool           current) const
{
  occ::handle<Draw_Drawable3D>    DS;
  occ::handle<TNaming_NamedShape> NS;
  if (L.FindAttribute(TNaming_NamedShape::GetID(), NS))
  {
    TopoDS_Shape S;
    if (current)
    {
      S = TNaming_Tool::CurrentShape(NS);
    }
    else
    {
      S = TNaming_Tool::GetShape(NS);
    }
    DS = DrawableShape(S, color);
  }
  return DS;
}

//=================================================================================================

occ::handle<Draw_Drawable3D> DDataStd_DrawDriver::DrawableShape(const TopoDS_Shape&  s,
                                                                const Draw_ColorKind color)
{
  occ::handle<DBRep_DrawableShape> DS;
  DS = new DBRep_DrawableShape(s, color, color, color, Draw_bleu, THESIZE, NBISOS, DISCRET);
  return DS;
}