Integration of OCCT 6.5.0 from SVN

src/RWStepVisual/RWStepVisual.cdl

@@ -0,0 +1,140 @@
+-- File:        StepVisual.cdl
+-- Created:     Mon Dec  4 12:02:22 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+package RWStepVisual 
+
+uses
+
+	StepData, Interface, TCollection, TColStd, StepVisual
+
+is
+
+
+--class ReadWriteModule;
+
+--class GeneralModule;
+
+-- Removed from Rev2 to Rev4 : class RWAnnotationCurveOccurrence;
+-- Removed from Rev2 to Rev4 : class RWAnnotationFillArea;
+-- Removed from Rev2 to Rev4 : class RWAnnotationFillAreaOccurrence;
+-- Removed from Rev2 to Rev4 : class RWAnnotationOccurrence;
+-- Removed from Rev2 to Rev4 : class RWAnnotationSubfigureOccurrence;
+-- Removed from Rev2 to Rev4 : class RWAnnotationSymbol;
+-- Removed from Rev2 to Rev4 : class RWAnnotationSymbolOccurrence;
+-- Removed from Rev2 to Rev4 : class RWAnnotationText;
+-- Removed from Rev2 to Rev4 : class RWAnnotationTextOccurrence;
+class RWAreaInSet;
+class RWBackgroundColour;
+class RWCameraImage;
+class RWCameraModel;
+class RWCameraModelD2;
+class RWCameraModelD3;
+class RWCameraUsage;
+class RWColour;
+class RWColourRgb;
+class RWColourSpecification;
+class RWContextDependentInvisibility;
+class RWContextDependentOverRidingStyledItem;
+-- Removed from CC1-Rev2 to CC1-Rev4, re-added CC2-Rev4 :
+class RWCompositeText;
+-- Removed from Rev2 to Rev4 : class RWCompositeTextWithAssociatedCurves;
+-- Removed from Rev2 to Rev4 : class RWCompositeTextWithBlankingBox;
+-- Removed from CC1-Rev2 to CC1-Rev4, re-added CC2-Rev4 :
+class RWCompositeTextWithExtent;
+
+class RWCurveStyle;
+class RWCurveStyleFont;
+class RWCurveStyleFontPattern;
+-- Removed from Rev2 to Rev4 : class RWDefinedSymbol;
+-- Removed from Rev2 to Rev4 : class RWDimensionCurve;
+-- Removed from Rev2 to Rev4 : class RWDimensionCurveTerminator;
+-- Removed from Rev2 to Rev4 : class RWDraughtingAnnotationOccurrence;
+-- Removed from Rev2 to Rev4 : class RWDraughtingCallout;
+class RWDraughtingModel; -- added for CAX-IF TR3
+class RWDraughtingPreDefinedColour;
+class RWDraughtingPreDefinedCurveFont;
+-- Removed from Rev2 to Rev4 : class RWDraughtingSubfigureRepresentation;
+-- Removed from Rev2 to Rev4 : class RWDraughtingSymbolRepresentation;
+-- Removed from Rev2 to Rev4 : class RWDraughtingTextLiteralWithDelineation;
+-- Removed from Rev2 to Rev4 : class RWDrawingDefinition;
+-- Removed from Rev2 to Rev4 : class RWDrawingRevision;
+--moved to RWStepBasic: class RWExternalSource;
+class RWExternallyDefinedCurveFont;
+-- Removed from Rev2 to Rev4 : class RWExternallyDefinedHatchStyle;
+--moved to RWStepBasic: class RWExternallyDefinedItem;
+-- Removed from Rev2 to Rev4 : class RWExternallyDefinedSymbol;
+-- Removed from Rev2 to Rev4 : class RWExternallyDefinedTextFont;
+-- Removed from Rev2 to Rev4 : class RWExternallyDefinedTileStyle;
+class RWFillAreaStyle;
+class RWFillAreaStyleColour;
+-- Removed from Rev2 to Rev4 : class RWFillAreaStyleHatching;
+-- Removed from Rev2 to Rev4 : class RWFillAreaStyleTileSymbolWithStyle;
+-- Removed from Rev2 to Rev4 : class RWFillAreaStyleTiles;
+class RWInvisibility;
+class RWMechanicalDesignGeometricPresentationArea;
+class RWMechanicalDesignGeometricPresentationRepresentation;
+-- Removed from Rev2 to Rev4 : class RWMechanicalDesignPresentationArea;
+class RWOverRidingStyledItem;
+class RWPlanarBox;
+class RWPlanarExtent;
+class RWPointStyle;
+class RWPreDefinedColour;
+class RWPreDefinedCurveFont;
+class RWPreDefinedItem;
+-- Removed from Rev2 to Rev4 : class RWPreDefinedSymbol;
+-- Removed from Rev2 to Rev4 : class RWPreDefinedTextFont;
+class RWPresentationArea;
+class RWPresentationLayerAssignment;
+class RWPresentationRepresentation;
+class RWPresentationSet;
+class RWPresentationSize;
+class RWPresentationStyleAssignment;
+class RWPresentationStyleByContext;
+class RWPresentationView;
+-- Removed from Rev2 to Rev4 : class RWProductDataRepresentationView;
+class RWStyledItem;
+class RWSurfaceSideStyle;
+class RWSurfaceStyleBoundary;
+class RWSurfaceStyleControlGrid;
+class RWSurfaceStyleFillArea;
+class RWSurfaceStyleParameterLine;
+class RWSurfaceStyleSegmentationCurve;
+class RWSurfaceStyleSilhouette;
+class RWSurfaceStyleUsage;
+-- Removed from Rev2 to Rev4 : class RWSymbolColour;
+-- Removed from Rev2 to Rev4 : class RWSymbolRepresentation;
+-- Removed from Rev2 to Rev4 : class RWSymbolRepresentationMap;
+-- Removed from Rev2 to Rev4 : class RWSymbolStyle;
+-- Removed from Rev2 to Rev4 : class RWSymbolTarget;
+class RWTemplate;
+class RWTemplateInstance;
+-- Removed from Rev2 to Rev4 : class RWTerminatorSymbol;
+-- Removed from CC1-Rev2 to CC1-Rev4, re-added CC2-Rev4 :
+class RWTextLiteral;
+-- Removed from Rev2 to Rev4 : class RWTextLiteralWithAssociatedCurves;
+-- Removed from Rev2 to Rev4 : class RWTextLiteralWithBlankingBox;
+-- Removed from Rev2 to Rev4 : class RWTextLiteralWithDelineation;
+-- Removed from Rev2 to Rev4 : class RWTextLiteralWithExtent;
+-- Removed from CC1-Rev2 to CC1-Rev4, re-added CC2-Rev4 :
+class RWTextStyle;
+class RWTextStyleForDefinedFont;
+class RWTextStyleWithBoxCharacteristics;
+-- Removed from Rev2 to Rev4 : class RWTextStyleWithMirror;
+class RWViewVolume;
+
+    -- Added from Rev2 to Rev4
+class RWPresentedItemRepresentation;
+class RWPresentationLayerUsage;
+
+
+	---Package Method ---
+
+--	Init;
+	---Purpose: enforced the initialisation of the  libraries
+
+end RWStepVisual;

src/RWStepVisual/RWStepVisual_RWAreaInSet.cdl

@@ -0,0 +1,30 @@
+-- File:        AreaInSet.cdl
+-- Created:     Mon Dec  4 12:02:23 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWAreaInSet from RWStepVisual
+
+	---Purpose : Read & Write Module for AreaInSet
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     AreaInSet from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWAreaInSet;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable AreaInSet from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : AreaInSet from StepVisual);
+
+	Share(me; ent : AreaInSet from StepVisual; iter : in out EntityIterator);
+
+end RWAreaInSet;

src/RWStepVisual/RWStepVisual_RWAreaInSet.cxx

@@ -0,0 +1,69 @@
+
+#include <RWStepVisual_RWAreaInSet.ixx>
+#include <StepVisual_PresentationArea.hxx>
+#include <StepVisual_PresentationSet.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_AreaInSet.hxx>
+
+
+RWStepVisual_RWAreaInSet::RWStepVisual_RWAreaInSet () {}
+
+void RWStepVisual_RWAreaInSet::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_AreaInSet)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"area_in_set")) return;
+
+	// --- own field : area ---
+
+	Handle(StepVisual_PresentationArea) aArea;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadEntity(num, 1,"area", ach, STANDARD_TYPE(StepVisual_PresentationArea), aArea);
+
+	// --- own field : inSet ---
+
+	Handle(StepVisual_PresentationSet) aInSet;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadEntity(num, 2,"in_set", ach, STANDARD_TYPE(StepVisual_PresentationSet), aInSet);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aArea, aInSet);
+}
+
+
+void RWStepVisual_RWAreaInSet::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_AreaInSet)& ent) const
+{
+
+	// --- own field : area ---
+
+	SW.Send(ent->Area());
+
+	// --- own field : inSet ---
+
+	SW.Send(ent->InSet());
+}
+
+
+void RWStepVisual_RWAreaInSet::Share(const Handle(StepVisual_AreaInSet)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->Area());
+
+
+	iter.GetOneItem(ent->InSet());
+}
+

src/RWStepVisual/RWStepVisual_RWBackgroundColour.cdl

@@ -0,0 +1,30 @@
+-- File:        BackgroundColour.cdl
+-- Created:     Mon Dec  4 12:02:23 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWBackgroundColour from RWStepVisual
+
+	---Purpose : Read & Write Module for BackgroundColour
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     BackgroundColour from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWBackgroundColour;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable BackgroundColour from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : BackgroundColour from StepVisual);
+
+	Share(me; ent : BackgroundColour from StepVisual; iter : in out EntityIterator);
+
+end RWBackgroundColour;

src/RWStepVisual/RWStepVisual_RWBackgroundColour.cxx

@@ -0,0 +1,55 @@
+
+#include <RWStepVisual_RWBackgroundColour.ixx>
+#include <StepVisual_AreaOrView.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_BackgroundColour.hxx>
+
+
+RWStepVisual_RWBackgroundColour::RWStepVisual_RWBackgroundColour () {}
+
+void RWStepVisual_RWBackgroundColour::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_BackgroundColour)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"background_colour")) return;
+
+	// --- own field : presentation ---
+
+	StepVisual_AreaOrView aPresentation;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadEntity(num,1,"presentation",ach,aPresentation);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aPresentation);
+}
+
+
+void RWStepVisual_RWBackgroundColour::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_BackgroundColour)& ent) const
+{
+
+	// --- own field : presentation ---
+
+	SW.Send(ent->Presentation().Value());
+}
+
+
+void RWStepVisual_RWBackgroundColour::Share(const Handle(StepVisual_BackgroundColour)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->Presentation().Value());
+}
+

src/RWStepVisual/RWStepVisual_RWCameraImage.cdl

@@ -0,0 +1,30 @@
+-- File:        CameraImage.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWCameraImage from RWStepVisual
+
+	---Purpose : Read & Write Module for CameraImage
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     CameraImage from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWCameraImage;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable CameraImage from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : CameraImage from StepVisual);
+
+	Share(me; ent : CameraImage from StepVisual; iter : in out EntityIterator);
+
+end RWCameraImage;

src/RWStepVisual/RWStepVisual_RWCameraImage.cxx

@@ -0,0 +1,79 @@
+
+#include <RWStepVisual_RWCameraImage.ixx>
+#include <StepRepr_RepresentationMap.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_CameraImage.hxx>
+
+
+RWStepVisual_RWCameraImage::RWStepVisual_RWCameraImage () {}
+
+void RWStepVisual_RWCameraImage::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_CameraImage)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"camera_image")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- inherited field : mappingSource ---
+
+	Handle(StepRepr_RepresentationMap) aMappingSource;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadEntity(num, 2,"mapping_source", ach, STANDARD_TYPE(StepRepr_RepresentationMap), aMappingSource);
+
+	// --- inherited field : mappingTarget ---
+
+	Handle(StepRepr_RepresentationItem) aMappingTarget;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadEntity(num, 3,"mapping_target", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aMappingTarget);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aMappingSource, aMappingTarget);
+}
+
+
+void RWStepVisual_RWCameraImage::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_CameraImage)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- inherited field mappingSource ---
+
+	SW.Send(ent->MappingSource());
+
+	// --- inherited field mappingTarget ---
+
+	SW.Send(ent->MappingTarget());
+}
+
+
+void RWStepVisual_RWCameraImage::Share(const Handle(StepVisual_CameraImage)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->MappingSource());
+
+
+	iter.GetOneItem(ent->MappingTarget());
+}
+

src/RWStepVisual/RWStepVisual_RWCameraModel.cdl

@@ -0,0 +1,27 @@
+-- File:        CameraModel.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWCameraModel from RWStepVisual
+
+	---Purpose : Read & Write Module for CameraModel
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     CameraModel from StepVisual
+
+is
+
+	Create returns RWCameraModel;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable CameraModel from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : CameraModel from StepVisual);
+
+end RWCameraModel;

src/RWStepVisual/RWStepVisual_RWCameraModel.cxx

@@ -0,0 +1,40 @@
+
+#include <RWStepVisual_RWCameraModel.ixx>
+
+
+RWStepVisual_RWCameraModel::RWStepVisual_RWCameraModel () {}
+
+void RWStepVisual_RWCameraModel::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_CameraModel)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"camera_model has not 1 parameter(s)")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName);
+}
+
+
+void RWStepVisual_RWCameraModel::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_CameraModel)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+}

src/RWStepVisual/RWStepVisual_RWCameraModelD2.cdl

@@ -0,0 +1,30 @@
+-- File:        CameraModelD2.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWCameraModelD2 from RWStepVisual
+
+	---Purpose : Read & Write Module for CameraModelD2
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     CameraModelD2 from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWCameraModelD2;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable CameraModelD2 from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : CameraModelD2 from StepVisual);
+
+	Share(me; ent : CameraModelD2 from StepVisual; iter : in out EntityIterator);
+
+end RWCameraModelD2;

src/RWStepVisual/RWStepVisual_RWCameraModelD2.cxx

@@ -0,0 +1,75 @@
+
+#include <RWStepVisual_RWCameraModelD2.ixx>
+#include <StepVisual_PlanarBox.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_CameraModelD2.hxx>
+
+
+RWStepVisual_RWCameraModelD2::RWStepVisual_RWCameraModelD2 () {}
+
+void RWStepVisual_RWCameraModelD2::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_CameraModelD2)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"camera_model_d2")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- own field : viewWindow ---
+
+	Handle(StepVisual_PlanarBox) aViewWindow;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadEntity(num, 2,"view_window", ach, STANDARD_TYPE(StepVisual_PlanarBox), aViewWindow);
+
+	// --- own field : viewWindowClipping ---
+
+	Standard_Boolean aViewWindowClipping;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadBoolean (num,3,"view_window_clipping",ach,aViewWindowClipping);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aViewWindow, aViewWindowClipping);
+}
+
+
+void RWStepVisual_RWCameraModelD2::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_CameraModelD2)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- own field : viewWindow ---
+
+	SW.Send(ent->ViewWindow());
+
+	// --- own field : viewWindowClipping ---
+
+	SW.SendBoolean(ent->ViewWindowClipping());
+}
+
+
+void RWStepVisual_RWCameraModelD2::Share(const Handle(StepVisual_CameraModelD2)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->ViewWindow());
+}
+

src/RWStepVisual/RWStepVisual_RWCameraModelD3.cdl

@@ -0,0 +1,30 @@
+-- File:        CameraModelD3.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWCameraModelD3 from RWStepVisual
+
+	---Purpose : Read & Write Module for CameraModelD3
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     CameraModelD3 from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWCameraModelD3;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable CameraModelD3 from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : CameraModelD3 from StepVisual);
+
+	Share(me; ent : CameraModelD3 from StepVisual; iter : in out EntityIterator);
+
+end RWCameraModelD3;

src/RWStepVisual/RWStepVisual_RWCameraModelD3.cxx

@@ -0,0 +1,79 @@
+
+#include <RWStepVisual_RWCameraModelD3.ixx>
+#include <StepGeom_Axis2Placement3d.hxx>
+#include <StepVisual_ViewVolume.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_CameraModelD3.hxx>
+
+
+RWStepVisual_RWCameraModelD3::RWStepVisual_RWCameraModelD3 () {}
+
+void RWStepVisual_RWCameraModelD3::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_CameraModelD3)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"camera_model_d3")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- own field : viewReferenceSystem ---
+
+	Handle(StepGeom_Axis2Placement3d) aViewReferenceSystem;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadEntity(num, 2,"view_reference_system", ach, STANDARD_TYPE(StepGeom_Axis2Placement3d), aViewReferenceSystem);
+
+	// --- own field : perspectiveOfVolume ---
+
+	Handle(StepVisual_ViewVolume) aPerspectiveOfVolume;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadEntity(num, 3,"perspective_of_volume", ach, STANDARD_TYPE(StepVisual_ViewVolume), aPerspectiveOfVolume);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aViewReferenceSystem, aPerspectiveOfVolume);
+}
+
+
+void RWStepVisual_RWCameraModelD3::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_CameraModelD3)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- own field : viewReferenceSystem ---
+
+	SW.Send(ent->ViewReferenceSystem());
+
+	// --- own field : perspectiveOfVolume ---
+
+	SW.Send(ent->PerspectiveOfVolume());
+}
+
+
+void RWStepVisual_RWCameraModelD3::Share(const Handle(StepVisual_CameraModelD3)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->ViewReferenceSystem());
+
+
+	iter.GetOneItem(ent->PerspectiveOfVolume());
+}
+

src/RWStepVisual/RWStepVisual_RWCameraUsage.cdl

@@ -0,0 +1,30 @@
+-- File:        CameraUsage.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWCameraUsage from RWStepVisual
+
+	---Purpose : Read & Write Module for CameraUsage
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     CameraUsage from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWCameraUsage;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable CameraUsage from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : CameraUsage from StepVisual);
+
+	Share(me; ent : CameraUsage from StepVisual; iter : in out EntityIterator);
+
+end RWCameraUsage;

src/RWStepVisual/RWStepVisual_RWCameraUsage.cxx

@@ -0,0 +1,69 @@
+
+#include <RWStepVisual_RWCameraUsage.ixx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_Representation.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_CameraUsage.hxx>
+
+
+RWStepVisual_RWCameraUsage::RWStepVisual_RWCameraUsage () {}
+
+void RWStepVisual_RWCameraUsage::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_CameraUsage)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"camera_usage")) return;
+
+	// --- inherited field : mappingOrigin ---
+
+	Handle(StepRepr_RepresentationItem) aMappingOrigin;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadEntity(num, 1,"mapping_origin", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aMappingOrigin);
+
+	// --- inherited field : mappedRepresentation ---
+
+	Handle(StepRepr_Representation) aMappedRepresentation;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadEntity(num, 2,"mapped_representation", ach, STANDARD_TYPE(StepRepr_Representation), aMappedRepresentation);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aMappingOrigin, aMappedRepresentation);
+}
+
+
+void RWStepVisual_RWCameraUsage::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_CameraUsage)& ent) const
+{
+
+	// --- inherited field mappingOrigin ---
+
+	SW.Send(ent->MappingOrigin());
+
+	// --- inherited field mappedRepresentation ---
+
+	SW.Send(ent->MappedRepresentation());
+}
+
+
+void RWStepVisual_RWCameraUsage::Share(const Handle(StepVisual_CameraUsage)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->MappingOrigin());
+
+
+	iter.GetOneItem(ent->MappedRepresentation());
+}
+

src/RWStepVisual/RWStepVisual_RWColour.cdl

@@ -0,0 +1,27 @@
+-- File:        Colour.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWColour from RWStepVisual
+
+	---Purpose : Read & Write Module for Colour
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     Colour from StepVisual
+
+is
+
+	Create returns RWColour;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable Colour from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : Colour from StepVisual);
+
+end RWColour;

src/RWStepVisual/RWStepVisual_RWColour.cxx

@@ -0,0 +1,24 @@
+
+#include <RWStepVisual_RWColour.ixx>
+
+
+RWStepVisual_RWColour::RWStepVisual_RWColour () {}
+
+void RWStepVisual_RWColour::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_Colour)& ent) const
+{
+  // --- Number of Parameter Control ---
+  
+  if (!data->CheckNbParams(num,0,ach,"colour")) return;
+  
+  //--- Initialisation of the read entity ---
+}
+
+void RWStepVisual_RWColour::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_Colour)& ent) const
+{
+}

src/RWStepVisual/RWStepVisual_RWColourRgb.cdl

@@ -0,0 +1,27 @@
+-- File:        ColourRgb.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWColourRgb from RWStepVisual
+
+	---Purpose : Read & Write Module for ColourRgb
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     ColourRgb from StepVisual
+
+is
+
+	Create returns RWColourRgb;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable ColourRgb from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : ColourRgb from StepVisual);
+
+end RWColourRgb;

src/RWStepVisual/RWStepVisual_RWColourRgb.cxx

@@ -0,0 +1,70 @@
+
+#include <RWStepVisual_RWColourRgb.ixx>
+
+
+RWStepVisual_RWColourRgb::RWStepVisual_RWColourRgb () {}
+
+void RWStepVisual_RWColourRgb::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_ColourRgb)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,4,ach,"colour_rgb")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- own field : red ---
+
+	Standard_Real aRed;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadReal (num,2,"red",ach,aRed);
+
+	// --- own field : green ---
+
+	Standard_Real aGreen;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadReal (num,3,"green",ach,aGreen);
+
+	// --- own field : blue ---
+
+	Standard_Real aBlue;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat4 =` not needed
+	data->ReadReal (num,4,"blue",ach,aBlue);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aRed, aGreen, aBlue);
+}
+
+
+void RWStepVisual_RWColourRgb::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_ColourRgb)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- own field : red ---
+
+	SW.Send(ent->Red());
+
+	// --- own field : green ---
+
+	SW.Send(ent->Green());
+
+	// --- own field : blue ---
+
+	SW.Send(ent->Blue());
+}

src/RWStepVisual/RWStepVisual_RWColourSpecification.cdl

@@ -0,0 +1,27 @@
+-- File:        ColourSpecification.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWColourSpecification from RWStepVisual
+
+	---Purpose : Read & Write Module for ColourSpecification
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     ColourSpecification from StepVisual
+
+is
+
+	Create returns RWColourSpecification;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable ColourSpecification from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : ColourSpecification from StepVisual);
+
+end RWColourSpecification;

src/RWStepVisual/RWStepVisual_RWColourSpecification.cxx

@@ -0,0 +1,40 @@
+
+#include <RWStepVisual_RWColourSpecification.ixx>
+
+
+RWStepVisual_RWColourSpecification::RWStepVisual_RWColourSpecification () {}
+
+void RWStepVisual_RWColourSpecification::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_ColourSpecification)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"colour_specification")) return;
+
+	// --- own field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName);
+}
+
+
+void RWStepVisual_RWColourSpecification::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_ColourSpecification)& ent) const
+{
+
+	// --- own field : name ---
+
+	SW.Send(ent->Name());
+}

src/RWStepVisual/RWStepVisual_RWCompositeText.cdl

@@ -0,0 +1,30 @@
+-- File:        CompositeText.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWCompositeText from RWStepVisual
+
+	---Purpose : Read & Write Module for CompositeText
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     CompositeText from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWCompositeText;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable CompositeText from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : CompositeText from StepVisual);
+
+	Share(me; ent : CompositeText from StepVisual; iter : in out EntityIterator);
+
+end RWCompositeText;

src/RWStepVisual/RWStepVisual_RWCompositeText.cxx

@@ -0,0 +1,87 @@
+
+#include <RWStepVisual_RWCompositeText.ixx>
+#include <StepVisual_HArray1OfTextOrCharacter.hxx>
+#include <StepVisual_TextOrCharacter.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_CompositeText.hxx>
+
+
+RWStepVisual_RWCompositeText::RWStepVisual_RWCompositeText () {}
+
+void RWStepVisual_RWCompositeText::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_CompositeText)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"composite_text has not 2 parameter(s)")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- own field : collectedText ---
+
+	Handle(StepVisual_HArray1OfTextOrCharacter) aCollectedText;
+	StepVisual_TextOrCharacter aCollectedTextItem;
+	Standard_Integer nsub2;
+	nsub2 = data->SubListNumber(num, 2, Standard_False);
+	if (nsub2 !=0) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aCollectedText = new StepVisual_HArray1OfTextOrCharacter (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2,i2,"collected_text",ach,aCollectedTextItem))
+	      aCollectedText->SetValue(i2,aCollectedTextItem);
+	  }
+	}
+	else {
+	  ach->AddFail("Parameter #2 (collected_text) is not a LIST");
+	}
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aCollectedText);
+}
+
+
+void RWStepVisual_RWCompositeText::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_CompositeText)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- own field : collectedText ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbCollectedText();  i2 ++) {
+	  SW.Send(ent->CollectedTextValue(i2).Value());
+	}
+	SW.CloseSub();
+}
+
+
+void RWStepVisual_RWCompositeText::Share(const Handle(StepVisual_CompositeText)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbCollectedText();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->CollectedTextValue(is1).Value());
+	}
+
+}
+

src/RWStepVisual/RWStepVisual_RWCompositeTextWithExtent.cdl

@@ -0,0 +1,30 @@
+-- File:        CompositeTextWithExtent.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWCompositeTextWithExtent from RWStepVisual
+
+	---Purpose : Read & Write Module for CompositeTextWithExtent
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     CompositeTextWithExtent from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWCompositeTextWithExtent;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable CompositeTextWithExtent from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : CompositeTextWithExtent from StepVisual);
+
+	Share(me; ent : CompositeTextWithExtent from StepVisual; iter : in out EntityIterator);
+
+end RWCompositeTextWithExtent;

src/RWStepVisual/RWStepVisual_RWCompositeTextWithExtent.cxx

@@ -0,0 +1,101 @@
+
+#include <RWStepVisual_RWCompositeTextWithExtent.ixx>
+#include <StepVisual_PlanarExtent.hxx>
+#include <StepVisual_HArray1OfTextOrCharacter.hxx>
+#include <StepVisual_TextOrCharacter.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_CompositeTextWithExtent.hxx>
+
+
+RWStepVisual_RWCompositeTextWithExtent::RWStepVisual_RWCompositeTextWithExtent () {}
+
+void RWStepVisual_RWCompositeTextWithExtent::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_CompositeTextWithExtent)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"composite_text_with_extent has not 3 parameter(s)")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- inherited field : collectedText ---
+
+	Handle(StepVisual_HArray1OfTextOrCharacter) aCollectedText;
+	StepVisual_TextOrCharacter aCollectedTextItem;
+	Standard_Integer nsub2;
+	nsub2 = data->SubListNumber(num, 2, Standard_False);
+	if (nsub2 !=0) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aCollectedText = new StepVisual_HArray1OfTextOrCharacter (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2,i2,"collected_text",ach,aCollectedTextItem))
+	      aCollectedText->SetValue(i2,aCollectedTextItem);
+	  }
+	}
+	else {
+	  ach->AddFail("Parameter #2 (collected_text) is not a LIST");
+	}
+
+	// --- own field : extent ---
+
+	Handle(StepVisual_PlanarExtent) aExtent;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadEntity(num, 3,"extent", ach, STANDARD_TYPE(StepVisual_PlanarExtent), aExtent);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aCollectedText, aExtent);
+}
+
+
+void RWStepVisual_RWCompositeTextWithExtent::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_CompositeTextWithExtent)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- inherited field collectedText ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbCollectedText();  i2 ++) {
+	  SW.Send(ent->CollectedTextValue(i2).Value());
+	}
+	SW.CloseSub();
+
+	// --- own field : extent ---
+
+	SW.Send(ent->Extent());
+}
+
+
+void RWStepVisual_RWCompositeTextWithExtent::Share(const Handle(StepVisual_CompositeTextWithExtent)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbCollectedText();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->CollectedTextValue(is1).Value());
+	}
+
+
+
+	iter.GetOneItem(ent->Extent());
+}
+

src/RWStepVisual/RWStepVisual_RWContextDependentInvisibility.cdl

@@ -0,0 +1,30 @@
+-- File:        ContextDependentInvisibility.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWContextDependentInvisibility from RWStepVisual
+
+	---Purpose : Read & Write Module for ContextDependentInvisibility
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     ContextDependentInvisibility from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWContextDependentInvisibility;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable ContextDependentInvisibility from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : ContextDependentInvisibility from StepVisual);
+
+	Share(me; ent : ContextDependentInvisibility from StepVisual; iter : in out EntityIterator);
+
+end RWContextDependentInvisibility;

src/RWStepVisual/RWStepVisual_RWContextDependentInvisibility.cxx

@@ -0,0 +1,87 @@
+
+#include <RWStepVisual_RWContextDependentInvisibility.ixx>
+#include <StepVisual_InvisibilityContext.hxx>
+#include <StepVisual_HArray1OfInvisibleItem.hxx>
+#include <StepVisual_InvisibleItem.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_ContextDependentInvisibility.hxx>
+
+
+RWStepVisual_RWContextDependentInvisibility::RWStepVisual_RWContextDependentInvisibility () {}
+
+void RWStepVisual_RWContextDependentInvisibility::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_ContextDependentInvisibility)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"context_dependent_invisibility")) return;
+
+	// --- inherited field : invisibleItems ---
+
+	Handle(StepVisual_HArray1OfInvisibleItem) aInvisibleItems;
+	StepVisual_InvisibleItem aInvisibleItemsItem;
+	Standard_Integer nsub1;
+	if (data->ReadSubList (num,1,"invisible_items",ach,nsub1)) {
+	  Standard_Integer nb1 = data->NbParams(nsub1);
+	  aInvisibleItems = new StepVisual_HArray1OfInvisibleItem (1, nb1);
+	  for (Standard_Integer i1 = 1; i1 <= nb1; i1 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	    if (data->ReadEntity (nsub1,i1,"invisible_items",ach,aInvisibleItemsItem))
+	      aInvisibleItems->SetValue(i1,aInvisibleItemsItem);
+	  }
+	}
+
+	// --- own field : presentationContext ---
+
+	StepVisual_InvisibilityContext aPresentationContext;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadEntity(num,2,"presentation_context",ach,aPresentationContext);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aInvisibleItems, aPresentationContext);
+}
+
+
+void RWStepVisual_RWContextDependentInvisibility::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_ContextDependentInvisibility)& ent) const
+{
+
+	// --- inherited field invisibleItems ---
+
+	SW.OpenSub();
+	for (Standard_Integer i1 = 1;  i1 <= ent->NbInvisibleItems();  i1 ++) {
+	  SW.Send(ent->InvisibleItemsValue(i1).Value());
+	}
+	SW.CloseSub();
+
+	// --- own field : presentationContext ---
+
+	SW.Send(ent->PresentationContext().Value());
+}
+
+
+void RWStepVisual_RWContextDependentInvisibility::Share(const Handle(StepVisual_ContextDependentInvisibility)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbInvisibleItems();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->InvisibleItemsValue(is1).Value());
+	}
+
+
+
+	iter.GetOneItem(ent->PresentationContext().Value());
+}
+

src/RWStepVisual/RWStepVisual_RWContextDependentOverRidingStyledItem.cdl

@@ -0,0 +1,30 @@
+-- File:        ContextDependentOverRidingStyledItem.cdl
+-- Created:     Mon Dec  4 12:02:24 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWContextDependentOverRidingStyledItem from RWStepVisual
+
+	---Purpose : Read & Write Module for ContextDependentOverRidingStyledItem
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     ContextDependentOverRidingStyledItem from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWContextDependentOverRidingStyledItem;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable ContextDependentOverRidingStyledItem from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : ContextDependentOverRidingStyledItem from StepVisual);
+
+	Share(me; ent : ContextDependentOverRidingStyledItem from StepVisual; iter : in out EntityIterator);
+
+end RWContextDependentOverRidingStyledItem;

src/RWStepVisual/RWStepVisual_RWContextDependentOverRidingStyledItem.cxx

@@ -0,0 +1,144 @@
+
+#include <RWStepVisual_RWContextDependentOverRidingStyledItem.ixx>
+#include <StepVisual_HArray1OfStyleContextSelect.hxx>
+#include <StepVisual_StyleContextSelect.hxx>
+#include <StepVisual_HArray1OfPresentationStyleAssignment.hxx>
+#include <StepVisual_PresentationStyleAssignment.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepVisual_StyledItem.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_ContextDependentOverRidingStyledItem.hxx>
+
+
+RWStepVisual_RWContextDependentOverRidingStyledItem::RWStepVisual_RWContextDependentOverRidingStyledItem () {}
+
+void RWStepVisual_RWContextDependentOverRidingStyledItem::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_ContextDependentOverRidingStyledItem)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,5,ach,"context_dependent_over_riding_styled_item")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- inherited field : styles ---
+
+	Handle(StepVisual_HArray1OfPresentationStyleAssignment) aStyles;
+	Handle(StepVisual_PresentationStyleAssignment) anent2;
+	Standard_Integer nsub2;
+	if (data->ReadSubList (num,2,"styles",ach,nsub2)) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aStyles = new StepVisual_HArray1OfPresentationStyleAssignment (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2, i2,"presentation_style_assignment", ach,
+				  STANDARD_TYPE(StepVisual_PresentationStyleAssignment), anent2))
+	      aStyles->SetValue(i2, anent2);
+	  }
+	}
+
+	// --- inherited field : item ---
+
+	Handle(StepRepr_RepresentationItem) aItem;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItem);
+
+	// --- inherited field : overRiddenStyle ---
+
+	Handle(StepVisual_StyledItem) aOverRiddenStyle;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat4 =` not needed
+	data->ReadEntity(num, 4,"over_ridden_style", ach, STANDARD_TYPE(StepVisual_StyledItem), aOverRiddenStyle);
+
+	// --- own field : styleContext ---
+
+	Handle(StepVisual_HArray1OfStyleContextSelect) aStyleContext;
+	StepVisual_StyleContextSelect aStyleContextItem;
+	Standard_Integer nsub5;
+	if (data->ReadSubList (num,5,"style_context",ach,nsub5)) {
+	  Standard_Integer nb5 = data->NbParams(nsub5);
+	  aStyleContext = new StepVisual_HArray1OfStyleContextSelect (1, nb5);
+	  for (Standard_Integer i5 = 1; i5 <= nb5; i5 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat5 =` not needed
+	    if (data->ReadEntity (nsub5,i5,"style_context",ach,aStyleContextItem))
+	      aStyleContext->SetValue(i5,aStyleContextItem);
+	  }
+	}
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aStyles, aItem, aOverRiddenStyle, aStyleContext);
+}
+
+
+void RWStepVisual_RWContextDependentOverRidingStyledItem::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_ContextDependentOverRidingStyledItem)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- inherited field styles ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbStyles();  i2 ++) {
+	  SW.Send(ent->StylesValue(i2));
+	}
+	SW.CloseSub();
+
+	// --- inherited field item ---
+
+	SW.Send(ent->Item());
+
+	// --- inherited field overRiddenStyle ---
+
+	SW.Send(ent->OverRiddenStyle());
+
+	// --- own field : styleContext ---
+
+	SW.OpenSub();
+	for (Standard_Integer i5 = 1;  i5 <= ent->NbStyleContext();  i5 ++) {
+	  SW.Send(ent->StyleContextValue(i5).Value());
+	}
+	SW.CloseSub();
+}
+
+
+void RWStepVisual_RWContextDependentOverRidingStyledItem::Share(const Handle(StepVisual_ContextDependentOverRidingStyledItem)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbStyles();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->StylesValue(is1));
+	}
+
+
+
+	iter.GetOneItem(ent->Item());
+
+
+	iter.GetOneItem(ent->OverRiddenStyle());
+
+
+	Standard_Integer nbElem4 = ent->NbStyleContext();
+	for (Standard_Integer is4=1; is4<=nbElem4; is4 ++) {
+	  iter.GetOneItem(ent->StyleContextValue(is4).Value());
+	}
+
+}
+

src/RWStepVisual/RWStepVisual_RWCurveStyle.cdl

@@ -0,0 +1,30 @@
+-- File:        CurveStyle.cdl
+-- Created:     Mon Dec  4 12:02:25 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWCurveStyle from RWStepVisual
+
+	---Purpose : Read & Write Module for CurveStyle
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     CurveStyle from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWCurveStyle;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable CurveStyle from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : CurveStyle from StepVisual);
+
+	Share(me; ent : CurveStyle from StepVisual; iter : in out EntityIterator);
+
+end RWCurveStyle;

src/RWStepVisual/RWStepVisual_RWCurveStyle.cxx

@@ -0,0 +1,102 @@
+#include <RWStepVisual_RWCurveStyle.ixx>
+#include <StepVisual_CurveStyleFontSelect.hxx>
+#include <StepBasic_SizeSelect.hxx>
+#include <StepVisual_Colour.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <StepVisual_CurveStyle.hxx>
+//#include <StepBasic_SizeMember.hxx>
+
+
+//=======================================================================
+//function : RWStepVisual_RWCurveStyle
+//purpose  : 
+//=======================================================================
+
+RWStepVisual_RWCurveStyle::RWStepVisual_RWCurveStyle()
+{
+}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  : 
+//=======================================================================
+
+void RWStepVisual_RWCurveStyle::ReadStep(const Handle(StepData_StepReaderData)& data,
+					 const Standard_Integer num,
+					 Handle(Interface_Check)& ach,
+					 const Handle(StepVisual_CurveStyle)& ent) const
+{
+
+  // --- Number of Parameter Control ---
+  if (!data->CheckNbParams(num,4,ach,"curve_style")) return;
+
+  // --- own field : name ---
+  Handle(TCollection_HAsciiString) aName;
+  
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+  data->ReadString (num,1,"name",ach,aName);
+
+  // --- own field : curveFont ---
+  // idem RWStepVisual_BooleanOperand.
+  // doit etre remis a niveau avant utilisation
+  StepVisual_CurveStyleFontSelect aCurveFont;
+  data->ReadEntity(num,2,"curve_font",ach,aCurveFont);
+
+  // --- own field : curveWidth ---
+  StepBasic_SizeSelect aCurveWidth;
+  data->ReadEntity(num,3,"curve_width",ach,aCurveWidth);
+//  Handle(StepBasic_SizeMember) memb = new StepBasic_SizeMember;
+//  data->ReadMember(num,3,"curve_width",ach,memb);
+//  if ( ! memb->HasName() ) {
+//    ach->AddWarning("Parameter #3 (curve_width) is not a POSITIVE_LENGTH_MEASURE");
+//    memb->SetName ( "POSITIVE_LENGTH_MEASURE" );
+//  }
+//  aCurveWidth.SetValue(memb);
+
+  // --- own field : curveColour ---
+  Handle(StepVisual_Colour) aCurveColour;
+  
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat4 =` not needed
+  data->ReadEntity(num, 4,"curve_colour", ach, STANDARD_TYPE(StepVisual_Colour), aCurveColour);
+
+  //--- Initialisation of the read entity ---
+  ent->Init(aName, aCurveFont, aCurveWidth, aCurveColour);
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose  : 
+//=======================================================================
+
+void RWStepVisual_RWCurveStyle::WriteStep(StepData_StepWriter& SW,
+					  const Handle(StepVisual_CurveStyle)& ent) const
+{
+
+  // --- own field : name ---
+  SW.Send(ent->Name());
+
+  // --- own field : curveFont ---
+  SW.Send(ent->CurveFont().Value());
+
+  // --- own field : curveWidth ---
+  SW.Send(ent->CurveWidth().Value());
+
+  // --- own field : curveColour ---
+  SW.Send(ent->CurveColour());
+}
+
+
+//=======================================================================
+//function : Share
+//purpose  : 
+//=======================================================================
+
+void RWStepVisual_RWCurveStyle::Share(const Handle(StepVisual_CurveStyle)& ent, 
+				      Interface_EntityIterator& iter) const
+{
+  iter.GetOneItem(ent->CurveFont().Value());
+  iter.GetOneItem(ent->CurveColour());
+}
+

src/RWStepVisual/RWStepVisual_RWCurveStyleFont.cdl

@@ -0,0 +1,30 @@
+-- File:        CurveStyleFont.cdl
+-- Created:     Mon Dec  4 12:02:25 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWCurveStyleFont from RWStepVisual
+
+	---Purpose : Read & Write Module for CurveStyleFont
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     CurveStyleFont from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWCurveStyleFont;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable CurveStyleFont from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : CurveStyleFont from StepVisual);
+
+	Share(me; ent : CurveStyleFont from StepVisual; iter : in out EntityIterator);
+
+end RWCurveStyleFont;

src/RWStepVisual/RWStepVisual_RWCurveStyleFont.cxx

@@ -0,0 +1,84 @@
+
+#include <RWStepVisual_RWCurveStyleFont.ixx>
+#include <StepVisual_HArray1OfCurveStyleFontPattern.hxx>
+#include <StepVisual_CurveStyleFontPattern.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_CurveStyleFont.hxx>
+
+
+RWStepVisual_RWCurveStyleFont::RWStepVisual_RWCurveStyleFont () {}
+
+void RWStepVisual_RWCurveStyleFont::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_CurveStyleFont)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"curve_style_font")) return;
+
+	// --- own field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- own field : patternList ---
+
+	Handle(StepVisual_HArray1OfCurveStyleFontPattern) aPatternList;
+	Handle(StepVisual_CurveStyleFontPattern) anent2;
+	Standard_Integer nsub2;
+	if (data->ReadSubList (num,2,"pattern_list",ach,nsub2)) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aPatternList = new StepVisual_HArray1OfCurveStyleFontPattern (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2, i2,"curve_style_font_pattern", ach,
+				  STANDARD_TYPE(StepVisual_CurveStyleFontPattern), anent2))
+	      aPatternList->SetValue(i2, anent2);
+	  }
+	}
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aPatternList);
+}
+
+
+void RWStepVisual_RWCurveStyleFont::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_CurveStyleFont)& ent) const
+{
+
+	// --- own field : name ---
+
+	SW.Send(ent->Name());
+
+	// --- own field : patternList ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbPatternList();  i2 ++) {
+	  SW.Send(ent->PatternListValue(i2));
+	}
+	SW.CloseSub();
+}
+
+
+void RWStepVisual_RWCurveStyleFont::Share(const Handle(StepVisual_CurveStyleFont)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbPatternList();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->PatternListValue(is1));
+	}
+
+}
+

src/RWStepVisual/RWStepVisual_RWCurveStyleFontPattern.cdl

@@ -0,0 +1,27 @@
+-- File:        CurveStyleFontPattern.cdl
+-- Created:     Mon Dec  4 12:02:25 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWCurveStyleFontPattern from RWStepVisual
+
+	---Purpose : Read & Write Module for CurveStyleFontPattern
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     CurveStyleFontPattern from StepVisual
+
+is
+
+	Create returns RWCurveStyleFontPattern;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable CurveStyleFontPattern from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : CurveStyleFontPattern from StepVisual);
+
+end RWCurveStyleFontPattern;

src/RWStepVisual/RWStepVisual_RWCurveStyleFontPattern.cxx

@@ -0,0 +1,50 @@
+
+#include <RWStepVisual_RWCurveStyleFontPattern.ixx>
+
+
+RWStepVisual_RWCurveStyleFontPattern::RWStepVisual_RWCurveStyleFontPattern () {}
+
+void RWStepVisual_RWCurveStyleFontPattern::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_CurveStyleFontPattern)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"curve_style_font_pattern")) return;
+
+	// --- own field : visibleSegmentLength ---
+
+	Standard_Real aVisibleSegmentLength;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadReal (num,1,"visible_segment_length",ach,aVisibleSegmentLength);
+
+	// --- own field : invisibleSegmentLength ---
+
+	Standard_Real aInvisibleSegmentLength;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadReal (num,2,"invisible_segment_length",ach,aInvisibleSegmentLength);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aVisibleSegmentLength, aInvisibleSegmentLength);
+}
+
+
+void RWStepVisual_RWCurveStyleFontPattern::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_CurveStyleFontPattern)& ent) const
+{
+
+	// --- own field : visibleSegmentLength ---
+
+	SW.Send(ent->VisibleSegmentLength());
+
+	// --- own field : invisibleSegmentLength ---
+
+	SW.Send(ent->InvisibleSegmentLength());
+}

src/RWStepVisual/RWStepVisual_RWDraughtingModel.cdl

@@ -0,0 +1,35 @@
+-- File:	RWStepVisual_RWDraughtingModel.cdl
+-- Created:	Thu Jan 13 10:08:42 2000 
+-- Author:	Andrey BETENEV
+-- Generator:	ExpToCas (EXPRESS -> CASCADE/XSTEP Translator) V1.0
+-- Copyright:	Matra Datavision 1999
+
+class RWDraughtingModel from RWStepVisual
+
+    ---Purpose: Read & Write tool for DraughtingModel
+
+uses
+    Check from Interface,
+    StepWriter from StepData,
+    StepReaderData from StepData,
+    EntityIterator from Interface,
+    DraughtingModel from StepVisual
+
+is
+    Create returns RWDraughtingModel from RWStepVisual;
+	---Purpose: Empty constructor
+
+    ReadStep (me; data: StepReaderData from StepData; num: Integer;
+                  ach : in out Check from Interface;
+                  ent : DraughtingModel from StepVisual);
+	---Purpose: Reads DraughtingModel
+
+    WriteStep (me; SW: in out StepWriter from StepData;
+                   ent: DraughtingModel from StepVisual);
+	---Purpose: Writes DraughtingModel
+
+    Share (me; ent : DraughtingModel from StepVisual;
+               iter: in out EntityIterator from Interface);
+	---Purpose: Fills data for graph (shared items)
+
+end RWDraughtingModel;

src/RWStepVisual/RWStepVisual_RWDraughtingModel.cxx

@@ -0,0 +1,100 @@
+// File:	RWStepVisual_RWDraughtingModel.cxx
+// Created:	Thu Jan 13 10:08:42 2000 
+// Author:	Andrey BETENEV
+// Generator:	ExpToCas (EXPRESS -> CASCADE/XSTEP Translator) V1.0
+// Copyright:	Matra Datavision 1999
+
+#include <RWStepVisual_RWDraughtingModel.ixx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+
+//=======================================================================
+//function : RWStepVisual_RWDraughtingModel
+//purpose  : 
+//=======================================================================
+
+RWStepVisual_RWDraughtingModel::RWStepVisual_RWDraughtingModel ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose  : 
+//=======================================================================
+
+void RWStepVisual_RWDraughtingModel::ReadStep (const Handle(StepData_StepReaderData)& data,
+                                               const Standard_Integer num,
+                                               Handle(Interface_Check)& ach,
+                                               const Handle(StepVisual_DraughtingModel) &ent) const
+{
+  // Check number of parameters
+  if ( ! data->CheckNbParams(num,3,ach,"draughting_model") ) return;
+
+  // Inherited fields of Representation
+
+  Handle(TCollection_HAsciiString) aRepresentation_Name;
+  data->ReadString (num, 1, "representation.name", ach, aRepresentation_Name);
+
+  Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+  Standard_Integer sub2 = 0;
+  if ( data->ReadSubList (num, 2, "representation.items", ach, sub2) ) {
+    Standard_Integer num2 = sub2;
+    Standard_Integer nb0 = data->NbParams(num2);
+    aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+    for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+      Handle(StepRepr_RepresentationItem) anIt0;
+      data->ReadEntity (num2, i0, "representation.items", ach, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+      aRepresentation_Items->SetValue(i0, anIt0);
+    }
+  }
+
+  Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+  data->ReadEntity (num, 3, "representation.context_of_items", ach, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+  // Initialize entity
+  ent->Init(aRepresentation_Name,
+            aRepresentation_Items,
+            aRepresentation_ContextOfItems);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  : 
+//=======================================================================
+
+void RWStepVisual_RWDraughtingModel::WriteStep (StepData_StepWriter& SW,
+                                                const Handle(StepVisual_DraughtingModel) &ent) const
+{
+
+  // Inherited fields of Representation
+
+  SW.Send (ent->StepRepr_Representation::Name());
+
+  SW.OpenSub();
+  for (Standard_Integer i1=1; i1 <= ent->StepRepr_Representation::Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = ent->StepRepr_Representation::Items()->Value(i1);
+    SW.Send (Var0);
+  }
+  SW.CloseSub();
+
+  SW.Send (ent->StepRepr_Representation::ContextOfItems());
+}
+
+//=======================================================================
+//function : Share
+//purpose  : 
+//=======================================================================
+
+void RWStepVisual_RWDraughtingModel::Share (const Handle(StepVisual_DraughtingModel) &ent,
+                                            Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of Representation
+
+  for (Standard_Integer i1=1; i1 <= ent->StepRepr_Representation::Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = ent->StepRepr_Representation::Items()->Value(i1);
+    iter.AddItem (Var0);
+  }
+
+  iter.AddItem (ent->StepRepr_Representation::ContextOfItems());
+}

src/RWStepVisual/RWStepVisual_RWDraughtingPreDefinedColour.cdl

@@ -0,0 +1,27 @@
+-- File:        DraughtingPreDefinedColour.cdl
+-- Created:     Mon Dec  4 12:02:25 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWDraughtingPreDefinedColour from RWStepVisual
+
+	---Purpose : Read & Write Module for DraughtingPreDefinedColour
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     DraughtingPreDefinedColour from StepVisual
+
+is
+
+	Create returns RWDraughtingPreDefinedColour;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable DraughtingPreDefinedColour from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : DraughtingPreDefinedColour from StepVisual);
+
+end RWDraughtingPreDefinedColour;

src/RWStepVisual/RWStepVisual_RWDraughtingPreDefinedColour.cxx

@@ -0,0 +1,42 @@
+//:S4134: abv 03.03.99: implementation of DraughtingPreDefinedColour modified
+
+#include <RWStepVisual_RWDraughtingPreDefinedColour.ixx>
+#include <StepVisual_PreDefinedItem.hxx>
+
+
+RWStepVisual_RWDraughtingPreDefinedColour::RWStepVisual_RWDraughtingPreDefinedColour () {}
+
+void RWStepVisual_RWDraughtingPreDefinedColour::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_DraughtingPreDefinedColour)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"draughting_pre_defined_colour has not 1 parameter(s)")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->GetPreDefinedItem()->Init(aName);
+}
+
+
+void RWStepVisual_RWDraughtingPreDefinedColour::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_DraughtingPreDefinedColour)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->GetPreDefinedItem()->Name());
+}

src/RWStepVisual/RWStepVisual_RWDraughtingPreDefinedCurveFont.cdl

@@ -0,0 +1,27 @@
+-- File:        DraughtingPreDefinedCurveFont.cdl
+-- Created:     Mon Dec  4 12:02:25 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWDraughtingPreDefinedCurveFont from RWStepVisual
+
+	---Purpose : Read & Write Module for DraughtingPreDefinedCurveFont
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     DraughtingPreDefinedCurveFont from StepVisual
+
+is
+
+	Create returns RWDraughtingPreDefinedCurveFont;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable DraughtingPreDefinedCurveFont from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : DraughtingPreDefinedCurveFont from StepVisual);
+
+end RWDraughtingPreDefinedCurveFont;

src/RWStepVisual/RWStepVisual_RWDraughtingPreDefinedCurveFont.cxx

@@ -0,0 +1,40 @@
+
+#include <RWStepVisual_RWDraughtingPreDefinedCurveFont.ixx>
+
+
+RWStepVisual_RWDraughtingPreDefinedCurveFont::RWStepVisual_RWDraughtingPreDefinedCurveFont () {}
+
+void RWStepVisual_RWDraughtingPreDefinedCurveFont::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_DraughtingPreDefinedCurveFont)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"draughting_pre_defined_curve_font has not 1 parameter(s)")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName);
+}
+
+
+void RWStepVisual_RWDraughtingPreDefinedCurveFont::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_DraughtingPreDefinedCurveFont)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+}

src/RWStepVisual/RWStepVisual_RWExternallyDefinedCurveFont.cdl

@@ -0,0 +1,35 @@
+-- File:	RWStepVisual_RWExternallyDefinedCurveFont.cdl
+-- Created:	Wed May 10 15:09:07 2000 
+-- Author:	Andrey BETENEV
+-- Generator:	ExpToCas (EXPRESS -> CASCADE/XSTEP Translator) V1.1
+-- Copyright:	Matra Datavision 2000
+
+class RWExternallyDefinedCurveFont from RWStepVisual
+
+    ---Purpose: Read & Write tool for ExternallyDefinedCurveFont
+
+uses
+    Check from Interface,
+    StepWriter from StepData,
+    StepReaderData from StepData,
+    EntityIterator from Interface,
+    ExternallyDefinedCurveFont from StepVisual
+
+is
+    Create returns RWExternallyDefinedCurveFont from RWStepVisual;
+	---Purpose: Empty constructor
+
+    ReadStep (me; data: StepReaderData from StepData; num: Integer;
+                  ach : in out Check from Interface;
+                  ent : ExternallyDefinedCurveFont from StepVisual);
+	---Purpose: Reads ExternallyDefinedCurveFont
+
+    WriteStep (me; SW: in out StepWriter from StepData;
+                   ent: ExternallyDefinedCurveFont from StepVisual);
+	---Purpose: Writes ExternallyDefinedCurveFont
+
+    Share (me; ent : ExternallyDefinedCurveFont from StepVisual;
+               iter: in out EntityIterator from Interface);
+	---Purpose: Fills data for graph (shared items)
+
+end RWExternallyDefinedCurveFont;

src/RWStepVisual/RWStepVisual_RWExternallyDefinedCurveFont.cxx

@@ -0,0 +1,74 @@
+// File:	RWStepVisual_RWExternallyDefinedCurveFont.cxx
+// Created:	Wed May 10 15:09:07 2000 
+// Author:	Andrey BETENEV
+// Generator:	ExpToCas (EXPRESS -> CASCADE/XSTEP Translator) V1.1
+// Copyright:	Matra Datavision 2000
+
+#include <RWStepVisual_RWExternallyDefinedCurveFont.ixx>
+
+//=======================================================================
+//function : RWStepVisual_RWExternallyDefinedCurveFont
+//purpose  : 
+//=======================================================================
+
+RWStepVisual_RWExternallyDefinedCurveFont::RWStepVisual_RWExternallyDefinedCurveFont ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose  : 
+//=======================================================================
+
+void RWStepVisual_RWExternallyDefinedCurveFont::ReadStep (const Handle(StepData_StepReaderData)& data,
+                                                          const Standard_Integer num,
+                                                          Handle(Interface_Check)& ach,
+                                                          const Handle(StepVisual_ExternallyDefinedCurveFont) &ent) const
+{
+  // Check number of parameters
+  if ( ! data->CheckNbParams(num,2,ach,"externally_defined_curve_font") ) return;
+
+  // Inherited fields of ExternallyDefinedItem
+
+  StepBasic_SourceItem aExternallyDefinedItem_ItemId;
+  data->ReadEntity (num, 1, "externally_defined_item.item_id", ach, aExternallyDefinedItem_ItemId);
+
+  Handle(StepBasic_ExternalSource) aExternallyDefinedItem_Source;
+  data->ReadEntity (num, 2, "externally_defined_item.source", ach, STANDARD_TYPE(StepBasic_ExternalSource), aExternallyDefinedItem_Source);
+
+  // Initialize entity
+  ent->Init(aExternallyDefinedItem_ItemId,
+            aExternallyDefinedItem_Source);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  : 
+//=======================================================================
+
+void RWStepVisual_RWExternallyDefinedCurveFont::WriteStep (StepData_StepWriter& SW,
+                                                           const Handle(StepVisual_ExternallyDefinedCurveFont) &ent) const
+{
+
+  // Inherited fields of ExternallyDefinedItem
+
+  SW.Send (ent->StepBasic_ExternallyDefinedItem::ItemId().Value());
+
+  SW.Send (ent->StepBasic_ExternallyDefinedItem::Source());
+}
+
+//=======================================================================
+//function : Share
+//purpose  : 
+//=======================================================================
+
+void RWStepVisual_RWExternallyDefinedCurveFont::Share (const Handle(StepVisual_ExternallyDefinedCurveFont) &ent,
+                                                       Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of ExternallyDefinedItem
+
+  iter.AddItem (ent->StepBasic_ExternallyDefinedItem::ItemId().Value());
+
+  iter.AddItem (ent->StepBasic_ExternallyDefinedItem::Source());
+}

src/RWStepVisual/RWStepVisual_RWFillAreaStyle.cdl

@@ -0,0 +1,30 @@
+-- File:        FillAreaStyle.cdl
+-- Created:     Mon Dec  4 12:02:27 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWFillAreaStyle from RWStepVisual
+
+	---Purpose : Read & Write Module for FillAreaStyle
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     FillAreaStyle from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWFillAreaStyle;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable FillAreaStyle from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : FillAreaStyle from StepVisual);
+
+	Share(me; ent : FillAreaStyle from StepVisual; iter : in out EntityIterator);
+
+end RWFillAreaStyle;

src/RWStepVisual/RWStepVisual_RWFillAreaStyle.cxx

@@ -0,0 +1,83 @@
+
+#include <RWStepVisual_RWFillAreaStyle.ixx>
+#include <StepVisual_HArray1OfFillStyleSelect.hxx>
+#include <StepVisual_FillStyleSelect.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_FillAreaStyle.hxx>
+
+
+RWStepVisual_RWFillAreaStyle::RWStepVisual_RWFillAreaStyle () {}
+
+void RWStepVisual_RWFillAreaStyle::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_FillAreaStyle)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"fill_area_style")) return;
+
+	// --- own field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- own field : fillStyles ---
+
+	Handle(StepVisual_HArray1OfFillStyleSelect) aFillStyles;
+	StepVisual_FillStyleSelect aFillStylesItem;
+	Standard_Integer nsub2;
+	if (data->ReadSubList (num,2,"fill_styles",ach,nsub2)) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aFillStyles = new StepVisual_HArray1OfFillStyleSelect (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2,i2,"fill_styles",ach,aFillStylesItem))
+	      aFillStyles->SetValue(i2,aFillStylesItem);
+	  }
+	}
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aFillStyles);
+}
+
+
+void RWStepVisual_RWFillAreaStyle::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_FillAreaStyle)& ent) const
+{
+
+	// --- own field : name ---
+
+	SW.Send(ent->Name());
+
+	// --- own field : fillStyles ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbFillStyles();  i2 ++) {
+	  SW.Send(ent->FillStylesValue(i2).Value());
+	}
+	SW.CloseSub();
+}
+
+
+void RWStepVisual_RWFillAreaStyle::Share(const Handle(StepVisual_FillAreaStyle)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbFillStyles();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->FillStylesValue(is1).Value());
+	}
+
+}
+

src/RWStepVisual/RWStepVisual_RWFillAreaStyleColour.cdl

@@ -0,0 +1,30 @@
+-- File:        FillAreaStyleColour.cdl
+-- Created:     Mon Dec  4 12:02:27 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWFillAreaStyleColour from RWStepVisual
+
+	---Purpose : Read & Write Module for FillAreaStyleColour
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     FillAreaStyleColour from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWFillAreaStyleColour;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable FillAreaStyleColour from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : FillAreaStyleColour from StepVisual);
+
+	Share(me; ent : FillAreaStyleColour from StepVisual; iter : in out EntityIterator);
+
+end RWFillAreaStyleColour;

src/RWStepVisual/RWStepVisual_RWFillAreaStyleColour.cxx

@@ -0,0 +1,65 @@
+
+#include <RWStepVisual_RWFillAreaStyleColour.ixx>
+#include <StepVisual_Colour.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_FillAreaStyleColour.hxx>
+
+
+RWStepVisual_RWFillAreaStyleColour::RWStepVisual_RWFillAreaStyleColour () {}
+
+void RWStepVisual_RWFillAreaStyleColour::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_FillAreaStyleColour)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"fill_area_style_colour")) return;
+
+	// --- own field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- own field : fillColour ---
+
+	Handle(StepVisual_Colour) aFillColour;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadEntity(num, 2,"fill_colour", ach, STANDARD_TYPE(StepVisual_Colour), aFillColour);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aFillColour);
+}
+
+
+void RWStepVisual_RWFillAreaStyleColour::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_FillAreaStyleColour)& ent) const
+{
+
+	// --- own field : name ---
+
+	SW.Send(ent->Name());
+
+	// --- own field : fillColour ---
+
+	SW.Send(ent->FillColour());
+}
+
+
+void RWStepVisual_RWFillAreaStyleColour::Share(const Handle(StepVisual_FillAreaStyleColour)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->FillColour());
+}
+

src/RWStepVisual/RWStepVisual_RWInvisibility.cdl

@@ -0,0 +1,30 @@
+-- File:        Invisibility.cdl
+-- Created:     Mon Dec  4 12:02:27 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWInvisibility from RWStepVisual
+
+	---Purpose : Read & Write Module for Invisibility
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     Invisibility from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWInvisibility;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable Invisibility from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : Invisibility from StepVisual);
+
+	Share(me; ent : Invisibility from StepVisual; iter : in out EntityIterator);
+
+end RWInvisibility;

src/RWStepVisual/RWStepVisual_RWInvisibility.cxx

@@ -0,0 +1,73 @@
+
+#include <RWStepVisual_RWInvisibility.ixx>
+#include <StepVisual_HArray1OfInvisibleItem.hxx>
+#include <StepVisual_InvisibleItem.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_Invisibility.hxx>
+
+
+RWStepVisual_RWInvisibility::RWStepVisual_RWInvisibility () {}
+
+void RWStepVisual_RWInvisibility::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_Invisibility)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"invisibility")) return;
+
+	// --- own field : invisibleItems ---
+
+	Handle(StepVisual_HArray1OfInvisibleItem) aInvisibleItems;
+	StepVisual_InvisibleItem aInvisibleItemsItem;
+	Standard_Integer nsub1;
+	if (data->ReadSubList (num,1,"invisible_items",ach,nsub1)) {
+	  Standard_Integer nb1 = data->NbParams(nsub1);
+	  aInvisibleItems = new StepVisual_HArray1OfInvisibleItem (1, nb1);
+	  for (Standard_Integer i1 = 1; i1 <= nb1; i1 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	    if (data->ReadEntity (nsub1,i1,"invisible_items",ach,aInvisibleItemsItem))
+	      aInvisibleItems->SetValue(i1,aInvisibleItemsItem);
+	  }
+	}
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aInvisibleItems);
+}
+
+
+void RWStepVisual_RWInvisibility::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_Invisibility)& ent) const
+{
+
+	// --- own field : invisibleItems ---
+
+	SW.OpenSub();
+	for (Standard_Integer i1 = 1;  i1 <= ent->NbInvisibleItems();  i1 ++) {
+	  SW.Send(ent->InvisibleItemsValue(i1).Value());
+	}
+	SW.CloseSub();
+}
+
+
+void RWStepVisual_RWInvisibility::Share(const Handle(StepVisual_Invisibility)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbInvisibleItems();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->InvisibleItemsValue(is1).Value());
+	}
+
+}
+

src/RWStepVisual/RWStepVisual_RWMechanicalDesignGeometricPresentationArea.cdl

@@ -0,0 +1,30 @@
+-- File:        MechanicalDesignGeometricPresentationArea.cdl
+-- Created:     Mon Dec  4 12:02:28 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWMechanicalDesignGeometricPresentationArea from RWStepVisual
+
+	---Purpose : Read & Write Module for MechanicalDesignGeometricPresentationArea
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     MechanicalDesignGeometricPresentationArea from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWMechanicalDesignGeometricPresentationArea;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable MechanicalDesignGeometricPresentationArea from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : MechanicalDesignGeometricPresentationArea from StepVisual);
+
+	Share(me; ent : MechanicalDesignGeometricPresentationArea from StepVisual; iter : in out EntityIterator);
+
+end RWMechanicalDesignGeometricPresentationArea;

src/RWStepVisual/RWStepVisual_RWMechanicalDesignGeometricPresentationArea.cxx

@@ -0,0 +1,98 @@
+
+#include <RWStepVisual_RWMechanicalDesignGeometricPresentationArea.ixx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_MechanicalDesignGeometricPresentationArea.hxx>
+
+
+RWStepVisual_RWMechanicalDesignGeometricPresentationArea::RWStepVisual_RWMechanicalDesignGeometricPresentationArea () {}
+
+void RWStepVisual_RWMechanicalDesignGeometricPresentationArea::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_MechanicalDesignGeometricPresentationArea)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"mechanical_design_geometric_presentation_area")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- inherited field : items ---
+
+	Handle(StepRepr_HArray1OfRepresentationItem) aItems;
+	Handle(StepRepr_RepresentationItem) anent2;
+	Standard_Integer nsub2;
+	if (data->ReadSubList (num,2,"items",ach,nsub2)) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aItems = new StepRepr_HArray1OfRepresentationItem (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2, i2,"representation_item", ach,
+				  STANDARD_TYPE(StepRepr_RepresentationItem), anent2))
+	      aItems->SetValue(i2, anent2);
+	  }
+	}
+
+	// --- inherited field : contextOfItems ---
+
+	Handle(StepRepr_RepresentationContext) aContextOfItems;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadEntity(num, 3,"context_of_items", ach, STANDARD_TYPE(StepRepr_RepresentationContext), aContextOfItems);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aItems, aContextOfItems);
+}
+
+
+void RWStepVisual_RWMechanicalDesignGeometricPresentationArea::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_MechanicalDesignGeometricPresentationArea)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- inherited field items ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbItems();  i2 ++) {
+	  SW.Send(ent->ItemsValue(i2));
+	}
+	SW.CloseSub();
+
+	// --- inherited field contextOfItems ---
+
+	SW.Send(ent->ContextOfItems());
+}
+
+
+void RWStepVisual_RWMechanicalDesignGeometricPresentationArea::Share(const Handle(StepVisual_MechanicalDesignGeometricPresentationArea)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbItems();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->ItemsValue(is1));
+	}
+
+
+
+	iter.GetOneItem(ent->ContextOfItems());
+}
+

src/RWStepVisual/RWStepVisual_RWMechanicalDesignGeometricPresentationRepresentation.cdl

@@ -0,0 +1,30 @@
+-- File:        MechanicalDesignGeometricPresentationRepresentation.cdl
+-- Created:     Mon Dec  4 12:02:28 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWMechanicalDesignGeometricPresentationRepresentation from RWStepVisual
+
+	---Purpose : Read & Write Module for MechanicalDesignGeometricPresentationRepresentation
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     MechanicalDesignGeometricPresentationRepresentation from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWMechanicalDesignGeometricPresentationRepresentation;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable MechanicalDesignGeometricPresentationRepresentation from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : MechanicalDesignGeometricPresentationRepresentation from StepVisual);
+
+	Share(me; ent : MechanicalDesignGeometricPresentationRepresentation from StepVisual; iter : in out EntityIterator);
+
+end RWMechanicalDesignGeometricPresentationRepresentation;

src/RWStepVisual/RWStepVisual_RWMechanicalDesignGeometricPresentationRepresentation.cxx

@@ -0,0 +1,98 @@
+
+#include <RWStepVisual_RWMechanicalDesignGeometricPresentationRepresentation.ixx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_MechanicalDesignGeometricPresentationRepresentation.hxx>
+
+
+RWStepVisual_RWMechanicalDesignGeometricPresentationRepresentation::RWStepVisual_RWMechanicalDesignGeometricPresentationRepresentation () {}
+
+void RWStepVisual_RWMechanicalDesignGeometricPresentationRepresentation::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_MechanicalDesignGeometricPresentationRepresentation)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"mechanical_design_geometric_presentation_representation")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- inherited field : items ---
+
+	Handle(StepRepr_HArray1OfRepresentationItem) aItems;
+	Handle(StepRepr_RepresentationItem) anent2;
+	Standard_Integer nsub2;
+	if (data->ReadSubList (num,2,"items",ach,nsub2)) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  if (nb2 > 0) aItems = new StepRepr_HArray1OfRepresentationItem (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2, i2,"representation_item", ach,
+				  STANDARD_TYPE(StepRepr_RepresentationItem), anent2))
+	      aItems->SetValue(i2, anent2);
+	  }
+	}
+
+	// --- inherited field : contextOfItems ---
+
+	Handle(StepRepr_RepresentationContext) aContextOfItems;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadEntity(num, 3,"context_of_items", ach, STANDARD_TYPE(StepRepr_RepresentationContext), aContextOfItems);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aItems, aContextOfItems);
+}
+
+
+void RWStepVisual_RWMechanicalDesignGeometricPresentationRepresentation::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_MechanicalDesignGeometricPresentationRepresentation)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- inherited field items ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbItems();  i2 ++) {
+	  SW.Send(ent->ItemsValue(i2));
+	}
+	SW.CloseSub();
+
+	// --- inherited field contextOfItems ---
+
+	SW.Send(ent->ContextOfItems());
+}
+
+
+void RWStepVisual_RWMechanicalDesignGeometricPresentationRepresentation::Share(const Handle(StepVisual_MechanicalDesignGeometricPresentationRepresentation)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbItems();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->ItemsValue(is1));
+	}
+
+
+
+	iter.GetOneItem(ent->ContextOfItems());
+}
+

src/RWStepVisual/RWStepVisual_RWOverRidingStyledItem.cdl

@@ -0,0 +1,30 @@
+-- File:        OverRidingStyledItem.cdl
+-- Created:     Mon Dec  4 12:02:28 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWOverRidingStyledItem from RWStepVisual
+
+	---Purpose : Read & Write Module for OverRidingStyledItem
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     OverRidingStyledItem from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWOverRidingStyledItem;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable OverRidingStyledItem from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : OverRidingStyledItem from StepVisual);
+
+	Share(me; ent : OverRidingStyledItem from StepVisual; iter : in out EntityIterator);
+
+end RWOverRidingStyledItem;

src/RWStepVisual/RWStepVisual_RWOverRidingStyledItem.cxx

@@ -0,0 +1,112 @@
+
+#include <RWStepVisual_RWOverRidingStyledItem.ixx>
+#include <StepVisual_StyledItem.hxx>
+#include <StepVisual_HArray1OfPresentationStyleAssignment.hxx>
+#include <StepVisual_PresentationStyleAssignment.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_OverRidingStyledItem.hxx>
+
+
+RWStepVisual_RWOverRidingStyledItem::RWStepVisual_RWOverRidingStyledItem () {}
+
+void RWStepVisual_RWOverRidingStyledItem::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_OverRidingStyledItem)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,4,ach,"over_riding_styled_item")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- inherited field : styles ---
+
+	Handle(StepVisual_HArray1OfPresentationStyleAssignment) aStyles;
+	Handle(StepVisual_PresentationStyleAssignment) anent2;
+	Standard_Integer nsub2;
+	if (data->ReadSubList (num,2,"styles",ach,nsub2)) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aStyles = new StepVisual_HArray1OfPresentationStyleAssignment (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2, i2,"presentation_style_assignment", ach,
+				  STANDARD_TYPE(StepVisual_PresentationStyleAssignment), anent2))
+	      aStyles->SetValue(i2, anent2);
+	  }
+	}
+
+	// --- inherited field : item ---
+
+	Handle(StepRepr_RepresentationItem) aItem;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItem);
+
+	// --- own field : overRiddenStyle ---
+
+	Handle(StepVisual_StyledItem) aOverRiddenStyle;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat4 =` not needed
+	data->ReadEntity(num, 4,"over_ridden_style", ach, STANDARD_TYPE(StepVisual_StyledItem), aOverRiddenStyle);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aStyles, aItem, aOverRiddenStyle);
+}
+
+
+void RWStepVisual_RWOverRidingStyledItem::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_OverRidingStyledItem)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- inherited field styles ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbStyles();  i2 ++) {
+	  SW.Send(ent->StylesValue(i2));
+	}
+	SW.CloseSub();
+
+	// --- inherited field item ---
+
+	SW.Send(ent->Item());
+
+	// --- own field : overRiddenStyle ---
+
+	SW.Send(ent->OverRiddenStyle());
+}
+
+
+void RWStepVisual_RWOverRidingStyledItem::Share(const Handle(StepVisual_OverRidingStyledItem)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbStyles();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->StylesValue(is1));
+	}
+
+
+
+	iter.GetOneItem(ent->Item());
+
+
+	iter.GetOneItem(ent->OverRiddenStyle());
+}
+

src/RWStepVisual/RWStepVisual_RWPlanarBox.cdl

@@ -0,0 +1,30 @@
+-- File:        PlanarBox.cdl
+-- Created:     Mon Dec  4 12:02:28 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPlanarBox from RWStepVisual
+
+	---Purpose : Read & Write Module for PlanarBox
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PlanarBox from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWPlanarBox;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PlanarBox from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PlanarBox from StepVisual);
+
+	Share(me; ent : PlanarBox from StepVisual; iter : in out EntityIterator);
+
+end RWPlanarBox;

src/RWStepVisual/RWStepVisual_RWPlanarBox.cxx

@@ -0,0 +1,85 @@
+
+#include <RWStepVisual_RWPlanarBox.ixx>
+#include <StepGeom_Axis2Placement.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_PlanarBox.hxx>
+
+
+RWStepVisual_RWPlanarBox::RWStepVisual_RWPlanarBox () {}
+
+void RWStepVisual_RWPlanarBox::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PlanarBox)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,4,ach,"planar_box")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- inherited field : sizeInX ---
+
+	Standard_Real aSizeInX;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadReal (num,2,"size_in_x",ach,aSizeInX);
+
+	// --- inherited field : sizeInY ---
+
+	Standard_Real aSizeInY;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadReal (num,3,"size_in_y",ach,aSizeInY);
+
+	// --- own field : placement ---
+
+	StepGeom_Axis2Placement aPlacement;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat4 =` not needed
+	data->ReadEntity(num,4,"placement",ach,aPlacement);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aSizeInX, aSizeInY, aPlacement);
+}
+
+
+void RWStepVisual_RWPlanarBox::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PlanarBox)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- inherited field sizeInX ---
+
+	SW.Send(ent->SizeInX());
+
+	// --- inherited field sizeInY ---
+
+	SW.Send(ent->SizeInY());
+
+	// --- own field : placement ---
+
+	SW.Send(ent->Placement().Value());
+}
+
+
+void RWStepVisual_RWPlanarBox::Share(const Handle(StepVisual_PlanarBox)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->Placement().Value());
+}
+

src/RWStepVisual/RWStepVisual_RWPlanarExtent.cdl

@@ -0,0 +1,27 @@
+-- File:        PlanarExtent.cdl
+-- Created:     Mon Dec  4 12:02:28 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPlanarExtent from RWStepVisual
+
+	---Purpose : Read & Write Module for PlanarExtent
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PlanarExtent from StepVisual
+
+is
+
+	Create returns RWPlanarExtent;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PlanarExtent from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PlanarExtent from StepVisual);
+
+end RWPlanarExtent;

src/RWStepVisual/RWStepVisual_RWPlanarExtent.cxx

@@ -0,0 +1,60 @@
+
+#include <RWStepVisual_RWPlanarExtent.ixx>
+
+
+RWStepVisual_RWPlanarExtent::RWStepVisual_RWPlanarExtent () {}
+
+void RWStepVisual_RWPlanarExtent::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PlanarExtent)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"planar_extent")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- own field : sizeInX ---
+
+	Standard_Real aSizeInX;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadReal (num,2,"size_in_x",ach,aSizeInX);
+
+	// --- own field : sizeInY ---
+
+	Standard_Real aSizeInY;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadReal (num,3,"size_in_y",ach,aSizeInY);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aSizeInX, aSizeInY);
+}
+
+
+void RWStepVisual_RWPlanarExtent::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PlanarExtent)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- own field : sizeInX ---
+
+	SW.Send(ent->SizeInX());
+
+	// --- own field : sizeInY ---
+
+	SW.Send(ent->SizeInY());
+}

src/RWStepVisual/RWStepVisual_RWPointStyle.cdl

@@ -0,0 +1,30 @@
+-- File:        PointStyle.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPointStyle from RWStepVisual
+
+	---Purpose : Read & Write Module for PointStyle
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PointStyle from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWPointStyle;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PointStyle from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PointStyle from StepVisual);
+
+	Share(me; ent : PointStyle from StepVisual; iter : in out EntityIterator);
+
+end RWPointStyle;

src/RWStepVisual/RWStepVisual_RWPointStyle.cxx

@@ -0,0 +1,87 @@
+
+#include <RWStepVisual_RWPointStyle.ixx>
+#include <StepVisual_MarkerSelect.hxx>
+#include <StepBasic_SizeSelect.hxx>
+#include <StepVisual_Colour.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_PointStyle.hxx>
+
+
+RWStepVisual_RWPointStyle::RWStepVisual_RWPointStyle () {}
+
+void RWStepVisual_RWPointStyle::ReadStep
+(const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepVisual_PointStyle)& ent) const
+{
+  
+  
+  // --- Number of Parameter Control ---
+  
+  if (!data->CheckNbParams(num,4,ach,"point_style")) return;
+  
+  // --- own field : name ---
+  
+  Handle(TCollection_HAsciiString) aName;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+  data->ReadString (num,1,"name",ach,aName);
+  
+  // --- own field : marker ---
+  // idem RWStepVisual_RWBooleanResult
+  
+  StepVisual_MarkerSelect aMarker;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+  data->ReadEntity(num,2,"marker",ach,aMarker);
+  
+  // --- own field : markerSize ---
+  // idem RWStepVisual_RWBooleanResult
+  
+  StepBasic_SizeSelect aMarkerSize;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+  data->ReadEntity(num,3,"marker_size",ach,aMarkerSize);
+  
+  // --- own field : markerColour ---
+  
+  Handle(StepVisual_Colour) aMarkerColour;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat4 =` not needed
+  data->ReadEntity(num, 4,"marker_colour", ach, STANDARD_TYPE(StepVisual_Colour), aMarkerColour);
+  
+  //--- Initialisation of the read entity ---
+  
+  
+  ent->Init(aName, aMarker, aMarkerSize, aMarkerColour);
+}
+
+
+void RWStepVisual_RWPointStyle::WriteStep
+(StepData_StepWriter& SW,
+ const Handle(StepVisual_PointStyle)& ent) const
+{
+  
+  // --- own field : name ---
+  SW.Send(ent->Name());
+  
+  // --- own field : marker ---
+  SW.Send(ent->Marker().Value());
+  
+  // --- own field : markerSize ---
+  SW.Send(ent->MarkerSize().Value());
+  
+  // --- own field : markerColour ---
+  SW.Send(ent->MarkerColour());
+}
+
+
+void RWStepVisual_RWPointStyle::Share(const Handle(StepVisual_PointStyle)& ent, Interface_EntityIterator& iter) const
+{
+  
+  if (ent->Marker().CaseNumber() > 0)
+    iter.GetOneItem(ent->Marker().Value());
+  iter.GetOneItem(ent->MarkerColour());
+}
+

src/RWStepVisual/RWStepVisual_RWPreDefinedColour.cdl

@@ -0,0 +1,27 @@
+-- File:        PreDefinedColour.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPreDefinedColour from RWStepVisual
+
+	---Purpose : Read & Write Module for PreDefinedColour
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PreDefinedColour from StepVisual
+
+is
+
+	Create returns RWPreDefinedColour;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PreDefinedColour from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PreDefinedColour from StepVisual);
+
+end RWPreDefinedColour;

src/RWStepVisual/RWStepVisual_RWPreDefinedColour.cxx

@@ -0,0 +1,41 @@
+//:S4134: abv 03.03.99: implementation of PreDefinedColour modified
+
+#include <RWStepVisual_RWPreDefinedColour.ixx>
+#include <StepVisual_PreDefinedItem.hxx>
+
+RWStepVisual_RWPreDefinedColour::RWStepVisual_RWPreDefinedColour () {}
+
+void RWStepVisual_RWPreDefinedColour::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PreDefinedColour)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"pre_defined_colour")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->GetPreDefinedItem()->Init(aName);
+}
+
+
+void RWStepVisual_RWPreDefinedColour::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PreDefinedColour)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->GetPreDefinedItem()->Name());
+}

src/RWStepVisual/RWStepVisual_RWPreDefinedCurveFont.cdl

@@ -0,0 +1,27 @@
+-- File:        PreDefinedCurveFont.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPreDefinedCurveFont from RWStepVisual
+
+	---Purpose : Read & Write Module for PreDefinedCurveFont
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PreDefinedCurveFont from StepVisual
+
+is
+
+	Create returns RWPreDefinedCurveFont;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PreDefinedCurveFont from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PreDefinedCurveFont from StepVisual);
+
+end RWPreDefinedCurveFont;

src/RWStepVisual/RWStepVisual_RWPreDefinedCurveFont.cxx

@@ -0,0 +1,40 @@
+
+#include <RWStepVisual_RWPreDefinedCurveFont.ixx>
+
+
+RWStepVisual_RWPreDefinedCurveFont::RWStepVisual_RWPreDefinedCurveFont () {}
+
+void RWStepVisual_RWPreDefinedCurveFont::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PreDefinedCurveFont)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"pre_defined_curve_font")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName);
+}
+
+
+void RWStepVisual_RWPreDefinedCurveFont::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PreDefinedCurveFont)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+}

src/RWStepVisual/RWStepVisual_RWPreDefinedItem.cdl

@@ -0,0 +1,27 @@
+-- File:        PreDefinedItem.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPreDefinedItem from RWStepVisual
+
+	---Purpose : Read & Write Module for PreDefinedItem
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PreDefinedItem from StepVisual
+
+is
+
+	Create returns RWPreDefinedItem;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PreDefinedItem from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PreDefinedItem from StepVisual);
+
+end RWPreDefinedItem;

src/RWStepVisual/RWStepVisual_RWPreDefinedItem.cxx

@@ -0,0 +1,40 @@
+
+#include <RWStepVisual_RWPreDefinedItem.ixx>
+
+
+RWStepVisual_RWPreDefinedItem::RWStepVisual_RWPreDefinedItem () {}
+
+void RWStepVisual_RWPreDefinedItem::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PreDefinedItem)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"pre_defined_item")) return;
+
+	// --- own field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName);
+}
+
+
+void RWStepVisual_RWPreDefinedItem::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PreDefinedItem)& ent) const
+{
+
+	// --- own field : name ---
+
+	SW.Send(ent->Name());
+}

src/RWStepVisual/RWStepVisual_RWPresentationArea.cdl

@@ -0,0 +1,30 @@
+-- File:        PresentationArea.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPresentationArea from RWStepVisual
+
+	---Purpose : Read & Write Module for PresentationArea
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PresentationArea from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWPresentationArea;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PresentationArea from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PresentationArea from StepVisual);
+
+	Share(me; ent : PresentationArea from StepVisual; iter : in out EntityIterator);
+
+end RWPresentationArea;

src/RWStepVisual/RWStepVisual_RWPresentationArea.cxx

@@ -0,0 +1,98 @@
+
+#include <RWStepVisual_RWPresentationArea.ixx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_PresentationArea.hxx>
+
+
+RWStepVisual_RWPresentationArea::RWStepVisual_RWPresentationArea () {}
+
+void RWStepVisual_RWPresentationArea::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PresentationArea)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"presentation_area")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- inherited field : items ---
+
+	Handle(StepRepr_HArray1OfRepresentationItem) aItems;
+	Handle(StepRepr_RepresentationItem) anent2;
+	Standard_Integer nsub2;
+	if (data->ReadSubList (num,2,"items",ach,nsub2)) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aItems = new StepRepr_HArray1OfRepresentationItem (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2, i2,"representation_item", ach,
+				  STANDARD_TYPE(StepRepr_RepresentationItem), anent2))
+	      aItems->SetValue(i2, anent2);
+	  }
+	}
+
+	// --- inherited field : contextOfItems ---
+
+	Handle(StepRepr_RepresentationContext) aContextOfItems;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadEntity(num, 3,"context_of_items", ach, STANDARD_TYPE(StepRepr_RepresentationContext), aContextOfItems);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aItems, aContextOfItems);
+}
+
+
+void RWStepVisual_RWPresentationArea::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PresentationArea)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- inherited field items ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbItems();  i2 ++) {
+	  SW.Send(ent->ItemsValue(i2));
+	}
+	SW.CloseSub();
+
+	// --- inherited field contextOfItems ---
+
+	SW.Send(ent->ContextOfItems());
+}
+
+
+void RWStepVisual_RWPresentationArea::Share(const Handle(StepVisual_PresentationArea)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbItems();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->ItemsValue(is1));
+	}
+
+
+
+	iter.GetOneItem(ent->ContextOfItems());
+}
+

src/RWStepVisual/RWStepVisual_RWPresentationLayerAssignment.cdl

@@ -0,0 +1,30 @@
+-- File:        PresentationLayerAssignment.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPresentationLayerAssignment from RWStepVisual
+
+	---Purpose : Read & Write Module for PresentationLayerAssignment
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PresentationLayerAssignment from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWPresentationLayerAssignment;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PresentationLayerAssignment from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PresentationLayerAssignment from StepVisual);
+
+	Share(me; ent : PresentationLayerAssignment from StepVisual; iter : in out EntityIterator);
+
+end RWPresentationLayerAssignment;

src/RWStepVisual/RWStepVisual_RWPresentationLayerAssignment.cxx

@@ -0,0 +1,93 @@
+
+#include <RWStepVisual_RWPresentationLayerAssignment.ixx>
+#include <StepVisual_HArray1OfLayeredItem.hxx>
+#include <StepVisual_LayeredItem.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_PresentationLayerAssignment.hxx>
+
+
+RWStepVisual_RWPresentationLayerAssignment::RWStepVisual_RWPresentationLayerAssignment () {}
+
+void RWStepVisual_RWPresentationLayerAssignment::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PresentationLayerAssignment)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"presentation_layer_assignment")) return;
+
+	// --- own field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- own field : description ---
+
+	Handle(TCollection_HAsciiString) aDescription;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadString (num,2,"description",ach,aDescription);
+
+	// --- own field : assignedItems ---
+
+	Handle(StepVisual_HArray1OfLayeredItem) aAssignedItems;
+	StepVisual_LayeredItem aAssignedItemsItem;
+	Standard_Integer nsub3;
+	if (data->ReadSubList (num,3,"assigned_items",ach,nsub3)) {
+	  Standard_Integer nb3 = data->NbParams(nsub3);
+	  aAssignedItems = new StepVisual_HArray1OfLayeredItem (1, nb3);
+	  for (Standard_Integer i3 = 1; i3 <= nb3; i3 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	    if (data->ReadEntity (nsub3,i3,"assigned_items",ach,aAssignedItemsItem))
+	      aAssignedItems->SetValue(i3,aAssignedItemsItem);
+	  }
+	}
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aDescription, aAssignedItems);
+}
+
+
+void RWStepVisual_RWPresentationLayerAssignment::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PresentationLayerAssignment)& ent) const
+{
+
+	// --- own field : name ---
+
+	SW.Send(ent->Name());
+
+	// --- own field : description ---
+
+	SW.Send(ent->Description());
+
+	// --- own field : assignedItems ---
+
+	SW.OpenSub();
+	for (Standard_Integer i3 = 1;  i3 <= ent->NbAssignedItems();  i3 ++) {
+	  SW.Send(ent->AssignedItemsValue(i3).Value());
+	}
+	SW.CloseSub();
+}
+
+
+void RWStepVisual_RWPresentationLayerAssignment::Share(const Handle(StepVisual_PresentationLayerAssignment)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbAssignedItems();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->AssignedItemsValue(is1).Value());
+	}
+
+}
+

src/RWStepVisual/RWStepVisual_RWPresentationLayerUsage.cdl

@@ -0,0 +1,30 @@
+-- File:        PresentationLayerUsage.cdl
+-- Created:     Mon Dec  4 12:02:28 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPresentationLayerUsage from RWStepVisual
+
+	---Purpose : Read & Write Module for PresentationLayerUsage
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PresentationLayerUsage from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWPresentationLayerUsage;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PresentationLayerUsage from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PresentationLayerUsage from StepVisual);
+
+	Share(me; ent : PresentationLayerUsage from StepVisual; iter : in out EntityIterator);
+
+end RWPresentationLayerUsage;

src/RWStepVisual/RWStepVisual_RWPresentationLayerUsage.cxx

@@ -0,0 +1,61 @@
+
+#include <RWStepVisual_RWPresentationLayerUsage.ixx>
+#include <StepVisual_PresentationLayerAssignment.hxx>
+#include <StepVisual_PresentationRepresentation.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_PresentationLayerUsage.hxx>
+
+
+RWStepVisual_RWPresentationLayerUsage::RWStepVisual_RWPresentationLayerUsage () {}
+
+void RWStepVisual_RWPresentationLayerUsage::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PresentationLayerUsage)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"presentation_layer_usage")) return;
+
+	// --- own fields
+#include <StepVisual_PresentationLayerAssignment.hxx>
+#include <StepVisual_PresentationRepresentation.hxx>
+	Handle(StepVisual_PresentationLayerAssignment) pla;
+	Handle(StepVisual_PresentationRepresentation)  pr;
+
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadEntity(num, 1,"assignment", ach, STANDARD_TYPE(StepVisual_PresentationLayerAssignment), pla);
+	//szv#4:S4163:12Mar99 `stat1 =` not needed
+	data->ReadEntity(num, 2,"presentation", ach, STANDARD_TYPE(StepVisual_PresentationRepresentation), pr);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(pla,pr);
+}
+
+
+void RWStepVisual_RWPresentationLayerUsage::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PresentationLayerUsage)& ent) const
+{
+
+	// --- own field : dimensions ---
+
+	SW.Send(ent->Assignment());
+	SW.Send(ent->Presentation());
+}
+
+
+void RWStepVisual_RWPresentationLayerUsage::Share(const Handle(StepVisual_PresentationLayerUsage)& ent, Interface_EntityIterator& iter) const
+{
+	iter.AddItem(ent->Assignment());
+	iter.AddItem(ent->Presentation());
+}

src/RWStepVisual/RWStepVisual_RWPresentationRepresentation.cdl

@@ -0,0 +1,30 @@
+-- File:        PresentationRepresentation.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPresentationRepresentation from RWStepVisual
+
+	---Purpose : Read & Write Module for PresentationRepresentation
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PresentationRepresentation from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWPresentationRepresentation;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PresentationRepresentation from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PresentationRepresentation from StepVisual);
+
+	Share(me; ent : PresentationRepresentation from StepVisual; iter : in out EntityIterator);
+
+end RWPresentationRepresentation;

src/RWStepVisual/RWStepVisual_RWPresentationRepresentation.cxx

@@ -0,0 +1,98 @@
+
+#include <RWStepVisual_RWPresentationRepresentation.ixx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_PresentationRepresentation.hxx>
+
+
+RWStepVisual_RWPresentationRepresentation::RWStepVisual_RWPresentationRepresentation () {}
+
+void RWStepVisual_RWPresentationRepresentation::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PresentationRepresentation)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"presentation_representation")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- inherited field : items ---
+
+	Handle(StepRepr_HArray1OfRepresentationItem) aItems;
+	Handle(StepRepr_RepresentationItem) anent2;
+	Standard_Integer nsub2;
+	if (data->ReadSubList (num,2,"items",ach,nsub2)) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aItems = new StepRepr_HArray1OfRepresentationItem (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2, i2,"representation_item", ach,
+				  STANDARD_TYPE(StepRepr_RepresentationItem), anent2))
+	      aItems->SetValue(i2, anent2);
+	  }
+	}
+
+	// --- inherited field : contextOfItems ---
+
+	Handle(StepRepr_RepresentationContext) aContextOfItems;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadEntity(num, 3,"context_of_items", ach, STANDARD_TYPE(StepRepr_RepresentationContext), aContextOfItems);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aItems, aContextOfItems);
+}
+
+
+void RWStepVisual_RWPresentationRepresentation::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PresentationRepresentation)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- inherited field items ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbItems();  i2 ++) {
+	  SW.Send(ent->ItemsValue(i2));
+	}
+	SW.CloseSub();
+
+	// --- inherited field contextOfItems ---
+
+	SW.Send(ent->ContextOfItems());
+}
+
+
+void RWStepVisual_RWPresentationRepresentation::Share(const Handle(StepVisual_PresentationRepresentation)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbItems();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->ItemsValue(is1));
+	}
+
+
+
+	iter.GetOneItem(ent->ContextOfItems());
+}
+

src/RWStepVisual/RWStepVisual_RWPresentationSet.cdl

@@ -0,0 +1,27 @@
+-- File:        PresentationSet.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPresentationSet from RWStepVisual
+
+	---Purpose : Read & Write Module for PresentationSet
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PresentationSet from StepVisual
+
+is
+
+	Create returns RWPresentationSet;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PresentationSet from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PresentationSet from StepVisual);
+
+end RWPresentationSet;

src/RWStepVisual/RWStepVisual_RWPresentationSet.cxx

@@ -0,0 +1,27 @@
+
+#include <RWStepVisual_RWPresentationSet.ixx>
+
+
+RWStepVisual_RWPresentationSet::RWStepVisual_RWPresentationSet () {}
+
+void RWStepVisual_RWPresentationSet::ReadStep
+(const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepVisual_PresentationSet)& ent) const
+{
+  
+  
+  // --- Number of Parameter Control ---
+  
+  if (!data->CheckNbParams(num,0,ach,"presentation_set")) return;
+  
+  //--- Initialisation of the read entity ---
+  
+}
+void RWStepVisual_RWPresentationSet::WriteStep
+(StepData_StepWriter& SW,
+ const Handle(StepVisual_PresentationSet)& ent) const
+{
+}
+

src/RWStepVisual/RWStepVisual_RWPresentationSize.cdl

@@ -0,0 +1,30 @@
+-- File:        PresentationSize.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPresentationSize from RWStepVisual
+
+	---Purpose : Read & Write Module for PresentationSize
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PresentationSize from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWPresentationSize;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PresentationSize from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PresentationSize from StepVisual);
+
+	Share(me; ent : PresentationSize from StepVisual; iter : in out EntityIterator);
+
+end RWPresentationSize;

src/RWStepVisual/RWStepVisual_RWPresentationSize.cxx

@@ -0,0 +1,69 @@
+
+#include <RWStepVisual_RWPresentationSize.ixx>
+#include <StepVisual_PresentationSizeAssignmentSelect.hxx>
+#include <StepVisual_PlanarBox.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_PresentationSize.hxx>
+
+
+RWStepVisual_RWPresentationSize::RWStepVisual_RWPresentationSize () {}
+
+void RWStepVisual_RWPresentationSize::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PresentationSize)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"presentation_size")) return;
+
+	// --- own field : unit ---
+
+	StepVisual_PresentationSizeAssignmentSelect aUnit;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadEntity(num,1,"unit",ach,aUnit);
+
+	// --- own field : size ---
+
+	Handle(StepVisual_PlanarBox) aSize;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadEntity(num, 2,"size", ach, STANDARD_TYPE(StepVisual_PlanarBox), aSize);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aUnit, aSize);
+}
+
+
+void RWStepVisual_RWPresentationSize::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PresentationSize)& ent) const
+{
+
+	// --- own field : unit ---
+
+	SW.Send(ent->Unit().Value());
+
+	// --- own field : size ---
+
+	SW.Send(ent->Size());
+}
+
+
+void RWStepVisual_RWPresentationSize::Share(const Handle(StepVisual_PresentationSize)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->Unit().Value());
+
+
+	iter.GetOneItem(ent->Size());
+}
+

src/RWStepVisual/RWStepVisual_RWPresentationStyleAssignment.cdl

@@ -0,0 +1,30 @@
+-- File:        PresentationStyleAssignment.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPresentationStyleAssignment from RWStepVisual
+
+	---Purpose : Read & Write Module for PresentationStyleAssignment
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PresentationStyleAssignment from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWPresentationStyleAssignment;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PresentationStyleAssignment from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PresentationStyleAssignment from StepVisual);
+
+	Share(me; ent : PresentationStyleAssignment from StepVisual; iter : in out EntityIterator);
+
+end RWPresentationStyleAssignment;

src/RWStepVisual/RWStepVisual_RWPresentationStyleAssignment.cxx

@@ -0,0 +1,73 @@
+
+#include <RWStepVisual_RWPresentationStyleAssignment.ixx>
+#include <StepVisual_HArray1OfPresentationStyleSelect.hxx>
+#include <StepVisual_PresentationStyleSelect.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_PresentationStyleAssignment.hxx>
+
+
+RWStepVisual_RWPresentationStyleAssignment::RWStepVisual_RWPresentationStyleAssignment () {}
+
+void RWStepVisual_RWPresentationStyleAssignment::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PresentationStyleAssignment)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"presentation_style_assignment")) return;
+
+	// --- own field : styles ---
+
+	Handle(StepVisual_HArray1OfPresentationStyleSelect) aStyles;
+	StepVisual_PresentationStyleSelect aStylesItem;
+	Standard_Integer nsub1;
+	if (data->ReadSubList (num,1,"styles",ach,nsub1)) {
+	  Standard_Integer nb1 = data->NbParams(nsub1);
+	  aStyles = new StepVisual_HArray1OfPresentationStyleSelect (1, nb1);
+	  for (Standard_Integer i1 = 1; i1 <= nb1; i1 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	    if (data->ReadEntity (nsub1,i1,"styles",ach,aStylesItem))
+	      aStyles->SetValue(i1,aStylesItem);
+	  }
+	}
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aStyles);
+}
+
+
+void RWStepVisual_RWPresentationStyleAssignment::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PresentationStyleAssignment)& ent) const
+{
+
+	// --- own field : styles ---
+
+	SW.OpenSub();
+	for (Standard_Integer i1 = 1;  i1 <= ent->NbStyles();  i1 ++) {
+	  SW.Send(ent->StylesValue(i1).Value());
+	}
+	SW.CloseSub();
+}
+
+
+void RWStepVisual_RWPresentationStyleAssignment::Share(const Handle(StepVisual_PresentationStyleAssignment)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbStyles();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->StylesValue(is1).Value());
+	}
+
+}
+

src/RWStepVisual/RWStepVisual_RWPresentationStyleByContext.cdl

@@ -0,0 +1,30 @@
+-- File:        PresentationStyleByContext.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPresentationStyleByContext from RWStepVisual
+
+	---Purpose : Read & Write Module for PresentationStyleByContext
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PresentationStyleByContext from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWPresentationStyleByContext;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PresentationStyleByContext from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PresentationStyleByContext from StepVisual);
+
+	Share(me; ent : PresentationStyleByContext from StepVisual; iter : in out EntityIterator);
+
+end RWPresentationStyleByContext;

src/RWStepVisual/RWStepVisual_RWPresentationStyleByContext.cxx

@@ -0,0 +1,87 @@
+
+#include <RWStepVisual_RWPresentationStyleByContext.ixx>
+#include <StepVisual_StyleContextSelect.hxx>
+#include <StepVisual_HArray1OfPresentationStyleSelect.hxx>
+#include <StepVisual_PresentationStyleSelect.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_PresentationStyleByContext.hxx>
+
+
+RWStepVisual_RWPresentationStyleByContext::RWStepVisual_RWPresentationStyleByContext () {}
+
+void RWStepVisual_RWPresentationStyleByContext::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PresentationStyleByContext)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"presentation_style_by_context")) return;
+
+	// --- inherited field : styles ---
+
+	Handle(StepVisual_HArray1OfPresentationStyleSelect) aStyles;
+	StepVisual_PresentationStyleSelect aStylesItem;
+	Standard_Integer nsub1;
+	if (data->ReadSubList (num,1,"styles",ach,nsub1)) {
+	  Standard_Integer nb1 = data->NbParams(nsub1);
+	  aStyles = new StepVisual_HArray1OfPresentationStyleSelect (1, nb1);
+	  for (Standard_Integer i1 = 1; i1 <= nb1; i1 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	    if (data->ReadEntity (nsub1,i1,"styles",ach,aStylesItem))
+	      aStyles->SetValue(i1,aStylesItem);
+	  }
+	}
+
+	// --- own field : styleContext ---
+
+	StepVisual_StyleContextSelect aStyleContext;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	data->ReadEntity(num,2,"style_context",ach,aStyleContext);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aStyles, aStyleContext);
+}
+
+
+void RWStepVisual_RWPresentationStyleByContext::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PresentationStyleByContext)& ent) const
+{
+
+	// --- inherited field styles ---
+
+	SW.OpenSub();
+	for (Standard_Integer i1 = 1;  i1 <= ent->NbStyles();  i1 ++) {
+	  SW.Send(ent->StylesValue(i1).Value());
+	}
+	SW.CloseSub();
+
+	// --- own field : styleContext ---
+
+	SW.Send(ent->StyleContext().Value());
+}
+
+
+void RWStepVisual_RWPresentationStyleByContext::Share(const Handle(StepVisual_PresentationStyleByContext)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbStyles();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->StylesValue(is1).Value());
+	}
+
+
+
+	iter.GetOneItem(ent->StyleContext().Value());
+}
+

src/RWStepVisual/RWStepVisual_RWPresentationView.cdl

@@ -0,0 +1,30 @@
+-- File:        PresentationView.cdl
+-- Created:     Mon Dec  4 12:02:29 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPresentationView from RWStepVisual
+
+	---Purpose : Read & Write Module for PresentationView
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PresentationView from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWPresentationView;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PresentationView from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PresentationView from StepVisual);
+
+	Share(me; ent : PresentationView from StepVisual; iter : in out EntityIterator);
+
+end RWPresentationView;

src/RWStepVisual/RWStepVisual_RWPresentationView.cxx

@@ -0,0 +1,98 @@
+
+#include <RWStepVisual_RWPresentationView.ixx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_PresentationView.hxx>
+
+
+RWStepVisual_RWPresentationView::RWStepVisual_RWPresentationView () {}
+
+void RWStepVisual_RWPresentationView::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PresentationView)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"presentation_view has not 3 parameter(s)")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- inherited field : items ---
+
+	Handle(StepRepr_HArray1OfRepresentationItem) aItems;
+	Handle(StepRepr_RepresentationItem) anent2;
+	Standard_Integer nsub2;
+	if (data->ReadSubList (num,2,"items",ach,nsub2)) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aItems = new StepRepr_HArray1OfRepresentationItem (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2, i2,"representation_item", ach,
+				  STANDARD_TYPE(StepRepr_RepresentationItem), anent2))
+	      aItems->SetValue(i2, anent2);
+	  }
+	}
+
+	// --- inherited field : contextOfItems ---
+
+	Handle(StepRepr_RepresentationContext) aContextOfItems;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadEntity(num, 3,"context_of_items", ach, STANDARD_TYPE(StepRepr_RepresentationContext), aContextOfItems);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aItems, aContextOfItems);
+}
+
+
+void RWStepVisual_RWPresentationView::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PresentationView)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- inherited field items ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbItems();  i2 ++) {
+	  SW.Send(ent->ItemsValue(i2));
+	}
+	SW.CloseSub();
+
+	// --- inherited field contextOfItems ---
+
+	SW.Send(ent->ContextOfItems());
+}
+
+
+void RWStepVisual_RWPresentationView::Share(const Handle(StepVisual_PresentationView)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbItems();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->ItemsValue(is1));
+	}
+
+
+
+	iter.GetOneItem(ent->ContextOfItems());
+}
+

src/RWStepVisual/RWStepVisual_RWPresentedItemRepresentation.cdl

@@ -0,0 +1,30 @@
+-- File:        PresentedItemRepresentation.cdl
+-- Created:     Mon Dec  4 12:02:28 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWPresentedItemRepresentation from RWStepVisual
+
+	---Purpose : Read & Write Module for PresentedItemRepresentation
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     PresentedItemRepresentation from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWPresentedItemRepresentation;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable PresentedItemRepresentation from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : PresentedItemRepresentation from StepVisual);
+
+	Share(me; ent : PresentedItemRepresentation from StepVisual; iter : in out EntityIterator);
+
+end RWPresentedItemRepresentation;

src/RWStepVisual/RWStepVisual_RWPresentedItemRepresentation.cxx

@@ -0,0 +1,61 @@
+
+#include <RWStepVisual_RWPresentedItemRepresentation.ixx>
+#include <StepVisual_PresentationRepresentationSelect.hxx>
+#include <StepVisual_PresentedItem.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_PresentedItemRepresentation.hxx>
+
+
+RWStepVisual_RWPresentedItemRepresentation::RWStepVisual_RWPresentedItemRepresentation () {}
+
+void RWStepVisual_RWPresentedItemRepresentation::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_PresentedItemRepresentation)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"presented_item_representation")) return;
+
+	// --- own fields
+
+	StepVisual_PresentationRepresentationSelect prs;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadEntity(num,1,"date_time", ach, prs);
+
+	Handle(StepVisual_PresentedItem) pi;
+	//szv#4:S4163:12Mar99 `stat1 =` not needed
+	data->ReadEntity (num,2,"dated_approval",ach, STANDARD_TYPE(StepVisual_PresentedItem), pi);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(prs,pi);
+}
+
+
+void RWStepVisual_RWPresentedItemRepresentation::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_PresentedItemRepresentation)& ent) const
+{
+
+	// --- own field : dimensions ---
+
+	SW.Send(ent->Presentation().Value());
+	SW.Send(ent->Item());
+}
+
+
+void RWStepVisual_RWPresentedItemRepresentation::Share(const Handle(StepVisual_PresentedItemRepresentation)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->Presentation().Value());
+	iter.GetOneItem(ent->Item());
+}

src/RWStepVisual/RWStepVisual_RWStyledItem.cdl

@@ -0,0 +1,30 @@
+-- File:        StyledItem.cdl
+-- Created:     Mon Dec  4 12:02:31 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWStyledItem from RWStepVisual
+
+	---Purpose : Read & Write Module for StyledItem
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     StyledItem from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWStyledItem;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable StyledItem from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : StyledItem from StepVisual);
+
+	Share(me; ent : StyledItem from StepVisual; iter : in out EntityIterator);
+
+end RWStyledItem;

src/RWStepVisual/RWStepVisual_RWStyledItem.cxx

@@ -0,0 +1,98 @@
+
+#include <RWStepVisual_RWStyledItem.ixx>
+#include <StepVisual_HArray1OfPresentationStyleAssignment.hxx>
+#include <StepVisual_PresentationStyleAssignment.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_StyledItem.hxx>
+
+
+RWStepVisual_RWStyledItem::RWStepVisual_RWStyledItem () {}
+
+void RWStepVisual_RWStyledItem::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_StyledItem)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,3,ach,"styled_item")) return;
+
+	// --- inherited field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- own field : styles ---
+
+	Handle(StepVisual_HArray1OfPresentationStyleAssignment) aStyles;
+	Handle(StepVisual_PresentationStyleAssignment) anent2;
+	Standard_Integer nsub2;
+	if (data->ReadSubList (num,2,"styles",ach,nsub2)) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aStyles = new StepVisual_HArray1OfPresentationStyleAssignment (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2, i2,"presentation_style_assignment", ach,
+				  STANDARD_TYPE(StepVisual_PresentationStyleAssignment), anent2))
+	      aStyles->SetValue(i2, anent2);
+	  }
+	}
+
+	// --- own field : item ---
+
+	Handle(StepRepr_RepresentationItem) aItem;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
+	data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItem);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aStyles, aItem);
+}
+
+
+void RWStepVisual_RWStyledItem::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_StyledItem)& ent) const
+{
+
+	// --- inherited field name ---
+
+	SW.Send(ent->Name());
+
+	// --- own field : styles ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbStyles();  i2 ++) {
+	  SW.Send(ent->StylesValue(i2));
+	}
+	SW.CloseSub();
+
+	// --- own field : item ---
+
+	SW.Send(ent->Item());
+}
+
+
+void RWStepVisual_RWStyledItem::Share(const Handle(StepVisual_StyledItem)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbStyles();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->StylesValue(is1));
+	}
+
+
+
+	iter.GetOneItem(ent->Item());
+}
+

src/RWStepVisual/RWStepVisual_RWSurfaceSideStyle.cdl

@@ -0,0 +1,30 @@
+-- File:        SurfaceSideStyle.cdl
+-- Created:     Mon Dec  4 12:02:31 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWSurfaceSideStyle from RWStepVisual
+
+	---Purpose : Read & Write Module for SurfaceSideStyle
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     SurfaceSideStyle from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWSurfaceSideStyle;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable SurfaceSideStyle from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : SurfaceSideStyle from StepVisual);
+
+	Share(me; ent : SurfaceSideStyle from StepVisual; iter : in out EntityIterator);
+
+end RWSurfaceSideStyle;

src/RWStepVisual/RWStepVisual_RWSurfaceSideStyle.cxx

@@ -0,0 +1,83 @@
+
+#include <RWStepVisual_RWSurfaceSideStyle.ixx>
+#include <StepVisual_HArray1OfSurfaceStyleElementSelect.hxx>
+#include <StepVisual_SurfaceStyleElementSelect.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_SurfaceSideStyle.hxx>
+
+
+RWStepVisual_RWSurfaceSideStyle::RWStepVisual_RWSurfaceSideStyle () {}
+
+void RWStepVisual_RWSurfaceSideStyle::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_SurfaceSideStyle)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,2,ach,"surface_side_style")) return;
+
+	// --- own field : name ---
+
+	Handle(TCollection_HAsciiString) aName;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadString (num,1,"name",ach,aName);
+
+	// --- own field : styles ---
+
+	Handle(StepVisual_HArray1OfSurfaceStyleElementSelect) aStyles;
+	StepVisual_SurfaceStyleElementSelect aStylesItem;
+	Standard_Integer nsub2;
+	if (data->ReadSubList (num,2,"styles",ach,nsub2)) {
+	  Standard_Integer nb2 = data->NbParams(nsub2);
+	  aStyles = new StepVisual_HArray1OfSurfaceStyleElementSelect (1, nb2);
+	  for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+	    //szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
+	    if (data->ReadEntity (nsub2,i2,"styles",ach,aStylesItem))
+	      aStyles->SetValue(i2,aStylesItem);
+	  }
+	}
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aName, aStyles);
+}
+
+
+void RWStepVisual_RWSurfaceSideStyle::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_SurfaceSideStyle)& ent) const
+{
+
+	// --- own field : name ---
+
+	SW.Send(ent->Name());
+
+	// --- own field : styles ---
+
+	SW.OpenSub();
+	for (Standard_Integer i2 = 1;  i2 <= ent->NbStyles();  i2 ++) {
+	  SW.Send(ent->StylesValue(i2).Value());
+	}
+	SW.CloseSub();
+}
+
+
+void RWStepVisual_RWSurfaceSideStyle::Share(const Handle(StepVisual_SurfaceSideStyle)& ent, Interface_EntityIterator& iter) const
+{
+
+	Standard_Integer nbElem1 = ent->NbStyles();
+	for (Standard_Integer is1=1; is1<=nbElem1; is1 ++) {
+	  iter.GetOneItem(ent->StylesValue(is1).Value());
+	}
+
+}
+

src/RWStepVisual/RWStepVisual_RWSurfaceStyleBoundary.cdl

@@ -0,0 +1,30 @@
+-- File:        SurfaceStyleBoundary.cdl
+-- Created:     Mon Dec  4 12:02:31 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWSurfaceStyleBoundary from RWStepVisual
+
+	---Purpose : Read & Write Module for SurfaceStyleBoundary
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     SurfaceStyleBoundary from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWSurfaceStyleBoundary;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable SurfaceStyleBoundary from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : SurfaceStyleBoundary from StepVisual);
+
+	Share(me; ent : SurfaceStyleBoundary from StepVisual; iter : in out EntityIterator);
+
+end RWSurfaceStyleBoundary;

src/RWStepVisual/RWStepVisual_RWSurfaceStyleBoundary.cxx

@@ -0,0 +1,55 @@
+
+#include <RWStepVisual_RWSurfaceStyleBoundary.ixx>
+#include <StepVisual_CurveStyle.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_SurfaceStyleBoundary.hxx>
+
+
+RWStepVisual_RWSurfaceStyleBoundary::RWStepVisual_RWSurfaceStyleBoundary () {}
+
+void RWStepVisual_RWSurfaceStyleBoundary::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_SurfaceStyleBoundary)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"surface_style_boundary")) return;
+
+	// --- own field : styleOfBoundary ---
+
+	Handle(StepVisual_CurveStyle) aStyleOfBoundary;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadEntity(num, 1,"style_of_boundary", ach, STANDARD_TYPE(StepVisual_CurveStyle), aStyleOfBoundary);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aStyleOfBoundary);
+}
+
+
+void RWStepVisual_RWSurfaceStyleBoundary::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_SurfaceStyleBoundary)& ent) const
+{
+
+	// --- own field : styleOfBoundary ---
+
+	SW.Send(ent->StyleOfBoundary());
+}
+
+
+void RWStepVisual_RWSurfaceStyleBoundary::Share(const Handle(StepVisual_SurfaceStyleBoundary)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->StyleOfBoundary());
+}
+

src/RWStepVisual/RWStepVisual_RWSurfaceStyleControlGrid.cdl

@@ -0,0 +1,30 @@
+-- File:        SurfaceStyleControlGrid.cdl
+-- Created:     Mon Dec  4 12:02:31 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWSurfaceStyleControlGrid from RWStepVisual
+
+	---Purpose : Read & Write Module for SurfaceStyleControlGrid
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     SurfaceStyleControlGrid from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWSurfaceStyleControlGrid;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable SurfaceStyleControlGrid from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : SurfaceStyleControlGrid from StepVisual);
+
+	Share(me; ent : SurfaceStyleControlGrid from StepVisual; iter : in out EntityIterator);
+
+end RWSurfaceStyleControlGrid;

src/RWStepVisual/RWStepVisual_RWSurfaceStyleControlGrid.cxx

@@ -0,0 +1,55 @@
+
+#include <RWStepVisual_RWSurfaceStyleControlGrid.ixx>
+#include <StepVisual_CurveStyle.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_SurfaceStyleControlGrid.hxx>
+
+
+RWStepVisual_RWSurfaceStyleControlGrid::RWStepVisual_RWSurfaceStyleControlGrid () {}
+
+void RWStepVisual_RWSurfaceStyleControlGrid::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_SurfaceStyleControlGrid)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"surface_style_control_grid")) return;
+
+	// --- own field : styleOfControlGrid ---
+
+	Handle(StepVisual_CurveStyle) aStyleOfControlGrid;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadEntity(num, 1,"style_of_control_grid", ach, STANDARD_TYPE(StepVisual_CurveStyle), aStyleOfControlGrid);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aStyleOfControlGrid);
+}
+
+
+void RWStepVisual_RWSurfaceStyleControlGrid::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_SurfaceStyleControlGrid)& ent) const
+{
+
+	// --- own field : styleOfControlGrid ---
+
+	SW.Send(ent->StyleOfControlGrid());
+}
+
+
+void RWStepVisual_RWSurfaceStyleControlGrid::Share(const Handle(StepVisual_SurfaceStyleControlGrid)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->StyleOfControlGrid());
+}
+

src/RWStepVisual/RWStepVisual_RWSurfaceStyleFillArea.cdl

@@ -0,0 +1,30 @@
+-- File:        SurfaceStyleFillArea.cdl
+-- Created:     Mon Dec  4 12:02:31 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWSurfaceStyleFillArea from RWStepVisual
+
+	---Purpose : Read & Write Module for SurfaceStyleFillArea
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     SurfaceStyleFillArea from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWSurfaceStyleFillArea;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable SurfaceStyleFillArea from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : SurfaceStyleFillArea from StepVisual);
+
+	Share(me; ent : SurfaceStyleFillArea from StepVisual; iter : in out EntityIterator);
+
+end RWSurfaceStyleFillArea;

src/RWStepVisual/RWStepVisual_RWSurfaceStyleFillArea.cxx

@@ -0,0 +1,55 @@
+
+#include <RWStepVisual_RWSurfaceStyleFillArea.ixx>
+#include <StepVisual_FillAreaStyle.hxx>
+
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_SurfaceStyleFillArea.hxx>
+
+
+RWStepVisual_RWSurfaceStyleFillArea::RWStepVisual_RWSurfaceStyleFillArea () {}
+
+void RWStepVisual_RWSurfaceStyleFillArea::ReadStep
+	(const Handle(StepData_StepReaderData)& data,
+	 const Standard_Integer num,
+	 Handle(Interface_Check)& ach,
+	 const Handle(StepVisual_SurfaceStyleFillArea)& ent) const
+{
+
+
+	// --- Number of Parameter Control ---
+
+	if (!data->CheckNbParams(num,1,ach,"surface_style_fill_area")) return;
+
+	// --- own field : fillArea ---
+
+	Handle(StepVisual_FillAreaStyle) aFillArea;
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	data->ReadEntity(num, 1,"fill_area", ach, STANDARD_TYPE(StepVisual_FillAreaStyle), aFillArea);
+
+	//--- Initialisation of the read entity ---
+
+
+	ent->Init(aFillArea);
+}
+
+
+void RWStepVisual_RWSurfaceStyleFillArea::WriteStep
+	(StepData_StepWriter& SW,
+	 const Handle(StepVisual_SurfaceStyleFillArea)& ent) const
+{
+
+	// --- own field : fillArea ---
+
+	SW.Send(ent->FillArea());
+}
+
+
+void RWStepVisual_RWSurfaceStyleFillArea::Share(const Handle(StepVisual_SurfaceStyleFillArea)& ent, Interface_EntityIterator& iter) const
+{
+
+	iter.GetOneItem(ent->FillArea());
+}
+

src/RWStepVisual/RWStepVisual_RWSurfaceStyleParameterLine.cdl

@@ -0,0 +1,30 @@
+-- File:        SurfaceStyleParameterLine.cdl
+-- Created:     Mon Dec  4 12:02:31 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWSurfaceStyleParameterLine from RWStepVisual
+
+	---Purpose : Read & Write Module for SurfaceStyleParameterLine
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     SurfaceStyleParameterLine from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWSurfaceStyleParameterLine;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable SurfaceStyleParameterLine from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : SurfaceStyleParameterLine from StepVisual);
+
+	Share(me; ent : SurfaceStyleParameterLine from StepVisual; iter : in out EntityIterator);
+
+end RWSurfaceStyleParameterLine;

src/RWStepVisual/RWStepVisual_RWSurfaceStyleParameterLine.cxx

@@ -0,0 +1,108 @@
+
+#include <RWStepVisual_RWSurfaceStyleParameterLine.ixx>
+#include <StepVisual_CurveStyle.hxx>
+#include <Standard_Integer.hxx>
+
+#include <StepVisual_HArray1OfDirectionCountSelect.hxx>
+
+#include <Interface_EntityIterator.hxx>
+
+
+#include <StepVisual_SurfaceStyleParameterLine.hxx>
+
+
+RWStepVisual_RWSurfaceStyleParameterLine::RWStepVisual_RWSurfaceStyleParameterLine () {}
+
+void RWStepVisual_RWSurfaceStyleParameterLine::ReadStep
+(const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepVisual_SurfaceStyleParameterLine)& ent) const
+{
+  
+  
+  // --- Number of Parameter Control ---
+  
+  if (!data->CheckNbParams(num,2,ach,"surface_style_parameter_line")) return;
+  
+  // --- own field : styleOfParameterLines ---
+  
+  Handle(StepVisual_CurveStyle) aStyleOfParameterLines;
+  //szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+  data->ReadEntity(num, 1,"style_of_parameter_lines", ach, STANDARD_TYPE(StepVisual_CurveStyle), aStyleOfParameterLines);
+  
+  // --- own field : directionCounts ---
+  // DirectionCount : select de UDirectionCount et VDirectionCount qui sont
+  //                  des type INTEGER;
+  // Par consequent, on doit trouver dans le fichier :
+  //     ... , (U_DIRECTION_COUNT(10), V_DIRECTION_COUNT(1)) );
+
+  Standard_Integer numr, numpr;
+  TCollection_AsciiString UType("U_DIRECTION_COUNT");
+  TCollection_AsciiString VType("V_DIRECTION_COUNT");
+  TCollection_AsciiString TrueType;
+
+  Handle(StepVisual_HArray1OfDirectionCountSelect) aDirectionCounts;
+  Standard_Integer aDirectionCountsItem;
+  StepVisual_DirectionCountSelect aDirectionCountSelect;
+
+  Standard_Integer nsub2;
+  if (data->ReadSubList (num,2,"direction_counts",ach,nsub2)) {
+    Standard_Integer nb2 = data->NbParams(nsub2);
+    aDirectionCounts = new StepVisual_HArray1OfDirectionCountSelect(1, nb2);
+    for (Standard_Integer i2 = 1; i2 <= nb2; i2 ++) {
+      // looks for true type :
+      //szv#4:S4163:12Mar99 `Standard_Boolean statUV =` not needed
+      if (data->ReadTypedParam(nsub2,i2,Standard_True,"direction_count", ach,numr,numpr,TrueType)) {
+	//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
+	if (data->ReadInteger (numr,numpr,"direction_counts",ach,aDirectionCountsItem)) {
+	  if (TrueType == UType) {
+	    aDirectionCountSelect.SetUDirectionCount(aDirectionCountsItem);
+	    aDirectionCounts->SetValue(i2,aDirectionCountSelect);
+	  }
+	  else if (TrueType == VType) {
+	    aDirectionCountSelect.SetVDirectionCount(aDirectionCountsItem);
+	    aDirectionCounts->SetValue(i2,aDirectionCountSelect);
+	  }
+	  else {
+	    ach->AddFail("Parameter #2 (direction_counts) item has illegal TYPE");
+	  }
+	}
+	else {
+	  ach->AddFail("Parameter #2 (direction_counts) item is not an INTEGER");
+	}
+      }
+      else {
+	ach->AddFail("Parameter #2 (direction_counts) item is not TYPED");
+      }
+    }
+  }
+  
+  //--- Initialisation of the read entity ---
+  
+  ent->Init(aStyleOfParameterLines, aDirectionCounts);
+}
+
+
+void RWStepVisual_RWSurfaceStyleParameterLine::WriteStep
+(StepData_StepWriter& SW,
+ const Handle(StepVisual_SurfaceStyleParameterLine)& ent) const
+{
+  
+  // --- own field : styleOfParameterLines ---
+  
+  SW.Send(ent->StyleOfParameterLines());
+  
+  // --- own field : directionCounts ---
+  // Attention : a modifier avant utilisation
+
+  SW.Send(ent->DirectionCounts());
+}
+
+
+void RWStepVisual_RWSurfaceStyleParameterLine::Share(const Handle(StepVisual_SurfaceStyleParameterLine)& ent, Interface_EntityIterator& iter) const
+{
+  
+  iter.GetOneItem(ent->StyleOfParameterLines());
+}
+

src/RWStepVisual/RWStepVisual_RWSurfaceStyleSegmentationCurve.cdl

@@ -0,0 +1,30 @@
+-- File:        SurfaceStyleSegmentationCurve.cdl
+-- Created:     Mon Dec  4 12:02:32 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+class RWSurfaceStyleSegmentationCurve from RWStepVisual
+
+	---Purpose : Read & Write Module for SurfaceStyleSegmentationCurve
+
+uses Check from Interface,
+     StepReaderData from StepData,
+     StepWriter from StepData,
+     SurfaceStyleSegmentationCurve from StepVisual,
+     EntityIterator from Interface
+
+is
+
+	Create returns RWSurfaceStyleSegmentationCurve;
+
+	ReadStep (me; data : StepReaderData; num : Integer;
+	              ach : in out Check; ent : mutable SurfaceStyleSegmentationCurve from StepVisual);
+
+	WriteStep (me; SW : in out StepWriter; ent : SurfaceStyleSegmentationCurve from StepVisual);
+
+	Share(me; ent : SurfaceStyleSegmentationCurve from StepVisual; iter : in out EntityIterator);
+
+end RWSurfaceStyleSegmentationCurve;