public TagsManagerMainView(ITagsManager tagsManager, TagsManagerMainViewModel model,
IIdeaManager ideaManager, IRelationManager relationManager, IBlockManager blockManager, IMaterialManager materialManager)
{
_relationManager = relationManager;
_blockManager = blockManager;
var db = new AllDb()
{
RelationManager = _relationManager,
IdeaManager = ideaManager,
BlockManager = _blockManager,
TagsManager = tagsManager,
MaterialManager = materialManager
};
InitializeComponent();
_tagHelper = new TagTreeHelper(treeList, db);
_tagHelper.ReloadTree();
model.NodeAdded += dto =>
{
dto.AddNodeToTree(treeList);
treeList.CurrentItem = dto;
};
model.NodeAnnihilated += dto => dto.AnnihilateNode(treeList);
model.MaterialUpdate += dto => dto.UpdateMaterialInTree(treeList);
Loaded += (sender, args) =>
{
DataContext = model;
treeList.View.ValidateCell += (o, e) =>
{
var wrong = Path.GetInvalidFileNameChars();
if (e.Value.ToString().Any(wrong.Contains))
e.IsValid = false;
};
treeList.View.PreviewKeyDown += (o, eventArgs) =>
{
if (eventArgs.Key == Key.Enter || eventArgs.Key == Key.Return)
{
eventArgs.Handled = true;
treeList.View.CloseEditor();
RenameCurrent();
}
};
treeList.View.ShownEditor += ViewOnShownEditor;
model.RenameTag += dto => Dispatcher.Invoke(() =>
{
treeList.View.AllowEditing = true;
treeList.View.ShowEditor(true);
}, DispatcherPriority.Background);
model.Refresh += () => Dispatcher.Invoke(() => _tagHelper.ReloadTree(),
DispatcherPriority.Background);
};
}
public static TreeItemDto FromBase(Relation relation, AllDb db)
{
return new RelationDto(db)
{
Id = relation.Id,
Caption = GetCaption(relation),
IsClosed = true
};
}
public static TreeItemDto FromBase(Idea idea, AllDb db)
{
return new IdeaDto(db)
{
Id = idea.Id,
Caption = idea.Caption,
IsClosed = true
};
}
public static TreeItemDto FromBase(Material m, AllDb db)
{
return new MaterialDto(db)
{
Caption = m.Name,
IsClosed = true,
Id = m.Id
};
}
public TagSelectorView(ITagsManager tagsManager, IIdeaManager ideaManager,
IBlockManager blockManager, IRelationManager relationManager, ISettingsService settingsService, IMaterialManager materialManager)
{
_settingsService = settingsService;
var allDb = new AllDb
{
RelationManager = relationManager,
BlockManager = blockManager,
IdeaManager = ideaManager,
TagsManager = tagsManager,
MaterialManager = materialManager
};
InitializeComponent();
Loaded += (sender, args) =>
{
var model = RegionContext.GetObservableContext(this).Value as ISelectTagRegionView;
if (model != null)
{
var selectItem = new DelegateCommand<Guid>(id =>
{
if (model.TargetType == typeof(Tag))
_settingsService.AddRecentTag(id);
if (model.TargetType == typeof(Idea))
_settingsService.AddRecentIdea(id);
if (model.TargetType == typeof(Block))
_settingsService.AddRecentBlock(id);
if (model.TargetType == typeof(Comment))
_settingsService.AddRecentComment(id);
if (model.TargetType == typeof(Guidable))
_settingsService.AddRecentGuidable(id);
model.OkCommand.Execute(id);
});
var items = model.TargetType == typeof (Tag)
? _settingsService.GetRecentTags()
: model.TargetType == typeof (Idea)
? _settingsService.GetRecentIdeas()
: model.TargetType == typeof (Block)
? _settingsService.GetRecentBlocks()
: model.TargetType == typeof (Guidable)
? _settingsService.GetRecentGuidables()
: _settingsService.GetRecentComments();
var recent = new BarSubItem() {CategoryName = "BuiltInMenus", Content = "Recent"};
MainMenu.Items.Add(recent);
foreach (var item in items.OrderByDescending(i => i.Order))
recent.Items.Add(new BarButtonItem{Content = item.Name,
CommandParameter = item.Id, Command = selectItem});
}
DataContext = model;
};
_tagHelper = new TagTreeHelper(treeList, allDb);
_tagHelper.ReloadTree();
}
public static TreeItemDto FromBase(Comment comment, AllDb db)
{
return new CommentDto(db)
{
Id = comment.Id,
Caption = comment.Caption,
IsClosed = true,
_targetId = comment.Target.Id
};
}
public static TreeItemDto FromBase(Reference r, AllDb db)
{
return new ReferenceDto(db)
{
Caption = r.FirstBlock.Caption,
FirstBlockId = r.FirstBlockId,
SecondBlockId = r.SecondBlockId,
IsClosed = true,
Id = r.FirstBlockId
};
}
public static TreeItemDto FromBase(Tag tag, AllDb db)
{
return new TagDto(db)
{
Caption = tag.Caption,
Id = tag.Id,
MyIdea = tag.MyIdeaId,
Parent = tag.ParentId,
IsClosed = true
};
}
public CommentDto(AllDb allDb)
{
_db = allDb;
}
public TagTreeHelper(TreeListControl treeListControl, AllDb db)
{
_treeListControl = treeListControl;
_db = db;
}
private ReferenceDto(AllDb db)
{
_db = db;
}
public RelationDto(AllDb db)
{
_db = db;
}
public TagsManagerMainViewModel(ITagsManager tagsManager, IBlockManager blockManager,
EventAggregator eventAggregator, IReferenceManager referenceManager, IRelationManager relationManager,
IIdeaManager ideaManager, ISharedService shared, IMaterialManager materialManager, IParticlesManager particlesManager)
{
_eventAggregator = eventAggregator;
_shared = shared;
_db = new AllDb()
{
TagsManager = tagsManager,
RelationManager = relationManager,
IdeaManager = ideaManager,
BlockManager = blockManager,
MaterialManager = materialManager,
ParticlesManager = particlesManager
};
_eventAggregator.GetEvent<BlockAddedEvent>().Subscribe(guid =>
{
var block = _db.BlockManager.GetBlockById(guid);
if (block is Idea)
{
var ideaDto = IdeaDto.FromBase(block as Idea, _db);
OnNodeAdded(ideaDto);
}
if (block is Relation)
{
var relDto = RelationDto.FromBase(block as Relation, _db);
OnNodeAdded(relDto);
}
if (block is Comment)
{
var commDto = CommentDto.FromBase(block as Comment, _db);
OnNodeAdded(commDto);
}
});
_eventAggregator.GetEvent<DatabaseImportedEvent>().Subscribe(s => OnRefresh());
_eventAggregator.GetEvent<MaterialUpdatedEvent>().Subscribe(guid =>
{
var mat = _db.MaterialManager.GetMaterialById(guid);
var matDto = MaterialDto.FromBase(mat, _db);
OnMaterialUpdate(matDto as MaterialDto);
});
NewTagCommand = new DelegateCommand<TreeItemDto>((dto) =>
{
if (dto == null || dto is TagDto)
{
var added = _db.TagsManager.AddTag(dto == null ? null : (Guid?) dto.Id, "New tag");
var addedDto = TagDto.FromBase(added, _db);
OnNodeAdded(addedDto);
OnRenameTag(addedDto);
}
});
NewIdeaCommand = new DelegateCommand<TreeItemDto>(dto =>
{
/*var added = _ideaManager.CreateIdea("New idea");
var addedDto = _map.Map<IdeaDto>(added);
OnNodeAdded(addedDto);
OnRenameTag(addedDto);*/
});
AddReferenceCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto || dto is RelationDto)
{
var dlgVm = new CreateReferenceDlgViewModel(_db.BlockManager, dto);
if (shared.SelectedParticle != Guid.Empty)
{
var pis = _db.ParticlesManager.GetParticleInplacesForParticle(shared.SelectedParticle);
if (pis != null && pis.Any())
{
var block = _db.BlockManager.GetBlockById(pis.First().BlockId) as Idea;
if (block != null)
dlgVm.Block2 = new NamedGuid() {Caption = block.Caption, Uid = block.Id};
}
}
var dlg = new CreateReferenceDlg(dlgVm);
var res = dlg.ShowDialog();
if (res.HasValue && res.Value)
{
if (dlgVm.IsTo || dlgVm.IsBoth)
{
var refer = referenceManager.CreateReference(dlgVm.Block1.Uid, dlgVm.Block2.Uid);
OnNodeAdded(ReferenceDto.FromBase(refer, _db));
}
if (dlgVm.IsFrom || dlgVm.IsBoth)
{
var refer = referenceManager.CreateReference(dlgVm.Block2.Uid, dlgVm.Block1.Uid);
OnNodeAdded(ReferenceDto.FromBase(refer, _db));
}
}
}
});
ClearCommand = new DelegateCommand(() =>
{
tagsManager.DeleteAllTAgs();
OnRefresh();
});
OpenIdeaCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto)
Interfaces.CompositeCommands.OpenBlockCommand.Execute(dto.Id);
if (dto is MaterialDto)
Interfaces.CompositeCommands.OpenSourceCommand.Execute(dto.Id);
});
RenameCommand = new DelegateCommand<TreeItemDto>(OnRenameTag);
AddCurrentMaterialCommand = new DelegateCommand<TagDto>(dto =>
{
if (_shared.CurrentMaterial.HasValue)
{
_db.TagsManager.ApplyTagToMaterial(_shared.CurrentMaterial.Value, dto.Id);
var m = _db.MaterialManager.GetMaterialById(_shared.CurrentMaterial.Value);
var addedDto = MaterialDto.FromBase(m, _db);
OnNodeAdded(addedDto);
}
});
DeleteCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto)
{
_db.IdeaManager.DeleteIdea((dto as IdeaDto).Id);
NodeAnnihilated(dto);
}
});
}
public MaterialDto(AllDb db)
{
_db = db;
}
public IdeaDto(AllDb db)
{
_db = db;
}
public TagDto(AllDb db)
{
_db = db;
}
