public static string GetDropLabel(Dialog_BillConfig dialog) { Bill_Production bill = Traverse.Create(dialog).Field("bill").GetValue <Bill_Production>(); GroupMode groupMode = BillAssignationUtility.IsFor(bill); switch (groupMode) { case GroupMode.ColonyOnly: return("PrisonLabor_ColonyOnly".Translate()); case GroupMode.PrisonersOnly: return("PrisonLabor_PrisonersOnly".Translate()); case GroupMode.ColonistsOnly: return("AnyWorker".Translate()); case GroupMode.SlavesOnly: return("AnySlave".Translate()); case GroupMode.CaptiveOnly: return("PrisonLabor_PrisonersAndSlaveOnly".Translate()); default: return((!ModsConfig.IdeologyActive || !bill.SlavesOnly) ? ("AnyWorker".Translate()) : ("AnySlave".Translate())); } }
protected void InitGroups(GroupMode mode) { switch (mode) { case GroupMode.None: break; case GroupMode.Folder: this.Groups.Add("Folders", "Folders"); break; case GroupMode.Type: this.Groups.Add("Folders", "Folders"); this.Groups.Add("Text", "Text"); this.Groups.Add("Audio", "Audio"); this.Groups.Add("Image", "Image"); this.Groups.Add("Video", "Video"); this.Groups.Add("Other", "Other"); break; case GroupMode.Size: this.Groups.Add("Small", "Small 0 - 9 MB"); this.Groups.Add("Medium", "Medium 10 - 99 MB"); this.Groups.Add("Large", "Large 100 MB - 999 GB"); this.Groups.Add("Huge", "Huge > 1 GB"); break; default: throw new NotImplementedException(String.Format("GroupMode {0} not implemented", mode)); } }
public void ShowFolder(DossierFolderInfo folder, int depth = 0, GroupMode mode = GroupMode.None) { this.BeginUpdate(); this.Items.Clear(); this.Groups.Clear(); InitGroups(mode); this.Items.Add(GetFolderItem(folder, mode, true)); List <ListViewItem> sort = new List <ListViewItem>(); foreach (DossierFileInfo file in folder.Files) { sort.Add(GetFileItem(file, mode)); } int recurse = (depth == -1 ? int.MaxValue : depth); if (recurse > 0) { foreach (DossierFolderInfo sub in folder.Folders) { this.Items.Add(GetFolderItem(sub, mode)); sort.AddRange(GetFileItems(sub, recurse - 1, mode)); } } this.Items.AddRange(sort.OrderBy(i => i.Text).ToArray()); this.EndUpdate(); }
public static void SetFor(Bill key, GroupMode value) { if (!Map.ContainsKey(key)) { Map[key] = new BillGroupData(); } Map[key].Mode = value; }
public void Reset() { // Do not raise PropertyChanged event when resetting. enableRaisePropertyChanged = false; ServerAddress = DefaultValueEmptyString; Username = DefaultValueEmptyString; ShowFileAndFolderGroupingHeader = true; PreviewImageDownloadMode = PreviewImageDownloadMode.Always; UseWindowsHello = false; GroupMode = GroupMode.GroupByNameAscending; ExpertMode = false; enableRaisePropertyChanged = true; }
private void btnGroup_Click(object sender, EventArgs e) { if (sender == btnGroupNone) { categoryMode = GroupMode.None; } else if (sender == btnGroupType) { categoryMode = GroupMode.Type; } else if (sender == btnGroupCategory) { categoryMode = GroupMode.Category; } ListAddins(categoryMode); }
private ListViewGroup GetGroup(IAddin filter, GroupMode category = GroupMode.None) { ListViewGroup result = null; if (category == GroupMode.Type) { var grpName = filter.Type.ToString(); result = GetGroup(grpName, AddinUtils._(Host, grpName)); } else if (category == GroupMode.Category) { result = GetGroup(filter.CategoryName, filter.DisplayCategoryName); } else { result = GetGroup("None", AddinUtils._(Host, AddinUtils.T("None"))); } return(result); }
static bool Postfix(bool __result, Bill __instance, Pawn p) { if (__result == false && __instance.PawnRestriction == null) { GroupMode group = BillAssignationUtility.IsFor(__instance); if (group == GroupMode.ColonyOnly && __instance.SlavesOnly && p.IsSlave) { return(true); } if (group == GroupMode.SlavesOnly && __instance.SlavesOnly && p.IsSlave) { return(true); } if (group == GroupMode.CaptiveOnly && __instance.SlavesOnly && p.IsSlave) { return(true); } if (__instance.recipe.workSkill != null) { int level = p.skills.GetSkill(__instance.recipe.workSkill).Level; if (level < __instance.allowedSkillRange.min) { JobFailReason.Is("UnderAllowedSkill".Translate(__instance.allowedSkillRange.min), __instance.Label); return(false); } if (level > __instance.allowedSkillRange.max) { JobFailReason.Is("AboveAllowedSkill".Translate(__instance.allowedSkillRange.max), __instance.Label); return(false); } } if (group == GroupMode.ColonyOnly || (group == GroupMode.CaptiveOnly && p.IsPrisoner)) { return(true); } } return(__result); }
private void ListAddins(GroupMode groupMode = GroupMode.Type) { #region Add addin to Listview & Category by addin Group lvAddins.BeginUpdate(); if (lvAddins.Items.Count <= 0) { foreach (var item in AddinItems) { item.Group = GetGroup(item.Tag as IAddin, categoryMode); lvAddins.Items.Add(item); } } else { foreach (ListViewItem item in lvAddins.Items) { item.Group = GetGroup(item.Tag as IAddin, categoryMode); } } lvAddins.EndUpdate(); #endregion }
/// <summary> /// Sets the group mode for the given case. Inheritance is handled as specified by the parameters. /// </summary> /// <param name="edgeType">The type of an edge connected to the group node.</param> /// <param name="exactEdgeType">Specifies, whether only the exact given edge type is meant.</param> /// <param name="adjNodeType">The type of a node connected to the group node.</param> /// <param name="exactAdjNodeType">Specifies, whether only the exact given node type is meant.</param> /// <param name="groupMode">The group mode to be applied.</param> public void SetEdgeGroupMode(EdgeType edgeType, bool exactEdgeType, NodeType adjNodeType, bool exactAdjNodeType, GroupMode groupMode) { foreach (EdgeType subEdgeType in edgeType.subOrSameTypes) { Dictionary <NodeType, GroupMode> groupEdge; if (!groupEdges.TryGetValue(subEdgeType, out groupEdge)) { if (groupMode == GroupMode.None) { return; } groupEdge = new Dictionary <NodeType, GroupMode>(); groupEdges[subEdgeType] = groupEdge; } foreach (NodeType subNodeType in adjNodeType.SubOrSameTypes) { if (groupMode == GroupMode.None) { groupEdge.Remove(subNodeType); } else { groupEdge[subNodeType] = groupMode; } if (exactAdjNodeType) { break; // don't change group modes for subtypes of adjNodeType } } if (exactEdgeType) { break; // don't change group modes for subtypes of edgeType } } }
protected ListViewItem GetFolderItem(DossierFolderInfo folder, GroupMode mode, bool root = false) { ListViewItem item = new ListViewItem(); item.Text = root ? folder.FullPath : folder.Name; item.Tag = folder; if (this.View == View.Details) { item.SubItems.Add("Folder"); item.SubItems.Add(Dossier.BytesDisplayText(root ? folder.ReportRecursive.GrandTotal.TotalSize : folder.Report.GrandTotal.TotalSize)); } if (mode == GroupMode.Type || mode == GroupMode.Folder) { item.Group = GetGroup("Folders"); } item.ImageKey = root ? "open" : "closed"; item.ForeColor = Color.White; item.BackColor = root ? Color.Black : Color.Gray; return(item); }
public BillGroupData() { Mode = GroupMode.ColonyOnly; }
private static void DumpGroups(IGraph graph, Set <INode> nodes, DumpContext dc) { // Compute the nesting hierarchy (groups) Dictionary <INode, DumpGroupNode> groupNodes = new Dictionary <INode, DumpGroupNode>(); Dictionary <INode, INode> containedIn = new Dictionary <INode, INode>(); Set <INode> groupedNodes = new Set <INode>(); // (by iterating the group node types in order of dump declaration and removing the iterated nodes from the available nodes, // the conflict resolution priorities of debug enable are taken care of) foreach (GroupNodeType groupNodeType in dc.DumpInfo.GroupNodeTypes) { foreach (INode node in graph.GetCompatibleNodes(groupNodeType.NodeType)) { if (nodes.Contains(node)) { if (!groupNodes.ContainsKey(node)) { groupNodes.Add(node, new DumpGroupNode()); // todo: is the if needed? } nodes.Remove(node); } if (dc.DumpInfo.IsExcludedNodeType(node.Type)) { continue; } foreach (IEdge edge in node.Incoming) { GroupMode grpMode = groupNodeType.GetEdgeGroupMode(edge.Type, edge.Source.Type); if ((grpMode & GroupMode.GroupIncomingNodes) == 0) { continue; } if (!dc.Nodes.Contains(edge.Source)) { continue; } groupNodes[node].groupedNodes.Add(edge.Source); if (!containedIn.ContainsKey(edge.Source)) { containedIn.Add(edge.Source, node); // crashes without if in case of multiple containment due to dump misspecification by user } groupedNodes.Add(edge.Source); if ((grpMode & GroupMode.Hidden) != 0) { dc.ExcludedEdges.Add(edge); } } foreach (IEdge edge in node.Outgoing) { GroupMode grpMode = groupNodeType.GetEdgeGroupMode(edge.Type, edge.Target.Type); if ((grpMode & GroupMode.GroupOutgoingNodes) == 0) { continue; } if (!dc.Nodes.Contains(edge.Target)) { continue; } groupNodes[node].groupedNodes.Add(edge.Target); if (!containedIn.ContainsKey(edge.Target)) { containedIn.Add(edge.Target, node); // crashes without if in case of multiple containment due to dump misspecification by user } groupedNodes.Add(edge.Target); if ((grpMode & GroupMode.Hidden) != 0) { dc.ExcludedEdges.Add(edge); } } } } // Dump the groups (begin at the roots of the group trees) foreach (KeyValuePair <INode, DumpGroupNode> groupNode in groupNodes) { if (!containedIn.ContainsKey(groupNode.Key)) { DumpGroupTree(groupNode.Key, groupNodes, dc); DumpEdgesFromNode(groupNode.Key, dc); } } // Dump the rest, which has not been grouped nodes.Remove(groupedNodes); foreach (INode node in nodes) { DumpNodeAndEdges(node, dc); } }
private void tsbGroup_ByGroup_Click(object sender, EventArgs e) { this.ActiveGroupMode = GroupMode.Group; }
private void Append(IEnumerable items, GroupMode mode) { IEnumerator en = items.GetEnumerator(); if (en.MoveNext()) { if (mode == GroupMode.Group) AppendNumberedGroupStart(); else if (mode == GroupMode.NoncapturingGroup) AppendNoncapturingGroupStart(); _pendingOr = false; int length = Length; Append(en.Current); while (en.MoveNext()) { _pendingOr = _pendingOr || (Length > length); length = Length; Append(en.Current); } _pendingOr = false; if (mode != GroupMode.None) AppendGroupEnd(); } }
private void tsbGroup_ByInstrumentType_Click(object sender, EventArgs e) { this.ActiveGroupMode = GroupMode.InstrumentType; }
public static string GetLayerPath(PsdLayer layer, NamingConvention fileNaming, GroupMode groupMode) { string filename = $"{layer.Name}.png"; string folder = string.Empty; if (fileNaming != NamingConvention.LayerNameOnly) { bool isDir = fileNaming == NamingConvention.CreateGroupFolders; var docLayer = layer.Document as IPsdLayer; var parent = layer.Parent; while (parent != null && parent.Equals(docLayer) == false) { if (isDir) { if (string.IsNullOrEmpty(folder)) { folder = parent.Name; } else { folder = string.Format("{0}/{1}", parent.Name, folder); } } else { filename = string.Format("{0}_{1}", parent.Name, filename); } parent = parent.Parent; if (groupMode == GroupMode.ParentOnly) { break; } } } return(filename); }
private bool TryGroupNode(INode groupNode, IEdge edge, String srcName, String tgtName, GroupNodeType srcGroupNodeType, GroupNodeType tgtGroupNodeType, ref GroupMode grpMode) { if(groupNode == edge.Target) { grpMode = tgtGroupNodeType.GetEdgeGroupMode(edge.Type, edge.Source.Type); if((grpMode & GroupMode.GroupIncomingNodes) != 0) { ycompStream.Write("moveNode \"n" + srcName + "\" \"n" + tgtName + "\"\n"); return true; } } else if(groupNode == edge.Source) { grpMode = srcGroupNodeType.GetEdgeGroupMode(edge.Type, edge.Target.Type); if((grpMode & GroupMode.GroupOutgoingNodes) != 0) { ycompStream.Write("moveNode \"n" + tgtName + "\" \"n" + srcName + "\"\n"); return true; } } return false; }
public FilterControl() { Children = new Drawable[] { new Box { Colour = Color4.Black, Alpha = 0.8f, RelativeSizeAxes = Axes.Both, }, new Container { Padding = new MarginPadding(20), AlwaysReceiveInput = true, RelativeSizeAxes = Axes.Both, Width = 0.5f, Anchor = Anchor.TopRight, Origin = Anchor.TopRight, Children = new Drawable[] { searchTextBox = new SearchTextBox { RelativeSizeAxes = Axes.X, OnChange = (sender, newText) => { if (newText) { FilterChanged?.Invoke(); } }, Exit = () => Exit?.Invoke(), }, new Box { RelativeSizeAxes = Axes.X, Height = 1, Colour = OsuColour.Gray(80), Origin = Anchor.BottomLeft, Anchor = Anchor.BottomLeft, }, new FillFlowContainer { Anchor = Anchor.BottomRight, Origin = Anchor.BottomRight, Direction = FillDirection.Horizontal, RelativeSizeAxes = Axes.X, AutoSizeAxes = Axes.Y, AlwaysReceiveInput = true, Children = new Drawable[] { groupTabs = new OsuTabControl <GroupMode> { RelativeSizeAxes = Axes.X, Height = 24, Width = 0.5f, AutoSort = true }, //spriteText = new OsuSpriteText //{ // Font = @"Exo2.0-Bold", // Text = "Sort results by", // TextSize = 14, // Margin = new MarginPadding // { // Top = 5, // Bottom = 5 // }, //}, sortTabs = new OsuTabControl <SortMode>() { RelativeSizeAxes = Axes.X, Width = 0.5f, Height = 24, AutoSort = true, } } }, } } }; groupTabs.PinItem(GroupMode.All); groupTabs.PinItem(GroupMode.RecentlyPlayed); groupTabs.ItemChanged += (sender, value) => Group = value; sortTabs.ItemChanged += (sender, value) => Sort = value; }
public Group(GroupMode mode, string title, int offset = 0) { this.offset = offset; this.Mode = mode; this.Title = title; }
private void SetGroupMode(GroupMode value) { this.groupMode = value; this.Instruments = this.Instruments; }
public InstrumentSelectorPanel() { this.InitializeComponent(); this.treeView.TreeViewNodeSorter = (IComparer) new InstrumentListNodeSorter(); this.groupMode = GroupMode.None; }
public void AddEdge(IEdge edge) { if (IsEdgeExcluded(edge)) { return; } String edgeRealizerName = edgeRealizerOverride ?? realizers.GetEdgeRealizer(edge.Type, dumpInfo); String edgeName = graph.GetElementName(edge); String srcName = graph.GetElementName(edge.Source); String tgtName = graph.GetElementName(edge.Target); if (edge.Source != edge.Target) { GroupNodeType srcGroupNodeType = dumpInfo.GetGroupNodeType(edge.Source.Type); GroupNodeType tgtGroupNodeType = dumpInfo.GetGroupNodeType(edge.Target.Type); INode groupNodeFirst = null, groupNodeSecond = null; if (tgtGroupNodeType != null) { groupNodeFirst = edge.Target; } if (srcGroupNodeType != null) { if (groupNodeFirst == null) { groupNodeFirst = edge.Source; } else if (srcGroupNodeType.Priority > tgtGroupNodeType.Priority) { groupNodeSecond = groupNodeFirst; groupNodeFirst = edge.Source; } else { groupNodeSecond = edge.Source; } } GroupMode grpMode = GroupMode.None; bool groupedNode = false; if (groupNodeFirst != null) { groupedNode = TryGroupNode(groupNodeFirst, edge, srcName, tgtName, srcGroupNodeType, tgtGroupNodeType, ref grpMode); if (!groupedNode && groupNodeSecond != null) { groupedNode = TryGroupNode(groupNodeSecond, edge, srcName, tgtName, srcGroupNodeType, tgtGroupNodeType, ref grpMode); } } // If no grouping rule applies, grpMode is GroupMode.None (= 0) if ((grpMode & GroupMode.Hidden) != 0) { hiddenEdges[edge] = true; isDirty = true; isLayoutDirty = true; return; } } ycompStream.Write("addEdge \"e" + edgeName + "\" \"n" + srcName + "\" \"n" + tgtName + "\" \"" + edgeRealizerName + "\" \"" + GetElemLabel(edge) + "\"\n"); foreach (AttributeType attrType in edge.Type.AttributeTypes) { string attrTypeString; string attrValueString; EncodeAttr(attrType, edge, out attrTypeString, out attrValueString); ycompStream.Write("changeEdgeAttr \"e" + edgeName + "\" \"" + attrType.OwnerType.Name + "::" + attrType.Name + " : " + attrTypeString + "\" \"" + attrValueString + "\"\n"); } isDirty = true; isLayoutDirty = true; }
/// <summary> /// 分组 /// </summary> /// <param name="flux"></param> /// <param name="columns"></param> /// <param name="mode"></param> /// <returns></returns> public static IFlux Group(this IFlux flux, Columns columns, GroupMode mode = GroupMode.By) { return(flux.Pipe(@$ "group(columns: {columns}, mode: " "{mode.ToString().ToLower()}" ")", SingleQuotesBehavior.NoReplace)); }
private void tsbGroup_ByCurrency_Click(object sender, EventArgs e) { this.ActiveGroupMode = GroupMode.Currency; }
private void tsbGroup_ByMaturity_Click(object sender, EventArgs e) { this.ActiveGroupMode = GroupMode.Maturity; }
private bool TryGroupNode(INode groupNode, IEdge edge, String srcName, String tgtName, GroupNodeType srcGroupNodeType, GroupNodeType tgtGroupNodeType, ref GroupMode grpMode) { if (groupNode == edge.Target) { grpMode = tgtGroupNodeType.GetEdgeGroupMode(edge.Type, edge.Source.Type); if ((grpMode & GroupMode.GroupIncomingNodes) != 0) { ycompStream.Write("moveNode \"n" + srcName + "\" \"n" + tgtName + "\"\n"); return(true); } } else if (groupNode == edge.Source) { grpMode = srcGroupNodeType.GetEdgeGroupMode(edge.Type, edge.Target.Type); if ((grpMode & GroupMode.GroupOutgoingNodes) != 0) { ycompStream.Write("moveNode \"n" + tgtName + "\" \"n" + srcName + "\"\n"); return(true); } } return(false); }
public Group(GroupMode mode, string title, DayOfWeek dayOfWeek) { this.dayOfWeek = dayOfWeek; this.Mode = mode; this.Title = title; }
protected ListViewItem GetFileItem(DossierFileInfo file, GroupMode mode) { ListViewItem item = new ListViewItem(); item.Text = file.Name; item.Tag = file; if (file.IsSystem) { item.ForeColor = Color.Red; } else if (file.IsHidden) { item.ForeColor = Color.DarkGray; } else if (file.IsEncrypted) { item.ForeColor = Color.Green; } else if (file.IsCompressed) { item.ForeColor = Color.Blue; } if (file.IsVerified) { item.BackColor = Color.Honeydew; } else if (file.Hash != Guid.Empty) { item.BackColor = Color.LemonChiffon; } item.ImageKey = file.Type.ToString(); if (this.View == View.Details) { item.SubItems.Add(file.Type.ToString()); item.SubItems.Add(Dossier.BytesDisplayText(file.Size)); item.SubItems.Add(file.DisplayDate); } if (mode == GroupMode.Folder) { DossierFolderInfo root = (DossierFolderInfo)this.Items[0].Tag; int length = file.Parent.FullPath.Length; if (length > root.FullPath.Length) { length = root.FullPath.Length + 1; } item.Group = this.GetGroup(file.Parent.FullPath.Substring(length)); } else if (mode == GroupMode.Type) { if (file.Type == DossierTypes.Text) { item.Group = this.GetGroup(DossierTypes.Text.ToString()); } else if (file.Type == DossierTypes.Audio) { item.Group = this.GetGroup(DossierTypes.Audio.ToString()); } else if (file.Type == DossierTypes.Image) { item.Group = this.GetGroup(DossierTypes.Image.ToString()); } else if (file.Type == DossierTypes.Video) { item.Group = this.GetGroup(DossierTypes.Video.ToString()); } else { item.Group = this.GetGroup(DossierTypes.File.ToString()); } } else { item.Group = null; } return(item); }
private void tsbGroup_BySector_Click(object sender, EventArgs e) { this.ActiveGroupMode = GroupMode.Sector; }
private void tsbGroup_Alphabetically_Click(object sender, EventArgs e) { this.ActiveGroupMode = GroupMode.Alphabet; }
private void tsbGroup_ByExchange_Click(object sender, EventArgs e) { this.ActiveGroupMode = GroupMode.Exchange; }
private void tsbGroup_None_Click(object sender, EventArgs e) { this.ActiveGroupMode = GroupMode.None; }
protected List <ListViewItem> GetFileItems(DossierFolderInfo folder, int recurse, GroupMode mode) { List <ListViewItem> items = new List <ListViewItem>(); foreach (DossierFileInfo file in folder.Files) { items.Add(GetFileItem(file, mode)); } if (recurse > 1) { foreach (DossierFolderInfo sub in folder.Folders) { items.AddRange(GetFileItems(sub, recurse - 1, mode)); } } return(items); }
public FilterControl() { Children = new Drawable[] { Background = new Box { Colour = Color4.Black, Alpha = 0.8f, RelativeSizeAxes = Axes.Both, }, new Container { Padding = new MarginPadding(20), RelativeSizeAxes = Axes.Both, Width = 0.5f, Anchor = Anchor.TopRight, Origin = Anchor.TopRight, Children = new Drawable[] { searchTextBox = new SearchTextBox { RelativeSizeAxes = Axes.X, Exit = () => Exit?.Invoke(), }, new Box { RelativeSizeAxes = Axes.X, Height = 1, Colour = OsuColour.Gray(80), Origin = Anchor.BottomLeft, Anchor = Anchor.BottomLeft, }, new FillFlowContainer { Anchor = Anchor.BottomRight, Origin = Anchor.BottomRight, Direction = FillDirection.Horizontal, RelativeSizeAxes = Axes.X, AutoSizeAxes = Axes.Y, Children = new Drawable[] { groupTabs = new OsuTabControl <GroupMode> { RelativeSizeAxes = Axes.X, Height = 24, Width = 0.5f, AutoSort = true }, //spriteText = new OsuSpriteText //{ // Font = @"Exo2.0-Bold", // Text = "Sort results by", // Size = 14, // Margin = new MarginPadding // { // Top = 5, // Bottom = 5 // }, //}, sortTabs = new OsuTabControl <SortMode> { RelativeSizeAxes = Axes.X, Width = 0.5f, Height = 24, AutoSort = true, } } }, } } }; searchTextBox.Current.ValueChanged += t => FilterChanged?.Invoke(CreateCriteria()); groupTabs.PinItem(GroupMode.All); groupTabs.PinItem(GroupMode.RecentlyPlayed); groupTabs.Current.ValueChanged += val => Group = val; sortTabs.Current.ValueChanged += val => Sort = val; }
internal void Append(object value, GroupMode mode) { if (value == null) return; Pattern pattern = value as Pattern; if (pattern != null) { Append(pattern); return; } string text = value as string; if (text != null) { Append(text); return; } if (value is char) { Append((char)value); return; } CharGrouping charGrouping = value as CharGrouping; if (charGrouping != null) { Append(charGrouping); return; } object[] values = value as object[]; if (values != null) { Append(values, mode); return; } IEnumerable items = value as IEnumerable; if (items != null) Append(items, mode); }
/// <summary> /// Adds or extends a GroupNodeType. /// All nodes connected via the given edge type and fulfilling the GroupType condition are placed inside a group /// corresponding to the according group node. The edges which lead to the grouping are not displayed. /// The group node types are ordered by the time of creation. Groups of group node types created later /// will be moved into groups of group node types created earlier. /// </summary> /// <param name="nodeType">The node type of the group node.</param> /// <param name="exactNodeType">True, if the node type must be exact, false, if also subtypes are allowed.</param> /// <param name="edgeType">An edge type along which nodes are grouped.</param> /// <param name="exactEdgeType">True, if the edge type must be exact, false, if also subtypes are allowed.</param> /// <param name="incNodeType">The incident node type according to the edge.</param> /// <param name="exactIncNodeType">True, if the incident node type must be exact, false, if also subtypes are allowed.</param> /// <param name="groupMode">Specifies how the edge is used for grouping.</param> public void AddOrExtendGroupNodeType(NodeType nodeType, bool exactNodeType, EdgeType edgeType, bool exactEdgeType, NodeType incNodeType, bool exactIncNodeType, GroupMode groupMode) { foreach (NodeType subType in nodeType.SubOrSameTypes) { GroupNodeType groupNodeType; if (!nodeTypeToGroupNodeType.TryGetValue(subType, out groupNodeType)) { groupNodeType = new GroupNodeType(subType, nextGroupID--); nodeTypeToGroupNodeType[subType] = groupNodeType; groupNodeTypes.Add(groupNodeType); } groupNodeType.SetEdgeGroupMode(edgeType, exactEdgeType, incNodeType, exactIncNodeType, groupMode); if (exactNodeType) { break; // don't change group modes for any subtypes } } }
private void Append(object[] values, GroupMode mode) { if (values.Length > 0) { if (mode == GroupMode.Group) AppendNumberedGroupStart(); else if (mode == GroupMode.NoncapturingGroup) AppendNoncapturingGroupStart(); _pendingOr = false; int length = Length; for (int i = 0; i < values.Length; i++) { _pendingOr = _pendingOr || (Length > length); length = Length; Append(values[i]); } _pendingOr = false; if (mode != GroupMode.None) AppendGroupEnd(); } }