[wxWidgets.git] / utils / dialoged / src / reseditr.h

/////////////////////////////////////////////////////////////////////////////
// Name:        reseditr.h
// Purpose:     Resource editor class
// Author:      Julian Smart
// Modified by:
// Created:     04/01/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:   	wxWindows license
/////////////////////////////////////////////////////////////////////////////

#ifndef _RESEDITR_H_
#define _RESEDITR_H_

#define wxDIALOG_EDITOR_VERSION 2.1

#ifdef __GNUG__
#pragma interface "reseditr.h"
#endif

#include "wx/wx.h"
#include "wx/string.h"
#include "wx/layout.h"
#include "wx/resource.h"
#include "wx/toolbar.h"
#include "wx/imaglist.h"
#include "wx/treectrl.h"
#include "wx/proplist.h"
#include "wx/txtstrm.h"
#include "symbtabl.h"
#include "winstyle.h"

#define RESED_DELETE            301
#define RESED_RECREATE          303
#define RESED_CLEAR             304
#define RESED_NEW_DIALOG        305
#define RESED_NEW_PANEL         306
#define RESED_TEST              310
#define RESED_CONVERT_WXRS      311 // Convert old WXRs to new

#define RESED_CONTENTS          320

#define IDC_TREECTRL            500
#define IDC_LISTCTRL            501

// For control list ('palette')
#define RESED_POINTER           0
#define RESED_BUTTON            1
#define RESED_BMPBUTTON         2
#define RESED_STATICTEXT        3
#define RESED_STATICBMP         4
#define RESED_STATICBOX         5
#define RESED_TEXTCTRL_SINGLE   6
#define RESED_TEXTCTRL_MULTIPLE 7
#define RESED_LISTBOX           8
#define RESED_CHOICE            9
#define RESED_COMBOBOX          10
#define RESED_CHECKBOX          11
#define RESED_SLIDER            12
#define RESED_GAUGE             13
#define RESED_RADIOBOX          14
#define RESED_RADIOBUTTON       15
#define RESED_SCROLLBAR         16
#define RESED_TREECTRL          17
#define RESED_LISTCTRL          18
#define RESED_SPINBUTTON        19

/*
* Controls loading, saving, user interface of resource editor(s).
*/

class wxResourceEditorFrame;
class EditorToolBar;
class wxWindowPropertyInfo;
class wxResourceEditorProjectTree;
class wxResourceEditorControlList;

#ifdef __WXMSW__
#define wxHelpController wxWinHelpController
#else
#define wxHelpController wxHTMLHelpController;
#endif

class wxHelpController;

/*
* The resourceTable contains a list of wxItemResources (which each may
* have further children, defining e.g. a dialog box with controls).
*
* We need to associate actual windows with each wxItemResource,
* instead of the current 'one current window' scheme.
*
*  - We create a new dialog, create a wxItemResource,
*    associate the dialog with wxItemResource via a hash table.
*    Must be a hash table in case dialog is deleted without
*    telling the resource manager.
*  - When we save the resource after editing/closing the dialog,
*    we check the wxItemResource/wxDialog and children for
*    consistency (throw away items no longer in the wxDialog,
*    create any new wxItemResources).
*  - We save the wxItemResources via the wxPropertyInfo classes,
*    so devolve the code to the appropriate class.
*    This involves creating a new temporary wxPropertyInfo for
*    the purpose.
*
* We currently assume we only create one instance of a window for
* each wxItemResource. We will need to relax this when we're editing
* in situ.
*
*
*/

class wxResourceTableWithSaving: public wxResourceTable
{
public:
    wxResourceTableWithSaving():wxResourceTable()
    {
        // Add all known window styles
        m_styleTable.Init();
    }
    virtual bool Save(const wxString& filename);
    virtual bool SaveResource(wxTextOutputStream& stream, wxItemResource* item, wxItemResource* parentItem);
    
    void GeneratePanelStyleString(long windowStyle, char *buf);
    void GenerateDialogStyleString(long windowStyle, char *buf);
    
    void GenerateControlStyleString(const wxString& windowClass, long windowStyle, char *buf);
    
    void OutputFont(wxTextOutputStream& stream, const wxFont& font);
    wxControl *CreateItem(wxPanel *panel, const wxItemResource *childResource, const wxItemResource* parentResource);
    
protected:
    wxWindowStyleTable    m_styleTable;
};

class wxResourceEditorScrolledWindow;

class wxResourceManager: public wxObject
{
    friend class wxResourceEditorFrame;
    
public:
    wxResourceManager();
    ~wxResourceManager();
    
    // Operations
    
    // Initializes the resource manager
    bool Initialize();
    
    // Load/save window size etc.
    bool LoadOptions();
    bool SaveOptions();
    
    // Show or hide the resource editor frame, which displays a list
    // of resources with ability to edit them.
    virtual bool ShowResourceEditor(bool show, wxWindow *parent = NULL, const char *title = "wxWindows Dialog Editor");
    
    // Convert old WXRs to new
    virtual bool ConvertWXRs();
    bool DoConvertWXR(const wxString& oldPath, const wxString& newPath);
    bool ChangeOldToNewResource(wxItemResource* parent, wxItemResource* res);
    bool InsertLabelResource(wxItemResource* parent, wxItemResource* res);

    virtual bool Save();
    virtual bool SaveAs();
    virtual bool Save(const wxString& filename);
    virtual bool Load(const wxString& filename);
    virtual bool Clear(bool deleteWindows = TRUE, bool force = TRUE);
    virtual void SetFrameTitle(const wxString& filename);
    virtual void ClearCurrentDialog();
    virtual bool New(bool loadFromFile = TRUE, const wxString& filename = "");
    virtual bool SaveIfModified();
    virtual void AlignItems(int flag);
    virtual void CopySize(int command); // Copy width, height or both from first control
    virtual void ToBackOrFront(bool toBack);
    virtual void DistributePositions(int command); // Distribute controls evenly between first and last
    virtual wxWindow *FindParentOfSelection();
    
    virtual wxFrame *OnCreateEditorFrame(const char *title);
    virtual wxMenuBar *OnCreateEditorMenuBar(wxFrame *parent);
    virtual wxResourceEditorScrolledWindow *OnCreateEditorPanel(wxFrame *parent);
    virtual wxToolBar *OnCreateToolBar(wxFrame *parent);
    
    // Create a window information object for the give window
    wxWindowPropertyInfo* CreatePropertyInfoForWindow(wxWindow *win);
    // Edit the given window
    void EditWindow(wxWindow *win);
    
    virtual void UpdateResourceList();
    virtual void AddItemsRecursively(long parent, wxItemResource *resource);
    virtual bool EditSelectedResource();
    virtual bool Edit(wxItemResource *res);
    virtual bool CreateNewPanel();
    virtual bool CreatePanelItem(wxItemResource *panelResource, wxPanel *panel, char *itemType, int x = 10, int y = 10, bool isBitmap = FALSE);
    virtual bool DeleteSelection();
    virtual bool TestCurrentDialog(wxWindow* parent);
    
    // Saves the window info into the resource, and deletes the
    // handler. Doesn't actually disassociate the window from
    // the resources. Replaces OnClose.
    virtual bool SaveInfoAndDeleteHandler(wxWindow* win);
    
    // Destroys the window. If this is the 'current' panel, NULLs the
    // variable.
    virtual bool DeleteWindow(wxWindow* win);
    virtual bool DeleteResource(wxItemResource *res);
    virtual bool DeleteResource(wxWindow *win);
    
    // Add bitmap resource if there isn't already one with this filename.
    virtual wxString AddBitmapResource(const wxString& filename);
    
    // Delete the bitmap resource if it isn't being used by another resource.
    virtual void PossiblyDeleteBitmapResource(const wxString& resourceName);
    
    // Helper function for above
    virtual bool IsBitmapResourceUsed(const wxString& resourceName);
    
    wxItemResource *FindBitmapResourceByFilename(const wxString& filename);
    
    wxString FindBitmapFilenameForResource(wxItemResource *resource);
    
    // Is this window identifier in use?
    bool IsSymbolUsed(wxItemResource* thisResource, wxWindowID id) ;
    
    // Is this window identifier compatible with the given name? (i.e.
    // does it already exist under a different name)
    bool IsIdentifierOK(const wxString& name, wxWindowID id);
    
    // Change all integer ids that match oldId, to newId.
    // This is necessary if an id is changed for one resource - all resources
    // must be changed.
    void ChangeIds(int oldId, int newId);
    
    // If any resource ids were missing (or their symbol was missing),
    // repair them i.e. give them new ids. Returns TRUE if any resource
    // needed repairing.
    bool RepairResourceIds();
    
    // Deletes 'win' and creates a new window from the resource that
    // was associated with it. E.g. if you can't change properties on the
    // fly, you'll need to delete the window and create it again.
    virtual wxWindow *RecreateWindowFromResource(wxWindow *win, wxWindowPropertyInfo *info = NULL, bool instantiateFirst = TRUE);
    
    virtual bool RecreateSelection();
    
    // Remove selection handles if this control is selected
    void DeselectItemIfNecessary(wxWindow *win);
    
    // Need to search through resource table removing this from
    // any resource which has this as a parent.
    virtual bool RemoveResourceFromParent(wxItemResource *res);
    
    virtual bool EditDialog(wxDialog *dialog, wxWindow *parent);
    
    void AddSelection(wxWindow *win);
    void RemoveSelection(wxWindow *win);
    
    virtual void MakeUniqueName(char *prefix, char *buf);
    
    // (Dis)associate resource<->physical window
    // Doesn't delete any windows.
    virtual void AssociateResource(wxItemResource *resource, wxWindow *win);
    virtual bool DisassociateResource(wxItemResource *resource);
    virtual bool DisassociateResource(wxWindow *win);
    virtual bool DisassociateWindows();
    virtual wxItemResource *FindResourceForWindow(wxWindow *win);
    virtual wxWindow *FindWindowForResource(wxItemResource *resource);
    
    virtual bool InstantiateAllResourcesFromWindows();
    virtual bool InstantiateResourceFromWindow(wxItemResource *resource, wxWindow *window, bool recurse = FALSE);
    
    // Accessors
    inline void SetEditorFrame(wxFrame *fr) { m_editorFrame = fr; }
    inline void SetEditorToolBar(EditorToolBar *tb) { m_editorToolBar = tb; }
    inline wxFrame *GetEditorFrame() const { return m_editorFrame; }
    inline wxResourceEditorProjectTree *GetEditorResourceTree() const { return m_editorResourceTree; }
    inline wxResourceEditorControlList *GetEditorControlList() const { return m_editorControlList; }
    inline wxList& GetSelections() { return m_selections; }
    inline wxMenu *GetPopupMenu() const { return m_popupMenu; }
#ifdef __WXMSW__
    inline wxHelpController *GetHelpController() const { return m_helpController; }
#endif
    
    inline void Modify(bool mod = TRUE) { m_modified = mod; }
    inline bool Modified() const { return m_modified; }
    
    inline wxResourceTable& GetResourceTable() { return m_resourceTable; }
    inline wxHashTable& GetResourceAssociations() { return m_resourceAssociations; }
    
    inline wxString GetCurrentFilename() const { return m_currentFilename; }
    static wxResourceManager* GetCurrentResourceManager() { return sm_currentResourceManager; }
    
    inline void SetSymbolFilename(const wxString& s) { m_symbolFilename = s; }
    inline wxString GetSymbolFilename() const { return m_symbolFilename; }
    
    inline wxRect& GetPropertyWindowSize() { return m_propertyWindowSize; }
    inline wxRect& GetResourceEditorWindowSize() { return m_resourceEditorWindowSize; }
    
    wxResourceSymbolTable& GetSymbolTable() { return m_symbolTable; }
    
    // Generate a window id and a first stab at a name
    int GenerateWindowId(const wxString& prefix, wxString& idName) ;
    
    // Member variables
 protected:
#ifdef __WXMSW__
     wxHelpController*                m_helpController;
#endif
     wxResourceTableWithSaving        m_resourceTable;
     wxFrame*                         m_editorFrame;
     wxResourceEditorScrolledWindow*  m_editorPanel;
     wxMenu*                          m_popupMenu;
     wxResourceEditorProjectTree*     m_editorResourceTree;
     wxResourceEditorControlList*     m_editorControlList;
     EditorToolBar*                   m_editorToolBar;
     int                              m_nameCounter;
     int                              m_symbolIdCounter; // For generating window ids
     bool                             m_modified;
     wxHashTable                      m_resourceAssociations;
     wxList                           m_selections;
     wxString                         m_currentFilename;
     wxBitmap*                        m_bitmapImage; // Default for static bitmaps/buttons
     
     wxImageList                      m_imageList;
     long                             m_rootDialogItem; // Root of dialog hierarchy in tree (unused)
     
     // Options to be saved/restored
     wxString                         m_optionsResourceFilename; // e.g. dialoged.ini, .dialogrc
     wxRect                           m_propertyWindowSize;
     wxRect                           m_resourceEditorWindowSize;
     static wxResourceManager*        sm_currentResourceManager;
     
     // Symbol table with identifiers for controls
     wxResourceSymbolTable            m_symbolTable;
     // Filename for include file, e.g. resource.h
     wxString                         m_symbolFilename;
};


class wxResourceEditorFrame: public wxFrame
{
public:
    DECLARE_CLASS(wxResourceEditorFrame)
        
        wxResourceManager *manager;
    wxResourceEditorFrame(wxResourceManager *resMan, wxFrame *parent, const wxString& title,
        const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize(600, 400),
        long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "frame");
    ~wxResourceEditorFrame();
    
    void OnCloseWindow(wxCloseEvent& event);
    
    void OnNew(wxCommandEvent& event);
    void OnOpen(wxCommandEvent& event);
    void OnNewDialog(wxCommandEvent& event);
    void OnClear(wxCommandEvent& event);
    void OnSave(wxCommandEvent& event);
    void OnSaveAs(wxCommandEvent& event);
    void OnExit(wxCommandEvent& event);
    void OnAbout(wxCommandEvent& event);
    void OnContents(wxCommandEvent& event);
    void OnDeleteSelection(wxCommandEvent& event);
    void OnRecreateSelection(wxCommandEvent& event);
    void OnTest(wxCommandEvent& event);
    void OnConvertWXRs(wxCommandEvent& event);
    
    DECLARE_EVENT_TABLE()
};

class wxResourceEditorScrolledWindow: public wxScrolledWindow
{
public:
    wxResourceEditorScrolledWindow(wxWindow *parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
        long style = 0);
    ~wxResourceEditorScrolledWindow();
    
    void OnPaint(wxPaintEvent& event);
    
    void DrawTitle(wxDC& dc);
    
    // Accessors
    inline int GetMarginX() { return m_marginX; }
    inline int GetMarginY() { return m_marginY; }
    
public:
    wxWindow* m_childWindow;
private:
    int m_marginX, m_marginY;
    
    DECLARE_EVENT_TABLE()
};

#define OBJECT_MENU_EDIT      1
#define OBJECT_MENU_DELETE    2

/*
* Main toolbar
*
*/

class EditorToolBar: public wxToolBar
{
public:
    EditorToolBar(wxFrame *frame, const wxPoint& pos = wxPoint(0, 0), const wxSize& size = wxSize(0, 0),
        long style = wxTB_HORIZONTAL);
    bool OnLeftClick(int toolIndex, bool toggled);
    void OnMouseEnter(int toolIndex);
    
    DECLARE_EVENT_TABLE()
};

// Toolbar ids
#define TOOLBAR_LOAD_FILE                   101
#define TOOLBAR_SAVE_FILE                   102
#define TOOLBAR_NEW                         103
#define TOOLBAR_TREE                        105
#define TOOLBAR_HELP                        106

// Formatting tools
#define TOOLBAR_FORMAT_HORIZ                110
#define TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN     111
#define TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN    112
#define TOOLBAR_FORMAT_VERT                 113
#define TOOLBAR_FORMAT_VERT_TOP_ALIGN       114
#define TOOLBAR_FORMAT_VERT_BOT_ALIGN       115

#define TOOLBAR_TO_FRONT                    116
#define TOOLBAR_TO_BACK                     117
#define TOOLBAR_COPY_SIZE                   118
#define TOOLBAR_COPY_WIDTH                  119
#define TOOLBAR_COPY_HEIGHT                 120
#define TOOLBAR_DISTRIBUTE_HORIZ            121
#define TOOLBAR_DISTRIBUTE_VERT             122

/*
* this class is used to store data associated with a tree item
*/
class wxResourceTreeData : public wxTreeItemData
{
public:
    wxResourceTreeData(wxItemResource *resource) { m_resource = resource; }
    
    wxItemResource *GetResource() const { return m_resource; }
    
private:
    wxItemResource *m_resource;
};

#endif
Commit	Line	Data
457814b5 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: reseditr.h
	3	// Purpose: Resource editor class
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 04/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifndef _RESEDITR_H_
	13	#define _RESEDITR_H_
	14
f6bcfd97	15	#define wxDIALOG_EDITOR_VERSION 2.1
457814b5 JS	16
	17	#ifdef __GNUG__
	18	#pragma interface "reseditr.h"
	19	#endif
	20
	21	#include "wx/wx.h"
	22	#include "wx/string.h"
	23	#include "wx/layout.h"
	24	#include "wx/resource.h"
ae8351fc JS	25	#include "wx/toolbar.h"
ae8351fc JS	26	#include "wx/imaglist.h"
1195ec42	27	#include "wx/treectrl.h"
41c09d48	28	#include "wx/proplist.h"
e70f5e13	29	#include "wx/txtstrm.h"
03f68f12	30	#include "symbtabl.h"
bbcdf8bc	31	#include "winstyle.h"
457814b5	32
f6bcfd97 BP	33	#define RESED_DELETE 301
	34	#define RESED_RECREATE 303
	35	#define RESED_CLEAR 304
	36	#define RESED_NEW_DIALOG 305
	37	#define RESED_NEW_PANEL 306
	38	#define RESED_TEST 310
	39	#define RESED_CONVERT_WXRS 311 // Convert old WXRs to new
457814b5	40
f6bcfd97	41	#define RESED_CONTENTS 320
457814b5	42
f6bcfd97 BP	43	#define IDC_TREECTRL 500
f6bcfd97 BP	44	#define IDC_LISTCTRL 501
ae8351fc JS	45
	46	// For control list ('palette')
	47	#define RESED_POINTER 0
	48	#define RESED_BUTTON 1
	49	#define RESED_BMPBUTTON 2
	50	#define RESED_STATICTEXT 3
	51	#define RESED_STATICBMP 4
	52	#define RESED_STATICBOX 5
	53	#define RESED_TEXTCTRL_SINGLE 6
	54	#define RESED_TEXTCTRL_MULTIPLE 7
	55	#define RESED_LISTBOX 8
	56	#define RESED_CHOICE 9
	57	#define RESED_COMBOBOX 10
	58	#define RESED_CHECKBOX 11
	59	#define RESED_SLIDER 12
	60	#define RESED_GAUGE 13
	61	#define RESED_RADIOBOX 14
	62	#define RESED_RADIOBUTTON 15
	63	#define RESED_SCROLLBAR 16
	64	#define RESED_TREECTRL 17
	65	#define RESED_LISTCTRL 18
	66	#define RESED_SPINBUTTON 19
	67
457814b5	68	/*
f6bcfd97 BP	69	* Controls loading, saving, user interface of resource editor(s).
f6bcfd97 BP	70	*/
457814b5 JS	71
457814b5 JS	72	class wxResourceEditorFrame;
457814b5 JS	73	class EditorToolBar;
457814b5 JS	74	class wxWindowPropertyInfo;
ae8351fc JS	75	class wxResourceEditorProjectTree;
ae8351fc JS	76	class wxResourceEditorControlList;
457814b5	77
2049ba38	78	#ifdef __WXMSW__
457814b5 JS	79	#define wxHelpController wxWinHelpController
457814b5 JS	80	#else
b127f301	81	#define wxHelpController wxHTMLHelpController;
457814b5 JS	82	#endif
	83
	84	class wxHelpController;
	85
	86	/*
f6bcfd97 BP	87	* The resourceTable contains a list of wxItemResources (which each may
	88	* have further children, defining e.g. a dialog box with controls).
	89	*
	90	* We need to associate actual windows with each wxItemResource,
	91	* instead of the current 'one current window' scheme.
	92	*
	93	* - We create a new dialog, create a wxItemResource,
	94	* associate the dialog with wxItemResource via a hash table.
	95	* Must be a hash table in case dialog is deleted without
	96	* telling the resource manager.
	97	* - When we save the resource after editing/closing the dialog,
	98	* we check the wxItemResource/wxDialog and children for
	99	* consistency (throw away items no longer in the wxDialog,
	100	* create any new wxItemResources).
	101	* - We save the wxItemResources via the wxPropertyInfo classes,
	102	* so devolve the code to the appropriate class.
	103	* This involves creating a new temporary wxPropertyInfo for
	104	* the purpose.
	105	*
	106	* We currently assume we only create one instance of a window for
	107	* each wxItemResource. We will need to relax this when we're editing
	108	* in situ.
	109	*
	110	*
bbcdf8bc	111	*/
457814b5	112
f6bcfd97 BP	113	class wxResourceTableWithSaving: public wxResourceTable
	114	{
	115	public:
	116	wxResourceTableWithSaving():wxResourceTable()
	117	{
	118	// Add all known window styles
	119	m_styleTable.Init();
	120	}
	121	virtual bool Save(const wxString& filename);
	122	virtual bool SaveResource(wxTextOutputStream& stream, wxItemResource* item, wxItemResource* parentItem);
	123
	124	void GeneratePanelStyleString(long windowStyle, char *buf);
	125	void GenerateDialogStyleString(long windowStyle, char *buf);
	126
	127	void GenerateControlStyleString(const wxString& windowClass, long windowStyle, char *buf);
	128
	129	void OutputFont(wxTextOutputStream& stream, const wxFont& font);
	130	wxControl CreateItem(wxPanel panel, const wxItemResource childResource, const wxItemResource parentResource);
	131
bbcdf8bc	132	protected:
f6bcfd97	133	wxWindowStyleTable m_styleTable;
457814b5	134	};
f6bcfd97	135
ae8351fc JS	136	class wxResourceEditorScrolledWindow;
ae8351fc JS	137
457814b5 JS	138	class wxResourceManager: public wxObject
457814b5 JS	139	{
f6bcfd97 BP	140	friend class wxResourceEditorFrame;
f6bcfd97 BP	141
ae8351fc	142	public:
f6bcfd97 BP	143	wxResourceManager();
	144	~wxResourceManager();
	145
	146	// Operations
	147
	148	// Initializes the resource manager
	149	bool Initialize();
	150
	151	// Load/save window size etc.
	152	bool LoadOptions();
	153	bool SaveOptions();
	154
	155	// Show or hide the resource editor frame, which displays a list
	156	// of resources with ability to edit them.
	157	virtual bool ShowResourceEditor(bool show, wxWindow parent = NULL, const char title = "wxWindows Dialog Editor");
	158
	159	// Convert old WXRs to new
	160	virtual bool ConvertWXRs();
	161	bool DoConvertWXR(const wxString& oldPath, const wxString& newPath);
	162	bool ChangeOldToNewResource(wxItemResource* parent, wxItemResource* res);
	163	bool InsertLabelResource(wxItemResource* parent, wxItemResource* res);
	164
	165	virtual bool Save();
	166	virtual bool SaveAs();
	167	virtual bool Save(const wxString& filename);
	168	virtual bool Load(const wxString& filename);
	169	virtual bool Clear(bool deleteWindows = TRUE, bool force = TRUE);
	170	virtual void SetFrameTitle(const wxString& filename);
	171	virtual void ClearCurrentDialog();
	172	virtual bool New(bool loadFromFile = TRUE, const wxString& filename = "");
	173	virtual bool SaveIfModified();
	174	virtual void AlignItems(int flag);
	175	virtual void CopySize(int command); // Copy width, height or both from first control
	176	virtual void ToBackOrFront(bool toBack);
	177	virtual void DistributePositions(int command); // Distribute controls evenly between first and last
	178	virtual wxWindow *FindParentOfSelection();
	179
	180	virtual wxFrame OnCreateEditorFrame(const char title);
	181	virtual wxMenuBar OnCreateEditorMenuBar(wxFrame parent);
	182	virtual wxResourceEditorScrolledWindow OnCreateEditorPanel(wxFrame parent);
	183	virtual wxToolBar OnCreateToolBar(wxFrame parent);
	184
	185	// Create a window information object for the give window
	186	wxWindowPropertyInfo* CreatePropertyInfoForWindow(wxWindow *win);
	187	// Edit the given window
	188	void EditWindow(wxWindow *win);
	189
	190	virtual void UpdateResourceList();
	191	virtual void AddItemsRecursively(long parent, wxItemResource *resource);
	192	virtual bool EditSelectedResource();
	193	virtual bool Edit(wxItemResource *res);
	194	virtual bool CreateNewPanel();
	195	virtual bool CreatePanelItem(wxItemResource panelResource, wxPanel panel, char *itemType, int x = 10, int y = 10, bool isBitmap = FALSE);
	196	virtual bool DeleteSelection();
	197	virtual bool TestCurrentDialog(wxWindow* parent);
	198
	199	// Saves the window info into the resource, and deletes the
	200	// handler. Doesn't actually disassociate the window from
	201	// the resources. Replaces OnClose.
	202	virtual bool SaveInfoAndDeleteHandler(wxWindow* win);
	203
	204	// Destroys the window. If this is the 'current' panel, NULLs the
	205	// variable.
	206	virtual bool DeleteWindow(wxWindow* win);
207	virtual bool DeleteResource(wxItemResource *res);
208	virtual bool DeleteResource(wxWindow *win);
209
210	// Add bitmap resource if there isn't already one with this filename.
211	virtual wxString AddBitmapResource(const wxString& filename);
212
213	// Delete the bitmap resource if it isn't being used by another resource.
214	virtual void PossiblyDeleteBitmapResource(const wxString& resourceName);
215
216	// Helper function for above
217	virtual bool IsBitmapResourceUsed(const wxString& resourceName);
218
219	wxItemResource *FindBitmapResourceByFilename(const wxString& filename);
220
221	wxString FindBitmapFilenameForResource(wxItemResource *resource);
222
223	// Is this window identifier in use?
224	bool IsSymbolUsed(wxItemResource* thisResource, wxWindowID id) ;
225
226	// Is this window identifier compatible with the given name? (i.e.
227	// does it already exist under a different name)
228	bool IsIdentifierOK(const wxString& name, wxWindowID id);
229
230	// Change all integer ids that match oldId, to newId.
231	// This is necessary if an id is changed for one resource - all resources
232	// must be changed.
233	void ChangeIds(int oldId, int newId);
234
235	// If any resource ids were missing (or their symbol was missing),
236	// repair them i.e. give them new ids. Returns TRUE if any resource
237	// needed repairing.
238	bool RepairResourceIds();
239
240	// Deletes 'win' and creates a new window from the resource that
241	// was associated with it. E.g. if you can't change properties on the
242	// fly, you'll need to delete the window and create it again.
243	virtual wxWindow RecreateWindowFromResource(wxWindow win, wxWindowPropertyInfo *info = NULL, bool instantiateFirst = TRUE);
244
245	virtual bool RecreateSelection();
246
247	// Remove selection handles if this control is selected
248	void DeselectItemIfNecessary(wxWindow *win);
249
250	// Need to search through resource table removing this from
251	// any resource which has this as a parent.
252	virtual bool RemoveResourceFromParent(wxItemResource *res);
253
254	virtual bool EditDialog(wxDialog dialog, wxWindow parent);
255
256	void AddSelection(wxWindow *win);
257	void RemoveSelection(wxWindow *win);
258
259	virtual void MakeUniqueName(char prefix, char buf);
260
261	// (Dis)associate resource<->physical window
262	// Doesn't delete any windows.
263	virtual void AssociateResource(wxItemResource resource, wxWindow win);
264	virtual bool DisassociateResource(wxItemResource *resource);
265	virtual bool DisassociateResource(wxWindow *win);
266	virtual bool DisassociateWindows();
267	virtual wxItemResource FindResourceForWindow(wxWindow win);
268	virtual wxWindow FindWindowForResource(wxItemResource resource);
269
270	virtual bool InstantiateAllResourcesFromWindows();
271	virtual bool InstantiateResourceFromWindow(wxItemResource resource, wxWindow window, bool recurse = FALSE);
272
273	// Accessors
274	inline void SetEditorFrame(wxFrame *fr) { m_editorFrame = fr; }
275	inline void SetEditorToolBar(EditorToolBar *tb) { m_editorToolBar = tb; }
276	inline wxFrame *GetEditorFrame() const { return m_editorFrame; }
277	inline wxResourceEditorProjectTree *GetEditorResourceTree() const { return m_editorResourceTree; }
278	inline wxResourceEditorControlList *GetEditorControlList() const { return m_editorControlList; }
279	inline wxList& GetSelections() { return m_selections; }
280	inline wxMenu *GetPopupMenu() const { return m_popupMenu; }
d0fff5cb	281	#ifdef __WXMSW__
f6bcfd97	282	inline wxHelpController *GetHelpController() const { return m_helpController; }
d0fff5cb	283	#endif
f6bcfd97 BP	284
	285	inline void Modify(bool mod = TRUE) { m_modified = mod; }
	286	inline bool Modified() const { return m_modified; }
	287
	288	inline wxResourceTable& GetResourceTable() { return m_resourceTable; }
	289	inline wxHashTable& GetResourceAssociations() { return m_resourceAssociations; }
	290
	291	inline wxString GetCurrentFilename() const { return m_currentFilename; }
	292	static wxResourceManager* GetCurrentResourceManager() { return sm_currentResourceManager; }
	293
	294	inline void SetSymbolFilename(const wxString& s) { m_symbolFilename = s; }
	295	inline wxString GetSymbolFilename() const { return m_symbolFilename; }
	296
	297	inline wxRect& GetPropertyWindowSize() { return m_propertyWindowSize; }
	298	inline wxRect& GetResourceEditorWindowSize() { return m_resourceEditorWindowSize; }
	299
	300	wxResourceSymbolTable& GetSymbolTable() { return m_symbolTable; }
	301
	302	// Generate a window id and a first stab at a name
	303	int GenerateWindowId(const wxString& prefix, wxString& idName) ;
	304
	305	// Member variables
ae8351fc	306	protected:
d0fff5cb	307	#ifdef __WXMSW__
f6bcfd97	308	wxHelpController* m_helpController;
d0fff5cb	309	#endif
f6bcfd97 BP	310	wxResourceTableWithSaving m_resourceTable;
	311	wxFrame* m_editorFrame;
	312	wxResourceEditorScrolledWindow* m_editorPanel;
	313	wxMenu* m_popupMenu;
	314	wxResourceEditorProjectTree* m_editorResourceTree;
	315	wxResourceEditorControlList* m_editorControlList;
	316	EditorToolBar* m_editorToolBar;
	317	int m_nameCounter;
	318	int m_symbolIdCounter; // For generating window ids
	319	bool m_modified;
	320	wxHashTable m_resourceAssociations;
	321	wxList m_selections;
	322	wxString m_currentFilename;
	323	wxBitmap* m_bitmapImage; // Default for static bitmaps/buttons
	324
	325	wxImageList m_imageList;
	326	long m_rootDialogItem; // Root of dialog hierarchy in tree (unused)
	327
	328	// Options to be saved/restored
	329	wxString m_optionsResourceFilename; // e.g. dialoged.ini, .dialogrc
	330	wxRect m_propertyWindowSize;
	331	wxRect m_resourceEditorWindowSize;
	332	static wxResourceManager* sm_currentResourceManager;
	333
	334	// Symbol table with identifiers for controls
	335	wxResourceSymbolTable m_symbolTable;
	336	// Filename for include file, e.g. resource.h
	337	wxString m_symbolFilename;
457814b5 JS	338	};
457814b5 JS	339
ae8351fc	340
457814b5 JS	341	class wxResourceEditorFrame: public wxFrame
457814b5 JS	342	{
f6bcfd97 BP	343	public:
	344	DECLARE_CLASS(wxResourceEditorFrame)
	345
	346	wxResourceManager *manager;
	347	wxResourceEditorFrame(wxResourceManager resMan, wxFrame parent, const wxString& title,
	348	const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize(600, 400),
	349	long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "frame");
	350	~wxResourceEditorFrame();
	351
	352	void OnCloseWindow(wxCloseEvent& event);
	353
	354	void OnNew(wxCommandEvent& event);
	355	void OnOpen(wxCommandEvent& event);
	356	void OnNewDialog(wxCommandEvent& event);
	357	void OnClear(wxCommandEvent& event);
	358	void OnSave(wxCommandEvent& event);
	359	void OnSaveAs(wxCommandEvent& event);
	360	void OnExit(wxCommandEvent& event);
	361	void OnAbout(wxCommandEvent& event);
	362	void OnContents(wxCommandEvent& event);
	363	void OnDeleteSelection(wxCommandEvent& event);
	364	void OnRecreateSelection(wxCommandEvent& event);
	365	void OnTest(wxCommandEvent& event);
	366	void OnConvertWXRs(wxCommandEvent& event);
	367
	368	DECLARE_EVENT_TABLE()
457814b5 JS	369	};
457814b5 JS	370
ae8351fc	371	class wxResourceEditorScrolledWindow: public wxScrolledWindow
457814b5	372	{
f6bcfd97 BP	373	public:
	374	wxResourceEditorScrolledWindow(wxWindow *parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
	375	long style = 0);
	376	~wxResourceEditorScrolledWindow();
	377
	378	void OnPaint(wxPaintEvent& event);
	379
	380	void DrawTitle(wxDC& dc);
	381
	382	// Accessors
	383	inline int GetMarginX() { return m_marginX; }
	384	inline int GetMarginY() { return m_marginY; }
	385
	386	public:
	387	wxWindow* m_childWindow;
	388	private:
	389	int m_marginX, m_marginY;
	390
	391	DECLARE_EVENT_TABLE()
ae8351fc	392	};
457814b5 JS	393
	394	#define OBJECT_MENU_EDIT 1
	395	#define OBJECT_MENU_DELETE 2
	396
	397	/*
f6bcfd97 BP	398	* Main toolbar
	399	*
	400	*/
	401
ae8351fc	402	class EditorToolBar: public wxToolBar
457814b5	403	{
ae8351fc	404	public:
f6bcfd97 BP	405	EditorToolBar(wxFrame *frame, const wxPoint& pos = wxPoint(0, 0), const wxSize& size = wxSize(0, 0),
	406	long style = wxTB_HORIZONTAL);
	407	bool OnLeftClick(int toolIndex, bool toggled);
	408	void OnMouseEnter(int toolIndex);
	409
	410	DECLARE_EVENT_TABLE()
457814b5 JS	411	};
	412
	413	// Toolbar ids
f6bcfd97 BP	414	#define TOOLBAR_LOAD_FILE 101
	415	#define TOOLBAR_SAVE_FILE 102
	416	#define TOOLBAR_NEW 103
	417	#define TOOLBAR_TREE 105
	418	#define TOOLBAR_HELP 106
457814b5 JS	419
457814b5 JS	420	// Formatting tools
f6bcfd97 BP	421	#define TOOLBAR_FORMAT_HORIZ 110
	422	#define TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN 111
	423	#define TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN 112
	424	#define TOOLBAR_FORMAT_VERT 113
	425	#define TOOLBAR_FORMAT_VERT_TOP_ALIGN 114
	426	#define TOOLBAR_FORMAT_VERT_BOT_ALIGN 115
	427
	428	#define TOOLBAR_TO_FRONT 116
	429	#define TOOLBAR_TO_BACK 117
	430	#define TOOLBAR_COPY_SIZE 118
	431	#define TOOLBAR_COPY_WIDTH 119
	432	#define TOOLBAR_COPY_HEIGHT 120
	433	#define TOOLBAR_DISTRIBUTE_HORIZ 121
	434	#define TOOLBAR_DISTRIBUTE_VERT 122
457814b5	435
1195ec42	436	/*
f6bcfd97 BP	437	* this class is used to store data associated with a tree item
f6bcfd97 BP	438	*/
1195ec42 VZ	439	class wxResourceTreeData : public wxTreeItemData
	440	{
	441	public:
	442	wxResourceTreeData(wxItemResource *resource) { m_resource = resource; }
f6bcfd97	443
1195ec42	444	wxItemResource *GetResource() const { return m_resource; }
f6bcfd97	445
1195ec42 VZ	446	private:
	447	wxItemResource *m_resource;
	448	};
	449
457814b5 JS	450	#endif
457814b5 JS	451