//---------------------------------------------------
public override void FrontToBack(I2iObjetGraphique child)
{
m_listeObjets.Remove(child);
m_listeObjets.Insert(0, child);
}
//------------------------------------------------------
public override void FrontToBack(I2iObjetGraphique child)
{
}
//------------------------------------------------------------------
public override bool ContainsChild(I2iObjetGraphique child)
{
return(false);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture &&
serializer.GetObjetAttache(typeof(CContexteDonnee)) != null)
{
ContexteDonnee = (CContexteDonnee)serializer.GetObjetAttache(typeof(CContexteDonnee));
}
else
{
ContexteDonnee = CContexteDonneeSysteme.GetInstance();
}
serializer.TraiteInt(ref m_nIdNextObjet);
if (nVersion > 0)
{
bool bHasType = TypeCible != null;
serializer.TraiteBool(ref bHasType);
if (bHasType)
{
serializer.TraiteType(ref m_typeCible);
}
else
{
m_typeCible = null;
}
}
else
{
m_typeCible = null;
}
//Lit les variables en premier car on en a besoin dans les actions
serializer.AttacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
if (result)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeVariables, this);
}
foreach (IVariableDynamique variable in m_listeVariables)
{
if (variable.IdVariable == c_strIdVariableElement) //TESTDBKEYOK
{
m_variableCible = (CVariableProcessTypeComplexe)variable;
}
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
foreach (IVariableDynamique var in m_listeVariables)
{
if (var.IdVariable == c_strIdVariableElement && var is CVariableProcessTypeComplexe)
{
m_variableCible = (CVariableProcessTypeComplexe)var;
m_typeCible = m_variableCible.TypeDonnee.TypeDotNetNatif;
m_bSurTableauDeCible = m_variableCible.TypeDonnee.IsArrayOfTypeNatif;
}
}
}
result = serializer.TraiteArrayListOf2iSerializable(m_listeActions, this);
if (result)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeLiensActions, this);
}
serializer.DetacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
//Lit les valeurs des variables
if (nVersion > 2)
{
result = SerializeValeursVariables(nVersion, serializer);
}
if (nVersion >= 3)
{
serializer.TraiteBool(ref m_bModeAsynchrone);
}
else
{
m_bModeAsynchrone = false;
}
if (nVersion >= 4)
{
serializer.TraiteString(ref m_strLibelle);
}
AssureVariableCible();
if (nVersion >= 5)
{
I2iSerializable objet = m_infoDeclencheur;
serializer.TraiteObject(ref objet);
m_infoDeclencheur = (CInfoDeclencheurProcess)objet;
}
if (nVersion >= 7)
{
serializer.TraiteBool(ref m_bSurTableauDeCible);
}
else
{
m_bSurTableauDeCible = false;
}
if (nVersion >= 9)
{
serializer.TraiteString(ref m_strLastErreur);
}
else
{
m_strLastErreur = "";
}
if (nVersion >= 10)
{
if (nVersion < 14 && serializer.Mode == ModeSerialisation.Lecture)
{
int nIdTemp = -1;
serializer.TraiteInt(ref nIdTemp);
m_strIdVariableRetour = nIdTemp.ToString();
}
else
{
serializer.TraiteString(ref m_strIdVariableRetour);
}
}
Dictionary <int, I2iObjetGraphique> dicIdToObjet = null;
if (nVersion >= 12)
{
int nbEle = m_ordreZ.Count;
serializer.TraiteInt(ref nbEle);
if (serializer.Mode == ModeSerialisation.Lecture)
{
dicIdToObjet = new Dictionary <int, I2iObjetGraphique>();
foreach (CAction action in ListeActions)
{
dicIdToObjet[action.IdObjetProcess] = action;
}
foreach (CLienAction lien in ListeLiens)
{
dicIdToObjet[lien.IdObjetProcess] = lien;
}
m_ordreZ.Clear();
for (int n = 0; n < nbEle; n++)
{
int nId = 0;
serializer.TraiteInt(ref nId);
I2iObjetGraphique objTmp = null;
if (dicIdToObjet.TryGetValue(nId, out objTmp))
{
m_ordreZ.Add((IObjetDeProcess)objTmp);
}
}
}
else if (serializer.Mode == ModeSerialisation.Ecriture)
{
foreach (IObjetDeProcess objet in m_ordreZ)
{
int nCopy = objet.IdObjetProcess;
serializer.TraiteInt(ref nCopy);
}
}
}
else
{
m_ordreZ = new List <IObjetDeProcess>();
foreach (CAction action in ListeActions)
{
m_ordreZ.Add(action);
}
foreach (CLienAction lien in ListeLiens)
{
m_ordreZ.Add(lien);
}
}
if (nVersion >= 13)
{
serializer.TraiteBool(ref m_bModeTransactionnel);
}
else
{
m_bModeTransactionnel = false;
}
return(result);
}
//----------------------------------------------------------
public override bool ContainsChild(I2iObjetGraphique child)
{
return(m_listeFils.Contains(child as C2iObjetGraphique));
}
//-----------------------------------------------------
private void m_controlEdition_AfterClicElementInSelection(I2iObjetGraphique e)
{
}
private bool ObjetGraphiqueIsLien(I2iObjetGraphique obj)
{
return(CUtilProjet.GetTypeElement(obj) == ETypeElementDeProjet.Lien);
}
/// //////////////////////////////////////////////////
protected override void Editeur_DragDrop(object sender, System.Windows.Forms.DragEventArgs e)
{
if (ObjetEdite == null)
{
return;
}
if (LockEdition)
{
return;
}
if (e.Data.GetDataPresent(typeof(CReferenceObjetDonnee)))
{
CReferenceObjetDonnee reference = e.Data.GetData(typeof(CReferenceObjetDonnee)) as CReferenceObjetDonnee;
if (reference.TypeObjet == typeof(CModeleAffectationUtilisateurs))
{
Point pt = PointToClient(new Point(e.X, e.Y));
Point ptLogique = GetLogicalPointFromDisplay(pt);
CWorkflowEtapeDessin dessinEtape = ObjetEdite.SelectionnerElementDuDessus(ptLogique) as CWorkflowEtapeDessin;
if (dessinEtape != null)
{
CModeleAffectationUtilisateurs modele = reference.GetObjet(CSc2iWin32DataClient.ContexteCourant) as CModeleAffectationUtilisateurs;
if (modele != null)
{
CParametresAffectationEtape parametres = modele.ParametresAffectation;
if (parametres != null)
{
CParametresInitialisationEtape parametre = dessinEtape.Initializations;
CParametresAffectationEtape parAff = parametre.Affectations;
if (parAff != null)
{
if (MessageBox.Show(I.T("Replace current assignments(Yes) or add new assignemnts(No) ?|20135"), "",
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
parAff = new CParametresAffectationEtape();
}
parAff.AddFormules(parametres.Formules);
parametre.Affectations = parAff;
dessinEtape.Initializations = parametre;
e.Effect = DragDropEffects.Link;
Refresh();
return;
}
}
}
}
}
}
List <CDonneeDragDropObjetGraphique> datas = GetDragDropData(e.Data);
if (datas == null || datas.Count == 0)
{
return;
}
List <I2iObjetGraphique> candidats = new List <I2iObjetGraphique>();
foreach (CRectangleDragForObjetGraphique rct in RectsDrags)
{
candidats.Add(rct.ObjetGraphique);
}
Point ptLocal = GetLogicalPointFromDisplay(PointToClient(new Point(e.X, e.Y)));
I2iObjetGraphique parent = ObjetEdite.SelectionnerElementConteneurDuDessus(ptLocal, candidats);
parent = DessinWorkflow;;
if (parent == null)
{
e.Effect = DragDropEffects.None;
}
else
{
List <I2iObjetGraphique> nouveaux = new List <I2iObjetGraphique>();
foreach (CRectangleDragForObjetGraphique rct in RectsDrags)
{
rct.RectangleDrag = rct.Datas.GetDragDropPosition(ptLocal);
rct.RectangleDrag = GetRectangleSelonModesActives(rct.RectangleDrag, ptLocal);
// rct.RectangleDrag.Offset((int)(AutoScrollPosition.X / Echelle), (int)(AutoScrollPosition.Y / Echelle));
//Si dummy de création (type de bloc), création d'une nouvelle étape
I2iObjetGraphique objetGraphique = rct.Datas.ObjetDragDrop;
CDummyObjetWorkflowPourCreation dummyCreation = objetGraphique as CDummyObjetWorkflowPourCreation;
if (dummyCreation != null)
{
CTypeEtapeWorkflow typeEtape = dummyCreation.TypeEtape;
if (typeEtape == null)
{
typeEtape = new CTypeEtapeWorkflow(DessinWorkflow.TypeWorkflow.ContexteDonnee);
typeEtape.CreateNewInCurrentContexte();
typeEtape.Workflow = DessinWorkflow.TypeWorkflow;
typeEtape.Bloc = Activator.CreateInstance(dummyCreation.TypeBloc, new object[] { typeEtape }) as CBlocWorkflow;
}
CWorkflowEtapeDessin graphEtape = new CWorkflowEtapeDessin();
graphEtape.TypeEtape = typeEtape;
objetGraphique = graphEtape;
objetGraphique.Size = dummyCreation.Size;
}
JusteBeforePositionneSurApresDragDrop(objetGraphique);
bool bParentIsInSelec = objetGraphique.Parent != null && candidats.Contains(objetGraphique.Parent);
bool bHasMove = false;
if (e.Effect == DragDropEffects.Copy)
{
Dictionary <Type, object> dicObjetsPourCloner = new Dictionary <Type, object>();
AddObjectsForClonerSerializer(dicObjetsPourCloner);
objetGraphique = (I2iObjetGraphique)objetGraphique.GetCloneAMettreDansParent(parent, dicObjetsPourCloner);
if (objetGraphique == null || !parent.AddChild(objetGraphique))
{
e.Effect = DragDropEffects.None;
objetGraphique.CancelClone();
continue;
}
else
{
objetGraphique.Parent = parent;
nouveaux.Add(objetGraphique);
}
bHasMove = true;
}
else
{
bHasMove = true;
if (objetGraphique.Parent != parent)
{
if (objetGraphique.Parent != null)
{
if (!bParentIsInSelec)
{
objetGraphique.Parent.RemoveChild(objetGraphique);
}
}
else
{
nouveaux.Add(objetGraphique);
}
if (!bParentIsInSelec)
{
if (!parent.AddChild(objetGraphique))
{
e.Effect = DragDropEffects.None;
continue;
}
else
{
objetGraphique.Parent = parent;
}
}
}
}
if (!bParentIsInSelec && bHasMove)
{
Point ptDrop = new Point(rct.RectangleDrag.Left, rct.RectangleDrag.Top);
objetGraphique.PositionAbsolue = ptDrop;
}
}
if (nouveaux.Count > 0)
{
RefreshSelectionChanged = false;
Selection.Clear();
Selection.AddRange(nouveaux);
RefreshSelectionChanged = true;
DeclencheAfterAddElements(nouveaux);
Refresh();
}
}
ElementModifie();
EnDeplacement = false;
Dessiner(true, true);
}
/// /////////////////////////////////////////////// public abstract bool AddChild(I2iObjetGraphique child);
//-------------------------------------------------------
public override bool AddChild(I2iObjetGraphique child)
{
child.Parent = this;
m_listeChilds.Add(child);
return(true);
}
public void RemoveChildOnlyInGraphic(I2iObjetGraphique child)
{
m_listeChilds.Remove(child);
}
/// //////////////////////////////////////////////////
protected override void Editeur_DragDrop(object sender, System.Windows.Forms.DragEventArgs e)
{
if (ObjetEdite == null)
{
return;
}
if (LockEdition)
{
return;
}
List <CDonneeDragDropObjetGraphique> datas = GetDragDropData(e.Data);
if (datas == null || datas.Count == 0)
{
return;
}
List <I2iObjetGraphique> candidats = new List <I2iObjetGraphique>();
foreach (CRectangleDragForObjetGraphique rct in RectsDrags)
{
candidats.Add(rct.ObjetGraphique);
}
Point ptLocal = GetLogicalPointFromDisplay(PointToClient(new Point(e.X, e.Y)));
I2iObjetGraphique parent = ObjetEdite.SelectionnerElementConteneurDuDessus(ptLocal, candidats);
CRepresentationExpressionGraphique repForParametre = parent as CRepresentationExpressionGraphique;
if (RectsDrags.Count() != 1)
{
repForParametre = null;
}
parent = ObjetEdite;
List <I2iObjetGraphique> nouveaux = new List <I2iObjetGraphique>();
foreach (CRectangleDragForObjetGraphique rct in RectsDrags)
{
rct.RectangleDrag = rct.Datas.GetDragDropPosition(ptLocal);
rct.RectangleDrag = GetRectangleSelonModesActives(rct.RectangleDrag, ptLocal);
// rct.RectangleDrag.Offset((int)(AutoScrollPosition.X / Echelle), (int)(AutoScrollPosition.Y / Echelle));
I2iObjetGraphique objetGraphique = rct.Datas.ObjetDragDrop;
JusteBeforePositionneSurApresDragDrop(objetGraphique);
bool bParentIsInSelec = objetGraphique.Parent != null && candidats.Contains(objetGraphique.Parent);
bool bHasMove = false;
if (e.Effect == DragDropEffects.Copy)
{
Dictionary <Type, object> dicObjetsPourCloner = new Dictionary <Type, object>();
AddObjectsForClonerSerializer(dicObjetsPourCloner);
objetGraphique = (I2iObjetGraphique)objetGraphique.GetCloneAMettreDansParent(parent, dicObjetsPourCloner);
if (objetGraphique == null || !parent.AddChild(objetGraphique))
{
e.Effect = DragDropEffects.None;
objetGraphique.CancelClone();
continue;
}
else
{
objetGraphique.Parent = parent;
nouveaux.Add(objetGraphique);
}
bHasMove = true;
}
else
{
if (repForParametre == null)
{
bHasMove = true;
if (objetGraphique.Parent != parent)
{
if (objetGraphique.Parent != null)
{
if (!bParentIsInSelec)
{
objetGraphique.Parent.RemoveChild(objetGraphique);
}
}
else
{
nouveaux.Add(objetGraphique);
}
if (!bParentIsInSelec)
{
if (!parent.AddChild(objetGraphique))
{
e.Effect = DragDropEffects.None;
continue;
}
else
{
objetGraphique.Parent = parent;
}
}
}
}
}
if (!bParentIsInSelec && bHasMove)
{
Point ptDrop = new Point(rct.RectangleDrag.Left, rct.RectangleDrag.Top);
objetGraphique.PositionAbsolue = ptDrop;
}
}
if (nouveaux.Count > 0)
{
RefreshSelectionChanged = false;
Selection.Clear();
Selection.AddRange(nouveaux);
RefreshSelectionChanged = true;
DeclencheAfterAddElements(nouveaux);
Refresh();
}
ElementModifie();
EnDeplacement = false;
Dessiner(true, true);
if (repForParametre != null)
{
CRepresentationExpressionGraphique repParametre = RectsDrags[0].Datas.ObjetDragDrop as CRepresentationExpressionGraphique;
if (repParametre != null)
{
ShowInterfaceLienParametre(repParametre, repForParametre);
}
}
}
//-----------------------------------------------
public bool ContainsChild(I2iObjetGraphique child)
{
return(m_listeRepresentations.Contains(child as CRepresentationExpressionGraphique));
}
//-----------------------------------------------
public bool IsChildOf(I2iObjetGraphique wnd)
{
return(false);
}
/// ////////////////////////////////////////////////////////////////
private void CControlEdition_MouseUp(object sender, System.Windows.Forms.MouseEventArgs e)
{
Point ptSouris = GetLogicalPointFromDisplay(new Point(e.X, e.Y));
I2iObjetGraphique wndNouvelEle = null;
switch (ModeEdition)
{
case EModeEditeurProjet.Selection:
break;
case EModeEditeurProjet.Projet:
if (BeforeAddElement != null && !BeforeAddElement())
{
break;
}
CProjet nouveauProjet;
if (m_bModeCreation)
{
nouveauProjet = new CProjet(WndProjetEdite.Projet.ContexteDonnee);
nouveauProjet.CreateNew();
}
else
{
CFiltreData filtre = new CFiltreDataAvance(CProjet.c_nomTable, "HasNo(" + CProjet.c_champIdParent + ") AND " + CProjet.c_champCodeSystemeComplet + " not like @1", ProjetEnCreation.CodeSystemePartiel + "%");
//string strIdsPrjsToIgnore = ProjetEnCreation.Id.ToString();
//foreach (CProjet prjFils in ProjetEnCreation.ProjetsFils)
// strIdsPrjsToIgnore += "," + prjFils.Id.ToString();
//filtre = CFiltreData.GetAndFiltre(filtre, new CFiltreDataAvance(CProjet.c_nomTable, CProjet.c_champId + " not in (" + strIdsPrjsToIgnore +")"));
CListeObjetsDonnees lstPrjs = new CListeObjetsDonnees(ProjetEnCreation.ContexteDonnee, typeof(CProjet), filtre);
CFormListeProjet frmProjets = new CFormListeProjet(lstPrjs);
nouveauProjet = (CProjet)CFormNavigateurPopupListe.SelectObject(frmProjets, null, "");
if (nouveauProjet == null)
{
return;
}
}
nouveauProjet.Projet = ProjetEnCreation;
nouveauProjet.DesignerProjetX = e.X;
nouveauProjet.DesignerProjetY = e.Y;
wndNouvelEle = new CWndProjetBrique(nouveauProjet);
break;
case EModeEditeurProjet.Intervention:
if (BeforeAddElement != null && !BeforeAddElement())
{
break;
}
CIntervention nouvelleInter;
if (m_bModeCreation)
{
nouvelleInter = new CIntervention(WndProjetEdite.Projet.ContexteDonnee);
nouvelleInter.CreateNew();
}
else
{
CFiltreData filtre = new CFiltreDataAvance(CIntervention.c_nomTable, "HasNo(" + CProjet.c_champId + ")");
CListeObjetsDonnees lstInter = new CListeObjetsDonnees(ProjetEnCreation.ContexteDonnee, typeof(CIntervention), filtre);
CFormListeInterventions frmInters = new CFormListeInterventions(lstInter);
nouvelleInter = (CIntervention)CFormNavigateurPopupListe.SelectObject(frmInters, null, "");
if (nouvelleInter == null)
{
return;
}
}
nouvelleInter.DesignerProjetX = e.X;
nouvelleInter.DesignerProjetY = e.Y;
nouvelleInter.Projet = WndProjetEdite.Projet;
wndNouvelEle = new CWndIntervention(nouvelleInter);
break;
case EModeEditeurProjet.LienStart:
I2iObjetGraphique o = WndProjetEdite.GetObjetFilsFromPoint(ptSouris);
if (o != null && o is IWndElementDeProjetPlanifiable)
{
m_eleDebutLien = (IWndElementDeProjetPlanifiable)o;
ModeEdition = EModeEditeurProjet.LienEnd;
}
break;
case EModeEditeurProjet.LienEnd:
ModeEdition = EModeEditeurProjet.LienStart;
I2iObjetGraphique ele = WndProjetEdite.GetObjetFilsFromPoint(ptSouris);
bool bCreer = true;
if (ele != null && ele != m_eleDebutLien && ele is IWndElementDeProjetPlanifiable)
{
foreach (I2iObjetGraphique objet in ObjetEdite.Childs)
{
if (objet is CWndLienDeProjet)
{
CWndLienDeProjet wndLien = (CWndLienDeProjet)objet;
if (wndLien.ElementArrivee == m_eleDebutLien &&
wndLien.ElementDepart == ele ||
wndLien.ElementArrivee == ele &&
wndLien.ElementDepart == m_eleDebutLien)
{
bCreer = false;
break;
}
}
}
if (bCreer && BeforeAddElement != null && !BeforeAddElement())
{
break;
}
if (bCreer)
{
CLienDeProjet lien = new CLienDeProjet(WndProjetEdite.Projet.ContexteDonnee);
lien.CreateNewInCurrentContexte();
lien.ElementA = m_eleDebutLien.ElementDuProjet;
lien.ElementB = ((IWndElementDeProjetPlanifiable)ele).ElementDuProjet;
lien.Projet = WndProjetEdite.Projet;
CWndLienDeProjet wndLien = new CWndLienDeProjet(lien);
wndLien.ElementDepart = (IWndElementDeProjetPlanifiable)m_eleDebutLien;
wndLien.ElementArrivee = (IWndElementDeProjetPlanifiable)ele;
wndNouvelEle = wndLien;
ModeEdition = EModeEditeurProjet.LienStart;
}
}
break;
}
if (wndNouvelEle != null)
{
Point pt = new Point(ptSouris.X - wndNouvelEle.Size.Width / 2, ptSouris.Y - wndNouvelEle.Size.Height / 2);
wndNouvelEle.Position = pt;
WndProjetEdite.AddChild(wndNouvelEle);
Selection.Clear();
Selection.Add(wndNouvelEle);
//Refresh();
if (AfterAddElement != null)
{
AfterAddElement(wndNouvelEle);
}
}
}
/// /////////////////////////////////////////////// public abstract bool ContainsChild(I2iObjetGraphique child);
private void SupprimerElement(I2iObjetGraphique ele)
{
m_controlEdition.Selection.Clear();
m_controlEdition.WndProjetEdite.RemoveChild(ele);
ActualiserDesigner();
}
/// /////////////////////////////////////////////// public abstract void RemoveChild(I2iObjetGraphique child);
private void SelectionnerContenu(I2iObjetGraphique o)
{
IElementDeProjet ele = CUtilProjet.GetIElementDeProjet(o);
SelectionnerContenu(ele);
}
/// ///////////////////////////////////////////////
public virtual void DeleteChild(I2iObjetGraphique child)
{
RemoveChild(child);
}
public override I2iObjetGraphique GetCloneAMettreDansParent(I2iObjetGraphique parent, Dictionary <Type, object> dicObjetsPourCloner)
{
return((I2iObjetGraphique)CCloner2iSerializable.Clone(this, dicObjetsPourCloner, new object[] { Process }));
}
/// /////////////////////////////////////////////// public abstract void BringToFront(I2iObjetGraphique child);
//-----------------------------------------------------------------
public bool CanEditeProprietes(I2iObjetGraphique objet)
{
return(GetTypeEditeurForObjet(objet) != null);
}
/// /////////////////////////////////////////////// public abstract void FrontToBack(I2iObjetGraphique child);
//------------------------------------------------------
public override void BringToFront(I2iObjetGraphique child)
{
}
//PREMIER CONTENEUR
public I2iObjetGraphique SelectionnerElementConteneurDuDessus(Point pt)
{
I2iObjetGraphique ele = null;
return(SelectionnerElementConteneurDuDessus(pt, ele));
}
//------------------------------------------------------------------
public override bool AddChild(I2iObjetGraphique child)
{
return(false);
}
/// <summary>
/// Appelé par les fonctions de drag and drop, pour cloner l'élément en vue de mettre la copie dans le parent demandé.
/// </summary>
/// <param name="parent"></param>
/// <param name="dicObjetsPourCloner"></param>
/// <returns></returns>
public virtual I2iObjetGraphique GetCloneAMettreDansParent(I2iObjetGraphique parent, Dictionary <Type, object> dicObjetsPourCloner)
{
return((I2iObjetGraphique)CCloner2iSerializable.Clone(this, dicObjetsPourCloner));
}
//------------------------------------------------------------------
public override void RemoveChild(I2iObjetGraphique child)
{
}
//---------------------------------------------------
public override void BringToFront(I2iObjetGraphique child)
{
m_listeObjets.Remove(child);
m_listeObjets.Add(child);
}