src/XSControl/XSControl_Utils.cxx

   1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   2 //
   3 // This file is part of Open CASCADE Technology software library.
   4 //
   5 // This library is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU Lesser General Public License version 2.1 as published
   7 // by the Free Software Foundation, with special exception defined in the file
   8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
   9 // distribution for complete text of the license and disclaimer of any warranty.
  10 //
  11 // Alternatively, this file may be used under the terms of Open CASCADE
  12 // commercial license or contractual agreement.
  13
  14
  15 #include <BRep_Builder.hxx>
  16 #include <BRepTools.hxx>
  17 #include <Interface_HArray1OfHAsciiString.hxx>
  18 #include <Interface_Macros.hxx>
  19 #include <Interface_MSG.hxx>
  20 #include <Message.hxx>
  21 #include <Message_Messenger.hxx>
  22 #include <Standard_Transient.hxx>
  23 #include <Standard_TypeMismatch.hxx>
  24 #include <TCollection_AsciiString.hxx>
  25 #include <TCollection_ExtendedString.hxx>
  26 #include <TCollection_HAsciiString.hxx>
  27 #include <TCollection_HExtendedString.hxx>
  28 #include <TColStd_HArray1OfTransient.hxx>
  29 #include <TColStd_HSequenceOfAsciiString.hxx>
  30 #include <TColStd_HSequenceOfExtendedString.hxx>
  31 #include <TopExp_Explorer.hxx>
  32 #include <TopoDS.hxx>
  33 #include <TopoDS_Compound.hxx>
  34 #include <TopoDS_HShape.hxx>
  35 #include <TopoDS_Iterator.hxx>
  36 #include <TopoDS_Shape.hxx>
  37 #include <TopoDS_Shell.hxx>
  38 #include <TopoDS_Wire.hxx>
  39 #include <Transfer_SimpleBinderOfTransient.hxx>
  40 #include <TransferBRep.hxx>
  41 #include <TransferBRep_ShapeBinder.hxx>
  42 #include <TransferBRep_ShapeMapper.hxx>
  43 #include <XSControl_Utils.hxx>
  44
  45 static TCollection_AsciiString    bufasc;
  46 static TCollection_ExtendedString bufext;
  47 static const Standard_ExtString   voidext = { 0 };
  48
  49
  50     XSControl_Utils::XSControl_Utils ()    {  }
  51
  52 //  #########################################################
  53 //  #######           Fonctions  de   TRACE           #######
  54
  55     void  XSControl_Utils::TraceLine (const Standard_CString line) const
  56 {
  57   Message_Messenger::StreamBuffer sout = Message::SendInfo();
  58   sout<<line<<std::endl;
  59 }
  60
  61     void  XSControl_Utils::TraceLines (const Handle(Standard_Transient)& lines) const
  62 {
  63   Message_Messenger::StreamBuffer sout = Message::SendInfo();
  64   Standard_Integer i,nb;
  65   DeclareAndCast(TColStd_HSequenceOfHAsciiString,linha,lines);
  66   if (!linha.IsNull()) {
  67     nb = linha->Length();
  68     for (i = 1; i <= nb; i ++)
  69       if (!linha->Value(i).IsNull()) sout<<linha->Value(i)->ToCString()<<std::endl;
  70     return;
  71   }
  72   DeclareAndCast(TColStd_HSequenceOfAsciiString,lina,lines);
  73   if (!lina.IsNull()) {
  74     nb = lina->Length();
  75     for (i = 1; i <= nb; i ++)
  76       sout<<lina->Value(i).ToCString()<<std::endl;
  77     return;
  78   }
  79   DeclareAndCast(TColStd_HSequenceOfHExtendedString,linhe,lines);
  80   if (!linhe.IsNull()) {
  81     nb = linhe->Length();
  82     for (i = 1; i <= nb; i ++)
  83       if (!linhe->Value(i).IsNull())
  84         sout << linhe->Value(i)->String() << std::endl;
  85     return;
  86   }
  87   DeclareAndCast(TColStd_HSequenceOfExtendedString,linee,lines);
  88   if (!linee.IsNull()) {
  89     nb = linee->Length();
  90     for (i = 1; i <= nb; i ++)
  91       sout << linee->Value(i) << std::endl;
  92     return;
  93   }
  94   DeclareAndCast(TCollection_HAsciiString,lin1a,lines);
  95   if (!lin1a.IsNull()) sout<<lin1a->String();
  96   DeclareAndCast(TCollection_HExtendedString,lin1e,lines);
  97   if (!lin1e.IsNull()) sout<<lin1e->String();
  98 }
  99
 100
 101 //  #########################################################
 102 //  #######   TRANSIENT : Quelques  acces  de  base   #######
 103
 104     Standard_Boolean  XSControl_Utils::IsKind
 105   (const Handle(Standard_Transient)& item, const Handle(Standard_Type)& what) const
 106 {
 107   if (item.IsNull()) return Standard_False;
 108   if (what.IsNull()) return Standard_False;
 109   return item->IsKind(what);
 110 }
 111
 112     Standard_CString  XSControl_Utils::TypeName
 113   (const Handle(Standard_Transient)& item, const Standard_Boolean nopk) const
 114 {
 115   if (item.IsNull()) return "";
 116   DeclareAndCast(Standard_Type,atype,item);
 117   if (atype.IsNull()) atype = item->DynamicType();
 118   Standard_CString tn = atype->Name();
 119   if (!nopk) return tn;
 120   for (int i = 0; tn[i] != '\0'; i ++) {
 121     if (tn[i] == '_') return &tn[i+1];
 122   }
 123   return tn;
 124 }
 125
 126
 127 //  #######       TRANSIENT : Fonctions de liste       #######
 128
 129     Handle(Standard_Transient)  XSControl_Utils::TraValue
 130   (const Handle(Standard_Transient)& seqval, const Standard_Integer num) const
 131 {
 132   Handle(Standard_Transient) val;
 133   if (num < 1) return val;
 134   if (seqval.IsNull()) return val;
 135   DeclareAndCast(TColStd_HSequenceOfHAsciiString,seqs,seqval);
 136   if (!seqs.IsNull())
 137     {  if (num <= seqs->Length()) val = seqs->Value(num);  return val;  }
 138   DeclareAndCast(TColStd_HSequenceOfTransient,seqt,seqval);
 139   if (!seqt.IsNull())
 140     {  if (num <= seqt->Length()) val = seqt->Value(num);  return val;  }
 141 //  throw Standard_TypeMismatch("XSControl_Utils::SeqTraValue");
 142   return val;
 143 }
 144
 145     Handle(TColStd_HSequenceOfTransient) XSControl_Utils::NewSeqTra () const
 146       {  return  new TColStd_HSequenceOfTransient();  }
 147
 148     void  XSControl_Utils::AppendTra
 149   (const Handle(TColStd_HSequenceOfTransient)& seqval,
 150    const Handle(Standard_Transient)& traval) const
 151       {  seqval->Append (traval);  }
 152
 153
 154 //  #######           DATES           #######
 155
 156     Standard_CString  XSControl_Utils::DateString
 157   (const Standard_Integer yy, const Standard_Integer mm,
 158    const Standard_Integer dd, const Standard_Integer hh,
 159    const Standard_Integer mn, const Standard_Integer ss) const
 160 {
 161   char ladate[50];
 162   Interface_MSG::TDate (ladate, yy,mm,dd,hh,mn,ss);
 163   bufasc.Clear();  bufasc.AssignCat(ladate);
 164   return bufasc.ToCString();
 165 }
 166
 167     void  XSControl_Utils::DateValues
 168   (const Standard_CString text,
 169    Standard_Integer& yy, Standard_Integer& mm, Standard_Integer& dd,
 170    Standard_Integer& hh, Standard_Integer& mn, Standard_Integer& ss) const
 171       {  Interface_MSG::NDate (text, yy,mm,dd,hh,mn,ss);  }
 172
 173
 174 //  ##########################################################
 175 //  #######           STRING : Ascii de base           #######
 176
 177     Standard_CString  XSControl_Utils::ToCString
 178   (const Handle(TCollection_HAsciiString)& strval) const
 179       {
 180 //JR/Hp
 181          Standard_CString astr = (Standard_CString ) (strval.IsNull() ? "" : strval->ToCString());
 182          return astr ;
 183 //         return (strval.IsNull() ? "" : strval->ToCString());
 184       }
 185
 186     Standard_CString  XSControl_Utils::ToCString
 187   (const TCollection_AsciiString& strval) const
 188       {  return strval.ToCString();  }
 189
 190     Handle(TCollection_HAsciiString)  XSControl_Utils::ToHString
 191   (const Standard_CString strcon) const
 192       {  return new TCollection_HAsciiString(strcon);  }
 193
 194     TCollection_AsciiString  XSControl_Utils::ToAString
 195   (const Standard_CString strcon) const
 196       {  return TCollection_AsciiString(strcon);  }
 197
 198 //  #######         STRING : Extended de base         #######
 199
 200     Standard_ExtString  XSControl_Utils::ToEString
 201   (const Handle(TCollection_HExtendedString)& strval) const
 202       {  return (strval.IsNull() ? voidext : strval->ToExtString());  }
 203
 204     Standard_ExtString  XSControl_Utils::ToEString
 205   (const TCollection_ExtendedString& strval) const
 206       {  return strval.ToExtString();  }
 207
 208     Handle(TCollection_HExtendedString)  XSControl_Utils::ToHString
 209   (const Standard_ExtString strcon) const
 210       {  return new TCollection_HExtendedString(strcon);  }
 211
 212     TCollection_ExtendedString  XSControl_Utils::ToXString
 213   (const Standard_ExtString strcon) const
 214       {  return TCollection_ExtendedString(strcon);  }
 215
 216 //  #######        STRING : Ascii <-> Extended        #######
 217
 218     Standard_ExtString  XSControl_Utils::AsciiToExtended (const Standard_CString str) const
 219 {
 220   bufext.Clear();  bufext = TCollection_ExtendedString (str);
 221   return bufext.ToExtString();
 222 }
 223
 224     Standard_Boolean  XSControl_Utils::IsAscii (const Standard_ExtString str) const
 225 {
 226   bufext.Clear();  bufext.AssignCat (str);
 227   return bufext.IsAscii();
 228 }
 229
 230     Standard_CString  XSControl_Utils::ExtendedToAscii (const Standard_ExtString str) const
 231 {
 232   bufext.Clear();  bufext.AssignCat (str);  bufasc.Clear();
 233   Standard_Integer i, nb = bufext.Length();
 234   for (i = 1; i <= nb; i ++) {
 235     int unext = bufext.Value(i);
 236     unext = unext & 127;
 237     char uncar = char(unext);
 238     bufasc.AssignCat (uncar);
 239   }
 240   return bufasc.ToCString();
 241 }
 242
 243 //  #######              STRING : LISTES              #######
 244
 245     Standard_CString  XSControl_Utils::CStrValue
 246   (const Handle(Standard_Transient)& list, const Standard_Integer num) const
 247 {
 248   DeclareAndCast(TColStd_HSequenceOfHAsciiString,linha,list);
 249   if (!linha.IsNull()) {
 250 //JR/Hp
 251     Standard_CString astr = (Standard_CString )
 252     (num > linha->Length() ? "" : linha->Value(num)->ToCString());
 253     return astr ;
 254 //    return (num > linha->Length() ? "" : linha->Value(num)->ToCString());
 255   }
 256
 257   DeclareAndCast(TColStd_HSequenceOfAsciiString,lina,list);
 258   if (!lina.IsNull()) {
 259 //JR/Hp
 260     Standard_CString astr = (Standard_CString )
 261     (num > lina->Length() ? "" : lina->Value(num).ToCString());
 262     return astr ;
 263 //    return (num > lina->Length() ? "" : lina->Value(num).ToCString());
 264   }
 265
 266   DeclareAndCast(TColStd_HSequenceOfHExtendedString,linhe,list);
 267   if (!linhe.IsNull()) {
 268 //JR/Hp
 269     Standard_CString astr = (Standard_CString )
 270     (num > linhe->Length() ? "" : ExtendedToAscii(linhe->Value(num)->ToExtString()));
 271     return astr ;
 272 //   return (num > linhe->Length() ? "" : ExtendedToAscii(linhe->Value(num)->ToExtString()));
 273   }
 274
 275   DeclareAndCast(TColStd_HSequenceOfExtendedString,linee,list);
 276   if (!linee.IsNull()) {
 277 //JR/Hp
 278     Standard_CString astr = (Standard_CString )
 279     (num > linee->Length() ? "" : ExtendedToAscii(linee->Value(num).ToExtString()));
 280     return astr ;
 281 //    return (num > linee->Length() ? "" : ExtendedToAscii(linee->Value(num).T
 282   }
 283
 284   DeclareAndCast(TCollection_HAsciiString,lin1a,list);
 285   if (!lin1a.IsNull()) return lin1a->ToCString();
 286   DeclareAndCast(TCollection_HExtendedString,lin1e,list);
 287   if (!lin1e.IsNull()) return ExtendedToAscii(lin1e->ToExtString());
 288   return "";
 289 }
 290
 291
 292     Standard_ExtString  XSControl_Utils::EStrValue
 293   (const Handle(Standard_Transient)& list, const Standard_Integer num) const
 294 {
 295   DeclareAndCast(TColStd_HSequenceOfHAsciiString,linha,list);
 296   if (!linha.IsNull()) return
 297     (num > linha->Length() ? voidext : AsciiToExtended(linha->Value(num)->ToCString()));
 298
 299   DeclareAndCast(TColStd_HSequenceOfAsciiString,lina,list);
 300   if (!lina.IsNull())
 301     (num > lina->Length() ? voidext : AsciiToExtended(lina->Value(num).ToCString()));
 302
 303   DeclareAndCast(TColStd_HSequenceOfHExtendedString,linhe,list);
 304   if (!linhe.IsNull()) return
 305     (num > linhe->Length() ? voidext : linhe->Value(num)->ToExtString());
 306
 307   DeclareAndCast(TColStd_HSequenceOfExtendedString,linee,list);
 308   if (!linee.IsNull()) return
 309     (num > linee->Length() ? voidext : linee->Value(num).ToExtString());
 310
 311   DeclareAndCast(TCollection_HAsciiString,lin1a,list);
 312   if (!lin1a.IsNull()) return AsciiToExtended(lin1a->ToCString());
 313   DeclareAndCast(TCollection_HExtendedString,lin1e,list);
 314   if (!lin1e.IsNull()) return lin1e->ToExtString();
 315   return voidext;
 316 }
 317
 318     Handle(TColStd_HSequenceOfHAsciiString) XSControl_Utils::NewSeqCStr () const
 319       {  return  new TColStd_HSequenceOfHAsciiString();  }
 320
 321     void  XSControl_Utils::AppendCStr
 322   (const Handle(TColStd_HSequenceOfHAsciiString)& seqval,
 323    const Standard_CString strval) const
 324       {  seqval->Append (new TCollection_HAsciiString(strval));  }
 325
 326     Handle(TColStd_HSequenceOfHExtendedString) XSControl_Utils::NewSeqEStr () const
 327       {  return  new TColStd_HSequenceOfHExtendedString();  }
 328
 329     void  XSControl_Utils::AppendEStr
 330   (const Handle(TColStd_HSequenceOfHExtendedString)& seqval,
 331    const Standard_ExtString strval) const
 332       {  seqval->Append (new TCollection_HExtendedString(strval));  }
 333
 334
 335 //  ##########################################################
 336 //  #######           SHAPES : Acces de base           #######
 337
 338     TopoDS_Shape  XSControl_Utils::CompoundFromSeq
 339   (const Handle(TopTools_HSequenceOfShape)& seqval) const
 340 {
 341   BRep_Builder B;
 342   TopoDS_Compound C;
 343   B.MakeCompound(C);
 344   Standard_Integer i,n = seqval->Length();
 345   for (i = 1; i <= n ; i ++)  B.Add(C,seqval->Value(i));
 346   return C;
 347 }
 348
 349     TopAbs_ShapeEnum  XSControl_Utils::ShapeType
 350   (const TopoDS_Shape& shape, const Standard_Boolean compound) const
 351 {
 352   if (shape.IsNull()) return TopAbs_SHAPE;
 353   TopAbs_ShapeEnum res = shape.ShapeType();
 354   if (!compound || res != TopAbs_COMPOUND) return res;
 355   res = TopAbs_SHAPE;
 356   for (TopoDS_Iterator iter(shape); iter.More(); iter.Next()) {
 357     TopoDS_Shape sh = iter.Value();
 358     if (sh.IsNull()) continue;
 359     TopAbs_ShapeEnum typ = sh.ShapeType();
 360     if (typ == TopAbs_COMPOUND) typ = ShapeType (sh,compound);
 361     if (res == TopAbs_SHAPE) res = typ;
 362 //   Egalite : OK;  Pseudo-Egalite : EDGE/WIRE ou FACE/SHELL
 363     else if (res == TopAbs_EDGE  && typ == TopAbs_WIRE)  res = typ;
 364     else if (res == TopAbs_WIRE  && typ == TopAbs_EDGE)  continue;
 365     else if (res == TopAbs_FACE  && typ == TopAbs_SHELL) res = typ;
 366     else if (res == TopAbs_SHELL && typ == TopAbs_FACE)  continue;
 367     else if (res != typ) return TopAbs_COMPOUND;
 368   }
 369   return res;
 370 }
 371
 372     TopoDS_Shape  XSControl_Utils::SortedCompound
 373   (const TopoDS_Shape& shape, const TopAbs_ShapeEnum type,
 374    const Standard_Boolean explore, const Standard_Boolean compound) const
 375 {
 376   if (shape.IsNull()) return shape;
 377   TopAbs_ShapeEnum typ = shape.ShapeType();
 378   TopoDS_Shape sh, sh0;
 379   Standard_Integer nb = 0;
 380
 381 //  Compound : on le prend, soit tel quel, soit son contenu
 382   if (typ == TopAbs_COMPOUND || typ == TopAbs_COMPSOLID) {
 383     TopoDS_Compound C;
 384     BRep_Builder B;
 385     B.MakeCompound (C);
 386     for (TopoDS_Iterator it(shape); it.More(); it.Next()) {
 387       sh0 = SortedCompound (it.Value(),type,explore,compound);
 388       if (sh0.IsNull()) continue;
 389       sh = sh0;
 390       typ = sh.ShapeType();
 391       if (typ == TopAbs_COMPOUND && !compound) {
 392         for (TopoDS_Iterator it2 (sh); it2.More(); it2.Next())
 393           {  nb ++;  sh = it2.Value();  B.Add (C, sh);  }
 394       }
 395       else  {  nb ++;  B.Add (C,sh);  }
 396     }
 397     if (nb == 0) C.Nullify();
 398     else if (nb == 1) return sh;
 399     return C;
 400   }
 401
 402 //   Egalite : OK;  Pseudo-Egalite : EDGE/WIRE ou FACE/SHELL
 403   if (typ == type) return shape;
 404   if (typ == TopAbs_EDGE && type == TopAbs_WIRE) {
 405     BRep_Builder B;
 406     TopoDS_Wire W;
 407     B.MakeWire (W);
 408     B.Add (W,shape);  // ne passe pas ! : TopoDS::Edge(shape)
 409     return W;
 410   }
 411   if (typ == TopAbs_FACE && type == TopAbs_SHELL) {
 412     BRep_Builder B;
 413     TopoDS_Shell S;
 414     B.MakeShell (S);
 415     B.Add (S,shape);  // ne passe pas ! : TopoDS::Face(shape));
 416     S.Closed (BRep_Tool::IsClosed (S));
 417     return S;
 418   }
 419
 420 //   Le reste : selon exploration
 421   if (!explore) {
 422     TopoDS_Shape nulsh;
 423     return nulsh;
 424   }
 425
 426 //  Ici, on doit explorer
 427 //  SOLID + mode COMPOUND : reconduire les SHELLs
 428   if (typ == TopAbs_SOLID && compound) {
 429     TopoDS_Compound C;
 430     BRep_Builder B;
 431     B.MakeCompound (C);
 432     for (TopoDS_Iterator it(shape); it.More(); it.Next()) {
 433       sh0 = SortedCompound (it.Value(),type,explore,compound);
 434       if (sh0.IsNull()) continue;
 435       sh = sh0;
 436       nb ++;  B.Add (C,sh);
 437     }
 438     if (nb == 0) C.Nullify();
 439     else if (nb == 1) return sh;
 440     return C;
 441   }
 442
 443 //  Exploration classique
 444   TopoDS_Compound CC;
 445   BRep_Builder BB;
 446   BB.MakeCompound(CC);
 447   for (TopExp_Explorer aExp (shape,type); aExp.More(); aExp.Next()) {
 448     nb ++;
 449     sh = aExp.Current();
 450     BB.Add (CC,sh);
 451   }
 452   if (nb == 0) CC.Nullify();
 453   else if (nb == 1) return sh;
 454   return CC;
 455 }
 456
 457
 458 //  #######               SHAPES : Liste               #######
 459
 460     TopoDS_Shape  XSControl_Utils::ShapeValue
 461   (const Handle(TopTools_HSequenceOfShape)& seqval, const Standard_Integer num) const
 462 {
 463   TopoDS_Shape shape;
 464   if (seqval.IsNull()) return shape;
 465   if (num > 0 && num <= seqval->Length()) shape = seqval->Value(num);
 466   return shape;
 467 }
 468
 469     Handle(TopTools_HSequenceOfShape) XSControl_Utils::NewSeqShape () const
 470       {  return  new TopTools_HSequenceOfShape();  }
 471
 472     void  XSControl_Utils::AppendShape
 473   (const Handle(TopTools_HSequenceOfShape)& seqval, const TopoDS_Shape& shape) const
 474       {  seqval->Append (shape);  }
 475
 476 //  #######            SHAPES <-> Transient            #######
 477
 478     Handle(Standard_Transient)  XSControl_Utils::ShapeBinder
 479   (const TopoDS_Shape& shape, const Standard_Boolean hs) const
 480       {  if (hs) return new TopoDS_HShape            (shape);
 481          else    return new TransferBRep_ShapeBinder (shape);  }
 482
 483     TopoDS_Shape  XSControl_Utils::BinderShape
 484   (const Handle(Standard_Transient)& tr) const
 485 {
 486   TopoDS_Shape sh;
 487   DeclareAndCast(Transfer_Binder,sb,tr);
 488   if (!sb.IsNull()) return TransferBRep::ShapeResult(sb);
 489   DeclareAndCast(TransferBRep_ShapeMapper,sm,tr);
 490   if (!sm.IsNull()) return sm->Value();
 491   DeclareAndCast(TopoDS_HShape,hs,tr);
 492   if (!hs.IsNull()) return hs->Shape();
 493   return sh;
 494 }
 495
 496
 497 //  ##########################################################
 498 //  #######        LISTES : Fonctions Generales        #######
 499
 500     Standard_Integer  XSControl_Utils::SeqLength
 501   (const Handle(Standard_Transient)& seqval) const
 502 {
 503   if (seqval.IsNull()) return 0;
 504   DeclareAndCast(TColStd_HSequenceOfHAsciiString,seqs,seqval);
 505   if (!seqs.IsNull()) return seqs->Length();
 506   DeclareAndCast(TColStd_HSequenceOfAsciiString,seqa,seqval);
 507   if (!seqa.IsNull()) return seqa->Length();
 508   DeclareAndCast(TColStd_HSequenceOfHExtendedString,seqe,seqval);
 509   if (!seqe.IsNull()) return seqe->Length();
 510   DeclareAndCast(TColStd_HSequenceOfHExtendedString,seqx,seqval);
 511   if (!seqx.IsNull()) return seqx->Length();
 512
 513   DeclareAndCast(TColStd_HSequenceOfTransient,seqt,seqval);
 514   if (!seqt.IsNull()) return seqt->Length();
 515   DeclareAndCast(TopTools_HSequenceOfShape,seqh,seqval);
 516   if (!seqh.IsNull()) return seqh->Length();
 517   DeclareAndCast(TColStd_HSequenceOfInteger,seqi,seqval);
 518   if (!seqi.IsNull()) return seqi->Length();
 519 //  throw Standard_TypeMismatch("XSControl_Utils::SeqLength");
 520   return 0;
 521 }
 522
 523     Handle(Standard_Transient)  XSControl_Utils::SeqToArr
 524   (const Handle(Standard_Transient)& seqval, const Standard_Integer first) const
 525 {
 526   Standard_Integer i,lng;
 527   Handle(Standard_Transient) val;
 528   if (seqval.IsNull()) return val;
 529   DeclareAndCast(TColStd_HSequenceOfHAsciiString,seqs,seqval);
 530   if (!seqs.IsNull()) {
 531     lng = seqs->Length();
 532     Handle(Interface_HArray1OfHAsciiString) arrs =
 533       new Interface_HArray1OfHAsciiString(first,lng-first+1);
 534     for (i = 1; i <= lng; i ++)  arrs->SetValue (i-first+1,seqs->Value(i));
 535     return arrs;
 536   }
 537   DeclareAndCast(TColStd_HSequenceOfTransient,seqt,seqval);
 538   if (!seqt.IsNull()) {
 539     lng = seqt->Length();
 540     Handle(TColStd_HArray1OfTransient) arrt =
 541       new TColStd_HArray1OfTransient(first,lng-first+1);
 542     for (i = 1; i <= lng; i ++)  arrt->SetValue (i-first+1,seqt->Value(i));
 543     return arrt;
 544   }
 545   throw Standard_TypeMismatch("XSControl_Utils::SeqToArr");
 546 }
 547
 548
 549     Handle(Standard_Transient)  XSControl_Utils::ArrToSeq
 550   (const Handle(Standard_Transient)& arrval) const
 551 {
 552   Standard_Integer i,first,last;
 553   Handle(Standard_Transient) val;
 554   if (arrval.IsNull()) return val;
 555   DeclareAndCast(Interface_HArray1OfHAsciiString,arrs,arrval);
 556   if (!arrs.IsNull()) {
 557     first = arrs->Lower();
 558     last  = arrs->Upper();
 559     Handle(TColStd_HSequenceOfHAsciiString) seqs =
 560       new TColStd_HSequenceOfHAsciiString();
 561     for (i = first; i <= last; i ++)  seqs->Append (arrs->Value(i));
 562     return seqs;
 563   }
 564   DeclareAndCast(TColStd_HArray1OfTransient,arrt,arrval);
 565   if (!arrt.IsNull()) {
 566     first = arrt->Lower();
 567     last  = arrt->Upper();
 568     Handle(TColStd_HSequenceOfTransient) seqt =
 569       new TColStd_HSequenceOfTransient();
 570     for (i = first; i <= last; i ++)  seqt->Append (arrt->Value(i));
 571     return seqt;
 572   }
 573   throw Standard_TypeMismatch("XSControl_Utils::ArrToSeq");
 574 }
 575
 576
 577     Standard_Integer  XSControl_Utils::SeqIntValue
 578   (const Handle(TColStd_HSequenceOfInteger)& seqval,
 579    const Standard_Integer num) const
 580 {
 581   if (seqval.IsNull()) return 0;
 582   return seqval->Value(num);
 583 }