protected override void SelectGroups(List <MutableObject> entry)
{
SelectedList = new List <MutableObject>();
UnSelectedList = new List <MutableObject>();
var selectedListOnly = SelectedListOnly.GetFirstValue(entry.First());
int entryCount = 0;
var maxEntries = NumberOfEntries.GetValue(entry);
foreach (var subEntry in EntryField.GetEntries(entry))
{
if (entryCount++ < maxEntries)
{
SelectedList.Add(subEntry.Last());
}
else
{
if (selectedListOnly)
{
break;
}
UnSelectedList.Add(subEntry.Last());
}
}
}
protected override IEnumerator ProcessPayload(VisualPayload payload)
{
var filledGraph = VisualizerFactory.InstantiateFilledGraph();
filledGraph.Initialize(this, payload);
AssignStates(filledGraph);
var mainColor = MainColor.GetFirstValue(payload.Data);
foreach (var entry in EntryField.GetEntries(payload.Data))
{
filledGraph.AddPoint(ZAxis.GetValue(entry),
YAxis.GetValue(entry));
}
filledGraph.SetGraphData(
mainColor);
filledGraph.ApplyPoints();
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
//payload.VisualData.Bound.Data = payload.Data;
var metaEntries = EntryField.GetEntries(payload.Data);
var createdPayloads = new List <VisualPayload>();
foreach (var metaEntry in metaEntries)
{
// foreach ( var entry in entries )
// {
var newBound = payload.VisualData.Bound.CreateDependingBound(Name);
var newPayload = new VisualPayload(metaEntry.Last(), new VisualDescription(newBound));
//newBound.Data = metaEntry.Last();
createdPayloads.Add(newPayload);
}
MetaSelectionSet selectionManager = MetaSelectionSet.ConstructPayloadSelectionSet(
payload.VisualData.Bound, createdPayloads,
NormalState, SelectedState, NoneSelectedState,
NormalStateMulti, SelectedStateMulti, NoneSelectedStateMulti);
var iterator = selectionManager.TransmitAll();
while (iterator.MoveNext())
{
yield return(null);
}
}
protected override void OnProcessOutputSchema(MutableObject newSchema)
{
foreach (var entry in Scope.GetEntries(newSchema))
{
SelectGroups(entry);
var firstEntry = EntryField.GetEntries(entry).First().Last();
if (firstEntry != null)
{
firstEntry = firstEntry.CloneKeys();
}
else
{
firstEntry = new MutableObject();
}
if (!firstEntry.ContainsKey(ImplicitSchemaIndicator.KeyName))
{
firstEntry.Add(ImplicitSchemaIndicator.KeyName, new ImplicitSchemaIndicator(this));
}
DenoteEmptySelectedList(newSchema, firstEntry);
DenoteEmptyUnSelectedList(newSchema, firstEntry);
if (!NewPayloadOnly.GetFirstValue(newSchema))
{
SelectedListTarget.SetValue(SelectedList, entry);
UnSelectedListTarget.SetValue(UnSelectedList, entry);
}
}
if (!NewPayloadOnly.GetFirstValue(newSchema))
{
SelectedSet.TransmitSchema(newSchema);
UnSelectedSet.TransmitSchema(newSchema);
}
else
{
SelectedSet.TransmitSchema(new MutableObject
{
{ SelectedListTarget.LastKey, SelectedList }
});
UnSelectedSet.TransmitSchema(new MutableObject
{
{ UnSelectedListTarget.LastKey, UnSelectedList }
});
}
}
protected override void SelectGroups(List <MutableObject> entry)
{
SelectedList = new List <MutableObject>();
UnSelectedList = new List <MutableObject>();
foreach (var element in EntryField.GetEntries(entry))
{
if (IsComms(element))
{
SelectedList.Add(element.Last());
}
else
{
UnSelectedList.Add(element.Last());
}
}
}
protected override void SelectGroups(List <MutableObject> entry)
{
SelectedList = new List <MutableObject>();
UnSelectedList = new List <MutableObject>();
foreach (var subEntry in EntryField.GetEntries(entry))
{
if (SelectedBool.GetValue(subEntry))
{
SelectedList.Add(subEntry.Last());
}
else
{
UnSelectedList.Add(subEntry.Last());
}
}
}
protected override void OnProcessOutputSchema(MutableObject newSchema)
{
SelectGroups(newSchema);
var firstEntry = EntryField.GetEntries(newSchema).First().Last();
if (firstEntry != null)
{
firstEntry = firstEntry.CloneKeys();
}
else
{
firstEntry = new MutableObject();
}
if (!firstEntry.ContainsKey(GroupSplitter.ImplicitSchemaIndicator.KeyName))
{
firstEntry.Add(GroupSplitter.ImplicitSchemaIndicator.KeyName, new GroupSplitter.ImplicitSchemaIndicator(this));
}
var outgoingList = SelectedList.Count == 0
? new List <MutableObject> {
firstEntry
}
: SelectedList;
MutableObject outgoingSchema;
if (NewPayloadOnly.GetFirstValue(newSchema))
{
outgoingSchema = new MutableObject();
outgoingSchema[EntryFieldName] = outgoingList;
}
else
{
outgoingSchema = newSchema;
SelectedListTarget.SetValue(outgoingList, outgoingSchema);
}
SelectedSet.TransmitSchema(outgoingSchema);
}
protected override void SelectGroups(MutableObject mutable)
{
var numberOfEntries = NumberOfEntries.GetFirstValue(mutable);
SelectedList = new List <MutableObject>();
int entryCount = 0;
foreach (var entry in EntryField.GetEntries(mutable))
{
if (++entryCount > numberOfEntries)
{
break;
}
SelectedList.Add(entry.Last());
}
}
protected override void SelectGroups(List <MutableObject> entry)
{
SelectedList = new List <MutableObject>();
UnSelectedList = new List <MutableObject>();
var stringArg = StringArgument.GetValue(entry);
var stringTokens = stringArg.Split(',');
foreach (var subEntry in EntryField.GetEntries(entry))
{
if (IsSelected(subEntry, stringTokens))
{
SelectedList.Add(subEntry.Last());
}
else
{
UnSelectedList.Add(subEntry.Last());
}
}
//Debug.LogFormat( "Selected {0}, did not select {1}", SelectedList.Count, UnSelectedList.Count );
}
protected override void OnProcessOutputSchema(MutableObject newSchema)
{
var entry = EntryField.GetEntries(newSchema);
var foundEntries = entry.ToList();
if (!foundEntries.Any())
{
Debug.Log("No valid entries in " + EntryField.AbsoluteKey);
Router.TransmitAllSchema(new MutableObject());
return;
}
MutableObject outMutable = null;
foreach (var foundEntry in EntryField.GetEntries(newSchema))
{
outMutable = foundEntry.Last();
break;
}
NormalState.TransmitSchema(outMutable);
SelectedState.TransmitSchema(outMutable);
NoneSelectedState.TransmitSchema(outMutable);
var multiSchema = new MutableObject()
{
{ "Entries", new List <MutableObject> {
outMutable
} }
};
NormalStateMulti.TransmitSchema(multiSchema);
SelectedStateMulti.TransmitSchema(multiSchema);
NoneSelectedStateMulti.TransmitSchema(multiSchema);
}
protected override void SelectGroups(List <MutableObject> entry)
{
SelectedList.Clear();
UnSelectedList.Clear();
var maintainCountAtEdges = MaintainCountAtEdgesField.GetLastKeyValue(entry.Last());
var entries = EntryField.GetEntries(entry);
var entriesCount = entries.Count();
if (entriesCount == 0)
{
Debug.LogError("What? Empty entries?");
}
var beforeWidth = SelectBeforeCount.GetLastKeyValue(entry.Last());
var afterWidth = SelectAfterCount.GetLastKeyValue(entry.Last());
var lowerBound = maintainCountAtEdges?Mathf.Min(beforeWidth, entriesCount - 1):0;
var upperBound = maintainCountAtEdges ? Mathf.Max(entriesCount - afterWidth - 1, 0) : entriesCount - 1;
if (lowerBound >= upperBound)
{
// use the lower of the two values for both bounds to avoid overlap
lowerBound = Mathf.Min(lowerBound, upperBound);
upperBound = Mathf.Min(lowerBound, upperBound);
}
var index = Mathf.Clamp(CenterIndex.GetLastKeyValue(entry.Last()),
lowerBound, upperBound);
var minIndex = Mathf.Max(index - beforeWidth, 0);
var maxIndex = Mathf.Min(index + afterWidth, entriesCount - 1);
//var i = 0;
//foreach ( var entry in entries )
//{
// if ( i < minIndex )
// UnSelectedList.
//}
bool selectedListOnly = SelectedListOnly.GetValue(entry);
int currentIndex = 0;
if (selectedListOnly)
{
foreach (var subEntry in EntryField.GetEntries(entry))
{
if (currentIndex > maxIndex)
{
break;
}
if (currentIndex >= minIndex)
{
SelectedList.Add(subEntry.Last());
}
currentIndex++;
}
}
else
{
foreach (var subEntry in EntryField.GetEntries(entry))
{
if (currentIndex < minIndex || currentIndex > maxIndex)
{
UnSelectedList.Add(subEntry.Last());
}
else
{
SelectedList.Add(subEntry.Last());
}
currentIndex++;
}
}
}
