Commited updated list of files to compile.

[wxWidgets.git] / src / unix / mimetype.cpp

diff --git a/src/unix/mimetype.cpp b/src/unix/mimetype.cpp
index aa0fc4f3de9be44e6b3f855612f38367773037e3..fffd9d50ddad4ba6e20b1997a16e607aca224620 100644 (file)
--- a/src/unix/mimetype.cpp
+++ b/src/unix/mimetype.cpp
@@ -9,8 +9,16 @@
 // Licence:     wxWindows license (part of wxExtra library)
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows license (part of wxExtra library)
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef    __GNUG__
-#pragma implementation "mimetype.h"
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma implementation "mimetype.h"

 #endif
 
 // for compilers that support precompilation, includes "wx.h".
 #endif
 
 // for compilers that support precompilation, includes "wx.h".


@@ -24,7 +32,7 @@
   #include "wx/defs.h"
 #endif
 
   #include "wx/defs.h"
 #endif
 

-#if (wxUSE_FILE && wxUSE_TEXTFILE) || defined(__WXMSW__)
+#if wxUSE_FILE && wxUSE_TEXTFILE

 
 #ifndef WX_PRECOMP
   #include "wx/string.h"
 
 #ifndef WX_PRECOMP
   #include "wx/string.h"


@@ -55,15 +63,31 @@
 class WXDLLEXPORT wxIcon;
 
 // ----------------------------------------------------------------------------
 class WXDLLEXPORT wxIcon;
 
 // ----------------------------------------------------------------------------

-// private classes
+// constants

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

+// MIME code tracing mask
+#define TRACE_MIME _T("mime")
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+// there are some fields which we don't understand but for which we don't give
+// warnings as we know that they're not important - this function is used to
+// test for them
+static bool IsKnownUnimportantField(const wxString& field);
+
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------

 
 

-// this class uses both mailcap and mime.types to gather information about file
+// This class uses both mailcap and mime.types to gather information about file

 // types.
 //
 // types.
 //

-// The information about mailcap file was extracted from metamail(1) sources and
-// documentation.
+// The information about mailcap file was extracted from metamail(1) sources
+// and documentation and subsequently revised when I found the RFC 1524
+// describing it.

 //
 // Format of mailcap file: spaces are ignored, each line is either a comment
 // (starts with '#') or a line of the form <field1>;<field2>;...;<fieldN>.
 //
 // Format of mailcap file: spaces are ignored, each line is either a comment
 // (starts with '#') or a line of the form <field1>;<field2>;...;<fieldN>.


@@ -90,7 +114,8 @@ class WXDLLEXPORT wxIcon;
 //  * print=xxx is the command to be used to print (and not view) the data of
 //    this type (parameter/filename expansion is done here too)
 //  * edit=xxx is the command to open/edit the data of this type
 //  * print=xxx is the command to be used to print (and not view) the data of
 //    this type (parameter/filename expansion is done here too)
 //  * edit=xxx is the command to open/edit the data of this type

-//  * needsterminal means that a new console must be created for the viewer
+//  * needsterminal means that a new interactive console must be created for
+//    the viewer

 //  * copiousoutput means that the viewer doesn't interact with the user but
 //    produces (possibly) a lof of lines of output on stdout (i.e. "cat" is a
 //    good example), thus it might be a good idea to use some kind of paging
 //  * copiousoutput means that the viewer doesn't interact with the user but
 //    produces (possibly) a lof of lines of output on stdout (i.e. "cat" is a
 //    good example), thus it might be a good idea to use some kind of paging


@@ -99,7 +124,7 @@ class WXDLLEXPORT wxIcon;
 //  * compose and composetyped fields are used to determine the program to be
 //    called to create a new message pert in the specified format (unused).
 //
 //  * compose and composetyped fields are used to determine the program to be
 //    called to create a new message pert in the specified format (unused).
 //

-// Parameter/filename xpansion:
+// Parameter/filename expansion:

 //  * %s is replaced with the (full) file name
 //  * %t is replaced with MIME type/subtype of the entry
 //  * for multipart type only %n is replaced with the nnumber of parts and %F is
 //  * %s is replaced with the (full) file name
 //  * %t is replaced with MIME type/subtype of the entry
 //  * for multipart type only %n is replaced with the nnumber of parts and %F is


@@ -108,18 +133,20 @@ class WXDLLEXPORT wxIcon;
 //  * %{parameter} is replaced with the value of parameter taken from
 //    Content-type header line of the message.
 //
 //  * %{parameter} is replaced with the value of parameter taken from
 //    Content-type header line of the message.
 //

-// FIXME any docs with real descriptions of these files??

 //
 // There are 2 possible formats for mime.types file, one entry per line (used
 //
 // There are 2 possible formats for mime.types file, one entry per line (used

-// for global mime.types) and "expanded" format where an entry takes multiple
-// lines (used for users mime.types).
+// for global mime.types and called Mosaic format) and "expanded" format where
+// an entry takes multiple lines (used for users mime.types and called
+// Netscape format).

 //
 // For both formats spaces are ignored and lines starting with a '#' are
 // comments. Each record has one of two following forms:
 //  a) for "brief" format:
 //      <mime type>  <space separated list of extensions>
 //  b) for "expanded" format:
 //
 // For both formats spaces are ignored and lines starting with a '#' are
 // comments. Each record has one of two following forms:
 //  a) for "brief" format:
 //      <mime type>  <space separated list of extensions>
 //  b) for "expanded" format:

-//      type=<mime type> \ desc="<description>" \ exts="ext"
+//      type=<mime type> \ 
+//      desc="<description>" \ 
+//      exts="<comma separated list of extensions>"

 //
 // We try to autodetect the format of mime.types: if a non-comment line starts
 // with "type=" we assume the second format, otherwise the first one.
 //
 // We try to autodetect the format of mime.types: if a non-comment line starts
 // with "type=" we assume the second format, otherwise the first one.


@@ -138,6 +165,11 @@ public:
     {
         m_next = NULL;
     }
     {
         m_next = NULL;
     }

+    
+    ~MailCapEntry()
+    {
+        if (m_next) delete m_next;
+    }

 
     // accessors
     const wxString& GetOpenCmd()  const { return m_openCmd;  }
 
     // accessors
     const wxString& GetOpenCmd()  const { return m_openCmd;  }


@@ -293,6 +325,9 @@ ArrayIconHandlers wxMimeTypesManagerImpl::ms_iconHandlers;
 // with blank lines separating the entries and indented lines starting with
 // TABs. We're interested in the field icon-filename whose value is the path
 // containing the icon.
 // with blank lines separating the entries and indented lines starting with
 // TABs. We're interested in the field icon-filename whose value is the path
 // containing the icon.

+//
+// Update (Chris Elliott): apparently there may be an optional "[lang]" prefix
+// just before the field name.

 
 void wxGNOMEIconHandler::LoadIconsFromKeyFile(const wxString& filename)
 {
 
 void wxGNOMEIconHandler::LoadIconsFromKeyFile(const wxString& filename)
 {


@@ -360,6 +395,16 @@ void wxGNOMEIconHandler::LoadIconsFromKeyFile(const wxString& filename)
             // this is a field=value ling
             pc++; // skip leading TAB
 
             // this is a field=value ling
             pc++; // skip leading TAB
 

+            // skip optional "[lang]"
+            if ( *pc == _T('[') )
+            {
+                while ( *pc )
+                {
+                    if ( *pc++ == _T(']') )
+                        break;
+                }
+            }
+

             static const int lenField = 13; // strlen("icon-filename")
             if ( wxStrncmp(pc, _T("icon-filename"), lenField) == 0 )
             {
             static const int lenField = 13; // strlen("icon-filename")
             if ( wxStrncmp(pc, _T("icon-filename"), lenField) == 0 )
             {


@@ -594,7 +639,7 @@ bool wxGNOMEIconHandler::GetIcon(const wxString& mimetype,
         *icon = icn;
 #else
     // helpful for testing in console mode
         *icon = icn;
 #else
     // helpful for testing in console mode

-    wxLogDebug(_T("Found GNOME icon for '%s': '%s'\n"),
+    wxLogTrace(TRACE_MIME, _T("Found GNOME icon for '%s': '%s'\n"),

                mimetype.c_str(), iconname.c_str());
 #endif
 
                mimetype.c_str(), iconname.c_str());
 #endif
 


@@ -634,45 +679,69 @@ void wxKDEIconHandler::LoadLinksForMimeSubtype(const wxString& dirbase,
     if ( !file.ReadAll(&text) )
         return;
 
     if ( !file.ReadAll(&text) )
         return;
 

-    int pos;
-    const wxChar *pc;
+    // first find the description string: it is the value in either "Comment="
+    // line or "Comment[<locale_name>]=" one
+    int posComment = wxNOT_FOUND;

 
 

-    // before trying to find an icon, grab mimetype information
-    // (because BFU's machine would hardly have well-edited mime.types but (s)he might
-    // have edited it in control panel...)
+    wxString comment;
+#if wxUSE_INTL
+    wxLocale *locale = wxGetLocale();
+    if ( locale )
+    {
+        // try "Comment[locale name]" first
+        comment << _T("Comment[") + locale->GetName() + _T("]=");

 
 

-    wxString mime_extension, mime_desc;
+        posComment = text.Find(comment);
+    }
+#endif // wxUSE_INTL

 
 

-    pos = wxNOT_FOUND;
-    if (wxGetLocale() != NULL)
-        mime_desc = _T("Comment[") + wxGetLocale()->GetName() + _T("]=");
-    if (pos == wxNOT_FOUND) mime_desc = _T("Comment=");
-    pos = text.Find(mime_desc);
-    if (pos == wxNOT_FOUND) mime_desc = wxEmptyString;
-    else
+    if ( posComment == wxNOT_FOUND )
+    {
+        comment = _T("Comment=");
+
+        posComment = text.Find(comment);
+    }
+
+    wxString mime_desc;
+    if ( posComment != wxNOT_FOUND )

     {
     {

-        pc = text.c_str() + pos + mime_desc.Length();
-        mime_desc = wxEmptyString;
-        while ( *pc && *pc != _T('\n') ) mime_desc += *pc++;
+        // found desc: it follows the comment until the end of line
+        const wxChar *pc = text.c_str() + posComment + comment.length();
+        while ( *pc && *pc != _T('\n') )
+        {
+            mime_desc += *pc++;
+        }

     }
     }

+    //else: no description
+
+    // next find the extensions
+    wxString mime_extension;

 
 

-    pos = text.Find(_T("Patterns="));
-    if (pos != wxNOT_FOUND)
+    int posExts = text.Find(_T("Patterns="));
+    if ( posExts != wxNOT_FOUND )

     {
         wxString exts;
     {
         wxString exts;

-        pc = text.c_str() + pos + 9;
-        while ( *pc && *pc != _T('\n') ) exts += *pc++;
-        wxStringTokenizer tokenizer(exts, _T(";"));
-        wxString e;
+        const wxChar *pc = text.c_str() + posExts + 9; // strlen("Patterns=")
+        while ( *pc && *pc != _T('\n') )
+        {
+            exts += *pc++;
+        }

 
 

-        while (tokenizer.HasMoreTokens())
+        wxStringTokenizer tokenizer(exts, _T(";"));
+        while ( tokenizer.HasMoreTokens() )

         {
         {

-            e = tokenizer.GetNextToken();
-            if (e.Left(2) != _T("*.")) continue; // don't support too difficult patterns
+            wxString e = tokenizer.GetNextToken();
+            if ( e.Left(2) != _T("*.") )
+                continue; // don't support too difficult patterns
+
+            if ( !mime_extension.empty() )
+            {
+                // separate from the previous ext
+                mime_extension << _T(' ');
+            }
+

             mime_extension << e.Mid(2);
             mime_extension << e.Mid(2);

-            mime_extension << _T(' ');

         }
         }

-        mime_extension.RemoveLast();

     }
 
     ms_infoTypes.Add(mimetype);
     }
 
     ms_infoTypes.Add(mimetype);


@@ -681,8 +750,8 @@ void wxKDEIconHandler::LoadLinksForMimeSubtype(const wxString& dirbase,
 
     // ok, now we can take care of icon:
 
 
     // ok, now we can take care of icon:
 

-    pos = text.Find(_T("Icon="));
-    if ( pos == wxNOT_FOUND )
+    int posIcon = text.Find(_T("Icon="));
+    if ( posIcon == wxNOT_FOUND )

     {
         // no icon info
         return;
     {
         // no icon info
         return;


@@ -690,7 +759,7 @@ void wxKDEIconHandler::LoadLinksForMimeSubtype(const wxString& dirbase,
 
     wxString icon;
 
 
     wxString icon;
 

-    pc = text.c_str() + pos + 5;  // 5 == strlen("Icon=")
+    const wxChar *pc = text.c_str() + posIcon + 5;  // 5 == strlen("Icon=")

     while ( *pc && *pc != _T('\n') )
     {
         icon += *pc++;
     while ( *pc && *pc != _T('\n') )
     {
         icon += *pc++;


@@ -798,6 +867,7 @@ void wxKDEIconHandler::Init()
         dirs.Add(_T("/usr/share"));
         dirs.Add(_T("/opt/kde/share"));
         icondirs.Add(_T("/usr/share/icons/"));
         dirs.Add(_T("/usr/share"));
         dirs.Add(_T("/opt/kde/share"));
         icondirs.Add(_T("/usr/share/icons/"));

+        icondirs.Add(_T("/usr/X11R6/share/icons/")); // Debian/Corel linux

         icondirs.Add(_T("/opt/kde/share/icons/"));
     }
 
         icondirs.Add(_T("/opt/kde/share/icons/"));
     }
 


@@ -839,7 +909,7 @@ bool wxKDEIconHandler::GetIcon(const wxString& mimetype,
         *icon = icn;
 #else
     // helpful for testing in console mode
         *icon = icn;
 #else
     // helpful for testing in console mode

-    wxLogDebug(_T("Found KDE icon for '%s': '%s'\n"),
+    wxLogTrace(TRACE_MIME, _T("Found KDE icon for '%s': '%s'\n"),

                mimetype.c_str(), iconname.c_str());
 #endif
 
                mimetype.c_str(), iconname.c_str());
 #endif
 


@@ -867,17 +937,26 @@ wxFileTypeImpl::GetEntry(const wxFileType::MessageParameters& params) const
     wxString command;
     MailCapEntry *entry = m_manager->m_aEntries[m_index[0]];
     while ( entry != NULL ) {
     wxString command;
     MailCapEntry *entry = m_manager->m_aEntries[m_index[0]];
     while ( entry != NULL ) {

-        // notice that an empty command would always succeed (it's ok)
+        // get the command to run as the test for this entry

         command = wxFileType::ExpandCommand(entry->GetTestCmd(), params);
 
         command = wxFileType::ExpandCommand(entry->GetTestCmd(), params);
 

-        if ( command.IsEmpty() || (wxSystem(command) == 0) ) {
-            // ok, passed
-            wxLogTrace(wxT("Test '%s' for mime type '%s' succeeded."),
+        // don't trace the test result if there is no test at all
+        if ( command.IsEmpty() )
+        {
+            // no test at all, ok
+            break;
+        }
+
+        if ( wxSystem(command) == 0 ) {
+            // ok, test passed
+            wxLogTrace(TRACE_MIME,
+                       wxT("Test '%s' for mime type '%s' succeeded."),

                        command.c_str(), params.GetMimeType().c_str());
             break;
         }
         else {
                        command.c_str(), params.GetMimeType().c_str());
             break;
         }
         else {

-            wxLogTrace(wxT("Test '%s' for mime type '%s' failed."),
+            wxLogTrace(TRACE_MIME,
+                       wxT("Test '%s' for mime type '%s' failed."),

                        command.c_str(), params.GetMimeType().c_str());
         }
 
                        command.c_str(), params.GetMimeType().c_str());
         }
 


@@ -989,11 +1068,22 @@ ArrayIconHandlers& wxMimeTypesManagerImpl::GetIconHandlers()
     return ms_iconHandlers;
 }
 
     return ms_iconHandlers;
 }
 

-// read system and user mailcaps (TODO implement mime.types support)

 wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
 wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()

+{
+    m_initialized = FALSE;
+}
+
+// read system and user mailcaps and other files
+void wxMimeTypesManagerImpl::Initialize()

 {
     // directories where we look for mailcap and mime.types by default
     // (taken from metamail(1) sources)
 {
     // directories where we look for mailcap and mime.types by default
     // (taken from metamail(1) sources)

+    //
+    // although RFC 1524 specifies the search path of
+    // /etc/:/usr/etc:/usr/local/etc only, it doesn't hurt to search in more
+    // places - OTOH, the RFC also says that this path can be changed with
+    // MAILCAPS environment variable (containing the colon separated full
+    // filenames to try) which is not done yet (TODO?)

     static const wxChar *aStandardLocations[] =
     {
         wxT("/etc"),
     static const wxChar *aStandardLocations[] =
     {
         wxT("/etc"),


@@ -1040,9 +1130,27 @@ wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
         handlers[hn]->GetMimeInfoRecords(this);
 }
 
         handlers[hn]->GetMimeInfoRecords(this);
 }
 

+
+wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl()
+{
+    size_t cnt = m_aEntries.GetCount();
+    for (size_t i = 0; i < cnt; i++)
+        delete m_aEntries[i];
+}
+
+wxFileType *
+wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
+{
+    wxFAIL_MSG( _T("unimplemented") ); // TODO
+
+    return NULL;
+}
+

 wxFileType *
 wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
 {
 wxFileType *
 wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
 {

+    InitIfNeeded();
+

     wxFileType *fileType = NULL;  
     size_t count = m_aExtensions.GetCount();
     for ( size_t n = 0; n < count; n++ ) {
     wxFileType *fileType = NULL;  
     size_t count = m_aExtensions.GetCount();
     for ( size_t n = 0; n < count; n++ ) {


@@ -1067,6 +1175,8 @@ wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
 wxFileType *
 wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
 {
 wxFileType *
 wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
 {

+    InitIfNeeded();
+

     // mime types are not case-sensitive
     wxString mimetype(mimeType);
     mimetype.MakeLower();
     // mime types are not case-sensitive
     wxString mimetype(mimeType);
     mimetype.MakeLower();


@@ -1103,6 +1213,8 @@ wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
 
 void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype)
 {
 
 void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype)
 {

+    InitIfNeeded();
+

     wxString extensions;
     const wxArrayString& exts = filetype.GetExtensions();
     size_t nExts = exts.GetCount();
     wxString extensions;
     const wxArrayString& exts = filetype.GetExtensions();
     size_t nExts = exts.GetCount();


@@ -1128,6 +1240,8 @@ void wxMimeTypesManagerImpl::AddMimeTypeInfo(const wxString& strMimeType,
                                              const wxString& strExtensions,
                                              const wxString& strDesc)
 {
                                              const wxString& strExtensions,
                                              const wxString& strDesc)
 {

+    InitIfNeeded();
+

     int index = m_aTypes.Index(strMimeType);
     if ( index == wxNOT_FOUND ) {
         // add a new entry
     int index = m_aTypes.Index(strMimeType);
     if ( index == wxNOT_FOUND ) {
         // add a new entry


@@ -1151,6 +1265,8 @@ void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
                                             const wxString& strTest,
                                             const wxString& strDesc)
 {
                                             const wxString& strTest,
                                             const wxString& strDesc)
 {

+    InitIfNeeded();
+

     MailCapEntry *entry = new MailCapEntry(strOpenCmd, strPrintCmd, strTest);
 
     int nIndex = m_aTypes.Index(strType);
     MailCapEntry *entry = new MailCapEntry(strOpenCmd, strPrintCmd, strTest);
 
     int nIndex = m_aTypes.Index(strType);


@@ -1175,7 +1291,8 @@ void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
 
 bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
 {
 
 bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
 {

-    wxLogTrace(wxT("--- Parsing mime.types file '%s' ---"), strFileName.c_str());
+    wxLogTrace(TRACE_MIME, wxT("--- Parsing mime.types file '%s' ---"),
+               strFileName.c_str());

 
     wxTextFile file(strFileName);
     if ( !file.Open() )
 
     wxTextFile file(strFileName);
     if ( !file.Open() )


@@ -1250,8 +1367,9 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
                 }
             }
             else {
                 }
             }
             else {

-                // unquoted string ends at the first space
-                for ( pEnd = pc; !wxIsspace(*pEnd); pEnd++ )
+                // unquoted string ends at the first space or at the end of
+                // line
+                for ( pEnd = pc; *pEnd && !wxIsspace(*pEnd); pEnd++ )

                     ;
             }
 
                     ;
             }
 


@@ -1302,9 +1420,8 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
             }
         }
 
             }
         }
 

-        // 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)
+        // depending on the format (Mosaic or Netscape) either space or comma
+        // is used to separate the extensions

         strExtensions.Replace(wxT(","), wxT(" "));
 
         // also deal with the leading dot
         strExtensions.Replace(wxT(","), wxT(" "));
 
         // also deal with the leading dot


@@ -1330,7 +1447,8 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
 bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                                          bool fallback)
 {
 bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                                          bool fallback)
 {

-    wxLogTrace(wxT("--- Parsing mailcap file '%s' ---"), strFileName.c_str());
+    wxLogTrace(TRACE_MIME, wxT("--- Parsing mailcap file '%s' ---"),
+               strFileName.c_str());

 
     wxTextFile file(strFileName);
     if ( !file.Open() )
 
     wxTextFile file(strFileName);
     if ( !file.Open() )


@@ -1378,18 +1496,31 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                  strTest,
                  strDesc,
                  curField; // accumulator
                  strTest,
                  strDesc,
                  curField; // accumulator

-        for ( bool cont = TRUE; cont; pc++ ) {
+        bool cont = TRUE;
+        while ( cont ) {

             switch ( *pc ) {
                 case wxT('\\'):
                     // interpret the next character literally (notice that
                     // backslash can be used for line continuation)
                     if ( *++pc == wxT('\0') ) {
             switch ( *pc ) {
                 case wxT('\\'):
                     // interpret the next character literally (notice that
                     // backslash can be used for line continuation)
                     if ( *++pc == wxT('\0') ) {

-                        // fetch the next line.
-
-                        // pc currently points to nowhere, but after the next
-                        // pc++ in the for line it will point to the beginning
-                        // of the next line in the file
-                        pc = file[++nLine].c_str() - 1;
+                        // fetch the next line if there is one
+                        if ( nLine == nLineCount - 1 ) {
+                            // something is wrong, bail out
+                            cont = FALSE;
+
+                            wxLogDebug(wxT("Mailcap file %s, line %d: "
+                                           "'\\' on the end of the last line "
+                                           "ignored."),
+                                       strFileName.c_str(),
+                                       nLine + 1);
+                        }
+                        else {
+                            // pass to the beginning of the next line
+                            pc = file[++nLine].c_str();
+
+                            // skip pc++ at the end of the loop
+                            continue;
+                        }

                     }
                     else {
                         // just a normal character
                     }
                     else {
                         // just a normal character


@@ -1411,6 +1542,12 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                     switch ( currentToken ) {
                         case Field_Type:
                             strType = curField;
                     switch ( currentToken ) {
                         case Field_Type:
                             strType = curField;

+                            if ( strType.empty() ) {
+                                // I don't think that this is a valid mailcap
+                                // entry, but try to interpret it somehow
+                                strType = _T('*');
+                            }
+

                             if ( strType.Find(wxT('/')) == wxNOT_FOUND ) {
                                 // we interpret "type" as "type/*"
                                 strType += wxT("/*");
                             if ( strType.Find(wxT('/')) == wxNOT_FOUND ) {
                                 // we interpret "type" as "type/*"
                                 strType += wxT("/*");


@@ -1426,7 +1563,7 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                             break;
 
                         case Field_Other:
                             break;
 
                         case Field_Other:

-                            {
+                            if ( !curField.empty() ) {

                                 // "good" mailcap entry?
                                 bool ok = TRUE;
 
                                 // "good" mailcap entry?
                                 bool ok = TRUE;
 


@@ -1465,25 +1602,23 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                                 }
                                 else {
                                     // no, it's a simple flag
                                 }
                                 else {
                                     // no, it's a simple flag

-                                    // TODO support the flags:
-                                    //  1. create an xterm for 'needsterminal'
-                                    //  2. append "| $PAGER" for 'copiousoutput'

                                     if ( curField == wxT("needsterminal") )
                                         needsterminal = TRUE;
                                     if ( curField == wxT("needsterminal") )
                                         needsterminal = TRUE;

-                                    else if ( curField == wxT("copiousoutput") )
+                                    else if ( curField == wxT("copiousoutput")) {
+                                        // copiousoutput impies that the
+                                        // viewer is a console program
+                                        needsterminal =

                                         copiousoutput = TRUE;
                                         copiousoutput = TRUE;

-                                    else if ( curField == wxT("textualnewlines") )
-                                        ;   // ignore
-                                    else
+                                    }
+                                    else {
+                                        // unknown flag

                                         ok = FALSE;
                                         ok = FALSE;

+                                    }

                                 }
 
                                 if ( !ok )
                                 {
                                 }
 
                                 if ( !ok )
                                 {

-                                    // we don't understand this field, but
-                                    // Netscape stores info in it, so don't warn
-                                    // about it
-                                    if ( curField.Left(16u) != "x-mozilla-flags=" )
+                                    if ( !IsKnownUnimportantField(curField) )

                                     {
                                         // don't flood the user with error
                                         // messages if we don't understand
                                     {
                                         // don't flood the user with error
                                         // messages if we don't understand


@@ -1503,6 +1638,7 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                                     }
                                 }
                             }
                                     }
                                 }
                             }

+                            //else: the field is empty, ignore silently

 
                             // it already has this value
                             //currentToken = Field_Other;
 
                             // it already has this value
                             //currentToken = Field_Other;


@@ -1519,6 +1655,9 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                 default:
                     curField += *pc;
             }
                 default:
                     curField += *pc;
             }

+
+            // continue in the same line
+            pc++;

         }
 
         // check that we really read something reasonable
         }
 
         // check that we really read something reasonable


@@ -1528,6 +1667,24 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                          strFileName.c_str(), nLine + 1);
         }
         else {
                          strFileName.c_str(), nLine + 1);
         }
         else {

+            // support for flags:
+            //  1. create an xterm for 'needsterminal'
+            //  2. append "| $PAGER" for 'copiousoutput'
+            //
+            // Note that the RFC says that having both needsterminal and
+            // copiousoutput is probably a mistake, so it seems that running
+            // programs with copiousoutput inside an xterm as it is done now
+            // is a bad idea (FIXME)
+            if ( copiousoutput ) {
+                const wxChar *p = wxGetenv(_T("PAGER"));
+                strOpenCmd << _T(" | ") << (p ? p : _T("more"));
+            }
+
+            if ( needsterminal ) {
+                strOpenCmd.Printf(_T("xterm -e sh -c '%s'"),
+                                  strOpenCmd.c_str());
+            }
+

             MailCapEntry *entry = new MailCapEntry(strOpenCmd,
                                                    strPrintCmd,
                                                    strTest);
             MailCapEntry *entry = new MailCapEntry(strOpenCmd,
                                                    strPrintCmd,
                                                    strTest);


@@ -1606,6 +1763,8 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
 
 size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 {
 
 size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 {

+    InitIfNeeded();
+

     mimetypes.Empty();
 
     wxString type;
     mimetypes.Empty();
 
     wxString type;


@@ -1623,6 +1782,40 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
     return mimetypes.GetCount();
 }
 
     return mimetypes.GetCount();
 }
 

+// ----------------------------------------------------------------------------
+// writing to MIME type files
+// ----------------------------------------------------------------------------
+
+bool wxFileTypeImpl::Unassociate()
+{
+    wxFAIL_MSG( _T("unimplemented") ); // TODO
+
+    return FALSE;
+}
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+static bool IsKnownUnimportantField(const wxString& fieldAll)
+{
+    static const wxChar *knownFields[] =
+    {
+        _T("x-mozilla-flags"),
+        _T("nametemplate"),
+        _T("textualnewlines"),
+    };
+
+    wxString field = fieldAll.BeforeFirst(_T('='));
+    for ( size_t n = 0; n < WXSIZEOF(knownFields); n++ )
+    {
+        if ( field.CmpNoCase(knownFields[n]) == 0 )
+            return TRUE;
+    }
+
+    return FALSE;
+}
+

 #endif
   // wxUSE_FILE && wxUSE_TEXTFILE
 
 #endif
   // wxUSE_FILE && wxUSE_TEXTFILE