///<summary> ///</summary> ///<param name="adapter"></param> ///<returns></returns> public static List <ChildGroupDescriptor> GetChildGroupsReferences(GroupAdapter adapter) { Type adapterType = adapter.GetType(); Type componentType = adapter.ComponentType; List <ChildGroupDescriptor> descriptors = new List <ChildGroupDescriptor>(); foreach (MemberInfo memberInfo in adapterType.GetMembers()) { var attributes = Core.Reflection.CoreReflector.GetMemberAttributes <ChildCollectionAttribute>(memberInfo); if (null != attributes && attributes.Count > 0) { ChildCollectionAttribute attribute = attributes[0]; MemberInfo mi = null; if (!string.IsNullOrEmpty(attribute.TargetContainer)) { MemberInfo[] list = componentType.GetMember(attribute.TargetContainer); if (list.Length > 0) { mi = list[0]; } } ChildGroupDescriptor descriptor = new ChildGroupDescriptor { Attribute = attribute, CollectionMemberInfo = memberInfo, TargetContainerMemberInfo = mi }; descriptors.Insert(0, descriptor); } } return(descriptors); }
protected bool CheckSelection(bool mustBeContainer, bool renderMessage = true) { if (null == Selection.activeTransform) { if (renderMessage) { GUILayout.Label(GuiContentCache.Instance.NoSelectionContent, StyleCache.Instance.CenteredLabel, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)); } return(false); } Adapter = GuiLookup.GetAdapter(Selection.activeTransform); GroupAdapter = Adapter as GroupAdapter; if (null == Adapter) { if (renderMessage) { GUILayout.Label(GuiContentCache.Instance.NotEDrivenComponentContent, StyleCache.Instance.CenteredLabel, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)); } return(false); } if (mustBeContainer && null == GroupAdapter) { if (renderMessage) { GUILayout.Label(GuiContentCache.Instance.NotAContainerContent, StyleCache.Instance.CenteredLabel, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)); } return(false); } return(true); }
protected override void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); SetContentView(Resource.Layout.Main); _context = this; var toolbar = FindViewById <Toolbar>(Resource.Id.toolbar); SetActionBar(toolbar); ActionBar.Title = "Messenger"; StartupHelper.Initialize(); new MessageStream().Subscribe(callback); GetGroups(); var groupList = FindViewById <ListView>(Resource.Id.groupListView); groupList.ItemClick += OnItemClick; Adapter = new GroupAdapter(Groups); groupList.Adapter = Adapter; }
protected override void HandleSelectionChange() { //Debug.Log("HandleSelectionChange"); /** * If not a container, nothing to do here; so return immediatelly * */ if (null == GroupAdapter) { return; } #if DEBUG if (DebugMode) { Debug.Log(string.Format(@"=========== Order ({0}) ========= {1}============================", GroupAdapter.LayoutOrder.Count, GroupAdapter.DescribeLayoutOrder())); } #endif SerializedObject serializedObject = EditorState.SerializedObject; if (null == serializedObject) { return; } _layout = serializedObject.FindProperty("Layout"); InitLayout(serializedObject); }
/// <summary> /// Since all of the tree displays use the selection change, I decided to implement it in superclass /// </summary> internal void ProcessSelectionChange() { //Debug.Log("ProcessSelectionChange: " + Selection.activeObject); if (null == Selection.activeGameObject) { return; } GameObject go = Selection.activeGameObject; /*if (null == go) * throw new Exception("Couldn't get the selection");*/ Adapter = go.GetComponent(typeof(ComponentAdapter)) as ComponentAdapter; if (null == Adapter) { /** * Not a GUI component * S hould do cleanup and handle selection (deselect basically) * */ GroupAdapter = null; //HandleSelectionChange(); return; } Target = Adapter; GroupAdapter = Target as GroupAdapter; HandleSelectionChange(); }
/// <summary> /// Scans the supplied parent adapter /// Converts ChildGroupPacks to SaveablePacks and saves them to dictionary /// These packs are used later (in "Process" method) to apply the changes after the play mode is stopped /// </summary> /// <param name="parentAdapter"></param> /// <param name="pack"></param> public void Update(GroupAdapter parentAdapter, ChildGroupPack pack) { //Debug.Log("Update: " + parentAdapter); #if DEBUG if (DebugMode) { //Debug.Log(string.Format("Linking {0} -> {1}", parentAdapter, childAdapter)); Debug.Log(string.Format("ParentChildLinker: Updating {0}", parentAdapter)); } #endif //Debug.Log("parentAdapter: " + parentAdapter); // 1. we have to monitor parentAdapter for later (if not yet monitored) if (Application.isPlaying) { PersistenceManager.Instance.Watch(parentAdapter); } // 2. if no pack supplied, read it now if (null == pack) { //Debug.Log("ParentChildLinker: Pack not defined. Reading now."); pack = ChildGroupPack.Read(parentAdapter); } // 3. register adapters for later pack.RegisterAdapters(); // 4. get relation object var guidPack = pack.ToSaveablePack(); // 5. cache it (overwrite existing!) _changes[guidPack.ParentInstanceId] = guidPack; }
// ReSharper restore UnassignedField.Global #endif internal static void Process(List <Node> removals) { if (0 == removals.Count) { return; } #if DEBUG if (DebugMode) { Debug.Log(string.Format("Processing {0} removals.", removals.Count)); } #endif //Debug.Log(string.Format("Processing {0} removals.", removals.Count)); // TODO: do removals bottom up! nesting level should be used here foreach (Node node in removals) { //if (null == node.Transform) // continue; // ROOT node.RemoveFromHierarchy(); //Debug.Log("node.ParentTransform: " + node.ParentTransform); if (null == node.ParentTransform) //|| /*!*/(adapter is StageAdapter)) { continue; // not a stage, return (if stage, should process) } // consolidate parent transform ComponentAdapter adapter = node.Adapter; GroupAdapter parentGroupAdapter = GuiLookup.GetAdapter(node.ParentTransform) as GroupAdapter; if (null != parentGroupAdapter) { /** * Stop monitoring * */ PersistenceManager.Instance.Unwatch(node.AdapterId); //PersistenceManager.Instance.RemoveAdapter(node.AdapterId); /** * Note: if object removed from the hierarchy, the adapter is destroyed * In that case following command doesn nothing (doesn not remove the slot from the parent) * Thus we have the consolidation below (removing null) * */ parentGroupAdapter.RemoveChild(adapter); // TODO: consolidate only for top level removals (add parameter) /*parentContainerAdapter.RemoveChild(adapter);*/ //parentContainerAdapter.RemoveAllChildren(); ChildGroupPack pack = ChildGroupPack.Read(parentGroupAdapter); pack.Consolidate(); // there is a null slot here. We have to re-render children //Debug.Log("*pack: " + pack); parentGroupAdapter.InstantiateChildren(true); } } }
public static void Process(List <Node> nodes) { if (nodes.Count == 0) { return; } //Debug.Log(string.Format("Processing {0} top level additions in edit mode.", nodes.Count)); foreach (Node node in nodes) { /** * 1. Process transforms * */ Transform transform = node.Transform; if (null == transform) { continue; // ROOT } ComponentAdapter adapter = GuiLookup.GetAdapter(transform); bool isStage = adapter is StageAdapter; Transform parentTransform = node.ParentTransform; /* This happens when a stage added to root */ if (null == parentTransform && !isStage) { continue; // not a stage, return (if stage, should process) } GroupAdapter parentAdapter = null; if (null != parentTransform) { parentAdapter = GuiLookup.GetAdapter(node.ParentTransform) as GroupAdapter; } /** * 2. Process adapters * */ if (null != adapter) { // this is eDriven.Gui component. process it properly if (null == parentAdapter) { if (!isStage) { const string txt = "eDriven.Gui components could be added to containers only"; throw new Exception(txt); } } else { parentAdapter.AddChild(adapter, true); //if (!PrefabUtil.IsCreatedFromPrefab(parentAdapter)) ParentChildLinker.Instance.Update(parentAdapter); } } } }
/// <summary> /// Finds a gui element in children. If such an element exists, returns it; if not, returns null /// </summary> /// <typeparam name="T">Type of the adapter to find</typeparam> /// <param name="go">Game object on which to do the search</param> /// <param name="id">Adapter ID</param> /// <returns></returns> public static T FindComponent <T>(GameObject go, string id) where T : Component { ComponentAdapter adapter = go.GetComponent <ComponentAdapter>(); Component component = adapter.Component; if (adapter.Id == id && adapter.ComponentType == typeof(T)) { return(component as T); } GroupAdapter groupAdapter = adapter as GroupAdapter; if (null != groupAdapter) { int count = groupAdapter.transform.childCount; for (int i = 0; i < count; i++) { Transform childTransform = groupAdapter.transform.GetChild(i); adapter = childTransform.GetComponent <ComponentAdapter>(); if (adapter.ComponentType == typeof(T) && null != adapter.Component && adapter.Component.Id == id) { break; } } } return(adapter.Component as T); }
public static ChildGroupPack Read(GroupAdapter groupAdapter) { #if DEBUG if (DebugMode) { Debug.Log(string.Format(@"Read")); } #endif ChildGroupPack childGroupPack = new ChildGroupPack(groupAdapter); var groupDescriptors = DesignerReflection.GetChildGroupsReferences(groupAdapter); foreach (ChildGroupDescriptor groupDescriptor in groupDescriptors) { List <ComponentAdapter> adapters = Core.Reflection.CoreReflector.GetMemberValue(groupDescriptor.CollectionMemberInfo, groupAdapter) as List <ComponentAdapter>; ChildGroup childGroup = new ChildGroup(adapters) { GroupName = groupDescriptor.CollectionMemberInfo.Name }; childGroupPack.Add(childGroup); } #if DEBUG if (DebugMode) { Debug.Log("Read. childGroupPack: " + childGroupPack); } #endif return(childGroupPack); }
private void SelectAdapter_Click(object sender, RoutedEventArgs e) { NetworkInterface ni = (NetworkInterface)Adapters.SelectedItem; if (ni != null) { Window window; if (ni.GetType().ToString() == "NSHG.NetworkInterfaces.Adaptor") { Adapter a = (Adapter)ni; window = new AdapterEditor(ref a, this); } else if (ni.GetType().ToString() == "NSHG.NetworkInterfaces.GroupAdaptor") { return; GroupAdapter ga = (GroupAdapter)ni; //GroupAdapterEditor window = new GroupAdapterEditor(ref ga, this); } else { return; } window.Show(); window.Focus(); } }
/// <summary> /// Finds a gui element in children. If such an element exists, returns it; if not, returns null /// </summary> /// <param name="go">Game object on which to do the search</param> /// <param name="id">Adapter ID</param> /// <returns></returns> public static Component FindComponent(GameObject go, string id) { ComponentAdapter adapter = go.GetComponent <ComponentAdapter>(); Component component = adapter.Component; if (adapter.Id == id) { return(component); } GroupAdapter groupAdapter = adapter as GroupAdapter; if (null != groupAdapter) { int count = groupAdapter.transform.childCount; for (int i = 0; i < count; i++) { Transform childTransform = groupAdapter.transform.GetChild(i); adapter = childTransform.GetComponent <ComponentAdapter>(); if (null != adapter.Component && adapter.Component.Id == id) { break; } } } return(adapter.Component); }
internal static void Process(List <Node> nodes) { if (nodes.Count == 0) { return; } //Debug.Log(string.Format("Processing {0} top level removals in edit mode.", nodes.Count)); foreach (Node node in nodes) { if (null == node.ParentTransform) { continue; } GroupAdapter parentGroupAdapter = GuiLookup.GetAdapter(node.ParentTransform) as GroupAdapter; if (null != parentGroupAdapter) { /** * Important: the removal could happen when we *move* components outside of the Stage hierarchy * From group's standpoint, these components have been *removed* * However, the adapters are not null, so the consolidation without a prior * removal would do nothing to the parent collection (e.g. the moved adapter * would still be on the list) * */ parentGroupAdapter.RemoveChild(node.Adapter); ChildGroupPack pack = ChildGroupPack.Read(parentGroupAdapter); pack.Consolidate(); // there is a null slot here. We have to re-render children } } }
public AdapterAnalysis(object target) { if (null != target) { ComponentAdapter = target as ComponentAdapter; SkinnableComponentAdapter = target as SkinnableComponentAdapter; SkinnableContainerAdapter = target as SkinnableContainerAdapter; GroupAdapter = target as GroupAdapter; if (null != GroupAdapter) { HasAbsoluteLayout = CheckForAbsoluteLayout(GroupAdapter); } if (null != ComponentAdapter && null != ComponentAdapter.transform && null != ComponentAdapter.transform.parent) { ParentGroupAdapter = ComponentAdapter.transform.parent.GetComponent <GroupAdapter>(); HasParent = null != ParentGroupAdapter; if (null != ParentGroupAdapter) { ParentIsStage = ParentGroupAdapter is StageAdapter; //ParentUsesLayoutDescriptor = ParentContainerAdapter.UseLayoutDescriptor; //ParentLayoutDescriptor = ParentContainerAdapter.LayoutDescriptor; ParentLayout = ParentGroupAdapter.Layout; ParentHasAbsoluteLayout = CheckForAbsoluteLayout(ParentGroupAdapter); } } } }
public GroupManager(GroupAdapter adapter) { //Debug.Log("Creating GroupManager"); _groupAdapter = adapter; _groupDescriptors = DesignerReflection.GetChildGroupsReferences(adapter); _pack = ChildGroupPack.Read(adapter); }
public void ChangeChannel(string channelId) { if (activeChat != null) { if (activeChat.Id.Equals(channelId)) { return; } activeChat.Hide(); } if (chats.ContainsKey(channelId)) { chats[channelId].Show(); activeChat = chats[channelId]; } else { MessagesAdapter adapter = null; switch (channelId[0]) { case 'D': adapter = new DirectMessageAdapter(Client.DirectMessages.Find((c) => c.id == channelId), this, Client); break; case 'C': adapter = new ChannelAdapter(Client.ChannelLookup[channelId], this, Client); break; case 'G': adapter = new GroupAdapter(Client.GroupLookup[channelId], this, Client); break; } if (adapter != null) { activeChat = new ChatInterface(adapter, this); activeChat.Location = new Point(220, 0); activeChat.Width = Width - 220; activeChat.Height = Height; activeChat.Anchor = AnchorStyles.Left | AnchorStyles.Bottom | AnchorStyles.Right | AnchorStyles.Top; chats.Add(channelId, activeChat); Controls.Add(activeChat); } else if (activeChat != null) { activeChat.Show(); } } }
public override View OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View view = inflater.Inflate(Resource.Layout.GroupsFragment, container, false); progressBar = view.FindViewById <ProgressBar>(Resource.Id.progressBar); recyclerView = view.FindViewById <RecyclerView>(Resource.Id.recycler_view); groupsAdapter = new GroupAdapter(Context, groupsList); recyclerView.SetAdapter(groupsAdapter); layoutManager = new LinearLayoutManager(Activity); recyclerView.SetLayoutManager(layoutManager); swiperefresh = view.FindViewById <SwipeRefreshLayout>(Resource.Id.swiperefresh); swiperefresh.Refresh += (e, s) => RefreshData(); return(view); }
/// <summary> /// Evaluates saved Adapter IDs to real adapters /// Note: DO NOT use useEditorUtility=true because it will grab the old adapter!!! /// </summary> /// <returns></returns> public static ChildGroupPack Apply(SaveablePack saveablePack) { #if DEBUG if (DebugMode) { Debug.Log(@"*** WRITING PACK *** " + saveablePack); } #endif // Note: we have to call the override having the second argument, supplying "true" // This is because if this is the adapter existing prior to play mode start, the dictionary points to the "old" adapter (a stale one) // this way we are making sure that the system looks for the specified adapter in the scene first, and then uses the dictionary (for the "new" adapters) GroupAdapter parentAdapter = ComponentRegistry.Instance.Get(saveablePack.ParentInstanceId, true) as GroupAdapter; ChildGroupPack childGroupPack = Read(parentAdapter); int index = 0; foreach (List <int> childGroupIds in saveablePack.InstanceIds) { List <ComponentAdapter> adapters = new List <ComponentAdapter>(); foreach (int adapterId in childGroupIds) { ComponentAdapter childAdapter = (ComponentAdapter)ComponentRegistry.Instance.Get(adapterId, true); // FALSE!!! /*if (null == childAdapter) * throw new Exception("Cannot find child adapter in dictionary: " + adapterId);*/ adapters.Add(childAdapter); } var actualGroup = childGroupPack.Groups[index]; actualGroup.Clear(); actualGroup.AddRange(adapters); index++; } #if DEBUG if (DebugMode) { Debug.Log("Apply. childGroupPack: " + childGroupPack); } #endif return(childGroupPack); }
protected override void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); Title = "Groups"; SetActivityContentView(Resource.Layout.Groups, Resource.Id.groups_layout); SupportActionBar.SetDisplayHomeAsUpEnabled(false); SupportActionBar.SetHomeButtonEnabled(false); SetUpProgressDialog(this, "Loading Groups..."); ViewModel = (GroupsViewModel)DataContext; managerMode = Settings.OrganizerMode; ListView = FindViewById <ListView>(Resource.Id.groupsList); GroupAdapter = new GroupAdapter(this, ViewModel.Groups); ListView.Adapter = GroupAdapter; #region Events ViewModel.Groups.CollectionChanged += (s, e) => { GroupAdapter.UpdateListView(); }; ViewModel.FinishedFirstLoad += (index) => { if (ViewModel.Groups.Count == 0) { return; } Timer timer = new Timer() { Interval = 1000 }; timer.Elapsed += (s, e) => RunOnUiThread(() => ListView.SetSelection(index)); }; ListView.ItemClick += (sender, e) => { if (ViewModel.Groups[e.Position] != null) { ViewModel.GoToGroupCommand.Execute(ViewModel.Groups[e.Position]); } }; #endregion }
public static void Write(GroupAdapter parentAdapter, ChildGroupPack pack) { ChildGroupPack currentGroupPack = ChildGroupPack.Read(parentAdapter); Debug.Log(string.Format("ParentAdapter: {0}, {1}", parentAdapter, parentAdapter.GetInstanceID())); for (int i = 0; i < currentGroupPack.Groups.Count; i++) { var currentGroup = currentGroupPack.Groups[i]; Debug.Log("newGroup.Adapters: " + currentGroup.Adapters.Count); currentGroup.Adapters.Clear(); //Debug.Log("newGroup.Adapters 2: " + newGroup.Adapters.Count); currentGroup.Adapters.AddRange(pack.Groups[i].Adapters); Debug.Log("newGroup.Adapters 2: " + currentGroup.Adapters.Count); } }
public static ChildGroupRenderingList BuildContentGroups(GroupAdapter groupAdapter) { //Debug.Log("BuildContentGroups"); ChildGroupRenderingList childGroupList = new ChildGroupRenderingList(); var groupDescriptors = DesignerReflection.GetChildGroupsReferences(groupAdapter); bool skipFirst = false; if (groupDescriptors.Count > 0) { skipFirst = groupDescriptors[0].Attribute.ShowHeader; } foreach (ChildGroupDescriptor descriptor in groupDescriptors) { var attr = descriptor.Attribute; ChildGroup group; if (attr.ShowHeader) { Texture iconTexture = null; if (!string.IsNullOrEmpty(attr.Icon)) { iconTexture = (Texture)Resources.Load(attr.Icon); } group = new ChildGroup(new GUIContent(attr.Label, iconTexture, attr.Tooltip)); } else { group = new ChildGroup(); } List <ComponentAdapter> adapters = Core.Reflection.CoreReflector.GetMemberValue(descriptor.CollectionMemberInfo, groupAdapter) as List <ComponentAdapter>; // temp hack // ReSharper disable ConvertIfStatementToNullCoalescingExpression if (null == adapters) // ReSharper restore ConvertIfStatementToNullCoalescingExpression { // ReSharper disable AssignNullToNotNullAttribute adapters = new List <ComponentAdapter>(Core.Reflection.CoreReflector.GetMemberValue(descriptor.CollectionMemberInfo, groupAdapter) as ComponentAdapter[]); // ReSharper restore AssignNullToNotNullAttribute } //Debug.Log("adapters.Count: " + adapters.Count); foreach (ComponentAdapter adapter in adapters) { //Debug.Log(" -> adapter: " + adapter); if (null != adapter) { var dataObject = new OrderDisplayRow(adapter.ToString(), adapter, new Rect(0, 0, 0, 0)) { Color = (adapter is GroupAdapter) ? Dark : Light, IsContainer = adapter is GroupAdapter }; if (skipFirst) { dataObject.YMin = OrderDisplay.ElementHeight; } //Debug.Log("Adding " + dataObject); group.Add(dataObject); } } // Debug.Log(string.Format(@"***** Group created: //{0} // //", group)); childGroupList.AddGroup(group); } //Debug.Log(childGroupList); return(childGroupList); }
public override void Render() { // mode switch EditorGUILayout.BeginHorizontal(StyleCache.Instance.Toolbar); _oldEnabled = GUI.enabled; GUI.enabled = null != Adapter; _clicked = GUILayout.Toggle(!_depthMode, new GUIContent("Order", TextureCache.Instance.OrderSelected), StyleCache.Instance.Toggle, GUILayout.Height(30), GUILayout.ExpandWidth(false)); if (_clicked && _depthMode) { _depthMode = false; } GUI.enabled = _oldEnabled; _oldEnabled = GUI.enabled; GUI.enabled = false; _clicked = GUILayout.Toggle(_depthMode, new GUIContent("Depth", TextureCache.Instance.Depth), StyleCache.Instance.Toggle, GUILayout.Height(30), GUILayout.ExpandWidth(false)); if (_clicked && !_depthMode) { _depthMode = true; } GUI.enabled = _oldEnabled; GUILayout.FlexibleSpace(); // Note: we need to always allow the addition of a Stage if (GUILayout.Button(GuiContentCache.Instance.AddChildControlContent, StyleCache.Instance.Toggle, GUILayout.Height(30), GUILayout.ExpandWidth(false))) { ToolboxDialog.Instance.ShowUtility(); } _oldEnabled = GUI.enabled; GUI.enabled = null != GroupAdapter; if (GUILayout.Button(GuiContentCache.Instance.RemoveAllChildrenButton, StyleCache.Instance.Button, GUILayout.Height(30))) { if (EditorUtility.DisplayDialog("Remove all?", "Are you sure you want to remove all children?", "OK", "Cancel")) { if (null != GroupAdapter) { //Debug.Log("Removing all children..."); GroupAdapter.RemoveAllChildren(); } } } GUI.enabled = _oldEnabled; EditorGUILayout.EndHorizontal(); if (null == _list.Data) { GUILayout.Label(GuiContentCache.Instance.NotAContainerContent, StyleCache.Instance.CenteredLabel, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)); return; } int count = _list.Data.RenderingItemsCount; if (0 == count) { GUILayout.Label(GuiContentCache.Instance.NoComponentsInTheContainer, StyleCache.Instance.CenteredLabel, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)); return; } _rect = GUILayoutUtility.GetLastRect(); // ReSharper disable once CompareOfFloatsByEqualityOperator if (_rect.width != 1 && _rect != _lastRect) { _lastRect = _rect; //_displayRect = new Rect(Padding, _lastRect.yMax + Padding, Bounds.width - Padding * 2, Bounds.height - _lastRect.yMax); _displayRect = new Rect(_lastRect.x + 1, _lastRect.yMax + 1, _lastRect.width - 2, Bounds.height - _lastRect.yMax); _list.UpdateLayout(_displayRect.width, _displayRect.height); } // wrap list inside area because it is not using GUILayout GUILayout.BeginArea(_displayRect); _list.Render(); GUILayout.EndArea(); }
private static int[] SearchRecivers(Connection connection) { var profileAdapter = new ProfileAdapter(connection); // Находим друзей var friends = profileAdapter.GetFriends<UserExtended>(); // Находим друзей друзей var friendsOfFriends = new List<UserExtended>(); foreach (var userExtended in friends) { friendsOfFriends.AddRange(profileAdapter.GetFriends<UserExtended>(userExtended.Id).ToList()); Console.WriteLine(friendsOfFriends.Count); } // Складываем всех друзей friendsOfFriends.AddRange(friends.ToList()); var groupAdapter = new GroupAdapter(connection); var groups = groupAdapter.GetGroups(connection.UserId); var adminGroup = groups.First(); var members = groupAdapter.GetGroupMembers(adminGroup.Id); friendsOfFriends = friendsOfFriends.Where(person => !members.Contains(person.Id)).ToList(); friendsOfFriends = friendsOfFriends.Where(person => person.Sex == "1").ToList(); friendsOfFriends = friendsOfFriends.Where(person => person.City == 144).ToList(); var ids = friendsOfFriends.Select(person => person.Id).ToArray(); ids = ids.Distinct().ToArray(); using (var writer = new StreamWriter("ids.txt")) { foreach (var id in ids) { writer.WriteLine(id); } } return ids; }
private ChildGroupPack(GroupAdapter parentAdapter) { _parentAdapter = parentAdapter; }
// ReSharper restore UnassignedField.Global #endif /// <summary> /// Is processing additions, as well as top level additions /// </summary> /// <param name="topLevelAdditions">Needed for adding into order</param> /// <param name="additions">Needed for child instantiation</param> internal static void Process(List <Node> topLevelAdditions, List <Node> additions) { if (0 == topLevelAdditions.Count && 0 == additions.Count) { return; } #if DEBUG if (DebugMode) { Debug.Log(string.Format("Processing {0} topLevelAdditions, {1} additions.", topLevelAdditions.Count, additions.Count)); } #endif foreach (Node node in additions) { bool isTopLevelAddition = topLevelAdditions.Contains(node); bool isPrefab = PrefabUtility.GetPrefabType(node.Adapter) == PrefabType.PrefabInstance; /** * 1. Process transforms * */ Transform transform = node.Transform; if (null == transform) { continue; // ROOT } ComponentAdapter adapter = GuiLookup.GetAdapter(transform); bool isStage = adapter is StageAdapter; Transform parentTransform = node.ParentTransform; if (null == parentTransform && !isStage) { continue; // not a stage, return (if stage, should process) } GroupAdapter parentAdapter = null; if (null != parentTransform) { parentAdapter = GuiLookup.GetAdapter(node.ParentTransform) as GroupAdapter; } /** * 2. Process adapters * */ if (null != adapter) { // this is eDriven.Gui component. process it properly if (null == parentAdapter) { if (!isStage) { const string txt = "eDriven.Gui components could be added to containers only"; throw new Exception(txt); } } else { /** * Update parent ordering for top level additions only! * */ if (isTopLevelAddition) { //node.Transform.parent = parentTransform; parentAdapter.AddChild(adapter, true); // instantiate and change the parent collection // ReSharper disable once RedundantCheckBeforeAssignment if (adapter.transform.parent != parentTransform) // avoid multiple OnHierarchyChange callbacks { adapter.transform.parent = parentTransform; } //adapter.transform.parent = parentTransform; ParentChildLinker.Instance.Update(parentAdapter); } else { //parentAdapter.DoInstantiate(adapter, true); // instantiate only ChildGroupPack pack = ChildGroupPack.Read(parentAdapter); pack.Consolidate(); // there is a null slot here. We have to re-render children parentAdapter.InstantiateChildren(true); } /** * Instantiate component * */ if (!adapter.Instantiated) { adapter.DoInstantiate(true); } /** * By now, the component should be instantiated * */ var cmp = adapter.Component; if (null == cmp) { throw new Exception("Component not found on ComponentAdapter: " + adapter); } } } /** * 3. If adapter stuff went without a problem... * */ // ReSharper disable once RedundantCheckBeforeAssignment if (node.Transform.parent != parentTransform) { node.Transform.parent = parentTransform; } } }
internal static void Process(List <Node> nodes) { if (nodes.Count == 0) { return; } //Debug.Log(string.Format("Processing {0} moves in edit mode.", nodes.Count)); foreach (Node node in nodes) { /** * 1. Process transforms * */ Transform transform = node.Transform; if (null == node.Transform) { throw new Exception("Transform is null"); } /*if (null == transform) * continue; // ROOT*/ //Debug.Log("node.Transform: " + transform); ComponentAdapter adapter = GuiLookup.GetAdapter(transform); bool isStage = adapter is StageAdapter; Transform oldParentTransform = node.OldParentTransform; Transform newParentTransform = node.ParentTransform; /* This happens when a stage moved to root */ if (null == newParentTransform && !isStage) { continue; // not a stage, return (if stage, should process) - only stage could be added to root } /** * The adapter was moved * It is still placed on the same (moved) transform * We are accessing the old and the new parent adapter via transforms: * 1. old parent transform could be referenced using the node.OldParentTransform * 2. new parent transform could be referenced using the node.ParentTransform * */ GroupAdapter oldParentAdapter = null != oldParentTransform? GuiLookup.GetAdapter(oldParentTransform) as GroupAdapter: null; GroupAdapter newParentAdapter = null != newParentTransform? GuiLookup.GetAdapter(newParentTransform) as GroupAdapter: null; Debug.Log(string.Format("[{0}] -> moving from [{1}] to [{2}]", adapter, null == oldParentAdapter ? "-" : oldParentAdapter.ToString(), null == newParentAdapter ? "-" : newParentAdapter.ToString() )); /** * 2. Sanity check * */ if (null == newParentAdapter && !isStage) { throw new Exception("eDriven.Gui components could be added to containers only"); } /** * 3. Process adapters * */ if (null != oldParentAdapter) { oldParentAdapter.RemoveChild(adapter); ParentChildLinker.Instance.Update(oldParentAdapter); } if (null != newParentAdapter) { newParentAdapter.AddChild(adapter, true); ParentChildLinker.Instance.Update(newParentAdapter); } /** * 4. Set transform * */ node.Transform.parent = newParentTransform; } }
public void Update(GroupAdapter parentAdapter) { Update(parentAdapter, null); }
private void addItem(object item) { if (GroupAdapter == null) { return; } IGroupHeader correctHeader = GroupAdapter.GenerateHeader(item); for (int i = 0; i < _collection.Count; i++) { if (_collection[i] is IGroupHeader) { IGroupHeader header = _collection[i] as IGroupHeader; int comp = correctHeader.CompareTo(header); //if goes inside this header if (comp == 0) { //binary search insert would have to walk to the end of the items anyways, so might as well do linear insert //move to the first item i++; for (; i < _collection.Count; i++) { //if we're at the next header, insert at here if (_collection[i] is IGroupFooter || _collection[i] is IGroupHeader) { _collection.Insert(i, item); return; } //or if the item goes before the item in the list else if (header.CompareInsideHeader(item, _collection[i]) < 0) { _collection.Insert(i, item); return; } //otherwise keep looking through the list } //if it wasn't added, must be at the end of the list _collection.Add(item); return; } //if goes before this header else if (comp < 0) { insert(i, correctHeader, item); return; } } } //item didn't find a matching header, needs a new header insert(_collection.Count, correctHeader, item); return; }
public static Router FromXML(XmlNode Parent, Action <string> log = null) { uint ID = 0; Dictionary <MAC, NetworkInterface> NetworkInterfaces = new Dictionary <MAC, NetworkInterface>(); bool respondToEcho = true; foreach (XmlNode n in Parent.ChildNodes) { switch (n.Name.ToLower()) { case "id": if (!uint.TryParse(n.InnerText, out ID)) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("failed to read ID"); Console.ForegroundColor = ConsoleColor.White; } break; case "adapter": try { Adapter a = Adapter.FromXML(n); NetworkInterfaces.Add(a.MyMACAddress, a); } catch { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Failed to read adapter"); Console.ForegroundColor = ConsoleColor.White; } break; case "groupadapter": try { GroupAdapter a = GroupAdapter.FromXML(n); NetworkInterfaces.Add(a.MyMACAddress, a); } catch { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Failed to read groupadapter"); Console.ForegroundColor = ConsoleColor.White; } break; case "respondtoecho": try { respondToEcho = bool.Parse(n.InnerText); } catch { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Failed to read flag: respondtoecho"); Console.ForegroundColor = ConsoleColor.White; } break; } } if (ID == 0) { throw new Exception("Invalid System XML ID not Specified"); } return(new Router(ID, NetworkInterfaces, RespToEcho: respondToEcho, Log: log)); }
// ReSharper restore UnassignedField.Global #endif internal static void Process(List <Node> moves) { #if DEBUG if (DebugMode) { Debug.Log(string.Format("Processing {0} moves.", moves.Count)); } #endif foreach (Node node in moves) { /** * 1. Process transforms * */ Transform transform = node.Transform; Transform parentTransform = node.ParentTransform; if (null == transform) { continue; // ROOT } //Debug.Log("node.Transform: " + transform); ComponentAdapter adapter = GuiLookup.GetAdapter(transform); bool thisIsStage = adapter is StageAdapter; /** * The adapter has been moved * It is still placed on the same (moved) transform * We are accessing the old and the new parent adapter via transforms: * - the old parent transform could be referenced using the node.OldParentTransform * - the new parent transform could be referenced using the node.ParentTransform * */ if (null == node.Transform) { throw new Exception("Transform is null"); } GroupAdapter oldParentAdapter = GuiLookup.GetAdapter(node.OldParentTransform) as GroupAdapter; GroupAdapter newParentAdapter = GuiLookup.GetAdapter(node.ParentTransform) as GroupAdapter; //Debug.Log(string.Format(" -> moving from [{0}] to [{1}]", oldParentAdapter, newParentAdapter)); /** * 2. Process adapters * */ if (null != oldParentAdapter) { oldParentAdapter.RemoveChild(adapter); ParentChildLinker.Instance.Update(oldParentAdapter); } if (null == newParentAdapter) { if (!thisIsStage) { const string txt = "eDriven.Gui components could be added to containers only"; //Debug.LogWarning(txt); throw new Exception(txt); } } else { newParentAdapter.AddChild(adapter, true); ParentChildLinker.Instance.Update(newParentAdapter); } /** * 3. If adapter stuff went without a problem... * */ node.Transform.parent = parentTransform; //ComponentAdapter adapter = GuiLookup.GetAdapter(transform); //bool thisIsStage = adapter is StageAdapter; ////Debug.Log("done."); //Transform parentTransform = node.ParentTransform; //if (null == parentTransform && !thisIsStage) // continue; // not a stage, return (if stage, should process) - only stage could be added to root //ContainerAdapter newParentAdapter = null; //if (null != parentTransform) // newParentAdapter = GuiLookup.GetAdapter(parentTransform) as ContainerAdapter; // /** // * 2. Process adapters // * */ // if (null != adapter) // { // // this is eDriven.Gui component. process it properly // if (null == newParentAdapter) // { // if (!thisIsStage) { // const string txt = "eDriven.Gui components could be added to containers only"; // //Debug.LogWarning(txt); // throw new Exception(txt); // //return; // } // } // else // { // ContainerAdapter oldParentAdapter = node.OldParentTransform.GetComponent<ContainerAdapter>(); // //Debug.Log("oldParentAdapter: " + oldParentAdapter); // //Debug.Log("newParentAdapter: " + newParentAdapter); // oldParentAdapter.RemoveChild(adapter); // newParentAdapter.AddChild(adapter, true); // ////if (!PrefabUtil.IsCreatedFromPrefab(oldParentAdapter)) // TODO: Need this? // // ParentChildLinker.Instance.Update(oldParentAdapter); // ////if (!PrefabUtil.IsCreatedFromPrefab(newParentAdapter)) // TODO: Need this? // // ParentChildLinker.Instance.Update(newParentAdapter); // if (EditorApplication.isPlaying) // { // if (!adapter.Instantiated) // adapter.DoInstantiate(true); // //Debug.Log(string.Format("OnHierarchyChange: Component instantiated: {0} [{1}]", adapter.Component, adapter.transform.GetInstanceID())); // } // var cmp = adapter.Component; // if (null == cmp) // { // throw new Exception("Component not found on ComponentAdapter: " + adapter); // } // } // } // /** // * 3. If adapter stuff went without a problem... // * */ // node.Transform.parent = parentTransform; } }
/// <summary> /// Checks the flags and executes the change received via the slots /// (the change that is not healthy to do inside the Render method) /// </summary> public override void Update() { if (null != _positionChangedParms) { //Debug.Log(string.Format("PositionChangedSlot: {0}, {1}", parameters[0], parameters[1])); DraggableItem draggableItem = (DraggableItem)_positionChangedParms[0]; int newItemIndex = (int)_positionChangedParms[1]; int newGroupIndex = (int)_positionChangedParms[2]; _positionChangedParms = null; ComponentAdapter adapter = (ComponentAdapter)draggableItem.Data; // Note: this actually applies changes to collections var pack = _groupManager.Reorder(adapter, newGroupIndex, newItemIndex); ParentChildLinker.Instance.Update(GroupAdapter, pack); //Refresh(); if (Application.isPlaying) { //ParentChildLinker.Instance.Update(ContainerAdapter, pack); // TODO: calling ParentChildLinker from here messes the thing RedrawComponentsInGameView(pack); } //HierarchyState.Instance.Rebuild(); EditorState.Instance.HierarchyChange(); /** * Emit for debugging purposes * */ CollectionChangedSignal.Emit(); } else if (null != _removedParms) { //Debug.Log(string.Format("RemovedSlot: {0}", parameters[0])); DraggableItem draggableItem = (DraggableItem)_removedParms[0]; //int groupIndex = (int)_removedParms[1]; //int itemIndex = (int)_removedParms[2]; _removedParms = null; ComponentAdapter adapter = draggableItem.Data as ComponentAdapter; if (null == adapter) { return; } //Debug.Log(string.Format("groupIndex: {0}, itemIndex: {1}", groupIndex, itemIndex)); /** * 1. Remove the adapter from the collection * */ var pack = _groupManager.Remove(adapter); /** * NOTE: We should not call the linker directly * That is because if we remove adapter from stage, the linker could not find it * We call the EditorState.Instance.HierarchyChange() below, so the * hierarchy change mechanism handles the removal stuff * */ //ParentChildLinker.Instance.Update(GroupAdapter, pack); if (Application.isPlaying) { RedrawComponentsInGameView(pack); } if (adapter.transform.parent != GroupAdapter.transform) { return; } //Refresh(); /** * 2. Check if the same adapter present in other collections * If not, remove the transform * */ var group = _groupManager.GetGroupContainingAdapter(adapter); //Debug.Log("group: " + group); if (null == group) { // this adapter is not present in any of the groups // remove the transform now OrderDisplayRow orderDisplayRow = (OrderDisplayRow)draggableItem; Transform transform = orderDisplayRow.Adapter.transform; GroupAdapter groupAdapter = transform.parent.GetComponent <GroupAdapter>(); groupAdapter.RemoveChild(orderDisplayRow.Adapter); //int instanceId = transform.GetInstanceID(); Object.DestroyImmediate(transform.gameObject); } // apply the change, for not to get the "ArgumentException: Getting control 3's position in a group with only 3 controls when doing Repaint Aborting" error Refresh(); //EditorState.Instance.HierarchyChange(); /** * Emit for debugging purposes * */ CollectionChangedSignal.Emit(); } if (null != _depthChangedParms) { //Debug.Log("OrderDisplay: changing depth"); // apply the change, for not to get the "ArgumentException: Getting control 3's position in a group with only 3 controls when doing Repaint Aborting" error //Refresh(); _depthChangedParms = null; } }