#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
// 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) {}
// wxAppConsole: wxApp for non-GUI applications
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxAppConsole : public wxEvtHandler
+class WXDLLIMPEXP_BASE wxAppConsole : public wxEvtHandler
{
public:
// ctor and dtor
#if wxUSE_GUI
-class WXDLLEXPORT_CORE wxAppBase : public wxAppConsole
+class WXDLLIMPEXP_CORE wxAppBase : public wxAppConsole
{
public:
wxAppBase();
#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
// 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
// ------------------------------------------------------
// 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
// 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)
#include "wx/version.h"
-class WXDLLEXPORT_BASE wxAppConsole;
+class WXDLLIMPEXP_BASE wxAppConsole;
// ----------------------------------------------------------------------------
// wxBuildOptions
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() { }
// 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();
#if wxUSE_CMDLINE_PARSER
-class WXDLLEXPORT_BASE wxDateTime;
+class WXDLLIMPEXP_BASE wxDateTime;
// ----------------------------------------------------------------------------
// constants
// 4. use GetXXX() to retrieve the parsed info
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxCmdLineParser
+class WXDLLIMPEXP_BASE wxCmdLineParser
{
public:
// ctors and initializers
// 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);
// (long) type (TODO doubles and other types such as wxDate coming soon).
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxConfigBase
+class WXDLLIMPEXP_BASE wxConfigBase
{
public:
// constants
// 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
'_' 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
#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
// 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
// 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);
// 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;
// objects of that class. See also wxDateSpan.
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxTimeSpan
+class WXDLLIMPEXP_BASE wxTimeSpan
{
public:
// constructors
// associated with those.
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxDateSpan
+class WXDLLIMPEXP_BASE wxDateSpan
{
public:
// constructors
// 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:
};
// 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;
// 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);
// 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") );
// 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);
}
// 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();
}
// ----------
// 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() &&
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);
// 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(),
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(),
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);
}
// 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") );
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") );
: (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") );
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") );
#if wxUSE_STREAMS
-class WXDLLEXPORT_BASE wxDataInputStream
+class WXDLLIMPEXP_BASE wxDataInputStream
{
public:
#if wxUSE_UNICODE
DECLARE_NO_COPY_CLASS(wxDataInputStream)
};
-class WXDLLEXPORT_BASE wxDataOutputStream
+class WXDLLIMPEXP_BASE wxDataOutputStream
{
public:
#if wxUSE_UNICODE
*/
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;
#define SQL_MAX_AUTHSTR_LEN MAXNAME
#endif
-class WXDLLEXPORT_BASE wxDbConnectInf
+class WXDLLIMPEXP_BASE wxDbConnectInf
{
private:
bool freeHenvOnDestroy;
}; // class wxDbConnectInf
-struct WXDLLEXPORT_BASE wxDbSqlTypeInfo
+struct WXDLLIMPEXP_BASE wxDbSqlTypeInfo
{
wxString TypeName;
SWORD FsqlType;
};
-class WXDLLEXPORT_BASE wxDbColFor
+class WXDLLIMPEXP_BASE wxDbColFor
{
public:
wxString s_Field; // Formated String for Output
};
-class WXDLLEXPORT_BASE wxDbColInf
+class WXDLLIMPEXP_BASE wxDbColInf
{
public:
wxChar catalog[128+1];
};
-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];
};
-class WXDLLEXPORT_BASE wxDbInf // Description of a Database
+class WXDLLIMPEXP_BASE wxDbInf // Description of a Database
{
public:
wxChar catalog[128+1];
// 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;
// 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,
// 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);
// 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);
#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);
// 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
}; // wxDbColDef
-class WXDLLEXPORT_BASE wxDbColDataPtr
+class WXDLLIMPEXP_BASE wxDbColDataPtr
{
public:
void *PtrDataObj;
// 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];
}; // wxDbIdxDef
-class WXDLLEXPORT_BASE wxDbTable
+class WXDLLIMPEXP_BASE wxDbTable
{
private:
ULONG tableID; // Used for debugging. This can help to match up mismatched constructors/destructors
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"
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,
//
// 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()
// 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)
// 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
// 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
// wxDirTraverser: helper class for wxDir::Traverse()
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxDirTraverser
+class WXDLLIMPEXP_BASE wxDirTraverser
{
public:
// called for each file found by wxDir::Traverse()
// 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
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:
/*
// wxDynamicLibrary - friendly interface to wxDllLoader
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxDynamicLibrary
+class WXDLLIMPEXP_BASE wxDynamicLibrary
{
public:
// ctors
// wxLibrary
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxLibrary : public wxObject
+class WXDLLIMPEXP_BASE wxLibrary : public wxObject
{
public:
wxLibrary(wxDllType handle);
// wxLibraries
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxLibraries
+class WXDLLIMPEXP_BASE wxLibraries
{
public:
wxLibraries();
// Global variables
// ----------------------------------------------------------------------------
-extern WXDLLEXPORT_DATA_BASE(wxLibraries) wxTheLibraries;
+extern WXDLLIMPEXP_DATA_BASE(wxLibraries) wxTheLibraries;
// ----------------------------------------------------------------------------
// Interesting defines
#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;
};
-class WXDLLEXPORT_BASE wxDynamicLibrary
+class WXDLLIMPEXP_BASE wxDynamicLibrary
{
public:
// instantiate this class directly anyway, use wxPluginManager
// instead.
-class WXDLLEXPORT_BASE wxPluginLibrary : public wxDynamicLibrary
+class WXDLLIMPEXP_BASE wxPluginLibrary : public wxDynamicLibrary
{
public:
};
-class WXDLLEXPORT_BASE wxPluginManager
+class WXDLLIMPEXP_BASE wxPluginManager
{
public:
// serves as a namespace for its static member functions.
#if WXWIN_COMPATIBILITY_2_2
-class WXDLLEXPORT_BASE wxDllLoader
+class WXDLLIMPEXP_BASE wxDllLoader
{
public:
// 8bit encodings/charsets. It can also convert from/to Unicode
//--------------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxEncodingConverter : public wxObject
+class WXDLLIMPEXP_BASE wxEncodingConverter : public wxObject
{
public:
// 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
// ----------------------------------------------------------------------------
#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
#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)
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
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)
//
// 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
*
*/
-class WXDLLEXPORT_BASE wxEvent : public wxObject
+class WXDLLIMPEXP_BASE wxEvent : public wxObject
{
private:
wxEvent& operator=(const wxEvent&);
wxEVT_COMMAND_TOGGLEBUTTON_CLICKED
*/
-class WXDLLEXPORT_CORE wxCommandEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxCommandEvent : public wxEvent
{
private:
wxCommandEvent& operator=(const wxCommandEvent& event);
// 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)
wxEVT_SCROLL_ENDSCROLL
*/
-class WXDLLEXPORT_CORE wxScrollEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxScrollEvent : public wxCommandEvent
{
public:
wxScrollEvent(wxEventType commandType = wxEVT_NULL,
wxEVT_SCROLLWIN_THUMBRELEASE
*/
-class WXDLLEXPORT_CORE wxScrollWinEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxScrollWinEvent : public wxEvent
{
public:
wxScrollWinEvent(wxEventType commandType = wxEVT_NULL,
wxMOUSE_BTN_RIGHT = 2
};
-class WXDLLEXPORT_CORE wxMouseEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxMouseEvent : public wxEvent
{
public:
wxMouseEvent(wxEventType mouseType = wxEVT_NULL);
wxEVT_SET_CURSOR
*/
-class WXDLLEXPORT_CORE wxSetCursorEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxSetCursorEvent : public wxEvent
{
public:
wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0)
wxEVT_KEY_UP
*/
-class WXDLLEXPORT_CORE wxKeyEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxKeyEvent : public wxEvent
{
public:
wxKeyEvent(wxEventType keyType = wxEVT_NULL);
wxEVT_SIZE
*/
-class WXDLLEXPORT_CORE wxSizeEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxSizeEvent : public wxEvent
{
public:
wxSizeEvent() : wxEvent(0, wxEVT_SIZE)
wxEVT_MOVE
*/
-class WXDLLEXPORT_CORE wxMoveEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxMoveEvent : public wxEvent
{
public:
wxMoveEvent()
#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)
DECLARE_DYNAMIC_CLASS(wxPaintEvent)
};
-class WXDLLEXPORT_CORE wxNcPaintEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxNcPaintEvent : public wxEvent
{
public:
wxNcPaintEvent(int winid = 0)
wxEVT_ERASE_BACKGROUND
*/
-class WXDLLEXPORT_CORE wxEraseEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxEraseEvent : public wxEvent
{
private:
wxEraseEvent& operator=(const wxEraseEvent& event);
wxEVT_KILL_FOCUS
*/
-class WXDLLEXPORT_CORE wxFocusEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxFocusEvent : public wxEvent
{
private:
wxFocusEvent& operator=(const wxFocusEvent& event);
// 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);
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)
wxEVT_INIT_DIALOG
*/
-class WXDLLEXPORT_CORE wxInitDialogEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxInitDialogEvent : public wxEvent
{
public:
wxInitDialogEvent(int Id = 0)
wxEVT_MENU_HIGHLIGHT,
*/
-class WXDLLEXPORT_CORE wxMenuEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxMenuEvent : public wxEvent
{
public:
wxMenuEvent(wxEventType type = wxEVT_NULL, int winid = 0)
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)
wxEVT_SHOW
*/
-class WXDLLEXPORT_CORE wxShowEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxShowEvent : public wxEvent
{
public:
wxShowEvent(int winid = 0, bool show = FALSE)
wxEVT_ICONIZE
*/
-class WXDLLEXPORT_CORE wxIconizeEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxIconizeEvent : public wxEvent
{
public:
wxIconizeEvent(int winid = 0, bool iconized = TRUE)
wxEVT_MAXIMIZE
*/
-class WXDLLEXPORT_CORE wxMaximizeEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxMaximizeEvent : public wxEvent
{
public:
wxMaximizeEvent(int winid = 0)
wxJOY_BUTTON4 = 8
};
-class WXDLLEXPORT_CORE wxJoystickEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxJoystickEvent : public wxEvent
{
public:
wxPoint m_pos;
wxEVT_DROP_FILES
*/
-class WXDLLEXPORT_CORE wxDropFilesEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxDropFilesEvent : public wxEvent
{
private:
wxDropFilesEvent& operator=(const wxDropFilesEvent& event);
wxEVT_UPDATE_UI
*/
-class WXDLLEXPORT_CORE wxUpdateUIEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxUpdateUIEvent : public wxCommandEvent
{
public:
wxUpdateUIEvent(wxWindowID commandId = 0)
*/
// TODO: shouldn't all events record the window ID?
-class WXDLLEXPORT_CORE wxSysColourChangedEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxSysColourChangedEvent : public wxEvent
{
public:
wxSysColourChangedEvent()
(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);
/*
wxEVT_DISPLAY_CHANGED
*/
-class WXDLLEXPORT_CORE wxDisplayChangedEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxDisplayChangedEvent : public wxEvent
{
private:
DECLARE_DYNAMIC_CLASS(wxDisplayChangedEvent)
wxEVT_PALETTE_CHANGED
*/
-class WXDLLEXPORT_CORE wxPaletteChangedEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxPaletteChangedEvent : public wxEvent
{
private:
wxPaletteChangedEvent& operator=(const wxPaletteChangedEvent& event);
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)
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);
wxEVT_DESTROY
*/
-class WXDLLEXPORT_CORE wxWindowCreateEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxWindowCreateEvent : public wxCommandEvent
{
public:
wxWindowCreateEvent(wxWindow *win = NULL);
DECLARE_DYNAMIC_CLASS(wxWindowCreateEvent)
};
-class WXDLLEXPORT_CORE wxWindowDestroyEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxWindowDestroyEvent : public wxCommandEvent
{
public:
wxWindowDestroyEvent(wxWindow *win = NULL);
wxEVT_DETAILED_HELP
*/
-class WXDLLEXPORT_CORE wxHelpEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxHelpEvent : public wxCommandEvent
{
public:
wxHelpEvent(wxEventType type = wxEVT_NULL,
wxEVT_CONTEXT_MENU
*/
-class WXDLLEXPORT_CORE wxContextMenuEvent : public wxCommandEvent
+class WXDLLIMPEXP_CORE wxContextMenuEvent : public wxCommandEvent
{
public:
wxContextMenuEvent(wxEventType type = wxEVT_NULL,
wxEVT_IDLE
*/
-class WXDLLEXPORT_CORE wxIdleEvent : public wxEvent
+class WXDLLIMPEXP_CORE wxIdleEvent : public wxEvent
{
public:
wxIdleEvent()
// 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
// 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);
};
// 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)
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)
// 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
// wxEvtHandler: the base class for all objects handling wxWindows events
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxEvtHandler : public wxObject
+class WXDLLIMPEXP_BASE wxEvtHandler : public wxObject
{
public:
wxEvtHandler();
// 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
// ----------------------------------------------------------------------------
// 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
// 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
// you call neither of them, dtor will call Discard().
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxTempFile
+class WXDLLIMPEXP_BASE wxTempFile
{
public:
// ctors
(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
#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
// ----------------------------------------------------------------------------
// 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
}
// 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
#include "wx/filefn.h"
#include "wx/datetime.h"
-class WXDLLEXPORT_BASE wxFile;
+class WXDLLIMPEXP_BASE wxFile;
// ----------------------------------------------------------------------------
// constants
// wxFileName: encapsulates a file path
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxFileName
+class WXDLLIMPEXP_BASE wxFileName
{
public:
// constructors and assignment
// (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,
// kinds of files (HTPP, FTP, local, tar.gz etc..)
//--------------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxFileSystemHandler : public wxObject
+class WXDLLIMPEXP_BASE wxFileSystemHandler : public wxObject
{
public:
wxFileSystemHandler() : wxObject() {}
// 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;}
*/
-class WXDLLEXPORT_BASE wxLocalFSHandler : public wxFileSystemHandler
+class WXDLLIMPEXP_BASE wxLocalFSHandler : public wxFileSystemHandler
{
public:
virtual bool CanOpen(const wxString& location);
#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
// ============================================================================
// in knowledge of the encodings equivalence
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxFontMapperBase
+class WXDLLIMPEXP_BASE wxFontMapperBase
{
public:
// constructtor and such
#if wxUSE_GUI
-class WXDLLEXPORT_CORE wxFontMapper : public wxFontMapperBase
+class WXDLLIMPEXP_CORE wxFontMapper : public wxFontMapperBase
{
public:
// default ctor
#else // !wxUSE_GUI
-class WXDLLEXPORT_BASE wxFontMapper : public wxFontMapperBase
+class WXDLLIMPEXP_BASE wxFontMapper : public wxFontMapperBase
{
};
// wxInternetFSHandler
//--------------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxInternetFSHandler : public wxFileSystemHandler
+class WXDLLIMPEXP_BASE wxInternetFSHandler : public wxFileSystemHandler
{
private:
wxHashTable m_Cache;
#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();
#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();
// pointers to objects
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxHashTableBase : public wxObject
+class WXDLLIMPEXP_BASE wxHashTableBase : public wxObject
{
public:
wxHashTableBase();
// 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)
// 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);
// for compatibility only
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxHashTable : public wxObject
+class WXDLLIMPEXP_BASE wxHashTable : public wxObject
{
public:
int n;
#include <stddef.h> // for ptrdiff_t
// private
-struct WXDLLEXPORT_BASE _wxHashTable_NodeBase
+struct WXDLLIMPEXP_BASE _wxHashTable_NodeBase
{
_wxHashTable_NodeBase() : m_nxt(0) {}
};
// private
-class WXDLLEXPORT_BASE _wxHashTableBase2
+class WXDLLIMPEXP_BASE _wxHashTableBase2
{
public:
typedef void (*NodeDtor)(_wxHashTable_NodeBase*);
// in the hash table class assignment operator (where they're assigned)
// integer types
-class WXDLLEXPORT_BASE wxIntegerHash
+class WXDLLIMPEXP_BASE wxIntegerHash
{
public:
wxIntegerHash() { }
wxIntegerHash& operator=(const wxIntegerHash&) { return *this; }
};
-class WXDLLEXPORT_BASE wxIntegerEqual
+class WXDLLIMPEXP_BASE wxIntegerEqual
{
public:
wxIntegerEqual() { }
};
// pointers
-class WXDLLEXPORT_BASE wxPointerHash
+class WXDLLIMPEXP_BASE wxPointerHash
{
public:
wxPointerHash() { }
wxPointerHash& operator=(const wxPointerHash&) { return *this; }
};
-class WXDLLEXPORT_BASE wxPointerEqual
+class WXDLLIMPEXP_BASE wxPointerEqual
{
public:
wxPointerEqual() { }
};
// wxString, char*, wxChar*
-class WXDLLEXPORT_BASE wxStringHash
+class WXDLLIMPEXP_BASE wxStringHash
{
public:
wxStringHash() {}
wxStringHash& operator=(const wxStringHash&) { return *this; }
};
-class WXDLLEXPORT_BASE wxStringEqual
+class WXDLLIMPEXP_BASE wxStringEqual
{
public:
wxStringEqual() {}
// 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
// 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
#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)
// 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
// translation information
// ----------------------------------------------------------------------------
-struct WXDLLEXPORT_BASE wxLanguageInfo
+struct WXDLLIMPEXP_BASE wxLanguageInfo
{
int Language; // wxLanguage id
wxString CanonicalName; // Canonical name, e.g. fr_FR
wxLOCALE_CONV_ENCODING = 0x0002 // convert encoding on the fly?
};
-class WXDLLEXPORT_BASE wxLocale
+class WXDLLIMPEXP_BASE wxLocale
{
public:
// ctor & dtor
// ----------------------------------------------------------------------------
// 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)
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)
};
-class WXDLLEXPORT_BASE wxServerBase: public wxObject
+class WXDLLIMPEXP_BASE wxServerBase: public wxObject
{
DECLARE_CLASS(wxServerBase)
virtual wxConnectionBase *OnAcceptConnection(const wxString& topic) = 0;
};
-class WXDLLEXPORT_BASE wxClientBase: public wxObject
+class WXDLLIMPEXP_BASE wxClientBase: public wxObject
{
DECLARE_CLASS(wxClientBase)
// 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
// 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
// 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:
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
// 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
// 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
// ----------------------------------------------------------------------------
#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
// ----------------------------------------------------------------------------
// normally, only a single instance of this class exists but it's not enforced
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxLog
+class WXDLLIMPEXP_BASE wxLog
{
public:
// ctor
// ----------------------------------------------------------------------------
// 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)
#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
// ~wxLogNull called, old log sink restored
}
*/
-class WXDLLEXPORT_BASE wxLogNull
+class WXDLLIMPEXP_BASE wxLogNull
{
public:
wxLogNull() : m_flagOld(wxLog::EnableLogging(FALSE)) { }
// does it itself in its ctor
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxLogChain : public wxLog
+class WXDLLIMPEXP_BASE wxLogChain : public wxLog
{
public:
wxLogChain(wxLog *logger);
};
// a chain log target which uses itself as the new logger
-class WXDLLEXPORT_BASE wxLogPassThrough : public wxLogChain
+class WXDLLIMPEXP_BASE wxLogPassThrough : public wxLogChain
{
public:
wxLogPassThrough();
// ----------------------------------------------------------------------------
// 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, \
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
inline void wxLog##level(arg, const wxChar *szFormat, ...) { }
// Empty Class to fake wxLogNull
-class WXDLLEXPORT_BASE wxLogNull
+class WXDLLIMPEXP_BASE wxLogNull
{
public:
wxLogNull() { }
#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
// 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);
// ----------------------------------------------------------------------------
#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
#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
#if wxUSE_LONGLONG_NATIVE
-class WXDLLEXPORT_BASE wxLongLongNative
+class WXDLLIMPEXP_BASE wxLongLongNative
{
public:
// ctors
};
-class WXDLLEXPORT_BASE wxULongLongNative
+class WXDLLIMPEXP_BASE wxULongLongNative
{
public:
// ctors
#if wxUSE_LONGLONG_WX
-class WXDLLEXPORT_BASE wxLongLongWx
+class WXDLLIMPEXP_BASE wxLongLongWx
{
public:
// ctors
};
-class WXDLLEXPORT_BASE wxULongLongWx
+class WXDLLIMPEXP_BASE wxULongLongWx
{
public:
// ctors
#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);
//**********************************************************************************
/*
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:
globals which have to do with the wxMemStruct class.
*/
-class WXDLLEXPORT_BASE wxDebugContext {
+class WXDLLIMPEXP_BASE wxDebugContext {
protected:
// Used to set alignment for markers.
};
// 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
// wxMemoryText
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxMemoryText : public wxTextBuffer
+class WXDLLIMPEXP_BASE wxMemoryText : public wxTextBuffer
{
public:
// Constructors.
#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()
/*
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
// This class is used with wxMimeTypesManager::AddFallbacks() and Associate()
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxFileTypeInfo
+class WXDLLIMPEXP_BASE wxFileTypeInfo
{
public:
// ctors
// 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
// given type) about them.
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxMimeTypesManager
+class WXDLLIMPEXP_BASE wxMimeTypesManager
{
public:
// static helper functions
// ----------------------------------------------------------------------------
// the default mime manager for wxWindows programs
-WXDLLEXPORT_DATA_BASE(extern wxMimeTypesManager *) wxTheMimeTypesManager;
+WXDLLIMPEXP_DATA_BASE(extern wxMimeTypesManager *) wxTheMimeTypesManager;
#endif // wxUSE_MIMETYPE
// 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() {}
// something you can printf() to
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxMessageOutput
+class WXDLLIMPEXP_BASE wxMessageOutput
{
public:
virtual ~wxMessageOutput() { }
// implementation which sends output to stderr
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxMessageOutputStderr : public wxMessageOutput
+class WXDLLIMPEXP_BASE wxMessageOutputStderr : public wxMessageOutput
{
public:
wxMessageOutputStderr() { }
#if wxUSE_GUI
-class WXDLLEXPORT_CORE wxMessageOutputMessageBox : public wxMessageOutput
+class WXDLLIMPEXP_CORE wxMessageOutputMessageBox : public wxMessageOutput
{
public:
wxMessageOutputMessageBox() { }
// implementation using the native way of outputting debug messages
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxMessageOutputDebug : public wxMessageOutput
+class WXDLLIMPEXP_BASE wxMessageOutputDebug : public wxMessageOutput
{
public:
wxMessageOutputDebug() { }
// implementation using wxLog (mainly for backwards compatibility)
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxMessageOutputLog : public wxMessageOutput
+class WXDLLIMPEXP_BASE wxMessageOutputLog : public wxMessageOutput
{
public:
wxMessageOutputLog() { }
#if wxUSE_STREAMS
-class WXDLLEXPORT_BASE wxMemoryInputStream : public wxInputStream
+class WXDLLIMPEXP_BASE wxMemoryInputStream : public wxInputStream
{
public:
wxMemoryInputStream(const void *data, size_t length);
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()
*
*/
-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:
DECLARE_NO_COPY_CLASS(wxDDEConnection)
};
-class WXDLLEXPORT_BASE wxDDEServer: public wxServerBase
+class WXDLLIMPEXP_BASE wxDDEServer: public wxServerBase
{
DECLARE_DYNAMIC_CLASS(wxDDEServer)
public:
wxDDEConnectionList m_connections;
};
-class WXDLLEXPORT_BASE wxDDEClient: public wxClientBase
+class WXDLLIMPEXP_BASE wxDDEClient: public wxClientBase
{
DECLARE_DYNAMIC_CLASS(wxDDEClient)
public:
wxDDEConnectionList m_connections;
};
-void WXDLLEXPORT_BASE wxDDEInitialize();
-void WXDLLEXPORT_BASE wxDDECleanUp();
+void WXDLLIMPEXP_BASE wxDDEInitialize();
+void WXDLLIMPEXP_BASE wxDDECleanUp();
#endif
// _WX_DDE_H_
// and is never used directly by the application
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxFileTypeImpl
+class WXDLLIMPEXP_BASE wxFileTypeImpl
{
public:
// ctor
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
// 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
#include "wx/defs.h"
#include "wx/memory.h"
-class WXDLLEXPORT_BASE wxObject;
+class WXDLLIMPEXP_BASE wxObject;
#if wxUSE_DYNAMIC_CLASSES
#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
typedef wxObject *(*wxObjectConstructorFn)(void);
-class WXDLLEXPORT_BASE wxClassInfo
+class WXDLLIMPEXP_BASE wxClassInfo
{
public:
wxClassInfo( const wxChar *className,
DECLARE_NO_COPY_CLASS(wxClassInfo)
};
-WXDLLEXPORT_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
+WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
// ----------------------------------------------------------------------------
// Dynamic class macros
// wxObject: the root class of wxWindows object hierarchy
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxObject
+class WXDLLIMPEXP_BASE wxObject
{
DECLARE_ABSTRACT_CLASS(wxObject)
// wxObjectRefData: ref counted data meant to be stored in wxObject
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxObjectRefData
+class WXDLLIMPEXP_BASE wxObjectRefData
{
- friend class WXDLLEXPORT_BASE wxObject;
+ friend class WXDLLIMPEXP_BASE wxObject;
public:
wxObjectRefData() : m_count(1) { }
// 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
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)
#include "wx/protocol/protocol.h"
#include "wx/url.h"
-class WXDLLEXPORT_BASE wxFTP : public wxProtocol
+class WXDLLIMPEXP_BASE wxFTP : public wxProtocol
{
public:
enum TransferMode
#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:
// wxProtocol: abstract base class for all protocols
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxProtocol
+class WXDLLIMPEXP_BASE wxProtocol
#if wxUSE_SOCKETS
: public wxSocketClient
#else
};
#if wxUSE_SOCKETS
-wxProtocolError WXDLLEXPORT_BASE GetLine(wxSocketBase *sock, wxString& result);
+wxProtocolError WXDLLIMPEXP_BASE GetLine(wxSocketBase *sock, wxString& result);
#endif
// ----------------------------------------------------------------------------
wxProtocolUserFor##class() { wxProtocolUse##class = TRUE; } \
} wxProtocolDoUse##class;
-class WXDLLEXPORT_BASE wxProtoInfo : public wxObject
+class WXDLLIMPEXP_BASE wxProtoInfo : public wxObject
{
public:
wxProtoInfo(const wxChar *name,
#if wxUSE_REGEX
-class WXDLLEXPORT_BASE wxString;
+class WXDLLIMPEXP_BASE wxString;
// ----------------------------------------------------------------------------
// constants
// 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
#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;
void Init();
};
-class WXDLLEXPORT_BASE wxIPV4address : public wxSockAddress {
+class WXDLLIMPEXP_BASE wxIPV4address : public wxSockAddress {
DECLARE_DYNAMIC_CLASS(wxIPV4address)
public:
wxIPV4address();
};
#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;
# 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;
*
*/
-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)
#include "wx/socket.h"
-class WXDLLEXPORT_BASE wxSocketOutputStream : public wxOutputStream
+class WXDLLIMPEXP_BASE wxSocketOutputStream : public wxOutputStream
{
public:
wxSocketOutputStream(wxSocketBase& s);
DECLARE_NO_COPY_CLASS(wxSocketOutputStream)
};
-class WXDLLEXPORT_BASE wxSocketInputStream : public wxInputStream
+class WXDLLIMPEXP_BASE wxSocketInputStream : public wxInputStream
{
public:
wxSocketInputStream(wxSocketBase& s);
DECLARE_NO_COPY_CLASS(wxSocketInputStream)
};
-class WXDLLEXPORT_BASE wxSocketStream : public wxSocketInputStream,
+class WXDLLIMPEXP_BASE wxSocketStream : public wxSocketInputStream,
public wxSocketOutputStream
{
public:
// wxSingleInstanceChecker
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxSingleInstanceChecker
+class WXDLLIMPEXP_BASE wxSingleInstanceChecker
{
public:
// default ctor, use Create() after it
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)
};
// wxSocketBase
// --------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxSocketBase : public wxObject
+class WXDLLIMPEXP_BASE wxSocketBase : public wxObject
{
DECLARE_CLASS(wxSocketBase)
// wxSocketServer
// --------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxSocketServer : public wxSocketBase
+class WXDLLIMPEXP_BASE wxSocketServer : public wxSocketBase
{
DECLARE_CLASS(wxSocketServer)
// wxSocketClient
// --------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxSocketClient : public wxSocketBase
+class WXDLLIMPEXP_BASE wxSocketClient : public wxSocketBase
{
DECLARE_CLASS(wxSocketClient)
// WARNING: still in alpha stage
-class WXDLLEXPORT_BASE wxDatagramSocket : public wxSocketBase
+class WXDLLIMPEXP_BASE wxDatagramSocket : public wxSocketBase
{
DECLARE_CLASS(wxDatagramSocket)
// wxSocketEvent
// --------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxSocketEvent : public wxEvent
+class WXDLLIMPEXP_BASE wxSocketEvent : public wxEvent
{
public:
wxSocketEvent(int id = 0)
#if wxUSE_STOPWATCH
-class WXDLLEXPORT_BASE wxStopWatch
+class WXDLLIMPEXP_BASE wxStopWatch
{
public:
// ctor starts the stop watch
// 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
// ----------------------------------------------------------------------------
// 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()
// wxMBConv (base class for conversions, using libc conversion itself)
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxMBConv
+class WXDLLIMPEXP_BASE wxMBConv
{
public:
// the actual conversion takes place here
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__
// 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
// 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);
};
#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
// 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
#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
// wxStreamBase: common (but non virtual!) base for all stream classes
// ---------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxStreamBase
+class WXDLLIMPEXP_BASE wxStreamBase
{
public:
wxStreamBase();
// 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
// wxOutputStream: base for the output streams
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxOutputStream : public wxStreamBase
+class WXDLLIMPEXP_BASE wxOutputStream : public wxStreamBase
{
public:
wxOutputStream();
// A stream for measuring streamed output
// ---------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxCountingOutputStream : public wxOutputStream
+class WXDLLIMPEXP_BASE wxCountingOutputStream : public wxOutputStream
{
public:
wxCountingOutputStream();
// "Filter" streams
// ---------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxFilterInputStream : public wxInputStream
+class WXDLLIMPEXP_BASE wxFilterInputStream : public wxInputStream
{
public:
wxFilterInputStream();
DECLARE_NO_COPY_CLASS(wxFilterInputStream)
};
-class WXDLLEXPORT_BASE wxFilterOutputStream : public wxOutputStream
+class WXDLLIMPEXP_BASE wxFilterOutputStream : public wxOutputStream
{
public:
wxFilterOutputStream();
// wxBufferedStreams to implement custom buffering
// ---------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxStreamBuffer
+class WXDLLIMPEXP_BASE wxStreamBuffer
{
public:
enum BufMode
// 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
// 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
// ----------------------------------------------------------------------------
// 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
}
// 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; }
// ---------------------------------------------------------------------------
// 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
// - 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
// 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
// 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()
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)
// 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)
{ 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; }
#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
// Enables an application to influence the wxWindows implementation
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxSystemOptions : public wxObject
+class WXDLLIMPEXP_BASE wxSystemOptions : public wxObject
{
public:
wxSystemOptions() { }
#endif // wxUSE_TEXTBUFFER
-class WXDLLEXPORT_BASE wxTextBuffer
+class WXDLLIMPEXP_BASE wxTextBuffer
{
public:
// constants and static functions
// wxTextFile
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxTextFile : public wxTextBuffer
+class WXDLLIMPEXP_BASE wxTextFile : public wxTextBuffer
{
public:
// constructors
// 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
// 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);
#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
wxEOL_DOS
} wxEOL;
-class WXDLLEXPORT_BASE wxTextOutputStream
+class WXDLLIMPEXP_BASE wxTextOutputStream
{
public:
#if wxUSE_UNICODE
wxURL_PROTOERR
} wxURLError;
-class WXDLLEXPORT_BASE wxURL : public wxObject
+class WXDLLIMPEXP_BASE wxURL : public wxObject
{
public:
wxURL(const wxString& url);
// 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
// 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
// ----------------------------------------------------------------------------
// 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
// 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
// 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);
};
// 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
// 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); }
// 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);
// ----------------------------------------------------------------------------
// 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)
// 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
* overloading wxVariant with unnecessary functionality.
*/
-class WXDLLEXPORT_BASE wxVariantData: public wxObject
+class WXDLLIMPEXP_BASE wxVariantData: public wxObject
{
DECLARE_ABSTRACT_CLASS(wxVariantData)
public:
* this class too much.
*/
-class WXDLLEXPORT_BASE wxVariant: public wxObject
+class WXDLLIMPEXP_BASE wxVariant: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxVariant)
public:
((classname*)(var.IsValueKindOf(&classname::sm_class##classname) ?\
var.GetWxObjectPtr() : NULL));
-extern wxVariant WXDLLEXPORT_BASE wxNullVariant;
+extern wxVariant WXDLLIMPEXP_BASE wxNullVariant;
#endif
// _WX_VARIANT_H_
#include "wx/defs.h"
-class WXDLLEXPORT_BASE wxVectorBase
+class WXDLLIMPEXP_BASE wxVectorBase
{
public:
typedef size_t size_type;
wxFS_VOL_MAX
};
-class WXDLLEXPORT_BASE wxFSVolumeBase
+class WXDLLIMPEXP_BASE wxFSVolumeBase
{
public:
// return the array containing the names of the volumes
// wxFileStream using wxFile
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxFileInputStream: public wxInputStream {
+class WXDLLIMPEXP_BASE wxFileInputStream: public wxInputStream {
public:
wxFileInputStream(const wxString& ifileName);
wxFileInputStream(wxFile& file);
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);
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);
};
// wxFFileStream using wxFFile
// ----------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxFFileInputStream: public wxInputStream {
+class WXDLLIMPEXP_BASE wxFFileInputStream: public wxInputStream {
public:
wxFFileInputStream(const wxString& ifileName);
wxFFileInputStream(wxFFile& file);
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);
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);
};
#define wxStrdup wxStrdupA
#endif
-WXDLLEXPORT_BASE bool wxOKlibc(); // for internal use
+WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
// ----------------------------------------------------------------------------
// printf() family saga
#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
//
// 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
//
// 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
// 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
#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
#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
//--------------------------------------------------------------------------------
-class WXDLLEXPORT_BASE wxZipInputStream : public wxInputStream
+class WXDLLIMPEXP_BASE wxZipInputStream : public wxInputStream
{
public:
wxZipInputStream(const wxString& archive, const wxString& file);
#include "wx/stream.h"
-class WXDLLEXPORT_BASE wxZlibInputStream: public wxFilterInputStream {
+class WXDLLIMPEXP_BASE wxZlibInputStream: public wxFilterInputStream {
public:
wxZlibInputStream(wxInputStream& stream);
virtual ~wxZlibInputStream();
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();
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;
}
// 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,
// font encoding <-> Win32 codepage conversion functions
// ----------------------------------------------------------------------------
-extern WXDLLEXPORT_BASE long wxEncodingToCharset(wxFontEncoding encoding)
+extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
{
switch ( 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);
projects / wxWidgets.git / commitdiff
