private TreeViewItemTool CreateTreeViewItem(CategoryTreeModel category)
{
TreeViewItemTool result = new TreeViewItemTool
{
Header = category.CategoryName,
Tag = category,
ContextMenu = new ContextMenu()
};
MenuItem itemAdd = new MenuItem {
Header = "Add Child Category"
};
MenuItem itemDelete = new MenuItem {
Header = "Delete Category"
};
itemAdd.Click += this.CategoryItem_Add;
itemDelete.Click += this.CategoryItem_Delete;
result.ContextMenu.Items.Add(itemAdd);
result.ContextMenu.Items.Add(itemDelete);
return(result);
}
private void Initialize()
{
var resulItems = (EventParser.ParseQuery(this, new ParseQueryEventArguments {
Title = "QueryTablesStack"
}));
bool haveTables = false;
foreach (TableMenuItem item in ((List <TableMenuItem>)resulItems).OrderBy(n => n.TableName))
{
TableModel table = item.TableModelObject;
if (this.excludeCanvasTables.Contains(table.TableName))
{
continue;
}
TreeViewItemTool tool = new TreeViewItemTool
{
Header = table.TableName,
Tag = table,
IsCheckBox = true,
IsChecked = included.Any(tn => tn.TableName == item.TableName)
};
this.uxTables.Items.Add(tool);
haveTables = true;
}
if (!haveTables)
{
MessageBox.Show("No tables found to select from.");
}
}
private bool SelectCategoryItem(TreeViewItemTool parent, int studyCategoryId)
{
if (parent.Tag != null)
{
CategoryTreeModel tagValue = parent.Tag.To <CategoryTreeModel>();
if (tagValue.StudyCategoryId == studyCategoryId)
{
parent.IsSelected = true;
return(true);
}
}
if (parent.Items == null)
{
return(false);
}
foreach (TreeViewItemTool child in parent.Items)
{
child.IsExpanded = this.SelectCategoryItem(child, studyCategoryId);
if (child.IsExpanded)
{
return(true);
}
}
return(false);
}
private void CategoryItem_Add(object sender, RoutedEventArgs e)
{
try
{
if (InputBox.ShowDialog("Category", "Name").IsFalse())
{
return;
}
;
int studyCategoryId = BiblesData.Database.InsertCategory(InputBox.Result, this.SelectedCategory.StudyCategoryId);
CategoryTreeModel treeModel = new CategoryTreeModel
{
CategoryName = InputBox.Result,
ParentStudyCategoryId = this.SelectedCategory.StudyCategoryId,
StudyCategoryId = studyCategoryId
};
TreeViewItemTool tool = this.CreateTreeViewItem(treeModel);
((TreeViewItemTool)this.uxCategoryTree.SelectedItem).Items.Add(tool);
((TreeViewItemTool)this.uxCategoryTree.SelectedItem).IsExpanded = true;
tool.IsSelected = true;
}
catch (Exception err)
{
ErrorLog.ShowError(err);
}
}
private void CategoryItem_Delete(object sender, RoutedEventArgs e)
{
try
{
if (MessageDisplay.Show($"Are you sure you would like to delete {this.SelectedCategory.CategoryName}", "Warning", MessageBoxButton.YesNo) != MessageBoxResult.Yes)
{
return;
}
BiblesData.Database.DeleteCategory(this.SelectedCategory.StudyCategoryId);
TreeViewItemTool category = this.uxCategoryTree.SelectedItem.To <TreeViewItemTool>();
if (category.Parent.GetType() == typeof(TreeViewItemTool))
{
TreeViewItemTool parent = category.Parent.To <TreeViewItemTool>();
parent.Items.Remove(category);
}
else
{
this.uxCategoryTree.Items.Remove(category);
}
}
catch (Exception err)
{
ErrorLog.ShowError(err);
}
}
public void Initialize()
{
ContextMenu categoryTreeContextMenu = new ContextMenu();
MenuItem treeAdd = new MenuItem {
Header = "Add Category"
};
treeAdd.Click += this.CategoryTree_Add;
categoryTreeContextMenu.Items.Add(treeAdd);
this.uxCategoryTree.ContextMenu = categoryTreeContextMenu;
List <CategoryTreeModel> categoriesList = BiblesData.Database.GetCategoryTree();
foreach (CategoryTreeModel category in categoriesList)
{
TreeViewItemTool categoryTreeItem = this.CreateTreeViewItem(category);
this.LoadCategoryChildren(category, categoryTreeItem);
this.uxCategoryTree.Items.Add(categoryTreeItem);
}
}
private void AddItem(object item)
{
Type itemType = item.GetType();
TreeViewItemTool headerItem = this.CreateHeader(itemType);
List <PropertyInfo> propertiesList = new List <PropertyInfo>(itemType.GetProperties());
List <ModelViewItem> itemsList = new List <ModelViewItem>();
double maxCaptionWidth = 100;
foreach (PropertyInfo inf in propertiesList)
{
double itemWidth = 0;
ModelViewItem viewItem = this.CreateField(headerItem.Tag.ToString(), item, inf, out itemWidth);
if (!viewItem.HasFieldInformation && this.LoadOnlyAttributedFields)
{
continue;
}
viewItem.ModelViewItemGotFocus += this.ModelItem_Focus;
itemsList.Add(viewItem);
if (itemWidth > maxCaptionWidth)
{
maxCaptionWidth = itemWidth;
}
}
int itemIndex = 0;
foreach (ModelViewItem modelItem in itemsList.OrderBy(i => i.Sort))
{
modelItem.CaptionWidth = maxCaptionWidth;
string itemKey = $"{headerItem.Tag}:{modelItem.PropertyName}";
itemsDesiredIndexDic.Add(itemKey, itemIndex);
this.CreateVisibilityMenuItem(modelItem, itemKey.ToString());
itemIndex++;
if (modelItem.Visibility != Visibility.Visible)
{
this.hidenItemsDict.Add(itemKey, modelItem.PropertyInfo);
continue;
}
headerItem.Items.Add(modelItem);
}
base.Items.Add(headerItem);
}
private TreeViewItemTool CreateTreeItem(ReportCategoryModel category)
{
TreeViewItemTool result = new TreeViewItemTool {
Header = category.CategoryName, Tag = category.CategoryId
};
return(result);
}
private TreeViewItemTool BuildTree(long categoryId, TreeViewItemTool parentItem, List <ReportCategoryModel> categories)
{
foreach (ReportCategoryModel category in categories.Where(pc => pc.ParentCategoryId == categoryId))
{
parentItem.Items.Add(this.BuildTree(category.CategoryId, this.CreateTreeItem(category), categories));
}
return(parentItem);
}
private TreeViewItemTool CreateTreeItem(ReportCategoryModel category)
{
TreeViewItemTool result = new TreeViewItemTool {
Header = category.CategoryName, Tag = category.CategoryId
};
result.Selected += this.TreeViewItemSelection_Changed;
return(result);
}
private void LoadCategoryChildren(CategoryTreeModel category, TreeViewItemTool categoryTreeItem)
{
foreach (CategoryTreeModel childCategory in category.ChildCategories)
{
TreeViewItemTool childTreeItem = this.CreateTreeViewItem(childCategory);
this.LoadCategoryChildren(childCategory, childTreeItem);
categoryTreeItem.Items.Add(childTreeItem);
}
}
private async void ConnectToGitHub()
{
await Task.Run(() =>
{
this.Dispatcher.Invoke(() =>
{
this.uxMessage.Content = "Connecting with server";
});
this.gitHubClient = new GitHubClient(new ProductHeaderValue("fromtheword"));
this.gitHubClient.SetRequestTimeout(new TimeSpan(0, 5, 0));
Task <Repository> repository = this.gitHubClient.Repository.Get("fromtheword", "Bibles-Application");
long reposirotyId = repository.Result.Id;
IReadOnlyList <RepositoryContent> allContent = this.gitHubClient.Repository.Content.GetAllContents(reposirotyId).Result;
foreach (RepositoryContent content in allContent.Where(t => t.Type == ContentType.Dir))
{
if (!this.directoryNames.Contains(content.Name))
{
continue;
}
TreeViewItemTool treeItem = null;
this.Dispatcher.Invoke(() =>
{
treeItem = new TreeViewItemTool {
Header = content.Name, ResourceImageName = "Folder"
};
this.uxDownloadTree.Items.Add(treeItem);
});
this.LoadDirectoryContent(content, treeItem, reposirotyId);
}
RepositoryContent biblesRepository = allContent.First(n => n.Name == "Bibles.msi");
this.Dispatcher.Invoke(() =>
{
TreeViewItemTool treeItem = new TreeViewItemTool {
Header = "Bibles Install", IsCheckBox = true, Tag = biblesRepository
};
this.uxDownloadTree.Items.Add(treeItem);
});
});
}
private void LoadTreeItems(string verseKey)
{
ModelsLink verseTree = BiblesData.Database.GetLinkTree(verseKey);
TreeViewItemTool item = new TreeViewItemTool
{
Header = GlobalStaticData.Intance.GetKeyDescription(verseTree.BibleVerseKey),
Tag = verseTree.BibleVerseKey
};
this.uxLinkTree.Items.Add(item);
this.LoadTreeItems(item, verseTree);
}
public void IsReadOnly(int parentIndex, string propertyName, bool isReadOnly)
{
TreeViewItemTool parent = (TreeViewItemTool)base.Items[parentIndex];
foreach (ModelViewItem item in parent.Items)
{
if (item.PropertyName != propertyName)
{
continue;
}
item.IsReadOnly = isReadOnly;
break;
}
}
private void DeleteCategory_Cliked(object sender, System.Windows.RoutedEventArgs e)
{
if (this.SelectedCategory == null)
{
MessageBox.Show("Please Select a Category.");
return;
}
try
{
long categoryId = this.SelectedCategory.Tag.ToInt64();
ReportTablesRepository repo = new ReportTablesRepository();
if (repo.CategoryHaveReports(categoryId))
{
throw new ApplicationException("Cannot delete Category while reports are attached.");
}
string message = $"Are you sure that you want to delete '{this.SelectedCategory.Header}'?";
MessageBoxResult boxResult = MessageBox.Show(message, "Delete", MessageBoxButton.YesNo);
if (boxResult != MessageBoxResult.Yes)
{
return;
}
repo.DeleteCategory(categoryId);
if (this.SelectedCategory.Parent.GetType() == typeof(TreeViewItemTool))
{
TreeViewItemTool parent = this.SelectedCategory.Parent as TreeViewItemTool;
parent.Items.Remove(this.SelectedCategory);
}
else
{
this.uxCategoryTree.Items.Remove(this.SelectedCategory);
}
}
catch (Exception err)
{
MessageBox.Show(err.InnerExceptionMessage());
}
}
public void SetValue(int parentIndex, string propertyName, object value)
{
TreeViewItemTool parent = (TreeViewItemTool)base.Items[parentIndex];
foreach (ModelViewItem item in parent.Items)
{
if (item.PropertyName != propertyName)
{
continue;
}
PropertyInfo inf = item.BindingExpression.DataItem.GetType().GetProperty(item.BindingExpression.ParentBinding.Path.Path);
inf.SetValue(item.BindingExpression.DataItem, value, null);
break;
}
}
private void OnDelete_Clicked(object sender, System.Windows.RoutedEventArgs e)
{
if (this.uxLinkTree.SelectedItem == null)
{
MessageDisplay.Show("Please select a Link");
return;
}
try
{
string verseKey = ((TreeViewItemTool)this.uxLinkTree.SelectedItem).Tag.ParseToString();
if (!this.modelsLinksDictionary.ContainsKey(verseKey))
{
MessageDisplay.Show("Cannot delete topmost parent item.");
return;
}
string message = $"{TranslationDictionary.Translate("Are you sure you would like to delete?")} {GlobalStaticData.Intance.GetKeyDescription(verseKey)}";
if (MessageDisplay.Show(message, "Warning", MessageBoxButton.YesNo) != MessageBoxResult.Yes)
{
return;
}
ModelsLink deleteItem = this.modelsLinksDictionary[verseKey];
BiblesData.Database.DeleteLink(deleteItem.LinkKeyId);
this.modelsLinksDictionary.Remove(verseKey);
TreeViewItemTool deleteTreeItemParent = ((TreeViewItemTool)this.uxLinkTree.SelectedItem).Parent.To <TreeViewItemTool>();
deleteTreeItemParent.Items.Remove(this.uxLinkTree.SelectedItem);
this.deletedLinksList.Add(verseKey);
}
catch (Exception err)
{
ErrorLog.ShowError(err);
}
}
private void LoadTreeItems(TreeViewItemTool parent, ModelsLink verseTree)
{
foreach (ModelsLink child in verseTree.BibleVerseChildLinks)
{
TreeViewItemTool item = new TreeViewItemTool
{
Header = GlobalStaticData.Intance.GetKeyDescription(child.BibleVerseKey),
Tag = child.BibleVerseKey
};
parent.Items.Add(item);
this.modelsLinksDictionary.Add(child.BibleVerseKey, child);
if (child.BibleVerseChildLinks.Count > 0)
{
this.LoadTreeItems(item, child);
}
}
}
private void InitializeMainTable(long masterReportId)
{
List <DataItemModel> systemTables = Integrity.GetSystemTables();
DataSourceRepository repo = new DataSourceRepository();
DataSourceMasterModel savedModel = repo.GetDataSourceMasterByPrimaryKey(masterReportId);
Dictionary <string, DataSourceTableModel> selectedTables = repo
.GetDataSourceTableByForeignKeyMasterReport_Id(masterReportId)
.ToDictionary(d => d.TableName);
this.MainTable = savedModel == null ? new DataSourceMasterModel {
MasterReport_Id = masterReportId
} : savedModel;
this.MainTable.SourceTables = systemTables.ToArray();
this.uxMainTable.Items.Add(this.MainTable);
this.uxMainTable[0, 0].IsReadOnly = savedModel != null;
foreach (DataItemModel table in systemTables)
{
if (table.DisplayValue == this.MainTable.MainTableName)
{
continue;
}
TreeViewItemTool tableItem = new TreeViewItemTool
{
Header = table.DisplayValue,
IsCheckBox = true,
IsChecked = selectedTables.ContainsKey(table.DisplayValue) ? selectedTables[table.DisplayValue].IsAvailable : false
};
this.uxOtherTables.Items.Add(tableItem);
this.treeTableItems.Add(tableItem);
}
}
private List <RepositoryContent> GetSelectedRepositories(TreeViewItemTool parent)
{
List <RepositoryContent> result = new List <RepositoryContent>();
foreach (TreeViewItemTool item in parent.Items)
{
if (!item.IsCheckBox)
{
result.AddRange(this.GetSelectedRepositories(item));
continue;
}
if (item.IsChecked)
{
result.Add(item.Tag.To <RepositoryContent>());
}
}
return(result);
}
private void LoadDirectoryContent(RepositoryContent parentContent, TreeViewItemTool parentTreeItem, long repositoryId)
{
IReadOnlyList <RepositoryContent> repositoryContentList = this.gitHubClient.Repository.Content.GetAllContents(repositoryId, parentContent.Path).Result;
foreach (RepositoryContent content in repositoryContentList)
{
TreeViewItemTool treeItem = null;
this.Dispatcher.Invoke(() =>
{
treeItem = new TreeViewItemTool {
Header = content.Name, IsCheckBox = (content.Type != ContentType.Dir)
};
});
if (content.Type == ContentType.Dir)
{
this.Dispatcher.Invoke(() =>
{
treeItem.ResourceImageName = "Folder";
});
this.LoadDirectoryContent(content, treeItem, repositoryId);
}
else
{
this.Dispatcher.Invoke(() =>
{
treeItem.Tag = content;
});
}
this.Dispatcher.Invoke(() =>
{
parentTreeItem.Items.Add(treeItem);
});
}
}
private void VisibilityItem_Checked(object sender, RoutedEventArgs e)
{ // We need to do this as the Visibility set leaves a gap as big as the one in my teeth
MenuItem item = (MenuItem)sender;
if (item.IsChecked)
{
string itemKey = item.Tag.ToString();
string[] itemKeysArray = itemKey.Split(new char[] { ':' });
PropertyInfo propertyItem = this.hidenItemsDict[itemKey];
int desiredIndex = itemsDesiredIndexDic[itemKey];
int parentIndex = 0;
TreeViewItemTool parent = this.FindParentItem(itemKeysArray[0], out parentIndex);
ModelViewItem modelItem = new ModelViewItem(parent.Tag.ToString(), this.Items[parentIndex], propertyItem);
if (parent.Items.Count == 0)
{
this.hidenItemsDict.Remove(itemKey);
parent.Items.Add(modelItem);
return;
}
modelItem.ModelViewItemGotFocus += this.ModelItem_Focus;
string checkItemKey = $"{((ModelViewItem)parent.Items[0]).ParentObjectTypeName}:{((ModelViewItem)parent.Items[0]).PropertyName}";
int itemsCollectionIndex = itemsDesiredIndexDic[checkItemKey];
int insertAt = 0;
while (itemsCollectionIndex < desiredIndex)
{
insertAt++;
if (insertAt >= parent.Items.Count)
{
break;
}
checkItemKey = $"{((ModelViewItem)parent.Items[insertAt]).ParentObjectTypeName}:{((ModelViewItem)parent.Items[insertAt]).PropertyName}";
itemsCollectionIndex = itemsDesiredIndexDic[checkItemKey];
}
modelItem.Visibility = Visibility.Visible;
this.hidenItemsDict.Remove(itemKey);
parent.Items.Insert(insertAt, modelItem);
}
else
{
int parentIndex = -1;
string itemKey = item.Tag.ToString();
ModelViewItem propertyItem = this.FindItem(itemKey, out parentIndex);
propertyItem.ModelViewItemGotFocus -= this.ModelItem_Focus;
TreeViewItemTool parent = ((TreeViewItemTool)base.Items[parentIndex]);
this.hidenItemsDict.Add(itemKey, propertyItem.PropertyInfo);
parent.Items.Remove(propertyItem);
}
this.RefreshcaptionWidths();
}
