public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
float height = singleLine * 1.25f;
float centerAmount = (height - singleLine) / 2;
float titleWidth = EditorHelpers.GetStringLengthinPix(label.text);
float widthVector = position.width - (height * 3) - titleWidth;
EditorGUI.LabelField(new Rect(position.x, position.y, titleWidth, height), label);
EditorGUI.PropertyField(new Rect(position.x + titleWidth, position.y + centerAmount, widthVector, height),
property, GUIContent.none);
var resetsContent = new GUIContent("R", "Resets the vector to " + Vector4.zero);
if (GUI.Button(new Rect(position.x + titleWidth + widthVector, position.y, height, height), resetsContent))
{
property.vector4Value = Vector4.zero;
}
var copyContent = new GUIContent("C", "Copies the vectors data.");
if (GUI.Button(new Rect(position.x + titleWidth + widthVector + height, position.y, height, height),
copyContent))
{
CopyPaste.EditorCopy(property.vector4Value);
}
var pasteContent = new GUIContent("P", "Pastes the vectors data.");
if (GUI.Button(
new Rect(position.x + titleWidth + widthVector + height + height, position.y, height, height),
pasteContent))
{
property.vector4Value = CopyPaste.Paste <Vector4>();
}
}
public override void ModelFinalize(CopyPaste.ModelProtoElement protoElement, CopyPaste.ModelProtoGroupMerger groupMerger)
{
base.ModelFinalize(protoElement, groupMerger);
RootDiagramNode node = new RootDiagramNode(this.Store);
node.PresentationElementClass = this;
this.DiagramClass.DiagramClassView.RootDiagramNodes.Add(node);
}
public ARScheduleMaint()
{
ARSetup ars = ARSetup.Current;
Document_History.Cache.AllowDelete = false;
Document_History.Cache.AllowInsert = false;
Document_History.Cache.AllowUpdate = false;
CopyPaste.SetVisible(false);
}
void Start()
{
playerState = EPlayerStates.Teleport;
itemSpawner = GetComponent <ItemSpawner>();
itemSelection = GetComponent <ItemSelection> ();
itemSelection2 = GetComponent <ItemSelection2> ();
copyPaste = GetComponent <CopyPaste>();
measureTool = GetComponent <MeasureTool>();
itemSpawner.enabled = false;
}
public CreateMatrixItems()
{
Save.SetVisible(false);
Insert.SetVisible(false);
Delete.SetVisible(false);
CopyPaste.SetVisible(false);
Next.SetVisible(false);
Previous.SetVisible(false);
First.SetVisible(false);
Last.SetVisible(false);
}
public override void ModelFinalize(CopyPaste.ModelProtoElement protoElement, CopyPaste.ModelProtoGroupMerger groupMerger)
{
base.ModelFinalize(protoElement, groupMerger);
if (protoElement.Name == "ReferenceRelationship")
FinalizeReferenceRelationshipMerge(protoElement, groupMerger, true);
else if (protoElement.Name == "EmbeddingRelationship")
FinalizeEmbeddingRelationshipsMerge(protoElement, groupMerger, true);
FinalizeRelationshipMerge(protoElement, groupMerger);
}
public ScheduleMaint()
{
GLSetup gls = GLSetup.Current;
Batch_History.Cache.AllowDelete = false;
Batch_History.Cache.AllowInsert = false;
Batch_History.Cache.AllowUpdate = false;
CopyPaste.SetVisible(false);
Views.Caches.Remove(typeof(Batch));
}
private void PasteButton_Click(object sender, EventArgs e)
{
var teraHandle = FindWindow(null, "TERA");
if (teraHandle == IntPtr.Zero)
{
MessageBox.Show("TERA is not running.");
return;
}
SetForegroundWindow(teraHandle);
CopyPaste.Paste();
}
public MatrixItemsStatusInquiry()
{
Save.SetVisible(false);
Insert.SetVisible(false);
Delete.SetVisible(false);
CopyPaste.SetVisible(false);
Next.SetVisible(false);
Previous.SetVisible(false);
First.SetVisible(false);
Last.SetVisible(false);
Cancel.SetVisible(false);
}
public void AllocView(IntPtr ObjectPtr)
{
if (Alloced)
{
Track_PitchView.setPartsObjectPtr(ObjectPtr);
Track_NoteView.setPartsObjectPtr(ObjectPtr);
Global_ActionView.setPartsObjectPtr(ObjectPtr);
Param_PitchView.setPartsObjectPtr(ObjectPtr);
Param_DynamicView.setPartsObjectPtr(ObjectPtr);
Track_NoteView.setSingerDataFinder(SingerDataFinders);
}
else
{
Track_NoteView = new NoteView(ObjectPtr, this.PianoWindow);
Track_NoteView.setSingerDataFinder(SingerDataFinders);
Track_PitchView = new PitchView(ObjectPtr, this.PianoWindow);
Param_PitchView = new PITParamView(ObjectPtr, this.ParamWindow);
Param_DynamicView = new DYNParamView(ObjectPtr, this.ParamWindow);
Global_ActionView = new ActionView(ObjectPtr, this.PianoWindow, this.ParamWindow);
CopyPasteController = new CopyPaste(ref Track_NoteView, ref Track_PitchView);
CopyPasteController.NoteCopyMemoryChanged += CopyPasteController_NoteCopyMemoryChanged;
Track_NoteView.NoteActionBegin += Track_NoteView_NoteActionBegin;
Track_NoteView.NoteActionEnd += Track_NoteView_NoteActionEnd;
Track_NoteView.NoteSelecting += Track_NoteView_NoteSelecting;
Track_PitchView.PitchActionBegin += Track_PitchView_PitchActionBegin;
Track_PitchView.PitchActionEnd += Track_PitchView_PitchActionEnd;
Param_DynamicView.DynActionBegin += Param_DynamicView_DynActionBegin;
Param_DynamicView.DynActionEnd += Param_DynamicView_DynActionEnd;
Param_PitchView.PitchActionBegin += Param_PitchView_PitchActionBegin;
Param_PitchView.PitchActionEnd += Param_PitchView_PitchActionEnd;
Global_ActionView.TickPosChange += Global_ActionView_TickPosChange;
Track_NoteView.NoteSelectListChange += Track_NoteView_NoteSelectListChange;
Alloced = true;
SetNoteViewTool(NoteView.NoteToolsType.Select);
SetParamGraphicTool(PitchView.PitchDragingType.DrawGraphS);
SwitchParamView(ParamViewType.Dynamic);
}
try
{
ParamWindow.RedrawPiano();
PianoWindow.RedrawPiano();
LastSelectIndex = -1;
}
catch {; }
}
private void hook_KeyPressed(object sender, KeyPressedEventArgs e)
{
if (e.Key == BasicTeraData.HotkeysData.Paste.Key && e.Modifier == BasicTeraData.HotkeysData.Paste.Value)
{
CopyPaste.Paste();
}
else if (e.Key == BasicTeraData.HotkeysData.Reset.Key && e.Modifier == BasicTeraData.HotkeysData.Reset.Value)
{
Reset();
}
foreach (var copy in BasicTeraData.HotkeysData.Copy.Where(copy => e.Key == copy.Key && e.Modifier == copy.Modifier))
{
CopyPaste.Copy(PlayerData(), copy.Header, copy.Content, copy.Footer);
}
}
internal void S_OTHER_USER_APPLY_PARTY(S_OTHER_USER_APPLY_PARTY message)
{
if (BasicTeraData.Instance.WindowData.ShowAfkEventsIngame || !TeraWindow.IsTeraActive())
{
PacketProcessor.Instance.FlashMessage.Add(DefaultNotifyAction(message.PlayerName + " " + LP.ApplyToYourParty,
LP.Class + ": " + LP.ResourceManager.GetString(message.PlayerClass.ToString(), LP.Culture) + Environment.NewLine + LP.Lvl + ": " + message.Lvl +
Environment.NewLine, EventType.OtherUserApply));
}
if (BasicTeraData.Instance.WindowData.CopyInspect)
{
var thread = new Thread(() => CopyPaste.CopyInspect(message.PlayerName));
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
}
}
/// <summary>Displays transparent cuboid for 2 secs.</summary>
public void SliderPreview(float v)
{
if (HeightIndicator != null)
{
Destroy(HeightIndicator);
}
if (PreviewToggle.isOn && !CopyPaste.IsEnabled())
{
float y = Consts.SliderValue2RealHeight(v);
HeightIndicator = GameObject.CreatePrimitive(PrimitiveType.Cube);
Destroy(HeightIndicator.GetComponent <BoxCollider>());
HeightIndicator.GetComponent <MeshRenderer>().material = partiallytransparent;
HeightIndicator.transform.localScale = new Vector3(3f, 0.05f, 3f);
HeightIndicator.transform.position = new Vector3(4 * Highlight.tile_pos.x + 2, y, 4 * Highlight.tile_pos.z + 2);
Destroy(HeightIndicator, 2);
}
}
public static object CopyPastObjectButtons(object obj)
{
var CopyContent = new GUIContent("Copy Data", "Copies the data.");
var PasteContent = new GUIContent("Paste Data", "Pastes the data.");
if (GUILayout.Button(CopyContent))
{
CopyPaste.EditorCopy(obj);
}
if (GUILayout.Button(PasteContent))
{
CopyPaste.EditorPaste(ref obj);
}
return(obj);
}
//[Obsolete("Use property drawer instead")]
public static Vector3 DrawVector3(GUIContent label, Vector3 vec, Vector3 defualtValue, bool allowTransformDrop = false)
{
EditorGUILayout.BeginHorizontal();
vec = EditorGUILayout.Vector3Field(label, vec);
if (allowTransformDrop)
{
var transformContent = new GUIContent("", "Asign the vectors value from a transform Position");
Transform transform = null;
transform = (Transform)EditorGUILayout.ObjectField(transformContent, transform, typeof(Transform), true, GUILayout.Width(50));
if (transform != null)
{
EditorGUILayout.EndHorizontal();
return(transform.position);
}
}
var resetContent = new GUIContent("R", "Resets the vector to " + defualtValue);
if (GUILayout.Button(resetContent, GUILayout.Width(25)))
{
vec = defualtValue;
}
var copyContent = new GUIContent("C", "Copies the vectors data.");
if (GUILayout.Button(copyContent, GUILayout.Width(25)))
{
CopyPaste.EditorCopy(vec);
}
var pasteContent = new GUIContent("P", "Pastes the vectors data.");
if (GUILayout.Button(pasteContent, GUILayout.Width(25)))
{
vec = CopyPaste.Paste <Vector3>();
}
EditorGUILayout.EndHorizontal();
return(vec);
}
public override void ModelFinalize(CopyPaste.ModelProtoElement protoElement, CopyPaste.ModelProtoGroupMerger groupMerger)
{
base.ModelFinalize(protoElement, groupMerger);
DomainClass domainClass = this.Store.ElementDirectory.FindElement(groupMerger.GetIdMapping(protoElement.ElementId)) as DomainClass;
if (domainClass == null)
return;
if (domainClass.IsDomainModel)
domainClass.IsDomainModel = false;
if (domainClass.BaseClass != null)
{
ReadOnlyCollection<DomainClassReferencesBaseClass> col = DomainRoleInfo.GetElementLinks<DomainClassReferencesBaseClass>(domainClass, DomainClassReferencesBaseClass.DerivedClassDomainRoleId);
if (col.Count != 1)
{
throw new ArgumentNullException("Domain class can only reference one base class");
}
DomainClassReferencesBaseClass r = col[0];
r.InhNodeId = Guid.Empty; // otherwise node id of the source element would be used
}
if (domainClass.DomainModelTreeNodes.Count == 0)
{
RootNode node = new RootNode(domainClass.Store);
node.DomainElement = domainClass;
node.IsElementHolder = true;
// add to the domain model diagram tree
domainClass.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(node);
domainClass.ModelContext.ViewContext.DomainModelTreeView.RootNodes.Add(node);
}
SerializationDomainClassAddRule.OnDomainClassAdded(domainClass);
SerializationHelper.UpdateDerivedElementsSerializationProperties(domainClass);
}
private void OnGUI()
{
GUILayout.Label("Language Editor", EditorStyles.boldLabel);
if (localizationMaster)
{
GUILayout.Label("Localization Master Found In Resources Folder.", EditorStyles.boldLabel);
EditorGUILayout.BeginHorizontal();
var saveContent = new GUIContent("Save active language", "Save active language");
var LoadContent = new GUIContent("Load active language", "Load active language");
if (GUILayout.Button(saveContent))
{
localizationMaster.Save();
}
if (GUILayout.Button(LoadContent))
{
localizationMaster.Load();
}
EditorGUILayout.EndHorizontal();
ShowAvailableLanguages = EditorGUILayout.Toggle("Show Available Languages", ShowAvailableLanguages);
if (ShowAvailableLanguages)
{
EditAvailableLanguages = EditorGUILayout.BeginToggleGroup("Show Available Languages", EditAvailableLanguages);
for (var i = 0; i < localizationMaster.AvailableLanguages.Count; i++)
{
if (localizationMaster.AvailableLanguages[i] == LocalizationMaster.englishID)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Label(i.ToString(), EditorStyles.boldLabel, GUILayout.Width(20));
GUILayout.Label(localizationMaster.AvailableLanguages[i]);
var setContent = new GUIContent("Set English to active language", "Set _en to Active Language");
if (localizationMaster.LangIndex != i)
{
if (GUILayout.Button(setContent))
{
localizationMaster.SetLang(i);
}
}
else
{
GUILayout.Label("Active", GUILayout.Width(100));
}
}
else
{
EditorGUILayout.BeginHorizontal();
GUILayout.Label(i.ToString(), EditorStyles.boldLabel, GUILayout.Width(20));
localizationMaster.AvailableLanguages[i] = EditorGUILayout.TextArea(localizationMaster.AvailableLanguages[i]);
var setContent = new GUIContent("Set Active", string.Format("Set {0} to Active Language", localizationMaster.AvailableLanguages[i]));
if (localizationMaster.LangIndex != i)
{
if (GUILayout.Button(setContent, GUILayout.Width(100)))
{
localizationMaster.SetLang(i);
}
}
else
{
GUILayout.Label("Active", GUILayout.Width(100));
}
var resetContent = new GUIContent("Reset Language", "Reset Entries to Key only");
if (GUILayout.Button(resetContent, GUILayout.Width(100)))
{
ResetLanguage(i);
}
var deleteContent = new GUIContent("X", "Delete Entry");
if (GUILayout.Button(deleteContent, GUILayout.Width(25)))
{
localizationMaster.AvailableLanguages.RemoveAt(i);
}
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.BeginHorizontal();
NewLangString = EditorGUILayout.TextArea(NewLangString);
if (GUILayout.Button("Add New Language"))
{
NewLanguage();
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndToggleGroup();
}
ShowLanguageEntries = EditorGUILayout.Toggle("Entries in the language Database. Show?", ShowLanguageEntries);
if (ShowLanguageEntries)
{
for (var i = 0; i < localizationMaster.DictionaryData.Data.Count; i++)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Label(i.ToString(), EditorStyles.boldLabel, GUILayout.Width(20));
localizationMaster.DictionaryData.Data[i] = new LocalizationDictionaryEntry(EditorGUILayout.TextArea(localizationMaster.DictionaryData.Data[i].Key, GUILayout.Width(position.width * 0.2f)),
EditorGUILayout.TextArea(localizationMaster.DictionaryData.Data[i].Data));
var copyContent = new GUIContent("C", "Copy Entry");
if (GUILayout.Button(copyContent, GUILayout.Width(25)))
{
CopyPaste.Copy(localizationMaster.DictionaryData.Data[i]);
}
var pasteContent = new GUIContent("P", "Paste Entry");
if (GUILayout.Button(pasteContent, GUILayout.Width(25)))
{
localizationMaster.DictionaryData.Data[i] = CopyPaste.Paste <LocalizationDictionaryEntry>();
}
var deleteContent = new GUIContent("X", "Delete Entry");
if (GUILayout.Button(deleteContent, GUILayout.Width(25)))
{
localizationMaster.DictionaryData.Data.RemoveAt(i);
}
EditorGUILayout.EndHorizontal();
}
if (GUILayout.Button("Add New Entry"))
{
localizationMaster.DictionaryData.Data.Add(new LocalizationDictionaryEntry("newKey", "newData"));
}
}
}
else
{
GUILayout.Label("WARNING \n Localization Master NOT Found In Resources Folder.", EditorStyles.boldLabel);
localizationMaster = Resources.Load(LocalizationMaster.DefaultLocation) as LocalizationMaster;
}
//groupEnabled = EditorGUILayout.BeginToggleGroup("Optional Settings", groupEnabled);
//myBool = EditorGUILayout.Toggle("Toggle", myBool);
//myFloat = EditorGUILayout.Slider("Slider", myFloat, -3, 3);
//EditorGUILayout.EndToggleGroup();
}
/*
* private static double StringCompare(string a, string b)
* {
* if (a == b)
* {
* return 100;
* }
* if ((a.Length == 0) || (b.Length == 0))
* {
* return 0;
* }
* double maxLen = a.Length > b.Length ? a.Length : b.Length;
* var minLen = a.Length < b.Length ? a.Length : b.Length;
* var sameCharAtIndex = 0;
* for (var i = 0; i < minLen; i++)
* {
* if (a[i] == b[i])
* {
* sameCharAtIndex++;
* }
* }
* return sameCharAtIndex/maxLen*100;
* }
*/
private static void CreateMenu()
{
Config = MainMenu.AddMenu("Chat Translator", "Config");
TranslatorMenu = Config.AddSubMenu("Translator", "Translator");
IncomingText = Config.AddSubMenu("IncomingText", "IncomingText");
OutgoingText = Config.AddSubMenu("OutgoingText", "OutgoingText");
Position = Config.AddSubMenu("Position", "Position");
Logger = Config.AddSubMenu("Logger", "Logger");
CopyPaste = Config.AddSubMenu("Paste", "Paste");
#region Translator Menu
TranslatorMenu.Add("Check", new KeyBind("Check", true, KeyBind.BindTypes.HoldActive, 32));
#endregion
#region Incoming Text Menu
IncomingText.AddLabel("From: ");
var incomingFrom = IncomingText.Add("From", new Slider("From: ", 0, 0, 63));
incomingFrom.DisplayName = FromArrayMenu[incomingFrom.CurrentValue];
incomingFrom.OnValueChange += delegate(ValueBase <int> sender, ValueBase <int> .ValueChangeArgs changeArgs)
{
sender.DisplayName = FromArrayMenu[changeArgs.NewValue];
};
IncomingText.AddLabel("To: ");
var incomingTo = IncomingText.Add("To", new Slider("To: ", 0, 0, 62));
incomingTo.DisplayName = ToArrayMenu[incomingFrom.CurrentValue];
incomingTo.OnValueChange += delegate(ValueBase <int> sender, ValueBase <int> .ValueChangeArgs changeArgs)
{
sender.DisplayName = ToArrayMenu[changeArgs.NewValue];
};
IncomingText.Add("ShowInChat", new CheckBox("Show in chat", false));
IncomingText.Add("Enabled", new CheckBox("Enabled"));
#endregion
#region Outgoing Text Menu
OutgoingText.AddLabel("From: ");
var outgoingFrom = OutgoingText.Add("OutFrom", new Slider("From: ", 0, 0, 63));
outgoingFrom.DisplayName = FromArrayMenu[outgoingFrom.CurrentValue];
outgoingFrom.OnValueChange += delegate(ValueBase <int> sender, ValueBase <int> .ValueChangeArgs changeArgs)
{
sender.DisplayName = FromArrayMenu[changeArgs.NewValue];
};
OutgoingText.AddLabel("To: ");
var outgoingTo = OutgoingText.Add("OutTo", new Slider("To: ", 0, 0, 62));
outgoingTo.DisplayName = ToArrayMenu[outgoingTo.CurrentValue];
outgoingTo.OnValueChange += delegate(ValueBase <int> sender, ValueBase <int> .ValueChangeArgs changeArgs)
{
sender.DisplayName = ToArrayMenu[changeArgs.NewValue];
};
OutgoingText.Add("EnabledOut", new CheckBox("Enabled", false));
#endregion
#region Position
Position.Add("Horizontal", new Slider("Horizontal", 15, 1, 2000));
Position.Add("Vertical", new Slider("Vertical", 500, 1, 2000));
Position.Add("AutoShow", new CheckBox("Show on message"));
Position.Add("Duration", new Slider("Duration", 3000, 1000, 8000));
#endregion
#region Logger
Logger.Add("EnabledLog", new CheckBox("Enable"));
#endregion
#region Copy Paste
CopyPaste.Add("Paste", new KeyBind("Paste", false, KeyBind.BindTypes.PressToggle, 'P'));
CopyPaste.Add("PasteForAll", new KeyBind("Paste for all", false, KeyBind.BindTypes.PressToggle, 'O'));
CopyPaste.Add("Delay", new Slider("Spam delay", 2000, 0, 2000));
CopyPaste.Add("DisablePaste", new CheckBox("Disable this section"));
Config.AddLabel("You can use your own API key");
Config.AddLabel(
"AppData\\Roaming\\EloBuddy\\yandexApiKey.txt, copy into the first line \"trnsl.1.1.201...\"");
#endregion
}
public override void ModelProcessMergeCopy(CopyPaste.ModelProtoElement protoElement, CopyPaste.ModelProtoGroup protoGroup)
{
base.ModelProcessMergeCopy(protoElement, protoGroup);
// copy rs and target elements if required
if (CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyEmbeddingTree ||
CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyAllTree ||
CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyReferenceTree)
{
foreach (DomainRole role in this.RolesPlayed)
{
if (role.Relationship is EmbeddingRelationship && role.Relationship.Source == role)
{
if (CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyEmbeddingTree ||
CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyAllTree)
{
ModelProtoElement e = (role.Relationship as IModelMergeElements).ModelCreateMergeCopy(protoGroup);
protoGroup.AddNewRootElement(e);
// continue with target element
if (ImmutabilityExtensionMethods.GetLocks(role.Relationship.Target.RolePlayer) == Locks.None)
{
if (!protoGroup.HasProtoElementFor(role.Relationship.Target.RolePlayer.Id, this.Partition))
{
ModelProtoElement d = (role.Relationship.Target.RolePlayer as IModelMergeElements).ModelCreateMergeCopy(protoGroup);
protoGroup.InsertNewRootElement(d, 0);
}
}
}
}
else if (role.Relationship is ReferenceRelationship && role.Relationship.Source == role)
{
if (CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyAllTree ||
CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyReferenceTree)
{
ModelProtoElement e = (role.Relationship as IModelMergeElements).ModelCreateMergeCopy(protoGroup);
protoGroup.AddNewRootElement(e);
}
}
}
// sort proto elements: bring domain classes to the top
protoGroup.SortProtoElements(SortProtoElements);
}
// copy order of attributes and children
DomainClassSerializationInfo info = new DomainClassSerializationInfo(
this.SerializedDomainClass.Children.Count,
this.SerializedDomainClass.Attributes.Count);
for (int i = 0; i < this.SerializedDomainClass.Attributes.Count; i++)
{
SerializationAttributeElement aatr = this.SerializedDomainClass.Attributes[i];
if( aatr is SerializedDomainProperty )
{
SerializedDomainProperty sP = aatr as SerializedDomainProperty;
ElementSerializationInfo sInfo = new ElementSerializationInfo(
sP.DomainProperty.Name, sP.DomainProperty.Id);
if (sP.OmitProperty)
sInfo.OmitElement = true;
info.AttributesOrder.Add(sInfo);
}
else if (aatr is SerializedIdProperty)
{
SerializedIdProperty sI = aatr as SerializedIdProperty;
ElementSerializationInfo sInfo = new ElementSerializationInfo("SerializedIdProperty", Guid.Empty);
if (sI.OmitIdProperty)
sInfo.OmitElement = true;
info.AttributesOrder.Add(sInfo);
}
}
for (int i = 0; i < this.SerializedDomainClass.Children.Count; i++)
{
SerializationElement sE = this.SerializedDomainClass.Children[i];
if (sE is SerializedReferenceRelationship)
{
SerializedReferenceRelationship sDomainRel = sE as SerializedReferenceRelationship;
ElementSerializationInfo sInfo = new ElementSerializationInfo(
sDomainRel.ReferenceRelationship.Name, sDomainRel.ReferenceRelationship.Id);
if (sDomainRel.OmitRelationship)
sInfo.OmitElement = true;
info.ChildrenOrder.Add(sInfo);
}
else if (sE is SerializedEmbeddingRelationship)
{
SerializedEmbeddingRelationship sDomainRel = sE as SerializedEmbeddingRelationship;
ElementSerializationInfo sInfo = new ElementSerializationInfo(
sDomainRel.EmbeddingRelationship.Name, sDomainRel.EmbeddingRelationship.Id);
if (sDomainRel.OmitRelationship)
sInfo.OmitElement = true;
info.ChildrenOrder.Add(sInfo);
}
else if (sE is SerializedDomainProperty)
{
SerializedDomainProperty sP = sE as SerializedDomainProperty;
ElementSerializationInfo sInfo = new ElementSerializationInfo(
sP.DomainProperty.Name, sP.DomainProperty.Id);
if (sP.OmitProperty)
sInfo.OmitElement = true;
info.ChildrenOrder.Add(sInfo);
}
}
protoElement.CustomArguments = info;
}
