public void Move() { #if DEBUG if (DebugMode) { Debug.Log(string.Format(@"Moving: {0} ", DescribeMoves())); } #endif // TODO: CreatingContentPane pane has already been set from the outside (the caller of this method) // that is because this flag has to be set not only for mover operations, but also for "manual" aditions // so we must rethink if this is to be used also here (it's redundant) List<DisplayListMember> childrenToTransfer = new List<DisplayListMember>(); for (int i = 0; i < _numberOfChildrenToMove; i++) { childrenToTransfer.Add(_docFrom.QChildren[i]); } foreach (DisplayListMember child in childrenToTransfer) { /** * Note: we have to use container's AddChild/RemoveChild stuff, because else the control won't initialize properly and its Visible will be false! // 20130507 * */ if (null != _docFrom) _docFrom.RemoveChild(child); if (null != _docTo) _docTo.AddChild(child); } #if DEBUG if (DebugMode) { Debug.Log(string.Format(@"Moved: {0} ", DescribeMoves())); } #endif if (null != _docFrom) _docFrom.InvalidateDrawingList(); if (null != _docTo) _docTo.InvalidateDrawingList(); }
/// <summary> /// Gets all skin classes /// </summary> public static List<Type> GetAllStyleableClasses() { List<Type> allTypes = TypeReflector.GetAllLoadedTypes(); List<Type> output = new List<Type>(); foreach (Type type in allTypes) { if (type.IsClass) { if (/*!GuiComponentsOnly || */StyleClientType.IsAssignableFrom(type)) { if (CoreReflector.HasClassAttributes<StyleAttribute>(type)) output.Add(type); } } } return output; }
/// <summary> /// Gets a parent chain /// Example: If out component is in a chain Stage-A-B-C-Component, this method returns the list of: Stage, A, B, C. /// </summary> /// <param name="component">Compo</param> /// <param name="reverse">Reverse the chain</param> /// <returns></returns> public static List<DisplayListMember> GetParentChain(DisplayListMember component, bool reverse) { if (null == component) throw new Exception("Component not defined"); List<DisplayListMember> list = new List<DisplayListMember>(); DisplayListMember current = component; //list.Add(current); // removed on 2011-09-18 while (!(current is Stage) && null != current.Parent) { current = current.Parent; list.Add(current); } if (reverse) list.Reverse(); return list; }
/// <summary> /// Updates the supplied depth list using the order list<br/> /// Generally, it removes all the depth values, refills the list, and then sorts by the child Depth value /// </summary> /// <param name="orderList"></param> /// <param name="depthList"></param> // ReSharper disable SuggestBaseTypeForParameter private static void UpdateDrawingList(List<DisplayListMember> orderList, List<DisplayListMember> depthList) // ReSharper restore SuggestBaseTypeForParameter { //Debug.Log(string.Format(" ! -> [orderList: {0}, depthList: {1}]", orderList.Count, depthList.Count)); /** * 1. Empty the list * */ depthList.Clear(); int len = orderList.Count; /** * 2. Fill the list with values from the order list * */ foreach (DisplayListMember displayListMember in orderList) { depthList.Add(displayListMember); } //Debug.Log(" depthList.Count: " + depthList.Count); if (len <= 1) { #if DEBUG if (DebugMode) { Debug.Log(string.Format(" -> [orderList: {0}, depthList: {1}] *", orderList.Count, depthList.Count)); } #endif return; // don't bother } /** * 3. Sort by Depth * */ for (int i = 1; i < len; i++) { for (int j = i; j > 0; j--) { if (depthList[j].Depth < depthList[j - 1].Depth) { _tmp = depthList[j]; depthList[j] = depthList[j - 1]; depthList[j - 1] = _tmp; } //else // break; } } //Debug.Log(ListUtil<DisplayListMember>.Format(depthList)); #if DEBUG if (DebugMode) { Debug.Log(string.Format(" -> [orderList: {0}, depthList: {1}]", orderList.Count, depthList.Count)); } #endif }
///<summary> ///</summary> ///<param name="component"></param> ///<param name="delimiter"></param> ///<returns></returns> public static string PathToString(Component component, string delimiter) { if (string.IsNullOrEmpty(delimiter)) delimiter = "."; /** * 1. Build path * */ List<Component> list = new List<Component>(); while (null != component) { list.Add(component); component = component.Parent as Component; } list.Reverse(); string name = ""; int count = list.Count; for (int i = 0; i < count; i++) { name += list[i].Name; if (i < count - 1) name += delimiter; } return name; }
/// <summary> /// Describes mulricast delegates /// </summary> /// <param name="componentType"></param> /// <returns></returns> public static string GetMulticastDelegates(Type componentType) { var memberNames = CoreReflector.GetFieldAndPropertyNames(componentType); //memberNames.Sort(MemberInfoSort); List<string> data = new List<string>(); foreach (var name in memberNames) { MemberWrapper mw = new MemberWrapper(componentType, name); if (mw.MemberType == typeof (Core.Events.MulticastDelegate)) { var output = mw.MemberInfo.Name; /*var clazz = mw.MemberInfo.DeclaringType; if (null != clazz) { var types = var instance = Activator.CreateInstance(clazz); var value = mw.GetValue(instance); if (null != value) output = string.Format(@"{0} [{1}]", output, value.GetType().FullName); }*/ var attributes = CoreReflector.GetMemberAttributes<EventAttribute>(mw.MemberInfo); if (attributes.Count > 0) { var eventAttribute = attributes[0]; output = string.Format(@"{0} → {1}", output, eventAttribute); } data.Add(output); } } data.Sort(); StringBuilder sb = new StringBuilder(); foreach (var item in data) { sb.AppendLine(item); } return string.Format(@"Multicast delegates ({0}): {1} {2}", data.Count, Line, sb) + NewLine/* + NewLine*/; }
/*private static string GetInterfaces(Type componentType) { var interfaces = componentType.GetInterfaces(); var list = new List<string>(); foreach (Type type in interfaces) { list.Add(type.Name); } return string.Join(", ", list.ToArray()); }*/ private static string GetSubclasses(Type componentType) { var list = new List<string>(); foreach (Type type in GlobalTypeDictionary.Instance.Values) { if (type.BaseType == componentType) list.Add(type.Name); } return list.Count == 0 ? "-" : string.Join(", ", list.ToArray()); }
public override void Apply(Component component) { DataGroup dataProviderClient = component as DataGroup; SkinnableDataContainer skinnableDataContainer = component as SkinnableDataContainer; if (null == dataProviderClient && null == skinnableDataContainer) { Debug.LogWarning("GUI component is not a DataGroup nor SkinnableDataContainer"); return; } List<object> list = new List<object>(); foreach (string s in Data) { list.Add(new ListItem(s, s)); } if (null != dataProviderClient) dataProviderClient.DataProvider = new ArrayList(list); else skinnableDataContainer.DataProvider = new ArrayList(list); }
private void LoadAvailableSkins(ComponentAdapter adapter) { var skins = EditorReflector.GetSkins(adapter.ComponentType).ToList(); #if DEBUG if (true) { StringBuilder sb = new StringBuilder(); if (skins.Count == 0) { sb.AppendLine("No available skins."); } else { /*foreach (KeyValuePair<string, Type> pair in skins) { sb.AppendLine(string.Format(" {0} -> {1}", pair.Key, pair.Value)); }*/ foreach (var skin in skins) { sb.AppendLine(string.Format(" -> {0}", skin)); } } /*Debug.Log(string.Format(@"====== Skins ====== {0}", sb));*/ } #endif _availableSkinClasses = new List<string>(); //if (_couldNotLocateMapper) // list.Add("=== Not found ==="); //list.Add("= Default ="); foreach (Type skinClass in skins) { _availableSkinClasses.Add(skinClass.FullName); } }
/// <summary> /// Used by designer /// </summary> /// <param name="componentType"></param> public static List<Type> GetSkinClasses(Type componentType) { List<Type> list = new List<Type>(); //Debug.Log("componentType: " + componentType); if (!componentType.IsSubclassOf(typeof(SkinnableComponent))) { //Debug.LogError("Component is not a subclass of SkinnableComponent: " + componentType); return list; } List<Type> types = GuiReflector.GetAllLoadedTypes(); foreach (Type type in types) { if (!type.IsClass) continue; if (!type.IsSubclassOf(typeof (Skin))) continue; var componentTypeSpecifiedInAttribute = SkinUtil.GetHostComponent(type); if (componentTypeSpecifiedInAttribute == componentType) { list.Add(type); } } return list; }
/// <summary> /// Gets style properties (attributes converted to style properties) /// </summary> /// <param name="type"></param> /// <param name="restrictToSerializableTypes"></param> /// <returns></returns> public static List<StyleProperty> GetStyleProperties(Type type, bool restrictToSerializableTypes = false) { var attributes = GetStyleAttributes(type); List<StyleProperty> list = new List<StyleProperty>(); foreach (var attribute in attributes) { /* with "skinClass" style, the Type isn't required. Set it here */ if (attribute.Name == "skinClass"/* && null == attribute.Type*/) { attribute.Type = typeof(string); attribute.Default = null; } if (restrictToSerializableTypes && StyleProperty.NonSerializableStyleTypes.Contains(attribute.Type)) continue; //if (!restrictToSerializableTypes || StyleProperty.AlowedTypes.ContainsKey(attribute.GetType())) try { list.Add(StyleProperty.FromAttribute(attribute)); } catch (StylePropertyCreationException ex) { // cannot be created } } return list; }
public static List<ScriptWithEventHandlers> GetEventHandlerScriptsPacked(GameObject go) { List<ScriptWithEventHandlers> list = new List<ScriptWithEventHandlers>(); MonoBehaviour[] components = go.GetComponents<MonoBehaviour>(); foreach (MonoBehaviour component in components) { if (component is ComponentAdapter) continue; // ignore component descriptors ScriptWithEventHandlers mapping = new ScriptWithEventHandlers(); mapping.AddRange(GetMethodsBySignature(component.GetType(), typeof(void), typeof(Event))); list.Add(mapping); } return list; }
/// <summary> /// Looks for a stack of components under the specified coordinates inside of the parent component /// Does the top-down processing: from parent to children /// Returns the top-most rendered component on given coordinates (on a single stage) /// Notes: /// 1. The returned list must be refersed in order to get the top component at the beginning of the list! /// 2. This is a recursive operation /// </summary> /// <param name="dlm">Parent component</param> /// <param name="coords">Coordinates</param> /// <param name="filter">Filter</param> /// <param name="stopOnDisabled">Should the process stop if component disabled</param> /// <param name="stopOnInvisible">Should the process stop if component not visible></param> /// <param name="list">The list passed by reference</param> /// <returns></returns> private static void GetComponentStackUnderCoordinates(DisplayListMember dlm, Point coords, Filter filter, bool stopOnDisabled, bool stopOnInvisible, ref List<DisplayListMember> list) { var component = dlm as InteractiveComponent; //Debug.Log("GetComponentStackUnderCoordinates: " + dlm); if (null != component) { if (stopOnInvisible && !dlm.Visible) // invisible return; if (stopOnDisabled && !component.Enabled) // disabled return; } _containsPoint = dlm.ContainsPoint(coords, false); //Debug.Log(" _containsPoint: " + dlm); if (_containsPoint && PassesFilter(dlm, filter)) { //Debug.Log(" PassesFilter: " + dlm); list.Add(dlm); } Group @group = dlm as Group; // in the case of container check the children if (null != @group) { if (!_containsPoint /*&& container.QClipContent*/) return; // the click was inside the container bounds, or container isn't clipping // check the children for clicks if (@group.MouseChildren) { foreach(DisplayListMember d in @group.QDrawingList) { //Component child = d as Component; //if (null != child) //{ /* Recursive call! */ //DisplayListMember c = GetComponentUnderCoordinates(d, coords, filter, stopOnDisabled); GetComponentStackUnderCoordinates(d, coords, filter, stopOnDisabled, stopOnInvisible, ref list); //Debug.Log(" -> " + c); //if (null != c) // list.Add(c); //} } } } else // simple component { DisplayObjectContainer doc = dlm as DisplayObjectContainer; // the click was inside the container bounds, or container isn't clipping // check the children for clicks if (null != doc && doc.QNumberOfChildren > 0 && doc.MouseChildren) { foreach (DisplayListMember d in doc.QDrawingList) { GetComponentStackUnderCoordinates(d, coords, filter, stopOnDisabled, stopOnInvisible, ref list); //DisplayListMember c = GetComponentUnderCoordinates(d, coords, filter, stopOnDisabled); //if (null != c) // list.Add(c); } } } }
/// <summary> /// Finds the Component stack under the mouse poiner /// </summary> // ReSharper disable MemberCanBePrivate.Global public void RecalculateMouseWheelTargets() // ReSharper restore MemberCanBePrivate.Global { //Debug.Log("RecalculateMouseWheelTargets: " + deltaY); if (_isMouseLeave) { _mouseWheelTargets.Clear(); return; } var members = CoordinateProcessor.GetComponentStackUnderCoordinatesOnAllStages( _mouseEvent.GlobalPosition, MouseWheelFilter, true, true // stopOnDisabled, stopOnInvisible ); _mouseWheelTargets = new List<Component>(); foreach (DisplayListMember member in members) { _mouseWheelTargets.Add((Component)member); } // Important: reverse targets //_mouseWheelTargets.Reverse(); // Debug.Log(string.Format(@"Mouse wheel targets ({0}): //{1}", _mouseWheelTargets.Count, ComponentUtil.DescribeComponentList(_mouseWheelTargets))); #if DEBUG if (DebugMode) { Debug.Log(string.Format(@"Mouse wheel targets ({0}): {1}", _mouseWheelTargets.Count, ComponentUtil.DescribeComponentList(_mouseWheelTargets))); } #endif }
/** * * Returns the base states for a given state. * This Array is in high-to-low order - the first entry * is the immediate basedOn state, the last entry is the topmost * basedOn state. */ private List<string> GetBaseStates(State state) { var baseStates = new List<string>(); // Push each basedOn name while (null != state && null != state.BasedOn) { baseStates.Add(state.BasedOn); state = GetState(state.BasedOn, true); } return baseStates; }
internal void RefreshComponentList() { _showComponents = EditorSettings.ReferenceShowComponents; _showSkinnableComponents = EditorSettings.ReferenceShowSkinnableComponents; _showSkins = EditorSettings.ReferenceShowSkins; _selectedIndex = -1; _selectionChanged = false; _classes.Clear(); var allClasses = GuiReflector.GetAllLoadedTypes(); foreach (var type in allClasses) { if (typeof(Component).IsAssignableFrom(type)) { if (!string.IsNullOrEmpty(_searchText) && !PassesSearchFilter(type.FullName, _searchText)) /*!type.FullName.ToUpper().Contains(_searchText.ToUpper())*/ continue; _classes.Add(type); } } _classes.Sort(TypeSort); //Debug.Log("_classes: " + _classes.Count); List<GUIContent> contentList = new List<GUIContent>(); foreach (var @class in _classes) { var isSkinnableComponent = typeof(SkinnableComponent).IsAssignableFrom(@class); var isSkin = typeof(Skin).IsAssignableFrom(@class); var isSimpleComponent = !isSkinnableComponent && !isSkin; var texture = GuiComponentEvaluator.EvaluateComponentRowIcon(@class); if (_showComponents && isSimpleComponent || _showSkinnableComponents && isSkinnableComponent || _showSkins && isSkin) { contentList.Add(new GUIContent(" " + @class.FullName, texture)); } } _contents = contentList.ToArray(); //Debug.Log("_contents: " + _contents.Length); }
override protected void AdjustSelection(int index, bool add/*=false*/) { int i; int curr; var newInterval = new List<int>(); IndexChangeEvent e; if (SelectedIndex == NO_SELECTION || DoingWholesaleChanges) { // The case where one item has been newly added and it needs to be // selected and careted because requireSelection is true. if (null != DataProvider && DataProvider.Length == 1 && RequireSelection) { newInterval.Add(0); _selectedIndices = newInterval; SelectedIndex = 0; ItemShowingCaret(0, true); // If the selection properties have been adjusted to account for items that // have been added or removed, send out a "valueCommit" event and // "caretChange" event so any bindings to them are updated correctly. DispatchEvent(new FrameworkEvent(FrameworkEvent.VALUE_COMMIT)); e = new IndexChangeEvent(IndexChangeEvent.CARET_CHANGE) {OldIndex = -1, NewIndex = CaretIndex}; DispatchEvent(e); } return; } // Ensure multiple and single selection are in-sync before adjusting // selection. Sometimes if selection has been changed before adding/removing // an item, we may not have handled selection via invalidation, so in those // cases, force a call to commitSelection() to validate and commit the selection. if ((null == SelectedIndices && SelectedIndex > NO_SELECTION) || (SelectedIndex > NO_SELECTION && null != SelectedIndices && SelectedIndices.IndexOf(SelectedIndex) == -1)) { CommitSelection(true); } // Handle the add or remove and adjust selection accordingly. if (add) { if (null != SelectedIndices) { for (i = 0; i < SelectedIndices.Count; i++) { curr = SelectedIndices[i]; // Adding an item above one of the selected items, // bump the selected item up. if (curr >= index) newInterval.Add(curr + 1); else newInterval.Add(curr); } } } else { // Quick check to see if we're removing the only selected item // in which case we need to honor requireSelection. if (null != SelectedIndices && !IsEmpty(SelectedIndices) && SelectedIndices.Count == 1 && index == SelectedIndex && RequireSelection) { //Removing the last item if (DataProvider.Length == 0) { newInterval = new List<int>(); } else if (index == 0) { // We can't just set selectedIndex to 0 directly // since the previous value was 0 and the new value is // 0, so the setter will return early. ProposedSelectedIndex = 0; InvalidateProperties(); return; } else { newInterval.Add(0); } } else if (null != SelectedIndices) { for (i = 0; i < SelectedIndices.Count; i++) { curr = SelectedIndices[i]; // Removing an item above one of the selected items, // bump the selected item down. if (curr > index) newInterval.Add(curr - 1); else if (curr < index) newInterval.Add(curr); } } } if (CaretIndex == SelectedIndex) { var oldIndex = CaretIndex; CaretIndex = GetFirstItemValue(newInterval); e = new IndexChangeEvent(IndexChangeEvent.CARET_CHANGE) {OldIndex = oldIndex, NewIndex = CaretIndex}; DispatchEvent(e); } else { ItemShowingCaret(CaretIndex, false); CaretIndexAdjusted = true; InvalidateProperties(); } var oldIndices = SelectedIndices; _selectedIndices = newInterval; SelectedIndex = GetFirstItemValue(newInterval); if (_selectedIndices != oldIndices) { SelectedIndexAdjusted = true; InvalidateProperties(); } }
public override List<DisplayListMember> GetTabChildren() { List<DisplayListMember> list = new List<DisplayListMember>(); list.AddRange(new DisplayListMember[]{ _btnCc, _btnBcc, _txtTo }); if (_btnCc.Selected) list.Add(_txtCc); if (_btnBcc.Selected) list.Add(_txtBcc); list.AddRange(new DisplayListMember[]{ _txtMessage, _btnSend }); return list; }
/** * * Given a new selection interval, figure out which * items are newly added/removed from the selection interval and update * selection properties and view accordingly. */ // ReSharper disable MemberCanBePrivate.Global protected void CommitMultipleSelection() // ReSharper restore MemberCanBePrivate.Global { var removedItems = new List<int>(); var addedItems = new List<int>(); int i; int count; if (!IsEmpty(_selectedIndices) && !IsEmpty(_proposedSelectedIndices)) { // Changing selection, determine which items were added to the // selection interval count = _proposedSelectedIndices.Count; for (i = 0; i < count; i++) { if (_selectedIndices.IndexOf(_proposedSelectedIndices[i]) < 0) addedItems.Add(_proposedSelectedIndices[i]); } // Then determine which items were removed from the selection // interval count = _selectedIndices.Count; for (i = 0; i < count; i++) { if (_proposedSelectedIndices.IndexOf(_selectedIndices[i]) < 0) removedItems.Add(_selectedIndices[i]); } } else if (!IsEmpty(_selectedIndices)) { // Going to a null selection, remove all removedItems = _selectedIndices; } else if (!IsEmpty(_proposedSelectedIndices)) { // Going from a null selection, add all addedItems = _proposedSelectedIndices; } // De-select the old items that were selected if (removedItems.Count > 0) { count = removedItems.Count; for (i = 0; i < count; i++) { ItemSelected(removedItems[i], false); } } // Select the new items in the new selection interval if (!IsEmpty(_proposedSelectedIndices)) { count = _proposedSelectedIndices.Count; for (i = 0; i < count; i++) { ItemSelected(_proposedSelectedIndices[i], true); } } // Commit the selected indices and put _proposedSelectedIndices // back to its default value. _selectedIndices = _proposedSelectedIndices; _proposedSelectedIndices = new List<int>(); }
private static string GetInheritance(Type componentType) { List<string> list = new List<string>(); while (null != componentType && (componentType != typeof(Component).BaseType)) // all up to Component { list.Add(componentType.Name); componentType = componentType.BaseType; } return string.Join(" → ", list.ToArray()); }
internal static void InitProtoChain(IStyleClient client) { /*if (client.GetType().FullName == "Assets.eDriven.Skins.ImageButtonSkin") Debug.Log("Assets.eDriven.Skins.ImageButtonSkin: " + client);*/ //Debug.Log("InitProtoChain: " + client); StyleManager styleManager = StyleManager.Instance; //StyleDeclaration classSelector = null; Component uicObject = client as Component; StyleDeclaration styleDeclaration; List<StyleDeclaration> universalSelectors = new List<StyleDeclaration>(); bool hasStyleName = false; object styleName = client.StyleName; //Debug.LogWarning("styleName: " + styleName); /** * prvo gledamo classname setiran na ovoj komponenti * ako je setiran, uzimamo style declaration za taj classname iz poola * */ if (null != styleName) { /*if (client.StyleName is string && (string)client.StyleName == "test") Debug.Log("client.StyleName");*/ // Get the style sheet referenced by the styleName property //classSelector = StyleManager.Instance.GetStyleDeclaration("." + StyleName); if (styleName is StyleDeclaration) { //Debug.LogWarning("Style name is StyleDeclaration: " + styleName); // Get the styles referenced by the styleName property. universalSelectors.Add((StyleDeclaration)styleName); } #region Still not used. This is normally used for parent-child style propagation (skins) //else if (/*styleName is IFlexDisplayObject || */styleName is IStyleClient) // TODO //{ // // If the styleName property is a Component, then there's a // // special search path for that case. // StyleProtoChain.InitProtoChainForUIComponentStyleName(client); // return; //} #endregion else if (styleName is string) { //Debug.LogWarning("Style name is istring: " + styleName); hasStyleName = true; } else { Debug.LogWarning("Error"); } } /** * ovdje sada imamo style declaration za classname * nakon toga moramo uzeti non-inherit chain (global root) i * inherit chain (inheriting styles od parenta) * oni su nam potrebni kako bi prenijeli stilove iz parenta ukoliko nisu deklarirani na ovoj komponenti * */ // To build the proto chain, we start at the end and work forward. // Referring to the list at the top of this function, we'll start by // getting the tail of the proto chain, which is: // - for non-inheriting styles, the global style sheet // - for inheriting styles, my parent's style object StyleTable nonInheritChain = styleManager.StylesRoot; StyleTable inheritChain; //IStyleClient p = Parent as IStyleClient; IStyleClient p = null; var visual = client as IVisualElement; if (null != visual) p = visual.Parent as IStyleClient; if (null != p) { inheritChain = p.InheritingStyles; #region Monitor //#if DEBUG // if (null != TYPE_TO_MONITOR) // { // if (uicObject.GetType() == TYPE_TO_MONITOR) // { // StringBuilder sb = new StringBuilder(); // sb.AppendLine(client + " -> parent chains:"); // sb.AppendLine("p.InheritingStyles: " + p.InheritingStyles); // sb.AppendLine("p.NonInheritingStyles: " + p.NonInheritingStyles); // Debug.Log(sb); // } // } //#endif #endregion if (inheritChain == STYLE_UNINITIALIZED) { // ako parent nema inicijaliziran inherit chain, znači da ništa ne nasljeđuje od svojih parenta // te također ni on sam ne definira niti jedan inheriting style. // u tom slučaju se možemo referencirati na non-inherit chain inheritChain = nonInheritChain; } } else { inheritChain = styleManager.StylesRoot; } #region Monitor //#if DEBUG // if (null != TYPE_TO_MONITOR) // { // if (uicObject.GetType() == TYPE_TO_MONITOR) // { // StringBuilder sb = new StringBuilder(); // sb.AppendLine(client + " -> chains:"); // sb.AppendLine("inheritChain: " + inheritChain); // sb.AppendLine("nonInheritChain: " + nonInheritChain); // Debug.Log(sb); // } // } //#endif #endregion /** * Sada moramo obraditi type deklaracije * Radi se o tome da stil Buttona nasljeđuje i stilove definirane na superklasama * Znači prvo potrebno je izbildati niz deklaracija (gleda se da li postoje definirane u stylesheetu) * i to redoslijedom od superklasa do ove klase * To odrađuje metoda "getClassStyleDeclarations()" koja vraća taj mini-niz * Redoslijed u nizu je bitan jer propertyji definirani na subklasi overrajdaju one na superklasi * */ // Working backwards up the list, the next element in the // search path is the type selector List<StyleDeclaration> styleDeclarations = GetMatchingStyleDeclarations(client, universalSelectors); if (null != styleDeclarations) { #region Monitor if (StyleDebugging.DebugComponents.Contains(client.GetType())) { StyleDebugging.DebugDeclarationApplication(client, styleDeclarations); } #endregion int n = styleDeclarations.Count; //typeSelectors.Count; for (int i = 0; i < n; i++) { styleDeclaration = styleDeclarations[i]; inheritChain = styleDeclaration.AddStyleToProtoChain(inheritChain, uicObject); nonInheritChain = styleDeclaration.AddStyleToProtoChain(nonInheritChain, uicObject); } } #region For simple (string) styles (like ".stile") - not used here //int n; //if (hasStyleName) //{ // var styleNames = Regex.Split((string) styleName, @"/\s+/"); // n = styleNames.Count(); // for (var i = 0; i < n; i++) // { // if (styleNames[i].Length > 0) // { // styleDeclaration = styleManager.GetMergedStyleDeclaration("." + styleNames[i]); // if (null != styleDeclaration) // universalSelectors.Add(styleDeclaration); // } // } //} //// Working backwards up the list, the next element in the //// search path is the type selector //var styleDeclarations = client.GetClassStyleDeclarations(); ////Debug.Log("##### styleDeclarations: " + styleDeclarations.Count); ////if (client is Skin && ((Skin)client).Parent is Button) ///*if (client.GetType().FullName == "Assets.eDriven.Skins.ImageButtonSkin") // Debug.Log("Skin: " + client);*/ //if (null != styleDeclarations) //{ // n = styleDeclarations.Count; //typeSelectors.Count; // for (int i = 0; i < n; i++) // { // styleDeclaration = styleDeclarations[i]; // inheritChain = styleDeclaration.AddStyleToProtoChain(inheritChain, uicObject); // nonInheritChain = styleDeclaration.AddStyleToProtoChain(nonInheritChain, uicObject); // /*if (styleDeclaration.effects) // object.registerEffects(styleDeclaration.effects);*/ // } //} //// Next are the class selectors //n = universalSelectors.Count; //for (var i = 0; i < n; i++) //{ // styleDeclaration = universalSelectors[i]; // if (null != styleDeclaration) // { // inheritChain = styleDeclaration.AddStyleToProtoChain(inheritChain, uicObject); // nonInheritChain = styleDeclaration.AddStyleToProtoChain(nonInheritChain, uicObject); // /*if (styleDeclaration.effects) // object.registerEffects(styleDeclaration.effects);*/ // } //} #endregion // Finally, we'll add the in-line styles // to the head of the proto chain. styleDeclaration = client.StyleDeclaration; client.InheritingStyles = null != styleDeclaration ? styleDeclaration.AddStyleToProtoChain(inheritChain, uicObject) : inheritChain; client.NonInheritingStyles = null != styleDeclaration ? styleDeclaration.AddStyleToProtoChain(nonInheritChain, uicObject) : nonInheritChain; #region Monitor //#if DEBUG // if (null != TYPE_TO_MONITOR) // { // if (uicObject.GetType() == TYPE_TO_MONITOR || uicObject.GetType() == typeof(HGroup)) // { // StringBuilder sb = new StringBuilder(); // sb.AppendLine(@"### proto chain initialized ### //" + ComponentUtil.PathToString(uicObject, "->")); // sb.AppendLine(); // if (null != client.StyleDeclaration && null != client.StyleDeclaration.Overrides) // { // sb.AppendLine("Overrides: " + client.StyleDeclaration.Overrides); // } // sb.AppendLine(); // sb.AppendLine("InheritingStyles: " + client.InheritingStyles); // sb.AppendLine(); // sb.AppendLine("NonInheritingStyles: " + client.NonInheritingStyles); // Debug.Log(sb); // } // } //#endif #endregion }
/*private static int ClassNameSort(Type x, Type y) { return String.Compare(x.Name, y.Name, StringComparison.OrdinalIgnoreCase); }*/ #endregion #region Skin parts /// <summary> /// Describes skin parts /// </summary> /// <param name="componentType"></param> /// <returns></returns> public static string GetSkinParts(Type componentType) { if (!typeof(SkinnableComponent).IsAssignableFrom(componentType)) { return string.Format(@"Skin parts: Not a skinnable component." + NewLine + NewLine); } var dict = GuiReflector.GetSkinParts(componentType); // string->bool var list = new List<string>(); foreach (string key in dict.Keys) { list.Add(key); } list.Sort(); StringBuilder sb = new StringBuilder(); foreach (var name in list) { MemberWrapper mw = new MemberWrapper(componentType, name); sb.AppendLine(string.Format("{0} [Type: {1}, Required: {2}]", name, mw.MemberType, dict[name])); } return string.Format(@"Skin parts ({0}): {1} {2}", list.Count, Line, sb) + NewLine/* + NewLine*/; }
private static List<StyleDeclaration> MatchStyleDeclarations(List<StyleDeclaration> declarations, IStyleClient client) { //Debug.Log("declarations: " + declarations); //if (null == declarations) // return null; var matchingDecls = new List<StyleDeclaration>(); if (null == declarations) return matchingDecls; // Find the subset of declarations that match this component foreach (StyleDeclaration decl in declarations) { if (decl.MatchesStyleClient(client)) matchingDecls.Add(decl); } return matchingDecls; }
private static string GetSignals(Type componentType) { var memberNames = CoreReflector.GetFieldAndPropertyNames(componentType); //memberNames.Sort(MemberInfoSort); List<MemberInfo> infos = new List<MemberInfo>(); foreach (var name in memberNames) { MemberWrapper mw = new MemberWrapper(componentType, name); if (mw.MemberType == typeof(Signal)) infos.Add(mw.MemberInfo); } infos.Sort(MemberInfoSort); StringBuilder sb = new StringBuilder(); foreach (var memberInfo in infos) { sb.AppendLine(memberInfo.Name); } return string.Format(@"Signals ({0}): {1} {2}", infos.Count, Line, sb) + NewLine/* + NewLine*/; }
// TODO: handle skipping non-focused components and circular changes private List<FocusableComponentDescriptor> GetFocusableComponents() { List<FocusableComponentDescriptor> list = new List<FocusableComponentDescriptor>(); ITabManagerClient fmc = _component as ITabManagerClient; if (null == fmc) return list; _components = TabChildren ?? fmc.GetTabChildren(); int index = 0; _components.ForEach(delegate(DisplayListMember child) { InteractiveComponent comp = child as InteractiveComponent; // form item if (FocusManager.IsFocusCandidate(comp)) // visible & enabled & focus enabled? list.Add(new FocusableComponentDescriptor(index, comp)); index++; }); return list; }
/// <summary> /// Gets all style properties /// </summary> /// <param name="type"></param> /// <param name="restrictToInspectableTypes"></param> public static List<StyleAttribute> GetStyleAttributes(Type type) { if (StyleAttributeCache.ContainsKey(type)) return StyleAttributeCache[type]; var styleAttributes = CoreReflector.GetClassAttributes<StyleAttribute>(type); List<StyleAttribute> attributes = new List<StyleAttribute>(); foreach (StyleAttribute attribute in styleAttributes) { /* with "skinClass" style, the Type isn't required. Set it here */ /*if (attribute.Name == "skinClass" && null == attribute.Type) attribute.Type = typeof(object);*/ if (/*!restrictToInspectableTypes || */(attribute.Name == "skinClass" || null != attribute.Type/* && StyleProperty.AlowedTypes.ContainsKey(attribute.Type)*/)) { /** * Important: Avoid duplication * Subclass attributes are being added before the superclass attributes, so we're fine * */ var name = attribute.Name; if (!attributes.Exists(delegate(StyleAttribute a) { return a.Name == name; })) { attributes.Add(attribute); } else { //Debug.Log(type + " has duplicated attribute: " + name + ": " + attribute.GetDefault()); } } } StyleAttributeCache[type] = attributes; return attributes; }
///<summary> ///</summary> ///<param name="type"></param> ///<param name="class"></param> ///<param name="id"></param> ///<param name="pseudo"></param> ///<returns></returns> internal static Selector BuildSelector(string type, string @class, string id, string pseudo) { Selector selector = new Selector(null); if (!string.IsNullOrEmpty(type)) { selector.Subject = type; } //Debug.Log(2); List<CSSCondition> conditions = new List<CSSCondition>(); if (!string.IsNullOrEmpty(@class)) { conditions.Add(new CSSCondition(CSSConditionKind.Class, @class)); } //Debug.Log(3); if (!string.IsNullOrEmpty(id)) { conditions.Add(new CSSCondition(CSSConditionKind.Id, id)); } /*if (!string.IsNullOrEmpty(pseudo)) { conditions.Add(new CSSCondition(CSSConditionKind.Pseudo, pseudo)); }*/ selector.Conditions = conditions; return selector; }
/** * */ // Returns an array of possible values private List<int> FindMatchingItems(string input) { // For now, just select the first match int startIndex; int stopIndex; int retVal; var retVector = new List<int>(); retVal = FindStringLoop(input, 0, DataProvider.Length); if (retVal != -1) retVector.Add(retVal); return retVector; }
/** * Return the indices of the item renderers visible within this DataGroup. * * <p>If clipAndEnableScrolling=true, return the indices of the visible=true * ItemRenderers that overlap this DataGroup's scrollRect, i.e. the ItemRenders * that are at least partially visible relative to this DataGroup. If * clipAndEnableScrolling=false, return a list of integers from * 0 to dataProvider.length - 1. Note that if this DataGroup's owner is a * Scroller, then clipAndEnableScrolling has been set to true.</p> * * <p>The corresponding item renderer for each returned index can be * retrieved with getElementAt(), even if the layout is virtual</p> * * <p>The order of the items in the returned Vector is not guaranteed.</p> * * <p>Note that the VerticalLayout and HorizontalLayout classes provide bindable * firstIndexInView and lastIndexInView properties which convey the same information * as this method.</p> * * Returns: The indices of the visible item renderers. */ ///<summary> ///</summary> ///<returns></returns> // ReSharper disable UnusedMember.Global public List<int> GetItemIndicesInView() // ReSharper restore UnusedMember.Global { if (null != Layout/* && Layout.UseVirtualLayout*/) return (null != _virtualRendererIndices) ? new List<int>(_virtualRendererIndices) : new List<int>(0); if (null == DataProvider) return new List<int>(); Rectangle scrollR = ScrollRect; int dataProviderLength = DataProvider.Length; if (null != scrollR) { List<int> visibleIndices = new List<int>(); Rectangle eltR = new Rectangle(); //const perspectiveProjection:PerspectiveProjection = transform.perspectiveProjection; for (int index = 0; index < dataProviderLength; index++) { //IVisualElement elt = GetContentChildAt(index); // element! InvalidationManagerClient elt = (InvalidationManagerClient) GetContentChildAt(index); // element! if (null == elt || !elt.Visible) continue; eltR.X = LayoutUtil.GetLayoutBoundsX(elt); //elt.getLayoutBoundsX(); eltR.Y = LayoutUtil.GetLayoutBoundsX(elt); //elt.getLayoutBoundsY(); eltR.Width = LayoutUtil.GetLayoutBoundsWidth(elt); //elt.getLayoutBoundsWidth(); eltR.Height = LayoutUtil.GetLayoutBoundsHeight(elt); //elt.getLayoutBoundsHeight(); if (scrollR.Intersects(eltR)) visibleIndices.Add(index); } return visibleIndices; } List<int> allIndices = new List<int>(dataProviderLength); for (var index = 0; index < dataProviderLength; index++) allIndices[index] = index; return allIndices; }