#include "wxsheaders.h"
#include "widget.h"

#include "properties/wxsstyleproperty.h"
#include "properties/wxscolourproperty.h"
#include "properties/wxsfontproperty.h"
#include "resources/wxswindowres.h"
#include "wxswidgetfactory.h"
#include "wxsresource.h"
#include "wxswindoweditor.h"
#include "wxswidgetevents.h"
#include <wx/tokenzr.h>
#include <wx/list.h>

#define COLOUR_ENTRY(Name) { _T(#Name), Name },

/** All system colours */
static struct { wxChar* Name; wxUint32 Value; } wxsSystemColours[] =
{
    COLOUR_ENTRY(wxSYS_COLOUR_SCROLLBAR)
    COLOUR_ENTRY(wxSYS_COLOUR_BACKGROUND)
    COLOUR_ENTRY(wxSYS_COLOUR_DESKTOP)
    COLOUR_ENTRY(wxSYS_COLOUR_ACTIVECAPTION)
    COLOUR_ENTRY(wxSYS_COLOUR_INACTIVECAPTION)
    COLOUR_ENTRY(wxSYS_COLOUR_MENU)
    COLOUR_ENTRY(wxSYS_COLOUR_WINDOW)
    COLOUR_ENTRY(wxSYS_COLOUR_WINDOWFRAME)
    COLOUR_ENTRY(wxSYS_COLOUR_MENUTEXT)
    COLOUR_ENTRY(wxSYS_COLOUR_WINDOWTEXT)
    COLOUR_ENTRY(wxSYS_COLOUR_CAPTIONTEXT)
    COLOUR_ENTRY(wxSYS_COLOUR_ACTIVEBORDER)
    COLOUR_ENTRY(wxSYS_COLOUR_INACTIVEBORDER)
    COLOUR_ENTRY(wxSYS_COLOUR_APPWORKSPACE)
    COLOUR_ENTRY(wxSYS_COLOUR_HIGHLIGHT)
    COLOUR_ENTRY(wxSYS_COLOUR_HIGHLIGHTTEXT)
    COLOUR_ENTRY(wxSYS_COLOUR_BTNFACE)
    COLOUR_ENTRY(wxSYS_COLOUR_3DFACE)
    COLOUR_ENTRY(wxSYS_COLOUR_BTNSHADOW)
    COLOUR_ENTRY(wxSYS_COLOUR_3DSHADOW)
    COLOUR_ENTRY(wxSYS_COLOUR_GRAYTEXT)
    COLOUR_ENTRY(wxSYS_COLOUR_BTNTEXT)
    COLOUR_ENTRY(wxSYS_COLOUR_INACTIVECAPTIONTEXT)
    COLOUR_ENTRY(wxSYS_COLOUR_BTNHIGHLIGHT)
    COLOUR_ENTRY(wxSYS_COLOUR_BTNHILIGHT)
    COLOUR_ENTRY(wxSYS_COLOUR_3DHIGHLIGHT)
    COLOUR_ENTRY(wxSYS_COLOUR_3DHILIGHT)
    COLOUR_ENTRY(wxSYS_COLOUR_3DDKSHADOW)
    COLOUR_ENTRY(wxSYS_COLOUR_3DLIGHT)
    COLOUR_ENTRY(wxSYS_COLOUR_INFOTEXT)
    COLOUR_ENTRY(wxSYS_COLOUR_INFOBK)
    COLOUR_ENTRY(wxSYS_COLOUR_LISTBOX)
    COLOUR_ENTRY(wxSYS_COLOUR_HOTLIGHT)
    COLOUR_ENTRY(wxSYS_COLOUR_GRADIENTACTIVECAPTION)
    COLOUR_ENTRY(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)
    COLOUR_ENTRY(wxSYS_COLOUR_MENUHILIGHT)
    COLOUR_ENTRY(wxSYS_COLOUR_MENUBAR)
    { NULL, 0 }
};

/** Number of items in system colours array */
static const int wxsSystemColoursCount = sizeof(wxsSystemColours) / sizeof(wxsSystemColours[0]);

wxsWidget::wxsWidget(wxsWidgetManager* Man,wxsWindowRes* Res,BasePropertiesType pType):
    PropertiesObject(this),
    Manager(Man),
    Preview(NULL),
    Resource(Res),
    Properties(NULL),
    Parent(NULL),
    MaxChildren(0),
    XmlElement(NULL),
    ContainerType(NoContainer),
    Updating(false),
    PropertiesCreated(false),
    BPType(pType),
    AssignedToTree(false),
    Events(NULL)
{
}

wxsWidget::wxsWidget(wxsWidgetManager* Man, wxsWindowRes* Res, bool ISwxWindow, int MaxChild,BasePropertiesType pType):
    PropertiesObject(this),
    Manager(Man),
    Preview(NULL),
    Resource(Res),
    Properties(NULL),
    Parent(NULL),
    MaxChildren(MaxChild),
    XmlElement(NULL),
    ContainerType(ISwxWindow ? ContainerWindow : ContainerSizer ),
    Updating(false),
    PropertiesCreated(false),
    BPType(pType),
    AssignedToTree(false),
    Events(NULL)
{
}

wxsWidget::~wxsWidget()
{
	assert ( Preview == NULL );
	assert ( Properties == NULL );

    while ( GetChildCount() )
    {
        wxsKILL(GetChild(GetChildCount()-1));
    }

    if ( Events )
    {
    	delete Events;
    	Events = NULL;
    }
}

void wxsWidget::AddDefaultProperties(BasePropertiesType pType)
{
    // Adding standard items

    if ( pType & bptVariable )
    {
        PropertiesObject.AddProperty(_("Var Name:"),BaseParams.VarName);
        PropertiesObject.AddProperty(_("Is Member:"),BaseParams.IsMember);
    }

    if ( pType & bptId )
    {
        PropertiesObject.AddProperty(_("Id:"),BaseParams.IdName);
    }

    if ( pType & bptPosition )
    {
        PropertiesObject.Add2IProperty(_("Position:"),BaseParams.PosX,BaseParams.PosY);
        PropertiesObject.AddProperty(_(" Default:"),BaseParams.DefaultPosition);
    }

    if ( pType & bptSize )
    {
        PropertiesObject.Add2IProperty(_("Size:"),BaseParams.SizeX,BaseParams.SizeY);
        PropertiesObject.AddProperty(_(" Default:"),BaseParams.DefaultSize);
    }

    if ( pType & bptEnabled )
    {
    	PropertiesObject.AddProperty(_("Enabled:"),BaseParams.Enabled);
    }

    if ( pType & bptFocused )
    {
    	PropertiesObject.AddProperty(_("Focused:"),BaseParams.Focused);
    }

    if ( pType & bptHidden )
    {
    	PropertiesObject.AddProperty(_("Hidden:"),BaseParams.Hidden);
    }

    if ( pType & bptColours )
    {
    	PropertiesObject.AddProperty(_("Foreground colour:"),
            new wxsColourProperty(&PropertiesObject,BaseParams.FgType,BaseParams.Fg) );
    	PropertiesObject.AddProperty(_("Background colour:"),
            new wxsColourProperty(&PropertiesObject,BaseParams.BgType,BaseParams.Bg) );
    }

    if ( pType & bptFont )
    {
    	PropertiesObject.AddProperty(_("Font:"),
            new wxsFontProperty(&PropertiesObject,BaseParams.UseFont,BaseParams.Font) );
    }

    if ( pType & bptToolTip )
    {
    	PropertiesObject.AddProperty(_("Tool tip:"),BaseParams.ToolTip);
    }

    // Adding style property

    if ( pType & bptStyle )
    {
        if ( GetInfo().Styles != NULL )
        {
            PropertiesObject.AddProperty(
                _T("Style:"),
                new wxsStyleProperty(
                    &PropertiesObject,
                    BaseParams.Style,
                    GetInfo().Styles),
                -1);
        }
    }

}

wxWindow* wxsWidget::CreatePreview(wxWindow* Parent,wxsWindowEditor* Editor)
{
    if ( Preview ) KillPreview();

    /* Creating widget */
    Preview = MyCreatePreview(Parent);
    if ( !Preview ) return NULL;

    /* Creating preview of child widgets */
    int Cnt = IsContainer() ? GetChildCount() : 0;
    for ( int i=0; i<Cnt; i++ )
    {
        GetChild(i)->CreatePreview(Preview,Editor);
    }

    MyFinalUpdatePreview(Preview);

    return Preview;
}

bool wxsWidget::PropertiesUpdated(bool Validate,bool Correct)
{
    if ( Updating ) return true;
    bool Result = true;
    Updating = true;
    if ( GetEditor() )
    {
    	GetEditor()->BuildPreview();
    }
    if ( Validate )
    {
    	Result = GetResource()->CheckBaseProperties(Correct,this);
    }
    GetResource()->NotifyChange();
    Updating = false;
    return Result;
}

void wxsWidget::KillPreview()
{
    /* Killing this one */
    if ( Preview != NULL )
    {
        delete Preview;
        PreviewDestroyed();
    }
}

void wxsWidget::PreviewApplyDefaults(wxWindow* Wnd)
{
	BasePropertiesType pType = GetBPType();
	if ( pType & bptEnabled && !BaseParams.Enabled )
	{
		Wnd->Disable();
	}

	if ( pType & bptFocused && BaseParams.Focused )
	{
		Wnd->SetFocus();
	}

	if ( pType & bptHidden && BaseParams.Hidden )
	{
		Wnd->Hide();
	}

	if ( pType & bptColours )
	{
		if ( BaseParams.FgType != wxsNO_COLOUR )
		{
			if ( BaseParams.FgType == wxsCUSTOM_COLOUR )
			{
				Wnd->SetForegroundColour(BaseParams.Fg);
			}
			else
			{
				Wnd->SetForegroundColour(wxSystemSettings::GetColour((wxSystemColour)BaseParams.FgType));
			}
		}

		if ( BaseParams.BgType != wxsNO_COLOUR )
		{
			if ( BaseParams.BgType == wxsCUSTOM_COLOUR )
			{
				Wnd->SetBackgroundColour(BaseParams.Bg);
			}
			else
			{
				Wnd->SetBackgroundColour(wxSystemSettings::GetColour((wxSystemColour)BaseParams.BgType));
			}
		}
	}

    if ( pType & bptToolTip && BaseParams.ToolTip )
    {
    	Wnd->SetToolTip(BaseParams.ToolTip);
    }

    if ( pType & bptFont && BaseParams.UseFont )
    {
    	Wnd->SetFont(BaseParams.Font);
    }

}

void wxsWidget::XmlAssignElement(TiXmlElement* Elem)
{
    XmlElement = Elem;
}

bool wxsWidget::XmlLoadDefaultsT(BasePropertiesType pType)
{
    assert ( XmlElem() != NULL );
    // Loading event handler enteries
    GetEvents()->XmlLoadFunctions(XmlElem());

    /* Processing position */
    if ( pType & bptPosition )
    {
        BaseParams.DefaultPosition = !XmlGetIntPair(_T("pos"),BaseParams.PosX,BaseParams.PosY);
    }

    /* Processing size */
    if ( pType & bptSize )
    {
        BaseParams.DefaultSize = !XmlGetIntPair(_T("size"),BaseParams.SizeX,BaseParams.SizeY);
    }

    /* Processing id */
    if ( pType & bptId )
    {
        const char* IdName = XmlElem()->Attribute("name");
        BaseParams.IdName = IdName ? wxString ( IdName, wxConvLocal ) : _T("");
    }

    /* Processing variable name and locality */
    if ( pType & bptVariable )
    {
        const char* VarName = XmlElem()->Attribute("variable");
        BaseParams.VarName = VarName ? wxString ( VarName, wxConvUTF8 ) : _T("");
        const char* IsMember = XmlElem()->Attribute("member");
        BaseParams.IsMember = IsMember ? ( strcasecmp(IsMember,"no") != 0 ) : true;
    }

    /* Processing style */
    if ( pType & bptStyle )
    {
        wxString StyleStr = XmlGetVariable(_T("style"));
        wxsStyle* Styles = GetInfo().Styles;
        BaseParams.Style = 0;
        if ( Styles )
        {
            for ( ; Styles->Name != _T(""); Styles++ )
            {
                int Pos = StyleStr.Find(Styles->Name);
                int Len = (int)Styles->Name.Length();
                if ( Pos < 0 ) continue;

                // One character after style in StyleStr should be checked - it
                // must be '|'. Same for character before.

                if ( ( Pos + Len >= (int)StyleStr.Len() || StyleStr.GetChar(Pos+Len) == _T('|') ) &&
                     ( Pos == 0 || StyleStr.GetChar(Pos-1) == _T('|') ) )
                {
                    BaseParams.Style |= Styles->Value;
                }
            }
        }
    }

    if ( pType & bptEnabled )
    {
    	BaseParams.Enabled = XmlGetInteger(_T("enabled"),1) != 0;
    }

    if ( pType & bptFocused )
    {
    	BaseParams.Focused = XmlGetInteger(_T("focused"),0) != 0;
    }

    if ( pType & bptHidden )
    {
    	BaseParams.Hidden = XmlGetInteger(_T("hiddedn"),0) != 0;
    }

    if ( pType & bptColours )
    {
    	wxString Colour = XmlGetVariable(_T("fg"));
    	Colour.Trim(true).Trim(false);
        BaseParams.FgType = wxsNO_COLOUR;
    	if ( !Colour.empty() )
    	{
    		if ( Colour[0] == _T('#') )
    		{
    			// Got web colour
    			long Value = 0;
    			if ( Colour.Mid(1).ToLong(&Value,0x10) )
    			{
    				BaseParams.FgType = wxsCUSTOM_COLOUR;
    				BaseParams.Fg = wxColour(
                        ( Value >> 16 ) & 0xFF,
                        ( Value >> 8 ) & 0xFF,
                        Value & 0xFF );
    			}
    		}
    		else
    		{
    			for ( int i=0; i<wxsSystemColoursCount; i++ )
    			{
    				if ( Colour == wxsSystemColours[i].Name )
    				{
    					BaseParams.FgType = wxsSystemColours[i].Value;
    					BaseParams.Fg = wxSystemSettings::GetColour((wxSystemColour)BaseParams.FgType);
    					break;
    				}
    			}
    		}
    	}

    	Colour = XmlGetVariable(_T("bg"));
    	Colour.Trim(true).Trim(false);
        BaseParams.BgType = wxsNO_COLOUR;
    	if ( !Colour.empty() )
    	{
    		if ( Colour[0] == _T('#') )
    		{
    			// Got web colour
    			long Value = 0;
    			if ( Colour.Mid(1).ToLong(&Value,0x10) )
    			{
    				BaseParams.BgType = wxsCUSTOM_COLOUR;
    				BaseParams.Bg = wxColour(
                        ( Value >> 16 ) & 0xFF,
                        ( Value >> 8 ) & 0xFF,
                        Value & 0xFF );
    			}
    		}
    		else
    		{
    			for ( int i=0; i<wxsSystemColoursCount; i++ )
    			{
    				if ( Colour == wxsSystemColours[i].Name )
    				{
    					BaseParams.BgType = wxsSystemColours[i].Value;
    					BaseParams.Bg = wxSystemSettings::GetColour((wxSystemColour)BaseParams.BgType);
    					break;
    				}
    			}
    		}
    	}
    }

    if ( pType & bptFont )
    {
    	TiXmlElement* Store = XmlElem();
    	TiXmlElement* Font = Store->FirstChildElement("font");
    	if ( Font != NULL )
    	{
    		XmlAssignElement(Font);

    		// Loading font stuff

    		int Size = XmlGetInteger(_T("size"),wxDEFAULT);

    		wxString Str = XmlGetVariable(_T("style"));
    		int Style = wxFONTSTYLE_NORMAL;
    		if ( Str == _T("italic") ) Style = wxFONTSTYLE_ITALIC;
    		else if ( Str == _T("slant") ) Style = wxFONTSTYLE_SLANT ;

    		Str = XmlGetVariable(_T("weight"));
    		int Weight = wxNORMAL;
    		if ( Str == _T("bold") ) Weight = wxBOLD;
    		else if ( Str == _T("light") ) Weight = wxLIGHT;

    		bool Underlined = XmlGetInteger(_T("underlined"),0) != 0;

    		int Family = wxDEFAULT;
            Str = XmlGetVariable(_T("family"));
            if (Str == _T("decorative")) Family = wxDECORATIVE;
            else if (Str == _T("roman")) Family = wxROMAN;
            else if (Str == _T("script")) Family = wxSCRIPT;
            else if (Str == _T("swiss")) Family = wxSWISS;
            else if (Str == _T("modern")) Family = wxMODERN;
            else if (Str == _T("teletype")) Family = wxTELETYPE;

            wxString Face = XmlGetVariable(_T("face"));

    		BaseParams.UseFont = true;
    		BaseParams.Font = wxFont(Size,Family,Style,Weight,Underlined,Face);
    	}
    	else
    	{
    		BaseParams.UseFont = false;
    		BaseParams.Font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
    	}
    	XmlAssignElement(Store);
    }

    if ( IsContainer() )
    {
        if ( !XmlLoadChildren() ) return false;
    }

    return true;
}

bool wxsWidget::XmlSaveDefaultsT(BasePropertiesType pType)
{
    assert ( XmlElem() != NULL );
    if ( GetResource()->GetEditMode() != wxsResFile )
    {
        GetEvents()->XmlSaveFunctions(XmlElem());
    }

    if ( pType & bptPosition )
    {
        if ( !BaseParams.DefaultPosition )
        {
            XmlSetIntPair(_T("pos"),BaseParams.PosX,BaseParams.PosY);
        }
    }

    if ( pType & bptSize )
    {
        if ( !BaseParams.DefaultSize )
        {
            XmlSetIntPair(_T("size"),BaseParams.SizeX,BaseParams.SizeY);
        }
    }

    if ( pType & bptId )
    {
        XmlElem()->SetAttribute("name",BaseParams.IdName.mb_str());
    }

    if ( pType & bptVariable )
    {
        XmlElem()->SetAttribute("variable",BaseParams.VarName.mb_str());
        XmlElem()->SetAttribute("member",BaseParams.IsMember?"yes":"no");
    }

    if ( pType & bptStyle )
    {
        int StyleBits = BaseParams.Style;

        wxString StyleString;

        // Warning: This may cause some data los if styles are not
        //          configured properly

        wxsStyle* Style = GetInfo().Styles;
        if ( Style )
        {
            for ( ; Style->Name; Style++ )
            {
                if ( ( Style->Value != 0 ) && ( ( StyleBits & Style->Value ) == Style->Value ) )
                {
                    StyleString.Append('|');
                    StyleString.Append(Style->Name);
                    StyleBits &= ~Style->Value;
                }
            }
        }

        if ( StyleString.Len() != 0 )
        {
            XmlSetVariable(_T("style"),StyleString.c_str()+1);
        }
    }

    if ( pType & bptEnabled )
    {
    	if ( !BaseParams.Enabled ) XmlSetInteger(_T("enabled"),0);
    }

    if ( pType & bptFocused )
    {
    	if ( BaseParams.Focused ) XmlSetInteger(_T("focused"),1);
    }

    if ( pType & bptHidden )
    {
    	if ( BaseParams.Hidden ) XmlSetInteger(_T("hiddedn"),1);
    }

    if ( pType & bptColours )
    {
    	if ( BaseParams.FgType == wxsCUSTOM_COLOUR )
    	{
    		XmlSetVariable( _T("fg"),
                wxString::Format(_T("#%02X%02X%02X"),
                    BaseParams.Fg.Red(),
                    BaseParams.Fg.Green(),
                    BaseParams.Fg.Blue() ) );
    	}
    	else
    	{
    		for ( int i=0; i<wxsSystemColoursCount; i++ )
    		{
    			if ( BaseParams.FgType == wxsSystemColours[i].Value )
    			{
    				XmlSetVariable( _T("fg"), wxsSystemColours[i].Name );
    				break;
    			}
    		}
    	}

    	if ( BaseParams.BgType == wxsCUSTOM_COLOUR )
    	{
    		XmlSetVariable( _T("bg"),
                wxString::Format(_T("#%02X%02X%02X"),
                    BaseParams.Bg.Red(),
                    BaseParams.Bg.Green(),
                    BaseParams.Bg.Blue() ) );
    	}
    	else
    	{
    		for ( int i=0; i<wxsSystemColoursCount; i++ )
    		{
    			if ( BaseParams.BgType == wxsSystemColours[i].Value )
    			{
    				XmlSetVariable( _T("bg"), wxsSystemColours[i].Name );
    				break;
    			}
    		}
    	}
    }

    if ( pType & bptFont && BaseParams.UseFont )
    {
    	TiXmlElement* Store = XmlElem();
    	XmlAssignElement(Store->InsertEndChild(TiXmlElement("font"))->ToElement());
    	wxFont& Font = BaseParams.Font;
    	XmlSetInteger(_T("size"),Font.GetPointSize());

    	switch ( Font.GetStyle() )
    	{
            case wxFONTSTYLE_ITALIC: XmlSetVariable(_T("style"),_T("italic")); break;
            case wxFONTSTYLE_SLANT : XmlSetVariable(_T("style"),_T("slant")); break;
            default:;
    	}

    	switch ( Font.GetWeight() )
    	{
    		case wxFONTWEIGHT_LIGHT: XmlSetVariable(_T("weight"),_T("light")); break;
            case wxFONTWEIGHT_BOLD : XmlSetVariable(_T("weight"),_T("bold")); break;
            default:;
    	}

    	switch ( Font.GetFamily() )
    	{
    		case wxFONTFAMILY_DECORATIVE: XmlSetVariable(_T("family"),_T("decorative")); break;
    		case wxFONTFAMILY_ROMAN     : XmlSetVariable(_T("family"),_T("roman")); break;
    		case wxFONTFAMILY_SCRIPT    : XmlSetVariable(_T("family"),_T("script")); break;
    		case wxFONTFAMILY_SWISS     : XmlSetVariable(_T("family"),_T("swiss")); break;
    		case wxFONTFAMILY_MODERN    : XmlSetVariable(_T("family"),_T("modern")); break;
    		case wxFONTFAMILY_TELETYPE  : XmlSetVariable(_T("family"),_T("teletype")); break;
    		default:;
    	}
    	if ( Font.GetUnderlined() ) XmlSetInteger(_T("underlined"),1);
    	if ( !Font.GetFaceName().empty() ) XmlSetVariable(_T("face"),Font.GetFaceName());
    	XmlAssignElement(Store);
    }

    if ( IsContainer() )
    {
        if ( !XmlSaveChildren() ) return false;
    }

    return true;
}

wxString wxsWidget::XmlGetVariable(const wxString& name)
{
    assert ( XmlElem() != NULL );

    if ( !name || !*name ) return _T("");
    TiXmlElement* Elem = XmlElem()->FirstChildElement(name.mb_str());
    if ( !Elem ) return _T("");

    TiXmlNode* Node = Elem->FirstChild();
    while ( Node )
    {
        TiXmlText* Text = Node->ToText();
        if ( Text )
        {
            return wxString(Text->Value(), wxConvUTF8);
        }
        Node = Node->NextSibling();
    }

    return _T("");
}

int wxsWidget::XmlGetInteger(const wxString& name,bool& IsInvalid,int DefaultValue)
{
    wxString Tmp = XmlGetVariable(name);
    long value;
    if ( !Tmp.Length() || !Tmp.ToLong(&value) )
    {
        IsInvalid = true;
        return DefaultValue;
    }
    IsInvalid = false;
    return (int)value;
}

bool wxsWidget::XmlGetIntPair(const wxString& Name,int& P1,int& P2,int DefP1,int DefP2)
{
    long _P1, _P2;
    wxString Tmp = XmlGetVariable(Name);
    if ( Tmp.Length() &&
         Tmp.BeforeFirst(_T(',')).ToLong(&_P1) &&
         Tmp.AfterLast(_T(',')).ToLong(&_P2) )
    {
        P1 = (int)_P1;
        P2 = (int)_P2;
        return true;
    }

    P1 = DefP1;
    P2 = DefP2;
    return false;
}

bool wxsWidget::XmlSetVariable(const wxString& Name,const wxString& Value)
{
    assert ( XmlElem() != NULL );
    TiXmlNode * NewNode = XmlElem()->InsertEndChild(TiXmlElement(Name.mb_str()));
    if ( NewNode )
    {
        NewNode->InsertEndChild(TiXmlText(Value.mb_str()));
        return true;
    }
    return false;
}

bool wxsWidget::XmlSetInteger(const wxString& Name,int Value)
{
    return XmlSetVariable(Name,wxString::Format(_T("%d"),Value));
}

bool wxsWidget::XmlSetIntPair(const wxString& Name,int Val1,int Val2)
{
    return XmlSetVariable(Name,wxString::Format(_T("%d,%d"),Val1,Val2));
}

bool wxsWidget::XmlLoadChildren()
{
    assert ( XmlElem() != NULL );

    bool Ret = true;

    for ( TiXmlElement* Element = XmlElem()->FirstChildElement();
          Element != NULL;
          Element = Element->NextSiblingElement() )
    {
    	if ( !XmlLoadChild(Element) )
    	{
    		Ret = false;
    	}
    }

    return Ret;
}

bool wxsWidget::XmlLoadChild(TiXmlElement* Element)
{
	// Processing <object> elements only
    if ( strcmp(Element->Value(),"object") ) return true;


    const char* Name = Element->Attribute("class");

    bool Ret = true;

    if ( Name && *Name )
    {
        wxsWidget* Child = wxsGEN(wxString(Name,wxConvUTF8),GetResource());
        if ( !Child )
        {
            return false;
        }

        if ( !Child->XmlLoad(Element) ) Ret = false;
        if ( AddChild(Child) < 0 )
        {
            delete Child;
            return false;
        }
    }
    return Ret;
}

bool wxsWidget::XmlSaveChildren()
{
    bool Ret = true;
    TiXmlElement* Elem = XmlElem();
    int Count = GetChildCount();
    for ( int i=0; i<Count; i++ )
    {
    	if ( !XmlSaveChild(i,Elem) ) Ret = false;
    }
    return Ret;
}

bool wxsWidget::XmlSaveChild(int ChildIndex,TiXmlElement* AddHere)
{
    wxsWidget* W = GetChild(ChildIndex);

    if ( W && W->GetInfo().Name )
    {
        TiXmlElement* SaveTo = AddHere->InsertEndChild(TiXmlElement("object"))->ToElement();

        if ( !SaveTo ) return false;

        SaveTo->SetAttribute("class",W->GetInfo().Name.mb_str());
        if ( !W->XmlSave(SaveTo) ) return false;
    }

    return true;
}

const wxsWidget::CodeDefines& wxsWidget::GetCodeDefines()
{
    CDefines.Style = _T("");
    CDefines.InitCode = _T("");

    wxString SelectCode = _T("");
    if ( GetParent() )
    {
        SelectCode << BaseParams.VarName << _T("->");
    }

    // Filling up styles

    wxsStyle* Style = GetInfo().Styles;
    int StyleV = BaseParams.Style;
    if ( Style )
    {
        for ( ; Style->Name; Style++ )
        {
            if ( Style->Value && ( ( StyleV & Style->Value ) == Style->Value ) )
            {
                StyleV &= ~Style->Value;

                if ( CDefines.Style.Length() ) CDefines.Style.Append('|');
                CDefines.Style.Append(Style->Name);
            }
        }
    }

    if ( CDefines.Style.Len() == 0 ) CDefines.Style = _T("0");

    // Creating position

    if ( BaseParams.DefaultPosition ) CDefines.Pos = _T("wxDefaultPosition");
    else CDefines.Pos.Printf(_T("wxPoint(%d,%d)"),BaseParams.PosX,BaseParams.PosY);

    // Creating size

    if ( BaseParams.DefaultSize ) CDefines.Size = _T("wxDefaultSize");
    else CDefines.Size.Printf(_T("wxSize(%d,%d)"),BaseParams.SizeX,BaseParams.SizeY);

    // Creating colours

    BasePropertiesType pType = GetBPType();

    if ( pType & bptColours )
    {
        wxString FColour;
        wxString BColour;

        if ( BaseParams.FgType == wxsCUSTOM_COLOUR )
        {
        	FColour.Printf(_T("wxColour(%d,%d,%d)"),
                BaseParams.Fg.Red(),
                BaseParams.Fg.Green(),
                BaseParams.Fg.Blue());
        }
        else
        {
        	for ( int i=0; i<wxsSystemColoursCount; i++ )
        	{
        		if ( BaseParams.FgType == wxsSystemColours[i].Value )
        		{
        			FColour.Printf(_T("wxSystemSettings::GetColour(%s)"),wxsSystemColours[i].Name);
        			break;
        		}
        	}
        }

        if ( BaseParams.BgType == wxsCUSTOM_COLOUR )
        {
        	BColour.Printf(_T("wxColour(%d,%d,%d)"),
                BaseParams.Bg.Red(),
                BaseParams.Bg.Green(),
                BaseParams.Bg.Blue());
        }
        else
        {
        	for ( int i=0; i<wxsSystemColoursCount; i++ )
        	{
        		if ( BaseParams.BgType == wxsSystemColours[i].Value )
        		{
        			BColour.Printf(_T("wxSystemSettings::GetColour(%s)"),wxsSystemColours[i].Name);
        			break;
        		}
        	}
        }


        if ( !FColour.empty() )
        {
            CDefines.InitCode << SelectCode << _T("SetForegroundColour(")
                              << FColour    << _T(");");
        }

        if ( !BColour.empty() )
        {
            CDefines.InitCode << SelectCode << _T("SetBackgroundColour(")
                              << BColour    << _T(");");
        }
    }

    if ( pType & bptFont && BaseParams.UseFont )
    {
    	wxFont& Font = BaseParams.Font;
    	CDefines.InitCode << SelectCode          << _T("SetFont(wxFont(")
    	                  << Font.GetPointSize() << _T(",");

    	switch ( Font.GetFamily() )
    	{
    		case wxFONTFAMILY_DECORATIVE: CDefines.InitCode << _T("wxFONTFAMILY_DECORATIVE,"); break;
    		case wxFONTFAMILY_ROMAN     : CDefines.InitCode << _T("wxFONTFAMILY_ROMAN,"); break;
    		case wxFONTFAMILY_SCRIPT    : CDefines.InitCode << _T("wxFONTFAMILY_SCRIPT,"); break;
    		case wxFONTFAMILY_SWISS     : CDefines.InitCode << _T("wxFONTFAMILY_SWISS,"); break;
    		case wxFONTFAMILY_MODERN    : CDefines.InitCode << _T("wxFONTFAMILY_MODERN,"); break;
    		case wxFONTFAMILY_TELETYPE  : CDefines.InitCode << _T("wxFONTFAMILY_TELETYPE,"); break;
    		default                     : CDefines.InitCode << _T("wxFONTFAMILY_DEFAULT,");
    	}

    	switch ( Font.GetStyle() )
        {
    		case wxFONTSTYLE_SLANT  : CDefines.InitCode << _T("wxFONTSTYLE_SLANT,"); break;
    		case wxFONTSTYLE_ITALIC : CDefines.InitCode << _T("wxFONTSTYLE_ITALIC,"); break;
    		default                 : CDefines.InitCode << _T("wxFONTSTYLE_NORMAL,");
    	}

        switch ( Font.GetWeight() )
        {
        	case wxFONTWEIGHT_BOLD : CDefines.InitCode << _T("wxFONTWEIGHT_BOLD,"); break;
        	case wxFONTWEIGHT_LIGHT: CDefines.InitCode << _T("wxFONTWEIGHT_LIGHT,"); break;
        	default                : CDefines.InitCode << _T("wxFONTWEIGHT_NORMAL,");
        }

        if ( Font.GetUnderlined() )
        {
        	CDefines.InitCode << _T("true,");
        }
        else
        {
        	CDefines.InitCode << _T("false,");
        }

        if ( Font.GetFaceName().empty() )
        {
        	CDefines.InitCode << _T("_T(\"\")");
        }
        else
        {
            CDefines.InitCode << GetWxString(Font.GetFaceName());
        }

        CDefines.InitCode << _T("));");
    }

    if ( pType & bptEnabled && !BaseParams.Enabled )
    {
    	CDefines.InitCode << SelectCode << _T("Disable();");
    }

    if ( pType & bptFocused && BaseParams.Focused )
    {
        CDefines.InitCode << SelectCode << _T("SetFocus();");
    }

    if ( pType & bptHidden && BaseParams.Hidden )
    {
    	CDefines.InitCode << SelectCode << _T("Hide();");
    }

    if ( pType & bptToolTip && !BaseParams.ToolTip.empty() )
    {
    	CDefines.InitCode << SelectCode << _T("SetToolTip(")
    	                  << GetWxString(BaseParams.ToolTip) << _T(");");
    }

    return CDefines;
}

bool wxsWidgetManager::RegisterInFactory()
{
    if ( !wxsFACTORY() ) return false;
    wxsFACTORY()->RegisterManager(this);
    return true;
}

void wxsWidget::BuildTree(wxTreeCtrl* Tree,wxTreeItemId Id,int Index)
{
    wxString Name = GetInfo().Name;

    // TODO (SpOoN#1#): Add icons
    wxTreeItemId SubId;
    if ( Index < 0 || Index >= (int)Tree->GetCount() )
    {
        SubId = Tree->AppendItem(Id,Name,-1,-1,new wxsResourceTreeData(this));
    }
    else
    {
        SubId = Tree->InsertItem(Id,Index,Name,-1,-1,new wxsResourceTreeData(this));
    }
    TreeId = SubId;
    AssignedToTree = true;

    int SubCnt = GetChildCount();
    for ( int i=0; i<SubCnt; i++ )
    {
        GetChild(i)->BuildTree(Tree,SubId);
    }
}

//Added by cyberkoa
/* ======================================================================
    Function Name : XmlSetStringArray
   ======================================================================

 Description : To write a series of strings from XRC with ParentName as
               parent element and ChildName as child element
  Example :  ParentName = "content" , ChildName="item"
              <content>
                   <item>Item 1</item>
                   <item>Option 2</item>
                   <item>3rd choice</item>
              </content>

*/

bool wxsWidget::XmlSetStringArray(const wxString& ParentName,const wxString& ChildName,wxArrayString& stringArray)
{
    assert ( XmlElem() != NULL );

    int Count = stringArray.GetCount();
    // No item, return without writing <content> and <item> elements
    if(Count==0) return false;

    // Adding <ParentName>  element
    TiXmlElement* ParentElement;
    TiXmlElement* ChildElement;
    ParentElement = XmlElem()->InsertEndChild(TiXmlElement(ParentName.mb_str()))->ToElement();

    for ( int i=0; i<Count; i++ )
    {
      ChildElement = ParentElement->InsertEndChild(TiXmlElement(ChildName.mb_str()))->ToElement();

      if (ChildElement)
        ChildElement->InsertEndChild(TiXmlText(stringArray[i].mb_str()));
    }
    return true;
}
//End added

//Added by cyberkoa
/* ======================================================================
    Function Name : XmlGetStringArray
   ======================================================================

 Description : To read a series of strings from XRC with ParentName as
               parent element and ChildName as child element
  Example :  ParentName = "content" , ChildName="item"
              <content>
                   <item>Item 1</item>
                   <item>Option 2</item>
                   <item>3rd choice</item>
              </content>

*/
bool wxsWidget::XmlGetStringArray(const wxString& ParentName,const wxString& ChildName,wxArrayString& stringArray)
{
    assert ( XmlElem() != NULL );

     // Empty it to make sure element added in an empty wxArrayString
      stringArray.Empty();

    TiXmlElement* ParentElement = XmlElem()->FirstChildElement(ParentName.mb_str());
    if(!ParentElement) return false;

    for (TiXmlElement* ChildElement= ParentElement->FirstChildElement(ChildName.mb_str());
          ChildElement != NULL;
          ChildElement = ChildElement->NextSiblingElement(ChildName.mb_str()))
          {

           TiXmlNode* Node = ChildElement->FirstChild();

			while(Node)
			{
			 if(Node->ToText())
              stringArray.Add(wxString(Node->ToText()->Value(),wxConvUTF8));

              Node=Node->NextSibling();
            }
          }

      if(stringArray.GetCount() > 0)return true; else return false;

}
//End added

void wxsWidget::KillTree(wxTreeCtrl* Tree)
{
	if ( AssignedToTree )
	{
		Tree->Delete(TreeId);
        InvalidateTreeIds();
	}
}

void wxsWidget::PreviewDestroyed()
{
    int Cnt = GetChildCount();
    for ( int i=0; i<Cnt; i++ )
    {
        GetChild(i)->PreviewDestroyed();
    }
    Preview = NULL;
}

void wxsWidget::InvalidateTreeIds()
{
	if ( !AssignedToTree ) return;
	AssignedToTree = false;
	int Cnt = GetChildCount();
	for ( int i=0; i<Cnt; i++ )
	{
		GetChild(i)->InvalidateTreeIds();
	}
}

wxsWindowEditor* wxsWidget::GetEditor()
{
	return Resource ? (wxsWindowEditor*)Resource->GetEditor() : NULL;
}

wxsWidgetEvents* wxsWidget::GetEvents()
{
	if ( !Events )
	{
		 Events = new wxsWidgetEvents(this);
		 // Filling up with events from info
		 wxsEventDesc* Desc = GetInfo().Events;
		 if ( Desc )
		 {
		 	while ( Desc->EventTypeName.Length() )
		 	{
		 		if ( Desc->EventEntry.Length() )
		 		{
		 			Events->AddEvent(*Desc,true);
		 		}
		 		Desc++;
		 	}
		 }
	}
	return Events;
}