/// <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); }