[occt.git] / src / IGESDimen / IGESDimen_ToolGeneralNote.cxx

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

//--------------------------------------------------------------------
//--------------------------------------------------------------------

#include <gp_Pnt.hxx>
#include <gp_XYZ.hxx>
#include <IGESData_DirChecker.hxx>
#include <IGESData_Dump.hxx>
#include <IGESData_IGESDumper.hxx>
#include <IGESData_IGESReaderData.hxx>
#include <IGESData_IGESWriter.hxx>
#include <IGESData_ParamCursor.hxx>
#include <IGESData_ParamReader.hxx>
#include <IGESDimen_GeneralNote.hxx>
#include <IGESDimen_ToolGeneralNote.hxx>
#include <IGESGraph_HArray1OfTextFontDef.hxx>
#include <IGESGraph_TextFontDef.hxx>
#include <Interface_Check.hxx>
#include <Interface_CopyTool.hxx>
#include <Interface_EntityIterator.hxx>
#include <Interface_HArray1OfHAsciiString.hxx>
#include <Interface_Macros.hxx>
#include <Interface_ShareTool.hxx>
#include <Message_Messenger.hxx>
#include <Standard_DomainError.hxx>
#include <TColgp_HArray1OfXYZ.hxx>
#include <TCollection_HAsciiString.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>

#include <stdio.h>
IGESDimen_ToolGeneralNote::IGESDimen_ToolGeneralNote ()    {  }


void  IGESDimen_ToolGeneralNote::ReadOwnParams
  (const Handle(IGESDimen_GeneralNote)& ent,
   const Handle(IGESData_IGESReaderData)& IR, IGESData_ParamReader& PR) const
{ 
  //Standard_Boolean st; //szv#4:S4163:12Mar99 moved down

  Standard_Integer nbval;
  Handle(TColStd_HArray1OfInteger) nbChars;
  Handle(TColStd_HArray1OfReal) boxWidths; 
  Handle(TColStd_HArray1OfReal) boxHeights;
  Handle(TColStd_HArray1OfInteger) fontCodes; 
  Handle(IGESGraph_HArray1OfTextFontDef) fontEntities;
  Handle(TColStd_HArray1OfReal) slantAngles; 
  Handle(TColStd_HArray1OfReal) rotationAngles;
  Handle(TColStd_HArray1OfInteger) mirrorFlags; 
  Handle(TColStd_HArray1OfInteger) rotateFlags;
  Handle(TColgp_HArray1OfXYZ) startPoints; 
  Handle(Interface_HArray1OfHAsciiString) texts; 

  Standard_Boolean st = PR.ReadInteger(PR.Current(), "Number of Text Strings", nbval);
  if (st && nbval > 0) {
    nbChars        = new TColStd_HArray1OfInteger(1, nbval);
    boxWidths      = new TColStd_HArray1OfReal(1, nbval);
    boxHeights     = new TColStd_HArray1OfReal(1, nbval);
    fontCodes      = new TColStd_HArray1OfInteger(1, nbval);
    fontEntities   = new IGESGraph_HArray1OfTextFontDef(1, nbval);
    slantAngles    = new TColStd_HArray1OfReal(1, nbval);
    rotationAngles = new TColStd_HArray1OfReal(1, nbval);
    mirrorFlags    = new TColStd_HArray1OfInteger(1, nbval);
    rotateFlags    = new TColStd_HArray1OfInteger(1, nbval);
    startPoints    = new TColgp_HArray1OfXYZ(1, nbval);
    texts          = new Interface_HArray1OfHAsciiString(1, nbval);
  }
  else  PR.AddFail("Number of Text Strings: Not Positive");


  if (! nbChars.IsNull())
    {
      for (Standard_Integer i = 1; i <= nbval; i++)
	{
          Standard_Integer nbChar;
          Standard_Real boxWidth;
          Standard_Real boxHeight;
          Standard_Integer fontCode;
          Handle(IGESGraph_TextFontDef) fontEntity;
          Standard_Real slantAngle;
          Standard_Real rotationAngle;
          Standard_Integer mirrorFlag;
          Standard_Integer rotateFlag;
          gp_XYZ startPoint;
          Handle(TCollection_HAsciiString) text;

          //st = PR.ReadInteger(PR.Current(), "Number of Characters", nbChar); //szv#4:S4163:12Mar99 moved in if
	  if (PR.ReadInteger(PR.Current(), "Number of Characters", nbChar))
	    nbChars->SetValue(i, nbChar);

          //st = PR.ReadReal(PR.Current(), "Box Width", boxWidth); //szv#4:S4163:12Mar99 moved in if
	  if (PR.ReadReal(PR.Current(), "Box Width", boxWidth))
	    boxWidths->SetValue(i, boxWidth);

          //st = PR.ReadReal(PR.Current(), "Box Height", boxHeight); //szv#4:S4163:12Mar99 moved in if
	  if (PR.ReadReal(PR.Current(), "Box Height", boxHeight))
	    boxHeights->SetValue(i, boxHeight);

	  Standard_Integer curnum = PR.CurrentNumber();
	  if (PR.DefinedElseSkip())
	    {
	      // Reading fontCode(Integer, must be positive)
	      PR.ReadInteger (PR.Current(), "Font Code", fontCode); //szv#4:S4163:12Mar99 `st=` not needed
	      // Reading fontEnt(TextFontDef) ?
	      if (fontCode < 0) {
		fontEntity = GetCasted(IGESGraph_TextFontDef,PR.ParamEntity (IR,curnum));
		if (fontEntity.IsNull()) PR.AddFail ("Font Entity : incorrect reference");
		fontEntities->SetValue(i, fontEntity);
		fontCodes->SetValue(i, -1);
	      }
	      else fontCodes->SetValue(i, fontCode);
	    }
          else
	    {
              fontCodes->SetValue(i, 1);
	    }

          if (PR.DefinedElseSkip())
	    {
              //st = PR.ReadReal(PR.Current(), "Slant Angle", slantAngle); //szv#4:S4163:12Mar99 moved in if
	      if (PR.ReadReal(PR.Current(), "Slant Angle", slantAngle))
		slantAngles->SetValue(i, slantAngle);
	    }
          else
              slantAngles->SetValue(i, M_PI/2);

          //st = PR.ReadReal(PR.Current(), "Rotation Angle", rotationAngle); //szv#4:S4163:12Mar99 moved in if
	  if (PR.ReadReal(PR.Current(), "Rotation Angle", rotationAngle))
	    rotationAngles->SetValue(i, rotationAngle);

          //st = PR.ReadInteger(PR.Current(), "Mirror Flag", mirrorFlag); //szv#4:S4163:12Mar99 moved in if
	  if (PR.ReadInteger(PR.Current(), "Mirror Flag", mirrorFlag))
	    mirrorFlags->SetValue(i, mirrorFlag);

          //st = PR.ReadInteger(PR.Current(), "Rotate Flag", rotateFlag); //szv#4:S4163:12Mar99 moved in if
	  if (PR.ReadInteger(PR.Current(), "Rotate Flag", rotateFlag))
	    rotateFlags->SetValue(i, rotateFlag);

          //st = PR.ReadXYZ(PR.CurrentList(1, 3), "Start Point", startPoint); //szv#4:S4163:12Mar99 moved in if
	  if (PR.ReadXYZ(PR.CurrentList(1, 3), "Start Point", startPoint))
	    startPoints->SetValue(i, startPoint);

          //st = PR.ReadText(PR.Current(), "Text String", text); //szv#4:S4163:12Mar99 moved in if
	  if (PR.ReadText(PR.Current(), "Text String", text))
	    texts->SetValue(i, text);
	}
    }
  //sln 28.09.2001, BUC61004, If the condition is false function ent->Init is not called in order to avoid exception
  if(!(nbChars.IsNull() || boxWidths.IsNull() || boxHeights.IsNull() || fontCodes.IsNull() || 
       fontEntities.IsNull() ||  slantAngles.IsNull() || rotationAngles.IsNull() || 
       mirrorFlags.IsNull() || rotateFlags.IsNull() || startPoints.IsNull() || texts.IsNull()))
    {
      DirChecker(ent).CheckTypeAndForm(PR.CCheck(),ent);
      ent->Init
        (nbChars, boxWidths, boxHeights, fontCodes, fontEntities,
         slantAngles, rotationAngles, mirrorFlags, rotateFlags,
         startPoints, texts);
    }
}

void  IGESDimen_ToolGeneralNote::WriteOwnParams
  (const Handle(IGESDimen_GeneralNote)& ent, IGESData_IGESWriter& IW) const 
{ 
  Standard_Integer nbval = ent->NbStrings();
  IW.Send(nbval);

  for (Standard_Integer i = 1; i <= nbval; i++)
    {
      IW.Send(ent->NbCharacters(i));
      IW.Send(ent->BoxWidth(i));
      IW.Send(ent->BoxHeight(i));
      if (ent->IsFontEntity(i))
	IW.Send(ent->FontEntity(i),Standard_True);  // negative
      else
	IW.Send(ent->FontCode(i));
      IW.Send(ent->SlantAngle(i));
      IW.Send(ent->RotationAngle(i));
      IW.Send(ent->MirrorFlag(i));
      IW.Send(ent->RotateFlag(i));
      IW.Send((ent->StartPoint(i)).X());
      IW.Send((ent->StartPoint(i)).Y());
      IW.Send((ent->StartPoint(i)).Z());
      IW.Send(ent->Text(i));
    }
}

void  IGESDimen_ToolGeneralNote::OwnShared
  (const Handle(IGESDimen_GeneralNote)& ent, Interface_EntityIterator& iter) const
{
  Standard_Integer nbval = ent->NbStrings();
  for (Standard_Integer i = 1; i <= nbval; i++) {
    if (ent->IsFontEntity(i))
      iter.GetOneItem(ent->FontEntity(i));
  }
}

void  IGESDimen_ToolGeneralNote::OwnCopy
  (const Handle(IGESDimen_GeneralNote)& another,
   const Handle(IGESDimen_GeneralNote)& ent, Interface_CopyTool& TC) const
{
  Standard_Integer nbval = another->NbStrings();

  Handle(TColStd_HArray1OfInteger) nbChars;
  Handle(TColStd_HArray1OfReal) boxWidths; 
  Handle(TColStd_HArray1OfReal) boxHeights;
  Handle(TColStd_HArray1OfInteger) fontCodes; 
  Handle(IGESGraph_HArray1OfTextFontDef) fontEntities;
  Handle(TColStd_HArray1OfReal) slantAngles; 
  Handle(TColStd_HArray1OfReal) rotationAngles;
  Handle(TColStd_HArray1OfInteger) mirrorFlags; 
  Handle(TColStd_HArray1OfInteger) rotateFlags;
  Handle(TColgp_HArray1OfXYZ) startPoints; 
  Handle(Interface_HArray1OfHAsciiString) texts; 

  nbChars        = new TColStd_HArray1OfInteger(1, nbval);
  boxWidths      = new TColStd_HArray1OfReal   (1, nbval);
  boxHeights     = new TColStd_HArray1OfReal   (1, nbval);
  fontCodes      = new TColStd_HArray1OfInteger(1, nbval);
  fontEntities   = new IGESGraph_HArray1OfTextFontDef(1, nbval);
  slantAngles    = new TColStd_HArray1OfReal   (1, nbval);
  rotationAngles = new TColStd_HArray1OfReal   (1, nbval);
  mirrorFlags    = new TColStd_HArray1OfInteger(1, nbval);
  rotateFlags    = new TColStd_HArray1OfInteger(1, nbval);
  startPoints    = new TColgp_HArray1OfXYZ     (1, nbval);
  texts          = new Interface_HArray1OfHAsciiString(1, nbval);

  for (Standard_Integer i = 1; i <= nbval; i++)
    {
      Standard_Integer nbChar = another->NbCharacters(i);
      nbChars->SetValue(i, nbChar);
      Standard_Real boxWidth = another->BoxWidth(i);
      boxWidths->SetValue(i, boxWidth);
      Standard_Real boxHeight = another->BoxHeight(i);
      boxHeights->SetValue(i, boxHeight);

      if (another->IsFontEntity(i))
	{
          DeclareAndCast(IGESGraph_TextFontDef, fontEntity, 
			 TC.Transferred(another->FontEntity(i)));
          fontEntities->SetValue(i, fontEntity);
          fontCodes->SetValue(i, -1);
	}
      else
	{
          Standard_Integer fontCode = another->FontCode(i);
          fontCodes->SetValue(i, fontCode);
////          fontEntities->SetValue(i, NULL);    par defaut
	}

      Standard_Real slantAngle = another->SlantAngle(i);
      slantAngles->SetValue(i, slantAngle);
      Standard_Real rotationAngle = another->RotationAngle(i);
      rotationAngles->SetValue(i, rotationAngle);
      Standard_Integer mirrorFlag = another->MirrorFlag(i);
      mirrorFlags->SetValue(i, mirrorFlag);
      Standard_Integer rotateFlag = another->RotateFlag(i);
      rotateFlags->SetValue(i, rotateFlag);
      gp_XYZ startPoint = (another->StartPoint(i)).XYZ();
      startPoints->SetValue(i, startPoint);
      Handle(TCollection_HAsciiString) text =
	new TCollection_HAsciiString(another->Text(i));
      texts->SetValue(i, text);
    }

  ent->Init(nbChars, boxWidths, boxHeights, fontCodes, fontEntities,
	    slantAngles, rotationAngles, mirrorFlags, rotateFlags,
	    startPoints, texts);
  ent->SetFormNumber(another->FormNumber());
}

IGESData_DirChecker  IGESDimen_ToolGeneralNote::DirChecker
  (const Handle(IGESDimen_GeneralNote)& /* ent */ ) const 
{ 
  IGESData_DirChecker DC (212, 0, 105);
  DC.Structure(IGESData_DefVoid);
  DC.LineFont(IGESData_DefValue);
  DC.LineWeight(IGESData_DefValue);
  DC.Color(IGESData_DefAny);
  DC.UseFlagRequired(1);
  DC.HierarchyStatusIgnored();
  return DC;
}

void  IGESDimen_ToolGeneralNote::OwnCheck
  (const Handle(IGESDimen_GeneralNote)& ent,
   const Interface_ShareTool& , Handle(Interface_Check)& ach) const 
{
  if (((ent->FormNumber() <   0) || (ent->FormNumber() >   8)) &&
      ((ent->FormNumber() < 100) || (ent->FormNumber() > 102)) &&
      (ent->FormNumber() != 105))
    ach->AddFail("Form Number: Not Valid");

  Standard_Integer upper = ent->NbStrings();
  for (Standard_Integer i = 1; i <= upper; i++)
    {
      if (ent->NbCharacters(i) != ent->Text(i)->Length())
	{
	  char mess[80];
	  sprintf(mess,"%d : Number of Characters != Length of Text String",i);
          ach->AddFail(mess);
	}
      Standard_Integer mflag = ent->MirrorFlag(i);
      if ((mflag < 0) || (mflag > 2))
	{
	  char mess[80];
	  sprintf(mess, "%d : Mirror flag != 0, 1, 2",i);
          ach->AddFail(mess);
	}
      Standard_Integer rflag = ent->RotateFlag(i);
      if ((rflag < 0) || (rflag > 1))
	{
	  char mess[80];
	  sprintf(mess, "%d : Rotate flag != 0, 1",i);
          ach->AddFail(mess);
	}
    }
}

void  IGESDimen_ToolGeneralNote::OwnDump
  (const Handle(IGESDimen_GeneralNote)& ent, const IGESData_IGESDumper& dumper,
   Standard_OStream& S, const Standard_Integer level) const 
{ 
  Standard_Integer sublevel = (level > 4) ? 1 : 0;
  Standard_Integer upper = ent->NbStrings();

  S << "IGESDimen_GeneralNote\n"
    << "Number of Text Strings : " << upper << "\n"
    << "Number of Characters :\n"
    << "Box Widths :\n"
    << "Box Heights :\n"
    << "Font Codes :\n"
    << "Font Entities :\n"
    << "Slant Angles :\n"
    << "Rotation Angles :\n"
    << "Mirror Flags :\n"
    << "Rotate Flags :\n"
    << "Start Points :\n"
    << "Texts : ";
  IGESData_DumpVals(S,-level,1, ent->NbStrings(),ent->NbCharacters);
  S << "\n";
  if (level > 4)
    {
      S << "Details of each String\n";
      for ( Standard_Integer i = 1; i <= upper; i++)
	{
          S << "[" << i << "]:\n"
            << "Number of Characters : " << ent->NbCharacters(i) << "  "
            << "Box Width  : " << ent->BoxWidth(i)  << "  "
            << "Box Height : " << ent->BoxHeight(i) << "\n";
          if (ent->IsFontEntity(i))
	    {
              S << "Font Entity : ";
              dumper.Dump (ent->FontEntity(i),S, sublevel);
              S << "\n";
	    }
          else
	    S << "Font Code : " << ent->FontCode(i) << "\n"
          << "Slant Angle : " << ent->SlantAngle(i) << "  "
          << "Rotation Angle : " << ent->RotationAngle(i) << "  "
          << "Mirror Flag : " << ent->MirrorFlag(i) << "  "
          << "Rotate Flag : " << ent->RotateFlag(i) << "\n"
          << "Start Point : ";
          IGESData_DumpXYZL(S,level, ent->StartPoint(i), ent->Location());
          S << "\nText : ";
          IGESData_DumpString(S,ent->Text(i));
          S << "\n";
	}
    }
  S << std::endl;
}
Commit	Line	Data
b311480e	1	// Created by: CKY / Contract Toubro-Larsen
b311480e	2	// Copyright (c) 1993-1999 Matra Datavision
973c2be1	3	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	4	//
973c2be1	5	// This file is part of Open CASCADE Technology software library.
7fd59977	6	//
d5f74e42	7	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	8	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	9	// by the Free Software Foundation, with special exception defined in the file
	10	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	11	// distribution for complete text of the license and disclaimer of any warranty.
7fd59977	12	//
973c2be1	13	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	14	// commercial license or contractual agreement.
b311480e	15
b311480e	16	//--------------------------------------------------------------------
7fd59977	17	//--------------------------------------------------------------------
7fd59977	18
42cf5bc1	19	#include <gp_Pnt.hxx>
	20	#include <gp_XYZ.hxx>
	21	#include <IGESData_DirChecker.hxx>
	22	#include <IGESData_Dump.hxx>
	23	#include <IGESData_IGESDumper.hxx>
	24	#include <IGESData_IGESReaderData.hxx>
	25	#include <IGESData_IGESWriter.hxx>
7fd59977	26	#include <IGESData_ParamCursor.hxx>
42cf5bc1	27	#include <IGESData_ParamReader.hxx>
	28	#include <IGESDimen_GeneralNote.hxx>
	29	#include <IGESDimen_ToolGeneralNote.hxx>
	30	#include <IGESGraph_HArray1OfTextFontDef.hxx>
7fd59977	31	#include <IGESGraph_TextFontDef.hxx>
42cf5bc1	32	#include <Interface_Check.hxx>
	33	#include <Interface_CopyTool.hxx>
	34	#include <Interface_EntityIterator.hxx>
7fd59977	35	#include <Interface_HArray1OfHAsciiString.hxx>
7fd59977	36	#include <Interface_Macros.hxx>
42cf5bc1	37	#include <Interface_ShareTool.hxx>
	38	#include <Message_Messenger.hxx>
	39	#include <Standard_DomainError.hxx>
	40	#include <TColgp_HArray1OfXYZ.hxx>
	41	#include <TCollection_HAsciiString.hxx>
	42	#include <TColStd_HArray1OfInteger.hxx>
	43	#include <TColStd_HArray1OfReal.hxx>
7fd59977	44
42cf5bc1	45	#include <stdio.h>
7fd59977	46	IGESDimen_ToolGeneralNote::IGESDimen_ToolGeneralNote () { }
	47
	48
	49	void IGESDimen_ToolGeneralNote::ReadOwnParams
	50	(const Handle(IGESDimen_GeneralNote)& ent,
	51	const Handle(IGESData_IGESReaderData)& IR, IGESData_ParamReader& PR) const
	52	{
	53	//Standard_Boolean st; //szv#4:S4163:12Mar99 moved down
	54
	55	Standard_Integer nbval;
	56	Handle(TColStd_HArray1OfInteger) nbChars;
	57	Handle(TColStd_HArray1OfReal) boxWidths;
	58	Handle(TColStd_HArray1OfReal) boxHeights;
	59	Handle(TColStd_HArray1OfInteger) fontCodes;
	60	Handle(IGESGraph_HArray1OfTextFontDef) fontEntities;
	61	Handle(TColStd_HArray1OfReal) slantAngles;
	62	Handle(TColStd_HArray1OfReal) rotationAngles;
	63	Handle(TColStd_HArray1OfInteger) mirrorFlags;
	64	Handle(TColStd_HArray1OfInteger) rotateFlags;
	65	Handle(TColgp_HArray1OfXYZ) startPoints;
	66	Handle(Interface_HArray1OfHAsciiString) texts;
	67
	68	Standard_Boolean st = PR.ReadInteger(PR.Current(), "Number of Text Strings", nbval);
	69	if (st && nbval > 0) {
	70	nbChars = new TColStd_HArray1OfInteger(1, nbval);
	71	boxWidths = new TColStd_HArray1OfReal(1, nbval);
	72	boxHeights = new TColStd_HArray1OfReal(1, nbval);
	73	fontCodes = new TColStd_HArray1OfInteger(1, nbval);
	74	fontEntities = new IGESGraph_HArray1OfTextFontDef(1, nbval);
	75	slantAngles = new TColStd_HArray1OfReal(1, nbval);
	76	rotationAngles = new TColStd_HArray1OfReal(1, nbval);
	77	mirrorFlags = new TColStd_HArray1OfInteger(1, nbval);
	78	rotateFlags = new TColStd_HArray1OfInteger(1, nbval);
	79	startPoints = new TColgp_HArray1OfXYZ(1, nbval);
	80	texts = new Interface_HArray1OfHAsciiString(1, nbval);
	81	}
	82	else PR.AddFail("Number of Text Strings: Not Positive");
	83
	84
	85	if (! nbChars.IsNull())
	86	{
	87	for (Standard_Integer i = 1; i <= nbval; i++)
	88	{
	89	Standard_Integer nbChar;
	90	Standard_Real boxWidth;
	91	Standard_Real boxHeight;
	92	Standard_Integer fontCode;
	93	Handle(IGESGraph_TextFontDef) fontEntity;
	94	Standard_Real slantAngle;
	95	Standard_Real rotationAngle;
	96	Standard_Integer mirrorFlag;
	97	Standard_Integer rotateFlag;
	98	gp_XYZ startPoint;
	99	Handle(TCollection_HAsciiString) text;
	100
	101	//st = PR.ReadInteger(PR.Current(), "Number of Characters", nbChar); //szv#4:S4163:12Mar99 moved in if
	102	if (PR.ReadInteger(PR.Current(), "Number of Characters", nbChar))
	103	nbChars->SetValue(i, nbChar);
	104
	105	//st = PR.ReadReal(PR.Current(), "Box Width", boxWidth); //szv#4:S4163:12Mar99 moved in if
	106	if (PR.ReadReal(PR.Current(), "Box Width", boxWidth))
	107	boxWidths->SetValue(i, boxWidth);
	108
	109	//st = PR.ReadReal(PR.Current(), "Box Height", boxHeight); //szv#4:S4163:12Mar99 moved in if
110	if (PR.ReadReal(PR.Current(), "Box Height", boxHeight))
111	boxHeights->SetValue(i, boxHeight);
112
113	Standard_Integer curnum = PR.CurrentNumber();
114	if (PR.DefinedElseSkip())
115	{
116	// Reading fontCode(Integer, must be positive)
117	PR.ReadInteger (PR.Current(), "Font Code", fontCode); //szv#4:S4163:12Mar99 `st=` not needed
118	// Reading fontEnt(TextFontDef) ?
119	if (fontCode < 0) {
120	fontEntity = GetCasted(IGESGraph_TextFontDef,PR.ParamEntity (IR,curnum));
121	if (fontEntity.IsNull()) PR.AddFail ("Font Entity : incorrect reference");
122	fontEntities->SetValue(i, fontEntity);
123	fontCodes->SetValue(i, -1);
124	}
125	else fontCodes->SetValue(i, fontCode);
126	}
127	else
128	{
129	fontCodes->SetValue(i, 1);
130	}
131
132	if (PR.DefinedElseSkip())
133	{
134	//st = PR.ReadReal(PR.Current(), "Slant Angle", slantAngle); //szv#4:S4163:12Mar99 moved in if
135	if (PR.ReadReal(PR.Current(), "Slant Angle", slantAngle))
136	slantAngles->SetValue(i, slantAngle);
137	}
138	else
c6541a0c	139	slantAngles->SetValue(i, M_PI/2);
7fd59977	140
	141	//st = PR.ReadReal(PR.Current(), "Rotation Angle", rotationAngle); //szv#4:S4163:12Mar99 moved in if
	142	if (PR.ReadReal(PR.Current(), "Rotation Angle", rotationAngle))
	143	rotationAngles->SetValue(i, rotationAngle);
	144
	145	//st = PR.ReadInteger(PR.Current(), "Mirror Flag", mirrorFlag); //szv#4:S4163:12Mar99 moved in if
	146	if (PR.ReadInteger(PR.Current(), "Mirror Flag", mirrorFlag))
	147	mirrorFlags->SetValue(i, mirrorFlag);
	148
	149	//st = PR.ReadInteger(PR.Current(), "Rotate Flag", rotateFlag); //szv#4:S4163:12Mar99 moved in if
	150	if (PR.ReadInteger(PR.Current(), "Rotate Flag", rotateFlag))
	151	rotateFlags->SetValue(i, rotateFlag);
	152
	153	//st = PR.ReadXYZ(PR.CurrentList(1, 3), "Start Point", startPoint); //szv#4:S4163:12Mar99 moved in if
	154	if (PR.ReadXYZ(PR.CurrentList(1, 3), "Start Point", startPoint))
	155	startPoints->SetValue(i, startPoint);
	156
	157	//st = PR.ReadText(PR.Current(), "Text String", text); //szv#4:S4163:12Mar99 moved in if
	158	if (PR.ReadText(PR.Current(), "Text String", text))
	159	texts->SetValue(i, text);
	160	}
	161	}
	162	//sln 28.09.2001, BUC61004, If the condition is false function ent->Init is not called in order to avoid exception
	163	if(!(nbChars.IsNull() \|\| boxWidths.IsNull() \|\| boxHeights.IsNull() \|\| fontCodes.IsNull() \|\|
	164	fontEntities.IsNull() \|\| slantAngles.IsNull() \|\| rotationAngles.IsNull() \|\|
	165	mirrorFlags.IsNull() \|\| rotateFlags.IsNull() \|\| startPoints.IsNull() \|\| texts.IsNull()))
	166	{
	167	DirChecker(ent).CheckTypeAndForm(PR.CCheck(),ent);
	168	ent->Init
	169	(nbChars, boxWidths, boxHeights, fontCodes, fontEntities,
	170	slantAngles, rotationAngles, mirrorFlags, rotateFlags,
	171	startPoints, texts);
	172	}
	173	}
	174
	175	void IGESDimen_ToolGeneralNote::WriteOwnParams
	176	(const Handle(IGESDimen_GeneralNote)& ent, IGESData_IGESWriter& IW) const
	177	{
	178	Standard_Integer nbval = ent->NbStrings();
	179	IW.Send(nbval);
	180
	181	for (Standard_Integer i = 1; i <= nbval; i++)
	182	{
	183	IW.Send(ent->NbCharacters(i));
	184	IW.Send(ent->BoxWidth(i));
	185	IW.Send(ent->BoxHeight(i));
	186	if (ent->IsFontEntity(i))
	187	IW.Send(ent->FontEntity(i),Standard_True); // negative
	188	else
	189	IW.Send(ent->FontCode(i));
	190	IW.Send(ent->SlantAngle(i));
	191	IW.Send(ent->RotationAngle(i));
	192	IW.Send(ent->MirrorFlag(i));
	193	IW.Send(ent->RotateFlag(i));
	194	IW.Send((ent->StartPoint(i)).X());
	195	IW.Send((ent->StartPoint(i)).Y());
	196	IW.Send((ent->StartPoint(i)).Z());
	197	IW.Send(ent->Text(i));
	198	}
	199	}
	200
	201	void IGESDimen_ToolGeneralNote::OwnShared
	202	(const Handle(IGESDimen_GeneralNote)& ent, Interface_EntityIterator& iter) const
	203	{
204	Standard_Integer nbval = ent->NbStrings();
205	for (Standard_Integer i = 1; i <= nbval; i++) {
206	if (ent->IsFontEntity(i))
207	iter.GetOneItem(ent->FontEntity(i));
208	}
209	}
210
211	void IGESDimen_ToolGeneralNote::OwnCopy
212	(const Handle(IGESDimen_GeneralNote)& another,
213	const Handle(IGESDimen_GeneralNote)& ent, Interface_CopyTool& TC) const
214	{
215	Standard_Integer nbval = another->NbStrings();
216
217	Handle(TColStd_HArray1OfInteger) nbChars;
218	Handle(TColStd_HArray1OfReal) boxWidths;
219	Handle(TColStd_HArray1OfReal) boxHeights;
220	Handle(TColStd_HArray1OfInteger) fontCodes;
221	Handle(IGESGraph_HArray1OfTextFontDef) fontEntities;
222	Handle(TColStd_HArray1OfReal) slantAngles;
223	Handle(TColStd_HArray1OfReal) rotationAngles;
224	Handle(TColStd_HArray1OfInteger) mirrorFlags;
225	Handle(TColStd_HArray1OfInteger) rotateFlags;
226	Handle(TColgp_HArray1OfXYZ) startPoints;
227	Handle(Interface_HArray1OfHAsciiString) texts;
228
229	nbChars = new TColStd_HArray1OfInteger(1, nbval);
230	boxWidths = new TColStd_HArray1OfReal (1, nbval);
231	boxHeights = new TColStd_HArray1OfReal (1, nbval);
232	fontCodes = new TColStd_HArray1OfInteger(1, nbval);
233	fontEntities = new IGESGraph_HArray1OfTextFontDef(1, nbval);
234	slantAngles = new TColStd_HArray1OfReal (1, nbval);
235	rotationAngles = new TColStd_HArray1OfReal (1, nbval);
236	mirrorFlags = new TColStd_HArray1OfInteger(1, nbval);
237	rotateFlags = new TColStd_HArray1OfInteger(1, nbval);
238	startPoints = new TColgp_HArray1OfXYZ (1, nbval);
239	texts = new Interface_HArray1OfHAsciiString(1, nbval);
240
241	for (Standard_Integer i = 1; i <= nbval; i++)
242	{
243	Standard_Integer nbChar = another->NbCharacters(i);
244	nbChars->SetValue(i, nbChar);
245	Standard_Real boxWidth = another->BoxWidth(i);
246	boxWidths->SetValue(i, boxWidth);
247	Standard_Real boxHeight = another->BoxHeight(i);
248	boxHeights->SetValue(i, boxHeight);
249
250	if (another->IsFontEntity(i))
251	{
252	DeclareAndCast(IGESGraph_TextFontDef, fontEntity,
253	TC.Transferred(another->FontEntity(i)));
254	fontEntities->SetValue(i, fontEntity);
255	fontCodes->SetValue(i, -1);
256	}
257	else
258	{
259	Standard_Integer fontCode = another->FontCode(i);
260	fontCodes->SetValue(i, fontCode);
261	//// fontEntities->SetValue(i, NULL); par defaut
262	}
263
264	Standard_Real slantAngle = another->SlantAngle(i);
265	slantAngles->SetValue(i, slantAngle);
266	Standard_Real rotationAngle = another->RotationAngle(i);
267	rotationAngles->SetValue(i, rotationAngle);
268	Standard_Integer mirrorFlag = another->MirrorFlag(i);
269	mirrorFlags->SetValue(i, mirrorFlag);
270	Standard_Integer rotateFlag = another->RotateFlag(i);
271	rotateFlags->SetValue(i, rotateFlag);
272	gp_XYZ startPoint = (another->StartPoint(i)).XYZ();
273	startPoints->SetValue(i, startPoint);
274	Handle(TCollection_HAsciiString) text =
275	new TCollection_HAsciiString(another->Text(i));
276	texts->SetValue(i, text);
277	}
278
279	ent->Init(nbChars, boxWidths, boxHeights, fontCodes, fontEntities,
280	slantAngles, rotationAngles, mirrorFlags, rotateFlags,
281	startPoints, texts);
282	ent->SetFormNumber(another->FormNumber());
283	}
284
285	IGESData_DirChecker IGESDimen_ToolGeneralNote::DirChecker
286	(const Handle(IGESDimen_GeneralNote)& /* ent */ ) const
287	{
288	IGESData_DirChecker DC (212, 0, 105);
289	DC.Structure(IGESData_DefVoid);
290	DC.LineFont(IGESData_DefValue);
291	DC.LineWeight(IGESData_DefValue);
292	DC.Color(IGESData_DefAny);
293	DC.UseFlagRequired(1);
294	DC.HierarchyStatusIgnored();
295	return DC;
296	}
297
298	void IGESDimen_ToolGeneralNote::OwnCheck
299	(const Handle(IGESDimen_GeneralNote)& ent,
300	const Interface_ShareTool& , Handle(Interface_Check)& ach) const
301	{
302	if (((ent->FormNumber() < 0) \|\| (ent->FormNumber() > 8)) &&
303	((ent->FormNumber() < 100) \|\| (ent->FormNumber() > 102)) &&
304	(ent->FormNumber() != 105))
305	ach->AddFail("Form Number: Not Valid");
306
307	Standard_Integer upper = ent->NbStrings();
308	for (Standard_Integer i = 1; i <= upper; i++)
309	{
310	if (ent->NbCharacters(i) != ent->Text(i)->Length())
311	{
312	char mess[80];
313	sprintf(mess,"%d : Number of Characters != Length of Text String",i);
314	ach->AddFail(mess);
315	}
316	Standard_Integer mflag = ent->MirrorFlag(i);
317	if ((mflag < 0) \|\| (mflag > 2))
318	{
319	char mess[80];
320	sprintf(mess, "%d : Mirror flag != 0, 1, 2",i);
321	ach->AddFail(mess);
322	}
323	Standard_Integer rflag = ent->RotateFlag(i);
324	if ((rflag < 0) \|\| (rflag > 1))
325	{
326	char mess[80];
327	sprintf(mess, "%d : Rotate flag != 0, 1",i);
328	ach->AddFail(mess);
329	}
330	}
331	}
332
333	void IGESDimen_ToolGeneralNote::OwnDump
334	(const Handle(IGESDimen_GeneralNote)& ent, const IGESData_IGESDumper& dumper,
0ebe5b0a	335	Standard_OStream& S, const Standard_Integer level) const
7fd59977	336	{
	337	Standard_Integer sublevel = (level > 4) ? 1 : 0;
	338	Standard_Integer upper = ent->NbStrings();
	339
0ebe5b0a	340	S << "IGESDimen_GeneralNote\n"
	341	<< "Number of Text Strings : " << upper << "\n"
	342	<< "Number of Characters :\n"
	343	<< "Box Widths :\n"
	344	<< "Box Heights :\n"
	345	<< "Font Codes :\n"
	346	<< "Font Entities :\n"
	347	<< "Slant Angles :\n"
	348	<< "Rotation Angles :\n"
	349	<< "Mirror Flags :\n"
	350	<< "Rotate Flags :\n"
	351	<< "Start Points :\n"
	352	<< "Texts : ";
7fd59977	353	IGESData_DumpVals(S,-level,1, ent->NbStrings(),ent->NbCharacters);
0ebe5b0a	354	S << "\n";
7fd59977	355	if (level > 4)
7fd59977	356	{
0ebe5b0a	357	S << "Details of each String\n";
7fd59977	358	for ( Standard_Integer i = 1; i <= upper; i++)
7fd59977	359	{
0ebe5b0a	360	S << "[" << i << "]:\n"
	361	<< "Number of Characters : " << ent->NbCharacters(i) << " "
	362	<< "Box Width : " << ent->BoxWidth(i) << " "
	363	<< "Box Height : " << ent->BoxHeight(i) << "\n";
7fd59977	364	if (ent->IsFontEntity(i))
	365	{
	366	S << "Font Entity : ";
	367	dumper.Dump (ent->FontEntity(i),S, sublevel);
0ebe5b0a	368	S << "\n";
7fd59977	369	}
7fd59977	370	else
0ebe5b0a	371	S << "Font Code : " << ent->FontCode(i) << "\n"
	372	<< "Slant Angle : " << ent->SlantAngle(i) << " "
	373	<< "Rotation Angle : " << ent->RotationAngle(i) << " "
	374	<< "Mirror Flag : " << ent->MirrorFlag(i) << " "
	375	<< "Rotate Flag : " << ent->RotateFlag(i) << "\n"
	376	<< "Start Point : ";
7fd59977	377	IGESData_DumpXYZL(S,level, ent->StartPoint(i), ent->Location());
	378	S << "\nText : ";
	379	IGESData_DumpString(S,ent->Text(i));
0ebe5b0a	380	S << "\n";
7fd59977	381	}
7fd59977	382	}
0ebe5b0a	383	S << std::endl;
7fd59977	384	}