//-------------------------------------------------------------------------------
internal void Expand(CCustomizableListItem item)
{
using (CWaitCursor waiter = new CWaitCursor())
{
CSetupSmartImportItem si = item as CSetupSmartImportItem;
if (si != null && si.ChildItems.Count() == 0)
{
CSetupSmartImportChampEntiteItem root = si as CSetupSmartImportChampEntiteItem;
if (root != null)
{
CreateChilds(si, root.ValeursExemples, root.ConfigMappage);
}
CSetupSmartImportEntiteParentItem itemParent = si as CSetupSmartImportEntiteParentItem;
if (itemParent != null)
{
CreateChilds(
si,
itemParent.ValeursParent,
itemParent.MappageEntiteParente != null ? itemParent.MappageEntiteParente.ConfigEntiteParente : null);
}
CSetupSmartImportEntiteFilleItem itemFille = si as CSetupSmartImportEntiteFilleItem;
if (itemFille != null)
{
CreateChilds(itemFille);
}
}
if (si != null)
{
si.Expand();
}
Refresh();
}
}
//-------------------------------------------------------------------
public CSetupSmartImportItem(
CSetupSmartImportItem parentItem,
CDefinitionProprieteDynamique def,
int nColorIndex)
: base(parentItem)
{
m_propriete = def;
m_nColorIndex = nColorIndex;
}
//-------------------------------------------------------------------------------
internal void Collapse(CCustomizableListItem item)
{
CSetupSmartImportItem si = item as CSetupSmartImportItem;
if (si != null)
{
si.Collapse();
}
Refresh();
}
//-----------------------------------------------------------
void itemKey_Click(object sender, EventArgs e)
{
CSetupSmartImportItem si = CurrentItem as CSetupSmartImportItem;
ToolStripMenuItem item = sender as ToolStripMenuItem;
if (item != null && item.Tag is bool && si != null)
{
si.UseAsKey = (bool)item.Tag;
UpdateVisuelKey();
HasChange = true;
}
}
//--------------------------------------------------------------------
protected override CResultAErreur MyMajChamps()
{
CResultAErreur result = base.MyMajChamps();
CSetupSmartImportItem si = CurrentItem as CSetupSmartImportItem;
if (result && si != null)
{
si.OptionCreation = m_wndOptionCreation.Option;
si.Source = m_controleSource.Source;
}
return(result);
}
//-------------------------------------------------------------------------------
protected void FillChemins(List <CDefinitionProprieteDynamique> lstChemins)
{
CSetupSmartImportItem parent = ItemParent as CSetupSmartImportItem;
if (parent != null)
{
parent.FillChemins(lstChemins);
}
if (Propriete != null)
{
lstChemins.Add(Propriete);
}
}
//--------------------------------------------------------------------
private void m_btnExpand_Click(object sender, EventArgs e)
{
CSetupSmartImportItem item = CurrentItem as CSetupSmartImportItem;
if (item != null && item.IsCollapse)
{
((CControleSetupSmartImport)AssociatedListControl).Expand(CurrentItem);
}
else if (item != null && !item.IsCollapse)
{
((CControleSetupSmartImport)AssociatedListControl).Collapse(CurrentItem);
}
m_btnExpand.Text = item.IsCollapse ? "+" : "-";
}
//-------------------------------------------------------------------
public CSetupSmartImportEntiteFilleItem(
CSetupSmartImportItem parentItem,
CDefinitionProprieteDynamique def,
CValeursProprietes valeursDuParent,
CMappageEntitesFilles mappageFille,
int nColorIndex)
: base(parentItem, def, nColorIndex)
{
m_valeursDuParent = valeursDuParent;
m_mappageFilles = mappageFille;
if (m_mappageFilles == null)
{
m_mappageFilles = new CMappageEntitesFilles();
m_mappageFilles.Propriete = def;
}
}
//-------------------------------------------------------------------
public CSetupSmartImportChampSimpleItem(
CSetupSmartImportItem parentItem,
CDefinitionProprieteDynamique def,
object valeurExemple,
CMappageChampSimple mappageSimple,
int nColorIndex)
: base(parentItem, def, nColorIndex)
{
m_valeurExemple = valeurExemple;
m_mappageSimple = mappageSimple;
if (m_mappageSimple == null)
{
m_mappageSimple = new CMappageChampSimple();
m_mappageSimple.Propriete = def;
}
}
//-----------------------------------------------------------
private void UpdateVisuelKey()
{
CSetupSmartImportItem si = CurrentItem as CSetupSmartImportItem;
if (si != null)
{
if (si.CanBeUsedAsKey)
{
m_imageSearchKey.Visible = true;
m_imageSearchKey.Image = si.UseAsKey ? Properties.Resources.SearchKey_Yes : Properties.Resources.SearchKey_No;
}
else
{
m_imageSearchKey.Visible = false;
}
}
}
//-------------------------------------------------------------------
public CSetupSmartImportChampEntiteItem(
CSetupSmartImportItem itempParent,
CValeursProprietes valeursExemple,
CSourceSmartImport source,
CConfigMappagesSmartImport config,
int nColorIndex)
: base(itempParent, null, nColorIndex)
{
m_valeursExemple = valeursExemple;
m_config = config;
m_source = source;
if (m_config == null && valeursExemple != null)
{
m_config = new CConfigMappagesSmartImport();
m_config.KeyEntite = valeursExemple.DbKeyObjet;
m_config.TypeEntite = valeursExemple.TypeObjet;
}
}
//-------------------------------------------------------------------
public CSetupSmartImportEntiteParentItem(
CSetupSmartImportItem parentItem,
CDefinitionProprieteDynamique def,
CValeursProprietes valeursParent,
CMappageEntiteParente mappageParent,
int nColorIndex)
: base(parentItem, def, nColorIndex)
{
m_valeursParent = valeursParent;
m_mappageParent = mappageParent;
if (m_mappageParent == null && m_valeursParent != null)
{
m_mappageParent = new CMappageEntiteParente();
m_mappageParent.Propriete = def;
m_mappageParent.ConfigEntiteParente = new CConfigMappagesSmartImport();
m_mappageParent.ConfigEntiteParente.TypeEntite = def.TypeDonnee.TypeDotNetNatif;
m_mappageParent.ConfigEntiteParente.KeyEntite = m_valeursParent.DbKeyObjet;
}
}
//-------------------------------------------------------------------------------
private void ExpandItemsWithData(CSetupSmartImportItem item)
{
if (item == null)
{
return;
}
if (item.HasConfigData())
{
if (!(item.Source is CSourceSmartImportReference) &&
!(item.Source is CSourceSmartImportFixedValue) ||
item.ItemParent == null)
{
Expand(item);
foreach (CSetupSmartImportItem child in item.ChildItems)
{
ExpandItemsWithData(child);
}
}
}
}
//---------------------------------------------------------------
private void m_imageSearchKey_Click(object sender, EventArgs e)
{
CSetupSmartImportItem si = CurrentItem as CSetupSmartImportItem;
ToolStripDropDown menu = new ToolStripDropDown();
ToolStripMenuItem itemKey = new ToolStripMenuItem(I.T("don't use this field to search entity|20117"));
itemKey.Image = Properties.Resources.SearchKey_No;
itemKey.Checked = si != null && !si.UseAsKey;
itemKey.CheckOnClick = true;
itemKey.Tag = false;
itemKey.Click += itemKey_Click;
menu.Items.Add(itemKey);
itemKey = new ToolStripMenuItem(I.T("Use this field to search entity|20118"));
itemKey.Image = Properties.Resources.SearchKey_Yes;
itemKey.CheckOnClick = true;
itemKey.Checked = si != null && !si.UseAsKey;
itemKey.Tag = true;
itemKey.Click += itemKey_Click;
menu.Items.Add(itemKey);
menu.Show(m_imageSearchKey, new Point(0, Height));
}
//-------------------------------------------------------------------------------
private bool HighLight(string strIdsMappage, string strChampEnCours)
{
//Pas terminé, trucs plus urgents à faire
foreach (CCustomizableListItem item in Items)
{
CSetupSmartImportItem si = item as CSetupSmartImportItem;
if (si != null)
{
if (si.Highlight)
{
RefreshItem(si);
}
si.Highlight = false;
}
}
try
{
if (Items.Count() == 0)
{
return(false);
}
string[] strIds = strIdsMappage.Split('.');
if (strIds.Length == 0)
{
return(false);
}
CSetupSmartImportChampEntiteItem root = Items[0] as CSetupSmartImportChampEntiteItem;
if (root == null || root.ConfigMappage == null || root.ConfigMappage.IdMappage != strIds[0])
{
return(false);
}
}
finally
{
}
return(false);
}
private void m_ctrlSetup_SelectionChanged(object sender, EventArgs e)
{
CSetupSmartImportItem item = m_ctrlSetup.CurrentSetupItem;
if (item == null)
{
m_lblChemin.Text = "";
}
else
{
IEnumerable <CDefinitionProprieteDynamique> defs = item.Chemin;
StringBuilder bl = new StringBuilder();
foreach (CDefinitionProprieteDynamique def in defs)
{
bl.Append(def.Nom);
bl.Append(".");
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
}
m_lblChemin.Text = bl.ToString();
}
}
//-------------------------------------------------------------------------------
private void CreateChilds(CSetupSmartImportEntiteFilleItem itemFille)
{
int nIndex = itemFille.Index;
int nColIndex = itemFille.ColorIndex;
HashSet <CDbKey> keysDone = new HashSet <CDbKey>();
if (itemFille.ValeursDeFilles != null)
{
foreach (CValeursProprietes val in itemFille.ValeursDeFilles)
{
CMappageEntiteFille mappage = itemFille.MappageEntitesFilles != null?
itemFille.MappageEntitesFilles.GetMappageForEntite(val.DbKeyObjet) :
null;
bool bCreate = true;
if (HideNullSources)
{
bCreate = mappage != null && mappage.Source != null;
}
if (bCreate)
{
nColIndex++;
if (CSetupSmartImportItem.GetCouleur(nColIndex) == itemFille.BackColor)
{
nColIndex++;
}
CSetupSmartImportChampEntiteItem item = new CSetupSmartImportChampEntiteItem(
itemFille,
val,
mappage != null ? mappage.Source : null,
mappage != null ? mappage.ConfigMappage : null,
nColIndex);
InsertItem(++nIndex, item, false);
if (val.DbKeyObjet != null)
{
keysDone.Add(val.DbKeyObjet);
}
}
}
}
if (itemFille.MappageEntitesFilles != null)
{
IEnumerable <CMappageEntiteFille> mapsFilles = itemFille.MappageEntitesFilles.MappagesEntitesFilles;
foreach (CMappageEntiteFille mapFille in mapsFilles)
{
if (mapFille.Source != null && mapFille.ConfigMappage != null)
{
CConfigMappagesSmartImport conf = mapFille.ConfigMappage;
if (conf.KeyEntite == null || !keysDone.Contains(conf.KeyEntite))
{
nColIndex++;
if (CSetupSmartImportItem.GetCouleur(nColIndex) == itemFille.BackColor)
{
nColIndex++;
}
CSetupSmartImportChampEntiteItem item = new CSetupSmartImportChampEntiteItem(
itemFille,
null,
mapFille.Source,
conf,
nColIndex);
InsertItem(++nIndex, item, false);
if (conf.KeyEntite != null)
{
keysDone.Add(conf.KeyEntite);
}
}
}
}
}
}
//-------------------------------------------------------------------------------
private void CreateChilds(CSetupSmartImportItem si, CValeursProprietes valeurs, CConfigMappagesSmartImport configMappage)
{
//Champs simples
HashSet <CDefinitionProprieteDynamique> set = new HashSet <CDefinitionProprieteDynamique>();
if (valeurs != null)
{
foreach (CDefinitionProprieteDynamique prop in valeurs.GetDefinitionsSimples())
{
if (prop != null)
{
set.Add(prop);
}
}
}
if (configMappage != null)
{
foreach (CMappageChampSimple mappage in configMappage.MappagesChampsSimples)
{
if (mappage.Propriete != null)
{
set.Add(mappage.Propriete);
}
}
}
List <CDefinitionProprieteDynamique> lst = new List <CDefinitionProprieteDynamique>(set.ToArray());
lst.Sort((x, y) => x.Nom.CompareTo(y.Nom));
int nIndex = si.Index;
foreach (CDefinitionProprieteDynamique def in lst)
{
CMappageChampSimple mappageSimple = configMappage != null?
configMappage.GetMappageSimpleFor(def) :
null;
bool bCreate = true;
if (HideNullSources)
{
bCreate = mappageSimple != null && mappageSimple.Source != null;
}
if (bCreate)
{
CSetupSmartImportChampSimpleItem item = new CSetupSmartImportChampSimpleItem(
si,
def,
valeurs != null ? valeurs.GetValeurSimple(def) : null,
mappageSimple,
si.ColorIndex);
InsertItem(++nIndex, item, false);
}
}
//Champs parents
int nColorIndex = si.ColorIndex;
set.Clear();
if (valeurs != null)
{
foreach (CDefinitionProprieteDynamique def in valeurs.GetDefinitionsParentes())
{
if (def != null)
{
set.Add(def);
}
}
}
if (configMappage != null)
{
foreach (CMappageEntiteParente map in configMappage.MappagesEntitesParentes)
{
if (map.Propriete != null)
{
set.Add(map.Propriete);
}
}
}
lst = new List <CDefinitionProprieteDynamique>(set.ToArray());
lst.Sort((x, y) => x.Nom.CompareTo(y.Nom));
foreach (CDefinitionProprieteDynamique def in lst)
{
CMappageEntiteParente mappageParent = configMappage != null?configMappage.GetMappageParentFor(def) : null;
bool bCreate = true;
if (HideNullSources)
{
bCreate = mappageParent != null && mappageParent.Source != null;
}
if (bCreate)
{
nColorIndex++;
if (CSetupSmartImportItem.GetCouleur(nColorIndex) == si.BackColor)
{
nColorIndex++;
}
CSetupSmartImportEntiteParentItem item = new CSetupSmartImportEntiteParentItem(
si,
def,
valeurs != null ? valeurs.GetValeurParente(def) : null,
mappageParent,
nColorIndex);
InsertItem(++nIndex, item, false);
}
}
set.Clear();
if (valeurs != null)
{
foreach (CDefinitionProprieteDynamique def in valeurs.GetDefinitionsFilles())
{
if (def != null)
{
set.Add(def);
}
}
}
if (configMappage != null)
{
foreach (CMappageEntitesFilles map in configMappage.MappagesEntitesFilles)
{
if (map.Propriete != null)
{
set.Add(map.Propriete);
}
}
}
lst = new List <CDefinitionProprieteDynamique>(set.ToArray());
lst.Sort((x, y) => x.Nom.CompareTo(y.Nom));
foreach (CDefinitionProprieteDynamique def in lst)
{
CMappageEntitesFilles mappageFilles = configMappage != null?configMappage.GetMappageFilleFor(def) : null;
bool bCreate = true;
if (HideNullSources)
{
bCreate = mappageFilles != null && mappageFilles.MappagesEntitesFilles.Count() > 0;
}
if (bCreate)
{
CSetupSmartImportEntiteFilleItem item = new CSetupSmartImportEntiteFilleItem(
si,
def,
valeurs,
mappageFilles,
si.ColorIndex
);
InsertItem(++nIndex, item, false);
}
}
}
//--------------------------------------------------------------------
protected override CResultAErreur MyInitChamps(CCustomizableListItem item)
{
CResultAErreur result = base.MyInitChamps(item);
if (!result)
{
return(result);
}
CSetupSmartImportItem si = item as CSetupSmartImportItem;
if (si != null)
{
m_lblChamp.BackColor = si.BackColor;
m_lblMarge.BackColor = si.BackColor;
if (si.Niveau > 0)
{
m_lblMarge.Width = si.Niveau * 10;
m_lblMarge.Visible = true;
}
else
{
m_lblMarge.Visible = false;
}
if (si.Propriete != null)
{
m_lblChamp.Text = si.Propriete.Nom;
}
else
{
m_lblChamp.Text = "";
}
if (si.ItemParent == null)
{
si.Source = new CSourceSmartImportObjet();
}
BackColor = Color.White;
ColorInactive = Parent.BackColor;
m_wndOptionCreation.IsApplicable = false;
m_lblValeur.Text = si.LibelleValeur;
m_btnExpand.Visible = si.IsExpandable;
m_btnExpand.Text = si.IsCollapse ? "+" : "-";
if (si.IsEntite)
{
if (si.Index != this.AssociatedListControl.CurrentItemIndex)
{
BackColor = si.BackColor;
}
ColorInactive = si.BackColor;
}
m_wndOptionCreation.IsApplicable = si.CanHaveOptionCreation;
m_wndOptionCreation.Option = si.OptionCreation;
IEnumerable <Type> sourcesPossibles = si.SourcesPossibles;
if (sourcesPossibles.Count() > 0)
{
m_controleSource.Visible = true;
m_controleSource.TypesSourcesValides = sourcesPossibles;
m_controleSource.Init(si.Source, si);
m_controleSource.DefaultValue = si.ValeurParDefaut;
m_controleSource.SetIsDrawingImage(IsCreatingImage);
m_imageSearchKey.Visible = true;
}
else
{
m_controleSource.Visible = false;
}
UpdateVisuelKey();
}
else
{
m_btnExpand.Visible = false;
}
return(result);
}
