private IEnumerable <ITreeItem> Parse(IEnumerable <TreeProject> projects,
IdCounter counter,
ITreeItem solution)
{
var items = new List <ITreeItem>();
foreach (var project in projects)
{
string name = project.Name;
var diagrams = project.Diagrams.Reverse();
var item = TreeEditor.CreateProjectItem(name, Context.CreateProject, counter);
solution.Add(item);
int id = int.Parse(name.Split(Constants.TagNameSeparator)[1]);
counter.Set(Math.Max(counter.Count, id + 1));
Parse(counter, diagrams, item, items);
}
var first = items.FirstOrDefault();
if (first != null)
{
first.SetSelected(true);
}
return(items);
}
public Artikel(string bez, string herstellerBez, decimal preis)
{
Artikelnummer = IdCounter.GetInstance().GetArtikelnummer();
Bezeichnung = bez;
Herstellername = herstellerBez;
Einzelpreis = preis;
}
private void Parse(IdCounter counter,
TreeDiagram diagram,
ITreeItem project,
List <ITreeItem> diagrams)
{
var lines = diagram.Reverse();
var first = lines.First().Split(new char[] { Constants.ArgumentSeparator, '\t', ' ' }, StringSplitOptions.RemoveEmptyEntries);
string name = first.Length >= 1 ? first[1] : null;
var sb = new StringBuilder();
foreach (var line in lines)
{
sb.AppendLine(line);
}
var item = TreeEditor.CreateDiagramItem(name, Context.CreateDiagram, counter);
item.SetTag(new Diagram(sb.ToString(), null));
project.Add(item);
diagrams.Add(item);
int id = int.Parse(name.Split(Constants.TagNameSeparator)[1]);
counter.Set(Math.Max(counter.Count, id + 1));
}
public static TreeItemType AddNewItem(ITree tree,
Func <ITreeItem> createProject,
Func <ITreeItem> createDiagram,
IdCounter counter)
{
var selected = tree.GetSelectedItem() as ITreeItem;
var type = GetTreeItemType(selected.GetUid());
if (type == TreeItemType.Diagram)
{
var project = selected.GetParent() as ITreeItem;
AddDiagram(project, true, createDiagram, counter);
return(TreeItemType.Diagram);
}
else if (type == TreeItemType.Project)
{
AddDiagram(selected, true, createDiagram, counter);
return(TreeItemType.Diagram);
}
else if (type == TreeItemType.Solution)
{
AddProject(selected, createProject, counter);
return(TreeItemType.Project);
}
return(TreeItemType.None);
}
public override TranslationContainer ToXliff(IdCounter counter)
{
var unitId = "u" + (counter.GetNextUnitId());
var xliffUnit = new Unit(unitId);
xliffUnit.Name = this.Name;
if (this.Attributes.Count > 0)
{
xliffUnit.Metadata = this.Attributes.ToXliffMetadata();
}
var segment = new Segment();
if (this.Value.IsHtml())
{
var source = new Source();
source.Text.Add(new CDataTag(this.Value));
segment.Source = source;
}
else
{
segment.Source = new Source(this.Value);
}
xliffUnit.Resources.Add(segment);
return(xliffUnit);
}
public static void IdsAppend(IEnumerable <object> elements, IdCounter counter)
{
foreach (var element in elements.Cast <IElement>())
{
element.SetUid(GetUid(counter, element));
}
}
public void Clear(ITree tree, ICanvas canvas, IdCounter counter)
{
TreeEditor.Clear(tree);
counter.Reset();
TagsReset();
SelectedListReset();
canvas.SetTags(null);
}
public static ITreeItem CreateDiagramItem(string uid,
Func <ITreeItem> createDiagram,
IdCounter counter)
{
var diagram = createDiagram();
diagram.SetUid(uid == null ? Constants.TagHeaderDiagram + Constants.TagNameSeparator + counter.Next().ToString() : uid);
return(diagram);
}
public static ITreeItem CreateSolutionItem(string uid,
Func <ITreeItem> createSolution,
IdCounter counter)
{
var solution = createSolution();
solution.SetUid(uid == null ? Constants.TagHeaderSolution + Constants.TagNameSeparator + counter.Next().ToString() : uid);
return(solution);
}
private void Parse(IdCounter counter,
IEnumerable <TreeDiagram> diagrams,
ITreeItem project,
List <ITreeItem> diagramList)
{
foreach (var diagram in diagrams)
{
Parse(counter, diagram, project, diagramList);
}
}
public static ITreeItem CreateProjectItem(string uid,
Func <ITreeItem> createProject,
IdCounter counter)
{
var project = createProject();
project.SetUid(uid == null ? Constants.TagHeaderProject + Constants.TagNameSeparator + counter.Next().ToString() : uid);
return(project);
}
internal static int UseId()
{
lock (SyncRoot)
{
if (_instance == null)
{
_instance = new IdCounter();
}
_counter++;
return(_counter);
}
}
private static XElement MakeTextBlockElement(GMTextBlock textBlock, IdCounter idCounter)
{
var textBlockElement = MakeXElementWithAttributes(
HocrFormatConsts.XNameDiv, new Dictionary <string, string>()
{
{ "class", HocrFormatConsts.ClassTextBlock },
{ "id", idCounter.NextTextBlockId },
{ "title", FormatTitleAttribute(textBlock.BoundingBox) }
});
foreach (var paragraph in textBlock.Paragraphs())
{
var paragraphElement = MakeXElementWithAttributes(
HocrFormatConsts.XNameP, new Dictionary <string, string>()
{
{ "class", HocrFormatConsts.ClassParagraph },
{ "dir", "ltr" },
{ "id", idCounter.NextParagraphId },
{ "title", FormatTitleAttribute(paragraph.BoundingBox) }
});
textBlockElement.Add(paragraphElement);
foreach (var line in paragraph.Lines())
{
var lineElement = MakeXElementWithAttributes(
HocrFormatConsts.XNameSpan, new Dictionary <string, string>()
{
{ "class", HocrFormatConsts.ClassLine },
{ "id", idCounter.NextLineId },
{ "title", FormatTitleAttribute(line.BoundingBox) }
});
paragraphElement.Add(lineElement);
foreach (var word in line.Words())
{
var wordElement = MakeXElementWithAttributes(
HocrFormatConsts.XNameSpan, new Dictionary <string, string>()
{
{ "class", HocrFormatConsts.ClassWord },
{ "id", idCounter.NextWordId },
{ "title", FormatTitleAttribute(word.BoundingBox, word.Accuracy) },
{ "accuracy", string.Format(CultureInfo.InvariantCulture, "{0:N2}", word.Accuracy / 100.0) }
});
lineElement.Add(wordElement);
wordElement.Add(
new XElement(HocrFormatConsts.XNameStrong, word.Text));
}
}
// TODO: store information about standalone words (they should be split onto lines)
}
return(textBlockElement);
}
private static XElement MakeCellElement(GMTableCell cell, IdCounter idCounter)
{
var cellElement = MakeXElementWithAttributes(
HocrFormatConsts.XNameDiv, new Dictionary <string, string>()
{
{ "class", HocrFormatConsts.ClassTableCell },
{ "id", idCounter.NextTextBlockId },
{ HocrFormatConsts.AttrCellRowIndex, cell.RowIndex.ToString() },
{ HocrFormatConsts.AttrCellColIndex, cell.ColIndex.ToString() },
{ HocrFormatConsts.AttrCellRowSpan, cell.RowSpan.ToString() },
{ HocrFormatConsts.AttrCellColSpan, cell.ColSpan.ToString() },
});
cellElement.Add(MakeTextBlockElement(cell.TextBlock, idCounter));
return(cellElement);
}
public static void AddDiagram(ITreeItem project,
bool select,
Func <ITreeItem> createDiagram,
IdCounter counter)
{
var diagram = CreateDiagramItem(null, createDiagram, counter);
project.Add(diagram);
ModelEditor.Store(null, diagram);
if (select == true)
{
diagram.SetSelected(true);
}
}
public override XliffElement ToXliff(IdCounter idCounter)
{
var id = "g" + (idCounter.GetNextGroupId());
var xliffGroup = new Group(id)
{
Name = this.Name,
Metadata = Attributes.ToXliffMetadata()
};
foreach (var container in Containers)
{
var xliffContainer = container.ToXliff(idCounter) as TranslationContainer;
xliffGroup.Containers.Add(xliffContainer);
}
return(xliffGroup);
}
public void Parse(ITree tree,
TreeSolution solution,
IdCounter counter,
Func <ITreeItem> CreateTreeSolutionItem)
{
string tagFileName = solution.TagFileName;
string solutionName = solution.Name;
var projects = solution.Projects.Reverse();
TagsLoad(tagFileName);
var item = TreeEditor.CreateSolutionItem(solutionName, CreateTreeSolutionItem, counter);
tree.Add(item);
Parse(projects, counter, item);
}
public override XliffElement ToXliff(IdCounter idCounter)
{
var fileId = "f" + idCounter.GetNextFileId();
var xliffFile = new File(fileId)
{
Original = this.SourceIdentifier,
Metadata = Attributes.ToXliffMetadata()
};
foreach (var container in this.Containers)
{
var xliffContainer = container.ToXliff(idCounter) as TranslationContainer;
xliffFile.Containers.Add(xliffContainer);
}
return(xliffFile);
}
private static List <Node> BuildLevel(List <Node> nodes, IdCounter idCounter)
{
List <Node> res = new List <Node>();
foreach (Node node in nodes)
{
node.id = idCounter.increment();
if (node.left != null)
{
res.Add(node.left);
}
if (node.right != null)
{
res.Add(node.right);
}
}
return(res);
}
private void InitializeEditor()
{
Editor = new DiagramEditor();
Editor.Context = new Context();
Editor.Context.CurrentTree = this.ExplorerControl.SolutionTree;
Editor.Context.CurrentCanvas = this.DiagramControl.DiagramCanvas;
var counter = new IdCounter();
counter.Set(3);
this.DiagramControl.DiagramCanvas.SetCounter(counter);
var prop = DiagramProperties.Default;
this.DiagramControl.DiagramCanvas.SetProperties(prop);
SetProperties(prop);
Editor.Context.IsControlPressed = () => Keyboard.Modifiers == ModifierKeys.Control;
Editor.Context.UpdateProperties = () => UpdateProperties(Editor.Context.CurrentCanvas.GetProperties());
Editor.Context.SetProperties = (p) => SetProperties(p);
Editor.Context.Clipboard = new WindowsClipboard();
// diagram creator
Editor.Context.DiagramCreator = GetDiagramCreator();
// set checkbox states
EnableInsertLast.IsChecked = Editor.Context.EnableInsertLast;
EnableSnap.IsChecked = Editor.Context.EnableSnap;
SnapOnRelease.IsChecked = Editor.Context.SnapOnRelease;
// explorer control
this.ExplorerControl.Editor = Editor;
this.ExplorerControl.DiagramView = this.DiagramControl.RootBorder;
// tree actions
Editor.Context.CreateSolution = () => this.ExplorerControl.CreateTreeSolutionItem();
Editor.Context.CreateProject = () => this.ExplorerControl.CreateTreeProjectItem();
Editor.Context.CreateDiagram = () => this.ExplorerControl.CreateTreeDiagramItem();
// update canvas grid
UpdateDiagramGrid(false);
}
public static void CreateDefaultSolution(ITree tree,
Func <ITreeItem> createSolution,
Func <ITreeItem> createProject,
Func <ITreeItem> createDiagram,
IdCounter counter)
{
var solution = CreateSolutionItem(null, createSolution, counter);
tree.Add(solution);
var project = CreateProjectItem(null, createProject, counter);
solution.Add(project);
var diagram = CreateDiagramItem(null, createDiagram, counter);
project.Add(diagram);
diagram.SetSelected(true);
}
public override TranslationContainer ToXliff(IdCounter counter)
{
var id = "g" + (counter.GetNextGroupId());
var xliffGroup = new Group(id)
{
Name = this.Name
};
if (this.Attributes.Count > 0)
{
xliffGroup.Metadata = this.Attributes.ToXliffMetadata();
}
foreach (var container in Containers)
{
var xliffContainer = container.ToXliff(counter);
xliffGroup.Containers.Add(xliffContainer);
}
return(xliffGroup);
}
public static void showAsTree(Node tree)
{
StringBuilder sb = new StringBuilder();
Dictionary <int, List <Node> > levels = new Dictionary <int, List <Node> >();
IdCounter idCounter = new IdCounter(0);
int level = 0;
List <Node> nodes = new List <Node>();
tree.id = idCounter.getId();
nodes.Add(tree);
levels.Add(level, nodes);
while (nodes.Any())
{
nodes = BuildLevel(levels[level], idCounter);
levels.Add(++level, nodes);
}
for (int i = 0; i < level; i++)
{
sb.Append(string.Join <Node>(", ", levels[i].ToArray()));
sb.Append("\n");
}
Console.WriteLine(sb.ToString());
}
public override XliffElement ToXliff(IdCounter idCounter)
{
var unitId = "u" + (idCounter.GetNextUnitId());
var xliffUnit = new Unit(unitId)
{
Name = this.Name,
Metadata = Attributes.ToXliffMetadata()
};
var segment = new Segment();
if (this.Value.IsHtml())
{
var source = new Source();
source.Text.Add(new CDataTag(this.Value));
segment.Source = source;
}
else
{
segment.Source = new Source(this.Value);
}
xliffUnit.Resources.Add(segment);
return(xliffUnit);
}
public void UpdateCounter(IdCounter original, IdCounter counter)
{
ModelEditor.IdsUpdateCounter(original, counter);
}
public abstract TranslationContainer ToXliff(IdCounter counter);
public static void IdsUpdateCounter(IdCounter original, IdCounter counter)
{
original.Set(Math.Max(original.Count, counter.Count));
}
private static string GetUid(IdCounter counter, IElement element)
{
return(string.Concat(element.GetUid().Split(Constants.TagNameSeparator)[0],
Constants.TagNameSeparator,
counter.Next().ToString()));
}
//Konstruktoren
public Bestellung()
{
Bestellnummer = IdCounter.GetInstance().GetBestellnummer();
BestellteArtikel = new List <ArtikelBestellung>();
}
public static XDocument ProcessModel([NotNull] TextGeometryModel model, string pathToScripts = "")
{
var bodyElement = new XElement(HocrFormatConsts.XNameBody);
var document =
new XDocument(
new XElement(HocrFormatConsts.XNameHtml,
new XElement(HocrFormatConsts.XNameHead,
new XElement(HocrFormatConsts.XNameTitle, "text geometric model"),
new XElement(HocrFormatConsts.XNameLink, new XAttribute("href", pathToScripts + "hocr.css"), new XAttribute("rel", "stylesheet")),
new XElement(HocrFormatConsts.XNameScript, new XAttribute("src", pathToScripts + "jquery.js"), " "),
new XElement(HocrFormatConsts.XNameScript, new XAttribute("src", pathToScripts + "hocr.js"), " "),
MakeXElementWithAttributes(HocrFormatConsts.XNameMeta, new Dictionary <string, string>()
{
{ "http-equiv", "Content-Type" },
{ "content", "text/html; charset=utf-8" }
}),
MakeMetaElement("ocr-system", "kontur-recognition"),
MakeMetaElement("ocr-capabilities", "ocr_page ocr_carea ocr_par ocr_line ocrx_word ocrp_wconf ocr_separator ocr_table")
),
bodyElement
)
);
var pageElement =
MakeXElementWithAttributes(
HocrFormatConsts.XNameDiv, new Dictionary <string, string>()
{
{ "class", HocrFormatConsts.ClassPage },
{ "id", "page_1" },
{ "title", string.Format("{0}; ppageno 0", FormatTitleAttribute(model.PageBox)) },
{ "gridunit", string.Format("{0}", model.GridUnit.Divisor) }
});
bodyElement.Add(pageElement);
var idCounter = new IdCounter();
foreach (var textBlock in model.TextBlocks())
{
pageElement.Add(MakeTextBlockElement(textBlock, idCounter));
}
foreach (var separator in model.Separators())
{
var separatorElement = MakeXElementWithAttributes(
HocrFormatConsts.XNameDiv, new Dictionary <string, string>()
{
{ "class", HocrFormatConsts.ClassSeparator },
{ "id", idCounter.NextSeparatorId },
{ "title", FormatTitleAttribute(separator.BoundingBox) },
{ "separator", string.Format("{0} {1} {2} {3} {4}",
separator.StartPointX, separator.StartPointY,
separator.EndPointX, separator.EndPointY, separator.Width) },
});
pageElement.Add(separatorElement);
}
foreach (GMTable table in model.Tables())
{
var tableElement = MakeXElementWithAttributes(
HocrFormatConsts.XNameDiv, new Dictionary <string, string>()
{
{ "class", HocrFormatConsts.ClassTable },
{ "id", idCounter.NextTableId },
{ "title", FormatTitleAttribute(table.BoundingBox) },
{ HocrFormatConsts.AttrTableRowsCount, table.RowsCount.ToString() },
{ HocrFormatConsts.AttrTableColsCount, table.ColsCount.ToString() }
});
foreach (var cell in table.Cells())
{
tableElement.Add(MakeCellElement(cell, idCounter));
}
pageElement.Add(tableElement);
}
return(document);
}
