Added files.

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

utils/dialoged/src/prop.h

@@ -0,0 +1,325 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        prop.h
+// Purpose:     Property sheet classes
+// Author:      Julian Smart
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _PROP_H_
+#define _PROP_H_
+
+#ifdef __GNUG__
+#pragma interface "prop.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/string.h"
+#include "wx/hash.h"
+#include "wx/dialog.h"
+#include "wx/frame.h"
+#include "wx/button.h"
+#include "wx/listbox.h"
+#include "wx/textctrl.h"
+#include "wx/gdicmn.h"
+#include "wx/layout.h"
+
+class wxWindow;
+class wxProperty;
+class wxPropertyValue;
+class wxPropertySheet;
+class wxPropertyView;
+class wxPropertyValidator;
+class wxPropertyValidatorRegistry;
+
+#define wxPROPERTY_VERSION 2.0
+
+// A storable sheet of values
+class wxPropertySheet: public wxObject
+{
+ DECLARE_DYNAMIC_CLASS(wxPropertySheet)
+ public:
+  wxPropertySheet(void);
+  ~wxPropertySheet(void);
+
+  // Add a property
+  virtual void AddProperty(wxProperty *property);
+
+  // Get property by name
+  virtual wxProperty *GetProperty(wxString name);
+
+  // Clear all properties
+  virtual void Clear(void);
+
+  virtual bool Save(ostream& str);
+  virtual bool Load(ostream& str);
+
+  virtual void UpdateAllViews(wxPropertyView *thisView = NULL);
+  inline virtual wxList& GetProperties(void) const { return (wxList&) m_properties; }
+  
+  // Sets/clears the modified flag for each property value
+  virtual void SetAllModified(bool flag = TRUE);
+
+ protected:
+  wxObject*         m_viewedObject;
+  wxList            m_properties;
+  wxPropertyView*   m_propertyView;
+
+};
+
+
+// Base class for property sheet views. There are currently two directly derived
+// classes: wxPropertyListView, and wxPropertyFormView.
+class wxPropertyView: public wxEvtHandler
+{
+ DECLARE_DYNAMIC_CLASS(wxPropertyView)
+ public:
+  wxPropertyView(long flags = 0);
+  ~wxPropertyView(void);
+
+  // Associates and shows the view
+  virtual void ShowView(wxPropertySheet *WXUNUSED(propertySheet), wxWindow *WXUNUSED(panel)) {}
+
+  // Update this view of the viewed object, called e.g. by
+  // the object itself.
+  virtual bool OnUpdateView(void) {return FALSE;};
+
+  // Override this to do something as soon as the property changed,
+  // if the view and validators support it.
+  virtual void OnPropertyChanged(wxProperty *WXUNUSED(property)) {}
+
+  virtual void AddRegistry(wxPropertyValidatorRegistry *registry);
+  inline virtual wxList& GetRegistryList(void) const
+   { return (wxList&) m_validatorRegistryList; }
+
+  virtual wxPropertyValidator *FindPropertyValidator(wxProperty *property);
+  inline virtual void SetPropertySheet(wxPropertySheet *sheet) { m_propertySheet = sheet; }
+  inline virtual wxPropertySheet *GetPropertySheet(void) const { return m_propertySheet; }
+
+  virtual void OnOk(void) {};
+  virtual void OnCancel(void) {};
+  virtual void OnHelp(void) {};
+
+  inline virtual bool OnClose(void) { return FALSE; }
+  inline long GetFlags(void) { return m_buttonFlags; }
+
+ protected:
+  long                  m_buttonFlags;
+  wxPropertySheet*      m_propertySheet;
+  wxProperty*           m_currentProperty;
+  wxList                m_validatorRegistryList;
+  wxPropertyValidator*  m_currentValidator;
+};
+
+
+class wxPropertyValidator: public wxEvtHandler
+{
+  DECLARE_DYNAMIC_CLASS(wxPropertyValidator)
+ public:
+  wxPropertyValidator(long flags = 0);
+  ~wxPropertyValidator(void);
+
+  inline long GetFlags(void) const { return m_validatorFlags; }
+  inline void SetValidatorProperty(wxProperty *prop) { m_validatorProperty = prop; }
+  inline wxProperty *GetValidatorProperty(void) const { return m_validatorProperty; }
+
+  virtual bool StringToFloat (char *s, float *number);
+  virtual bool StringToDouble (char *s, double *number);
+  virtual bool StringToInt (char *s, int *number);
+  virtual bool StringToLong (char *s, long *number);
+  virtual char *FloatToString (float number);
+  virtual char *DoubleToString (double number);
+  virtual char *IntToString (int number);
+  virtual char *LongToString (long number);
+
+ protected:
+  long          m_validatorFlags;
+  wxProperty*   m_validatorProperty;
+};
+
+
+// extern wxPropertyValidator *wxDefaultPropertyValidator;
+
+class wxPropertyValidatorRegistry: public wxHashTable
+{
+  DECLARE_DYNAMIC_CLASS(wxPropertyValidatorRegistry)
+ public:
+  wxPropertyValidatorRegistry(void);
+  ~wxPropertyValidatorRegistry(void);
+
+  virtual void RegisterValidator(wxString& roleName, wxPropertyValidator *validator);
+  virtual wxPropertyValidator *GetValidator(wxString& roleName);
+  void ClearRegistry(void);
+};
+
+/*
+ * Property value class
+ */
+
+typedef enum {
+    wxPropertyValueNull,
+    wxPropertyValueInteger,
+    wxPropertyValueReal,
+    wxPropertyValuebool,
+    wxPropertyValueString,
+    wxPropertyValueList,
+    wxPropertyValueIntegerPtr,
+    wxPropertyValueRealPtr,
+    wxPropertyValueboolPtr,
+    wxPropertyValueStringPtr
+} wxPropertyValueType;
+
+class wxPropertyValue: public wxObject
+{
+  DECLARE_DYNAMIC_CLASS(wxPropertyValue)
+
+  wxPropertyValue(void);                       // Unknown type
+  wxPropertyValue(const wxPropertyValue& copyFrom);  // Copy constructor
+  wxPropertyValue(const char *val);
+  wxPropertyValue(const wxString& val);
+  wxPropertyValue(long val);
+  wxPropertyValue(bool val);
+  wxPropertyValue(float val);
+  wxPropertyValue(double the_real);
+  wxPropertyValue(wxList *val);
+  wxPropertyValue(wxStringList *val);
+  // Pointer versions
+  wxPropertyValue(char **val);
+  wxPropertyValue(long *val);
+  wxPropertyValue(bool *val);
+  wxPropertyValue(float *val);
+
+  ~wxPropertyValue(void);
+
+  virtual inline wxPropertyValueType Type(void) const { return m_type; }
+  virtual inline void SetType(wxPropertyValueType typ) { m_type = typ; }
+  virtual long IntegerValue(void) const;
+  virtual float RealValue(void) const;
+  virtual bool BoolValue(void) const;
+  virtual char *StringValue(void) const;
+  virtual long *IntegerValuePtr(void) const;
+  virtual float *RealValuePtr(void) const;
+  virtual bool *BoolValuePtr(void) const;
+  virtual char **StringValuePtr(void) const;
+
+  // Get nth arg of clause (starting from 1)
+  virtual wxPropertyValue *Arg(wxPropertyValueType type, int arg) const;
+
+  // Return nth argument of a list expression (starting from zero)
+  virtual wxPropertyValue *Nth(int arg) const;
+  // Returns the number of elements in a list expression
+  virtual int Number(void) const;
+
+  virtual wxPropertyValue *NewCopy(void) const;
+  virtual void Copy(wxPropertyValue& copyFrom);
+
+  virtual void WritePropertyClause(ostream& stream);  // Write this expression as a top-level clause
+  virtual void WritePropertyType(ostream& stream);    // Write as any other subexpression
+
+  // Append an expression to a list
+  virtual void Append(wxPropertyValue *expr);
+  // Insert at beginning of list
+  virtual void Insert(wxPropertyValue *expr);
+
+  // Get first expr in list
+  virtual inline wxPropertyValue *GetFirst(void) const
+    { return ((m_type == wxPropertyValueList) ? m_value.first : (wxPropertyValue*)NULL); }
+
+  // Get next expr if this is a node in a list
+  virtual inline wxPropertyValue *GetNext(void) const
+    { return m_next; }
+
+  // Get last expr in list
+  virtual inline wxPropertyValue *GetLast(void) const
+    { return ((m_type == wxPropertyValueList) ? m_last : (wxPropertyValue*)NULL); }
+  
+  // Delete this node from the list
+  virtual void Delete(wxPropertyValue *node);
+
+  // Clear list
+  virtual void ClearList(void);
+
+  virtual inline void SetClientData(wxObject *data) { m_clientData = data; }
+  virtual inline wxObject *GetClientData(void) { return m_clientData; }
+
+  virtual wxString GetStringRepresentation(void);
+  
+  inline void SetModified(bool flag = TRUE) { m_modifiedFlag = flag; }
+  inline bool GetModified(void) { return m_modifiedFlag; }
+
+  // Operators
+  void operator=(const wxPropertyValue& val);
+//  void operator=(const char *val);
+  void operator=(const wxString& val);
+  void operator=(const long val);
+  void operator=(const bool val);
+  void operator=(const float val);
+  void operator=(const char **val);
+  void operator=(const long *val);
+  void operator=(const bool *val);
+  void operator=(const float *val);
+
+ public:
+  wxObject*             m_clientData;
+  wxPropertyValueType   m_type;
+  bool                  m_modifiedFlag;
+
+  union {
+    long integer; // Also doubles as bool
+    char *string;
+    float real;
+    long *integerPtr;
+    bool *boolPtr;
+    char **stringPtr;
+    float *realPtr;
+    wxPropertyValue *first;  // If is a list expr, points to the first node
+    } m_value;
+
+  wxPropertyValue*      m_next;     // If this is a node in a list, points to the next node
+  wxPropertyValue*      m_last;     // If is a list expr, points to the last node
+
+};
+
+/*
+ * Property class: contains a name and a value.
+ */
+
+class wxProperty: public wxObject
+{
+  DECLARE_DYNAMIC_CLASS(wxProperty)
+ protected:
+  bool                  m_enabled;
+ public:
+  wxPropertyValue       m_value;
+  wxString              m_name;
+  wxString              m_propertyRole;
+  wxPropertyValidator*  m_propertyValidator;
+  wxWindow*             m_propertyWindow; // Usually a panel item, if anything
+
+  wxProperty(void);
+  wxProperty(wxProperty& copyFrom);
+  wxProperty(wxString name, wxString role, wxPropertyValidator *ed = NULL);
+  wxProperty(wxString name, const wxPropertyValue& val, wxString role, wxPropertyValidator *ed = NULL);
+  ~wxProperty(void);
+
+  virtual wxPropertyValue& GetValue(void) const;
+  virtual wxPropertyValidator *GetValidator(void) const;
+  virtual wxString& GetName(void) const;
+  virtual wxString& GetRole(void) const;
+  virtual void SetValue(const wxPropertyValue& val);
+  virtual void SetValidator(wxPropertyValidator *v);
+  virtual void SetName(wxString& nm);
+  virtual void SetRole(wxString& role);
+  void operator=(const wxPropertyValue& val);
+  virtual inline void SetWindow(wxWindow *win) { m_propertyWindow = win; }
+  virtual inline wxWindow *GetWindow(void) const { return m_propertyWindow; }
+  
+  inline void Enable(bool en) { m_enabled = en; }
+  inline bool IsEnabled(void) const { return m_enabled; }
+};
+
+#endif
+

utils/dialoged/src/propform.h

@@ -0,0 +1,297 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        propform.h
+// Purpose:     Property form classes
+// Author:      Julian Smart
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:   	wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _PROPFORM_H_
+#define _PROPFORM_H_
+
+#ifdef __GNUG__
+#pragma interface "propform.h"
+#endif
+
+#include "prop.h"
+
+////
+//// Property form classes: for using an existing dialog or panel
+////
+
+#define wxID_PROP_REVERT        3100
+#define wxID_PROP_UPDATE        3101
+
+// Mediates between a physical panel and the property sheet
+class wxPropertyFormView: public wxPropertyView
+{
+ DECLARE_DYNAMIC_CLASS(wxPropertyFormView)
+ public:
+  wxPropertyFormView(wxWindow *propPanel = NULL, long flags = 0);
+  ~wxPropertyFormView(void);
+
+  // Associates and shows the view
+  virtual void ShowView(wxPropertySheet *propertySheet, wxWindow *panel);
+
+  // Update this view of the viewed object, called e.g. by
+  // the object itself.
+  virtual bool OnUpdateView(void);
+
+  // Transfer values from property sheet to dialog
+  virtual bool TransferToDialog(void);
+
+  // Transfer values from dialog to property sheet
+  virtual bool TransferToPropertySheet(void);
+
+  // Check that all the values are valid
+  virtual bool Check(void);
+
+  // Give each property in the sheet a panel item, by matching
+  // the name of the property to the name of the panel item.
+  // The user doesn't always want to call this; sometimes, it
+  // will have been done explicitly (e.g., no matching names).
+  virtual bool AssociateNames(void);
+
+  void OnOk(wxCommandEvent& event);
+  void OnCancel(wxCommandEvent& event);
+  void OnHelp(wxCommandEvent& event);
+  void OnUpdate(wxCommandEvent& event);
+  void OnRevert(wxCommandEvent& event);
+
+  virtual bool OnClose(void);
+  virtual void OnDoubleClick(wxControl *item);
+
+  // TODO: does OnCommand still get called...???
+  virtual void OnCommand(wxWindow& win, wxCommandEvent& event);
+
+  inline virtual void AssociatePanel(wxWindow *win) { m_propertyWindow = win; }
+  inline virtual wxWindow *GetPanel(void) const { return m_propertyWindow; }
+
+  inline virtual void SetManagedWindow(wxWindow *win) { m_managedWindow = win; }
+  inline virtual wxWindow *GetManagedWindow(void) const { return m_managedWindow; }
+
+  inline virtual wxButton *GetWindowCloseButton() const { return m_windowCloseButton; }
+  inline virtual wxButton *GetWindowCancelButton() const { return m_windowCancelButton; }
+  inline virtual wxButton *GetHelpButton() const { return m_windowHelpButton; }
+
+public:
+  static bool sm_dialogCancelled;
+
+ protected:
+  bool              m_detailedEditing;     // E.g. using listbox for choices
+
+  wxWindow*         m_propertyWindow; // Panel that the controls will appear on
+  wxWindow*         m_managedWindow; // Frame or dialog
+  
+  wxButton*         m_windowCloseButton; // Or OK
+  wxButton*         m_windowCancelButton;
+  wxButton*         m_windowHelpButton;
+
+DECLARE_EVENT_TABLE()
+
+};
+ 
+/*
+ * The type of validator used for forms (wxForm style but using an existing panel
+ * or dialog box).
+ * Classes derived from this know how to map from whatever widget they
+ * find themselves paired with, to the wxProperty and vice versa.
+ * Should the widget pointer be stored with the validator, or
+ * the wxProperty? If with the property, we don't have to supply
+ * a validator for every property. Otherwise, there ALWAYS needs
+ * to be a validator. On the other hand, not storing a wxWindow pointer
+ * in the wxProperty is more elegant. Perhaps.
+ * I think on balance, should put wxWindow pointer into wxProperty.
+ * After all, wxProperty will often be used to represent the data
+ * assocated with a window. It's that kinda thing.
+ */
+
+class wxPropertyFormValidator: public wxPropertyValidator
+{
+  DECLARE_DYNAMIC_CLASS(wxPropertyFormValidator)
+ protected:
+ public:
+  wxPropertyFormValidator(long flags = 0): wxPropertyValidator(flags) { }
+  ~wxPropertyFormValidator(void) {}
+  
+   // Called to check value is OK (e.g. when OK is pressed)
+   // Return FALSE if value didn't check out; signal to restore old value.
+   virtual bool OnCheckValue( wxProperty *WXUNUSED(property), wxPropertyFormView *WXUNUSED(view), 
+     wxWindow *WXUNUSED(parentWindow) ) { return TRUE; }
+
+   // Does the transferance from the property editing area to the property itself.
+   // Called by the view, e.g. when closing the window.
+   virtual bool OnRetrieveValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow) = 0;
+
+   // Called by the view to transfer the property to the window.
+   virtual bool OnDisplayValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow) = 0;
+
+  virtual void OnDoubleClick( wxProperty *WXUNUSED(property), wxPropertyFormView *WXUNUSED(view), 
+     wxWindow *WXUNUSED(parentWindow) ) { } 
+  virtual void OnSetFocus( wxProperty *WXUNUSED(property), wxPropertyFormView *WXUNUSED(view), 
+     wxWindow *WXUNUSED(parentWindow) ) { }
+  virtual void OnKillFocus( wxProperty *WXUNUSED(property), wxPropertyFormView *WXUNUSED(view), 
+     wxWindow *WXUNUSED(parentWindow) ) { }
+  virtual void OnCommand( wxProperty *WXUNUSED(property), wxPropertyFormView *WXUNUSED(view), 
+     wxWindow *WXUNUSED(parentWindow), wxCommandEvent& WXUNUSED(event) ) {}
+};
+
+/*
+ * Some default validators
+ */
+ 
+class wxRealFormValidator: public wxPropertyFormValidator
+{
+  DECLARE_DYNAMIC_CLASS(wxRealFormValidator)
+ public:
+   // 0.0, 0.0 means no range
+   wxRealFormValidator(float min = 0.0, float max = 0.0, long flags = 0):wxPropertyFormValidator(flags)
+   {
+     m_realMin = min; m_realMax = max;
+   }
+   ~wxRealFormValidator(void) {}
+
+   bool OnCheckValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+   bool OnRetrieveValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+   // Called by the view to transfer the property to the window.
+   bool OnDisplayValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+
+ protected:
+  float         m_realMin;
+  float         m_realMax;
+};
+
+class wxIntegerFormValidator: public wxPropertyFormValidator
+{
+  DECLARE_DYNAMIC_CLASS(wxIntegerFormValidator)
+ public:
+   // 0, 0 means no range
+   wxIntegerFormValidator(long min = 0, long max = 0, long flags = 0):wxPropertyFormValidator(flags)
+   {
+     m_integerMin = min; m_integerMax = max;
+   }
+   ~wxIntegerFormValidator(void) {}
+
+   bool OnCheckValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+   bool OnRetrieveValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+   bool OnDisplayValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+
+ protected:
+  long          m_integerMin;
+  long          m_integerMax;
+};
+
+class wxBoolFormValidator: public wxPropertyFormValidator
+{
+  DECLARE_DYNAMIC_CLASS(wxBoolFormValidator)
+ protected:
+ public:
+   wxBoolFormValidator(long flags = 0):wxPropertyFormValidator(flags)
+   {
+   }
+   ~wxBoolFormValidator(void) {}
+
+   bool OnCheckValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+   bool OnRetrieveValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+   bool OnDisplayValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+};
+
+class wxStringFormValidator: public wxPropertyFormValidator
+{
+  DECLARE_DYNAMIC_CLASS(wxStringFormValidator)
+ public:
+   wxStringFormValidator(wxStringList *list = NULL, long flags = 0);
+
+   ~wxStringFormValidator(void)
+   {
+     if (m_strings)
+       delete m_strings;
+   }
+
+   bool OnCheckValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+   bool OnRetrieveValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+   bool OnDisplayValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
+
+ protected:
+  wxStringList*     m_strings;
+};
+
+/*
+ * A default dialog box class to use.
+ */
+ 
+class wxPropertyFormDialog: public wxDialog
+{
+  DECLARE_CLASS(wxPropertyFormDialog)
+ public:
+  wxPropertyFormDialog(wxPropertyFormView *v, wxWindow *parent, const wxString& title,
+    const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
+    long style = wxDEFAULT_DIALOG_STYLE, const wxString& name = "dialogBox");
+  bool OnClose(void);
+  void OnDefaultAction(wxControl *item);
+  void OnCommand(wxWindow& win, wxCommandEvent& event);
+
+  // Extend event processing to search the view's event table
+  virtual bool ProcessEvent(wxEvent& event);
+
+ private:
+  wxPropertyFormView*       m_view;
+};
+
+/*
+ * A default panel class to use.
+ */
+ 
+class wxPropertyFormPanel: public wxPanel
+{
+  DECLARE_CLASS(wxPropertyFormPanel)
+ public:
+  wxPropertyFormPanel(wxPropertyFormView *v, wxWindow *parent, const wxPoint& pos = wxDefaultPosition,
+    const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "panel"):
+     wxPanel(parent, -1, pos, size, style, name)
+  {
+    m_view = v;
+  }
+  void OnDefaultAction(wxControl *item);
+  void OnCommand(wxWindow& win, wxCommandEvent& event);
+
+  // Extend event processing to search the view's event table
+  virtual bool ProcessEvent(wxEvent& event);
+
+ private:
+  wxPropertyFormView*       m_view;
+};
+
+/*
+ * A default frame class to use.
+ */
+ 
+class wxPropertyFormFrame: public wxFrame
+{
+  DECLARE_CLASS(wxPropertyFormFrame)
+ public:
+  wxPropertyFormFrame(wxPropertyFormView *v, wxFrame *parent, const wxString& title,
+    const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
+    long style = wxDEFAULT_FRAME, const wxString& name = "frame"):
+     wxFrame(parent, -1, title, pos, size, style, name)
+  {
+    m_view = v;
+    m_propertyPanel = NULL;
+  }
+  bool OnClose(void);
+
+  // Must call this to create panel and associate view
+  virtual bool Initialize(void);
+  virtual wxPanel *OnCreatePanel(wxFrame *parent, wxPropertyFormView *v);
+  inline virtual wxPanel *GetPropertyPanel(void) const { return m_propertyPanel; }
+
+ private:
+  wxPropertyFormView*       m_view;
+  wxPanel*                  m_propertyPanel;
+};
+
+#endif
+