Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removed XRC library from contrib

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@29320 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Václav Slavík
2004-09-24 15:36:11 +00:00
parent cab1a6053d
commit 2b2ba79b25
111 changed files with 2 additions and 15925 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
contrib/include/wx/xrc/xh_all.h
View File

@@ -1,55 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_tglbtn.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_gdctl.h"
#include "wx/xrc/xh_frame.h"
#include "wx/xrc/xh_scwin.h"
#include "wx/xrc/xh_split.h"
#include "wx/xrc/xh_wizrd.h"
#include "wx/xrc/xh_statbar.h"
#endif // _WX_XMLRES_H_

40
contrib/include/wx/xrc/xh_bmp.h
View File

@@ -1,40 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_bmp.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxBitmapXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxBitmapXmlHandler)
public:
wxBitmapXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
class WXDLLIMPEXP_XRC wxIconXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxIconXmlHandler)
public:
wxIconXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_BMP_H_

31
contrib/include/wx/xrc/xh_bmpbt.h
View File

@@ -1,31 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_bmpbt.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxBitmapButtonXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxBitmapButtonXmlHandler)
public:
wxBitmapButtonXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_BMPBT_H_

30
contrib/include/wx/xrc/xh_bttn.h
View File

@@ -1,30 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_bttn.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxButtonXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxButtonXmlHandler)
public:
wxButtonXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_BTTN_H_

30
contrib/include/wx/xrc/xh_cald.h
View File

@@ -1,30 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_cald.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxCalendarCtrlXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxCalendarCtrlXmlHandler)
public:
wxCalendarCtrlXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_CALD_H_

36
contrib/include/wx/xrc/xh_chckb.h
View File

@@ -1,36 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_chckb.h"
#endif
#include "wx/xrc/xmlres.h"
#include "wx/defs.h"
#if wxUSE_CHECKBOX
class WXDLLIMPEXP_XRC wxCheckBoxXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxCheckBoxXmlHandler)
public:
wxCheckBoxXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif
#endif // _WX_XH_CHECKBOX_H_

34
contrib/include/wx/xrc/xh_chckl.h
View File

@@ -1,34 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_chckl.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxCheckListBoxXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxCheckListBoxXmlHandler)
public:
wxCheckListBoxXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
private:
bool m_insideBox;
wxArrayString strList;
};
#endif // _WX_XH_CHECKLIST_H_

33
contrib/include/wx/xrc/xh_choic.h
View File

@@ -1,33 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_choic.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxChoiceXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxChoiceXmlHandler)
public:
wxChoiceXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
private:
bool m_insideBox;
wxArrayString strList;
};
#endif // _WX_XH_CHOIC_H_

36
contrib/include/wx/xrc/xh_combo.h
View File

@@ -1,36 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_combo.h"
#endif
#include "wx/xrc/xmlres.h"
#if wxUSE_COMBOBOX
class WXDLLIMPEXP_XRC wxComboBoxXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxComboBoxXmlHandler)
public:
wxComboBoxXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
private:
bool m_insideBox;
wxArrayString strList;
};
#endif
#endif // _WX_XH_COMBO_H_

30
contrib/include/wx/xrc/xh_dlg.h
View File

@@ -1,30 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_dlg.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxDialogXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxDialogXmlHandler)
public:
wxDialogXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_DLG_H_

30
contrib/include/wx/xrc/xh_frame.h
View File

@@ -1,30 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_frame.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxFrameXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxFrameXmlHandler)
public:
wxFrameXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_FRAME_H_

41
contrib/include/wx/xrc/xh_gauge.h
View File

@@ -1,41 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_gauge.h"
#endif
#include "wx/defs.h"
#if wxUSE_GAUGE
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxGaugeXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxGaugeXmlHandler)
enum
{
wxGAUGE_DEFAULT_RANGE = 100
};
public:
wxGaugeXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif
#endif // _WX_XH_GAUGE_H_

33
contrib/include/wx/xrc/xh_gdctl.h
View File

@@ -1,33 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: xh_gdctl.h
// Purpose: XML resource handler for wxGenericDirCtrl
// Author: Markus Greither
// Created: 2002/01/20
// RCS-ID: $Id$
// Copyright: (c) 2002 Markus Greither
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_GDCTL_H_
#define _WX_XH_GDCTL_H_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_gdctl.h"
#endif
#include "wx/xrc/xmlres.h"
#if wxUSE_DIRDLG
class WXDLLIMPEXP_XRC wxGenericDirCtrlXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxGenericDirCtrlXmlHandler)
public:
wxGenericDirCtrlXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif
#endif // _WX_XH_GDCTL_H_

35
contrib/include/wx/xrc/xh_html.h
View File

@@ -1,35 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_html.h"
#endif
#include "wx/xrc/xmlres.h"
#include "wx/defs.h"
#if wxUSE_HTML
class WXDLLIMPEXP_XRC wxHtmlWindowXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxHtmlWindowXmlHandler)
public:
wxHtmlWindowXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif
#endif // _WX_XH_SLIDER_H_

36
contrib/include/wx/xrc/xh_listb.h
View File

@@ -1,36 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_listb.h"
#endif
#include "wx/xrc/xmlres.h"
#if wxUSE_LISTBOX
class WXDLLIMPEXP_XRC wxListBoxXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxListBoxXmlHandler)
public:
wxListBoxXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
private:
bool m_insideBox;
wxArrayString strList;
};
#endif
#endif // _WX_XH_LISTB_H_

30
contrib/include/wx/xrc/xh_listc.h
View File

@@ -1,30 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_listc.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxListCtrlXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxListCtrlXmlHandler)
public:
wxListCtrlXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_LISTC_H_

42
contrib/include/wx/xrc/xh_menu.h
View File

@@ -1,42 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_menu.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxMenuXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxMenuXmlHandler)
public:
wxMenuXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
private:
bool m_insideMenu;
};
class WXDLLIMPEXP_XRC wxMenuBarXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxMenuBarXmlHandler)
public:
wxMenuBarXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_MENU_H_

38
contrib/include/wx/xrc/xh_notbk.h
View File

@@ -1,38 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_notbk.h"
#endif
#include "wx/xrc/xmlres.h"
#if wxUSE_NOTEBOOK
class WXDLLEXPORT wxNotebook;
class WXDLLIMPEXP_XRC wxNotebookXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxNotebookXmlHandler)
public:
wxNotebookXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
private:
bool m_isInside;
wxNotebook *m_notebook;
};
#endif
#endif // _WX_XH_NOTBK_H_

30
contrib/include/wx/xrc/xh_panel.h
View File

@@ -1,30 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_panel.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxPanelXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxPanelXmlHandler)
public:
wxPanelXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_PANEL_H_

34
contrib/include/wx/xrc/xh_radbt.h
View File

@@ -1,34 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_radbt.h"
#endif
#include "wx/xrc/xmlres.h"
#include "wx/defs.h"
#if wxUSE_RADIOBOX
class WXDLLIMPEXP_XRC wxRadioButtonXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxRadioButtonXmlHandler)
public:
wxRadioButtonXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif
#endif // _WX_XH_RADIOBUTTON_H_

36
contrib/include/wx/xrc/xh_radbx.h
View File

@@ -1,36 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_radbx.h"
#endif
#include "wx/xrc/xmlres.h"
#if wxUSE_RADIOBOX
class WXDLLIMPEXP_XRC wxRadioBoxXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxRadioBoxXmlHandler)
public:
wxRadioBoxXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
private:
bool m_insideBox;
wxArrayString strList;
};
#endif
#endif // _WX_XH_RADBX_H_

40
contrib/include/wx/xrc/xh_scrol.h
View File

@@ -1,40 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_scrol.h"
#endif
#include "wx/xrc/xmlres.h"
#include "wx/defs.h"
class WXDLLIMPEXP_XRC wxScrollBarXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxScrollBarXmlHandler)
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_

33
contrib/include/wx/xrc/xh_scwin.h
View File

@@ -1,33 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: xh_scwin.h
// Purpose: XML resource handler for wxScrolledWindow
// Author: Vaclav Slavik
// Created: 2002/10/18
// RCS-ID: $Id$
// Copyright: (c) 2002 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_SCWIN_H_
#define _WX_XH_SCWIN_H_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_scwin.h"
#endif
#include "wx/xrc/xmlres.h"
#include "wx/defs.h"
class WXDLLIMPEXP_XRC wxScrolledWindowXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxScrolledWindowXmlHandler)
public:
wxScrolledWindowXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_SCWIN_H_

59
contrib/include/wx/xrc/xh_sizer.h
View File

@@ -1,59 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_sizer.h"
#endif
#include "wx/xrc/xmlres.h"
#include "wx/sizer.h"
#include "wx/gbsizer.h"
class WXDLLEXPORT wxSizer;
class WXDLLIMPEXP_XRC wxSizerXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxSizerXmlHandler)
public:
wxSizerXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
private:
bool m_isInside;
bool m_isGBS;
wxSizer *m_parentSizer;
bool IsSizerNode(wxXmlNode *node);
wxObject* Handle_sizeritem();
wxObject* Handle_spacer();
wxObject* Handle_sizer();
wxSizer* Handle_wxBoxSizer();
wxSizer* Handle_wxStaticBoxSizer();
wxSizer* Handle_wxGridSizer();
wxSizer* Handle_wxFlexGridSizer();
wxSizer* Handle_wxGridBagSizer();
void SetGrowables(wxFlexGridSizer* fsizer, const wxChar* param, bool rows);
wxGBPosition GetGBPos(const wxString& param);
wxGBSpan GetGBSpan(const wxString& param);
wxSizerItem* MakeSizerItem();
void SetSizerItemAttributes(wxSizerItem* sitem);
void AddSizerItem(wxSizerItem* sitem);
};
#endif // _WX_XH_BOXSIZER_H_

41
contrib/include/wx/xrc/xh_slidr.h
View File

@@ -1,41 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_slidr.h"
#endif
#include "wx/xrc/xmlres.h"
#include "wx/defs.h"
#if wxUSE_SLIDER
class WXDLLIMPEXP_XRC wxSliderXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxSliderXmlHandler)
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_

57
contrib/include/wx/xrc/xh_spin.h
View File

@@ -1,57 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_spin.h"
#endif
#include "wx/xrc/xmlres.h"
#include "wx/defs.h"
#if wxUSE_SPINBTN
class WXDLLIMPEXP_XRC wxSpinButtonXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxSpinButtonXmlHandler)
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 WXDLLIMPEXP_XRC wxSpinCtrlXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxSpinCtrlXmlHandler)
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_

29
contrib/include/wx/xrc/xh_split.h
View File

@@ -1,29 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: xh_split.h
// Purpose: XRC resource for wxSplitterWindow
// Author: panga@freemail.hu, Vaclav Slavik
// Created: 2003/01/26
// RCS-ID: $Id$
// Copyright: (c) 2003 panga@freemail.hu, Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_SPLIT_H_
#define _WX_XH_SPLIT_H_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_split.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxSplitterWindowXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxSplitterWindowXmlHandler)
public:
wxSplitterWindowXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_SPLIT_H_

30
contrib/include/wx/xrc/xh_statbar.h
View File

@@ -1,30 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: xh_statbar.h
// Purpose: XML resource handler for wxStatusBar
// Author: Brian Ravnsgaard Riis
// Created: 2004/01/21
// RCS-ID:
// Copyright: (c) 2004 Brian Ravnsgaard Riis
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_STATBAR_H_
#define _WX_XH_STATBAR_H_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_statbar.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxStatusBarXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxStatusBarXmlHandler)
public:
wxStatusBarXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_STATBAR_H_

31
contrib/include/wx/xrc/xh_stbmp.h
View File

@@ -1,31 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_stbmp.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxStaticBitmapXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxStaticBitmapXmlHandler)
public:
wxStaticBitmapXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_STBMP_H_

31
contrib/include/wx/xrc/xh_stbox.h
View File

@@ -1,31 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_stbox.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxStaticBoxXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxStaticBoxXmlHandler)
public:
wxStaticBoxXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_STBOX_H_

33
contrib/include/wx/xrc/xh_stlin.h
View File

@@ -1,33 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_stlin.h"
#endif
#include "wx/xrc/xmlres.h"
#if wxUSE_STATLINE
class WXDLLIMPEXP_XRC wxStaticLineXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxStaticLineXmlHandler)
public:
wxStaticLineXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif
#endif // _WX_XH_STLIN_H_

31
contrib/include/wx/xrc/xh_sttxt.h
View File

@@ -1,31 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_sttxt.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxStaticTextXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxStaticTextXmlHandler)
public:
wxStaticTextXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_STBMP_H_

31
contrib/include/wx/xrc/xh_text.h
View File

@@ -1,31 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_text.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxTextCtrlXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxTextCtrlXmlHandler)
public:
wxTextCtrlXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_TEXT_H_

36
contrib/include/wx/xrc/xh_tglbtn.h
View File

@@ -1,36 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: xh_tglbtn.h
// Purpose: XML resource handler for wxToggleButton
// Author: Julian Smart
// Created: 2004-08-30
// RCS-ID: $Id$
// Copyright: (c) 2004 Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_TGLBTN_H_
#define _WX_XH_TGLBTN_H_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_tglbtn.h"
#endif
#include "wx/xrc/xmlres.h"
#include "wx/defs.h"
#if wxUSE_TOGGLEBTN
class WXDLLIMPEXP_XRC wxToggleButtonXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxToggleButtonXmlHandler)
public:
wxToggleButtonXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif
#endif // _WX_XH_TGLBTN_H_

39
contrib/include/wx/xrc/xh_toolb.h
View File

@@ -1,39 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_toolb.h"
#endif
#include "wx/xrc/xmlres.h"
#if wxUSE_TOOLBAR
class WXDLLEXPORT wxToolBar;
class WXDLLIMPEXP_XRC wxToolBarXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxToolBarXmlHandler)
public:
wxToolBarXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
private:
bool m_isInside;
wxToolBar *m_toolbar;
};
#endif
#endif // _WX_XH_TOOLBAR_H_

30
contrib/include/wx/xrc/xh_tree.h
View File

@@ -1,30 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_tree.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxTreeCtrlXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxTreeCtrlXmlHandler)
public:
wxTreeCtrlXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_TREE_H_

31
contrib/include/wx/xrc/xh_unkwn.h
View File

@@ -1,31 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_unkwn.h"
#endif
#include "wx/xrc/xmlres.h"
class WXDLLIMPEXP_XRC wxUnknownWidgetXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxUnknownWidgetXmlHandler)
public:
wxUnknownWidgetXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
};
#endif // _WX_XH_UNKWN_H_

39
contrib/include/wx/xrc/xh_wizrd.h
View File

@@ -1,39 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: xh_wizrd.h
// Purpose: XML resource handler for wxWizard
// Author: Vaclav Slavik
// Created: 2003/03/02
// RCS-ID: $Id$
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_WIZRD_H_
#define _WX_XH_WIZRDL_H_
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "xh_wizrd.h"
#endif
#include "wx/xrc/xmlres.h"
#if wxUSE_WIZARDDLG
#include "wx/wizard.h"
class WXDLLIMPEXP_XRC wxWizardXmlHandler : public wxXmlResourceHandler
{
DECLARE_DYNAMIC_CLASS(wxWizardXmlHandler)
public:
wxWizardXmlHandler();
virtual wxObject *DoCreateResource();
virtual bool CanHandle(wxXmlNode *node);
private:
wxWizard *m_wizard;
wxWizardPageSimple *m_lastSimplePage;
};
#endif
#endif // _WX_XH_PANEL_H_

493
contrib/include/wx/xrc/xmlres.h
View File

@@ -1,493 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// 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_
#if defined(__GNUG__) && !defined(__APPLE__)
#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/artprov.h"
#include "wx/xml/xml.h"
#ifdef WXMAKINGDLL_XRC
#define WXDLLIMPEXP_XRC WXEXPORT
#elif defined(WXUSINGDLL)
#define WXDLLIMPEXP_XRC WXIMPORT
#else // not making nor using DLL
#define WXDLLIMPEXP_XRC
#endif
class WXDLLEXPORT wxMenu;
class WXDLLEXPORT wxMenuBar;
class WXDLLEXPORT wxDialog;
class WXDLLEXPORT wxPanel;
class WXDLLEXPORT wxWindow;
class WXDLLEXPORT wxFrame;
class WXDLLEXPORT wxToolBar;
class WXDLLIMPEXP_XRC wxXmlResourceHandler;
class WXDLLIMPEXP_XRC wxXmlSubclassFactory;
class WXDLLIMPEXP_XRC wxXmlSubclassFactoriesList;
class wxXmlResourceModule;
// 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 wxWidgets 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 _T("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 WXDLLIMPEXP_XRC wxXmlResourceDataRecord
{
public:
wxXmlResourceDataRecord() : Doc(NULL), Time(wxDateTime::Now()) {}
~wxXmlResourceDataRecord() {delete Doc;}
wxString File;
wxXmlDocument *Doc;
wxDateTime Time;
};
WX_DECLARE_USER_EXPORTED_OBJARRAY(wxXmlResourceDataRecord,
wxXmlResourceDataRecords,
WXDLLIMPEXP_XRC);
enum wxXmlResourceFlags
{
wxXRC_USE_LOCALE = 1,
wxXRC_NO_SUBCLASSING = 2,
wxXRC_NO_RELOADING = 4
};
// This class holds XML resources from one or more .xml files
// (or derived forms, either binary or zipped -- see manual for
// details).
class WXDLLIMPEXP_XRC wxXmlResource : public wxObject
{
public:
// Constructor.
// Flags: wxXRC_USE_LOCALE
// translatable strings will be translated via _()
// wxXRC_NO_SUBCLASSING
// subclass property of object nodes will be ignored
// (useful for previews in XRC editors)
wxXmlResource(int flags = wxXRC_USE_LOCALE);
// Constructor.
// Flags: wxXRC_USE_LOCALE
// translatable strings will be translated via _()
// wxXRC_NO_SUBCLASSING
// subclass property of object nodes will be ignored
// (useful for previews in XRC editors)
wxXmlResource(const wxString& filemask, int flags = wxXRC_USE_LOCALE);
// Destructor.
~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 the wxWidgets library.
void InitAllHandlers();
// Initialize only a specific handler (or custom handler). Convention says
// that handler name is equal to the control's name plus 'XmlHandler', for
// example wxTextCtrlXmlHandler, wxHtmlWindowXmlHandler. The XML resource
// compiler (xmlres) can create include file that contains initialization
// code for all controls used within the resource.
void AddHandler(wxXmlResourceHandler *handler);
// Add a new handler at the begining of the handler list
void InsertHandler(wxXmlResourceHandler *handler);
// Removes all handlers
void ClearHandlers();
// Registers subclasses factory for use in XRC. This function is not meant
// for public use, please see the comment above wxXmlSubclassFactory
// definition.
static void AddSubclassFactory(wxXmlSubclassFactory *factory);
// Loads menu from resource. Returns NULL on failure.
wxMenu *LoadMenu(const wxString& name);
// Loads menubar from resource. Returns NULL on failure.
wxMenuBar *LoadMenuBar(wxWindow *parent, const wxString& name);
// Loads menubar from resource. Returns NULL on failure.
wxMenuBar *LoadMenuBar(const wxString& name) { return LoadMenuBar(NULL, name); }
#if wxUSE_TOOLBAR
// Loads a toolbar.
wxToolBar *LoadToolBar(wxWindow *parent, const wxString& name);
#endif
// Loads a dialog. dlg points to parent window (if any).
wxDialog *LoadDialog(wxWindow *parent, const wxString& name);
// Loads a dialog. dlg points to parent window (if any). This 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();
bool LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name);
// Loads a panel. panel points to parent window (if any).
wxPanel *LoadPanel(wxWindow *parent, const wxString& name);
// Loads a panel. panel points to parent window (if any). This form
// is used to finish creation of already existing instance.
bool LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name);
// Loads a frame.
wxFrame *LoadFrame(wxWindow* parent, const wxString& name);
bool LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name);
// Load an object from the resource specifying both the resource name and
// the classname. This lets you load nonstandard container windows.
wxObject *LoadObject(wxWindow *parent, const wxString& name,
const wxString& classname);
// Load an object from the resource specifying both the resource name and
// the classname. This form lets you finish the creation of an existing
// instance.
bool LoadObject(wxObject *instance, wxWindow *parent, const wxString& name,
const wxString& classname);
// Loads a bitmap resource from a file.
wxBitmap LoadBitmap(const wxString& name);
// Loads an icon resource from a file.
wxIcon LoadIcon(const wxString& name);
// Attaches an unknown control to the 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 a numeric ID that is equivalent to the string id used in an XML
// resource. To be used in event tables.
// Macro XRCID is provided for convenience
static int GetXRCID(const wxChar *str_id);
// Returns version information (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); }
//// Singleton accessors.
// Gets the global resources object or creates one if none exists.
static wxXmlResource *Get();
// Sets the global resources object and returns a pointer to the previous one (may be NULL).
static wxXmlResource *Set(wxXmlResource *res);
// Returns flags, which may be a bitlist of wxXRC_USE_LOCALE and wxXRC_NO_SUBCLASSING.
int GetFlags() const { return m_flags; }
// Set flags after construction.
void SetFlags(int flags) { m_flags = flags; }
protected:
// Scans the resources list for unloaded files and loads them. Also reloads
// files that have been modified since last loading.
bool UpdateResources();
// Finds a resource (calls UpdateResources) and returns a node containing it.
wxXmlNode *FindResource(const wxString& name, const wxString& classname, bool recursive = false);
// Helper function: finds a resource (calls UpdateResources) and returns a node containing it.
wxXmlNode *DoFindResource(wxXmlNode *parent, const wxString& name, const wxString& classname, bool recursive);
// Creates a resource from information in the given node
// (Uses only 'handlerToUse' if != NULL)
wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent,
wxObject *instance = NULL,
wxXmlResourceHandler *handlerToUse = NULL);
private:
long m_version;
int m_flags;
wxList m_handlers;
wxXmlResourceDataRecords m_data;
#if wxUSE_FILESYSTEM
wxFileSystem m_curFileSystem;
wxFileSystem& GetCurFileSystem() { return m_curFileSystem; }
#endif
friend class wxXmlResourceHandler;
friend class wxXmlResourceModule;
static wxXmlSubclassFactoriesList *ms_subclassFactories;
// singleton instance:
static wxXmlResource *ms_instance;
};
// This macro translates string identifier (as used in XML resource,
// e.g. <menuitem id="my_menu">...</menuitem>) to integer id that is needed by
// wxWidgets event tables.
// Example:
// BEGIN_EVENT_TABLE(MyFrame, wxFrame)
// EVT_MENU(XRCID("quit"), MyFrame::OnQuit)
// EVT_MENU(XRCID("about"), MyFrame::OnAbout)
// EVT_MENU(XRCID("new"), MyFrame::OnNew)
// EVT_MENU(XRCID("open"), MyFrame::OnOpen)
// END_EVENT_TABLE()
#define XRCID(str_id) \
wxXmlResource::GetXRCID(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;
// wxXmlResource::Get()->LoadDialog(&dlg, mainFrame, "my_dialog");
// XRCCTRL(dlg, "my_textctrl", wxTextCtrl)->SetValue(wxT("default value"));
#ifdef __WXDEBUG__
#define XRCCTRL(window, id, type) \
(wxDynamicCast((window).FindWindow(XRCID(id)), type))
#else
#define XRCCTRL(window, id, type) \
((type*)((window).FindWindow(XRCID(id))))
#endif
// wxXmlResourceHandler is an abstract base class for resource handlers
// capable of creating a control from an XML node.
class WXDLLIMPEXP_XRC wxXmlResourceHandler : public wxObject
{
DECLARE_ABSTRACT_CLASS(wxXmlResourceHandler)
public:
// Constructor.
wxXmlResourceHandler();
// Destructor.
virtual ~wxXmlResourceHandler() {}
// Creates an object (menu, dialog, control, ...) from an XML node.
// Should check for validity.
// parent is a higher-level object (usually window, dialog or panel)
// that is often neccessary to create the resource.
// If instance is non-NULL it should not create a new instance via 'new' but
// should 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
// a resource from it, false otherwise.
virtual bool CanHandle(wxXmlNode *node) = 0;
// Sets the parent resource.
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 a 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 parameter exists.
bool HasParam(const wxString& param);
// Finds the node or returns NULL.
wxXmlNode *GetParamNode(const wxString& param);
// Finds the parameter value or returns the empty string.
wxString GetParamValue(const wxString& param);
// Add a style flag (e.g. wxMB_DOCKABLE) to the 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 conversions:
// - 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, bool translate = true);
// Returns the XRCID.
int GetID();
// Returns the resource name.
wxString GetName();
// Gets a bool flag (1, t, yes, on, true are true, everything else is false).
bool GetBool(const wxString& param, bool defaultv = false);
// Gets the integer value from the parameter.
long GetLong( const wxString& param, long defaultv = 0 );
// Gets colour in HTML syntax (#RRGGBB).
wxColour GetColour(const wxString& param);
// Gets the size (may be in dialog units).
wxSize GetSize(const wxString& param = wxT("size"));
// Gets the position (may be in dialog units).
wxPoint GetPosition(const wxString& param = wxT("pos"));
// Gets a dimension (may be in dialog units).
wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0);
// Gets a bitmap.
wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize);
// Gets an icon.
wxIcon GetIcon(const wxString& param = wxT("icon"),
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize);
// Gets a font.
wxFont GetFont(const wxString& param = wxT("font"));
// Sets common window options.
void SetupWindow(wxWindow *wnd);
// Creates children.
void CreateChildren(wxObject *parent, bool this_hnd_only = false);
// Helper function.
void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = NULL);
// Creates a resource from a node.
wxObject *CreateResFromNode(wxXmlNode *node,
wxObject *parent, wxObject *instance = NULL)
{ return m_resource->CreateResFromNode(node, parent, instance); }
// helper
#if wxUSE_FILESYSTEM
wxFileSystem& GetCurFileSystem() { return m_resource->GetCurFileSystem(); }
#endif
};
// Programmer-friendly macros for writing XRC handlers:
#define XRC_ADD_STYLE(style) AddStyle(wxT(#style), style)
#define XRC_MAKE_INSTANCE(variable, classname) \
classname *variable = NULL; \
if (m_instance) \
variable = wxStaticCast(m_instance, classname); \
if (!variable) \
variable = new classname;
// FIXME -- remove this $%^#$%#$@# as soon as Ron checks his changes in!!
WXDLLIMPEXP_XRC void wxXmlInitResourceModule();
// This class is used to create instances of XRC "object" nodes with "subclass"
// property. It is _not_ supposed to be used by XRC users, you should instead
// register your subclasses via wxWidgets' RTTI mechanism. This class is useful
// only for language bindings developer who need a way to implement subclassing
// in wxWidgets ports that don't support wxRTTI (e.g. wxPython).
class WXDLLIMPEXP_XRC wxXmlSubclassFactory
{
public:
// Try to create instance of given class and return it, return NULL on
// failure:
virtual wxObject *Create(const wxString& className) = 0;
virtual ~wxXmlSubclassFactory() {}
};
/* -------------------------------------------------------------------------
Backward compatibility macros. Do *NOT* use, they may disappear in future
versions of the XRC library!
------------------------------------------------------------------------- */
#if WXWIN_COMPATIBILITY_2_4
#define ADD_STYLE XRC_ADD_STYLE
#define wxTheXmlResource wxXmlResource::Get()
#define XMLID XRCID
#define XMLCTRL XRCCTRL
#define GetXMLID GetXRCID
#endif
#endif // _WX_XMLRES_H_