src/TPrsStd/TPrsStd_ConstraintDriver.cxx

   1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   2 //
   3 // This file is part of Open CASCADE Technology software library.
   4 //
   5 // This library is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU Lesser General Public License version 2.1 as published
   7 // by the Free Software Foundation, with special exception defined in the file
   8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
   9 // distribution for complete text of the license and disclaimer of any warranty.
  10 //
  11 // Alternatively, this file may be used under the terms of Open CASCADE
  12 // commercial license or contractual agreement.
  13
  14
  15 #include <AIS_InteractiveContext.hxx>
  16 #include <AIS_InteractiveObject.hxx>
  17 #include <PrsDim_Relation.hxx>
  18 #include <Standard_Type.hxx>
  19 #include <TDataStd_Real.hxx>
  20 #include <TDataXtd_Constraint.hxx>
  21 #include <TDataXtd_Position.hxx>
  22 #include <TDF_Label.hxx>
  23 #include <TPrsStd_ConstraintDriver.hxx>
  24 #include <TPrsStd_ConstraintTools.hxx>
  25
  26 IMPLEMENT_STANDARD_RTTIEXT(TPrsStd_ConstraintDriver,TPrsStd_Driver)
  27
  28 //=======================================================================
  29 //function :
  30 //purpose  :
  31 //=======================================================================
  32 TPrsStd_ConstraintDriver::TPrsStd_ConstraintDriver()
  33 {
  34 }
  35
  36 //=======================================================================
  37 //function :
  38 //purpose  :
  39 //=======================================================================
  40 Standard_Boolean TPrsStd_ConstraintDriver::Update (const TDF_Label& aLabel,
  41                                                   Handle(AIS_InteractiveObject)& anAISObject)
  42 {
  43   Handle(TDataXtd_Constraint) apConstraint;
  44   if( !aLabel.FindAttribute(TDataXtd_Constraint::GetID(), apConstraint) ) {
  45    return Standard_False;
  46   }
  47
  48   if (!anAISObject.IsNull() && anAISObject->HasInteractiveContext()) {
  49     if (!apConstraint->Verified()) {
  50       TPrsStd_ConstraintTools::UpdateOnlyValue(apConstraint,anAISObject);
  51       Quantity_Color aColor;
  52       anAISObject->Color (aColor);
  53       if (aColor.Name() != Quantity_NOC_RED)
  54       {
  55         anAISObject->SetColor(Quantity_NOC_RED);
  56       }
  57       return Standard_True;
  58     }
  59   }
  60
  61   Handle(AIS_InteractiveObject) anAIS = anAISObject;
  62
  63   // recuperation
  64   TDataXtd_ConstraintEnum thetype = apConstraint->GetType();
  65
  66   switch (thetype)  {
  67   case TDataXtd_DISTANCE:
  68     {
  69       TPrsStd_ConstraintTools::ComputeDistance(apConstraint,anAIS);
  70       break;
  71     }
  72   case TDataXtd_PARALLEL:
  73     {
  74       TPrsStd_ConstraintTools::ComputeParallel(apConstraint,anAIS);
  75       break;
  76     }
  77   case TDataXtd_PERPENDICULAR:
  78     {
  79       TPrsStd_ConstraintTools::ComputePerpendicular(apConstraint,anAIS);
  80       break;
  81     }
  82   case TDataXtd_CONCENTRIC:
  83     {
  84       TPrsStd_ConstraintTools::ComputeConcentric(apConstraint,anAIS);
  85       break;
  86     }
  87   case TDataXtd_SYMMETRY:
  88     {
  89       TPrsStd_ConstraintTools::ComputeSymmetry(apConstraint,anAIS);
  90       break;
  91     }
  92   case TDataXtd_MIDPOINT:
  93     {
  94       TPrsStd_ConstraintTools::ComputeMidPoint(apConstraint,anAIS);
  95       break;
  96     }
  97   case TDataXtd_TANGENT:
  98     {
  99       TPrsStd_ConstraintTools::ComputeTangent(apConstraint,anAIS);
 100       break;
 101     }
 102   case TDataXtd_ANGLE:
 103     {
 104       TPrsStd_ConstraintTools::ComputeAngle(apConstraint,anAIS);
 105       break;
 106     }
 107   case TDataXtd_RADIUS:
 108     {
 109       TPrsStd_ConstraintTools::ComputeRadius(apConstraint,anAIS);
 110       break;
 111     }
 112   case TDataXtd_MINOR_RADIUS:
 113     {
 114       TPrsStd_ConstraintTools::ComputeMinRadius(apConstraint,anAIS);
 115       break;
 116     }
 117   case TDataXtd_MAJOR_RADIUS:
 118     {
 119       TPrsStd_ConstraintTools::ComputeMaxRadius(apConstraint,anAIS);
 120       break;
 121     }
 122   case TDataXtd_DIAMETER:
 123     {
 124       TPrsStd_ConstraintTools::ComputeDiameter(apConstraint,anAIS);
 125       break;
 126     }
 127   case TDataXtd_FIX:
 128     {
 129       TPrsStd_ConstraintTools::ComputeFix(apConstraint,anAIS);
 130       break;
 131     }
 132   case TDataXtd_OFFSET:
 133     {
 134       TPrsStd_ConstraintTools::ComputeOffset(apConstraint,anAIS);
 135       break;
 136     }
 137   case TDataXtd_COINCIDENT:
 138     {
 139       TPrsStd_ConstraintTools::ComputeCoincident(apConstraint,anAIS);
 140       break;
 141     }
 142   case TDataXtd_ROUND:
 143     {
 144       TPrsStd_ConstraintTools::ComputeRound(apConstraint,anAIS);
 145       break;
 146     }
 147
 148   case TDataXtd_MATE:
 149   case TDataXtd_ALIGN_FACES:
 150   case TDataXtd_ALIGN_AXES:
 151   case TDataXtd_AXES_ANGLE:
 152     {
 153       TPrsStd_ConstraintTools::ComputePlacement(apConstraint,anAIS);
 154       break;
 155     }
 156   case TDataXtd_EQUAL_DISTANCE :
 157     {
 158       TPrsStd_ConstraintTools::ComputeEqualDistance(apConstraint,anAIS);
 159       break;
 160     }
 161   case  TDataXtd_EQUAL_RADIUS:
 162     {
 163       TPrsStd_ConstraintTools::ComputeEqualRadius(apConstraint,anAIS);
 164       break;
 165     }
 166   default:
 167     {
 168       TPrsStd_ConstraintTools::ComputeOthers(apConstraint,anAIS);
 169       break;
 170     }
 171   }
 172   if (anAIS.IsNull()) return Standard_False;
 173
 174   anAIS->ResetTransformation();
 175   anAIS->SetToUpdate();
 176   anAIS->UpdateSelection();
 177
 178   anAISObject = anAIS;
 179
 180   Handle(TDataXtd_Position) Position;
 181   if (aLabel.FindAttribute(TDataXtd_Position::GetID(),Position)) {
 182     Handle(PrsDim_Relation)::DownCast(anAISObject)->SetPosition(Position->GetPosition());
 183   }
 184
 185   if (anAISObject->HasInteractiveContext()) {
 186     Quantity_Color originColor;
 187     anAISObject->Color (originColor);
 188     if (!apConstraint->Verified()) {
 189       if (originColor.Name() != Quantity_NOC_RED)
 190         anAISObject->SetColor(Quantity_NOC_RED);
 191     }
 192     else if (apConstraint->IsDimension() && apConstraint->GetValue()->IsCaptured()) {
 193       if (originColor.Name() != Quantity_NOC_PURPLE)
 194         anAISObject->SetColor(Quantity_NOC_PURPLE);
 195     }
 196     else if (!apConstraint->IsPlanar() && (originColor.Name() != Quantity_NOC_YELLOW))
 197       anAISObject->SetColor(Quantity_NOC_YELLOW);
 198   }
 199   else {
 200     if (!apConstraint->Verified()) {
 201       anAISObject->SetColor(Quantity_NOC_RED);
 202     }
 203     else if (apConstraint->IsDimension() && apConstraint->GetValue()->IsCaptured()) {
 204       anAISObject->SetColor(Quantity_NOC_PURPLE);
 205     }
 206     else if (!apConstraint->IsPlanar()) anAISObject->SetColor(Quantity_NOC_YELLOW);
 207   }
 208   return Standard_True;
 209 }
 210