Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
// Created on: 1997-07-30
// Created by: Denis PASCAL
// Copyright (c) 1997-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 <DDataStd.hxx>
#include <Draw_Interpretor.hxx>
#include <Draw_Appli.hxx>
#include <DDF.hxx>
#include <Message.hxx>
#include <TDF_Data.hxx>
#include <TDF_Label.hxx>
#include <TDF_AttributeSequence.hxx>
#include <BRep_Tool.hxx>
#include <DBRep.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>
#include <TCollection_AsciiString.hxx>
#include <TColStd_HArray1OfReal.hxx>
// LES ATTRIBUTES
#include <TDataXtd_Triangulation.hxx>
#include <TDataStd_Comment.hxx>
#include <TDataStd_Name.hxx>
#include <TDataStd_Integer.hxx>
#include <TDataStd_Real.hxx>
#include <TDF_Reference.hxx>
#include <TDataStd_UAttribute.hxx>
#include <TDataStd_IntegerArray.hxx>
#include <TDataStd_BooleanArray.hxx>
#include <TDataStd_RealArray.hxx>
#include <TDataStd_BooleanList.hxx>
#include <TDataStd_IntegerList.hxx>
#include <TDataStd_RealList.hxx>
#include <TDataStd_Variable.hxx>
#include <TDataStd_ExtStringArray.hxx>
#include <TDF_ChildIterator.hxx>
#include <TDF_Tool.hxx>
#include <TDataStd_NamedData.hxx>
#include <TColStd_DataMapOfStringInteger.hxx>
#include <TDataStd_DataMapOfStringReal.hxx>
#include <TDataStd_DataMapOfStringByte.hxx>
#include <TDataStd_DataMapOfStringString.hxx>
#include <TDataStd_DataMapOfStringHArray1OfInteger.hxx>
#include <TDataStd_DataMapOfStringHArray1OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TDataStd_AsciiString.hxx>
#include <TDataStd_IntPackedMap.hxx>
#include <TColStd_HPackedMapOfInteger.hxx>
#include <TColStd_PackedMapOfInteger.hxx>
#include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
#include <TDataStd_ByteArray.hxx>
#include <TDataStd_ListIteratorOfListOfByte.hxx>
#include <TColStd_ListIteratorOfListOfReal.hxx>
#include <TDataStd_ReferenceArray.hxx>
#include <TDataStd_ExtStringList.hxx>
#include <TDataStd_ReferenceList.hxx>
#include <TDataStd_ListIteratorOfListOfExtendedString.hxx>
#include <algorithm>
#include <vector>
#define MAXLENGTH 10
// #define DEB_DDataStd
//=======================================================================
// function : DDataStd_SetInteger
// purpose : SetInteger (DF, entry, value, [,guid])
//=======================================================================
static Standard_Integer DDataStd_SetInteger(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label L;
DDF::AddLabel(DF, arg[2], L);
if (nb == 4)
TDataStd_Integer::Set(L, Draw::Atoi(arg[3]));
else
{
if (!Standard_GUID::CheckGUIDFormat(arg[4]))
{
di << "DDataStd_SetInteger: The format of GUID is invalid\n";
return 1;
}
Standard_GUID guid(arg[4]);
TDataStd_Integer::Set(L, guid, Draw::Atoi(arg[3]));
}
return 0;
}
di << "DDataStd_SetInteger : Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_SetReal
// purpose : SetReal (DF, entry, value [,guid])
//=======================================================================
static Standard_Integer DDataStd_SetReal(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label L;
DDF::AddLabel(DF, arg[2], L);
if (nb == 4)
TDataStd_Real::Set(L, Draw::Atof(arg[3]));
else
{
if (!Standard_GUID::CheckGUIDFormat(arg[4]))
{
di << "DDataStd_SetReal: The format of GUID is invalid\n";
return 1;
}
Standard_GUID guid(arg[4]);
TDataStd_Real::Set(L, guid, Draw::Atof(arg[3]));
}
return 0;
}
di << "DDataStd_SetReal : Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_SetReference
// purpose : SetReference (DF, entry, reference)
//=======================================================================
static Standard_Integer DDataStd_SetReference(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label L;
DDF::AddLabel(DF, arg[2], L);
TDF_Label LREF;
if (!DDF::FindLabel(DF, arg[3], LREF))
return 1;
TDF_Reference::Set(L, LREF);
return 0;
}
di << "DDataStd_SetReference : Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_SetComment
// purpose : SetComment (DF, entry, Comment)
//=======================================================================
static Standard_Integer DDataStd_SetComment(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label L;
DDF::AddLabel(DF, arg[2], L);
TDataStd_Comment::Set(L, TCollection_ExtendedString(arg[3], Standard_True));
return 0;
}
di << "DDataStd_SetComment : Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_GetInteger
// purpose : GetReal (DF, entry, [drawname][, guid])
//=======================================================================
static Standard_Integer DDataStd_GetInteger(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3 || nb == 4 || nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
Handle(TDataStd_Integer) A;
Standard_GUID aGuid;
Standard_GUID aNullGuid("00000000-0000-0000-0000-000000000000");
Standard_Boolean isdrawname(Standard_False);
if (nb < 5)
{
if (nb == 4)
{ // DF, entry, guid
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
}
if (aGuid == aNullGuid)
{
isdrawname = Standard_True;
aGuid = TDataStd_Integer::GetID();
}
}
else if (nb == 5)
{
isdrawname = Standard_True;
if (Standard_GUID::CheckGUIDFormat(arg[4]))
aGuid = Standard_GUID(arg[4]);
else
{
di << "DDataStd_GetInteger: The format of GUID is invalid\n";
return 1;
}
}
if (!DDF::Find(DF, arg[2], aGuid, A))
return 1;
if (nb == 4 && isdrawname)
Draw::Set(arg[3], A->Get());
else
Draw::Set(arg[2], A->Get());
di << A->Get();
return 0;
}
di << "DDataStd_GetInteger : Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_GetReal
// purpose : GetReal (DF, entry, [drawname][, guid])
//=======================================================================
static Standard_Integer DDataStd_GetReal(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3 || nb == 4 || nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
Handle(TDataStd_Real) A;
Standard_GUID aGuid;
Standard_GUID aNullGuid("00000000-0000-0000-0000-000000000000");
Standard_Boolean isdrawname(Standard_False);
if (nb < 5)
{
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
}
if (aGuid == aNullGuid)
{
isdrawname = Standard_True;
aGuid = TDataStd_Real::GetID();
}
}
else if (nb == 5)
{
isdrawname = Standard_True;
if (Standard_GUID::CheckGUIDFormat(arg[4]))
aGuid = Standard_GUID(arg[4]);
else
{
di << "DDataStd_GetReal: The format of GUID is invalid\n";
return 1;
}
}
if (!DDF::Find(DF, arg[2], aGuid, A))
return 1;
if (nb == 4 && isdrawname)
Draw::Set(arg[3], A->Get());
else
Draw::Set(arg[2], A->Get());
di << A->Get();
return 0;
}
di << "DDataStd_GetReal : Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_GetReference
// purpose : GetShape (DF, entry)
//=======================================================================
static Standard_Integer DDataStd_GetReference(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
Handle(TDF_Reference) REF;
if (!DDF::Find(DF, arg[2], TDF_Reference::GetID(), REF))
return 1;
TCollection_AsciiString entry;
TDF_Tool::Entry(REF->Get(), entry);
di << entry.ToCString();
return 0;
}
di << "DDataStd_GetReference : Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_GetComment
// purpose : GetShape (DF, entry)
//=======================================================================
static Standard_Integer DDataStd_GetComment(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
Handle(TDataStd_Comment) A;
if (!DDF::Find(DF, arg[2], TDataStd_Comment::GetID(), A))
return 1;
di << A->Get();
return 0;
}
di << "DDataStd_GetComment : Error\n";
return 1;
}
//=======================================================================
// function :
// purpose : Self (document,label)
//=======================================================================
static Standard_Integer DDataStd_Self(Draw_Interpretor& di, Standard_Integer nb, const char** arg)
{
TCollection_AsciiString s;
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label L;
if (!DDF::FindLabel(DF, arg[2], L))
return 1;
// TDataStd::MakeSelfContained(L,removed);
// if (removed.IsEmpty()) std::cout << "no attribute removed" << std::endl;
// for (TDF_ListIteratorOfAttributeList it(removed);it.More();it.Next()) {
// TDF_Tool::Entry(it.Value()->Label(),s); std::cout << s << " ";
// std::cout << std::endl;
// }
return 0;
}
di << "Self : Error\n";
return 0;
}
//=======================================================================
// function : SetUObject (DF, entry, ObjectID)
//=======================================================================
// static Standard_Integer DDataStd_SetUObject (Draw_Interpretor&,
// Standard_Integer nb,
// const char** arg)
// {
// if( nb == 4 ) {
// Handle(TDF_Data) DF;
// if (!DDF::GetDF(arg[1],DF)) return 1;
// TDF_Label label;
// DDF::AddLabel(DF, arg[2], label);
// Standard_GUID guid(arg[3]); //"00000000-0000-0000-1111-000000000000");
// TDataStd_UObject::Set(label, guid);
// return 0;
// }
// std::cout << "Wrong arguments" << std::endl;
// return 1;
// }
//=======================================================================
// function : SetUAttribute (DF, entry, LocalID)
//=======================================================================
static Standard_Integer DDataStd_SetUAttribute(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_GUID guid(arg[3]); //"00000000-0000-0000-2222-000000000000");
TDataStd_UAttribute::Set(label, guid);
return 0;
}
di << "Wrong arguments" << "\n";
return 1;
}
//=======================================================================
// function : GetUAttribute (DF, entry, LoaclID)
//=======================================================================
static Standard_Integer DDataStd_GetUAttribute(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID guid(arg[3]); //"00000000-0000-0000-2222-000000000000");
Handle(TDataStd_UAttribute) UA;
if (!label.FindAttribute(guid, UA))
{
di << "No UAttribute Attribute on label" << "\n";
}
else
{
char* aStrGUID = new char[37];
UA->ID().ToCString(aStrGUID);
di << aStrGUID;
}
return 0;
}
di << "Wrong arguments" << "\n";
return 1;
}
//=======================================================================
// function : CheckUObject (DF, entry, ObjectID)
//=======================================================================
// static Standard_Integer DDataStd_CheckUObject (Draw_Interpretor&,
// Standard_Integer nb,
// const char** arg)
// {
// if( nb == 4 ) {
// Handle(TDF_Data) DF;
// if (!DDF::GetDF(arg[1],DF)) return 1;
// TDF_Label label;
// if( !DDF::FindLabel(DF, arg[2], label) ) {
// std::cout << "No label for entry" << std::endl;
// return 1;
// }
// Handle(TDataStd_Object) O;
// Handle(TDataStd_UObject) UO;
// Standard_GUID guidUO(arg[3]);
// if( !label.FindAttribute( TDataStd_Object::GetID(), O) ) {
// std::cout << "No Object Attribute on label" << std::endl;
// }
// else {
// std::cout << "UObject is found with ObjectID = ";
// O->Find(label, guidUO, UO);
// UO->ObjectID().ShallowDump(std::cout);
// std::cout << std::endl;
// }
// return 0;
// }
// std::cout << "Wrong arguments" << std::endl;
// return 1;
// }
//=======================================================================
// function : SetIntArray (DF, entry , isDelta, [-g Guid,] From, To, elmt1, elmt2, ...
//=======================================================================
static Standard_Integer DDataStd_SetIntArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 6)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
Standard_GUID guid;
Standard_Boolean isGuid(Standard_False);
Standard_Character c1(arg[4][0]), c2(arg[4][1]);
if (c1 == '-' && c2 == 'g')
{ // guid
if (!Standard_GUID::CheckGUIDFormat(arg[5]))
{
di << "DDataStd_SetIntArray: The format of GUID is invalid\n";
return 1;
}
guid = Standard_GUID(arg[5]);
isGuid = Standard_True;
}
Standard_Integer j(4);
if (isGuid)
j = 6;
if ((strlen(arg[j]) > MAXLENGTH || strlen(arg[j + 1]) > MAXLENGTH)
|| !TCollection_AsciiString(arg[j]).IsIntegerValue()
|| !TCollection_AsciiString(arg[j + 1]).IsIntegerValue())
{
di << "DDataStd_SetIntArray: From, To may be wrong\n";
return 1;
}
Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi(arg[j + 1]);
di << "Array of Standard_Integer with bounds from = " << From << " to = " << To << "\n";
Handle(TDataStd_IntegerArray) A;
if (!isGuid)
A = TDataStd_IntegerArray::Set(label, From, To, isDelta);
else
A = TDataStd_IntegerArray::Set(label, guid, From, To, isDelta);
if ((!isGuid && nb > 6) || (isGuid && nb > 8))
{
j = j + 2;
for (Standard_Integer i = From; i <= To; i++)
{
A->SetValue(i, Draw::Atoi(arg[j]));
j++;
}
}
return 0;
}
di << "DDataStd_SetIntArray: Error\n";
return 1;
}
//=======================================================================
// function : SetIntArrayValue (DF, entry, index, value)
//=======================================================================
static Standard_Integer DDataStd_SetIntArrayValue(Draw_Interpretor&,
Standard_Integer,
const char** arg)
{
// Get document.
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
// Get label.
TDF_Label label;
if (!DDF::AddLabel(DF, arg[2], label))
return 1;
// Get index and value.
Standard_Integer index = Draw::Atoi(arg[3]);
Standard_Integer value = Draw::Atoi(arg[4]);
// Set new value.
Handle(TDataStd_IntegerArray) arr;
if (label.FindAttribute(TDataStd_IntegerArray::GetID(), arr))
{
arr->SetValue(index, value);
return 0;
}
return 1;
}
//=======================================================================
// function : GetIntArray (DF, entry [, guid] )
//=======================================================================
static Standard_Integer DDataStd_GetIntArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_IntegerArray::GetID();
Handle(TDataStd_IntegerArray) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_IntegerArray with the specified GUID under label" << "\n";
return 1;
}
for (Standard_Integer i = A->Lower(); i <= A->Upper(); i++)
{
di << A->Value(i);
if (i < A->Upper())
di << " ";
}
di << "\n";
return 0;
}
di << "DDataStd_GetIntArray: Error\n";
return 1;
}
//=======================================================================
// function : GetIntArrayValue (DF, entry, index)
//=======================================================================
static Standard_Integer DDataStd_GetIntArrayValue(Draw_Interpretor& di,
Standard_Integer,
const char** arg)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_IntegerArray) A;
if (!label.FindAttribute(TDataStd_IntegerArray::GetID(), A))
{
di << "There is no TDataStd_IntegerArray under label" << "\n";
return 1;
}
Standard_Integer index = Draw::Atoi(arg[3]);
if (index < A->Lower() || index > A->Upper())
{
di << "Index is out of range\n";
return 1;
}
else
{
di << A->Value(index) << "\n";
}
return 0;
}
//=======================================================================
// function : ChangeIntArray (DF, entry, indx, val )
//=======================================================================
static Standard_Integer DDataStd_ChangeIntArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_IntegerArray) A;
if (!label.FindAttribute(TDataStd_IntegerArray::GetID(), A))
{
di << "There is no TDataStd_IntegerArray at label" << "\n";
return 1;
}
Standard_Integer indx = Draw::Atoi(arg[3]);
Standard_Integer val = Draw::Atoi(arg[4]);
Standard_Integer low = A->Lower(), up = A->Upper();
if (low <= indx && indx <= up)
A->SetValue(indx, val);
else
{
Handle(TColStd_HArray1OfInteger) Arr = A->Array();
Handle(TColStd_HArray1OfInteger) arr;
Standard_Integer i;
if (indx > up)
{
up = indx;
arr = new TColStd_HArray1OfInteger(low, up);
for (i = low; i <= Arr->Upper(); i++)
arr->SetValue(i, Arr->Value(i));
for (i = Arr->Upper() + 1; i <= up; i++)
{
if (i == up)
arr->SetValue(i, val);
else
arr->SetValue(i, 0);
}
}
else if (indx < up)
{ // clip array : indx to be negative
up = abs(indx);
arr = new TColStd_HArray1OfInteger(low, up);
for (i = low; i < up; i++)
arr->SetValue(i, Arr->Value(i));
arr->SetValue(up, val);
}
A->ChangeArray(arr);
}
return 0;
}
di << "DDataStd_ChangeIntArray: Error\n";
return 0;
}
//=======================================================================
// function : SetIntArrayT (DF, entry , isDelta, From, To) - for testing
// : huge arrays
//=======================================================================
static Standard_Integer DDataStd_SetIntArrayTest(Draw_Interpretor& di,
Standard_Integer,
const char** arg)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi(arg[5]);
di << "Array of Standard_Integer with bounds from = " << From << " to = " << To << "\n";
Handle(TDataStd_IntegerArray) A = TDataStd_IntegerArray::Set(label, From, To, isDelta);
Standard_Integer k = 100;
for (Standard_Integer i = From; i <= To; i++)
{
A->SetValue(i, ++k);
}
return 0;
}
//=======================================================================
// function : SetRealArray (DF, entry , isDelta, [-g Guid,] From, To, elmt1, elmt2, ...
//=======================================================================
static Standard_Integer DDataStd_SetRealArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 6)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
Standard_GUID guid;
Standard_Boolean isGuid(Standard_False);
Standard_Character c1(arg[4][0]), c2(arg[4][1]);
if (c1 == '-' && c2 == 'g')
{ // guid
if (!Standard_GUID::CheckGUIDFormat(arg[5]))
{
di << "DDataStd_SetRealArray: The format of GUID is invalid\n";
return 1;
}
guid = Standard_GUID(arg[5]);
isGuid = Standard_True;
}
Standard_Integer j(4);
if (isGuid)
j = 6;
if ((strlen(arg[j]) > MAXLENGTH || strlen(arg[j + 1]) > MAXLENGTH)
|| !TCollection_AsciiString(arg[j]).IsIntegerValue()
|| !TCollection_AsciiString(arg[j + 1]).IsIntegerValue())
{
di << "DDataStd_SetRealArray: From, To may be wrong\n";
return 1;
}
Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi(arg[j + 1]);
di << " Array of Standard_Real with bounds from = " << From << " to = " << To << "\n";
Handle(TDataStd_RealArray) A;
if (!isGuid)
A = TDataStd_RealArray::Set(label, From, To, isDelta);
else
A = TDataStd_RealArray::Set(label, guid, From, To, isDelta);
if ((!isGuid && nb > 6) || (isGuid && nb > 8))
{
j = j + 2;
for (Standard_Integer i = From; i <= To; i++)
{
A->SetValue(i, Draw::Atof(arg[j]));
j++;
}
}
return 0;
}
di << "DDataStd_SetRealArray: Error\n";
return 1;
}
//=======================================================================
// function : SetRealArrayValue (DF, entry, index value)
//=======================================================================
static Standard_Integer DDataStd_SetRealArrayValue(Draw_Interpretor&,
Standard_Integer,
const char** arg)
{
// Get document.
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
// Get label.
TDF_Label label;
if (!DDF::AddLabel(DF, arg[2], label))
return 1;
// Get index and value.
Standard_Integer index = Draw::Atoi(arg[3]);
Standard_Real value = Draw::Atof(arg[4]);
// Set new value.
Handle(TDataStd_RealArray) realArray;
if (label.FindAttribute(TDataStd_RealArray::GetID(), realArray))
{
realArray->SetValue(index, value);
return 0;
}
return 1;
}
//=======================================================================
// function : GetRealArray (DF, entry [, guid])
//=======================================================================
static Standard_Integer DDataStd_GetRealArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_RealArray::GetID();
Handle(TDataStd_RealArray) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_RealArray with the specified GUID at the label" << "\n";
#ifdef DEB_DDataStd
aGuid.ShallowDump(std::cout);
#endif
return 1;
}
for (Standard_Integer i = A->Lower(); i <= A->Upper(); i++)
{
#ifdef DEB_DDataStd
std::cout << A->Value(i) << std::endl;
#endif
di << A->Value(i);
if (i < A->Upper())
di << " ";
}
di << "\n";
return 0;
}
di << "TDataStd_RealArray: Error\n";
return 1;
}
//=======================================================================
// function : GetRealArrayValue (DF, entry, index)
//=======================================================================
static Standard_Integer DDataStd_GetRealArrayValue(Draw_Interpretor& di,
Standard_Integer,
const char** arg)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_RealArray) A;
if (!label.FindAttribute(TDataStd_RealArray::GetID(), A))
{
di << "There is no TDataStd_RealArray under label" << "\n";
return 1;
}
Standard_Integer index = Draw::Atoi(arg[3]);
if (index < A->Lower() || index > A->Upper())
{
di << "Index is out of range\n";
return 1;
}
else
{
di << A->Value(index) << "\n";
}
return 0;
}
//=======================================================================
// function : ChangeRealArray (DF, entry, indx, val )
//=======================================================================
static Standard_Integer DDataStd_ChangeRealArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_RealArray) A;
if (!label.FindAttribute(TDataStd_RealArray::GetID(), A))
{
di << "There is no TDataStd_RealArray at label" << "\n";
return 1;
}
Standard_Integer indx = Draw::Atoi(arg[3]);
Standard_Real val = Draw::Atof(arg[4]);
Standard_Integer low = A->Lower(), up = A->Upper();
if (low <= indx && indx <= up)
A->SetValue(indx, val);
else
{
Handle(TColStd_HArray1OfReal) Arr = A->Array();
Handle(TColStd_HArray1OfReal) arr;
Standard_Integer i;
if (indx > up)
{
up = indx;
arr = new TColStd_HArray1OfReal(low, up);
for (i = low; i <= Arr->Upper(); i++)
arr->SetValue(i, Arr->Value(i));
for (i = Arr->Upper() + 1; i <= up; i++)
{
if (i == up)
arr->SetValue(i, val);
else
arr->SetValue(i, 0);
}
}
else if (indx < up)
{ // clip array : indx to be negative
up = abs(indx);
arr = new TColStd_HArray1OfReal(low, up);
for (i = low; i < up; i++)
arr->SetValue(i, Arr->Value(i));
arr->SetValue(up, val);
}
A->ChangeArray(arr);
}
return 0;
}
di << "DDataStd_ChangeRealArray: Error\n";
return 0;
}
//=======================================================================
// function : SetVariable (DF, entry, isConstant[0/1], units)
//=======================================================================
static Standard_Integer DDataStd_SetVariable(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_Variable) aV = TDataStd_Variable::Set(label);
const char* aUnits = arg[4];
aV->Unit(Standard_CString(aUnits));
aV->Constant(Draw::Atoi(arg[3]) != 0);
return 0;
}
di << "Wrong arguments\n";
return 1;
}
//=======================================================================
// function : GetVariable (DF, entry, [isConstant], [units])
//=======================================================================
static Standard_Integer DDataStd_GetVariable(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_Variable) aV;
if (!label.FindAttribute(TDataStd_Variable::GetID(), aV))
{
di << "TDataStd_Variable: no such attribute\n";
}
Draw::Set(arg[3], TCollection_AsciiString(Standard_Integer(aV->IsConstant())).ToCString());
Draw::Set(arg[4], aV->Unit().ToCString());
return 0;
}
di << "Wrong arguments\n";
return 1;
}
#include <TDataStd_Relation.hxx>
#include <TDataStd_Variable.hxx>
//=======================================================================
// function : SetRelation (DF, entry, expression, var1[, var2, ...])
//=======================================================================
static Standard_Integer DDataStd_SetRelation(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_CString expr(arg[3]);
Handle(TDataStd_Relation) aR = TDataStd_Relation::Set(label);
aR->SetRelation(TCollection_ExtendedString(expr, Standard_True));
Handle(TDataStd_Variable) aV;
for (Standard_Integer i = 4; i < nb; i++)
{
if (!DDF::FindLabel(DF, arg[i], label))
{
di << "No label for entry" << arg[i] << "\n";
return 1;
}
if (!label.FindAttribute(TDataStd_Variable::GetID(), aV))
{
di << "No TDataStd_Variable Attribute on label\n";
return 1;
}
aR->GetVariables().Append(aV);
}
return 0;
}
di << "Usage: SetRelation (DF, entry, expression, var1[, var2, ...])\n";
return 1;
}
//=======================================================================
// function : DumpRelation (DF, entry)
//=======================================================================
static Standard_Integer DDataStd_DumpRelation(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry " << arg[2] << "\n";
return 1;
}
Handle(TDataStd_Relation) aR;
if (!label.FindAttribute(TDataStd_Relation::GetID(), aR))
{
di << "No TDataStd_Relation Attribute on label " << arg[2] << "\n";
return 1;
}
di << "Relation: expression = \"" << aR->GetRelation() << "\" variables list = (";
Handle(TDF_Attribute) aV;
TCollection_AsciiString anEntry;
TDF_ListIteratorOfAttributeList it;
for (it.Initialize(aR->GetVariables()); it.More(); it.Next())
{
aV = it.Value();
if (!aV.IsNull())
{
label = aV->Label();
TDF_Tool::Entry(label, anEntry);
di << anEntry.ToCString() << " ";
}
}
di << ")";
return 0;
}
di << "Usage: DumpRelation (DF, entry)\n";
return 1;
}
#include <TFunction_Function.hxx>
//=======================================================================
// function : SetFunction (DF, entry, guid, failure)
//=======================================================================
static Standard_Integer DDataStd_SetFunction(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_GUID guid(arg[3]);
Handle(TFunction_Function) aF = TFunction_Function::Set(label, guid);
int fail = Draw::Atoi(arg[4]);
aF->SetFailure(fail);
return 0;
}
di << "Wrong arguments" << "\n";
return 1;
}
//=======================================================================
// function : GetFunction (DF, entry, guid(out), failure(out))
//=======================================================================
static Standard_Integer DDataStd_GetFunction(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TFunction_Function) aF;
if (!label.FindAttribute(TFunction_Function::GetID(), aF))
{
di << "No TFunction_Function Attribute on label\n";
}
else
{
char* aStrGUID = new char[37];
aF->GetDriverGUID().ToCString(aStrGUID);
Draw::Set(arg[3], aStrGUID);
Draw::Set(arg[4], TCollection_AsciiString(aF->GetFailure()).ToCString());
}
return 0;
}
di << "Wrong arguments" << "\n";
return 1;
}
//=======================================================================
// function : SetExtStringArray (DF, entry , isDelta, [-g Guid, ]From, To, elmt1, elmt2, ...
//=======================================================================
static Standard_Integer DDataStd_SetExtStringArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 6)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
Standard_GUID guid;
Standard_Boolean isGuid(Standard_False);
Standard_Character c1(arg[4][0]), c2(arg[4][1]);
if (c1 == '-' && c2 == 'g')
{ // guid
if (!Standard_GUID::CheckGUIDFormat(arg[5]))
{
di << "DDataStd_SetExtStringArray: The format of GUID is invalid\n";
return 1;
}
guid = Standard_GUID(arg[5]);
isGuid = Standard_True;
}
Standard_Integer j(4);
if (isGuid)
j = 6;
if ((strlen(arg[j]) > MAXLENGTH || strlen(arg[j + 1]) > MAXLENGTH)
|| !TCollection_AsciiString(arg[j]).IsIntegerValue()
|| !TCollection_AsciiString(arg[j + 1]).IsIntegerValue())
{
di << "DDataStd_SetExtStringArray: From, To may be wrong\n";
return 1;
}
Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi(arg[j + 1]);
di << "Array of ExtString with bounds from = " << From << " to = " << To << "\n";
Handle(TDataStd_ExtStringArray) A;
if (!isGuid)
A = TDataStd_ExtStringArray::Set(label, From, To, isDelta);
else
A = TDataStd_ExtStringArray::Set(label, guid, From, To, isDelta);
if ((!isGuid && nb > 6) || (isGuid && nb > 8))
{
j = j + 2;
for (Standard_Integer i = From; i <= To; ++i)
{
TCollection_ExtendedString aVal(arg[j], Standard_True);
A->SetValue(i, aVal);
j++;
}
}
return 0;
}
di << "TDataStd_ExtStringArray: Error\n";
return 1;
}
//=======================================================================
// function : SetExtStringArrayValue (DF, entry, index, value)
//=======================================================================
static Standard_Integer DDataStd_SetExtStringArrayValue(Draw_Interpretor&,
Standard_Integer,
const char** arg)
{
// Get document.
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
// Get label.
TDF_Label label;
if (!DDF::AddLabel(DF, arg[2], label))
return 1;
// Get index and value.
Standard_Integer index = Draw::Atoi(arg[3]);
// Set new value.
Handle(TDataStd_ExtStringArray) arr;
if (label.FindAttribute(TDataStd_ExtStringArray::GetID(), arr))
{
TCollection_ExtendedString aVal(arg[4], Standard_True);
arr->SetValue(index, aVal);
return 0;
}
return 1;
}
//=======================================================================
// function : GetExtStringArray (DF, entry )
//=======================================================================
static Standard_Integer DDataStd_GetExtStringArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_ExtStringArray::GetID();
Handle(TDataStd_ExtStringArray) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_ExtStringArray with the specified GUID at the label" << "\n";
return 1;
}
for (Standard_Integer i = A->Lower(); i <= A->Upper(); i++)
{
di << A->Value(i);
if (i < A->Upper())
di << " ";
}
di << "\n";
return 0;
}
di << "DDataStd_GetExtStringArray: Error\n";
return 1;
}
//=======================================================================
// function : GetExtStringArrayValue (DF, entry, index)
//=======================================================================
static Standard_Integer DDataStd_GetExtStringArrayValue(Draw_Interpretor& di,
Standard_Integer,
const char** arg)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_ExtStringArray) A;
if (!label.FindAttribute(TDataStd_ExtStringArray::GetID(), A))
{
di << "There is no TDataStd_ExtStringArray under label" << "\n";
return 1;
}
Standard_Integer index = Draw::Atoi(arg[3]);
if (index < A->Lower() || index > A->Upper())
{
di << "Index is out of range\n";
return 1;
}
else
{
const TCollection_ExtendedString& value = A->Value(index);
di << value;
}
return 0;
}
//=======================================================================
// function : ChangeExtStrArray (DF, entry, indx, val )
//=======================================================================
static Standard_Integer DDataStd_ChangeExtStrArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_ExtStringArray) A;
if (!label.FindAttribute(TDataStd_ExtStringArray::GetID(), A))
{
di << "There is no TDataStd_ExtStringArray at label" << "\n";
return 1;
}
Standard_Integer indx = Draw::Atoi(arg[3]);
TCollection_ExtendedString val(arg[4]);
Standard_Integer low = A->Lower(), up = A->Upper();
if (low <= indx && indx <= up)
A->SetValue(indx, val); // TColStd_HArray1OfExtendedString
else
{
Handle(TColStd_HArray1OfExtendedString) Arr = A->Array();
Handle(TColStd_HArray1OfExtendedString) arr;
Standard_Integer i;
if (indx > up)
{
up = indx;
arr = new TColStd_HArray1OfExtendedString(low, up);
for (i = low; i <= Arr->Upper(); i++)
arr->SetValue(i, Arr->Value(i));
for (i = Arr->Upper() + 1; i <= up; i++)
{
if (i == up)
arr->SetValue(i, val);
else
arr->SetValue(i, 0);
}
}
else if (indx < up)
{ // clip array : indx to be negative
up = abs(indx);
arr = new TColStd_HArray1OfExtendedString(low, up);
for (i = low; i < up; i++)
arr->SetValue(i, Arr->Value(i));
arr->SetValue(up, val);
}
A->ChangeArray(arr);
}
return 0;
}
di << "DDataStd_ChangeExtStringArray: Error\n";
return 0;
}
//=======================================================================
// function : DDataStd_KeepUTF
// purpose : SetUTFName (DF, fatherEntry, fileName)
//=======================================================================
static Standard_Integer DDataStd_KeepUTF(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label L;
DDF::AddLabel(DF, arg[2], L);
Standard_CString aFileName(arg[3]);
#ifdef _MSC_VER
std::ifstream anIS(aFileName, std::ios::in | std::ios::binary);
#else
std::ifstream anIS(aFileName);
#endif
if (!anIS)
{
// Can not open file
Message::SendFail() << "Error: can't open file " << aFileName;
return 1;
}
char buf[1024];
char* p;
anIS.getline(buf, 1023, '\n');
// 0xEFBBBF - prefix of UTF8
p = &buf[3]; // skip prefix
TCollection_ExtendedString aES1(p, Standard_True);
TDataStd_Name::Set(L.NewChild(), aES1);
while (anIS.good() && !anIS.eof())
{
anIS.getline(buf, 1023, '\n');
TCollection_ExtendedString aES2(buf, Standard_True);
const TDF_Label& aLab = L.NewChild();
TDataStd_Name::Set(aLab, aES2);
}
return 0;
}
di << "SetUTFName : String is not kept in DF\n";
return 1;
}
//=======================================================================
// function : DDataStd_GetUTFtoFile
// purpose : GetUTF (DF, fatherEntry, fileName)
// : all strings from sub-labels of the <fatherEntry> concatenated
// : in one, converted to UTF8 and kept in the file
//=======================================================================
static Standard_Integer DDataStd_GetUTFtoFile(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label L;
if (!DDF::FindLabel(DF, arg[2], L))
return 1;
TCollection_ExtendedString aES;
Standard_Boolean aF = Standard_False;
TDF_ChildIterator anIt(L);
for (; anIt.More(); anIt.Next())
{
const TDF_Label& aLab = anIt.Value();
if (!aLab.IsNull())
{
Handle(TDataStd_Name) anAtt;
if (aLab.FindAttribute(TDataStd_Name::GetID(), anAtt))
{
if (anAtt->Get().Length())
{
if (aF)
aES += '\n';
aES += anAtt->Get();
aF = Standard_True;
}
}
}
}
if (!aES.Length())
{
Message::SendFail() << "Data is not found in the Document";
return 1;
}
Standard_CString aFileName(arg[3]);
#ifdef _MSC_VER
std::ofstream anOS(aFileName, std::ios::in | std::ios::binary | std::ios::ate);
#else
std::ofstream anOS(aFileName, std::ios::ate);
#endif
if (!anOS)
{
// A problem with the stream
#ifdef OCCT_DEBUG
std::cout << "Error: problem with the file stream, rdstate = " << anOS.rdstate() << std::endl;
#endif
}
unsigned char prefix[4] = {0xEF, 0xBB, 0xBF, 0x00};
anOS.write((char*)&prefix[0], 3);
Standard_Integer n = aES.LengthOfCString();
Standard_PCharacter aCstr = (Standard_PCharacter)Standard::Allocate(n + 1);
n = aES.ToUTF8CString(aCstr);
anOS.write((char*)&aCstr[0], n);
anOS.close();
Standard::Free(aCstr);
return 0;
}
di << "GetUTF : Data is not extracted to the specified file \n";
return 1;
}
//=======================================================================
// function : SetByteArray (DF, entry, isDelta, [-g Guid,] From, To, elmt1, elmt2, ... )
//=======================================================================
static Standard_Integer DDataStd_SetByteArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 6)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
Standard_GUID guid;
Standard_Boolean isGuid(Standard_False);
Standard_Character c1(arg[4][0]), c2(arg[4][1]);
if (c1 == '-' && c2 == 'g')
{ // guid
if (!Standard_GUID::CheckGUIDFormat(arg[5]))
{
di << "DDataStd_SetByteArray: The format of GUID is invalid\n";
return 1;
}
guid = Standard_GUID(arg[5]);
isGuid = Standard_True;
}
Standard_Integer j(4);
if (isGuid)
j = 6;
if ((strlen(arg[j]) > MAXLENGTH || strlen(arg[j + 1]) > MAXLENGTH)
|| !TCollection_AsciiString(arg[j]).IsIntegerValue()
|| !TCollection_AsciiString(arg[j + 1]).IsIntegerValue())
{
di << "DDataStd_SetByteArray: From, To may be wrong\n";
return 1;
}
Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi(arg[j + 1]);
di << "Array of Standard_Byte with bounds from = " << From << " to = " << To << "\n";
Handle(TDataStd_ByteArray) A;
if (!isGuid)
A = TDataStd_ByteArray::Set(label, From, To, isDelta);
else
A = TDataStd_ByteArray::Set(label, guid, From, To, isDelta);
if ((!isGuid && nb > 6) || (isGuid && nb > 8))
{
j = j + 2;
for (Standard_Integer i = From; i <= To; ++i)
{
Standard_Integer ival = Draw::Atoi(arg[j]);
if (ival < 0 || 255 < ival)
{
Message::SendFail() << "Bad value = " << ival;
return 1;
}
A->SetValue(i, (Standard_Byte)ival);
j++;
}
}
return 0;
}
di << "DDataStd_SetByteArray: Error\n";
return 1;
}
//=======================================================================
// function : SetByteArrayValue (DF, entry, index, value)
//=======================================================================
static Standard_Integer DDataStd_SetByteArrayValue(Draw_Interpretor&,
Standard_Integer,
const char** arg)
{
// Get document.
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
// Get label.
TDF_Label label;
if (!DDF::AddLabel(DF, arg[2], label))
return 1;
// Get index and value.
Standard_Integer index = Draw::Atoi(arg[3]);
Standard_Integer value = Draw::Atoi(arg[4]);
// Check the value.
if (value < 0 || 255 < value)
{
Message::SendFail() << "Bad value = " << value;
return 1;
}
// Set new value.
Handle(TDataStd_ByteArray) arr;
if (label.FindAttribute(TDataStd_ByteArray::GetID(), arr))
{
arr->SetValue(index, (Standard_Byte)value);
return 0;
}
return 1;
}
//=======================================================================
// function : SetBooleanArray (DF, entry, [-g Guid,] From, To, elmt1, elmt2, ... )
//=======================================================================
static Standard_Integer DDataStd_SetBooleanArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_GUID guid;
Standard_Boolean isGuid(Standard_False);
Standard_Character c1(arg[3][0]), c2(arg[3][1]);
if (c1 == '-' && c2 == 'g')
{ // guid
if (!Standard_GUID::CheckGUIDFormat(arg[4]))
{
di << "DDataStd_SetBooleanArray: The format of GUID is invalid\n";
return 1;
}
guid = Standard_GUID(arg[4]);
isGuid = Standard_True;
}
Standard_Integer j(3);
if (isGuid)
j = 5;
if ((strlen(arg[j]) > MAXLENGTH || strlen(arg[j + 1]) > MAXLENGTH)
|| !TCollection_AsciiString(arg[j]).IsIntegerValue()
|| !TCollection_AsciiString(arg[j + 1]).IsIntegerValue())
{
di << "DDataStd_SetBooleanArray: From, To may be wrong\n";
return 1;
}
Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi(arg[j + 1]);
di << "Array of Standard_Boolean with bounds from = " << From << " to = " << To << "\n";
Handle(TDataStd_BooleanArray) A;
if (!isGuid)
A = TDataStd_BooleanArray::Set(label, From, To);
else
A = TDataStd_BooleanArray::Set(label, guid, From, To);
if ((!isGuid && nb > 5) || (isGuid && nb > 7))
{
j = j + 2;
for (Standard_Integer i = From; i <= To; i++)
{
Standard_Integer ival = Draw::Atoi(arg[j]);
if (ival > 1)
{
Message::SendFail() << "Bad value (" << i << ") = " << ival << ". 0 or 1 is expected.";
return 1;
}
A->SetValue(i, ival != 0);
j++;
}
}
return 0;
}
di << "DDataStd_SetBooleanArray: Error\n";
return 1;
}
//=======================================================================
// function : SetBooleanArrayValue (DF, entry, index, value)
//=======================================================================
static Standard_Integer DDataStd_SetBooleanArrayValue(Draw_Interpretor& di,
Standard_Integer,
const char** arg)
{
// Get document.
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
// Get label.
TDF_Label label;
if (!DDF::AddLabel(DF, arg[2], label))
return 1;
// Get index and value.
Standard_Integer index = Draw::Atoi(arg[3]);
Standard_Integer value = Draw::Atoi(arg[4]);
// Check the value.
if (value != 0 && value != 1)
{
di << "DDataStd_SetBooleanArrayValue: Error! The value should be either 0 or 1.\n";
return 1;
}
// Set new value.
Handle(TDataStd_BooleanArray) arr;
if (label.FindAttribute(TDataStd_BooleanArray::GetID(), arr))
{
arr->SetValue(index, value != 0);
return 0;
}
return 1;
}
//=======================================================================
// function : DDataStd_SetExtStringList (DF, entry, [-g guid,] elmt1, elmt2, ... )
//=======================================================================
static Standard_Integer DDataStd_SetExtStringList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb > 2)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_GUID guid;
Standard_Boolean isGuid(Standard_False);
if (nb > 4)
{
Standard_Character c1(arg[3][0]), c2(arg[3][1]);
if (c1 == '-' && c2 == 'g')
{ // guid
if (!Standard_GUID::CheckGUIDFormat(arg[4]))
{
di << "DDataStd_SetExtStringList: The format of GUID is invalid\n";
return 1;
}
guid = Standard_GUID(arg[4]);
isGuid = Standard_True;
}
}
Standard_Integer j(0);
Handle(TDataStd_ExtStringList) A;
if (!isGuid)
{
A = TDataStd_ExtStringList::Set(label);
j = 3;
}
else
{
A = TDataStd_ExtStringList::Set(label, guid);
j = 5;
}
for (Standard_Integer i = j; i <= nb - 1; i++)
{
TCollection_ExtendedString aValue(arg[i]);
A->Append(aValue);
}
return 0;
}
di << "DDataStd_SetExtStringList: Error\n";
return 1;
}
//
//=======================================================================
// function : DDataStd_SetReferenceList (DF, entry, [-g guid] elmt1, elmt2, ... )
//=======================================================================
static Standard_Integer DDataStd_SetReferenceList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb > 2)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_GUID guid;
Standard_Boolean isGuid(Standard_False);
if (nb > 4)
{
Standard_Character c1(arg[3][0]), c2(arg[3][1]);
if (c1 == '-' && c2 == 'g')
{ // guid
if (!Standard_GUID::CheckGUIDFormat(arg[4]))
{
di << "DDataStd_SetReferenceList: The format of GUID is invalid\n";
return 1;
}
guid = Standard_GUID(arg[4]);
isGuid = Standard_True;
}
}
Standard_Integer j(0);
Handle(TDataStd_ReferenceList) A;
if (!isGuid)
{
A = TDataStd_ReferenceList::Set(label);
j = 3;
}
else
{
A = TDataStd_ReferenceList::Set(label, guid);
j = 5;
}
for (Standard_Integer i = j; i <= nb - 1; i++)
{
TDF_Label aValueLabel;
DDF::AddLabel(DF, arg[i], aValueLabel);
if (aValueLabel.IsNull())
continue;
A->Append(aValueLabel);
}
return 0;
}
di << "DDataStd_SetReferenceList: Error\n";
return 1;
}
//=======================================================================
// function : SetBooleanList (DF, entry, [-g Guid,] elmt1, elmt2, ... )
//=======================================================================
static Standard_Integer DDataStd_SetBooleanList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb > 2)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_GUID guid;
Standard_Boolean isGuid(Standard_False);
if (nb > 4)
{
Standard_Character c1(arg[3][0]), c2(arg[3][1]);
if (c1 == '-' && c2 == 'g')
{ // guid
if (!Standard_GUID::CheckGUIDFormat(arg[4]))
{
di << "DDataStd_SetBooleanList: The format of GUID is invalid\n";
return 1;
}
guid = Standard_GUID(arg[4]);
isGuid = Standard_True;
}
}
Standard_Integer j(0);
Handle(TDataStd_BooleanList) A;
if (!isGuid)
{
A = TDataStd_BooleanList::Set(label);
j = 3;
}
else
{
A = TDataStd_BooleanList::Set(label, guid);
j = 5;
}
for (Standard_Integer i = j; i <= nb - 1; i++)
{
Standard_Integer ival = Draw::Atoi(arg[i]);
if (ival > 1)
{
Message::SendFail() << "Bad value = " << ival << ". 0 or 1 is expected.";
return 1;
}
A->Append(ival != 0);
}
return 0;
}
di << "DDataStd_SetBooleanList: Error\n";
return 1;
}
//=======================================================================
// function : SetIntegerList (DF, entry, [-g guid] elmt1, elmt2, ... )
//=======================================================================
static Standard_Integer DDataStd_SetIntegerList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb > 2)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_GUID guid;
Standard_Boolean isGuid(Standard_False);
if (nb > 4)
{
Standard_Character c1(arg[3][0]), c2(arg[3][1]);
if (c1 == '-' && c2 == 'g')
{ // guid
if (!Standard_GUID::CheckGUIDFormat(arg[4]))
{
di << "DDataStd_SetIntegerList: The format of GUID is invalid\n";
return 1;
}
guid = Standard_GUID(arg[4]);
isGuid = Standard_True;
}
}
Standard_Integer j(0);
Handle(TDataStd_IntegerList) A;
if (!isGuid)
{
A = TDataStd_IntegerList::Set(label);
j = 3;
}
else
{
A = TDataStd_IntegerList::Set(label, guid);
j = 5;
}
for (Standard_Integer i = j; i <= nb - 1; i++)
{
Standard_Integer ival = Draw::Atoi(arg[i]);
A->Append(ival);
}
return 0;
}
di << "DDataStd_SetIntegerList: Error\n";
return 1;
}
//=======================================================================
// function : SetRealList (DF, entry, [-g guid,] elmt1, elmt2, ... )
//=======================================================================
static Standard_Integer DDataStd_SetRealList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb > 2)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_GUID guid;
Standard_Boolean isGuid(Standard_False);
if (nb > 4)
{
Standard_Character c1(arg[3][0]), c2(arg[3][1]);
if (c1 == '-' && c2 == 'g')
{ // guid
if (!Standard_GUID::CheckGUIDFormat(arg[4]))
{
di << "DDataStd_SetRealList: The format of GUID is invalid\n";
return 1;
}
guid = Standard_GUID(arg[4]);
isGuid = Standard_True;
}
}
Standard_Integer j(0);
Handle(TDataStd_RealList) A;
if (!isGuid)
{
A = TDataStd_RealList::Set(label);
j = 3;
}
else
{
A = TDataStd_RealList::Set(label, guid);
j = 5;
}
for (Standard_Integer i = j; i <= nb - 1; i++)
{
Standard_Real fval = Draw::Atof(arg[i]);
A->Append(fval);
}
return 0;
}
di << "DDataStd_SetRealList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_InsertBeforeExtStringList (DF, entry, index, value )
//=======================================================================
static Standard_Integer DDataStd_InsertBeforeExtStringList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_ExtStringList) A;
if (!label.FindAttribute(TDataStd_ExtStringList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
TCollection_ExtendedString value = arg[4];
if (A->InsertBefore(index, value))
return 0;
else
return 1;
}
di << "DDataStd_InsertBeforeExtStringList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_InsertAfterExtStringList (DF, entry, index, value )
//=======================================================================
static Standard_Integer DDataStd_InsertAfterExtStringList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_ExtStringList) A;
if (!label.FindAttribute(TDataStd_ExtStringList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
TCollection_ExtendedString value = arg[4];
if (A->InsertAfter(index, value))
return 0;
else
return 1;
}
di << "DDataStd_InsertAfterExtStringList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_RemoveExtStringList (DF, entry, index )
//=======================================================================
static Standard_Integer DDataStd_RemoveExtStringList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_ExtStringList) A;
if (!label.FindAttribute(TDataStd_ExtStringList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
if (A->Remove(index))
return 0;
else
return 1;
}
di << "DDataStd_RemoveExtStringList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_InsertBeforeBooleanList (DF, entry, index, value )
//=======================================================================
static Standard_Integer DDataStd_InsertBeforeBooleanList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_BooleanList) A;
if (!label.FindAttribute(TDataStd_BooleanList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
Standard_Boolean value = Draw::Atoi(arg[4]) != 0;
if (A->InsertBefore(index, value))
return 0;
else
return 1;
}
di << "DDataStd_InsertBeforeBooleanList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_InsertAfterBooleanList (DF, entry, index, value )
//=======================================================================
static Standard_Integer DDataStd_InsertAfterBooleanList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_BooleanList) A;
if (!label.FindAttribute(TDataStd_BooleanList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
Standard_Boolean value = Draw::Atoi(arg[4]) != 0;
if (A->InsertAfter(index, value))
return 0;
else
return 1;
}
di << "DDataStd_InsertAfterBooleanList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_RemoveBooleanList (DF, entry, index )
//=======================================================================
static Standard_Integer DDataStd_RemoveBooleanList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_BooleanList) A;
if (!label.FindAttribute(TDataStd_BooleanList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
if (A->Remove(index))
return 0;
else
return 1;
}
di << "DDataStd_RemoveBooleanList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_InsertBeforeIntegerList (DF, entry, index, value )
//=======================================================================
static Standard_Integer DDataStd_InsertBeforeIntegerList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_IntegerList) A;
if (!label.FindAttribute(TDataStd_IntegerList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
Standard_Integer value = (Standard_Integer)Draw::Atoi(arg[4]);
if (A->InsertBeforeByIndex(index, value))
return 0;
else
return 1;
}
di << "DDataStd_InsertBeforeIntegerList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_InsertAfterIntegerList (DF, entry, index, value )
//=======================================================================
static Standard_Integer DDataStd_InsertAfterIntegerList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_IntegerList) A;
if (!label.FindAttribute(TDataStd_IntegerList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
Standard_Integer value = (Standard_Integer)Draw::Atoi(arg[4]);
if (A->InsertAfterByIndex(index, value))
return 0;
else
return 1;
}
di << "DDataStd_InsertAfterIntegerList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_RemoveIntegerList (DF, entry, index )
//=======================================================================
static Standard_Integer DDataStd_RemoveIntegerList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_IntegerList) A;
if (!label.FindAttribute(TDataStd_IntegerList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
if (A->RemoveByIndex(index))
return 0;
else
return 1;
}
di << "DDataStd_RemoveIntegerList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_InsertBeforeRealList (DF, entry, index, value )
//=======================================================================
static Standard_Integer DDataStd_InsertBeforeRealList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_RealList) A;
if (!label.FindAttribute(TDataStd_RealList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
Standard_Real value = (Standard_Real)Draw::Atof(arg[4]);
if (A->InsertBeforeByIndex(index, value))
return 0;
else
return 1;
}
di << "DDataStd_InsertBeforeRealList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_InsertAfterRealList (DF, entry, index, value )
//=======================================================================
static Standard_Integer DDataStd_InsertAfterRealList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_RealList) A;
if (!label.FindAttribute(TDataStd_RealList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
Standard_Real value = (Standard_Real)Draw::Atof(arg[4]);
if (A->InsertAfterByIndex(index, value))
return 0;
else
return 1;
}
di << "DDataStd_InsertAfterRealList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_RemoveRealList (DF, entry, index )
//=======================================================================
static Standard_Integer DDataStd_RemoveRealList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_RealList) A;
if (!label.FindAttribute(TDataStd_RealList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
if (A->RemoveByIndex(index))
return 0;
else
return 1;
}
di << "DDataStd_RemoveRealList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_InsertBeforeReferenceList (DF, entry, index, value )
//=======================================================================
static Standard_Integer DDataStd_InsertBeforeReferenceList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_ReferenceList) A;
if (!label.FindAttribute(TDataStd_ReferenceList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
TDF_Label refLabel;
if (!DDF::AddLabel(DF, arg[4], refLabel))
return 1;
if (A->InsertBefore(index, refLabel))
return 0;
else
return 1;
}
di << "DDataStd_InsertBeforeReferenceList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_InsertAfterReferenceList (DF, entry, index, value )
//=======================================================================
static Standard_Integer DDataStd_InsertAfterReferenceList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_ReferenceList) A;
if (!label.FindAttribute(TDataStd_ReferenceList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
TDF_Label refLabel;
if (!DDF::AddLabel(DF, arg[4], refLabel))
return 1;
if (A->InsertAfter(index, refLabel))
return 0;
else
return 1;
}
di << "DDataStd_InsertAfterReferenceList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_RemoveReferenceList (DF, entry, index )
//=======================================================================
static Standard_Integer DDataStd_RemoveReferenceList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Handle(TDataStd_ReferenceList) A;
if (!label.FindAttribute(TDataStd_ReferenceList::GetID(), A))
return 1;
Standard_Integer index = Draw::Atoi(arg[3]);
if (A->Remove(index))
return 0;
else
return 1;
}
di << "DDataStd_RemoveReferenceList: Error\n";
return 1;
}
//=======================================================================
// function : GetByteArray (DF, entry [, guid] )
//=======================================================================
static Standard_Integer DDataStd_GetByteArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_ByteArray::GetID();
Handle(TDataStd_ByteArray) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_ByteArray with the specified GUID at the label" << "\n";
return 1;
}
for (Standard_Integer i = A->Lower(); i <= A->Upper(); i++)
{
di << A->Value(i);
if (i < A->Upper())
di << " ";
}
di << "\n";
return 0;
}
di << "DDataStd_GetByteArray: Error\n";
return 1;
}
//=======================================================================
// function : GetByteArrayValue (DF, entry, index)
//=======================================================================
static Standard_Integer DDataStd_GetByteArrayValue(Draw_Interpretor& di,
Standard_Integer,
const char** arg)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_ByteArray) A;
if (!label.FindAttribute(TDataStd_ByteArray::GetID(), A))
{
di << "There is no TDataStd_ByteArray under label" << "\n";
return 1;
}
Standard_Integer index = Draw::Atoi(arg[3]);
if (index < A->Lower() || index > A->Upper())
{
di << "Index is out of range\n";
return 1;
}
else
{
di << A->Value(index) << "\n";
}
return 0;
}
//=======================================================================
// function : GetBooleanArray (DF, entry [, guid] )
//=======================================================================
static Standard_Integer DDataStd_GetBooleanArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_BooleanArray::GetID();
Handle(TDataStd_BooleanArray) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_BooleanArray at label" << "\n";
return 1;
}
for (Standard_Integer i = A->Lower(); i <= A->Upper(); i++)
{
di << (Standard_Integer)A->Value(i);
if (i < A->Upper())
di << " ";
}
di << "\n";
return 0;
}
di << "DDataStd_GetBooleanArray: Error\n";
return 1;
}
//=======================================================================
// function : GetBooleanArrayValue (DF, entry, index)
//=======================================================================
static Standard_Integer DDataStd_GetBooleanArrayValue(Draw_Interpretor& di,
Standard_Integer,
const char** arg)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_BooleanArray) A;
if (!label.FindAttribute(TDataStd_BooleanArray::GetID(), A))
{
di << "There is no TDataStd_BooleanArray under label" << "\n";
return 1;
}
Standard_Integer index = Draw::Atoi(arg[3]);
if (index < A->Lower() || index > A->Upper())
{
di << "Index is out of range\n";
return 1;
}
else
{
di << ((A->Value(index) == Standard_True) ? "True" : "False") << "\n";
}
return 0;
}
//=======================================================================
// function : ChangeByteArray (DF, entry, indx, val )
//=======================================================================
static Standard_Integer DDataStd_ChangeByteArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_ByteArray) A;
if (!label.FindAttribute(TDataStd_ByteArray::GetID(), A))
{
di << "There is no TDataStd_ByteArray at label" << "\n";
return 1;
}
Standard_Integer indx = Draw::Atoi(arg[3]);
Standard_Integer ival = Draw::Atoi(arg[4]);
if (ival > 255 || ival < 0)
{
di << "DDataStd_ChangeByteArray: Bad value = " << ival << "\n";
return 1;
}
Standard_Integer low = A->Lower(), up = A->Upper();
if (low <= indx && indx <= up)
A->SetValue(indx, (Standard_Byte)ival);
else
{
Handle(TColStd_HArray1OfByte) Arr = A->InternalArray();
Handle(TColStd_HArray1OfByte) arr;
Standard_Integer i;
if (indx > up)
{
up = indx;
arr = new TColStd_HArray1OfByte(low, up);
for (i = low; i <= Arr->Upper(); i++)
arr->SetValue(i, Arr->Value(i));
for (i = Arr->Upper() + 1; i <= up; i++)
{
if (i == up)
arr->SetValue(i, (Standard_Byte)ival);
else
arr->SetValue(i, 0);
}
}
else if (indx < up)
{ // clip array : indx to be negative
up = abs(indx);
arr = new TColStd_HArray1OfByte(low, up);
for (i = low; i < up; i++)
arr->SetValue(i, Arr->Value(i));
arr->SetValue(up, (Standard_Byte)ival);
}
A->ChangeArray(arr);
}
return 0;
}
di << "DDataStd_ChangeByteArray: Error\n";
return 1;
}
//=======================================================================
// function : GetBooleanList (DF, entry [, guid])
//=======================================================================
static Standard_Integer DDataStd_GetBooleanList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_BooleanList::GetID();
Handle(TDataStd_BooleanList) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_BooleanList with the specified Guid at the label" << "\n";
return 1;
}
const TDataStd_ListOfByte& bList = A->List();
Standard_Boolean isEmpty = (bList.Extent() > 0) ? Standard_False : Standard_True;
if (!isEmpty)
{
TDataStd_ListIteratorOfListOfByte itr(bList);
for (; itr.More(); itr.Next())
{
di << (Standard_Integer)itr.Value() << " ";
}
di << "\n";
}
else
di << "List is empty\n";
return 0;
}
di << "DDataStd_GetBooleanList: Error\n";
return 1;
}
//=======================================================================
// function : GetIntegerList (DF, entry [, guid])
//=======================================================================
static Standard_Integer DDataStd_GetIntegerList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_IntegerList::GetID();
Handle(TDataStd_IntegerList) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_IntegerList with the specified GUID at the label" << "\n";
return 1;
}
const TColStd_ListOfInteger& iList = A->List();
Standard_Boolean isEmpty = (iList.Extent() > 0) ? Standard_False : Standard_True;
if (!isEmpty)
{
TColStd_ListIteratorOfListOfInteger itr(iList);
for (; itr.More(); itr.Next())
{
di << itr.Value() << " ";
}
di << "\n";
}
else
di << "List is empty\n";
return 0;
}
di << "DDataStd_GetIntegerList: Error\n";
return 1;
}
//=======================================================================
// function : GetRealList (DF, entry [, guid])
//=======================================================================
static Standard_Integer DDataStd_GetRealList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_RealList::GetID();
Handle(TDataStd_RealList) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_RealList with the specified GUID at the label" << "\n";
return 1;
}
const TColStd_ListOfReal& rList = A->List();
Standard_Boolean isEmpty = (rList.Extent() > 0) ? Standard_False : Standard_True;
if (!isEmpty)
{
TColStd_ListIteratorOfListOfReal itr(rList);
for (; itr.More(); itr.Next())
{
di << itr.Value() << " ";
}
di << "\n";
}
else
di << "List is empty\n";
return 0;
}
di << "DDataStd_GetRealList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_GetExtStringList (DF, entry [, guid])
//=======================================================================
static Standard_Integer DDataStd_GetExtStringList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_ExtStringList::GetID();
Handle(TDataStd_ExtStringList) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_ExtStringList at label" << "\n";
return 1;
}
const TDataStd_ListOfExtendedString& aList = A->List();
Standard_Boolean isEmpty = (aList.Extent() > 0) ? Standard_False : Standard_True;
if (!isEmpty)
{
TDataStd_ListIteratorOfListOfExtendedString itr(aList);
for (; itr.More(); itr.Next())
{
const TCollection_ExtendedString& aStr = itr.Value();
di << aStr << " ";
}
di << "\n";
}
else
{
di << "List is empty\n";
}
return 0;
}
di << "DDataStd_GetExtStringList: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_GetReferenceList (DF, entry [, guid])
//=======================================================================
static Standard_Integer DDataStd_GetReferenceList(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_ReferenceList::GetID();
Handle(TDataStd_ReferenceList) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_ReferenceList [with the specified guid] at the label" << "\n";
return 1;
}
const TDF_LabelList& aList = A->List();
Standard_Boolean isEmpty = (aList.Extent() > 0) ? Standard_False : Standard_True;
if (!isEmpty)
{
TDF_ListIteratorOfLabelList itr(aList);
for (; itr.More(); itr.Next())
{
const TDF_Label& aLabel = itr.Value();
if (!aLabel.IsNull())
{
TCollection_AsciiString entry;
TDF_Tool::Entry(aLabel, entry);
di << entry.ToCString() << " ";
}
}
di << "\n";
}
else
di << "List is empty\n";
return 0;
}
di << "DDataStd_GetReferenceList: Error\n";
return 1;
}
//
//=======================================================================
// function : SetIntPackedMap (DF, entry, isDelta, key1, key2, ...
//=======================================================================
static Standard_Integer DDataStd_SetIntPackedMap(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb > 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
Standard_Integer aNum = nb - 4;
Handle(TDataStd_IntPackedMap) anAtt;
if (!aLabel.FindAttribute(TDataStd_IntPackedMap::GetID(), anAtt))
anAtt = TDataStd_IntPackedMap::Set(aLabel, isDelta);
if (anAtt.IsNull())
{
di << "IntPackedMap attribute is not found or not set" << "\n";
return 1;
}
Standard_Integer j = 4;
TColStd_PackedMapOfInteger aMap;
for (Standard_Integer i = 1; i <= aNum; i++)
{
aMap.Add(Draw::Atoi(arg[j]));
j++;
}
const Handle(TColStd_HPackedMapOfInteger)& aHMap = new TColStd_HPackedMapOfInteger(aMap);
anAtt->ChangeMap(aHMap);
std::cout << "Map extent = " << anAtt->Extent() << std::endl;
return 0;
}
di << "DDataStd_SetIntPackedMap : Error\n";
return 1;
}
//=======================================================================
// function : GetIntPackedMap (DF, entry )
//=======================================================================
static Standard_Integer DDataStd_GetIntPackedMap(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
Handle(TDataStd_IntPackedMap) anAtt;
if (!aLabel.FindAttribute(TDataStd_IntPackedMap::GetID(), anAtt))
{
di << "IntPackedMap attribute is not found or not set" << "\n";
return 1;
}
//
const TColStd_PackedMapOfInteger& aMap = anAtt->GetMap();
TColStd_MapIteratorOfPackedMapOfInteger itr(aMap);
for (Standard_Integer j = 1; itr.More(); itr.Next(), j++)
{
Standard_Integer aKey(itr.Key());
di << aKey << " ";
}
return 0;
}
di << "DDataStd_GetIntPackedMap : Error\n";
return 1;
}
//=======================================================================
// function : ChangeIntPackedMap_Add (DF, entry, Key1, Key2,... )
//=======================================================================
static Standard_Integer DDataStd_ChangeIntPackedMap_Add(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_IntPackedMap) A;
if (!label.FindAttribute(TDataStd_IntPackedMap::GetID(), A))
{
di << "There is no TDataStd_IntPackedMap at label" << "\n";
return 1;
}
Standard_Integer i, aNum = nb - 3;
Handle(TColStd_HPackedMapOfInteger) aHMap = A->GetHMap();
Handle(TColStd_HPackedMapOfInteger) ahMap = new TColStd_HPackedMapOfInteger();
if (!aHMap.IsNull())
{
ahMap->ChangeMap().Assign(aHMap->Map());
for (i = 1; i <= aNum; i++)
{
Standard_Integer val = Draw::Atoi(arg[i + 2]);
if (!ahMap->Map().Contains(val))
ahMap->ChangeMap().Add(val);
}
A->ChangeMap(ahMap);
}
return 0;
}
di << "DDataStd_ChangeIntPackedMap_Add: Error\n";
return 0;
}
//=======================================================================
// function : ChangeIntPackedMap_Rem (DF, entry, Key1, Key2,... )
//=======================================================================
static Standard_Integer DDataStd_ChangeIntPackedMap_Rem(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_IntPackedMap) A;
if (!label.FindAttribute(TDataStd_IntPackedMap::GetID(), A))
{
di << "There is no TDataStd_IntPackedMap at label" << "\n";
return 1;
}
Standard_Integer i, aNum = nb - 3;
Handle(TColStd_HPackedMapOfInteger) aHMap = A->GetHMap();
Handle(TColStd_HPackedMapOfInteger) ahMap = new TColStd_HPackedMapOfInteger();
if (!aHMap.IsNull())
{
ahMap->ChangeMap().Assign(aHMap->Map());
for (i = 1; i <= aNum; i++)
{
Standard_Integer val = Draw::Atoi(arg[i + 2]);
if (ahMap->Map().Contains(val))
ahMap->ChangeMap().Remove(val);
}
A->ChangeMap(ahMap);
}
return 0;
}
di << "DDataStd_ChangeIntPackedMap_Rem: Error\n";
return 0;
}
//=======================================================================
// function : ChangeIntPackedMap_AddRem (DF, entry, Key1, Key2,... )
// : if Keyi exist in map - remove it, if no - add
//=======================================================================
static Standard_Integer DDataStd_ChangeIntPackedMap_AddRem(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Handle(TDataStd_IntPackedMap) A;
if (!label.FindAttribute(TDataStd_IntPackedMap::GetID(), A))
{
di << "There is no TDataStd_IntPackedMap at label" << "\n";
return 1;
}
Standard_Integer i, aNum = nb - 3;
Handle(TColStd_HPackedMapOfInteger) aHMap = A->GetHMap();
Handle(TColStd_HPackedMapOfInteger) ahMap = new TColStd_HPackedMapOfInteger();
if (!aHMap.IsNull())
{
ahMap->ChangeMap().Assign(aHMap->Map());
for (i = 1; i <= aNum; i++)
{
Standard_Integer val = Draw::Atoi(arg[i + 2]);
if (!ahMap->Map().Contains(val))
ahMap->ChangeMap().Add(val);
else
ahMap->ChangeMap().Remove(val);
}
A->ChangeMap(ahMap);
}
return 0;
}
di << "DDataStd_ChangeIntPackedMap_AddRem: Error\n";
return 0;
}
//=======================================================================
// function : SetIntPHugeMap (DF, entry, isDelta Num)
//=======================================================================
static Standard_Integer DDataStd_SetIntPHugeMap(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb > 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
Standard_Integer aNum = Draw::Atoi(arg[4]);
Handle(TDataStd_IntPackedMap) anAtt;
if (!aLabel.FindAttribute(TDataStd_IntPackedMap::GetID(), anAtt))
anAtt = TDataStd_IntPackedMap::Set(aLabel, isDelta);
if (anAtt.IsNull())
{
di << "IntPackedMap attribute is not found or not set" << "\n";
return 1;
}
TColStd_PackedMapOfInteger aMap;
for (Standard_Integer i = 1; i <= aNum; i++)
{
aMap.Add(i);
}
const Handle(TColStd_HPackedMapOfInteger)& aHMap = new TColStd_HPackedMapOfInteger(aMap);
anAtt->ChangeMap(aHMap);
std::cout << "Map extent = " << anAtt->Extent() << std::endl;
return 0;
}
di << "DDataStd_SetIntPHugeMap : Error\n";
return 1;
}
//=======================================================================
// function : SetNDataIntegers (DF, entry , Num
//=======================================================================
static Standard_Integer DDataStd_SetNDataIntegers2(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
anAtt = TDataStd_NamedData::Set(aLabel);
if (anAtt.IsNull())
{
di << "NamedData attribute is not found or not set" << "\n";
return 1;
}
j = 1111;
TCollection_ExtendedString aKey("Key_");
anAtt->LoadDeferredData();
for (Standard_Integer i = 1; i <= aNumP; i++)
{
TCollection_ExtendedString key = aKey + i;
Standard_Integer aVal = j + i;
anAtt->SetInteger(key, aVal);
j += 1;
}
return 0;
}
di << "DDataStd_SetNDataIntegers2 : Error\n";
return 1;
}
//================
//=======================================================================
// function : SetNDataIntArrays2 (DF, entry , key, NumOfArElem )
//=======================================================================
static Standard_Integer DDataStd_SetNDataIntAr2(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
Standard_Integer j;
TCollection_ExtendedString aKey(arg[3]);
Standard_Integer aNum = Draw::Atoi(arg[4]);
if (aNum <= 0)
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
anAtt = TDataStd_NamedData::Set(aLabel);
if (anAtt.IsNull())
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
j = 15;
Handle(TColStd_HArray1OfInteger) anArr = new TColStd_HArray1OfInteger(1, aNum);
for (Standard_Integer i = 1; i <= aNum; i++)
{
Standard_Integer aVal = j++;
anArr->SetValue(i, aVal);
j++;
}
anAtt->LoadDeferredData();
anAtt->SetArrayOfIntegers(aKey, anArr);
return 0;
}
di << "DDataStd_SetNDataIntArrays2 : Error\n";
return 1;
}
//=======================================================================
// function : SetAsciiString(DF, entry, String[, guid])
//=======================================================================
static Standard_Integer DDataStd_SetAsciiString(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4 || nb == 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
TCollection_AsciiString aString(arg[3]);
Standard_GUID aGuid(TDataStd_AsciiString::GetID());
if (nb == 5)
{
if (!Standard_GUID::CheckGUIDFormat(arg[4]))
{
di << "DDataStd_SetAsciiString: The format of GUID is invalid\n";
return 1;
}
aGuid = Standard_GUID(arg[4]);
}
Handle(TDataStd_AsciiString) anAtt = TDataStd_AsciiString::Set(aLabel, aGuid, aString);
if (anAtt.IsNull())
{
di << "AsciiString attribute is not found or not set" << "\n";
return 1;
}
std::cout << "String = " << anAtt->Get().ToCString() << " is kept in DF" << std::endl;
return 0;
}
di << "DDataStd_SetAsciiString : Error\n";
return 1;
}
//
//=======================================================================
// function : GetAsciiString(DF, entry[, guid] )
//=======================================================================
static Standard_Integer DDataStd_GetAsciiString(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3 || nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::FindLabel(DF, arg[2], aLabel);
if (aLabel.IsNull())
di << "Label is not found" << "\n";
Standard_GUID aGuid(TDataStd_AsciiString::GetID());
if (nb == 4)
{
if (!Standard_GUID::CheckGUIDFormat(arg[3]))
{
di << "DDataStd_GetAsciiString: The format of GUID is invalid\n";
return 1;
}
aGuid = Standard_GUID(arg[3]);
}
Handle(TDataStd_AsciiString) anAtt;
if (!aLabel.FindAttribute(aGuid, anAtt))
{
Message::SendFail() << "AsciiString attribute is not found or not set";
return 1;
}
#ifdef DEB_DDataStd
std::cout << "String = " << anAtt->Get().ToCString() << std::endl;
#endif
di << anAtt->Get().ToCString();
return 0;
}
di << "DDataStd_GetAsciiString : Error\n";
return 1;
}
//=======================================================================
// function : SetNDataIntegers (DF, entry , Num, key1, val1, ...
//=======================================================================
static Standard_Integer DDataStd_SetNDataIntegers(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 6)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
//
// TCollection_ExtendedString aString("123456789 0_abcde");
// Standard_Integer aPos = aString.Search(" ");
// std::cout << "From Start = " <<aPos<<std::endl;
// aPos = aString.SearchFromEnd(" ");
// std::cout << "From Start = " <<aPos<<std::endl;
// TCollection_ExtendedString aValue = aString.Split(aPos);
// std::cout << "Value = |"<<aValue<<std::endl;
// std::cout << "aKey = " << aString << "|"<<std::endl;
//
Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
anAtt = TDataStd_NamedData::Set(aLabel);
if (anAtt.IsNull())
{
di << "NamedData attribute is not found or not set" << "\n";
return 1;
}
j = 4;
anAtt->LoadDeferredData();
for (Standard_Integer i = 1; i <= aNumP; i++)
{
TCollection_ExtendedString aKey(arg[j]);
Standard_Integer aVal = Draw::Atoi(arg[j + 1]);
anAtt->SetInteger(aKey, aVal);
j += 2;
}
return 0;
}
di << "DDataStd_SetNDataIntegers : Error\n";
return 1;
}
//=======================================================================
// function : GetNDIntegers(DF, entry )
//=======================================================================
static Standard_Integer DDataStd_GetNDIntegers(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
anAtt->LoadDeferredData();
const TColStd_DataMapOfStringInteger& aMap = anAtt->GetIntegersContainer();
TColStd_DataMapIteratorOfDataMapOfStringInteger itr(aMap);
for (; itr.More(); itr.Next())
{
const TCollection_ExtendedString& aKey(itr.Key());
Standard_Integer aValue = itr.Value();
di << "Key = " << aKey << " Value = " << aValue << "\n";
}
return 0;
}
di << "DDataStd_GetNDIntegers : Error\n";
return 1;
}
//=======================================================================
// function : GetNDInteger(DF, entry, key [drawname])
//=======================================================================
static Standard_Integer DDataStd_GetNDInteger(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
anAtt->LoadDeferredData();
TCollection_ExtendedString aKey(arg[3], Standard_True);
if (!anAtt->HasInteger(aKey))
{
std::cout << "There is no data specified by Key = " << arg[3] << std::endl;
return 1;
}
else
{
std::cout << "Key = " << arg[3] << " Value = " << anAtt->GetInteger(aKey) << std::endl;
if (nb == 5)
Draw::Set(arg[4], anAtt->GetInteger(aKey));
return 0;
}
}
di << "DDataStd_SetNDataIntegers : Error\n";
return 1;
}
//========================== REALS ======================================
//=======================================================================
// function : SetNDataReals (DF, entry , Num, key1, val1, ...
//=======================================================================
static Standard_Integer DDataStd_SetNDataReals(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 6)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
anAtt = TDataStd_NamedData::Set(aLabel);
if (anAtt.IsNull())
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
j = 4;
anAtt->LoadDeferredData();
for (Standard_Integer i = 1; i <= aNumP; i++)
{
TCollection_ExtendedString aKey(arg[j]);
Standard_Real aVal = Draw::Atof(arg[j + 1]);
anAtt->SetReal(aKey, aVal);
j += 2;
}
return 0;
}
di << "DDataStd_SetNDataReals : Error\n";
return 1;
}
//=======================================================================
// function : GetNDReals(DF, entry )
//=======================================================================
static Standard_Integer DDataStd_GetNDReals(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
anAtt->LoadDeferredData();
const TDataStd_DataMapOfStringReal& aMap = anAtt->GetRealsContainer();
TDataStd_DataMapIteratorOfDataMapOfStringReal itr(aMap);
for (; itr.More(); itr.Next())
{
const TCollection_ExtendedString& aKey(itr.Key());
Standard_Real aValue = itr.Value();
di << "Key = " << aKey << " Value = " << aValue << "\n";
}
return 0;
}
di << "DDataStd_GetNDReals : Error\n";
return 1;
}
//=======================================================================
// function : GetNDReal(DF, entry, key [drawname])
//=======================================================================
static Standard_Integer DDataStd_GetNDReal(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
anAtt->LoadDeferredData();
TCollection_ExtendedString aKey(arg[3], Standard_True);
if (!anAtt->HasReal(aKey))
{
Message::SendFail() << "There is no data specified by Key = " << arg[3];
return 1;
}
else
{
std::cout << "Key = " << arg[3] << " Value = " << anAtt->GetReal(aKey) << std::endl;
if (nb == 5)
Draw::Set(arg[4], anAtt->GetReal(aKey));
return 0;
}
}
di << "DDataStd_GetNDReal : Error\n";
return 1;
}
//======================= Strings =======================================
//=======================================================================
// function : SetNDataStrings (DF, entry , Num, key1, val1, ...
//=======================================================================
static Standard_Integer DDataStd_SetNDataStrings(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 6)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
anAtt = TDataStd_NamedData::Set(aLabel);
if (anAtt.IsNull())
{
di << "NamedData attribute is not found or not set" << "\n";
return 1;
}
j = 4;
anAtt->LoadDeferredData();
for (Standard_Integer i = 1; i <= aNumP; i++)
{
TCollection_ExtendedString aKey(arg[j]);
TCollection_ExtendedString aVal(arg[j + 1]);
anAtt->SetString(aKey, aVal);
j += 2;
}
return 0;
}
di << "DDataStd_SetNDataStrings : Error\n";
return 1;
}
//=======================================================================
// function : GetNDStrings(DF, entry )
//=======================================================================
namespace
{
typedef std::pair<TCollection_ExtendedString, TCollection_ExtendedString>
DDataStd_GetNDStrings_Property;
bool isLess(const DDataStd_GetNDStrings_Property& theProperty1,
const DDataStd_GetNDStrings_Property& theProperty2)
{
return theProperty1.first.IsLess(theProperty2.first);
}
} // namespace
static Standard_Integer DDataStd_GetNDStrings(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
anAtt->LoadDeferredData();
const TDataStd_DataMapOfStringString& aMap = anAtt->GetStringsContainer();
std::vector<DDataStd_GetNDStrings_Property> aProperties;
for (TDataStd_DataMapIteratorOfDataMapOfStringString aIt(aMap); aIt.More(); aIt.Next())
{
aProperties.push_back(DDataStd_GetNDStrings_Property(aIt.Key(), aIt.Value()));
}
std::sort(aProperties.begin(), aProperties.end(), isLess);
for (std::vector<DDataStd_GetNDStrings_Property>::size_type aI = 0; aI < aProperties.size();
++aI)
{
di << "Key = " << aProperties[aI].first << " Value = " << aProperties[aI].second << "\n";
}
return 0;
}
di << "DDataStd_GetNDStrings : Error\n";
return 1;
}
//=======================================================================
// function : GetNDString(DF, entry, key [drawname])
//=======================================================================
static Standard_Integer DDataStd_GetNDString(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
di << "NamedData attribute is not found or not set" << "\n";
return 1;
}
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
anAtt->LoadDeferredData();
TCollection_ExtendedString aKey(arg[3], Standard_True);
if (!anAtt->HasString(aKey))
{
Message::SendFail() << "There is no data specified by Key = " << arg[3];
return 1;
}
else
{
TCollection_AsciiString aValue(anAtt->GetString(aKey));
std::cout << "Key = " << arg[3] << " Value = " << aValue.ToCString() << std::endl;
if (nb == 5)
Draw::Set(arg[4], aValue.ToCString());
return 0;
}
}
di << "DDataStd_GetNDString : Error\n";
return 1;
}
//=========================== Bytes =====================================
//=======================================================================
// function : SetNDataBytes (DF, entry , Num, key1, val1, ...
//=======================================================================
static Standard_Integer DDataStd_SetNDataBytes(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 6)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
anAtt = TDataStd_NamedData::Set(aLabel);
if (anAtt.IsNull())
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
j = 4;
anAtt->LoadDeferredData();
for (Standard_Integer i = 1; i <= aNumP; i++)
{
TCollection_ExtendedString aKey(arg[j]);
Standard_Byte aVal = (Standard_Byte)Draw::Atoi(arg[j + 1]);
anAtt->SetByte(aKey, aVal);
j += 2;
}
return 0;
}
di << "DDataStd_SetNDataBytes : Error\n";
return 1;
}
//=======================================================================
// function : GetNDBytes(DF, entry )
//=======================================================================
static Standard_Integer DDataStd_GetNDBytes(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
anAtt->LoadDeferredData();
const TDataStd_DataMapOfStringByte& aMap = anAtt->GetBytesContainer();
TDataStd_DataMapIteratorOfDataMapOfStringByte itr(aMap);
for (; itr.More(); itr.Next())
{
const TCollection_ExtendedString& aKey(itr.Key());
Standard_Byte aValue = itr.Value();
std::cout << "Key = " << aKey << " Value = " << aValue << std::endl;
}
return 0;
}
di << "DDataStd_GetNDBytes : Error\n";
return 1;
}
//=======================================================================
// function : GetNDByte(DF, entry, key [drawname])
//=======================================================================
static Standard_Integer DDataStd_GetNDByte(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
anAtt->LoadDeferredData();
TCollection_ExtendedString aKey(arg[3], Standard_True);
if (!anAtt->HasByte(aKey))
{
Message::SendFail() << "There is no data specified by Key = " << arg[3];
return 1;
}
else
{
std::cout << "Key = " << arg[3] << " Value = " << anAtt->GetByte(aKey) << std::endl;
if (nb == 5)
Draw::Set(arg[4], anAtt->GetByte(aKey));
return 0;
}
}
di << "DDataStd_GetNDByte : Error\n";
return 1;
}
//======================== IntArrays ====================================
//=======================================================================
// function : SetNDataIntArrays (DF, entry , key, NumOfArElem, val1, val2,... )
//=======================================================================
static Standard_Integer DDataStd_SetNDataIntAr(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 6)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
Standard_Integer j;
TCollection_ExtendedString aKey(arg[3]);
Standard_Integer aNum = Draw::Atoi(arg[4]);
if (aNum <= 0)
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
anAtt = TDataStd_NamedData::Set(aLabel);
if (anAtt.IsNull())
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
j = 5;
Handle(TColStd_HArray1OfInteger) anArr = new TColStd_HArray1OfInteger(1, aNum);
for (Standard_Integer i = 1; i <= aNum; i++)
{
Standard_Integer aVal = Draw::Atoi(arg[j]);
anArr->SetValue(i, aVal);
j++;
}
anAtt->LoadDeferredData();
anAtt->SetArrayOfIntegers(aKey, anArr);
return 0;
}
di << "DDataStd_SetNDataIntArrays : Error\n";
return 1;
}
//=======================================================================
// function : GetNDIntArrays(DF, entry )
//=======================================================================
static Standard_Integer DDataStd_GetNDIntArrays(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
anAtt->LoadDeferredData();
const TDataStd_DataMapOfStringHArray1OfInteger& aMap = anAtt->GetArraysOfIntegersContainer();
TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfInteger itr(aMap);
for (; itr.More(); itr.Next())
{
const TCollection_ExtendedString& aKey(itr.Key());
std::cout << "Key = " << aKey << std::endl;
const Handle(TColStd_HArray1OfInteger)& anArrValue = itr.Value();
if (!anArrValue.IsNull())
{
Standard_Integer lower = anArrValue->Lower();
Standard_Integer upper = anArrValue->Upper();
for (Standard_Integer i = lower; i <= upper; i++)
{
Standard_Integer aValue = anArrValue->Value(i);
std::cout << "\tValue(" << i << ") = " << aValue << std::endl;
}
}
else
std::cout << "\tthe specified array is Null " << std::endl;
}
return 0;
}
di << "DDataStd_GetNDIntArrays : Error\n";
return 1;
}
//=======================================================================
// function : GetNDIntArray(DF, entry, key )
//=======================================================================
static Standard_Integer DDataStd_GetNDIntArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
anAtt->LoadDeferredData();
TCollection_ExtendedString aKey(arg[3], Standard_True);
if (!anAtt->HasArrayOfIntegers(aKey))
{
Message::SendFail() << "There is no data specified by Key = " << arg[3];
return 1;
}
else
{
std::cout << "Key = " << arg[3] << std::endl;
Handle(TColStd_HArray1OfInteger) anArrValue = anAtt->GetArrayOfIntegers(aKey);
if (!anArrValue.IsNull())
{
Standard_Integer lower = anArrValue->Lower();
Standard_Integer upper = anArrValue->Upper();
for (Standard_Integer i = lower; i <= upper; i++)
{
Standard_Integer aValue = anArrValue->Value(i);
std::cout << "\tValue(" << i << ") = " << aValue << std::endl;
}
}
else
std::cout << "\tthe specified array is Null or not found" << std::endl;
return 0;
}
}
di << "DDataStd_SetNDataIntArray : Error\n";
return 1;
}
//============================= RealArrays ==============================
//=======================================================================
// function : SetNDataRealArrays (DF entry key NumOfArElem val1 val2... )
//=======================================================================
static Standard_Integer DDataStd_SetNDataRealAr(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 6)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
DDF::AddLabel(DF, arg[2], aLabel);
Standard_Integer j;
TCollection_ExtendedString aKey(arg[3]);
Standard_Integer aNum = Draw::Atoi(arg[4]);
if (aNum <= 0)
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
anAtt = TDataStd_NamedData::Set(aLabel);
if (anAtt.IsNull())
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
j = 5;
Handle(TColStd_HArray1OfReal) anArr = new TColStd_HArray1OfReal(1, aNum);
for (Standard_Integer i = 1; i <= aNum; i++)
{
Standard_Real aVal = Draw::Atof(arg[j]);
anArr->SetValue(i, aVal);
j++;
}
anAtt->LoadDeferredData();
anAtt->SetArrayOfReals(aKey, anArr);
return 0;
}
di << "DDataStd_SetNDataRealArrays : Error\n";
return 1;
}
//=======================================================================
// function : GetNDRealArrays(DF, entry )
//=======================================================================
static Standard_Integer DDataStd_GetNDRealArrays(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
Message::SendFail() << "NamedData attribute is not found or not set";
return 1;
}
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
anAtt->LoadDeferredData();
const TDataStd_DataMapOfStringHArray1OfReal& aMap = anAtt->GetArraysOfRealsContainer();
TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfReal itr(aMap);
for (; itr.More(); itr.Next())
{
const TCollection_ExtendedString& aKey(itr.Key());
std::cout << "Key = " << aKey << std::endl;
const Handle(TColStd_HArray1OfReal)& anArrValue = itr.Value();
if (!anArrValue.IsNull())
{
Standard_Integer lower = anArrValue->Lower();
Standard_Integer upper = anArrValue->Upper();
for (Standard_Integer i = lower; i <= upper; i++)
{
Standard_Real aValue = anArrValue->Value(i);
std::cout << "\tValue(" << i << ") = " << aValue << std::endl;
}
}
else
std::cout << "\tthe specified array is Null " << std::endl;
}
return 0;
}
di << "DDataStd_GetNDRealArrays : Error\n";
return 1;
}
//=======================================================================
// function : GetNDRealArray(DF, entry, key )
//=======================================================================
static Standard_Integer DDataStd_GetNDRealArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label aLabel;
if (!DDF::FindLabel(DF, arg[2], aLabel))
return 1;
Handle(TDataStd_NamedData) anAtt;
if (!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
{
di << "NamedData attribute is not found or not set" << "\n";
return 1;
}
std::cout << std::endl;
std::cout << "NamedData attribute at Label = " << arg[2] << std::endl;
anAtt->LoadDeferredData();
TCollection_ExtendedString aKey(arg[3], Standard_True);
if (!anAtt->HasArrayOfReals(aKey))
{
std::cout << "There is no data specified by Key = " << arg[3] << std::endl;
return 1;
}
else
{
std::cout << "Key = " << arg[3] << std::endl;
Handle(TColStd_HArray1OfReal) anArrValue = anAtt->GetArrayOfReals(aKey);
if (!anArrValue.IsNull())
{
Standard_Integer lower = anArrValue->Lower();
Standard_Integer upper = anArrValue->Upper();
for (Standard_Integer i = lower; i <= upper; i++)
{
Standard_Real aValue = anArrValue->Value(i);
std::cout << "\tValue(" << i << ") = " << aValue << std::endl;
}
}
else
std::cout << "\tthe specified array is Null or not found" << std::endl;
return 0;
}
}
di << "DDataStd_SetNDataRealArray : Error\n";
return 1;
}
//=======================================================================
// function : SetRefArray (DF, entry , [-g Guid,] From, To, elmt1, elmt2, ...
//=======================================================================
static Standard_Integer DDataStd_SetRefArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 5)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
DDF::AddLabel(DF, arg[2], label);
Standard_GUID guid;
Standard_Boolean isGuid(Standard_False);
Standard_Character c1(arg[3][0]), c2(arg[3][1]);
if (c1 == '-' && c2 == 'g')
{ // guid
if (!Standard_GUID::CheckGUIDFormat(arg[4]))
{
di << "DDataStd_SetRefArray: The format of GUID is invalid\n";
return 1;
}
guid = Standard_GUID(arg[4]);
isGuid = Standard_True;
}
Standard_Integer j(3);
if (isGuid)
j = 5;
if ((strlen(arg[j]) > MAXLENGTH || strlen(arg[j + 1]) > MAXLENGTH)
|| !TCollection_AsciiString(arg[j]).IsIntegerValue()
|| !TCollection_AsciiString(arg[j + 1]).IsIntegerValue())
{
di << "DDataStd_SetRefArray: From, To may be wrong\n";
return 1;
}
Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi(arg[j + 1]);
di << "RefArray with bounds from = " << From << " to = " << To << "\n";
Handle(TDataStd_ReferenceArray) A;
if (!isGuid)
A = TDataStd_ReferenceArray::Set(label, From, To);
else
A = TDataStd_ReferenceArray::Set(label, guid, From, To);
if ((!isGuid && nb > 5) || (isGuid && nb > 7))
{
j = j + 2;
for (Standard_Integer i = From; i <= To; i++)
{
TDF_Label aRefLabel;
DDF::AddLabel(DF, arg[j], aRefLabel);
A->SetValue(i, aRefLabel);
j++;
}
}
return 0;
}
di << "DDataStd_SetRefArray: Error\n";
return 1;
}
//=======================================================================
// function : SetRefArrayValue (DF, entry, index, value)
//=======================================================================
static Standard_Integer DDataStd_SetRefArrayValue(Draw_Interpretor&,
Standard_Integer,
const char** arg)
{
// Get document.
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
// Get label.
TDF_Label label;
if (!DDF::AddLabel(DF, arg[2], label))
return 1;
// Get index and value.
Standard_Integer index = Draw::Atoi(arg[3]);
// Set new value.
Handle(TDataStd_ReferenceArray) arr;
if (label.FindAttribute(TDataStd_ReferenceArray::GetID(), arr))
{
TDF_Label aRefLabel;
DDF::AddLabel(DF, arg[4], aRefLabel);
arr->SetValue(index, aRefLabel);
return 0;
}
return 1;
}
//=======================================================================
// function : GetRefArray (DF, entry [, guid])
//=======================================================================
static Standard_Integer DDataStd_GetRefArray(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_ReferenceArray::GetID();
Handle(TDataStd_ReferenceArray) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_ReferenceArray at the label" << "\n";
return 1;
}
for (Standard_Integer i = A->Lower(); i <= A->Upper(); i++)
{
const TDF_Label& aLabel = A->Value(i);
TCollection_AsciiString entry;
TDF_Tool::Entry(aLabel, entry);
di << entry.ToCString();
if (i < A->Upper())
di << " ";
}
di << "\n";
return 0;
}
di << "TDataStd_ReferenceArray: Error\n";
return 1;
}
//=======================================================================
// function : GetRefArrayValue (DF, entry, index)
//=======================================================================
static Standard_Integer DDataStd_GetRefArrayValue(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb >= 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label label;
if (!DDF::FindLabel(DF, arg[2], label))
{
di << "No label for entry" << "\n";
return 1;
}
Standard_GUID aGuid;
if (nb == 4)
{
if (Standard_GUID::CheckGUIDFormat(arg[3]))
aGuid = Standard_GUID(arg[3]);
else
{
di << "Wrong GUID format" << "\n";
return 1;
}
}
else
aGuid = TDataStd_ReferenceArray::GetID();
Handle(TDataStd_ReferenceArray) A;
if (!label.FindAttribute(aGuid, A))
{
di << "There is no TDataStd_ReferenceArray at the label" << "\n";
return 1;
}
Standard_Integer index = Draw::Atoi(arg[3]);
if (index < A->Lower() || index > A->Upper())
{
di << "Index is out of range\n";
return 1;
}
else
{
const TDF_Label& value = A->Value(index);
TCollection_AsciiString entry;
TDF_Tool::Entry(value, entry);
di << entry.ToCString() << "\n";
}
return 0;
}
di << "TDataStd_ReferenceArray: Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_SetTriangulation
// purpose : SetTriangulation (DF, entry, face)
//=======================================================================
static Standard_Integer DDataStd_SetTriangulation(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 4)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
TDF_Label L;
if (!DDF::AddLabel(DF, arg[2], L))
return 1;
// Get face.
TopoDS_Shape face = DBRep::Get(arg[3]);
if (face.IsNull() || face.ShapeType() != TopAbs_FACE)
{
di << "The face is null or not a face.\n";
return 1;
}
// Get triangulation of the face.
TopLoc_Location loc;
Handle(Poly_Triangulation) tris = BRep_Tool::Triangulation(TopoDS::Face(face), loc);
if (tris.IsNull())
{
di << "No triangulation in the face.\n";
return 1;
}
// Set the attribute.
TDataXtd_Triangulation::Set(L, tris);
return 0;
}
di << "DDataStd_SetTriangulation : Error\n";
return 1;
}
//=======================================================================
// function : DDataStd_DumpTriangulation
// purpose : DumpTriangulation (DF, entry)
//=======================================================================
static Standard_Integer DDataStd_DumpMesh(Draw_Interpretor& di,
Standard_Integer nb,
const char** arg)
{
if (nb == 3)
{
Handle(TDF_Data) DF;
if (!DDF::GetDF(arg[1], DF))
return 1;
Handle(TDataXtd_Triangulation) PT;
if (!DDF::Find(DF, arg[2], TDataXtd_Triangulation::GetID(), PT))
{
di << "The attribute doesn't exist at the label.\n";
return 1;
}
// Dump of the triangulation.
if (PT->Get().IsNull())
{
di << "No triangulation in the attribute.\n";
return 1;
}
di << "Deflection " << PT->Deflection() << "\n";
di << "Number of nodes " << PT->NbNodes() << "\n";
di << "Number of triangles " << PT->NbTriangles() << "\n";
if (PT->HasUVNodes())
di << "It has 2d-nodes\n";
if (PT->HasNormals())
di << "It has normals\n";
return 0;
}
di << "DDataStd_DumpTriangulation : Error\n";
return 1;
}
//=================================================================================================
void DDataStd::BasicCommands(Draw_Interpretor& theCommands)
{
static Standard_Boolean done = Standard_False;
if (done)
return;
done = Standard_True;
const char* g = "DData : Standard Attribute Commands";
// SET
theCommands.Add("SetInteger",
"SetInteger (DF, entry, value [,guid])",
__FILE__,
DDataStd_SetInteger,
g);
theCommands.Add("SetIntArray",
"SetIntArray (DF, entry, isDelta, [-g Guid,] From, To [, elmt1, elmt2, ...])",
__FILE__,
DDataStd_SetIntArray,
g);
theCommands.Add("SetIntArrayValue",
"SetIntArrayValue (DF, entry, index, value)",
__FILE__,
DDataStd_SetIntArrayValue,
g);
theCommands.Add("SetReal", "SetReal (DF, entry, value [,guid])", __FILE__, DDataStd_SetReal, g);
theCommands.Add("SetRealArray",
"SetRealArray (DF, entry, isDelta, [-g Guid,] From, To [, elmt1, elmt2, ...])",
__FILE__,
DDataStd_SetRealArray,
g);
theCommands.Add("SetRealArrayValue",
"SetRealArrayValue (DF, entry, index, value)",
__FILE__,
DDataStd_SetRealArrayValue,
g);
theCommands.Add("SetByteArray",
"SetByteArray (DF, entry, isDelta, [-g Guid,] From, To [, elmt1, elmt2, ...])",
__FILE__,
DDataStd_SetByteArray,
g);
theCommands.Add("SetByteArrayValue",
"SetByteArrayValue (DF, entry, index, value)",
__FILE__,
DDataStd_SetByteArrayValue,
g);
theCommands.Add(
"SetExtStringArray",
"SetExtStringArray (DF, entry, isDelta, [-g Guid,] From, To [, elmt1, elmt2, ...])",
__FILE__,
DDataStd_SetExtStringArray,
g);
theCommands.Add("SetExtStringArrayValue",
"SetExtStringArrayValue (DF, entry, index, value)",
__FILE__,
DDataStd_SetExtStringArrayValue,
g);
theCommands.Add("SetRefArray",
"SetRefArray (DF, entry, [-g Guid,] From, To [, lab1, lab2, ...])",
__FILE__,
DDataStd_SetRefArray,
g);
theCommands.Add("SetRefArrayValue",
"SetRefArrayValue (DF, entry, index, value)",
__FILE__,
DDataStd_SetRefArrayValue,
g);
theCommands.Add("SetIntPackedMap",
"SetIntPackedMap (DF, entry, isDelta, key1, key2, ... )",
__FILE__,
DDataStd_SetIntPackedMap,
g);
theCommands.Add("SetReference",
"SetReference (DF, entry, reference)",
__FILE__,
DDataStd_SetReference,
g);
theCommands.Add("SetComment",
"SetComment (DF, entry, comment)",
__FILE__,
DDataStd_SetComment,
g);
theCommands.Add("SetUAttribute",
"SetUAttribute (DF, entry, LocalID)",
__FILE__,
DDataStd_SetUAttribute,
g);
theCommands.Add("SetVariable",
"SetVariable (DF, entry, isConstant[0/1], units)",
__FILE__,
DDataStd_SetVariable,
g);
theCommands.Add("SetAsciiString",
"SetAsciiString (DF, entry, String )",
__FILE__,
DDataStd_SetAsciiString,
g);
theCommands.Add("SetBooleanArray",
"SetBooleanArray (DF, entry, [-g Guid,] From, To [, elmt1, elmt2, ...])",
__FILE__,
DDataStd_SetBooleanArray,
g);
theCommands.Add("SetBooleanArrayValue",
"SetBooleanArrayValue (DF, entry, index, value)",
__FILE__,
DDataStd_SetBooleanArrayValue,
g);
theCommands.Add("SetBooleanList",
"SetBooleanList (DF, entry, [-g Guid,] elmt1, elmt2, ... )",
__FILE__,
DDataStd_SetBooleanList,
g);
theCommands.Add("SetIntegerList",
"SetIntegerList (DF, entry, [-g Guid,] elmt1, elmt2, ... )",
__FILE__,
DDataStd_SetIntegerList,
g);
theCommands.Add("SetRealList",
"SetRealList (DF, entry, [-g guid,] elmt1, elmt2, ... )",
__FILE__,
DDataStd_SetRealList,
g);
theCommands.Add("SetExtStringList",
"SetExtStringList (DF, entry,[-g Guid,] elmt1, elmt2, ... )",
__FILE__,
DDataStd_SetExtStringList,
g);
theCommands.Add("SetReferenceList",
"SetReferenceList (DF, entry, [-g Guid,] elmt1, elmt2, ... )",
__FILE__,
DDataStd_SetReferenceList,
g);
theCommands.Add("SetTriangulation",
"SetTriangulation (DF, entry, face) - adds label with passed entry to \
DF and put an attribute with the triangulation from passed face",
__FILE__,
DDataStd_SetTriangulation,
g);
theCommands.Add("InsertBeforeExtStringList",
"InsertBeforeExtStringList (DF, entry, index, value )",
__FILE__,
DDataStd_InsertBeforeExtStringList,
g);
theCommands.Add("InsertAfterExtStringList",
"InsertAfterExtStringList (DF, entry, index, value )",
__FILE__,
DDataStd_InsertAfterExtStringList,
g);
theCommands.Add("RemoveExtStringList",
"RemoveExtStringList (DF, entry, index )",
__FILE__,
DDataStd_RemoveExtStringList,
g);
theCommands.Add("InsertBeforeBooleanList",
"InsertBeforeBooleanList (DF, entry, index, value )",
__FILE__,
DDataStd_InsertBeforeBooleanList,
g);
theCommands.Add("InsertAfterBooleanList",
"InsertAfterBooleanList (DF, entry, index, value )",
__FILE__,
DDataStd_InsertAfterBooleanList,
g);
theCommands.Add("RemoveBooleanList",
"RemoveBooleanList (DF, entry, index )",
__FILE__,
DDataStd_RemoveBooleanList,
g);
theCommands.Add("InsertBeforeIntegerList",
"InsertBeforeIntegerList (DF, entry, index, value )",
__FILE__,
DDataStd_InsertBeforeIntegerList,
g);
theCommands.Add("InsertAfterIntegerList",
"InsertAfterIntegerList (DF, entry, index, value )",
__FILE__,
DDataStd_InsertAfterIntegerList,
g);
theCommands.Add("RemoveIntegerList",
"RemoveIntegerList (DF, entry, index )",
__FILE__,
DDataStd_RemoveIntegerList,
g);
theCommands.Add("InsertBeforeRealList",
"InsertBeforeRealList (DF, entry, index, value )",
__FILE__,
DDataStd_InsertBeforeRealList,
g);
theCommands.Add("InsertAfterRealList",
"InsertAfterRealList (DF, entry, index, value )",
__FILE__,
DDataStd_InsertAfterRealList,
g);
theCommands.Add("RemoveRealList",
"RemoveRealList (DF, entry, index )",
__FILE__,
DDataStd_RemoveRealList,
g);
theCommands.Add("InsertBeforeReferenceList",
"InsertBeforeReferenceList (DF, entry, index, value )",
__FILE__,
DDataStd_InsertBeforeReferenceList,
g);
theCommands.Add("InsertAfterReferenceList",
"InsertAfterReferenceList (DF, entry, index, value )",
__FILE__,
DDataStd_InsertAfterReferenceList,
g);
theCommands.Add("RemoveReferenceList",
"RemoveReferenceList (DF, entry, index )",
__FILE__,
DDataStd_RemoveReferenceList,
g);
// GET
theCommands.Add("GetAsciiString",
"GetAsciiString (DF, entry )",
__FILE__,
DDataStd_GetAsciiString,
g);
theCommands.Add("GetInteger",
"GetInteger (DF, entry, [drawname][, guid])",
__FILE__,
DDataStd_GetInteger,
g);
theCommands.Add("GetIntArray",
"GetIntArray (DF, entry [, guid])",
__FILE__,
DDataStd_GetIntArray,
g);
theCommands.Add("GetIntArrayValue",
"GetIntArrayValue (DF, entry, index)",
__FILE__,
DDataStd_GetIntArrayValue,
g);
theCommands.Add("GetRealArray",
"GetRealArray (DF, entry [, guid])",
__FILE__,
DDataStd_GetRealArray,
g);
theCommands.Add("GetRealArrayValue",
"GetRealArrayValue (DF, entry, index)",
__FILE__,
DDataStd_GetRealArrayValue,
g);
theCommands.Add("GetByteArray",
"GetByteArray (DF, entry [, guid])",
__FILE__,
DDataStd_GetByteArray,
g);
theCommands.Add("GetByteArrayValue",
"GetByteArrayValue (DF, entry, index)",
__FILE__,
DDataStd_GetByteArrayValue,
g);
theCommands.Add("GetExtStringArray",
"GetExtStringArray (DF, entry [, guid])",
__FILE__,
DDataStd_GetExtStringArray,
g);
theCommands.Add("GetExtStringArrayValue",
"GetExtStringArrayValue (DF, entry, index)",
__FILE__,
DDataStd_GetExtStringArrayValue,
g);
theCommands.Add("GetRefArray",
"GetRefArray (DF, entry [, guid])",
__FILE__,
DDataStd_GetRefArray,
g);
theCommands.Add("GetRefArrayValue",
"GetRefArrayValue (DF, entry, index)",
__FILE__,
DDataStd_GetRefArrayValue,
g);
theCommands.Add("GetIntPackedMap",
"GetIntPackedMap (DF, entry )",
__FILE__,
DDataStd_GetIntPackedMap,
g);
theCommands.Add("GetReal",
"GetReal (DF, entry, [drawname][, guid])",
__FILE__,
DDataStd_GetReal,
g);
theCommands.Add("GetReference", "GetReference (DF, entry)", __FILE__, DDataStd_GetReference, g);
theCommands.Add("GetComment", "GetComment (DF, entry)", __FILE__, DDataStd_GetComment, g);
theCommands.Add("Self", "Self(document, entry)", __FILE__, DDataStd_Self, g);
theCommands.Add("GetUAttribute",
"GetUAttribute (DF, entry)",
__FILE__,
DDataStd_GetUAttribute,
g);
theCommands.Add("GetVariable",
"GetVariable (DF, entry, [isConstant], [units])",
__FILE__,
DDataStd_GetVariable,
g);
theCommands.Add("SetRelation",
"SetRelation (DF, entry, expression, var1[, var2, ...])",
__FILE__,
DDataStd_SetRelation,
g);
theCommands.Add("DumpRelation", "DumpRelation (DF, entry)", __FILE__, DDataStd_DumpRelation, g);
theCommands.Add("GetBooleanArray",
"GetBooleanArray (DF, entry [, guid])",
__FILE__,
DDataStd_GetBooleanArray,
g);
theCommands.Add("GetBooleanArrayValue",
"GetBooleanArrayValue (DF, entry, index)",
__FILE__,
DDataStd_GetBooleanArrayValue,
g);
theCommands.Add("GetBooleanList",
"GetBooleanList (DF, entry [, guid])",
__FILE__,
DDataStd_GetBooleanList,
g);
theCommands.Add("GetIntegerList",
"GetIntegerList (DF, entry [, guid])",
__FILE__,
DDataStd_GetIntegerList,
g);
theCommands.Add("GetRealList",
"GetRealList (DF, entry [, guid])",
__FILE__,
DDataStd_GetRealList,
g);
theCommands.Add("GetExtStringList",
"GetExtStringList (DF, entry [, guid])",
__FILE__,
DDataStd_GetExtStringList,
g);
theCommands.Add("GetReferenceList",
"GetReferenceList (DF, entry [, guid])",
__FILE__,
DDataStd_GetReferenceList,
g);
// ========================= UTF =====================================
const char* ggg = "UTF Commands";
theCommands.Add("SetUTFName",
"SetUTFName (DF, entry, fileName)",
__FILE__,
DDataStd_KeepUTF,
ggg);
theCommands.Add("GetUTF", "GetUTF (DF, entry, fileName)", __FILE__, DDataStd_GetUTFtoFile, ggg);
//======================= NData Commands ========================
const char* gN = "NData Commands";
theCommands.Add("SetNDataIntegers",
"SetNDataIntegers (DF, entry, NumPairs, key1, val1, ... )",
__FILE__,
DDataStd_SetNDataIntegers,
gN);
theCommands.Add("SetNDataReals",
"SetNDataReals (DF, entry, NumPairs, key1, val1, ... )",
__FILE__,
DDataStd_SetNDataReals,
gN);
theCommands.Add("SetNDataStrings",
"SetNDataStrings (DF, entry, NumPairs, key1, val1, ... )",
__FILE__,
DDataStd_SetNDataStrings,
gN);
theCommands.Add("SetNDataBytes",
"SetNDataBytes (DF, entry, NumPairs, key1, val1, ... )",
__FILE__,
DDataStd_SetNDataBytes,
gN);
theCommands.Add("SetNDataIntArrays",
"SetNDataIntArrays (DF entry entry key NumOfArrElems val1 val2... )",
__FILE__,
DDataStd_SetNDataIntAr,
gN);
theCommands.Add("SetNDataRealArrays",
"SetNDataRealArrays (DF entry key NumOfArrElems val1 val2... )",
__FILE__,
DDataStd_SetNDataRealAr,
gN);
// GET
theCommands.Add("GetNDIntegers",
"GetNDIntegers (DF, entry )",
__FILE__,
DDataStd_GetNDIntegers,
g);
theCommands.Add("GetNDInteger",
"GetNDInteger (DF entry key [drawname])",
__FILE__,
DDataStd_GetNDInteger,
g);
theCommands.Add("GetNDReals", "GetNDReals (DF entry )", __FILE__, DDataStd_GetNDReals, g);
theCommands.Add("GetNDReal",
"GetNDReal (DF entry key [drawname])",
__FILE__,
DDataStd_GetNDReal,
g);
theCommands.Add("GetNDStrings", "GetNDStrings (DF entry )", __FILE__, DDataStd_GetNDStrings, g);
theCommands.Add("GetNDString",
"GetNDString (DF entry key [drawname])",
__FILE__,
DDataStd_GetNDString,
g);
theCommands.Add("GetNDBytes", "GetNDBytes (DF entry )", __FILE__, DDataStd_GetNDBytes, g);
theCommands.Add("GetNDByte",
"GetNDByte (DF entry key [drawname])",
__FILE__,
DDataStd_GetNDByte,
g);
theCommands.Add("GetNDIntArrays",
"GetNDIntArrays (DF, entry )",
__FILE__,
DDataStd_GetNDIntArrays,
g);
theCommands.Add("GetNDIntArray",
"GetNDIntArray (DF entry key )",
__FILE__,
DDataStd_GetNDIntArray,
g);
theCommands.Add("GetNDRealArrays",
"GetNDRealArrays (DF entry )",
__FILE__,
DDataStd_GetNDRealArrays,
g);
theCommands.Add("GetNDRealArray",
"GetNDRealArray (DF entry key )",
__FILE__,
DDataStd_GetNDRealArray,
g);
//====================== Change =======================
theCommands.Add("ChangeByteArray",
"ChangeByteArray (DF, entry, indx, value )",
__FILE__,
DDataStd_ChangeByteArray,
g);
theCommands.Add("ChangeIntArray",
"ChangeIntArray (DF, entry, indx, value )",
__FILE__,
DDataStd_ChangeIntArray,
g);
theCommands.Add("ChangeRealArray",
"ChangeRealArray (DF, entry, indx, value )",
__FILE__,
DDataStd_ChangeRealArray,
g);
theCommands.Add("ChangeExtStrArray",
"ChangeExtStrArray (DF, entry, indx, value )",
__FILE__,
DDataStd_ChangeExtStrArray,
g);
theCommands.Add("ChangeIntPackedMap_Add",
"ChangeIntPackedMAp_Add (DF, entry, key[,key [...]] )",
__FILE__,
DDataStd_ChangeIntPackedMap_Add,
g);
theCommands.Add("ChangeIntPackedMap_Rem",
"ChangeIntPackedMAp_Rem (DF, entry, key[,key [...]] )",
__FILE__,
DDataStd_ChangeIntPackedMap_Rem,
g);
theCommands.Add("ChangeIntPackedMap_AddRem",
"ChangeIntPackedMAp_AddRem (DF, entry, key[,key [...]] )",
__FILE__,
DDataStd_ChangeIntPackedMap_AddRem,
g);
//=========================================================
// TFunction commands
const char* gg = "DFunction Commands";
theCommands.Add("SetFunction",
"SetFunction (DF, entry, guid, failure)",
__FILE__,
DDataStd_SetFunction,
gg);
theCommands.Add("GetFunction",
"GetFunction (DF, entry, guid(out), failure(out))",
__FILE__,
DDataStd_GetFunction,
gg);
//=========================================================
theCommands.Add("DumpTriangulation",
"DumpTriangulations (DF, entry) - dumps info about triangulation that \
stored in DF in triangulation attribute of a label with the passed entry",
__FILE__,
DDataStd_DumpMesh,
g);
//======================================================================
//======= for internal use
theCommands.Add("SetNDataIntegers2",
"SetNDataIntegers2 (DF, entry, NumPair )",
__FILE__,
DDataStd_SetNDataIntegers2,
gN);
theCommands.Add("SetNDataIntArrays2",
"SetNDataIntArrays2 (DF entry entry key NumOfArrElems)",
__FILE__,
DDataStd_SetNDataIntAr2,
gN);
theCommands.Add("SetIntArrayT",
"SetIntArrayT (DF, entry, isDelta, From, To )",
__FILE__,
DDataStd_SetIntArrayTest,
g);
theCommands.Add("SetIntPHugeMap",
"SetIntPHugeMap (DF, entry, isDelta Num)",
__FILE__,
DDataStd_SetIntPHugeMap,
g);
//=======
}
c5f20409cThis file is pinned to the selected release. Download the original to open it in your design tool.