private void treeView_MouseMove(object sender, MouseEventArgs e)
{
if (e.LeftButton == MouseButtonState.Pressed)
{
if (DropAdapter == null)
{
return;
}
if (!(e.Source is BaseTreeView))
{
return;
}
if (treeView.SelectedItem == null)
{
return;
}
TreeNavigationItem selectedTreeNavigationItem = treeView.SelectedItem as TreeNavigationItem;
if (!DropAdapter.DragStart(e, selectedTreeNavigationItem))
{
return;
}
TreeViewItem treeViewItem = GetTreeViewItemAt(e.GetPosition(treeView));
//_dragAdorner = new DragAdorner(treeViewItem, treeViewItem.DesiredSize, e.GetPosition(treeView));
DragDrop.DoDragDrop(treeView, treeView.SelectedItem, DragDropEffects.All);
//_dragAdorner.Detach();
}
}
protected override async Task <List <TreeNavigationItem> > DoLoadChildren(TreeNavigationItem parentTreeNavigationItem)
{
return(await Task.Run(() =>
{
return _service.GetChildren(MasterNavigationContext.CreateMasterNavigationContext(_masterNavigationItem), parentTreeNavigationItem);
}));
}
public static ExecutionEvent Create(TreeNavigationItem selectedTreeNavigationItem, TreeNavigationItem masterTreeNavigationItem)
{
return(new ExecutionEvent(new List <TreeNavigationItem>()
{
selectedTreeNavigationItem
}, masterTreeNavigationItem));
}
public void Drop(DragEventArgs e, TreeNavigationItem draggedTreeNavigationItem, TreeNavigationItem targetTreeNavigationItem)
{
IDropHandler activeDropHandler = null;
if (draggedTreeNavigationItem == null || targetTreeNavigationItem == null)
{
return;
}
if (draggedTreeNavigationItem.Id.Equals(targetTreeNavigationItem.Id))
{
return;
}
foreach (IDropHandler dropHandler in _dropHandlers)
{
if (dropHandler.IsActive(draggedTreeNavigationItem, targetTreeNavigationItem))
{
activeDropHandler = dropHandler;
break;
}
}
if (activeDropHandler != null)
{
activeDropHandler.Drop(draggedTreeNavigationItem, targetTreeNavigationItem);
}
}
protected virtual async Task <List <TreeNavigationItem> > DoLoadChildren(TreeNavigationItem parentTreeNavigationItem)
{
return(await Task.Run(() =>
{
return _service.GetChildren(NavigationContext.CreateNavigationContext(), parentTreeNavigationItem);
}));
}
public virtual void DragOver(DragEventArgs e, TreeNavigationItem draggedTreeNavigationItem, TreeNavigationItem targetTreeNavigationItem)
{
if (!ValidateDragAndDrop(_dragAndDropEqualityValidators, draggedTreeNavigationItem, targetTreeNavigationItem))
{
e.Effects = DragDropEffects.None;
return;
}
e.Effects = DragDropEffects.Move;
}
public GenerateLiquibaseWindowModelView(TreeNavigationItem selectedTreeNavigationItem)
: base("GenerateLiquibaseWindowModelView")
{
_generateService = ServiceActivator.Get <IGenerateLiquibaseService>();
_selectedTreeNavigationItem = selectedTreeNavigationItem;
LoadCommand = new RelayCommand(OnLoadCommand);
GenerateCommand = new RelayCommand(OnGenerateCommand, x => !IsThreadRunning);
CloseCommand = new RelayCommand(OnCloseCommand, x => !IsThreadRunning);
}
public UIElement GenerateUiControl(BaseDto dto, PropertyInfo propertyInfo, Grid grid, int rowIndex)
{
CreateLabel(propertyInfo, grid, rowIndex);
Grid referenceGrid = new Grid();
referenceGrid.ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(1, GridUnitType.Star)
});
referenceGrid.ColumnDefinitions.Add(new ColumnDefinition()
{
Width = GridLength.Auto
});
referenceGrid.ColumnDefinitions.Add(new ColumnDefinition()
{
Width = GridLength.Auto
});
Label referenceLabel = CreateReferenceLabel(dto, propertyInfo);
Button referenceButton = CreateButton("...", delegate
{
IReferenceEditor referenceEditor = CreateReferenceEditor(dto, propertyInfo); //(BaseReferenceEditor)Activator.CreateInstance(Type.GetType(editorAttribute.CompleteAssembly));
TreeNavigationItem selectedTreeNavigationItem = DialogUtils.OpenReferenceWindow(referenceEditor.GetProposals);
if (selectedTreeNavigationItem != null)
{
ReferenceString referenceString = new ReferenceString(selectedTreeNavigationItem.Id, selectedTreeNavigationItem.Name);
propertyInfo.SetValue(dto, referenceString);
referenceLabel.Content = referenceString.GetValue();
}
});
Image image = new Image();
image.Source = new BitmapImage(RemoveReferenceImage);
Button removeReferenceButton = CreateButton(image, delegate
{
propertyInfo.SetValue(dto, null);
referenceLabel.Content = string.Empty;
});
referenceGrid.Children.Add(referenceLabel);
referenceGrid.Children.Add(referenceButton);
referenceGrid.Children.Add(removeReferenceButton);
Grid.SetColumn(referenceLabel, 0);
Grid.SetColumn(referenceButton, 1);
Grid.SetColumn(removeReferenceButton, 2);
grid.Children.Add(referenceGrid);
Grid.SetRow(referenceGrid, rowIndex);
Grid.SetColumn(referenceGrid, 1);
return(referenceGrid);
}
public void Drop(TreeNavigationItem draggedTreeNavigationItem, TreeNavigationItem targetTreeNavigationItem)
{
Connection.GetInstance().StartTransaction();
IMoveAwareCRUDService moveAwareCRUDService = ServiceActivator.Get <IFolderCRUDService>();
moveAwareCRUDService.Move(draggedTreeNavigationItem.Id, targetTreeNavigationItem.Id);
Connection.GetInstance().EndTransaction();
Publisher.GetInstance().Publish(PublishEvent.CreateDeletionEvent(draggedTreeNavigationItem.Id, draggedTreeNavigationItem.GetParentId()));
Publisher.GetInstance().Publish(PublishEvent.CreateCreationEvent(draggedTreeNavigationItem.Id, targetTreeNavigationItem.GetParentId()));
}
private void treeView_Drop(object sender, DragEventArgs e)
{
if (DropAdapter == null)
{
return;
}
TreeNavigationItem targetTreeNavigationItem = GetTreeNavigationItemAt(e.GetPosition(treeView));
TreeNavigationItem draggedTreeNavigationItem = GetDataFromDragEventArgs(e);
DropAdapter.Drop(e, draggedTreeNavigationItem, targetTreeNavigationItem);
}
private List <TreeNavigationItem> CreateVirtualFolders(Guid compositeTypeId)
{
List <TreeNavigationItem> roots = new List <TreeNavigationItem>();
TreeNavigationItem presetRoot = new TreeNavigationItem(IdConstants.PRESET_FOLDER_ID, "Presets", NavigationType.FOLDER);
List <TreeNavigationItem> presets = GetChildrenToFolder(presetRoot.Id, compositeTypeId);
ExtendTreeNavigationItems(presets, presetRoot);
presetRoot.Children = new ObservableCollection <TreeNavigationItem>(presets);
roots.Add(presetRoot);
return(roots);
}
public async void LoadChildren(TreeNavigationItem parentTreeNavigationItem)
{
if (parentTreeNavigationItem == null)
{
return;
}
if (parentTreeNavigationItem.HasRemoteChildren)
{
parentTreeNavigationItem.HasRemoteChildren = false;
parentTreeNavigationItem.SetChildren(await DoLoadChildren(parentTreeNavigationItem));
}
}
private void treeView_DragOver(object sender, DragEventArgs e)
{
if (DropAdapter == null)
{
return;
}
TreeNavigationItem targetTreeNavigationItem = GetTreeNavigationItemAt(e.GetPosition(treeView));
TreeNavigationItem draggedTreeNavigationItem = GetDataFromDragEventArgs(e);
// _dragAdorner.UpdatePosition(e.GetPosition(treeView));
DropAdapter.DragOver(e, draggedTreeNavigationItem, targetTreeNavigationItem);
e.Handled = true;
}
public async void OnSelectionChange(object selection)
{
if (!(selection is TreeNavigationItem))
{
return;
}
_masterNavigationItem = (TreeNavigationItem)selection;
Roots = new ObservableCollection <TreeNavigationItem>();
Roots.Add(new TreeNavigationItem(Guid.Empty, ResourceUtils.GetMessage(MessageKeyConstants.LABEL_LOADING), NavigationType.FOLDER));
OnPropertyChanged(() => Roots);
Roots = new ObservableCollection <TreeNavigationItem>(await DoLoadRoots());
OnPropertyChanged(() => Roots);
}
protected virtual void ExtendTreeNavigationItems(List <TreeNavigationItem> treeNavigationItems, TreeNavigationItem parentTreeNavigationItem)
{
TreeNavigationItem loadingTreeNavigationItem = new TreeNavigationItem(Guid.Empty, "Loading...", NavigationType.FOLDER);
foreach (TreeNavigationItem treeNavigationItem in treeNavigationItems)
{
if (treeNavigationItem.HasRemoteChildren)
{
treeNavigationItem.Children.Add(loadingTreeNavigationItem);
}
if (parentTreeNavigationItem != null)
{
treeNavigationItem.Parent = parentTreeNavigationItem;
}
}
}
protected TreeNavigationItem Find(ObservableCollection <TreeNavigationItem> treeNavigationItems, Guid id)
{
foreach (TreeNavigationItem treeNavigationItem in treeNavigationItems)
{
if (id.Equals(treeNavigationItem.Id))
{
return(treeNavigationItem);
}
TreeNavigationItem foundTreeNavigationItem = Find(treeNavigationItem.Children, id);
if (foundTreeNavigationItem != null)
{
return(foundTreeNavigationItem);
}
}
return(null);
}
public TreeNavigationItem Reload(TreeNavigationItem treeNavigationItem)
{
TreeNavigationItem updatedTreeNavigationItem = null;
switch (treeNavigationItem.Type)
{
case NavigationType.PRESET:
updatedTreeNavigationItem = _presetNavigationRepository.FindSpecificPreset(treeNavigationItem.Id);
break;
case NavigationType.COMPOSITE_PRESET_ELEMENT:
updatedTreeNavigationItem = _compositePresetElementNavigationRepository.FindSpecificCompositePresetElement(treeNavigationItem.Id);
break;
}
return(updatedTreeNavigationItem);
}
private void DoUpdate(IList <TreeNavigationItem> children, TreeNavigationItem parentTreeNavigationItem, TreeNavigationItem originalTreeNavigationItem)
{
int indexOfUpdatedTreeNavigationItem = children.IndexOf(originalTreeNavigationItem);
children.RemoveAt(indexOfUpdatedTreeNavigationItem);
TreeNavigationItem updatedTreeNavigationItem = _service.Reload(originalTreeNavigationItem);
updatedTreeNavigationItem.Parent = parentTreeNavigationItem;
updatedTreeNavigationItem.HasRemoteChildren = originalTreeNavigationItem.HasRemoteChildren;
updatedTreeNavigationItem.Children = originalTreeNavigationItem.Children;
if (!updatedTreeNavigationItem.HasRemoteChildren && updatedTreeNavigationItem.Children.Count > 0)
{
updatedTreeNavigationItem.IsExpanded = true;
}
children.Insert(indexOfUpdatedTreeNavigationItem, updatedTreeNavigationItem);
}
protected virtual void OnFilterChangedCommand(object obj)
{
if (string.IsNullOrEmpty(obj.ToString()))
{
Proposals.Filter = null;
}
Proposals.Filter = x =>
{
TreeNavigationItem treeNavigationItem = (TreeNavigationItem)x;
if (treeNavigationItem == null)
{
return(false);
}
return(treeNavigationItem.Name.ToLower().Contains(obj.ToString().ToLower()));
};
}
public GenerateCodeTypeTreeNavigationItem GetTypeToGenerate(Guid owningTypeId)
{
TreeNavigationItem compositeTypeTreeNavigationItem = _compositeTypeNavigationRepository.FindSpecific(owningTypeId);
List <TreeNavigationItem> compositeTypeElementTreeNavigationItems = _compositeTypeElementNavigationRepository.FindChildren(owningTypeId);
GenerateCodeTypeTreeNavigationItem generateCodeTypeTreeNavigationItem = new GenerateCodeTypeTreeNavigationItem();
generateCodeTypeTreeNavigationItem.Name = compositeTypeTreeNavigationItem.Name;
List <GenerateCodeTypeElementTreeNavigationItem> generateCodeTypeElementTreeNavigationItems = new List <GenerateCodeTypeElementTreeNavigationItem>();
foreach (CompositeTypeElementTreeNavigationItem compositeTypeElementTreeNavigationItem in compositeTypeElementTreeNavigationItems)
{
generateCodeTypeTreeNavigationItem.Fields.Add(CreateGenerateCodeTypeElementTreeNavigationItem(compositeTypeElementTreeNavigationItem));
}
return(generateCodeTypeTreeNavigationItem);
}
protected virtual void OnCreate(PublishEvent publishEvent)
{
TreeNavigationItem parentTreeNavigationItem = Find(Roots, publishEvent.ParentObjectId.Value);
if (parentTreeNavigationItem == null)
{
return;
}
parentTreeNavigationItem.SetChildren(_service.GetChildren(NavigationContext.CreateNavigationContext(), parentTreeNavigationItem));
parentTreeNavigationItem.IsExpanded = true;
TreeNavigationItem affectedTreeNavigationItem = Find(Roots, publishEvent.AffectedObjectId);
if (affectedTreeNavigationItem != null)
{
affectedTreeNavigationItem.IsSelected = true;
}
}
public int Compare(object x, object y)
{
TreeNavigationItem firstTreeNavigationItem = x as TreeNavigationItem;
TreeNavigationItem secondTreeNavigationItem = y as TreeNavigationItem;
int compare = firstTreeNavigationItem.Type.CompareTo(secondTreeNavigationItem.Type);
if (compare == 0)
{
if (firstTreeNavigationItem.Name != null)
{
return(firstTreeNavigationItem.Name.CompareTo(secondTreeNavigationItem.Name));
}
return(firstTreeNavigationItem.ToString().CompareTo(secondTreeNavigationItem.ToString()));
}
return(compare);
}
public void Drop(TreeNavigationItem draggedTreeNavigationItem, TreeNavigationItem targetTreeNavigationItem)
{
string name = Guid.NewGuid().ToString().Substring(0, 7);
ICompositeTypeElementCRUDService compositeTypeElementCRUDService = ServiceActivator.Get <ICompositeTypeElementCRUDService>();
CompositeTypeElementDto compositeTypeElementDto = new CompositeTypeElementDto();
compositeTypeElementDto.Description = name;
compositeTypeElementDto.UniqueName = name;
compositeTypeElementDto.RuntimeId = Guid.NewGuid();
compositeTypeElementDto.ProjectId = targetTreeNavigationItem.ProjectId;
compositeTypeElementDto.OwningTypeId = targetTreeNavigationItem.Id;
compositeTypeElementDto.State = State.NEW;
compositeTypeElementDto.ElementTypeReference = new ReferenceString(draggedTreeNavigationItem.Id, draggedTreeNavigationItem.Name);
Connection.GetInstance().StartTransaction();
compositeTypeElementDto = compositeTypeElementCRUDService.Persist(compositeTypeElementDto);
Connection.GetInstance().EndTransaction();
Publisher.GetInstance().Publish(PublishEvent.CreateCreationEvent(compositeTypeElementDto.Id, compositeTypeElementDto.OwningTypeId));
}
protected override void OnCreate(PublishEvent publishEvent)
{
TreeNavigationItem parentTreeNavigationItem = Find(Roots, publishEvent.AffectedObjectId);
if (parentTreeNavigationItem == null)
{
return;
}
parentTreeNavigationItem.SetChildren(_service.GetChildren(MasterNavigationContext.CreateMasterNavigationContext(_masterNavigationItem), parentTreeNavigationItem));
parentTreeNavigationItem.IsExpanded = true;
TreeNavigationItem affectedTreeNavigationItem = Find(Roots, publishEvent.AffectedObjectId);
if (affectedTreeNavigationItem != null)
{
affectedTreeNavigationItem.IsSelected = true;
}
}
protected virtual void OnDelete(PublishEvent publishEvent)
{
TreeNavigationItem treeNavigationItem = Find(Roots, publishEvent.AffectedObjectId);
if (treeNavigationItem == null)
{
return;
}
if (treeNavigationItem.GetParentId() == null)
{
Roots.Remove(treeNavigationItem);
}
else
{
TreeNavigationItem parentTreeNavigationItem = treeNavigationItem.Parent;
parentTreeNavigationItem.Children.Remove(treeNavigationItem);
}
}
protected virtual void OnUpdate(PublishEvent publishEvent)
{
TreeNavigationItem treeNavigationItem = Find(Roots, publishEvent.AffectedObjectId);
if (treeNavigationItem == null)
{
return;
}
TreeNavigationItem parentTreeNavigationItem = treeNavigationItem.Parent;
if (parentTreeNavigationItem == null)
{
DoUpdate(Roots, parentTreeNavigationItem, treeNavigationItem);
}
else
{
DoUpdate(parentTreeNavigationItem.Children, parentTreeNavigationItem, treeNavigationItem);
}
}
protected override FolderDto CreateNewDto(ExecutionEvent executionEvent)
{
FolderDto folderDto = base.CreateNewDto(executionEvent);
folderDto.State = State.NEW;
TreeNavigationItem selectedTreeNavigationItem = executionEvent.GetFirstSelectedTreeNavigationItem();
if (NavigationType.PROJECT.Equals(selectedTreeNavigationItem.Type))
{
folderDto.ProjectId = selectedTreeNavigationItem.Id;
folderDto.ParentId = null;
}
else
{
folderDto.ProjectId = selectedTreeNavigationItem.ProjectId;
folderDto.ParentId = selectedTreeNavigationItem.Id;
}
return(folderDto);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value == null)
{
return(null);
}
if (!(value is TreeNavigationItem))
{
return(null);
}
TreeNavigationItem treeNavigationItem = value as TreeNavigationItem;
if (NavigationType.PRESET.Equals(treeNavigationItem.Type))
{
PresetTreeNavigationItem presetTreeNavigationItem = (PresetTreeNavigationItem)treeNavigationItem;
if (presetTreeNavigationItem.IsDefault)
{
return(new Uri("pack://application:,,,/Images/preset_default.png"));
}
}
return(NavigationTypeToImage.NAVIGATION_TYPE_TO_IMAGE[treeNavigationItem.Type]);
}
protected override void DoExecute(ExecutionEvent executionEvent)
{
try
{
ICollection <Guid> idsToRemove = TreeNavigationItem.CollectIds(executionEvent.GetSelectedTreeNavigationItems());
string questionMessage = GetQuestionMessage(idsToRemove.Count, executionEvent.GetFirstSelectedTreeNavigationItem().Name);
if (MessageBoxResult.No.Equals(MessageDialogUtils.Question(questionMessage, executionEvent.GetFirstSelectedTreeNavigationItem().Name)))
{
return;
}
foreach (Guid idToRemove in idsToRemove)
{
Delete(executionEvent, idToRemove);
OnSuccessful(executionEvent, idToRemove);
}
}
catch (ValidationException ex)
{
WindowsManager.GetInstance().ShowDialog <MessageWindow>(new MessageWindowModelView(ex.GetValidationResult()));
}
}
private void AllowMultiSelection(TreeView treeView)
{
if (IsSelectionChangeActiveProperty == null)
{
return;
}
treeView.SelectedItemChanged += (a, b) =>
{
TreeNavigationItem treeNavigationItem = /*treeView.SelectedItem*/ b.NewValue as TreeNavigationItem;
if (treeNavigationItem == null)
{
return;
}
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
object isSelectionChangeActive = IsSelectionChangeActiveProperty.GetValue(treeView, null);
IsSelectionChangeActiveProperty.SetValue(treeView, true, null);
SelectedItems.ForEach(item => item.IsSelected = true);
IsSelectionChangeActiveProperty.SetValue(treeView, isSelectionChangeActive, null);
}
else
{
SelectedItems.ForEach(item => item.IsSelected = (item == treeNavigationItem));
SelectedItems.Clear();
}
if (!SelectedItems.Contains(treeNavigationItem))
{
SelectedItems.Add(treeNavigationItem);
}
else
{
treeNavigationItem.IsSelected = false;
SelectedItems.Remove(treeNavigationItem);
}
};
}
