changed wxXML to XRC, wx/xml/*.h->wx/xrc/*.h

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@10489 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

contrib/include/wx/xrc/xh_all.h

@@ -0,0 +1,49 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_all.h
+// Purpose:     includes all xh_*.h files
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_ALL_H_
+#define _WX_XH_ALL_H_
+
+
+// Existing handlers:
+
+#include "wx/xrc/xh_menu.h"
+#include "wx/xrc/xh_panel.h"
+#include "wx/xrc/xh_dlg.h"
+#include "wx/xrc/xh_bttn.h"
+#include "wx/xrc/xh_chckb.h"
+#include "wx/xrc/xh_gauge.h"
+#include "wx/xrc/xh_html.h"
+#include "wx/xrc/xh_spin.h"
+#include "wx/xrc/xh_sttxt.h"
+#include "wx/xrc/xh_slidr.h"
+#include "wx/xrc/xh_radbt.h"
+#include "wx/xrc/xh_radbx.h"
+#include "wx/xrc/xh_combo.h"
+#include "wx/xrc/xh_chckl.h"
+#include "wx/xrc/xh_choic.h"
+#include "wx/xrc/xh_sizer.h"
+#include "wx/xrc/xh_stbmp.h"
+#include "wx/xrc/xh_notbk.h"
+#include "wx/xrc/xh_text.h"
+#include "wx/xrc/xh_listb.h"
+#include "wx/xrc/xh_toolb.h"
+#include "wx/xrc/xh_bmpbt.h"
+#include "wx/xrc/xh_stbox.h"
+#include "wx/xrc/xh_scrol.h"
+#include "wx/xrc/xh_tree.h"
+#include "wx/xrc/xh_cald.h"
+#include "wx/xrc/xh_listc.h"
+#include "wx/xrc/xh_stlin.h"
+#include "wx/xrc/xh_bmp.h"
+#include "wx/xrc/xh_unkwn.h"
+#include "wx/xrc/xh_frame.h"
+
+#endif // _WX_XMLRES_H_

contrib/include/wx/xrc/xh_bmp.h

@@ -0,0 +1,38 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_bmp.h
+// Purpose:     XML resource handler for wxBitmap and wxIcon
+// Author:      Vaclav Slavik
+// Created:     2000/09/00
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_BMP_H_
+#define _WX_XH_BMP_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_bmp.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+
+class WXXMLDLLEXPORT wxBitmapXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxBitmapXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+class WXXMLDLLEXPORT wxIconXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxIconXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_BMP_H_

contrib/include/wx/xrc/xh_bmpbt.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_bmpbt.h
+// Purpose:     XML resource handler for bitmap buttons
+// Author:      Brian Gavin
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_BMPBT_H_
+#define _WX_XH_BMPBT_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_bmpbt.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+
+class WXXMLDLLEXPORT wxBitmapButtonXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxBitmapButtonXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_BMPBT_H_

contrib/include/wx/xrc/xh_bttn.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_bttn.h
+// Purpose:     XML resource handler for buttons
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_BTTN_H_
+#define _WX_XH_BTTN_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_bttn.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+class WXXMLDLLEXPORT wxButtonXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxButtonXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_BTTN_H_

contrib/include/wx/xrc/xh_cald.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_cald.h
+// Purpose:     XML resource handler for wxCalendarCtrl
+// Author:      Brian Gavin
+// Created:     2000/09/09
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CALD_H_
+#define _WX_XH_CALD_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_cald.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+class WXXMLDLLEXPORT wxCalendarCtrlXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxCalendarCtrlXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_CALD_H_

contrib/include/wx/xrc/xh_chckb.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_chckb.h
+// Purpose:     XML resource handler for wxCheckBox
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CHCKB_H_
+#define _WX_XH_CHCKB_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_chckb.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+#include "wx/defs.h"
+
+#if wxUSE_CHECKBOX
+
+class WXXMLDLLEXPORT wxCheckBoxXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxCheckBoxXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+#endif
+
+
+#endif // _WX_XH_CHECKBOX_H_
+

contrib/include/wx/xrc/xh_chckl.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_chckl.h
+// Purpose:     XML resource handler for wxCheckListBox
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CHCKL_H_
+#define _WX_XH_CHCKL_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_chckl.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+class WXXMLDLLEXPORT wxCheckListXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxCheckListXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+private:
+    bool m_insideBox;
+    wxArrayString strList;
+};
+
+
+
+#endif // _WX_XH_CHECKLIST_H_

contrib/include/wx/xrc/xh_choic.h

@@ -0,0 +1,32 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_choic.h
+// Purpose:     XML resource handler for wxChoice
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CHOIC_H_
+#define _WX_XH_CHOIC_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_choic.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+class WXXMLDLLEXPORT wxChoiceXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxChoiceXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+private:
+    bool m_insideBox;
+    wxArrayString strList;
+};
+
+
+#endif // _WX_XH_CHOIC_H_

contrib/include/wx/xrc/xh_combo.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_combo.h
+// Purpose:     XML resource handler for wxComboBox
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_COMBO_H_
+#define _WX_XH_COMBO_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_combo.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_COMBOBOX
+
+class WXXMLDLLEXPORT wxComboBoxXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxComboBoxXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+private:
+    bool m_insideBox;
+    wxArrayString strList;
+};
+
+#endif
+
+#endif // _WX_XH_COMBO_H_

contrib/include/wx/xrc/xh_dlg.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_dlg.h
+// Purpose:     XML resource handler for dialogs
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_DLG_H_
+#define _WX_XH_DLG_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_dlg.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+class WXXMLDLLEXPORT wxDialogXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxDialogXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_DLG_H_

contrib/include/wx/xrc/xh_frame.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_frame.h
+// Purpose:     XML resource handler for dialogs
+// Author:      Vaclav Slavik & Aleks.
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_FRAME_H_
+#define _WX_XH_FRAME_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_frame.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+class WXXMLDLLEXPORT wxFrameXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxFrameXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_FRAME_H_

contrib/include/wx/xrc/xh_gauge.h

@@ -0,0 +1,40 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_gauge.h
+// Purpose:     XML resource handler for wxGauge
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_GAUGE_H_
+#define _WX_XH_GAUGE_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_gauge.h"
+#endif
+
+#include "wx/defs.h"
+
+#if wxUSE_GAUGE
+
+#include "wx/xrc/xmlres.h"
+
+
+class WXXMLDLLEXPORT wxGaugeXmlHandler : public wxXmlResourceHandler
+{
+    enum
+    {
+        wxGAUGE_DEFAULT_RANGE = 100
+    };
+
+public:
+    wxGaugeXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+#endif
+
+#endif // _WX_XH_GAUGE_H_

contrib/include/wx/xrc/xh_html.h

@@ -0,0 +1,34 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_html.h
+// Purpose:     XML resource handler for wxHtmlWindow
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_HTML_H_
+#define _WX_XH_HTML_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_html.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+#include "wx/defs.h"
+
+#if wxUSE_HTML
+
+class WXXMLDLLEXPORT wxHtmlWindowXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxHtmlWindowXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+#endif
+
+#endif // _WX_XH_SLIDER_H_

contrib/include/wx/xrc/xh_listb.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_listb.h
+// Purpose:     XML resource handler for wxListbox
+// Author:      Bob Mitchell & Vaclav Slavik
+// Created:     2000/07/29
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell & Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_LISTB_H_
+#define _WX_XH_LISTB_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_listb.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_LISTBOX
+
+class WXXMLDLLEXPORT wxListBoxXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxListBoxXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+private:
+    bool m_insideBox;
+    wxArrayString strList;
+};
+
+#endif
+
+#endif // _WX_XH_LISTB_H_

contrib/include/wx/xrc/xh_listc.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_listc.h
+// Purpose:     XML resource handler for wxCalendarCtrl
+// Author:      Brian Gavin
+// Created:     2000/09/09
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_LISTC_H_
+#define _WX_XH_LISTC_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_listc.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+class WXXMLDLLEXPORT wxListCtrlXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxListCtrlXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_LISTC_H_

contrib/include/wx/xrc/xh_menu.h

@@ -0,0 +1,40 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_menu.h
+// Purpose:     XML resource handler for menus/menubars
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_MENU_H_
+#define _WX_XH_MENU_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_menu.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+class WXXMLDLLEXPORT wxMenuXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxMenuXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+
+private:
+    bool m_insideMenu;
+};
+
+class WXXMLDLLEXPORT wxMenuBarXmlHandler : public wxXmlResourceHandler
+{
+    public:
+        wxMenuBarXmlHandler();
+        virtual wxObject *DoCreateResource();
+        virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_MENU_H_

contrib/include/wx/xrc/xh_notbk.h

@@ -0,0 +1,37 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_notbk.h
+// Purpose:     XML resource handler for wxNotebook
+// Author:      Vaclav Slavik
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_NOTBK_H_
+#define _WX_XH_NOTBK_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_notbk.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_NOTEBOOK
+
+class WXDLLEXPORT wxNotebook;
+
+class WXXMLDLLEXPORT wxNotebookXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxNotebookXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+
+private:
+    bool m_isInside;
+    wxNotebook *m_notebook;
+};
+
+#endif
+
+#endif // _WX_XH_NOTBK_H_

contrib/include/wx/xrc/xh_panel.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_panel.h
+// Purpose:     XML resource handler for panels
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_PANEL_H_
+#define _WX_XH_PANEL_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_panel.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+class WXXMLDLLEXPORT wxPanelXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxPanelXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_PANEL_H_

contrib/include/wx/xrc/xh_radbt.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_radbt.h
+// Purpose:     XML resource handler for radio buttons
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_RADBT_H_
+#define _WX_XH_RADBT_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_radbt.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+#include "wx/defs.h"
+
+#if wxUSE_RADIOBOX
+
+class WXXMLDLLEXPORT wxRadioButtonXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxRadioButtonXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+#endif
+
+#endif // _WX_XH_RADIOBUTTON_H_

contrib/include/wx/xrc/xh_radbx.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_radbx.h
+// Purpose:     XML resource handler for radio box
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_RADBX_H_
+#define _WX_XH_RADBX_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_radbx.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_RADIOBOX
+
+class WXXMLDLLEXPORT wxRadioBoxXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxRadioBoxXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+private:
+    bool m_insideBox;
+    wxArrayString strList;
+};
+
+#endif
+
+#endif // _WX_XH_RADBX_H_

contrib/include/wx/xrc/xh_scrol.h

@@ -0,0 +1,39 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_scrol.h
+// Purpose:     XML resource handler for wxScrollBar
+// Author:      Brian Gavin
+// Created:     2000/09/09
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SCROL_H_
+#define _WX_XH_SCROL_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_scrol.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+#include "wx/defs.h"
+
+
+
+class WXXMLDLLEXPORT wxScrollBarXmlHandler : public wxXmlResourceHandler
+{
+    enum
+    {
+        wxSL_DEFAULT_VALUE = 0,
+        wxSL_DEFAULT_MIN = 0,
+        wxSL_DEFAULT_MAX = 100
+    };
+
+public:
+    wxScrollBarXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_SCROL_H_

contrib/include/wx/xrc/xh_sizer.h

@@ -0,0 +1,38 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_sizer.h
+// Purpose:     XML resource handler for wxBoxSizer
+// Author:      Vaclav Slavik
+// Created:     2000/04/24
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SIZER_H_
+#define _WX_XH_SIZER_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_sizer.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+
+class WXDLLEXPORT wxSizer;
+
+class WXXMLDLLEXPORT wxSizerXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxSizerXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+
+private:
+    bool m_isInside;
+    wxSizer *m_parentSizer;
+
+    bool IsSizerNode(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_BOXSIZER_H_

contrib/include/wx/xrc/xh_slidr.h

@@ -0,0 +1,40 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_slidr.h
+// Purpose:     XML resource handler for wxSlider
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SLIDR_H_
+#define _WX_XH_SLIDR_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_slidr.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+#include "wx/defs.h"
+
+#if wxUSE_SLIDER
+
+class WXXMLDLLEXPORT wxSliderXmlHandler : public wxXmlResourceHandler
+{
+    enum
+    {
+        wxSL_DEFAULT_VALUE = 0,
+        wxSL_DEFAULT_MIN = 0,
+        wxSL_DEFAULT_MAX = 100
+    };
+
+public:
+    wxSliderXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+#endif
+
+#endif // _WX_XH_SLIDER_H_

contrib/include/wx/xrc/xh_spin.h

@@ -0,0 +1,55 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_spin.h
+// Purpose:     XML resource handler for wxSpinButton
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SPIN_H_
+#define _WX_XH_SPIN_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_spin.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+#include "wx/defs.h"
+
+#if wxUSE_SPINBTN
+class WXXMLDLLEXPORT wxSpinButtonXmlHandler : public wxXmlResourceHandler
+{
+    enum
+    {
+        wxSP_DEFAULT_VALUE = 0,
+        wxSP_DEFAULT_MIN = 0,
+        wxSP_DEFAULT_MAX = 100
+    };
+
+public:
+    wxSpinButtonXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+#endif
+
+#if wxUSE_SPINCTRL
+class WXXMLDLLEXPORT wxSpinCtrlXmlHandler : public wxXmlResourceHandler
+{
+    enum
+    {
+        wxSP_DEFAULT_VALUE = 0,
+        wxSP_DEFAULT_MIN = 0,
+        wxSP_DEFAULT_MAX = 100
+    };
+
+public:
+    wxSpinCtrlXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+#endif
+
+#endif // _WX_XH_SPIN_H_

contrib/include/wx/xrc/xh_stbmp.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_stbmp.h
+// Purpose:     XML resource handler for wxStaticBitmap
+// Author:      Vaclav Slavik
+// Created:     2000/04/22
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STBMP_H_
+#define _WX_XH_STBMP_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_stbmp.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+
+class WXXMLDLLEXPORT wxStaticBitmapXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxStaticBitmapXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_STBMP_H_

contrib/include/wx/xrc/xh_stbox.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_stbox.h
+// Purpose:     XML resource handler for wxStaticBox
+// Author:      Brian Gavin
+// Created:     2000/09/00
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STBOX_H_
+#define _WX_XH_STBOX_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_stbox.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+
+class WXXMLDLLEXPORT wxStaticBoxXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxStaticBoxXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_STBOX_H_

contrib/include/wx/xrc/xh_stlin.h

@@ -0,0 +1,32 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_stlin.h
+// Purpose:     XML resource handler for wxStaticLine
+// Author:      Vaclav Slavik
+// Created:     2000/09/00
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STLIN_H_
+#define _WX_XH_STLIN_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_stlin.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_STATLINE
+
+class WXXMLDLLEXPORT wxStaticLineXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxStaticLineXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+#endif
+
+#endif // _WX_XH_STLIN_H_

contrib/include/wx/xrc/xh_sttxt.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_sttxt.h
+// Purpose:     XML resource handler for wxStaticBitmap
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Bob Mitchell
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STTXT_H_
+#define _WX_XH_STTXT_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_sttxt.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+
+class WXXMLDLLEXPORT wxStaticTextXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxStaticTextXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_STBMP_H_

contrib/include/wx/xrc/xh_text.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_text.h
+// Purpose:     XML resource handler for wxTextCtrl
+// Author:      Aleksandras Gluchovas
+// Created:     2000/03/21
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Aleksandras Gluchovas
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_TEXT_H_
+#define _WX_XH_TEXT_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_text.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+
+class WXXMLDLLEXPORT wxTextCtrlXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxTextCtrlXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_TEXT_H_

contrib/include/wx/xrc/xh_toolb.h

@@ -0,0 +1,38 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_toolb.h
+// Purpose:     XML resource handler for wxBoxSizer
+// Author:      Vaclav Slavik
+// Created:     2000/08/11
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_TOOLB_H_
+#define _WX_XH_TOOLB_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_toolb.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_TOOLBAR
+
+class WXDLLEXPORT wxToolBar;
+
+class WXXMLDLLEXPORT wxToolBarXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxToolBarXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+
+private:
+    bool m_isInside;
+    wxToolBar *m_toolbar;
+};
+
+#endif
+
+#endif // _WX_XH_TOOLBAR_H_

contrib/include/wx/xrc/xh_tree.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_tree.h
+// Purpose:     XML resource handler for wxTreeCtrl
+// Author:      Brian Gavin
+// Created:     2000/09/09
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_TREE_H_
+#define _WX_XH_TREE_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_tree.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+class WXXMLDLLEXPORT wxTreeCtrlXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxTreeCtrlXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_TREE_H_

contrib/include/wx/xrc/xh_unkwn.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_unkwn.h
+// Purpose:     XML resource handler for unkown widget
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_UNKWN_H_
+#define _WX_XH_UNKWN_H_
+
+#ifdef __GNUG__
+#pragma interface "xh_unkwn.h"
+#endif
+
+#include "wx/xrc/xmlres.h"
+
+
+class WXXMLDLLEXPORT wxUnknownWidgetXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxUnknownWidgetXmlHandler();
+    virtual wxObject *DoCreateResource();
+    virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_UNKWN_H_

contrib/include/wx/xrc/xml.h

@@ -0,0 +1,264 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xml.h
+// Purpose:     wxXmlDocument - XML parser & data holder class
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XML_H_
+#define _WX_XML_H_
+
+#ifdef __GNUG__
+#pragma interface "xml.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/string.h"
+#include "wx/object.h"
+#include "wx/list.h"
+
+#ifdef WXXMLISDLL
+#define WXXMLDLLEXPORT WXDLLEXPORT
+#else
+#define WXXMLDLLEXPORT
+#endif
+
+class WXXMLDLLEXPORT wxXmlNode;
+class WXXMLDLLEXPORT wxXmlProperty;
+class WXXMLDLLEXPORT wxXmlDocument;
+class WXXMLDLLEXPORT wxXmlIOHandler;
+class WXDLLEXPORT wxInputStream;
+class WXDLLEXPORT wxOutputStream;
+
+
+// Represents XML node type.
+enum wxXmlNodeType
+{
+    // note: values are synchronized with xmlElementType from libxml
+    wxXML_ELEMENT_NODE       =  1,
+    wxXML_ATTRIBUTE_NODE     =  2,
+    wxXML_TEXT_NODE          =  3,
+    wxXML_CDATA_SECTION_NODE =  4,
+    wxXML_ENTITY_REF_NODE    =  5,
+    wxXML_ENTITY_NODE        =  6,
+    wxXML_PI_NODE            =  7,
+    wxXML_COMMENT_NODE       =  8,
+    wxXML_DOCUMENT_NODE      =  9,
+    wxXML_DOCUMENT_TYPE_NODE = 10,
+    wxXML_DOCUMENT_FRAG_NODE = 11,
+    wxXML_NOTATION_NODE      = 12,
+    wxXML_HTML_DOCUMENT_NODE = 13
+};
+
+
+// Types of XML files:
+
+enum wxXmlIOType
+{
+    wxXML_IO_AUTO = 0,    // detect it automatically
+    wxXML_IO_EXPAT,       // use Expat to load from text/xml document
+    wxXML_IO_TEXT_OUTPUT, // generic saver into text/xml
+    wxXML_IO_BIN,         // save in binary uncompressed proprietary format
+    wxXML_IO_BINZ         // svae in binary zlib-compressed proprietary format
+};
+
+
+// Represents node property(ies).
+// Example: in <img src="hello.gif" id="3"/> "src" is property with value
+//          "hello.gif" and "id" is prop. with value "3".
+
+class WXXMLDLLEXPORT wxXmlProperty
+{
+public:
+    wxXmlProperty() : m_next(NULL) {}
+    wxXmlProperty(const wxString& name, const wxString& value,
+                  wxXmlProperty *next)
+            : m_name(name), m_value(value), m_next(next) {}
+    ~wxXmlProperty() { delete m_next; }
+
+    wxString GetName() const { return m_name; }
+    wxString GetValue() const { return m_value; }
+    wxXmlProperty *GetNext() const { return m_next; }
+
+    void SetName(const wxString& name) { m_name = name; }
+    void SetValue(const wxString& value) { m_value = value; }
+    void SetNext(wxXmlProperty *next) { m_next = next; }
+
+private:
+    wxString m_name;
+    wxString m_value;
+    wxXmlProperty *m_next;
+};
+
+
+
+// Represents node in XML document. Node has name and may have content
+// and properties. Most common node types are wxXML_TEXT_NODE (name and props
+// are irrelevant) and wxXML_ELEMENT_NODE (e.g. in <title>hi</title> there is
+// element with name="title", irrelevant content and one child (wxXML_TEXT_NODE
+// with content="hi").
+//
+// If wxUSE_UNICODE is 0, all strings are encoded in UTF-8 encoding (same as
+// ASCII for characters 0-127). You can use wxMBConvUTF8 to convert then to
+// desired encoding:
+//
+//     wxCSConv myConv("iso8859-2");
+//     wxString s(cMB2WC(node->GetContent().c_str()), myConv);
+
+class WXXMLDLLEXPORT wxXmlNode
+{
+public:
+    wxXmlNode() : m_properties(NULL), m_parent(NULL),
+                  m_children(NULL), m_next(NULL) {}
+    wxXmlNode(wxXmlNode *parent,wxXmlNodeType type,
+              const wxString& name, const wxString& content,
+              wxXmlProperty *props, wxXmlNode *next);
+    ~wxXmlNode() { delete m_properties; delete m_next; delete m_children; }
+
+    // copy ctor & operator=. Note that this does NOT copy syblings
+    // and parent pointer, i.e. m_parent and m_next will be NULL
+    // after using copy ctor and are never unmodified by operator=.
+    // On the other hand, it DOES copy children and properties.
+    wxXmlNode(const wxXmlNode& node);
+    wxXmlNode& operator=(const wxXmlNode& node);
+
+    // user-friendly creation:
+    wxXmlNode(wxXmlNodeType type, const wxString& name,
+              const wxString& content = wxEmptyString);
+    void AddChild(wxXmlNode *child);
+    void InsertChild(wxXmlNode *child, wxXmlNode *before_node);
+    bool RemoveChild(wxXmlNode *child);
+    void AddProperty(const wxString& name, const wxString& value);
+    bool DeleteProperty(const wxString& name);
+
+    // access methods:
+    wxXmlNodeType GetType() const { return m_type; }
+    wxString GetName() const { return m_name; }
+    wxString GetContent() const { return m_content; }
+
+    wxXmlNode *GetParent() const { return m_parent; }
+    wxXmlNode *GetNext() const { return m_next; }
+    wxXmlNode *GetChildren() const { return m_children; }
+
+    wxXmlProperty *GetProperties() const { return m_properties; }
+    bool GetPropVal(const wxString& propName, wxString *value) const;
+    wxString GetPropVal(const wxString& propName,
+                        const wxString& defaultVal) const;
+    bool HasProp(const wxString& propName) const;
+
+    void SetType(wxXmlNodeType type) { m_type = type; }
+    void SetName(const wxString& name) { m_name = name; }
+    void SetContent(const wxString& con) { m_content = con; }
+
+    void SetParent(wxXmlNode *parent) { m_parent = parent; }
+    void SetNext(wxXmlNode *next) { m_next = next; }
+    void SetChildren(wxXmlNode *child) { m_children = child; }
+
+    void SetProperties(wxXmlProperty *prop) { m_properties = prop; }
+    void AddProperty(wxXmlProperty *prop);
+
+private:
+    wxXmlNodeType m_type;
+    wxString m_name;
+    wxString m_content;
+    wxXmlProperty *m_properties;
+    wxXmlNode *m_parent, *m_children, *m_next;
+
+    void DoCopy(const wxXmlNode& node);
+};
+
+
+
+
+
+
+
+// This class holds XML data/document as parsed by libxml. Note that
+// internal representation is independant on libxml and you can use
+// it without libxml (see Load/SaveBinary).
+
+class WXXMLDLLEXPORT wxXmlDocument : public wxObject
+{
+public:
+    wxXmlDocument() : wxObject(), m_version(wxT("1.0")), m_root(NULL)  {}
+    wxXmlDocument(const wxString& filename,
+                  wxXmlIOType io_type = wxXML_IO_AUTO);
+    wxXmlDocument(wxInputStream& stream,
+                  wxXmlIOType io_type = wxXML_IO_AUTO);
+    ~wxXmlDocument() { delete m_root; }
+
+    wxXmlDocument(const wxXmlDocument& doc);
+    wxXmlDocument& operator=(const wxXmlDocument& doc);
+
+    // Parses .xml file and loads data. Returns TRUE on success, FALSE
+    // otherwise.
+    // NOTE: Any call to this method will result into linking against libxml
+    //       and app's binary size will grow by ca. 250kB
+    bool Load(const wxString& filename, wxXmlIOType io_type = wxXML_IO_AUTO);
+    bool Load(wxInputStream& stream, wxXmlIOType io_type = wxXML_IO_AUTO);
+
+    // Saves document as .xml file.
+    bool Save(const wxString& filename,
+              wxXmlIOType io_type = wxXML_IO_TEXT_OUTPUT) const;
+    bool Save(wxOutputStream& stream,
+              wxXmlIOType io_type = wxXML_IO_TEXT_OUTPUT) const;
+
+    bool IsOk() const { return m_root != NULL; }
+
+    // Returns root node of the document.
+    wxXmlNode *GetRoot() const { return m_root; }
+
+    // Returns version of document (may be empty).
+    wxString GetVersion() const { return m_version; }
+    // Returns encoding of document (may be empty).
+    // Note: this is the encoding original fail was saved in, *not* the
+    // encoding of in-memory representation! Data in wxXmlNode are always
+    // stored in wchar_t (in Unicode build) or UTF-8 encoded
+    // (if wxUSE_UNICODE is 0).
+    wxString GetEncoding() const { return m_encoding; }
+
+    // Write-access methods:
+    void SetRoot(wxXmlNode *node) { delete m_root ; m_root = node; }
+    void SetVersion(const wxString& version) { m_version = version; }
+    void SetEncoding(const wxString& encoding) { m_encoding = encoding; }
+
+    static void AddHandler(wxXmlIOHandler *handler);
+    static void CleanUpHandlers();
+    static void InitStandardHandlers();
+
+protected:
+    static wxList *sm_handlers;
+
+private:
+    wxString m_version, m_encoding;
+    wxXmlNode *m_root;
+
+    void DoCopy(const wxXmlDocument& doc);
+};
+
+
+
+// wxXmlIOHandler takes care of loading and/or saving XML data.
+// see xmlio.h for available handlers
+
+class WXXMLDLLEXPORT wxXmlIOHandler : public wxObject
+{
+    public:
+        wxXmlIOHandler() {}
+
+        virtual wxXmlIOType GetType() = 0;
+        virtual bool CanLoad(wxInputStream& stream) = 0;
+        virtual bool CanSave() = 0;
+
+        virtual bool Load(wxInputStream& stream, wxXmlDocument& doc) = 0;
+        virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc) = 0;
+};
+
+
+
+void wxXmlInitXmlModule();
+
+#endif // _WX_XML_H_

contrib/include/wx/xrc/xmlio.h

@@ -0,0 +1,85 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xmlio.h
+// Purpose:     wxXmlIOHandler - XML I/O classes
+// Author:      Vaclav Slavik
+// Created:     2000/07/24
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XMLIO_H_
+#define _WX_XMLIO_H_
+
+#ifdef __GNUG__
+#pragma interface "xmlio.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/string.h"
+#include "wx/xrc/xml.h"
+
+
+class WXXMLDLLEXPORT wxXmlIOHandlerExpat : public wxXmlIOHandler
+{
+public:
+    virtual wxXmlIOType GetType() { return wxXML_IO_EXPAT; }
+    virtual bool CanLoad(wxInputStream& stream);
+    virtual bool CanSave() { return FALSE; }
+
+    virtual bool Load(wxInputStream& stream, wxXmlDocument& doc);
+    virtual bool Save(wxOutputStream& WXUNUSED(stream), const wxXmlDocument& WXUNUSED(doc))
+        { return FALSE; }
+};
+
+
+class WXXMLDLLEXPORT wxXmlIOHandlerWriter : public wxXmlIOHandler
+{
+public:
+    virtual wxXmlIOType GetType() { return wxXML_IO_TEXT_OUTPUT; }
+    virtual bool CanLoad(wxInputStream& WXUNUSED(stream)) { return FALSE; }
+    virtual bool CanSave() { return TRUE; }
+
+    virtual bool Load(wxInputStream& WXUNUSED(stream), wxXmlDocument& WXUNUSED(doc)) 
+        { return FALSE; }
+    virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc);
+};
+
+
+class WXXMLDLLEXPORT wxXmlIOHandlerBin : public wxXmlIOHandler
+{
+public:
+    wxXmlIOHandlerBin() {}
+
+    virtual wxXmlIOType GetType() { return wxXML_IO_BIN; }
+    virtual bool CanLoad(wxInputStream& stream);
+    virtual bool CanSave() { return TRUE; }
+
+    virtual bool Load(wxInputStream& stream, wxXmlDocument& doc);
+    virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc);
+
+protected:
+    wxString ReadHeader(wxInputStream& stream);
+    void WriteHeader(wxOutputStream& stream, const wxString& header);
+};
+
+
+
+#if wxUSE_ZLIB
+
+class WXXMLDLLEXPORT wxXmlIOHandlerBinZ : public wxXmlIOHandlerBin
+{
+public:
+    wxXmlIOHandlerBinZ() {}
+
+    virtual wxXmlIOType GetType() { return wxXML_IO_BINZ; }
+    virtual bool CanLoad(wxInputStream& stream);
+
+    virtual bool Load(wxInputStream& stream, wxXmlDocument& doc);
+    virtual bool Save(wxOutputStream& stream, const wxXmlDocument& doc);
+};
+
+#endif
+
+
+#endif // _WX_XMLIO_H_

contrib/include/wx/xrc/xmlres.h

@@ -0,0 +1,358 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xmlres.h
+// Purpose:     XML resources
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// RCS-ID:      $Id$
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XMLRES_H_
+#define _WX_XMLRES_H_
+
+#ifdef __GNUG__
+#pragma interface "xmlres.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/string.h"
+#include "wx/dynarray.h"
+#include "wx/datetime.h"
+#include "wx/list.h"
+#include "wx/gdicmn.h"
+#include "wx/filesys.h"
+#include "wx/bitmap.h"
+#include "wx/icon.h"
+
+#include "wx/xrc/xml.h"
+
+class WXDLLEXPORT wxMenu;
+class WXDLLEXPORT wxMenuBar;
+class WXDLLEXPORT wxDialog;
+class WXDLLEXPORT wxPanel;
+class WXDLLEXPORT wxWindow;
+class WXDLLEXPORT wxFrame;
+class WXDLLEXPORT wxToolBar;
+
+class WXXMLDLLEXPORT wxXmlResourceHandler;
+
+
+// These macros indicate current version of XML resources (this information is
+// encoded in root node of XRC file as "version" property).
+//
+// Rules for increasing version number:
+//   - change it only if you made incompatible change to the format. Addition of new
+//     attribute to control handler is _not_ incompatible change, because older
+//     versions of the library may ignore it.
+//   - if you change version number, follow these steps:
+//       - set major, minor and release numbers to respective version numbers of
+//         the wxWindows library (see wx/version.h)
+//       - reset revision to 0 unless the first three are same as before, in which
+//         case you should increase revision by one
+#define WX_XMLRES_CURRENT_VERSION_MAJOR            2
+#define WX_XMLRES_CURRENT_VERSION_MINOR            3
+#define WX_XMLRES_CURRENT_VERSION_RELEASE          0
+#define WX_XMLRES_CURRENT_VERSION_REVISION         1
+#define WX_XMLRES_CURRENT_VERSION_STRING    "2.3.0.1"
+
+#define WX_XMLRES_CURRENT_VERSION \
+                (WX_XMLRES_CURRENT_VERSION_MAJOR * 256*256*256 + \
+                 WX_XMLRES_CURRENT_VERSION_MINOR * 256*256 + \
+                 WX_XMLRES_CURRENT_VERSION_RELEASE * 256 + \
+                 WX_XMLRES_CURRENT_VERSION_REVISION)
+
+class WXXMLDLLEXPORT wxXmlResourceDataRecord
+{
+public:
+    wxXmlResourceDataRecord() : Doc(NULL), Time(wxDateTime::Now()) {}
+    ~wxXmlResourceDataRecord() {delete Doc;}
+
+    wxString File;
+    wxXmlDocument *Doc;
+    wxDateTime Time;
+};
+
+
+#ifdef WXXMLISDLL
+WX_DECLARE_EXPORTED_OBJARRAY(wxXmlResourceDataRecord, wxXmlResourceDataRecords);
+#else
+WX_DECLARE_OBJARRAY(wxXmlResourceDataRecord, wxXmlResourceDataRecords);
+#endif
+
+
+// This class holds XML resources from one or more .xml files
+// (or derived forms, either binary or zipped -- see manual for
+// details).
+
+class WXXMLDLLEXPORT wxXmlResource : public wxObject
+{
+public:
+    // Ctor. If use_locale is TRUE, translatable strings are
+    // translated via _(). You can disable it by passing use_locale=FALSE
+    // (for example if you provide resource file for each locale)
+    wxXmlResource(bool use_locale = TRUE);
+    wxXmlResource(const wxString& filemask, bool use_locale = TRUE);
+    ~wxXmlResource();
+
+    // Loads resources from XML files that match given filemask.
+    // This method understands VFS (see filesys.h).
+    bool Load(const wxString& filemask);
+
+    // Initialize handlers for all supported controls/windows. This will
+    // make the executable quite big because it forces linking against
+    // most of wxWin library
+    void InitAllHandlers();
+
+    // Initialize only specific handler (or custom handler). Convention says
+    // that handler name is equal to control's name plus 'XmlHandler', e.g.
+    // wxTextCtrlXmlHandler, wxHtmlWindowXmlHandler. XML resource compiler
+    // (xmlres) can create include file that contains initialization code for
+    // all controls used within the resource.
+    void AddHandler(wxXmlResourceHandler *handler);
+
+    // Removes all handlers
+    void ClearHandlers();
+
+    // Loads menu from resource. Returns NULL on failure.
+    wxMenu *LoadMenu(const wxString& name);
+
+    // Loads menubar from resource. Returns NULL on failure.
+    wxMenuBar *LoadMenuBar(const wxString& name);
+
+#if wxUSE_TOOLBAR
+    // Loads toolbar
+    wxToolBar *LoadToolBar(wxWindow *parent, const wxString& name);
+#endif
+
+    // Loads dialog. dlg points to parent window (if any). Second form
+    // is used to finish creation of already existing instance (main reason
+    // for this is that you may want to use derived class with new event table)
+    // Example (typical usage):
+    //      MyDialog dlg;
+    //      wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog");
+    //      dlg->ShowModal();
+    wxDialog *LoadDialog(wxWindow *parent, const wxString& name);
+    bool LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name);
+
+    // Loads panel. panel points to parent window (if any). Second form
+    // is used to finish creation of already existing instance.
+    wxPanel *LoadPanel(wxWindow *parent, const wxString& name);
+    bool LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name);
+
+    bool LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name);
+
+    // Loads bitmap or icon resource from file:
+    wxBitmap LoadBitmap(const wxString& name);
+    wxIcon LoadIcon(const wxString& name);
+
+    // Attaches unknown control into given panel/window/dialog:
+    // (unknown controls are used in conjunction with <object class="unknown">)
+    bool AttachUnknownControl(const wxString& name, wxWindow *control,
+                              wxWindow *parent = NULL);
+
+    // Returns numeric ID that is equivalent to string id used in XML
+    // resource. To be used in event tables
+    // Macro XMLID is provided for convenience
+    static int GetXMLID(const char *str_id);
+
+    // Returns version info (a.b.c.d = d+ 256*c + 256^2*b + 256^3*a)
+    long GetVersion() const { return m_version; }
+
+    // Compares resources version to argument. Returns -1 if resources version
+    // is less than the argument, +1 if greater and 0 if they equal.
+    int CompareVersion(int major, int minor, int release, int revision) const
+        { return GetVersion() -
+                 (major*256*256*256 + minor*256*256 + release*256 + revision); }
+
+protected:
+    // Scans resources list for unloaded files and loads them. Also reloads
+    // files that have been modified since last loading.
+    void UpdateResources();
+
+    // Finds resource (calls UpdateResources) and returns node containing it
+    wxXmlNode *FindResource(const wxString& name, const wxString& classname);
+
+    // Creates resource from info in given node:
+    wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent, wxObject *instance = NULL);
+
+    // Remove nodes with property "platform" that does not
+    // match current platform
+    void ProcessPlatformProperty(wxXmlNode *node);
+
+    bool GetUseLocale() { return m_useLocale; }
+
+private:
+    long m_version;
+
+    bool m_useLocale;
+    wxList m_handlers;
+    wxXmlResourceDataRecords m_data;
+#if wxUSE_FILESYSTEM
+    wxFileSystem m_curFileSystem;
+    wxFileSystem& GetCurFileSystem() { return m_curFileSystem; }
+#endif
+
+    friend class wxXmlResourceHandler;
+};
+
+
+// Global instance of resource class. For your convenience.
+extern wxXmlResource *wxTheXmlResource;
+
+// This macro translates string identifier (as used in XML resource,
+// e.g. <menuitem id="my_menu">...</menuitem>) to integer id that is needed by
+// wxWindows event tables.
+// Example:
+//    BEGIN_EVENT_TABLE(MyFrame, wxFrame)
+//       EVT_MENU(XMLID("quit"), MyFrame::OnQuit)
+//       EVT_MENU(XMLID("about"), MyFrame::OnAbout)
+//       EVT_MENU(XMLID("new"), MyFrame::OnNew)
+//       EVT_MENU(XMLID("open"), MyFrame::OnOpen)
+//    END_EVENT_TABLE()
+
+#define XMLID(str_id) \
+    wxXmlResource::GetXMLID(wxT(str_id))
+
+
+// This macro returns pointer to particular control in dialog
+// created using XML resources. You can use it to set/get values from
+// controls.
+// Example:
+//    wxDialog dlg;
+//    wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog");
+//    XMLCTRL(dlg, "my_textctrl", wxTextCtrl)->SetValue(wxT("default value"));
+
+#ifdef __WXDEBUG__
+#define XMLCTRL(window, id, type) \
+    (wxDynamicCast((window).FindWindow(XMLID(id)), type))
+#else
+#define XMLCTRL(window, id, type) \
+    ((type*)((window).FindWindow(XMLID(id))))
+#endif
+
+
+class WXXMLDLLEXPORT wxXmlResourceHandler : public wxObject
+{
+public:
+    wxXmlResourceHandler();
+    virtual ~wxXmlResourceHandler() {}
+
+    // Creates object (menu, dialog, control, ...) from XML node.
+    // Should check for validity.
+    // parent is higher-level object (usually window, dialog or panel)
+    // that is often neccessary to create resource
+    // if instance != NULL it should not create new instance via 'new' but
+    // rather use this one and call its Create method
+    wxObject *CreateResource(wxXmlNode *node, wxObject *parent,
+                             wxObject *instance);
+
+    // This one is called from CreateResource after variables
+    // were filled
+    virtual wxObject *DoCreateResource() = 0;
+
+    // Returns TRUE if it understands this node and can create
+    // resource from it, FALSE otherwise.
+    virtual bool CanHandle(wxXmlNode *node) = 0;
+
+    void SetParentResource(wxXmlResource *res) { m_resource = res; }
+
+
+protected:
+
+    wxXmlResource *m_resource;
+    wxArrayString m_styleNames;
+    wxArrayInt m_styleValues;
+
+    // Variables (filled by CreateResource)
+    wxXmlNode *m_node;
+    wxString m_class;
+    wxObject *m_parent, *m_instance;
+    wxWindow *m_parentAsWindow, *m_instanceAsWindow;
+
+    // --- Handy methods:
+
+    // Returns true if the node has property class equal to classname,
+    // e.g. <object class="wxDialog">
+    bool IsOfClass(wxXmlNode *node, const wxString& classname)
+        { return node->GetPropVal(wxT("class"), wxEmptyString) == classname; }
+
+    // Gets node content from wxXML_ENTITY_NODE
+    // (the problem is, <tag>content<tag> is represented as
+    // wxXML_ENTITY_NODE name="tag", content=""
+    //    |-- wxXML_TEXT_NODE or
+    //        wxXML_CDATA_SECTION_NODE name="" content="content"
+    wxString GetNodeContent(wxXmlNode *node);
+
+    // Check to see if a param exists
+    bool HasParam(const wxString& param);
+
+    // Finds the node or returns NULL
+    wxXmlNode *GetParamNode(const wxString& param);
+    wxString GetParamValue(const wxString& param);
+
+    // Add style flag (e.g. wxMB_DOCKABLE) to list of flags
+    // understood by this handler
+    void AddStyle(const wxString& name, int value);
+
+    // Add styles common to all wxWindow-derived classes
+    void AddWindowStyles();
+
+    // Gets style flags from text in form "flag | flag2| flag3 |..."
+    // Only understads flags added with AddStyle
+    int GetStyle(const wxString& param = wxT("style"), int defaults = 0);
+
+    // Gets text from param and does some convertions:
+    // - replaces \n, \r, \t by respective chars (according to C syntax)
+    // - replaces $ by & and $$ by $ (needed for $File => &File because of XML)
+    // - calls wxGetTranslations (unless disabled in wxXmlResource)
+    wxString GetText(const wxString& param);
+
+    // Return XMLID
+    int GetID();
+    wxString GetName();
+
+    // Get bool flag (1,t,yes,on,true are TRUE, everything else is FALSE)
+    bool GetBool(const wxString& param, bool defaultv = FALSE);
+
+    // Get integer value from param
+    long GetLong( const wxString& param, long defaultv = 0 );
+
+    // Get colour in HTML syntax (#RRGGBB)
+    wxColour GetColour(const wxString& param);
+
+    // Get size/position (may be in dlg units):
+    wxSize GetSize(const wxString& param = wxT("size"));
+    wxPoint GetPosition(const wxString& param = wxT("pos"));
+
+    // Get dimension (may be in dlg units):
+    wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0);
+
+    // Get bitmap:
+    wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
+                       wxSize size = wxDefaultSize);
+    wxIcon GetIcon(const wxString& param = wxT("icon"),
+                   wxSize size = wxDefaultSize);
+
+    // Get font:
+    wxFont GetFont(const wxString& param = wxT("font"));
+
+    // Sets common window options:
+    void SetupWindow(wxWindow *wnd);
+
+    void CreateChildren(wxObject *parent, bool this_hnd_only = FALSE);
+    void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = NULL);
+    wxObject *CreateResFromNode(wxXmlNode *node,
+                                wxObject *parent, wxObject *instance = NULL)
+        { return m_resource->CreateResFromNode(node, parent, instance); }
+
+    // helper
+    wxFileSystem& GetCurFileSystem() { return m_resource->GetCurFileSystem(); }
+};
+
+#define ADD_STYLE(style) AddStyle(wxT(#style), style)
+
+
+void wxXmlInitResourceModule();
+
+#endif // _WX_XMLRES_H_