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

set eol-style and keywords properties on new files

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@66584 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Paul Cornett
2011-01-05 06:56:36 +00:00
parent 2960bae821
commit e1d3601aca
26 changed files with 3708 additions and 3708 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/wx/rtti.h
View File

@@ -4,7 +4,7 @@
// Author: Julian Smart // Author: Julian Smart
// Modified by: Ron Lee // Modified by: Ron Lee
// Created: 01/02/97 // Created: 01/02/97
// RCS-ID: $Id: rtti.h 48412 2007-08-27 17:04:02Z FM $ // RCS-ID: $Id$
// Copyright: (c) 1997 Julian Smart // Copyright: (c) 1997 Julian Smart
// (c) 2001 Ron Lee <ron@debian.org> // (c) 2001 Ron Lee <ron@debian.org>
// Licence: wxWindows licence // Licence: wxWindows licence

558
include/wx/variantbase.h
View File

@@ -1,279 +1,279 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: wx/variantbase.h // Name: wx/variantbase.h
// Purpose: wxVariantBase class, a minimal version of wxVariant used by XTI // Purpose: wxVariantBase class, a minimal version of wxVariant used by XTI
// Author: Julian Smart // Author: Julian Smart
// Modified by: Francesco Montorsi // Modified by: Francesco Montorsi
// Created: 10/09/98 // Created: 10/09/98
// RCS-ID: $Id: variant.h 44625 2007-03-07 11:35:04Z VZ $ // RCS-ID: $Id$
// Copyright: (c) Julian Smart // Copyright: (c) Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_VARIANTBASE_H_ #ifndef _WX_VARIANTBASE_H_
#define _WX_VARIANTBASE_H_ #define _WX_VARIANTBASE_H_
#include "wx/defs.h" #include "wx/defs.h"
#if wxUSE_VARIANT #if wxUSE_VARIANT
#include "wx/string.h" #include "wx/string.h"
#include "wx/arrstr.h" #include "wx/arrstr.h"
#include "wx/cpp.h" #include "wx/cpp.h"
#include <typeinfo> #include <typeinfo>
#if wxUSE_DATETIME #if wxUSE_DATETIME
#include "wx/datetime.h" #include "wx/datetime.h"
#endif // wxUSE_DATETIME #endif // wxUSE_DATETIME
#include "wx/iosfwrap.h" #include "wx/iosfwrap.h"
class wxTypeInfo; class wxTypeInfo;
class wxObject; class wxObject;
class wxClassInfo; class wxClassInfo;
/* /*
* wxVariantData stores the actual data in a wxVariant object, * wxVariantData stores the actual data in a wxVariant object,
* to allow it to store any type of data. * to allow it to store any type of data.
* Derive from this to provide custom data handling. * Derive from this to provide custom data handling.
* *
* NB: To prevent addition of extra vtbl pointer to wxVariantData, * NB: To prevent addition of extra vtbl pointer to wxVariantData,
* we don't multiple-inherit from wxObjectRefData. Instead, * we don't multiple-inherit from wxObjectRefData. Instead,
* we simply replicate the wxObject ref-counting scheme. * we simply replicate the wxObject ref-counting scheme.
* *
* NB: When you construct a wxVariantData, it will have refcount * NB: When you construct a wxVariantData, it will have refcount
* of one. Refcount will not be further increased when * of one. Refcount will not be further increased when
* it is passed to wxVariant. This simulates old common * it is passed to wxVariant. This simulates old common
* scenario where wxVariant took ownership of wxVariantData * scenario where wxVariant took ownership of wxVariantData
* passed to it. * passed to it.
* If you create wxVariantData for other reasons than passing * If you create wxVariantData for other reasons than passing
* it to wxVariant, technically you are not required to call * it to wxVariant, technically you are not required to call
* DecRef() before deleting it. * DecRef() before deleting it.
* *
* TODO: in order to replace wxPropertyValue, we would need * TODO: in order to replace wxPropertyValue, we would need
* to consider adding constructors that take pointers to C++ variables, * to consider adding constructors that take pointers to C++ variables,
* or removing that functionality from the wxProperty library. * or removing that functionality from the wxProperty library.
* Essentially wxPropertyValue takes on some of the wxValidator functionality * Essentially wxPropertyValue takes on some of the wxValidator functionality
* by storing pointers and not just actual values, allowing update of C++ data * by storing pointers and not just actual values, allowing update of C++ data
* to be handled automatically. Perhaps there's another way of doing this without * to be handled automatically. Perhaps there's another way of doing this without
* overloading wxVariant with unnecessary functionality. * overloading wxVariant with unnecessary functionality.
*/ */
class WXDLLIMPEXP_BASE wxVariantData class WXDLLIMPEXP_BASE wxVariantData
{ {
friend class wxVariantBase; friend class wxVariantBase;
public: public:
wxVariantData() wxVariantData()
: m_count(1) : m_count(1)
{ } { }
#if wxUSE_STD_IOSTREAM #if wxUSE_STD_IOSTREAM
virtual bool Write(wxSTD ostream& WXUNUSED(str)) const { return false; } virtual bool Write(wxSTD ostream& WXUNUSED(str)) const { return false; }
virtual bool Read(wxSTD istream& WXUNUSED(str)) { return false; } virtual bool Read(wxSTD istream& WXUNUSED(str)) { return false; }
#endif #endif
virtual bool Write(wxString& WXUNUSED(str)) const { return false; } virtual bool Write(wxString& WXUNUSED(str)) const { return false; }
virtual bool Read(wxString& WXUNUSED(str)) { return false; } virtual bool Read(wxString& WXUNUSED(str)) { return false; }
// Override these to provide common functionality // Override these to provide common functionality
virtual bool Eq(wxVariantData& data) const = 0; virtual bool Eq(wxVariantData& data) const = 0;
// What type is it? Return a string name. // What type is it? Return a string name.
virtual wxString GetType() const = 0; virtual wxString GetType() const = 0;
// returns the type info of the content // returns the type info of the content
virtual const wxTypeInfo* GetTypeInfo() const = 0; virtual const wxTypeInfo* GetTypeInfo() const = 0;
// If it based on wxObject return the ClassInfo. // If it based on wxObject return the ClassInfo.
virtual wxClassInfo* GetValueClassInfo() { return NULL; } virtual wxClassInfo* GetValueClassInfo() { return NULL; }
int GetRefCount() const int GetRefCount() const
{ return m_count; } { return m_count; }
void IncRef() void IncRef()
{ m_count++; } { m_count++; }
void DecRef() void DecRef()
{ {
if ( --m_count == 0 ) if ( --m_count == 0 )
delete this; delete this;
} }
protected: protected:
// Protected dtor should make some incompatible code // Protected dtor should make some incompatible code
// break more louder. That is, they should do data->DecRef() // break more louder. That is, they should do data->DecRef()
// instead of delete data. // instead of delete data.
virtual ~wxVariantData() {} virtual ~wxVariantData() {}
private: private:
int m_count; int m_count;
}; };
template<typename T> class wxVariantDataT : public wxVariantData template<typename T> class wxVariantDataT : public wxVariantData
{ {
public: public:
wxVariantDataT(const T& d) : m_data(d) {} wxVariantDataT(const T& d) : m_data(d) {}
virtual ~wxVariantDataT() {} virtual ~wxVariantDataT() {}
// get a ref to the stored data // get a ref to the stored data
T & Get() { return m_data; } T & Get() { return m_data; }
// get a const ref to the stored data // get a const ref to the stored data
const T & Get() const { return m_data; } const T & Get() const { return m_data; }
// set the data // set the data
void Set(const T& d) { m_data = d; } void Set(const T& d) { m_data = d; }
// Override these to provide common functionality // Override these to provide common functionality
virtual bool Eq(wxVariantData& WXUNUSED(data)) const virtual bool Eq(wxVariantData& WXUNUSED(data)) const
{ return false; /* FIXME!! */ } { return false; /* FIXME!! */ }
// What type is it? Return a string name. // What type is it? Return a string name.
virtual wxString GetType() const virtual wxString GetType() const
{ return GetTypeInfo()->GetTypeName(); } { return GetTypeInfo()->GetTypeName(); }
// return a heap allocated duplicate // return a heap allocated duplicate
//virtual wxVariantData* Clone() const { return new wxVariantDataT<T>( Get() ); } //virtual wxVariantData* Clone() const { return new wxVariantDataT<T>( Get() ); }
// returns the type info of the contentc // returns the type info of the contentc
virtual const wxTypeInfo* GetTypeInfo() const { return wxGetTypeInfo( (T*) NULL ); } virtual const wxTypeInfo* GetTypeInfo() const { return wxGetTypeInfo( (T*) NULL ); }
private: private:
T m_data; T m_data;
}; };
/* /*
* wxVariantBase can store any kind of data, but has some basic types * wxVariantBase can store any kind of data, but has some basic types
* built in. * built in.
*/ */
class WXDLLIMPEXP_BASE wxVariantBase class WXDLLIMPEXP_BASE wxVariantBase
{ {
public: public:
wxVariantBase(); wxVariantBase();
wxVariantBase(const wxVariantBase& variant); wxVariantBase(const wxVariantBase& variant);
wxVariantBase(wxVariantData* data, const wxString& name = wxEmptyString); wxVariantBase(wxVariantData* data, const wxString& name = wxEmptyString);
template<typename T> template<typename T>
wxVariantBase(const T& data, const wxString& name = wxEmptyString) : wxVariantBase(const T& data, const wxString& name = wxEmptyString) :
m_data(new wxVariantDataT<T>(data)), m_name(name) {} m_data(new wxVariantDataT<T>(data)), m_name(name) {}
virtual ~wxVariantBase(); virtual ~wxVariantBase();
// generic assignment // generic assignment
void operator= (const wxVariantBase& variant); void operator= (const wxVariantBase& variant);
// Assignment using data, e.g. // Assignment using data, e.g.
// myVariant = new wxStringVariantData("hello"); // myVariant = new wxStringVariantData("hello");
void operator= (wxVariantData* variantData); void operator= (wxVariantData* variantData);
bool operator== (const wxVariantBase& variant) const; bool operator== (const wxVariantBase& variant) const;
bool operator!= (const wxVariantBase& variant) const; bool operator!= (const wxVariantBase& variant) const;
// Sets/gets name // Sets/gets name
inline void SetName(const wxString& name) { m_name = name; } inline void SetName(const wxString& name) { m_name = name; }
inline const wxString& GetName() const { return m_name; } inline const wxString& GetName() const { return m_name; }
// Tests whether there is data // Tests whether there is data
bool IsNull() const; bool IsNull() const;
// FIXME: used by wxVariantBase code but is nice wording... // FIXME: used by wxVariantBase code but is nice wording...
bool IsEmpty() const { return IsNull(); } bool IsEmpty() const { return IsNull(); }
// For compatibility with wxWidgets <= 2.6, this doesn't increase // For compatibility with wxWidgets <= 2.6, this doesn't increase
// reference count. // reference count.
wxVariantData* GetData() const { return m_data; } wxVariantData* GetData() const { return m_data; }
void SetData(wxVariantData* data) ; void SetData(wxVariantData* data) ;
// make a 'clone' of the object // make a 'clone' of the object
void Ref(const wxVariantBase& clone); void Ref(const wxVariantBase& clone);
// destroy a reference // destroy a reference
void UnRef(); void UnRef();
// Make NULL (i.e. delete the data) // Make NULL (i.e. delete the data)
void MakeNull(); void MakeNull();
// write contents to a string (e.g. for debugging) // write contents to a string (e.g. for debugging)
wxString MakeString() const; wxString MakeString() const;
// Delete data and name // Delete data and name
void Clear(); void Clear();
// Returns a string representing the type of the variant, // Returns a string representing the type of the variant,
// e.g. "string", "bool", "stringlist", "list", "double", "long" // e.g. "string", "bool", "stringlist", "list", "double", "long"
wxString GetType() const; wxString GetType() const;
bool IsType(const wxString& type) const; bool IsType(const wxString& type) const;
bool IsValueKindOf(const wxClassInfo* type) const; bool IsValueKindOf(const wxClassInfo* type) const;
// FIXME wxXTI methods: // FIXME wxXTI methods:
// get the typeinfo of the stored object // get the typeinfo of the stored object
const wxTypeInfo* GetTypeInfo() const const wxTypeInfo* GetTypeInfo() const
{ {
if (!m_data) if (!m_data)
return NULL; return NULL;
return m_data->GetTypeInfo(); return m_data->GetTypeInfo();
} }
// get a ref to the stored data // get a ref to the stored data
template<typename T> T& Get(wxTEMPLATED_MEMBER_FIX(T)) template<typename T> T& Get(wxTEMPLATED_MEMBER_FIX(T))
{ {
wxVariantDataT<T> *dataptr = wxVariantDataT<T> *dataptr =
wx_dynamic_cast(wxVariantDataT<T>*, m_data); wx_dynamic_cast(wxVariantDataT<T>*, m_data);
wxASSERT_MSG( dataptr, wxASSERT_MSG( dataptr,
wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) ); wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) );
return dataptr->Get(); return dataptr->Get();
} }
// get a const ref to the stored data // get a const ref to the stored data
template<typename T> const T& Get(wxTEMPLATED_MEMBER_FIX(T)) const template<typename T> const T& Get(wxTEMPLATED_MEMBER_FIX(T)) const
{ {
const wxVariantDataT<T> *dataptr = const wxVariantDataT<T> *dataptr =
wx_dynamic_cast(const wxVariantDataT<T>*, m_data); wx_dynamic_cast(const wxVariantDataT<T>*, m_data);
wxASSERT_MSG( dataptr, wxASSERT_MSG( dataptr,
wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) ); wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) );
return dataptr->Get(); return dataptr->Get();
} }
template<typename T> bool HasData(wxTEMPLATED_MEMBER_FIX(T)) const template<typename T> bool HasData(wxTEMPLATED_MEMBER_FIX(T)) const
{ {
const wxVariantDataT<T> *dataptr = const wxVariantDataT<T> *dataptr =
wx_dynamic_cast(const wxVariantDataT<T>*, m_data); wx_dynamic_cast(const wxVariantDataT<T>*, m_data);
return dataptr != NULL; return dataptr != NULL;
} }
// returns this value as string // returns this value as string
wxString GetAsString() const; wxString GetAsString() const;
// gets the stored data casted to a wxObject*, // gets the stored data casted to a wxObject*,
// returning NULL if cast is not possible // returning NULL if cast is not possible
wxObject* GetAsObject(); wxObject* GetAsObject();
protected: protected:
wxVariantData* m_data; wxVariantData* m_data;
wxString m_name; wxString m_name;
}; };
#include "wx/dynarray.h" #include "wx/dynarray.h"
WX_DECLARE_OBJARRAY_WITH_DECL(wxVariantBase, wxVariantBaseArray, class WXDLLIMPEXP_BASE); WX_DECLARE_OBJARRAY_WITH_DECL(wxVariantBase, wxVariantBaseArray, class WXDLLIMPEXP_BASE);
// templated streaming, every type must have their specialization for these methods // templated streaming, every type must have their specialization for these methods
template<typename T> template<typename T>
void wxStringReadValue( const wxString &s, T &data ); void wxStringReadValue( const wxString &s, T &data );
template<typename T> template<typename T>
void wxStringWriteValue( wxString &s, const T &data); void wxStringWriteValue( wxString &s, const T &data);
template<typename T> template<typename T>
void wxToStringConverter( const wxVariantBase &v, wxString &s wxTEMPLATED_FUNCTION_FIX(T)) \ void wxToStringConverter( const wxVariantBase &v, wxString &s wxTEMPLATED_FUNCTION_FIX(T)) \
{ wxStringWriteValue( s, v.wxTEMPLATED_MEMBER_CALL(Get, T) ); } { wxStringWriteValue( s, v.wxTEMPLATED_MEMBER_CALL(Get, T) ); }
template<typename T> template<typename T>
void wxFromStringConverter( const wxString &s, wxVariantBase &v wxTEMPLATED_FUNCTION_FIX(T)) \ void wxFromStringConverter( const wxString &s, wxVariantBase &v wxTEMPLATED_FUNCTION_FIX(T)) \
{ T d; wxStringReadValue( s, d ); v = wxVariantBase(d); } { T d; wxStringReadValue( s, d ); v = wxVariantBase(d); }
#endif // wxUSE_VARIANT #endif // wxUSE_VARIANT
#endif // _WX_VARIANTBASE_H_ #endif // _WX_VARIANTBASE_H_

1040
include/wx/xtictor.h
View File

File diff suppressed because it is too large Load Diff

220
include/wx/xtihandler.h
View File

@@ -1,110 +1,110 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: wx/xtihandler.h // Name: wx/xtihandler.h
// Purpose: XTI handlers // Purpose: XTI handlers
// Author: Stefan Csomor // Author: Stefan Csomor
// Modified by: Francesco Montorsi // Modified by: Francesco Montorsi
// Created: 27/07/03 // Created: 27/07/03
// RCS-ID: $Id: xti.h 47299 2007-07-10 15:58:27Z FM $ // RCS-ID: $Id$
// Copyright: (c) 1997 Julian Smart // Copyright: (c) 1997 Julian Smart
// (c) 2003 Stefan Csomor // (c) 2003 Stefan Csomor
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _XTIHANDLER_H_ #ifndef _XTIHANDLER_H_
#define _XTIHANDLER_H_ #define _XTIHANDLER_H_
#include "wx/defs.h" #include "wx/defs.h"
#if wxUSE_EXTENDED_RTTI #if wxUSE_EXTENDED_RTTI
#include "wx/string.h" #include "wx/string.h"
class WXDLLIMPEXP_BASE wxObject; class WXDLLIMPEXP_BASE wxObject;
class WXDLLIMPEXP_BASE wxClassInfo; class WXDLLIMPEXP_BASE wxClassInfo;
class WXDLLIMPEXP_BASE wxDynamicClassInfo; class WXDLLIMPEXP_BASE wxDynamicClassInfo;
class WXDLLIMPEXP_BASE wxHashTable; class WXDLLIMPEXP_BASE wxHashTable;
class WXDLLIMPEXP_BASE wxHashTable_Node; class WXDLLIMPEXP_BASE wxHashTable_Node;
class WXDLLIMPEXP_BASE wxObjectRefData; class WXDLLIMPEXP_BASE wxObjectRefData;
class WXDLLIMPEXP_BASE wxEvent; class WXDLLIMPEXP_BASE wxEvent;
class WXDLLIMPEXP_BASE wxEvtHandler; class WXDLLIMPEXP_BASE wxEvtHandler;
typedef void (wxObject::*wxObjectEventFunction)(wxEvent&); typedef void (wxObject::*wxObjectEventFunction)(wxEvent&);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Handler Info // Handler Info
// //
// this describes an event sink // this describes an event sink
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxHandlerInfo class WXDLLIMPEXP_BASE wxHandlerInfo
{ {
friend class WXDLLIMPEXP_BASE wxDynamicClassInfo; friend class WXDLLIMPEXP_BASE wxDynamicClassInfo;
public: public:
wxHandlerInfo(wxHandlerInfo* &iter, wxHandlerInfo(wxHandlerInfo* &iter,
wxClassInfo* itsClass, wxClassInfo* itsClass,
const wxString& name, const wxString& name,
wxObjectEventFunction address, wxObjectEventFunction address,
const wxClassInfo* eventClassInfo) : const wxClassInfo* eventClassInfo) :
m_eventFunction(address), m_eventFunction(address),
m_name(name), m_name(name),
m_eventClassInfo(eventClassInfo), m_eventClassInfo(eventClassInfo),
m_itsClass(itsClass) m_itsClass(itsClass)
{ {
Insert(iter); Insert(iter);
} }
~wxHandlerInfo() ~wxHandlerInfo()
{ Remove(); } { Remove(); }
// return the name of this handler // return the name of this handler
const wxString& GetName() const { return m_name; } const wxString& GetName() const { return m_name; }
// return the class info of the event // return the class info of the event
const wxClassInfo *GetEventClassInfo() const { return m_eventClassInfo; } const wxClassInfo *GetEventClassInfo() const { return m_eventClassInfo; }
// get the handler function pointer // get the handler function pointer
wxObjectEventFunction GetEventFunction() const { return m_eventFunction; } wxObjectEventFunction GetEventFunction() const { return m_eventFunction; }
// returns NULL if this is the last handler of this class // returns NULL if this is the last handler of this class
wxHandlerInfo* GetNext() const { return m_next; } wxHandlerInfo* GetNext() const { return m_next; }
// return the class this property is declared in // return the class this property is declared in
const wxClassInfo* GetDeclaringClass() const { return m_itsClass; } const wxClassInfo* GetDeclaringClass() const { return m_itsClass; }
private: private:
// inserts this handler at the end of the linked chain which begins // inserts this handler at the end of the linked chain which begins
// with "iter" handler. // with "iter" handler.
void Insert(wxHandlerInfo* &iter); void Insert(wxHandlerInfo* &iter);
// removes this handler from the linked chain of the m_itsClass handlers. // removes this handler from the linked chain of the m_itsClass handlers.
void Remove(); void Remove();
wxObjectEventFunction m_eventFunction; wxObjectEventFunction m_eventFunction;
wxString m_name; wxString m_name;
const wxClassInfo* m_eventClassInfo; const wxClassInfo* m_eventClassInfo;
wxHandlerInfo* m_next; wxHandlerInfo* m_next;
wxClassInfo* m_itsClass; wxClassInfo* m_itsClass;
}; };
#define wxHANDLER(name,eventClassType) \ #define wxHANDLER(name,eventClassType) \
static wxHandlerInfo _handlerInfo##name( first, class_t::GetClassInfoStatic(), \ static wxHandlerInfo _handlerInfo##name( first, class_t::GetClassInfoStatic(), \
wxT(#name), (wxObjectEventFunction) (wxEventFunction) &name, \ wxT(#name), (wxObjectEventFunction) (wxEventFunction) &name, \
CLASSINFO( eventClassType ) ); CLASSINFO( eventClassType ) );
#define wxBEGIN_HANDLERS_TABLE(theClass) \ #define wxBEGIN_HANDLERS_TABLE(theClass) \
wxHandlerInfo *theClass::GetHandlersStatic() \ wxHandlerInfo *theClass::GetHandlersStatic() \
{ \ { \
typedef theClass class_t; \ typedef theClass class_t; \
static wxHandlerInfo* first = NULL; static wxHandlerInfo* first = NULL;
#define wxEND_HANDLERS_TABLE() \ #define wxEND_HANDLERS_TABLE() \
return first; } return first; }
#define wxEMPTY_HANDLERS_TABLE(theClass) \ #define wxEMPTY_HANDLERS_TABLE(theClass) \
wxBEGIN_HANDLERS_TABLE(theClass) \ wxBEGIN_HANDLERS_TABLE(theClass) \
wxEND_HANDLERS_TABLE() wxEND_HANDLERS_TABLE()
#endif // wxUSE_EXTENDED_RTTI #endif // wxUSE_EXTENDED_RTTI
#endif // _XTIHANDLER_H_ #endif // _XTIHANDLER_H_

1194
include/wx/xtiprop.h
View File

File diff suppressed because it is too large Load Diff

1162
include/wx/xtitypes.h
View File

File diff suppressed because it is too large Load Diff

2
samples/xti/classlist.cpp
View File

@@ -4,7 +4,7 @@
// Author: Francesco Montorsi // Author: Francesco Montorsi
// Modified by: // Modified by:
// Created: 03/06/2007 14:49:55 // Created: 03/06/2007 14:49:55
// RCS-ID: $Id: classlist.cpp 48186 2007-08-19 19:59:54Z FM $ // RCS-ID: $Id$
// Copyright: (c) 2007 Francesco Montorsi // Copyright: (c) 2007 Francesco Montorsi
// Licence: wxWidgets license // Licence: wxWidgets license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////

2
samples/xti/classlist.h
View File

@@ -4,7 +4,7 @@
// Author: Francesco Montorsi // Author: Francesco Montorsi
// Modified by: // Modified by:
// Created: 03/06/2007 14:49:55 // Created: 03/06/2007 14:49:55
// RCS-ID: $Id: classlist.h 47845 2007-08-01 12:53:50Z FM $ // RCS-ID: $Id$
// Copyright: (c) 2007 Francesco Montorsi // Copyright: (c) 2007 Francesco Montorsi
// Licence: wxWidgets license // Licence: wxWidgets license
//////////////////////////////////////////////////// ////////////////////////////////////////////////////

552
samples/xti/codereadercallback.cpp
View File

@@ -1,276 +1,276 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/xtistrm.cpp // Name: src/common/xtistrm.cpp
// Purpose: streaming runtime metadata information // Purpose: streaming runtime metadata information
// Author: Stefan Csomor // Author: Stefan Csomor
// Modified by: // Modified by:
// Created: 27/07/03 // Created: 27/07/03
// RCS-ID: $Id: xtistrm.cpp 47828 2007-07-31 19:26:56Z FM $ // RCS-ID: $Id$
// Copyright: (c) 2003 Stefan Csomor // Copyright: (c) 2003 Stefan Csomor
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#include "wx/xtistrm.h" #include "wx/xtistrm.h"
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/object.h" #include "wx/object.h"
#include "wx/hash.h" #include "wx/hash.h"
#include "wx/event.h" #include "wx/event.h"
#endif #endif
#include <map> #include <map>
#include <vector> #include <vector>
#include <string> #include <string>
using namespace std; using namespace std;
#include "wx/tokenzr.h" #include "wx/tokenzr.h"
#include "wx/txtstrm.h" #include "wx/txtstrm.h"
#include "codereadercallback.h" #include "codereadercallback.h"
#if !wxUSE_EXTENDED_RTTI #if !wxUSE_EXTENDED_RTTI
#error This sample requires XTI (eXtended RTTI) enabled #error This sample requires XTI (eXtended RTTI) enabled
#endif #endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxObjectCodeReaderCallback - depersisting to code // wxObjectCodeReaderCallback - depersisting to code
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
struct wxObjectCodeReaderCallback::wxObjectCodeReaderCallbackInternal struct wxObjectCodeReaderCallback::wxObjectCodeReaderCallbackInternal
{ {
#if wxUSE_UNICODE #if wxUSE_UNICODE
map<int,wstring> m_objectNames; map<int,wstring> m_objectNames;
#else #else
map<int,string> m_objectNames; map<int,string> m_objectNames;
#endif #endif
void SetObjectName(int objectID, const wxString &name ) void SetObjectName(int objectID, const wxString &name )
{ {
if ( m_objectNames.find(objectID) != m_objectNames.end() ) if ( m_objectNames.find(objectID) != m_objectNames.end() )
{ {
wxLogError( _("Passing a already registered object to SetObjectName") ); wxLogError( _("Passing a already registered object to SetObjectName") );
return ; return ;
} }
m_objectNames[objectID] = (const wxChar *)name; m_objectNames[objectID] = (const wxChar *)name;
} }
wxString GetObjectName( int objectID ) wxString GetObjectName( int objectID )
{ {
if ( objectID == wxNullObjectID ) if ( objectID == wxNullObjectID )
return wxT("NULL"); return wxT("NULL");
if ( m_objectNames.find(objectID) == m_objectNames.end() ) if ( m_objectNames.find(objectID) == m_objectNames.end() )
{ {
wxLogError( _("Passing an unkown object to GetObject") ); wxLogError( _("Passing an unkown object to GetObject") );
return wxEmptyString; return wxEmptyString;
} }
return wxString( m_objectNames[objectID].c_str() ); return wxString( m_objectNames[objectID].c_str() );
} }
}; };
wxObjectCodeReaderCallback::wxObjectCodeReaderCallback(wxTextOutputStream *out) wxObjectCodeReaderCallback::wxObjectCodeReaderCallback(wxTextOutputStream *out)
: m_fp(out) : m_fp(out)
{ {
m_data = new wxObjectCodeReaderCallbackInternal; m_data = new wxObjectCodeReaderCallbackInternal;
} }
wxObjectCodeReaderCallback::~wxObjectCodeReaderCallback() wxObjectCodeReaderCallback::~wxObjectCodeReaderCallback()
{ {
delete m_data; delete m_data;
} }
void wxObjectCodeReaderCallback::AllocateObject(int objectID, wxClassInfo *classInfo, void wxObjectCodeReaderCallback::AllocateObject(int objectID, wxClassInfo *classInfo,
wxVariantBaseArray &WXUNUSED(metadata)) wxVariantBaseArray &WXUNUSED(metadata))
{ {
wxString objectName = wxString::Format( wxT("LocalObject_%d"), objectID ); wxString objectName = wxString::Format( wxT("LocalObject_%d"), objectID );
m_fp->WriteString( wxString::Format( wxT("\t%s *%s = new %s;\n"), m_fp->WriteString( wxString::Format( wxT("\t%s *%s = new %s;\n"),
classInfo->GetClassName(), classInfo->GetClassName(),
objectName.c_str(), objectName.c_str(),
classInfo->GetClassName()) ); classInfo->GetClassName()) );
m_data->SetObjectName( objectID, objectName ); m_data->SetObjectName( objectID, objectName );
} }
void wxObjectCodeReaderCallback::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo)) void wxObjectCodeReaderCallback::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))
{ {
m_fp->WriteString( wxString::Format( wxT("\tdelete %s;\n"), m_fp->WriteString( wxString::Format( wxT("\tdelete %s;\n"),
m_data->GetObjectName( objectID).c_str() ) ); m_data->GetObjectName( objectID).c_str() ) );
} }
wxString wxObjectCodeReaderCallback::ValueAsCode( const wxVariantBase &param ) wxString wxObjectCodeReaderCallback::ValueAsCode( const wxVariantBase &param )
{ {
wxString value; wxString value;
const wxTypeInfo* type = param.GetTypeInfo(); const wxTypeInfo* type = param.GetTypeInfo();
if ( type->GetKind() == wxT_CUSTOM ) if ( type->GetKind() == wxT_CUSTOM )
{ {
const wxCustomTypeInfo* cti = wx_dynamic_cast(const wxCustomTypeInfo*, type); const wxCustomTypeInfo* cti = wx_dynamic_cast(const wxCustomTypeInfo*, type);
if ( cti ) if ( cti )
{ {
value.Printf( wxT("%s(%s)"), cti->GetTypeName().c_str(), value.Printf( wxT("%s(%s)"), cti->GetTypeName().c_str(),
param.GetAsString().c_str() ); param.GetAsString().c_str() );
} }
else else
{ {
wxLogError ( _("Internal error, illegal wxCustomTypeInfo") ); wxLogError ( _("Internal error, illegal wxCustomTypeInfo") );
} }
} }
else if ( type->GetKind() == wxT_STRING ) else if ( type->GetKind() == wxT_STRING )
{ {
value.Printf( wxT("\"%s\""),param.GetAsString().c_str() ); value.Printf( wxT("\"%s\""),param.GetAsString().c_str() );
} }
else else
{ {
value.Printf( wxT("%s"), param.GetAsString().c_str() ); value.Printf( wxT("%s"), param.GetAsString().c_str() );
} }
return value; return value;
} }
void wxObjectCodeReaderCallback::CreateObject(int objectID, void wxObjectCodeReaderCallback::CreateObject(int objectID,
const wxClassInfo *WXUNUSED(classInfo), const wxClassInfo *WXUNUSED(classInfo),
int paramCount, int paramCount,
wxVariantBase *params, wxVariantBase *params,
int *objectIDValues, int *objectIDValues,
const wxClassInfo **WXUNUSED(objectClassInfos), const wxClassInfo **WXUNUSED(objectClassInfos),
wxVariantBaseArray &WXUNUSED(metadata) wxVariantBaseArray &WXUNUSED(metadata)
) )
{ {
int i; int i;
m_fp->WriteString( wxString::Format( wxT("\t%s->Create("), m_fp->WriteString( wxString::Format( wxT("\t%s->Create("),
m_data->GetObjectName(objectID).c_str() ) ); m_data->GetObjectName(objectID).c_str() ) );
for (i = 0; i < paramCount; i++) for (i = 0; i < paramCount; i++)
{ {
if ( objectIDValues[i] != wxInvalidObjectID ) if ( objectIDValues[i] != wxInvalidObjectID )
{ {
wxString str = wxString str =
wxString::Format( wxT("%s"), wxString::Format( wxT("%s"),
m_data->GetObjectName( objectIDValues[i] ).c_str() ); m_data->GetObjectName( objectIDValues[i] ).c_str() );
m_fp->WriteString( str ); m_fp->WriteString( str );
} }
else else
{ {
m_fp->WriteString( m_fp->WriteString(
wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) ); wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );
} }
if (i < paramCount - 1) if (i < paramCount - 1)
m_fp->WriteString( wxT(", ")); m_fp->WriteString( wxT(", "));
} }
m_fp->WriteString( wxT(");\n") ); m_fp->WriteString( wxT(");\n") );
} }
void wxObjectCodeReaderCallback::ConstructObject(int objectID, void wxObjectCodeReaderCallback::ConstructObject(int objectID,
const wxClassInfo *classInfo, const wxClassInfo *classInfo,
int paramCount, int paramCount,
wxVariantBase *params, wxVariantBase *params,
int *objectIDValues, int *objectIDValues,
const wxClassInfo **WXUNUSED(objectClassInfos), const wxClassInfo **WXUNUSED(objectClassInfos),
wxVariantBaseArray &WXUNUSED(metadata) wxVariantBaseArray &WXUNUSED(metadata)
) )
{ {
wxString objectName = wxString::Format( wxT("LocalObject_%d"), objectID ); wxString objectName = wxString::Format( wxT("LocalObject_%d"), objectID );
m_fp->WriteString( wxString::Format( wxT("\t%s *%s = new %s("), m_fp->WriteString( wxString::Format( wxT("\t%s *%s = new %s("),
classInfo->GetClassName(), classInfo->GetClassName(),
objectName.c_str(), objectName.c_str(),
classInfo->GetClassName()) ); classInfo->GetClassName()) );
m_data->SetObjectName( objectID, objectName ); m_data->SetObjectName( objectID, objectName );
int i; int i;
for (i = 0; i < paramCount; i++) for (i = 0; i < paramCount; i++)
{ {
if ( objectIDValues[i] != wxInvalidObjectID ) if ( objectIDValues[i] != wxInvalidObjectID )
m_fp->WriteString( wxString::Format( wxT("%s"), m_fp->WriteString( wxString::Format( wxT("%s"),
m_data->GetObjectName( objectIDValues[i] ).c_str() ) ); m_data->GetObjectName( objectIDValues[i] ).c_str() ) );
else else
{ {
m_fp->WriteString( m_fp->WriteString(
wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) ); wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );
} }
if (i < paramCount - 1) if (i < paramCount - 1)
m_fp->WriteString( wxT(", ") ); m_fp->WriteString( wxT(", ") );
} }
m_fp->WriteString( wxT(");\n") ); m_fp->WriteString( wxT(");\n") );
} }
void wxObjectCodeReaderCallback::SetProperty(int objectID, void wxObjectCodeReaderCallback::SetProperty(int objectID,
const wxClassInfo *WXUNUSED(classInfo), const wxClassInfo *WXUNUSED(classInfo),
const wxPropertyInfo* propertyInfo, const wxPropertyInfo* propertyInfo,
const wxVariantBase &value) const wxVariantBase &value)
{ {
m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"), m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
m_data->GetObjectName(objectID).c_str(), m_data->GetObjectName(objectID).c_str(),
propertyInfo->GetAccessor()->GetSetterName().c_str(), propertyInfo->GetAccessor()->GetSetterName().c_str(),
ValueAsCode(value).c_str()) ); ValueAsCode(value).c_str()) );
} }
void wxObjectCodeReaderCallback::SetPropertyAsObject(int objectID, void wxObjectCodeReaderCallback::SetPropertyAsObject(int objectID,
const wxClassInfo *WXUNUSED(classInfo), const wxClassInfo *WXUNUSED(classInfo),
const wxPropertyInfo* propertyInfo, const wxPropertyInfo* propertyInfo,
int valueObjectId) int valueObjectId)
{ {
if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT ) if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT )
m_fp->WriteString( wxString::Format( wxT("\t%s->%s(*%s);\n"), m_fp->WriteString( wxString::Format( wxT("\t%s->%s(*%s);\n"),
m_data->GetObjectName(objectID).c_str(), m_data->GetObjectName(objectID).c_str(),
propertyInfo->GetAccessor()->GetSetterName().c_str(), propertyInfo->GetAccessor()->GetSetterName().c_str(),
m_data->GetObjectName( valueObjectId).c_str() ) ); m_data->GetObjectName( valueObjectId).c_str() ) );
else else
m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"), m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
m_data->GetObjectName(objectID).c_str(), m_data->GetObjectName(objectID).c_str(),
propertyInfo->GetAccessor()->GetSetterName().c_str(), propertyInfo->GetAccessor()->GetSetterName().c_str(),
m_data->GetObjectName( valueObjectId).c_str() ) ); m_data->GetObjectName( valueObjectId).c_str() ) );
} }
void wxObjectCodeReaderCallback::AddToPropertyCollection( int objectID, void wxObjectCodeReaderCallback::AddToPropertyCollection( int objectID,
const wxClassInfo *WXUNUSED(classInfo), const wxClassInfo *WXUNUSED(classInfo),
const wxPropertyInfo* propertyInfo, const wxPropertyInfo* propertyInfo,
const wxVariantBase &value) const wxVariantBase &value)
{ {
m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"), m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
m_data->GetObjectName(objectID).c_str(), m_data->GetObjectName(objectID).c_str(),
propertyInfo->GetAccessor()->GetAdderName().c_str(), propertyInfo->GetAccessor()->GetAdderName().c_str(),
ValueAsCode(value).c_str()) ); ValueAsCode(value).c_str()) );
} }
// sets the corresponding property (value is an object) // sets the corresponding property (value is an object)
void wxObjectCodeReaderCallback:: void wxObjectCodeReaderCallback::
AddToPropertyCollectionAsObject(int WXUNUSED(objectID), AddToPropertyCollectionAsObject(int WXUNUSED(objectID),
const wxClassInfo *WXUNUSED(classInfo), const wxClassInfo *WXUNUSED(classInfo),
const wxPropertyInfo* WXUNUSED(propertyInfo), const wxPropertyInfo* WXUNUSED(propertyInfo),
int WXUNUSED(valueObjectId)) int WXUNUSED(valueObjectId))
{ {
// TODO // TODO
} }
void wxObjectCodeReaderCallback::SetConnect(int eventSourceObjectID, void wxObjectCodeReaderCallback::SetConnect(int eventSourceObjectID,
const wxClassInfo *WXUNUSED(eventSourceClassInfo), const wxClassInfo *WXUNUSED(eventSourceClassInfo),
const wxPropertyInfo *delegateInfo, const wxPropertyInfo *delegateInfo,
const wxClassInfo *eventSinkClassInfo, const wxClassInfo *eventSinkClassInfo,
const wxHandlerInfo* handlerInfo, const wxHandlerInfo* handlerInfo,
int eventSinkObjectID ) int eventSinkObjectID )
{ {
wxString ehsource = m_data->GetObjectName( eventSourceObjectID ); wxString ehsource = m_data->GetObjectName( eventSourceObjectID );
wxString ehsink = m_data->GetObjectName(eventSinkObjectID); wxString ehsink = m_data->GetObjectName(eventSinkObjectID);
wxString ehsinkClass = eventSinkClassInfo->GetClassName(); wxString ehsinkClass = eventSinkClassInfo->GetClassName();
const wxEventSourceTypeInfo *delegateTypeInfo = const wxEventSourceTypeInfo *delegateTypeInfo =
wx_dynamic_cast(const wxEventSourceTypeInfo*, delegateInfo->GetTypeInfo()); wx_dynamic_cast(const wxEventSourceTypeInfo*, delegateInfo->GetTypeInfo());
if ( delegateTypeInfo ) if ( delegateTypeInfo )
{ {
int eventType = delegateTypeInfo->GetEventType(); int eventType = delegateTypeInfo->GetEventType();
wxString handlerName = handlerInfo->GetName(); wxString handlerName = handlerInfo->GetName();
wxString code = wxString code =
wxString::Format( wxString::Format(
wxT("\t%s->Connect( %s->GetId(), %d, ") wxT("\t%s->Connect( %s->GetId(), %d, ")
wxT("(wxObjectEventFunction)(wxEventFunction) & %s::%s, NULL, %s );"), wxT("(wxObjectEventFunction)(wxEventFunction) & %s::%s, NULL, %s );"),
ehsource.c_str(), ehsource.c_str(), eventType, ehsinkClass.c_str(), ehsource.c_str(), ehsource.c_str(), eventType, ehsinkClass.c_str(),
handlerName.c_str(), ehsink.c_str() ); handlerName.c_str(), ehsink.c_str() );
m_fp->WriteString( code ); m_fp->WriteString( code );
} }
else else
{ {
wxLogError(_("delegate has no type info")); wxLogError(_("delegate has no type info"));
} }
} }

208
samples/xti/codereadercallback.h
View File

@@ -1,104 +1,104 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: wx/xtistrm.h // Name: wx/xtistrm.h
// Purpose: streaming runtime metadata information (extended class info) // Purpose: streaming runtime metadata information (extended class info)
// Author: Stefan Csomor // Author: Stefan Csomor
// Modified by: // Modified by:
// Created: 27/07/03 // Created: 27/07/03
// RCS-ID: $Id: xtistrm.h 47827 2007-07-31 19:25:09Z FM $ // RCS-ID: $Id$
// Copyright: (c) 2003 Stefan Csomor // Copyright: (c) 2003 Stefan Csomor
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _CODEDEPERSISTER_ #ifndef _CODEDEPERSISTER_
#define _CODEDEPERSISTER_ #define _CODEDEPERSISTER_
#include "wx/defs.h" #include "wx/defs.h"
/* /*
wxObjectCodeReaderCallback implements the callbacks that will depersist wxObjectCodeReaderCallback implements the callbacks that will depersist
an object into a C++ initialization function. an object into a C++ initialization function.
*/ */
class WXDLLIMPEXP_BASE wxTextOutputStream; class WXDLLIMPEXP_BASE wxTextOutputStream;
class WXDLLIMPEXP_BASE wxObjectCodeReaderCallback: public wxObjectWriterCallback class WXDLLIMPEXP_BASE wxObjectCodeReaderCallback: public wxObjectWriterCallback
{ {
private: private:
struct wxObjectCodeReaderCallbackInternal; struct wxObjectCodeReaderCallbackInternal;
wxObjectCodeReaderCallbackInternal * m_data; wxObjectCodeReaderCallbackInternal * m_data;
wxTextOutputStream *m_fp; wxTextOutputStream *m_fp;
wxString ValueAsCode( const wxVariantBase &param ); wxString ValueAsCode( const wxVariantBase &param );
public: public:
wxObjectCodeReaderCallback(wxTextOutputStream *out); wxObjectCodeReaderCallback(wxTextOutputStream *out);
virtual ~wxObjectCodeReaderCallback(); virtual ~wxObjectCodeReaderCallback();
// allocate the new object on the heap, that object will have the passed in ID // allocate the new object on the heap, that object will have the passed in ID
virtual void AllocateObject(int objectID, wxClassInfo *classInfo, virtual void AllocateObject(int objectID, wxClassInfo *classInfo,
wxVariantBaseArray &metadata); wxVariantBaseArray &metadata);
// initialize the already allocated object having the ID objectID // initialize the already allocated object having the ID objectID
// with the Create method creation parameters which are objects are // with the Create method creation parameters which are objects are
// having their Ids passed in objectIDValues having objectId <> wxInvalidObjectID // having their Ids passed in objectIDValues having objectId <> wxInvalidObjectID
virtual void CreateObject(int objectID, virtual void CreateObject(int objectID,
const wxClassInfo *classInfo, const wxClassInfo *classInfo,
int paramCount, int paramCount,
wxVariantBase *variantValues, wxVariantBase *variantValues,
int *objectIDValues, int *objectIDValues,
const wxClassInfo **objectClassInfos, const wxClassInfo **objectClassInfos,
wxVariantBaseArray &metadata wxVariantBaseArray &metadata
); );
// construct the new object on the heap, that object will have the // construct the new object on the heap, that object will have the
// passed in ID (for objects that don't support allocate-create type // passed in ID (for objects that don't support allocate-create type
// of creation) creation parameters which are objects are having their // of creation) creation parameters which are objects are having their
// Ids passed in objectIDValues having objectId <> wxInvalidObjectID // Ids passed in objectIDValues having objectId <> wxInvalidObjectID
virtual void ConstructObject(int objectID, virtual void ConstructObject(int objectID,
const wxClassInfo *classInfo, const wxClassInfo *classInfo,
int paramCount, int paramCount,
wxVariantBase *VariantValues, wxVariantBase *VariantValues,
int *objectIDValues, int *objectIDValues,
const wxClassInfo **objectClassInfos, const wxClassInfo **objectClassInfos,
wxVariantBaseArray &metadata); wxVariantBaseArray &metadata);
// destroy the heap-allocated object having the ID objectID, this may // destroy the heap-allocated object having the ID objectID, this may
// be used if an object is embedded in another object and set via value // be used if an object is embedded in another object and set via value
// semantics, so the intermediate object can be destroyed after safely // semantics, so the intermediate object can be destroyed after safely
virtual void DestroyObject(int objectID, wxClassInfo *classInfo); virtual void DestroyObject(int objectID, wxClassInfo *classInfo);
// set the corresponding property // set the corresponding property
virtual void SetProperty(int objectID, virtual void SetProperty(int objectID,
const wxClassInfo *classInfo, const wxClassInfo *classInfo,
const wxPropertyInfo* propertyInfo, const wxPropertyInfo* propertyInfo,
const wxVariantBase &variantValue); const wxVariantBase &variantValue);
// sets the corresponding property (value is an object) // sets the corresponding property (value is an object)
virtual void SetPropertyAsObject(int objectId, virtual void SetPropertyAsObject(int objectId,
const wxClassInfo *classInfo, const wxClassInfo *classInfo,
const wxPropertyInfo* propertyInfo, const wxPropertyInfo* propertyInfo,
int valueObjectId); int valueObjectId);
// adds an element to a property collection // adds an element to a property collection
virtual void AddToPropertyCollection( int objectID, virtual void AddToPropertyCollection( int objectID,
const wxClassInfo *classInfo, const wxClassInfo *classInfo,
const wxPropertyInfo* propertyInfo, const wxPropertyInfo* propertyInfo,
const wxVariantBase &VariantValue); const wxVariantBase &VariantValue);
// sets the corresponding property (value is an object) // sets the corresponding property (value is an object)
virtual void AddToPropertyCollectionAsObject(int objectID, virtual void AddToPropertyCollectionAsObject(int objectID,
const wxClassInfo *classInfo, const wxClassInfo *classInfo,
const wxPropertyInfo* propertyInfo, const wxPropertyInfo* propertyInfo,
int valueObjectId); int valueObjectId);
// sets the corresponding event handler // sets the corresponding event handler
virtual void SetConnect(int eventSourceObjectID, virtual void SetConnect(int eventSourceObjectID,
const wxClassInfo *eventSourceClassInfo, const wxClassInfo *eventSourceClassInfo,
const wxPropertyInfo *delegateInfo, const wxPropertyInfo *delegateInfo,
const wxClassInfo *eventSinkClassInfo, const wxClassInfo *eventSinkClassInfo,
const wxHandlerInfo* handlerInfo, const wxHandlerInfo* handlerInfo,
int eventSinkObjectID ); int eventSinkObjectID );
}; };
#endif #endif

2
samples/xti/xti.bkl
View File

@@ -1,5 +1,5 @@
<?xml version="1.0" ?> <?xml version="1.0" ?>
<!-- $Id: xti.bkl 48186 2007-08-19 19:59:54Z FM $ --> <!-- $Id$ -->
<makefile> <makefile>

2
samples/xti/xti.cpp
View File

@@ -4,7 +4,7 @@
// Author: Stefan Csomor, Francesco Montorsi // Author: Stefan Csomor, Francesco Montorsi
// Modified by: // Modified by:
// Created: 13/5/2007 // Created: 13/5/2007
// RCS-ID: $Id: xti.cpp 48407 2007-08-26 23:17:23Z FM $ // RCS-ID: $Id$
// Copyright: (c) Stefan Csomor, Francesco Montorsi // Copyright: (c) Stefan Csomor, Francesco Montorsi
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////

186
src/common/bmpbtncmn.cpp
View File

@@ -1,93 +1,93 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/bmpbtncmn.cpp // Name: src/common/bmpbtncmn.cpp
// Purpose: wxBitmapButton common code // Purpose: wxBitmapButton common code
// Author: Julian Smart // Author: Julian Smart
// Modified by: // Modified by:
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id: bmpbuttn.cpp 45338 2007-04-08 22:18:35Z VZ $ // RCS-ID: $Id$
// Copyright: (c) Julian Smart // Copyright: (c) Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_BMPBUTTON #if wxUSE_BMPBUTTON
#include "wx/bmpbuttn.h" #include "wx/bmpbuttn.h"
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/log.h" #include "wx/log.h"
#include "wx/dcmemory.h" #include "wx/dcmemory.h"
#include "wx/image.h" #include "wx/image.h"
#endif #endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxBitmapButtonStyle ) wxDEFINE_FLAGS( wxBitmapButtonStyle )
wxBEGIN_FLAGS( wxBitmapButtonStyle ) wxBEGIN_FLAGS( wxBitmapButtonStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxFLAGS_MEMBER(wxBU_AUTODRAW) wxFLAGS_MEMBER(wxBU_AUTODRAW)
wxFLAGS_MEMBER(wxBU_LEFT) wxFLAGS_MEMBER(wxBU_LEFT)
wxFLAGS_MEMBER(wxBU_RIGHT) wxFLAGS_MEMBER(wxBU_RIGHT)
wxFLAGS_MEMBER(wxBU_TOP) wxFLAGS_MEMBER(wxBU_TOP)
wxFLAGS_MEMBER(wxBU_BOTTOM) wxFLAGS_MEMBER(wxBU_BOTTOM)
wxEND_FLAGS( wxBitmapButtonStyle ) wxEND_FLAGS( wxBitmapButtonStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxBitmapButton, wxButton, "wx/bmpbuttn.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxBitmapButton, wxButton, "wx/bmpbuttn.h")
wxBEGIN_PROPERTIES_TABLE(wxBitmapButton) wxBEGIN_PROPERTIES_TABLE(wxBitmapButton)
wxPROPERTY_FLAGS( WindowStyle, wxBitmapButtonStyle, long, \ wxPROPERTY_FLAGS( WindowStyle, wxBitmapButtonStyle, long, \
SetWindowStyleFlag, GetWindowStyleFlag, \ SetWindowStyleFlag, GetWindowStyleFlag, \
wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, wxT("Helpstring"), \ wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, wxT("Helpstring"), \
wxT("group")) // style wxT("group")) // style
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxBitmapButton) wxEMPTY_HANDLERS_TABLE(wxBitmapButton)
wxCONSTRUCTOR_5( wxBitmapButton, wxWindow*, Parent, wxWindowID, Id, \ wxCONSTRUCTOR_5( wxBitmapButton, wxWindow*, Parent, wxWindowID, Id, \
wxBitmap, Bitmap, wxPoint, Position, wxSize, Size ) wxBitmap, Bitmap, wxPoint, Position, wxSize, Size )
/* /*
TODO PROPERTIES : TODO PROPERTIES :
long "style" , wxBU_AUTODRAW long "style" , wxBU_AUTODRAW
bool "default" , 0 bool "default" , 0
bitmap "selected" , bitmap "selected" ,
bitmap "focus" , bitmap "focus" ,
bitmap "disabled" , bitmap "disabled" ,
*/ */
#endif // wxUSE_BMPBUTTON #endif // wxUSE_BMPBUTTON

178
src/common/checkboxcmn.cpp
View File

@@ -1,89 +1,89 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/checkboxcmn.cpp // Name: src/common/checkboxcmn.cpp
// Purpose: wxCheckBox common code // Purpose: wxCheckBox common code
// Author: Julian Smart // Author: Julian Smart
// Modified by: // Modified by:
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id: checkbox.cpp 45492 2007-04-16 00:53:05Z VZ $ // RCS-ID: $Id$
// Copyright: (c) Julian Smart // Copyright: (c) Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ============================================================================ // ============================================================================
// declarations // declarations
// ============================================================================ // ============================================================================
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// headers // headers
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_CHECKBOX #if wxUSE_CHECKBOX
#include "wx/checkbox.h" #include "wx/checkbox.h"
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxCheckBoxStyle ) wxDEFINE_FLAGS( wxCheckBoxStyle )
wxBEGIN_FLAGS( wxCheckBoxStyle ) wxBEGIN_FLAGS( wxCheckBoxStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxNO_BORDER) wxFLAGS_MEMBER(wxNO_BORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxNO_FULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxNO_FULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxEND_FLAGS( wxCheckBoxStyle ) wxEND_FLAGS( wxCheckBoxStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxCheckBox, wxControl, "wx/checkbox.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxCheckBox, wxControl, "wx/checkbox.h")
wxBEGIN_PROPERTIES_TABLE(wxCheckBox) wxBEGIN_PROPERTIES_TABLE(wxCheckBox)
wxEVENT_PROPERTY( Click, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEvent ) wxEVENT_PROPERTY( Click, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEvent )
wxPROPERTY( Font, wxFont, SetFont, GetFont, wxEMPTY_PARAMETER_VALUE, \ wxPROPERTY( Font, wxFont, SetFont, GetFont, wxEMPTY_PARAMETER_VALUE, \
0 /*flags*/, wxT("Helpstring"), wxT("group")) 0 /*flags*/, wxT("Helpstring"), wxT("group"))
wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxString(), \ wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxString(), \
0 /*flags*/, wxT("Helpstring"), wxT("group")) 0 /*flags*/, wxT("Helpstring"), wxT("group"))
wxPROPERTY( Value,bool, SetValue, GetValue, wxEMPTY_PARAMETER_VALUE, \ wxPROPERTY( Value,bool, SetValue, GetValue, wxEMPTY_PARAMETER_VALUE, \
0 /*flags*/, wxT("Helpstring"), wxT("group")) 0 /*flags*/, wxT("Helpstring"), wxT("group"))
wxPROPERTY_FLAGS( WindowStyle, wxCheckBoxStyle, long, SetWindowStyleFlag, \ wxPROPERTY_FLAGS( WindowStyle, wxCheckBoxStyle, long, SetWindowStyleFlag, \
GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) // style wxT("Helpstring"), wxT("group")) // style
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxCheckBox) wxEMPTY_HANDLERS_TABLE(wxCheckBox)
wxCONSTRUCTOR_6( wxCheckBox, wxWindow*, Parent, wxWindowID, Id, \ wxCONSTRUCTOR_6( wxCheckBox, wxWindow*, Parent, wxWindowID, Id, \
wxString, Label, wxPoint, Position, wxSize, Size, long, WindowStyle ) wxString, Label, wxPoint, Position, wxSize, Size, long, WindowStyle )
#endif // wxUSE_CHECKBOX #endif // wxUSE_CHECKBOX

204
src/common/checklstcmn.cpp
View File

@@ -1,102 +1,102 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Name: src/common/checklstcmn.cpp // Name: src/common/checklstcmn.cpp
// Purpose: wxCheckListBox common code // Purpose: wxCheckListBox common code
// Author: Vadim Zeitlin // Author: Vadim Zeitlin
// Modified by: // Modified by:
// Created: 16.11.97 // Created: 16.11.97
// RCS-ID: $Id: checklst.cpp 45515 2007-04-17 01:19:43Z VZ $ // RCS-ID: $Id$
// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence: wxWindows licence // Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// ============================================================================ // ============================================================================
// declarations // declarations
// ============================================================================ // ============================================================================
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// headers // headers
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_CHECKLISTBOX #if wxUSE_CHECKLISTBOX
#include "wx/checklst.h" #include "wx/checklst.h"
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/object.h" #include "wx/object.h"
#include "wx/colour.h" #include "wx/colour.h"
#include "wx/font.h" #include "wx/font.h"
#include "wx/bitmap.h" #include "wx/bitmap.h"
#include "wx/window.h" #include "wx/window.h"
#include "wx/listbox.h" #include "wx/listbox.h"
#include "wx/dcmemory.h" #include "wx/dcmemory.h"
#include "wx/settings.h" #include "wx/settings.h"
#include "wx/log.h" #include "wx/log.h"
#endif #endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxCheckListBoxStyle ) wxDEFINE_FLAGS( wxCheckListBoxStyle )
wxBEGIN_FLAGS( wxCheckListBoxStyle ) wxBEGIN_FLAGS( wxCheckListBoxStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxFLAGS_MEMBER(wxLB_SINGLE) wxFLAGS_MEMBER(wxLB_SINGLE)
wxFLAGS_MEMBER(wxLB_MULTIPLE) wxFLAGS_MEMBER(wxLB_MULTIPLE)
wxFLAGS_MEMBER(wxLB_EXTENDED) wxFLAGS_MEMBER(wxLB_EXTENDED)
wxFLAGS_MEMBER(wxLB_HSCROLL) wxFLAGS_MEMBER(wxLB_HSCROLL)
wxFLAGS_MEMBER(wxLB_ALWAYS_SB) wxFLAGS_MEMBER(wxLB_ALWAYS_SB)
wxFLAGS_MEMBER(wxLB_NEEDED_SB) wxFLAGS_MEMBER(wxLB_NEEDED_SB)
wxFLAGS_MEMBER(wxLB_SORT) wxFLAGS_MEMBER(wxLB_SORT)
wxFLAGS_MEMBER(wxLB_OWNERDRAW) wxFLAGS_MEMBER(wxLB_OWNERDRAW)
wxEND_FLAGS( wxCheckListBoxStyle ) wxEND_FLAGS( wxCheckListBoxStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxCheckListBox, wxListBox, "wx/checklst.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxCheckListBox, wxListBox, "wx/checklst.h")
wxBEGIN_PROPERTIES_TABLE(wxCheckListBox) wxBEGIN_PROPERTIES_TABLE(wxCheckListBox)
wxEVENT_PROPERTY( Toggle, wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, wxCommandEvent ) wxEVENT_PROPERTY( Toggle, wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, wxCommandEvent )
wxPROPERTY_FLAGS( WindowStyle, wxCheckListBoxStyle, long, SetWindowStyleFlag, \ wxPROPERTY_FLAGS( WindowStyle, wxCheckListBoxStyle, long, SetWindowStyleFlag, \
GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, wxLB_OWNERDRAW /*flags*/, \ GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, wxLB_OWNERDRAW /*flags*/, \
wxT("Helpstring"), wxT("group")) // style wxT("Helpstring"), wxT("group")) // style
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxCheckListBox) wxEMPTY_HANDLERS_TABLE(wxCheckListBox)
wxCONSTRUCTOR_4( wxCheckListBox, wxWindow*, Parent, wxWindowID, Id, \ wxCONSTRUCTOR_4( wxCheckListBox, wxWindow*, Parent, wxWindowID, Id, \
wxPoint, Position, wxSize, Size ) wxPoint, Position, wxSize, Size )
#endif #endif

170
src/common/dirctrlcmn.cpp
View File

@@ -1,85 +1,85 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/dirctrlcmn.cpp // Name: src/common/dirctrlcmn.cpp
// Purpose: wxGenericDirCtrl common code // Purpose: wxGenericDirCtrl common code
// Author: Harm van der Heijden, Robert Roebling, Julian Smart // Author: Harm van der Heijden, Robert Roebling, Julian Smart
// Modified by: // Modified by:
// Created: 12/12/98 // Created: 12/12/98
// RCS-ID: $Id: dirctrlg.cpp 45395 2007-04-11 00:23:19Z VZ $ // RCS-ID: $Id$
// Copyright: (c) Harm van der Heijden, Robert Roebling and Julian Smart // Copyright: (c) Harm van der Heijden, Robert Roebling and Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_DIRDLG || wxUSE_FILEDLG #if wxUSE_DIRDLG || wxUSE_FILEDLG
#include "wx/generic/dirctrlg.h" #include "wx/generic/dirctrlg.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// XTI // XTI
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxGenericDirCtrlStyle ) wxDEFINE_FLAGS( wxGenericDirCtrlStyle )
wxBEGIN_FLAGS( wxGenericDirCtrlStyle ) wxBEGIN_FLAGS( wxGenericDirCtrlStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxFLAGS_MEMBER(wxDIRCTRL_DIR_ONLY) wxFLAGS_MEMBER(wxDIRCTRL_DIR_ONLY)
wxFLAGS_MEMBER(wxDIRCTRL_3D_INTERNAL) wxFLAGS_MEMBER(wxDIRCTRL_3D_INTERNAL)
wxFLAGS_MEMBER(wxDIRCTRL_SELECT_FIRST) wxFLAGS_MEMBER(wxDIRCTRL_SELECT_FIRST)
wxFLAGS_MEMBER(wxDIRCTRL_SHOW_FILTERS) wxFLAGS_MEMBER(wxDIRCTRL_SHOW_FILTERS)
wxEND_FLAGS( wxGenericDirCtrlStyle ) wxEND_FLAGS( wxGenericDirCtrlStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxGenericDirCtrl, wxControl, "wx/dirctrl.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxGenericDirCtrl, wxControl, "wx/dirctrl.h")
wxBEGIN_PROPERTIES_TABLE(wxGenericDirCtrl) wxBEGIN_PROPERTIES_TABLE(wxGenericDirCtrl)
wxHIDE_PROPERTY( Children ) wxHIDE_PROPERTY( Children )
wxPROPERTY( DefaultPath, wxString, SetDefaultPath, GetDefaultPath, \ wxPROPERTY( DefaultPath, wxString, SetDefaultPath, GetDefaultPath, \
wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, wxT("Helpstring"), wxT("group")) wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, wxT("Helpstring"), wxT("group"))
wxPROPERTY( Filter, wxString, SetFilter, GetFilter, wxEMPTY_PARAMETER_VALUE, \ wxPROPERTY( Filter, wxString, SetFilter, GetFilter, wxEMPTY_PARAMETER_VALUE, \
0 /*flags*/, wxT("Helpstring"), wxT("group") ) 0 /*flags*/, wxT("Helpstring"), wxT("group") )
wxPROPERTY( DefaultFilter, int, SetFilterIndex, GetFilterIndex, \ wxPROPERTY( DefaultFilter, int, SetFilterIndex, GetFilterIndex, \
wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, wxT("Helpstring"), wxT("group") ) wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, wxT("Helpstring"), wxT("group") )
wxPROPERTY_FLAGS( WindowStyle, wxGenericDirCtrlStyle, long, SetWindowStyleFlag, \ wxPROPERTY_FLAGS( WindowStyle, wxGenericDirCtrlStyle, long, SetWindowStyleFlag, \
GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0, wxT("Helpstring"), \ GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0, wxT("Helpstring"), \
wxT("group") ) wxT("group") )
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxGenericDirCtrl) wxEMPTY_HANDLERS_TABLE(wxGenericDirCtrl)
wxCONSTRUCTOR_8( wxGenericDirCtrl, wxWindow*, Parent, wxWindowID, Id, \ wxCONSTRUCTOR_8( wxGenericDirCtrl, wxWindow*, Parent, wxWindowID, Id, \
wxString, DefaultPath, wxPoint, Position, wxSize, Size, \ wxString, DefaultPath, wxPoint, Position, wxSize, Size, \
long, WindowStyle, wxString, Filter, int, DefaultFilter ) long, WindowStyle, wxString, Filter, int, DefaultFilter )
#endif // wxUSE_DIRDLG || wxUSE_FILEDLG #endif // wxUSE_DIRDLG || wxUSE_FILEDLG

178
src/common/gridcmn.cpp
View File

@@ -1,89 +1,89 @@
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// Name: src/common/gridcmn.cpp // Name: src/common/gridcmn.cpp
// Purpose: wxGrid common code // Purpose: wxGrid common code
// Author: Michael Bedward (based on code by Julian Smart, Robin Dunn) // Author: Michael Bedward (based on code by Julian Smart, Robin Dunn)
// Modified by: Robin Dunn, Vadim Zeitlin, Santiago Palacios // Modified by: Robin Dunn, Vadim Zeitlin, Santiago Palacios
// Created: 1/08/1999 // Created: 1/08/1999
// RCS-ID: $Id: grid.cpp 45814 2007-05-05 10:16:40Z RR $ // RCS-ID: $Id$
// Copyright: (c) Michael Bedward (mbedward@ozemail.com.au) // Copyright: (c) Michael Bedward (mbedward@ozemail.com.au)
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx/wx.h". // For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_GRID #if wxUSE_GRID
#include "wx/grid.h" #include "wx/grid.h"
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/utils.h" #include "wx/utils.h"
#include "wx/dcclient.h" #include "wx/dcclient.h"
#include "wx/settings.h" #include "wx/settings.h"
#include "wx/log.h" #include "wx/log.h"
#include "wx/textctrl.h" #include "wx/textctrl.h"
#include "wx/checkbox.h" #include "wx/checkbox.h"
#include "wx/combobox.h" #include "wx/combobox.h"
#include "wx/valtext.h" #include "wx/valtext.h"
#include "wx/intl.h" #include "wx/intl.h"
#include "wx/math.h" #include "wx/math.h"
#include "wx/listbox.h" #include "wx/listbox.h"
#endif #endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxGridStyle ) wxDEFINE_FLAGS( wxGridStyle )
wxBEGIN_FLAGS( wxGridStyle ) wxBEGIN_FLAGS( wxGridStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB)
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxEND_FLAGS( wxGridStyle ) wxEND_FLAGS( wxGridStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxGrid, wxScrolledWindow, "wx/grid.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxGrid, wxScrolledWindow, "wx/grid.h")
wxBEGIN_PROPERTIES_TABLE(wxGrid) wxBEGIN_PROPERTIES_TABLE(wxGrid)
wxHIDE_PROPERTY( Children ) wxHIDE_PROPERTY( Children )
wxPROPERTY_FLAGS( WindowStyle, wxGridStyle, long, SetWindowStyleFlag, \ wxPROPERTY_FLAGS( WindowStyle, wxGridStyle, long, SetWindowStyleFlag, \
GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) // style wxT("Helpstring"), wxT("group")) // style
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxGrid) wxEMPTY_HANDLERS_TABLE(wxGrid)
wxCONSTRUCTOR_5( wxGrid, wxWindow*, Parent, wxWindowID, Id, wxPoint, Position, \ wxCONSTRUCTOR_5( wxGrid, wxWindow*, Parent, wxWindowID, Id, wxPoint, Position, \
wxSize, Size, long, WindowStyle ) wxSize, Size, long, WindowStyle )
/* /*
TODO : Expose more information of a list's layout, etc. via appropriate objects (e.g., NotebookPageInfo) TODO : Expose more information of a list's layout, etc. via appropriate objects (e.g., NotebookPageInfo)
*/ */
#endif // wxUSE_GRID #endif // wxUSE_GRID

110
src/common/odcombocmn.cpp
View File

@@ -1,55 +1,55 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/odcombocmn.cpp // Name: src/common/odcombocmn.cpp
// Purpose: wxOwnerDrawnComboBox common code // Purpose: wxOwnerDrawnComboBox common code
// Author: Jaakko Salli // Author: Jaakko Salli
// Modified by: // Modified by:
// Created: Apr-30-2006 // Created: Apr-30-2006
// RCS-ID: $Id: odcombo.cpp 45397 2007-04-11 10:32:01Z MBN $ // RCS-ID: $Id$
// Copyright: (c) 2005 Jaakko Salli // Copyright: (c) 2005 Jaakko Salli
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ============================================================================ // ============================================================================
// declarations // declarations
// ============================================================================ // ============================================================================
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// headers // headers
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_ODCOMBOBOX #if wxUSE_ODCOMBOBOX
#include "wx/odcombo.h" #include "wx/odcombo.h"
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/log.h" #include "wx/log.h"
#include "wx/combobox.h" #include "wx/combobox.h"
#include "wx/dcclient.h" #include "wx/dcclient.h"
#include "wx/settings.h" #include "wx/settings.h"
#include "wx/dialog.h" #include "wx/dialog.h"
#endif #endif
#include "wx/combo.h" #include "wx/combo.h"
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxIMPLEMENT_DYNAMIC_CLASS2_XTI(wxOwnerDrawnComboBox, wxComboCtrl, \ wxIMPLEMENT_DYNAMIC_CLASS2_XTI(wxOwnerDrawnComboBox, wxComboCtrl, \
wxControlWithItems, "wx/odcombo.h") wxControlWithItems, "wx/odcombo.h")
wxBEGIN_PROPERTIES_TABLE(wxOwnerDrawnComboBox) wxBEGIN_PROPERTIES_TABLE(wxOwnerDrawnComboBox)
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxOwnerDrawnComboBox) wxEMPTY_HANDLERS_TABLE(wxOwnerDrawnComboBox)
wxCONSTRUCTOR_5( wxOwnerDrawnComboBox , wxWindow* , Parent , wxWindowID , \ wxCONSTRUCTOR_5( wxOwnerDrawnComboBox , wxWindow* , Parent , wxWindowID , \
Id , wxString , Value , wxPoint , Position , wxSize , Size ) Id , wxString , Value , wxPoint , Position , wxSize , Size )
#endif // wxUSE_ODCOMBOBOX #endif // wxUSE_ODCOMBOBOX

174
src/common/panelcmn.cpp
View File

@@ -1,87 +1,87 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/panelcmn.cpp // Name: src/common/panelcmn.cpp
// Purpose: wxPanel common code // Purpose: wxPanel common code
// Author: Julian Smart, Robert Roebling, Vadim Zeitlin // Author: Julian Smart, Robert Roebling, Vadim Zeitlin
// Modified by: // Modified by:
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id: panelg.cpp 45056 2007-03-25 22:41:11Z VZ $ // RCS-ID: $Id$
// Copyright: (c) Julian Smart // Copyright: (c) Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ============================================================================ // ============================================================================
// declarations // declarations
// ============================================================================ // ============================================================================
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// headers // headers
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/object.h" #include "wx/object.h"
#include "wx/font.h" #include "wx/font.h"
#include "wx/colour.h" #include "wx/colour.h"
#include "wx/settings.h" #include "wx/settings.h"
#include "wx/log.h" #include "wx/log.h"
#include "wx/panel.h" #include "wx/panel.h"
#include "wx/containr.h" #include "wx/containr.h"
#endif #endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxPanelStyle ) wxDEFINE_FLAGS( wxPanelStyle )
wxBEGIN_FLAGS( wxPanelStyle ) wxBEGIN_FLAGS( wxPanelStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB)
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxEND_FLAGS( wxPanelStyle ) wxEND_FLAGS( wxPanelStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxPanel, wxWindow, "wx/panel.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxPanel, wxWindow, "wx/panel.h")
wxBEGIN_PROPERTIES_TABLE(wxPanel) wxBEGIN_PROPERTIES_TABLE(wxPanel)
wxPROPERTY_FLAGS( WindowStyle, wxPanelStyle, long, \ wxPROPERTY_FLAGS( WindowStyle, wxPanelStyle, long, \
SetWindowStyleFlag, GetWindowStyleFlag, \ SetWindowStyleFlag, GetWindowStyleFlag, \
wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) // style wxT("Helpstring"), wxT("group")) // style
// style wxTAB_TRAVERSAL // style wxTAB_TRAVERSAL
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxPanel) wxEMPTY_HANDLERS_TABLE(wxPanel)
wxCONSTRUCTOR_6( wxPanel, wxWindow*, Parent, wxWindowID, Id, \ wxCONSTRUCTOR_6( wxPanel, wxWindow*, Parent, wxWindowID, Id, \
wxPoint, Position, wxSize, Size, long, WindowStyle, \ wxPoint, Position, wxSize, Size, long, WindowStyle, \
wxString, Name) wxString, Name)

186
src/common/radiobtncmn.cpp
View File

@@ -1,93 +1,93 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/radiobtncmn.cpp // Name: src/common/radiobtncmn.cpp
// Purpose: wxRadioButton common code // Purpose: wxRadioButton common code
// Author: Julian Smart // Author: Julian Smart
// Modified by: // Modified by:
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id: radiobut.cpp 41144 2006-09-10 23:08:13Z VZ $ // RCS-ID: $Id$
// Copyright: (c) Julian Smart // Copyright: (c) Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ============================================================================ // ============================================================================
// declarations // declarations
// ============================================================================ // ============================================================================
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// headers // headers
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_RADIOBTN #if wxUSE_RADIOBTN
#include "wx/radiobut.h" #include "wx/radiobut.h"
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/settings.h" #include "wx/settings.h"
#include "wx/dcscreen.h" #include "wx/dcscreen.h"
#endif #endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxRadioButtonStyle ) wxDEFINE_FLAGS( wxRadioButtonStyle )
wxBEGIN_FLAGS( wxRadioButtonStyle ) wxBEGIN_FLAGS( wxRadioButtonStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxFLAGS_MEMBER(wxRB_GROUP) wxFLAGS_MEMBER(wxRB_GROUP)
wxEND_FLAGS( wxRadioButtonStyle ) wxEND_FLAGS( wxRadioButtonStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxRadioButton, wxControl, "wx/radiobut.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxRadioButton, wxControl, "wx/radiobut.h")
wxBEGIN_PROPERTIES_TABLE(wxRadioButton) wxBEGIN_PROPERTIES_TABLE(wxRadioButton)
wxEVENT_PROPERTY( Click, wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEvent ) wxEVENT_PROPERTY( Click, wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEvent )
wxPROPERTY( Font, wxFont, SetFont, GetFont , wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ wxPROPERTY( Font, wxFont, SetFont, GetFont , wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) wxT("Helpstring"), wxT("group"))
wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxString(), 0 /*flags*/, \ wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxString(), 0 /*flags*/, \
wxT("Helpstring"), wxT("group") ) wxT("Helpstring"), wxT("group") )
wxPROPERTY( Value,bool, SetValue, GetValue, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ wxPROPERTY( Value,bool, SetValue, GetValue, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
wxT("Helpstring"), wxT("group") ) wxT("Helpstring"), wxT("group") )
wxPROPERTY_FLAGS( WindowStyle, wxRadioButtonStyle, long, SetWindowStyleFlag, \ wxPROPERTY_FLAGS( WindowStyle, wxRadioButtonStyle, long, SetWindowStyleFlag, \
GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) // style wxT("Helpstring"), wxT("group")) // style
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxRadioButton) wxEMPTY_HANDLERS_TABLE(wxRadioButton)
wxCONSTRUCTOR_6( wxRadioButton, wxWindow*, Parent, wxWindowID, Id, \ wxCONSTRUCTOR_6( wxRadioButton, wxWindow*, Parent, wxWindowID, Id, \
wxString, Label, wxPoint, Position, wxSize, Size, long, WindowStyle ) wxString, Label, wxPoint, Position, wxSize, Size, long, WindowStyle )
#endif // wxUSE_RADIOBTN #endif // wxUSE_RADIOBTN

180
src/common/scrolbarcmn.cpp
View File

@@ -1,90 +1,90 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/scrolbarcmn.cpp // Name: src/common/scrolbarcmn.cpp
// Purpose: wxScrollBar common code // Purpose: wxScrollBar common code
// Author: Julian Smart // Author: Julian Smart
// Modified by: // Modified by:
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id: scrolbar.cpp 39476 2006-05-30 13:43:18Z ABX $ // RCS-ID: $Id$
// Copyright: (c) Julian Smart // Copyright: (c) Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_SCROLLBAR #if wxUSE_SCROLLBAR
#include "wx/scrolbar.h" #include "wx/scrolbar.h"
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/utils.h" #include "wx/utils.h"
#include "wx/settings.h" #include "wx/settings.h"
#endif #endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxScrollBarStyle ) wxDEFINE_FLAGS( wxScrollBarStyle )
wxBEGIN_FLAGS( wxScrollBarStyle ) wxBEGIN_FLAGS( wxScrollBarStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxFLAGS_MEMBER(wxSB_HORIZONTAL) wxFLAGS_MEMBER(wxSB_HORIZONTAL)
wxFLAGS_MEMBER(wxSB_VERTICAL) wxFLAGS_MEMBER(wxSB_VERTICAL)
wxEND_FLAGS( wxScrollBarStyle ) wxEND_FLAGS( wxScrollBarStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxScrollBar, wxControl, "wx/scrolbar.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxScrollBar, wxControl, "wx/scrolbar.h")
wxBEGIN_PROPERTIES_TABLE(wxScrollBar) wxBEGIN_PROPERTIES_TABLE(wxScrollBar)
wxEVENT_RANGE_PROPERTY( Scroll, wxEVT_SCROLL_TOP, \ wxEVENT_RANGE_PROPERTY( Scroll, wxEVT_SCROLL_TOP, \
wxEVT_SCROLL_CHANGED, wxScrollEvent ) wxEVT_SCROLL_CHANGED, wxScrollEvent )
wxPROPERTY( ThumbPosition, int, SetThumbPosition, GetThumbPosition, 0, \ wxPROPERTY( ThumbPosition, int, SetThumbPosition, GetThumbPosition, 0, \
0 /*flags*/, wxT("Helpstring"), wxT("group")) 0 /*flags*/, wxT("Helpstring"), wxT("group"))
wxPROPERTY( Range, int, SetRange, GetRange, 0, \ wxPROPERTY( Range, int, SetRange, GetRange, 0, \
0 /*flags*/, wxT("Helpstring"), wxT("group")) 0 /*flags*/, wxT("Helpstring"), wxT("group"))
wxPROPERTY( ThumbSize, int, SetThumbSize, GetThumbSize, 0, \ wxPROPERTY( ThumbSize, int, SetThumbSize, GetThumbSize, 0, \
0 /*flags*/, wxT("Helpstring"), wxT("group")) 0 /*flags*/, wxT("Helpstring"), wxT("group"))
wxPROPERTY( PageSize, int, SetPageSize, GetPageSize, 0, \ wxPROPERTY( PageSize, int, SetPageSize, GetPageSize, 0, \
0 /*flags*/, wxT("Helpstring"), wxT("group")) 0 /*flags*/, wxT("Helpstring"), wxT("group"))
wxPROPERTY_FLAGS( WindowStyle, wxScrollBarStyle, long, SetWindowStyleFlag, \ wxPROPERTY_FLAGS( WindowStyle, wxScrollBarStyle, long, SetWindowStyleFlag, \
GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) // style wxT("Helpstring"), wxT("group")) // style
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxScrollBar) wxEMPTY_HANDLERS_TABLE(wxScrollBar)
wxCONSTRUCTOR_5( wxScrollBar, wxWindow*, Parent, wxWindowID, Id, \ wxCONSTRUCTOR_5( wxScrollBar, wxWindow*, Parent, wxWindowID, Id, \
wxPoint, Position, wxSize, Size, long, WindowStyle ) wxPoint, Position, wxSize, Size, long, WindowStyle )
#endif // wxUSE_SCROLLBAR #endif // wxUSE_SCROLLBAR

216
src/common/slidercmn.cpp
View File

@@ -1,108 +1,108 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/slidercmn.cpp // Name: src/common/slidercmn.cpp
// Purpose: wxSlider common code // Purpose: wxSlider common code
// Author: Julian Smart // Author: Julian Smart
// Modified by: // Modified by:
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id: slider95.cpp 41054 2006-09-07 19:01:45Z ABX $ // RCS-ID: $Id$
// Copyright: (c) Julian Smart 1998 // Copyright: (c) Julian Smart 1998
// Vadim Zeitlin 2004 // Vadim Zeitlin 2004
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ============================================================================ // ============================================================================
// declarations // declarations
// ============================================================================ // ============================================================================
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// headers // headers
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_SLIDER #if wxUSE_SLIDER
#include "wx/slider.h" #include "wx/slider.h"
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxSliderStyle ) wxDEFINE_FLAGS( wxSliderStyle )
wxBEGIN_FLAGS( wxSliderStyle ) wxBEGIN_FLAGS( wxSliderStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxFLAGS_MEMBER(wxSL_HORIZONTAL) wxFLAGS_MEMBER(wxSL_HORIZONTAL)
wxFLAGS_MEMBER(wxSL_VERTICAL) wxFLAGS_MEMBER(wxSL_VERTICAL)
wxFLAGS_MEMBER(wxSL_AUTOTICKS) wxFLAGS_MEMBER(wxSL_AUTOTICKS)
wxFLAGS_MEMBER(wxSL_LABELS) wxFLAGS_MEMBER(wxSL_LABELS)
wxFLAGS_MEMBER(wxSL_LEFT) wxFLAGS_MEMBER(wxSL_LEFT)
wxFLAGS_MEMBER(wxSL_TOP) wxFLAGS_MEMBER(wxSL_TOP)
wxFLAGS_MEMBER(wxSL_RIGHT) wxFLAGS_MEMBER(wxSL_RIGHT)
wxFLAGS_MEMBER(wxSL_BOTTOM) wxFLAGS_MEMBER(wxSL_BOTTOM)
wxFLAGS_MEMBER(wxSL_BOTH) wxFLAGS_MEMBER(wxSL_BOTH)
wxFLAGS_MEMBER(wxSL_SELRANGE) wxFLAGS_MEMBER(wxSL_SELRANGE)
wxFLAGS_MEMBER(wxSL_INVERSE) wxFLAGS_MEMBER(wxSL_INVERSE)
wxEND_FLAGS( wxSliderStyle ) wxEND_FLAGS( wxSliderStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxSlider, wxControl, "wx/slider.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxSlider, wxControl, "wx/slider.h")
wxBEGIN_PROPERTIES_TABLE(wxSlider) wxBEGIN_PROPERTIES_TABLE(wxSlider)
wxEVENT_RANGE_PROPERTY( Scroll, wxEVT_SCROLL_TOP, wxEVT_SCROLL_CHANGED, wxScrollEvent ) wxEVENT_RANGE_PROPERTY( Scroll, wxEVT_SCROLL_TOP, wxEVT_SCROLL_CHANGED, wxScrollEvent )
wxEVENT_PROPERTY( Updated, wxEVT_COMMAND_SLIDER_UPDATED, wxCommandEvent ) wxEVENT_PROPERTY( Updated, wxEVT_COMMAND_SLIDER_UPDATED, wxCommandEvent )
wxPROPERTY( Value, int, SetValue, GetValue, 0, 0 /*flags*/, \ wxPROPERTY( Value, int, SetValue, GetValue, 0, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) wxT("Helpstring"), wxT("group"))
wxPROPERTY( Minimum, int, SetMin, GetMin, 0, 0 /*flags*/, \ wxPROPERTY( Minimum, int, SetMin, GetMin, 0, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) wxT("Helpstring"), wxT("group"))
wxPROPERTY( Maximum, int, SetMax, GetMax, 0, 0 /*flags*/, \ wxPROPERTY( Maximum, int, SetMax, GetMax, 0, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) wxT("Helpstring"), wxT("group"))
wxPROPERTY( PageSize, int, SetPageSize, GetLineSize, 1, 0 /*flags*/, \ wxPROPERTY( PageSize, int, SetPageSize, GetLineSize, 1, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) wxT("Helpstring"), wxT("group"))
wxPROPERTY( LineSize, int, SetLineSize, GetLineSize, 1, 0 /*flags*/, \ wxPROPERTY( LineSize, int, SetLineSize, GetLineSize, 1, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) wxT("Helpstring"), wxT("group"))
wxPROPERTY( ThumbLength, int, SetThumbLength, GetThumbLength, 1, 0 /*flags*/, \ wxPROPERTY( ThumbLength, int, SetThumbLength, GetThumbLength, 1, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) wxT("Helpstring"), wxT("group"))
wxPROPERTY_FLAGS( WindowStyle, wxSliderStyle, long, SetWindowStyleFlag, \ wxPROPERTY_FLAGS( WindowStyle, wxSliderStyle, long, SetWindowStyleFlag, \
GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) // style wxT("Helpstring"), wxT("group")) // style
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxSlider) wxEMPTY_HANDLERS_TABLE(wxSlider)
wxCONSTRUCTOR_8( wxSlider, wxWindow*, Parent, wxWindowID, Id, int, Value, \ wxCONSTRUCTOR_8( wxSlider, wxWindow*, Parent, wxWindowID, Id, int, Value, \
int, Minimum, int, Maximum, wxPoint, Position, wxSize, Size, \ int, Minimum, int, Maximum, wxPoint, Position, wxSize, Size, \
long, WindowStyle ) long, WindowStyle )
#endif // wxUSE_SLIDER #endif // wxUSE_SLIDER

198
src/common/spinbtncmn.cpp
View File

@@ -1,99 +1,99 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/spinbtncmn.cpp // Name: src/common/spinbtncmn.cpp
// Purpose: wxSpinButton common code // Purpose: wxSpinButton common code
// Author: Julian Smart // Author: Julian Smart
// Modified by: // Modified by:
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id: spinbutt.cpp 44657 2007-03-07 22:56:34Z VZ $ // RCS-ID: $Id$
// Copyright: (c) Julian Smart // Copyright: (c) Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ============================================================================ // ============================================================================
// declarations // declarations
// ============================================================================ // ============================================================================
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// headers // headers
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/app.h" #include "wx/app.h"
#endif #endif
#if wxUSE_SPINBTN #if wxUSE_SPINBTN
#include "wx/spinbutt.h" #include "wx/spinbutt.h"
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxSpinButtonStyle ) wxDEFINE_FLAGS( wxSpinButtonStyle )
wxBEGIN_FLAGS( wxSpinButtonStyle ) wxBEGIN_FLAGS( wxSpinButtonStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxFLAGS_MEMBER(wxSP_HORIZONTAL) wxFLAGS_MEMBER(wxSP_HORIZONTAL)
wxFLAGS_MEMBER(wxSP_VERTICAL) wxFLAGS_MEMBER(wxSP_VERTICAL)
wxFLAGS_MEMBER(wxSP_ARROW_KEYS) wxFLAGS_MEMBER(wxSP_ARROW_KEYS)
wxFLAGS_MEMBER(wxSP_WRAP) wxFLAGS_MEMBER(wxSP_WRAP)
wxEND_FLAGS( wxSpinButtonStyle ) wxEND_FLAGS( wxSpinButtonStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxSpinButton, wxControl, "wx/spinbut.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxSpinButton, wxControl, "wx/spinbut.h")
wxBEGIN_PROPERTIES_TABLE(wxSpinButton) wxBEGIN_PROPERTIES_TABLE(wxSpinButton)
wxEVENT_RANGE_PROPERTY( Spin, wxEVT_SCROLL_TOP, wxEVT_SCROLL_CHANGED, wxSpinEvent ) wxEVENT_RANGE_PROPERTY( Spin, wxEVT_SCROLL_TOP, wxEVT_SCROLL_CHANGED, wxSpinEvent )
wxPROPERTY( Value, int, SetValue, GetValue, 0, 0 /*flags*/, \ wxPROPERTY( Value, int, SetValue, GetValue, 0, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) wxT("Helpstring"), wxT("group"))
wxPROPERTY( Min, int, SetMin, GetMin, 0, 0 /*flags*/, \ wxPROPERTY( Min, int, SetMin, GetMin, 0, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) wxT("Helpstring"), wxT("group"))
wxPROPERTY( Max, int, SetMax, GetMax, 0, 0 /*flags*/, \ wxPROPERTY( Max, int, SetMax, GetMax, 0, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) wxT("Helpstring"), wxT("group"))
wxPROPERTY_FLAGS( WindowStyle, wxSpinButtonStyle, long, SetWindowStyleFlag, \ wxPROPERTY_FLAGS( WindowStyle, wxSpinButtonStyle, long, SetWindowStyleFlag, \
GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) // style wxT("Helpstring"), wxT("group")) // style
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxSpinButton) wxEMPTY_HANDLERS_TABLE(wxSpinButton)
wxCONSTRUCTOR_5( wxSpinButton, wxWindow*, Parent, wxWindowID, Id, \ wxCONSTRUCTOR_5( wxSpinButton, wxWindow*, Parent, wxWindowID, Id, \
wxPoint, Position, wxSize, Size, long, WindowStyle ) wxPoint, Position, wxSize, Size, long, WindowStyle )
IMPLEMENT_DYNAMIC_CLASS(wxSpinEvent, wxNotifyEvent) IMPLEMENT_DYNAMIC_CLASS(wxSpinEvent, wxNotifyEvent)
#endif // wxUSE_SPINBTN #endif // wxUSE_SPINBTN

170
src/common/statbmpcmn.cpp
View File

@@ -1,85 +1,85 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/statbmpcmn.cpp // Name: src/common/statbmpcmn.cpp
// Purpose: wxStaticBitmap common code // Purpose: wxStaticBitmap common code
// Author: Julian Smart // Author: Julian Smart
// Modified by: // Modified by:
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id: statbmp.cpp 42816 2006-10-31 08:50:17Z RD $ // RCS-ID: $Id$
// Copyright: (c) Julian Smart // Copyright: (c) Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// =========================================================================== // ===========================================================================
// declarations // declarations
// =========================================================================== // ===========================================================================
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// headers // headers
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_STATBMP #if wxUSE_STATBMP
#include "wx/statbmp.h" #include "wx/statbmp.h"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// XTI // XTI
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
wxDEFINE_FLAGS( wxStaticBitmapStyle ) wxDEFINE_FLAGS( wxStaticBitmapStyle )
wxBEGIN_FLAGS( wxStaticBitmapStyle ) wxBEGIN_FLAGS( wxStaticBitmapStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxEND_FLAGS( wxStaticBitmapStyle ) wxEND_FLAGS( wxStaticBitmapStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxStaticBitmap, wxControl, "wx/statbmp.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxStaticBitmap, wxControl, "wx/statbmp.h")
wxBEGIN_PROPERTIES_TABLE(wxStaticBitmap) wxBEGIN_PROPERTIES_TABLE(wxStaticBitmap)
wxPROPERTY_FLAGS( WindowStyle, wxStaticBitmapStyle, long, \ wxPROPERTY_FLAGS( WindowStyle, wxStaticBitmapStyle, long, \
SetWindowStyleFlag, GetWindowStyleFlag, \ SetWindowStyleFlag, GetWindowStyleFlag, \
wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, wxT("Helpstring"), \ wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, wxT("Helpstring"), \
wxT("group")) // style wxT("group")) // style
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxStaticBitmap) wxEMPTY_HANDLERS_TABLE(wxStaticBitmap)
wxCONSTRUCTOR_5( wxStaticBitmap, wxWindow*, Parent, wxWindowID, Id, \ wxCONSTRUCTOR_5( wxStaticBitmap, wxWindow*, Parent, wxWindowID, Id, \
wxBitmap, Bitmap, wxPoint, Position, wxSize, Size ) wxBitmap, Bitmap, wxPoint, Position, wxSize, Size )
/* /*
TODO PROPERTIES : TODO PROPERTIES :
bitmap bitmap
*/ */
#endif // wxUSE_STATBMP #endif // wxUSE_STATBMP

162
src/common/statboxcmn.cpp
View File

@@ -1,81 +1,81 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/statboxcmn.cpp // Name: src/common/statboxcmn.cpp
// Purpose: wxStaticBox common code // Purpose: wxStaticBox common code
// Author: Julian Smart // Author: Julian Smart
// Modified by: // Modified by:
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id: statbox.cpp 45008 2007-03-22 02:28:06Z VZ $ // RCS-ID: $Id$
// Copyright: (c) Julian Smart // Copyright: (c) Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ============================================================================ // ============================================================================
// declarations // declarations
// ============================================================================ // ============================================================================
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// headers // headers
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_STATBOX #if wxUSE_STATBOX
#include "wx/statbox.h" #include "wx/statbox.h"
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxStaticBoxStyle ) wxDEFINE_FLAGS( wxStaticBoxStyle )
wxBEGIN_FLAGS( wxStaticBoxStyle ) wxBEGIN_FLAGS( wxStaticBoxStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxEND_FLAGS( wxStaticBoxStyle ) wxEND_FLAGS( wxStaticBoxStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxStaticBox, wxControl, "wx/statbox.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxStaticBox, wxControl, "wx/statbox.h")
wxBEGIN_PROPERTIES_TABLE(wxStaticBox) wxBEGIN_PROPERTIES_TABLE(wxStaticBox)
wxPROPERTY( Label, wxString, SetLabel, GetLabel, wxString(), 0 /*flags*/, \ wxPROPERTY( Label, wxString, SetLabel, GetLabel, wxString(), 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) wxT("Helpstring"), wxT("group"))
wxPROPERTY_FLAGS( WindowStyle, wxStaticBoxStyle, long, SetWindowStyleFlag, \ wxPROPERTY_FLAGS( WindowStyle, wxStaticBoxStyle, long, SetWindowStyleFlag, \
GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) // style wxT("Helpstring"), wxT("group")) // style
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxStaticBox) wxEMPTY_HANDLERS_TABLE(wxStaticBox)
wxCONSTRUCTOR_6( wxStaticBox, wxWindow*, Parent, wxWindowID, Id, \ wxCONSTRUCTOR_6( wxStaticBox, wxWindow*, Parent, wxWindowID, Id, \
wxString, Label, wxPoint, Position, wxSize, Size, \ wxString, Label, wxPoint, Position, wxSize, Size, \
long, WindowStyle ) long, WindowStyle )
#endif // wxUSE_STATBOX #endif // wxUSE_STATBOX

160
src/common/statlinecmn.cpp
View File

@@ -1,80 +1,80 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: src/common/statlinecmn.cpp // Name: src/common/statlinecmn.cpp
// Purpose: wxStaticLine common code // Purpose: wxStaticLine common code
// Author: Vadim Zeitlin // Author: Vadim Zeitlin
// Created: 28.06.99 // Created: 28.06.99
// Version: $Id: statline.cpp 41054 2006-09-07 19:01:45Z ABX $ // Version: $Id$
// Copyright: (c) 1998 Vadim Zeitlin // Copyright: (c) 1998 Vadim Zeitlin
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ============================================================================ // ============================================================================
// declarations // declarations
// ============================================================================ // ============================================================================
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// headers // headers
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#include "wx/statline.h" #include "wx/statline.h"
#if wxUSE_STATLINE #if wxUSE_STATLINE
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// XTI // XTI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDEFINE_FLAGS( wxStaticLineStyle ) wxDEFINE_FLAGS( wxStaticLineStyle )
wxBEGIN_FLAGS( wxStaticLineStyle ) wxBEGIN_FLAGS( wxStaticLineStyle )
// new style border flags, we put them first to // new style border flags, we put them first to
// use them for streaming out // use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE) wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN) wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE) wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED) wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC) wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE) wxFLAGS_MEMBER(wxBORDER_NONE)
// old style border flags // old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER) wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER) wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER) wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER) wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER) wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER) wxFLAGS_MEMBER(wxBORDER)
// standard window styles // standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL) wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN) wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS) wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL) wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL) wxFLAGS_MEMBER(wxHSCROLL)
wxFLAGS_MEMBER(wxLI_HORIZONTAL) wxFLAGS_MEMBER(wxLI_HORIZONTAL)
wxFLAGS_MEMBER(wxLI_VERTICAL) wxFLAGS_MEMBER(wxLI_VERTICAL)
wxEND_FLAGS( wxStaticLineStyle ) wxEND_FLAGS( wxStaticLineStyle )
wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxStaticLine, wxControl, "wx/statline.h") wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxStaticLine, wxControl, "wx/statline.h")
wxBEGIN_PROPERTIES_TABLE(wxStaticLine) wxBEGIN_PROPERTIES_TABLE(wxStaticLine)
wxPROPERTY_FLAGS( WindowStyle, wxStaticLineStyle, long, SetWindowStyleFlag, \ wxPROPERTY_FLAGS( WindowStyle, wxStaticLineStyle, long, SetWindowStyleFlag, \
GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) // style wxT("Helpstring"), wxT("group")) // style
wxEND_PROPERTIES_TABLE() wxEND_PROPERTIES_TABLE()
wxEMPTY_HANDLERS_TABLE(wxStaticLine) wxEMPTY_HANDLERS_TABLE(wxStaticLine)
wxCONSTRUCTOR_5( wxStaticLine, wxWindow*, Parent, wxWindowID, Id, \ wxCONSTRUCTOR_5( wxStaticLine, wxWindow*, Parent, wxWindowID, Id, \
wxPoint, Position, wxSize, Size, long, WindowStyle) wxPoint, Position, wxSize, Size, long, WindowStyle)
#endif // wxUSE_STATLINE #endif // wxUSE_STATLINE