AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests 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
Show Stats 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/init.h" // we must declare wxEntry()
class WXDLLEXPORT_CORE wxApp;
class WXDLLEXPORT_BASE wxAppTraits;
class WXDLLEXPORT_BASE wxCmdLineParser;
class WXDLLEXPORT_BASE wxLog;
class WXDLLEXPORT_BASE wxMessageOutput;
class WXDLLIMPEXP_CORE wxApp;
class WXDLLIMPEXP_BASE wxAppTraits;
class WXDLLIMPEXP_BASE wxCmdLineParser;
class WXDLLIMPEXP_BASE wxLog;
class WXDLLIMPEXP_BASE wxMessageOutput;
// ----------------------------------------------------------------------------
// typedefs
@ -57,7 +57,7 @@ enum
// VS: Fullscreen/framebuffer application needs to choose display mode prior
// to wxWindows initialization. This class holds information about display
// mode. It is used by wxApp::Set/GetDisplayMode.
class WXDLLEXPORT_CORE wxDisplayModeInfo
class WXDLLIMPEXP_CORE wxDisplayModeInfo
{
public:
wxDisplayModeInfo() : m_ok(FALSE) {}
@ -79,7 +79,7 @@ private:
// wxAppConsole: wxApp for non-GUI applications
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxAppConsole : public wxEvtHandler
class WXDLLIMPEXP_BASE wxAppConsole : public wxEvtHandler
{
public:
// ctor and dtor
@ -302,7 +302,7 @@ protected:
#if wxUSE_GUI
class WXDLLEXPORT_CORE wxAppBase : public wxAppConsole
class WXDLLIMPEXP_CORE wxAppBase : public wxAppConsole
{
public:
wxAppBase();
@ -503,7 +503,7 @@ protected:
#endif
#else // !GUI
// 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
@ -516,7 +516,7 @@ protected:
// 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
// not wxApp)
WXDLLEXPORT_DATA_BASE(extern wxApp*) wxTheApp;
WXDLLIMPEXP_DATA_BASE(extern wxApp*) wxTheApp;
// ----------------------------------------------------------------------------
// global functions
@ -526,13 +526,13 @@ WXDLLEXPORT_DATA_BASE(extern wxApp*) wxTheApp;
// ------------------------------------------------------
// Force an exit from main loop
extern void WXDLLEXPORT_BASE wxExit();
extern void WXDLLIMPEXP_BASE wxExit();
// Yield to other apps/messages
extern bool WXDLLEXPORT_BASE wxYield();
extern bool WXDLLIMPEXP_BASE wxYield();
// Yield to other apps/messages
extern void WXDLLEXPORT_BASE wxWakeUpIdle();
extern void WXDLLIMPEXP_BASE wxWakeUpIdle();
// ----------------------------------------------------------------------------
// 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
// object. Convoluted, but necessary.
class WXDLLEXPORT_BASE wxAppInitializer
class WXDLLIMPEXP_BASE wxAppInitializer
{
public:
wxAppInitializer(wxAppInitializerFunction fn)

2
include/wx/build.h
View File

@ -14,7 +14,7 @@
#include "wx/version.h"
class WXDLLEXPORT_BASE wxAppConsole;
class WXDLLIMPEXP_BASE wxAppConsole;
// ----------------------------------------------------------------------------
// 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
};
class WXDLLEXPORT_BASE wxClientData
class WXDLLIMPEXP_BASE wxClientData
{
public:
wxClientData() { }
virtual ~wxClientData() { }
};
class WXDLLEXPORT_BASE wxStringClientData : public wxClientData
class WXDLLIMPEXP_BASE wxStringClientData : public wxClientData
{
public:
wxStringClientData() : m_data() { }
@ -57,7 +57,7 @@ private:
// NOTE: This functionality is currently duplicated in wxEvtHandler in order
// to avoid having more than one vtable in that class hierarchy.
class WXDLLEXPORT_BASE wxClientDataContainer
class WXDLLIMPEXP_BASE wxClientDataContainer
{
public:
wxClientDataContainer();

6
include/wx/cmdline.h
View File

@ -22,7 +22,7 @@
#if wxUSE_CMDLINE_PARSER
class WXDLLEXPORT_BASE wxDateTime;
class WXDLLIMPEXP_BASE wxDateTime;
// ----------------------------------------------------------------------------
// constants
@ -91,7 +91,7 @@ struct wxCmdLineEntryDesc
// 4. use GetXXX() to retrieve the parsed info
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxCmdLineParser
class WXDLLIMPEXP_BASE wxCmdLineParser
{
public:
// ctors and initializers
@ -219,7 +219,7 @@ private:
// this function is always available (even if !wxUSE_CMDLINE_PARSER) because it
// is used by wxWin itself under Windows
class WXDLLEXPORT_BASE wxCmdLineParser
class WXDLLIMPEXP_BASE wxCmdLineParser
{
public:
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).
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxConfigBase
class WXDLLIMPEXP_BASE wxConfigBase
{
public:
// constants
@ -293,7 +293,7 @@ private:
// you work in the entry directory and the path is automatically restored
// when the function returns
// Taken out of wxConfig since not all compilers can cope with nested classes.
class WXDLLEXPORT_BASE wxConfigPathChanger
class WXDLLIMPEXP_BASE wxConfigPathChanger
{
public:
// ctor/dtor do path changing/restorin
@ -339,12 +339,12 @@ private:
'_' 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
*/
WXDLLEXPORT_BASE void wxSplitPath(wxArrayString& aParts, const wxChar *sz);
WXDLLIMPEXP_BASE void wxSplitPath(wxArrayString& aParts, const wxChar *sz);
#endif

88
include/wx/datetime.h
View File

@ -26,9 +26,9 @@
#include "wx/longlong.h"
class WXDLLEXPORT_BASE wxDateTime;
class WXDLLEXPORT_BASE wxTimeSpan;
class WXDLLEXPORT_BASE wxDateSpan;
class WXDLLIMPEXP_BASE wxDateTime;
class WXDLLIMPEXP_BASE wxTimeSpan;
class WXDLLIMPEXP_BASE wxDateSpan;
// 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
@ -117,16 +117,16 @@ class WXDLLEXPORT_BASE wxDateSpan;
// argument for arguments of type wxDateTime; it is also returned by all
// functions returning wxDateTime on failure (this is why it is also called
// 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
// ----------------------------------------------------------------------------
// wxDateTime represents an absolute moment in the time
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxDateTime
class WXDLLIMPEXP_BASE wxDateTime
{
public:
// types
@ -398,7 +398,7 @@ public:
// a class representing a time zone: basicly, this is just an offset
// (in seconds) from GMT
class WXDLLEXPORT_BASE TimeZone
class WXDLLIMPEXP_BASE TimeZone
{
public:
TimeZone(TZ tz);
@ -418,7 +418,7 @@ public:
// NB: this struct should always be kept normalized (i.e. mon should
// be < 12, 1 <= day <= 31 &c), so use AddMonths(), AddDays()
// instead of modifying the member fields directly!
struct WXDLLEXPORT_BASE Tm
struct WXDLLIMPEXP_BASE Tm
{
wxDateTime_t msec, sec, min, hour, mday;
Month mon;
@ -1005,7 +1005,7 @@ private:
// objects of that class. See also wxDateSpan.
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxTimeSpan
class WXDLLIMPEXP_BASE wxTimeSpan
{
public:
// constructors
@ -1185,7 +1185,7 @@ private:
// associated with those.
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxDateSpan
class WXDLLIMPEXP_BASE wxDateSpan
{
public:
// constructors
@ -1298,11 +1298,11 @@ WX_DECLARE_EXPORTED_OBJARRAY(wxDateTime, wxDateTimeArray);
// virtual methods to work with the holidays they correspond to.
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxDateTimeHolidayAuthority;
class WXDLLIMPEXP_BASE wxDateTimeHolidayAuthority;
WX_DEFINE_EXPORTED_ARRAY(wxDateTimeHolidayAuthority *, wxHolidayAuthoritiesArray);
class wxDateTimeHolidaysModule;
class WXDLLEXPORT_BASE wxDateTimeHolidayAuthority
class WXDLLIMPEXP_BASE wxDateTimeHolidayAuthority
{
friend class wxDateTimeHolidaysModule;
public:
@ -1347,7 +1347,7 @@ private:
};
// the holidays for this class are all Saturdays and Sundays
class WXDLLEXPORT_BASE wxDateTimeWorkDays : public wxDateTimeHolidayAuthority
class WXDLLIMPEXP_BASE wxDateTimeWorkDays : public wxDateTimeHolidayAuthority
{
protected:
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
inline wxDateTime WXDLLEXPORT_BASE operator+(const wxDateTime& dt,
inline wxDateTime WXDLLIMPEXP_BASE operator+(const wxDateTime& dt,
const wxTimeSpan& ts)
{
return dt.Add(ts);
}
inline wxDateTime WXDLLEXPORT_BASE operator-(const wxDateTime& dt,
inline wxDateTime WXDLLIMPEXP_BASE operator-(const wxDateTime& dt,
const wxTimeSpan& ts)
{
return dt.Subtract(ts);
}
inline wxDateTime WXDLLEXPORT_BASE operator+(const wxDateTime& dt,
inline wxDateTime WXDLLIMPEXP_BASE operator+(const wxDateTime& dt,
const wxDateSpan& ds)
{
return dt.Add(ds);
}
inline wxDateTime WXDLLEXPORT_BASE operator-(const wxDateTime& dt,
inline wxDateTime WXDLLIMPEXP_BASE operator-(const wxDateTime& dt,
const wxDateSpan& ds)
{
return dt.Subtract(ds);
}
inline wxTimeSpan WXDLLEXPORT_BASE operator-(const wxDateTime& dt1,
inline wxTimeSpan WXDLLIMPEXP_BASE operator-(const wxDateTime& dt1,
const wxDateTime& dt2)
{
return dt1.Subtract(dt2);
@ -1421,42 +1421,42 @@ inline wxTimeSpan WXDLLEXPORT_BASE operator-(const wxDateTime& dt1,
// 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") );
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") );
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") );
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") );
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") );
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") );
@ -1470,24 +1470,24 @@ inline bool WXDLLEXPORT_BASE operator!=(const wxDateTime& t1, const wxDateTime&
// arithmetics
// -----------
inline wxTimeSpan WXDLLEXPORT_BASE operator+(const wxTimeSpan& ts1,
inline wxTimeSpan WXDLLIMPEXP_BASE operator+(const wxTimeSpan& ts1,
const wxTimeSpan& ts2)
{
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)
{
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);
}
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);
}
@ -1495,32 +1495,32 @@ inline wxTimeSpan WXDLLEXPORT_BASE operator*(int n, const wxTimeSpan& ts)
// 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();
}
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();
}
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();
}
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();
}
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();
}
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();
}
@ -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
inline WXDLLEXPORT_BASE bool operator==(const wxDateSpan& ds1,
inline WXDLLIMPEXP_BASE bool operator==(const wxDateSpan& ds1,
const wxDateSpan& ds2)
{
return ds1.GetYears() == ds2.GetYears() &&
@ -1541,7 +1541,7 @@ inline WXDLLEXPORT_BASE bool operator==(const wxDateSpan& ds1,
ds1.GetTotalDays() == ds2.GetTotalDays();
}
inline WXDLLEXPORT_BASE bool operator!=(const wxDateSpan& ds1,
inline WXDLLIMPEXP_BASE bool operator!=(const wxDateSpan& ds1,
const wxDateSpan& ds2)
{
return !(ds1 == ds2);
@ -1550,7 +1550,7 @@ inline WXDLLEXPORT_BASE bool operator!=(const wxDateSpan& ds1,
// arithmetics
// -----------
inline WXDLLEXPORT_BASE wxDateSpan operator+(const wxDateSpan& ds1,
inline WXDLLIMPEXP_BASE wxDateSpan operator+(const wxDateSpan& ds1,
const wxDateSpan& ds2)
{
return wxDateSpan(ds1.GetYears() + ds2.GetYears(),
@ -1559,7 +1559,7 @@ inline WXDLLEXPORT_BASE wxDateSpan operator+(const wxDateSpan& ds1,
ds1.GetDays() + ds2.GetDays());
}
inline WXDLLEXPORT_BASE wxDateSpan operator-(const wxDateSpan& ds1,
inline WXDLLIMPEXP_BASE wxDateSpan operator-(const wxDateSpan& ds1,
const wxDateSpan& ds2)
{
return wxDateSpan(ds1.GetYears() - ds2.GetYears(),
@ -1568,12 +1568,12 @@ inline WXDLLEXPORT_BASE wxDateSpan operator-(const wxDateSpan& ds1,
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);
}
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);
}
@ -1588,7 +1588,7 @@ inline WXDLLEXPORT_BASE wxDateSpan operator*(int n, const wxDateSpan& ds)
// 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") );
@ -1596,7 +1596,7 @@ inline WXDLLEXPORT_BASE void wxNextMonth(wxDateTime::Month& m)
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") );
@ -1604,7 +1604,7 @@ inline WXDLLEXPORT_BASE void wxPrevMonth(wxDateTime::Month& m)
: (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") );
@ -1612,7 +1612,7 @@ inline WXDLLEXPORT_BASE void wxNextWDay(wxDateTime::WeekDay& wd)
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") );

4
include/wx/datstrm.h
View File

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

44
include/wx/db.h
View File

@ -123,8 +123,8 @@ enum enumDummy {enumDum1};
*/
const int wxDB_PATH_MAX = 254;
WXDLLEXPORT_DATA_BASE(extern wxChar const *) SQL_LOG_FILENAME;
WXDLLEXPORT_DATA_BASE(extern wxChar const *) SQL_CATALOG_FILENAME;
WXDLLIMPEXP_DATA_BASE(extern wxChar const *) SQL_LOG_FILENAME;
WXDLLIMPEXP_DATA_BASE(extern wxChar const *) SQL_CATALOG_FILENAME;
// Database Globals
const int DB_TYPE_NAME_LEN = 40;
@ -269,7 +269,7 @@ enum wxODBC_ERRORS
#define SQL_MAX_AUTHSTR_LEN MAXNAME
#endif
class WXDLLEXPORT_BASE wxDbConnectInf
class WXDLLIMPEXP_BASE wxDbConnectInf
{
private:
bool freeHenvOnDestroy;
@ -331,7 +331,7 @@ class WXDLLEXPORT_BASE wxDbConnectInf
}; // class wxDbConnectInf
struct WXDLLEXPORT_BASE wxDbSqlTypeInfo
struct WXDLLIMPEXP_BASE wxDbSqlTypeInfo
{
wxString TypeName;
SWORD FsqlType;
@ -342,7 +342,7 @@ struct WXDLLEXPORT_BASE wxDbSqlTypeInfo
};
class WXDLLEXPORT_BASE wxDbColFor
class WXDLLIMPEXP_BASE wxDbColFor
{
public:
wxString s_Field; // Formated String for Output
@ -361,7 +361,7 @@ public:
};
class WXDLLEXPORT_BASE wxDbColInf
class WXDLLIMPEXP_BASE wxDbColInf
{
public:
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:
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:
wxChar catalog[128+1];
@ -459,11 +459,11 @@ enum wxDBMS
// will overwrite the errors of the previously destroyed wxDb object in
// this variable.
WXDLLEXPORT_DATA_BASE(extern wxChar)
WXDLLIMPEXP_DATA_BASE(extern wxChar)
DBerrorList[DB_MAX_ERROR_HISTORY][DB_MAX_ERROR_MSG_LEN];
class WXDLLEXPORT_BASE wxDb
class WXDLLIMPEXP_BASE wxDb
{
private:
bool dbIsOpen;
@ -702,15 +702,15 @@ class wxTablesInUse : public wxObject
// 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
// completed.
wxDb WXDLLEXPORT_BASE *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCursors=(bool)wxODBC_FWD_ONLY_CURSORS);
bool WXDLLEXPORT_BASE wxDbFreeConnection(wxDb *pDb);
void WXDLLEXPORT_BASE wxDbCloseConnections(void);
int WXDLLEXPORT_BASE wxDbConnectionsInUse(void);
wxDb WXDLLIMPEXP_BASE *wxDbGetConnection(wxDbConnectInf *pDbConfig, bool FwdOnlyCursors=(bool)wxODBC_FWD_ONLY_CURSORS);
bool WXDLLIMPEXP_BASE wxDbFreeConnection(wxDb *pDb);
void WXDLLIMPEXP_BASE wxDbCloseConnections(void);
int WXDLLIMPEXP_BASE wxDbConnectionsInUse(void);
// Writes a message to the wxLog window (stdout usually) when an internal error
// situation occurs. This function only works in DEBUG builds
const wxChar* WXDLLEXPORT_BASE
const wxChar* WXDLLIMPEXP_BASE
wxDbLogExtendedErrorMsg(const wxChar *userText,
wxDb *pDb,
const wxChar *ErrFile,
@ -718,7 +718,7 @@ wxDbLogExtendedErrorMsg(const wxChar *userText,
// 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);
@ -732,7 +732,7 @@ int WXDLLEXPORT wxDbCreateDataSource(const wxString &driverName, const wxString
// for a list of available datasources. Call this routine
// the first time using SQL_FETCH_FIRST. Continue to call it
// 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,
SWORD DsDescMax, UWORD direction = SQL_FETCH_NEXT);
@ -765,15 +765,15 @@ typedef wxTablesInUse CstructTablesInUse;
#endif
// 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);
bool WXDLLEXPORT_BASE FreeDbConnection(wxDB *pDb);
void WXDLLEXPORT_BASE CloseDbConnections(void);
int WXDLLEXPORT_BASE NumberDbConnectionsInUse(void);
bool WXDLLIMPEXP_BASE FreeDbConnection(wxDB *pDb);
void WXDLLIMPEXP_BASE CloseDbConnections(void);
int WXDLLIMPEXP_BASE NumberDbConnectionsInUse(void);
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,
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
// source, exchange data between the data source and the C++
// object, and so on.
class WXDLLEXPORT_BASE wxDbColDef
class WXDLLIMPEXP_BASE wxDbColDef
{
public:
wxChar ColName[DB_MAX_COLUMN_NAME_LEN+1]; // Column Name
@ -77,7 +77,7 @@ public:
}; // wxDbColDef
class WXDLLEXPORT_BASE wxDbColDataPtr
class WXDLLIMPEXP_BASE wxDbColDataPtr
{
public:
void *PtrDataObj;
@ -87,7 +87,7 @@ public:
// This structure is used when creating secondary indexes.
class WXDLLEXPORT_BASE wxDbIdxDef
class WXDLLIMPEXP_BASE wxDbIdxDef
{
public:
wxChar ColName[DB_MAX_COLUMN_NAME_LEN+1];
@ -95,7 +95,7 @@ public:
}; // wxDbIdxDef
class WXDLLEXPORT_BASE wxDbTable
class WXDLLIMPEXP_BASE wxDbTable
{
private:
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 wxDDEConnection;
WX_DECLARE_USER_EXPORTED_LIST(wxDDEClient, wxDDEClientList, WXDLLEXPORT_BASE);
WX_DECLARE_USER_EXPORTED_LIST(wxDDEServer, wxDDEServerList, WXDLLEXPORT_BASE);
WX_DECLARE_USER_EXPORTED_LIST(wxDDEConnection, wxDDEConnectionList, WXDLLEXPORT_BASE);
WX_DECLARE_USER_EXPORTED_LIST(wxDDEClient, wxDDEClientList, WXDLLIMPEXP_BASE);
WX_DECLARE_USER_EXPORTED_LIST(wxDDEServer, wxDDEServerList, WXDLLIMPEXP_BASE);
WX_DECLARE_USER_EXPORTED_LIST(wxDDEConnection, wxDDEConnectionList, WXDLLIMPEXP_BASE);
#if defined(__WXMSW__)
#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
szMsg - optional message explaining the reason
*/
extern void WXDLLEXPORT_BASE wxOnAssert(const wxChar *szFile,
extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *szFile,
int nLine,
const wxChar *szCond,
const wxChar *szMsg = NULL);
// call this function to break into the debugger unconditionally (assuming
// 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
//
// note using "int" and not "bool" for cond to avoid VC++ warnings about
// implicit conversions when doing "wxAssert( pointer )" and also use of
// "!!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,
int nLine,
const wxChar *szCond,
@ -112,7 +112,7 @@
//
// NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and shouldn't be
// used any longer
extern bool WXDLLEXPORT_BASE wxAssertIsEqual(int x, int y);
extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
#else
#define wxTrap()
@ -124,7 +124,7 @@
// Use of wxFalse instead of FALSE suppresses compiler warnings about testing
// constant expression
WXDLLEXPORT_DATA_BASE(extern const bool) wxFalse;
WXDLLIMPEXP_DATA_BASE(extern const bool) wxFalse;
#define wxAssertFailure wxFalse
// 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
// returns false otherwise
#ifdef __WXMAC__
extern bool WXDLLEXPORT_BASE wxIsDebuggerRunning();
extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
#else // !Mac
inline bool wxIsDebuggerRunning() { return false; }
#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
// declaration if using it or to nothing at all if we don't use wxWin as DLL
#ifdef WXMAKINGDLL_BASE
#define WXDLLEXPORT_BASE WXEXPORT
#define WXDLLEXPORT_DATA_BASE(type) WXEXPORT type
#define WXDLLIMPEXP_BASE WXEXPORT
#define WXDLLIMPEXP_DATA_BASE(type) WXEXPORT type
#elif defined(WXUSINGDLL_BASE)
#define WXDLLEXPORT_BASE WXIMPORT
#define WXDLLEXPORT_DATA_BASE(type) WXIMPORT type
#define WXDLLIMPEXP_BASE WXIMPORT
#define WXDLLIMPEXP_DATA_BASE(type) WXIMPORT type
#else // not making nor using DLL
#define WXDLLEXPORT_BASE
#define WXDLLEXPORT_DATA_BASE(type) type
#define WXDLLIMPEXP_BASE
#define WXDLLIMPEXP_DATA_BASE(type) type
#endif
#ifdef WXMAKINGDLL_CORE
#define WXDLLEXPORT_CORE WXEXPORT
#define WXDLLEXPORT_DATA_CORE(type) WXEXPORT type
#define WXDLLIMPEXP_CORE WXEXPORT
#define WXDLLIMPEXP_DATA_CORE(type) WXEXPORT type
#elif defined(WXUSINGDLL_CORE)
#define WXDLLEXPORT_CORE WXIMPORT
#define WXDLLEXPORT_DATA_CORE(type) WXIMPORT type
#define WXDLLIMPEXP_CORE WXIMPORT
#define WXDLLIMPEXP_DATA_CORE(type) WXIMPORT type
#else // not making nor using DLL
#define WXDLLEXPORT_CORE
#define WXDLLEXPORT_DATA_CORE(type) type
#define WXDLLIMPEXP_CORE
#define WXDLLIMPEXP_DATA_CORE(type) type
#endif
// for backwards compatibility, define suffix-less versions too
#define WXDLLEXPORT WXDLLEXPORT_CORE
#define WXDLLEXPORT_DATA WXDLLEXPORT_DATA_CORE
#define WXDLLEXPORT WXDLLIMPEXP_CORE
#define WXDLLEXPORT_DATA WXDLLIMPEXP_DATA_CORE
// ----------------------------------------------------------------------------
// Very common macros

6
include/wx/dir.h
View File

@ -49,7 +49,7 @@ enum wxDirTraverseResult
// wxDirTraverser: helper class for wxDir::Traverse()
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxDirTraverser
class WXDLLIMPEXP_BASE wxDirTraverser
{
public:
// called for each file found by wxDir::Traverse()
@ -79,9 +79,9 @@ public:
// 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:
// 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
class, it simply serves as a namespace for its static member functions.
*/
class WXDLLEXPORT_BASE wxDllLoader
class WXDLLIMPEXP_BASE wxDllLoader
{
public:
/*
@ -130,7 +130,7 @@ private:
// wxDynamicLibrary - friendly interface to wxDllLoader
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxDynamicLibrary
class WXDLLIMPEXP_BASE wxDynamicLibrary
{
public:
// ctors
@ -185,7 +185,7 @@ private:
// wxLibrary
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxLibrary : public wxObject
class WXDLLIMPEXP_BASE wxLibrary : public wxObject
{
public:
wxLibrary(wxDllType handle);
@ -210,7 +210,7 @@ public:
// wxLibraries
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxLibraries
class WXDLLIMPEXP_BASE wxLibraries
{
public:
wxLibraries();
@ -229,7 +229,7 @@ protected:
// Global variables
// ----------------------------------------------------------------------------
extern WXDLLEXPORT_DATA_BASE(wxLibraries) wxTheLibraries;
extern WXDLLIMPEXP_DATA_BASE(wxLibraries) wxTheLibraries;
// ----------------------------------------------------------------------------
// Interesting defines

10
include/wx/dynload.h
View File

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

116
include/wx/event.h
View File

@ -31,12 +31,12 @@
// forward declarations
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxList;
class WXDLLIMPEXP_BASE wxList;
#if wxUSE_GUI
class WXDLLEXPORT_CORE wxDC;
class WXDLLEXPORT_CORE wxMenu;
class WXDLLEXPORT_CORE wxWindow;
class WXDLLIMPEXP_CORE wxDC;
class WXDLLIMPEXP_CORE wxMenu;
class WXDLLIMPEXP_CORE wxWindow;
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
@ -91,14 +91,14 @@ typedef int wxEventType;
#define DECLARE_EXPORTED_EVENT_TYPE(expdecl, name, value) \
extern expdecl const wxEventType name;
#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) \
DECLARE_EXPORTED_EVENT_TYPE(/* */, name, value)
#define DEFINE_EVENT_TYPE(name) const wxEventType name = wxNewEventType();
#define DEFINE_LOCAL_EVENT_TYPE(name) DEFINE_EVENT_TYPE(name)
// 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
@ -111,9 +111,9 @@ BEGIN_DECLARE_EVENT_TYPES()
#else // !WXWIN_COMPATIBILITY_EVENT_TYPES
// it is important to still have these as constants to avoid
// initialization order related problems
DECLARE_EXPORTED_EVENT_TYPE(WXDLLEXPORT_BASE, wxEVT_NULL, 0)
DECLARE_EXPORTED_EVENT_TYPE(WXDLLEXPORT_BASE, wxEVT_FIRST, 10000)
DECLARE_EXPORTED_EVENT_TYPE(WXDLLEXPORT_BASE, wxEVT_USER_FIRST, wxEVT_FIRST + 2000)
DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_NULL, 0)
DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_FIRST, 10000)
DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_BASE, wxEVT_USER_FIRST, wxEVT_FIRST + 2000)
#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
DECLARE_EVENT_TYPE(wxEVT_COMMAND_BUTTON_CLICKED, 1)
@ -145,7 +145,7 @@ BEGIN_DECLARE_EVENT_TYPES()
DECLARE_EVENT_TYPE(wxEVT_COMMAND_SPINCTRL_UPDATED, 18)
// 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)
// Mouse event types
@ -249,7 +249,7 @@ BEGIN_DECLARE_EVENT_TYPES()
DECLARE_EVENT_TYPE(wxEVT_MEASURE_ITEM, 436)
DECLARE_EVENT_TYPE(wxEVT_COMPARE_ITEM, 437)
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_SIZING, 441)
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
#if !WXWIN_COMPATIBILITY_EVENT_TYPES
extern const wxEventType WXDLLEXPORT_CORE wxEVT_COMMAND_TEXT_UPDATED;
extern const wxEventType WXDLLIMPEXP_CORE wxEVT_COMMAND_TEXT_UPDATED;
#endif
#if WXWIN_COMPATIBILITY
@ -341,7 +341,7 @@ END_DECLARE_EVENT_TYPES()
*
*/
class WXDLLEXPORT_BASE wxEvent : public wxObject
class WXDLLIMPEXP_BASE wxEvent : public wxObject
{
private:
wxEvent& operator=(const wxEvent&);
@ -411,7 +411,7 @@ private:
wxEVT_COMMAND_TOGGLEBUTTON_CLICKED
*/
class WXDLLEXPORT_CORE wxCommandEvent : public wxEvent
class WXDLLIMPEXP_CORE wxCommandEvent : public wxEvent
{
private:
wxCommandEvent& operator=(const wxCommandEvent& event);
@ -474,7 +474,7 @@ private:
// this class adds a possibility to react (from the user) code to a control
// notification: allow or veto the operation being reported.
class WXDLLEXPORT_CORE wxNotifyEvent : public wxCommandEvent
class WXDLLIMPEXP_CORE wxNotifyEvent : public wxCommandEvent
{
public:
wxNotifyEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)
@ -517,7 +517,7 @@ private:
wxEVT_SCROLL_ENDSCROLL
*/
class WXDLLEXPORT_CORE wxScrollEvent : public wxCommandEvent
class WXDLLIMPEXP_CORE wxScrollEvent : public wxCommandEvent
{
public:
wxScrollEvent(wxEventType commandType = wxEVT_NULL,
@ -547,7 +547,7 @@ private:
wxEVT_SCROLLWIN_THUMBRELEASE
*/
class WXDLLEXPORT_CORE wxScrollWinEvent : public wxEvent
class WXDLLIMPEXP_CORE wxScrollWinEvent : public wxEvent
{
public:
wxScrollWinEvent(wxEventType commandType = wxEVT_NULL,
@ -610,7 +610,7 @@ enum
wxMOUSE_BTN_RIGHT = 2
};
class WXDLLEXPORT_CORE wxMouseEvent : public wxEvent
class WXDLLIMPEXP_CORE wxMouseEvent : public wxEvent
{
public:
wxMouseEvent(wxEventType mouseType = wxEVT_NULL);
@ -780,7 +780,7 @@ private:
wxEVT_SET_CURSOR
*/
class WXDLLEXPORT_CORE wxSetCursorEvent : public wxEvent
class WXDLLIMPEXP_CORE wxSetCursorEvent : public wxEvent
{
public:
wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0)
@ -821,7 +821,7 @@ private:
wxEVT_KEY_UP
*/
class WXDLLEXPORT_CORE wxKeyEvent : public wxEvent
class WXDLLIMPEXP_CORE wxKeyEvent : public wxEvent
{
public:
wxKeyEvent(wxEventType keyType = wxEVT_NULL);
@ -927,7 +927,7 @@ private:
wxEVT_SIZE
*/
class WXDLLEXPORT_CORE wxSizeEvent : public wxEvent
class WXDLLIMPEXP_CORE wxSizeEvent : public wxEvent
{
public:
wxSizeEvent() : wxEvent(0, wxEVT_SIZE)
@ -964,7 +964,7 @@ private:
wxEVT_MOVE
*/
class WXDLLEXPORT_CORE wxMoveEvent : public wxEvent
class WXDLLIMPEXP_CORE wxMoveEvent : public wxEvent
{
public:
wxMoveEvent()
@ -1004,10 +1004,10 @@ private:
#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__))
// 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
class WXDLLEXPORT_CORE wxPaintEvent : public wxEvent
class WXDLLIMPEXP_CORE wxPaintEvent : public wxEvent
{
public:
wxPaintEvent(int Id = 0)
@ -1032,7 +1032,7 @@ private:
DECLARE_DYNAMIC_CLASS(wxPaintEvent)
};
class WXDLLEXPORT_CORE wxNcPaintEvent : public wxEvent
class WXDLLIMPEXP_CORE wxNcPaintEvent : public wxEvent
{
public:
wxNcPaintEvent(int winid = 0)
@ -1050,7 +1050,7 @@ private:
wxEVT_ERASE_BACKGROUND
*/
class WXDLLEXPORT_CORE wxEraseEvent : public wxEvent
class WXDLLIMPEXP_CORE wxEraseEvent : public wxEvent
{
private:
wxEraseEvent& operator=(const wxEraseEvent& event);
@ -1082,7 +1082,7 @@ private:
wxEVT_KILL_FOCUS
*/
class WXDLLEXPORT_CORE wxFocusEvent : public wxEvent
class WXDLLIMPEXP_CORE wxFocusEvent : public wxEvent
{
private:
wxFocusEvent& operator=(const wxFocusEvent& event);
@ -1113,7 +1113,7 @@ private:
// wxChildFocusEvent notifies the parent that a child has got the focus: unlike
// wxFocusEvent it is propgated upwards the window chain
class WXDLLEXPORT_CORE wxChildFocusEvent : public wxCommandEvent
class WXDLLIMPEXP_CORE wxChildFocusEvent : public wxCommandEvent
{
public:
wxChildFocusEvent(wxWindow *win = NULL);
@ -1132,7 +1132,7 @@ private:
wxEVT_ACTIVATE_APP
*/
class WXDLLEXPORT_CORE wxActivateEvent : public wxEvent
class WXDLLIMPEXP_CORE wxActivateEvent : public wxEvent
{
public:
wxActivateEvent(wxEventType type = wxEVT_NULL, bool active = TRUE, int Id = 0)
@ -1158,7 +1158,7 @@ private:
wxEVT_INIT_DIALOG
*/
class WXDLLEXPORT_CORE wxInitDialogEvent : public wxEvent
class WXDLLIMPEXP_CORE wxInitDialogEvent : public wxEvent
{
public:
wxInitDialogEvent(int Id = 0)
@ -1178,7 +1178,7 @@ private:
wxEVT_MENU_HIGHLIGHT,
*/
class WXDLLEXPORT_CORE wxMenuEvent : public wxEvent
class WXDLLIMPEXP_CORE wxMenuEvent : public wxEvent
{
public:
wxMenuEvent(wxEventType type = wxEVT_NULL, int winid = 0)
@ -1209,7 +1209,7 @@ private:
wxEVT_QUERY_END_SESSION
*/
class WXDLLEXPORT_CORE wxCloseEvent : public wxEvent
class WXDLLIMPEXP_CORE wxCloseEvent : public wxEvent
{
public:
wxCloseEvent(wxEventType type = wxEVT_NULL, int winid = 0)
@ -1276,7 +1276,7 @@ private:
wxEVT_SHOW
*/
class WXDLLEXPORT_CORE wxShowEvent : public wxEvent
class WXDLLIMPEXP_CORE wxShowEvent : public wxEvent
{
public:
wxShowEvent(int winid = 0, bool show = FALSE)
@ -1302,7 +1302,7 @@ private:
wxEVT_ICONIZE
*/
class WXDLLEXPORT_CORE wxIconizeEvent : public wxEvent
class WXDLLIMPEXP_CORE wxIconizeEvent : public wxEvent
{
public:
wxIconizeEvent(int winid = 0, bool iconized = TRUE)
@ -1327,7 +1327,7 @@ private:
wxEVT_MAXIMIZE
*/
class WXDLLEXPORT_CORE wxMaximizeEvent : public wxEvent
class WXDLLIMPEXP_CORE wxMaximizeEvent : public wxEvent
{
public:
wxMaximizeEvent(int winid = 0)
@ -1365,7 +1365,7 @@ enum
wxJOY_BUTTON4 = 8
};
class WXDLLEXPORT_CORE wxJoystickEvent : public wxEvent
class WXDLLIMPEXP_CORE wxJoystickEvent : public wxEvent
{
public:
wxPoint m_pos;
@ -1443,7 +1443,7 @@ private:
wxEVT_DROP_FILES
*/
class WXDLLEXPORT_CORE wxDropFilesEvent : public wxEvent
class WXDLLIMPEXP_CORE wxDropFilesEvent : public wxEvent
{
private:
wxDropFilesEvent& operator=(const wxDropFilesEvent& event);
@ -1496,7 +1496,7 @@ private:
wxEVT_UPDATE_UI
*/
class WXDLLEXPORT_CORE wxUpdateUIEvent : public wxCommandEvent
class WXDLLIMPEXP_CORE wxUpdateUIEvent : public wxCommandEvent
{
public:
wxUpdateUIEvent(wxWindowID commandId = 0)
@ -1548,7 +1548,7 @@ private:
*/
// TODO: shouldn't all events record the window ID?
class WXDLLEXPORT_CORE wxSysColourChangedEvent : public wxEvent
class WXDLLIMPEXP_CORE wxSysColourChangedEvent : public wxEvent
{
public:
wxSysColourChangedEvent()
@ -1567,7 +1567,7 @@ private:
(even if it released the capture itself).
*/
class WXDLLEXPORT_CORE wxMouseCaptureChangedEvent : public wxEvent
class WXDLLIMPEXP_CORE wxMouseCaptureChangedEvent : public wxEvent
{
private:
wxMouseCaptureChangedEvent operator=(const wxMouseCaptureChangedEvent& event);
@ -1595,7 +1595,7 @@ private:
/*
wxEVT_DISPLAY_CHANGED
*/
class WXDLLEXPORT_CORE wxDisplayChangedEvent : public wxEvent
class WXDLLIMPEXP_CORE wxDisplayChangedEvent : public wxEvent
{
private:
DECLARE_DYNAMIC_CLASS(wxDisplayChangedEvent)
@ -1612,7 +1612,7 @@ public:
wxEVT_PALETTE_CHANGED
*/
class WXDLLEXPORT_CORE wxPaletteChangedEvent : public wxEvent
class WXDLLIMPEXP_CORE wxPaletteChangedEvent : public wxEvent
{
private:
wxPaletteChangedEvent& operator=(const wxPaletteChangedEvent& event);
@ -1645,7 +1645,7 @@ private:
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:
wxQueryNewPaletteEvent(wxWindowID winid = 0)
@ -1675,7 +1675,7 @@ private:
wxEVT_NAVIGATION_KEY
*/
// 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:
wxNavigationKeyEvent& operator=(const wxNavigationKeyEvent& event);
@ -1746,7 +1746,7 @@ private:
wxEVT_DESTROY
*/
class WXDLLEXPORT_CORE wxWindowCreateEvent : public wxCommandEvent
class WXDLLIMPEXP_CORE wxWindowCreateEvent : public wxCommandEvent
{
public:
wxWindowCreateEvent(wxWindow *win = NULL);
@ -1759,7 +1759,7 @@ private:
DECLARE_DYNAMIC_CLASS(wxWindowCreateEvent)
};
class WXDLLEXPORT_CORE wxWindowDestroyEvent : public wxCommandEvent
class WXDLLIMPEXP_CORE wxWindowDestroyEvent : public wxCommandEvent
{
public:
wxWindowDestroyEvent(wxWindow *win = NULL);
@ -1778,7 +1778,7 @@ private:
wxEVT_DETAILED_HELP
*/
class WXDLLEXPORT_CORE wxHelpEvent : public wxCommandEvent
class WXDLLIMPEXP_CORE wxHelpEvent : public wxCommandEvent
{
public:
wxHelpEvent(wxEventType type = wxEVT_NULL,
@ -1825,7 +1825,7 @@ private:
wxEVT_CONTEXT_MENU
*/
class WXDLLEXPORT_CORE wxContextMenuEvent : public wxCommandEvent
class WXDLLIMPEXP_CORE wxContextMenuEvent : public wxCommandEvent
{
public:
wxContextMenuEvent(wxEventType type = wxEVT_NULL,
@ -1857,7 +1857,7 @@ private:
wxEVT_IDLE
*/
class WXDLLEXPORT_CORE wxIdleEvent : public wxEvent
class WXDLLIMPEXP_CORE wxIdleEvent : public wxEvent
{
public:
wxIdleEvent()
@ -1906,7 +1906,7 @@ typedef void (wxObject::*wxObjectEventFunction)(wxEvent&);
// we have to keep both versions
#if WXWIN_COMPATIBILITY_EVENT_TYPES
struct WXDLLEXPORT_BASE wxEventTableEntry
struct WXDLLIMPEXP_BASE wxEventTableEntry
{
// For some reason, this can't be wxEventType, or VC++ complains.
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
// entries
struct WXDLLEXPORT_BASE wxEventTableEntryBase
struct WXDLLIMPEXP_BASE wxEventTableEntryBase
{
private:
wxEventTableEntryBase& operator=(const wxEventTableEntryBase& event);
@ -1956,7 +1956,7 @@ public:
};
// 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,
wxObjectEventFunction fn, wxObject *data)
@ -1973,10 +1973,10 @@ struct WXDLLEXPORT_BASE wxEventTableEntry : public wxEventTableEntryBase
const int& m_eventType;
};
class WXDLLEXPORT_BASE wxEvtHandler;
class WXDLLIMPEXP_BASE wxEvtHandler;
// 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,
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}
// ----------------------------------------------------------------------------
struct WXDLLEXPORT_BASE wxEventTable
struct WXDLLIMPEXP_BASE wxEventTable
{
const wxEventTable *baseTable; // base event table (next in chain)
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
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxEvtHandler : public wxObject
class WXDLLIMPEXP_BASE wxEvtHandler : public wxObject
{
public:
wxEvtHandler();
@ -2476,9 +2476,9 @@ typedef void (wxEvtHandler::*wxMouseCaptureChangedEventFunction)(wxMouseCaptureC
// for pending event processing - notice that there is intentionally no
// WXDLLEXPORT here
extern WXDLLEXPORT_BASE wxList *wxPendingEvents;
extern WXDLLIMPEXP_BASE wxList *wxPendingEvents;
#if wxUSE_THREADS
extern WXDLLEXPORT_BASE wxCriticalSection *wxPendingEventsLocker;
extern WXDLLIMPEXP_BASE wxCriticalSection *wxPendingEventsLocker;
#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.
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFFile
class WXDLLIMPEXP_BASE wxFFile
{
public:
// 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.
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFile
class WXDLLIMPEXP_BASE wxFile
{
public:
// more file constants
@ -150,7 +150,7 @@ private:
// you call neither of them, dtor will call Discard().
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxTempFile
class WXDLLIMPEXP_BASE wxTempFile
{
public:
// ctors

10
include/wx/fileconf.h
View File

@ -92,12 +92,12 @@
(it's on by default, the current status can be retrieved with
IsExpandingEnvVars function).
*/
class WXDLLEXPORT_BASE wxFileConfigGroup;
class WXDLLEXPORT_BASE wxFileConfigEntry;
class WXDLLEXPORT_BASE wxFileConfigLineList;
class WXDLLEXPORT_BASE wxInputStream;
class WXDLLIMPEXP_BASE wxFileConfigGroup;
class WXDLLIMPEXP_BASE wxFileConfigEntry;
class WXDLLIMPEXP_BASE wxFileConfigLineList;
class WXDLLIMPEXP_BASE wxInputStream;
class WXDLLEXPORT_BASE wxFileConfig : public wxConfigBase
class WXDLLIMPEXP_BASE wxFileConfig : public wxConfigBase
{
public:
// 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)
#include <sys/stat.h>
#endif
WXDLLEXPORT_BASE int wxStat( const wxChar *file_name, wxStructStat *buf );
WXDLLEXPORT_BASE int wxAccess( const wxChar *pathname, int mode );
WXDLLEXPORT_BASE int wxOpen( const wxChar *pathname, int flags, mode_t mode );
WXDLLIMPEXP_BASE int wxStat( const wxChar *file_name, wxStructStat *buf );
WXDLLIMPEXP_BASE int wxAccess( const wxChar *pathname, int mode );
WXDLLIMPEXP_BASE int wxOpen( const wxChar *pathname, int flags, mode_t mode );
#else
#define wxOpen open
#define wxStat stat
@ -168,98 +168,98 @@ WXDLLEXPORT_BASE int wxOpen( const wxChar *pathname, int flags, mode_t mode );
// ----------------------------------------------------------------------------
// 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)
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
WXDLLEXPORT_BASE wxChar* wxFileNameFromPath(wxChar *path);
WXDLLEXPORT_BASE wxString wxFileNameFromPath(const wxString& path);
WXDLLIMPEXP_BASE wxChar* wxFileNameFromPath(wxChar *path);
WXDLLIMPEXP_BASE wxString wxFileNameFromPath(const wxString& path);
// Get directory
WXDLLEXPORT_BASE wxString wxPathOnly(const wxString& path);
WXDLLIMPEXP_BASE wxString wxPathOnly(const wxString& path);
// 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
WXDLLEXPORT_BASE void wxStripExtension(wxChar *buffer);
WXDLLEXPORT_BASE void wxStripExtension(wxString& buffer);
WXDLLIMPEXP_BASE void wxStripExtension(wxChar *buffer);
WXDLLIMPEXP_BASE void wxStripExtension(wxString& buffer);
// Get a temporary filename
WXDLLEXPORT_BASE wxChar* wxGetTempFileName(const wxString& prefix, wxChar *buf = (wxChar *) NULL);
WXDLLEXPORT_BASE bool wxGetTempFileName(const wxString& prefix, wxString& buf);
WXDLLIMPEXP_BASE wxChar* wxGetTempFileName(const wxString& prefix, wxChar *buf = (wxChar *) NULL);
WXDLLIMPEXP_BASE bool wxGetTempFileName(const wxString& prefix, wxString& buf);
// Expand file name (~/ and ${OPENWINHOME}/ stuff)
WXDLLEXPORT_BASE wxChar* wxExpandPath(wxChar *dest, const wxChar *path);
WXDLLEXPORT_BASE bool wxExpandPath(wxString& dest, const wxChar *path);
WXDLLIMPEXP_BASE wxChar* wxExpandPath(wxChar *dest, const wxChar *path);
WXDLLIMPEXP_BASE bool wxExpandPath(wxString& dest, const wxChar *path);
// Contract w.r.t environment (</usr/openwin/lib, OPENWHOME> -> ${OPENWINHOME}/lib)
// and make (if under the home tree) relative to home
// [caller must copy-- volatile]
WXDLLEXPORT_BASE wxChar* wxContractPath(const wxString& filename,
WXDLLIMPEXP_BASE wxChar* wxContractPath(const wxString& filename,
const wxString& envname = wxEmptyString,
const wxString& user = wxEmptyString);
// 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
WXDLLEXPORT_BASE wxChar* wxCopyAbsolutePath(const wxString& path);
WXDLLIMPEXP_BASE wxChar* wxCopyAbsolutePath(const wxString& path);
// Get first file name matching given wild card.
// Flags are reserved for future use.
#define wxFILE 1
#define wxDIR 2
WXDLLEXPORT_BASE wxString wxFindFirstFile(const wxChar *spec, int flags = wxFILE);
WXDLLEXPORT_BASE wxString wxFindNextFile();
WXDLLIMPEXP_BASE wxString wxFindFirstFile(const wxChar *spec, int flags = wxFILE);
WXDLLIMPEXP_BASE wxString wxFindNextFile();
// 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)?
// If dot_special is TRUE, doesn't match * against . (eliminating
// `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
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
WXDLLEXPORT_BASE bool wxCopyFile(const wxString& file1, const wxString& file2,
WXDLLIMPEXP_BASE bool wxCopyFile(const wxString& file1, const wxString& file2,
bool overwrite = TRUE);
// Remove file
WXDLLEXPORT_BASE bool wxRemoveFile(const wxString& file);
WXDLLIMPEXP_BASE bool wxRemoveFile(const wxString& 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.
// If buf is NULL, allocates space using new, else
// copies into buf.
// IMPORTANT NOTE getcwd is know not to work under some releases
// 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
// NB: can't have the same name because of overloading ambiguity
WXDLLEXPORT_BASE wxString wxGetCwd();
WXDLLIMPEXP_BASE wxString wxGetCwd();
// Set working directory
WXDLLEXPORT_BASE bool wxSetWorkingDirectory(const wxString& d);
WXDLLIMPEXP_BASE bool wxSetWorkingDirectory(const wxString& d);
// 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.
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
#define wxDirExists wxPathExists
@ -333,31 +333,31 @@ inline bool wxIsPathSeparator(wxChar c)
}
// 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
// (understands both '/' and '\\')
WXDLLEXPORT_BASE void wxSplitPath(const wxChar *pszFileName,
WXDLLIMPEXP_BASE void wxSplitPath(const wxChar *pszFileName,
wxString *pstrPath,
wxString *pstrName,
wxString *pstrExt);
// 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).
// On non-Windows platform, probably just return the empty string.
WXDLLEXPORT_BASE wxString wxGetOSDirectory();
WXDLLIMPEXP_BASE wxString wxGetOSDirectory();
// Get file modification time
WXDLLEXPORT_BASE time_t wxFileModificationTime(const wxString& filename);
WXDLLIMPEXP_BASE time_t wxFileModificationTime(const wxString& filename);
// ----------------------------------------------------------------------------
// classes
// ----------------------------------------------------------------------------
// Path searching
class WXDLLEXPORT_BASE wxPathList : public wxStringList
class WXDLLIMPEXP_BASE wxPathList : public wxStringList
{
public:
// Adds all paths in environment variable

4
include/wx/filename.h
View File

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

8
include/wx/filesys.h
View File

@ -42,7 +42,7 @@ class wxFileSystem;
// (in 'index.htm#chapter2', 'chapter2' is anchor)
//--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFSFile : public wxObject
class WXDLLIMPEXP_BASE wxFSFile : public wxObject
{
public:
wxFSFile(wxInputStream *stream, const wxString& loc,
@ -103,7 +103,7 @@ private:
// kinds of files (HTPP, FTP, local, tar.gz etc..)
//--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileSystemHandler : public wxObject
class WXDLLIMPEXP_BASE wxFileSystemHandler : public wxObject
{
public:
wxFileSystemHandler() : wxObject() {}
@ -157,7 +157,7 @@ protected:
// kinds of files (HTPP, FTP, local, tar.gz etc..)
//--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileSystem : public wxObject
class WXDLLIMPEXP_BASE wxFileSystem : public wxObject
{
public:
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:
virtual bool CanOpen(const wxString& location);

12
include/wx/fontmap.h
View File

@ -25,13 +25,13 @@
#endif // wxUSE_GUI
#if wxUSE_CONFIG
class WXDLLEXPORT_BASE wxConfigBase;
class WXDLLIMPEXP_BASE wxConfigBase;
#endif // wxUSE_CONFIG
class WXDLLEXPORT_BASE wxFontMapper;
class WXDLLIMPEXP_BASE wxFontMapper;
#if wxUSE_GUI
class WXDLLEXPORT_CORE wxWindow;
class WXDLLIMPEXP_CORE wxWindow;
#endif // wxUSE_GUI
// ============================================================================
@ -47,7 +47,7 @@ class WXDLLEXPORT_BASE wxFontMapper;
// in knowledge of the encodings equivalence
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFontMapperBase
class WXDLLIMPEXP_BASE wxFontMapperBase
{
public:
// constructtor and such
@ -167,7 +167,7 @@ private:
#if wxUSE_GUI
class WXDLLEXPORT_CORE wxFontMapper : public wxFontMapperBase
class WXDLLIMPEXP_CORE wxFontMapper : public wxFontMapperBase
{
public:
// default ctor
@ -240,7 +240,7 @@ private:
#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
//--------------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxInternetFSHandler : public wxFileSystemHandler
class WXDLLIMPEXP_BASE wxInternetFSHandler : public wxFileSystemHandler
{
private:
wxHashTable m_Cache;

6
include/wx/fs_mem.h
View File

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

4
include/wx/fs_zip.h
View File

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

8
include/wx/hash.h
View File

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

16
include/wx/hashmap.h
View File

@ -21,7 +21,7 @@
#include <stddef.h> // for ptrdiff_t
// private
struct WXDLLEXPORT_BASE _wxHashTable_NodeBase
struct WXDLLIMPEXP_BASE _wxHashTable_NodeBase
{
_wxHashTable_NodeBase() : m_nxt(0) {}
@ -33,7 +33,7 @@ struct WXDLLEXPORT_BASE _wxHashTable_NodeBase
};
// private
class WXDLLEXPORT_BASE _wxHashTableBase2
class WXDLLIMPEXP_BASE _wxHashTableBase2
{
public:
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)
// integer types
class WXDLLEXPORT_BASE wxIntegerHash
class WXDLLIMPEXP_BASE wxIntegerHash
{
public:
wxIntegerHash() { }
@ -421,7 +421,7 @@ public:
wxIntegerHash& operator=(const wxIntegerHash&) { return *this; }
};
class WXDLLEXPORT_BASE wxIntegerEqual
class WXDLLIMPEXP_BASE wxIntegerEqual
{
public:
wxIntegerEqual() { }
@ -436,7 +436,7 @@ public:
};
// pointers
class WXDLLEXPORT_BASE wxPointerHash
class WXDLLIMPEXP_BASE wxPointerHash
{
public:
wxPointerHash() { }
@ -448,7 +448,7 @@ public:
wxPointerHash& operator=(const wxPointerHash&) { return *this; }
};
class WXDLLEXPORT_BASE wxPointerEqual
class WXDLLIMPEXP_BASE wxPointerEqual
{
public:
wxPointerEqual() { }
@ -458,7 +458,7 @@ public:
};
// wxString, char*, wxChar*
class WXDLLEXPORT_BASE wxStringHash
class WXDLLIMPEXP_BASE wxStringHash
{
public:
wxStringHash() {}
@ -476,7 +476,7 @@ public:
wxStringHash& operator=(const wxStringHash&) { return *this; }
};
class WXDLLEXPORT_BASE wxStringEqual
class WXDLLIMPEXP_BASE wxStringEqual
{
public:
wxStringEqual() {}

6
include/wx/iconloc.h
View File

@ -18,7 +18,7 @@
// wxIconLocation: describes the location of an icon
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxIconLocationBase
class WXDLLIMPEXP_BASE wxIconLocationBase
{
public:
// ctor takes the name of the file where the icon is
@ -43,7 +43,7 @@ private:
// index of the icon
#if defined(__WXMSW__)
class WXDLLEXPORT_BASE wxIconLocation : public wxIconLocationBase
class WXDLLIMPEXP_BASE wxIconLocation : public wxIconLocationBase
{
public:
// 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
// must be a class because we forward declare it as class
class WXDLLEXPORT_BASE wxIconLocation : public wxIconLocationBase
class WXDLLIMPEXP_BASE wxIconLocation : public wxIconLocationBase
{
public:
wxEXPLICIT wxIconLocation(const wxString& filename = wxEmptyString)

12
include/wx/intl.h
View File

@ -45,9 +45,9 @@
// forward decls
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxLocale;
class WXDLLEXPORT_BASE wxMsgCatalog;
class WXDLLEXPORT_BASE wxLanguageInfoArray;
class WXDLLIMPEXP_BASE wxLocale;
class WXDLLIMPEXP_BASE wxMsgCatalog;
class WXDLLIMPEXP_BASE wxLanguageInfoArray;
// ============================================================================
// locale support
@ -308,7 +308,7 @@ enum wxLanguage
// translation information
// ----------------------------------------------------------------------------
struct WXDLLEXPORT_BASE wxLanguageInfo
struct WXDLLIMPEXP_BASE wxLanguageInfo
{
int Language; // wxLanguage id
wxString CanonicalName; // Canonical name, e.g. fr_FR
@ -362,7 +362,7 @@ enum wxLocaleInitFlags
wxLOCALE_CONV_ENCODING = 0x0002 // convert encoding on the fly?
};
class WXDLLEXPORT_BASE wxLocale
class WXDLLIMPEXP_BASE wxLocale
{
public:
// ctor & dtor
@ -522,7 +522,7 @@ private:
// ----------------------------------------------------------------------------
// 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
inline const wxChar *wxGetTranslation(const wxChar *sz)

10
include/wx/ipcbase.h
View File

@ -42,10 +42,10 @@ enum wxIPCFormat
wxIPC_PRIVATE = 20
};
class WXDLLEXPORT_BASE wxServerBase;
class WXDLLEXPORT_BASE wxClientBase;
class WXDLLIMPEXP_BASE wxServerBase;
class WXDLLIMPEXP_BASE wxClientBase;
class WXDLLEXPORT_BASE wxConnectionBase: public wxObject
class WXDLLIMPEXP_BASE wxConnectionBase: public wxObject
{
DECLARE_CLASS(wxConnectionBase)
@ -129,7 +129,7 @@ private:
};
class WXDLLEXPORT_BASE wxServerBase: public wxObject
class WXDLLIMPEXP_BASE wxServerBase: public wxObject
{
DECLARE_CLASS(wxServerBase)
@ -144,7 +144,7 @@ public:
virtual wxConnectionBase *OnAcceptConnection(const wxString& topic) = 0;
};
class WXDLLEXPORT_BASE wxClientBase: public wxObject
class WXDLLIMPEXP_BASE wxClientBase: public wxObject
{
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
// (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;
// 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
// resolve ambiguity which we would otherwise have with wxStringList::Find() and
// wxList::Find(const char *).
class WXDLLEXPORT_BASE wxListKey
class WXDLLIMPEXP_BASE wxListKey
{
public:
// implicit ctors
@ -129,11 +129,11 @@ private:
// 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;
public:
@ -193,9 +193,9 @@ private:
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()
private:
// common part of all ctors
@ -515,9 +515,9 @@ private:
// 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:
#ifdef wxWARN_COMPAT_LIST_USE
@ -545,9 +545,9 @@ private:
// 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:
// ctors and such

34
include/wx/log.h
View File

@ -25,9 +25,9 @@
// ----------------------------------------------------------------------------
#if wxUSE_GUI
class WXDLLEXPORT_CORE wxTextCtrl;
class WXDLLEXPORT_CORE wxLogFrame;
class WXDLLEXPORT_CORE wxFrame;
class WXDLLIMPEXP_CORE wxTextCtrl;
class WXDLLIMPEXP_CORE wxLogFrame;
class WXDLLIMPEXP_CORE wxFrame;
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
@ -109,7 +109,7 @@ enum
// normally, only a single instance of this class exists but it's not enforced
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxLog
class WXDLLIMPEXP_BASE wxLog
{
public:
// ctor
@ -261,7 +261,7 @@ private:
// ----------------------------------------------------------------------------
// 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)
@ -279,7 +279,7 @@ protected:
#if wxUSE_STD_IOSTREAM
// log everything to an "ostream", cerr by default
class WXDLLEXPORT_BASE wxLogStream : public wxLog
class WXDLLIMPEXP_BASE wxLogStream : public wxLog
{
public:
// redirect log output to an ostream
@ -315,7 +315,7 @@ protected:
// ~wxLogNull called, old log sink restored
}
*/
class WXDLLEXPORT_BASE wxLogNull
class WXDLLIMPEXP_BASE wxLogNull
{
public:
wxLogNull() : m_flagOld(wxLog::EnableLogging(FALSE)) { }
@ -334,7 +334,7 @@ private:
// does it itself in its ctor
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxLogChain : public wxLog
class WXDLLIMPEXP_BASE wxLogChain : public wxLog
{
public:
wxLogChain(wxLog *logger);
@ -374,7 +374,7 @@ private:
};
// a chain log target which uses itself as the new logger
class WXDLLEXPORT_BASE wxLogPassThrough : public wxLogChain
class WXDLLIMPEXP_BASE wxLogPassThrough : public wxLogChain
{
public:
wxLogPassThrough();
@ -399,19 +399,19 @@ public:
// ----------------------------------------------------------------------------
// 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
WXDLLEXPORT_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0);
WXDLLIMPEXP_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0);
// ----------------------------------------------------------------------------
// define wxLog<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); \
extern void WXDLLEXPORT_BASE wxLog##level(const wxChar *szFormat, \
extern void WXDLLIMPEXP_BASE wxLog##level(const wxChar *szFormat, \
...) ATTRIBUTE_PRINTF_1
#define DECLARE_LOG_FUNCTION2_EXP(level, arg, expdecl) \
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, \
...) ATTRIBUTE_PRINTF_2
#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
@ -434,7 +434,7 @@ inline void wxVLog##level(arg, const wxChar *szFormat, \
inline void wxLog##level(arg, const wxChar *szFormat, ...) { }
// Empty Class to fake wxLogNull
class WXDLLEXPORT_BASE wxLogNull
class WXDLLIMPEXP_BASE wxLogNull
{
public:
wxLogNull() { }
@ -467,7 +467,7 @@ DECLARE_LOG_FUNCTION(Status);
#if wxUSE_GUI
// this one is the same as previous except that it allows to explicitly
// 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
// 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,
// i.e. without using wxMessageBox() for example because it could crash
void WXDLLEXPORT_BASE
void WXDLLIMPEXP_BASE
wxSafeShowMessage(const wxString& title, const wxString& text);
// ----------------------------------------------------------------------------

16
include/wx/longlong.h
View File

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

14
include/wx/memory.h
View File

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

2
include/wx/memtext.h
View File

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

18
include/wx/mimetype.h
View File

@ -30,9 +30,9 @@
#include "wx/dynarray.h"
// fwd decls
class WXDLLEXPORT_BASE wxIconLocation;
class WXDLLEXPORT_BASE wxFileTypeImpl;
class WXDLLEXPORT_BASE wxMimeTypesManagerImpl;
class WXDLLIMPEXP_BASE wxIconLocation;
class WXDLLIMPEXP_BASE wxFileTypeImpl;
class WXDLLIMPEXP_BASE wxMimeTypesManagerImpl;
// these constants define the MIME informations source under UNIX and are used
// by wxMimeTypesManager::Initialize()
@ -49,7 +49,7 @@ enum wxMailcapStyle
/*
TODO: would it be more convenient to have this class?
class WXDLLEXPORT_BASE wxMimeType : public wxString
class WXDLLIMPEXP_BASE wxMimeType : public wxString
{
public:
// all string ctors here
@ -76,7 +76,7 @@ public:
// This class is used with wxMimeTypesManager::AddFallbacks() and Associate()
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileTypeInfo
class WXDLLIMPEXP_BASE wxFileTypeInfo
{
public:
// ctors
@ -162,9 +162,9 @@ WX_DECLARE_EXPORTED_OBJARRAY(wxFileTypeInfo, wxArrayFileTypeInfo);
// 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:
// An object of this class must be passed to Get{Open|Print}Command. The
@ -278,7 +278,7 @@ private:
// given type) about them.
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxMimeTypesManager
class WXDLLIMPEXP_BASE wxMimeTypesManager
{
public:
// static helper functions
@ -385,7 +385,7 @@ private:
// ----------------------------------------------------------------------------
// the default mime manager for wxWindows programs
WXDLLEXPORT_DATA_BASE(extern wxMimeTypesManager *) wxTheMimeTypesManager;
WXDLLIMPEXP_DATA_BASE(extern wxMimeTypesManager *) wxTheMimeTypesManager;
#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
// instance of this class on program startup, call its OnInit() method and call
// OnExit() on program termination (but only if OnInit() succeeded)
class WXDLLEXPORT_BASE wxModule : public wxObject
class WXDLLIMPEXP_BASE wxModule : public wxObject
{
public:
wxModule() {}

10
include/wx/msgout.h
View File

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

4
include/wx/mstream.h
View File

@ -16,7 +16,7 @@
#if wxUSE_STREAMS
class WXDLLEXPORT_BASE wxMemoryInputStream : public wxInputStream
class WXDLLIMPEXP_BASE wxMemoryInputStream : public wxInputStream
{
public:
wxMemoryInputStream(const void *data, size_t length);
@ -44,7 +44,7 @@ private:
DECLARE_NO_COPY_CLASS(wxMemoryInputStream)
};
class WXDLLEXPORT_BASE wxMemoryOutputStream : public wxOutputStream
class WXDLLIMPEXP_BASE wxMemoryOutputStream : public wxOutputStream
{
public:
// 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 WXDLLEXPORT_BASE wxDDEClient;
class WXDLLIMPEXP_BASE wxDDEServer;
class WXDLLIMPEXP_BASE wxDDEClient;
class WXDLLEXPORT_BASE wxDDEConnection: public wxConnectionBase
class WXDLLIMPEXP_BASE wxDDEConnection: public wxConnectionBase
{
DECLARE_DYNAMIC_CLASS(wxDDEConnection)
public:
@ -82,7 +82,7 @@ public:
DECLARE_NO_COPY_CLASS(wxDDEConnection)
};
class WXDLLEXPORT_BASE wxDDEServer: public wxServerBase
class WXDLLIMPEXP_BASE wxDDEServer: public wxServerBase
{
DECLARE_DYNAMIC_CLASS(wxDDEServer)
public:
@ -111,7 +111,7 @@ protected:
wxDDEConnectionList m_connections;
};
class WXDLLEXPORT_BASE wxDDEClient: public wxClientBase
class WXDLLIMPEXP_BASE wxDDEClient: public wxClientBase
{
DECLARE_DYNAMIC_CLASS(wxDDEClient)
public:
@ -140,8 +140,8 @@ protected:
wxDDEConnectionList m_connections;
};
void WXDLLEXPORT_BASE wxDDEInitialize();
void WXDLLEXPORT_BASE wxDDECleanUp();
void WXDLLIMPEXP_BASE wxDDEInitialize();
void WXDLLIMPEXP_BASE wxDDECleanUp();
#endif
// _WX_DDE_H_

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

@ -27,7 +27,7 @@
// and is never used directly by the application
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileTypeImpl
class WXDLLIMPEXP_BASE wxFileTypeImpl
{
public:
// ctor
@ -92,7 +92,7 @@ private:
bool RemoveDescription();
};
class WXDLLEXPORT_BASE wxMimeTypesManagerImpl
class WXDLLIMPEXP_BASE wxMimeTypesManagerImpl
{
public:
// 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
// ---------------------------------------------------------------------------
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

18
include/wx/object.h
View File

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

4
include/wx/process.h
View File

@ -39,7 +39,7 @@ enum
// function will be called when the process terminates.
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxProcess : public wxEvtHandler
class WXDLLIMPEXP_BASE wxProcess : public wxEvtHandler
{
public:
// kill the process with the given PID
@ -139,7 +139,7 @@ BEGIN_DECLARE_EVENT_TYPES()
DECLARE_EVENT_TYPE(wxEVT_END_PROCESS, 440)
END_DECLARE_EVENT_TYPES()
class WXDLLEXPORT_BASE wxProcessEvent : public wxEvent
class WXDLLIMPEXP_BASE wxProcessEvent : public wxEvent
{
public:
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/url.h"
class WXDLLEXPORT_BASE wxFTP : public wxProtocol
class WXDLLIMPEXP_BASE wxFTP : public wxProtocol
{
public:
enum TransferMode

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

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

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

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

6
include/wx/regex.h
View File

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

8
include/wx/sckaddr.h
View File

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

6
include/wx/sckipc.h
View File

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

6
include/wx/sckstrm.h
View File

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

4
include/wx/snglinst.h
View File

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

10
include/wx/socket.h
View File

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

12
include/wx/stopwatch.h
View File

@ -17,7 +17,7 @@
#if wxUSE_STOPWATCH
class WXDLLEXPORT_BASE wxStopWatch
class WXDLLIMPEXP_BASE wxStopWatch
{
public:
// ctor starts the stop watch
@ -67,11 +67,11 @@ private:
// Starts a global timer
// -- DEPRECATED: use wxStopWatch instead
void WXDLLEXPORT_BASE wxStartTimer();
void WXDLLIMPEXP_BASE wxStartTimer();
// Gets elapsed milliseconds since last wxStartTimer or wxGetElapsedTime
// -- DEPRECATED: use wxStopWatch instead
long WXDLLEXPORT_BASE wxGetElapsedTime(bool resetTimer = TRUE);
long WXDLLIMPEXP_BASE wxGetElapsedTime(bool resetTimer = TRUE);
#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.
extern long WXDLLEXPORT_BASE wxGetLocalTime();
extern long WXDLLIMPEXP_BASE wxGetLocalTime();
// 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
// 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
#define wxGetCurrentTime() wxGetLocalTime()

32
include/wx/strconv.h
View File

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

26
include/wx/stream.h
View File

@ -25,14 +25,14 @@
#include "wx/string.h"
#include "wx/filefn.h" // for off_t, wxInvalidOffset and wxSeekMode
class WXDLLEXPORT_BASE wxStreamBase;
class WXDLLEXPORT_BASE wxInputStream;
class WXDLLEXPORT_BASE wxOutputStream;
class WXDLLIMPEXP_BASE wxStreamBase;
class WXDLLIMPEXP_BASE wxInputStream;
class WXDLLIMPEXP_BASE wxOutputStream;
typedef wxInputStream& (*__wxInputManip)(wxInputStream&);
typedef wxOutputStream& (*__wxOutputManip)(wxOutputStream&);
WXDLLEXPORT_BASE wxOutputStream& wxEndL(wxOutputStream& o_stream);
WXDLLIMPEXP_BASE wxOutputStream& wxEndL(wxOutputStream& o_stream);
// ----------------------------------------------------------------------------
// constants
@ -67,7 +67,7 @@ enum wxStreamError
// wxStreamBase: common (but non virtual!) base for all stream classes
// ---------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxStreamBase
class WXDLLIMPEXP_BASE wxStreamBase
{
public:
wxStreamBase();
@ -106,7 +106,7 @@ protected:
// wxInputStream: base class for the input streams
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxInputStream : public wxStreamBase
class WXDLLIMPEXP_BASE wxInputStream : public wxStreamBase
{
public:
// ctor and dtor, nothing exciting
@ -238,7 +238,7 @@ protected:
// wxOutputStream: base for the output streams
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxOutputStream : public wxStreamBase
class WXDLLIMPEXP_BASE wxOutputStream : public wxStreamBase
{
public:
wxOutputStream();
@ -274,7 +274,7 @@ protected:
// A stream for measuring streamed output
// ---------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxCountingOutputStream : public wxOutputStream
class WXDLLIMPEXP_BASE wxCountingOutputStream : public wxOutputStream
{
public:
wxCountingOutputStream();
@ -294,7 +294,7 @@ protected:
// "Filter" streams
// ---------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFilterInputStream : public wxInputStream
class WXDLLIMPEXP_BASE wxFilterInputStream : public wxInputStream
{
public:
wxFilterInputStream();
@ -313,7 +313,7 @@ protected:
DECLARE_NO_COPY_CLASS(wxFilterInputStream)
};
class WXDLLEXPORT_BASE wxFilterOutputStream : public wxOutputStream
class WXDLLIMPEXP_BASE wxFilterOutputStream : public wxOutputStream
{
public:
wxFilterOutputStream();
@ -339,7 +339,7 @@ protected:
// wxBufferedStreams to implement custom buffering
// ---------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxStreamBuffer
class WXDLLIMPEXP_BASE wxStreamBuffer
{
public:
enum BufMode
@ -457,7 +457,7 @@ private:
// wxBufferedInputStream
// ---------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxBufferedInputStream : public wxFilterInputStream
class WXDLLIMPEXP_BASE wxBufferedInputStream : public wxFilterInputStream
{
public:
// if a non NULL buffer is given to the stream, it will be deleted by it
@ -493,7 +493,7 @@ protected:
// wxBufferedOutputStream
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxBufferedOutputStream : public wxFilterOutputStream
class WXDLLIMPEXP_BASE wxBufferedOutputStream : public wxFilterOutputStream
{
public:
// 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
extern WXDLLEXPORT_DATA_BASE(const wxChar*) wxEmptyString;
extern WXDLLIMPEXP_DATA_BASE(const wxChar*) wxEmptyString;
// ---------------------------------------------------------------------------
// 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
class WXDLLEXPORT_BASE wxString; // not yet defined
class WXDLLIMPEXP_BASE wxString; // not yet defined
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)
// ---------------------------------------------------------------------------
struct WXDLLEXPORT_BASE wxStringData
struct WXDLLIMPEXP_BASE wxStringData
{
int nRefs; // reference count
size_t nDataLength, // actual string length
@ -233,9 +233,9 @@ struct WXDLLEXPORT_BASE wxStringData
// - 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
// that all inline functions can be effectively inlined, verify that all
@ -607,15 +607,15 @@ public:
// 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
// insert an int into string
@ -1027,7 +1027,7 @@ public:
// from the array (operator[] or Item() method), a reference is returned.
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxArrayString
class WXDLLIMPEXP_BASE wxArrayString
{
public:
// type of function used by wxArrayString::Sort()
@ -1151,7 +1151,7 @@ private:
bool m_autoSort; // if TRUE, keep the array always sorted
};
class WXDLLEXPORT_BASE wxSortedArrayString : public wxArrayString
class WXDLLIMPEXP_BASE wxSortedArrayString : public wxArrayString
{
public:
wxSortedArrayString() : wxArrayString(TRUE)
@ -1164,7 +1164,7 @@ public:
// wxStringBuffer: a tiny class allowing to get a writable pointer into string
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxStringBuffer
class WXDLLIMPEXP_BASE wxStringBuffer
{
public:
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); }
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
wxString WXDLLEXPORT_BASE operator+(const wxString& string1, const wxString& string2);
wxString WXDLLEXPORT_BASE operator+(const wxString& string, wxChar ch);
wxString WXDLLEXPORT_BASE operator+(wxChar ch, const wxString& string);
wxString WXDLLEXPORT_BASE operator+(const wxString& string, const wxChar *psz);
wxString WXDLLEXPORT_BASE operator+(const wxChar *psz, const wxString& string);
wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2);
wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
#if wxUSE_UNICODE
inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
{ return string + (const wchar_t *)buf; }
@ -1277,8 +1277,8 @@ inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
#include "wx/iosfwrap.h"
WXDLLEXPORT_BASE wxSTD istream& operator>>(wxSTD istream&, wxString&);
WXDLLEXPORT_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
WXDLLIMPEXP_BASE wxSTD istream& operator>>(wxSTD istream&, wxString&);
WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
#endif // wxSTD_STRING_COMPATIBILITY

2
include/wx/sysopt.h
View File

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

2
include/wx/textbuf.h
View File

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

2
include/wx/textfile.h
View File

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

4
include/wx/tokenzr.h
View File

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

10
include/wx/txtstrm.h
View File

@ -20,16 +20,16 @@
#if wxUSE_STREAMS
class WXDLLEXPORT_BASE wxTextInputStream;
class WXDLLEXPORT_BASE wxTextOutputStream;
class WXDLLIMPEXP_BASE wxTextInputStream;
class WXDLLIMPEXP_BASE wxTextOutputStream;
typedef wxTextInputStream& (*__wxTextInputManip)(wxTextInputStream&);
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:
#if wxUSE_UNICODE
@ -83,7 +83,7 @@ typedef enum
wxEOL_DOS
} wxEOL;
class WXDLLEXPORT_BASE wxTextOutputStream
class WXDLLIMPEXP_BASE wxTextOutputStream
{
public:
#if wxUSE_UNICODE

2
include/wx/url.h
View File

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

128
include/wx/utils.h
View File

@ -39,11 +39,11 @@
// Forward declaration
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxProcess;
class WXDLLEXPORT_BASE wxFrame;
class WXDLLEXPORT_BASE wxWindow;
class WXDLLEXPORT_BASE wxWindowList;
class WXDLLEXPORT_BASE wxPoint;
class WXDLLIMPEXP_BASE wxProcess;
class WXDLLIMPEXP_BASE wxFrame;
class WXDLLIMPEXP_BASE wxWindow;
class WXDLLIMPEXP_BASE wxWindowList;
class WXDLLIMPEXP_BASE wxPoint;
// ----------------------------------------------------------------------------
// Macros
@ -59,15 +59,15 @@ class WXDLLEXPORT_BASE wxPoint;
// Useful buffer (FIXME VZ: To be removed!!!)
// Now only needed in MSW port
#if !defined(__WXMOTIF__) && !defined(__WXGTK__) && !defined(__WXX11__) && !defined(__WXMGL__) && !defined(__WXMAC__)
WXDLLEXPORT_DATA_BASE(extern wxChar*) wxBuffer;
WXDLLIMPEXP_DATA_BASE(extern wxChar*) wxBuffer;
#endif
// 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
// 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
// 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
WXDLLEXPORT_BASE void wxBell();
WXDLLIMPEXP_BASE void wxBell();
// Get OS description as a user-readable string
WXDLLEXPORT_BASE wxString wxGetOsDescription();
WXDLLIMPEXP_BASE wxString wxGetOsDescription();
// Get OS version
WXDLLEXPORT_BASE int wxGetOsVersion(int *majorVsn = (int *) NULL,
WXDLLIMPEXP_BASE int wxGetOsVersion(int *majorVsn = (int *) NULL,
int *minorVsn = (int *) NULL);
// 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)
WXDLLEXPORT_BASE const wxChar *wxGetInstallPrefix();
WXDLLIMPEXP_BASE const wxChar *wxGetInstallPrefix();
// Return path to wxWin data (/usr/share/wx/%{version}) (Unices)
WXDLLEXPORT_BASE wxString wxGetDataDir();
WXDLLIMPEXP_BASE wxString wxGetDataDir();
#if wxUSE_GUI
@ -130,26 +130,26 @@ WXDLLEXPORT long wxGetCurrentId();
// these functions are deprecated, use wxString methods instead!
#if WXWIN_COMPATIBILITY_2_4
WXDLLEXPORT_DATA_BASE(extern const wxChar*) wxFloatToStringStr;
WXDLLEXPORT_DATA_BASE(extern const wxChar*) wxDoubleToStringStr;
WXDLLIMPEXP_DATA_BASE(extern const wxChar*) wxFloatToStringStr;
WXDLLIMPEXP_DATA_BASE(extern const wxChar*) wxDoubleToStringStr;
WXDLLEXPORT_BASE void StringToFloat(const wxChar *s, float *number);
WXDLLEXPORT_BASE wxChar* FloatToString(float number, const wxChar *fmt = wxFloatToStringStr);
WXDLLEXPORT_BASE void StringToDouble(const wxChar *s, double *number);
WXDLLEXPORT_BASE wxChar* DoubleToString(double number, const wxChar *fmt = wxDoubleToStringStr);
WXDLLEXPORT_BASE void StringToInt(const wxChar *s, int *number);
WXDLLEXPORT_BASE void StringToLong(const wxChar *s, long *number);
WXDLLEXPORT_BASE wxChar* IntToString(int number);
WXDLLEXPORT_BASE wxChar* LongToString(long number);
WXDLLIMPEXP_BASE void StringToFloat(const wxChar *s, float *number);
WXDLLIMPEXP_BASE wxChar* FloatToString(float number, const wxChar *fmt = wxFloatToStringStr);
WXDLLIMPEXP_BASE void StringToDouble(const wxChar *s, double *number);
WXDLLIMPEXP_BASE wxChar* DoubleToString(double number, const wxChar *fmt = wxDoubleToStringStr);
WXDLLIMPEXP_BASE void StringToInt(const wxChar *s, int *number);
WXDLLIMPEXP_BASE void StringToLong(const wxChar *s, long *number);
WXDLLIMPEXP_BASE wxChar* IntToString(int number);
WXDLLIMPEXP_BASE wxChar* LongToString(long number);
#endif // WXWIN_COMPATIBILITY_2_4
// 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
WXDLLEXPORT_BASE void wxDecToHex(int dec, wxChar *buf);
WXDLLEXPORT_BASE wxString wxDecToHex(int dec);
WXDLLIMPEXP_BASE void wxDecToHex(int dec, wxChar *buf);
WXDLLIMPEXP_BASE wxString wxDecToHex(int dec);
// ----------------------------------------------------------------------------
// Process management
@ -180,18 +180,18 @@ enum
// 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
// 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);
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);
// execute the command capturing its output into an array line by line, this is
// always synchronous
WXDLLEXPORT_BASE long wxExecute(const wxString& command,
WXDLLIMPEXP_BASE long wxExecute(const wxString& command,
wxArrayString& output);
// also capture stderr (also synchronous)
WXDLLEXPORT_BASE long wxExecute(const wxString& command,
WXDLLIMPEXP_BASE long wxExecute(const wxString& command,
wxArrayString& output,
wxArrayString& error);
@ -234,38 +234,38 @@ enum wxShutdownFlags
};
// 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
// Windows, all others mean TERM), return 0 if ok and -1 on error
//
// return detailed error in rc if not NULL
WXDLLEXPORT_BASE int wxKill(long pid,
WXDLLIMPEXP_BASE int wxKill(long pid,
wxSignal sig = wxSIGTERM,
wxKillError *rc = NULL);
// Execute a command in an interactive shell window (always synchronously)
// 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
// 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
WXDLLEXPORT_BASE void wxSleep(int nSecs);
WXDLLIMPEXP_BASE void wxSleep(int nSecs);
// 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
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)
WXDLLEXPORT_BASE long wxGetFreeMemory();
WXDLLIMPEXP_BASE long wxGetFreeMemory();
// should wxApp::OnFatalException() be called?
WXDLLEXPORT_BASE bool wxHandleFatalExceptions(bool doit = TRUE);
WXDLLIMPEXP_BASE bool wxHandleFatalExceptions(bool doit = TRUE);
// ----------------------------------------------------------------------------
// 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
// 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
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
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!
// Get eMail address
WXDLLEXPORT_BASE bool wxGetEmailAddress(wxChar *buf, int maxSize);
WXDLLEXPORT_BASE wxString wxGetEmailAddress();
WXDLLIMPEXP_BASE bool wxGetEmailAddress(wxChar *buf, int maxSize);
WXDLLIMPEXP_BASE wxString wxGetEmailAddress();
// Get hostname.
WXDLLEXPORT_BASE bool wxGetHostName(wxChar *buf, int maxSize);
WXDLLEXPORT_BASE wxString wxGetHostName();
WXDLLIMPEXP_BASE bool wxGetHostName(wxChar *buf, int maxSize);
WXDLLIMPEXP_BASE wxString wxGetHostName();
// Get FQDN
WXDLLEXPORT_BASE wxString wxGetFullHostName();
WXDLLEXPORT_BASE bool wxGetFullHostName(wxChar *buf, int maxSize);
WXDLLIMPEXP_BASE wxString wxGetFullHostName();
WXDLLIMPEXP_BASE bool wxGetFullHostName(wxChar *buf, int maxSize);
// Get user ID e.g. jacs (this is known as login name under Unix)
WXDLLEXPORT_BASE bool wxGetUserId(wxChar *buf, int maxSize);
WXDLLEXPORT_BASE wxString wxGetUserId();
WXDLLIMPEXP_BASE bool wxGetUserId(wxChar *buf, int maxSize);
WXDLLIMPEXP_BASE wxString wxGetUserId();
// Get user name e.g. Julian Smart
WXDLLEXPORT_BASE bool wxGetUserName(wxChar *buf, int maxSize);
WXDLLEXPORT_BASE wxString wxGetUserName();
WXDLLIMPEXP_BASE bool wxGetUserName(wxChar *buf, int maxSize);
WXDLLIMPEXP_BASE wxString wxGetUserName();
// Get current Home dir and copy to dest (returns pstr->c_str())
WXDLLEXPORT_BASE wxString wxGetHomeDir();
WXDLLEXPORT_BASE const wxChar* wxGetHomeDir(wxString *pstr);
WXDLLIMPEXP_BASE wxString wxGetHomeDir();
WXDLLIMPEXP_BASE const wxChar* wxGetHomeDir(wxString *pstr);
// Get the user's home dir (caller must copy --- volatile)
// returns NULL is no HOME dir is known
#if defined(__UNIX__) && wxUSE_UNICODE
WXDLLEXPORT_BASE const wxMB2WXbuf wxGetUserHome(const wxString& user = wxEmptyString);
WXDLLIMPEXP_BASE const wxMB2WXbuf wxGetUserHome(const wxString& user = wxEmptyString);
#else
WXDLLEXPORT_BASE wxChar* wxGetUserHome(const wxString& user = wxEmptyString);
WXDLLIMPEXP_BASE wxChar* wxGetUserHome(const wxString& user = wxEmptyString);
#endif
// 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 *pFree = NULL);
@ -486,10 +486,10 @@ void WXDLLEXPORT wxGetMousePosition( int* x, int* y );
// ----------------------------------------------------------------------------
// Yield to other apps/messages
WXDLLEXPORT_BASE bool wxYield();
WXDLLIMPEXP_BASE bool wxYield();
// 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)
@ -499,15 +499,15 @@ WXDLLEXPORT_BASE bool wxYieldIfNeeded();
// Format a message on the standard error (UNIX) or the debugging
// 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)
WXDLLEXPORT_DATA_BASE(extern const wxChar*) wxInternalErrorStr;
WXDLLEXPORT_BASE void wxError(const wxString& msg, const wxString& title = wxInternalErrorStr);
WXDLLIMPEXP_DATA_BASE(extern const wxChar*) wxInternalErrorStr;
WXDLLIMPEXP_BASE void wxError(const wxString& msg, const wxString& title = wxInternalErrorStr);
// Fatal error (exits)
WXDLLEXPORT_DATA_BASE(extern const wxChar*) wxFatalErrorStr;
WXDLLEXPORT_BASE void wxFatalError(const wxString& msg, const wxString& title = wxFatalErrorStr);
WXDLLIMPEXP_DATA_BASE(extern const wxChar*) wxFatalErrorStr;
WXDLLIMPEXP_BASE void wxFatalError(const wxString& msg, const wxString& title = wxFatalErrorStr);
#endif // WXWIN_COMPATIBILITY_2_2

6
include/wx/variant.h
View File

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

2
include/wx/vector.h
View File

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

2
include/wx/volume.h
View File

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

12
include/wx/wfstream.h
View File

@ -30,7 +30,7 @@
// wxFileStream using wxFile
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFileInputStream: public wxInputStream {
class WXDLLIMPEXP_BASE wxFileInputStream: public wxInputStream {
public:
wxFileInputStream(const wxString& ifileName);
wxFileInputStream(wxFile& file);
@ -55,7 +55,7 @@ class WXDLLEXPORT_BASE wxFileInputStream: public wxInputStream {
DECLARE_NO_COPY_CLASS(wxFileInputStream)
};
class WXDLLEXPORT_BASE wxFileOutputStream: public wxOutputStream {
class WXDLLIMPEXP_BASE wxFileOutputStream: public wxOutputStream {
public:
wxFileOutputStream(const wxString& fileName);
wxFileOutputStream(wxFile& file);
@ -85,7 +85,7 @@ class WXDLLEXPORT_BASE wxFileOutputStream: public wxOutputStream {
DECLARE_NO_COPY_CLASS(wxFileOutputStream)
};
class WXDLLEXPORT_BASE wxFileStream: public wxFileInputStream, public wxFileOutputStream {
class WXDLLIMPEXP_BASE wxFileStream: public wxFileInputStream, public wxFileOutputStream {
public:
wxFileStream(const wxString& fileName);
};
@ -94,7 +94,7 @@ class WXDLLEXPORT_BASE wxFileStream: public wxFileInputStream, public wxFileOutp
// wxFFileStream using wxFFile
// ----------------------------------------------------------------------------
class WXDLLEXPORT_BASE wxFFileInputStream: public wxInputStream {
class WXDLLIMPEXP_BASE wxFFileInputStream: public wxInputStream {
public:
wxFFileInputStream(const wxString& ifileName);
wxFFileInputStream(wxFFile& file);
@ -119,7 +119,7 @@ class WXDLLEXPORT_BASE wxFFileInputStream: public wxInputStream {
DECLARE_NO_COPY_CLASS(wxFFileInputStream)
};
class WXDLLEXPORT_BASE wxFFileOutputStream: public wxOutputStream {
class WXDLLIMPEXP_BASE wxFFileOutputStream: public wxOutputStream {
public:
wxFFileOutputStream(const wxString& fileName);
wxFFileOutputStream(wxFFile& file);
@ -149,7 +149,7 @@ class WXDLLEXPORT_BASE wxFFileOutputStream: public wxOutputStream {
DECLARE_NO_COPY_CLASS(wxFFileOutputStream)
};
class WXDLLEXPORT_BASE wxFFileStream: public wxFFileInputStream, public wxFFileOutputStream {
class WXDLLIMPEXP_BASE wxFFileStream: public wxFFileInputStream, public wxFFileOutputStream {
public:
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
#endif
WXDLLEXPORT_BASE bool wxOKlibc(); // for internal use
WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
// ----------------------------------------------------------------------------
// printf() family saga
@ -728,11 +728,11 @@ WXDLLEXPORT_BASE bool wxOKlibc(); // for internal use
#ifndef wxSnprintf_
// 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;
#endif
#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);
#endif
@ -801,19 +801,19 @@ WXDLLEXPORT_BASE bool wxOKlibc(); // for internal use
//
// VZ: note that this is never defined currently
#ifdef wxNEED_WX_CTYPE_H
WXDLLEXPORT_BASE int wxIsalnum(wxChar ch);
WXDLLEXPORT_BASE int wxIsalpha(wxChar ch);
WXDLLEXPORT_BASE int wxIsctrl(wxChar ch);
WXDLLEXPORT_BASE int wxIsdigit(wxChar ch);
WXDLLEXPORT_BASE int wxIsgraph(wxChar ch);
WXDLLEXPORT_BASE int wxIslower(wxChar ch);
WXDLLEXPORT_BASE int wxIsprint(wxChar ch);
WXDLLEXPORT_BASE int wxIspunct(wxChar ch);
WXDLLEXPORT_BASE int wxIsspace(wxChar ch);
WXDLLEXPORT_BASE int wxIsupper(wxChar ch);
WXDLLEXPORT_BASE int wxIsxdigit(wxChar ch);
WXDLLEXPORT_BASE int wxTolower(wxChar ch);
WXDLLEXPORT_BASE int wxToupper(wxChar ch);
WXDLLIMPEXP_BASE int wxIsalnum(wxChar ch);
WXDLLIMPEXP_BASE int wxIsalpha(wxChar ch);
WXDLLIMPEXP_BASE int wxIsctrl(wxChar ch);
WXDLLIMPEXP_BASE int wxIsdigit(wxChar ch);
WXDLLIMPEXP_BASE int wxIsgraph(wxChar ch);
WXDLLIMPEXP_BASE int wxIslower(wxChar ch);
WXDLLIMPEXP_BASE int wxIsprint(wxChar ch);
WXDLLIMPEXP_BASE int wxIspunct(wxChar ch);
WXDLLIMPEXP_BASE int wxIsspace(wxChar ch);
WXDLLIMPEXP_BASE int wxIsupper(wxChar ch);
WXDLLIMPEXP_BASE int wxIsxdigit(wxChar ch);
WXDLLIMPEXP_BASE int wxTolower(wxChar ch);
WXDLLIMPEXP_BASE int wxToupper(wxChar ch);
#endif // wxNEED_WX_CTYPE_H
// 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
#ifdef wxNEED_WX_STRING_H
WXDLLEXPORT_BASE wxChar * wxStrcat(wxChar *dest, const wxChar *src);
WXDLLEXPORT_BASE const wxChar * wxStrchr(const wxChar *s, wxChar c);
WXDLLEXPORT_BASE wxChar * wxStrchr(wxChar *s, wxChar c)
WXDLLIMPEXP_BASE wxChar * wxStrcat(wxChar *dest, const wxChar *src);
WXDLLIMPEXP_BASE const wxChar * wxStrchr(const wxChar *s, wxChar c);
WXDLLIMPEXP_BASE wxChar * wxStrchr(wxChar *s, wxChar c)
{ return (wxChar *)wxStrchr((const wxChar *)s, c); }
WXDLLEXPORT_BASE int wxStrcmp(const wxChar *s1, const wxChar *s2);
WXDLLEXPORT_BASE int wxStrcoll(const wxChar *s1, const wxChar *s2);
WXDLLEXPORT_BASE wxChar * wxStrcpy(wxChar *dest, const wxChar *src);
WXDLLEXPORT_BASE size_t wxStrcspn(const wxChar *s, const wxChar *reject);
WXDLLEXPORT_BASE size_t wxStrlen(const wxChar *s);
WXDLLEXPORT_BASE wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n);
WXDLLEXPORT_BASE int wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n);
WXDLLEXPORT_BASE wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n);
WXDLLEXPORT_BASE const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept);
WXDLLEXPORT_BASE wxChar * wxStrpbrk(wxChar *s, const wxChar *accept)
WXDLLIMPEXP_BASE int wxStrcmp(const wxChar *s1, const wxChar *s2);
WXDLLIMPEXP_BASE int wxStrcoll(const wxChar *s1, const wxChar *s2);
WXDLLIMPEXP_BASE wxChar * wxStrcpy(wxChar *dest, const wxChar *src);
WXDLLIMPEXP_BASE size_t wxStrcspn(const wxChar *s, const wxChar *reject);
WXDLLIMPEXP_BASE size_t wxStrlen(const wxChar *s);
WXDLLIMPEXP_BASE wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n);
WXDLLIMPEXP_BASE int wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n);
WXDLLIMPEXP_BASE wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n);
WXDLLIMPEXP_BASE const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept);
WXDLLIMPEXP_BASE wxChar * wxStrpbrk(wxChar *s, const wxChar *accept)
{ return (wxChar *)wxStrpbrk((const wxChar *)s, accept); }
WXDLLEXPORT_BASE const wxChar * wxStrrchr(const wxChar *s, wxChar c);
WXDLLEXPORT_BASE wxChar * wxStrrchr(wxChar *s, wxChar c)
WXDLLIMPEXP_BASE const wxChar * wxStrrchr(const wxChar *s, wxChar c);
WXDLLIMPEXP_BASE wxChar * wxStrrchr(wxChar *s, wxChar c)
{ return (wxChar *)wxStrrchr((const wxChar *)s, c); }
WXDLLEXPORT_BASE size_t wxStrspn(const wxChar *s, const wxChar *accept);
WXDLLEXPORT_BASE const wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle);
WXDLLEXPORT_BASE wxChar *wxStrstr(wxChar *haystack, const wxChar *needle)
WXDLLIMPEXP_BASE size_t wxStrspn(const wxChar *s, const wxChar *accept);
WXDLLIMPEXP_BASE const wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle);
WXDLLIMPEXP_BASE wxChar *wxStrstr(wxChar *haystack, const wxChar *needle)
{ return (wxChar *)wxStrstr((const wxChar *)haystack, needle); }
WXDLLEXPORT_BASE double wxStrtod(const wxChar *nptr, wxChar **endptr);
WXDLLEXPORT_BASE long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base);
WXDLLEXPORT_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 double wxStrtod(const wxChar *nptr, wxChar **endptr);
WXDLLIMPEXP_BASE long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base);
WXDLLIMPEXP_BASE unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base);
WXDLLIMPEXP_BASE size_t wxStrxfrm(wxChar *dest, const wxChar *src, size_t n);
#endif // wxNEED_WX_STRING_H
#ifndef wxStrdupA
WXDLLEXPORT_BASE char *wxStrdupA(const char *psz);
WXDLLIMPEXP_BASE char *wxStrdupA(const char *psz);
#endif
#ifndef wxStrdupW
WXDLLEXPORT_BASE wchar_t *wxStrdupW(const wchar_t *pwz);
WXDLLIMPEXP_BASE wchar_t *wxStrdupW(const wchar_t *pwz);
#endif
#ifndef wxStricmp
WXDLLEXPORT_BASE int wxStricmp(const wxChar *psz1, const wxChar *psz2);
WXDLLIMPEXP_BASE int wxStricmp(const wxChar *psz1, const wxChar *psz2);
#endif
#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
#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
#ifndef wxSetlocale
class WXDLLEXPORT_BASE wxWCharBuffer;
WXDLLEXPORT_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
class WXDLLIMPEXP_BASE wxWCharBuffer;
WXDLLIMPEXP_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
#endif
// stdio.h functions
#ifdef wxNEED_WX_STDIO_H
#include <stdio.h>
WXDLLEXPORT_BASE FILE * wxFopen(const wxChar *path, const wxChar *mode);
WXDLLEXPORT_BASE FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream);
WXDLLEXPORT_BASE int wxRemove(const wxChar *path);
WXDLLEXPORT_BASE int wxRename(const wxChar *oldpath, const wxChar *newpath);
WXDLLIMPEXP_BASE FILE * wxFopen(const wxChar *path, const wxChar *mode);
WXDLLIMPEXP_BASE FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream);
WXDLLIMPEXP_BASE int wxRemove(const wxChar *path);
WXDLLIMPEXP_BASE int wxRename(const wxChar *oldpath, const wxChar *newpath);
// *printf() family is handled separately
#endif // wxNEED_WX_STDIO_H
@ -895,14 +895,14 @@ WXDLLEXPORT_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
// stdlib.h functions
#ifndef wxAtof
WXDLLEXPORT_BASE double wxAtof(const wxChar *psz);
WXDLLIMPEXP_BASE double wxAtof(const wxChar *psz);
#endif
#ifdef wxNEED_WX_STDLIB_H
WXDLLEXPORT_BASE int wxAtoi(const wxChar *psz);
WXDLLEXPORT_BASE long wxAtol(const wxChar *psz);
WXDLLEXPORT_BASE wxChar * wxGetenv(const wxChar *name);
WXDLLEXPORT_BASE int wxSystem(const wxChar *psz);
WXDLLIMPEXP_BASE int wxAtoi(const wxChar *psz);
WXDLLIMPEXP_BASE long wxAtol(const wxChar *psz);
WXDLLIMPEXP_BASE wxChar * wxGetenv(const wxChar *name);
WXDLLIMPEXP_BASE int wxSystem(const wxChar *psz);
#endif
@ -911,7 +911,7 @@ WXDLLEXPORT_BASE int wxSystem(const wxChar *psz);
#if defined(__MWERKS__) && defined(macintosh)
#include <time.h>
#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);
#endif // wxNEED_WX_TIME_H
@ -921,8 +921,8 @@ WXDLLEXPORT_BASE int wxSystem(const wxChar *psz);
#if wxUSE_WCHAR_T
// multibyte<->widechar conversion
WXDLLEXPORT_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 wxMB2WC(wchar_t *buf, const char *psz, size_t n);
WXDLLIMPEXP_BASE size_t wxWC2MB(char *buf, const wchar_t *psz, size_t n);
#if wxUSE_UNICODE
#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:
wxZipInputStream(const wxString& archive, const wxString& file);

4
include/wx/zstream.h
View File

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

2
src/msw/fontutil.cpp
View File

@ -118,7 +118,7 @@ bool wxGetNativeFontEncoding(wxFontEncoding encoding,
encoding = wxFont::GetDefaultEncoding();
}
extern WXDLLEXPORT_BASE long wxEncodingToCharset(wxFontEncoding encoding);
extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding);
info->charset = wxEncodingToCharset(encoding);
if ( info->charset == -1 )
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
extern WXDLLEXPORT_BASE long wxEncodingToCodepage(wxFontEncoding encoding);
extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding);
#if wxUSE_UNICODE_MSLU
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
// ----------------------------------------------------------------------------
extern WXDLLEXPORT_BASE long wxEncodingToCharset(wxFontEncoding encoding)
extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
{
switch ( encoding )
{
@ -1120,7 +1120,7 @@ extern WXDLLEXPORT_BASE long wxEncodingToCharset(wxFontEncoding encoding)
#include "wx/fontmap.h"
extern WXDLLEXPORT_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
{
// translate encoding into the Windows CHARSET
long charset = wxEncodingToCharset(encoding);