m_ext;
};
-WX_DECLARE_OBJARRAY(wxFileTypeInfo, wxArrayFileTypeInfo);
+WX_DECLARE_EXPORTED_OBJARRAY(wxFileTypeInfo, wxArrayFileTypeInfo);
#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(wxArrayFileTypeInfo);
wxArrayFileTypeInfo m_fallbacks;
};
+#elif defined( __WXMAC__ )
+
+WX_DECLARE_EXPORTED_OBJARRAY(wxFileTypeInfo, wxArrayFileTypeInfo);
+#include "wx/arrimpl.cpp"
+WX_DEFINE_OBJARRAY(wxArrayFileTypeInfo);
+
+class wxMimeTypesManagerImpl
+{
+public :
+ wxMimeTypesManagerImpl() { }
+
+ // implement containing class functions
+ wxFileType *GetFileTypeFromExtension(const wxString& ext);
+ wxFileType *GetFileTypeFromMimeType(const wxString& mimeType);
+
+ // this are NOPs under MacOS
+ bool ReadMailcap(const wxString& filename, bool fallback = TRUE) { return TRUE; }
+ bool ReadMimeTypes(const wxString& filename) { return TRUE; }
+
+ void AddFallback(const wxFileTypeInfo& ft) { m_fallbacks.Add(ft); }
+
+private:
+ wxArrayFileTypeInfo m_fallbacks;
+};
+
+class wxFileTypeImpl
+{
+public:
+ // initialize us with our file type name
+ void SetFileType(const wxString& strFileType)
+ { m_strFileType = strFileType; }
+ void SetExt(const wxString& ext)
+ { m_ext = ext; }
+
+ // implement accessor functions
+ bool GetExtensions(wxArrayString& extensions);
+ bool GetMimeType(wxString *mimeType) const;
+ bool GetIcon(wxIcon *icon) const;
+ bool GetDescription(wxString *desc) const;
+ bool GetOpenCommand(wxString *openCmd,
+ const wxFileType::MessageParameters&) const
+ { return GetCommand(openCmd, "open"); }
+ bool GetPrintCommand(wxString *printCmd,
+ const wxFileType::MessageParameters&) const
+ { return GetCommand(printCmd, "print"); }
+
+private:
+ // helper function
+ bool GetCommand(wxString *command, const char *verb) const;
+
+ wxString m_strFileType, m_ext;
+};
+
#else // Unix
// this class uses both mailcap and mime.types to gather information about file
break;
}
- wxASSERT_MSG( n == pos, _T("invalid position in MailCapEntry::Insert") );
+ wxASSERT_MSG( n == pos, wxT("invalid position in MailCapEntry::Insert") );
m_next = cur->m_next;
cur->m_next = this;
// append this element to the list
void Append(MailCapEntry *next)
{
- wxCHECK_RET( next != NULL, _T("Append()ing to what?") );
+ wxCHECK_RET( next != NULL, wxT("Append()ing to what?") );
// FIXME slooow...
MailCapEntry *cur;
cur->m_next = this;
- wxASSERT_MSG( !m_next, _T("Append()ing element already in the list?") );
+ wxASSERT_MSG( !m_next, wxT("Append()ing element already in the list?") );
}
private:
bool hasFilename = FALSE;
wxString str;
- for ( const wxChar *pc = command.c_str(); *pc != _T('\0'); pc++ ) {
- if ( *pc == _T('%') ) {
+ for ( const wxChar *pc = command.c_str(); *pc != wxT('\0'); pc++ ) {
+ if ( *pc == wxT('%') ) {
switch ( *++pc ) {
- case _T('s'):
+ case wxT('s'):
// '%s' expands into file name (quoted because it might
// contain spaces) - except if there are already quotes
// there because otherwise some programs may get confused
// by double double quotes
#if 0
- if ( *(pc - 2) == _T('"') )
+ if ( *(pc - 2) == wxT('"') )
str << params.GetFileName();
else
- str << _T('"') << params.GetFileName() << _T('"');
+ str << wxT('"') << params.GetFileName() << wxT('"');
#endif
str << params.GetFileName();
hasFilename = TRUE;
break;
- case _T('t'):
+ case wxT('t'):
// '%t' expands into MIME type (quote it too just to be
// consistent)
- str << _T('\'') << params.GetMimeType() << _T('\'');
+ str << wxT('\'') << params.GetMimeType() << wxT('\'');
break;
- case _T('{'):
+ case wxT('{'):
{
- const wxChar *pEnd = wxStrchr(pc, _T('}'));
+ const wxChar *pEnd = wxStrchr(pc, wxT('}'));
if ( pEnd == NULL ) {
wxString mimetype;
wxLogWarning(_("Unmatched '{' in an entry for "
"mime type %s."),
params.GetMimeType().c_str());
- str << _T("%{");
+ str << wxT("%{");
}
else {
wxString param(pc + 1, pEnd - pc - 1);
- str << _T('\'') << params.GetParamValue(param) << _T('\'');
+ str << wxT('\'') << params.GetParamValue(param) << wxT('\'');
pc = pEnd;
}
}
break;
- case _T('n'):
- case _T('F'):
+ case wxT('n'):
+ case wxT('F'):
// TODO %n is the number of parts, %F is an array containing
// the names of temp files these parts were written to
// and their mime types.
break;
default:
- wxLogDebug(_T("Unknown field %%%c in command '%s'."),
+ wxLogDebug(wxT("Unknown field %%%c in command '%s'."),
*pc, command.c_str());
str << *pc;
}
// metamail(1) man page states that if the mailcap entry doesn't have '%s'
// the program will accept the data on stdin: so give it to it!
if ( !hasFilename && !str.IsEmpty() ) {
- str << _T(" < '") << params.GetFileName() << _T('\'');
+ str << wxT(" < '") << params.GetFileName() << wxT('\'');
}
return str;
bool wxMimeTypesManager::IsOfType(const wxString& mimeType,
const wxString& wildcard)
{
- wxASSERT_MSG( mimeType.Find(_T('*')) == wxNOT_FOUND,
- _T("first MIME type can't contain wildcards") );
+ wxASSERT_MSG( mimeType.Find(wxT('*')) == wxNOT_FOUND,
+ wxT("first MIME type can't contain wildcards") );
// all comparaisons are case insensitive (2nd arg of IsSameAs() is FALSE)
- if ( wildcard.BeforeFirst(_T('/')).IsSameAs(mimeType.BeforeFirst(_T('/')), FALSE) )
+ if ( wildcard.BeforeFirst(wxT('/')).IsSameAs(mimeType.BeforeFirst(wxT('/')), FALSE) )
{
- wxString strSubtype = wildcard.AfterFirst(_T('/'));
+ wxString strSubtype = wildcard.AfterFirst(wxT('/'));
- if ( strSubtype == _T("*") ||
- strSubtype.IsSameAs(mimeType.AfterFirst(_T('/')), FALSE) )
+ if ( strSubtype == wxT("*") ||
+ strSubtype.IsSameAs(mimeType.AfterFirst(wxT('/')), FALSE) )
{
// matches (either exactly or it's a wildcard)
return TRUE;
// suppress possible error messages
wxLogNull nolog;
wxString strKey;
- strKey << m_strFileType << _T("\\shell\\") << verb << _T("\\command");
+ strKey << m_strFileType << wxT("\\shell\\") << verb << wxT("\\command");
wxRegKey key(wxRegKey::HKCR, strKey);
wxString command;
if ( key.Open() ) {
// it's the default value of the key
- if ( key.QueryValue(_T(""), command) ) {
+ if ( key.QueryValue(wxT(""), command) ) {
// transform it from '%1' to '%s' style format string
// NB: we don't make any attempt to verify that the string is valid,
bool foundFilename = FALSE;
size_t len = command.Len();
for ( size_t n = 0; (n < len) && !foundFilename; n++ ) {
- if ( command[n] == _T('%') &&
- (n + 1 < len) && command[n + 1] == _T('1') ) {
+ if ( command[n] == wxT('%') &&
+ (n + 1 < len) && command[n + 1] == wxT('1') ) {
// replace it with '%s'
- command[n + 1] = _T('s');
+ command[n + 1] = wxT('s');
foundFilename = TRUE;
}
if ( !foundFilename ) {
// we didn't find any '%1'!
// HACK: append the filename at the end, hope that it will do
- command << _T(" %s");
+ command << wxT(" %s");
}
}
}
cmd = m_info->GetOpenCommand();
}
else {
- cmd = GetCommand(_T("open"));
+ cmd = GetCommand(wxT("open"));
}
*openCmd = wxFileType::ExpandCommand(cmd, params);
cmd = m_info->GetPrintCommand();
}
else {
- cmd = GetCommand(_T("print"));
+ cmd = GetCommand(wxT("print"));
}
*printCmd = wxFileType::ExpandCommand(cmd, params);
// suppress possible error messages
wxLogNull nolog;
- wxRegKey key(wxRegKey::HKCR, /*m_strFileType*/ _T(".") + m_ext);
- if ( key.Open() && key.QueryValue(_T("Content Type"), *mimeType) ) {
+ wxRegKey key(wxRegKey::HKCR, /*m_strFileType*/ wxT(".") + m_ext);
+ if ( key.Open() && key.QueryValue(wxT("Content Type"), *mimeType) ) {
return TRUE;
}
else {
}
wxString strIconKey;
- strIconKey << m_strFileType << _T("\\DefaultIcon");
+ strIconKey << m_strFileType << wxT("\\DefaultIcon");
// suppress possible error messages
wxLogNull nolog;
if ( key.Open() ) {
wxString strIcon;
// it's the default value of the key
- if ( key.QueryValue(_T(""), strIcon) ) {
+ if ( key.QueryValue(wxT(""), strIcon) ) {
// the format is the following: <full path to file>, <icon index>
// NB: icon index may be negative as well as positive and the full
// path may contain the environment variables inside '%'
- wxString strFullPath = strIcon.BeforeLast(_T(',')),
- strIndex = strIcon.AfterLast(_T(','));
+ wxString strFullPath = strIcon.BeforeLast(wxT(',')),
+ strIndex = strIcon.AfterLast(wxT(','));
// index may be omitted, in which case BeforeLast(',') is empty and
// AfterLast(',') is the whole string
if ( strFullPath.IsEmpty() ) {
strFullPath = strIndex;
- strIndex = _T("0");
+ strIndex = wxT("0");
}
wxString strExpPath = wxExpandEnvVars(strFullPath);
switch ( (int)hIcon ) {
case 0: // means no icons were found
case 1: // means no such file or it wasn't a DLL/EXE/OCX/ICO/...
- wxLogDebug(_T("incorrect registry entry '%s': no such icon."),
+ wxLogDebug(wxT("incorrect registry entry '%s': no such icon."),
key.GetName().c_str());
break;
if ( key.Open() ) {
// it's the default value of the key
- if ( key.QueryValue(_T(""), *desc) ) {
+ if ( key.QueryValue(wxT(""), *desc) ) {
return TRUE;
}
}
{
// add the leading point if necessary
wxString str;
- if ( ext[0u] != _T('.') ) {
- str = _T('.');
+ if ( ext[0u] != wxT('.') ) {
+ str = wxT('.');
}
str << ext;
wxRegKey key(wxRegKey::HKCR, str);
if ( key.Open() ) {
// it's the default value of the key
- if ( key.QueryValue(_T(""), strFileType) ) {
+ if ( key.QueryValue(wxT(""), strFileType) ) {
// create the new wxFileType object
wxFileType *fileType = new wxFileType;
fileType->m_impl->Init(strFileType, ext);
{
// HACK I don't know of any official documentation which mentions this
// location, but as a matter of fact IE uses it, so why not we?
- static const wxChar *szMimeDbase = _T("MIME\\Database\\Content Type\\");
+ static const wxChar *szMimeDbase = wxT("MIME\\Database\\Content Type\\");
wxString strKey = szMimeDbase;
strKey << mimeType;
wxString ext;
wxRegKey key(wxRegKey::HKCR, strKey);
if ( key.Open() ) {
- if ( key.QueryValue(_T("Extension"), ext) ) {
+ if ( key.QueryValue(wxT("Extension"), ext) ) {
return GetFileTypeFromExtension(ext);
}
}
return NULL;
}
+#elif defined ( __WXMAC__ )
+
+
+bool wxFileTypeImpl::GetCommand(wxString *command, const char *verb) const
+{
+ return FALSE;
+}
+
+// @@ this function is half implemented
+bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
+{
+ return FALSE;
+}
+
+bool wxFileTypeImpl::GetMimeType(wxString *mimeType) const
+{
+ if ( m_strFileType.Length() > 0 )
+ {
+ *mimeType = m_strFileType ;
+ return TRUE ;
+ }
+ else
+ return FALSE;
+}
+
+bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
+{
+ // no such file type or no value or incorrect icon entry
+ return FALSE;
+}
+
+bool wxFileTypeImpl::GetDescription(wxString *desc) const
+{
+ return FALSE;
+}
+
+// extension -> file type
+wxFileType *
+wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& e)
+{
+ wxString ext = e ;
+ ext = ext.Lower() ;
+ if ( ext == "txt" )
+ {
+ wxFileType *fileType = new wxFileType;
+ fileType->m_impl->SetFileType("text/text");
+ fileType->m_impl->SetExt(ext);
+ return fileType;
+ }
+ else if ( ext == "htm" || ext == "html" )
+ {
+ wxFileType *fileType = new wxFileType;
+ fileType->m_impl->SetFileType("text/html");
+ fileType->m_impl->SetExt(ext);
+ return fileType;
+ }
+ else if ( ext == "gif" )
+ {
+ wxFileType *fileType = new wxFileType;
+ fileType->m_impl->SetFileType("image/gif");
+ fileType->m_impl->SetExt(ext);
+ return fileType;
+ }
+ else if ( ext == "png" )
+ {
+ wxFileType *fileType = new wxFileType;
+ fileType->m_impl->SetFileType("image/png");
+ fileType->m_impl->SetExt(ext);
+ return fileType;
+ }
+ else if ( ext == "jpg" || ext == "jpeg" )
+ {
+ wxFileType *fileType = new wxFileType;
+ fileType->m_impl->SetFileType("image/jpeg");
+ fileType->m_impl->SetExt(ext);
+ return fileType;
+ }
+ else if ( ext == "bmp" )
+ {
+ wxFileType *fileType = new wxFileType;
+ fileType->m_impl->SetFileType("image/bmp");
+ fileType->m_impl->SetExt(ext);
+ return fileType;
+ }
+ else if ( ext == "tif" || ext == "tiff" )
+ {
+ wxFileType *fileType = new wxFileType;
+ fileType->m_impl->SetFileType("image/tiff");
+ fileType->m_impl->SetExt(ext);
+ return fileType;
+ }
+ else if ( ext == "xpm" )
+ {
+ wxFileType *fileType = new wxFileType;
+ fileType->m_impl->SetFileType("image/xpm");
+ fileType->m_impl->SetExt(ext);
+ return fileType;
+ }
+ else if ( ext == "xbm" )
+ {
+ wxFileType *fileType = new wxFileType;
+ fileType->m_impl->SetFileType("image/xbm");
+ fileType->m_impl->SetExt(ext);
+ return fileType;
+ }
+ // unknown extension
+ return NULL;
+}
+
+// MIME type -> extension -> file type
+wxFileType *
+wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
+{
+ return NULL;
+}
#else // Unix
MailCapEntry *
if ( command.IsEmpty() || (wxSystem(command) == 0) ) {
// ok, passed
- wxLogTrace(_T("Test '%s' for mime type '%s' succeeded."),
+ wxLogTrace(wxT("Test '%s' for mime type '%s' succeeded."),
command.c_str(), params.GetMimeType().c_str());
break;
}
else {
- wxLogTrace(_T("Test '%s' for mime type '%s' failed."),
+ wxLogTrace(wxT("Test '%s' for mime type '%s' failed."),
command.c_str(), params.GetMimeType().c_str());
}
// one extension in the space or comma delimitid list
wxString strExt;
for ( const wxChar *p = strExtensions; ; p++ ) {
- if ( *p == _T(' ') || *p == _T(',') || *p == _T('\0') ) {
+ if ( *p == wxT(' ') || *p == wxT(',') || *p == wxT('\0') ) {
if ( !strExt.IsEmpty() ) {
extensions.Add(strExt);
strExt.Empty();
//else: repeated spaces (shouldn't happen, but it's not that
// important if it does happen)
- if ( *p == _T('\0') )
+ if ( *p == wxT('\0') )
break;
}
- else if ( *p == _T('.') ) {
+ else if ( *p == wxT('.') ) {
// remove the dot from extension (but only if it's the first char)
if ( !strExt.IsEmpty() ) {
- strExt += _T('.');
+ strExt += wxT('.');
}
//else: no, don't append it
}
// (taken from metamail(1) sources)
static const wxChar *aStandardLocations[] =
{
- _T("/etc"),
- _T("/usr/etc"),
- _T("/usr/local/etc"),
- _T("/etc/mail"),
- _T("/usr/public/lib")
+ wxT("/etc"),
+ wxT("/usr/etc"),
+ wxT("/usr/local/etc"),
+ wxT("/etc/mail"),
+ wxT("/usr/public/lib")
};
// first read the system wide file(s)
for ( size_t n = 0; n < WXSIZEOF(aStandardLocations); n++ ) {
wxString dir = aStandardLocations[n];
- wxString file = dir + _T("/mailcap");
+ wxString file = dir + wxT("/mailcap");
if ( wxFile::Exists(file) ) {
ReadMailcap(file);
}
- file = dir + _T("/mime.types");
+ file = dir + wxT("/mime.types");
if ( wxFile::Exists(file) ) {
ReadMimeTypes(file);
}
}
- wxString strHome = wxGetenv(_T("HOME"));
+ wxString strHome = wxGetenv(wxT("HOME"));
// and now the users mailcap
- wxString strUserMailcap = strHome + _T("/.mailcap");
+ wxString strUserMailcap = strHome + wxT("/.mailcap");
if ( wxFile::Exists(strUserMailcap) ) {
ReadMailcap(strUserMailcap);
}
// read the users mime.types
- wxString strUserMimeTypes = strHome + _T("/.mime.types");
+ wxString strUserMimeTypes = strHome + wxT("/.mime.types");
if ( wxFile::Exists(strUserMimeTypes) ) {
ReadMimeTypes(strUserMimeTypes);
}
for ( size_t n = 0; n < count; n++ ) {
wxString extensions = m_aExtensions[n];
while ( !extensions.IsEmpty() ) {
- wxString field = extensions.BeforeFirst(_T(' '));
- extensions = extensions.AfterFirst(_T(' '));
+ wxString field = extensions.BeforeFirst(wxT(' '));
+ extensions = extensions.AfterFirst(wxT(' '));
// consider extensions as not being case-sensitive
if ( field.IsSameAs(ext, FALSE /* no case */) ) {
// then try to find "text/*" as match for "text/plain" (for example)
// NB: if mimeType doesn't contain '/' at all, BeforeFirst() will return
// the whole string - ok.
- wxString strCategory = mimetype.BeforeFirst(_T('/'));
+ wxString strCategory = mimetype.BeforeFirst(wxT('/'));
size_t nCount = m_aTypes.Count();
for ( size_t n = 0; n < nCount; n++ ) {
- if ( (m_aTypes[n].BeforeFirst(_T('/')) == strCategory ) &&
- m_aTypes[n].AfterFirst(_T('/')) == _T("*") ) {
+ if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) &&
+ m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") ) {
index = n;
break;
}
void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype)
{
+ wxString extensions;
const wxArrayString& exts = filetype.GetExtensions();
size_t nExts = exts.GetCount();
for ( size_t nExt = 0; nExt < nExts; nExt++ ) {
if ( nExt > 0 ) {
- extensions += _T(' ');
+ extensions += wxT(' ');
}
extensions += exts[nExt];
}
AddMailcapInfo(filetype.GetMimeType(),
filetype.GetOpenCommand(),
filetype.GetPrintCommand(),
- _T(""),
+ wxT(""),
filetype.GetDescription());
}
if ( !strDesc.IsEmpty() ) {
m_aDescriptions[index] = strDesc; // replace old value
}
- m_aExtensions[index] += strExtensions;
+ m_aExtensions[index] += ' ' + strExtensions;
}
}
m_aTypes.Add(strType);
m_aEntries.Add(entry);
- m_aExtensions.Add(_T(""));
+ m_aExtensions.Add(wxT(""));
m_aDescriptions.Add(strDesc);
}
else {
bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
{
- wxLogTrace(_T("--- Parsing mime.types file '%s' ---"), strFileName.c_str());
+ wxLogTrace(wxT("--- Parsing mime.types file '%s' ---"), strFileName.c_str());
wxTextFile file(strFileName);
if ( !file.Open() )
pc++;
// comment?
- if ( *pc == _T('#') ) {
+ if ( *pc == wxT('#') ) {
// skip the whole line
pc = NULL;
continue;
}
// detect file format
- const wxChar *pEqualSign = wxStrchr(pc, _T('='));
+ const wxChar *pEqualSign = wxStrchr(pc, wxT('='));
if ( pEqualSign == NULL ) {
// brief format
// ------------
// first field is mime type
- for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != _T('\0'); pc++ ) {
+ for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != wxT('\0'); pc++ ) {
strMimeType += *pc;
}
;
const wxChar *pEnd;
- if ( *pc == _T('"') ) {
+ if ( *pc == wxT('"') ) {
// the string is quoted and ends at the matching quote
- pEnd = wxStrchr(++pc, _T('"'));
+ pEnd = wxStrchr(++pc, wxT('"'));
if ( pEnd == NULL ) {
wxLogWarning(_("Mime.types file %s, line %d: unterminated "
"quoted string."),
wxString strRHS(pc, pEnd - pc);
// check what follows this entry
- if ( *pEnd == _T('"') ) {
+ if ( *pEnd == wxT('"') ) {
// skip this quote
pEnd++;
}
// if there is something left, it may be either a '\\' to continue
// the line or the next field of the same entry
- bool entryEnded = *pc == _T('\0'),
+ bool entryEnded = *pc == wxT('\0'),
nextFieldOnSameLine = FALSE;
if ( !entryEnded ) {
- nextFieldOnSameLine = ((*pc != _T('\\')) || (pc[1] != _T('\0')));
+ nextFieldOnSameLine = ((*pc != wxT('\\')) || (pc[1] != wxT('\0')));
}
// now see what we got
- if ( strLHS == _T("type") ) {
+ if ( strLHS == wxT("type") ) {
strMimeType = strRHS;
}
- else if ( strLHS == _T("desc") ) {
+ else if ( strLHS == wxT("desc") ) {
strDesc = strRHS;
}
- else if ( strLHS == _T("exts") ) {
+ else if ( strLHS == wxT("exts") ) {
strExtensions = strRHS;
}
else {
// although it doesn't seem to be covered by RFCs, some programs
// (notably Netscape) create their entries with several comma
// separated extensions (RFC mention the spaces only)
- strExtensions.Replace(_T(","), _T(" "));
+ strExtensions.Replace(wxT(","), wxT(" "));
// also deal with the leading dot
- if ( !strExtensions.IsEmpty() && strExtensions[0] == _T('.') ) {
+#if defined(__VISAGECPP__) && __IBMCPP__ >= 400
+ if ( !strExtensions.IsEmpty() && strExtensions[size_t(0)] == wxT('.') ) {
+#else
+ if ( !strExtensions.IsEmpty() && strExtensions[0] == wxT('.') ) {
+#endif
strExtensions.erase(0, 1);
}
bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
bool fallback)
{
- wxLogTrace(_T("--- Parsing mailcap file '%s' ---"), strFileName.c_str());
+ wxLogTrace(wxT("--- Parsing mailcap file '%s' ---"), strFileName.c_str());
wxTextFile file(strFileName);
if ( !file.Open() )
pc++;
// comment or empty string?
- if ( *pc == _T('#') || *pc == _T('\0') )
+ if ( *pc == wxT('#') || *pc == wxT('\0') )
continue;
// no, do parse
curField; // accumulator
for ( bool cont = TRUE; cont; pc++ ) {
switch ( *pc ) {
- case _T('\\'):
+ case wxT('\\'):
// interpret the next character literally (notice that
// backslash can be used for line continuation)
- if ( *++pc == _T('\0') ) {
+ if ( *++pc == wxT('\0') ) {
// fetch the next line.
// pc currently points to nowhere, but after the next
}
break;
- case _T('\0'):
+ case wxT('\0'):
cont = FALSE; // end of line reached, exit the loop
// fall through
- case _T(';'):
+ case wxT(';'):
// store this field and start looking for the next one
// trim whitespaces from both sides
switch ( currentToken ) {
case Field_Type:
strType = curField;
- if ( strType.Find(_T('/')) == wxNOT_FOUND ) {
+ if ( strType.Find(wxT('/')) == wxNOT_FOUND ) {
// we interpret "type" as "type/*"
- strType += _T("/*");
+ strType += wxT("/*");
}
currentToken = Field_OpenCmd;
bool ok = TRUE;
// is this something of the form foo=bar?
- const wxChar *pEq = wxStrchr(curField, _T('='));
+ const wxChar *pEq = wxStrchr(curField, wxT('='));
if ( pEq != NULL ) {
- wxString lhs = curField.BeforeFirst(_T('=')),
- rhs = curField.AfterFirst(_T('='));
+ wxString lhs = curField.BeforeFirst(wxT('=')),
+ rhs = curField.AfterFirst(wxT('='));
lhs.Trim(TRUE); // from right
rhs.Trim(FALSE); // from left
- if ( lhs == _T("print") )
+ if ( lhs == wxT("print") )
strPrintCmd = rhs;
- else if ( lhs == _T("test") )
+ else if ( lhs == wxT("test") )
strTest = rhs;
- else if ( lhs == _T("description") ) {
+ else if ( lhs == wxT("description") ) {
// it might be quoted
- if ( rhs[0u] == _T('"') &&
- rhs.Last() == _T('"') ) {
+ if ( rhs[0u] == wxT('"') &&
+ rhs.Last() == wxT('"') ) {
strDesc = wxString(rhs.c_str() + 1,
rhs.Len() - 2);
}
strDesc = rhs;
}
}
- else if ( lhs == _T("compose") ||
- lhs == _T("composetyped") ||
- lhs == _T("notes") ||
- lhs == _T("edit") )
+ else if ( lhs == wxT("compose") ||
+ lhs == wxT("composetyped") ||
+ lhs == wxT("notes") ||
+ lhs == wxT("edit") )
; // ignore
else
ok = FALSE;
// TODO support the flags:
// 1. create an xterm for 'needsterminal'
// 2. append "| $PAGER" for 'copiousoutput'
- if ( curField == _T("needsterminal") )
+ if ( curField == wxT("needsterminal") )
needsterminal = TRUE;
- else if ( curField == _T("copiousoutput") )
+ else if ( curField == wxT("copiousoutput") )
copiousoutput = TRUE;
- else if ( curField == _T("textualnewlines") )
+ else if ( curField == wxT("textualnewlines") )
; // ignore
else
ok = FALSE;
// programmer
wxLogDebug
(
- _T("Mailcap file %s, line %d: unknown "
+ wxT("Mailcap file %s, line %d: unknown "
"field '%s' for the MIME type "
"'%s' ignored."),
strFileName.c_str(),
break;
default:
- wxFAIL_MSG(_T("unknown field type in mailcap"));
+ wxFAIL_MSG(wxT("unknown field type in mailcap"));
}
// next token starts immediately after ';'
m_aTypes.Add(strType);
m_aEntries.Add(entry);
- m_aExtensions.Add(_T(""));
+ m_aExtensions.Add(wxT(""));
m_aDescriptions.Add(strDesc);
}
else {
projects / wxWidgets.git / blobdiff