Balancing calls inside of a EditorWindow OnGUI method causing problems

I’m making a system to balance calls inside of the OnGUI method of a EditorWindow.
I’m doing the following:

    public void Update()
    {
        Repaint();
    }

Inside of my OnGUI method I’m calling this Balancer. I have one list with the callbacks (List).
So the idea is simple, some callvaxc
I’m skipping some repaint frames for the callback that has the complete GUI, and calling on each repaint for other callbacks (for example, a marquee label or dispalying gifs).

By some reason, this error happens “Getting control 0’s position in a group with only 0 controls when doing repaint”

	private int m_repaintCounter;

	public void Draw()
    {
        Event e = Event.current;
        try
        {
            foreach (var action in m_actions)
            {
                try
                {

                        // Test 1
                        // MainAction is a class that inherits from Action (class MainAction : Action)
                        if (action is MainAction)
                        {
							bool isDesignedType = e.rawType == EventType.Repaint || e.rawType == EventType.Layout;

                            if (isDesignedType)
                                ++m_repaintCounter;

                            if (!(m_repaintCounter == 20 && isDesignedType))
                                continue;
                            else
                                m_repaintCounter = 0;
                        }

                        // Test 2
                        action.Value();
                }
                catch (Exception ex)
                {
                    Debug.LogException(ex);
                }
            }
        }
        catch
        {
            // Due to recompile the collection will modified, so we need to avoid the exception
        }
    }

But if I comment the “Test 1” everythings works fine.

On the ctor of the class we need to specify a callback to a GUI method, for example:

    public Balancer(Action drawAction)
    {
        m_actions = new List<Action>();
        m_actions.Add(drawAction);
    }

So we could do easily (inside the EditorWindow):

private Balancer m_balancer;

public void OnEnable() 
{
	m_balancer = new Balancer(Draw);
}

public void Draw() 
{
	// This block will be called every 20 repaints as specified on the if statment
	GUILayout.BeginHorizontal("box");
	{
	    GUILayout.Button("I'm the first button");
	    GUILayout.Button("I'm to the right");

	    // This marquee will be called on each repaint
	    m_balancer.AddAction(() => CustomClass.DisplayMarquee("example"));
	}
    GUILayout.EndHorizontal();
}

// Inside of the Balancer class we have
// We use System.Linq.Expressions to identify actions that were added already

private HashSet<string> m_alreadyAddedActions = new HashSet<string>();

public void AddAction(Expression<Action> callback) 
{
	if(!m_alreadyAddedActions.Add(callback.ToString()))
		return;

	m_actions.Add(callback.Compile());
}

I can’t figure this out. I couldn’t find any information on the internet. Can anyone help me?

What you do there completely breaks the GUI system. Every event that should be handled by OnGUI is paird with a layout event that comes directly before the actual event. You filter out random events which makes no sense at all.

You may want to read through my IMGUI crash course. Since UA has a broken Markdown renderer, you can find another version here which is slightly better formatted.

If you want to skip “repaint frames”, why do you call Repaint 200 times in the first place? Just do your skipping inside Update and let the GUI system alone.

With your current setup, even when you take the layout event out of your filtering the result would be a flashing GUI that is barely visible. When you call Repaint on an editor window it is actually cleared. Since you skip all the drawing, nothing would be drawn at all and you would have an empty window except every 20 redraws.