/// <summary>
/// MethodeParameter Handling (normal starting with "in", out param starting wit "out")
/// </summary>
public override string MethodeInParameter(FieldContainer inMethodeParameter)
{
var tmpName = inMethodeParameter.Name;
if (RegexHelper.NameStartsWith_In.IsMatch(tmpName))
{
tmpName = tmpName.Substring(2);
}
else if (RegexHelper.NameStartsWith_Out.IsMatch(tmpName))
{
tmpName = tmpName.Substring(3);
}
else if (RegexHelper.NameStartsWith_Tmp.IsMatch(tmpName))
{
tmpName = tmpName.Substring(3);
}
if (!RegexHelper.IsFirstCharUpper(tmpName))
{
tmpName = tmpName[0].ToString().ToUpper() + tmpName.Substring(1);
}
if (inMethodeParameter.ModifierList.Contains("out"))
{
return("out" + tmpName);
}
return("in" + tmpName);
}
void OnMouseUp()
{
if (xAxisFree || yAxisFree)
{
yAxisFree = false;
xAxisFree = false;
if (translatedObjects != null && translatedObjects.Count > 0)
{
while (translatedObjects.Count > 0)
{
FieldElement tempField = new FieldElement(new Vector2(100, 100));
foreach (FieldElement field in translatedObjects)
{
if (Vector2.Distance(field.Coordinate, FieldContainer.GetFreeFieldElement().Coordinate) < Vector2.Distance(tempField.Coordinate, FieldContainer.GetFreeFieldElement().Coordinate))
{
tempField = field;
}
}
MovementHandler.newHoldPoint(tempField.fieldObject);
tempField.fieldObject.transform.DOLocalMove(MovementHandler.GetObjectPosition(tempField.fieldObject), 0.5f);
translatedObjects.Remove(tempField);
}
translatedObjects.Clear();
}
MovementHandler.newHoldPoint(this.gameObject);
gameObject.transform.DOLocalMove(MovementHandler.GetObjectPosition(this.gameObject), 0.5f);
ResultHandler.CheckResult();
}
}
internal void ValidateMemberName(FieldContainer field, string lastName)
{
if (field != null)
{
bool duplicated = false;
FieldContainer c;
foreach (var item in m_content.Controls)
{
c = item as FieldContainer;
if (c != null && c != field)
{
if (c.MemberName == field.MemberName)
{
duplicated = true;
c.ValidMemberName = false;
}
if (!c.ValidMemberName && c.LastMemberName == lastName)
{
c.ValidMemberName = true;
}
}
}
field.ValidMemberName = !duplicated;
}
}
public void FieldContainerTest()
{
int testValue = 5;
Field field1 = new Field(1);
Field field2 = new Field(2);
Field field3 = new Field(3);
Field field4 = new Field(4);
Field field5 = new Field(5);
Field field6 = new Field(6);
Field field7 = new Field(7);
Field field8 = new Field(8);
Field field9 = new Field(9);
FieldContainer row1 = new FieldContainer(field1, field2, field3, field4, field5, field6, field7, field8, field9);
Field field12 = new Field(12);
Field field13 = new Field(13);
Field field14 = new Field(14);
Field field15 = new Field(15);
Field field16 = new Field(16);
Field field17 = new Field(17);
Field field18 = new Field(18);
Field field19 = new Field(19);
FieldContainer column1 = new FieldContainer(field1, field12, field13, field14, field15, field16, field17, field18, field19);
field1.FieldValue = testValue;
Assert.IsFalse(field14.IsValuePossible(testValue));
}
public static void newHoldPoint(GameObject obj)
{
Vector2 originalVectorPosition = FieldContainer.GetFieldElementByGameObject(obj).Coordinate;
Vector2 newVectorPosition = FieldContainer.GetFieldElementByGameObject(obj).Coordinate;
float distance = Vector2.Distance(FieldContainer.GetFieldElementByGameObject(obj).Coordinate, (Vector2)obj.transform.localPosition);
bool isChanged = false;
foreach (FieldElement field in FieldContainer.GetCollection())
{
if (field.isFree)
{
float tempDistance = Vector2.Distance(field.Coordinate, (Vector2)obj.transform.localPosition);
if (tempDistance <= distance)
{
newVectorPosition = field.Coordinate;
isChanged = true;
}
}
}
FieldContainer.SetNewCoordinates(obj, newVectorPosition);
if (isChanged)
{
FieldContainer.GetFreeFieldElement().Coordinate = originalVectorPosition;
}
}
public void Set(FieldContainer entity, IFieldDefinition field, File file)
{
var options = field.Option as Litium.FieldFramework.FieldTypes.PointerOption;
var pointerType = GetTypeFor(options.EntityType);
if (!pointerType.IsInstanceOfType(file))
{
throw new Exception($"An object of type {file.GetType()} can not be set to a pointer ({field.Id}) of type {options.EntityType}");
}
if (options.MultiSelect)
{
var files = entity.GetValue <List <PointerItem> >(field.Id)?
.Select(r => _mediaArchive.GetFile(r.EntitySystemId))
.Where(r => r != null)
.ToList() ?? new List <File>();
files.RemoveAll(r => string.Equals(r.Name, file.Name, StringComparison.OrdinalIgnoreCase));
files.Add(_mediaArchive.GetFile(file.SystemId));
Sort?.Invoke(entity, field, files);
entity.AddOrUpdateValue(field.Id, files.Select(r => new PointerItem()
{
EntitySystemId = r.SystemId
}).ToList());
}
else
{
entity.AddOrUpdateValue(field.Id, new PointerItem()
{
EntitySystemId = file.SystemId
});
}
}
internal override void ResolveFields(ModuleData data, FieldContainer container)
{
var resolved = container.ResolveField(SchemaField.SwitchPath);
switchField = data.GetDataField(resolved.container, resolved.field);
RefreshInstrumentFields();
}
/// <summary>
/// 初始化 BeginEndDateBox 控件 FieldContainer=DateField+DateField
/// </summary>
/// <param name="paramField_Start"></param>
/// <param name="field"></param>
/// <param name="container"></param>
/// <param name="isReadonly"></param>
private void IniParamBeginEndDateBox(string paramField_Start, ParamField field, Container container, bool isReadonly)
{
if (field.Type != ParamFieldType.BeginEndDateBox)
{
return;
}
Caption caption = uiHelper.UiData.GetCaption(field.Caption, field.FieldName);
FieldContainer result = new FieldContainer();
string fieldName = paramField_Start + field.FieldName;
this.IniAllParamField(fieldName, field);
result.ID = fieldName;
result.FieldLabel = caption.Value;
result.LabelWidth = 80;
result.LabelAlign = LabelAlign.Right;
result.Layout = LayoutType.HBox.ToString();
result.Flex = 1;
var defaultValue = field.DefaultValue;
if (string.IsNullOrWhiteSpace(defaultValue))
{
defaultValue = string.Empty;
}
var values = defaultValue.Split('|');
var dateFields = new List <DateField>();
dateFields.Add(new DateField()
{
ID = result.ID + UiHelper.BEGIN_DATE_STATE_END, FieldLabel = "起"
});
dateFields.Add(new DateField()
{
ID = result.ID + UiHelper.END_DATE_STATE_END, FieldLabel = "止"
});
for (int i = 0; i < dateFields.Count; i++)
{
var dateField = dateFields[i];
dateField.LabelWidth = 20;
dateField.LabelSeparator = string.Empty;
dateField.LabelAlign = LabelAlign.Right;
dateField.Format = "yyyy-MM-dd";
dateField.Flex = 1;
DateTime?dateFieldValue = DateTime.Now;
if (values.Length > i)
{
dateFieldValue = getDefaultDateTime(values[i]);
}
if (dateFieldValue != null)
{
dateField.Text = ((DateTime)dateFieldValue).ToString(dateField.Format);
}
if (isReadonly || field.ReadOnly)
{
dateField.ReadOnly = true;
}
result.Items.Add(dateField);
}
container.Add(result);
}
public static bool CanBeMoved(Vector3 verifiableVector)
{
if (FieldContainer.GetExtremeBorderPoint1().x > verifiableVector.x && FieldContainer.GetExtremeBorderPoint1().y > verifiableVector.y && FieldContainer.GetExtremeBorderPoint2().x < verifiableVector.x && FieldContainer.GetExtremeBorderPoint2().y < verifiableVector.y)
{
return(true);
}
return(false);
}
internal void RemoveItem(FieldContainer field)
{
if (m_content.Controls.Contains(field))
{
m_content.Controls.Remove(field);
RepositionList();
}
}
/// <summary>
/// Manage Code inside Methode
/// </summary>
/// <param name="inMethodeContainer"></param>
/// <param name="inClass"></param>
private void ManageField(Dictionary <string, List <BaseType> > inDictionary, FieldContainer inMethodeContainer, ClassContainer inClass)
{
ManageTypeContainer(inDictionary, inMethodeContainer.Type, inClass);
if (inMethodeContainer.DefaultValue != null)
{
CodeEntryHandling(inMethodeContainer.DefaultValue.CodeEntries[0], new FieldNameFinder(inClass));
}
}
public TagStruct(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
string name_string = null;
s.ReadAttribute("name", ref name_string);
Name = name_string;
Fields = new FieldContainer();
}
public void LinkEncoderField <T>(T value, string expected)
{
var decoded = new FieldContainer <T> {
Field = value
};
var encoded = LinkerTester.Encode(Linker.CreateEncoder(new JSONSchema <FieldContainer <T> >()), decoded);
Assert.AreEqual(expected, Encoding.UTF8.GetString(encoded));
}
private static DataSegment CreateDataSegment(FieldContainer fieldContainer, IReadOnlyList <IDataField> fields)
{
var segment = new DataSegment(fieldContainer.Address, new byte[fieldContainer.Size]);
foreach (DataFieldBase field in fields)
{
field.Save(segment);
}
return(segment);
}
internal override void ResolveFields(ModuleData data, FieldContainer container)
{
var resolved = container.ResolveField(SchemaField.SwitchPath);
switchField = data.GetDataField(resolved.container, resolved.field);
// We never unsubscribe from this, but that's okay: we expect the lifetime of the
// data fields to be the same as the lifetime of the containing ModuleData.
switchField.PropertyChanged += SwitchFieldChanged;
RefreshInstrumentFields();
}
private DataSegment CreateDataSegment(FieldContainer fieldContainer, IReadOnlyList <IDataField> fields)
{
var segment = originalSegmentsByFieldContainer[fieldContainer].Clone();
foreach (DataFieldBase field in fields)
{
field.Save(segment);
}
return(segment);
}
private void Start()
{
fieldGUI = transform.GetComponent <FieldGUI>();
fieldUI = transform.GetComponent <FieldUI>();
fieldContainer = transform.GetComponent <FieldContainer>();
fieldContainerUI = transform.GetComponent <FieldContainerUI>();
settingsGUI = transform.GetComponent <SettingsGUI>();
panel = transform.GetComponent <Panel>();
isingAlgorithm = transform.GetComponent <IsingAlgorithm>();
}
/// <summary>
/// Initializes a new instance of the <see cref="IdentifiedFeatureViewModel"/> class.
/// </summary>
public IdentifiedFeatureViewModel(Feature feature, FeatureTable featureTable, ConnectivityMode connectivityMode)
{
if (feature != null)
{
Feature = feature;
PopupManager = new PopupManager(new Popup(feature, featureTable.PopupDefinition));
Fields = FieldContainer.GetFields(PopupManager);
FeatureTable = featureTable;
ConnectivityMode = connectivityMode;
}
}
/// <summary>
/// 初始化 BeginEndTextBox 控件 FieldContainer=TextField+TextField
/// </summary>
/// <param name="paramField_Start"></param>
/// <param name="field"></param>
/// <param name="container"></param>
/// <param name="isReadonly"></param>
private void IniParamBeginEndTextBox(string paramField_Start, ParamField field, Container container, bool isReadonly)
{
if (field.Type != ParamFieldType.BeginEndTextBox)
{
return;
}
Caption caption = uiHelper.UiData.GetCaption(field.Caption, field.FieldName);
FieldContainer result = new FieldContainer();
string fieldName = paramField_Start + field.FieldName;
this.IniAllParamField(fieldName, field);
result.ID = fieldName;
result.FieldLabel = caption.Value;
result.LabelWidth = 80;
result.LabelAlign = LabelAlign.Right;
result.Layout = LayoutType.HBox.ToString();
result.Flex = 1;
var defaultValue = field.DefaultValue;
if (string.IsNullOrWhiteSpace(defaultValue))
{
defaultValue = string.Empty;
}
var values = defaultValue.Split('|');
var textFields = new List <TextField>();
textFields.Add(new TextField()
{
ID = result.ID + UiHelper.BEGIN_TEXT_STATE_END, FieldLabel = "起"
});
textFields.Add(new TextField()
{
ID = result.ID + UiHelper.END_TEXT_STATE_END, FieldLabel = "止"
});
for (int i = 0; i < textFields.Count; i++)
{
var textField = textFields[i];
textField.LabelWidth = 16;
textField.LabelSeparator = string.Empty;
textField.LabelAlign = LabelAlign.Right;
textField.Flex = 1;
if ((values.Length > i) && (!string.IsNullOrWhiteSpace(values[i])))
{
textField.Text = values[i];
}
if (isReadonly || field.ReadOnly)
{
textField.ReadOnly = true;
}
result.Items.Add(textField);
}
container.Add(result);
}
async void TapGestureRecognizer_Tapped(System.Object sender, System.EventArgs e)
{
FieldContainer.TranslationX = Width;
FieldContainer.IsVisible = true;
ProfileContainer.TranslationY = 120;
await Task.WhenAll(
ProfileContainer.TranslateTo(ProfileContainer.TranslationX, 0, 400, easing: Easing.CubicInOut),
FieldContainer.TranslateTo(0, FieldContainer.TranslationY, 400, easing: Easing.CubicInOut),
Name.FadeTo(0, 400)
);
}
public static bool HasXRowFreeField(float xValue)
{
foreach (FieldElement field in FieldContainer.GetCollection())
{
if (field.Coordinate.x == xValue && field.isFree)
{
//Debug.Log(field.Coordinate + "\n" + xValue);
return(true);
}
}
return(false);
}
/// <summary>
/// Add Field to Class
/// </summary>
public static FieldContainer AddField(this ClassContainer inClass, string inFieldName, BaseType inType, string inDefaultValue = null, params FieldAttributes[] inAttributes)
{
var tmpFieldContainer = new FieldContainer()
{
Name = inFieldName,
Type = new TypeContainer {
Type = inType, Name = inType.Name
}
};
inClass.FieldList.Add(tmpFieldContainer);
return(tmpFieldContainer);
}
private FieldContainer GetFieldContainer(
FilterHtmlGenerator.Filter filterData,
SelectBox selectBox)
{
var fieldContainer = new FieldContainer(StandartConfigFilterFieldContainer(filterData))
{
ID = RegistrationControlToRepository(UniquePrefixes.FieldContainerCommon, filterData),
ClientIDMode = ClientIDMode.Static,
};
fieldContainer.Items.Add(selectBox);
return(fieldContainer);
}
//Starts a whole new game
public bool Start()
{
if (matchRunning)
{
return(!matchRunning);
}
FieldContainer.Send();
GameField.Instance.LoadMap("new/Moveables/test_map16");
GameField.Instance.AddControlInterface(Control.Instance.ControlInterfaces);
Graphic.Instance.Start();
Control.Instance.readKeyLoop();
matchRunning = true;
return(true);
}
public static Vector3 GetObjectPosition(GameObject obj)
{
Vector3 vect = new Vector3();
foreach (FieldElement field in FieldContainer.GetCollection())
{
if (field.fieldObject != null && obj.GetInstanceID() == field.fieldObject.GetInstanceID())
{
vect = field.Coordinate;
}
}
vect.z = FieldContainer.zValue;
return(vect);
}
private void RebuildList()
{
m_content.Controls.Clear();
if (string.IsNullOrEmpty(m_jsonResult))
{
return;
}
try
{
Newtonsoft.Json.Linq.JContainer collection = Newtonsoft.Json.JsonConvert.DeserializeObject <Newtonsoft.Json.Linq.JContainer>(m_jsonResult);
if (collection.Type == Newtonsoft.Json.Linq.JTokenType.Array && m_collectionType == CollectionPropertyEditorUtils.CollectionType.JsonArray)
{
Newtonsoft.Json.Linq.JArray arr = collection as Newtonsoft.Json.Linq.JArray;
if (arr != null)
{
FieldContainer field;
foreach (var item in arr)
{
field = new FieldContainer(this, m_collectionType, m_creator, item.ToString(Newtonsoft.Json.Formatting.None));
field.Width = m_content.Width;
field.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
m_content.Controls.Add(field);
}
}
}
else if (collection.Type == Newtonsoft.Json.Linq.JTokenType.Object && m_collectionType == CollectionPropertyEditorUtils.CollectionType.JsonObject)
{
Newtonsoft.Json.Linq.JObject obj = collection as Newtonsoft.Json.Linq.JObject;
if (obj != null)
{
FieldContainer field;
foreach (var item in obj.Properties())
{
field = new FieldContainer(this, m_collectionType, m_creator, item.Value.ToString(Newtonsoft.Json.Formatting.None), item.Name);
field.Width = m_content.Width;
field.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
m_content.Controls.Add(field);
}
}
}
}
catch { }
RepositionList();
}
private void AddFieldtoString(StringBuilder inOutput, FieldContainer inField, int inIndentDepth)
{
AddComment(inOutput, inField.Comment, inIndentDepth, true);
var tmpFieldString = $"{ReturnModifiersOrdered(inField.ModifierList)}{CreateStringFromType(inField.Type)}{inField.Name}";
if (inField.DefaultValue != null)
{
var tmpSb = new StringBuilder();
AddCodeBlockToString(tmpSb, inField.DefaultValue, 0);
tmpFieldString = $"{tmpFieldString} = {tmpSb}";
inOutput.Append(CreateIndent(inIndentDepth) + tmpFieldString);
}
else
{
tmpFieldString += ";";
inOutput.AppendLine(CreateIndent(inIndentDepth) + tmpFieldString);
}
}
public void Set(FieldContainer entity, IFieldDefinition field, File file)
{
var images = entity.GetValue <List <Guid> >(field.Id)?
.Select(r => _mediaArchive.GetFile(r))
.Where(r => r != null)
.ToList() ?? new List <File>();
if (images.Any(r => r.SystemId == file.SystemId))
{
// Field already contain this file. Don't do anything.
return;
}
images.RemoveAll(r => string.Equals(r.Name, file.Name, StringComparison.OrdinalIgnoreCase));
images.Add(_mediaArchive.GetFile(file.SystemId));
Sort?.Invoke(entity, field, images);
entity.AddOrUpdateValue(field.Id, images.Select(r => r.SystemId).ToList());
}
internal void AddNewItem(FieldContainer after = null)
{
FieldContainer field = new FieldContainer(
this,
m_collectionType,
m_creator,
null,
m_collectionType == CollectionPropertyEditorUtils.CollectionType.JsonArray ? null : ""
);
field.Width = m_content.Width;
field.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
m_content.Controls.Add(field);
int index = after == null ? -1 : m_content.Controls.GetChildIndex(after);
if (index >= 0 && index < m_content.Controls.Count - 1)
{
m_content.Controls.SetChildIndex(field, index);
}
RepositionList();
}
public static List <FieldElement> GetOsculantObjects(Vector2 vect, bool onAxisX, bool onAxisY) //TODO
{
List <FieldElement> newList = new List <FieldElement>();
Vector2 freeFieldPosition = new Vector2();
foreach (FieldElement field in FieldContainer.GetCollection())
{
if (field.isFree)
{
freeFieldPosition = field.Coordinate;
}
}
foreach (FieldElement field in FieldContainer.GetCollection())
{
if (field.Coordinate != vect && onAxisX)
{
if (!field.isFree && vect.x == field.Coordinate.x && field.Coordinate.x == freeFieldPosition.x)
{
if ((vect.y > field.Coordinate.y && field.Coordinate.y > freeFieldPosition.y) || (vect.y < field.Coordinate.y && field.Coordinate.y < freeFieldPosition.y))
{
newList.Add(field);
}
}
}
if (field.Coordinate != vect && onAxisY)
{
if (!field.isFree && vect.y == field.Coordinate.y && field.Coordinate.y == freeFieldPosition.y)
{
if ((vect.x > field.Coordinate.x && field.Coordinate.x > freeFieldPosition.x) || (vect.x < field.Coordinate.x && field.Coordinate.x < freeFieldPosition.x))
{
newList.Add(field);
}
}
}
}
return(newList);
}
public TagStruct(BlamLib.CheApe.ProjectState state, IO.XmlStream s)
{
string name_string = null;
s.ReadAttribute("name", ref name_string);
Name = name_string;
Fields = new FieldContainer();
}
