[occt.git] / src / IFSelect / IFSelect_ShareOut.cxx

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


#include <IFSelect_Dispatch.hxx>
#include <IFSelect_GeneralModifier.hxx>
#include <IFSelect_Modifier.hxx>
#include <IFSelect_ShareOut.hxx>
#include <Interface_InterfaceError.hxx>
#include <Interface_Macros.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_HAsciiString.hxx>

#include <stdio.h>
IMPLEMENT_STANDARD_RTTIEXT(IFSelect_ShareOut,Standard_Transient)

IFSelect_ShareOut::IFSelect_ShareOut ()
{
  thedefrt  = new TCollection_HAsciiString ("Default");
  thenbdefs = thelastrun = 0;
}


    void  IFSelect_ShareOut::Clear (const Standard_Boolean onlydisp)
{
  thedisps.Clear();
  ClearResult(!onlydisp);
  if (onlydisp) return;
  themodelmodifiers.Clear();
  thefilemodifiers.Clear();
}

    Standard_Boolean  IFSelect_ShareOut::RemoveItem
  (const Handle(Standard_Transient)& item)
{
  DeclareAndCast(IFSelect_GeneralModifier,modifier,item);
  if (!modifier.IsNull()) {
    Standard_Boolean formodel = modifier->IsKind(STANDARD_TYPE(IFSelect_Modifier));
    Standard_Integer atnum = ModifierRank(modifier);
    return RemoveModifier (formodel,atnum);
  }
  DeclareAndCast(IFSelect_Dispatch,disp,item);
  if (!disp.IsNull()) {
    Standard_Integer atnum = DispatchRank(disp);
    return RemoveDispatch(atnum);
  }
  return Standard_False;
}


    void  IFSelect_ShareOut::ClearResult (const Standard_Boolean alsoname)
{
  thelastrun = 0;
  if (alsoname) thenbdefs = 0;
}

    Standard_Integer  IFSelect_ShareOut::LastRun () const
      {  return thelastrun;  }

    void  IFSelect_ShareOut::SetLastRun (const Standard_Integer lastrun)
      {  thelastrun = lastrun;  }

//  #######################################################################
//  ####                DISPATCHES (ENVOI DES FICHIERS)                ####

    Standard_Integer  IFSelect_ShareOut::NbDispatches () const 
      {  return thedisps.Length();  }

    Standard_Integer  IFSelect_ShareOut::DispatchRank
  (const Handle(IFSelect_Dispatch)& disp) const 
{
  if (disp.IsNull()) return 0;
  for (Standard_Integer i = thedisps.Length(); i >= 1; i --)
    if (disp == thedisps.Value(i)) return i;
  return 0;
}

    const Handle(IFSelect_Dispatch)&  IFSelect_ShareOut::Dispatch
  (const Standard_Integer num) const 
{
  return thedisps.Value(num);
}

    void  IFSelect_ShareOut::AddDispatch
  (const Handle(IFSelect_Dispatch)& disp)
{
  if (disp.IsNull()) return;
  thedisps.Append(disp);
}


    Standard_Boolean  IFSelect_ShareOut::RemoveDispatch
  (const Standard_Integer rank)
{
  if (rank <= thelastrun || rank > thedisps.Length()) return Standard_False;
  thedisps.Remove(rank);
  return Standard_True;
}

//  ##########################################################################
//  ####                            MODIFIERS                             ####

    void  IFSelect_ShareOut::AddModifier
  (const Handle(IFSelect_GeneralModifier)& modifier,
   const Standard_Integer atnum)
{
  Standard_Boolean formodel = modifier->IsKind(STANDARD_TYPE(IFSelect_Modifier));
  if (ModifierRank(modifier) == 0)  AddModif (modifier,formodel,atnum);
  Handle(IFSelect_Dispatch) nuldisp;
  modifier->SetDispatch(nuldisp);
}

    void  IFSelect_ShareOut::AddModifier
  (const Handle(IFSelect_GeneralModifier)& modifier,
   const Standard_Integer dispnum, const Standard_Integer atnum)
{
  Standard_Boolean formodel = modifier->IsKind(STANDARD_TYPE(IFSelect_Modifier));
  if (ModifierRank(modifier) == 0)  AddModif (modifier,formodel,atnum);
  Handle(IFSelect_Dispatch) disp = Dispatch(dispnum);
  modifier->SetDispatch(disp);
}


    void  IFSelect_ShareOut::AddModif
  (const Handle(IFSelect_GeneralModifier)& modifier,
   const Standard_Boolean formodel, const Standard_Integer atnum)
{
  if (formodel) {
    if (atnum > 0 && atnum <= themodelmodifiers.Length())
      themodelmodifiers.InsertBefore(atnum,modifier);
    else themodelmodifiers.Append(modifier);
  } else {
    if (atnum > 0 && atnum <= thefilemodifiers.Length())
      thefilemodifiers.InsertBefore(atnum,modifier);
    else thefilemodifiers.Append(modifier);
  }
}

    Standard_Integer  IFSelect_ShareOut::NbModifiers
  (const Standard_Boolean formodel) const 
{
  if (formodel) return themodelmodifiers.Length();
  else          return thefilemodifiers.Length();
}

    Handle(IFSelect_GeneralModifier)  IFSelect_ShareOut::GeneralModifier
  (const Standard_Boolean formodel, const Standard_Integer atnum) const
{
  if (formodel) return themodelmodifiers.Value(atnum);
  else          return thefilemodifiers.Value(atnum);
}

    Handle(IFSelect_Modifier)  IFSelect_ShareOut::ModelModifier
  (const Standard_Integer num) const 
{  return Handle(IFSelect_Modifier)::DownCast(themodelmodifiers.Value(num));  }

    Standard_Integer  IFSelect_ShareOut::ModifierRank
  (const Handle(IFSelect_GeneralModifier)& modifier) const 
{
  Standard_Integer i;
  Standard_Boolean formodel = modifier->IsKind(STANDARD_TYPE(IFSelect_Modifier));
  if (formodel) {
    for (i = themodelmodifiers.Length(); i >= 1; i --)
      if (modifier == themodelmodifiers.Value(i)) return i;
  } else {
    for (i = thefilemodifiers.Length(); i >= 1; i --)
      if (modifier == thefilemodifiers.Value(i)) return i;
  }
  return 0;
}


    Standard_Boolean  IFSelect_ShareOut::RemoveModifier
  (const Standard_Boolean formodel, const Standard_Integer atnum)
{
  if (atnum <= 0) return Standard_False;
  if (formodel) {
    if (atnum > themodelmodifiers.Length()) return Standard_False;
    themodelmodifiers.Remove(atnum);
  } else {
    if (atnum > thefilemodifiers.Length()) return Standard_False;
    thefilemodifiers.Remove(atnum);
  }
  return Standard_True;
}


//    ChangeModifierRank revient a une permutation circulaire :
//    before est mis en after, ceux qui sont entre tournent
    Standard_Boolean    IFSelect_ShareOut::ChangeModifierRank
  (const Standard_Boolean formodel,
   const Standard_Integer before,   const Standard_Integer after)
{
  Standard_Integer nb;
  if (before <= 0 || after <= 0) return Standard_False;
  if (before == after) return Standard_True;
  if (formodel) {
    nb = themodelmodifiers.Length();
    if (before > nb || after > nb) return Standard_False;
    Handle(IFSelect_GeneralModifier) bef = themodelmodifiers.Value(before);
    themodelmodifiers.Remove(before);
    if (after == nb) themodelmodifiers.Append(bef);
    else             themodelmodifiers.InsertBefore(after,bef);
  } else {
    nb = thefilemodifiers.Length();
    if (before > nb || after > nb) return Standard_False;
    Handle(IFSelect_GeneralModifier) bef = thefilemodifiers.Value(before);
    thefilemodifiers.Remove(before);
    if (after == nb) thefilemodifiers.Append(bef);
    else             thefilemodifiers.InsertBefore(after,bef);
  }
  return Standard_True;
}

//  #######################################################################
//  ####                    NOMINATION DES FICHIERS                    ####
//  Rq : thenbdefs s applique tant que l on ne change pas les termes principaux

    Standard_Boolean  IFSelect_ShareOut::SetRootName
  (const Standard_Integer num, const Handle(TCollection_HAsciiString)& name)
{
  if (num < 1 || num > thedisps.Length()) return Standard_False;
  if (RootNumber(name) != 0) return Standard_False;
  Dispatch(num)->SetRootName (name);
  return Standard_True;
}

    Standard_Boolean  IFSelect_ShareOut::HasRootName
  (const Standard_Integer num) const
{
  if (num < 1 || num > thedisps.Length()) return Standard_False;
  return Dispatch(num)->HasRootName();
}

    Handle(TCollection_HAsciiString)  IFSelect_ShareOut::RootName
  (const Standard_Integer num) const
{
  Handle(TCollection_HAsciiString) nulname;
  if (num < 1 || num > thedisps.Length()) return nulname;
  return Dispatch(num)->RootName();
}

    Standard_Integer  IFSelect_ShareOut::RootNumber
  (const Handle(TCollection_HAsciiString)& name) const
{
  if (name.IsNull()) return 0;
  if (!thedefrt.IsNull()) {
    if (thedefrt->IsSameString(name)) return -1;
  }
  for (Standard_Integer i = 1; i <= thedisps.Length(); i ++) {
    Handle(TCollection_HAsciiString) root = thedisps.Value(i)->RootName();
    if (root.IsNull()) continue;
    if (root->IsSameString(name)) return i;
  }
  return 0;
}


    void  IFSelect_ShareOut::SetPrefix
  (const Handle(TCollection_HAsciiString)& pref)
      {  thepref = pref;  thenbdefs = 0;  }

    Standard_Boolean  IFSelect_ShareOut::SetDefaultRootName
  (const Handle(TCollection_HAsciiString)& defrt)
{
  if (RootNumber(defrt) != 0) return Standard_False;
  if (thedefrt.IsNull() || !thedefrt->IsSameString(defrt)) thenbdefs = 0;
  thedefrt = defrt;
  return Standard_True;
}

    void  IFSelect_ShareOut::SetExtension
  (const Handle(TCollection_HAsciiString)& ext)
      {  theext = ext;  thenbdefs = 0;  }

    Handle(TCollection_HAsciiString)  IFSelect_ShareOut::Prefix () const 
{
  if (thepref.IsNull()) return new TCollection_HAsciiString("");
  return thepref;
}

    Handle(TCollection_HAsciiString)  IFSelect_ShareOut::DefaultRootName () const
{
  if (thedefrt.IsNull()) return new TCollection_HAsciiString("");
  return thedefrt;
}

    Handle(TCollection_HAsciiString)  IFSelect_ShareOut::Extension () const 
{
  if (theext.IsNull()) return new TCollection_HAsciiString("");
  return theext;
}


    TCollection_AsciiString  IFSelect_ShareOut::FileName
  (const Standard_Integer dnum, const Standard_Integer pnum,
   const Standard_Integer nbpack)
{
  Handle(TCollection_HAsciiString) rot = RootName(dnum);
  Standard_Integer num  = pnum;
  Standard_Integer npac = nbpack;
  Standard_Boolean sufnum = (npac > 1 || num > 1);
  if (rot.IsNull()) {
    rot = thedefrt;
    thenbdefs ++;  num = thenbdefs;
    npac = 0;
    sufnum = Standard_True; // numeroter sur noms par defaut, des le 1er sans 0
  }

  TCollection_AsciiString res;
  if (!thepref.IsNull()) res.AssignCat (thepref->ToCString());
  if (!rot.IsNull())     res.AssignCat (rot->ToCString());

//  Suffixe numerique
  if (sufnum) {    // sinon, pas de suffixe numerique
//  Nom du PacketSuffix : _ suivi du numero <num>
//  Si nbpack non nul, alors on a un majorant et on peut preceder de zeros
//  Ex.: nbpack = 50 (donc 2 chiffres), num = 3, cela donnera _03
//  idnum pas utilise : cette methode peut etre redefinie et utiliser idnum ...
//  Si nbpack = 0 ou 1, num = 1 pas de suffixe, sinon suffixe "_num" tel quel
//  MODIF du 3-NOV-1995 -> pour eviter toute confusion, num = 1 donne aussi _1
    Standard_Integer nbch = 0;
    char format[30],suffixe[30];  format[1] = ' ';
    if (npac >= num) {
      Standard_Integer nbpa = 1;
      while (nbpa <= npac)  {  nbpa *= 10; nbch ++;  }
    }
    if (nbch > 1) {
      sprintf(format,"_ %d.%dd",nbch,nbch);
      format[1] = '%';
    } else if (npac >= num || num >= 1) {
      sprintf(format,"_ d");
      format[1] = '%';
    }
    if (format[1] == '%') {
      sprintf (suffixe,format,num);
      res.AssignCat (suffixe);
    }
  }

  if (!theext.IsNull())  res.AssignCat (theext->ToCString());
  return res;
}
Commit	Line	Data
973c2be1	1	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	2	//
973c2be1	3	// This file is part of Open CASCADE Technology software library.
b311480e	4	//
d5f74e42	5	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	6	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	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.
b311480e	10	//
973c2be1	11	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	12	// commercial license or contractual agreement.
b311480e	13
42cf5bc1	14
	15	#include <IFSelect_Dispatch.hxx>
	16	#include <IFSelect_GeneralModifier.hxx>
	17	#include <IFSelect_Modifier.hxx>
	18	#include <IFSelect_ShareOut.hxx>
7fd59977	19	#include <Interface_InterfaceError.hxx>
7fd59977	20	#include <Interface_Macros.hxx>
42cf5bc1	21	#include <Standard_OutOfRange.hxx>
	22	#include <Standard_Transient.hxx>
	23	#include <Standard_Type.hxx>
	24	#include <TCollection_AsciiString.hxx>
	25	#include <TCollection_HAsciiString.hxx>
7fd59977	26
42cf5bc1	27	#include <stdio.h>
25e59720	28	IMPLEMENT_STANDARD_RTTIEXT(IFSelect_ShareOut,Standard_Transient)
92efcf78	29
b311480e	30	IFSelect_ShareOut::IFSelect_ShareOut ()
7fd59977	31	{
	32	thedefrt = new TCollection_HAsciiString ("Default");
	33	thenbdefs = thelastrun = 0;
	34	}
	35
	36
	37	void IFSelect_ShareOut::Clear (const Standard_Boolean onlydisp)
	38	{
	39	thedisps.Clear();
	40	ClearResult(!onlydisp);
	41	if (onlydisp) return;
	42	themodelmodifiers.Clear();
	43	thefilemodifiers.Clear();
	44	}
	45
	46	Standard_Boolean IFSelect_ShareOut::RemoveItem
	47	(const Handle(Standard_Transient)& item)
	48	{
	49	DeclareAndCast(IFSelect_GeneralModifier,modifier,item);
	50	if (!modifier.IsNull()) {
7fd59977	51	Standard_Boolean formodel = modifier->IsKind(STANDARD_TYPE(IFSelect_Modifier));
	52	Standard_Integer atnum = ModifierRank(modifier);
	53	return RemoveModifier (formodel,atnum);
	54	}
	55	DeclareAndCast(IFSelect_Dispatch,disp,item);
	56	if (!disp.IsNull()) {
	57	Standard_Integer atnum = DispatchRank(disp);
	58	return RemoveDispatch(atnum);
	59	}
	60	return Standard_False;
	61	}
	62
	63
	64	void IFSelect_ShareOut::ClearResult (const Standard_Boolean alsoname)
	65	{
	66	thelastrun = 0;
	67	if (alsoname) thenbdefs = 0;
	68	}
	69
	70	Standard_Integer IFSelect_ShareOut::LastRun () const
	71	{ return thelastrun; }
	72
	73	void IFSelect_ShareOut::SetLastRun (const Standard_Integer lastrun)
	74	{ thelastrun = lastrun; }
	75
	76	// #######################################################################
	77	// #### DISPATCHES (ENVOI DES FICHIERS) ####
	78
	79	Standard_Integer IFSelect_ShareOut::NbDispatches () const
	80	{ return thedisps.Length(); }
	81
	82	Standard_Integer IFSelect_ShareOut::DispatchRank
	83	(const Handle(IFSelect_Dispatch)& disp) const
	84	{
	85	if (disp.IsNull()) return 0;
	86	for (Standard_Integer i = thedisps.Length(); i >= 1; i --)
	87	if (disp == thedisps.Value(i)) return i;
	88	return 0;
	89	}
	90
	91	const Handle(IFSelect_Dispatch)& IFSelect_ShareOut::Dispatch
	92	(const Standard_Integer num) const
	93	{
	94	return thedisps.Value(num);
	95	}
	96
	97	void IFSelect_ShareOut::AddDispatch
	98	(const Handle(IFSelect_Dispatch)& disp)
	99	{
	100	if (disp.IsNull()) return;
	101	thedisps.Append(disp);
	102	}
	103
	104
	105	Standard_Boolean IFSelect_ShareOut::RemoveDispatch
	106	(const Standard_Integer rank)
	107	{
	108	if (rank <= thelastrun \|\| rank > thedisps.Length()) return Standard_False;
	109	thedisps.Remove(rank);
	110	return Standard_True;
	111	}
	112
	113	// ##########################################################################
	114	// #### MODIFIERS ####
115
116	void IFSelect_ShareOut::AddModifier
117	(const Handle(IFSelect_GeneralModifier)& modifier,
118	const Standard_Integer atnum)
119	{
120	Standard_Boolean formodel = modifier->IsKind(STANDARD_TYPE(IFSelect_Modifier));
121	if (ModifierRank(modifier) == 0) AddModif (modifier,formodel,atnum);
122	Handle(IFSelect_Dispatch) nuldisp;
123	modifier->SetDispatch(nuldisp);
124	}
125
126	void IFSelect_ShareOut::AddModifier
127	(const Handle(IFSelect_GeneralModifier)& modifier,
128	const Standard_Integer dispnum, const Standard_Integer atnum)
129	{
130	Standard_Boolean formodel = modifier->IsKind(STANDARD_TYPE(IFSelect_Modifier));
131	if (ModifierRank(modifier) == 0) AddModif (modifier,formodel,atnum);
132	Handle(IFSelect_Dispatch) disp = Dispatch(dispnum);
133	modifier->SetDispatch(disp);
134	}
135
136
137	void IFSelect_ShareOut::AddModif
138	(const Handle(IFSelect_GeneralModifier)& modifier,
139	const Standard_Boolean formodel, const Standard_Integer atnum)
140	{
141	if (formodel) {
142	if (atnum > 0 && atnum <= themodelmodifiers.Length())
143	themodelmodifiers.InsertBefore(atnum,modifier);
144	else themodelmodifiers.Append(modifier);
145	} else {
146	if (atnum > 0 && atnum <= thefilemodifiers.Length())
147	thefilemodifiers.InsertBefore(atnum,modifier);
148	else thefilemodifiers.Append(modifier);
149	}
150	}
151
152	Standard_Integer IFSelect_ShareOut::NbModifiers
153	(const Standard_Boolean formodel) const
154	{
155	if (formodel) return themodelmodifiers.Length();
156	else return thefilemodifiers.Length();
157	}
158
159	Handle(IFSelect_GeneralModifier) IFSelect_ShareOut::GeneralModifier
160	(const Standard_Boolean formodel, const Standard_Integer atnum) const
161	{
162	if (formodel) return themodelmodifiers.Value(atnum);
163	else return thefilemodifiers.Value(atnum);
164	}
165
166	Handle(IFSelect_Modifier) IFSelect_ShareOut::ModelModifier
167	(const Standard_Integer num) const
168	{ return Handle(IFSelect_Modifier)::DownCast(themodelmodifiers.Value(num)); }
169
170	Standard_Integer IFSelect_ShareOut::ModifierRank
171	(const Handle(IFSelect_GeneralModifier)& modifier) const
172	{
173	Standard_Integer i;
174	Standard_Boolean formodel = modifier->IsKind(STANDARD_TYPE(IFSelect_Modifier));
175	if (formodel) {
176	for (i = themodelmodifiers.Length(); i >= 1; i --)
177	if (modifier == themodelmodifiers.Value(i)) return i;
178	} else {
179	for (i = thefilemodifiers.Length(); i >= 1; i --)
180	if (modifier == thefilemodifiers.Value(i)) return i;
181	}
182	return 0;
183	}
184
185
186	Standard_Boolean IFSelect_ShareOut::RemoveModifier
187	(const Standard_Boolean formodel, const Standard_Integer atnum)
188	{
189	if (atnum <= 0) return Standard_False;
190	if (formodel) {
191	if (atnum > themodelmodifiers.Length()) return Standard_False;
192	themodelmodifiers.Remove(atnum);
193	} else {
194	if (atnum > thefilemodifiers.Length()) return Standard_False;
195	thefilemodifiers.Remove(atnum);
196	}
197	return Standard_True;
198	}
199
200
201	// ChangeModifierRank revient a une permutation circulaire :
202	// before est mis en after, ceux qui sont entre tournent
203	Standard_Boolean IFSelect_ShareOut::ChangeModifierRank
204	(const Standard_Boolean formodel,
205	const Standard_Integer before, const Standard_Integer after)
206	{
207	Standard_Integer nb;
208	if (before <= 0 \|\| after <= 0) return Standard_False;
209	if (before == after) return Standard_True;
210	if (formodel) {
211	nb = themodelmodifiers.Length();
212	if (before > nb \|\| after > nb) return Standard_False;
213	Handle(IFSelect_GeneralModifier) bef = themodelmodifiers.Value(before);
214	themodelmodifiers.Remove(before);
215	if (after == nb) themodelmodifiers.Append(bef);
216	else themodelmodifiers.InsertBefore(after,bef);
217	} else {
218	nb = thefilemodifiers.Length();
219	if (before > nb \|\| after > nb) return Standard_False;
220	Handle(IFSelect_GeneralModifier) bef = thefilemodifiers.Value(before);
221	thefilemodifiers.Remove(before);
222	if (after == nb) thefilemodifiers.Append(bef);
223	else thefilemodifiers.InsertBefore(after,bef);
224	}
225	return Standard_True;
226	}
227
228	// #######################################################################
229	// #### NOMINATION DES FICHIERS ####
230	// Rq : thenbdefs s applique tant que l on ne change pas les termes principaux
231
232	Standard_Boolean IFSelect_ShareOut::SetRootName
233	(const Standard_Integer num, const Handle(TCollection_HAsciiString)& name)
234	{
235	if (num < 1 \|\| num > thedisps.Length()) return Standard_False;
236	if (RootNumber(name) != 0) return Standard_False;
237	Dispatch(num)->SetRootName (name);
238	return Standard_True;
239	}
240
241	Standard_Boolean IFSelect_ShareOut::HasRootName
242	(const Standard_Integer num) const
243	{
244	if (num < 1 \|\| num > thedisps.Length()) return Standard_False;
245	return Dispatch(num)->HasRootName();
246	}
247
248	Handle(TCollection_HAsciiString) IFSelect_ShareOut::RootName
249	(const Standard_Integer num) const
250	{
251	Handle(TCollection_HAsciiString) nulname;
252	if (num < 1 \|\| num > thedisps.Length()) return nulname;
253	return Dispatch(num)->RootName();
254	}
255
256	Standard_Integer IFSelect_ShareOut::RootNumber
257	(const Handle(TCollection_HAsciiString)& name) const
258	{
259	if (name.IsNull()) return 0;
260	if (!thedefrt.IsNull()) {
261	if (thedefrt->IsSameString(name)) return -1;
262	}
263	for (Standard_Integer i = 1; i <= thedisps.Length(); i ++) {
264	Handle(TCollection_HAsciiString) root = thedisps.Value(i)->RootName();
265	if (root.IsNull()) continue;
266	if (root->IsSameString(name)) return i;
267	}
268	return 0;
269	}
270
271
272	void IFSelect_ShareOut::SetPrefix
273	(const Handle(TCollection_HAsciiString)& pref)
274	{ thepref = pref; thenbdefs = 0; }
275
276	Standard_Boolean IFSelect_ShareOut::SetDefaultRootName
277	(const Handle(TCollection_HAsciiString)& defrt)
278	{
279	if (RootNumber(defrt) != 0) return Standard_False;
280	if (thedefrt.IsNull() \|\| !thedefrt->IsSameString(defrt)) thenbdefs = 0;
281	thedefrt = defrt;
282	return Standard_True;
283	}
284
285	void IFSelect_ShareOut::SetExtension
286	(const Handle(TCollection_HAsciiString)& ext)
287	{ theext = ext; thenbdefs = 0; }
288
289	Handle(TCollection_HAsciiString) IFSelect_ShareOut::Prefix () const
290	{
291	if (thepref.IsNull()) return new TCollection_HAsciiString("");
292	return thepref;
293	}
294
295	Handle(TCollection_HAsciiString) IFSelect_ShareOut::DefaultRootName () const
296	{
297	if (thedefrt.IsNull()) return new TCollection_HAsciiString("");
298	return thedefrt;
299	}
300
301	Handle(TCollection_HAsciiString) IFSelect_ShareOut::Extension () const
302	{
303	if (theext.IsNull()) return new TCollection_HAsciiString("");
304	return theext;
305	}
306
307
308	TCollection_AsciiString IFSelect_ShareOut::FileName
309	(const Standard_Integer dnum, const Standard_Integer pnum,
310	const Standard_Integer nbpack)
311	{
312	Handle(TCollection_HAsciiString) rot = RootName(dnum);
313	Standard_Integer num = pnum;
314	Standard_Integer npac = nbpack;
315	Standard_Boolean sufnum = (npac > 1 \|\| num > 1);
316	if (rot.IsNull()) {
317	rot = thedefrt;
318	thenbdefs ++; num = thenbdefs;
319	npac = 0;
320	sufnum = Standard_True; // numeroter sur noms par defaut, des le 1er sans 0
321	}
322
323	TCollection_AsciiString res;
324	if (!thepref.IsNull()) res.AssignCat (thepref->ToCString());
325	if (!rot.IsNull()) res.AssignCat (rot->ToCString());
326
327	// Suffixe numerique
328	if (sufnum) { // sinon, pas de suffixe numerique
329	// Nom du PacketSuffix : _ suivi du numero <num>
330	// Si nbpack non nul, alors on a un majorant et on peut preceder de zeros
331	// Ex.: nbpack = 50 (donc 2 chiffres), num = 3, cela donnera _03
332	// idnum pas utilise : cette methode peut etre redefinie et utiliser idnum ...
333	// Si nbpack = 0 ou 1, num = 1 pas de suffixe, sinon suffixe "_num" tel quel
334	// MODIF du 3-NOV-1995 -> pour eviter toute confusion, num = 1 donne aussi _1
335	Standard_Integer nbch = 0;
5efab28a	336	char format[30],suffixe[30]; format[1] = ' ';
7fd59977	337	if (npac >= num) {
	338	Standard_Integer nbpa = 1;
	339	while (nbpa <= npac) { nbpa *= 10; nbch ++; }
	340	}
	341	if (nbch > 1) {
	342	sprintf(format,"_ %d.%dd",nbch,nbch);
	343	format[1] = '%';
	344	} else if (npac >= num \|\| num >= 1) {
	345	sprintf(format,"_ d");
	346	format[1] = '%';
	347	}
	348	if (format[1] == '%') {
	349	sprintf (suffixe,format,num);
	350	res.AssignCat (suffixe);
	351	}
	352	}
	353
	354	if (!theext.IsNull()) res.AssignCat (theext->ToCString());
	355	return res;
	356	}