private void CreateRecursive(Core.Object obj, HttpResponse response)
        {
            if (_createdControls.Contains(obj))
            {
                return;
            }
            _createdControls.Add(obj);
            var st = obj.GetState();

            obj.Render(st);

            var props = st.GetAllProperies();

            foreach (var p in props)
            {
                if (p.Value is qxDotNet.Core.Object)
                {
                    CreateRecursive(p.Value as qxDotNet.Core.Object, response);
                }
            }

            var children = obj.GetChildren(false);

            if (children != null)
            {
                foreach (var item in children)
                {
                    if (item != null)
                    {
                        CreateRecursive((item as Core.Object), response);
                    }
                }
            }

            if (!obj.DisallowCreation && (_isRefreshRequest || !obj.IsCreated))
            {
                if (!_registeredControls.ContainsKey(obj.clientId))
                {
                    _registeredControls.Add(obj.clientId, new WeakReference(obj));
                }
                var typeName = obj.GetTypeName();
                if (typeName != null)
                {
                    response.Write(string.Format("{0} = new {1}({2});\n", obj.GetReference(), typeName, obj.GetCustomConstructor()));
                }
            }
        }
        private void RenderRecursive(Core.Object obj, HttpResponse response)
        {
            if (obj.GetTypeName() == null)
            {
                obj.CustomPreRender(response, _isRefreshRequest);
                obj.CustomPostRender(response, _isRefreshRequest);
                return;
            }
            var stateBag = obj.GetState();
            Dictionary <string, object>  properties;
            List <Core.Object.EventInfo> events;
            var st = obj.GetState();

            if (_isRefreshRequest || !obj.IsCreated)
            {
                properties = st.GetAllProperies();
                events     = st.GetAllEvents();
            }
            else
            {
                properties = st.GetNewProperties();
                events     = st.GetNewEvents();
            }

            obj.CustomPreRender(response, _isRefreshRequest);

            if (!_isRefreshRequest)
            {
                var removed = obj.GetRemovedChildren();
                if (removed != null)
                {
                    foreach (Core.Object item in removed)
                    {
                        if (item.GetTypeName() != null)
                        {
                            response.Write(obj.GetRemoveObjectReference(item));
                        }
                    }
                }
            }

            var children    = obj.GetChildren(!_isRefreshRequest);
            var newChildren = children;

            // font hack
            var fontList = new List <qxDotNet.Font>();

            foreach (var p in st.GetAllProperies())
            {
                if (p.Value is qxDotNet.Font)
                {
                    (p.Value as qxDotNet.Font).fontRenderPhase = false;
                    RenderRecursive(p.Value as qxDotNet.Core.Object, response);
                    (p.Value as qxDotNet.Font).fontRenderPhase = true;
                    fontList.Add(p.Value as qxDotNet.Font);
                }
            }

            children = obj.GetChildren(false);


            foreach (var p in st.GetAllProperies())
            {
                if (p.Value is qxDotNet.Core.Object)
                {
                    RenderRecursive(p.Value as qxDotNet.Core.Object, response);
                    _renderedControls.Add(p.Value as qxDotNet.Core.Object);
                }
            }

            if (children != null)
            {
                foreach (var item in children)
                {
                    if (item != null)
                    {
                        if (!_renderedControls.Contains(item as Core.Object))
                        {
                            RenderRecursive((item as Core.Object), response);
                        }
                    }
                }
            }

            if (newChildren != null)
            {
                foreach (Core.Object item in newChildren)
                {
                    if (item != null)
                    {
                        if (!item.DisallowCreation && item.GetTypeName() != null)
                        {
                            response.Write(obj.GetAddObjectReference(item));
                        }
                    }
                }
            }

            if (obj is qxDotNet.Font)
            {
                //font hack
                foreach (var prop in properties)
                {
                    var fontObj = obj as qxDotNet.Font;
                    if (prop.Key == "size")
                    {
                        if (!fontObj.fontRenderPhase)
                        {
                            continue;
                        }
                    }
                    else
                    {
                        if (fontObj.fontRenderPhase)
                        {
                            continue;
                        }
                    }
                    response.Write(obj.GetSetPropertyValueExpression(prop.Key, prop.Value));
                }
            }
            else
            {
                foreach (var prop in properties)
                {
                    response.Write(obj.GetSetPropertyValueExpression(prop.Key, prop.Value));
                }
            }


            // font hack
            foreach (var item in fontList)
            {
                RenderRecursive(item as qxDotNet.Core.Object, response);
            }

            foreach (var ev in events)
            {
                if (!_isRefreshRequest && ev.IsEventSent)
                {
                    continue;
                }
                response.Write(obj.GetReference() + ".addListener(\"" + ev.name + "\", function(e) {");
                if (!string.IsNullOrEmpty(ev.CustomEventCondition))
                {
                    response.Write("if (" + ev.CustomEventCondition + ") {\n");
                }
                if (ev.modifiedProperies.Count == 0)
                {
                    response.Write("App.ev(" + obj.clientId + ", \"" + ev.name + "\", null);\n");
                }
                else
                {
                    var props = "";
                    foreach (var item in ev.modifiedProperies)
                    {
                        if (ev.referencedProperies.Contains(item))
                        {
                            props += ".pr(\"" + item + "\",";
                            props += "\"" + obj.GetGetPropertyAccessor(item, true) + "\"";
                            props += ")";
                        }
                        else
                        {
                            props += ".pr(\"" + item + "\",";
                            props += "\"" + obj.GetGetPropertyAccessor(item, false) + "\"";
                            props += ")";
                        }
                    }
                    response.Write("App.ev(" + obj.clientId + ", \"" + ev.name + "\")" + props + ";");
                }
                if (ev.callServer)
                {
                    response.Write(ev.CustomCallServerExpression);
                }
                if (!string.IsNullOrEmpty(ev.CustomEventCondition))
                {
                    response.Write("}\n");
                }
                response.Write("});\n");
                ev.IsEventSent = true;
            }

            obj.CustomPostRender(response, _isRefreshRequest);

            if (!(obj is qxDotNet.Font) || (obj as qxDotNet.Font).fontRenderPhase)
            {
                obj.Commit();
            }
        }