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; }