List<ValueObjectDescriptor> FindValueObjects(CodeItem item)
{
var e = item.GetExtension<CompilationUnitExtension>();
var visitor = new ValueObjectFinder();
e.CompilationUnit.AcceptVisitor(visitor, null);
return visitor.ValueObjectInfos;
}
public static Visibility GetIgnoreVisibility(CodeItem item)
{
var filterRule = GetFilterRule(item);
if (filterRule != null)
{
return(filterRule.Ignore ? Visibility.Collapsed : Visibility.Visible);
}
return(Visibility.Visible);
}
/// <summary>
/// Set opacity of code item to value given in the filter window
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private static double SetOpacity(CodeItem item)
{
var filterRule = GetFilterRule(item);
if (filterRule != null)
{
return(GetOpacityValue(filterRule.Opacity));
}
return(1.0);
}
public void scanView_OnScanResult(Result result)
{
Device.BeginInvokeOnMainThread(async() =>
{
CodeItem newItem = new CodeItem();
newItem.Name = result.BarcodeFormat.ToString();
newItem.Code = result.Text;
newItem.CodeType = result.BarcodeFormat.ToString();
await App.Database.SaveItemAsync(newItem);
await DisplayAlert("Scanned result", "The barcode's text is " + result.Text + ". The barcode's format is " + result.BarcodeFormat, "OK");
});
}
void repository_CodeItemCreated(ICodeRepository sender, CodeItem item)
{
if (!item.Name.EndsWith(".cs")) return;
if (item.Name.EndsWith(".ctorgen.cs")) return;
var relations = FindDependencyRelations(item);
if (relations.Count == 0) return;
var generatedItems = CreateTopLevelCode(relations);
var dependency = item.SourceOf(Path.GetFileNameWithoutExtension(item.Name) + ".ctorgen.cs");
SaveGeneratedCodeToDependency(generatedItems, dependency);
}
private static FilterRule GetFilterRule(CodeItem item)
{
if (SettingsHelper.FilterRules == null)
{
return(null);
}
var filterRule = SettingsHelper.FilterRules.LastOrDefault(f =>
(f.Access == item.Access || f.Access == CodeItemAccessEnum.All) &&
(f.Kind == item.Kind || f.Kind == CodeItemKindEnum.All));
return(filterRule);
}
List<ValueObjectDescriptor> SkipAndWarnValueObjectsWithNoFields(CodeItem item, List<ValueObjectDescriptor> valueObjects)
{
var skipped = valueObjects.Where(v => v.FieldDeclarations.Count == 0);
foreach (var valueObject in skipped)
{
item.Logger.Send(
"Cannot generate value type because no fields are declared.",
new Location(valueObject.TypeDeclaration.StartLocation.Line, valueObject.TypeDeclaration.StartLocation.Column),
new Location(valueObject.TypeDeclaration.EndLocation.Line, valueObject.TypeDeclaration.EndLocation.Column),
Genuilder.Extensibility.Utilities.LogType.Error
);
}
return valueObjects.Except(skipped).ToList();
}
void repository_CodeItemCreated(ICodeRepository sender, CodeItem item)
{
if (!item.Name.EndsWith(".cs")) return;
if (item.Name.EndsWith(".vogen.cs")) return;
var valueObjects = FindValueObjects(item);
if (valueObjects.Count == 0) return;
valueObjects = SkipAndWarnValueObjectsWithNoFields(item, valueObjects);
var generatedItems = CreateTopLevelCode(valueObjects);
var dependency = item.SourceOf(Path.GetFileNameWithoutExtension(item.Name) + ".vogen.cs");
SaveGeneratedCodeToDependency(generatedItems, dependency);
}
private CodeItem[] GetCodes(ByteNode[] items)
{
Heap <ByteNode> heap = new Heap <ByteNode>(items);
while (heap.Count > 1)
{
ByteNode lhs = heap.DeleteMin(); // left node is smaller / 0
ByteNode rhs = heap.DeleteMin(); // right node is bigger / 1
ByteNode parent = new ByteNode(lhs, rhs); // give them a parent
heap.Add(parent);
}
CodeItem[] codes = new CodeItem[256];
AddCode(codes, heap.DeleteMin(), 0, new List <bool>());
return(codes);
}
List <ValueObjectDescriptor> SkipAndWarnValueObjectsWithNoFields(CodeItem item, List <ValueObjectDescriptor> valueObjects)
{
var skipped = valueObjects.Where(v => v.FieldDeclarations.Count == 0);
foreach (var valueObject in skipped)
{
item.Logger.Send(
"Cannot generate value type because no fields are declared.",
new Location(valueObject.TypeDeclaration.StartLocation.Line, valueObject.TypeDeclaration.StartLocation.Column),
new Location(valueObject.TypeDeclaration.EndLocation.Line, valueObject.TypeDeclaration.EndLocation.Column),
Genuilder.Extensibility.Utilities.LogType.Error
);
}
return(valueObjects.Except(skipped).ToList());
}
public static void ApplyHistoryIndicator(CodeDocumentViewModel model)
{
for (int i = 0; i < model.HistoryItems.Count; i++)
{
CodeItem historyItem = model.HistoryItems[i];
var codeItem = model.CodeDocument
.Flatten()
.FirstOrDefault(item => item.Id.Equals(historyItem.Id));
if (codeItem == null)
{
continue;
}
ApplyHistoryIndicator(codeItem, i);
}
}
private bool GetIsTypeMatch(CodeItem codeItem, CodeSlot slot)
{
switch (slot.SlotType)
{
case SLOT_TYPE.Idea:
return(true);
case SLOT_TYPE.ConditionCode:
return(codeItem.CodeType == CODE_TYPE.Condition);
case SLOT_TYPE.MovementCode:
return(codeItem.CodeType == CODE_TYPE.Movement);
}
return(false);
}
private static bool AddToRegion(List <CodeRegionItem> regions, CodeItem item)
{
if (item?.StartLine == null)
{
return(false);
}
foreach (var region in regions)
{
if (item.StartLine >= region.StartLine && item.StartLine <= region.EndLine)
{
region.Members.Add(item);
return(true);
}
}
return(false);
}
public CodeSlot GetClosestSlot(CodeItem codeItem)
{
var closestDistance = float.MaxValue;
var closestSlot = _codeSlots[0];
foreach (var codeSlot in _codeSlots)
{
var distance = GetDistanceToSlot(codeItem, codeSlot);
if (distance < closestDistance)
{
closestDistance = distance;
closestSlot = codeSlot;
}
}
return(closestSlot);
}
public async Task <CodeItem> SaveCompiledCode(IAcidCodeCompiler codeCompiler)
{
codeCompiler = codeCompiler ?? throw new ArgumentNullException(nameof(codeCompiler));
if (!codeCompiler.IsCodeCompiled)
{
throw new ApplicationException("Compile code before saving");
}
CodeItem codeItem = new CodeItem();
codeItem.CodeText = codeCompiler.CodeText;
codeItem.EntryPoint = codeCompiler.EntryPoint;
await _codeRepository.SaveCodeItemAsync(codeItem);
return(codeItem);
}
private static IEnumerable <CodeItem> Descendants(this CodeItem root)
{
var items = new Stack <CodeItem>(new[] { root });
while (items.Any())
{
var item = items.Pop();
yield return(item);
if (item is IMembers)
{
foreach (var i in (item as IMembers).Members)
{
items.Push(i);
}
}
}
}
private static bool ShouldBeVisible(CodeItem item, string name = "")
{
var visible = true;
if (Settings.Default.FilterRules != null)
{
var filterRule = Settings.Default.FilterRules.LastOrDefault(f =>
(f.Access == item.Access || f.Access == CodeItemAccessEnum.All) &&
(f.Kind == item.Kind || f.Kind == CodeItemKindEnum.All));
if (filterRule != null)
{
visible = filterRule.Visible;
}
}
return(visible && item.Name.Contains(name, StringComparison.OrdinalIgnoreCase));
}
/// <summary>
/// Attempts to find a <see cref="ICollapsible" /> associated with the specified <see
/// cref="IMembers" />.
/// </summary>
/// <param name="item">The IMembers CodeItem.</param>
/// <param name="manager">The outlining manager to get all regions</param>
/// <param name="textView">The textview to find collapsibles in</param>
/// <returns>The <see cref="ICollapsible" /> on the same starting line, otherwise null.</returns>
private static ICollapsible FindCollapsibleFromCodeItem(CodeItem item, IOutliningManager manager, IWpfTextView textView)
{
if (item.Kind == CodeItemKindEnum.ImplementedInterface)
{
return(null);
}
if (item.StartLine > textView.TextBuffer.CurrentSnapshot.LineCount)
{
return(null);
}
var snapshotLine = textView.TextBuffer.CurrentSnapshot.GetLineFromLineNumber(item.StartLine);
var collapsibles = manager.GetAllRegions(snapshotLine.Extent);
return((from collapsible in collapsibles
let startLine = GetStartLineForCollapsible(collapsible)
where startLine == item.StartLine
select collapsible).FirstOrDefault());
}
//extract a single orgId and one or more roles
public CodeItem AsOrgRolesItem()
{
try
{
var item = new CodeItem()
{
IdsList = GetListOrDefault("RelationshipId"),
Id = GetValueOrDefault("AgentId", 0)
};
item.ItemList = "[" + String.Join(", ", item.IdsList.ToArray()) + "]";
return(item);
}
catch
{
return(new CodeItem());
}
}
private void ArrangeCode(CodeItem codeItem, CodeSlot targetSlot)
{
if (codeItem.CodeSlot == targetSlot)
{
return;
}
switch (codeItem.CodeSlot.SlotType)
{
case SLOT_TYPE.Idea:
_ideaPages.Remove(codeItem);
break;
case SLOT_TYPE.ConditionCode:
_codingPages[codeItem.CodeSlot.Id].Condition = null;
break;
case SLOT_TYPE.MovementCode:
_codingPages[codeItem.CodeSlot.Id].Movement = null;
break;
}
switch (targetSlot.SlotType)
{
case SLOT_TYPE.Idea:
_ideaPages.Add(codeItem);
break;
case SLOT_TYPE.ConditionCode:
_codingPages[targetSlot.Id].Condition = codeItem;
break;
case SLOT_TYPE.MovementCode:
_codingPages[targetSlot.Id].Movement = codeItem;
break;
}
codeItem.CodeSlot.host = null;
targetSlot.host = codeItem;
codeItem.CodeSlot = targetSlot;
}
public static void AddItemToHistory(CodeItem item)
{
if (item == null)
{
return;
}
var model = item.Control.CodeDocumentViewModel;
// Clear current indicators
model.HistoryItems.ForEach(i => i.StatusMonikerVisibility = Visibility.Collapsed);
// Add new indicator, only keep the five latest history items
model.HistoryItems.RemoveAll(i => i.Id.Equals(item.Id));
model.HistoryItems.Insert(0, item);
model.HistoryItems = model.HistoryItems.Take(MaxHistoryItems).ToList();
SolutionStorageHelper.SaveToSolutionStorage(item.Control, model);
ApplyHistoryIndicator(model);
}
public void OnReleaseCodeItem(CodeItem codeItem)
{
var targetSlot = _isSnapped > 0 ? _snappedSlot : _originalSlot;
ArrangeCode(_selectedCodeItem, targetSlot);
_selectedCodeItem.transform.localScale = Vector3.one;
_selectedCodeItem.transform.position = targetSlot.transform.position;
_selectedCodeItem = null;
if (codeItem.CodeSlot.SlotType == SLOT_TYPE.Idea)
{
SoundManager.Instance.PlaySfx(SFX.Ui_MouseDown);
}
else
{
SoundManager.Instance.PlaySfx(SFX.Ui_MouseUp);
}
}
public List <CodeItem> EntityTypes_GetAll()
{
List <CodeItem> list = new List <CodeItem>();
//check if in cache
string key = "entityCodes";
//check cache for list
if (HttpRuntime.Cache[key] != null)
{
list = (List <CodeItem>)HttpRuntime.Cache[key];
return(list);
}
CodeItem value = new CodeItem();
list = CodesManager.Codes_EntityTypes_GetAll();
HttpRuntime.Cache.Insert(key, list);
return(list);
}
public void SaveCodeItem(CodeItem codeItem)
{
codeItem = codeItem ?? throw new ArgumentNullException(nameof(codeItem));
if (codeItem.Id == 0)
{
_dbContext.CodeItems.Add(codeItem);
}
else
{
var dbEntry = _dbContext.CodeItems.Find(codeItem.Id);
if (dbEntry != null)
{
dbEntry.CodeText = codeItem.CodeText;
dbEntry.EntryPoint = codeItem.EntryPoint;
}
}
_dbContext.SaveChanges();
}
public void CheckSlotSnap(CodeItem codeItem)
{
foreach (var slot in _codeSlots)
{
if (slot.host == null || slot.host == codeItem)
{
if (GetIsTypeMatch(codeItem, slot))
{
var distance = GetDistanceToSlot(codeItem, slot);
if (distance < _slotSnapDistance)
{
_selectedCodeItem.transform.position = slot.transform.position;
_snappedSlot = slot;
_isSnapped = _snapWaitCount;
return;
}
}
}
}
_isSnapped = Mathf.Max(_isSnapped - 1, 0);
}
public async Task SaveCodeItemAsync(CodeItem codeItem)
{
codeItem = codeItem ?? throw new ArgumentNullException(nameof(codeItem));
if (codeItem.Id == 0)
{
_dbContext.CodeItems.Add(codeItem);
}
else
{
var dbEntry = await _dbContext.CodeItems.FindAsync(codeItem.Id);
if (dbEntry != null)
{
dbEntry.CodeText = codeItem.CodeText;
dbEntry.EntryPoint = codeItem.EntryPoint;
}
}
await _dbContext.SaveChangesAsync();
}
/// <summary>
/// Find frameworkElement belonging to a code item
/// </summary>
/// <param name="itemsControl">itemsControl to search in</param>
/// <param name="item">item to find</param>
/// <returns></returns>
private static FrameworkElement FindItemContainer(ItemsControl itemsControl, CodeItem item)
{
if (itemsControl == null)
{
return(null);
}
var itemContainer = itemsControl.ItemContainerGenerator.ContainerFromItem(item);
var itemContainerSubItemsControl = FindVisualChild <ItemsControl>(itemContainer);
if (itemContainerSubItemsControl != null)
{
return(itemContainerSubItemsControl);
}
if ((itemContainer as ContentPresenter)?.Content == item)
{
return(itemContainer as FrameworkElement);
}
return(null);
}
/// <summary>
/// Determine if an item should be visible
/// </summary>
/// <param name="item">CodeItem that is checked</param>
/// <param name="name">Text filter</param>
/// <param name="filterOnBookmarks">Are we only showing bookmarks?</param>
/// <param name="bookmarks">List of current bookmarks</param>
/// <returns></returns>
private static bool ShouldBeVisible(CodeItem item, string name = "",
bool filterOnBookmarks = false, Dictionary <string, int> bookmarks = null)
{
var visible = true;
var filterRule = GetFilterRule(item);
if (filterRule != null && filterRule.Visible == false)
{
return(false);
}
if (filterOnBookmarks)
{
visible = BookmarkHelper.IsBookmark(bookmarks, item);
}
if (!string.IsNullOrEmpty(name))
{
visible = visible && item.Name.Contains(name, StringComparison.OrdinalIgnoreCase);
}
// If an item has any visible members, it should be visible.
// If an item does not have any visible members, hide it depending on an option
if (item is IMembers hasMembersItem &&
hasMembersItem?.Members != null)
{
if (hasMembersItem.Members.Any(m => m.IsVisible == Visibility.Visible))
{
visible = true;
}
else if (!hasMembersItem.Members.Any(m => m.IsVisible == Visibility.Visible) && filterRule != null)
{
visible = !filterRule.HideIfEmpty;
}
}
return(visible);
}
private static void BuildFromXmlBlock(TreeNode node, XmlBlock xmlBlock)
{
if (xmlBlock.CodeSnippets != null && xmlBlock.CodeSnippets.Length > 0)
{
foreach (var xmlChildCode in xmlBlock.CodeSnippets)
{
var childCodeItem = new CodeItem(xmlChildCode);
var childCodeNode = node.Nodes.Add(childCodeItem.ToString());
childCodeNode.Tag = childCodeItem;
}
}
if (xmlBlock.Blocks != null && xmlBlock.Blocks.Length > 0)
{
foreach (var xmlChildBlock in xmlBlock.Blocks)
{
var childBlockItem = new BlockItem(xmlChildBlock);
var childBlockNode = node.Nodes.Add(childBlockItem.ToString());
childBlockNode.Tag = childBlockItem;
BuildFromXmlBlock(childBlockNode, xmlChildBlock);
}
}
}
/// <summary>
/// Attempts to find a <see cref="ICollapsible" /> associated with the specified <see
/// cref="IMembers" />.
/// </summary>
/// <param name="item">The IMembers CodeItem.</param>
/// <param name="outliningManagerService">The outlining manager to get all regions</param>
/// <param name="textView">The textview to find collapsibles in</param>
/// <returns>The <see cref="ICollapsible" /> on the same starting line, otherwise null.</returns>
private static ICollapsible FindCollapsibleFromCodeItem(CodeItem item,
IOutliningManagerService outliningManagerService, IWpfTextView textView)
{
if (item.Kind == CodeItemKindEnum.ImplementedInterface)
{
return(null);
}
if (item.StartLine > textView.TextBuffer.CurrentSnapshot.LineCount)
{
return(null);
}
try
{
var outliningManager = GetOutliningManager(outliningManagerService, textView);
if (outliningManager == null)
{
return(null);
}
var collapsibles = outliningManager.GetAllRegions(ToSnapshotSpan(textView, item.Span));
return((from collapsible in collapsibles
let startLine = GetStartLineForCollapsible(collapsible)
where startLine == item.StartLine
select collapsible).FirstOrDefault());
}
catch (ArgumentOutOfRangeException)
{
// FindCollapsibleFromCodeItem failed for item
return(null);
}
catch (ObjectDisposedException)
{
// FindCollapsibleFromCodeItem failed because of disposed object
return(null);
}
}
void repository_CodeItemCreated(ICodeRepository sender, CodeItem item)
{
if (!item.Name.EndsWith(".cs"))
{
return;
}
if (item.Name.EndsWith(".ctorgen.cs"))
{
return;
}
var relations = FindDependencyRelations(item);
if (relations.Count == 0)
{
return;
}
var generatedItems = CreateTopLevelCode(relations);
var dependency = item.SourceOf(Path.GetFileNameWithoutExtension(item.Name) + ".ctorgen.cs");
SaveGeneratedCodeToDependency(generatedItems, dependency);
}
/// <summary>
/// Help add a CodeItem to an inner Region structure
/// </summary>
/// <param name="members"></param>
/// <param name="item"></param>
/// <returns></returns>
private static bool AddToRegion(List <CodeItem> members, CodeItem item)
{
foreach (var member in members)
{
if (member == null)
{
continue;
}
if (member is IMembers && AddToRegion((member as IMembers).Members, item))
{
return(true);
}
if (member.Kind == CodeItemKindEnum.Region && IsContainedWithin(item, member))
{
(member as CodeRegionItem).Members.Add(item);
return(true);
}
}
return(false);
}
/// <summary>
/// Main block, definitions block...
/// </summary>
/// <param name="pars"></param>
public void Visit(ParsedScopePreProcBlock pars)
{
if (pars.Flags.HasFlag(ParseFlag.FromInclude))
{
return;
}
// only display special blocks on the explorer
if (pars.Type == ParsedPreProcBlockType.Prototype || pars.Type == ParsedPreProcBlockType.Block)
{
return;
}
// convert to explorer type
CodeExplorerIconType type;
if (!Enum.TryParse(pars.Type.ToString(), out type))
{
return;
}
// to code explorer
CodeItem parentNode = type == CodeExplorerIconType.MainBlock ? null : GetExplorerListNode("AppBuilder blocks", CodeExplorerIconType.Block);
CodeItem newNode = CodeItem.Factory.New(type);
newNode.DisplayText = pars.Name;
newNode.Flags = pars.Flags;
newNode.SubText = null;
newNode.DocumentOwner = pars.FilePath;
newNode.GoToLine = pars.Line;
newNode.GoToColumn = pars.Column;
if (type != CodeExplorerIconType.MainBlock)
{
newNode.Type = type;
}
PushToCodeExplorer(parentNode, newNode);
}
private void AddCode(CodeItem[] codes, ByteNode treeNode, int p, List <bool> list)
{
if (treeNode.Parent != null)
{
if (treeNode.IsLeftChild)
{
list.Add(false); // false stands for 0
}
else
{
list.Add(true); // true stands for 1
}
}
if (treeNode.IsLeaf)
{
if (treeNode.Times > 0) // if the code never happen, we won't waste time on it
{
CodeItem codeItem = new CodeItem();
codeItem.ByteValue = treeNode.ByteValue;
codeItem.CodeValue = GetCodeValue(list);
codeItem.CodeBits = list.ToArray();
codes[treeNode.ByteValue] = codeItem;
}
}
else
{
AddCode(codes, treeNode.Left, p + 1, list); // traverse the tree recursively
AddCode(codes, treeNode.Right, p + 1, list);
}
if (list.Count > 0)
{
list.RemoveAt(list.Count - 1);
}
}
private static TreeNode AddNewCodeItem(TreeNode selectedNode, CodeItem codeItem)
{
if (selectedNode.Tag is CodeItem)
{
var parentNode = selectedNode.Parent;
var selectedIndex = selectedNode.Index;
var newNode = parentNode.Nodes.Insert(selectedIndex + 1, codeItem.ToString());
newNode.Tag = codeItem;
return newNode;
}
if (selectedNode.Tag is BlockItem)
{
int index;
for (index = 0; index < selectedNode.Nodes.Count; ++index)
if (selectedNode.Nodes[index].Tag is BlockItem) break;
var newNode = selectedNode.Nodes.Insert(index, codeItem.ToString());
newNode.Tag = codeItem;
return newNode;
}
return null;
}
private static void BuildFromXmlBlock(TreeNode node, XmlBlock xmlBlock)
{
if (xmlBlock.CodeSnippets != null && xmlBlock.CodeSnippets.Length > 0)
foreach (var xmlChildCode in xmlBlock.CodeSnippets)
{
var childCodeItem = new CodeItem(xmlChildCode);
var childCodeNode = node.Nodes.Add(childCodeItem.ToString());
childCodeNode.Tag = childCodeItem;
}
if (xmlBlock.Blocks != null && xmlBlock.Blocks.Length > 0)
foreach (var xmlChildBlock in xmlBlock.Blocks)
{
var childBlockItem = new BlockItem(xmlChildBlock);
var childBlockNode = node.Nodes.Add(childBlockItem.ToString());
childBlockNode.Tag = childBlockItem;
BuildFromXmlBlock(childBlockNode, xmlChildBlock);
}
}
List<DependencyRelation> FindDependencyRelations(CodeItem item)
{
var extension = item.GetExtension<CompilationUnitExtension>();
var dependencyFinder = new DependencyFinder();
extension.CompilationUnit.AcceptVisitor(dependencyFinder, null);
return dependencyFinder.DependencyRelations;
}
