var cmToggle = new CmToggle(..);
 cmToogle.modifiers.CheckMark(
     // create modifier for DEFAULT_STATE but we will add other state using ____NextSelector
     new CmModifierImageAndBackground(CmSelector.DEFAULT_STATE)
         .BorderWidth(0)
         .BorderRadius(60.px())
         .BorderColorRGBA(new Color32(255, 51, 4, 255))

         //Now add modifiers for HOVER state
         .____NextSelector(CmSelector.HOVER)
         .Scale(1.2f)

         //Now add modifiers for the DISABLED state
         .____NextSelector(CmSelector.DISABLED)
         .BackgroundColorRGBA(Color.white)

         //Now add modifiers for the CHECKED state
         .____NextSelector(CmSelector.CHECKED)
         .BackgroundColorRGBA(Color.gray)
 );

public abstract class CmExample1ThemeBase : CmThemeBase
{
    public abstract void StyleButton(CmButton button);
}

    public class CmExample1ThemeOne : CmExample1ThemeBase
    {
        public override CmButtonModifiers StyleButton()
        {
            // get style builder for button and set styles for two states - default, on mouse hover
            var modifiers = CmButton.GetModifiersBuilder();
            modifiers.Button(
                new CmModifierText(CmSelector.DefaultState)
                    .AnimDuration(300) // 300 miliseconds
                    .BackgroundColorRGBA(Color.white)
                    .TextFontSize(30.Px())

                    // below section is for mouse hover state
                    .____NextSelector(CmSelector.Hover)
                    .Scale(1.2f, 1.2f) // scale x and y
                    .BackgroundColorRGBA(new Color(1f, 7.0f, 0.4f, 1.0f)) // rgba
            );
            return modifiers;
        }

     // create simple button with text and UI event handler from this screen to handle events in this screen
    var button = new CmButton(this, text, GetCmUiEventsHandler());

    // get theme assigned to this screen and use its function to style this button
    button.SetStyle(GetTheme().StyleButton);

            // get style builder for button and set styles for two states - default, on mouse hover
            var modifiers = CmButton.GetModifiersBuilder();
            modifiers.Button(
                new CmModifierText(CmSelector.DefaultState)
                    .AnimDuration(300) // 300 miliseconds
                    .BackgroundColorRGBA(Color.white)
                    .TextFontSize(30.Px())

                    // below section is for mouse hover state
                    .____NextSelector(CmSelector.Hover)
                    .Scale(1.2f, 1.2f) // scale x and y
                    .BackgroundColorRGBA(new Color(1f, 7.0f, 0.4f, 1.0f)) // rgba
            );

public class MyFirstScreenManager : CmScreenManager<MyFirstTheme>
{
    public override void OnBindUiEventsHandler(CmUIEventsHandler eventsHandler)
    {
        // here you can handle events from your screens if you want.
        // for example button clicks or other
    }

    public override void OnAddSupportedScreens(List<CmScreen<MyFirstTheme>> supportedScreenList)
    {
        // here we will add our screens for this scene. For example settings, about, map select
    }

    public override void OnAddSupportedThemes(List<MyFirstTheme> themeBases)
    {
        // here we will add all our themes or just one theme if we will not add more
        // usually we will add one theme.
    }

    public override void OnSetMainScreen()
    {
        // this is called on start. Here we set which screen is main by just moving to it
    }
}

    public abstract class MyFirstTheme: CmThemeBase
    {
    }

    public abstract class MyFirstTheme: CmThemeBase
    {
        public abstract CmButtonModifiers StyleButton();
    }

    // white theme implementation
    public class MyFirstThemeWhite: MyFirstTheme
    {
        public override CmButtonModifiers StyleButton() {
            // here we would add styling for white button
        }

        public override string GetThemeName()
        {
            return "MyFirstThemeWhite";
        }
    }

    // black theme implementation
    public class MyFirstThemeBlack: MyFirstTheme
    {
        public override CmButtonModifiers StyleButton() {
            // here we would add styling for black button
        }

        public override string GetThemeName()
        {
            return "MyFirstThemeBlack";
        }
    }

    // white theme implementation
    public class MyFirstThemeWhite: MyFirstTheme
    {
        public override string GetThemeName()
        {
            return "MyFirstThemeWhite";
        }
    }

public class MyFirstScreenManager : CmScreenManager<MyFirstTheme>
{
    public override void OnBindUiEventsHandler(CmUIEventsHandler eventsHandler)
    {
        // here you can handle events from your screens if you want.
        // for example button clicks or other
    }

    public override void OnAddSupportedScreens(List<CmScreen<MyFirstTheme>> supportedScreenList)
    {
        // here we will add our screens for this scene. For example settings, about, map select
    }

    public override void OnAddSupportedThemes(List<MyFirstTheme> themeBases)
    {
        // add our theme implementation (wchich is empty for now)
        themeBases.Add(new MyFirstThemeWhite());
    }

    public override void OnSetMainScreen()
    {
        // this is called on start. Here we set which screen is main by just moving to it
    }
}

    public class MyFirstMainMenuScreen : CmScreen<MyFirstTheme>
    {
        public MyFirstMainMenuScreen(CmScreenManager<MyFirstTheme> parent = null,
            VisualElement root = null) : base(parent, root)
        {
            // this can be always empty
        }

        public override void BindUIEventsOnStart(CmUIEventsHandler eventsHandler)
        {
            // this method is the same as in your screen manager
            // here you can handle events from your screen if you want.
            // for example button clicks or other
        }

        public override void OnMakeScreenContent(ScreenContentBuilder contentBuilder)
        {
            // here we will create our controls and set styling for our controls using mthods from base theme (as you remember these methods are abstract so we don't know need to know which implementation is currently used)
        }

        public override string GetScreenName()
        {
            // Screen name is useful for further screen changing in game/menu. You will change screens using their names
            return "MainMenu";
        }
    }

    public class MyFirstMainMenuScreen : CmScreen<MyFirstTheme>
    {
        public MyFirstMainMenuScreen(CmScreenManager<MyFirstTheme> parent,
            VisualElement root = null) : base(parent, root)
        {
            // this can be always empty
        }

        public override void BindUIEventsOnStart(CmUIEventsHandler eventsHandler)
        {
            // we don't handle any on click events now so it will be empty
        }

        public override void OnMakeScreenContent(ScreenContentBuilder contentBuilder)
        {
            // here we add:
            // 1. Main contanier for the whole screen. This is background
            var mainContainer = new CmColumn(this);
            mainContainer.SetStyle(GetTheme().MainContainer);

            // now we add center panel with buttons to this mainContainer
            AddCenterPanel(mainContainer);

            // add whole content to
            contentBuilder.AddContent(mainContainer);
        }

        private void AddCenterPanel(CmColumn mainContainer)
        {
            // create center panel
            var centerPanel = new CmColumn(this);
            centerPanel.SetStyle(GetTheme().MenuPanel);

            // create 3 buttons and add them to center panel
            centerPanel.AddContent(CreateButton("Start game", "Start"));
            centerPanel.AddContent(CreateButton("Options", "Options"));
            centerPanel.AddContent(CreateButton("Exit game", "Exit"));

            // now we add center panel to main container
            mainContainer.AddContent(centerPanel);
        }

        private CmButton CreateButton(string label, string name)
        {
            // create button
            var cmButton = new CmButton(this, label, GetCmUiEventsHandler());
            cmButton.SetStyle(GetTheme().MenuButton);

            cmButton.SetName(name);
            return cmButton;
        }

        public override string GetScreenName()
        {
            // Screen name is useful for further screen changing in game/menu. You will change screens using their names
            return "MainMenu";
        }
    }

    cmButton.SetStyle(GetTheme().MenuButton);

    cmButton.SetStyle(GetTheme().MenuButton);

    var cmButton = new CmButton(this, label, GetCmUiEventsHandler());

    public abstract class MyFirstTheme: CmThemeBase
    {
        public abstract ICmControlModifiers MainContainer();
        public abstract ICmControlModifiers MenuPanel();
        public abstract ICmControlModifiers MenuButton();
    }

    public class MyFirstThemeWhite: MyFirstTheme
    {
        public override string GetThemeName()
        {
            return "MyFirstThemeWhite";
        }

        // style for main container background
        public override ICmControlModifiers MainContainer()
        {
            // each control has method GetModifiersBuilder() so you can build style and return
            var modifiers = CmColumn.GetModifiersBuilder();

            // I will explain this Column method under this code
            modifiers.Column(new CmModifierColumn(CmSelector.DefaultState)
                // set width and height to fullscreen (I could use weight() modifier) 
                .FillMaxWidth()
                .FillMaxHeight()
                // this is container called column and we want to add another panel to it and make it center 
                .VerticalArrangement(CmArrangement.CENTER)
                .HorizontalAlignment(CmAlignment.CENTER)
                // this is background color of this fullscren container. R G B A, so Blue color = 1 full blue, and alpha 0.5f
                .BackgroundColorRGBA(new Color(0, 0, 1, 0.5f))
            );
            return modifiers;
        }

        // style center menu panel
        public override ICmControlModifiers MenuPanel()
        {
            // each control has method GetModifiersBuilder() so you can build style and return
            var modifiers = CmColumn.GetModifiersBuilder();

            // I will explain this Column method under this code
            modifiers.Column(new CmModifierColumn(CmSelector.DefaultState) 
                // this is center panel that will contain 3 buttons so make them center vertically when there will be added
                .VerticalArrangement(CmArrangement.CENTER)
                .BorderRadius(20.Px())
                .Width(30.Percent()) // set wodth to 30 % of available space
                .Height(50.Percent()) // set height to 50 % of available space
                .BackgroundColorRGBA(Color.white)
            );
            return modifiers;
        }

        // style for each of three buttons of our implementation
        public override ICmControlModifiers MenuButton()
        {
            // each control has method GetModifiersBuilder() so you can build style and return
            var modifiers = CmButton.GetModifiersBuilder();

            // I will explain this Button method under this code
            modifiers.Button(
                new CmModifierText(CmSelector.DefaultState)
                    // set width and height to auto
                    .WidthAuto()
                    .HeightAuto()
                    .BackgroundColorRGBA(Color.yellow)
                    .TextFontSize(20.Px())
                    .BorderWidth(1)
                    .BorderRadius(20.Px())
                    // set margin of 16 pixels around control 
                    .MarginAll(16, 16, 16, 16)

                    // this is magic I will allow animation and make animation for 400 ms
                    // you will ask what animation?. Because below we add scaling and font to bold 
                    // when mouse will hover over this button. So if we add animation then this state will be changed
                    // over time instead of instant change. It will slowly change state
                    .AnimEnable()
                    .AnimDuration(400)

                    // ok now we switch bulder to hover state. Now when we add modifiers we do it for new state 
                    // which is hover state and all modifiers will now be to button when mouse will hover
                    .____NextSelector(CmSelector.Hover)
                    // scale button when mouse is hovering
                    .Scale(x: 1.05f, y: 1.4f)
                    // set font for text when mouse is hovering
                    .TextFontStyle(CmFontStyle.bold)
                    // and 
                    .TextColorRGB(Color.red)

            );
            return modifiers;
        }
    }

.Method_2
{
    width: auto;
    height: auto;
    background-color: rgba(255,235,4,1.00);
    font-size: 20px;
    border-width: 1px;
    border-top-left-radius: 20px;
    border-top-right-radius: 20px;
    border-bottom-left-radius: 20px;
    border-bottom-right-radius: 20px;
    margin: 16px 16px 16px 16px;
    transition-property: all;
    transition-duration: 400ms;
}

.Method_2:hover
{
    scale: 1.05 1.40;
    -unity-font-style: bold;
    color: rgb(255,0,0);
}

    public class MyFirstMainMenuScreen : CmScreen<MyFirstTheme>
    {
        .....

        public override void BindUIEventsOnStart(CmUIEventsHandler eventsHandler)
        {
            eventsHandler.buttonClick = @base =>
            {
                if (@base.GetName().Equals("Start"))
                {
                    SetCurrentScreen("your screen name");
                }

                if (@base.GetName().Equals("Exit"))
                {
                    Application.Quit();
                }
            };
        }

        .....
    }

public abstract class MyExampleTheme : CmThemeBase
{
    public abstract CmButtonModifiers StyleButton(CmButton button);
}

public class MyThemeWhite : MyExampleTheme
{
    public override CmButtonModifiers StyleButton(CmButton button)
    {
        // each controls has its own set of methods to style. We will get style interface for this button
        // image have other group of function, than for example text. We use different interface for styling different controls
        // Because we don't want to style font for image - it has no sense

        // so get modifiers for styling
        var modifiers = CmButton.GetModifiersBuilder();
        // style with modifiers
        modifiers.Button(
                // change background color and textfont size for the button in default state, so not for state like mouse hover over control or disabled state. Default state is for all states for control, but if you add styles for mouse hover then it will override this styles while mouse is hovering otherwise it will use default modifiers. 
                new CmModifierText(CmSelector.DEFAULT_STATE)
                    .BackgroundColorRGBA(Color.white)
                    .TextFontSize(30.px())
            );
        }
        return modifiers;
    }
}

public class MyThemeBlack : MyExampleTheme
{
    public override CmButtonModifiers StyleButton(CmButton button)
    {
        var modifiers = CmButton.GetModifiersBuilder();
        modifiers.Button(
                new CmModifierText(CmSelector.DEFAULT_STATE)
                    .BackgroundColorRGBA(Color.black)
            );
        return modifiers;
    }
}

    // IMyExampleTheme is a base theme interface
    public class MyScreenManager : CmScreenManager<MyExampleTheme>
    {
        ...

        //This is called by the system to add themes to the list
        public override void OnAddSupportedThemes(List<MyExampleTheme> themes)
        {
            //Add all themes here for this screen manager
            themes.Add(new MyThemeWhite());
            themes.Add(new MyThemeBlack());
        }
        ...
    }

    // code for creating button with a style from your theme method StyleButton()
    public CmButton createMainButton(string buttonTitle)
    {
        // Create a simple button with buttonTitle and UI event handler from this screen to handle events in this screen
        var button = new CmButton(buttonTitle, cmUIEventsHandler: GetCmUiEventsHandler());

        //Get the current assigned theme to this screen and use your function to style this button
        //This theme could be one of your added themes: MyThemeWhite, MyThemeBlack
        button.SetStlye(GetTheme().StyleButton);
        return button;
    }

    // CmThemeDefault will be used as a base theme and this is the empty theme for filling purposes
    public class MyScreenManager : CmScreenManager<CmThemeDefault>
    {
        ...
        public override void OnAddSupportedScreens(List<CmScreen<CmThemeDefault>> supportedScreenList) {}
        public override void OnAddSupportedThemes(List<CmThemeDefault> supportedThemes) {}
        ...
    }

    // abstract base class MyExampleTheme for theming this window will be used as a base theme
    public class MyScreenManager : CmScreenManager<MyExampleTheme>
    {
        public override void OnBindUiEventsHandler(CmUIEventsHandler eventsHandler)
        {
            // handle global actions on UI like clicks and other
            eventsHandler.ButtonClick = button =>
            {
                // check globally if the user clicked the button, recognize the button by its name
                if (button.GetName().Equals("here_will_be_your_button_name_to_check_for"))
                {
                    //Here you will do some actions
                }
            };
        }

        public override void OnAddSupportedScreens(List<CmScreen<MyExampleTheme>> supportedScreens)
        {
            //Here you will add all your screens for this screen manager, and you will be able to change screen runtime
            supportedScreens.Add(new MyMainScreen(this));
        }

        public override void OnAddSupportedThemes(List<MyExampleTheme> theme)
        {
            //Add all your themes here for this screen manager
            themes.Add(new MyThemeWhite());
            themes.Add(new MyThemeBlack());
        }

        public override void OnSetMainScreen()
        {
            //You can set the main screen here at the start if you have multiple screens. by default main screen is the first Screen
            //All screens have their names as strings so you can create your screens as ENUM names and pass it here so there
            // will be no magic strings :)
            SetCurrentScreen("ScreenMain");
        }
    }

    SetCurrentTheme(new MyThemeBlack());

    public void SetCurrentTheme(THEME originalTheme, bool rebuildControlsWithNewTheme = false)

    public virtual void SetCurrentScreen(string currentScreenName, bool makeContent = true)

   // in your monobehaviour - somewhere in your player game logic
   public void UpdateUI()
   {
       if (_screensManager == null)
       {
           _screensManager = CmScreenManagerHelper.FindScreenManager();
       }

       _screensManager.SetUserData(someUserData);
   }

public virtual void OnUserDataChange(Object data)

public class PlayerInGameScreen : CmScreenPart<MyExampleTheme>{
   ...
   public override void OnUserDataChange(Object data)
   {
       if (data is PlayerData playerData)
       {
           _userName.SetText(playerData.UserName);
           _healtBar.SetProgress(playerData.Health);
       }
   }
}

    public class CmExample2ThemesScreenManager : CmScreenManager<CmExample2ThemesBase>
    {
        public override void OnBindUiEventsHandler(CmUIEventsHandler eventsHandler)
        {
            // handle global actions on UI like clicks and other
            eventsHandler.ButtonClick = @base => { };
        }

        public override void OnAddSupportedScreens(List<CmScreen<CmExample2ThemesBase>> supportedScreenList)
        {
            //Add all screens here for this screen manager
            supportedScreenList.Add(new CmSimpleThemeMainScreen(this));
        }

        public override void OnAddSupportedThemes(List<CmExample2ThemesBase> themeBases)
        {
            //Add all themes here for this screen manager
            themeBases.Add(new CmExample2ThemeOne());
            themeBases.Add(new CmExample2ThemeTwo());
        }

        public override void OnSetMainScreen()
        {
            //You can set the main screen here at the start if you have multiple screens. by default main screen is the first Screen
            // added to supportedScreenList in above OnAddSupportedScreens(..) function
            SetCurrentScreen(CmSimpleThemeMainScreen.MAIN_SCREEN_NAME);
        }
    }

    // CmThemeDefault will be used as a base theme and this is the empty theme for filling purposes
    public class MyMainScreen : CmScreen<CmThemeDefault>
    {
        ...
        // needed constructor 
        public MyMainScreen(CmScreenManager<CmThemeDefault> parent = null, VisualElement root = null) 
            : base(parent, root) {}

        ...
    }

    // CmThemeDefault will be used as a base theme and this is the empty theme for filling purposes
    public class MyMainScreen : CmScreen<MyExampleTheme>
    {
        public static string MYMAIN_SCREEN_NAME = "MyMainScreen";

        // needed empty constructor 
        public MyMainScreen(CmScreenManager<MyExampleTheme> parent = null, VisualElement root = null) 
            : base(parent, root) {}

        public override void bindUIEventsOnStart(CmUIEventsHandler eventsHandler)
        {
            // handle events here
        }

        public override void OnMakeScreenContent(ScreenContentBuilder contentBuilder)
        {
            //create controls here and add them to contentList
            contentBuilder.AddContent(...create content here...);
        }

        public override string GetScreenName()
        {
            // return screen name. Screen name is useful for further screen changing in game/menu
            return MYMAIN_SCREEN_NAME;
        }
    }

    /// <summary>
    /// This is a simple main screen that extends CmScreen but you have to tell us that you will be using CmExample1ThemeBase
    /// as the base theme for this screen, so we will know that all themes extended from CmExample1ThemeBase will be compatible
    /// for styling controls
    /// </summary>
    public class CmExample1MainScreen : CmScreen<CmExample1ThemeBase>
    {
        public static string MAIN_SCREEN_NAME = "Example1MainScreen";

        /// <summary>
        /// button names (could be enums but finally should be converted to a string to set the name of control)
        /// </summary>
        private const string MainButtonName = "MyButtonName";

        public CmExample1MainScreen(CmScreenManager<CmExample1ThemeBase> parent = null, VisualElement root = null) :
            base(parent, root)
        {
        }

        public override void bindUIEventsOnStart(CmUIEventsHandler eventsHandler)
        {
            // handle clicks for all buttons on this screen
            eventsHandler.ButtonClick = button =>
            {
                //Check if the user clicked button with name "MyButtonName"
                if (button.GetName().Equals(MainButtonName))
                {
                    // handle on click for the main button
                }
            };
        }

        public override void OnMakeScreenContent(ScreenContentBuilder contentBuilder)
        {
            contentBuilder.Add(createMainPanel());
        }

        private CmColumn createMainPanel()
        {
            //Add column container and set vertical and horizontal position for all controls that will be added to it to the center
            //They will be on the screen center
            //Set background color for this column and make it fullscreen by setting Weight(1) - see modifiers section for more details
            var column = new CmColumn();
            column.Modifiers.Column(new CmModifierColumn(CmSelector.DEFAULT_STATE)
                .VerticalArrangement(CmArrangement.CENTER)
                .HorizontalAlignment(CmAlignment.CENTER)
                .BackgroundColorRGBA(new Color(0,0,1,0.5f))
                .Weight(1)
            );

            //Create button with text and name (name will be used in the event handler to recognize events from this control)
            var button = createMainButton("My main button (hello world button :)", MainButtonName);

            //Add button to column
            column.AddContent(button);

            return column;
        }

        public CmButton createMainButton(string text, string name)
        {
            //Create a simple button with text and UI event handler from this screen to handle events in this screen
            var button = new CmButton(text, cmUIEventsHandler: GetCmUiEventsHandler());

            //Set button name for further event handling
            button.SetName(name);

            // Get the theme assigned to this screen and use its function to style this button.
            // We will not call theme method but pass method address to StyleButton function
            button.SetStyle(GetTheme().StyleButton);
            return button;
        }

        public override string GetScreenName()
        {
            // return the screen name for this screen. Screen name is useful for further screen changing in-game/menu
            return MAIN_SCREEN_NAME;
        }
    }

    // CmThemeDefault will be used as a base theme and this is the empty theme for filling purposes
    public class MyMainScreen : CmScreen<CmThemeDefault>
    {
        ...
        // needed constructor 
        public MyMainScreen(CmScreenManager<CmThemeDefault> parent = null, VisualElement root = null) 
            : base(parent, root) {}

        ...
    }

    // CmThemeDefault will be used as a base theme and this is the empty theme for filling purposes
    public class CmScreenPartTopSectionExampleSP : CmScreenPart<MyExampleTheme>
    {
        public CmScreenPartTopSectionExampleSP(CmScreen<MyExampleTheme> screen) : base(screen)
        {
        }

        public override void BindUIEventsOnStart(CmUIEventsHandler eventsHandler)
        {
        }

        public override CmControlBase MakeContent()
        {
            var row = new CmRow();
            GetTheme().StyleScreenPartContentRow(row);

            row.AddContent(OptionButton("Theme1", "Theme1"));
            row.AddContent(OptionButton("Theme2", "Theme2"));
            return row;
        }

        public CmButton OptionButton(string text, string name)
        {
            var button = new CmButton(text, cmUIEventsHandler: getUIEventsHandler());
            button.SetName(name);
            // pass style function address to SetStyle to style button by it
            // GetTheme() returns current assigned theme MyThemeWhite or MyThemeBlack
            button.SetSyle(GetTheme().StyleButton);
            return button;
        }
    }

    public class MainMenuPanelSp : CmScreenPart<CmThemeTestBase>
    {

        public override void BindUIEventsOnStart(CmUIEventsHandler uiEventsHandler)
        {
            uiEventsHandler.ButtonClick = control =>
            {
                //If the control name is "MultiPlayer" then the user clicks the button "MultiPlayer"
                if (control.GetName().Equals("MultiPlayer"))
                {
                    // SetCurrentScreen() is CmScreenPart function that will change the current screen by its name
                    // ScreenTypes is an enum, so screens have enum names converted to a string
                    //Using an enum helps to reduce magic strings here and there in-app, but also you can use this enum for screen names in many places 
                    SetCurrentScreen(ScreenTypes.MAIN_MENU_MAP_SELECT.ToString());
                }

                //If the control name is "Exit" then the user clicks the button "Exit"
                if (control.GetName().Equals("Exit"))
                {
                    Application.Quit(0);
                }
            };
        }
    }

    public class PlayerInGameStatsSp : CmScreenPart<CmThemeTestBase>
    {

        public override void BindUIEventsOnStart(CmUIEventsHandler uiEventsHandler)
        {
            // handle image click or whatever
            ...
        }

        public CmImage createUserImage()
        {
            // so let's pass built-in event handler from PlayerInGameStatsSp
            var image = new CmImage(this.getUIEventsHandler());
            return image;
        }

        ...
    }

    public class PlayerInGameStatsSp : CmScreenPart<CmThemeTestBase>
    {

        public CmButton createExitButton()
        {
            var eventHandler = new CmUIEventsHandler("MyEventHandler");
            var button = new CmButton(eventHandler);
            button.setName("Exit");

            eventHandler.ButtonClick = control =>
            {
                //If the control name is "Exit" then the user clicks the button "Exit"
                if (control.GetName().Equals("Exit"))
                {
                    Application.Quit(0);
                }
            };

            //But now you will have to handle events using your event handler
            return button;
        }

        ...
    }

    public class CmUIEventsHandler{
        .....
        public Action<CmControlBase, GeometryChangedEvent> GenericOnGeometryChange = null;
        public Action<CmControlBase, PointerDownEvent> GenericPointerDown = null;
        public Action<CmControlBase, PointerUpEvent> GenericPointerUp = null;
        public Action<CmControlBase, PointerMoveEvent> GenericPointerMove = null;
        public Action<CmControlBase, PointerOutEvent> GenericPointerOut = null;
        public Action<CmControlBase> GenericMouseDown = null;
        public Action<CmControlBase, ClickEvent> GenericClick = null;
        public Action<CmControlBase> GenericMouseUp = null;
        public Action<CmControlBase> GenericMouseEnter = null;
        public Action<CmControlBase> GenericMouseLeave = null;
        public Action<CmControlBase> GenericKeyUp = null;
        public Action<CmControlBase> GenericKeyDown = null;
        public Action<CmButton> ButtonClick = null;
        public Action<CmTextField, String> TextFieldChange = null;
        public Action<CmToggle, Boolean> ToggleCheckChange = null;
        public Action<CmRadioButton, Boolean> RadioButtonCheckChange = null;
        public Action<CmFoldout, Boolean> FoldoutCheckChange = null;
        public Action<CmControlBase, float> SlidingHandleValueChange = null;
        public Action<CmDropdownField, string> DropdownFieldSelect = null;
        ....
    }

        public override void BindUIEventsOnStart(CmUIEventsHandler uiEventsHandler)
        {
            // action ButtonClick will be called by the control when someone clicks a button and you will assign 
            // lambda to that action to handle the event on the button click
            uiEventsHandler.ButtonClick = (clicked_control) =>
            {
                if (clicked_control.GetName().Equals("Exit"))
                {
                    Application.Quit(0);
                }
            };
        }
    }

        public CmModifierColumn HorizontalAlignment(CmAlignment alignment);
        public CmModifierColumn VerticalArrangement(CmArrangement arrangement);

        public CmModifierRow HorizontalArrangement(CmArrangement arrangement)
        public CmModifierRow VerticalAlignment(CmAlignment alignment)

        public CmToggleModifiers Background(CmModifierBackground modifier)
        public CmToggleModifiers Label(CmModifierText modifier)
        public CmToggleModifiers CheckMarkBackground(CmModifierBackground modifier)
        public CmToggleModifiers CheckMark(CmModifierImageAndBackground modifier)

 var cmToggle = new CmToggle(..);

 var modifiers = cmToogle.GetModifiersBuilder();

 // change CheckMarkBackground
 modifiers.CheckMarkBackground(...)

 // change checkmark
 modifiers.CheckMark(...)

 // change Label
 modifiers.Label(...)

    var modifiers = cmToogle.GetModifiersBuilder();
    modifiers.CheckMarkBackground(
        new CmModifierBackground(CmSelector.DefaultState)
                    .OverflowVisible()
    )

 var cmToggle = new CmToggle(..);
 cmToogle.GetModifiersBuilder().CheckMark(
     // create modifier for DEFAULT_STATE but we will add other states using ____NextSelector
     new CmModifierImageAndBackground(CmSelector.DEFAULT_STATE)
         .BorderWidth(0)
         .BorderRadius(60.px())
         .BorderColorRGBA(new Color32(255, 51, 4, 255))

         //Now add modifiers for HOVER state
         .____NextSelector(CmSelector.HOVER)
         .Scale(1.2f)

         //Now add modifiers for the DISABLED state
         .____NextSelector(CmSelector.DISABLED)
         .BackgroundColorRGBA(Color.white)

         //Now add modifiers for the CHECKED state
         .____NextSelector(CmSelector.CHECKED)
         .BackgroundColorRGBA(Color.gray)
 );

new CmModifierBackground(CmSelector.DEFAULT_STATE)
.Width(40.Px()) // pixels

new CmModifierBackground(CmSelector.DEFAULT_STATE)
.Width(40) // pixels

new CmModifierBackground(CmSelector.DEFAULT_STATE)
.Width(10.Percent()) // percentage of available area

 cmToogle.Modifiers.CheckMark(
     // create modifier for DEFAULT_STATE but we will add other state using ____NextSelector
     new CmModifierImageAndBackground(CmSelector.DEFAULT_STATE)
         .TextFontSize(12.em())
 );

 var cmToggle = new CmToggle(..);

 //Create a custom selector for the label with the name: "your_custom_selector_name_enter_here"
 cmToogle.GetModifiersBuilder().Label(
     new CmModifierText(CmSelector.DEFAULT_STATE, "your_custom_selector_name_enter_here")
         .Hide()
 );

 //------------------------ 
 // then runtime somewhere in code you can use:

 //Add your selector to hide the label
 cmToggle.SetCustomSelector("your_custom_selector_name_enter_here");

 // to remove your selector to show the label
 cmToggle.RemoveCustomSelector("your_custom_selector_name_enter_here");

    /// <summary>
    /// Use this to build a selecor for control. For example when you want to change style when the mouse is over a control.
    /// This is a pseudo Class Type of visual element eg. selector.
    /// </summary>
    public enum CmSelector
    {
        /// default style
        DEFAULT_STATE,

        /// The cursor is positioned over the element.
        HOVER,

        /// A user interacts with the element. Button click for example.
        ACTIVE,

        /// A user stops to interact with the element.
        INACTIVE,

        /// The element has focus.
        FOCUS,

        /// USS doesn’t support this pseudo-state. Use :checked instead.
        SELECTED,

        /// The element is in a disabled state.
        DISABLED,

        /// The element is in an enabled state.
        ENABLED,

        /// The element is a Toggle or RadioButton element and it’s selected.
        CHECKED,

        /// The element is the highest-level element in the visual tree
        ROOT
    }

 var cmToggle = new CmToggle(..);
 cmToogle.GetModifiersBuilder().CheckMark(
     // create modifier for DEFAULT_STATE but we will add other states using ____NextSelector
     new CmModifierImageAndBackground(CmSelector.DEFAULT_STATE)
         .BorderWidth(0)
         .BorderRadius(60.px())
         .BorderColorRGBA(new Color32(255, 51, 4, 255))

         //Now add modifiers for HOVER state
         .____NextSelector(CmSelector.HOVER)
         .Scale(1.2f)

         //Now add modifiers for the DISABLED state
         .____NextSelector(CmSelector.DISABLED)
         .BackgroundColorRGBA(Color.white)
 );

    // left, top, right, bottom
    public T LeftInitial();
    public T RightInitial();
    public T TopInitial();
    public T BottomInitial();
    public T Left(int left);
    public T Left(UssPropertyVal left);
    public T Right(int right);
    public T Right(UssPropertyVal right);
    public T Top(int top);
    public T Top(UssPropertyVal top);
    public T Bottom(int bottom);
    public T Bottom(UssPropertyVal bottom);

    // size related
    public T Width(int width);
    public T Width(UssPropertyVal width);
    public T FillMaxWidth(float factor);
    public T WidthWrapContent();
    public T WidthAuto();
    public T FillParentWidth();

    public T Height(int height);
    public T Height(UssPropertyVal height);
    public T FillMaxHeight(float factor);
    public T HeightWrapContent();
    public T HeightAuto();
    public T FillParentHeight();
    public T Weight(float weight = 1.0f);

    // animation
    public T AnimEnable(bool enable = true);
    public T AnimDuration(int durationMillisecond = 1);
    public T AnimDelay(int delayMillisecond = 1);
    public T AnimEasing(CmAnimationEasing cmAnimationEasing);
    public T AnimEasingInitial();
    public T AnimDelayInitial();
    public T AnimDurationInitial();
    public T AnimEnableInitial();

    // pading
    public T PaddingAll(UssPropertyVal left, UssPropertyVal top, UssPropertyVal right, UssPropertyVal bottom);
    public T PaddingLeft(UssPropertyVal left);
    public T PaddingRight(UssPropertyVal right);
    public T PaddingTop(UssPropertyVal top);
    public T PaddingBottom(UssPropertyVal bottom);
    public T PaddingHorizVert(UssPropertyVal horizontalPadding, UssPropertyVal verticalPadding);
    public T PaddingAll(int left, int top, int right, int bottom);
    public T PaddingLeft(int left);
    public T PaddingRight(int right);
    public T PaddingTop(int top);
    public T PaddingBottom(int bottom);
    public T PaddingHorizVert(int horizontalPadding, int verticalPadding);

    // visibility
    public T Opacity(float opacity = 1.0f);
    public T Invisible();
    public T Hide();
    public T Show();

    // position related to parent
    public T PositionRelativeToParent();
    public T PositionAbsoluteInFirstRelativeParent();

    public T FreeFloatingWorldSpace();
    public T AttachToParent();
    public T DetachFromAllParents();

    // scale
    public T Scale(int scale);
    public T Scale(UssPropertyVal scale);
    public T Scale(float scale);
    public T Scale(int x, int y);
    public T Scale(UssPropertyVal x, UssPropertyVal y);
    public T Scale(float x, float y);

    // transform rotate/move/translate
    public T Rotate(UssPropertyRotationVal angle);
    public T Move(UssPropertyVal tx, UssPropertyVal ty);
    public T Translate(UssPropertyVal tx, UssPropertyVal ty);

    // orygin
    public T OriginCornerTopLeft();
    public T OriginCornerTopRight();
    public T OriginCornerBottomLeft();
    public T OriginCornerBottomRight();
    public T OriginAtCenterPoint();
    public T OriginEdgeLeftCenter();
    public T OriginEdgeTopCenter();
    public T OriginEdgeRightCenter();
    public T OriginEdgeBottomCenter();
    public T OriginPoint(UssPropertyVal tx, UssPropertyVal ty);

    // overflow (it means clip/no clip children controls to not draw over parent borders)
    public T OverflowVisible();
    public T OverflowHidden();
    public T OverflowClip();
    public T OverflowScroll();
    public T AlignSelf(CmAlignment alignment);
    public T AlignSelfInitial();

    // min max width/height
    public T MinWidthInitial();
    public T MinHeightInitial();
    public T MaxWidthInitial();
    public T MaxHeightInitial();
    public T MinWidth(int minWidth);
    public T MinWidth(UssPropertyVal minWidth);
    public T MinHeight(int minHeight);
    public T MinHeight(UssPropertyVal minHeight);
    public T MaxWidth(int maxWidth);
    public T MaxWidth(UssPropertyVal maxWidth);
    public T MaxHeight(int maxHeight);
    public T MaxHeight(UssPropertyVal maxHeight);

    // flex modifiers for more advanced usage similar to USS
    public T FlexShrinkInitial();
    public T FlexGrowInitial();
    public T FlexBasisInitial();
    public T FlexShrink(int shrink);
    public T FlexShrink(UssPropertyVal shrink);
    public T FlexDontShrink();
    public T FlexAllowShrink();
    public T FlexGrow(int grow);
    public T FlexGrow(UssPropertyVal grow);
    public T FlexDontGrow();
    public T FlexAllowGrow();
    public T FlexBasis(int basis);
    public T FlexBasis(UssPropertyVal basis);
    public T FlexBasisAuto();

    // border color
    public T BorderColorRGB(Color color);
    public T BorderColorRGBA(Color color);
    public T BorderColorHex(string hexColor);
    public T BorderColorRGBA(Color32 color);
    public T BorderColorRGB(Color32 color);
    public T BorderColorTransparent();


    // border radius
    public T BorderRadius(int radius);
    public T BorderRadiusLeftTop(int radius);
    public T BorderRadiusLeftBottom(int radius);
    public T BorderRadiusRightTop(int radius);
    public T BorderRadiusRightBottom(int radius);
    public T BorderRadiusInitial();
    public T BorderRadiusLeftTopInitial();
    public T BorderRadiusLeftBottomInitial();
    public T BorderRadiusRightTopInitial();
    public T BorderRadiusRightBottomInitial();

    public T BorderRadius(UssPropertyVal radius);
    public T BorderRadiusLeftTop(UssPropertyVal radius);
    public T BorderRadiusLeftBottom(UssPropertyVal radius);
    public T BorderRadiusRightTop(UssPropertyVal radius);
    public T BorderRadiusRightBottom(UssPropertyVal radius);

    // border width
    public T BorderWidth(int borderWidth);
    public T BorderWidthLeft(int borderWidth);
    public T BorderWidthBottom(int borderWidth);
    public T BorderWidthTop(int borderWidth);
    public T BorderWidthRight(int borderWidth);
    public T BorderWidth(UssPropertyVal borderWidth);
    public T BorderWidthLeft(UssPropertyVal borderWidth);
    public T BorderWidthBottom(UssPropertyVal borderWidth);
    public T BorderWidthTop(UssPropertyVal borderWidth);
    public T BorderWidthRight(UssPropertyVal borderWidth);

    // margin
    public T Margin(UssPropertyVal margin);
    public T MarginAll(UssPropertyVal left, UssPropertyVal top, UssPropertyVal right, UssPropertyVal bottom);
    public T MarginLeft(UssPropertyVal left);
    public T MarginRight(UssPropertyVal right);
    public T MarginTop(UssPropertyVal top);
    public T MarginBottom(UssPropertyVal bottom);
    public T MarginHorizVert(UssPropertyVal horizontalMargin, UssPropertyVal verticalMargin);
    public T Margin(int margin);
    public T MarginAll(int left, int top, int right, int bottom);
    public T MarginLeft(int left);
    public T MarginRight(int right);
    public T MarginTop(int top);
    public T MarginBottom(int bottom);
    public T MarginHorizVert(int horizontalMargin, int verticalMargin);

    public T MarginLeftInitial();
    public T MarginRightInitial();
    public T MarginTopInitial();
    public T MarginBottomInitial();

    // background color
    public T BackgroundColorRGB(Color color);
    public T BackgroundColorRGBA(Color color);
    public T BackgroundColorHex(string hexColor);
    public T BackgroundColorRGBA(Color32 color);
    public T BackgroundColorRGB(Color32 color);
    public T BackgroundColorTransparent();

    // background image
    public T BackgroundImageRes(string path);
    public T BackgroundImageUrl(string path);
    public T BackgroundIcon(CmUnityIcons cmUnityIcons);
    public T BackgroundImageInitial();

    // background image tint color
    public T BackgroundImageTintRGB(Color color);
    public T BackgroundImageTintRGBA(Color color);
    public T BackgroundImageTintHex(string colorHex);
    public T BackgroundImageTintRGBA(Color32 color);
    public T BackgroundImageTintRGB(Color32 color);
    public T BackgroundImageTintTransparent();


    // background image slice (for proper image scalling like 9 patch)
    public T BackgroundImageSliceLeft(int sliceValue);
    public T BackgroundImageSliceRight(int sliceValue);
    public T BackgroundImageSliceTop(int sliceValue);
    public T BackgroundImageSliceBottom(int sliceValue);
    public T BackgroundImageSliceScale(int sliceScale);
    public T BackgroundImageSliceScale(UssPropertyVal sliceScale);
    public T BackgroundImageSliceLeftInitial();
    public T BackgroundImageSliceRightInitial();
    public T BackgroundImageSliceTopInitial();
    public T BackgroundImageSliceBottomInitial();
    public T BackgroundImageSliceScaleInitial();

    // background scale
    public T BackgroundScaleMode(CmBackgroundScaleMode cmBackgroundScaleMode);
    public T BackgroundScaleModeInitial();

    // background repeat
    public T BackgroundRepeat(CmBackgroundRepeat cmBackgroundRepeat);

    // background position
    public T BackgroundPositionX(CmBackgroundPosition positionX);
    public T BackgroundPositionY(CmBackgroundPosition positionY);
    public T BackgroundPositionX(int positionX);
    public T BackgroundPositionY(int positionY);
    public T BackgroundPositionX(UssPropertyVal positionX);
    public T BackgroundPositionY(UssPropertyVal positionY);

    // background size
    public T BackgroundSize(UssPropertyVal bgSize);
    public T BackgroundSizeContainInArea();
    public T BackgroundSizeCoverArea();