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

renamed WXDLLEXPORT_BASE/CORE to WXDLLIMPEXP_BASE/CORE

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@21570 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2003-07-02 01:59:24 +00:00
parent 886dd7d28e
commit bddd7a8d89
76 changed files with 598 additions and 598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
include/wx/app.h
View File

@@ -26,11 +26,11 @@
#include "wx/build.h" #include "wx/build.h"
#include "wx/init.h" // we must declare wxEntry() #include "wx/init.h" // we must declare wxEntry()
class WXDLLEXPORT_CORE wxApp; class WXDLLIMPEXP_CORE wxApp;
class WXDLLEXPORT_BASE wxAppTraits; class WXDLLIMPEXP_BASE wxAppTraits;
class WXDLLEXPORT_BASE wxCmdLineParser; class WXDLLIMPEXP_BASE wxCmdLineParser;
class WXDLLEXPORT_BASE wxLog; class WXDLLIMPEXP_BASE wxLog;
class WXDLLEXPORT_BASE wxMessageOutput; class WXDLLIMPEXP_BASE wxMessageOutput;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// typedefs // typedefs
@@ -57,7 +57,7 @@ enum
// VS: Fullscreen/framebuffer application needs to choose display mode prior // VS: Fullscreen/framebuffer application needs to choose display mode prior
// to wxWindows initialization. This class holds information about display // to wxWindows initialization. This class holds information about display
// mode. It is used by wxApp::Set/GetDisplayMode. // mode. It is used by wxApp::Set/GetDisplayMode.
class WXDLLEXPORT_CORE wxDisplayModeInfo class WXDLLIMPEXP_CORE wxDisplayModeInfo
{ {
public: public:
wxDisplayModeInfo() : m_ok(FALSE) {} wxDisplayModeInfo() : m_ok(FALSE) {}
@@ -79,7 +79,7 @@ private:
// wxAppConsole: wxApp for non-GUI applications // wxAppConsole: wxApp for non-GUI applications
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxAppConsole : public wxEvtHandler class WXDLLIMPEXP_BASE wxAppConsole : public wxEvtHandler
{ {
public: public:
// ctor and dtor // ctor and dtor
@@ -302,7 +302,7 @@ protected:
#if wxUSE_GUI #if wxUSE_GUI
class WXDLLEXPORT_CORE wxAppBase : public wxAppConsole class WXDLLIMPEXP_CORE wxAppBase : public wxAppConsole
{ {
public: public:
wxAppBase(); wxAppBase();
@@ -503,7 +503,7 @@ protected:
#endif #endif
#else // !GUI #else // !GUI
// can't use typedef because wxApp forward declared as a class // can't use typedef because wxApp forward declared as a class
class WXDLLEXPORT_BASE wxApp : public wxAppConsole class WXDLLIMPEXP_BASE wxApp : public wxAppConsole
{ {
}; };
#endif // GUI/!GUI #endif // GUI/!GUI
@@ -516,7 +516,7 @@ protected:
// is discouraged, consider using DECLARE_APP() after which you may call // is discouraged, consider using DECLARE_APP() after which you may call
// wxGetApp() which will return the object of the correct type (i.e. MyApp and // wxGetApp() which will return the object of the correct type (i.e. MyApp and
// not wxApp) // not wxApp)
WXDLLEXPORT_DATA_BASE(extern wxApp*) wxTheApp; WXDLLIMPEXP_DATA_BASE(extern wxApp*) wxTheApp;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// global functions // global functions
@@ -526,13 +526,13 @@ WXDLLEXPORT_DATA_BASE(extern wxApp*) wxTheApp;
// ------------------------------------------------------ // ------------------------------------------------------
// Force an exit from main loop // Force an exit from main loop
extern void WXDLLEXPORT_BASE wxExit(); extern void WXDLLIMPEXP_BASE wxExit();
// Yield to other apps/messages // Yield to other apps/messages
extern bool WXDLLEXPORT_BASE wxYield(); extern bool WXDLLIMPEXP_BASE wxYield();
// Yield to other apps/messages // Yield to other apps/messages
extern void WXDLLEXPORT_BASE wxWakeUpIdle(); extern void WXDLLIMPEXP_BASE wxWakeUpIdle();
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// macros for dynamic creation of the application object // macros for dynamic creation of the application object
@@ -542,7 +542,7 @@ extern void WXDLLEXPORT_BASE wxWakeUpIdle();
// creator function. wxApp can then call this function to create a new app // creator function. wxApp can then call this function to create a new app
// object. Convoluted, but necessary. // object. Convoluted, but necessary.
class WXDLLEXPORT_BASE wxAppInitializer class WXDLLIMPEXP_BASE wxAppInitializer
{ {
public: public:
wxAppInitializer(wxAppInitializerFunction fn) wxAppInitializer(wxAppInitializerFunction fn)

2
include/wx/build.h
View File

@@ -14,7 +14,7 @@
#include "wx/version.h" #include "wx/version.h"
class WXDLLEXPORT_BASE wxAppConsole; class WXDLLIMPEXP_BASE wxAppConsole;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxBuildOptions // wxBuildOptions

6
include/wx/clntdata.h
View File

@@ -29,14 +29,14 @@ enum wxClientDataType
wxClientData_Void // client data is untyped and we don't own it wxClientData_Void // client data is untyped and we don't own it
}; };
class WXDLLEXPORT_BASE wxClientData class WXDLLIMPEXP_BASE wxClientData
{ {
public: public:
wxClientData() { } wxClientData() { }
virtual ~wxClientData() { } virtual ~wxClientData() { }
}; };
class WXDLLEXPORT_BASE wxStringClientData : public wxClientData class WXDLLIMPEXP_BASE wxStringClientData : public wxClientData
{ {
public: public:
wxStringClientData() : m_data() { } wxStringClientData() : m_data() { }
@@ -57,7 +57,7 @@ private:
// NOTE: This functionality is currently duplicated in wxEvtHandler in order // NOTE: This functionality is currently duplicated in wxEvtHandler in order
// to avoid having more than one vtable in that class hierarchy. // to avoid having more than one vtable in that class hierarchy.
class WXDLLEXPORT_BASE wxClientDataContainer class WXDLLIMPEXP_BASE wxClientDataContainer
{ {
public: public:
wxClientDataContainer(); wxClientDataContainer();

6
include/wx/cmdline.h
View File

@@ -22,7 +22,7 @@
#if wxUSE_CMDLINE_PARSER #if wxUSE_CMDLINE_PARSER
class WXDLLEXPORT_BASE wxDateTime; class WXDLLIMPEXP_BASE wxDateTime;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// constants // constants
@@ -91,7 +91,7 @@ struct wxCmdLineEntryDesc
// 4. use GetXXX() to retrieve the parsed info // 4. use GetXXX() to retrieve the parsed info
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxCmdLineParser class WXDLLIMPEXP_BASE wxCmdLineParser
{ {
public: public:
// ctors and initializers // ctors and initializers
@@ -219,7 +219,7 @@ private:
// this function is always available (even if !wxUSE_CMDLINE_PARSER) because it // this function is always available (even if !wxUSE_CMDLINE_PARSER) because it
// is used by wxWin itself under Windows // is used by wxWin itself under Windows
class WXDLLEXPORT_BASE wxCmdLineParser class WXDLLIMPEXP_BASE wxCmdLineParser
{ {
public: public:
static wxArrayString ConvertStringToArgs(const wxChar *cmdline); static wxArrayString ConvertStringToArgs(const wxChar *cmdline);

8
include/wx/confbase.h
View File

@@ -74,7 +74,7 @@ enum
// (long) type (TODO doubles and other types such as wxDate coming soon). // (long) type (TODO doubles and other types such as wxDate coming soon).
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxConfigBase class WXDLLIMPEXP_BASE wxConfigBase
{ {
public: public:
// constants // constants
@@ -293,7 +293,7 @@ private:
// you work in the entry directory and the path is automatically restored // you work in the entry directory and the path is automatically restored
// when the function returns // when the function returns
// Taken out of wxConfig since not all compilers can cope with nested classes. // Taken out of wxConfig since not all compilers can cope with nested classes.
class WXDLLEXPORT_BASE wxConfigPathChanger class WXDLLIMPEXP_BASE wxConfigPathChanger
{ {
public: public:
// ctor/dtor do path changing/restorin // ctor/dtor do path changing/restorin
@@ -339,12 +339,12 @@ private:
'_' only. '$' must be escaped ('\$') in order to be taken literally. '_' only. '$' must be escaped ('\$') in order to be taken literally.
*/ */
WXDLLEXPORT_BASE wxString wxExpandEnvVars(const wxString &sz); WXDLLIMPEXP_BASE wxString wxExpandEnvVars(const wxString &sz);
/* /*
Split path into parts removing '..' in progress Split path into parts removing '..' in progress
*/ */
WXDLLEXPORT_BASE void wxSplitPath(wxArrayString& aParts, const wxChar *sz); WXDLLIMPEXP_BASE void wxSplitPath(wxArrayString& aParts, const wxChar *sz);
#endif #endif

88
include/wx/datetime.h
View File

@@ -26,9 +26,9 @@
#include "wx/longlong.h" #include "wx/longlong.h"
class WXDLLEXPORT_BASE wxDateTime; class WXDLLIMPEXP_BASE wxDateTime;
class WXDLLEXPORT_BASE wxTimeSpan; class WXDLLIMPEXP_BASE wxTimeSpan;
class WXDLLEXPORT_BASE wxDateSpan; class WXDLLIMPEXP_BASE wxDateSpan;
// a hack: don't use inline functions in debug builds - we don't care about // a hack: don't use inline functions in debug builds - we don't care about
// performances and this only leads to increased rebuild time (because every // performances and this only leads to increased rebuild time (because every
@@ -117,16 +117,16 @@ class WXDLLEXPORT_BASE wxDateSpan;
// argument for arguments of type wxDateTime; it is also returned by all // argument for arguments of type wxDateTime; it is also returned by all
// functions returning wxDateTime on failure (this is why it is also called // functions returning wxDateTime on failure (this is why it is also called
// wxInvalidDateTime) // wxInvalidDateTime)
class WXDLLEXPORT_BASE wxDateTime; class WXDLLIMPEXP_BASE wxDateTime;
extern WXDLLEXPORT_DATA_BASE(const wxDateTime) wxDefaultDateTime; extern WXDLLIMPEXP_DATA_BASE(const wxDateTime) wxDefaultDateTime;
#define wxInvalidDateTime wxDefaultDateTime #define wxInvalidDateTime wxDefaultDateTime
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxDateTime represents an absolute moment in the time // wxDateTime represents an absolute moment in the time
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxDateTime class WXDLLIMPEXP_BASE wxDateTime
{ {
public: public:
// types // types
@@ -398,7 +398,7 @@ public:
// a class representing a time zone: basicly, this is just an offset // a class representing a time zone: basicly, this is just an offset
// (in seconds) from GMT // (in seconds) from GMT
class WXDLLEXPORT_BASE TimeZone class WXDLLIMPEXP_BASE TimeZone
{ {
public: public:
TimeZone(TZ tz); TimeZone(TZ tz);
@@ -418,7 +418,7 @@ public:
// NB: this struct should always be kept normalized (i.e. mon should // NB: this struct should always be kept normalized (i.e. mon should
// be < 12, 1 <= day <= 31 &c), so use AddMonths(), AddDays() // be < 12, 1 <= day <= 31 &c), so use AddMonths(), AddDays()
// instead of modifying the member fields directly! // instead of modifying the member fields directly!
struct WXDLLEXPORT_BASE Tm struct WXDLLIMPEXP_BASE Tm
{ {
wxDateTime_t msec, sec, min, hour, mday; wxDateTime_t msec, sec, min, hour, mday;
Month mon; Month mon;
@@ -1005,7 +1005,7 @@ private:
// objects of that class. See also wxDateSpan. // objects of that class. See also wxDateSpan.
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxTimeSpan class WXDLLIMPEXP_BASE wxTimeSpan
{ {
public: public:
// constructors // constructors
@@ -1185,7 +1185,7 @@ private:
// associated with those. // associated with those.
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxDateSpan class WXDLLIMPEXP_BASE wxDateSpan
{ {
public: public:
// constructors // constructors
@@ -1298,11 +1298,11 @@ WX_DECLARE_EXPORTED_OBJARRAY(wxDateTime, wxDateTimeArray);
// virtual methods to work with the holidays they correspond to. // virtual methods to work with the holidays they correspond to.
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxDateTimeHolidayAuthority; class WXDLLIMPEXP_BASE wxDateTimeHolidayAuthority;
WX_DEFINE_EXPORTED_ARRAY(wxDateTimeHolidayAuthority *, wxHolidayAuthoritiesArray); WX_DEFINE_EXPORTED_ARRAY(wxDateTimeHolidayAuthority *, wxHolidayAuthoritiesArray);
class wxDateTimeHolidaysModule; class wxDateTimeHolidaysModule;
class WXDLLEXPORT_BASE wxDateTimeHolidayAuthority class WXDLLIMPEXP_BASE wxDateTimeHolidayAuthority
{ {
friend class wxDateTimeHolidaysModule; friend class wxDateTimeHolidaysModule;
public: public:
@@ -1347,7 +1347,7 @@ private:
}; };
// the holidays for this class are all Saturdays and Sundays // the holidays for this class are all Saturdays and Sundays
class WXDLLEXPORT_BASE wxDateTimeWorkDays : public wxDateTimeHolidayAuthority class WXDLLIMPEXP_BASE wxDateTimeWorkDays : public wxDateTimeHolidayAuthority
{ {
protected: protected:
virtual bool DoIsHoliday(const wxDateTime& dt) const; virtual bool DoIsHoliday(const wxDateTime& dt) const;
@@ -1388,31 +1388,31 @@ protected:
// no need to check for validity - the member functions we call will do it // no need to check for validity - the member functions we call will do it
inline wxDateTime WXDLLEXPORT_BASE operator+(const wxDateTime& dt, inline wxDateTime WXDLLIMPEXP_BASE operator+(const wxDateTime& dt,
const wxTimeSpan& ts) const wxTimeSpan& ts)
{ {
return dt.Add(ts); return dt.Add(ts);
} }
inline wxDateTime WXDLLEXPORT_BASE operator-(const wxDateTime& dt, inline wxDateTime WXDLLIMPEXP_BASE operator-(const wxDateTime& dt,
const wxTimeSpan& ts) const wxTimeSpan& ts)
{ {
return dt.Subtract(ts); return dt.Subtract(ts);
} }
inline wxDateTime WXDLLEXPORT_BASE operator+(const wxDateTime& dt, inline wxDateTime WXDLLIMPEXP_BASE operator+(const wxDateTime& dt,
const wxDateSpan& ds) const wxDateSpan& ds)
{ {
return dt.Add(ds); return dt.Add(ds);
} }
inline wxDateTime WXDLLEXPORT_BASE operator-(const wxDateTime& dt, inline wxDateTime WXDLLIMPEXP_BASE operator-(const wxDateTime& dt,
const wxDateSpan& ds) const wxDateSpan& ds)
{ {
return dt.Subtract(ds); return dt.Subtract(ds);
} }
inline wxTimeSpan WXDLLEXPORT_BASE operator-(const wxDateTime& dt1, inline wxTimeSpan WXDLLIMPEXP_BASE operator-(const wxDateTime& dt1,
const wxDateTime& dt2) const wxDateTime& dt2)
{ {
return dt1.Subtract(dt2); return dt1.Subtract(dt2);
@@ -1421,42 +1421,42 @@ inline wxTimeSpan WXDLLEXPORT_BASE operator-(const wxDateTime& dt1,
// comparison // comparison
// ---------- // ----------
inline bool WXDLLEXPORT_BASE operator<(const wxDateTime& t1, const wxDateTime& t2) inline bool WXDLLIMPEXP_BASE operator<(const wxDateTime& t1, const wxDateTime& t2)
{ {
wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") ); wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
return t1.GetValue() < t2.GetValue(); return t1.GetValue() < t2.GetValue();
} }
inline bool WXDLLEXPORT_BASE operator<=(const wxDateTime& t1, const wxDateTime& t2) inline bool WXDLLIMPEXP_BASE operator<=(const wxDateTime& t1, const wxDateTime& t2)
{ {
wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") ); wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
return t1.GetValue() <= t2.GetValue(); return t1.GetValue() <= t2.GetValue();
} }
inline bool WXDLLEXPORT_BASE operator>(const wxDateTime& t1, const wxDateTime& t2) inline bool WXDLLIMPEXP_BASE operator>(const wxDateTime& t1, const wxDateTime& t2)
{ {
wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") ); wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
return t1.GetValue() > t2.GetValue(); return t1.GetValue() > t2.GetValue();
} }
inline bool WXDLLEXPORT_BASE operator>=(const wxDateTime& t1, const wxDateTime& t2) inline bool WXDLLIMPEXP_BASE operator>=(const wxDateTime& t1, const wxDateTime& t2)
{ {
wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") ); wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
return t1.GetValue() >= t2.GetValue(); return t1.GetValue() >= t2.GetValue();
} }
inline bool WXDLLEXPORT_BASE operator==(const wxDateTime& t1, const wxDateTime& t2) inline bool WXDLLIMPEXP_BASE operator==(const wxDateTime& t1, const wxDateTime& t2)
{ {
wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") ); wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
return t1.GetValue() == t2.GetValue(); return t1.GetValue() == t2.GetValue();
} }
inline bool WXDLLEXPORT_BASE operator!=(const wxDateTime& t1, const wxDateTime& t2) inline bool WXDLLIMPEXP_BASE operator!=(const wxDateTime& t1, const wxDateTime& t2)
{ {
wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") ); wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
@@ -1470,24 +1470,24 @@ inline bool WXDLLEXPORT_BASE operator!=(const wxDateTime& t1, const wxDateTime&
// arithmetics // arithmetics
// ----------- // -----------
inline wxTimeSpan WXDLLEXPORT_BASE operator+(const wxTimeSpan& ts1, inline wxTimeSpan WXDLLIMPEXP_BASE operator+(const wxTimeSpan& ts1,
const wxTimeSpan& ts2) const wxTimeSpan& ts2)
{ {
return wxTimeSpan(ts1.GetValue() + ts2.GetValue()); return wxTimeSpan(ts1.GetValue() + ts2.GetValue());
} }
inline wxTimeSpan WXDLLEXPORT_BASE operator-(const wxTimeSpan& ts1, inline wxTimeSpan WXDLLIMPEXP_BASE operator-(const wxTimeSpan& ts1,
const wxTimeSpan& ts2) const wxTimeSpan& ts2)
{ {
return wxTimeSpan(ts1.GetValue() - ts2.GetValue()); return wxTimeSpan(ts1.GetValue() - ts2.GetValue());
} }
inline wxTimeSpan WXDLLEXPORT_BASE operator*(const wxTimeSpan& ts, int n) inline wxTimeSpan WXDLLIMPEXP_BASE operator*(const wxTimeSpan& ts, int n)
{ {
return wxTimeSpan(ts).Multiply(n); return wxTimeSpan(ts).Multiply(n);
} }
inline wxTimeSpan WXDLLEXPORT_BASE operator*(int n, const wxTimeSpan& ts) inline wxTimeSpan WXDLLIMPEXP_BASE operator*(int n, const wxTimeSpan& ts)
{ {
return wxTimeSpan(ts).Multiply(n); return wxTimeSpan(ts).Multiply(n);
} }
@@ -1495,32 +1495,32 @@ inline wxTimeSpan WXDLLEXPORT_BASE operator*(int n, const wxTimeSpan& ts)
// comparison // comparison
// ---------- // ----------
inline bool WXDLLEXPORT_BASE operator<(const wxTimeSpan &t1, const wxTimeSpan &t2) inline bool WXDLLIMPEXP_BASE operator<(const wxTimeSpan &t1, const wxTimeSpan &t2)
{ {
return t1.GetValue() < t2.GetValue(); return t1.GetValue() < t2.GetValue();
} }
inline bool WXDLLEXPORT_BASE operator<=(const wxTimeSpan &t1, const wxTimeSpan &t2) inline bool WXDLLIMPEXP_BASE operator<=(const wxTimeSpan &t1, const wxTimeSpan &t2)
{ {
return t1.GetValue() <= t2.GetValue(); return t1.GetValue() <= t2.GetValue();
} }
inline bool WXDLLEXPORT_BASE operator>(const wxTimeSpan &t1, const wxTimeSpan &t2) inline bool WXDLLIMPEXP_BASE operator>(const wxTimeSpan &t1, const wxTimeSpan &t2)
{ {
return t1.GetValue() > t2.GetValue(); return t1.GetValue() > t2.GetValue();
} }
inline bool WXDLLEXPORT_BASE operator>=(const wxTimeSpan &t1, const wxTimeSpan &t2) inline bool WXDLLIMPEXP_BASE operator>=(const wxTimeSpan &t1, const wxTimeSpan &t2)
{ {
return t1.GetValue() >= t2.GetValue(); return t1.GetValue() >= t2.GetValue();
} }
inline bool WXDLLEXPORT_BASE operator==(const wxTimeSpan &t1, const wxTimeSpan &t2) inline bool WXDLLIMPEXP_BASE operator==(const wxTimeSpan &t1, const wxTimeSpan &t2)
{ {
return t1.GetValue() == t2.GetValue(); return t1.GetValue() == t2.GetValue();
} }
inline bool WXDLLEXPORT_BASE operator!=(const wxTimeSpan &t1, const wxTimeSpan &t2) inline bool WXDLLIMPEXP_BASE operator!=(const wxTimeSpan &t1, const wxTimeSpan &t2)
{ {
return t1.GetValue() != t2.GetValue(); return t1.GetValue() != t2.GetValue();
} }
@@ -1533,7 +1533,7 @@ inline bool WXDLLEXPORT_BASE operator!=(const wxTimeSpan &t1, const wxTimeSpan &
// ---------- // ----------
// ds1 == d2 if and only if for every wxDateTime t t + ds1 == t + ds2 // ds1 == d2 if and only if for every wxDateTime t t + ds1 == t + ds2
inline WXDLLEXPORT_BASE bool operator==(const wxDateSpan& ds1, inline WXDLLIMPEXP_BASE bool operator==(const wxDateSpan& ds1,
const wxDateSpan& ds2) const wxDateSpan& ds2)
{ {
return ds1.GetYears() == ds2.GetYears() && return ds1.GetYears() == ds2.GetYears() &&
@@ -1541,7 +1541,7 @@ inline WXDLLEXPORT_BASE bool operator==(const wxDateSpan& ds1,
ds1.GetTotalDays() == ds2.GetTotalDays(); ds1.GetTotalDays() == ds2.GetTotalDays();
} }
inline WXDLLEXPORT_BASE bool operator!=(const wxDateSpan& ds1, inline WXDLLIMPEXP_BASE bool operator!=(const wxDateSpan& ds1,
const wxDateSpan& ds2) const wxDateSpan& ds2)
{ {
return !(ds1 == ds2); return !(ds1 == ds2);
@@ -1550,7 +1550,7 @@ inline WXDLLEXPORT_BASE bool operator!=(const wxDateSpan& ds1,
// arithmetics // arithmetics
// ----------- // -----------
inline WXDLLEXPORT_BASE wxDateSpan operator+(const wxDateSpan& ds1, inline WXDLLIMPEXP_BASE wxDateSpan operator+(const wxDateSpan& ds1,
const wxDateSpan& ds2) const wxDateSpan& ds2)
{ {
return wxDateSpan(ds1.GetYears() + ds2.GetYears(), return wxDateSpan(ds1.GetYears() + ds2.GetYears(),
@@ -1559,7 +1559,7 @@ inline WXDLLEXPORT_BASE wxDateSpan operator+(const wxDateSpan& ds1,
ds1.GetDays() + ds2.GetDays()); ds1.GetDays() + ds2.GetDays());
} }
inline WXDLLEXPORT_BASE wxDateSpan operator-(const wxDateSpan& ds1, inline WXDLLIMPEXP_BASE wxDateSpan operator-(const wxDateSpan& ds1,
const wxDateSpan& ds2) const wxDateSpan& ds2)
{ {
return wxDateSpan(ds1.GetYears() - ds2.GetYears(), return wxDateSpan(ds1.GetYears() - ds2.GetYears(),
@@ -1568,12 +1568,12 @@ inline WXDLLEXPORT_BASE wxDateSpan operator-(const wxDateSpan& ds1,
ds1.GetDays() - ds2.GetDays()); ds1.GetDays() - ds2.GetDays());
} }
inline WXDLLEXPORT_BASE wxDateSpan operator*(const wxDateSpan& ds, int n) inline WXDLLIMPEXP_BASE wxDateSpan operator*(const wxDateSpan& ds, int n)
{ {
return wxDateSpan(ds).Multiply(n); return wxDateSpan(ds).Multiply(n);
} }
inline WXDLLEXPORT_BASE wxDateSpan operator*(int n, const wxDateSpan& ds) inline WXDLLIMPEXP_BASE wxDateSpan operator*(int n, const wxDateSpan& ds)
{ {
return wxDateSpan(ds).Multiply(n); return wxDateSpan(ds).Multiply(n);
} }
@@ -1588,7 +1588,7 @@ inline WXDLLEXPORT_BASE wxDateSpan operator*(int n, const wxDateSpan& ds)
// for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) ) // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
inline WXDLLEXPORT_BASE void wxNextMonth(wxDateTime::Month& m) inline WXDLLIMPEXP_BASE void wxNextMonth(wxDateTime::Month& m)
{ {
wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") ); wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
@@ -1596,7 +1596,7 @@ inline WXDLLEXPORT_BASE void wxNextMonth(wxDateTime::Month& m)
m = (wxDateTime::Month)(m + 1); m = (wxDateTime::Month)(m + 1);
} }
inline WXDLLEXPORT_BASE void wxPrevMonth(wxDateTime::Month& m) inline WXDLLIMPEXP_BASE void wxPrevMonth(wxDateTime::Month& m)
{ {
wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") ); wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
@@ -1604,7 +1604,7 @@ inline WXDLLEXPORT_BASE void wxPrevMonth(wxDateTime::Month& m)
: (wxDateTime::Month)(m - 1); : (wxDateTime::Month)(m - 1);
} }
inline WXDLLEXPORT_BASE void wxNextWDay(wxDateTime::WeekDay& wd) inline WXDLLIMPEXP_BASE void wxNextWDay(wxDateTime::WeekDay& wd)
{ {
wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") ); wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
@@ -1612,7 +1612,7 @@ inline WXDLLEXPORT_BASE void wxNextWDay(wxDateTime::WeekDay& wd)
wd = (wxDateTime::WeekDay)(wd + 1); wd = (wxDateTime::WeekDay)(wd + 1);
} }
inline WXDLLEXPORT_BASE void wxPrevWDay(wxDateTime::WeekDay& wd) inline WXDLLIMPEXP_BASE void wxPrevWDay(wxDateTime::WeekDay& wd)
{ {
wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") ); wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );

4
include/wx/datstrm.h
View File

@@ -22,7 +22,7 @@
#if wxUSE_STREAMS #if wxUSE_STREAMS
class WXDLLEXPORT_BASE wxDataInputStream class WXDLLIMPEXP_BASE wxDataInputStream
{ {
public: public:
#if wxUSE_UNICODE #if wxUSE_UNICODE
@@ -64,7 +64,7 @@ protected:
DECLARE_NO_COPY_CLASS(wxDataInputStream) DECLARE_NO_COPY_CLASS(wxDataInputStream)
}; };
class WXDLLEXPORT_BASE wxDataOutputStream class WXDLLIMPEXP_BASE wxDataOutputStream
{ {
public: public:
#if wxUSE_UNICODE #if wxUSE_UNICODE

44
include/wx/db.h
View File

@@ -123,8 +123,8 @@ enum enumDummy {enumDum1};
*/ */
const int wxDB_PATH_MAX = 254; const int wxDB_PATH_MAX = 254;
WXDLLEXPORT_DATA_BASE(extern wxChar const *) SQL_LOG_FILENAME; WXDLLIMPEXP_DATA_BASE(extern wxChar const *) SQL_LOG_FILENAME;
WXDLLEXPORT_DATA_BASE(extern wxChar const *) SQL_CATALOG_FILENAME; WXDLLIMPEXP_DATA_BASE(extern wxChar const *) SQL_CATALOG_FILENAME;
// Database Globals // Database Globals
const int DB_TYPE_NAME_LEN = 40; const int DB_TYPE_NAME_LEN = 40;
@@ -269,7 +269,7 @@ enum wxODBC_ERRORS
#define SQL_MAX_AUTHSTR_LEN MAXNAME #define SQL_MAX_AUTHSTR_LEN MAXNAME
#endif #endif
class WXDLLEXPORT_BASE wxDbConnectInf class WXDLLIMPEXP_BASE wxDbConnectInf
{ {
private: private:
bool freeHenvOnDestroy; bool freeHenvOnDestroy;
@@ -331,7 +331,7 @@ class WXDLLEXPORT_BASE wxDbConnectInf
}; // class wxDbConnectInf }; // class wxDbConnectInf
struct WXDLLEXPORT_BASE wxDbSqlTypeInfo struct WXDLLIMPEXP_BASE wxDbSqlTypeInfo
{ {
wxString TypeName; wxString TypeName;
SWORD FsqlType; SWORD FsqlType;
@@ -342,7 +342,7 @@ struct WXDLLEXPORT_BASE wxDbSqlTypeInfo
}; };
class WXDLLEXPORT_BASE wxDbColFor class WXDLLIMPEXP_BASE wxDbColFor
{ {
public: public:
wxString s_Field; // Formated String for Output wxString s_Field; // Formated String for Output
@@ -361,7 +361,7 @@ public:
}; };
class WXDLLEXPORT_BASE wxDbColInf class WXDLLIMPEXP_BASE wxDbColInf
{ {
public: public:
wxChar catalog[128+1]; wxChar catalog[128+1];
@@ -391,7 +391,7 @@ public:
}; };
class WXDLLEXPORT_BASE wxDbTableInf // Description of a Table class WXDLLIMPEXP_BASE wxDbTableInf // Description of a Table
{ {
public: public:
wxChar tableName[DB_MAX_TABLE_NAME_LEN+1]; wxChar tableName[DB_MAX_TABLE_NAME_LEN+1];
@@ -407,7 +407,7 @@ public:
}; };
class WXDLLEXPORT_BASE wxDbInf // Description of a Database class WXDLLIMPEXP_BASE wxDbInf // Description of a Database
{ {
public: public:
wxChar catalog[128+1]; wxChar catalog[128+1];
@@ -459,11 +459,11 @@ enum wxDBMS
// will overwrite the errors of the previously destroyed wxDb object in // will overwrite the errors of the previously destroyed wxDb object in
// this variable. // this variable.
WXDLLEXPORT_DATA_BASE(extern wxChar) WXDLLIMPEXP_DATA_BASE(extern wxChar)
DBerrorList[DB_MAX_ERROR_HISTORY][DB_MAX_ERROR_MSG_LEN]; DBerrorList[DB_MAX_ERROR_HISTORY][DB_MAX_ERROR_MSG_LEN];
class WXDLLEXPORT_BASE wxDb class WXDLLIMPEXP_BASE wxDb
{ {
private: private:
bool dbIsOpen; bool dbIsOpen;
@@ -702,15 +702,15 @@ class wxTablesInUse : public wxObject
// The following routines allow a user to get new database connections, free them // The following routines allow a user to get new database connections, free them
// for other code segments to use, or close all of them when the application has // for other code segments to use, or close all of them when the application has
// completed. // completed.
wxDb WXDLLEXPORT_BASE *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCursors=(bool)wxODBC_FWD_ONLY_CURSORS); wxDb WXDLLIMPEXP_BASE *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCursors=(bool)wxODBC_FWD_ONLY_CURSORS);
bool WXDLLEXPORT_BASE wxDbFreeConnection(wxDb *pDb); bool WXDLLIMPEXP_BASE wxDbFreeConnection(wxDb *pDb);
void WXDLLEXPORT_BASE wxDbCloseConnections(void); void WXDLLIMPEXP_BASE wxDbCloseConnections(void);
int WXDLLEXPORT_BASE wxDbConnectionsInUse(void); int WXDLLIMPEXP_BASE wxDbConnectionsInUse(void);
// Writes a message to the wxLog window (stdout usually) when an internal error // Writes a message to the wxLog window (stdout usually) when an internal error
// situation occurs. This function only works in DEBUG builds // situation occurs. This function only works in DEBUG builds
const wxChar* WXDLLEXPORT_BASE const wxChar* WXDLLIMPEXP_BASE
wxDbLogExtendedErrorMsg(const wxChar *userText, wxDbLogExtendedErrorMsg(const wxChar *userText,
wxDb *pDb, wxDb *pDb,
const wxChar *ErrFile, const wxChar *ErrFile,
@@ -718,7 +718,7 @@ wxDbLogExtendedErrorMsg(const wxChar *userText,
// This function sets the sql log state for all open wxDb objects // This function sets the sql log state for all open wxDb objects
bool WXDLLEXPORT_BASE bool WXDLLIMPEXP_BASE
wxDbSqlLog(wxDbSqlLogState state, const wxString &filename = SQL_LOG_FILENAME); wxDbSqlLog(wxDbSqlLogState state, const wxString &filename = SQL_LOG_FILENAME);
@@ -732,7 +732,7 @@ int WXDLLEXPORT wxDbCreateDataSource(const wxString &driverName, const wxString
// for a list of available datasources. Call this routine // for a list of available datasources. Call this routine
// the first time using SQL_FETCH_FIRST. Continue to call it // the first time using SQL_FETCH_FIRST. Continue to call it
// using SQL_FETCH_NEXT until you've exhausted the list. // using SQL_FETCH_NEXT until you've exhausted the list.
bool WXDLLEXPORT_BASE bool WXDLLIMPEXP_BASE
wxDbGetDataSource(HENV henv, wxChar *Dsn, SWORD DsnMax, wxChar *DsDesc, wxDbGetDataSource(HENV henv, wxChar *Dsn, SWORD DsnMax, wxChar *DsDesc,
SWORD DsDescMax, UWORD direction = SQL_FETCH_NEXT); SWORD DsDescMax, UWORD direction = SQL_FETCH_NEXT);
@@ -765,15 +765,15 @@ typedef wxTablesInUse CstructTablesInUse;
#endif #endif
// Deprecated function names that are replaced by the function names listed above // Deprecated function names that are replaced by the function names listed above
wxDB WXDLLEXPORT_BASE wxDB WXDLLIMPEXP_BASE
*GetDbConnection(DbStuff *pDbStuff, bool FwdOnlyCursors=(bool)wxODBC_FWD_ONLY_CURSORS); *GetDbConnection(DbStuff *pDbStuff, bool FwdOnlyCursors=(bool)wxODBC_FWD_ONLY_CURSORS);
bool WXDLLEXPORT_BASE FreeDbConnection(wxDB *pDb); bool WXDLLIMPEXP_BASE FreeDbConnection(wxDB *pDb);
void WXDLLEXPORT_BASE CloseDbConnections(void); void WXDLLIMPEXP_BASE CloseDbConnections(void);
int WXDLLEXPORT_BASE NumberDbConnectionsInUse(void); int WXDLLIMPEXP_BASE NumberDbConnectionsInUse(void);
bool SqlLog(sqlLog state, const wxChar *filename = SQL_LOG_FILENAME); bool SqlLog(sqlLog state, const wxChar *filename = SQL_LOG_FILENAME);
bool WXDLLEXPORT_BASE bool WXDLLIMPEXP_BASE
GetDataSource(HENV henv, char *Dsn, SWORD DsnMax, char *DsDesc, SWORD DsDescMax, GetDataSource(HENV henv, char *Dsn, SWORD DsnMax, char *DsDesc, SWORD DsDescMax,
UWORD direction = SQL_FETCH_NEXT); UWORD direction = SQL_FETCH_NEXT);

8
include/wx/dbtable.h
View File

@@ -56,7 +56,7 @@ const int wxDB_NO_MORE_COLUMN_NUMBERS = -1;
// wxDbTable class which allows it to create a table in the data // wxDbTable class which allows it to create a table in the data
// source, exchange data between the data source and the C++ // source, exchange data between the data source and the C++
// object, and so on. // object, and so on.
class WXDLLEXPORT_BASE wxDbColDef class WXDLLIMPEXP_BASE wxDbColDef
{ {
public: public:
wxChar ColName[DB_MAX_COLUMN_NAME_LEN+1]; // Column Name wxChar ColName[DB_MAX_COLUMN_NAME_LEN+1]; // Column Name
@@ -77,7 +77,7 @@ public:
}; // wxDbColDef }; // wxDbColDef
class WXDLLEXPORT_BASE wxDbColDataPtr class WXDLLIMPEXP_BASE wxDbColDataPtr
{ {
public: public:
void *PtrDataObj; void *PtrDataObj;
@@ -87,7 +87,7 @@ public:
// This structure is used when creating secondary indexes. // This structure is used when creating secondary indexes.
class WXDLLEXPORT_BASE wxDbIdxDef class WXDLLIMPEXP_BASE wxDbIdxDef
{ {
public: public:
wxChar ColName[DB_MAX_COLUMN_NAME_LEN+1]; wxChar ColName[DB_MAX_COLUMN_NAME_LEN+1];
@@ -95,7 +95,7 @@ public:
}; // wxDbIdxDef }; // wxDbIdxDef
class WXDLLEXPORT_BASE wxDbTable class WXDLLIMPEXP_BASE wxDbTable
{ {
private: private:
ULONG tableID; // Used for debugging. This can help to match up mismatched constructors/destructors ULONG tableID; // Used for debugging. This can help to match up mismatched constructors/destructors

6
include/wx/dde.h
View File

@@ -7,9 +7,9 @@ class wxDDEClient;
class wxDDEServer; class wxDDEServer;
class wxDDEConnection; class wxDDEConnection;
WX_DECLARE_USER_EXPORTED_LIST(wxDDEClient, wxDDEClientList, WXDLLEXPORT_BASE); WX_DECLARE_USER_EXPORTED_LIST(wxDDEClient, wxDDEClientList, WXDLLIMPEXP_BASE);
WX_DECLARE_USER_EXPORTED_LIST(wxDDEServer, wxDDEServerList, WXDLLEXPORT_BASE); WX_DECLARE_USER_EXPORTED_LIST(wxDDEServer, wxDDEServerList, WXDLLIMPEXP_BASE);
WX_DECLARE_USER_EXPORTED_LIST(wxDDEConnection, wxDDEConnectionList, WXDLLEXPORT_BASE); WX_DECLARE_USER_EXPORTED_LIST(wxDDEConnection, wxDDEConnectionList, WXDLLIMPEXP_BASE);
#if defined(__WXMSW__) #if defined(__WXMSW__)
#include "wx/msw/dde.h" #include "wx/msw/dde.h"

12
include/wx/debug.h
View File

@@ -78,21 +78,21 @@
szFile and nLine - file name and line number of the ASSERT szFile and nLine - file name and line number of the ASSERT
szMsg - optional message explaining the reason szMsg - optional message explaining the reason
*/ */
extern void WXDLLEXPORT_BASE wxOnAssert(const wxChar *szFile, extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *szFile,
int nLine, int nLine,
const wxChar *szCond, const wxChar *szCond,
const wxChar *szMsg = NULL); const wxChar *szMsg = NULL);
// call this function to break into the debugger unconditionally (assuming // call this function to break into the debugger unconditionally (assuming
// the program is running under debugger, of course) // the program is running under debugger, of course)
extern void WXDLLEXPORT_BASE wxTrap(); extern void WXDLLIMPEXP_BASE wxTrap();
// helper function used to implement wxASSERT and wxASSERT_MSG // helper function used to implement wxASSERT and wxASSERT_MSG
// //
// note using "int" and not "bool" for cond to avoid VC++ warnings about // note using "int" and not "bool" for cond to avoid VC++ warnings about
// implicit conversions when doing "wxAssert( pointer )" and also use of // implicit conversions when doing "wxAssert( pointer )" and also use of
// "!!cond" below to ensure that everything is converted to int // "!!cond" below to ensure that everything is converted to int
extern void WXDLLEXPORT_BASE wxAssert(int cond, extern void WXDLLIMPEXP_BASE wxAssert(int cond,
const wxChar *szFile, const wxChar *szFile,
int nLine, int nLine,
const wxChar *szCond, const wxChar *szCond,
@@ -112,7 +112,7 @@
// //
// NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and shouldn't be // NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and shouldn't be
// used any longer // used any longer
extern bool WXDLLEXPORT_BASE wxAssertIsEqual(int x, int y); extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
#else #else
#define wxTrap() #define wxTrap()
@@ -124,7 +124,7 @@
// Use of wxFalse instead of FALSE suppresses compiler warnings about testing // Use of wxFalse instead of FALSE suppresses compiler warnings about testing
// constant expression // constant expression
WXDLLEXPORT_DATA_BASE(extern const bool) wxFalse; WXDLLIMPEXP_DATA_BASE(extern const bool) wxFalse;
#define wxAssertFailure wxFalse #define wxAssertFailure wxFalse
// special form of assert: always triggers it (in debug mode) // special form of assert: always triggers it (in debug mode)
@@ -227,7 +227,7 @@ WXDLLEXPORT_DATA_BASE(extern const bool) wxFalse;
// currently this only really works under Mac in CodeWarrior builds, it always // currently this only really works under Mac in CodeWarrior builds, it always
// returns false otherwise // returns false otherwise
#ifdef __WXMAC__ #ifdef __WXMAC__
extern bool WXDLLEXPORT_BASE wxIsDebuggerRunning(); extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
#else // !Mac #else // !Mac
inline bool wxIsDebuggerRunning() { return false; } inline bool wxIsDebuggerRunning() { return false; }
#endif // Mac/!Mac #endif // Mac/!Mac

28
include/wx/defs.h
View File

@@ -387,30 +387,30 @@ typedef int wxWindowID;
// WXDLLEXPORT maps to export declaration when building the DLL, to import // WXDLLEXPORT maps to export declaration when building the DLL, to import
// declaration if using it or to nothing at all if we don't use wxWin as DLL // declaration if using it or to nothing at all if we don't use wxWin as DLL
#ifdef WXMAKINGDLL_BASE #ifdef WXMAKINGDLL_BASE
#define WXDLLEXPORT_BASE WXEXPORT #define WXDLLIMPEXP_BASE WXEXPORT
#define WXDLLEXPORT_DATA_BASE(type) WXEXPORT type #define WXDLLIMPEXP_DATA_BASE(type) WXEXPORT type
#elif defined(WXUSINGDLL_BASE) #elif defined(WXUSINGDLL_BASE)
#define WXDLLEXPORT_BASE WXIMPORT #define WXDLLIMPEXP_BASE WXIMPORT
#define WXDLLEXPORT_DATA_BASE(type) WXIMPORT type #define WXDLLIMPEXP_DATA_BASE(type) WXIMPORT type
#else // not making nor using DLL #else // not making nor using DLL
#define WXDLLEXPORT_BASE #define WXDLLIMPEXP_BASE
#define WXDLLEXPORT_DATA_BASE(type) type #define WXDLLIMPEXP_DATA_BASE(type) type
#endif #endif
#ifdef WXMAKINGDLL_CORE #ifdef WXMAKINGDLL_CORE
#define WXDLLEXPORT_CORE WXEXPORT #define WXDLLIMPEXP_CORE WXEXPORT
#define WXDLLEXPORT_DATA_CORE(type) WXEXPORT type #define WXDLLIMPEXP_DATA_CORE(type) WXEXPORT type
#elif defined(WXUSINGDLL_CORE) #elif defined(WXUSINGDLL_CORE)
#define WXDLLEXPORT_CORE WXIMPORT #define WXDLLIMPEXP_CORE WXIMPORT
#define WXDLLEXPORT_DATA_CORE(type) WXIMPORT type #define WXDLLIMPEXP_DATA_CORE(type) WXIMPORT type
#else // not making nor using DLL #else // not making nor using DLL
#define WXDLLEXPORT_CORE #define WXDLLIMPEXP_CORE
#define WXDLLEXPORT_DATA_CORE(type) type #define WXDLLIMPEXP_DATA_CORE(type) type
#endif #endif
// for backwards compatibility, define suffix-less versions too // for backwards compatibility, define suffix-less versions too
#define WXDLLEXPORT WXDLLEXPORT_CORE #define WXDLLEXPORT WXDLLIMPEXP_CORE
#define WXDLLEXPORT_DATA WXDLLEXPORT_DATA_CORE #define WXDLLEXPORT_DATA WXDLLIMPEXP_DATA_CORE
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Very common macros // Very common macros

6
include/wx/dir.h
View File

@@ -49,7 +49,7 @@ enum wxDirTraverseResult
// wxDirTraverser: helper class for wxDir::Traverse() // wxDirTraverser: helper class for wxDir::Traverse()
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxDirTraverser class WXDLLIMPEXP_BASE wxDirTraverser
{ {
public: public:
// called for each file found by wxDir::Traverse() // called for each file found by wxDir::Traverse()
@@ -79,9 +79,9 @@ public:
// wxDir: portable equivalent of {open/read/close}dir functions // wxDir: portable equivalent of {open/read/close}dir functions
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxDirData; class WXDLLIMPEXP_BASE wxDirData;
class WXDLLEXPORT_BASE wxDir class WXDLLIMPEXP_BASE wxDir
{ {
public: public:
// test for existence of a directory with the given name // test for existence of a directory with the given name

10
include/wx/dynlib.h
View File

@@ -76,7 +76,7 @@
DLLs and the resolving of symbols in them. There are no instances of this DLLs and the resolving of symbols in them. There are no instances of this
class, it simply serves as a namespace for its static member functions. class, it simply serves as a namespace for its static member functions.
*/ */
class WXDLLEXPORT_BASE wxDllLoader class WXDLLIMPEXP_BASE wxDllLoader
{ {
public: public:
/* /*
@@ -130,7 +130,7 @@ private:
// wxDynamicLibrary - friendly interface to wxDllLoader // wxDynamicLibrary - friendly interface to wxDllLoader
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxDynamicLibrary class WXDLLIMPEXP_BASE wxDynamicLibrary
{ {
public: public:
// ctors // ctors
@@ -185,7 +185,7 @@ private:
// wxLibrary // wxLibrary
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxLibrary : public wxObject class WXDLLIMPEXP_BASE wxLibrary : public wxObject
{ {
public: public:
wxLibrary(wxDllType handle); wxLibrary(wxDllType handle);
@@ -210,7 +210,7 @@ public:
// wxLibraries // wxLibraries
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxLibraries class WXDLLIMPEXP_BASE wxLibraries
{ {
public: public:
wxLibraries(); wxLibraries();
@@ -229,7 +229,7 @@ protected:
// Global variables // Global variables
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
extern WXDLLEXPORT_DATA_BASE(wxLibraries) wxTheLibraries; extern WXDLLIMPEXP_DATA_BASE(wxLibraries) wxTheLibraries;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Interesting defines // Interesting defines

10
include/wx/dynload.h
View File

@@ -38,7 +38,7 @@
#include "wx/msw/private.h" #include "wx/msw/private.h"
#endif #endif
class WXDLLEXPORT_BASE wxPluginLibrary; class WXDLLIMPEXP_BASE wxPluginLibrary;
WX_DECLARE_EXPORTED_STRING_HASH_MAP(wxPluginLibrary *, wxDLManifest); WX_DECLARE_EXPORTED_STRING_HASH_MAP(wxPluginLibrary *, wxDLManifest);
typedef wxDLManifest wxDLImports; typedef wxDLManifest wxDLImports;
@@ -98,7 +98,7 @@ enum wxDLFlags
}; };
class WXDLLEXPORT_BASE wxDynamicLibrary class WXDLLIMPEXP_BASE wxDynamicLibrary
{ {
public: public:
@@ -188,7 +188,7 @@ protected:
// instantiate this class directly anyway, use wxPluginManager // instantiate this class directly anyway, use wxPluginManager
// instead. // instead.
class WXDLLEXPORT_BASE wxPluginLibrary : public wxDynamicLibrary class WXDLLIMPEXP_BASE wxPluginLibrary : public wxDynamicLibrary
{ {
public: public:
@@ -242,7 +242,7 @@ private:
}; };
class WXDLLEXPORT_BASE wxPluginManager class WXDLLIMPEXP_BASE wxPluginManager
{ {
public: public:
@@ -308,7 +308,7 @@ private:
// serves as a namespace for its static member functions. // serves as a namespace for its static member functions.
#if WXWIN_COMPATIBILITY_2_2 #if WXWIN_COMPATIBILITY_2_2
class WXDLLEXPORT_BASE wxDllLoader class WXDLLIMPEXP_BASE wxDllLoader
{ {
public: public:

2
include/wx/encconv.h
View File

@@ -55,7 +55,7 @@ WX_DEFINE_ARRAY_INT(wxFontEncoding, wxFontEncodingArray);
// 8bit encodings/charsets. It can also convert from/to Unicode // 8bit encodings/charsets. It can also convert from/to Unicode
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxEncodingConverter : public wxObject class WXDLLIMPEXP_BASE wxEncodingConverter : public wxObject
{ {
public: public:

116
include/wx/event.h
View File

@@ -31,12 +31,12 @@
// forward declarations // forward declarations
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxList; class WXDLLIMPEXP_BASE wxList;
#if wxUSE_GUI #if wxUSE_GUI
class WXDLLEXPORT_CORE wxDC; class WXDLLIMPEXP_CORE wxDC;
class WXDLLEXPORT_CORE wxMenu; class WXDLLIMPEXP_CORE wxMenu;
class WXDLLEXPORT_CORE wxWindow; class WXDLLIMPEXP_CORE wxWindow;
#endif // wxUSE_GUI #endif // wxUSE_GUI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -91,14 +91,14 @@ typedef int wxEventType;
#define DECLARE_EXPORTED_EVENT_TYPE(expdecl, name, value) \ #define DECLARE_EXPORTED_EVENT_TYPE(expdecl, name, value) \
extern expdecl const wxEventType name; extern expdecl const wxEventType name;
#define DECLARE_EVENT_TYPE(name, value) \ #define DECLARE_EVENT_TYPE(name, value) \
DECLARE_EXPORTED_EVENT_TYPE(WXDLLEXPORT_CORE, name, value) DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_CORE, name, value)
#define DECLARE_LOCAL_EVENT_TYPE(name, value) \ #define DECLARE_LOCAL_EVENT_TYPE(name, value) \
DECLARE_EXPORTED_EVENT_TYPE(/* */, name, value) DECLARE_EXPORTED_EVENT_TYPE(/* */, name, value)
#define DEFINE_EVENT_TYPE(name) const wxEventType name = wxNewEventType(); #define DEFINE_EVENT_TYPE(name) const wxEventType name = wxNewEventType();
#define DEFINE_LOCAL_EVENT_TYPE(name) DEFINE_EVENT_TYPE(name) #define DEFINE_LOCAL_EVENT_TYPE(name) DEFINE_EVENT_TYPE(name)
// generate a new unique event type // generate a new unique event type
extern WXDLLEXPORT_BASE wxEventType wxNewEventType(); extern WXDLLIMPEXP_BASE wxEventType wxNewEventType();
#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
@@ -111,9 +111,9 @@ BEGIN_DECLARE_EVENT_TYPES()
#else // !WXWIN_COMPATIBILITY_EVENT_TYPES #else // !WXWIN_COMPATIBILITY_EVENT_TYPES
// it is important to still have these as constants to avoid // it is important to still have these as constants to avoid
// initialization order related problems // initialization order related problems
DECLARE_EXPORTED_EVENT_TYPE(WXDLLEXPORT_BASE, wxEVT_NULL, 0) DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_NULL, 0)
DECLARE_EXPORTED_EVENT_TYPE(WXDLLEXPORT_BASE, wxEVT_FIRST, 10000) DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_FIRST, 10000)
DECLARE_EXPORTED_EVENT_TYPE(WXDLLEXPORT_BASE, wxEVT_USER_FIRST, wxEVT_FIRST + 2000) DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_USER_FIRST, wxEVT_FIRST + 2000)
#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
DECLARE_EVENT_TYPE(wxEVT_COMMAND_BUTTON_CLICKED, 1) DECLARE_EVENT_TYPE(wxEVT_COMMAND_BUTTON_CLICKED, 1)
@@ -145,7 +145,7 @@ BEGIN_DECLARE_EVENT_TYPES()
DECLARE_EVENT_TYPE(wxEVT_COMMAND_SPINCTRL_UPDATED, 18) DECLARE_EVENT_TYPE(wxEVT_COMMAND_SPINCTRL_UPDATED, 18)
// Sockets and timers send events, too // Sockets and timers send events, too
DECLARE_EXPORTED_EVENT_TYPE(WXDLLEXPORT_BASE, wxEVT_SOCKET, 50) DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_SOCKET, 50)
DECLARE_EVENT_TYPE(wxEVT_TIMER , 80) DECLARE_EVENT_TYPE(wxEVT_TIMER , 80)
// Mouse event types // Mouse event types
@@ -249,7 +249,7 @@ BEGIN_DECLARE_EVENT_TYPES()
DECLARE_EVENT_TYPE(wxEVT_MEASURE_ITEM, 436) DECLARE_EVENT_TYPE(wxEVT_MEASURE_ITEM, 436)
DECLARE_EVENT_TYPE(wxEVT_COMPARE_ITEM, 437) DECLARE_EVENT_TYPE(wxEVT_COMPARE_ITEM, 437)
DECLARE_EVENT_TYPE(wxEVT_INIT_DIALOG, 438) DECLARE_EVENT_TYPE(wxEVT_INIT_DIALOG, 438)
DECLARE_EXPORTED_EVENT_TYPE(WXDLLEXPORT_BASE, wxEVT_IDLE, 439) DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_IDLE, 439)
DECLARE_EVENT_TYPE(wxEVT_UPDATE_UI, 440) DECLARE_EVENT_TYPE(wxEVT_UPDATE_UI, 440)
DECLARE_EVENT_TYPE(wxEVT_SIZING, 441) DECLARE_EVENT_TYPE(wxEVT_SIZING, 441)
DECLARE_EVENT_TYPE(wxEVT_MOVING, 4442) DECLARE_EVENT_TYPE(wxEVT_MOVING, 4442)
@@ -282,7 +282,7 @@ END_DECLARE_EVENT_TYPES()
// //
// still, any new code using it should include wx/textctrl.h explicitly // still, any new code using it should include wx/textctrl.h explicitly
#if !WXWIN_COMPATIBILITY_EVENT_TYPES #if !WXWIN_COMPATIBILITY_EVENT_TYPES
extern const wxEventType WXDLLEXPORT_CORE wxEVT_COMMAND_TEXT_UPDATED; extern const wxEventType WXDLLIMPEXP_CORE wxEVT_COMMAND_TEXT_UPDATED;
#endif #endif
#if WXWIN_COMPATIBILITY #if WXWIN_COMPATIBILITY
@@ -341,7 +341,7 @@ END_DECLARE_EVENT_TYPES()
* *
*/ */
class WXDLLEXPORT_BASE wxEvent : public wxObject class WXDLLIMPEXP_BASE wxEvent : public wxObject
{ {
private: private:
wxEvent& operator=(const wxEvent&); wxEvent& operator=(const wxEvent&);
@@ -411,7 +411,7 @@ private:
wxEVT_COMMAND_TOGGLEBUTTON_CLICKED wxEVT_COMMAND_TOGGLEBUTTON_CLICKED
*/ */
class WXDLLEXPORT_CORE wxCommandEvent : public wxEvent class WXDLLIMPEXP_CORE wxCommandEvent : public wxEvent
{ {
private: private:
wxCommandEvent& operator=(const wxCommandEvent& event); wxCommandEvent& operator=(const wxCommandEvent& event);
@@ -474,7 +474,7 @@ private:
// this class adds a possibility to react (from the user) code to a control // this class adds a possibility to react (from the user) code to a control
// notification: allow or veto the operation being reported. // notification: allow or veto the operation being reported.
class WXDLLEXPORT_CORE wxNotifyEvent : public wxCommandEvent class WXDLLIMPEXP_CORE wxNotifyEvent : public wxCommandEvent
{ {
public: public:
wxNotifyEvent(wxEventType commandType = wxEVT_NULL, int winid = 0) wxNotifyEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)
@@ -517,7 +517,7 @@ private:
wxEVT_SCROLL_ENDSCROLL wxEVT_SCROLL_ENDSCROLL
*/ */
class WXDLLEXPORT_CORE wxScrollEvent : public wxCommandEvent class WXDLLIMPEXP_CORE wxScrollEvent : public wxCommandEvent
{ {
public: public:
wxScrollEvent(wxEventType commandType = wxEVT_NULL, wxScrollEvent(wxEventType commandType = wxEVT_NULL,
@@ -547,7 +547,7 @@ private:
wxEVT_SCROLLWIN_THUMBRELEASE wxEVT_SCROLLWIN_THUMBRELEASE
*/ */
class WXDLLEXPORT_CORE wxScrollWinEvent : public wxEvent class WXDLLIMPEXP_CORE wxScrollWinEvent : public wxEvent
{ {
public: public:
wxScrollWinEvent(wxEventType commandType = wxEVT_NULL, wxScrollWinEvent(wxEventType commandType = wxEVT_NULL,
@@ -610,7 +610,7 @@ enum
wxMOUSE_BTN_RIGHT = 2 wxMOUSE_BTN_RIGHT = 2
}; };
class WXDLLEXPORT_CORE wxMouseEvent : public wxEvent class WXDLLIMPEXP_CORE wxMouseEvent : public wxEvent
{ {
public: public:
wxMouseEvent(wxEventType mouseType = wxEVT_NULL); wxMouseEvent(wxEventType mouseType = wxEVT_NULL);
@@ -780,7 +780,7 @@ private:
wxEVT_SET_CURSOR wxEVT_SET_CURSOR
*/ */
class WXDLLEXPORT_CORE wxSetCursorEvent : public wxEvent class WXDLLIMPEXP_CORE wxSetCursorEvent : public wxEvent
{ {
public: public:
wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0) wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0)
@@ -821,7 +821,7 @@ private:
wxEVT_KEY_UP wxEVT_KEY_UP
*/ */
class WXDLLEXPORT_CORE wxKeyEvent : public wxEvent class WXDLLIMPEXP_CORE wxKeyEvent : public wxEvent
{ {
public: public:
wxKeyEvent(wxEventType keyType = wxEVT_NULL); wxKeyEvent(wxEventType keyType = wxEVT_NULL);
@@ -927,7 +927,7 @@ private:
wxEVT_SIZE wxEVT_SIZE
*/ */
class WXDLLEXPORT_CORE wxSizeEvent : public wxEvent class WXDLLIMPEXP_CORE wxSizeEvent : public wxEvent
{ {
public: public:
wxSizeEvent() : wxEvent(0, wxEVT_SIZE) wxSizeEvent() : wxEvent(0, wxEVT_SIZE)
@@ -964,7 +964,7 @@ private:
wxEVT_MOVE wxEVT_MOVE
*/ */
class WXDLLEXPORT_CORE wxMoveEvent : public wxEvent class WXDLLIMPEXP_CORE wxMoveEvent : public wxEvent
{ {
public: public:
wxMoveEvent() wxMoveEvent()
@@ -1004,10 +1004,10 @@ private:
#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__)) #if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__))
// see comments in src/msw|os2/dcclient.cpp where g_isPainting is defined // see comments in src/msw|os2/dcclient.cpp where g_isPainting is defined
extern WXDLLEXPORT_CORE int g_isPainting; extern WXDLLIMPEXP_CORE int g_isPainting;
#endif // debug #endif // debug
class WXDLLEXPORT_CORE wxPaintEvent : public wxEvent class WXDLLIMPEXP_CORE wxPaintEvent : public wxEvent
{ {
public: public:
wxPaintEvent(int Id = 0) wxPaintEvent(int Id = 0)
@@ -1032,7 +1032,7 @@ private:
DECLARE_DYNAMIC_CLASS(wxPaintEvent) DECLARE_DYNAMIC_CLASS(wxPaintEvent)
}; };
class WXDLLEXPORT_CORE wxNcPaintEvent : public wxEvent class WXDLLIMPEXP_CORE wxNcPaintEvent : public wxEvent
{ {
public: public:
wxNcPaintEvent(int winid = 0) wxNcPaintEvent(int winid = 0)
@@ -1050,7 +1050,7 @@ private:
wxEVT_ERASE_BACKGROUND wxEVT_ERASE_BACKGROUND
*/ */
class WXDLLEXPORT_CORE wxEraseEvent : public wxEvent class WXDLLIMPEXP_CORE wxEraseEvent : public wxEvent
{ {
private: private:
wxEraseEvent& operator=(const wxEraseEvent& event); wxEraseEvent& operator=(const wxEraseEvent& event);
@@ -1082,7 +1082,7 @@ private:
wxEVT_KILL_FOCUS wxEVT_KILL_FOCUS
*/ */
class WXDLLEXPORT_CORE wxFocusEvent : public wxEvent class WXDLLIMPEXP_CORE wxFocusEvent : public wxEvent
{ {
private: private:
wxFocusEvent& operator=(const wxFocusEvent& event); wxFocusEvent& operator=(const wxFocusEvent& event);
@@ -1113,7 +1113,7 @@ private:
// wxChildFocusEvent notifies the parent that a child has got the focus: unlike // wxChildFocusEvent notifies the parent that a child has got the focus: unlike
// wxFocusEvent it is propgated upwards the window chain // wxFocusEvent it is propgated upwards the window chain
class WXDLLEXPORT_CORE wxChildFocusEvent : public wxCommandEvent class WXDLLIMPEXP_CORE wxChildFocusEvent : public wxCommandEvent
{ {
public: public:
wxChildFocusEvent(wxWindow *win = NULL); wxChildFocusEvent(wxWindow *win = NULL);
@@ -1132,7 +1132,7 @@ private:
wxEVT_ACTIVATE_APP wxEVT_ACTIVATE_APP
*/ */
class WXDLLEXPORT_CORE wxActivateEvent : public wxEvent class WXDLLIMPEXP_CORE wxActivateEvent : public wxEvent
{ {
public: public:
wxActivateEvent(wxEventType type = wxEVT_NULL, bool active = TRUE, int Id = 0) wxActivateEvent(wxEventType type = wxEVT_NULL, bool active = TRUE, int Id = 0)
@@ -1158,7 +1158,7 @@ private:
wxEVT_INIT_DIALOG wxEVT_INIT_DIALOG
*/ */
class WXDLLEXPORT_CORE wxInitDialogEvent : public wxEvent class WXDLLIMPEXP_CORE wxInitDialogEvent : public wxEvent
{ {
public: public:
wxInitDialogEvent(int Id = 0) wxInitDialogEvent(int Id = 0)
@@ -1178,7 +1178,7 @@ private:
wxEVT_MENU_HIGHLIGHT, wxEVT_MENU_HIGHLIGHT,
*/ */
class WXDLLEXPORT_CORE wxMenuEvent : public wxEvent class WXDLLIMPEXP_CORE wxMenuEvent : public wxEvent
{ {
public: public:
wxMenuEvent(wxEventType type = wxEVT_NULL, int winid = 0) wxMenuEvent(wxEventType type = wxEVT_NULL, int winid = 0)
@@ -1209,7 +1209,7 @@ private:
wxEVT_QUERY_END_SESSION wxEVT_QUERY_END_SESSION
*/ */
class WXDLLEXPORT_CORE wxCloseEvent : public wxEvent class WXDLLIMPEXP_CORE wxCloseEvent : public wxEvent
{ {
public: public:
wxCloseEvent(wxEventType type = wxEVT_NULL, int winid = 0) wxCloseEvent(wxEventType type = wxEVT_NULL, int winid = 0)
@@ -1276,7 +1276,7 @@ private:
wxEVT_SHOW wxEVT_SHOW
*/ */
class WXDLLEXPORT_CORE wxShowEvent : public wxEvent class WXDLLIMPEXP_CORE wxShowEvent : public wxEvent
{ {
public: public:
wxShowEvent(int winid = 0, bool show = FALSE) wxShowEvent(int winid = 0, bool show = FALSE)
@@ -1302,7 +1302,7 @@ private:
wxEVT_ICONIZE wxEVT_ICONIZE
*/ */
class WXDLLEXPORT_CORE wxIconizeEvent : public wxEvent class WXDLLIMPEXP_CORE wxIconizeEvent : public wxEvent
{ {
public: public:
wxIconizeEvent(int winid = 0, bool iconized = TRUE) wxIconizeEvent(int winid = 0, bool iconized = TRUE)
@@ -1327,7 +1327,7 @@ private:
wxEVT_MAXIMIZE wxEVT_MAXIMIZE
*/ */
class WXDLLEXPORT_CORE wxMaximizeEvent : public wxEvent class WXDLLIMPEXP_CORE wxMaximizeEvent : public wxEvent
{ {
public: public:
wxMaximizeEvent(int winid = 0) wxMaximizeEvent(int winid = 0)
@@ -1365,7 +1365,7 @@ enum
wxJOY_BUTTON4 = 8 wxJOY_BUTTON4 = 8
}; };
class WXDLLEXPORT_CORE wxJoystickEvent : public wxEvent class WXDLLIMPEXP_CORE wxJoystickEvent : public wxEvent
{ {
public: public:
wxPoint m_pos; wxPoint m_pos;
@@ -1443,7 +1443,7 @@ private:
wxEVT_DROP_FILES wxEVT_DROP_FILES
*/ */
class WXDLLEXPORT_CORE wxDropFilesEvent : public wxEvent class WXDLLIMPEXP_CORE wxDropFilesEvent : public wxEvent
{ {
private: private:
wxDropFilesEvent& operator=(const wxDropFilesEvent& event); wxDropFilesEvent& operator=(const wxDropFilesEvent& event);
@@ -1496,7 +1496,7 @@ private:
wxEVT_UPDATE_UI wxEVT_UPDATE_UI
*/ */
class WXDLLEXPORT_CORE wxUpdateUIEvent : public wxCommandEvent class WXDLLIMPEXP_CORE wxUpdateUIEvent : public wxCommandEvent
{ {
public: public:
wxUpdateUIEvent(wxWindowID commandId = 0) wxUpdateUIEvent(wxWindowID commandId = 0)
@@ -1548,7 +1548,7 @@ private:
*/ */
// TODO: shouldn't all events record the window ID? // TODO: shouldn't all events record the window ID?
class WXDLLEXPORT_CORE wxSysColourChangedEvent : public wxEvent class WXDLLIMPEXP_CORE wxSysColourChangedEvent : public wxEvent
{ {
public: public:
wxSysColourChangedEvent() wxSysColourChangedEvent()
@@ -1567,7 +1567,7 @@ private:
(even if it released the capture itself). (even if it released the capture itself).
*/ */
class WXDLLEXPORT_CORE wxMouseCaptureChangedEvent : public wxEvent class WXDLLIMPEXP_CORE wxMouseCaptureChangedEvent : public wxEvent
{ {
private: private:
wxMouseCaptureChangedEvent operator=(const wxMouseCaptureChangedEvent& event); wxMouseCaptureChangedEvent operator=(const wxMouseCaptureChangedEvent& event);
@@ -1595,7 +1595,7 @@ private:
/* /*
wxEVT_DISPLAY_CHANGED wxEVT_DISPLAY_CHANGED
*/ */
class WXDLLEXPORT_CORE wxDisplayChangedEvent : public wxEvent class WXDLLIMPEXP_CORE wxDisplayChangedEvent : public wxEvent
{ {
private: private:
DECLARE_DYNAMIC_CLASS(wxDisplayChangedEvent) DECLARE_DYNAMIC_CLASS(wxDisplayChangedEvent)
@@ -1612,7 +1612,7 @@ public:
wxEVT_PALETTE_CHANGED wxEVT_PALETTE_CHANGED
*/ */
class WXDLLEXPORT_CORE wxPaletteChangedEvent : public wxEvent class WXDLLIMPEXP_CORE wxPaletteChangedEvent : public wxEvent
{ {
private: private:
wxPaletteChangedEvent& operator=(const wxPaletteChangedEvent& event); wxPaletteChangedEvent& operator=(const wxPaletteChangedEvent& event);
@@ -1645,7 +1645,7 @@ private:
Indicates the window is getting keyboard focus and should re-do its palette. Indicates the window is getting keyboard focus and should re-do its palette.
*/ */
class WXDLLEXPORT_CORE wxQueryNewPaletteEvent : public wxEvent class WXDLLIMPEXP_CORE wxQueryNewPaletteEvent : public wxEvent
{ {
public: public:
wxQueryNewPaletteEvent(wxWindowID winid = 0) wxQueryNewPaletteEvent(wxWindowID winid = 0)
@@ -1675,7 +1675,7 @@ private:
wxEVT_NAVIGATION_KEY wxEVT_NAVIGATION_KEY
*/ */
// NB: don't derive from command event to avoid being propagated to the parent // NB: don't derive from command event to avoid being propagated to the parent
class WXDLLEXPORT_CORE wxNavigationKeyEvent : public wxEvent class WXDLLIMPEXP_CORE wxNavigationKeyEvent : public wxEvent
{ {
private: private:
wxNavigationKeyEvent& operator=(const wxNavigationKeyEvent& event); wxNavigationKeyEvent& operator=(const wxNavigationKeyEvent& event);
@@ -1746,7 +1746,7 @@ private:
wxEVT_DESTROY wxEVT_DESTROY
*/ */
class WXDLLEXPORT_CORE wxWindowCreateEvent : public wxCommandEvent class WXDLLIMPEXP_CORE wxWindowCreateEvent : public wxCommandEvent
{ {
public: public:
wxWindowCreateEvent(wxWindow *win = NULL); wxWindowCreateEvent(wxWindow *win = NULL);
@@ -1759,7 +1759,7 @@ private:
DECLARE_DYNAMIC_CLASS(wxWindowCreateEvent) DECLARE_DYNAMIC_CLASS(wxWindowCreateEvent)
}; };
class WXDLLEXPORT_CORE wxWindowDestroyEvent : public wxCommandEvent class WXDLLIMPEXP_CORE wxWindowDestroyEvent : public wxCommandEvent
{ {
public: public:
wxWindowDestroyEvent(wxWindow *win = NULL); wxWindowDestroyEvent(wxWindow *win = NULL);
@@ -1778,7 +1778,7 @@ private:
wxEVT_DETAILED_HELP wxEVT_DETAILED_HELP
*/ */
class WXDLLEXPORT_CORE wxHelpEvent : public wxCommandEvent class WXDLLIMPEXP_CORE wxHelpEvent : public wxCommandEvent
{ {
public: public:
wxHelpEvent(wxEventType type = wxEVT_NULL, wxHelpEvent(wxEventType type = wxEVT_NULL,
@@ -1825,7 +1825,7 @@ private:
wxEVT_CONTEXT_MENU wxEVT_CONTEXT_MENU
*/ */
class WXDLLEXPORT_CORE wxContextMenuEvent : public wxCommandEvent class WXDLLIMPEXP_CORE wxContextMenuEvent : public wxCommandEvent
{ {
public: public:
wxContextMenuEvent(wxEventType type = wxEVT_NULL, wxContextMenuEvent(wxEventType type = wxEVT_NULL,
@@ -1857,7 +1857,7 @@ private:
wxEVT_IDLE wxEVT_IDLE
*/ */
class WXDLLEXPORT_CORE wxIdleEvent : public wxEvent class WXDLLIMPEXP_CORE wxIdleEvent : public wxEvent
{ {
public: public:
wxIdleEvent() wxIdleEvent()
@@ -1906,7 +1906,7 @@ typedef void (wxObject::*wxObjectEventFunction)(wxEvent&);
// we have to keep both versions // we have to keep both versions
#if WXWIN_COMPATIBILITY_EVENT_TYPES #if WXWIN_COMPATIBILITY_EVENT_TYPES
struct WXDLLEXPORT_BASE wxEventTableEntry struct WXDLLIMPEXP_BASE wxEventTableEntry
{ {
// For some reason, this can't be wxEventType, or VC++ complains. // For some reason, this can't be wxEventType, or VC++ complains.
int m_eventType; // main event type int m_eventType; // main event type
@@ -1922,7 +1922,7 @@ struct WXDLLEXPORT_BASE wxEventTableEntry
// struct containing the members common to static and dynamic event tables // struct containing the members common to static and dynamic event tables
// entries // entries
struct WXDLLEXPORT_BASE wxEventTableEntryBase struct WXDLLIMPEXP_BASE wxEventTableEntryBase
{ {
private: private:
wxEventTableEntryBase& operator=(const wxEventTableEntryBase& event); wxEventTableEntryBase& operator=(const wxEventTableEntryBase& event);
@@ -1956,7 +1956,7 @@ public:
}; };
// an entry from a static event table // an entry from a static event table
struct WXDLLEXPORT_BASE wxEventTableEntry : public wxEventTableEntryBase struct WXDLLIMPEXP_BASE wxEventTableEntry : public wxEventTableEntryBase
{ {
wxEventTableEntry(const int& evType, int winid, int idLast, wxEventTableEntry(const int& evType, int winid, int idLast,
wxObjectEventFunction fn, wxObject *data) wxObjectEventFunction fn, wxObject *data)
@@ -1973,10 +1973,10 @@ struct WXDLLEXPORT_BASE wxEventTableEntry : public wxEventTableEntryBase
const int& m_eventType; const int& m_eventType;
}; };
class WXDLLEXPORT_BASE wxEvtHandler; class WXDLLIMPEXP_BASE wxEvtHandler;
// an entry used in dynamic event table managed by wxEvtHandler::Connect() // an entry used in dynamic event table managed by wxEvtHandler::Connect()
struct WXDLLEXPORT_BASE wxDynamicEventTableEntry : public wxEventTableEntryBase struct WXDLLIMPEXP_BASE wxDynamicEventTableEntry : public wxEventTableEntryBase
{ {
wxDynamicEventTableEntry(int evType, int winid, int idLast, wxDynamicEventTableEntry(int evType, int winid, int idLast,
wxObjectEventFunction fn, wxObject *data, wxEvtHandler* eventSink) wxObjectEventFunction fn, wxObject *data, wxEvtHandler* eventSink)
@@ -2002,7 +2002,7 @@ struct WXDLLEXPORT_BASE wxDynamicEventTableEntry : public wxEventTableEntryBase
// wxEventTable: an array of event entries terminated with {0, 0, 0, 0, 0} // wxEventTable: an array of event entries terminated with {0, 0, 0, 0, 0}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
struct WXDLLEXPORT_BASE wxEventTable struct WXDLLIMPEXP_BASE wxEventTable
{ {
const wxEventTable *baseTable; // base event table (next in chain) const wxEventTable *baseTable; // base event table (next in chain)
const wxEventTableEntry *entries; // bottom of entry array const wxEventTableEntry *entries; // bottom of entry array
@@ -2012,7 +2012,7 @@ struct WXDLLEXPORT_BASE wxEventTable
// wxEvtHandler: the base class for all objects handling wxWindows events // wxEvtHandler: the base class for all objects handling wxWindows events
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxEvtHandler : public wxObject class WXDLLIMPEXP_BASE wxEvtHandler : public wxObject
{ {
public: public:
wxEvtHandler(); wxEvtHandler();
@@ -2476,9 +2476,9 @@ typedef void (wxEvtHandler::*wxMouseCaptureChangedEventFunction)(wxMouseCaptureC
// for pending event processing - notice that there is intentionally no // for pending event processing - notice that there is intentionally no
// WXDLLEXPORT here // WXDLLEXPORT here
extern WXDLLEXPORT_BASE wxList *wxPendingEvents; extern WXDLLIMPEXP_BASE wxList *wxPendingEvents;
#if wxUSE_THREADS #if wxUSE_THREADS
extern WXDLLEXPORT_BASE wxCriticalSection *wxPendingEventsLocker; extern WXDLLIMPEXP_BASE wxCriticalSection *wxPendingEventsLocker;
#endif #endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

2
include/wx/ffile.h
View File

@@ -34,7 +34,7 @@
// dtor which is _not_ virtual, so it shouldn't be used as a base class. // dtor which is _not_ virtual, so it shouldn't be used as a base class.
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFFile class WXDLLIMPEXP_BASE wxFFile
{ {
public: public:
// ctors // ctors

4
include/wx/file.h
View File

@@ -54,7 +54,7 @@
// dtor which is _not_ virtual, so it shouldn't be used as a base class. // dtor which is _not_ virtual, so it shouldn't be used as a base class.
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFile class WXDLLIMPEXP_BASE wxFile
{ {
public: public:
// more file constants // more file constants
@@ -150,7 +150,7 @@ private:
// you call neither of them, dtor will call Discard(). // you call neither of them, dtor will call Discard().
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxTempFile class WXDLLIMPEXP_BASE wxTempFile
{ {
public: public:
// ctors // ctors

10
include/wx/fileconf.h
View File

@@ -92,12 +92,12 @@
(it's on by default, the current status can be retrieved with (it's on by default, the current status can be retrieved with
IsExpandingEnvVars function). IsExpandingEnvVars function).
*/ */
class WXDLLEXPORT_BASE wxFileConfigGroup; class WXDLLIMPEXP_BASE wxFileConfigGroup;
class WXDLLEXPORT_BASE wxFileConfigEntry; class WXDLLIMPEXP_BASE wxFileConfigEntry;
class WXDLLEXPORT_BASE wxFileConfigLineList; class WXDLLIMPEXP_BASE wxFileConfigLineList;
class WXDLLEXPORT_BASE wxInputStream; class WXDLLIMPEXP_BASE wxInputStream;
class WXDLLEXPORT_BASE wxFileConfig : public wxConfigBase class WXDLLIMPEXP_BASE wxFileConfig : public wxConfigBase
{ {
public: public:
// construct the "standard" full name for global (system-wide) and // construct the "standard" full name for global (system-wide) and

80
include/wx/filefn.h
View File

@@ -154,9 +154,9 @@ enum wxSeekMode
#if defined(__MWERKS__) && defined(macintosh) #if defined(__MWERKS__) && defined(macintosh)
#include <sys/stat.h> #include <sys/stat.h>
#endif #endif
WXDLLEXPORT_BASE int wxStat( const wxChar *file_name, wxStructStat *buf ); WXDLLIMPEXP_BASE int wxStat( const wxChar *file_name, wxStructStat *buf );
WXDLLEXPORT_BASE int wxAccess( const wxChar *pathname, int mode ); WXDLLIMPEXP_BASE int wxAccess( const wxChar *pathname, int mode );
WXDLLEXPORT_BASE int wxOpen( const wxChar *pathname, int flags, mode_t mode ); WXDLLIMPEXP_BASE int wxOpen( const wxChar *pathname, int flags, mode_t mode );
#else #else
#define wxOpen open #define wxOpen open
#define wxStat stat #define wxStat stat
@@ -168,98 +168,98 @@ WXDLLEXPORT_BASE int wxOpen( const wxChar *pathname, int flags, mode_t mode );
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// functions // functions
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
WXDLLEXPORT_BASE bool wxFileExists(const wxString& filename); WXDLLIMPEXP_BASE bool wxFileExists(const wxString& filename);
// does the path exist? (may have or not '/' or '\\' at the end) // does the path exist? (may have or not '/' or '\\' at the end)
WXDLLEXPORT_BASE bool wxPathExists(const wxChar *pszPathName); WXDLLIMPEXP_BASE bool wxPathExists(const wxChar *pszPathName);
WXDLLEXPORT_BASE bool wxIsAbsolutePath(const wxString& filename); WXDLLIMPEXP_BASE bool wxIsAbsolutePath(const wxString& filename);
// Get filename // Get filename
WXDLLEXPORT_BASE wxChar* wxFileNameFromPath(wxChar *path); WXDLLIMPEXP_BASE wxChar* wxFileNameFromPath(wxChar *path);
WXDLLEXPORT_BASE wxString wxFileNameFromPath(const wxString& path); WXDLLIMPEXP_BASE wxString wxFileNameFromPath(const wxString& path);
// Get directory // Get directory
WXDLLEXPORT_BASE wxString wxPathOnly(const wxString& path); WXDLLIMPEXP_BASE wxString wxPathOnly(const wxString& path);
// wxString version // wxString version
WXDLLEXPORT_BASE wxString wxRealPath(const wxString& path); WXDLLIMPEXP_BASE wxString wxRealPath(const wxString& path);
WXDLLEXPORT_BASE void wxDos2UnixFilename(wxChar *s); WXDLLIMPEXP_BASE void wxDos2UnixFilename(wxChar *s);
WXDLLEXPORT_BASE void wxUnix2DosFilename(wxChar *s); WXDLLIMPEXP_BASE void wxUnix2DosFilename(wxChar *s);
// Strip the extension, in situ // Strip the extension, in situ
WXDLLEXPORT_BASE void wxStripExtension(wxChar *buffer); WXDLLIMPEXP_BASE void wxStripExtension(wxChar *buffer);
WXDLLEXPORT_BASE void wxStripExtension(wxString& buffer); WXDLLIMPEXP_BASE void wxStripExtension(wxString& buffer);
// Get a temporary filename // Get a temporary filename
WXDLLEXPORT_BASE wxChar* wxGetTempFileName(const wxString& prefix, wxChar *buf = (wxChar *) NULL); WXDLLIMPEXP_BASE wxChar* wxGetTempFileName(const wxString& prefix, wxChar *buf = (wxChar *) NULL);
WXDLLEXPORT_BASE bool wxGetTempFileName(const wxString& prefix, wxString& buf); WXDLLIMPEXP_BASE bool wxGetTempFileName(const wxString& prefix, wxString& buf);
// Expand file name (~/ and ${OPENWINHOME}/ stuff) // Expand file name (~/ and ${OPENWINHOME}/ stuff)
WXDLLEXPORT_BASE wxChar* wxExpandPath(wxChar *dest, const wxChar *path); WXDLLIMPEXP_BASE wxChar* wxExpandPath(wxChar *dest, const wxChar *path);
WXDLLEXPORT_BASE bool wxExpandPath(wxString& dest, const wxChar *path); WXDLLIMPEXP_BASE bool wxExpandPath(wxString& dest, const wxChar *path);
// Contract w.r.t environment (</usr/openwin/lib, OPENWHOME> -> ${OPENWINHOME}/lib) // Contract w.r.t environment (</usr/openwin/lib, OPENWHOME> -> ${OPENWINHOME}/lib)
// and make (if under the home tree) relative to home // and make (if under the home tree) relative to home
// [caller must copy-- volatile] // [caller must copy-- volatile]
WXDLLEXPORT_BASE wxChar* wxContractPath(const wxString& filename, WXDLLIMPEXP_BASE wxChar* wxContractPath(const wxString& filename,
const wxString& envname = wxEmptyString, const wxString& envname = wxEmptyString,
const wxString& user = wxEmptyString); const wxString& user = wxEmptyString);
// Destructive removal of /./ and /../ stuff // Destructive removal of /./ and /../ stuff
WXDLLEXPORT_BASE wxChar* wxRealPath(wxChar *path); WXDLLIMPEXP_BASE wxChar* wxRealPath(wxChar *path);
// Allocate a copy of the full absolute path // Allocate a copy of the full absolute path
WXDLLEXPORT_BASE wxChar* wxCopyAbsolutePath(const wxString& path); WXDLLIMPEXP_BASE wxChar* wxCopyAbsolutePath(const wxString& path);
// Get first file name matching given wild card. // Get first file name matching given wild card.
// Flags are reserved for future use. // Flags are reserved for future use.
#define wxFILE 1 #define wxFILE 1
#define wxDIR 2 #define wxDIR 2
WXDLLEXPORT_BASE wxString wxFindFirstFile(const wxChar *spec, int flags = wxFILE); WXDLLIMPEXP_BASE wxString wxFindFirstFile(const wxChar *spec, int flags = wxFILE);
WXDLLEXPORT_BASE wxString wxFindNextFile(); WXDLLIMPEXP_BASE wxString wxFindNextFile();
// Does the pattern contain wildcards? // Does the pattern contain wildcards?
WXDLLEXPORT_BASE bool wxIsWild(const wxString& pattern); WXDLLIMPEXP_BASE bool wxIsWild(const wxString& pattern);
// Does the pattern match the text (usually a filename)? // Does the pattern match the text (usually a filename)?
// If dot_special is TRUE, doesn't match * against . (eliminating // If dot_special is TRUE, doesn't match * against . (eliminating
// `hidden' dot files) // `hidden' dot files)
WXDLLEXPORT_BASE bool wxMatchWild(const wxString& pattern, const wxString& text, bool dot_special = TRUE); WXDLLIMPEXP_BASE bool wxMatchWild(const wxString& pattern, const wxString& text, bool dot_special = TRUE);
// Concatenate two files to form third // Concatenate two files to form third
WXDLLEXPORT_BASE bool wxConcatFiles(const wxString& file1, const wxString& file2, const wxString& file3); WXDLLIMPEXP_BASE bool wxConcatFiles(const wxString& file1, const wxString& file2, const wxString& file3);
// Copy file1 to file2 // Copy file1 to file2
WXDLLEXPORT_BASE bool wxCopyFile(const wxString& file1, const wxString& file2, WXDLLIMPEXP_BASE bool wxCopyFile(const wxString& file1, const wxString& file2,
bool overwrite = TRUE); bool overwrite = TRUE);
// Remove file // Remove file
WXDLLEXPORT_BASE bool wxRemoveFile(const wxString& file); WXDLLIMPEXP_BASE bool wxRemoveFile(const wxString& file);
// Rename file // Rename file
WXDLLEXPORT_BASE bool wxRenameFile(const wxString& file1, const wxString& file2); WXDLLIMPEXP_BASE bool wxRenameFile(const wxString& file1, const wxString& file2);
// Get current working directory. // Get current working directory.
// If buf is NULL, allocates space using new, else // If buf is NULL, allocates space using new, else
// copies into buf. // copies into buf.
// IMPORTANT NOTE getcwd is know not to work under some releases // IMPORTANT NOTE getcwd is know not to work under some releases
// of Win32s 1.3, according to MS release notes! // of Win32s 1.3, according to MS release notes!
WXDLLEXPORT_BASE wxChar* wxGetWorkingDirectory(wxChar *buf = (wxChar *) NULL, int sz = 1000); WXDLLIMPEXP_BASE wxChar* wxGetWorkingDirectory(wxChar *buf = (wxChar *) NULL, int sz = 1000);
// new and preferred version of wxGetWorkingDirectory // new and preferred version of wxGetWorkingDirectory
// NB: can't have the same name because of overloading ambiguity // NB: can't have the same name because of overloading ambiguity
WXDLLEXPORT_BASE wxString wxGetCwd(); WXDLLIMPEXP_BASE wxString wxGetCwd();
// Set working directory // Set working directory
WXDLLEXPORT_BASE bool wxSetWorkingDirectory(const wxString& d); WXDLLIMPEXP_BASE bool wxSetWorkingDirectory(const wxString& d);
// Make directory // Make directory
WXDLLEXPORT_BASE bool wxMkdir(const wxString& dir, int perm = 0777); WXDLLIMPEXP_BASE bool wxMkdir(const wxString& dir, int perm = 0777);
// Remove directory. Flags reserved for future use. // Remove directory. Flags reserved for future use.
WXDLLEXPORT_BASE bool wxRmdir(const wxString& dir, int flags = 0); WXDLLIMPEXP_BASE bool wxRmdir(const wxString& dir, int flags = 0);
// compatibility defines, don't use in new code // compatibility defines, don't use in new code
#define wxDirExists wxPathExists #define wxDirExists wxPathExists
@@ -333,31 +333,31 @@ inline bool wxIsPathSeparator(wxChar c)
} }
// does the string ends with path separator? // does the string ends with path separator?
WXDLLEXPORT_BASE bool wxEndsWithPathSeparator(const wxChar *pszFileName); WXDLLIMPEXP_BASE bool wxEndsWithPathSeparator(const wxChar *pszFileName);
// split the full path into path (including drive for DOS), name and extension // split the full path into path (including drive for DOS), name and extension
// (understands both '/' and '\\') // (understands both '/' and '\\')
WXDLLEXPORT_BASE void wxSplitPath(const wxChar *pszFileName, WXDLLIMPEXP_BASE void wxSplitPath(const wxChar *pszFileName,
wxString *pstrPath, wxString *pstrPath,
wxString *pstrName, wxString *pstrName,
wxString *pstrExt); wxString *pstrExt);
// find a file in a list of directories, returns false if not found // find a file in a list of directories, returns false if not found
WXDLLEXPORT_BASE bool wxFindFileInPath(wxString *pStr, const wxChar *pszPath, const wxChar *pszFile); WXDLLIMPEXP_BASE bool wxFindFileInPath(wxString *pStr, const wxChar *pszPath, const wxChar *pszFile);
// Get the OS directory if appropriate (such as the Windows directory). // Get the OS directory if appropriate (such as the Windows directory).
// On non-Windows platform, probably just return the empty string. // On non-Windows platform, probably just return the empty string.
WXDLLEXPORT_BASE wxString wxGetOSDirectory(); WXDLLIMPEXP_BASE wxString wxGetOSDirectory();
// Get file modification time // Get file modification time
WXDLLEXPORT_BASE time_t wxFileModificationTime(const wxString& filename); WXDLLIMPEXP_BASE time_t wxFileModificationTime(const wxString& filename);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// classes // classes
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Path searching // Path searching
class WXDLLEXPORT_BASE wxPathList : public wxStringList class WXDLLIMPEXP_BASE wxPathList : public wxStringList
{ {
public: public:
// Adds all paths in environment variable // Adds all paths in environment variable

4
include/wx/filename.h
View File

@@ -38,7 +38,7 @@
#include "wx/filefn.h" #include "wx/filefn.h"
#include "wx/datetime.h" #include "wx/datetime.h"
class WXDLLEXPORT_BASE wxFile; class WXDLLIMPEXP_BASE wxFile;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// constants // constants
@@ -90,7 +90,7 @@ enum
// wxFileName: encapsulates a file path // wxFileName: encapsulates a file path
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileName class WXDLLIMPEXP_BASE wxFileName
{ {
public: public:
// constructors and assignment // constructors and assignment

8
include/wx/filesys.h
View File

@@ -42,7 +42,7 @@ class wxFileSystem;
// (in 'index.htm#chapter2', 'chapter2' is anchor) // (in 'index.htm#chapter2', 'chapter2' is anchor)
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFSFile : public wxObject class WXDLLIMPEXP_BASE wxFSFile : public wxObject
{ {
public: public:
wxFSFile(wxInputStream *stream, const wxString& loc, wxFSFile(wxInputStream *stream, const wxString& loc,
@@ -103,7 +103,7 @@ private:
// kinds of files (HTPP, FTP, local, tar.gz etc..) // kinds of files (HTPP, FTP, local, tar.gz etc..)
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileSystemHandler : public wxObject class WXDLLIMPEXP_BASE wxFileSystemHandler : public wxObject
{ {
public: public:
wxFileSystemHandler() : wxObject() {} wxFileSystemHandler() : wxObject() {}
@@ -157,7 +157,7 @@ protected:
// kinds of files (HTPP, FTP, local, tar.gz etc..) // kinds of files (HTPP, FTP, local, tar.gz etc..)
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileSystem : public wxObject class WXDLLIMPEXP_BASE wxFileSystem : public wxObject
{ {
public: public:
wxFileSystem() : wxObject() {m_Path = m_LastName = wxEmptyString; m_Handlers.DeleteContents(TRUE); m_FindFileHandler = NULL;} wxFileSystem() : wxObject() {m_Path = m_LastName = wxEmptyString; m_Handlers.DeleteContents(TRUE); m_FindFileHandler = NULL;}
@@ -241,7 +241,7 @@ special characters :
*/ */
class WXDLLEXPORT_BASE wxLocalFSHandler : public wxFileSystemHandler class WXDLLIMPEXP_BASE wxLocalFSHandler : public wxFileSystemHandler
{ {
public: public:
virtual bool CanOpen(const wxString& location); virtual bool CanOpen(const wxString& location);

12
include/wx/fontmap.h
View File

@@ -25,13 +25,13 @@
#endif // wxUSE_GUI #endif // wxUSE_GUI
#if wxUSE_CONFIG #if wxUSE_CONFIG
class WXDLLEXPORT_BASE wxConfigBase; class WXDLLIMPEXP_BASE wxConfigBase;
#endif // wxUSE_CONFIG #endif // wxUSE_CONFIG
class WXDLLEXPORT_BASE wxFontMapper; class WXDLLIMPEXP_BASE wxFontMapper;
#if wxUSE_GUI #if wxUSE_GUI
class WXDLLEXPORT_CORE wxWindow; class WXDLLIMPEXP_CORE wxWindow;
#endif // wxUSE_GUI #endif // wxUSE_GUI
// ============================================================================ // ============================================================================
@@ -47,7 +47,7 @@ class WXDLLEXPORT_BASE wxFontMapper;
// in knowledge of the encodings equivalence // in knowledge of the encodings equivalence
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFontMapperBase class WXDLLIMPEXP_BASE wxFontMapperBase
{ {
public: public:
// constructtor and such // constructtor and such
@@ -167,7 +167,7 @@ private:
#if wxUSE_GUI #if wxUSE_GUI
class WXDLLEXPORT_CORE wxFontMapper : public wxFontMapperBase class WXDLLIMPEXP_CORE wxFontMapper : public wxFontMapperBase
{ {
public: public:
// default ctor // default ctor
@@ -240,7 +240,7 @@ private:
#else // !wxUSE_GUI #else // !wxUSE_GUI
class WXDLLEXPORT_BASE wxFontMapper : public wxFontMapperBase class WXDLLIMPEXP_BASE wxFontMapper : public wxFontMapperBase
{ {
}; };

2
include/wx/fs_inet.h
View File

@@ -39,7 +39,7 @@ limitation)
// wxInternetFSHandler // wxInternetFSHandler
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxInternetFSHandler : public wxFileSystemHandler class WXDLLIMPEXP_BASE wxInternetFSHandler : public wxFileSystemHandler
{ {
private: private:
wxHashTable m_Cache; wxHashTable m_Cache;

6
include/wx/fs_mem.h
View File

@@ -24,15 +24,15 @@
#include "wx/filesys.h" #include "wx/filesys.h"
#if wxUSE_GUI #if wxUSE_GUI
class WXDLLEXPORT_CORE wxBitmap; class WXDLLIMPEXP_CORE wxBitmap;
class WXDLLEXPORT_CORE wxImage; class WXDLLIMPEXP_CORE wxImage;
#endif // wxUSE_GUI #endif // wxUSE_GUI
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
// wxMemoryFSHandler // wxMemoryFSHandler
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMemoryFSHandlerBase : public wxFileSystemHandler class WXDLLIMPEXP_BASE wxMemoryFSHandlerBase : public wxFileSystemHandler
{ {
public: public:
wxMemoryFSHandlerBase(); wxMemoryFSHandlerBase();

4
include/wx/fs_zip.h
View File

@@ -24,13 +24,13 @@
#include "wx/filesys.h" #include "wx/filesys.h"
class WXDLLEXPORT_BASE wxHashTableLong; class WXDLLIMPEXP_BASE wxHashTableLong;
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
// wxZipFSHandler // wxZipFSHandler
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxZipFSHandler : public wxFileSystemHandler class WXDLLIMPEXP_BASE wxZipFSHandler : public wxFileSystemHandler
{ {
public: public:
wxZipFSHandler(); wxZipFSHandler();

8
include/wx/hash.h
View File

@@ -34,7 +34,7 @@
// pointers to objects // pointers to objects
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxHashTableBase : public wxObject class WXDLLIMPEXP_BASE wxHashTableBase : public wxObject
{ {
public: public:
wxHashTableBase(); wxHashTableBase();
@@ -76,7 +76,7 @@ private:
// a hash table which stores longs // a hash table which stores longs
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxHashTableLong : public wxObject class WXDLLIMPEXP_BASE wxHashTableLong : public wxObject
{ {
public: public:
wxHashTableLong(size_t size = wxHASH_SIZE_DEFAULT) wxHashTableLong(size_t size = wxHASH_SIZE_DEFAULT)
@@ -114,7 +114,7 @@ private:
// wxStringHashTable: a hash table which indexes strings with longs // wxStringHashTable: a hash table which indexes strings with longs
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxStringHashTable : public wxObject class WXDLLIMPEXP_BASE wxStringHashTable : public wxObject
{ {
public: public:
wxStringHashTable(size_t sizeTable = wxHASH_SIZE_DEFAULT); wxStringHashTable(size_t sizeTable = wxHASH_SIZE_DEFAULT);
@@ -147,7 +147,7 @@ private:
// for compatibility only // for compatibility only
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxHashTable : public wxObject class WXDLLIMPEXP_BASE wxHashTable : public wxObject
{ {
public: public:
int n; int n;

16
include/wx/hashmap.h
View File

@@ -21,7 +21,7 @@
#include <stddef.h> // for ptrdiff_t #include <stddef.h> // for ptrdiff_t
// private // private
struct WXDLLEXPORT_BASE _wxHashTable_NodeBase struct WXDLLIMPEXP_BASE _wxHashTable_NodeBase
{ {
_wxHashTable_NodeBase() : m_nxt(0) {} _wxHashTable_NodeBase() : m_nxt(0) {}
@@ -33,7 +33,7 @@ struct WXDLLEXPORT_BASE _wxHashTable_NodeBase
}; };
// private // private
class WXDLLEXPORT_BASE _wxHashTableBase2 class WXDLLIMPEXP_BASE _wxHashTableBase2
{ {
public: public:
typedef void (*NodeDtor)(_wxHashTable_NodeBase*); typedef void (*NodeDtor)(_wxHashTable_NodeBase*);
@@ -407,7 +407,7 @@ inline bool grow_lf70( size_t buckets, size_t items )
// in the hash table class assignment operator (where they're assigned) // in the hash table class assignment operator (where they're assigned)
// integer types // integer types
class WXDLLEXPORT_BASE wxIntegerHash class WXDLLIMPEXP_BASE wxIntegerHash
{ {
public: public:
wxIntegerHash() { } wxIntegerHash() { }
@@ -421,7 +421,7 @@ public:
wxIntegerHash& operator=(const wxIntegerHash&) { return *this; } wxIntegerHash& operator=(const wxIntegerHash&) { return *this; }
}; };
class WXDLLEXPORT_BASE wxIntegerEqual class WXDLLIMPEXP_BASE wxIntegerEqual
{ {
public: public:
wxIntegerEqual() { } wxIntegerEqual() { }
@@ -436,7 +436,7 @@ public:
}; };
// pointers // pointers
class WXDLLEXPORT_BASE wxPointerHash class WXDLLIMPEXP_BASE wxPointerHash
{ {
public: public:
wxPointerHash() { } wxPointerHash() { }
@@ -448,7 +448,7 @@ public:
wxPointerHash& operator=(const wxPointerHash&) { return *this; } wxPointerHash& operator=(const wxPointerHash&) { return *this; }
}; };
class WXDLLEXPORT_BASE wxPointerEqual class WXDLLIMPEXP_BASE wxPointerEqual
{ {
public: public:
wxPointerEqual() { } wxPointerEqual() { }
@@ -458,7 +458,7 @@ public:
}; };
// wxString, char*, wxChar* // wxString, char*, wxChar*
class WXDLLEXPORT_BASE wxStringHash class WXDLLIMPEXP_BASE wxStringHash
{ {
public: public:
wxStringHash() {} wxStringHash() {}
@@ -476,7 +476,7 @@ public:
wxStringHash& operator=(const wxStringHash&) { return *this; } wxStringHash& operator=(const wxStringHash&) { return *this; }
}; };
class WXDLLEXPORT_BASE wxStringEqual class WXDLLIMPEXP_BASE wxStringEqual
{ {
public: public:
wxStringEqual() {} wxStringEqual() {}

6
include/wx/iconloc.h
View File

@@ -18,7 +18,7 @@
// wxIconLocation: describes the location of an icon // wxIconLocation: describes the location of an icon
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxIconLocationBase class WXDLLIMPEXP_BASE wxIconLocationBase
{ {
public: public:
// ctor takes the name of the file where the icon is // ctor takes the name of the file where the icon is
@@ -43,7 +43,7 @@ private:
// index of the icon // index of the icon
#if defined(__WXMSW__) #if defined(__WXMSW__)
class WXDLLEXPORT_BASE wxIconLocation : public wxIconLocationBase class WXDLLIMPEXP_BASE wxIconLocation : public wxIconLocationBase
{ {
public: public:
// ctor takes the name of the file where the icon is and the icons index in // ctor takes the name of the file where the icon is and the icons index in
@@ -68,7 +68,7 @@ wxIconLocation::wxIconLocation(const wxString& file, int num)
#else // !MSW #else // !MSW
// must be a class because we forward declare it as class // must be a class because we forward declare it as class
class WXDLLEXPORT_BASE wxIconLocation : public wxIconLocationBase class WXDLLIMPEXP_BASE wxIconLocation : public wxIconLocationBase
{ {
public: public:
wxEXPLICIT wxIconLocation(const wxString& filename = wxEmptyString) wxEXPLICIT wxIconLocation(const wxString& filename = wxEmptyString)

12
include/wx/intl.h
View File

@@ -45,9 +45,9 @@
// forward decls // forward decls
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxLocale; class WXDLLIMPEXP_BASE wxLocale;
class WXDLLEXPORT_BASE wxMsgCatalog; class WXDLLIMPEXP_BASE wxMsgCatalog;
class WXDLLEXPORT_BASE wxLanguageInfoArray; class WXDLLIMPEXP_BASE wxLanguageInfoArray;
// ============================================================================ // ============================================================================
// locale support // locale support
@@ -308,7 +308,7 @@ enum wxLanguage
// translation information // translation information
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
struct WXDLLEXPORT_BASE wxLanguageInfo struct WXDLLIMPEXP_BASE wxLanguageInfo
{ {
int Language; // wxLanguage id int Language; // wxLanguage id
wxString CanonicalName; // Canonical name, e.g. fr_FR wxString CanonicalName; // Canonical name, e.g. fr_FR
@@ -362,7 +362,7 @@ enum wxLocaleInitFlags
wxLOCALE_CONV_ENCODING = 0x0002 // convert encoding on the fly? wxLOCALE_CONV_ENCODING = 0x0002 // convert encoding on the fly?
}; };
class WXDLLEXPORT_BASE wxLocale class WXDLLIMPEXP_BASE wxLocale
{ {
public: public:
// ctor & dtor // ctor & dtor
@@ -522,7 +522,7 @@ private:
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// get the current locale object (note that it may be NULL!) // get the current locale object (note that it may be NULL!)
extern WXDLLEXPORT_BASE wxLocale* wxGetLocale(); extern WXDLLIMPEXP_BASE wxLocale* wxGetLocale();
// get the translation of the string in the current locale // get the translation of the string in the current locale
inline const wxChar *wxGetTranslation(const wxChar *sz) inline const wxChar *wxGetTranslation(const wxChar *sz)

10
include/wx/ipcbase.h
View File

@@ -42,10 +42,10 @@ enum wxIPCFormat
wxIPC_PRIVATE = 20 wxIPC_PRIVATE = 20
}; };
class WXDLLEXPORT_BASE wxServerBase; class WXDLLIMPEXP_BASE wxServerBase;
class WXDLLEXPORT_BASE wxClientBase; class WXDLLIMPEXP_BASE wxClientBase;
class WXDLLEXPORT_BASE wxConnectionBase: public wxObject class WXDLLIMPEXP_BASE wxConnectionBase: public wxObject
{ {
DECLARE_CLASS(wxConnectionBase) DECLARE_CLASS(wxConnectionBase)
@@ -129,7 +129,7 @@ private:
}; };
class WXDLLEXPORT_BASE wxServerBase: public wxObject class WXDLLIMPEXP_BASE wxServerBase: public wxObject
{ {
DECLARE_CLASS(wxServerBase) DECLARE_CLASS(wxServerBase)
@@ -144,7 +144,7 @@ public:
virtual wxConnectionBase *OnAcceptConnection(const wxString& topic) = 0; virtual wxConnectionBase *OnAcceptConnection(const wxString& topic) = 0;
}; };
class WXDLLEXPORT_BASE wxClientBase: public wxObject class WXDLLIMPEXP_BASE wxClientBase: public wxObject
{ {
DECLARE_CLASS(wxClientBase) DECLARE_CLASS(wxClientBase)

24
include/wx/list.h
View File

@@ -39,9 +39,9 @@
// due to circular header dependencies this function has to be declared here // due to circular header dependencies this function has to be declared here
// (normally it's found in utils.h which includes itself list.h...) // (normally it's found in utils.h which includes itself list.h...)
extern WXDLLEXPORT_BASE wxChar* copystring(const wxChar *s); extern WXDLLIMPEXP_BASE wxChar* copystring(const wxChar *s);
class WXDLLEXPORT_BASE wxObjectListNode; class WXDLLIMPEXP_BASE wxObjectListNode;
typedef wxObjectListNode wxNode; typedef wxObjectListNode wxNode;
// undef it to get rid of old, deprecated functions // undef it to get rid of old, deprecated functions
@@ -88,7 +88,7 @@ union wxListKeyValue
// for any keyed operation instead of 2 almost equivalent. OTOH, it's needed to // for any keyed operation instead of 2 almost equivalent. OTOH, it's needed to
// resolve ambiguity which we would otherwise have with wxStringList::Find() and // resolve ambiguity which we would otherwise have with wxStringList::Find() and
// wxList::Find(const char *). // wxList::Find(const char *).
class WXDLLEXPORT_BASE wxListKey class WXDLLIMPEXP_BASE wxListKey
{ {
public: public:
// implicit ctors // implicit ctors
@@ -129,11 +129,11 @@ private:
// wxNodeBase class is a (base for) node in a double linked list // wxNodeBase class is a (base for) node in a double linked list
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
WXDLLEXPORT_DATA_BASE(extern wxListKey) wxDefaultListKey; WXDLLIMPEXP_DATA_BASE(extern wxListKey) wxDefaultListKey;
class WXDLLEXPORT_BASE wxListBase; class WXDLLIMPEXP_BASE wxListBase;
class WXDLLEXPORT_BASE wxNodeBase class WXDLLIMPEXP_BASE wxNodeBase
{ {
friend class wxListBase; friend class wxListBase;
public: public:
@@ -193,9 +193,9 @@ private:
class wxList; class wxList;
class WXDLLEXPORT_BASE wxListBase : public wxObject class WXDLLIMPEXP_BASE wxListBase : public wxObject
{ {
friend class WXDLLEXPORT_BASE wxNodeBase; // should be able to call DetachNode() friend class WXDLLIMPEXP_BASE wxNodeBase; // should be able to call DetachNode()
friend class wxHashTableBase; // should be able to call untyped Find() friend class wxHashTableBase; // should be able to call untyped Find()
private: private:
// common part of all ctors // common part of all ctors
@@ -515,9 +515,9 @@ private:
// wxList compatibility class: in fact, it's a list of wxObjects // wxList compatibility class: in fact, it's a list of wxObjects
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode, class WXDLLEXPORT_BASE); WX_DECLARE_LIST_2(wxObject, wxObjectList, wxObjectListNode, class WXDLLIMPEXP_BASE);
class WXDLLEXPORT_BASE wxList : public wxObjectList class WXDLLIMPEXP_BASE wxList : public wxObjectList
{ {
public: public:
#ifdef wxWARN_COMPAT_LIST_USE #ifdef wxWARN_COMPAT_LIST_USE
@@ -545,9 +545,9 @@ private:
// wxStringList class for compatibility with the old code // wxStringList class for compatibility with the old code
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
WX_DECLARE_LIST_2(wxChar, wxStringListBase, wxStringListNode, class WXDLLEXPORT_BASE); WX_DECLARE_LIST_2(wxChar, wxStringListBase, wxStringListNode, class WXDLLIMPEXP_BASE);
class WXDLLEXPORT_BASE wxStringList : public wxStringListBase class WXDLLIMPEXP_BASE wxStringList : public wxStringListBase
{ {
public: public:
// ctors and such // ctors and such

34
include/wx/log.h
View File

@@ -25,9 +25,9 @@
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#if wxUSE_GUI #if wxUSE_GUI
class WXDLLEXPORT_CORE wxTextCtrl; class WXDLLIMPEXP_CORE wxTextCtrl;
class WXDLLEXPORT_CORE wxLogFrame; class WXDLLIMPEXP_CORE wxLogFrame;
class WXDLLEXPORT_CORE wxFrame; class WXDLLIMPEXP_CORE wxFrame;
#endif // wxUSE_GUI #endif // wxUSE_GUI
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -109,7 +109,7 @@ enum
// normally, only a single instance of this class exists but it's not enforced // normally, only a single instance of this class exists but it's not enforced
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxLog class WXDLLIMPEXP_BASE wxLog
{ {
public: public:
// ctor // ctor
@@ -261,7 +261,7 @@ private:
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// log everything to a "FILE *", stderr by default // log everything to a "FILE *", stderr by default
class WXDLLEXPORT_BASE wxLogStderr : public wxLog class WXDLLIMPEXP_BASE wxLogStderr : public wxLog
{ {
DECLARE_NO_COPY_CLASS(wxLogStderr) DECLARE_NO_COPY_CLASS(wxLogStderr)
@@ -279,7 +279,7 @@ protected:
#if wxUSE_STD_IOSTREAM #if wxUSE_STD_IOSTREAM
// log everything to an "ostream", cerr by default // log everything to an "ostream", cerr by default
class WXDLLEXPORT_BASE wxLogStream : public wxLog class WXDLLIMPEXP_BASE wxLogStream : public wxLog
{ {
public: public:
// redirect log output to an ostream // redirect log output to an ostream
@@ -315,7 +315,7 @@ protected:
// ~wxLogNull called, old log sink restored // ~wxLogNull called, old log sink restored
} }
*/ */
class WXDLLEXPORT_BASE wxLogNull class WXDLLIMPEXP_BASE wxLogNull
{ {
public: public:
wxLogNull() : m_flagOld(wxLog::EnableLogging(FALSE)) { } wxLogNull() : m_flagOld(wxLog::EnableLogging(FALSE)) { }
@@ -334,7 +334,7 @@ private:
// does it itself in its ctor // does it itself in its ctor
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxLogChain : public wxLog class WXDLLIMPEXP_BASE wxLogChain : public wxLog
{ {
public: public:
wxLogChain(wxLog *logger); wxLogChain(wxLog *logger);
@@ -374,7 +374,7 @@ private:
}; };
// a chain log target which uses itself as the new logger // a chain log target which uses itself as the new logger
class WXDLLEXPORT_BASE wxLogPassThrough : public wxLogChain class WXDLLIMPEXP_BASE wxLogPassThrough : public wxLogChain
{ {
public: public:
wxLogPassThrough(); wxLogPassThrough();
@@ -399,19 +399,19 @@ public:
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// return the last system error code // return the last system error code
WXDLLEXPORT_BASE unsigned long wxSysErrorCode(); WXDLLIMPEXP_BASE unsigned long wxSysErrorCode();
// return the error message for given (or last if 0) error code // return the error message for given (or last if 0) error code
WXDLLEXPORT_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0); WXDLLIMPEXP_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// define wxLog<level> // define wxLog<level>
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#define DECLARE_LOG_FUNCTION(level) \ #define DECLARE_LOG_FUNCTION(level) \
extern void WXDLLEXPORT_BASE wxVLog##level(const wxChar *szFormat, \ extern void WXDLLIMPEXP_BASE wxVLog##level(const wxChar *szFormat, \
va_list argptr); \ va_list argptr); \
extern void WXDLLEXPORT_BASE wxLog##level(const wxChar *szFormat, \ extern void WXDLLIMPEXP_BASE wxLog##level(const wxChar *szFormat, \
...) ATTRIBUTE_PRINTF_1 ...) ATTRIBUTE_PRINTF_1
#define DECLARE_LOG_FUNCTION2_EXP(level, arg, expdecl) \ #define DECLARE_LOG_FUNCTION2_EXP(level, arg, expdecl) \
extern void expdecl wxVLog##level(arg, const wxChar *szFormat, \ extern void expdecl wxVLog##level(arg, const wxChar *szFormat, \
@@ -419,7 +419,7 @@ extern void expdecl wxVLog##level(arg, const wxChar *szFormat, \
extern void expdecl wxLog##level(arg, const wxChar *szFormat, \ extern void expdecl wxLog##level(arg, const wxChar *szFormat, \
...) ATTRIBUTE_PRINTF_2 ...) ATTRIBUTE_PRINTF_2
#define DECLARE_LOG_FUNCTION2(level, arg) \ #define DECLARE_LOG_FUNCTION2(level, arg) \
DECLARE_LOG_FUNCTION2_EXP(level, arg, WXDLLEXPORT_BASE) DECLARE_LOG_FUNCTION2_EXP(level, arg, WXDLLIMPEXP_BASE)
#else // !wxUSE_LOG #else // !wxUSE_LOG
@@ -434,7 +434,7 @@ inline void wxVLog##level(arg, const wxChar *szFormat, \
inline void wxLog##level(arg, const wxChar *szFormat, ...) { } inline void wxLog##level(arg, const wxChar *szFormat, ...) { }
// Empty Class to fake wxLogNull // Empty Class to fake wxLogNull
class WXDLLEXPORT_BASE wxLogNull class WXDLLIMPEXP_BASE wxLogNull
{ {
public: public:
wxLogNull() { } wxLogNull() { }
@@ -467,7 +467,7 @@ DECLARE_LOG_FUNCTION(Status);
#if wxUSE_GUI #if wxUSE_GUI
// this one is the same as previous except that it allows to explicitly // this one is the same as previous except that it allows to explicitly
// specify the frame to which the output should go // specify the frame to which the output should go
DECLARE_LOG_FUNCTION2_EXP(Status, wxFrame *pFrame, WXDLLEXPORT_CORE); DECLARE_LOG_FUNCTION2_EXP(Status, wxFrame *pFrame, WXDLLIMPEXP_CORE);
#endif // wxUSE_GUI #endif // wxUSE_GUI
// additional one: as wxLogError, but also logs last system call error code // additional one: as wxLogError, but also logs last system call error code
@@ -507,7 +507,7 @@ DECLARE_LOG_FUNCTION2(SysError, long lErrCode);
// wxLogFatalError helper: show the (fatal) error to the user in a safe way, // wxLogFatalError helper: show the (fatal) error to the user in a safe way,
// i.e. without using wxMessageBox() for example because it could crash // i.e. without using wxMessageBox() for example because it could crash
void WXDLLEXPORT_BASE void WXDLLIMPEXP_BASE
wxSafeShowMessage(const wxString& title, const wxString& text); wxSafeShowMessage(const wxString& title, const wxString& text);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

16
include/wx/longlong.h
View File

@@ -111,8 +111,8 @@
#define wxUSE_LONGLONG_NATIVE 0 #define wxUSE_LONGLONG_NATIVE 0
#endif #endif
class WXDLLEXPORT_BASE wxLongLongWx; class WXDLLIMPEXP_BASE wxLongLongWx;
class WXDLLEXPORT_BASE wxULongLongWx; class WXDLLIMPEXP_BASE wxULongLongWx;
#if defined(__VISUALC__) && !defined(__WIN32__) #if defined(__VISUALC__) && !defined(__WIN32__)
#define wxLongLong wxLongLongWx #define wxLongLong wxLongLongWx
#define wxULongLong wxULongLongWx #define wxULongLong wxULongLongWx
@@ -130,8 +130,8 @@
#ifndef wxUSE_LONGLONG_WX #ifndef wxUSE_LONGLONG_WX
#define wxUSE_LONGLONG_WX 0 #define wxUSE_LONGLONG_WX 0
class WXDLLEXPORT_BASE wxLongLongNative; class WXDLLIMPEXP_BASE wxLongLongNative;
class WXDLLEXPORT_BASE wxULongLongNative; class WXDLLIMPEXP_BASE wxULongLongNative;
typedef wxLongLongNative wxLongLong; typedef wxLongLongNative wxLongLong;
typedef wxULongLongNative wxULongLong; typedef wxULongLongNative wxULongLong;
#endif #endif
@@ -148,7 +148,7 @@
#if wxUSE_LONGLONG_NATIVE #if wxUSE_LONGLONG_NATIVE
class WXDLLEXPORT_BASE wxLongLongNative class WXDLLIMPEXP_BASE wxLongLongNative
{ {
public: public:
// ctors // ctors
@@ -350,7 +350,7 @@ private:
}; };
class WXDLLEXPORT_BASE wxULongLongNative class WXDLLIMPEXP_BASE wxULongLongNative
{ {
public: public:
// ctors // ctors
@@ -536,7 +536,7 @@ private:
#if wxUSE_LONGLONG_WX #if wxUSE_LONGLONG_WX
class WXDLLEXPORT_BASE wxLongLongWx class WXDLLIMPEXP_BASE wxLongLongWx
{ {
public: public:
// ctors // ctors
@@ -733,7 +733,7 @@ private:
}; };
class WXDLLEXPORT_BASE wxULongLongWx class WXDLLIMPEXP_BASE wxULongLongWx
{ {
public: public:
// ctors // ctors

14
include/wx/memory.h
View File

@@ -30,8 +30,8 @@
#ifdef __WXDEBUG__ #ifdef __WXDEBUG__
WXDLLEXPORT_BASE void * wxDebugAlloc(size_t size, wxChar * fileName, int lineNum, bool isObject, bool isVect = FALSE); WXDLLIMPEXP_BASE void * wxDebugAlloc(size_t size, wxChar * fileName, int lineNum, bool isObject, bool isVect = FALSE);
WXDLLEXPORT_BASE void wxDebugFree(void * buf, bool isVect = FALSE); WXDLLIMPEXP_BASE void wxDebugFree(void * buf, bool isVect = FALSE);
//********************************************************************************** //**********************************************************************************
/* /*
@@ -124,9 +124,9 @@ typedef unsigned int wxMarkerType;
allocated memory. allocated memory.
*/ */
class WXDLLEXPORT_BASE wxMemStruct { class WXDLLIMPEXP_BASE wxMemStruct {
friend class WXDLLEXPORT_BASE wxDebugContext; // access to the m_next pointer for list traversal. friend class WXDLLIMPEXP_BASE wxDebugContext; // access to the m_next pointer for list traversal.
public: public:
public: public:
@@ -202,7 +202,7 @@ typedef void (wxMemStruct::*PmSFV) ();
globals which have to do with the wxMemStruct class. globals which have to do with the wxMemStruct class.
*/ */
class WXDLLEXPORT_BASE wxDebugContext { class WXDLLIMPEXP_BASE wxDebugContext {
protected: protected:
// Used to set alignment for markers. // Used to set alignment for markers.
@@ -300,8 +300,8 @@ private:
}; };
// Output a debug message, in a system dependent fashion. // Output a debug message, in a system dependent fashion.
void WXDLLEXPORT_BASE wxTrace(const wxChar *fmt ...) ATTRIBUTE_PRINTF_1; void WXDLLIMPEXP_BASE wxTrace(const wxChar *fmt ...) ATTRIBUTE_PRINTF_1;
void WXDLLEXPORT_BASE wxTraceLevel(int level, const wxChar *fmt ...) ATTRIBUTE_PRINTF_2; void WXDLLIMPEXP_BASE wxTraceLevel(int level, const wxChar *fmt ...) ATTRIBUTE_PRINTF_2;
#define WXTRACE wxTrace #define WXTRACE wxTrace
#define WXTRACELEVEL wxTraceLevel #define WXTRACELEVEL wxTraceLevel

2
include/wx/memtext.h
View File

@@ -19,7 +19,7 @@
// wxMemoryText // wxMemoryText
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMemoryText : public wxTextBuffer class WXDLLIMPEXP_BASE wxMemoryText : public wxTextBuffer
{ {
public: public:
// Constructors. // Constructors.

18
include/wx/mimetype.h
View File

@@ -30,9 +30,9 @@
#include "wx/dynarray.h" #include "wx/dynarray.h"
// fwd decls // fwd decls
class WXDLLEXPORT_BASE wxIconLocation; class WXDLLIMPEXP_BASE wxIconLocation;
class WXDLLEXPORT_BASE wxFileTypeImpl; class WXDLLIMPEXP_BASE wxFileTypeImpl;
class WXDLLEXPORT_BASE wxMimeTypesManagerImpl; class WXDLLIMPEXP_BASE wxMimeTypesManagerImpl;
// these constants define the MIME informations source under UNIX and are used // these constants define the MIME informations source under UNIX and are used
// by wxMimeTypesManager::Initialize() // by wxMimeTypesManager::Initialize()
@@ -49,7 +49,7 @@ enum wxMailcapStyle
/* /*
TODO: would it be more convenient to have this class? TODO: would it be more convenient to have this class?
class WXDLLEXPORT_BASE wxMimeType : public wxString class WXDLLIMPEXP_BASE wxMimeType : public wxString
{ {
public: public:
// all string ctors here // all string ctors here
@@ -76,7 +76,7 @@ public:
// This class is used with wxMimeTypesManager::AddFallbacks() and Associate() // This class is used with wxMimeTypesManager::AddFallbacks() and Associate()
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileTypeInfo class WXDLLIMPEXP_BASE wxFileTypeInfo
{ {
public: public:
// ctors // ctors
@@ -162,9 +162,9 @@ WX_DECLARE_EXPORTED_OBJARRAY(wxFileTypeInfo, wxArrayFileTypeInfo);
// the accessors *must* be checked! // the accessors *must* be checked!
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileType class WXDLLIMPEXP_BASE wxFileType
{ {
friend class WXDLLEXPORT_BASE wxMimeTypesManagerImpl; // it has access to m_impl friend class WXDLLIMPEXP_BASE wxMimeTypesManagerImpl; // it has access to m_impl
public: public:
// An object of this class must be passed to Get{Open|Print}Command. The // An object of this class must be passed to Get{Open|Print}Command. The
@@ -278,7 +278,7 @@ private:
// given type) about them. // given type) about them.
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMimeTypesManager class WXDLLIMPEXP_BASE wxMimeTypesManager
{ {
public: public:
// static helper functions // static helper functions
@@ -385,7 +385,7 @@ private:
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// the default mime manager for wxWindows programs // the default mime manager for wxWindows programs
WXDLLEXPORT_DATA_BASE(extern wxMimeTypesManager *) wxTheMimeTypesManager; WXDLLIMPEXP_DATA_BASE(extern wxMimeTypesManager *) wxTheMimeTypesManager;
#endif // wxUSE_MIMETYPE #endif // wxUSE_MIMETYPE

2
include/wx/module.h
View File

@@ -26,7 +26,7 @@ WX_DECLARE_EXPORTED_LIST(wxModule, wxModuleList);
// declaring a class derived from wxModule will automatically create an // declaring a class derived from wxModule will automatically create an
// instance of this class on program startup, call its OnInit() method and call // instance of this class on program startup, call its OnInit() method and call
// OnExit() on program termination (but only if OnInit() succeeded) // OnExit() on program termination (but only if OnInit() succeeded)
class WXDLLEXPORT_BASE wxModule : public wxObject class WXDLLIMPEXP_BASE wxModule : public wxObject
{ {
public: public:
wxModule() {} wxModule() {}

10
include/wx/msgout.h
View File

@@ -28,7 +28,7 @@
// something you can printf() to // something you can printf() to
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMessageOutput class WXDLLIMPEXP_BASE wxMessageOutput
{ {
public: public:
virtual ~wxMessageOutput() { } virtual ~wxMessageOutput() { }
@@ -50,7 +50,7 @@ private:
// implementation which sends output to stderr // implementation which sends output to stderr
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMessageOutputStderr : public wxMessageOutput class WXDLLIMPEXP_BASE wxMessageOutputStderr : public wxMessageOutput
{ {
public: public:
wxMessageOutputStderr() { } wxMessageOutputStderr() { }
@@ -64,7 +64,7 @@ public:
#if wxUSE_GUI #if wxUSE_GUI
class WXDLLEXPORT_CORE wxMessageOutputMessageBox : public wxMessageOutput class WXDLLIMPEXP_CORE wxMessageOutputMessageBox : public wxMessageOutput
{ {
public: public:
wxMessageOutputMessageBox() { } wxMessageOutputMessageBox() { }
@@ -78,7 +78,7 @@ public:
// implementation using the native way of outputting debug messages // implementation using the native way of outputting debug messages
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMessageOutputDebug : public wxMessageOutput class WXDLLIMPEXP_BASE wxMessageOutputDebug : public wxMessageOutput
{ {
public: public:
wxMessageOutputDebug() { } wxMessageOutputDebug() { }
@@ -90,7 +90,7 @@ public:
// implementation using wxLog (mainly for backwards compatibility) // implementation using wxLog (mainly for backwards compatibility)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMessageOutputLog : public wxMessageOutput class WXDLLIMPEXP_BASE wxMessageOutputLog : public wxMessageOutput
{ {
public: public:
wxMessageOutputLog() { } wxMessageOutputLog() { }

4
include/wx/mstream.h
View File

@@ -16,7 +16,7 @@
#if wxUSE_STREAMS #if wxUSE_STREAMS
class WXDLLEXPORT_BASE wxMemoryInputStream : public wxInputStream class WXDLLIMPEXP_BASE wxMemoryInputStream : public wxInputStream
{ {
public: public:
wxMemoryInputStream(const void *data, size_t length); wxMemoryInputStream(const void *data, size_t length);
@@ -44,7 +44,7 @@ private:
DECLARE_NO_COPY_CLASS(wxMemoryInputStream) DECLARE_NO_COPY_CLASS(wxMemoryInputStream)
}; };
class WXDLLEXPORT_BASE wxMemoryOutputStream : public wxOutputStream class WXDLLIMPEXP_BASE wxMemoryOutputStream : public wxOutputStream
{ {
public: public:
// if data is !NULL it must be allocated with malloc() // if data is !NULL it must be allocated with malloc()

14
include/wx/msw/dde.h
View File

@@ -42,10 +42,10 @@
* *
*/ */
class WXDLLEXPORT_BASE wxDDEServer; class WXDLLIMPEXP_BASE wxDDEServer;
class WXDLLEXPORT_BASE wxDDEClient; class WXDLLIMPEXP_BASE wxDDEClient;
class WXDLLEXPORT_BASE wxDDEConnection: public wxConnectionBase class WXDLLIMPEXP_BASE wxDDEConnection: public wxConnectionBase
{ {
DECLARE_DYNAMIC_CLASS(wxDDEConnection) DECLARE_DYNAMIC_CLASS(wxDDEConnection)
public: public:
@@ -82,7 +82,7 @@ public:
DECLARE_NO_COPY_CLASS(wxDDEConnection) DECLARE_NO_COPY_CLASS(wxDDEConnection)
}; };
class WXDLLEXPORT_BASE wxDDEServer: public wxServerBase class WXDLLIMPEXP_BASE wxDDEServer: public wxServerBase
{ {
DECLARE_DYNAMIC_CLASS(wxDDEServer) DECLARE_DYNAMIC_CLASS(wxDDEServer)
public: public:
@@ -111,7 +111,7 @@ protected:
wxDDEConnectionList m_connections; wxDDEConnectionList m_connections;
}; };
class WXDLLEXPORT_BASE wxDDEClient: public wxClientBase class WXDLLIMPEXP_BASE wxDDEClient: public wxClientBase
{ {
DECLARE_DYNAMIC_CLASS(wxDDEClient) DECLARE_DYNAMIC_CLASS(wxDDEClient)
public: public:
@@ -140,8 +140,8 @@ protected:
wxDDEConnectionList m_connections; wxDDEConnectionList m_connections;
}; };
void WXDLLEXPORT_BASE wxDDEInitialize(); void WXDLLIMPEXP_BASE wxDDEInitialize();
void WXDLLEXPORT_BASE wxDDECleanUp(); void WXDLLIMPEXP_BASE wxDDECleanUp();
#endif #endif
// _WX_DDE_H_ // _WX_DDE_H_

4
include/wx/msw/mimetype.h
View File

@@ -27,7 +27,7 @@
// and is never used directly by the application // and is never used directly by the application
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileTypeImpl class WXDLLIMPEXP_BASE wxFileTypeImpl
{ {
public: public:
// ctor // ctor
@@ -92,7 +92,7 @@ private:
bool RemoveDescription(); bool RemoveDescription();
}; };
class WXDLLEXPORT_BASE wxMimeTypesManagerImpl class WXDLLIMPEXP_BASE wxMimeTypesManagerImpl
{ {
public: public:
// nothing to do here, we don't load any data but just go and fetch it from // nothing to do here, we don't load any data but just go and fetch it from

4
include/wx/msw/private.h
View File

@@ -486,9 +486,9 @@ private:
// global data // global data
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
WXDLLEXPORT_DATA_BASE(extern wxChar*) wxBuffer; WXDLLIMPEXP_DATA_BASE(extern wxChar*) wxBuffer;
WXDLLEXPORT_DATA_BASE(extern HINSTANCE) wxhInstance; WXDLLIMPEXP_DATA_BASE(extern HINSTANCE) wxhInstance;
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// global functions // global functions

18
include/wx/object.h
View File

@@ -24,7 +24,7 @@
#include "wx/defs.h" #include "wx/defs.h"
#include "wx/memory.h" #include "wx/memory.h"
class WXDLLEXPORT_BASE wxObject; class WXDLLIMPEXP_BASE wxObject;
#if wxUSE_DYNAMIC_CLASSES #if wxUSE_DYNAMIC_CLASSES
@@ -41,9 +41,9 @@ class WXDLLEXPORT_BASE wxObject;
#undef GetClassInfo #undef GetClassInfo
#endif #endif
class WXDLLEXPORT_BASE wxClassInfo; class WXDLLIMPEXP_BASE wxClassInfo;
class WXDLLEXPORT_BASE wxHashTable; class WXDLLIMPEXP_BASE wxHashTable;
class WXDLLEXPORT_BASE wxObjectRefData; class WXDLLIMPEXP_BASE wxObjectRefData;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxClassInfo // wxClassInfo
@@ -51,7 +51,7 @@ class WXDLLEXPORT_BASE wxObjectRefData;
typedef wxObject *(*wxObjectConstructorFn)(void); typedef wxObject *(*wxObjectConstructorFn)(void);
class WXDLLEXPORT_BASE wxClassInfo class WXDLLIMPEXP_BASE wxClassInfo
{ {
public: public:
wxClassInfo( const wxChar *className, wxClassInfo( const wxChar *className,
@@ -133,7 +133,7 @@ private:
DECLARE_NO_COPY_CLASS(wxClassInfo) DECLARE_NO_COPY_CLASS(wxClassInfo)
}; };
WXDLLEXPORT_BASE wxObject *wxCreateDynamicObject(const wxChar *name); WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Dynamic class macros // Dynamic class macros
@@ -392,7 +392,7 @@ inline void wxCheckCast(void *ptr)
// wxObject: the root class of wxWindows object hierarchy // wxObject: the root class of wxWindows object hierarchy
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxObject class WXDLLIMPEXP_BASE wxObject
{ {
DECLARE_ABSTRACT_CLASS(wxObject) DECLARE_ABSTRACT_CLASS(wxObject)
@@ -490,9 +490,9 @@ protected:
// wxObjectRefData: ref counted data meant to be stored in wxObject // wxObjectRefData: ref counted data meant to be stored in wxObject
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxObjectRefData class WXDLLIMPEXP_BASE wxObjectRefData
{ {
friend class WXDLLEXPORT_BASE wxObject; friend class WXDLLIMPEXP_BASE wxObject;
public: public:
wxObjectRefData() : m_count(1) { } wxObjectRefData() : m_count(1) { }

4
include/wx/process.h
View File

@@ -39,7 +39,7 @@ enum
// function will be called when the process terminates. // function will be called when the process terminates.
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxProcess : public wxEvtHandler class WXDLLIMPEXP_BASE wxProcess : public wxEvtHandler
{ {
public: public:
// kill the process with the given PID // kill the process with the given PID
@@ -139,7 +139,7 @@ BEGIN_DECLARE_EVENT_TYPES()
DECLARE_EVENT_TYPE(wxEVT_END_PROCESS, 440) DECLARE_EVENT_TYPE(wxEVT_END_PROCESS, 440)
END_DECLARE_EVENT_TYPES() END_DECLARE_EVENT_TYPES()
class WXDLLEXPORT_BASE wxProcessEvent : public wxEvent class WXDLLIMPEXP_BASE wxProcessEvent : public wxEvent
{ {
public: public:
wxProcessEvent(int id = 0, int pid = 0, int exitcode = 0) : wxEvent(id) wxProcessEvent(int id = 0, int pid = 0, int exitcode = 0) : wxEvent(id)

2
include/wx/protocol/ftp.h
View File

@@ -25,7 +25,7 @@
#include "wx/protocol/protocol.h" #include "wx/protocol/protocol.h"
#include "wx/url.h" #include "wx/url.h"
class WXDLLEXPORT_BASE wxFTP : public wxProtocol class WXDLLIMPEXP_BASE wxFTP : public wxProtocol
{ {
public: public:
enum TransferMode enum TransferMode

2
include/wx/protocol/http.h
View File

@@ -18,7 +18,7 @@
#include "wx/list.h" #include "wx/list.h"
#include "wx/protocol/protocol.h" #include "wx/protocol/protocol.h"
class WXDLLEXPORT_BASE wxHTTP : public wxProtocol { class WXDLLIMPEXP_BASE wxHTTP : public wxProtocol {
DECLARE_DYNAMIC_CLASS(wxHTTP) DECLARE_DYNAMIC_CLASS(wxHTTP)
DECLARE_PROTOCOL(wxHTTP) DECLARE_PROTOCOL(wxHTTP)
protected: protected:

6
include/wx/protocol/protocol.h
View File

@@ -50,7 +50,7 @@ typedef enum
// wxProtocol: abstract base class for all protocols // wxProtocol: abstract base class for all protocols
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxProtocol class WXDLLIMPEXP_BASE wxProtocol
#if wxUSE_SOCKETS #if wxUSE_SOCKETS
: public wxSocketClient : public wxSocketClient
#else #else
@@ -86,7 +86,7 @@ private:
}; };
#if wxUSE_SOCKETS #if wxUSE_SOCKETS
wxProtocolError WXDLLEXPORT_BASE GetLine(wxSocketBase *sock, wxString& result); wxProtocolError WXDLLIMPEXP_BASE GetLine(wxSocketBase *sock, wxString& result);
#endif #endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -108,7 +108,7 @@ bool wxProtocolUse##class = TRUE;
wxProtocolUserFor##class() { wxProtocolUse##class = TRUE; } \ wxProtocolUserFor##class() { wxProtocolUse##class = TRUE; } \
} wxProtocolDoUse##class; } wxProtocolDoUse##class;
class WXDLLEXPORT_BASE wxProtoInfo : public wxObject class WXDLLIMPEXP_BASE wxProtoInfo : public wxObject
{ {
public: public:
wxProtoInfo(const wxChar *name, wxProtoInfo(const wxChar *name,

6
include/wx/regex.h
View File

@@ -20,7 +20,7 @@
#if wxUSE_REGEX #if wxUSE_REGEX
class WXDLLEXPORT_BASE wxString; class WXDLLIMPEXP_BASE wxString;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// constants // constants
@@ -67,9 +67,9 @@ enum
// wxRegEx: a regular expression // wxRegEx: a regular expression
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxRegExImpl; class WXDLLIMPEXP_BASE wxRegExImpl;
class WXDLLEXPORT_BASE wxRegEx class WXDLLIMPEXP_BASE wxRegEx
{ {
public: public:
// default ctor: use Compile() later // default ctor: use Compile() later

8
include/wx/sckaddr.h
View File

@@ -24,7 +24,7 @@
#include "wx/gsocket.h" #include "wx/gsocket.h"
class WXDLLEXPORT_BASE wxSockAddress : public wxObject { class WXDLLIMPEXP_BASE wxSockAddress : public wxObject {
DECLARE_ABSTRACT_CLASS(wxSockAddress) DECLARE_ABSTRACT_CLASS(wxSockAddress)
public: public:
typedef enum { IPV4=1, IPV6=2, UNIX=3 } Addr; typedef enum { IPV4=1, IPV6=2, UNIX=3 } Addr;
@@ -52,7 +52,7 @@ private:
void Init(); void Init();
}; };
class WXDLLEXPORT_BASE wxIPV4address : public wxSockAddress { class WXDLLIMPEXP_BASE wxIPV4address : public wxSockAddress {
DECLARE_DYNAMIC_CLASS(wxIPV4address) DECLARE_DYNAMIC_CLASS(wxIPV4address)
public: public:
wxIPV4address(); wxIPV4address();
@@ -78,7 +78,7 @@ private:
}; };
#ifdef ENABLE_IPV6 #ifdef ENABLE_IPV6
class WXDLLEXPORT_BASE wxIPV6address : public wxSockAddress { class WXDLLIMPEXP_BASE wxIPV6address : public wxSockAddress {
DECLARE_DYNAMIC_CLASS(wxIPV6address) DECLARE_DYNAMIC_CLASS(wxIPV6address)
private: private:
struct sockaddr_in6 *m_addr; struct sockaddr_in6 *m_addr;
@@ -107,7 +107,7 @@ public:
# include <sys/un.h> # include <sys/un.h>
#endif #endif
class WXDLLEXPORT_BASE wxUNIXaddress : public wxSockAddress { class WXDLLIMPEXP_BASE wxUNIXaddress : public wxSockAddress {
DECLARE_DYNAMIC_CLASS(wxUNIXaddress) DECLARE_DYNAMIC_CLASS(wxUNIXaddress)
private: private:
struct sockaddr_un *m_addr; struct sockaddr_un *m_addr;

6
include/wx/sckipc.h
View File

@@ -53,10 +53,10 @@
* *
*/ */
class WXDLLEXPORT_BASE wxTCPServer; class WXDLLIMPEXP_BASE wxTCPServer;
class WXDLLEXPORT_BASE wxTCPClient; class WXDLLIMPEXP_BASE wxTCPClient;
class WXDLLEXPORT_BASE wxTCPConnection: public wxConnectionBase class WXDLLIMPEXP_BASE wxTCPConnection: public wxConnectionBase
{ {
DECLARE_DYNAMIC_CLASS(wxTCPConnection) DECLARE_DYNAMIC_CLASS(wxTCPConnection)

6
include/wx/sckstrm.h
View File

@@ -21,7 +21,7 @@
#include "wx/socket.h" #include "wx/socket.h"
class WXDLLEXPORT_BASE wxSocketOutputStream : public wxOutputStream class WXDLLIMPEXP_BASE wxSocketOutputStream : public wxOutputStream
{ {
public: public:
wxSocketOutputStream(wxSocketBase& s); wxSocketOutputStream(wxSocketBase& s);
@@ -40,7 +40,7 @@ class WXDLLEXPORT_BASE wxSocketOutputStream : public wxOutputStream
DECLARE_NO_COPY_CLASS(wxSocketOutputStream) DECLARE_NO_COPY_CLASS(wxSocketOutputStream)
}; };
class WXDLLEXPORT_BASE wxSocketInputStream : public wxInputStream class WXDLLIMPEXP_BASE wxSocketInputStream : public wxInputStream
{ {
public: public:
wxSocketInputStream(wxSocketBase& s); wxSocketInputStream(wxSocketBase& s);
@@ -59,7 +59,7 @@ class WXDLLEXPORT_BASE wxSocketInputStream : public wxInputStream
DECLARE_NO_COPY_CLASS(wxSocketInputStream) DECLARE_NO_COPY_CLASS(wxSocketInputStream)
}; };
class WXDLLEXPORT_BASE wxSocketStream : public wxSocketInputStream, class WXDLLIMPEXP_BASE wxSocketStream : public wxSocketInputStream,
public wxSocketOutputStream public wxSocketOutputStream
{ {
public: public:

4
include/wx/snglinst.h
View File

@@ -23,7 +23,7 @@
// wxSingleInstanceChecker // wxSingleInstanceChecker
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxSingleInstanceChecker class WXDLLIMPEXP_BASE wxSingleInstanceChecker
{ {
public: public:
// default ctor, use Create() after it // default ctor, use Create() after it
@@ -59,7 +59,7 @@ private:
void Init() { m_impl = NULL; } void Init() { m_impl = NULL; }
// the implementation details (platform specific) // the implementation details (platform specific)
class WXDLLEXPORT_BASE wxSingleInstanceCheckerImpl *m_impl; class WXDLLIMPEXP_BASE wxSingleInstanceCheckerImpl *m_impl;
DECLARE_NO_COPY_CLASS(wxSingleInstanceChecker) DECLARE_NO_COPY_CLASS(wxSingleInstanceChecker)
}; };

10
include/wx/socket.h
View File

@@ -105,7 +105,7 @@ typedef int wxSocketFlags;
// wxSocketBase // wxSocketBase
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxSocketBase : public wxObject class WXDLLIMPEXP_BASE wxSocketBase : public wxObject
{ {
DECLARE_CLASS(wxSocketBase) DECLARE_CLASS(wxSocketBase)
@@ -270,7 +270,7 @@ private:
// wxSocketServer // wxSocketServer
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxSocketServer : public wxSocketBase class WXDLLIMPEXP_BASE wxSocketServer : public wxSocketBase
{ {
DECLARE_CLASS(wxSocketServer) DECLARE_CLASS(wxSocketServer)
@@ -290,7 +290,7 @@ public:
// wxSocketClient // wxSocketClient
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxSocketClient : public wxSocketBase class WXDLLIMPEXP_BASE wxSocketClient : public wxSocketBase
{ {
DECLARE_CLASS(wxSocketClient) DECLARE_CLASS(wxSocketClient)
@@ -312,7 +312,7 @@ public:
// WARNING: still in alpha stage // WARNING: still in alpha stage
class WXDLLEXPORT_BASE wxDatagramSocket : public wxSocketBase class WXDLLIMPEXP_BASE wxDatagramSocket : public wxSocketBase
{ {
DECLARE_CLASS(wxDatagramSocket) DECLARE_CLASS(wxDatagramSocket)
@@ -337,7 +337,7 @@ public:
// wxSocketEvent // wxSocketEvent
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxSocketEvent : public wxEvent class WXDLLIMPEXP_BASE wxSocketEvent : public wxEvent
{ {
public: public:
wxSocketEvent(int id = 0) wxSocketEvent(int id = 0)

12
include/wx/stopwatch.h
View File

@@ -17,7 +17,7 @@
#if wxUSE_STOPWATCH #if wxUSE_STOPWATCH
class WXDLLEXPORT_BASE wxStopWatch class WXDLLIMPEXP_BASE wxStopWatch
{ {
public: public:
// ctor starts the stop watch // ctor starts the stop watch
@@ -67,11 +67,11 @@ private:
// Starts a global timer // Starts a global timer
// -- DEPRECATED: use wxStopWatch instead // -- DEPRECATED: use wxStopWatch instead
void WXDLLEXPORT_BASE wxStartTimer(); void WXDLLIMPEXP_BASE wxStartTimer();
// Gets elapsed milliseconds since last wxStartTimer or wxGetElapsedTime // Gets elapsed milliseconds since last wxStartTimer or wxGetElapsedTime
// -- DEPRECATED: use wxStopWatch instead // -- DEPRECATED: use wxStopWatch instead
long WXDLLEXPORT_BASE wxGetElapsedTime(bool resetTimer = TRUE); long WXDLLIMPEXP_BASE wxGetElapsedTime(bool resetTimer = TRUE);
#endif // wxUSE_LONGLONG #endif // wxUSE_LONGLONG
@@ -80,14 +80,14 @@ long WXDLLEXPORT_BASE wxGetElapsedTime(bool resetTimer = TRUE);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Get number of seconds since local time 00:00:00 Jan 1st 1970. // Get number of seconds since local time 00:00:00 Jan 1st 1970.
extern long WXDLLEXPORT_BASE wxGetLocalTime(); extern long WXDLLIMPEXP_BASE wxGetLocalTime();
// Get number of seconds since GMT 00:00:00, Jan 1st 1970. // Get number of seconds since GMT 00:00:00, Jan 1st 1970.
extern long WXDLLEXPORT_BASE wxGetUTCTime(); extern long WXDLLIMPEXP_BASE wxGetUTCTime();
#if wxUSE_LONGLONG #if wxUSE_LONGLONG
// Get number of milliseconds since local time 00:00:00 Jan 1st 1970 // Get number of milliseconds since local time 00:00:00 Jan 1st 1970
extern wxLongLong WXDLLEXPORT_BASE wxGetLocalTimeMillis(); extern wxLongLong WXDLLIMPEXP_BASE wxGetLocalTimeMillis();
#endif // wxUSE_LONGLONG #endif // wxUSE_LONGLONG
#define wxGetCurrentTime() wxGetLocalTime() #define wxGetCurrentTime() wxGetLocalTime()

32
include/wx/strconv.h
View File

@@ -36,7 +36,7 @@
// wxMBConv (base class for conversions, using libc conversion itself) // wxMBConv (base class for conversions, using libc conversion itself)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMBConv class WXDLLIMPEXP_BASE wxMBConv
{ {
public: public:
// the actual conversion takes place here // the actual conversion takes place here
@@ -63,33 +63,33 @@ public:
virtual ~wxMBConv(); virtual ~wxMBConv();
}; };
WXDLLEXPORT_DATA_BASE(extern wxMBConv) wxConvLibc; WXDLLIMPEXP_DATA_BASE(extern wxMBConv) wxConvLibc;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxMBConvUTF7 (for conversion using UTF7 encoding) // wxMBConvUTF7 (for conversion using UTF7 encoding)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMBConvUTF7 : public wxMBConv class WXDLLIMPEXP_BASE wxMBConvUTF7 : public wxMBConv
{ {
public: public:
virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const; virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const; virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
}; };
WXDLLEXPORT_DATA_BASE(extern wxMBConvUTF7) wxConvUTF7; WXDLLIMPEXP_DATA_BASE(extern wxMBConvUTF7) wxConvUTF7;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxMBConvUTF8 (for conversion using UTF8 encoding) // wxMBConvUTF8 (for conversion using UTF8 encoding)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMBConvUTF8 : public wxMBConv class WXDLLIMPEXP_BASE wxMBConvUTF8 : public wxMBConv
{ {
public: public:
virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const; virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const; virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
}; };
WXDLLEXPORT_DATA_BASE(extern wxMBConvUTF8) wxConvUTF8; WXDLLIMPEXP_DATA_BASE(extern wxMBConvUTF8) wxConvUTF8;
#ifdef __WXGTK12__ #ifdef __WXGTK12__
@@ -97,14 +97,14 @@ WXDLLEXPORT_DATA_BASE(extern wxMBConvUTF8) wxConvUTF8;
// wxMBConvUTF8 (for conversion using GDK's internal converions) // wxMBConvUTF8 (for conversion using GDK's internal converions)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMBConvGdk : public wxMBConv class WXDLLIMPEXP_BASE wxMBConvGdk : public wxMBConv
{ {
public: public:
virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const; virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const; virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
}; };
WXDLLEXPORT_DATA_BASE(extern wxMBConvGdk) wxConvGdk; WXDLLIMPEXP_DATA_BASE(extern wxMBConvGdk) wxConvGdk;
#endif // wxGTK 1.2 #endif // wxGTK 1.2
@@ -112,9 +112,9 @@ WXDLLEXPORT_DATA_BASE(extern wxMBConvGdk) wxConvGdk;
// wxCSConv (for conversion based on loadable char sets) // wxCSConv (for conversion based on loadable char sets)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxCharacterSet; class WXDLLIMPEXP_BASE wxCharacterSet;
class WXDLLEXPORT_BASE wxCSConv : public wxMBConv class WXDLLIMPEXP_BASE wxCSConv : public wxMBConv
{ {
public: public:
wxCSConv(const wxChar *charset); wxCSConv(const wxChar *charset);
@@ -141,9 +141,9 @@ private:
}; };
#define wxConvFile wxConvLocal #define wxConvFile wxConvLocal
WXDLLEXPORT_DATA_BASE(extern wxCSConv) wxConvLocal; WXDLLIMPEXP_DATA_BASE(extern wxCSConv) wxConvLocal;
WXDLLEXPORT_DATA_BASE(extern wxCSConv) wxConvISO8859_1; WXDLLIMPEXP_DATA_BASE(extern wxCSConv) wxConvISO8859_1;
WXDLLEXPORT_DATA_BASE(extern wxMBConv *) wxConvCurrent; WXDLLIMPEXP_DATA_BASE(extern wxMBConv *) wxConvCurrent;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// filename conversion macros // filename conversion macros
@@ -171,15 +171,15 @@ WXDLLEXPORT_DATA_BASE(extern wxMBConv *) wxConvCurrent;
// stand-ins in absence of wchar_t // stand-ins in absence of wchar_t
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMBConv class WXDLLIMPEXP_BASE wxMBConv
{ {
public: public:
const char* cMB2WX(const char *psz) const { return psz; } const char* cMB2WX(const char *psz) const { return psz; }
const char* cWX2MB(const char *psz) const { return psz; } const char* cWX2MB(const char *psz) const { return psz; }
}; };
WXDLLEXPORT_DATA_BASE(extern wxMBConv) wxConvLibc, wxConvFile, wxConvLocal, wxConvISO8859_1, wxConvUTF8; WXDLLIMPEXP_DATA_BASE(extern wxMBConv) wxConvLibc, wxConvFile, wxConvLocal, wxConvISO8859_1, wxConvUTF8;
WXDLLEXPORT_DATA_BASE(extern wxMBConv *) wxConvCurrent; WXDLLIMPEXP_DATA_BASE(extern wxMBConv *) wxConvCurrent;
#define wxFNCONV(name) name #define wxFNCONV(name) name
#define wxFNSTRINGCAST WXSTRINGCAST #define wxFNSTRINGCAST WXSTRINGCAST

26
include/wx/stream.h
View File

@@ -25,14 +25,14 @@
#include "wx/string.h" #include "wx/string.h"
#include "wx/filefn.h" // for off_t, wxInvalidOffset and wxSeekMode #include "wx/filefn.h" // for off_t, wxInvalidOffset and wxSeekMode
class WXDLLEXPORT_BASE wxStreamBase; class WXDLLIMPEXP_BASE wxStreamBase;
class WXDLLEXPORT_BASE wxInputStream; class WXDLLIMPEXP_BASE wxInputStream;
class WXDLLEXPORT_BASE wxOutputStream; class WXDLLIMPEXP_BASE wxOutputStream;
typedef wxInputStream& (*__wxInputManip)(wxInputStream&); typedef wxInputStream& (*__wxInputManip)(wxInputStream&);
typedef wxOutputStream& (*__wxOutputManip)(wxOutputStream&); typedef wxOutputStream& (*__wxOutputManip)(wxOutputStream&);
WXDLLEXPORT_BASE wxOutputStream& wxEndL(wxOutputStream& o_stream); WXDLLIMPEXP_BASE wxOutputStream& wxEndL(wxOutputStream& o_stream);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// constants // constants
@@ -67,7 +67,7 @@ enum wxStreamError
// wxStreamBase: common (but non virtual!) base for all stream classes // wxStreamBase: common (but non virtual!) base for all stream classes
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxStreamBase class WXDLLIMPEXP_BASE wxStreamBase
{ {
public: public:
wxStreamBase(); wxStreamBase();
@@ -106,7 +106,7 @@ protected:
// wxInputStream: base class for the input streams // wxInputStream: base class for the input streams
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxInputStream : public wxStreamBase class WXDLLIMPEXP_BASE wxInputStream : public wxStreamBase
{ {
public: public:
// ctor and dtor, nothing exciting // ctor and dtor, nothing exciting
@@ -238,7 +238,7 @@ protected:
// wxOutputStream: base for the output streams // wxOutputStream: base for the output streams
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxOutputStream : public wxStreamBase class WXDLLIMPEXP_BASE wxOutputStream : public wxStreamBase
{ {
public: public:
wxOutputStream(); wxOutputStream();
@@ -274,7 +274,7 @@ protected:
// A stream for measuring streamed output // A stream for measuring streamed output
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxCountingOutputStream : public wxOutputStream class WXDLLIMPEXP_BASE wxCountingOutputStream : public wxOutputStream
{ {
public: public:
wxCountingOutputStream(); wxCountingOutputStream();
@@ -294,7 +294,7 @@ protected:
// "Filter" streams // "Filter" streams
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFilterInputStream : public wxInputStream class WXDLLIMPEXP_BASE wxFilterInputStream : public wxInputStream
{ {
public: public:
wxFilterInputStream(); wxFilterInputStream();
@@ -313,7 +313,7 @@ protected:
DECLARE_NO_COPY_CLASS(wxFilterInputStream) DECLARE_NO_COPY_CLASS(wxFilterInputStream)
}; };
class WXDLLEXPORT_BASE wxFilterOutputStream : public wxOutputStream class WXDLLIMPEXP_BASE wxFilterOutputStream : public wxOutputStream
{ {
public: public:
wxFilterOutputStream(); wxFilterOutputStream();
@@ -339,7 +339,7 @@ protected:
// wxBufferedStreams to implement custom buffering // wxBufferedStreams to implement custom buffering
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxStreamBuffer class WXDLLIMPEXP_BASE wxStreamBuffer
{ {
public: public:
enum BufMode enum BufMode
@@ -457,7 +457,7 @@ private:
// wxBufferedInputStream // wxBufferedInputStream
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxBufferedInputStream : public wxFilterInputStream class WXDLLIMPEXP_BASE wxBufferedInputStream : public wxFilterInputStream
{ {
public: public:
// if a non NULL buffer is given to the stream, it will be deleted by it // if a non NULL buffer is given to the stream, it will be deleted by it
@@ -493,7 +493,7 @@ protected:
// wxBufferedOutputStream // wxBufferedOutputStream
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxBufferedOutputStream : public wxFilterOutputStream class WXDLLIMPEXP_BASE wxBufferedOutputStream : public wxFilterOutputStream
{ {
public: public:
// if a non NULL buffer is given to the stream, it will be deleted by it // if a non NULL buffer is given to the stream, it will be deleted by it

40
include/wx/string.h
View File

@@ -101,7 +101,7 @@ const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// global pointer to empty string // global pointer to empty string
extern WXDLLEXPORT_DATA_BASE(const wxChar*) wxEmptyString; extern WXDLLIMPEXP_DATA_BASE(const wxChar*) wxEmptyString;
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// global functions complementing standard C string library replacements for // global functions complementing standard C string library replacements for
@@ -166,7 +166,7 @@ inline int Stricmp(const char *psz1, const char *psz2)
} }
// return an empty wxString // return an empty wxString
class WXDLLEXPORT_BASE wxString; // not yet defined class WXDLLIMPEXP_BASE wxString; // not yet defined
inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; } inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@@ -174,7 +174,7 @@ inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString;
// is never used directly (but had to be put here to allow inlining) // is never used directly (but had to be put here to allow inlining)
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
struct WXDLLEXPORT_BASE wxStringData struct WXDLLIMPEXP_BASE wxStringData
{ {
int nRefs; // reference count int nRefs; // reference count
size_t nDataLength, // actual string length size_t nDataLength, // actual string length
@@ -233,9 +233,9 @@ struct WXDLLEXPORT_BASE wxStringData
// - regular expressions support // - regular expressions support
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxString class WXDLLIMPEXP_BASE wxString
{ {
friend class WXDLLEXPORT_BASE wxArrayString; friend class WXDLLIMPEXP_BASE wxArrayString;
// NB: special care was taken in arranging the member functions in such order // NB: special care was taken in arranging the member functions in such order
// that all inline functions can be effectively inlined, verify that all // that all inline functions can be effectively inlined, verify that all
@@ -607,15 +607,15 @@ public:
// non-destructive concatenation // non-destructive concatenation
// //
friend wxString WXDLLEXPORT_BASE operator+(const wxString& string1, const wxString& string2); friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2);
// //
friend wxString WXDLLEXPORT_BASE operator+(const wxString& string, wxChar ch); friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
// //
friend wxString WXDLLEXPORT_BASE operator+(wxChar ch, const wxString& string); friend wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
// //
friend wxString WXDLLEXPORT_BASE operator+(const wxString& string, const wxChar *psz); friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
// //
friend wxString WXDLLEXPORT_BASE operator+(const wxChar *psz, const wxString& string); friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
// stream-like functions // stream-like functions
// insert an int into string // insert an int into string
@@ -1027,7 +1027,7 @@ public:
// from the array (operator[] or Item() method), a reference is returned. // from the array (operator[] or Item() method), a reference is returned.
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxArrayString class WXDLLIMPEXP_BASE wxArrayString
{ {
public: public:
// type of function used by wxArrayString::Sort() // type of function used by wxArrayString::Sort()
@@ -1151,7 +1151,7 @@ private:
bool m_autoSort; // if TRUE, keep the array always sorted bool m_autoSort; // if TRUE, keep the array always sorted
}; };
class WXDLLEXPORT_BASE wxSortedArrayString : public wxArrayString class WXDLLIMPEXP_BASE wxSortedArrayString : public wxArrayString
{ {
public: public:
wxSortedArrayString() : wxArrayString(TRUE) wxSortedArrayString() : wxArrayString(TRUE)
@@ -1164,7 +1164,7 @@ public:
// wxStringBuffer: a tiny class allowing to get a writable pointer into string // wxStringBuffer: a tiny class allowing to get a writable pointer into string
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxStringBuffer class WXDLLIMPEXP_BASE wxStringBuffer
{ {
public: public:
wxStringBuffer(wxString& str, size_t lenWanted = 1024) wxStringBuffer(wxString& str, size_t lenWanted = 1024)
@@ -1249,11 +1249,11 @@ inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
{ return (s2.Cmp((const char *)s1) != 0); } { return (s2.Cmp((const char *)s1) != 0); }
#endif // wxUSE_UNICODE/!wxUSE_UNICODE #endif // wxUSE_UNICODE/!wxUSE_UNICODE
wxString WXDLLEXPORT_BASE operator+(const wxString& string1, const wxString& string2); wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2);
wxString WXDLLEXPORT_BASE operator+(const wxString& string, wxChar ch); wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
wxString WXDLLEXPORT_BASE operator+(wxChar ch, const wxString& string); wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
wxString WXDLLEXPORT_BASE operator+(const wxString& string, const wxChar *psz); wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
wxString WXDLLEXPORT_BASE operator+(const wxChar *psz, const wxString& string); wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
#if wxUSE_UNICODE #if wxUSE_UNICODE
inline wxString operator+(const wxString& string, const wxWCharBuffer& buf) inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
{ return string + (const wchar_t *)buf; } { return string + (const wchar_t *)buf; }
@@ -1277,8 +1277,8 @@ inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
#include "wx/iosfwrap.h" #include "wx/iosfwrap.h"
WXDLLEXPORT_BASE wxSTD istream& operator>>(wxSTD istream&, wxString&); WXDLLIMPEXP_BASE wxSTD istream& operator>>(wxSTD istream&, wxString&);
WXDLLEXPORT_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&); WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
#endif // wxSTD_STRING_COMPATIBILITY #endif // wxSTD_STRING_COMPATIBILITY

2
include/wx/sysopt.h
View File

@@ -20,7 +20,7 @@
// Enables an application to influence the wxWindows implementation // Enables an application to influence the wxWindows implementation
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxSystemOptions : public wxObject class WXDLLIMPEXP_BASE wxSystemOptions : public wxObject
{ {
public: public:
wxSystemOptions() { } wxSystemOptions() { }

2
include/wx/textbuf.h
View File

@@ -46,7 +46,7 @@ WX_DEFINE_EXPORTED_ARRAY_INT(wxTextFileType, ArrayFileType);
#endif // wxUSE_TEXTBUFFER #endif // wxUSE_TEXTBUFFER
class WXDLLEXPORT_BASE wxTextBuffer class WXDLLIMPEXP_BASE wxTextBuffer
{ {
public: public:
// constants and static functions // constants and static functions

2
include/wx/textfile.h
View File

@@ -30,7 +30,7 @@
// wxTextFile // wxTextFile
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxTextFile : public wxTextBuffer class WXDLLIMPEXP_BASE wxTextFile : public wxTextBuffer
{ {
public: public:
// constructors // constructors

4
include/wx/tokenzr.h
View File

@@ -41,7 +41,7 @@ enum wxStringTokenizerMode
// wxStringTokenizer: replaces infamous strtok() and has some other features // wxStringTokenizer: replaces infamous strtok() and has some other features
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxStringTokenizer : public wxObject class WXDLLIMPEXP_BASE wxStringTokenizer : public wxObject
{ {
public: public:
// ctors and initializers // ctors and initializers
@@ -123,7 +123,7 @@ protected:
// the function takes the same parameters as wxStringTokenizer ctor and returns // the function takes the same parameters as wxStringTokenizer ctor and returns
// the array containing all tokens // the array containing all tokens
wxArrayString WXDLLEXPORT_BASE wxArrayString WXDLLIMPEXP_BASE
wxStringTokenize(const wxString& str, wxStringTokenize(const wxString& str,
const wxString& delims = wxDEFAULT_DELIMITERS, const wxString& delims = wxDEFAULT_DELIMITERS,
wxStringTokenizerMode mode = wxTOKEN_DEFAULT); wxStringTokenizerMode mode = wxTOKEN_DEFAULT);

10
include/wx/txtstrm.h
View File

@@ -20,16 +20,16 @@
#if wxUSE_STREAMS #if wxUSE_STREAMS
class WXDLLEXPORT_BASE wxTextInputStream; class WXDLLIMPEXP_BASE wxTextInputStream;
class WXDLLEXPORT_BASE wxTextOutputStream; class WXDLLIMPEXP_BASE wxTextOutputStream;
typedef wxTextInputStream& (*__wxTextInputManip)(wxTextInputStream&); typedef wxTextInputStream& (*__wxTextInputManip)(wxTextInputStream&);
typedef wxTextOutputStream& (*__wxTextOutputManip)(wxTextOutputStream&); typedef wxTextOutputStream& (*__wxTextOutputManip)(wxTextOutputStream&);
WXDLLEXPORT_BASE wxTextOutputStream &endl( wxTextOutputStream &stream ); WXDLLIMPEXP_BASE wxTextOutputStream &endl( wxTextOutputStream &stream );
class WXDLLEXPORT_BASE wxTextInputStream class WXDLLIMPEXP_BASE wxTextInputStream
{ {
public: public:
#if wxUSE_UNICODE #if wxUSE_UNICODE
@@ -83,7 +83,7 @@ typedef enum
wxEOL_DOS wxEOL_DOS
} wxEOL; } wxEOL;
class WXDLLEXPORT_BASE wxTextOutputStream class WXDLLIMPEXP_BASE wxTextOutputStream
{ {
public: public:
#if wxUSE_UNICODE #if wxUSE_UNICODE

2
include/wx/url.h
View File

@@ -37,7 +37,7 @@ typedef enum {
wxURL_PROTOERR wxURL_PROTOERR
} wxURLError; } wxURLError;
class WXDLLEXPORT_BASE wxURL : public wxObject class WXDLLIMPEXP_BASE wxURL : public wxObject
{ {
public: public:
wxURL(const wxString& url); wxURL(const wxString& url);

128
include/wx/utils.h
View File

@@ -39,11 +39,11 @@
// Forward declaration // Forward declaration
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxProcess; class WXDLLIMPEXP_BASE wxProcess;
class WXDLLEXPORT_BASE wxFrame; class WXDLLIMPEXP_BASE wxFrame;
class WXDLLEXPORT_BASE wxWindow; class WXDLLIMPEXP_BASE wxWindow;
class WXDLLEXPORT_BASE wxWindowList; class WXDLLIMPEXP_BASE wxWindowList;
class WXDLLEXPORT_BASE wxPoint; class WXDLLIMPEXP_BASE wxPoint;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Macros // Macros
@@ -59,15 +59,15 @@ class WXDLLEXPORT_BASE wxPoint;
// Useful buffer (FIXME VZ: To be removed!!!) // Useful buffer (FIXME VZ: To be removed!!!)
// Now only needed in MSW port // Now only needed in MSW port
#if !defined(__WXMOTIF__) && !defined(__WXGTK__) && !defined(__WXX11__) && !defined(__WXMGL__) && !defined(__WXMAC__) #if !defined(__WXMOTIF__) && !defined(__WXGTK__) && !defined(__WXX11__) && !defined(__WXMGL__) && !defined(__WXMAC__)
WXDLLEXPORT_DATA_BASE(extern wxChar*) wxBuffer; WXDLLIMPEXP_DATA_BASE(extern wxChar*) wxBuffer;
#endif #endif
// Make a copy of this string using 'new' // Make a copy of this string using 'new'
WXDLLEXPORT_BASE wxChar* copystring(const wxChar *s); WXDLLIMPEXP_BASE wxChar* copystring(const wxChar *s);
#if WXWIN_COMPATIBILITY_2 #if WXWIN_COMPATIBILITY_2
// Matches string one within string two regardless of case // Matches string one within string two regardless of case
WXDLLEXPORT_BASE bool StringMatch(const wxChar *one, const wxChar *two, bool subString = TRUE, bool exact = FALSE); WXDLLIMPEXP_BASE bool StringMatch(const wxChar *one, const wxChar *two, bool subString = TRUE, bool exact = FALSE);
#endif #endif
// A shorter way of using strcmp // A shorter way of using strcmp
@@ -78,22 +78,22 @@ WXDLLEXPORT_BASE bool StringMatch(const wxChar *one, const wxChar *two, bool sub
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Sound the bell // Sound the bell
WXDLLEXPORT_BASE void wxBell(); WXDLLIMPEXP_BASE void wxBell();
// Get OS description as a user-readable string // Get OS description as a user-readable string
WXDLLEXPORT_BASE wxString wxGetOsDescription(); WXDLLIMPEXP_BASE wxString wxGetOsDescription();
// Get OS version // Get OS version
WXDLLEXPORT_BASE int wxGetOsVersion(int *majorVsn = (int *) NULL, WXDLLIMPEXP_BASE int wxGetOsVersion(int *majorVsn = (int *) NULL,
int *minorVsn = (int *) NULL); int *minorVsn = (int *) NULL);
// Return a string with the current date/time // Return a string with the current date/time
WXDLLEXPORT_BASE wxString wxNow(); WXDLLIMPEXP_BASE wxString wxNow();
// Return path where wxWindows is installed (mostly useful in Unices) // Return path where wxWindows is installed (mostly useful in Unices)
WXDLLEXPORT_BASE const wxChar *wxGetInstallPrefix(); WXDLLIMPEXP_BASE const wxChar *wxGetInstallPrefix();
// Return path to wxWin data (/usr/share/wx/%{version}) (Unices) // Return path to wxWin data (/usr/share/wx/%{version}) (Unices)
WXDLLEXPORT_BASE wxString wxGetDataDir(); WXDLLIMPEXP_BASE wxString wxGetDataDir();
#if wxUSE_GUI #if wxUSE_GUI
@@ -130,26 +130,26 @@ WXDLLEXPORT long wxGetCurrentId();
// these functions are deprecated, use wxString methods instead! // these functions are deprecated, use wxString methods instead!
#if WXWIN_COMPATIBILITY_2_4 #if WXWIN_COMPATIBILITY_2_4
WXDLLEXPORT_DATA_BASE(extern const wxChar*) wxFloatToStringStr; WXDLLIMPEXP_DATA_BASE(extern const wxChar*) wxFloatToStringStr;
WXDLLEXPORT_DATA_BASE(extern const wxChar*) wxDoubleToStringStr; WXDLLIMPEXP_DATA_BASE(extern const wxChar*) wxDoubleToStringStr;
WXDLLEXPORT_BASE void StringToFloat(const wxChar *s, float *number); WXDLLIMPEXP_BASE void StringToFloat(const wxChar *s, float *number);
WXDLLEXPORT_BASE wxChar* FloatToString(float number, const wxChar *fmt = wxFloatToStringStr); WXDLLIMPEXP_BASE wxChar* FloatToString(float number, const wxChar *fmt = wxFloatToStringStr);
WXDLLEXPORT_BASE void StringToDouble(const wxChar *s, double *number); WXDLLIMPEXP_BASE void StringToDouble(const wxChar *s, double *number);
WXDLLEXPORT_BASE wxChar* DoubleToString(double number, const wxChar *fmt = wxDoubleToStringStr); WXDLLIMPEXP_BASE wxChar* DoubleToString(double number, const wxChar *fmt = wxDoubleToStringStr);
WXDLLEXPORT_BASE void StringToInt(const wxChar *s, int *number); WXDLLIMPEXP_BASE void StringToInt(const wxChar *s, int *number);
WXDLLEXPORT_BASE void StringToLong(const wxChar *s, long *number); WXDLLIMPEXP_BASE void StringToLong(const wxChar *s, long *number);
WXDLLEXPORT_BASE wxChar* IntToString(int number); WXDLLIMPEXP_BASE wxChar* IntToString(int number);
WXDLLEXPORT_BASE wxChar* LongToString(long number); WXDLLIMPEXP_BASE wxChar* LongToString(long number);
#endif // WXWIN_COMPATIBILITY_2_4 #endif // WXWIN_COMPATIBILITY_2_4
// Convert 2-digit hex number to decimal // Convert 2-digit hex number to decimal
WXDLLEXPORT_BASE int wxHexToDec(const wxString& buf); WXDLLIMPEXP_BASE int wxHexToDec(const wxString& buf);
// Convert decimal integer to 2-character hex string // Convert decimal integer to 2-character hex string
WXDLLEXPORT_BASE void wxDecToHex(int dec, wxChar *buf); WXDLLIMPEXP_BASE void wxDecToHex(int dec, wxChar *buf);
WXDLLEXPORT_BASE wxString wxDecToHex(int dec); WXDLLIMPEXP_BASE wxString wxDecToHex(int dec);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Process management // Process management
@@ -180,18 +180,18 @@ enum
// If flags contain wxEXEC_SYNC, return -1 on failure and the exit code of the // If flags contain wxEXEC_SYNC, return -1 on failure and the exit code of the
// process if everything was ok. Otherwise (i.e. if wxEXEC_ASYNC), return 0 on // process if everything was ok. Otherwise (i.e. if wxEXEC_ASYNC), return 0 on
// failure and the PID of the launched process if ok. // failure and the PID of the launched process if ok.
WXDLLEXPORT_BASE long wxExecute(wxChar **argv, int flags = wxEXEC_ASYNC, WXDLLIMPEXP_BASE long wxExecute(wxChar **argv, int flags = wxEXEC_ASYNC,
wxProcess *process = (wxProcess *) NULL); wxProcess *process = (wxProcess *) NULL);
WXDLLEXPORT_BASE long wxExecute(const wxString& command, int flags = wxEXEC_ASYNC, WXDLLIMPEXP_BASE long wxExecute(const wxString& command, int flags = wxEXEC_ASYNC,
wxProcess *process = (wxProcess *) NULL); wxProcess *process = (wxProcess *) NULL);
// execute the command capturing its output into an array line by line, this is // execute the command capturing its output into an array line by line, this is
// always synchronous // always synchronous
WXDLLEXPORT_BASE long wxExecute(const wxString& command, WXDLLIMPEXP_BASE long wxExecute(const wxString& command,
wxArrayString& output); wxArrayString& output);
// also capture stderr (also synchronous) // also capture stderr (also synchronous)
WXDLLEXPORT_BASE long wxExecute(const wxString& command, WXDLLIMPEXP_BASE long wxExecute(const wxString& command,
wxArrayString& output, wxArrayString& output,
wxArrayString& error); wxArrayString& error);
@@ -234,38 +234,38 @@ enum wxShutdownFlags
}; };
// Shutdown or reboot the PC // Shutdown or reboot the PC
WXDLLEXPORT_BASE bool wxShutdown(wxShutdownFlags wFlags); WXDLLIMPEXP_BASE bool wxShutdown(wxShutdownFlags wFlags);
// send the given signal to the process (only NONE and KILL are supported under // send the given signal to the process (only NONE and KILL are supported under
// Windows, all others mean TERM), return 0 if ok and -1 on error // Windows, all others mean TERM), return 0 if ok and -1 on error
// //
// return detailed error in rc if not NULL // return detailed error in rc if not NULL
WXDLLEXPORT_BASE int wxKill(long pid, WXDLLIMPEXP_BASE int wxKill(long pid,
wxSignal sig = wxSIGTERM, wxSignal sig = wxSIGTERM,
wxKillError *rc = NULL); wxKillError *rc = NULL);
// Execute a command in an interactive shell window (always synchronously) // Execute a command in an interactive shell window (always synchronously)
// If no command then just the shell // If no command then just the shell
WXDLLEXPORT_BASE bool wxShell(const wxString& command = wxEmptyString); WXDLLIMPEXP_BASE bool wxShell(const wxString& command = wxEmptyString);
// As wxShell(), but must give a (non interactive) command and its output will // As wxShell(), but must give a (non interactive) command and its output will
// be returned in output array // be returned in output array
WXDLLEXPORT_BASE bool wxShell(const wxString& command, wxArrayString& output); WXDLLIMPEXP_BASE bool wxShell(const wxString& command, wxArrayString& output);
// Sleep for nSecs seconds // Sleep for nSecs seconds
WXDLLEXPORT_BASE void wxSleep(int nSecs); WXDLLIMPEXP_BASE void wxSleep(int nSecs);
// Sleep for a given amount of milliseconds // Sleep for a given amount of milliseconds
WXDLLEXPORT_BASE void wxUsleep(unsigned long milliseconds); WXDLLIMPEXP_BASE void wxUsleep(unsigned long milliseconds);
// Get the process id of the current process // Get the process id of the current process
WXDLLEXPORT_BASE unsigned long wxGetProcessId(); WXDLLIMPEXP_BASE unsigned long wxGetProcessId();
// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX) // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
WXDLLEXPORT_BASE long wxGetFreeMemory(); WXDLLIMPEXP_BASE long wxGetFreeMemory();
// should wxApp::OnFatalException() be called? // should wxApp::OnFatalException() be called?
WXDLLEXPORT_BASE bool wxHandleFatalExceptions(bool doit = TRUE); WXDLLIMPEXP_BASE bool wxHandleFatalExceptions(bool doit = TRUE);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Environment variables // Environment variables
@@ -273,10 +273,10 @@ WXDLLEXPORT_BASE bool wxHandleFatalExceptions(bool doit = TRUE);
// returns TRUE if variable exists (value may be NULL if you just want to check // returns TRUE if variable exists (value may be NULL if you just want to check
// for this) // for this)
WXDLLEXPORT_BASE bool wxGetEnv(const wxString& var, wxString *value); WXDLLIMPEXP_BASE bool wxGetEnv(const wxString& var, wxString *value);
// set the env var name to the given value, return TRUE on success // set the env var name to the given value, return TRUE on success
WXDLLEXPORT_BASE bool wxSetEnv(const wxString& var, const wxChar *value); WXDLLIMPEXP_BASE bool wxSetEnv(const wxString& var, const wxChar *value);
// remove the env var from environment // remove the env var from environment
inline bool wxUnsetEnv(const wxString& var) { return wxSetEnv(var, NULL); } inline bool wxUnsetEnv(const wxString& var) { return wxSetEnv(var, NULL); }
@@ -288,39 +288,39 @@ inline bool wxUnsetEnv(const wxString& var) { return wxSetEnv(var, NULL); }
// NB: "char *" functions are deprecated, use wxString ones! // NB: "char *" functions are deprecated, use wxString ones!
// Get eMail address // Get eMail address
WXDLLEXPORT_BASE bool wxGetEmailAddress(wxChar *buf, int maxSize); WXDLLIMPEXP_BASE bool wxGetEmailAddress(wxChar *buf, int maxSize);
WXDLLEXPORT_BASE wxString wxGetEmailAddress(); WXDLLIMPEXP_BASE wxString wxGetEmailAddress();
// Get hostname. // Get hostname.
WXDLLEXPORT_BASE bool wxGetHostName(wxChar *buf, int maxSize); WXDLLIMPEXP_BASE bool wxGetHostName(wxChar *buf, int maxSize);
WXDLLEXPORT_BASE wxString wxGetHostName(); WXDLLIMPEXP_BASE wxString wxGetHostName();
// Get FQDN // Get FQDN
WXDLLEXPORT_BASE wxString wxGetFullHostName(); WXDLLIMPEXP_BASE wxString wxGetFullHostName();
WXDLLEXPORT_BASE bool wxGetFullHostName(wxChar *buf, int maxSize); WXDLLIMPEXP_BASE bool wxGetFullHostName(wxChar *buf, int maxSize);
// Get user ID e.g. jacs (this is known as login name under Unix) // Get user ID e.g. jacs (this is known as login name under Unix)
WXDLLEXPORT_BASE bool wxGetUserId(wxChar *buf, int maxSize); WXDLLIMPEXP_BASE bool wxGetUserId(wxChar *buf, int maxSize);
WXDLLEXPORT_BASE wxString wxGetUserId(); WXDLLIMPEXP_BASE wxString wxGetUserId();
// Get user name e.g. Julian Smart // Get user name e.g. Julian Smart
WXDLLEXPORT_BASE bool wxGetUserName(wxChar *buf, int maxSize); WXDLLIMPEXP_BASE bool wxGetUserName(wxChar *buf, int maxSize);
WXDLLEXPORT_BASE wxString wxGetUserName(); WXDLLIMPEXP_BASE wxString wxGetUserName();
// Get current Home dir and copy to dest (returns pstr->c_str()) // Get current Home dir and copy to dest (returns pstr->c_str())
WXDLLEXPORT_BASE wxString wxGetHomeDir(); WXDLLIMPEXP_BASE wxString wxGetHomeDir();
WXDLLEXPORT_BASE const wxChar* wxGetHomeDir(wxString *pstr); WXDLLIMPEXP_BASE const wxChar* wxGetHomeDir(wxString *pstr);
// Get the user's home dir (caller must copy --- volatile) // Get the user's home dir (caller must copy --- volatile)
// returns NULL is no HOME dir is known // returns NULL is no HOME dir is known
#if defined(__UNIX__) && wxUSE_UNICODE #if defined(__UNIX__) && wxUSE_UNICODE
WXDLLEXPORT_BASE const wxMB2WXbuf wxGetUserHome(const wxString& user = wxEmptyString); WXDLLIMPEXP_BASE const wxMB2WXbuf wxGetUserHome(const wxString& user = wxEmptyString);
#else #else
WXDLLEXPORT_BASE wxChar* wxGetUserHome(const wxString& user = wxEmptyString); WXDLLIMPEXP_BASE wxChar* wxGetUserHome(const wxString& user = wxEmptyString);
#endif #endif
// get number of total/free bytes on the disk where path belongs // get number of total/free bytes on the disk where path belongs
WXDLLEXPORT_BASE bool wxGetDiskSpace(const wxString& path, WXDLLIMPEXP_BASE bool wxGetDiskSpace(const wxString& path,
wxLongLong *pTotal = NULL, wxLongLong *pTotal = NULL,
wxLongLong *pFree = NULL); wxLongLong *pFree = NULL);
@@ -486,10 +486,10 @@ void WXDLLEXPORT wxGetMousePosition( int* x, int* y );
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Yield to other apps/messages // Yield to other apps/messages
WXDLLEXPORT_BASE bool wxYield(); WXDLLIMPEXP_BASE bool wxYield();
// Like wxYield, but fails silently if the yield is recursive. // Like wxYield, but fails silently if the yield is recursive.
WXDLLEXPORT_BASE bool wxYieldIfNeeded(); WXDLLIMPEXP_BASE bool wxYieldIfNeeded();
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Error message functions used by wxWindows (deprecated, use wxLog) // Error message functions used by wxWindows (deprecated, use wxLog)
@@ -499,15 +499,15 @@ WXDLLEXPORT_BASE bool wxYieldIfNeeded();
// Format a message on the standard error (UNIX) or the debugging // Format a message on the standard error (UNIX) or the debugging
// stream (Windows) // stream (Windows)
WXDLLEXPORT_BASE void wxDebugMsg(const wxChar *fmt ...) ATTRIBUTE_PRINTF_1; WXDLLIMPEXP_BASE void wxDebugMsg(const wxChar *fmt ...) ATTRIBUTE_PRINTF_1;
// Non-fatal error (continues) // Non-fatal error (continues)
WXDLLEXPORT_DATA_BASE(extern const wxChar*) wxInternalErrorStr; WXDLLIMPEXP_DATA_BASE(extern const wxChar*) wxInternalErrorStr;
WXDLLEXPORT_BASE void wxError(const wxString& msg, const wxString& title = wxInternalErrorStr); WXDLLIMPEXP_BASE void wxError(const wxString& msg, const wxString& title = wxInternalErrorStr);
// Fatal error (exits) // Fatal error (exits)
WXDLLEXPORT_DATA_BASE(extern const wxChar*) wxFatalErrorStr; WXDLLIMPEXP_DATA_BASE(extern const wxChar*) wxFatalErrorStr;
WXDLLEXPORT_BASE void wxFatalError(const wxString& msg, const wxString& title = wxFatalErrorStr); WXDLLIMPEXP_BASE void wxFatalError(const wxString& msg, const wxString& title = wxFatalErrorStr);
#endif // WXWIN_COMPATIBILITY_2_2 #endif // WXWIN_COMPATIBILITY_2_2

6
include/wx/variant.h
View File

@@ -45,7 +45,7 @@
* overloading wxVariant with unnecessary functionality. * overloading wxVariant with unnecessary functionality.
*/ */
class WXDLLEXPORT_BASE wxVariantData: public wxObject class WXDLLIMPEXP_BASE wxVariantData: public wxObject
{ {
DECLARE_ABSTRACT_CLASS(wxVariantData) DECLARE_ABSTRACT_CLASS(wxVariantData)
public: public:
@@ -79,7 +79,7 @@ public:
* this class too much. * this class too much.
*/ */
class WXDLLEXPORT_BASE wxVariant: public wxObject class WXDLLIMPEXP_BASE wxVariant: public wxObject
{ {
DECLARE_DYNAMIC_CLASS(wxVariant) DECLARE_DYNAMIC_CLASS(wxVariant)
public: public:
@@ -284,7 +284,7 @@ protected:
((classname*)(var.IsValueKindOf(&classname::sm_class##classname) ?\ ((classname*)(var.IsValueKindOf(&classname::sm_class##classname) ?\
var.GetWxObjectPtr() : NULL)); var.GetWxObjectPtr() : NULL));
extern wxVariant WXDLLEXPORT_BASE wxNullVariant; extern wxVariant WXDLLIMPEXP_BASE wxNullVariant;
#endif #endif
// _WX_VARIANT_H_ // _WX_VARIANT_H_

2
include/wx/vector.h
View File

@@ -13,7 +13,7 @@
#include "wx/defs.h" #include "wx/defs.h"
class WXDLLEXPORT_BASE wxVectorBase class WXDLLIMPEXP_BASE wxVectorBase
{ {
public: public:
typedef size_t size_type; typedef size_t size_type;

2
include/wx/volume.h
View File

@@ -52,7 +52,7 @@ enum wxFSVolumeKind
wxFS_VOL_MAX wxFS_VOL_MAX
}; };
class WXDLLEXPORT_BASE wxFSVolumeBase class WXDLLIMPEXP_BASE wxFSVolumeBase
{ {
public: public:
// return the array containing the names of the volumes // return the array containing the names of the volumes

12
include/wx/wfstream.h
View File

@@ -30,7 +30,7 @@
// wxFileStream using wxFile // wxFileStream using wxFile
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileInputStream: public wxInputStream { class WXDLLIMPEXP_BASE wxFileInputStream: public wxInputStream {
public: public:
wxFileInputStream(const wxString& ifileName); wxFileInputStream(const wxString& ifileName);
wxFileInputStream(wxFile& file); wxFileInputStream(wxFile& file);
@@ -55,7 +55,7 @@ class WXDLLEXPORT_BASE wxFileInputStream: public wxInputStream {
DECLARE_NO_COPY_CLASS(wxFileInputStream) DECLARE_NO_COPY_CLASS(wxFileInputStream)
}; };
class WXDLLEXPORT_BASE wxFileOutputStream: public wxOutputStream { class WXDLLIMPEXP_BASE wxFileOutputStream: public wxOutputStream {
public: public:
wxFileOutputStream(const wxString& fileName); wxFileOutputStream(const wxString& fileName);
wxFileOutputStream(wxFile& file); wxFileOutputStream(wxFile& file);
@@ -85,7 +85,7 @@ class WXDLLEXPORT_BASE wxFileOutputStream: public wxOutputStream {
DECLARE_NO_COPY_CLASS(wxFileOutputStream) DECLARE_NO_COPY_CLASS(wxFileOutputStream)
}; };
class WXDLLEXPORT_BASE wxFileStream: public wxFileInputStream, public wxFileOutputStream { class WXDLLIMPEXP_BASE wxFileStream: public wxFileInputStream, public wxFileOutputStream {
public: public:
wxFileStream(const wxString& fileName); wxFileStream(const wxString& fileName);
}; };
@@ -94,7 +94,7 @@ class WXDLLEXPORT_BASE wxFileStream: public wxFileInputStream, public wxFileOutp
// wxFFileStream using wxFFile // wxFFileStream using wxFFile
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFFileInputStream: public wxInputStream { class WXDLLIMPEXP_BASE wxFFileInputStream: public wxInputStream {
public: public:
wxFFileInputStream(const wxString& ifileName); wxFFileInputStream(const wxString& ifileName);
wxFFileInputStream(wxFFile& file); wxFFileInputStream(wxFFile& file);
@@ -119,7 +119,7 @@ class WXDLLEXPORT_BASE wxFFileInputStream: public wxInputStream {
DECLARE_NO_COPY_CLASS(wxFFileInputStream) DECLARE_NO_COPY_CLASS(wxFFileInputStream)
}; };
class WXDLLEXPORT_BASE wxFFileOutputStream: public wxOutputStream { class WXDLLIMPEXP_BASE wxFFileOutputStream: public wxOutputStream {
public: public:
wxFFileOutputStream(const wxString& fileName); wxFFileOutputStream(const wxString& fileName);
wxFFileOutputStream(wxFFile& file); wxFFileOutputStream(wxFFile& file);
@@ -149,7 +149,7 @@ class WXDLLEXPORT_BASE wxFFileOutputStream: public wxOutputStream {
DECLARE_NO_COPY_CLASS(wxFFileOutputStream) DECLARE_NO_COPY_CLASS(wxFFileOutputStream)
}; };
class WXDLLEXPORT_BASE wxFFileStream: public wxFFileInputStream, public wxFFileOutputStream { class WXDLLIMPEXP_BASE wxFFileStream: public wxFFileInputStream, public wxFFileOutputStream {
public: public:
wxFFileStream(const wxString& fileName); wxFFileStream(const wxString& fileName);
}; };

114
include/wx/wxchar.h
View File

@@ -679,7 +679,7 @@ inline size_t wxStrlen(const wxChar *psz) { return psz ? wxStrlen_(psz) : 0; }
#define wxStrdup wxStrdupA #define wxStrdup wxStrdupA
#endif #endif
WXDLLEXPORT_BASE bool wxOKlibc(); // for internal use WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// printf() family saga // printf() family saga
@@ -728,11 +728,11 @@ WXDLLEXPORT_BASE bool wxOKlibc(); // for internal use
#ifndef wxSnprintf_ #ifndef wxSnprintf_
// no [v]snprintf(), cook our own // no [v]snprintf(), cook our own
WXDLLEXPORT_BASE int wxSnprintf_(wxChar *buf, size_t len, const wxChar *format, WXDLLIMPEXP_BASE int wxSnprintf_(wxChar *buf, size_t len, const wxChar *format,
...) ATTRIBUTE_PRINTF_3; ...) ATTRIBUTE_PRINTF_3;
#endif #endif
#ifndef wxVsnprintf_ #ifndef wxVsnprintf_
WXDLLEXPORT_BASE int wxVsnprintf_(wxChar *buf, size_t len, const wxChar *format, WXDLLIMPEXP_BASE int wxVsnprintf_(wxChar *buf, size_t len, const wxChar *format,
va_list argptr); va_list argptr);
#endif #endif
@@ -801,19 +801,19 @@ WXDLLEXPORT_BASE bool wxOKlibc(); // for internal use
// //
// VZ: note that this is never defined currently // VZ: note that this is never defined currently
#ifdef wxNEED_WX_CTYPE_H #ifdef wxNEED_WX_CTYPE_H
WXDLLEXPORT_BASE int wxIsalnum(wxChar ch); WXDLLIMPEXP_BASE int wxIsalnum(wxChar ch);
WXDLLEXPORT_BASE int wxIsalpha(wxChar ch); WXDLLIMPEXP_BASE int wxIsalpha(wxChar ch);
WXDLLEXPORT_BASE int wxIsctrl(wxChar ch); WXDLLIMPEXP_BASE int wxIsctrl(wxChar ch);
WXDLLEXPORT_BASE int wxIsdigit(wxChar ch); WXDLLIMPEXP_BASE int wxIsdigit(wxChar ch);
WXDLLEXPORT_BASE int wxIsgraph(wxChar ch); WXDLLIMPEXP_BASE int wxIsgraph(wxChar ch);
WXDLLEXPORT_BASE int wxIslower(wxChar ch); WXDLLIMPEXP_BASE int wxIslower(wxChar ch);
WXDLLEXPORT_BASE int wxIsprint(wxChar ch); WXDLLIMPEXP_BASE int wxIsprint(wxChar ch);
WXDLLEXPORT_BASE int wxIspunct(wxChar ch); WXDLLIMPEXP_BASE int wxIspunct(wxChar ch);
WXDLLEXPORT_BASE int wxIsspace(wxChar ch); WXDLLIMPEXP_BASE int wxIsspace(wxChar ch);
WXDLLEXPORT_BASE int wxIsupper(wxChar ch); WXDLLIMPEXP_BASE int wxIsupper(wxChar ch);
WXDLLEXPORT_BASE int wxIsxdigit(wxChar ch); WXDLLIMPEXP_BASE int wxIsxdigit(wxChar ch);
WXDLLEXPORT_BASE int wxTolower(wxChar ch); WXDLLIMPEXP_BASE int wxTolower(wxChar ch);
WXDLLEXPORT_BASE int wxToupper(wxChar ch); WXDLLIMPEXP_BASE int wxToupper(wxChar ch);
#endif // wxNEED_WX_CTYPE_H #endif // wxNEED_WX_CTYPE_H
// under VC++ 6.0 isspace() returns 1 for 8 bit chars which completely breaks // under VC++ 6.0 isspace() returns 1 for 8 bit chars which completely breaks
@@ -828,66 +828,66 @@ WXDLLEXPORT_BASE bool wxOKlibc(); // for internal use
// //
// VZ: this is never defined neither currently // VZ: this is never defined neither currently
#ifdef wxNEED_WX_STRING_H #ifdef wxNEED_WX_STRING_H
WXDLLEXPORT_BASE wxChar * wxStrcat(wxChar *dest, const wxChar *src); WXDLLIMPEXP_BASE wxChar * wxStrcat(wxChar *dest, const wxChar *src);
WXDLLEXPORT_BASE const wxChar * wxStrchr(const wxChar *s, wxChar c); WXDLLIMPEXP_BASE const wxChar * wxStrchr(const wxChar *s, wxChar c);
WXDLLEXPORT_BASE wxChar * wxStrchr(wxChar *s, wxChar c) WXDLLIMPEXP_BASE wxChar * wxStrchr(wxChar *s, wxChar c)
{ return (wxChar *)wxStrchr((const wxChar *)s, c); } { return (wxChar *)wxStrchr((const wxChar *)s, c); }
WXDLLEXPORT_BASE int wxStrcmp(const wxChar *s1, const wxChar *s2); WXDLLIMPEXP_BASE int wxStrcmp(const wxChar *s1, const wxChar *s2);
WXDLLEXPORT_BASE int wxStrcoll(const wxChar *s1, const wxChar *s2); WXDLLIMPEXP_BASE int wxStrcoll(const wxChar *s1, const wxChar *s2);
WXDLLEXPORT_BASE wxChar * wxStrcpy(wxChar *dest, const wxChar *src); WXDLLIMPEXP_BASE wxChar * wxStrcpy(wxChar *dest, const wxChar *src);
WXDLLEXPORT_BASE size_t wxStrcspn(const wxChar *s, const wxChar *reject); WXDLLIMPEXP_BASE size_t wxStrcspn(const wxChar *s, const wxChar *reject);
WXDLLEXPORT_BASE size_t wxStrlen(const wxChar *s); WXDLLIMPEXP_BASE size_t wxStrlen(const wxChar *s);
WXDLLEXPORT_BASE wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n); WXDLLIMPEXP_BASE wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n);
WXDLLEXPORT_BASE int wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n); WXDLLIMPEXP_BASE int wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n);
WXDLLEXPORT_BASE wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n); WXDLLIMPEXP_BASE wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n);
WXDLLEXPORT_BASE const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept); WXDLLIMPEXP_BASE const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept);
WXDLLEXPORT_BASE wxChar * wxStrpbrk(wxChar *s, const wxChar *accept) WXDLLIMPEXP_BASE wxChar * wxStrpbrk(wxChar *s, const wxChar *accept)
{ return (wxChar *)wxStrpbrk((const wxChar *)s, accept); } { return (wxChar *)wxStrpbrk((const wxChar *)s, accept); }
WXDLLEXPORT_BASE const wxChar * wxStrrchr(const wxChar *s, wxChar c); WXDLLIMPEXP_BASE const wxChar * wxStrrchr(const wxChar *s, wxChar c);
WXDLLEXPORT_BASE wxChar * wxStrrchr(wxChar *s, wxChar c) WXDLLIMPEXP_BASE wxChar * wxStrrchr(wxChar *s, wxChar c)
{ return (wxChar *)wxStrrchr((const wxChar *)s, c); } { return (wxChar *)wxStrrchr((const wxChar *)s, c); }
WXDLLEXPORT_BASE size_t wxStrspn(const wxChar *s, const wxChar *accept); WXDLLIMPEXP_BASE size_t wxStrspn(const wxChar *s, const wxChar *accept);
WXDLLEXPORT_BASE const wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle); WXDLLIMPEXP_BASE const wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle);
WXDLLEXPORT_BASE wxChar *wxStrstr(wxChar *haystack, const wxChar *needle) WXDLLIMPEXP_BASE wxChar *wxStrstr(wxChar *haystack, const wxChar *needle)
{ return (wxChar *)wxStrstr((const wxChar *)haystack, needle); } { return (wxChar *)wxStrstr((const wxChar *)haystack, needle); }
WXDLLEXPORT_BASE double wxStrtod(const wxChar *nptr, wxChar **endptr); WXDLLIMPEXP_BASE double wxStrtod(const wxChar *nptr, wxChar **endptr);
WXDLLEXPORT_BASE long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base); WXDLLIMPEXP_BASE long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base);
WXDLLEXPORT_BASE unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base); WXDLLIMPEXP_BASE unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base);
WXDLLEXPORT_BASE size_t wxStrxfrm(wxChar *dest, const wxChar *src, size_t n); WXDLLIMPEXP_BASE size_t wxStrxfrm(wxChar *dest, const wxChar *src, size_t n);
#endif // wxNEED_WX_STRING_H #endif // wxNEED_WX_STRING_H
#ifndef wxStrdupA #ifndef wxStrdupA
WXDLLEXPORT_BASE char *wxStrdupA(const char *psz); WXDLLIMPEXP_BASE char *wxStrdupA(const char *psz);
#endif #endif
#ifndef wxStrdupW #ifndef wxStrdupW
WXDLLEXPORT_BASE wchar_t *wxStrdupW(const wchar_t *pwz); WXDLLIMPEXP_BASE wchar_t *wxStrdupW(const wchar_t *pwz);
#endif #endif
#ifndef wxStricmp #ifndef wxStricmp
WXDLLEXPORT_BASE int wxStricmp(const wxChar *psz1, const wxChar *psz2); WXDLLIMPEXP_BASE int wxStricmp(const wxChar *psz1, const wxChar *psz2);
#endif #endif
#ifndef wxStrnicmp #ifndef wxStrnicmp
WXDLLEXPORT_BASE int wxStrnicmp(const wxChar *psz1, const wxChar *psz2, size_t len); WXDLLIMPEXP_BASE int wxStrnicmp(const wxChar *psz1, const wxChar *psz2, size_t len);
#endif #endif
#ifndef wxStrtok #ifndef wxStrtok
WXDLLEXPORT_BASE wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr); WXDLLIMPEXP_BASE wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr);
#endif #endif
#ifndef wxSetlocale #ifndef wxSetlocale
class WXDLLEXPORT_BASE wxWCharBuffer; class WXDLLIMPEXP_BASE wxWCharBuffer;
WXDLLEXPORT_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale); WXDLLIMPEXP_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
#endif #endif
// stdio.h functions // stdio.h functions
#ifdef wxNEED_WX_STDIO_H #ifdef wxNEED_WX_STDIO_H
#include <stdio.h> #include <stdio.h>
WXDLLEXPORT_BASE FILE * wxFopen(const wxChar *path, const wxChar *mode); WXDLLIMPEXP_BASE FILE * wxFopen(const wxChar *path, const wxChar *mode);
WXDLLEXPORT_BASE FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream); WXDLLIMPEXP_BASE FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream);
WXDLLEXPORT_BASE int wxRemove(const wxChar *path); WXDLLIMPEXP_BASE int wxRemove(const wxChar *path);
WXDLLEXPORT_BASE int wxRename(const wxChar *oldpath, const wxChar *newpath); WXDLLIMPEXP_BASE int wxRename(const wxChar *oldpath, const wxChar *newpath);
// *printf() family is handled separately // *printf() family is handled separately
#endif // wxNEED_WX_STDIO_H #endif // wxNEED_WX_STDIO_H
@@ -895,14 +895,14 @@ WXDLLEXPORT_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
// stdlib.h functions // stdlib.h functions
#ifndef wxAtof #ifndef wxAtof
WXDLLEXPORT_BASE double wxAtof(const wxChar *psz); WXDLLIMPEXP_BASE double wxAtof(const wxChar *psz);
#endif #endif
#ifdef wxNEED_WX_STDLIB_H #ifdef wxNEED_WX_STDLIB_H
WXDLLEXPORT_BASE int wxAtoi(const wxChar *psz); WXDLLIMPEXP_BASE int wxAtoi(const wxChar *psz);
WXDLLEXPORT_BASE long wxAtol(const wxChar *psz); WXDLLIMPEXP_BASE long wxAtol(const wxChar *psz);
WXDLLEXPORT_BASE wxChar * wxGetenv(const wxChar *name); WXDLLIMPEXP_BASE wxChar * wxGetenv(const wxChar *name);
WXDLLEXPORT_BASE int wxSystem(const wxChar *psz); WXDLLIMPEXP_BASE int wxSystem(const wxChar *psz);
#endif #endif
@@ -911,7 +911,7 @@ WXDLLEXPORT_BASE int wxSystem(const wxChar *psz);
#if defined(__MWERKS__) && defined(macintosh) #if defined(__MWERKS__) && defined(macintosh)
#include <time.h> #include <time.h>
#endif #endif
WXDLLEXPORT_BASE size_t wxStrftime(wxChar *s, size_t max, WXDLLIMPEXP_BASE size_t wxStrftime(wxChar *s, size_t max,
const wxChar *fmt, const struct tm *tm); const wxChar *fmt, const struct tm *tm);
#endif // wxNEED_WX_TIME_H #endif // wxNEED_WX_TIME_H
@@ -921,8 +921,8 @@ WXDLLEXPORT_BASE int wxSystem(const wxChar *psz);
#if wxUSE_WCHAR_T #if wxUSE_WCHAR_T
// multibyte<->widechar conversion // multibyte<->widechar conversion
WXDLLEXPORT_BASE size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n); WXDLLIMPEXP_BASE size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n);
WXDLLEXPORT_BASE size_t wxWC2MB(char *buf, const wchar_t *psz, size_t n); WXDLLIMPEXP_BASE size_t wxWC2MB(char *buf, const wchar_t *psz, size_t n);
#if wxUSE_UNICODE #if wxUSE_UNICODE
#define wxMB2WX wxMB2WC #define wxMB2WX wxMB2WC

2
include/wx/zipstrm.h
View File

@@ -26,7 +26,7 @@
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxZipInputStream : public wxInputStream class WXDLLIMPEXP_BASE wxZipInputStream : public wxInputStream
{ {
public: public:
wxZipInputStream(const wxString& archive, const wxString& file); wxZipInputStream(const wxString& archive, const wxString& file);

4
include/wx/zstream.h
View File

@@ -21,7 +21,7 @@
#include "wx/stream.h" #include "wx/stream.h"
class WXDLLEXPORT_BASE wxZlibInputStream: public wxFilterInputStream { class WXDLLIMPEXP_BASE wxZlibInputStream: public wxFilterInputStream {
public: public:
wxZlibInputStream(wxInputStream& stream); wxZlibInputStream(wxInputStream& stream);
virtual ~wxZlibInputStream(); virtual ~wxZlibInputStream();
@@ -37,7 +37,7 @@ class WXDLLEXPORT_BASE wxZlibInputStream: public wxFilterInputStream {
DECLARE_NO_COPY_CLASS(wxZlibInputStream) DECLARE_NO_COPY_CLASS(wxZlibInputStream)
}; };
class WXDLLEXPORT_BASE wxZlibOutputStream: public wxFilterOutputStream { class WXDLLIMPEXP_BASE wxZlibOutputStream: public wxFilterOutputStream {
public: public:
wxZlibOutputStream(wxOutputStream& stream, int level = -1); wxZlibOutputStream(wxOutputStream& stream, int level = -1);
virtual ~wxZlibOutputStream(); virtual ~wxZlibOutputStream();

2
src/msw/fontutil.cpp
View File

@@ -118,7 +118,7 @@ bool wxGetNativeFontEncoding(wxFontEncoding encoding,
encoding = wxFont::GetDefaultEncoding(); encoding = wxFont::GetDefaultEncoding();
} }
extern WXDLLEXPORT_BASE long wxEncodingToCharset(wxFontEncoding encoding); extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding);
info->charset = wxEncodingToCharset(encoding); info->charset = wxEncodingToCharset(encoding);
if ( info->charset == -1 ) if ( info->charset == -1 )
return FALSE; return FALSE;

2
src/msw/textctrl.cpp
View File

@@ -566,7 +566,7 @@ DWORD CALLBACK wxRichEditStreamIn(DWORD dwCookie, BYTE *buf, LONG cb, LONG *pcb)
} }
// from utils.cpp // from utils.cpp
extern WXDLLEXPORT_BASE long wxEncodingToCodepage(wxFontEncoding encoding); extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding);
#if wxUSE_UNICODE_MSLU #if wxUSE_UNICODE_MSLU
bool wxTextCtrl::StreamIn(const wxString& value, bool wxTextCtrl::StreamIn(const wxString& value,

4
src/msw/utils.cpp
View File

@@ -1049,7 +1049,7 @@ void wxSleep(int nSecs)
// font encoding <-> Win32 codepage conversion functions // font encoding <-> Win32 codepage conversion functions
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
extern WXDLLEXPORT_BASE long wxEncodingToCharset(wxFontEncoding encoding) extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
{ {
switch ( encoding ) switch ( encoding )
{ {
@@ -1120,7 +1120,7 @@ extern WXDLLEXPORT_BASE long wxEncodingToCharset(wxFontEncoding encoding)
#include "wx/fontmap.h" #include "wx/fontmap.h"
extern WXDLLEXPORT_BASE long wxEncodingToCodepage(wxFontEncoding encoding) extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
{ {
// translate encoding into the Windows CHARSET // translate encoding into the Windows CHARSET
long charset = wxEncodingToCharset(encoding); long charset = wxEncodingToCharset(encoding);