/// ///////////////////////////////////////////
public void ApplyToObjet(object obj)
{
try
{
IObjetAModificationContextuelle objContextuel = obj as IObjetAModificationContextuelle;
if (objContextuel != null)
{
string strContexteModif = objContextuel.ContexteDeModification;
if (IsContexteException(strContexteModif))
{
m_tableRestrictions.Clear();
m_tableRestrictionsHorsPriorites.Clear();
m_restrictionUtilisateur = ERestriction.Aucune;
m_restrictionHorsPriorité = ERestriction.Aucune;
return;
}
}
if (obj is IObjetARestrictionSurEntite)
{
((IObjetARestrictionSurEntite)obj).CompleteRestriction(this);
}
}
catch { }
}
//-------------------------------------------------------------------------------------
public void AppliqueRestrictions(
CListeRestrictionsUtilisateurSurType lstRestrictions,
CGestionnaireReadOnlySysteme gestionnaire)
{
if (SourceType == null)
{
return;
}
CRestrictionUtilisateurSurType restriction = lstRestrictions.GetRestriction(SourceType);
if (restriction != null)
{
foreach (KeyValuePair <object, CInfoControle> kv in m_dicControleToInfo)
{
CInfoControle info = kv.Value;
if (info.Field.Length > 0)
{
ERestriction rest = restriction.GetRestriction(info.Field);
Control ctrl = kv.Key as Control;
if (ctrl != null)
{
if ((rest & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
gestionnaire.SetReadOnly(ctrl, true);
}
else
{
gestionnaire.SetReadOnly(ctrl, false);
}
}
}
}
}
}
//---------------------------------------------------------------
private static void CompleteRestrictionsProcessEtAutres(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct module = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_ProcessEtAutres_ID);
ERestriction rest = ERestriction.Hide;
if (module != null)
{
rest = module.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(CVariableSurObjet), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CEvenement), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CGroupeParametrage), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CProcessInDb), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CRelationDefinisseurComportementInduit), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CRelationElementComportement), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CComportementGenerique), rest);
listeRestrictions.AddRestriction(restriction);
}
}
//-------------------------------------------------------------------------
private void ValideRestrictionEnCours()
{
if (m_restrictionAffichee == null)
{
return;
}
foreach (ListViewItem item in m_wndListeChamps.Items)
{
string strProp = (string)item.Tag;
ERestriction rest = ERestriction.Aucune;
if (item.ImageIndex == 1)
{
rest = ERestriction.ReadOnly;
}
if (item.ImageIndex == 2)
{
rest = ERestriction.Hide;
}
m_restrictionAffichee.SetRestrictionLocale(strProp, rest);
}
//m_restrictionAffichee.Priorite = m_txtSeuil.IntValue != null?m_txtSeuil.IntValue.Value:0;
ListViewItem itemToModify = GetItemForType(m_restrictionAffichee.TypeAssocie);
if (itemToModify != null)
{
InitItem(itemToModify, m_restrictionAffichee);
}
}
//---------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (EditedElement != null && m_textBoxNumerique != null)
{
ERestriction rest = restrictionSurObjetEdite.RestrictionGlobale;
C2iWndTextBoxEntier wndTxt = WndAssociee as C2iWndTextBoxEntier;
if (wndTxt != null)
{
CDefinitionProprieteDynamique def = wndTxt.Property;
if (def != null)
{
rest = def.GetRestrictionAAppliquer(restrictionSurObjetEdite);
}
}
switch (rest)
{
case ERestriction.ReadOnly:
case ERestriction.Hide:
{
gestionnaireReadOnly.SetReadOnly(m_textBoxNumerique, true);
break;
}
default: break;
}
}
}
//---------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
bool bShowPictureRestriction = false;
if (listeRestrictions != null && EditedElement != null)
{
CChampCustom champ = WndVariable.Variable as CChampCustom;
if (champ != null && restrictionSurObjetEdite != null && m_controleForVariable.Control != null)
{
ERestriction rest = restrictionSurObjetEdite.GetRestriction(champ.CleRestriction);
if ((rest & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
gestionnaireReadOnly.SetReadOnly(m_controleForVariable.Control, true);
bShowPictureRestriction = true;
}
}
}
if (VisualiseurReadOnly != null)
{
if (bShowPictureRestriction)
{
VisualiseurReadOnly.Visible = true;
}
else
{
VisualiseurReadOnly.Visible = false;
}
}
}
/// ///////////////////////////////////////////
public void SetRestrictionLocale(string strPropriete, ERestriction restriction)
{
m_tableRestrictions[strPropriete] = restriction;
if (restriction == ERestriction.Aucune)
{
m_tableRestrictions.Remove(strPropriete);
}
}
/// ///////////////////////////////////////////
protected void SetRestrictionHorsPriorite(string strPropriete, ERestriction restriction)
{
m_tableRestrictionsHorsPriorites[strPropriete] = restriction;
if (restriction == ERestriction.Aucune)
{
m_tableRestrictionsHorsPriorites.Remove(strPropriete);
}
}
/// ///////////////////////////////////////////
public void AddRestrictionsHorsPriorite(CRestrictionUtilisateurSurType restriction)
{
m_restrictionHorsPriorité |= restriction.RestrictionGlobale;
foreach (DictionaryEntry entry in restriction.m_tableRestrictions)
{
SetRestrictionHorsPriorite((string)entry.Key,
GetRestrictionHorsPriorite((string)entry.Key) |
restriction.GetRestriction((string)entry.Key));
}
}
/// ///////////////////////////////////////////
protected ERestriction GetRestrictionHorsPriorite(string strPropriete)
{
ERestriction restriction = ERestriction.Aucune;
if (m_tableRestrictionsHorsPriorites[strPropriete] != null)
{
restriction = (ERestriction)m_tableRestrictionsHorsPriorites[strPropriete];
}
return(restriction);
}
//-------------------------------------------------------------------------
private int GetIndexImage(ERestriction rest)
{
if ((rest & ERestriction.Hide) == ERestriction.Hide)
{
return(2);
}
if ((rest & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
return(1);
}
return(0);
}
/// ///////////////////////////////////////////
public string[] GetProprietesReadOnly()
{
List <string> lst = new List <string>();
foreach (DictionaryEntry entry in m_tableRestrictions)
{
ERestriction rest = (ERestriction)entry.Value;
if (!CanModify(rest))
{
lst.Add((string)entry.Key);
}
}
return(lst.ToArray());
}
//---------------------------------------------------------------
private static void CompleteRestrictionsStructuresExport(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct module = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_StructuresExport_ID);
ERestriction rest = ERestriction.Hide;
if (module != null)
{
rest = module.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(C2iStructureExportInDB), rest);
listeRestrictions.AddRestriction(restriction);
}
}
//---------------------------------------------------------------
private static void CompleteRestrictionsDonneesPrecalculees(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct moduleDonnees = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_DonneesPrecalculees_ID);
ERestriction rest = ERestriction.Hide;
if (moduleDonnees != null)
{
rest = moduleDonnees.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(CTypeDonneeCumulee), rest);
listeRestrictions.AddRestriction(restriction);
}
}
//---------------------------------------------------------------
private static void CompleteRestrictionsChampsCalcules(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct module = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_ChampsCalc_Id);
ERestriction rest = ERestriction.Hide;
if (module != null)
{
rest = module.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(CChampCalcule), rest);
listeRestrictions.AddRestriction(restriction);
}
}
//-------------------------------------------------------------------------
private void InverseFlagRestriction(ERestriction restriction)
{
if (m_restrictionAffichee == null)
{
return;
}
if ((m_restrictionAffichee.RestrictionUtilisateur & restriction) == restriction)
{
m_restrictionAffichee.RestrictionUtilisateur -= (int)restriction;
}
else
{
m_restrictionAffichee.RestrictionUtilisateur += (int)restriction;
}
ShowRestriction(m_restrictionAffichee);
}
//---------------------------------------------------------------
private static void CompleteRestrictionsClientWorkflows(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct moduleClientTypeWorkflow = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_ParametrageWorkflow);
ERestriction rest = ERestriction.Hide;
rest = ERestriction.Hide;
if (moduleClientTypeWorkflow != null)
{
rest = moduleClientTypeWorkflow.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(CTypeWorkflow), rest);
listeRestrictions.AddRestriction(restriction);
}
}
private static void CompleteRestrictionsModeletesEtats(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct module = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_RapportsCrystal_ID);
ERestriction rest = ERestriction.Hide;
if (module != null)
{
rest = module.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(C2iRapportCrystal), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(C2iCategorieRapportCrystal), rest);
listeRestrictions.AddRestriction(restriction);
}
}
/// ///////////////////////////////////////////
///
/// ///////////////////////////////////////////
public void AppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurElementEdite,
CListeRestrictionsUtilisateurSurType listeRestriction,
IGestionnaireReadOnlySysteme gestionnaire)
{
if (listeRestriction != null && EditedElement != null)
{
CChampCustom champ = m_wndSelectionValeurChamp.ChampCustom;
if (champ != null && restrictionSurElementEdite != null)
{
ERestriction rest = restrictionSurElementEdite.GetRestriction(champ.CleRestriction);
if ((rest & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
gestionnaire.SetReadOnly(Control, true);
}
}
}
}
//---------------------------------------------------------------
public void AppliqueRestrictions(CListeRestrictionsUtilisateurSurType restrictions, sc2i.common.Restrictions.IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (m_createur != null && restrictions != null && gestionnaireReadOnly != null)
{
if (m_formulaire != null && m_formulaire.TypeElementEdite != null)
{
restrictions = restrictions.Clone() as CListeRestrictionsUtilisateurSurType;
CRestrictionUtilisateurSurType restriction = restrictions.GetRestriction(m_formulaire.TypeElementEdite);
ERestriction rest = restriction.GetRestriction(Formulaire.CleRestriction);
if ((int)rest > (int)restriction.RestrictionGlobale)
{
restriction.RestrictionUtilisateur = rest;
}
restrictions.SetRestriction(restriction);
}
m_createur.AppliqueRestrictions(restrictions, gestionnaireReadOnly);
}
}
//---------------------------------------------------------------
private static void CompleteRestrictionsFiltresEtListes(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct module = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_Filtres_ID);
ERestriction rest = ERestriction.Hide;
if (module != null)
{
rest = module.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(CFiltreDynamiqueInDb), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CListeEntites), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CRelationListeEntites_Entite), rest);
listeRestrictions.AddRestriction(restriction);
}
}
//--------------------------------------------------------------------------------
private static void CompleteRestrictionsTypesCaracteristiquesEntite(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct module = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_TypeCaracteristiques_ID);
ERestriction rest = ERestriction.Hide;
if (module != null)
{
rest = module.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(CTypeCaracteristiqueEntite), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CRelationTypeCaracteristiqueEntite_ChampCustom), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CRelationTypeCaracteristiqueEntite_Formulaire), rest);
listeRestrictions.AddRestriction(restriction);
}
}
//---------------------------------------------------------------
private static void CompleteRestrictionsAppWorkflows(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleAppPrtct moduleAppWorkflow = configModules.GetModuleApp(CConfigModulesTimos.c_appModuleWorkflow);
ERestriction rest = ERestriction.Hide;
if (moduleAppWorkflow != null)
{
rest = moduleAppWorkflow.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(CTypeWorkflow), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CWorkflow), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CTypeEtapeWorkflow), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CEtapeWorkflow), rest);
listeRestrictions.AddRestriction(restriction);
}
}
//-------------------------------------------------------------------------------------------------------------
private static void CompleteRestrictionsConfigurationCompteMail(CConfigModulesTimos configModules, CListeRestrictionsUtilisateurSurType listeRestrictions)
{
CLicenceModuleClientPrtct module = configModules.GetModuleClient(CConfigModulesTimos.c_clientModule_ConfigurationCompteMail_ID);
ERestriction rest = ERestriction.Hide;
if (module != null)
{
rest = module.Restriction;
}
if (rest != ERestriction.Aucune)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(typeof(CCompteMail), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CDossierMail), rest);
listeRestrictions.AddRestriction(restriction);
restriction = new CRestrictionUtilisateurSurType(typeof(CRegleMail), rest);
listeRestrictions.AddRestriction(restriction);
}
}
//-------------------------------------------------------------------------
private string GetLibelleRestriction(ERestriction rest)
{
if ((rest & ERestriction.Hide) == ERestriction.Hide)
{
return(I.T("Mask|20101"));
}
if ((rest & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
return(I.T("Read only|20102"));
}
string strLibelle = I.T("Read/Write|20103");
if ((rest & ERestriction.NoCreate) != ERestriction.NoCreate)
{
strLibelle += I.T("Create|20104");
}
if ((rest & ERestriction.NoDelete) != ERestriction.NoDelete)
{
strLibelle += I.T("Delete|20105");
}
return(strLibelle);
}
/// ///////////////////////////////////////////////////
private void InitPageWithObjetCourant(Crownwood.Magic.Controls.TabPage page)
{
if (m_tablePagesInit.ContainsKey(page) &&
m_tablePagesInit[page])
{
return;
}
if (m_tableCreateurs[page] == null)
{
CreateControles(page);
}
ERestriction restrictionFormulaire = m_tablePageToRestriction[page];
CCreateur2iFormulaire createur = (CCreateur2iFormulaire)m_tableCreateurs[page];
createur.ReadOnly = (restrictionFormulaire & ERestriction.ReadOnly) == ERestriction.ReadOnly;
createur.LockEdition = m_bIsLock || (restrictionFormulaire & ERestriction.ReadOnly) == ERestriction.ReadOnly;
if (createur != null)
{
createur.ElementEdite = m_elementEdite;
}
m_tablePagesInit[page] = true;
}
//---------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (EditedElement != null && m_checkBox != null)
{
//Chope la restriction sur le champ concerné
C2iWndCheckBox chk = WndAssociee as C2iWndCheckBox;
ERestriction rest = restrictionSurObjetEdite.RestrictionGlobale;
if (chk != null)
{
CDefinitionProprieteDynamique def = chk.Property;
if (def != null)
{
rest = def.GetRestrictionAAppliquer(restrictionSurObjetEdite);
}
}
switch (rest)
{
case ERestriction.ReadOnly:
{
gestionnaireReadOnly.SetReadOnly(m_checkBox, true);
break;
}
case ERestriction.Hide:
{
gestionnaireReadOnly.SetReadOnly(m_checkBox, true);
m_checkBox.Hide();
break;
}
default: break;
}
}
}
//--------------------------------------------------------------------------------------
public void ConvertToRestrictionSansPriorite()
{
// Combine la restriction utilisateur avec la restriction hors priorité
m_restrictionHorsPriorité = m_restrictionHorsPriorité | m_restrictionUtilisateur;
m_restrictionUtilisateur = ERestriction.Aucune;
// Combine toutes les restriction sur champ
foreach (string strKey in m_tableRestrictionsHorsPriorites.Keys)
{
SetRestrictionHorsPriorite(strKey,
GetRestrictionHorsPriorite(strKey) | GetRestrictionLocale(strKey));
}
foreach (string strKey in m_tableRestrictions.Keys)
{
SetRestrictionHorsPriorite(strKey,
GetRestrictionHorsPriorite(strKey) | GetRestrictionLocale(strKey));
}
// On vide toutes les Restriction utilisateur, car elles sont maintenatn stockées dans
// les restriction Hors Priorité
m_tableRestrictions.Clear();
m_restrictionUtilisateur = ERestriction.Aucune;
}
//---------------------------------------------------------------
protected override void MyAppliqueRestriction(
CRestrictionUtilisateurSurType restrictionSurObjetEdite,
CListeRestrictionsUtilisateurSurType listeRestrictions,
IGestionnaireReadOnlySysteme gestionnaireReadOnly)
{
if (EditedElement != null &&
m_selectionneur != null)
{
ERestriction rest = restrictionSurObjetEdite.RestrictionGlobale;
C2iWndTextBoxFiltreRapide wndTxt = WndAssociee as C2iWndTextBoxFiltreRapide;
if (wndTxt != null)
{
CDefinitionProprieteDynamique def = wndTxt.Property;
if (def != null)
{
rest = def.GetRestrictionAAppliquer(restrictionSurObjetEdite);
}
}
if ((rest & ERestriction.ReadOnly) == ERestriction.ReadOnly)
{
gestionnaireReadOnly.SetReadOnly(m_selectionneur, true);
}
}
}
public void UpdateOnglets()
{
if (!LockEdition)
{
//valide les modifs car on va tout supprimer
MAJ_Champs();
}
m_bIsInitializing = true;
Hashtable tablePagesToHide = new Hashtable();
foreach (Crownwood.Magic.Controls.TabPage page in TabPages)
{
m_tablePagesInit[page] = false;
tablePagesToHide[page] = true;
}
if (m_elementEdite == null)
{
return;
}
/* YK : On obtient la session de l'objet en cours d'édition au lieur de la session par défaut */
CSessionClient session = null;
IObjetDonneeAIdNumeriqueAuto objetDonnee = m_elementEdite as IObjetDonneeAIdNumeriqueAuto;
if (objetDonnee != null)
{
session = CSessionClient.GetSessionForIdSession(objetDonnee.ContexteDonnee.IdSession);
}
else
{
session = CSessionClient.GetSessionUnique();
}
ArrayList lstFormulaires = new ArrayList(m_elementEdite.GetFormulaires());
lstFormulaires.Sort(new CSorterFormulaires());
//Lit les champs liés et leurs valeurs
StringBuilder bl = new StringBuilder();
foreach (CFormulaire formulaire in lstFormulaires)
{
bl.Append(formulaire.Id);
bl.Append(",");
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
CListeObjetsDonnees lst = new CListeObjetsDonnees(((CFormulaire)lstFormulaires[0]).ContexteDonnee, typeof(CFormulaire));
lst.Filtre = new CFiltreData(CFormulaire.c_champId + " in (" + bl.ToString() + ")");
lst.AssureLectureFaite();
lst.ReadDependances("RelationsChamps", "RelationsChamps.Champ", "RelationsChamps.Champ.ListeValeurs");
}
foreach (CFormulaire formulaire in lstFormulaires)
{
CRestrictionUtilisateurSurType restriction = new CRestrictionUtilisateurSurType(m_elementEdite.GetType());
if (session.GetInfoUtilisateur() != null)
{
int?nIdVersion = null;
IObjetAContexteDonnee objetAContexte = m_elementEdite as IObjetAContexteDonnee;
if (objetAContexte != null)
{
nIdVersion = objetAContexte.ContexteDonnee.IdVersionDeTravail;
}
restriction = session.GetInfoUtilisateur().GetRestrictionsSurObjet(m_elementEdite, nIdVersion);
}
ERestriction restrictionFormulaire = restriction.GetRestriction(formulaire.CleRestriction);
if ((restrictionFormulaire & ERestriction.Hide) != ERestriction.Hide)
{
Crownwood.Magic.Controls.TabPage page = (Crownwood.Magic.Controls.TabPage)m_tableIdFormulaireToTabPage[formulaire.Id];
CCreateur2iFormulaire createur = null;
if (page == null)
{
C2iWndFenetre wnd = formulaire.Formulaire;
if (wnd != null)
{
page = new Crownwood.Magic.Controls.TabPage(wnd.Text);
page.SuspendLayout();
if (wnd.Text == "")
{
page.Title = formulaire.Libelle;
}
TabPages.Add(page);
m_tableCreateurs[page] = null;
m_tablePageTo2iWnd[page] = wnd;
m_tableIdFormulaireToTabPage[formulaire.Id] = page;
}
}
else
{
createur = (CCreateur2iFormulaire)m_tableCreateurs[page];
}
if (page != null)
{
m_tablePageToRestriction[page] = restrictionFormulaire;
if (!TabPages.Contains(page))
{
TabPages.Add(page);
}
tablePagesToHide.Remove(page);
}
}
}
/*CChampCustom[] champs = ElementEdite.GetChampsHorsFormulaire();
* if ( champs.Length != 0 )
* {
* UpdatePageChamps( nRest );
* if ( m_pageGrid != null )
* tablePagesToHide.Remove(m_pageGrid);
* }*/
foreach (Crownwood.Magic.Controls.TabPage pageToDel in tablePagesToHide.Keys)
{
TabPages.Remove(pageToDel);
}
if (TabPages.Count == 1)
{
this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.HideAlways;
}
else
{
this.HideTabsMode = Crownwood.Magic.Controls.TabControl.HideTabsModes.ShowAlways;
}
if (SelectedTab != null)
{
InitPageWithObjetCourant(SelectedTab);
}
m_bIsInitializing = false;
}
