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;
}
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);
}
public InstrumentSelectorPanel()
{
this.InitializeComponent();
this.treeView.TreeViewNodeSorter = (IComparer) new InstrumentListNodeSorter();
this.groupMode = GroupMode.None;
}
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_ByGroup_Click(object sender, EventArgs e)
{
this.ActiveGroupMode = GroupMode.Group;
}
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;
}
private void tsbGroup_ByMaturity_Click(object sender, EventArgs e)
{
this.ActiveGroupMode = GroupMode.Maturity;
}
private void tsbGroup_None_Click(object sender, EventArgs e)
{
this.ActiveGroupMode = GroupMode.None;
}
private void tsbGroup_BySector_Click(object sender, EventArgs e)
{
this.ActiveGroupMode = GroupMode.Sector;
}
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();
}
}
