public bool ShouldFilterType(BookmarkNode value)
{
bool none = filters == BookmarkFilters.None;
bool all = filters == BookmarkFilters.All;
if (none)
{
return(false);
}
else if (all)
{
return(true);
}
else
{
bool recentSearch = filters.HasFlag(BookmarkFilters.RecentSearch);
bool querySearch = filters.HasFlag(BookmarkFilters.QuerySearch);
bool taggedSearch = filters.HasFlag(BookmarkFilters.TaggedSearch);
bool library = filters.HasFlag(BookmarkFilters.Library);
bool details = filters.HasFlag(BookmarkFilters.Details);
bool download = filters.HasFlag(BookmarkFilters.Download);
return((recentSearch && value.Value.StartsWith("recent:", StringComparison.OrdinalIgnoreCase)) ||
(querySearch && value.Value.StartsWith("search:", StringComparison.OrdinalIgnoreCase)) ||
(taggedSearch && value.Value.StartsWith("tagged:", StringComparison.OrdinalIgnoreCase)) ||
(library && value.Value.StartsWith("library:", StringComparison.OrdinalIgnoreCase)) ||
(details && value.Value.StartsWith("details:", StringComparison.OrdinalIgnoreCase)) ||
(download && value.Value.StartsWith("download:", StringComparison.OrdinalIgnoreCase)));
}
}
private void CreateDocumentMap(Document document)
{
// Create a collection of 'Page and Brick' pairs.
BrickPagePairCollection pairs = new BrickPagePairCollection();
// Create an enumerator of all document bricks.
DocumentBrickEnumerator en = new DocumentBrickEnumerator(document);
// Add the 'Brick-Page' pairs for all document bricks.
while (en.MoveNext())
{
pairs.Add(BrickPagePair.Create(en.Brick, en.Page));
}
// Add bookmarks for all pairs to the document's map.
foreach (BrickPagePair pair in pairs)
{
Page page = document.Pages[pair.PageIndex];
Brick brick = page.GetBrickByIndices(pair.BrickIndices) as Brick;
string BrickText = ((TextBrick)brick).Text;
BookmarkNode mapNode = new BookmarkNode(BrickText, brick, page);
document.BookmarkNodes.Add(mapNode);
}
}
public bool ShouldFilterText(BookmarkNode value)
{
string searchFilter = text;
return(value.Text.IndexOf(searchFilter, StringComparison.InvariantCultureIgnoreCase) >= 0 ||
value.Path.IndexOf(searchFilter, StringComparison.InvariantCultureIgnoreCase) >= 0);
}
protected override EmployeeThumbnail FillNode(EmployeeThumbnail parent, BookmarkNode bookmarkNode, string navigationScript)
{
var imageBrick = bookmarkNode.Brick as ImageBrick;
if (imageBrick == null && !parent.IsRoot)
{
return(null);
}
var result = new EmployeeThumbnail();
if (imageBrick != null)
{
string fileName = bookmarkNode.Text + ".png";
string filePath = HttpContext.Current.Server.MapPath("~/App_Data/Thumbnails/" + fileName);
if (!Directory.Exists(Path.GetDirectoryName(filePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
}
if (!File.Exists(filePath))
{
imageBrick.Image.Save(filePath, ImageFormat.Png);
}
result.ImageFileName = fileName;
result.Text = bookmarkNode.Text;
result.NavigationScript = navigationScript;
result.Width = Unit.Pixel(imageBrick.Image.Width / 2);
result.Height = Unit.Pixel(imageBrick.Image.Height / 2);
result.BorderColor = imageBrick.BorderColor;
result.BorderWidth = Unit.Pixel((int)imageBrick.BorderWidth);
}
parent.Items.Add(result);
return(result);
}
private int IsNodeIncluded(ArrayList bookmarklist, BookmarkNode bookmarkNode)
{
foreach (BookMarkList item in bookmarklist)
{
if (item.Name == bookmarkNode.Text)
{
return(bookmarklist.IndexOf(item));
}
}
return(-1);
}
private void AddNode(BookmarkNode node, TreeListNode parentNode)
{
TreeListNode treeNode = treeList1.AppendNode(new object[] { node.Text }, parentNode);
treeNode.Tag = node;
foreach (BookmarkNode childNode in node.Nodes)
{
AddNode(childNode, treeNode);
}
}
private void DisplayCurrentBrick(BookmarkNode node)
{
if (node != null)
{
if (prevNode != null)
{
printControl1.PrintingSystem.UnmarkBrick(prevNode.Brick, prevNode.Page);
}
printControl1.ShowBrick(node.Brick, node.Page);
printControl1.PrintingSystem.MarkBrick(node.Brick, node.Page);
prevNode = node;
}
}
private int GetIndex(BookmarkNode n)
{
if (n != null)
{
if (n.Nodes.Count == 0)
{
return(n.PageIndex);
}
else
{
return(GetIndex(n.Nodes[n.Nodes.Count - 1]));
}
}
return(-1);
}
/// <inheritdoc />
public List <TreeViewNode> ValueFor(string directory)
{
if (directory == null)
{
throw new ArgumentNullException(nameof(directory));
}
var nodes = new List <TreeViewNode>();
var tldGitFolders = Directory.GetDirectories(directory, ".git", SearchOption.TopDirectoryOnly);
if (tldGitFolders.Any())
{
var bookmarkNode = new BookmarkNode
{
Name = new DirectoryInfo(directory).Name,
Path = directory,
IsLeaf = true
};
nodes.Add(bookmarkNode);
}
if (Directory.GetDirectories(directory, ".git", SearchOption.AllDirectories).Length.Equals(tldGitFolders.Length))
{
return(nodes);
}
var folderNode = new BookmarkFolderNode
{
Name = new DirectoryInfo(directory).Name,
IsLeaf = false
};
var subDirectories = Directory.GetDirectories(directory);
foreach (var subDirectory in subDirectories)
{
folderNode.Children.AddRange(ValueFor(subDirectory));
}
nodes.Add(folderNode);
return(nodes);
}
public TreeNode AddItem(string path, BookmarkNode item)
{
TreeNode contentNode = new TreeNode();
contentNode.Text = item.Text;
contentNode.Tag = new AddBookmarkItemTask(path, item);
TreeNodeCollection parentNodes = null;
if (path.Contains('/') && !path.StartsWith("/", StringComparison.OrdinalIgnoreCase))
{
TreeNode parentNode = AddFolder(path, true);
parentNodes = parentNode.Nodes;
}
else
{
parentNodes = treeView.Nodes;
}
ContextMenu contentNodeContextMenu = new ContextMenu();
contentNodeContextMenu.Popup += ItemContentNodeContextMenu_Popup;
contentNodeContextMenu.Tag = contentNode;
contentNode.ContextMenu = contentNodeContextMenu;
parentNodes.Add(contentNode);
string[] tokens = item.Value.Split(new char[] { ':' });
int galleryId;
if (QueryParser.ParseDetailsSearch(tokens, out galleryId) ||
QueryParser.ParseDownloadSearch(tokens, out galleryId))
{
WebBrowserToolTip.SetToolTip(contentNode, galleryId);
}
treeView.SelectedNode = contentNode;
return(contentNode);
}
public void Outline_DoesNotError(string exeFileName)
{
HtmlToPdfRunner runner = new HtmlToPdfRunner(exeFileName);
string html = @"<!DOCTYPE html>
<html>
<head>
</head>
<body>
<h1>Test Page</h1>
</body>
</html>";
using (TempHtmlFile htmlFile = new TempHtmlFile(html))
{
using (TempPdfFile pdfFile = new TempPdfFile(this.TestContext))
{
string commandLine = $"--outline \"{htmlFile.FilePath}\" \"{pdfFile.FilePath}\"";
HtmlToPdfRunResult result = runner.Run(commandLine);
Assert.AreEqual(0, result.ExitCode, result.Output);
using (var pdfDocument = UglyToad.PdfPig.PdfDocument.Open(pdfFile.FilePath))
{
Assert.AreEqual(1, pdfDocument.NumberOfPages);
Page page = pdfDocument.GetPage(1);
bool containsBookmarks = pdfDocument.TryGetBookmarks(out Bookmarks bookmarks);
Assert.IsTrue(containsBookmarks);
Assert.AreEqual(1, bookmarks.Roots.Count);
BookmarkNode rootBookmark = bookmarks.Roots[0];
Assert.AreEqual("Test Page", rootBookmark.Title);
Assert.AreEqual(0, rootBookmark.Level);
Assert.AreEqual(true, rootBookmark.IsLeaf);
Assert.AreEqual(0, rootBookmark.Children.Count);
Assert.AreEqual("Test Page", page.Text);
}
}
}
}
public bool ShouldFilter(BookmarkNode value)
{
return(ShouldFilterText(value) &&
ShouldFilterType(value));
}
public BookMarkList(BookmarkNode node_Renamed, int page_Renamed, string name_Renamed)
{
this.node_Renamed = node_Renamed;
this.page_Renamed = page_Renamed;
this.name_Renamed = name_Renamed;
}
private void treeList1_FocusedNodeChanged(object sender, DevExpress.XtraTreeList.FocusedNodeChangedEventArgs e)
{
BookmarkNode node = e.Node.Tag as BookmarkNode;
DisplayCurrentBrick(node);
}
public record BkItem(BookmarkTreeNode TreeNode, BookmarkNode Node);
internal void ParseScript(string file)
{
this.treeViewOutline.BeginUpdate();
this._model = new TreeModel();
this._outline = ScriptOutline.CreateFromScript(file);
if (this._outline != null)
{
BookmarkNode rootNode = new BookmarkNode(this._outline.Class, BookmarkNode.Categories.Class, null);
this._model.Nodes.Add(rootNode);
try
{
BookmarkNode replicationNode = new BookmarkNode("Replication", BookmarkNode.Categories.Replication, this._outline.Replication);
rootNode.Nodes.Add(replicationNode);
BookmarkNode defaultPropertiesNode = new BookmarkNode("Default Properties", BookmarkNode.Categories.DefaultProperties, this._outline.DefaultProperties);
rootNode.Nodes.Add(defaultPropertiesNode);
BookmarkNode varsNode = new BookmarkNode("Variables", BookmarkNode.Categories.Group, null);
rootNode.Nodes.Add(varsNode);
foreach (ScriptOutline.VarDesc scriptVar in this._outline.Variables)
{
BookmarkNode varNode = new BookmarkNode(scriptVar.Identifier, BookmarkNode.Categories.Variable, scriptVar);
varsNode.Nodes.Add(varNode);
}
BookmarkNode stateNode = null;
Dictionary<string, BookmarkNode> states = new Dictionary<string, BookmarkNode>();
BookmarkNode functionsNode = new BookmarkNode("Functions", BookmarkNode.Categories.Group, null);
rootNode.Nodes.Add(functionsNode);
states.Clear();
stateNode = new BookmarkNode("\tGlobal", BookmarkNode.Categories.State, null);
states["\tGlobal"] = stateNode;
functionsNode.Nodes.Add(stateNode);
foreach (ScriptOutline.StateDesc scriptState in this._outline.States)
{
stateNode = new BookmarkNode(scriptState.Identifier, BookmarkNode.Categories.State, scriptState);
states[scriptState.Identifier] = stateNode;
functionsNode.Nodes.Add(stateNode);
}
foreach (ScriptOutline.FunctionDesc scriptFunction in this._outline.Functions)
{
BookmarkNode functionNode = new BookmarkNode(scriptFunction.Identifier, BookmarkNode.Categories.Function, scriptFunction);
if (states.TryGetValue(scriptFunction.State, out stateNode))
{
stateNode.Nodes.Add(functionNode);
}
}
BookmarkNode eventsNode = new BookmarkNode("Events", BookmarkNode.Categories.Group, null);
rootNode.Nodes.Add(eventsNode);
states.Clear();
stateNode = new BookmarkNode("\tGlobal", BookmarkNode.Categories.State, null);
states["\tGlobal"] = stateNode;
eventsNode.Nodes.Add(stateNode);
foreach (ScriptOutline.StateDesc scriptState in this._outline.States)
{
stateNode = new BookmarkNode(scriptState.Identifier, BookmarkNode.Categories.State, scriptState);
states[scriptState.Identifier] = stateNode;
eventsNode.Nodes.Add(stateNode);
}
foreach (ScriptOutline.EventDesc scriptEvent in this._outline.Events)
{
BookmarkNode eventNode = new BookmarkNode(scriptEvent.Identifier, BookmarkNode.Categories.Event, scriptEvent);
if (states.TryGetValue(scriptEvent.State, out stateNode))
{
stateNode.Nodes.Add(eventNode);
}
}
}
catch (Exception e)
{
ExceptionMessageBox msgBox = new ExceptionMessageBox(e);
msgBox.ShowDialog();
}
}
this.treeViewOutline.Model = _model;
this.treeViewOutline.EndUpdate();
foreach (TreeNodeAdv node in this.treeViewOutline.Root.Children)
{
node.Expand();
}
}
