Loading files
f2929057eThis file is pinned to the selected release. Download the original to open it in your design tool.
// 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.
// #58 rln 28.12.98 Versioning
#include <IFSelect_Act.hxx>
#include <IFSelect_CheckCounter.hxx>
#include <IFSelect_DispGlobal.hxx>
#include <IFSelect_DispPerCount.hxx>
#include <IFSelect_DispPerFiles.hxx>
#include <IFSelect_DispPerOne.hxx>
#include <IFSelect_DispPerSignature.hxx>
#include <IFSelect_EditForm.hxx>
#include <IFSelect_Editor.hxx>
#include <IFSelect_Functions.hxx>
#include <IFSelect_GraphCounter.hxx>
#include <IFSelect_IntParam.hxx>
#include <IFSelect_ListEditor.hxx>
#include <IFSelect_ModifReorder.hxx>
#include <IFSelect_SelectDiff.hxx>
#include <IFSelect_SelectEntityNumber.hxx>
#include <IFSelect_SelectErrorEntities.hxx>
#include <IFSelect_SelectIncorrectEntities.hxx>
#include <IFSelect_SelectIntersection.hxx>
#include <IFSelect_Selection.hxx>
#include <IFSelect_SelectModelEntities.hxx>
#include <IFSelect_SelectModelRoots.hxx>
#include <IFSelect_SelectPointed.hxx>
#include <IFSelect_SelectRange.hxx>
#include <IFSelect_SelectRoots.hxx>
#include <IFSelect_SelectShared.hxx>
#include <IFSelect_SelectSharing.hxx>
#include <IFSelect_SelectSignature.hxx>
#include <IFSelect_SelectSuite.hxx>
#include <IFSelect_SelectUnion.hxx>
#include <IFSelect_SelectUnknownEntities.hxx>
#include <IFSelect_SessionPilot.hxx>
#include <IFSelect_ShareOut.hxx>
#include <IFSelect_SignatureList.hxx>
#include <IFSelect_SignCounter.hxx>
#include <IFSelect_SignType.hxx>
#include <IFSelect_Transformer.hxx>
#include <IFSelect_WorkLibrary.hxx>
#include <IFSelect_WorkSession.hxx>
#include <Interface_Category.hxx>
#include <Interface_CheckIterator.hxx>
#include <Interface_EntityIterator.hxx>
#include <Interface_InterfaceModel.hxx>
#include <MoniTool_Macros.hxx>
#include <Interface_MSG.hxx>
#include <Interface_Static.hxx>
#include <Interface_Version.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
#include <Standard_Transient.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_HAsciiString.hxx>
#include <NCollection_Sequence.hxx>
#include <NCollection_HSequence.hxx>
#include <cstdio>
// Decomposition of a file name in its parts : prefix, root, suffix
static void SplitFileName(const char* const filename,
TCollection_AsciiString& prefix,
TCollection_AsciiString& fileroot,
TCollection_AsciiString& suffix)
{
int nomdeb, nomfin, nomlon;
TCollection_AsciiString resfile(filename);
nomlon = resfile.Length();
nomdeb = resfile.SearchFromEnd("/");
if (nomdeb <= 0)
{
nomdeb = resfile.SearchFromEnd("\\"); // for NT
}
if (nomdeb < 0)
{
nomdeb = 0;
}
nomfin = resfile.SearchFromEnd(".");
if (nomfin < nomdeb)
{
nomfin = nomlon + 1;
}
if (nomdeb > 0)
{
prefix = resfile.SubString(1, nomdeb);
}
fileroot = resfile.SubString(nomdeb + 1, nomfin - 1);
if (nomfin <= nomlon)
{
suffix = resfile.SubString(nomfin, nomlon);
}
}
// Functions defines a certain number of commands
// registered in the Activator Dictionary (by unit Acts)
// The actions themselves are grouped at the end of file
// The definitions
static IFSelect_ReturnStatus funstatus(const occ::handle<IFSelect_SessionPilot>&)
{
// **** Version & cie ****
// #58 rln
Message_Messenger::StreamBuffer sout = Message::SendInfo();
sout << "Processor Version : " << XSTEP_PROCESSOR_VERSION << '\n';
sout << "OL Version : " << XSTEP_SYSTEM_VERSION << '\n';
sout << "Configuration : " << XSTEP_Config << '\n';
sout << "UL Names : " << XSTEP_ULNames << '\n';
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun1(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** ToggleHandler ****
bool hand = !WS->ErrorHandle();
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (hand)
{
sout << " -- Mode Catch Error now Active" << '\n';
}
else
{
sout << " -- Mode Catch Error now Inactive" << '\n';
}
WS->SetErrorHandle(hand);
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun3(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** XRead / Load ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Read/Load : give file name !" << '\n';
return IFSelect_RetError;
}
if (WS->Protocol().IsNull())
{
sout << "Protocol not defined" << '\n';
return IFSelect_RetError;
}
if (WS->WorkLibrary().IsNull())
{
sout << "WorkLibrary not defined" << '\n';
return IFSelect_RetError;
}
IFSelect_ReturnStatus status = WS->ReadFile(arg1);
// status: 0 OK, 1 read error, 2 Fail(try/catch),
// -1 file not found, -2 reading done but empty result
switch (status)
{
case IFSelect_RetVoid:
sout << "file:" << arg1 << " gives empty result" << '\n';
break;
case IFSelect_RetError:
sout << "file:" << arg1 << " could not be opened" << '\n';
break;
case IFSelect_RetDone:
sout << "file:" << arg1 << " read" << '\n';
break;
case IFSelect_RetFail:
sout << "file:" << arg1 << " : error while reading" << '\n';
break;
case IFSelect_RetStop:
sout << "file:" << arg1 << " : EXCEPTION while reading" << '\n';
break;
default:
sout << "file:" << arg1 << " could not be read" << '\n';
break;
}
if (status != IFSelect_RetDone)
{
return status;
}
// sout<<" - clearing list of already written files"<<std::endl;
WS->BeginSentFiles(true);
return status;
}
static IFSelect_ReturnStatus fun4(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Write All ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Write All : give file name !" << '\n';
return IFSelect_RetError;
}
return WS->SendAll(arg1);
}
static IFSelect_ReturnStatus fun5(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// const char* const arg2 = pilot->Arg(2);
// **** Write Selected ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Write Selected : give file name + givelist !" << '\n';
return IFSelect_RetError;
}
occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> result =
IFSelect_Functions::GiveList(WS, pilot->CommandPart(2));
if (result.IsNull())
{
sout << "No entity selected" << '\n';
return IFSelect_RetError;
}
else
{
sout << "Nb Entities selected : " << result->Length() << '\n';
}
occ::handle<IFSelect_SelectPointed> sp = new IFSelect_SelectPointed;
sp->SetList(result);
return WS->SendSelected(arg1, sp);
}
static IFSelect_ReturnStatus fun6(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Write Entite(s) ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Write Entitie(s) : give file name + n0s entitie(s)!" << '\n';
return IFSelect_RetError;
}
int ko = 0;
occ::handle<IFSelect_SelectPointed> sp = new IFSelect_SelectPointed;
for (int ia = 2; ia < argc; ia++)
{
int id = pilot->Number(pilot->Arg(ia));
if (id > 0)
{
occ::handle<Standard_Transient> item = WS->StartingEntity(id);
if (sp->Add(item))
{
sout << "Added:no." << id << '\n';
}
else
{
sout << " Fail Add n0." << id << '\n';
ko++;
}
}
else
{
sout << "Not an entity number:" << pilot->Arg(ia) << '\n';
ko++;
}
}
if (ko > 0)
{
sout << ko << " bad arguments, abandon" << '\n';
return IFSelect_RetError;
}
return WS->SendSelected(arg1, sp);
}
static IFSelect_ReturnStatus fun7(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Entity Label ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give entity number" << '\n';
return IFSelect_RetError;
}
if (!WS->HasModel())
{
sout << "No loaded model, abandon" << '\n';
return IFSelect_RetError;
}
int nument = WS->NumberFromLabel(arg1);
if (nument <= 0 || nument > WS->NbStartingEntities())
{
sout << "Not a suitable number: " << arg1 << '\n';
return IFSelect_RetError;
}
sout << "N0." << nument << " ->Label in Model : ";
WS->Model()->PrintLabel(WS->StartingEntity(nument), sout);
sout << '\n';
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun8(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Entity Number ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give label to search" << '\n';
return IFSelect_RetError;
}
if (!WS->HasModel())
{
sout << "No loaded model, abandon" << '\n';
return IFSelect_RetError;
}
const occ::handle<Interface_InterfaceModel>& model = WS->Model();
int i, cnt = 0;
bool exact = false;
sout << " ** Search Entity Number for Label : " << arg1 << '\n';
for (i = model->NextNumberForLabel(arg1, 0, exact); i != 0;
i = model->NextNumberForLabel(arg1, i, exact))
{
cnt++;
sout << " ** Found n0/id:";
model->Print(model->Value(i), sout);
sout << '\n';
}
if (cnt == 0)
{
sout << " ** No Match" << '\n';
}
else if (cnt == 1)
{
sout << " ** 1 Match" << '\n';
}
else
{
sout << cnt << " Matches" << '\n';
}
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun9(const occ::handle<IFSelect_SessionPilot>& pilot)
{
// **** List Types ****
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
occ::handle<IFSelect_Signature> signtype = WS->SignType();
if (signtype.IsNull())
{
signtype = new IFSelect_SignType;
}
occ::handle<IFSelect_SignCounter> counter = new IFSelect_SignCounter(signtype, false);
return pilot->ExecuteCounter(counter, 1);
}
static IFSelect_ReturnStatus funcount(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg0 = pilot->Arg(0);
const char* const arg1 = pilot->Arg(1);
bool listmode = (arg0[0] == 'l');
// **** List Counter ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Designer signature ou compteur, + facultatif selection + facultatif entite" << '\n';
sout << " signature/compteur seul -> tout le modele" << '\n'
<< " sign/compteur + selection -> cette selection, evaluation normale" << '\n'
<< " sign/compteur + sel + num -> cette selection evaluee sur entite n0 num" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_SignCounter, counter, WS->NamedItem(arg1));
if (counter.IsNull())
{
DeclareAndCast(IFSelect_Signature, signa, WS->NamedItem(arg1));
if (!signa.IsNull())
{
counter = new IFSelect_SignCounter(signa, false, listmode);
}
}
// occ::handle<IFSelect_Selection> sel;
// int n3 = 0; if (argc > 3) n3 = WS->NumberFromLabel(arg3);
// if (argc > 2) sel = GetCasted(IFSelect_Selection,WS->NamedItem(arg2));
// if (counter.IsNull() || (argc > 2 && n3 <= 0 && sel.IsNull()) ) {
// sout<<"Nom:"<<arg1; if (argc > 2) sout<<" et/ou "<<arg2;
// sout<<" incorrect (demande: compteur ou signature [selection])"<<std::endl;
// return IFSelect_RetError;
// }
// Addition: if Selection, we apply a GraphCounter
// And in this case, we can have several: the limit is the keyword "on"
int onflag = 0;
int i; // svv Jan11 2000 : porting on DEC
for (i = 2; i < argc; i++)
{
if (!strcmp(pilot->Arg(i), "on"))
{
onflag = i;
break;
}
}
occ::handle<IFSelect_Selection> sel = WS->GiveSelection(arg1);
DeclareAndCast(IFSelect_SelectDeduct, seld, sel);
if (!seld.IsNull())
{
// If onflag, create a SelectSuite
if (onflag > 2)
{
occ::handle<IFSelect_SelectSuite> suite = new IFSelect_SelectSuite;
for (i = 1; i < onflag; i++)
{
sel = WS->GiveSelection(pilot->Arg(i));
if (!suite->AddInput(sel))
{
sout << "Incorrect definition for applied selection" << '\n';
return IFSelect_RetError;
}
}
seld = suite;
}
occ::handle<IFSelect_GraphCounter> gc = new IFSelect_GraphCounter(false, listmode);
gc->SetApplied(seld);
counter = gc;
}
if (counter.IsNull())
{
sout << "Neither Counter nor Signature : " << arg1 << '\n';
return IFSelect_RetError;
}
if (onflag == 0)
{
onflag = 1;
}
IFSelect_PrintCount pcm = IFSelect_ListByItem;
if (arg0[0] == 'c')
{
pcm = IFSelect_CountByItem;
}
if (arg0[0] == 's')
{
pcm = IFSelect_CountSummary;
}
return pilot->ExecuteCounter(counter, onflag + 1, pcm);
}
static IFSelect_ReturnStatus funsigntype(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Sign Type ****
occ::handle<IFSelect_Signature> signtype = WS->SignType();
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (signtype.IsNull())
{
sout << "signtype actually undefined" << '\n';
}
else
{
occ::handle<TCollection_HAsciiString> str = WS->Name(signtype);
int id = WS->ItemIdent(signtype);
sout << signtype->Label() << '\n';
if (str.IsNull())
{
if (id > 0)
{
sout << "signtype : item n0 " << id << '\n';
}
}
else
{
sout << "signtype : also named as " << str->ToCString() << '\n';
}
}
if (argc < 2)
{
sout << "signtype newitem to change, signtype . to clear" << '\n';
}
else
{
if (arg1[0] == '.' && arg1[1] == '\0')
{
signtype.Nullify();
sout << "signtype now cleared" << '\n';
}
else
{
signtype = GetCasted(IFSelect_Signature, WS->NamedItem(arg1));
if (signtype.IsNull())
{
sout << "Not a Signature : " << arg1 << '\n';
return IFSelect_RetError;
}
else
{
sout << "signtype now set to " << arg1 << '\n';
}
}
WS->SetSignType(signtype);
return IFSelect_RetDone;
}
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus funsigncase(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
const char* const arg1 = pilot->Arg(1);
// **** Sign Case ****
occ::handle<IFSelect_Signature> signcase = GetCasted(IFSelect_Signature, WS->NamedItem(arg1));
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (signcase.IsNull())
{
sout << "Not a Signature : " << arg1 << '\n';
}
else
{
bool hasmin, hasmax;
int valmin, valmax;
if (signcase->IsIntCase(hasmin, valmin, hasmax, valmax))
{
sout << "Signature " << arg1 << " : Integer Case";
if (hasmin)
{
sout << " - Mini:" << valmin;
}
if (hasmax)
{
sout << " - Maxi:" << valmax;
}
sout << '\n';
}
occ::handle<NCollection_HSequence<TCollection_AsciiString>> caselist = signcase->CaseList();
if (caselist.IsNull())
{
sout << "Signature " << arg1 << " : no predefined case, see command count " << arg1 << '\n';
}
else
{
int i, nb = caselist->Length();
sout << "Signature " << arg1 << " : " << nb << " basic cases :" << '\n';
for (i = 1; i <= nb; i++)
{
sout << " " << caselist->Value(i);
}
sout << '\n';
}
}
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun10(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Entity Status ****
int i, nb;
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
nb = Interface_Category::NbCategories();
sout << " Categories defined :" << nb << " i.e. :\n";
for (i = 0; i <= nb; i++)
{
sout << "Cat." << i << " : " << Interface_Category::Name(i) << "\n";
}
sout << " On a given entity : give its number" << '\n';
return IFSelect_RetVoid;
}
int num = pilot->Number(arg1);
if (num <= 0 || num > WS->NbStartingEntities())
{
sout << "Not a suitable entity number : " << arg1 << '\n';
return IFSelect_RetError;
}
occ::handle<Standard_Transient> ent = WS->StartingEntity(num);
WS->PrintEntityStatus(ent, sout);
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun11(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** DumpModel (Data) ****
int niv = 0;
// char arg10 = arg1[0];
// if (argc < 2) arg10 = '?';
Message_Messenger::StreamBuffer sout = Message::SendInfo();
switch (arg1[0])
{
case '?':
sout << "? for this help, else give a listing mode (first letter suffices) :\n"
<< " general General Statistics\n roots Roots\n"
<< " entities All Entities\n"
<< " listfails CheckList (fails) per entity\n"
<< " messages CheckList (complete) per entity\n"
<< " fails CheckList (fails) per message (counting)\n"
<< " check CheckList (complete) per message (counting)\n"
<< " totalcheck CheckList (complete) per message (listing n0 ents)\n"
<< " FAILS CheckList (fails) per message (listing complete)\n"
<< " TOTALCHECK CheckList (complete) per message (listing complete)" << '\n';
return IFSelect_RetVoid;
case 'g':
niv = 0;
break;
case 'r':
niv = 1;
break;
case 'e':
niv = 2;
break;
case 'l':
niv = 3;
break;
case 'm':
niv = 4;
break;
case 'c':
niv = 5;
break;
case 't':
niv = 6;
break;
case 'T':
niv = 7;
break;
case 'f':
niv = 8;
break;
case 'F':
niv = 10;
break;
default:
sout << "Unknown Mode . data simply for help" << '\n';
return IFSelect_RetError;
}
WS->TraceDumpModel(niv);
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fundumpent(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
occ::handle<IFSelect_WorkLibrary> WL = WS->WorkLibrary();
int levdef = 0, levmax = 10, level;
WL->DumpLevels(levdef, levmax);
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2 || (argc == 2 && levmax < 0))
{
sout << "Give n0 or id of entity";
if (levmax < 0)
{
sout << " and dump level" << '\n';
}
else
{
sout << " + optional, dump level in [0 - " << levmax << "] , default = " << levdef << '\n';
}
for (level = 0; level <= levmax; level++)
{
const char* help = WL->DumpHelp(level);
if (help[0] != '\0')
{
sout << level << " : " << help << '\n';
}
}
return IFSelect_RetError;
}
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
int num = pilot->Number(arg1);
if (num == 0)
{
return IFSelect_RetError;
}
level = levdef;
if (argc > 2)
{
level = atoi(arg2);
}
occ::handle<Standard_Transient> ent = WS->StartingEntity(num);
if (ent.IsNull())
{
sout << "No entity with given id " << arg1 << " (" << num << ") is found in the current model"
<< '\n';
}
else
{
sout << " -- DUMP Entity n0 " << num << " level " << level << '\n';
WL->DumpEntity(WS->Model(), WS->Protocol(), ent, sout, level);
Interface_CheckIterator chl = WS->CheckOne(ent);
if (!chl.IsEmpty(false))
{
chl.Print(sout, WS->Model(), false);
}
}
// sout << std::flush;
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus funsign(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << " Give signature name + n0 or id of entity" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Signature, sign, WS->NamedItem(arg1));
if (sign.IsNull())
{
sout << "Not a signature : " << arg1 << '\n';
return IFSelect_RetError;
}
int num = pilot->Number(arg2);
occ::handle<Standard_Transient> ent = WS->StartingEntity(num);
if (num == 0)
{
return IFSelect_RetError;
}
sout << "Entity n0 " << num << " : " << WS->SignValue(sign, ent) << '\n';
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus funqp(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << " Give 2 numeros or labels : dad son" << '\n';
return IFSelect_RetError;
}
int n1 = WS->NumberFromLabel(arg1);
int n2 = WS->NumberFromLabel(arg2);
sout << "QueryParent for dad:" << arg1 << ":" << n1 << " and son:" << arg2 << ":" << n2 << '\n';
int qp = WS->QueryParent(WS->StartingEntity(n1), WS->StartingEntity(n2));
if (qp < 0)
{
sout << arg1 << " is not super-entity of " << arg2 << '\n';
}
else if (qp == 0)
{
sout << arg1 << " is same as " << arg2 << '\n';
}
else
{
sout << arg1 << " is super-entity of " << arg2 << " , max level found=" << qp << '\n';
}
// sout<<" Trouve "<<qp<<std::endl;
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun12(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** DumpShare ****
WS->DumpShare();
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun13(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** ListItems ****
WS->ListItems(pilot->Arg(1));
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun14(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** NewInt ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 1)
{
sout << "Give integer value for IntParam" << '\n';
return IFSelect_RetError;
}
occ::handle<IFSelect_IntParam> intpar = new IFSelect_IntParam;
if (argc >= 1)
{
intpar->SetValue(atoi(arg1));
}
return pilot->RecordItem(intpar);
}
static IFSelect_ReturnStatus fun15(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** SetInt ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Donner 2 arguments : nom Parametre et Valeur" << '\n';
return IFSelect_RetError;
}
int val = atoi(arg2);
DeclareAndCast(IFSelect_IntParam, par, WS->NamedItem(arg1));
if (!WS->SetIntValue(par, val))
{
return IFSelect_RetFail;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun16(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** NewText ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 1)
{
sout << "Give text value for TextParam" << '\n';
return IFSelect_RetError;
}
occ::handle<TCollection_HAsciiString> textpar = new TCollection_HAsciiString();
if (argc >= 1)
{
textpar->AssignCat(arg1);
}
return pilot->RecordItem(textpar);
}
static IFSelect_ReturnStatus fun17(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** SetText ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Donner 2 arguments : nom Parametre et Valeur" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(TCollection_HAsciiString, par, WS->NamedItem(arg1));
if (!WS->SetTextValue(par, arg2))
{
return IFSelect_RetFail;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun19(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** DumpSel ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give 1 argument : Selection Name" << '\n';
return IFSelect_RetError;
}
WS->DumpSelection(GetCasted(IFSelect_Selection, WS->NamedItem(arg1)));
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun20(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
// **** EvalSel ****
// **** GiveList ****
// **** GiveShort GivePointed ****
// **** MakeList ****
char mode = pilot->Arg(0)[0]; // givelist/makelist
if (mode == 'g')
{
mode = pilot->Arg(0)[4]; // l list s short p pointed
}
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give Entity ID, or Selection Name [+ optional other selection or entity]" << '\n';
return IFSelect_RetError;
}
// MakeList: on existing Pointed or to be created
occ::handle<IFSelect_SelectPointed> pnt;
if (mode == 'm')
{
const char* const arg1 = pilot->Arg(1);
occ::handle<Standard_Transient> item = WS->NamedItem(arg1);
pnt = GetCasted(IFSelect_SelectPointed, item);
if (!pnt.IsNull())
{
sout << arg1 << ":Already existing Selection for List, cleared then filled" << '\n';
pnt->Clear();
}
else if (!item.IsNull())
{
sout << arg1 << ":Already existing Item not for a List, command ignored" << '\n';
return IFSelect_RetFail;
}
else
{
pnt = new IFSelect_SelectPointed;
WS->AddNamedItem(arg1, pnt);
}
}
occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> result =
IFSelect_Functions::GiveList(WS, pilot->CommandPart((mode == 'm' ? 2 : 1)));
if (result.IsNull())
{
return IFSelect_RetError;
}
Interface_EntityIterator iter(result);
sout << pilot->CommandPart((mode == 'm' ? 2 : 1)) << " : ";
if (mode == 'l')
{
WS->ListEntities(iter, 0, sout);
}
else if (mode == 's' || mode == 'm')
{
WS->ListEntities(iter, 2, sout);
}
else if (mode == 'p')
{
sout << iter.NbEntities() << " Entities : ";
for (iter.Start(); iter.More(); iter.Next())
{
sout << " +" << WS->StartingNumber(iter.Value());
}
sout << '\n';
}
if (!pnt.IsNull())
{
pnt->SetList(result);
sout << "List set to a SelectPointed : " << pilot->Arg(1) << '\n';
sout << "Later editable by command setlist" << '\n';
}
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun20c(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
// **** GiveCount ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give Entity ID, or Selection Name [+ optional other selection or entity]" << '\n';
return IFSelect_RetError;
}
// WS->EvaluateSelection(GetCasted(IFSelect_Selection,WS->NamedItem(arg1)));
occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> result =
IFSelect_Functions::GiveList(WS, pilot->CommandPart(1));
if (result.IsNull())
{
return IFSelect_RetError;
}
sout << pilot->CommandPart(1) << " : List of " << result->Length() << " Entities" << '\n';
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus funselsuite(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
// **** SelSuite ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give Entity ID, or Selection Name [+ optional other selection or entity]" << '\n';
return IFSelect_RetError;
}
// WS->EvaluateSelection(GetCasted(IFSelect_Selection,WS->NamedItem(arg1)));
occ::handle<IFSelect_SelectSuite> selsuite = new IFSelect_SelectSuite;
for (int i = 1; i < argc; i++)
{
occ::handle<IFSelect_Selection> sel = WS->GiveSelection(pilot->Arg(i));
if (!selsuite->AddInput(sel))
{
sout << pilot->Arg(i - 1) << " : not a SelectDeduct, no more can be added. Abandon" << '\n';
return IFSelect_RetError;
}
}
selsuite->SetLabel(pilot->CommandPart(1));
return pilot->RecordItem(selsuite);
}
static IFSelect_ReturnStatus fun21(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** ClearItems ****
WS->ClearItems();
WS->ClearFinalModifiers();
WS->ClearShareOut(false);
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun22(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** ClearData ****
int mode = -1;
if (argc >= 2)
{
if (arg1[0] == 'a')
{
mode = 1;
}
if (arg1[0] == 'g')
{
mode = 2;
}
if (arg1[0] == 'c')
{
mode = 3;
}
if (arg1[0] == 'p')
{
mode = 4;
}
if (arg1[0] == '?')
{
mode = -1;
}
}
else
{
mode = 0;
}
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (mode <= 0)
{
if (mode < 0)
{
sout << "Give a suitable mode";
}
sout << " Available Modes :\n"
<< " a : all data g : graph+check c : check p : selectpointed" << '\n';
return (mode < 0 ? IFSelect_RetError : IFSelect_RetVoid);
}
WS->ClearData(mode);
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun24(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
// **** Item Label ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
TCollection_AsciiString label;
if (argc < 2)
{
sout << " Give label to search" << '\n';
return IFSelect_RetError;
}
for (int i = 1; i < argc; i++)
{
label.AssignCat(pilot->Arg(i));
if (i < argc - 1)
{
label.AssignCat(" ");
}
}
for (int mode = 0; mode <= 2; mode++)
{
int nbitems = 0;
int id;
sout << "Searching label : " << label << ". in mode ";
if (mode == 0)
{
sout << " exact" << '\n';
}
if (mode == 1)
{
sout << " same head" << '\n';
}
if (mode == 2)
{
sout << " search if present" << '\n';
}
for (id = WS->NextIdentForLabel(label.ToCString(), 0, mode); id != 0;
id = WS->NextIdentForLabel(label.ToCString(), id, mode))
{
sout << " " << id;
nbitems++;
}
sout << " -- giving " << nbitems << " found" << '\n';
}
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun27(const occ::handle<IFSelect_SessionPilot>& pilot)
{
int argc = pilot->NbWords();
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
const char* const arg1 = pilot->Arg(1);
const char* arg2 = pilot->Arg(2);
const char* const anEmptyStr = "";
if (arg2 && strlen(arg2) == 2 && arg2[0] == '"' && arg2[1] == '"')
{
arg2 = anEmptyStr;
}
// **** Param(Value) ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2 || (argc == 3 && strcmp(arg1, "-p") == 0))
{
occ::handle<NCollection_HSequence<occ::handle<TCollection_HAsciiString>>> li =
Interface_Static::Items();
int i, nb = li->Length(), aPatternNb = 0;
size_t aPatternLen = strlen(arg2);
if (argc == 3)
{
for (i = 1; i <= nb; i++)
{
if (strncmp(li->Value(i)->String().ToCString(), arg2, aPatternLen) == 0)
{
aPatternNb++;
}
}
}
else
{
aPatternNb = nb;
}
sout << " List of parameters : " << aPatternNb << " items : " << '\n';
for (i = 1; i <= nb; i++)
{
if (argc == 3 && strncmp(li->Value(i)->String().ToCString(), arg2, aPatternLen) != 0)
{
continue;
}
sout << li->Value(i)->String();
sout << " : " << Interface_Static::CVal(li->Value(i)->ToCString()) << '\n';
}
return IFSelect_RetVoid;
}
else if (atoi(arg1) > 0)
{
int use = atoi(arg1);
WS->TraceStatics(use);
}
else
{
if (argc > 2)
{
sout << " FORMER STATUS of Static Parameter " << arg1 << '\n';
}
else
{
sout << " ACTUAL STATUS of Static Parameter " << arg1 << '\n';
}
if (!Interface_Static::IsPresent(arg1))
{
sout << " Parameter " << arg1 << " undefined" << '\n';
return IFSelect_RetError;
}
if (!Interface_Static::IsSet(arg1))
{
sout << " Parameter " << arg1 << " not valued" << '\n';
}
else if (argc == 2)
{
Interface_Static::Static(arg1)->Print(sout);
}
else
{
sout << " Value : " << Interface_Static::CVal(arg1) << '\n';
}
if (argc == 2)
{
sout << "To modify, param name_param new_val" << '\n';
}
else
{
if (strlen(arg2) != 0)
{
sout << " New demanded value : " << arg2;
}
else
{
sout << " New demanded value : not valued";
}
if (Interface_Static::SetCVal(arg1, arg2))
{
sout << " OK" << '\n';
return IFSelect_RetDone;
}
else
{
sout << " , refused" << '\n';
return IFSelect_RetError;
}
}
}
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun29(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** SentFiles ****
occ::handle<NCollection_HSequence<occ::handle<TCollection_HAsciiString>>> list = WS->SentFiles();
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (list.IsNull())
{
sout << "List of Sent Files not enabled" << '\n';
return IFSelect_RetVoid;
}
int i, nb = list->Length();
sout << " Sent Files : " << nb << " : " << '\n';
for (i = 1; i <= nb; i++)
{
sout << list->Value(i)->ToCString() << '\n';
}
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun30(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** FilePrefix ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
if (WS->FilePrefix().IsNull())
{
sout << "No prefix defined" << '\n';
}
else
{
sout << "Prefixe : " << WS->FilePrefix()->ToCString() << '\n';
}
sout << "Pour changer : filepref newprefix" << '\n';
return IFSelect_RetVoid;
}
WS->SetFilePrefix(arg1);
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun31(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** FileExtension ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
if (WS->FileExtension().IsNull())
{
sout << "Pas d extension definie" << '\n';
}
else
{
sout << "Extension : " << WS->FileExtension()->ToCString() << '\n';
}
sout << "Pour changer : fileext newext" << '\n';
return IFSelect_RetVoid;
}
WS->SetFileExtension(arg1);
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun32(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** FileRoot ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give Dispatch and Root name" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Dispatch, disp, WS->NamedItem(arg1));
if (argc < 3)
{
if (WS->FileRoot(disp).IsNull())
{
sout << "No root defined for " << arg1 << '\n';
}
else
{
sout << "Root for " << arg1 << " : " << WS->FileRoot(disp)->ToCString() << '\n';
}
sout << "Pour changer : fileroot nomdisp newroot" << '\n';
return IFSelect_RetVoid;
}
if (!WS->SetFileRoot(disp, arg2))
{
return IFSelect_RetFail;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun33(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Default File Root ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
if (WS->DefaultFileRoot().IsNull())
{
sout << "No default root defined" << '\n';
}
else
{
sout << "Racine par defaut : " << WS->DefaultFileRoot()->ToCString() << '\n';
}
sout << "Pour changer : filedef newdef" << '\n';
return IFSelect_RetVoid;
}
WS->SetDefaultFileRoot(arg1);
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun34(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** EvalFile ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (!WS->HasModel())
{
sout << "No Model loaded, abort" << '\n';
return IFSelect_RetFail;
}
sout << "Evaluation avec Memorisation des resultats" << '\n';
WS->EvaluateFile();
int nbf = WS->NbFiles();
for (int i = 1; i <= nbf; i++)
{
occ::handle<Interface_InterfaceModel> mod = WS->FileModel(i);
if (mod.IsNull())
{
sout << "Modele " << i << " Model non genere ..." << '\n';
continue;
}
TCollection_AsciiString name = WS->FileName(i);
sout << "Fichier n0 " << i << " Nb Entites : " << mod->NbEntities() << " Nom: ";
sout << name << '\n';
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun35(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** ClearFile ****
WS->ClearFile();
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun36(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
// **** Split ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
IFSelect_ReturnStatus stat = IFSelect_RetVoid;
if (argc < 2)
{
sout << "Split : last dispatch list defined" << '\n';
}
else
{
WS->ClearShareOut(true);
for (int i = 1; i < argc; i++)
{
DeclareAndCast(IFSelect_Dispatch, disp, WS->NamedItem(pilot->Arg(i)));
if (disp.IsNull())
{
sout << "Pas un dispatch:" << pilot->Arg(i) << ", Splitt abandonne" << '\n';
stat = IFSelect_RetError;
}
else
{
WS->SetActive(disp, true);
}
}
}
if (stat == IFSelect_RetError)
{
return stat;
}
WS->BeginSentFiles(true);
if (!WS->SendSplit())
{
return IFSelect_RetFail;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun37(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Remaining Data ****
char mode = '?';
IFSelect_RemainMode numod = IFSelect_RemainDisplay;
if (argc >= 2)
{
mode = arg1[0];
}
if (mode == 'u')
{
numod = IFSelect_RemainUndo;
}
else if (mode == 'l')
{
numod = IFSelect_RemainDisplay;
}
else if (mode == 'c')
{
numod = IFSelect_RemainCompute;
}
else if (mode == 'f')
{
numod = IFSelect_RemainForget;
}
else
{
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Donner un Mode - ";
}
sout << "Modes possibles : l list, c compute, u undo, f forget" << '\n';
if (mode == '?')
{
return IFSelect_RetDone;
}
else
{
return IFSelect_RetError;
}
}
if (!WS->SetRemaining(numod))
{
return IFSelect_RetVoid;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun38(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** SetModelContent ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Donner nom selection et mode (k=keep,r=remove)" << '\n';
return IFSelect_RetError;
}
bool keepmode;
DeclareAndCast(IFSelect_Selection, sel, WS->NamedItem(arg1));
if (sel.IsNull())
{
sout << "No Selection with Name : " << arg1 << '\n';
return IFSelect_RetError;
}
if (arg2[0] == 'k')
{
sout << " -- SetContent keep ...";
keepmode = true;
}
else if (arg2[0] == 'r')
{
sout << " -- SetContent remove ...";
keepmode = false;
}
else
{
sout << "Donner nom selection et mode (k=keep,r=remove)" << '\n';
return IFSelect_RetError;
}
if (WS->SetModelContent(sel, keepmode))
{
sout << " Done" << '\n';
}
else
{
sout << " Result empty, ignored" << '\n';
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun40(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** ListModif ****
WS->ListFinalModifiers(true);
WS->ListFinalModifiers(false);
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun41(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Modifier ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Donner Nom du Modifier" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_GeneralModifier, modif, WS->NamedItem(arg1));
if (modif.IsNull())
{
sout << "No Modifier with Name : " << arg1 << '\n';
return IFSelect_RetVoid;
}
occ::handle<IFSelect_IntParam> low, up;
occ::handle<IFSelect_Dispatch> disp = modif->Dispatch();
sout << "Modifier : " << arg1 << " Label : " << modif->Label() << '\n';
int rank = WS->ModifierRank(modif);
if (modif->IsKind(STANDARD_TYPE(IFSelect_Modifier)))
{
sout << "Model Modifier n0." << rank;
}
else
{
sout << "File Modifier n0." << rank;
}
if (disp.IsNull())
{
sout << " Applique a tous les Dispatchs" << '\n';
}
else
{
sout << " Dispatch : " << disp->Label();
if (WS->HasName(disp))
{
sout << " - Nom:" << WS->Name(disp)->ToCString();
}
sout << '\n';
}
occ::handle<IFSelect_Selection> sel = modif->Selection();
if (!sel.IsNull())
{
sout << " Selection : " << sel->Label();
}
if (WS->HasName(sel))
{
sout << " - Nom:" << WS->Name(sel)->ToCString();
}
sout << '\n';
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun42(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** ModifSel ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Donner Nom Modifier; + Nom Selection optionnel\n"
<< "Selection to Set a Selection, otherwise Cancel" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_GeneralModifier, modif, WS->NamedItem(arg1));
if (modif.IsNull())
{
sout << "Not a Modifier name : " << arg1 << '\n';
return IFSelect_RetError;
}
occ::handle<IFSelect_Selection> sel;
if (arg2[0] != '\0')
{
sel = GetCasted(IFSelect_Selection, WS->NamedItem(arg2));
if (sel.IsNull())
{
sout << "Not a Selection name : " << arg2 << '\n';
return IFSelect_RetError;
}
}
if (!WS->SetItemSelection(modif, sel))
{
return IFSelect_RetFail;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun43(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** SetAppliedModifier ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Donner Nom Modifier; + Nom Dispatch ou Transformer optionnel :\n"
<< " - rien : tous Dispatches\n - Dispatch : ce Dispatch seul\n"
<< " - Transformer : pas un Dispatch mais un Transformer" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_GeneralModifier, modif, WS->NamedItem(arg1));
if (modif.IsNull())
{
sout << "Not a Modifier name : " << arg1 << '\n';
return IFSelect_RetError;
}
occ::handle<Standard_Transient> item;
if (arg2[0] != '\0')
{
item = WS->NamedItem(arg2);
if (item.IsNull())
{
sout << "Pas un nom connu : " << arg2 << '\n';
return IFSelect_RetError;
}
}
else
{
item = WS->ShareOut();
}
if (!WS->SetAppliedModifier(modif, item))
{
return IFSelect_RetFail;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun44(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** ResetApplied (modifier) ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Designer un modifier" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_GeneralModifier, modif, WS->NamedItem(arg1));
if (modif.IsNull())
{
sout << "Not a Modifier name : " << arg1 << '\n';
return IFSelect_RetError;
}
if (!WS->ResetAppliedModifier(modif))
{
return IFSelect_RetFail;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun45(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
const char* const arg3 = pilot->Arg(3);
// **** ModifMove ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 4)
{
sout << "modifmove MF rang1 rang2, M for Model F for File" << '\n';
return IFSelect_RetError;
}
bool formodel;
if (arg1[0] == 'm' || arg1[0] == 'M')
{
formodel = true;
}
else if (arg1[0] == 'f' || arg1[0] == 'F')
{
formodel = false;
}
else
{
sout << "specify M for Model, F for File" << '\n';
return IFSelect_RetError;
}
int before = atoi(arg2);
int after = atoi(arg3);
if (before == 0 || after == 0)
{
sout << "Donner 2 Entiers Positifs" << '\n';
return IFSelect_RetError;
}
if (!WS->ChangeModifierRank(formodel, before, after))
{
return IFSelect_RetFail;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun51(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** DispSel ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Donner Noms Dispatch et Selection Finale" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Dispatch, disp, WS->NamedItem(arg1));
if (disp.IsNull())
{
sout << "Not a Dispatch name : " << arg1 << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Selection, sel, WS->NamedItem(arg2));
if (sel.IsNull())
{
sout << "Not a Selection name : " << arg2 << '\n';
return IFSelect_RetError;
}
if (!WS->SetItemSelection(disp, sel))
{
return IFSelect_RetFail;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun_dispone(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** DispOne ****
occ::handle<IFSelect_DispPerOne> disp = new IFSelect_DispPerOne;
return pilot->RecordItem(disp);
}
static IFSelect_ReturnStatus fun_dispglob(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** DispGlob ****
occ::handle<IFSelect_DispGlobal> disp = new IFSelect_DispGlobal;
return pilot->RecordItem(disp);
}
static IFSelect_ReturnStatus fun_dispcount(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** DispCount ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give IntParam Name for Count" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_IntParam, par, WS->NamedItem(arg1));
if (par.IsNull())
{
sout << "Not an IntParam name : " << arg1 << '\n';
return IFSelect_RetError;
}
occ::handle<IFSelect_DispPerCount> disp = new IFSelect_DispPerCount;
disp->SetCount(par);
return pilot->RecordItem(disp);
}
static IFSelect_ReturnStatus fun_dispfiles(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** DispFiles ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give IntParam Name for NbFiles" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_IntParam, par, WS->NamedItem(arg1));
if (par.IsNull())
{
sout << "Not an IntParam name : " << arg1 << '\n';
return IFSelect_RetError;
}
occ::handle<IFSelect_DispPerFiles> disp = new IFSelect_DispPerFiles;
disp->SetCount(par);
return pilot->RecordItem(disp);
}
static IFSelect_ReturnStatus fun_dispsign(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** DispFiles ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Donner Nom Signature" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Signature, sig, WS->NamedItem(arg1));
if (sig.IsNull())
{
sout << "Not a Signature name : " << arg1 << '\n';
return IFSelect_RetError;
}
occ::handle<IFSelect_DispPerSignature> disp = new IFSelect_DispPerSignature;
disp->SetSignCounter(new IFSelect_SignCounter(sig));
return pilot->RecordItem(disp);
}
static IFSelect_ReturnStatus fun56(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Dispatch ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Donner Nom du Dispatch" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Dispatch, disp, WS->NamedItem(arg1));
if (disp.IsNull())
{
sout << "Pas un dispatch : " << arg1 << '\n';
return IFSelect_RetError;
}
int num = WS->DispatchRank(disp);
sout << "Dispatch with Name : " << arg1 << " , in ShareOut, Number " << num << " : ";
occ::handle<IFSelect_Selection> sel = WS->ItemSelection(disp);
occ::handle<TCollection_HAsciiString> selname = WS->Name(sel);
if (sel.IsNull())
{
sout << "No Final Selection" << '\n';
}
else if (selname.IsNull())
{
sout << "Selection Finale : #" << WS->ItemIdent(sel) << '\n';
}
else
{
sout << "Selection Finale : " << selname->ToCString() << '\n';
}
if (disp->HasRootName())
{
sout << "-- Root file name : " << disp->RootName()->ToCString() << '\n';
}
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun57(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Remove ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give Name to Remove !" << '\n';
return IFSelect_RetError;
}
if (!WS->RemoveNamedItem(arg1))
{
return IFSelect_RetFail;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun58(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** EvalDisp ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "evaldisp mode disp [disp ...] : Mode + Name(s) of Dispatch(es). Mode:\n"
<< " 0 brief 1 +forgotten ents 2 +duplicata 3 1+2" << '\n'
<< "See also : evaladisp writedisp xsplit" << '\n';
return IFSelect_RetVoid;
}
bool OK = true;
int i, mode = atoi(arg1);
sout << " Mode " << mode << "\n";
for (i = 2; i < argc; i++)
{
DeclareAndCast(IFSelect_Dispatch, disp, WS->NamedItem(pilot->Arg(i)));
if (disp.IsNull())
{
sout << "Not a dispatch:" << pilot->Arg(i) << '\n';
OK = false;
}
}
if (!OK)
{
sout << "Some of the parameters are not correct" << '\n';
return IFSelect_RetError;
}
WS->ClearShareOut(true);
for (i = 2; i < argc; i++)
{
DeclareAndCast(IFSelect_Dispatch, disp, WS->NamedItem(pilot->Arg(i)));
WS->SetActive(disp, true);
}
// WS->EvaluateDispatch(disp,mode);
WS->EvaluateComplete(mode);
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun_evaladisp(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** EvalADisp [GiveList] ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "evaladisp mode(=0-1-2-3) disp [givelist] : Mode + Dispatch [+ GiveList]\n If "
"GiveList not given, computed from Selection of the Dispatch. Mode:\n"
<< " 0 brief 1 +forgotten ents 2 +duplicata 3 1+2" << '\n'
<< "See also : writedisp" << '\n';
return IFSelect_RetVoid;
}
if (arg1[1] != '\0')
{
sout << "first parameter : mode, must be a number between 0 and 3" << '\n';
return IFSelect_RetError;
}
int mode = atoi(arg1);
sout << " Mode " << mode << "\n";
// DeclareAndCast(IFSelect_Dispatch,disp,WS->NamedItem(pilot->Arg(2)));
occ::handle<IFSelect_Dispatch> disp = IFSelect_Functions::GiveDispatch(WS, pilot->Arg(2), true);
if (disp.IsNull())
{
sout << "Not a dispatch:" << pilot->Arg(2) << '\n';
return IFSelect_RetError;
}
occ::handle<IFSelect_Selection> selsav = disp->FinalSelection();
occ::handle<IFSelect_Selection> sel;
if (argc > 3)
{
occ::handle<IFSelect_SelectPointed> sp = new IFSelect_SelectPointed;
occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> list =
IFSelect_Functions::GiveList(pilot->Session(), pilot->CommandPart(3));
int nb = (list.IsNull() ? 0 : list->Length());
if (nb > 0)
{
sp->AddList(list);
sel = sp;
}
}
if (sel.IsNull() && selsav.IsNull())
{
sout << "No Selection nor GiveList defined" << '\n';
return IFSelect_RetError;
}
if (sel.IsNull() && !selsav.IsNull())
{
if (argc > 3)
{
sout << "GiveList is empty, hence computed from the Selection of the Dispatch" << '\n';
}
sel = selsav;
}
disp->SetFinalSelection(sel);
// WS->ClearShareOut(true);
// WS->SetActive(disp,true);
WS->EvaluateDispatch(disp, mode);
disp->SetFinalSelection(selsav);
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun_writedisp(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** EvalADisp [GiveList] ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "writedisp filename disp [givelist] : FileName + Dispatch [+ GiveList]\n If GiveList "
"not given, computed from Selection of the Dispatch.\n"
<< "FileName : rootname.ext will gives rootname_1.ext etc...\n"
<< " path/rootname.ext gives path/rootname_1.ext etc...\n"
<< "See also : evaladisp" << '\n';
return IFSelect_RetVoid;
}
TCollection_AsciiString prefix, rootname, suffix;
SplitFileName(arg1, prefix, rootname, suffix);
if (rootname.Length() == 0 || suffix.Length() == 0)
{
sout << "Empty Root Name or Extension" << '\n';
return IFSelect_RetError;
}
// DeclareAndCast(IFSelect_Dispatch,disp,WS->NamedItem(pilot->Arg(2)));
occ::handle<IFSelect_Dispatch> disp = IFSelect_Functions::GiveDispatch(WS, pilot->Arg(2), true);
if (disp.IsNull())
{
sout << "Not a dispatch:" << pilot->Arg(2) << '\n';
return IFSelect_RetError;
}
occ::handle<IFSelect_Selection> selsav = disp->FinalSelection();
occ::handle<IFSelect_Selection> sel;
if (argc > 3)
{
occ::handle<IFSelect_SelectPointed> sp = new IFSelect_SelectPointed;
occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> list =
IFSelect_Functions::GiveList(pilot->Session(), pilot->CommandPart(3));
int nb = (list.IsNull() ? 0 : list->Length());
if (nb > 0)
{
sp->AddList(list);
sel = sp;
}
}
if (sel.IsNull() && selsav.IsNull())
{
sout << "No Selection nor GiveList defined" << '\n';
return IFSelect_RetError;
}
if (sel.IsNull() && !selsav.IsNull())
{
if (argc > 3)
{
sout << "GiveList is empty, hence computed from the Selection of the Dispatch" << '\n';
}
sel = selsav;
}
WS->ClearShareOut(true);
disp->SetFinalSelection(sel);
WS->SetActive(disp, true);
WS->BeginSentFiles(true);
WS->SetFilePrefix(prefix.ToCString());
WS->SetFileExtension(suffix.ToCString());
WS->SetFileRoot(disp, rootname.ToCString());
bool OK = WS->SendSplit();
disp->SetFinalSelection(selsav);
return (OK ? IFSelect_RetDone : IFSelect_RetFail);
}
static IFSelect_ReturnStatus fun59(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** EvalComplete ****
int mode = 0;
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << " -- mode par defaut 0\n";
}
else
{
mode = atoi(arg1);
sout << " -- mode : " << mode << '\n';
}
WS->EvaluateComplete(mode);
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun60(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** LastRunCheckList ****
Interface_CheckIterator chlist = WS->LastRunCheckList();
occ::handle<IFSelect_CheckCounter> counter = new IFSelect_CheckCounter(false);
counter->Analyse(chlist, WS->Model(), false);
Message_Messenger::StreamBuffer sout = Message::SendInfo();
counter->PrintCount(sout);
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun61(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** RunTransformer ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give Transformer Name" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Transformer, tsf, WS->NamedItem(arg1));
int effect = WS->RunTransformer(tsf);
switch (effect)
{
case -4:
sout << "Edition sur place, nouveau Protocole, erreur recalcul graphe" << '\n';
break;
case -3:
sout << "Erreur, Transformation ignoree" << '\n';
break;
case -2:
sout << "Error on in-place editing, risk of corruption (check)" << '\n';
break;
case -1:
sout << "Error on local editing, risk of corruption (check)" << '\n';
break;
case 0:
if (tsf.IsNull())
{
sout << "Erreur, pas un Transformer: " << arg1 << '\n';
}
else
{
sout << "Execution non faite" << '\n';
}
break;
case 1:
sout << "Transformation locale (graphe non touche)" << '\n';
break;
case 2:
sout << "Edition sur place (graphe recalcule)" << '\n';
break;
case 3:
sout << "Modele reconstruit" << '\n';
break;
case 4:
sout << "Edition sur place, nouveau Protocole" << '\n';
break;
case 5:
sout << "Nouveau Modele avec nouveau Protocole" << '\n';
break;
default:
break;
}
return ((effect > 0) ? IFSelect_RetDone : IFSelect_RetFail);
}
static IFSelect_ReturnStatus fun62(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** TransformStandard Copy ****
return pilot->RecordItem(WS->NewTransformStandard(true));
}
static IFSelect_ReturnStatus fun63(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** TransformStandard OntheSpot ****
return pilot->RecordItem(WS->NewTransformStandard(false));
}
static IFSelect_ReturnStatus fun6465(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** Run Modifier avec Standard Copy ****
// **** Run Modifier avec OnTheSpot ****
bool runcopy = (pilot->Arg(0)[3] == 'c');
// either it's a name, otherwise it's a command
occ::handle<IFSelect_Modifier> modif;
if (WS->NameIdent(arg1) > 0)
{
modif = GetCasted(IFSelect_Modifier, WS->NamedItem(arg1));
}
else
{
pilot->RemoveWord(0); // it was the run command
pilot->Perform();
modif = GetCasted(IFSelect_Modifier, pilot->RecordedItem());
}
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (modif.IsNull())
{
sout << "Not a Modifier name : " << arg1 << '\n';
return IFSelect_RetError;
}
occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> list;
occ::handle<IFSelect_SelectPointed> sp;
if (argc > 2)
{
list = IFSelect_Functions::GiveList(WS, pilot->CommandPart(2));
sp = new IFSelect_SelectPointed;
sp->SetList(list);
}
int effect = 0;
effect = WS->RunModifierSelected(modif, sp, runcopy);
// sout<<"Modifier applique sur TransformStandard #"<<WS->ItemIdent(tsf)<<std::endl;
switch (effect)
{
case -4:
sout << "Edition sur place, nouveau Protocole, erreur recalcul graphe" << '\n';
break;
case -3:
sout << "Erreur, Transformation ignoree" << '\n';
break;
case -2:
sout << "Error on in-place editing, risk of corruption (check)" << '\n';
break;
case -1:
sout << "Error on local editing, risk of corruption (check)" << '\n';
break;
case 0:
if (modif.IsNull())
{
sout << "Erreur, pas un Modifier: " << arg1 << '\n';
}
else
{
sout << "Execution non faite" << '\n';
}
break;
case 1:
sout << "Transformation locale (graphe non touche)" << '\n';
break;
case 2:
sout << "Edition sur place (graphe recalcule)" << '\n';
break;
case 3:
sout << "Modele reconstruit" << '\n';
break;
case 4:
sout << "Edition sur place, nouveau Protocole" << '\n';
break;
case 5:
sout << "Nouveau Modele avec nouveau Protocole" << '\n';
break;
default:
break;
}
return ((effect > 0) ? IFSelect_RetDone : IFSelect_RetFail);
}
static IFSelect_ReturnStatus fun66(const occ::handle<IFSelect_SessionPilot>& pilot)
{
// **** (xset) ModifReorder ****
char opt = ' ';
int argc = pilot->NbWords();
if (argc >= 2)
{
opt = pilot->Word(1).Value(1);
}
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (opt != 'f' && opt != 'l')
{
sout << "Donner option : f -> root-first l -> root-last" << '\n';
return IFSelect_RetError;
}
return pilot->RecordItem(new IFSelect_ModifReorder(opt == 'l'));
}
static IFSelect_ReturnStatus fun70(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** SelToggle ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give Selection Name" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Selection, sel, WS->NamedItem(arg1));
if (!WS->ToggleSelectExtract(sel))
{
sout << "Pas une SelectExtract : " << arg1 << '\n';
return IFSelect_RetFail;
}
if (WS->IsReversedSelectExtract(sel))
{
sout << arg1 << " a present Reversed" << '\n';
}
else
{
sout << arg1 << " a present Directe" << '\n';
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun71(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** SelInput ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Donner Noms Selections cible et input" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Selection, sel, WS->NamedItem(arg1));
DeclareAndCast(IFSelect_Selection, sou, WS->NamedItem(arg2));
if (sel.IsNull() || sou.IsNull())
{
sout << "Incorrect : " << arg1 << "," << arg2 << '\n';
return IFSelect_RetError;
}
if (!WS->SetInputSelection(sel, sou))
{
sout << "Nom incorrect ou Selection " << arg1 << " ni Extract ni Deduct" << '\n';
return IFSelect_RetFail;
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun72(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** SelModelRoots ****
return pilot->RecordItem(new IFSelect_SelectModelRoots);
}
static IFSelect_ReturnStatus fun73(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** SelRange ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc >= 2 && arg1[0] == '?')
{
argc = 1;
}
if (argc < 2)
{
sout << "Donner la description du SelectRange"
<< " Accepted forms :\n <n1> <n2> : Range from <n1> to <n2>\n"
<< " <n1> tout seul : Range n0 <n1>\n from <n1> : Range From <n1>\n"
<< " until <n2> : Range Until <n2>" << '\n';
return IFSelect_RetVoid;
}
occ::handle<IFSelect_IntParam> low, up;
occ::handle<IFSelect_SelectRange> sel;
// Range From
if (pilot->Word(1).IsEqual("from"))
{
if (argc < 3)
{
sout << "Forme admise : from <i>" << '\n';
return IFSelect_RetError;
}
low = GetCasted(IFSelect_IntParam, WS->NamedItem(arg2));
sel = new IFSelect_SelectRange;
sel->SetFrom(low);
// Range Until
}
else if (pilot->Word(1).IsEqual("until"))
{
if (argc < 3)
{
sout << "Forme admise : until <i>" << '\n';
return IFSelect_RetError;
}
up = GetCasted(IFSelect_IntParam, WS->NamedItem(arg2));
sel = new IFSelect_SelectRange;
sel->SetUntil(up);
// Range One (n-th)
}
else if (argc < 3)
{
low = GetCasted(IFSelect_IntParam, WS->NamedItem(arg1));
sel = new IFSelect_SelectRange;
sel->SetOne(low);
// Range (from-to)
}
else
{
low = GetCasted(IFSelect_IntParam, WS->NamedItem(arg1));
up = GetCasted(IFSelect_IntParam, WS->NamedItem(arg2));
sel = new IFSelect_SelectRange;
sel->SetRange(low, up);
}
return pilot->RecordItem(sel);
}
static IFSelect_ReturnStatus fun74(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** SelRoots ****
return pilot->RecordItem(new IFSelect_SelectRoots);
}
static IFSelect_ReturnStatus fun75(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** SelShared ****
return pilot->RecordItem(new IFSelect_SelectShared);
}
static IFSelect_ReturnStatus fun76(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** SelDiff ****
occ::handle<IFSelect_Selection> sel = new IFSelect_SelectDiff;
if (sel.IsNull())
{
return IFSelect_RetFail;
}
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Diff without input : don't forget to define them (ctlmain, ctlsec)!" << '\n';
}
DeclareAndCast(IFSelect_Selection, selmain, WS->NamedItem(arg1));
DeclareAndCast(IFSelect_Selection, selsec, WS->NamedItem(arg2));
if (argc >= 2)
{
if (!WS->SetControl(sel, selmain, true))
{
sout << "Echec ControlMain:" << arg1 << " , a refaire (ctlmain)" << '\n';
}
}
if (argc >= 3)
{
if (!WS->SetControl(sel, selsec, false))
{
sout << "Echec ControlSecond:" << arg2 << " , a refaire (ctlsec)" << '\n';
}
}
return pilot->RecordItem(sel);
}
static IFSelect_ReturnStatus fun77(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** SelControlMain ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Give Control and MainInput Names" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Selection, sel, WS->NamedItem(arg1));
DeclareAndCast(IFSelect_Selection, selmain, WS->NamedItem(arg2));
if (WS->SetControl(sel, selmain, true))
{
return IFSelect_RetDone;
}
sout << "Incorrect name or Selection " << arg1 << " not of Control type" << '\n';
return IFSelect_RetFail;
}
static IFSelect_ReturnStatus fun78(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** SelControlSecond ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Give Control and SecondInput Names" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Selection, sel, WS->NamedItem(arg1));
DeclareAndCast(IFSelect_Selection, seldif, WS->NamedItem(arg2));
if (WS->SetControl(sel, seldif, false))
{
return IFSelect_RetDone;
}
sout << "Incorrect name or Selection " << arg1 << " not of Control type" << '\n';
return IFSelect_RetFail;
}
static IFSelect_ReturnStatus fun79(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** SelModelAll ****
return pilot->RecordItem(new IFSelect_SelectModelEntities);
}
static IFSelect_ReturnStatus fun80(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** SelCombAdd ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Donner n0 Combine et une Input" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Selection, sel, WS->NamedItem(arg1));
DeclareAndCast(IFSelect_Selection, seladd, WS->NamedItem(arg2));
if (WS->CombineAdd(sel, seladd))
{
return IFSelect_RetDone;
}
sout << "Nom incorrect ou Selection " << arg1 << " pas Combine" << '\n';
return IFSelect_RetFail;
}
static IFSelect_ReturnStatus fun81(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
// **** SelCombRem ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Donner n0 Combine et RANG a supprimer" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Selection, sel, WS->NamedItem(arg1));
DeclareAndCast(IFSelect_Selection, inp, WS->NamedItem(arg2));
if (WS->CombineRemove(sel, inp))
{
return IFSelect_RetDone;
}
sout << "Nom incorrect ou Selection " << arg1 << " ni Union ni Intersection" << '\n';
return IFSelect_RetFail;
}
static IFSelect_ReturnStatus fun82(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** SelEntNumber ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give IntParam Name for Entity n0" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_IntParam, par, WS->NamedItem(arg1));
occ::handle<IFSelect_SelectEntityNumber> sel = new IFSelect_SelectEntityNumber;
sel->SetNumber(par);
return pilot->RecordItem(sel);
}
static IFSelect_ReturnStatus fun83(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** SelUnion ****
return pilot->RecordItem(new IFSelect_SelectUnion);
}
static IFSelect_ReturnStatus fun84(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** SelIntersection ****
return pilot->RecordItem(new IFSelect_SelectIntersection);
}
static IFSelect_ReturnStatus fun85(const occ::handle<IFSelect_SessionPilot>& pilot)
{
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** SelTextType Exact ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Donner le TYPE a selectionner" << '\n';
return IFSelect_RetError;
}
return pilot->RecordItem(new IFSelect_SelectSignature(new IFSelect_SignType, arg1, true));
}
static IFSelect_ReturnStatus fun86(const occ::handle<IFSelect_SessionPilot>& pilot)
{
// **** SelErrorEntities ****
return pilot->RecordItem(new IFSelect_SelectErrorEntities);
}
static IFSelect_ReturnStatus fun87(const occ::handle<IFSelect_SessionPilot>& pilot)
{
// **** SelUnknownEntities **
return pilot->RecordItem(new IFSelect_SelectUnknownEntities);
}
static IFSelect_ReturnStatus fun88(const occ::handle<IFSelect_SessionPilot>& pilot)
{
// **** SelSharing ****
return pilot->RecordItem(new IFSelect_SelectSharing);
}
static IFSelect_ReturnStatus fun89(const occ::handle<IFSelect_SessionPilot>& pilot)
{
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** SelTextType Contain **
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Donner le TYPE a selectionner" << '\n';
return IFSelect_RetError;
}
return pilot->RecordItem(new IFSelect_SelectSignature(new IFSelect_SignType, arg1, false));
}
static IFSelect_ReturnStatus fun90(const occ::handle<IFSelect_SessionPilot>& pilot)
{
// **** SelPointed ****
occ::handle<IFSelect_SelectPointed> sp = new IFSelect_SelectPointed;
if (pilot->NbWords() > 1)
{
occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> list =
IFSelect_Functions::GiveList(pilot->Session(), pilot->CommandPart(1));
if (list.IsNull())
{
return IFSelect_RetFail;
}
Message_Messenger::StreamBuffer sout = Message::SendInfo();
sout << "SelectPointed : " << list->Length() << " entities" << '\n';
sp->AddList(list);
}
return pilot->RecordItem(sp);
}
static IFSelect_ReturnStatus fun91(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
// **** SetPointed (edit) / SetList (edit) ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Donner NOM SelectPointed + Option(s) :\n"
<< " aucune : liste des entites pointees\n"
<< " 0: Clear +nn ajout entite nn -nn enleve nn /nn toggle nn" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_SelectPointed, sp, WS->NamedItem(arg1));
if (sp.IsNull())
{
sout << "Pas une SelectPointed:" << arg1 << '\n';
return IFSelect_RetError;
}
const occ::handle<Interface_InterfaceModel>& model = WS->Model(); // for Print
if (argc == 2)
{ // listage simple
int nb = sp->NbItems();
sout << " SelectPointed : " << arg1 << " : " << nb << " Items :" << '\n';
for (int i = 1; i <= nb; i++)
{
occ::handle<Standard_Transient> pointed = sp->Item(i);
int id = WS->StartingNumber(pointed);
if (id == 0)
{
sout << " (inconnu)";
}
else
{
sout << " ";
model->Print(pointed, sout);
}
}
if (nb > 0)
{
sout << '\n';
}
return IFSelect_RetDone;
}
for (int ia = 2; ia < argc; ia++)
{
const TCollection_AsciiString argi = pilot->Word(ia);
int id = pilot->Number(&(argi.ToCString())[1]);
if (id == 0)
{
if (!argi.IsEqual("0"))
{
sout << "Incorrect,ignore:" << argi << '\n';
}
else
{
sout << "Clear SelectPointed" << '\n';
sp->Clear();
}
}
else if (argi.Value(1) == '-')
{
occ::handle<Standard_Transient> item = WS->StartingEntity(id);
if (sp->Remove(item))
{
sout << "Removed:no." << id;
}
else
{
sout << " Echec Remove " << id;
}
sout << ": " << '\n';
model->Print(item, sout);
}
else if (argi.Value(1) == '/')
{
occ::handle<Standard_Transient> item = WS->StartingEntity(id);
if (sp->Remove(item))
{
sout << "Toggled:n0." << id;
}
else
{
sout << " Echec Toggle " << id;
}
sout << ": " << '\n';
model->Print(item, sout);
}
else if (argi.Value(1) == '+')
{
occ::handle<Standard_Transient> item = WS->StartingEntity(id);
if (sp->Add(item))
{
sout << "Added:no." << id;
}
else
{
sout << " Echec Add " << id;
}
sout << ": " << '\n';
model->Print(item, sout);
}
else
{
sout << "Ignore:" << argi << " , give n0 PRECEDED by + or - or /" << '\n';
}
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun92(const occ::handle<IFSelect_SessionPilot>& pilot)
{
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** SelIncorrectEntities ****
WS->ComputeCheck();
return pilot->RecordItem(new IFSelect_SelectIncorrectEntities);
}
static IFSelect_ReturnStatus fun93(const occ::handle<IFSelect_SessionPilot>& pilot)
{
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** SelSignature ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Give name of Signature or Counter, text + option exact(D) else contains" << '\n';
return IFSelect_RetError;
}
bool exact = true;
if (argc > 3)
{
if (pilot->Arg(3)[0] == 'c')
{
exact = false;
}
}
DeclareAndCast(IFSelect_Signature, sign, WS->NamedItem(arg1));
DeclareAndCast(IFSelect_SignCounter, cnt, WS->NamedItem(arg1));
occ::handle<IFSelect_SelectSignature> sel;
if (!sign.IsNull())
{
sel = new IFSelect_SelectSignature(sign, arg2, exact);
}
else if (!cnt.IsNull())
{
sel = new IFSelect_SelectSignature(cnt, arg2, exact);
}
else
{
sout << arg1 << ":neither Signature nor Counter" << '\n';
return IFSelect_RetError;
}
return pilot->RecordItem(sel);
}
static IFSelect_ReturnStatus fun94(const occ::handle<IFSelect_SessionPilot>& pilot)
{
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** SignCounter ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Donner nom signature" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_Signature, sign, WS->NamedItem(arg1));
if (sign.IsNull())
{
sout << arg1 << ":pas une signature" << '\n';
return IFSelect_RetError;
}
occ::handle<IFSelect_SignCounter> cnt = new IFSelect_SignCounter(sign, true, true);
return pilot->RecordItem(cnt);
}
static IFSelect_ReturnStatus funbselected(const occ::handle<IFSelect_SessionPilot>& pilot)
{
int argc = pilot->NbWords();
const char* const arg1 = pilot->Arg(1);
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// **** NbSelected = GraphCounter ****
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Donner nom selection (deduction) a appliquer" << '\n';
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_SelectDeduct, applied, WS->GiveSelection(arg1));
if (applied.IsNull())
{
sout << arg1 << ":pas une SelectDeduct" << '\n';
return IFSelect_RetError;
}
occ::handle<IFSelect_GraphCounter> cnt = new IFSelect_GraphCounter(true, true);
cnt->SetApplied(applied);
return pilot->RecordItem(cnt);
}
// #########################################
// #### EDITOR - EDITFORM ####
// #########################################
static IFSelect_ReturnStatus fun_editlist(const occ::handle<IFSelect_SessionPilot>& pilot)
{
int argc = pilot->NbWords();
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give the name of an EditForm or an Editor" << '\n';
return IFSelect_RetError;
}
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
// EditForm
DeclareAndCast(IFSelect_EditForm, edf, WS->NamedItem(arg1));
occ::handle<IFSelect_Editor> edt;
if (!edf.IsNull())
{
sout << "Print EditForm " << arg1 << '\n';
edt = edf->Editor();
if (argc < 3)
{
// DEFINITIONS : Editor (direct ou via EditForm)
if (edt.IsNull())
{
edt = GetCasted(IFSelect_Editor, WS->NamedItem(arg1));
}
if (edt.IsNull())
{
return IFSelect_RetVoid;
}
sout << "Editor, Label : " << edt->Label() << '\n';
sout << '\n' << " -- Names (short - complete) + Labels of Values" << '\n';
edt->PrintNames(sout);
sout << '\n' << " -- Definitions --" << '\n';
edt->PrintDefs(sout);
if (!edf.IsNull())
{
edf->PrintDefs(sout);
sout << '\n'
<< "To display values, add an option : o original f final m modified" << '\n';
}
return IFSelect_RetVoid;
}
else
{
char opt = arg2[0];
int what = 0;
if (opt == 'o')
{
what = -1;
}
else if (opt == 'f')
{
what = 1;
}
edf->PrintValues(sout, what, false);
}
}
return IFSelect_RetVoid;
}
static IFSelect_ReturnStatus fun_editvalue(const occ::handle<IFSelect_SessionPilot>& pilot)
{
int argc = pilot->NbWords();
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 3)
{
sout << "Give the name of an EditForm + name of Value [+ newvalue or . to nullify]" << '\n';
return IFSelect_RetError;
}
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
DeclareAndCast(IFSelect_EditForm, edf, WS->NamedItem(arg1));
if (edf.IsNull())
{
sout << "Not an EditForm : " << arg1 << '\n';
return IFSelect_RetError;
}
int num = edf->NameNumber(arg2);
if (num == 0)
{
sout << "Unknown Value Name : " << arg2 << '\n';
}
if (num < 0)
{
sout << "Not Extracted Value Name : " << arg2 << '\n';
}
if (num <= 0)
{
return IFSelect_RetError;
}
bool islist = edf->Editor()->IsList(num);
const char* name = edf->Editor()->Name(num, true); // real name
occ::handle<NCollection_HSequence<occ::handle<TCollection_HAsciiString>>> listr;
occ::handle<TCollection_HAsciiString> str;
sout << "Value Name : " << name << (edf->IsModified(num) ? "(already edited) : " : " : ");
if (islist)
{
listr = edf->EditedList(num);
if (listr.IsNull())
{
sout << "(NULL LIST)" << '\n';
}
else
{
int ilist, nblist = listr->Length();
sout << "(List : " << nblist << " Items)" << '\n';
for (ilist = 1; ilist <= nblist; ilist++)
{
str = listr->Value(ilist);
sout << " [" << ilist << "] " << (str.IsNull() ? "(NULL)" : str->ToCString()) << '\n';
}
}
if (argc < 4)
{
sout << "To Edit, options by editval edit-form value-name ?" << '\n';
}
}
else
{
str = edf->EditedValue(num);
sout << (str.IsNull() ? "(NULL)" : str->ToCString()) << '\n';
}
if (argc < 4)
{
return IFSelect_RetVoid;
}
// Valeur simple ou liste ?
int numarg = 3;
str.Nullify();
const char* const argval = pilot->Arg(numarg);
if (islist)
{
if (argval[0] == '?')
{
sout << "To Edit, options" << '\n'
<< " + val : add value at end (blanks allowed)" << '\n'
<< " +nn text : insert val before item nn" << '\n'
<< " nn text : replace item nn with a new value" << '\n'
<< " -nn : remove item nn" << '\n'
<< " . : clear the list" << '\n';
return IFSelect_RetVoid;
}
bool stated = false;
occ::handle<IFSelect_ListEditor> listed = edf->ListEditor(num);
if (listed.IsNull())
{
return IFSelect_RetError;
}
if (argval[0] == '.')
{
listr.Nullify();
stated = listed->LoadEdited(listr);
}
else if (argval[0] == '+')
{
int numadd = 0;
if (argval[1] != '\0')
{
numadd = atoi(argval);
}
stated =
listed->AddValue(new TCollection_HAsciiString(pilot->CommandPart(numarg + 1)), numadd);
}
else if (argval[0] == '-')
{
int numrem = atoi(argval);
stated = listed->Remove(numrem);
}
else
{
int numset = atoi(argval);
if (numset > 0)
{
stated =
listed->AddValue(new TCollection_HAsciiString(pilot->CommandPart(numarg + 1)), numset);
}
}
if (stated)
{
stated = edf->ModifyList(num, listed, true);
}
if (stated)
{
sout << "List Edition done" << '\n';
}
else
{
sout << "List Edition not done, option" << argval << '\n';
}
}
else
{
if (argval[0] == '.' && argval[1] == '\0')
{
str.Nullify();
}
else
{
str = new TCollection_HAsciiString(pilot->CommandPart(numarg));
}
if (edf->Modify(num, str, true))
{
sout << "Now set to " << (str.IsNull() ? "(NULL)" : str->ToCString()) << '\n';
}
else
{
sout << "Modify not done" << '\n';
return IFSelect_RetFail;
}
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun_editclear(const occ::handle<IFSelect_SessionPilot>& pilot)
{
int argc = pilot->NbWords();
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give the name of an EditForm [+ name of Value else all]" << '\n';
return IFSelect_RetError;
}
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
DeclareAndCast(IFSelect_EditForm, edf, WS->NamedItem(arg1));
if (edf.IsNull())
{
sout << "Not an EditForm : " << arg1 << '\n';
return IFSelect_RetError;
}
if (argc < 3)
{
edf->ClearEdit();
sout << "All Modifications Cleared" << '\n';
}
else
{
int num = edf->NameNumber(arg2);
if (num == 0)
{
sout << "Unknown Value Name : " << arg2 << '\n';
}
if (num < 0)
{
sout << "Not Extracted Value Name : " << arg2 << '\n';
}
if (num <= 0)
{
return IFSelect_RetError;
}
if (!edf->IsModified(num))
{
sout << "Value " << arg2 << " was not modified" << '\n';
return IFSelect_RetVoid;
}
edf->ClearEdit(num);
sout << "Modification on Value " << arg2 << " Cleared" << '\n';
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun_editapply(const occ::handle<IFSelect_SessionPilot>& pilot)
{
int argc = pilot->NbWords();
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give the name of an EditForm [+ option keep to re-apply edited values]" << '\n';
return IFSelect_RetError;
}
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
DeclareAndCast(IFSelect_EditForm, edf, WS->NamedItem(arg1));
if (edf.IsNull())
{
sout << "Not an EditForm : " << arg1 << '\n';
return IFSelect_RetError;
}
occ::handle<Standard_Transient> ent = edf->Entity();
occ::handle<Interface_InterfaceModel> model = edf->Model();
if (!model.IsNull())
{
if (ent.IsNull())
{
sout << "Applying modifications on loaded model" << '\n';
}
else
{
sout << "Applying modifications on loaded entity : ";
model->PrintLabel(ent, sout);
}
}
else
{
sout << "Applying modifications" << '\n';
}
if (!edf->ApplyData(edf->Entity(), edf->Model()))
{
sout << "Modifications could not be applied" << '\n';
return IFSelect_RetFail;
}
sout << "Modifications have been applied" << '\n';
bool stat = true;
if (argc > 2 && arg2[0] == 'k')
{
stat = false;
}
if (stat)
{
edf->ClearEdit();
sout << "Edited values are cleared" << '\n';
}
else
{
sout << "Edited values are kept for another loading/applying" << '\n';
}
return IFSelect_RetDone;
}
static IFSelect_ReturnStatus fun_editload(const occ::handle<IFSelect_SessionPilot>& pilot)
{
int argc = pilot->NbWords();
Message_Messenger::StreamBuffer sout = Message::SendInfo();
if (argc < 2)
{
sout << "Give the name of an EditForm [+ Entity-Ident]" << '\n';
return IFSelect_RetError;
}
const char* const arg1 = pilot->Arg(1);
const char* const arg2 = pilot->Arg(2);
occ::handle<IFSelect_WorkSession> WS = pilot->Session();
DeclareAndCast(IFSelect_EditForm, edf, WS->NamedItem(arg1));
if (edf.IsNull())
{
sout << "Not an EditForm : " << arg1 << '\n';
return IFSelect_RetError;
}
int num = (argc < 3 ? 0 : pilot->Number(arg2));
bool stat = false;
if (argc < 3)
{
sout << "EditForm " << arg1 << " : Loading Model" << '\n';
stat = edf->LoadModel(WS->Model());
}
else if (num <= 0)
{
sout << "Not an entity ident : " << arg2 << '\n';
return IFSelect_RetError;
}
else
{
sout << "EditForm " << arg1 << " : Loading Entity " << arg2 << '\n';
stat = edf->LoadData(WS->StartingEntity(num), WS->Model());
}
if (!stat)
{
sout << "Loading not done" << '\n';
return IFSelect_RetFail;
}
sout << "Loading done" << '\n';
return IFSelect_RetDone;
}
// #########################################
// #### FONCTIONS COMPLEMENTAIRES ####
// #########################################
occ::handle<Standard_Transient> IFSelect_Functions::GiveEntity(
const occ::handle<IFSelect_WorkSession>& WS,
const char* const name)
{
occ::handle<Standard_Transient> ent; // demarre a Null
int num = GiveEntityNumber(WS, name);
if (num > 0)
{
ent = WS->StartingEntity(num);
}
return ent;
}
int IFSelect_Functions::GiveEntityNumber(const occ::handle<IFSelect_WorkSession>& WS,
const char* const name)
{
int num = 0;
if (!name || name[0] == '\0')
{
constexpr size_t aBufferSize = 80;
char ligne[aBufferSize];
ligne[0] = '\0';
std::cin.width(aBufferSize);
std::cin >> ligne;
// std::cin.clear(); std::cin.getline (ligne,79);
if (ligne[0] == '\0')
{
return 0;
}
num = WS->NumberFromLabel(ligne);
}
else
{
num = WS->NumberFromLabel(name);
}
return num;
}
occ::handle<NCollection_HSequence<occ::handle<Standard_Transient>>> IFSelect_Functions::GiveList(
const occ::handle<IFSelect_WorkSession>& WS,
const char* const first,
const char* const second)
{
return WS->GiveList(first, second);
}
// Function which returns an EVALUATED DISPATCH
// (could be added in WorkSession.cdl ...)
// Two modes : returns dispatch as it is, or return with edition
// Dispatch Name can be : an immediate name of already recorded Dispatch
// Or a name of dispatch + a parameter : dispatch-name(param-value)
// According to type of Dispatch : integer , signature name
occ::handle<IFSelect_Dispatch> IFSelect_Functions::GiveDispatch(
const occ::handle<IFSelect_WorkSession>& WS,
const char* const name,
const bool mode)
{
DeclareAndCast(IFSelect_Dispatch, disp, WS->NamedItem(name));
if (!disp.IsNull())
{
return disp; // OK as it is given
}
// Else, let s try special cases
TCollection_AsciiString nam(name);
int paro = nam.Location(1, '(', 1, nam.Length());
int parf = nam.Location(1, ')', 1, nam.Length());
nam.SetValue(paro, '\0');
nam.SetValue(parf, '\0');
if (paro <= 0 && parf <= 0)
{
return disp;
}
disp = GetCasted(IFSelect_Dispatch, WS->NamedItem(nam.ToCString()));
if (disp.IsNull())
{
return disp; // KO anyway
}
// According to the type of dispatch :
Message_Messenger::StreamBuffer sout = Message::SendInfo();
DeclareAndCast(IFSelect_DispPerCount, dc, disp);
if (!dc.IsNull())
{
int nb = atoi(&(nam.ToCString())[paro]);
if (nb <= 0)
{
sout << " DispPerCount, count is not positive" << '\n';
disp.Nullify();
return disp;
}
if (mode)
{
occ::handle<IFSelect_IntParam> val = new IFSelect_IntParam;
val->SetValue(nb);
dc->SetCount(val);
}
return dc;
}
DeclareAndCast(IFSelect_DispPerFiles, dp, disp);
if (!dp.IsNull())
{
int nb = atoi(&(nam.ToCString())[paro]);
if (nb <= 0)
{
sout << " DispPerFiles, count is not positive" << '\n';
disp.Nullify();
return disp;
}
if (mode)
{
occ::handle<IFSelect_IntParam> val = new IFSelect_IntParam;
val->SetValue(nb);
dp->SetCount(val);
}
return dp;
}
DeclareAndCast(IFSelect_DispPerSignature, ds, disp);
if (!ds.IsNull())
{
DeclareAndCast(IFSelect_Signature, sg, WS->NamedItem(&(nam.ToCString())[paro]));
if (sg.IsNull())
{
sout << "DispPerSignature " << nam << " , Signature not valid : " << &(nam.ToCString())[paro]
<< '\n';
disp.Nullify();
return disp;
}
if (mode)
{
ds->SetSignCounter(new IFSelect_SignCounter(sg));
}
return ds;
}
sout << "Dispatch : " << name << " , Parameter : " << &(nam.ToCString())[paro] << '\n';
return disp;
}
// #########################################
// #### INITIALISATIONS ####
// #########################################
static int THE_IFSelect_Functions_initactor = 0;
void IFSelect_Functions::Init()
{
if (THE_IFSelect_Functions_initactor)
{
return;
}
THE_IFSelect_Functions_initactor = 1;
IFSelect_Act::SetGroup("DE: General");
IFSelect_Act::AddFunc("xstatus", "Lists XSTEP Status : Version, System Name ...", funstatus);
IFSelect_Act::AddFunc("handler", "Toggle status catch Handler Error of the session", fun1);
IFSelect_Act::AddFunc("xload", "file:string : Read File -> Load Model", fun3);
IFSelect_Act::AddFunc("xread", "file:string : Read File -> Load Model", fun3);
IFSelect_Act::AddFunc("writeall", "file:string : Write all model (no split)", fun4);
IFSelect_Act::AddFunc("writesel", "file:string sel:Selection : Write Selected (no split)", fun5);
IFSelect_Act::AddFunc("writeent",
"file:string n1ent n2ent...:integer : Write Entite(s) (no split)",
fun6);
IFSelect_Act::AddFunc("writent",
"file:string n1ent n2ent...:integer : Write Entite(s) (no split)",
fun6);
IFSelect_Act::AddFunc("elabel", "nument:integer : Displays Label Model of an entity", fun7);
IFSelect_Act::AddFunc("enum",
"label:string : Displays entities n0.s of which Label Model ends by..",
fun8);
IFSelect_Act::AddFunc("listtypes",
"List nb entities per type. Optional selection name else all model",
fun9);
IFSelect_Act::AddFunc("count", "Count : counter [selection]", funcount);
IFSelect_Act::AddFunc("listcount", "List Counted : counter [selection [nument]]", funcount);
IFSelect_Act::AddFunc("sumcount", "Summary Counted : counter [selection [nument]]", funcount);
IFSelect_Act::AddFunc("signtype", "Sign Type [newone]", funsigntype);
IFSelect_Act::AddFunc("signcase", "signature : displays possible cases", funsigncase);
IFSelect_Act::AddFunc("estatus", "ent/nument : displays status of an entity", fun10);
IFSelect_Act::AddFunc("data", "Data (DumpModel); whole help : data tout court", fun11);
IFSelect_Act::AddFunc("entity", "give n0 ou id of entity [+ level]", fundumpent);
IFSelect_Act::AddFunc("signature", "signature name + n0/ident entity", funsign);
IFSelect_Act::AddFunc("queryparent", " give 2 n0s/labels of entities : dad son", funqp);
IFSelect_Act::AddFunc("dumpshare", "Dump Share (dispatches, IntParams)", fun12);
IFSelect_Act::AddFunc("listitems", "List Items [label else all] ->Type,Label[,Name]", fun13);
IFSelect_Act::AddFSet("integer", "value:integer : cree un IntParam", fun14);
IFSelect_Act::AddFunc("setint",
"name:IntParam newValue:integer : Change valeur IntParam",
fun15);
IFSelect_Act::AddFSet("text", "value:string : cree un TextParam", fun16);
IFSelect_Act::AddFunc("settext",
"Name:TextParam newValue:string : Change valeur TextParam",
fun17);
IFSelect_Act::AddFunc("dumpsel", "Dump Selection followed by Name of Selection to dump", fun19);
IFSelect_Act::AddFunc("evalsel", "name:Selection [num/sel] : Evalue une Selection", fun20);
IFSelect_Act::AddFunc("givelist", "num/sel [num/sel ...] : Evaluates GiveList", fun20);
IFSelect_Act::AddFunc("giveshort", "num/sel [num/sel ...] : GiveList in short form", fun20);
IFSelect_Act::AddFunc("givepointed",
"num/sel [num/sel ...] : GiveList to fill a SelectPointed",
fun20);
IFSelect_Act::AddFunc("makelist",
"listname [givelist] : Makes a List(SelectPointed) from GiveList",
fun20);
IFSelect_Act::AddFunc("givecount", "num/sel [num/sel ...] : Counts GiveList", fun20c);
IFSelect_Act::AddFSet("selsuite", "sel sel ... : Creates a SelectSuite", funselsuite);
IFSelect_Act::AddFunc("clearitems", "Clears all items (selections, dispatches, etc)", fun21);
IFSelect_Act::AddFunc("cleardata",
"mode:a-g-c-p : Clears all or some data (model, check...)",
fun22);
IFSelect_Act::AddFunc("itemlabel", "xxx xxx : liste items having this label", fun24);
IFSelect_Act::AddFunc("param",
"[-p Pattern] - displays all parameters or filtered by pattern;\n"
"par_name - displays parameter;\n"
"par_name par_value - changes parameter's value",
fun27);
IFSelect_Act::AddFunc("sentfiles", "Lists files sent from last Load", fun29);
IFSelect_Act::AddFunc("fileprefix", "prefix:string : definit File Prefix", fun30);
IFSelect_Act::AddFunc("fileext", "extent:string : definit File Extension", fun31);
IFSelect_Act::AddFunc("fileroot",
"disp:Dispatch root:string : definit File Root sur un Dispatch",
fun32);
IFSelect_Act::AddFunc("filedef", "defroot:string : definit File DefaultRoot", fun33);
IFSelect_Act::AddFunc("evalfile", "Evaluation du FileNaming et memorisation", fun34);
IFSelect_Act::AddFunc("clearfile", "Efface la liste d'EvalFile", fun35);
IFSelect_Act::AddFunc("xsplit",
"[disp:Dispatch sinon tout] : Split, la grande affaire !",
fun36);
IFSelect_Act::AddFunc("remaining",
"options... : Remaining Entities, help complet par remaining ?",
fun37);
IFSelect_Act::AddFunc("setcontent",
"sel:Selection mode:k ou r : Restreint contenu du modele",
fun38);
IFSelect_Act::AddFunc("listmodif", "List Final Modifiers", fun40);
IFSelect_Act::AddFunc("dumpmodif", "modif:Modifier : Affiche le Statut d'un Modifier", fun41);
IFSelect_Act::AddFunc("modifsel",
"modif:Modifier [sel:Selection] : Change/Cancel Selection of Modifier",
fun42);
IFSelect_Act::AddFunc(
"setapplied",
"modif:Modifier [name:un item sinon sortie fichier] : Applique un Modifier",
fun43);
IFSelect_Act::AddFunc("resetapplied",
"modif:Modifier : Remove a Modifier from file output",
fun44);
IFSelect_Act::AddFunc(
"modifmove",
"modif:Modifier M(model)/F(file) avant,apres:integer : Deplace un Modifier (sortie fichier)",
fun45);
IFSelect_Act::AddFunc("dispsel",
"disp:Dispatch sel:Selection -> Final Selection of Dispatch",
fun51);
IFSelect_Act::AddFSet("dispone", "cree DispPerOne", fun_dispone);
IFSelect_Act::AddFSet("dispglob", "cree DispGlobal", fun_dispglob);
IFSelect_Act::AddFSet("dispcount", "count:IntParam : cree DispPerCount", fun_dispcount);
IFSelect_Act::AddFSet("dispfile", "files:IntParam : cree DispPerFiles", fun_dispfiles);
IFSelect_Act::AddFSet("dispsign", "sign:Signature : cree DispPerSignature", fun_dispsign);
IFSelect_Act::AddFunc("dumpdisp", "disp:Dispatch : Affiche le Statut d'un Dispatch", fun56);
IFSelect_Act::AddFunc("xremove", "nom : Remove a Control Item from the Session", fun57);
IFSelect_Act::AddFunc("evaldisp",
"mode=[0-3] disp:Dispatch : Evaluates one or more Dispatch(es)",
fun58);
IFSelect_Act::AddFunc(
"evaladisp",
"mode=[0-3] disp:Dispatch [givelist] : Evaluates a Dispatch (on a GiveList)",
fun_evaladisp);
IFSelect_Act::AddFunc(
"writedisp",
"filepattern disp:Dispatch [givelist] : Writes Entities by Splitting by a Dispatch",
fun_writedisp);
IFSelect_Act::AddFunc("evalcomplete", "Complete Evaluation of the Distribution", fun59);
IFSelect_Act::AddFunc("runcheck", "affiche LastRunCheckList (write,modif)", fun60);
IFSelect_Act::AddFunc("runtranformer", "transf:Transformer : Applique un Transformer", fun61);
IFSelect_Act::AddFSet("copy", "cree TransformStandard, option Copy, vide", fun62);
IFSelect_Act::AddFSet("onthespot", "cree TransformStandard, option OntheSpot, vide", fun63);
IFSelect_Act::AddFunc(
"runcopy",
"modif:ModelModifier [givelist] : Run <modif> via TransformStandard option Copy",
fun6465);
IFSelect_Act::AddFunc(
"runonthespot",
"modif:ModelModifier [givelist] : Run <modif> via TransformStandard option OnTheSpot",
fun6465);
IFSelect_Act::AddFSet("reorder", "[f ou t] reordonne le modele", fun66);
IFSelect_Act::AddFunc("toggle", "sel:Selection genre Extract : Toggle Direct/Reverse", fun70);
IFSelect_Act::AddFunc("input",
"sel:Selection genre Deduct ou Extract input:Selection : Set Input",
fun71);
IFSelect_Act::AddFSet("modelroots", "cree SelectModelRoots", fun72);
IFSelect_Act::AddFSet("range", "options... : create SelectRange ...; simply for help", fun73);
IFSelect_Act::AddFSet("roots", "cree SelectRoots (local roots)", fun74);
IFSelect_Act::AddFSet("shared", "cree SelectShared", fun75);
IFSelect_Act::AddFSet("diff", "[main:Selection diff:Selection] : cree SelectDiff", fun76);
IFSelect_Act::AddFunc("selmain",
"sel:Selection genre Control main:Selection : Set Main Input",
fun77);
IFSelect_Act::AddFunc("selsecond",
"sel:Selection genre Control sec:Selection : Set Second Input",
fun78);
IFSelect_Act::AddFSet("modelall", "cree SelectModelAll", fun79);
IFSelect_Act::AddFunc("seladd",
"sel:Selection genre Combine input:Selection : Add Selection",
fun80);
IFSelect_Act::AddFunc("selrem",
"sel:Selection genre Combine input:Selection : Remove Selection",
fun81);
IFSelect_Act::AddFSet("number", "num:IntParam : Cree SelectEntityNumber", fun82);
IFSelect_Act::AddFSet("union", "cree SelectUnion (vide), cf aussi combadd, combrem", fun83);
IFSelect_Act::AddFSet("intersect",
"cree SelectIntersection (vide), cf aussi combadd, combrem",
fun84);
IFSelect_Act::AddFSet("typexact", "type:string : cree SelectTextType Exact", fun85);
IFSelect_Act::AddFSet("errors", "cree SelectErrorEntities (from file)", fun86);
IFSelect_Act::AddFSet("unknown", "cree SelectUnknownEntities", fun87);
IFSelect_Act::AddFSet("sharing", "cree SelectSharing", fun88);
IFSelect_Act::AddFSet("typecontain", "type:string : cree SelectTextType Contains", fun89);
IFSelect_Act::AddFSet("pointed", "cree SelectPointed [num/sel num/sel]", fun90);
IFSelect_Act::AddFunc("setpointed",
"sel:SelectPointed : edit SelectPointed. simply for help",
fun91);
IFSelect_Act::AddFunc("setlist",
"sel:SelectPointed : edit SelectPointed. simply for help",
fun91);
IFSelect_Act::AddFSet("incorrect", "cree SelectIncorrectEntities (computed)", fun92);
IFSelect_Act::AddFSet("signsel",
"sign:Signature|cnt:Counter text:string [e(D)|c] : cree SelectSignature",
fun93);
IFSelect_Act::AddFSet("signcounter", "sign:Signature : cree SignCounter", fun94);
IFSelect_Act::AddFSet("nbselected",
"applied:Selection : cree GraphCounter(=NbSelected)",
funbselected);
IFSelect_Act::AddFunc("editlist", "editor or editform : lists defs + values", fun_editlist);
IFSelect_Act::AddFunc("editvalue",
"editform paramname [newval or .] : lists-changes a value",
fun_editvalue);
IFSelect_Act::AddFunc("editclear",
"editform [paramname] : clears edition on all or one param",
fun_editclear);
IFSelect_Act::AddFunc("editload",
"editform [entity-id] : loads from model or an entity",
fun_editload);
IFSelect_Act::AddFunc("editapply", "editform [keep] : applies on loaded data", fun_editapply);
}