CrabUI.CUIGlobalStyleResolver Class Reference

Contains all logic for resolving styles in the framework. More...

Static Public Member Functions
static void	OnComponentStyleChanged (CUIComponent host)
static void	OnComponentStylePropChanged (CUIComponent host, string key)
static void	OnPaletteChange (CUIPalette palette)
static void	OnDefaultStyleChanged (Type CUIType)
static void	OnDefaultStylePropChanged (Type CUIType, string key)
static void	ApplyStyleOn (CUIStyle style, CUIComponent target)
static void	ApplyStylePropOn (CUIStyle style, string name, CUIComponent target, CUITypeMetaData meta=null)
	Applies 1 prop with name on the target.

Static Public Attributes
static string	CUIPalettePrefix = "CUIPalette."

Detailed Description

Contains all logic for resolving styles in the framework.

Definition at line 17 of file CUIGlobalStyleResolver.cs.

Member Function Documentation

ApplyStyleOn()

static void CrabUI.CUIGlobalStyleResolver.ApplyStyleOn ( CUIStyle style, CUIComponent target )

static

Definition at line 125 of file CUIGlobalStyleResolver.cs.

    {
      if (target == null)
      {
        CUI.Warning($"Style target is null");
        return;
      }
 
      CUITypeMetaData meta = CUITypeMetaData.Get(target.GetType());
 
      foreach (string name in style.Props.Keys)
      {
        ApplyStylePropOn(style, name, target, meta);
      }
    }

ApplyStylePropOn()

static void CrabUI.CUIGlobalStyleResolver.ApplyStylePropOn ( CUIStyle style, string name, CUIComponent target, CUITypeMetaData meta = null )

static

Applies 1 prop with name on the target.

Definition at line 146 of file CUIGlobalStyleResolver.cs.

    {
      if (target.Unreal) return;
 
      if (target == null) { CUI.Warning($"Style target is null"); return; }
 
      meta ??= CUITypeMetaData.Get(target.GetType());
 
      PropertyInfo pi = meta.Assignable.GetValueOrDefault(name);
 
      if (pi == null)
      {
        if (CUIPalette.NotifyExcessivePropStyles) CUI.Warning($"Can't apply style: Couldn't find {name} prop in {target}");
 
        return;
      }
 
      string raw = style[name];
 
      if (raw.StartsWith(CUIPalettePrefix))
      {
        PaletteExtractResult result = CUIPalette.Extract(raw.Substring(CUIPalettePrefix.Length), target.Palette);
        if (result.Ok)
        {
          raw = result.Value;
        }
        else
        {
          if (CUIPalette.NotifiMissingPropStyles)
          {
            CUI.Warning($"Can't find {raw.Substring(CUIPalettePrefix.Length)} palette style for {target}");
          }
          return;
        }
      }
 
      MethodInfo parse = CUIExtensions.Parse.GetValueOrDefault(pi.PropertyType);
 
      parse ??= pi.PropertyType.GetMethod(
        "Parse",
        BindingFlags.Public | BindingFlags.Static,
        new Type[] { typeof(string) }
      );
 
      if (parse == null)
      {
        CUI.Warning($"Can't parse style prop {name} for {target} because it's type {pi.PropertyType.Name} is missing Parse method");
        return;
      }
 
      try
      {
        pi.SetValue(target, parse.Invoke(null, new object[] { raw }));
      }
      catch (Exception e)
      {
        CUI.Warning($"Can't parse {raw} into {pi.PropertyType.Name} for {target}");
        CUI.Warning(e);
      }
    }

OnComponentStyleChanged()

static void CrabUI.CUIGlobalStyleResolver.OnComponentStyleChanged ( CUIComponent host )

static

Definition at line 21 of file CUIGlobalStyleResolver.cs.

    {
      CUITypeMetaData meta = CUITypeMetaData.Get(host.GetType());
      host.ResolvedStyle = CUIStyle.Merge(meta.ResolvedDefaultStyle, host.Style);
      ApplyStyleOn(host.ResolvedStyle, host);
      host.InvokeOnStyleApplied();
    }

OnComponentStylePropChanged()

static void CrabUI.CUIGlobalStyleResolver.OnComponentStylePropChanged ( CUIComponent host, string key )

static

Definition at line 29 of file CUIGlobalStyleResolver.cs.

    {
      CUITypeMetaData meta = CUITypeMetaData.Get(host.GetType());
 
      if (meta.ResolvedDefaultStyle.Props.ContainsKey(key))
      {
        host.ResolvedStyle[key] = meta.ResolvedDefaultStyle[key];
      }
 
      if (host.Style.Props.ContainsKey(key))
      {
        host.ResolvedStyle[key] = host.Style[key];
      }
 
      ApplyStylePropOn(host.ResolvedStyle, key, host, meta);
      host.InvokeOnStyleApplied();
    }

OnDefaultStyleChanged()

static void CrabUI.CUIGlobalStyleResolver.OnDefaultStyleChanged ( Type CUIType )

static

Definition at line 58 of file CUIGlobalStyleResolver.cs.

    {
      try
      {
        // Merge default styles
        CUIReflection.CUITypeTree[CUIType].RunRecursive((node) =>
        {
          node.Meta.ResolvedDefaultStyle = CUIStyle.Merge(
            node.Parent?.Meta.ResolvedDefaultStyle,
            node.Meta.DefaultStyle
          );
        });
 
        // Apply default styles
        CUIReflection.CUITypeTree[CUIType].RunRecursive((node) =>
        {
          foreach (CUIComponent c in CUIComponent.ComponentsByType.GetPage(node.T))
          {
            OnComponentStyleChanged(c);
          }
        });
      }
      catch (Exception e)
      {
        CUI.Warning($"OnDefaultStyleChanged| {e}");
      }
    }

OnDefaultStylePropChanged()

static void CrabUI.CUIGlobalStyleResolver.OnDefaultStylePropChanged ( Type CUIType, string key )

static

Definition at line 86 of file CUIGlobalStyleResolver.cs.

    {
      try
      {
        // Merge default styles
        CUIReflection.CUITypeTree[CUIType].RunRecursive((node) =>
        {
          if (node.Parent != null)
          {
            if (node.Parent.Meta.ResolvedDefaultStyle.Props.ContainsKey(key))
            {
              node.Meta.ResolvedDefaultStyle[key] = node.Parent.Meta.ResolvedDefaultStyle[key];
            }
          }
 
          if (node.Meta.DefaultStyle.Props.ContainsKey(key))
          {
            node.Meta.ResolvedDefaultStyle[key] = node.Meta.DefaultStyle[key];
          }
        });
 
        // Apply default styles
        CUIReflection.CUITypeTree[CUIType].RunRecursive((node) =>
        {
          foreach (CUIComponent c in CUIComponent.ComponentsByType.GetPage(node.T))
          {
            OnComponentStylePropChanged(c, key);
          }
        });
      }
      catch (Exception e)
      {
        CUI.Warning(e);
      }
    }

OnPaletteChange()

static void CrabUI.CUIGlobalStyleResolver.OnPaletteChange ( CUIPalette palette )

static

Definition at line 47 of file CUIGlobalStyleResolver.cs.

    {
      foreach (Type CUIType in CUIReflection.CUITypes.Values)
      {
        foreach (CUIComponent c in CUIComponent.ComponentsByType.GetPage(CUIType))
        {
          ApplyStyleOn(c.ResolvedStyle, c);
        }
      }
    }

Member Data Documentation

CUIPalettePrefix

string CrabUI.CUIGlobalStyleResolver.CUIPalettePrefix = "CUIPalette."

static

Definition at line 142 of file CUIGlobalStyleResolver.cs.

---

The documentation for this class was generated from the following file:

• CSharp/Client/CrabUI/Style/CUIGlobalStyleResolver.cs