\section{\class{wxString}}\label{wxstring}
-\overview{Overview}{wxstringoverview}
+\wxheading{Derived from}
+
+None
-\helpref{Member functions by category}{wxstringcategories}
+\wxheading{See also}
+
+\overview{Overview}{wxstringoverview}
-{\bf CAVE:} The description of the memberfunctions is very
-sparse in the moment. It will be extended in the next
-version of the help file. The list of memberfunctions
-is complete.
+\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxString::wxString}\label{wxstringconstruct}
-\func{void}{wxString}{\param{void}{}}\\
-\func{void}{wxString}{\param{const wxString\&}{ x}}\\
-\func{void}{wxString}{\param{const wxSubString\&}{ x}}\\
-\func{void}{wxString}{\param{const char*}{ t}}\\
-\func{void}{wxString}{\param{const char*}{ t}, \param{int}{ len}}\\
-\func{void}{wxString}{\param{char}{ c}}
+\func{}{wxString}{\void}
-Constructors.
+Default constructor.
-\membersection{wxString::\destruct{wxString}}\label{wxstringdestruct}
+\func{}{wxString}{\param{const wxString\&}{ x}}
-\func{void}{\destruct{wxString}}{\void}
+Copy constructor.
-String destructor.
+\func{}{wxString}{\param{char}{ ch}, \param{size\_t}{ n = 1}}
-\membersection{wxString::Alloc}\label{wxstringAlloc}
+Constructs a string of {\it n} copies of character {\it ch}.
-\func{void}{Alloc}{\param{int}{ newsize}}
+\func{}{wxString}{\param{const char*}{ psz}, \param{size\_t}{ nLength = STRING\_MAXLEN}}
-Preallocate some space for wxString.
+Takes first {\it nLength} characters from the C string {\it psz}.
+The default value of STRING\_MAXLEN means take all the string.
-\membersection{wxString::Allocation}\label{wxstringAllocation}
+\func{}{wxString}{\param{const unsigned char*}{ psz}, \param{size\_t}{ nLength = STRING\_MAXLEN}}
-\func{int}{Allocation}{\param{void}{}} \param{ const}{}
+For compilers using unsigned char: takes first {\it nLength} characters from the C string {\it psz}.
+The default value of STRING\_MAXLEN means take all the string.
-Report current allocation (not length!).
+\func{}{wxString}{\param{const wchar\_t*}{ psz}}
-\membersection{wxString::Append}\label{wxstringAppend}
+Constructs a string from the wide (UNICODE) string.
-\func{wxString\&}{Append}{\param{const char*}{ cs}}\\
-\func{wxString\&}{Append}{\param{const wxString\&}{ s}}
+\membersection{wxString::\destruct{wxString}}\label{wxstringdestruct}
-Concatenation.
+\func{}{\destruct{wxString}}{\void}
-\func{wxString\&}{Append}{\param{char}{ c}, \param{int}{ rep = 1}}
+String destructor. Note that this is not virtual, so wxString must not be inherited from.
-Append {\it c}, {\it rep} times
+\membersection{wxString::Alloc}\label{wxstringAlloc}
-\membersection{wxString::After}\label{wxstringAfter}
+\func{void}{Alloc}{\param{uint}{ newsize}}
-\func{wxSubString}{After}{\param{int}{ pos}}\\
-\func{wxSubString}{After}{\param{const wxString\&}{ x}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{After}{\param{const wxSubString\&}{ x}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{After}{\param{const char*}{ t}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{After}{\param{char}{ c}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{After}{\param{const wxRegex\&}{ r}, \param{int}{ startpos = 0}}
+Preallocate some space for wxString. Only works if the data of this string is not shared.
-\membersection{wxString::At}\label{wxstringAt}
+\membersection{wxString::Append}\label{wxstringAppend}
+
+\func{wxString\&}{Append}{\param{const char*}{ psz}}
-\func{wxSubString}{At}{\param{int}{ pos}, \param{int}{ len}}\\
-\func{wxSubString}{operator ()}{\param{int}{ pos}, \param{int}{ len}}\\
-\func{wxSubString}{At}{\param{const wxString\&}{ x}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{At}{\param{const wxSubString\&}{ x}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{At}{\param{const char*}{ t}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{At}{\param{char}{ c}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{At}{\param{const wxRegex\&}{ r}, \param{int}{ startpos = 0}}
+Concatenates {\it psz} to this string, returning a reference to it.
-wxSubString extraction.
+\func{wxString\&}{Append}{\param{char}{ ch}, \param{int}{ count = 1}}
-Note that you can't take a substring of a const wxString, since
-this leaves open the possiblility of indirectly modifying the
-wxString through the wxSubString.
+Concatenates character {\it ch} to this string, {\it count} times, returning a reference
+to it.
+
+\membersection{wxString::After}\label{wxstringAfter}
+
+\constfunc{wxString}{After}{\param{char}{ ch}}
+
+Gets all the characters after the first occurence of {\it ch}.
+Returns the empty string if {\it ch} is not found.
\membersection{wxString::Before}\label{wxstringBefore}
-\func{wxSubString}{Before}{\param{int}{ pos}}\\
-\func{wxSubString}{Before}{\param{const wxString\&}{ x}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{Before}{\param{const wxSubString\&}{ x}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{Before}{\param{const char*}{ t}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{Before}{\param{char}{ c}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{Before}{\param{const wxRegex\&}{ r}, \param{int}{ startpos = 0}}
-
-\membersection{wxString::Capitalize}\label{wxstringCapitalize}
-
-\func{void}{Capitalize}{\param{void}{}}\\
-\func{friend wxString}{Capitalize}{\param{wxString\&}{ x}}
-
-\membersection{wxString::Cat}\label{wxstringCat}
-
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const wxString\&}{ b}, \param{wxString\&}{ c}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const wxSubString\&}{ b}, \param{wxString\&}{ c}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const char*}{ b}, \param{wxString\&}{ c}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{char}{ b}, \param{wxString\&}{ c}}\\
-\func{friend void}{Cat}{\param{const wxSubString\&}{ a}, \param{const wxString\&}{ b}, \param{wxString\&}{ c}}\\
-\func{friend void}{Cat}{\param{const wxSubString\&}{ a}, \param{const wxSubString\&}{ b}, \param{wxString\&}{ c}}\\
-\func{friend void}{Cat}{\param{const wxSubString\&}{ a}, \param{const char*}{ b}, \param{wxString\&}{ c}}\\
-\func{friend void}{Cat}{\param{const wxSubString\&}{ a}, \param{char}{ b}, \param{wxString\&}{ c}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const wxString\&}{ b}, \param{wxString\&}{ c}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const wxSubString\&}{ b}, \param{wxString\&}{ c}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const char*}{ b}, \param{wxString\&}{ c}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{char}{ b}, \param{wxString\&}{ c}}
-
-Concatenate first two arguments, store the result in the last argument.
-
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const wxString\&}{ b}, \param{const wxString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const wxString\&}{ b}, \param{const wxSubString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const wxString\&}{ b}, \param{const char*}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const wxString\&}{ b}, \param{char}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const wxSubString\&}{ b}, \param{const wxString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const wxSubString\&}{ b}, \param{const wxSubString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const wxSubString\&}{ b}, \param{const char*}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const wxSubString\&}{ b}, \param{char}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const char*}{ b}, \param{const wxString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const char*}{ b}, \param{const wxSubString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const char*}{ b}, \param{const char*}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const wxString\&}{ a}, \param{const char*}{ b}, \param{char}{ c}, \param{wxString\&}{ d}}
-
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const wxString\&}{ b}, \param{const wxString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const wxString\&}{ b}, \param{const wxSubString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const wxString\&}{ b}, \param{const char*}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const wxString\&}{ b}, \param{char}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const wxSubString\&}{ b}, \param{const wxString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const wxSubString\&}{ b}, \param{const wxSubString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const wxSubString\&}{ b}, \param{const char*}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const wxSubString\&}{ b}, \param{char}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const char*}{ b}, \param{const wxString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const char*}{ b}, \param{const wxSubString\&}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const char*}{ b}, \param{const char*}{ c}, \param{wxString\&}{ d}}\\
-\func{friend void}{Cat}{\param{const char*}{ a}, \param{const char*}{ b}, \param{char}{ c}, \param{wxString\&}{ d}}
-
-Double concatenation, by request. (Yes, there are too many versions,
-but if one is supported, then the others should be too).
-Concatenate the first 3 args, store the result in the last argument.
-
-\membersection{wxString::Chars}\label{wxstringChars}
-
-\func{const char*}{Chars}{\param{void}{}} \param{ const}{}
+\constfunc{wxString}{Before}{\param{char}{ ch}}
-Conversion.
+Gets all characters before the last occurence of {\it ch}.
+Returns empty string if {\it ch} is not found.
\membersection{wxString::CompareTo}\label{wxstringCompareTo}
\begin{verbatim}
#define NO_POS ((int)(-1)) // undefined position
-enum CaseCompare {exact, ignoreCase};
+enum caseCompare {exact, ignoreCase};
\end{verbatim}
-\func{int}{CompareTo}{\param{const char*}{ cs}, \param{CaseCompare}{ cmp = exact}} \param{ const}{}\\
-\func{int}{CompareTo}{\param{const wxString\&}{ cs}, \param{CaseCompare}{ cmp = exact}} \param{ const}{}
-
-\membersection{wxString::Contains}\label{wxstringContains}
-
-\func{bool}{Contains}{\param{char}{ c}} \param{ const}{}\\
-\func{bool}{Contains}{\param{const wxString\&}{ y}} \param{ const}{}\\
-\func{bool}{Contains}{\param{const wxSubString\&}{ y}} \param{ const}{}\\
-\func{bool}{Contains}{\param{const char*}{ t}} \param{ const}{}\\
-\func{bool}{Contains}{\param{const wxRegex\&}{ r}} \param{ const}{}
+\constfunc{int}{CompareTo}{\param{const char*}{ psz}, \param{caseCompare}{ cmp = exact}}
-Return 1 if target appears anyhere in wxString; else 0.
+Case-sensitive comparison. Returns 0 if equal, 1 if greater or -1 if less.
-\func{bool}{Contains}{\param{const char*}{ pat}, \param{CaseCompare}{ cmp}} \param{ const}{}\\
-\func{bool}{Contains}{\param{const wxString\&}{ pat}, \param{CaseCompare}{ cmp}} \param{ const}{}
-
-Case dependent/independent variation .
-
-\func{bool}{Contains}{\param{char}{ c}, \param{int}{ pos}} \param{ const}{}\\
-\func{bool}{Contains}{\param{const wxString\&}{ y}, \param{int}{ pos}} \param{ const}{}\\
-\func{bool}{Contains}{\param{const wxSubString\&}{ y}, \param{int}{ pos}} \param{ const}{}\\
-\func{bool}{Contains}{\param{const char*}{ t}, \param{int}{ pos}} \param{ const}{}\\
-\func{bool}{Contains}{\param{const wxRegex\&}{ r}, \param{int}{ pos}} \param{ const}{}
-
-Return 1 if the target appears anywhere after position {\it pos} (or
-before, if {\it pos} is negative) in wxString; else 0.
-
-\membersection{wxString::Copy}\label{wxstringCopy}
+\membersection{wxString::Contains}\label{wxstringContains}
-\func{wxString}{Copy}{\param{void}{}} \param{ const}{}
+\func{bool}{Contains}{\param{const wxString\&}{ str}}
-Duplication.
+Returns 1 if target appears anyhere in wxString; else 0.
-\membersection{wxString::Del}\label{wxstringDel}
+\membersection{wxString::IsEmpty}\label{wxstringisempty}
-\func{wxString\&}{Del}{\param{int}{ pos}, \param{int}{ len}}
+\constfunc{bool}{IsEmpty}{\void}
-Delete {\it len} characters starting at {\it pos}.
+\membersection{wxString::First}\label{wxstringfirst}
-\func{wxString\&}{Del}{\param{const wxString\&}{ y}, \param{int}{ startpos = 0}}\\
-\func{wxString\&}{Del}{\param{const wxSubString\&}{ y}, \param{int}{ startpos = 0}}\\
-\func{wxString\&}{Del}{\param{const char*}{ t}, \param{int}{ startpos = 0}}\\
-\func{wxString\&}{Del}{\param{char}{ c}, \param{int}{ startpos = 0}}\\
-\func{wxString\&}{Del}{\param{const wxRegex\&}{ r}, \param{int}{ startpos = 0}}
+\func{size\_t}{First}{\param{char}{ c}}
-Delete the first occurrence of target after {\it startpos}.
+\constfunc{size\_t}{First}{\param{const char*}{ psz}}
-\membersection{wxString::DownCase}\label{wxstringDownCase}
+\constfunc{size\_t}{First}{\param{const wxString\&}{ str}}
-\func{void}{Downcase}{\param{void}{}}\\
-\func{friend wxString}{Downcase}{\param{wxString\&}{ x}}
+\constfunc{size\_t}{First}{\param{const char}{ ch}}
-\membersection{wxString::Elem}\label{wxstringElem}
+Returns first occurrence of item.
-\func{char}{Elem}{\param{int}{ i}} \param{ const}{}
-Element extraction.
-\membersection{wxString::Empty}\label{wxstringEmpty}
-\func{int}{Empty}{\param{void}{}} \param{ const}{}
-\membersection{wxString::Error}\label{wxstringError}
-\func{void}{Error}{\param{const char*}{ msg}} \param{ const}{}
-\membersection{wxString::First}\label{wxstringFirst}
-\func{int}{First}{\param{char}{ c}} \param{ const}{}\\
-\func{int}{First}{\param{const char*}{ cs}} \param{ const}{}\\
-\func{int}{First}{\param{const wxString\&}{ cs}} \param{ const}{}
-Return first or last occurrence of item.
\membersection{wxString::Firstchar}\label{wxstringFirstchar}
\func{char}{Firstchar}{\param{void}{}} \param{ const}{}
class WXDLLEXPORT wxDDEConnection: public wxConnectionBase
{
DECLARE_DYNAMIC_CLASS(wxDDEConnection)
- public:
- char *buf_ptr;
- wxString topic_name;
- int buf_size;
- wxDDEServer *server;
- wxDDEClient *client;
-
- WXHCONV hConv;
- char *sending_data;
- int data_size;
- int data_type;
-
+public:
wxDDEConnection(char *buffer, int size);
wxDDEConnection(void);
~wxDDEConnection(void);
// Calls that CLIENT can make
- virtual bool Execute(char *data, int size = -1, int format = wxCF_TEXT);
- virtual bool Execute(const wxString& str) { return Execute((char *)(const char *)str, -1, wxCF_TEXT); }
- virtual char *Request(const wxString& item, int *size = NULL, int format = wxCF_TEXT);
- virtual bool Poke(const wxString& item, char *data, int size = -1, int format = wxCF_TEXT);
+ virtual bool Execute(char *data, int size = -1, wxDataFormat format = wxDF_TEXT);
+ virtual bool Execute(const wxString& str) { return Execute((char *)(const char *)str, -1, wxDF_TEXT); }
+ virtual char *Request(const wxString& item, int *size = NULL, wxDataFormat format = wxDF_TEXT);
+ virtual bool Poke(const wxString& item, char *data, int size = -1, wxDataFormat format = wxDF_TEXT);
virtual bool StartAdvise(const wxString& item);
virtual bool StopAdvise(const wxString& item);
// Calls that SERVER can make
- virtual bool Advise(const wxString& item, char *data, int size = -1, int format = wxCF_TEXT);
+ virtual bool Advise(const wxString& item, char *data, int size = -1, wxDataFormat format = wxDF_TEXT);
// Calls that both can make
virtual bool Disconnect(void);
// Callbacks to SERVER - override at will
- virtual bool OnExecute(const wxString& topic, char *data, int size, int format) { return FALSE; };
- virtual char *OnRequest(const wxString& topic, const wxString& item, int *size, int format) { return NULL; };
- virtual bool OnPoke(const wxString& topic, const wxString& item, char *data, int size, int format) { return FALSE; };
+ virtual bool OnExecute(const wxString& topic, char *data, int size, wxDataFormat format) { return FALSE; };
+ virtual char *OnRequest(const wxString& topic, const wxString& item, int *size, wxDataFormat format) { return NULL; };
+ virtual bool OnPoke(const wxString& topic, const wxString& item, char *data, int size, wxDataFormat format) { return FALSE; };
virtual bool OnStartAdvise(const wxString& topic, const wxString& item) { return FALSE; };
virtual bool OnStopAdvise(const wxString& topic, const wxString& item) { return FALSE; };
// Callbacks to CLIENT - override at will
- virtual bool OnAdvise(const wxString& topic, const wxString& item, char *data, int size, int format) { return FALSE; };
+ virtual bool OnAdvise(const wxString& topic, const wxString& item, char *data, int size, wxDataFormat format) { return FALSE; };
// Callbacks to BOTH
// Default behaviour is to delete connection and return TRUE
virtual bool OnDisconnect(void);
+
+ public:
+ char* m_bufPtr;
+ wxString m_topicName;
+ int m_bufSize;
+ wxDDEServer* m_server;
+ wxDDEClient* m_client;
+
+ WXHCONV m_hConv;
+ char* m_sendingData;
+ int m_dataSize;
+ wxDataFormat m_dataType;
};
class WXDLLEXPORT wxDDEServer: public wxServerBase
// Find/delete wxDDEConnection corresponding to the HCONV
wxDDEConnection *FindConnection(WXHCONV conv);
bool DeleteConnection(WXHCONV conv);
- inline wxString& GetServiceName(void) const { return (wxString&) service_name; }
- inline wxList& GetConnections(void) const { return (wxList&) connections; }
+ inline wxString& GetServiceName(void) const { return (wxString&) m_serviceName; }
+ inline wxList& GetConnections(void) const { return (wxList&) m_connections; }
protected:
- int lastError;
- wxString service_name;
- wxList connections;
+ int m_lastError;
+ wxString m_serviceName;
+ wxList m_connections;
};
class WXDLLEXPORT wxDDEClient: public wxClientBase
// Find/delete wxDDEConnection corresponding to the HCONV
wxDDEConnection *FindConnection(WXHCONV conv);
bool DeleteConnection(WXHCONV conv);
- inline wxList& GetConnections(void) const { return (wxList&) connections; }
+ inline wxList& GetConnections(void) const { return (wxList&) m_connections; }
protected:
- int lastError;
- wxList connections;
+ int m_lastError;
+ wxList m_connections;
};
void WXDLLEXPORT wxDDEInitialize();
// implement base class pure virtuals
virtual wxDataFormat GetPreferredFormat() const
- { return wxDataObject::Text; }
+ { return (wxDataFormat) wxDataObject::Text; }
virtual bool IsSupportedFormat(wxDataFormat format) const
{ return format == wxDataObject::Text || format == wxDataObject::Locale; }
virtual uint GetDataSize() const
{
switch (dataFormat)
{
- case wxCF_BITMAP:
+ case wxDF_BITMAP:
{
wxBitmap *wxBM = (wxBitmap *)obj;
return success;
break;
}
- case wxCF_DIB:
+ case wxDF_DIB:
{
#if USE_IMAGE_LOADING_IN_MSW
HBITMAP hBitmap=(HBITMAP) ((wxBitmap *)obj)->GetHBITMAP();
break;
}
#if USE_METAFILE
- case wxCF_METAFILE:
+ case wxDF_METAFILE:
{
wxMetaFile *wxMF = (wxMetaFile *)obj;
HANDLE data = GlobalAlloc(GHND, sizeof(METAFILEPICT) + 1);
return FALSE;
break;
}
- case wxCF_OEMTEXT:
- dataFormat = wxCF_TEXT;
- case wxCF_TEXT:
+ case wxDF_OEMTEXT:
+ dataFormat = wxDF_TEXT;
+ case wxDF_TEXT:
width = strlen((char *)obj) + 1;
height = 1;
default:
{
switch (dataFormat)
{
- case wxCF_BITMAP:
+ case wxDF_BITMAP:
{
BITMAP bm;
HBITMAP hBitmap = (HBITMAP) GetClipboardData(CF_BITMAP);
return (wxObject *)wxBM;
break;
}
- case wxCF_METAFILE:
+ case wxDF_METAFILE:
case CF_SYLK:
case CF_DIF:
case CF_TIFF:
case CF_PALETTE:
- case wxCF_DIB:
+ case wxDF_DIB:
{
return FALSE;
break;
}
- case wxCF_OEMTEXT:
- dataFormat = wxCF_TEXT;
- case wxCF_TEXT:
+ case wxDF_OEMTEXT:
+ dataFormat = wxDF_TEXT;
+ case wxDF_TEXT:
default:
{
HANDLE hGlobalMemory = GetClipboardData(dataFormat);
static int FormatStringToID(char *str)
{
if (!strcmp(str, "TEXT"))
- return wxCF_TEXT;
-
+ return wxDF_TEXT;
+
return wxRegisterClipboardFormat(str);
}
cbString = str;
if (wxOpenClipboard()) {
- if (!wxSetClipboardData(wxCF_TEXT, (wxObject *)str))
+ if (!wxSetClipboardData(wxDF_TEXT, (wxObject *)str))
got_selection = FALSE;
else
got_selection = wxCloseClipboard();
SendMessage(hWnd, WM_CUT, (WPARAM)0, (LPARAM)0);
// Now replace with 'value', by pasting.
- wxSetClipboardData(wxCF_TEXT, (wxObject *)(const char *)value, 0, 0);
+ wxSetClipboardData(wxDF_TEXT, (wxObject *)(const char *)value, 0, 0);
// Paste into edit control
SendMessage(hWnd, WM_PASTE, (WPARAM)0, (LPARAM)0L);
wxDDEServer::wxDDEServer(void)
{
- service_name = "";
+ m_serviceName = "";
wxDDEServerObjects.Append(this);
}
bool wxDDEServer::Create(const wxString& server_name)
{
- service_name = server_name;
+ m_serviceName = server_name;
HSZ serviceName = DdeCreateStringHandle(DDEIdInst, (char*) (const char *)server_name, CP_WINANSI);
if (DdeNameService(DDEIdInst, serviceName, NULL, DNS_REGISTER) == 0)
wxDDEServer::~wxDDEServer(void)
{
- if (service_name != "")
+ if (m_serviceName != "")
{
- HSZ serviceName = DdeCreateStringHandle(DDEIdInst, (char*) (const char *)service_name, CP_WINANSI);
+ HSZ serviceName = DdeCreateStringHandle(DDEIdInst, (char*) (const char *)m_serviceName, CP_WINANSI);
if (DdeNameService(DDEIdInst, serviceName, NULL, DNS_UNREGISTER) == 0)
{
DDEPrintError();
}
wxDDEServerObjects.DeleteObject(this);
- wxNode *node = connections.First();
+ wxNode *node = m_connections.First();
while (node)
{
wxDDEConnection *connection = (wxDDEConnection *)node->Data();
}
// If any left after this, delete them
- node = connections.First();
+ node = m_connections.First();
while (node)
{
wxDDEConnection *connection = (wxDDEConnection *)node->Data();
wxDDEConnection *wxDDEServer::FindConnection(WXHCONV conv)
{
- wxNode *node = connections.First();
+ wxNode *node = m_connections.First();
wxDDEConnection *found = NULL;
while (node && !found)
{
wxDDEConnection *connection = (wxDDEConnection *)node->Data();
- if (connection->hConv == conv)
+ if (connection->m_hConv == conv)
found = connection;
else node = node->Next();
}
// Only delete the entry in the map, not the actual connection
bool wxDDEServer::DeleteConnection(WXHCONV conv)
{
- wxNode *node = connections.First();
+ wxNode *node = m_connections.First();
bool found = FALSE;
while (node && !found)
{
wxDDEConnection *connection = (wxDDEConnection *)node->Data();
- if (connection->hConv == conv)
+ if (connection->m_hConv == conv)
{
found = TRUE;
delete node;
wxDDEClient::~wxDDEClient(void)
{
wxDDEClientObjects.DeleteObject(this);
- wxNode *node = connections.First();
+ wxNode *node = m_connections.First();
while (node)
{
wxDDEConnection *connection = (wxDDEConnection *)node->Data();
delete connection; // Deletes the node implicitly (see ~wxDDEConnection)
- node = connections.First();
+ node = m_connections.First();
}
}
wxDDEConnection *connection = (wxDDEConnection*) OnMakeConnection();
if (connection)
{
- connection->hConv = (WXHCONV) hConv;
- connection->topic_name = topic;
- connection->client = this;
- connections.Append(connection);
+ connection->m_hConv = (WXHCONV) hConv;
+ connection->m_topicName = topic;
+ connection->m_client = this;
+ m_connections.Append(connection);
return connection;
}
else return NULL;
wxDDEConnection *wxDDEClient::FindConnection(WXHCONV conv)
{
- wxNode *node = connections.First();
+ wxNode *node = m_connections.First();
wxDDEConnection *found = NULL;
while (node && !found)
{
wxDDEConnection *connection = (wxDDEConnection *)node->Data();
- if (connection->hConv == conv)
+ if (connection->m_hConv == conv)
found = connection;
else node = node->Next();
}
// Only delete the entry in the map, not the actual connection
bool wxDDEClient::DeleteConnection(WXHCONV conv)
{
- wxNode *node = connections.First();
+ wxNode *node = m_connections.First();
bool found = FALSE;
while (node && !found)
{
wxDDEConnection *connection = (wxDDEConnection *)node->Data();
- if (connection->hConv == conv)
+ if (connection->m_hConv == conv)
{
found = TRUE;
delete node;
{
if (DDEDefaultIPCBuffer == NULL)
DDEDefaultIPCBuffer = new char[DDEDefaultIPCBufferSize];
- buf_ptr = DDEDefaultIPCBuffer;
- buf_size = DDEDefaultIPCBufferSize;
+ m_bufPtr = DDEDefaultIPCBuffer;
+ m_bufSize = DDEDefaultIPCBufferSize;
}
else
{
- buf_ptr = buffer;
- buf_size = size;
+ m_bufPtr = buffer;
+ m_bufSize = size;
}
- topic_name = "";
+ m_topicName = "";
- client = NULL;
- server = NULL;
+ m_client = NULL;
+ m_server = NULL;
- hConv = 0;
- sending_data = NULL;
+ m_hConv = 0;
+ m_sendingData = NULL;
}
wxDDEConnection::wxDDEConnection(void)
{
- hConv = 0;
- sending_data = NULL;
- server = NULL;
- client = NULL;
+ m_hConv = 0;
+ m_sendingData = NULL;
+ m_server = NULL;
+ m_client = NULL;
if (DDEDefaultIPCBuffer == NULL)
DDEDefaultIPCBuffer = new char[DDEDefaultIPCBufferSize];
- buf_ptr = DDEDefaultIPCBuffer;
- buf_size = DDEDefaultIPCBufferSize;
- topic_name = "";
+ m_bufPtr = DDEDefaultIPCBuffer;
+ m_bufSize = DDEDefaultIPCBufferSize;
+ m_topicName = "";
}
wxDDEConnection::~wxDDEConnection(void)
{
- if (server)
- server->GetConnections().DeleteObject(this);
+ if (m_server)
+ m_server->GetConnections().DeleteObject(this);
else
- client->GetConnections().DeleteObject(this);
+ m_client->GetConnections().DeleteObject(this);
}
// Calls that CLIENT can make
bool wxDDEConnection::Disconnect(void)
{
- DDEDeleteConnection((HCONV) hConv);
- return (DdeDisconnect((HCONV) hConv) != 0);
+ DDEDeleteConnection((HCONV) m_hConv);
+ return (DdeDisconnect((HCONV) m_hConv) != 0);
}
-bool wxDDEConnection::Execute(char *data, int size, int format)
+bool wxDDEConnection::Execute(char *data, int size, wxDataFormat format)
{
DWORD result;
if (size < 0)
size ++;
- return (DdeClientTransaction((LPBYTE)data, size, (HCONV) hConv,
+ return (DdeClientTransaction((LPBYTE)data, size, (HCONV) m_hConv,
NULL, format, XTYP_EXECUTE, 5000, &result) ? TRUE : FALSE);
}
-char *wxDDEConnection::Request(const wxString& item, int *size, int format)
+char *wxDDEConnection::Request(const wxString& item, int *size, wxDataFormat format)
{
DWORD result;
HSZ atom = DDEGetAtom(item);
- HDDEDATA returned_data = DdeClientTransaction(NULL, 0, (HCONV) hConv,
+ HDDEDATA returned_data = DdeClientTransaction(NULL, 0, (HCONV) m_hConv,
atom, format, XTYP_REQUEST, 5000, &result);
- DWORD len = DdeGetData(returned_data, (LPBYTE)(buf_ptr), buf_size, 0);
+ DWORD len = DdeGetData(returned_data, (LPBYTE)(m_bufPtr), m_bufSize, 0);
DdeFreeDataHandle(returned_data);
if (size) *size = (int)len;
if (len > 0)
{
- return buf_ptr;
+ return m_bufPtr;
}
else return NULL;
}
-bool wxDDEConnection::Poke(const wxString& item, char *data, int size, int format)
+bool wxDDEConnection::Poke(const wxString& item, char *data, int size, wxDataFormat format)
{
DWORD result;
if (size < 0)
size ++;
HSZ item_atom = DDEGetAtom(item);
- return (DdeClientTransaction((LPBYTE)data, size, (HCONV) hConv,
+ return (DdeClientTransaction((LPBYTE)data, size, (HCONV) m_hConv,
item_atom, format, XTYP_POKE, 5000, &result) ? TRUE : FALSE);
}
DWORD result;
HSZ atom = DDEGetAtom(item);
- return (DdeClientTransaction(NULL, 0, (HCONV) hConv,
+ return (DdeClientTransaction(NULL, 0, (HCONV) m_hConv,
atom, CF_TEXT, XTYP_ADVSTART, 5000, &result) ? TRUE : FALSE);
}
DWORD result;
HSZ atom = DDEGetAtom(item);
- return (DdeClientTransaction(NULL, 0, (HCONV) hConv,
+ return (DdeClientTransaction(NULL, 0, (HCONV) m_hConv,
atom, CF_TEXT, XTYP_ADVSTOP, 5000, &result) ? TRUE : FALSE);
}
// Calls that SERVER can make
-bool wxDDEConnection::Advise(const wxString& item, char *data, int size, int format)
+bool wxDDEConnection::Advise(const wxString& item, char *data, int size, wxDataFormat format)
{
if (size < 0)
size = strlen(data);
size ++;
HSZ item_atom = DDEGetAtom(item);
- HSZ topic_atom = DDEGetAtom(topic_name);
- sending_data = data;
- data_size = size;
- data_type = format;
+ HSZ topic_atom = DDEGetAtom(m_topicName);
+ m_sendingData = data;
+ m_dataSize = size;
+ m_dataType = format;
return (DdePostAdvise(DDEIdInst, topic_atom, item_atom) != 0);
}
(wxDDEConnection*) server->OnAcceptConnection(wxString(topic_buf));
if (connection)
{
- connection->server = server;
+ connection->m_server = server;
server->GetConnections().Append(connection);
- connection->hConv = 0;
- connection->topic_name = topic_buf;
+ connection->m_hConv = 0;
+ connection->m_topicName = topic_buf;
DDECurrentlyConnecting = connection;
return (DDERETURN)TRUE;
}
{
if (DDECurrentlyConnecting)
{
- DDECurrentlyConnecting->hConv = (WXHCONV) hConv;
+ DDECurrentlyConnecting->m_hConv = (WXHCONV) hConv;
DDECurrentlyConnecting = NULL;
return (DDERETURN)TRUE;
}
if (connection)
{
- DWORD len = DdeGetData(hData, (LPBYTE)(connection->buf_ptr), connection->buf_size, 0);
+ DWORD len = DdeGetData(hData, (LPBYTE)(connection->m_bufPtr), connection->m_bufSize, 0);
DdeFreeDataHandle(hData);
- if (connection->OnExecute(connection->topic_name, connection->buf_ptr, (int)len, wFmt))
+ if (connection->OnExecute(connection->m_topicName, connection->m_bufPtr, (int)len, (wxDataFormat) wFmt))
return (DDERETURN)DDE_FACK;
else
return (DDERETURN)DDE_FNOTPROCESSED;
CP_WINANSI);
int user_size = -1;
- char *data = connection->OnRequest(connection->topic_name, wxString(item_name), &user_size, wFmt);
+ char *data = connection->OnRequest(connection->m_topicName, wxString(item_name), &user_size, (wxDataFormat) wFmt);
if (data)
{
if (user_size < 0) user_size = strlen(data);
char item_name[200];
DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
CP_WINANSI);
- DWORD len = DdeGetData(hData, (LPBYTE)(connection->buf_ptr), connection->buf_size, 0);
+ DWORD len = DdeGetData(hData, (LPBYTE)(connection->m_bufPtr), connection->m_bufSize, 0);
DdeFreeDataHandle(hData);
- connection->OnPoke(connection->topic_name, wxString(item_name), connection->buf_ptr, (int)len, wFmt);
+ connection->OnPoke(connection->m_topicName, wxString(item_name), connection->m_bufPtr, (int)len, (wxDataFormat) wFmt);
return (DDERETURN)DDE_FACK;
} else return (DDERETURN)DDE_FNOTPROCESSED;
break;
DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
CP_WINANSI);
- return (DDERETURN)connection->OnStartAdvise(connection->topic_name, wxString(item_name));
+ return (DDERETURN)connection->OnStartAdvise(connection->m_topicName, wxString(item_name));
} else return (DDERETURN)0;
break;
}
char item_name[200];
DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
CP_WINANSI);
- return (DDERETURN)connection->OnStopAdvise(connection->topic_name, wxString(item_name));
+ return (DDERETURN)connection->OnStopAdvise(connection->m_topicName, wxString(item_name));
} else return (DDERETURN)0;
break;
}
{
wxDDEConnection *connection = DDEFindConnection(hConv);
- if (connection && connection->sending_data)
+ if (connection && connection->m_sendingData)
{
HDDEDATA data = DdeCreateDataHandle(DDEIdInst,
- (LPBYTE)connection->sending_data,
- connection->data_size, 0, hsz2, connection->data_type, 0);
- connection->sending_data = NULL;
+ (LPBYTE)connection->m_sendingData,
+ connection->m_dataSize, 0, hsz2, connection->m_dataType, 0);
+ connection->m_sendingData = NULL;
return (DDERETURN)data;
} else return (DDERETURN)NULL;
break;
DdeQueryString(DDEIdInst, hsz2, (LPSTR)item_name, sizeof(item_name),
CP_WINANSI);
- DWORD len = DdeGetData(hData, (LPBYTE)(connection->buf_ptr), connection->buf_size, 0);
+ DWORD len = DdeGetData(hData, (LPBYTE)(connection->m_bufPtr), connection->m_bufSize, 0);
DdeFreeDataHandle(hData);
- if (connection->OnAdvise(connection->topic_name, wxString(item_name), connection->buf_ptr, (int)len, wFmt))
+ if (connection->OnAdvise(connection->m_topicName, wxString(item_name), connection->m_bufPtr, (int)len, (wxDataFormat) wFmt))
return (DDERETURN)DDE_FACK;
else
return (DDERETURN)DDE_FNOTPROCESSED;
wxOpenClipboard();
if (!wxEmptyClipboard()) return FALSE;
}
- bool success = wxSetClipboardData(wxCF_METAFILE,this, width,height);
+ bool success = wxSetClipboardData(wxDF_METAFILE,this, width,height);
if (!alreadyOpen) wxCloseClipboard();
return (bool) success;
}
}
// and now check the type of data requested
- if ( m_pDataObject->IsSupportedFormat(pformatetc->cfFormat) ) {
+ if ( m_pDataObject->IsSupportedFormat((wxDataFormat) pformatetc->cfFormat) ) {
wxLogTrace("wxIDataObject::QueryGetData: %s ok",
- wxDataObject::GetFormatName(pformatetc->cfFormat));
+ wxDataObject::GetFormatName((wxDataFormat) pformatetc->cfFormat));
return S_OK;
}
else {
wxLogTrace("wxIDataObject::QueryGetData: %s unsupported",
- wxDataObject::GetFormatName(pformatetc->cfFormat));
+ wxDataObject::GetFormatName((wxDataFormat) pformatetc->cfFormat));
return DV_E_FORMATETC;
}
}
{
m_cRef = 0;
m_pTarget = pTarget;
- m_cfFormat = 0;
+ m_cfFormat = (wxDataFormat) 0;
m_pIDataObject = NULL;
}
// means) for file drag and drop
if ( pIDataSource->QueryGetData(&s_fmtMemory) == S_OK ) {
// remember this format: we'll later ask for data in it
- m_pIDropTarget->SetSupportedFormat(s_fmtMemory.cfFormat);
+ m_pIDropTarget->SetSupportedFormat((wxDataFormat) s_fmtMemory.cfFormat);
return TRUE;
}
}
wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const
{
- return CF_TEXT;
+ return wxDF_TEXT;
}
// ============================================================================
wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
{
#ifdef __WIN32__
- return CF_HDROP;
+ return wxDF_FILENAME;
#else
// TODO: how to implement this in WIN16?
- return CF_TEXT;
+ return wxDF_TEXT;
#endif
}
SendMessage(hWnd, WM_CUT, (WPARAM)0, (LPARAM)0);
// Now replace with 'value', by pasting.
- wxSetClipboardData(wxCF_TEXT, (wxObject *) (const char *)value, 0, 0);
+ wxSetClipboardData(wxDF_TEXT, (wxObject *) (const char *)value, 0, 0);
// Paste into edit control
SendMessage(hWnd, WM_PASTE, (WPARAM)0, (LPARAM)0L);
all: $(LIBTARGET)
+
$(PROGRAM): $(PROGRAM).exe
wx:
projects / wxWidgets.git / commitdiff
