/// <summary>
/// Mets les éléments selectionnés dans le presse-papiers.
/// </summary>
/// <param name="copieListMeasure"></param>
/// <param name="isCut">true=>cut/false=>copy</param>
private void SetInClipboard(List <Kernel.Domain.Role> copieListMeasure, Kernel.Domain.Role parent = null)
{
if (copieListMeasure.Count > 0)
{
Kernel.Util.ClipbordUtil.ClearClipboard();
List <IHierarchyObject> listeCopy = new List <IHierarchyObject>(0);
if (!isTreeInCutMode)
{
foreach (Kernel.Domain.Role roleToCopy in copieListMeasure)
{
listeCopy.Add(roleToCopy.GetCopy());
}
}
else
{
listeCopy.AddRange(copieListMeasure);
if (parent == null)
{
parent = this.Root;
}
int nbreCutElement = listeCopy.Count;
}
Kernel.Util.ClipbordUtil.SetHierarchyObject(listeCopy);
}
}
/// <summary>
///
/// </summary>
/// <returns>La role sélectionnée dans le cas de multiselection mode</returns>
public Kernel.Domain.Role GetSelectedMultiRole()
{
Kernel.Domain.Role r = null;
r = this.tree.SelectedItem != null ? this.tree.SelectedItem as Kernel.Domain.Role :
(this.tree.SelectedItem == null && this.tree.SelectedValue != null && this.tree.SelectedValue != defaultValue ?
(this.tree.SelectedValue as Kernel.Domain.Role) : null);
return(r);
}
/// <summary>
/// Cette fonction permet d'ajouter à l'arbre les éléments (Target) venus du presse-papier.
/// </summary>
/// <param name="measure"></param>
/// <param name="name"></param>
/// <param name="parent"></param>
private void pasteValue(Kernel.Domain.Role r, string name, Kernel.Domain.Role parent = null)
{
Kernel.Domain.Role clipboardAddedRole = ValidateName(r, name);
if (clipboardAddedRole != null)
{
AddToTreeCopiedElements(clipboardAddedRole, parent);
}
}
/// <summary>
/// Cette méthode est appélée lorsque l'utilisateur clique sur le menu "New".
/// Elle permet de créer un nouveau noeud dans l'abre.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnNewNode(object sender, RoutedEventArgs e)
{
Kernel.Domain.Role r = GetSelectedRole();
AddNode(r);
if (r != null)
{
removeCTRLSelection();
}
}
/// <summary>
/// Supprime un noeud et ses fils.
/// </summary>
/// <param name="model">Le noeud à supprimer</param>
public void DeleteNode(Kernel.Domain.Role item)
{
if (item != null && item.parent != null)
{
item.parent.RemoveChild(item);
if (Changed != null)
{
Changed();
}
}
}
/// <summary>
/// Cette methode permet la copie d'un élément sélectionné dans le treeview
/// Après la séléction de l'objet, un copie de cet objet est placée dans le presse-papiers
/// en attente d'être collé.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnCopyNode(object sender, RoutedEventArgs e)
{
Kernel.Domain.Role r = GetSelectedMultiRole();
List <Kernel.Domain.Role> listeSelectedR = selectedRoles.Keys.ToList <Kernel.Domain.Role>();
if ((listeSelectedR.Count == 0) && r != null)
{
listeSelectedR.Add(r);
}
isTreeInCutMode = false;
SetInClipboard(listeSelectedR);
}
/// <summary>
/// Cette méthode permet de couper un élément sélectionné dans le treeview
/// Lorsqu'on clique sur le menu contextuelle cut,
/// la variable CurrentCutObjet prend la valeur de l'élément selectionné
/// et une copie de cette dernière est placé dans le presse-papier.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnCutNode(object sender, RoutedEventArgs e)
{
isTreeInCutMode = true;
Kernel.Domain.Role r = GetSelectedRole();
List <Kernel.Domain.Role> listeSelectedRole = selectedRoles.Keys.ToList <Kernel.Domain.Role>();
if ((listeSelectedRole.Count == 0) && r != null)
{
listeSelectedRole.Add(r);
}
Kernel.Domain.Role parent = r.parent;
SetInClipboard(listeSelectedRole, parent);
}
/// <summary>
/// Cette méthode permet de coller un objet précédement copier ou couper.
/// A cet effet on vérifie si le Paste vient après un Cut(si CurrentCutObject!=null) ou un Copy,
/// puis on met dans le presse-papiers une copie de l'élément coupé ou copié.
/// On affecte un nouveau parent à l'élément coupé/copié.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnPasteNode(object sender, RoutedEventArgs e)
{
Kernel.Domain.Role parent = GetSelectedRole();
if (selectedRoles.Count > 0)
{
if (selectedRoles.ContainsKey(GetSelectedMultiRole()))
{
parent = GetSelectedMultiRole();
}
}
getRolesFromClipboard(Kernel.Util.ClipbordUtil.GetRole(), parent);
}
/// <summary>
/// Crée une nouvelle instance de EditableTree
/// </summary>
public RoleTreeView()
{
InitializeComponent();
this.Focusable = true;
this.BorderBrush = Brushes.White;
InitializeDataTemplate();
InitializeHandlers();
InitializeContextMenu();
this.Root = new Domain.Role();
defaultValue = new Domain.Role();
defaultValue.name = Label_DEFAULT_ROLE;
defaultValue.IsDefault = true;
this.RoleService = Kernel.Application.ApplicationManager.Instance.ControllerFactory.ServiceFactory.GetRoleService();
}
//Handles the TreeView's ItemDrop event
private void OnItemDrop(object sender, EO.Wpf.ItemDropEventArgs e)
{
Kernel.Domain.Role source = (Kernel.Domain.Role)e.SourceItem;
Kernel.Domain.Role target1 = (Kernel.Domain.Role)e.TargetItem1;
Kernel.Domain.Role target2 = (Kernel.Domain.Role)e.TargetItem2;
Kernel.Domain.Role parent = target2 != null ? target2 : target1;
parent.AddChild(source);
e.Canceled = true;
if (Changed != null)
{
Changed();
}
}
private void OnExitEditMode(object sender, EO.Wpf.EditItemEventArgs e)
{
try
{
if (e.Item is Kernel.Domain.Role)
{
Kernel.Domain.Role editedMeasure = (Kernel.Domain.Role)e.Item;
string name = e.Text.Trim();
Kernel.Domain.Role validName = ValidateName(editedMeasure, name);
if (validName == null)
{
e.Canceled = true;
return;
}
if (editedMeasure.IsDefault)
{
if (name.ToUpper() != Label_DEFAULT_ROLE.ToUpper())
{
Kernel.Domain.Role addedNode = new Domain.Role();
addedNode.name = name;
editedMeasure.name = Label_DEFAULT_ROLE;
editedMeasure.parent.UpdateChild(editedMeasure);
addedNode = ValidateName(addedNode, name);
AddNode(null, addedNode.name);
e.Canceled = true;
}
}
else
{
Kernel.Domain.Role valid = ValidateName(editedMeasure, name);
editedMeasure.name = valid.name;
editedMeasure.parent.UpdateChild(editedMeasure);
}
if (Changed != null)
{
Changed();
}
}
//The event must be canceled, otherwise the TreeView will
//set the TreeViewItem's Header to the new text
e.Canceled = true;
}
catch (Exception)
{
return;
}
}
protected override IHierarchyObject GetNewTreeViewModel()
{
Kernel.Domain.Role role = new Kernel.Domain.Role();
role.name = "Role1";
if (Root != null)
{
Kernel.Domain.Measure m = null;
int i = 1;
do
{
role.name = "Role" + i++;
m = (Kernel.Domain.Measure)Root.GetChildByName(role.name);
}while (m != null);
}
return(role);
}
protected Kernel.Domain.Role GetNewTreeViewModel(Domain.Role value = null)
{
Kernel.Domain.Role role = new Kernel.Domain.Role();
role.name = "Role1";
if (Root != null)
{
Kernel.Domain.Role m = null;
int i = 1;
do
{
role.name = "Role" + i++;
m = (Kernel.Domain.Role)Root.GetChildByName(role.name);
}while (m != null);
}
return(role);
}
/// <summary>
/// Affiche le contenu de la mesure
/// </summary>
/// <param name="root"></param>
public void DisplayRoot(Kernel.Domain.Role root)
{
this.Root = root;
if (this.Root == null)
{
this.tree.ItemsSource = null;
}
else
{
RefreshParent(this.Root);
this.Root.AddChild(defaultValue);
this.tree.ItemsSource = this.Root.GetItems();
SetSelectedRole(defaultValue);
}
}
/// <summary>
/// Ajoute un nouveau noeud fils au noeud passé en paramètre.
/// </summary>
/// <param name="parent">Le noeud auquel il fau ajouter un fils</param>
/// <param name="name">le nom du noeud</param>
/// <returns>Le nouveau noed créé</returns>
public virtual Kernel.Domain.Role AddNode(Kernel.Domain.Role parent, string name = "")
{
Kernel.Domain.Role child = GetNewTreeViewModel();
if (name != "")
{
child.name = name;
}
this.Root.AddChild(child);
if (Changed != null)
{
Changed();
}
SetSelectedRole(defaultValue);
return(child);
}
/// <summary>
/// Cette méthod ajoute les éléments du presse-papier à l'arbre.
/// </summary>
/// <param name="measure"></param>
/// <param name="parent"></param>
private void AddToTreeCopiedElements(Kernel.Domain.Role r, Kernel.Domain.Role parent = null)
{
if (parent != null)
{
parent.AddChild(r);
}
else
{
this.Root.AddChild(r);
}
if (Changed != null)
{
Changed();
}
this.Root.AddChild(defaultValue);
}
public override OperationState Save()
{
try
{
GetRoleBrowser().form.fillObject();
Kernel.Domain.Role root = GetRoleBrowser().form.EditedObject;
root = getRoleService().saveRole(root);
GetRoleBrowser().form.EditedObject = root;
GetRoleBrowser().form.displayObject();
//if (base.Save() == OperationState.STOP) return OperationState.STOP;
}
catch (Exception)
{
DisplayError("Save Role", "Unable to save Role.");
return(OperationState.STOP);
}
return(OperationState.CONTINUE);
}
/// <summary>
/// Cette méthode permet de rétablir la couleur d'une measure. Ceci en spécifiant que la
/// measure copiée n'est pas la mesure par défaut.
/// </summary>
/// <param name="measure"></param>
/// <returns></returns>
private Kernel.Domain.Role RestoreMeasureForeground(Kernel.Domain.Role role)
{
role.IsDefault = false;
int j = 0;
for (int i = role.GetItems().Count - 1; i >= 0; i--)
{
Kernel.Domain.Role subMeasure = role.childrenListChangeHandler.Items[j];
subMeasure = ValidateName(subMeasure, subMeasure.name);
if (subMeasure.name != role.childrenListChangeHandler.Items[j].name)
{
role.childrenListChangeHandler.Items[j].name = subMeasure.name;
}
RestoreMeasureForeground(subMeasure);
j++;
}
return(role);
}
/// <summary>
/// Cette methode permet la selection du noeud présent derrière la souris
/// lorsque fait un click-droit.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnPreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
{
EO.Wpf.TreeViewItem treeViewItem = VisualUpwardSearch(e.OriginalSource as DependencyObject);
if (treeViewItem != null)
{
treeViewItem.Focus();
SelectionManager(treeViewItem);
e.Handled = true;
}
else
{
Kernel.Domain.Role r = GetSelectedRole();
if (r != null)
{
r.IsSelected = false;
}
tree.Focus();
removeCTRLSelection();
}
}
/// <summary>
/// Retoune la liste de roles du fichier ouvert.
/// </summary>
/// <param name="file"></param>
/// <returns>La liste de roles du fichier ouvert</returns>
public Kernel.Domain.Role getRootRole()
{
try
{
var request = new RestRequest(ResourcePath + "/root", Method.GET);
RestResponse queryResult = (RestResponse)RestClient.Execute(request);
try
{
Kernel.Domain.Role root = RestSharp.SimpleJson.DeserializeObject <Kernel.Domain.Role>(queryResult.Content);
return(root);
}
catch (Exception)
{
return(null);
}
}
catch (Exception e)
{
throw new BcephalException("Unable to Return roles.", e);
}
}
/// <summary>
/// Selectionne une mesure dans l'arbre
/// </summary>
/// <param name="measure">La mesure à sélectionner</param>
public void SetSelectedRole(Kernel.Domain.Role role)
{
if (role != null)
{
role.IsSelected = true;
}
else
{
Kernel.Domain.Role selection = GetSelectedMultiRole();
if (selection != null)
{
selection.IsSelected = false;
}
}
try
{
tree.Focus();
}
catch (Exception)
{
}
}
///// <summary>
///// verifie l'ordre de selection utilisé.
///// </summary>
///// <returns>true if selection is in block UP to Down or Down to Up</returns>
//public bool SelectionOrder()
//{
// int i = 0;
// bool IsSelectionBlock = true;
// indexSelecte = new List<int>(0);
// if(selectedRoles.Keys.Count>0)
// {
// indexSelecte.Add(selectedRoles.Keys.ElementAt(i).GetPosition());
// while (i < (selectedRoles.Keys.Count() - 1) && IsSelectionBlock)
// {
// indexSelecte.Add(selectedRoles.Keys.ElementAt(i + 1).GetPosition());
// IsSelectionBlock = ((selectedRoles.Keys.ElementAt(i).GetPosition() < selectedRoles.Keys.ElementAt(i + 1).GetPosition()) && (selectedRoles.Keys.ElementAt(i).GetPosition() + 1 == selectedRoles.Keys.ElementAt(i + 1).GetPosition())) || ((selectedRoles.Keys.ElementAt(i).GetPosition() > selectedRoles.Keys.ElementAt(i + 1).GetPosition()) && (selectedRoles.Keys.ElementAt(i).GetPosition() - 1 == selectedRoles.Keys.ElementAt(i + 1).GetPosition())) ? true : false;
// if(IsSelectionBlock)
// if (selectedRoles.Keys.ElementAt(i).parent != selectedRoles.Keys.ElementAt(i + 1).parent)
// return false;
// //verify if selection order is up to down, return false otherwise
// this.isSelectionDownToUp = (selectedRoles.Keys.ElementAt(i).GetPosition() > selectedRoles.Keys.ElementAt(i + 1).GetPosition()) && (selectedRoles.Keys.ElementAt(i).GetPosition() - 1 == selectedRoles.Keys.ElementAt(i + 1).GetPosition());
// i++;
// }
// indexSelecte.BubbleSort();
// return IsSelectionBlock;
// }
// return false;
//}
/// <summary>
/// Cette méthode permet de désactiver un menuItem dans le cas
/// où l'opération associée à ce menuItem n'est pas possible pour
/// le noeud courant.
/// </summary>
/// <param name="e"></param>
protected override void OnContextMenuOpening(ContextMenuEventArgs e)
{
Kernel.Domain.Role selectedItem = GetSelectedRole();
if (selectedRoles.Count > 0 && selectedItem == null)
{
selectedItem = selectedRoles.Keys.Last();
}
if (Root != null)
{
this.tree.ContextMenu.Visibility = System.Windows.Visibility.Visible;
this.newMenuItem.IsEnabled = this.Root != null && selectedItem != defaultValue && selectedRoles.Count <= 1;
this.cutMenuItem.IsEnabled = this.Root != null && selectedItem != null && selectedItem.parent != null && selectedItem != defaultValue;
this.copyMenuItem.IsEnabled = this.Root != null && selectedItem != null && selectedItem.parent != null && selectedItem != defaultValue;
this.pasteMenuItem.IsEnabled = this.Root != null && !Kernel.Util.ClipbordUtil.IsClipBoardEmptyMeasure() && selectedItem != defaultValue && selectedRoles.Count <= 1;
this.deleteMenuItem.IsEnabled = this.Root != null && selectedItem != null && selectedItem.parent != null && selectedItem != defaultValue;
}
else
{
this.tree.ContextMenu.Visibility = System.Windows.Visibility.Collapsed;
}
}
/// <summary>
/// Cette méthode permet de vérifier si une measure de l'arbre possède un nom identique à celui d'une measure qui
/// vient du presse-papier. S'il y a identité de nom, un nouveau nom est donné à la measure venant du presse-papier.
/// </summary>
/// <param name="measure"></param>
/// <param name="name"></param>
/// <returns>La measure à copier</returns>
private Kernel.Domain.Role ValidateName(Kernel.Domain.Role role, string name)
{
bool result = true;
role.name = name;
Kernel.Domain.Role currentMeasure = role.CloneObject() as Kernel.Domain.Role;
if (string.IsNullOrEmpty(name))
{
Kernel.Util.MessageDisplayer.DisplayError("Empty Measure", "Measure can't be empty! ");
result = false;
}
Kernel.Domain.Role m = (Kernel.Domain.Role)Root.GetNotEditedChildByName(role, name);
if (m == null)
{
return(role);
}
if (m != null && m.Equals(role))
{
if (role.IsDefault)
{
result = false;
}
result = true;
}
if (m != null && !m.Equals(role))
{
currentMeasure = currentMeasure.GetCopy() as Kernel.Domain.Role;
currentMeasure = ValidateName(currentMeasure, currentMeasure.name);
}
if (result)
{
return(currentMeasure);
}
return(null);
}
/// <summary>
/// Colle les éléments dans treeview après un copy/cut.
/// </summary>
/// <param name="measuresInClipboard">les éléments présents dans le presse-papier</param>
/// <param name="isCutOperation">Le mode false=>copy/true=>cut</param>
/// <param name="parent">Le parent sur lequel on effectue l'opération.</param>
private void getRolesFromClipboard(List <Kernel.Domain.Role> rolesInClipboard, Kernel.Domain.Role parent = null)
{
if (rolesInClipboard != null && rolesInClipboard.Count > 0)
{
if (isTreeInCutMode)
{
int nbCutElement = rolesInClipboard.Count;
for (int i = 0; i < nbCutElement; i++)
{
AddToTreeCopiedElements(RestoreMeasureForeground(rolesInClipboard[i]), parent);
}
isTreeInCutMode = false;
SetInClipboard(rolesInClipboard);
if (Changed != null)
{
Changed();
}
}
else
{
int nbreCopies = rolesInClipboard.Count;
if (rolesInClipboard != null && nbreCopies > 0)
{
for (int j = 0; j <= nbreCopies - 1; j++)
{
RestoreMeasureForeground(rolesInClipboard[j]);
pasteValue(rolesInClipboard[j], rolesInClipboard[j].name, parent);
}
}
}
}
}
/// <summary>
/// Ajoute la valeur par défaut après avoir créer une role
/// </summary>
/// <param name="value">le parent de la role à créer</param>
/// <returns>la mesure créé</returns>
public Domain.Role addDefaultNode(Kernel.Domain.Role value = null)
{
Domain.Role r = AddNode(value);
return(r);
}
