Calculate correct client size for windows that are using deferred sizing.

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

diff --git a/src/unix/mimetype.cpp b/src/unix/mimetype.cpp
index ece8e422eb3052c82f61f78c2b5583cb74df1905..8c2ddad03e862c56b88bd96a7daed2ab09641a9b 100644 (file)
--- a/src/unix/mimetype.cpp
+++ b/src/unix/mimetype.cpp
@@ -6,12 +6,28 @@
 // Created:     23.09.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     23.09.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

-// Licence:     wxWindows license (part of wxExtra library)
+// Licence:     wxWindows licence (part of wxExtra library)

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef    __GNUG__
-#pragma implementation "mimetype.h"
-#endif
+// known bugs; there may be others!! chris elliott, biol75@york.ac.uk 27 Mar 01
+
+// 1) .mailcap and .mimetypes can be either in a netscape or metamail format
+//    and entries may get confused during writing (I've tried to fix this; please let me know
+//    any files that fail)
+// 2) KDE and Gnome do not yet fully support international read/write
+// 3) Gnome key lines like open.latex."LaTeX this file"=latex %f will have odd results
+// 4) writing to files comments out the existing data; I hope this avoids losing
+//    any data which we could not read, and data which we did not store like test=
+// 5) results from reading files with multiple entries (especially matches with type/* )
+//    may (or may not) work for getXXX commands
+// 6) Loading the png icons in Gnome doesn't work for me...
+// 7) In Gnome, if keys.mime exists but keys.users does not, there is
+//    an error message in debug mode, but the file is still written OK
+// 8) Deleting entries is only allowed from the user file; sytem wide entries
+//    will be preserved during unassociate
+// 9) KDE does not yet handle multiple actions; Netscape mode never will
+
+// TODO: this file is a mess, we need to split it and review everything (VZ)

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


@@ -24,15 +40,11 @@
   #include "wx/defs.h"
 #endif
 
   #include "wx/defs.h"
 #endif
 

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

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

-  #if wxUSE_GUI
-    #include "wx/icon.h"
-  #endif
-#endif //WX_PRECOMP
-
+#endif

 
 #include "wx/log.h"
 #include "wx/file.h"
 
 #include "wx/log.h"
 #include "wx/file.h"


@@ -45,25 +57,215 @@
 #include "wx/dir.h"
 #include "wx/utils.h"
 #include "wx/tokenzr.h"
 #include "wx/dir.h"
 #include "wx/utils.h"
 #include "wx/tokenzr.h"

+#include "wx/iconloc.h"
+#include "wx/filename.h"

 
 #include "wx/unix/mimetype.h"
 
 // other standard headers
 #include <ctype.h>
 
 
 #include "wx/unix/mimetype.h"
 
 // other standard headers
 #include <ctype.h>
 

+#ifdef __VMS
+/* silence warnings for comparing unsigned int's <0 */
+# pragma message disable unscomzer
+#endif
+
+// wxMimeTypeCommands stores the verbs defined for the given MIME type with
+// their values
+class wxMimeTypeCommands
+{
+public:
+    wxMimeTypeCommands() {}
+
+    wxMimeTypeCommands(const wxArrayString& verbs,
+                       const wxArrayString& commands)
+        : m_verbs(verbs),
+          m_commands(commands)
+    {
+    }
+
+    // add a new verb with the command or replace the old value
+    void AddOrReplaceVerb(const wxString& verb, const wxString& cmd)
+    {
+        int n = m_verbs.Index(verb, false /* ignore case */);
+        if ( n == wxNOT_FOUND )
+        {
+            m_verbs.Add(verb);
+            m_commands.Add(cmd);
+        }
+        else
+        {
+            m_commands[n] = cmd;
+        }
+    }
+
+    void Add(const wxString& s)
+    {
+        m_verbs.Add(s.BeforeFirst(wxT('=')));
+        m_commands.Add(s.AfterFirst(wxT('=')));
+    }
+
+    // access the commands
+    size_t GetCount() const { return m_verbs.GetCount(); }
+    const wxString& GetVerb(size_t n) const { return m_verbs[n]; }
+    const wxString& GetCmd(size_t n) const { return m_commands[n]; }
+
+    bool HasVerb(const wxString& verb) const
+        { return m_verbs.Index(verb) != wxNOT_FOUND; }
+
+    wxString GetCommandForVerb(const wxString& verb, size_t *idx = NULL) const
+    {
+        wxString s;
+
+        int n = m_verbs.Index(verb);
+        if ( n != wxNOT_FOUND )
+        {
+            s = m_commands[(size_t)n];
+            if ( idx )
+                *idx = n;
+        }
+
+        return s;
+    }
+
+    // get a "verb=command" string
+    wxString GetVerbCmd(size_t n) const
+    {
+        return m_verbs[n] + wxT('=') + m_commands[n];
+    }
+
+private:
+    wxArrayString m_verbs;
+    wxArrayString m_commands;
+};
+
+// this class extends wxTextFile
+//
+// VZ: ???
+class wxMimeTextFile : public wxTextFile
+{
+public:
+    // constructors
+    wxMimeTextFile () : wxTextFile () {};
+    wxMimeTextFile(const wxString& strFile) : wxTextFile(strFile) {};
+
+    int pIndexOf(const wxString & sSearch, bool bIncludeComments = false, int iStart = 0)
+    {
+        size_t i = iStart;
+        int nResult = wxNOT_FOUND;
+        if (i >= GetLineCount())
+            return wxNOT_FOUND;
+
+        wxString sTest = sSearch;
+        sTest.MakeLower();
+        wxString sLine;
+
+        if (bIncludeComments)
+        {
+            while ( i < GetLineCount() )
+            {
+                sLine = GetLine(i);
+                sLine.MakeLower();
+                if (sLine.Contains(sTest))
+                    nResult = (int) i;
+
+                i++;
+            }
+        }
+        else
+        {
+            while ( (i < GetLineCount()) )
+            {
+                sLine = GetLine(i);
+                sLine.MakeLower();
+                if ( ! sLine.StartsWith(wxT("#")))
+                {
+                    if (sLine.Contains(sTest))
+                        nResult = (int) i;
+                }
+
+                i++;
+            }
+        }
+
+        return  nResult;
+    }
+
+    bool CommentLine(int nIndex)
+    {
+        if (nIndex < 0)
+            return false;
+        if (nIndex >= (int)GetLineCount() )
+            return false;
+
+        GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
+        return true;
+    }
+
+    bool CommentLine(const wxString & sTest)
+    {
+        int nIndex = pIndexOf(sTest);
+        if (nIndex < 0)
+            return false;
+        if (nIndex >= (int)GetLineCount() )
+            return false;
+
+        GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
+        return true;
+    }
+
+    wxString GetVerb(size_t i)
+    {
+        if (i > GetLineCount() )
+            return wxEmptyString;
+
+        wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
+        return sTmp;
+    }
+
+    wxString GetCmd(size_t i)
+    {
+        if (i > GetLineCount() )
+            return wxEmptyString;
+
+        wxString sTmp = GetLine(i).AfterFirst(wxT('='));
+        return sTmp;
+    }
+};
+

 // in case we're compiling in non-GUI mode
 class WXDLLEXPORT wxIcon;
 
 // in case we're compiling in non-GUI mode
 class WXDLLEXPORT wxIcon;
 

+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+// MIME code tracing mask
+#define TRACE_MIME wxT("mime")
+
+// give trace messages about the results of mailcap tests
+#define TRACE_MIME_TEST wxT("mimetest")
+
+// ----------------------------------------------------------------------------
+// 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
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // 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 +292,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 +302,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 +311,23 @@ 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> BACKSLASH
+//      desc="<description>" BACKSLASH
+//      exts="<comma separated list of extensions>"
+//
+// (where BACKSLASH is a literal '\\' which we can't put here because cpp
+// misinterprets it)

 //
 // 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.


@@ -127,187 +335,342 @@ class WXDLLEXPORT wxIcon;
 // there may be more than one entry for one and the same mime type, to
 // choose the right one we have to run the command specified in the test
 // field on our data.
 // there may be more than one entry for one and the same mime type, to
 // choose the right one we have to run the command specified in the test
 // field on our data.

-class MailCapEntry
+
+// ----------------------------------------------------------------------------
+// wxGNOME
+// ----------------------------------------------------------------------------
+
+// GNOME stores the info we're interested in in several locations:
+//  1. xxx.keys files under /usr/share/mime-info
+//  2. xxx.keys files under ~/.gnome/mime-info
+//
+// The format of xxx.keys file is the following:
+//
+// mimetype/subtype:
+//      field=value
+//
+// 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.
+
+
+bool wxMimeTypesManagerImpl::CheckGnomeDirsExist()

 {
 {

-public:
-    // ctor
-    MailCapEntry(const wxString& openCmd,
-                 const wxString& printCmd,
-                 const wxString& testCmd)
-        : m_openCmd(openCmd), m_printCmd(printCmd), m_testCmd(testCmd)
+    wxString gnomedir;
+    wxGetHomeDir( &gnomedir );
+    wxString sTmp = gnomedir;
+    sTmp = sTmp + wxT("/.gnome");
+    if (! wxDir::Exists( sTmp ) )

     {
     {

-        m_next = NULL;
+        if (!wxMkdir( sTmp ))
+        {
+            wxLogError(wxT("Failed to create directory %s/.gnome."), sTmp.c_str());
+            return false;
+        }

     }
 
     }
 

-    // accessors
-    const wxString& GetOpenCmd()  const { return m_openCmd;  }
-    const wxString& GetPrintCmd() const { return m_printCmd; }
-    const wxString& GetTestCmd()  const { return m_testCmd;  }
-
-    MailCapEntry *GetNext() const { return m_next; }
-
-    // operations
-        // prepend this element to the list
-    void Prepend(MailCapEntry *next) { m_next = next; }
-        // insert into the list at given position
-    void Insert(MailCapEntry *next, size_t pos)
+    sTmp = sTmp + wxT("/mime-info");
+    if (! wxDir::Exists( sTmp ) )

     {
     {

-        // FIXME slooow...
-        MailCapEntry *cur;
-        size_t n = 0;
-        for ( cur = next; cur != NULL; cur = cur->m_next, n++ ) {
-            if ( n == pos )
-                break;
+        if (!wxMkdir( sTmp ))
+        {
+            wxLogError(wxT("Failed to create directory %s/mime-info."), sTmp.c_str());
+            return false;

         }
         }

+    }

 
 

-        wxASSERT_MSG( n == pos, wxT("invalid position in MailCapEntry::Insert") );
+    return true;
+}

 
 

-        m_next = cur->m_next;
-        cur->m_next = this;
-    }
-        // append this element to the list
-    void Append(MailCapEntry *next)
+bool wxMimeTypesManagerImpl::WriteGnomeKeyFile(int index, bool delete_index)
+{
+    wxString gnomedir;
+    wxGetHomeDir( &gnomedir );
+
+    wxMimeTextFile outfile( gnomedir + wxT("/.gnome/mime-info/user.keys"));
+    // if this fails probably Gnome is not installed ??
+    // create it anyway as a private mime store
+
+#if defined(__WXGTK20__) && wxUSE_UNICODE
+    if (! outfile.Open( wxConvUTF8) )
+#else
+    if (! outfile.Open() )
+#endif

     {
     {

-        wxCHECK_RET( next != NULL, wxT("Append()ing to what?") );
+        if (delete_index)
+            return false;
+        if (!CheckGnomeDirsExist() )
+            return false;

 
 

-        // FIXME slooow...
-        MailCapEntry *cur;
-        for ( cur = next; cur->m_next != NULL; cur = cur->m_next )
-            ;
+        outfile.Create();
+    }

 
 

-        cur->m_next = this;
+    wxString sTmp, strType = m_aTypes[index];
+    int nIndex = outfile.pIndexOf(strType);
+    if ( nIndex == wxNOT_FOUND )
+    {
+        outfile.AddLine( strType + wxT(':') );
+        // see file:/usr/doc/gnome-libs-devel-1.0.40/devel-docs/mime-type-handling.txt
+        // as this does not deal with internationalisation
+        //        wxT( "\t[en_US]") + verb + wxT ('=') + cmd + wxT(" %f");
+        wxMimeTypeCommands * entries = m_aEntries[index];
+        size_t count = entries->GetCount();
+        for ( size_t i = 0; i < count; i++ )
+        {
+            sTmp = entries->GetVerbCmd( i );
+            sTmp.Replace( wxT("%s"), wxT("%f") );
+            sTmp = wxT( "\t") + sTmp;
+            outfile.AddLine( sTmp );
+        }

 
 

-        wxASSERT_MSG( !m_next, wxT("Append()ing element already in the list?") );
+        //for international use do something like this
+        //outfile.AddLine( wxString( "\t[en_US]icon-filename=") + cmd );
+        outfile.AddLine( wxT( "\ticon-filename=") + m_aIcons[index] );

     }
     }

+    else
+    {
+        if (delete_index)
+            outfile.CommentLine(nIndex);

 
 

-private:
-    wxString m_openCmd,         // command to use to open/view the file
-             m_printCmd,        //                     print
-             m_testCmd;         // only apply this entry if test yields
-                                // true (i.e. the command returns 0)
+        wxMimeTypeCommands sOld;
+        size_t nOld = nIndex + 1;
+        bool oldEntryEnd = false;
+        while ( (nOld < outfile.GetLineCount() ) && !oldEntryEnd)
+        {
+            sTmp = outfile.GetLine(nOld);
+            if ( (sTmp[0u] == wxT('\t')) || (sTmp[0u] == wxT('#')) )
+            {
+                // we have another line to deal with
+                outfile.CommentLine(nOld);
+                nOld++;

 
 

-    MailCapEntry *m_next;       // in the linked list
-};
+                // add the line to our store
+                if ((!delete_index) && (sTmp[0u] == wxT('\t')))
+                    sOld.Add(sTmp);
+            }
+            // next mimetpye ?? or blank line
+            else
+                oldEntryEnd = true;
+        }

 
 

+        // list of entries in our data; these should all be in sOld,
+        // though sOld may also contain other entries , eg flags
+        if (!delete_index)
+        {
+            wxMimeTypeCommands * entries = m_aEntries[index];
+            size_t i;
+            for (i=0; i < entries->GetCount(); i++)
+            {
+                // replace any entries in sold that match verbs we know
+                sOld.AddOrReplaceVerb( entries->GetVerb(i), entries->GetCmd(i) );
+            }

 
 

-// the base class which may be used to find an icon for the MIME type
-class wxMimeTypeIconHandler
-{
-public:
-    virtual bool GetIcon(const wxString& mimetype, wxIcon *icon) = 0;
+            //sOld should also contain the icon
+            if ( !m_aIcons[index].empty() )
+                sOld.AddOrReplaceVerb( wxT("icon-filename"), m_aIcons[index] );

 
 

-    // this function fills manager with MIME types information gathered
-    // (as side effect) when searching for icons. This may be particularly
-    // useful if mime.types is incomplete (e.g. RedHat distributions).
-    virtual void GetMimeInfoRecords(wxMimeTypesManagerImpl *manager) = 0;
-};
+            for (i=0; i < sOld.GetCount(); i++)
+            {
+                sTmp = sOld.GetVerbCmd( i );
+                sTmp.Replace( wxT("%s"), wxT("%f") );
+                sTmp = wxT("\t") + sTmp;
+                nIndex++;
+                outfile.InsertLine( sTmp, nIndex );
+            }
+        }
+    }

 
 

+    bool bTmp = outfile.Write();
+    return bTmp;
+}

 
 

-// the icon handler which uses GNOME MIME database
-class wxGNOMEIconHandler : public wxMimeTypeIconHandler
+bool wxMimeTypesManagerImpl::WriteGnomeMimeFile(int index, bool delete_index)

 {
 {

-public:
-    virtual bool GetIcon(const wxString& mimetype, wxIcon *icon);
-    virtual void GetMimeInfoRecords(wxMimeTypesManagerImpl *manager) {}
-
-private:
-    void Init();
-    void LoadIconsFromKeyFile(const wxString& filename);
-    void LoadKeyFilesFromDir(const wxString& dirbase);
+    wxString gnomedir;
+    wxGetHomeDir( &gnomedir );

 
 

-    static bool m_inited;
+    wxMimeTextFile outfile( gnomedir + wxT("/.gnome/mime-info/user.mime") );
+    // if this fails probably Gnome is not installed ??
+    // create it anyway as a private mime store
+    if (! outfile.Open() )
+    {
+        if (delete_index)
+            return false;
+        if (!CheckGnomeDirsExist() )
+            return false;

 
 

-    static wxSortedArrayString ms_mimetypes;
-    static wxArrayString       ms_icons;
-};
+        outfile.Create();
+    }

 
 

-// the icon handler which uses KDE MIME database
-class wxKDEIconHandler : public wxMimeTypeIconHandler
-{
-public:
-    virtual bool GetIcon(const wxString& mimetype, wxIcon *icon);
-    virtual void GetMimeInfoRecords(wxMimeTypesManagerImpl *manager);
+    wxString strType = m_aTypes[index];
+    int nIndex = outfile.pIndexOf(strType);
+    if ( nIndex == wxNOT_FOUND )
+    {
+        outfile.AddLine( strType );
+        outfile.AddLine( wxT("\text:") + m_aExtensions.Item(index) );
+    }
+    else
+    {
+        if (delete_index)
+        {
+            outfile.CommentLine(nIndex);
+            outfile.CommentLine(nIndex + 1);
+        }
+        else
+        {
+            // check for next line being the right one to replace ??
+            wxString sOld = outfile.GetLine(nIndex + 1);
+            if (sOld.Contains( wxT("\text: ") ))
+            {
+                outfile.GetLine(nIndex + 1) = wxT("\text: ") + m_aExtensions.Item(index);
+            }
+            else
+            {
+                outfile.InsertLine( wxT("\text: ") + m_aExtensions.Item(index), nIndex + 1 );
+            }
+        }
+    }

 
 

-private:
-    void LoadLinksForMimeSubtype(const wxString& dirbase,
-                                 const wxString& subdir,
-                                 const wxString& filename,
-                                 const wxArrayString& icondirs);
-    void LoadLinksForMimeType(const wxString& dirbase,
-                              const wxString& subdir,
-                              const wxArrayString& icondirs);
-    void LoadLinkFilesFromDir(const wxString& dirbase,
-                              const wxArrayString& icondirs);
-    void Init();
-
-    static bool m_inited;
-
-    static wxSortedArrayString ms_mimetypes;
-    static wxArrayString       ms_icons;
-
-    static wxArrayString       ms_infoTypes;
-    static wxArrayString       ms_infoDescriptions;
-    static wxArrayString       ms_infoExtensions;
-};
+    bool bTmp = outfile.Write();
+    return bTmp;
+}

 
 

+void wxMimeTypesManagerImpl::LoadGnomeDataFromKeyFile(const wxString& filename,
+                                                      const wxArrayString& dirs)
+{
+    wxTextFile textfile(filename);
+#if defined(__WXGTK20__) && wxUSE_UNICODE
+    if ( !textfile.Open(wxConvUTF8) )
+#else
+    if ( !textfile.Open() )
+#endif
+        return;

 
 

+    wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s  ---"),
+            filename.c_str());

 
 

-// ----------------------------------------------------------------------------
-// various statics
-// ----------------------------------------------------------------------------
+    // values for the entry being parsed
+    wxString curMimeType, curIconFile;
+    wxMimeTypeCommands * entry = new wxMimeTypeCommands;

 
 

-static wxGNOMEIconHandler gs_iconHandlerGNOME;
-static wxKDEIconHandler gs_iconHandlerKDE;
+    // these are always empty in this file
+    wxArrayString strExtensions;
+    wxString strDesc;

 
 

-bool wxGNOMEIconHandler::m_inited = FALSE;
-wxSortedArrayString wxGNOMEIconHandler::ms_mimetypes;
-wxArrayString       wxGNOMEIconHandler::ms_icons;
+    const wxChar *pc;
+    size_t nLineCount = textfile.GetLineCount();
+    size_t nLine = 0;
+    while ( nLine < nLineCount )
+    {
+        pc = textfile[nLine].c_str();
+        if ( *pc != wxT('#') )
+        {

 
 

-bool wxKDEIconHandler::m_inited = FALSE;
-wxSortedArrayString wxKDEIconHandler::ms_mimetypes;
-wxArrayString       wxKDEIconHandler::ms_icons;
+            wxLogTrace(TRACE_MIME, wxT("--- Reading from Gnome file %s '%s' ---"),
+                    filename.c_str(), pc);

 
 

-wxArrayString       wxKDEIconHandler::ms_infoTypes;
-wxArrayString       wxKDEIconHandler::ms_infoDescriptions;
-wxArrayString       wxKDEIconHandler::ms_infoExtensions;
+            wxString sTmp(pc);
+            if (sTmp.Contains(wxT("=")) )
+            {
+                if (sTmp.Contains( wxT("icon-filename=") ) )
+                {
+                    // GNOME 1:
+                    curIconFile = sTmp.AfterFirst(wxT('='));
+                }
+                else if (sTmp.Contains( wxT("icon_filename=") ) )
+                {
+                    // GNOME 2:
+                    curIconFile = sTmp.AfterFirst(wxT('='));
+
+                    if (!wxFileExists(curIconFile))
+                    {
+                        size_t nDirs = dirs.GetCount();
+                        for (size_t nDir = 0; nDir < nDirs; nDir++)
+                        {
+                            wxFileName newFile( curIconFile );
+                            newFile.SetPath( dirs[nDir] );
+                            newFile.AppendDir( wxT("pixmaps") );
+                            newFile.AppendDir( wxT("document-icons") );
+                            newFile.SetExt( wxT("png") );
+                            if (newFile.FileExists())
+                                curIconFile = newFile.GetFullPath();
+                        }
+                    }
+                }
+                else //: some other field,
+                {
+                    //may contain lines like this (RH7)
+                    // \t[lang]open.tex."TeX this file"=tex %f
+                    // \tflags.tex.flags=needsterminal
+                    // \topen.latex."LaTeX this file"=latex %f
+                    // \tflags.latex.flags=needsterminal
+
+                    // \topen=xdvi %f
+                    // \tview=xdvi %f
+                    // \topen.convert.Convert file to Postscript=dvips %f -o `basename %f .dvi`.ps
+
+                    // for now ignore lines with flags in...FIX
+                    sTmp = sTmp.AfterLast(wxT(']'));
+                    sTmp = sTmp.AfterLast(wxT('\t'));
+                    sTmp.Trim(false).Trim();
+                    if (0 == sTmp.Replace( wxT("%f"), wxT("%s") ))
+                        sTmp = sTmp + wxT(" %s");
+                    entry->Add(sTmp);
+                }

 
 

+            } // emd of has an equals sign
+            else
+            {
+                // not a comment and not an equals sign
+                if (sTmp.Contains(wxT('/')))
+                {
+                    // this is the start of the new mimetype
+                    // overwrite any existing data
+                    if (! curMimeType.empty())
+                    {
+                        AddToMimeData( curMimeType, curIconFile, entry, strExtensions, strDesc );
+
+                        // now get ready for next bit
+                        entry = new wxMimeTypeCommands;
+                    }

 
 

-ArrayIconHandlers wxMimeTypesManagerImpl::ms_iconHandlers;
+                    curMimeType = sTmp.BeforeFirst(wxT(':'));
+                }
+            }
+        } // end of not a comment

 
 

-// ----------------------------------------------------------------------------
-// wxGNOMEIconHandler
-// ----------------------------------------------------------------------------
+        // ignore blank lines
+        nLine++;
+    } // end of while, save any data

 
 

-// GNOME stores the info we're interested in in several locations:
-//  1. xxx.keys files under /usr/share/mime-info
-//  2. xxx.keys files under ~/.gnome/mime-info
-//
-// The format of xxx.keys file is the following:
-//
-// mimetype/subtype:
-//      field=value
-//
-// 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.
+    if (! curMimeType.empty())
+        AddToMimeData( curMimeType, curIconFile, entry, strExtensions, strDesc);
+}

 
 

-void wxGNOMEIconHandler::LoadIconsFromKeyFile(const wxString& filename)
+void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& filename)

 {
     wxTextFile textfile(filename);
     if ( !textfile.Open() )
         return;
 
 {
     wxTextFile textfile(filename);
     if ( !textfile.Open() )
         return;
 

+    wxLogTrace(TRACE_MIME,
+               wxT("--- Opened Gnome file %s  ---"),
+               filename.c_str());
+

     // values for the entry being parsed
     // values for the entry being parsed

-    wxString curMimeType, curIconFile;
+    wxString curMimeType, curExtList;

 
     const wxChar *pc;
     size_t nLineCount = textfile.GetLineCount();
 
     const wxChar *pc;
     size_t nLineCount = textfile.GetLineCount();

-    for ( size_t nLine = 0; ; nLine++ )
+    for ( size_t nLine = 0; /* nothing */; nLine++ )

     {
         if ( nLine < nLineCount )
         {
             pc = textfile[nLine].c_str();
     {
         if ( nLine < nLineCount )
         {
             pc = textfile[nLine].c_str();

-            if ( *pc == _T('#') )
+            if ( *pc == wxT('#') )

             {
                 // skip comments
                 continue;
             {
                 // skip comments
                 continue;


@@ -322,80 +685,69 @@ void wxGNOMEIconHandler::LoadIconsFromKeyFile(const wxString& filename)
         if ( !pc || !*pc )
         {
             // end of the entry
         if ( !pc || !*pc )
         {
             // end of the entry

-            if ( !!curMimeType && !!curIconFile )
+            if ( !curMimeType.empty() && !curExtList.empty() )

             {
             {

-                // do we already know this mimetype?
-                int i = ms_mimetypes.Index(curMimeType);
-                if ( i == wxNOT_FOUND )
-                {
-                    // add a new entry
-                    size_t n = ms_mimetypes.Add(curMimeType);
-                    ms_icons.Insert(curIconFile, n);
-                }
-                else
-                {
-                    // replace the existing one (this means that the directories
-                    // should be searched in order of increased priority!)
-                    ms_icons[(size_t)i] = curIconFile;
-                }
+                 wxLogTrace(TRACE_MIME,
+                            wxT("--- At end of Gnome file  finding mimetype %s  ---"),
+                            curMimeType.c_str());
+
+                 AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);

             }
 
             if ( !pc )
             {
             }
 
             if ( !pc )
             {

-                // the end - this can only happen if nLine == nLineCount
+                // the end: this can only happen if nLine == nLineCount

                 break;
             }
 
                 break;
             }
 

-            curIconFile.Empty();
+            curExtList.Empty();

 
             continue;
         }
 
         // what do we have here?
 
             continue;
         }
 
         // what do we have here?

-        if ( *pc == _T('\t') )
+        if ( *pc == wxT('\t') )

         {
             // this is a field=value ling
             pc++; // skip leading TAB
 
         {
             // this is a field=value ling
             pc++; // skip leading TAB
 

-            static const int lenField = 13; // strlen("icon-filename")
-            if ( wxStrncmp(pc, _T("icon-filename"), lenField) == 0 )
+            static const int lenField = 5; // strlen("ext: ")
+            if ( wxStrncmp(pc, wxT("ext: "), lenField) == 0 )

             {
             {

-                // skip '=' which follows and take everything left until the end
-                // of line
-                curIconFile = pc + lenField + 1;
+                // skip it and take everything left until the end of line
+                curExtList = pc + lenField;

             }
             //else: some other field, we don't care
         }
         else
         {
             // this is the start of the new section
             }
             //else: some other field, we don't care
         }
         else
         {
             // this is the start of the new section

+            wxLogTrace(TRACE_MIME,
+                       wxT("--- In Gnome file  finding mimetype %s  ---"),
+                       curMimeType.c_str());
+
+            if (! curMimeType.empty())
+                AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
+

             curMimeType.Empty();
 
             curMimeType.Empty();
 

-            while ( *pc != _T(':') && *pc != _T('\0') )
+            while ( *pc != wxT(':') && *pc != wxT('\0') )

             {
                 curMimeType += *pc++;
             }
             {
                 curMimeType += *pc++;
             }

-
-            if ( !*pc )
-            {
-                // we reached the end of line without finding the colon,
-                // something is wrong - ignore this line completely
-                wxLogDebug(_T("Unreckognized line %d in file '%s' ignored"),
-                           nLine + 1, filename.c_str());
-
-                break;
-            }

         }
     }
 }
 
         }
     }
 }
 

-void wxGNOMEIconHandler::LoadKeyFilesFromDir(const wxString& dirbase)
+
+void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(
+                      const wxString& dirbase, const wxArrayString& dirs)

 {
 {

-    wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
-                  _T("base directory shouldn't end with a slash") );
+    wxASSERT_MSG( !dirbase.empty() && !wxEndsWithPathSeparator(dirbase),
+                  wxT("base directory shouldn't end with a slash") );

 
     wxString dirname = dirbase;
 
     wxString dirname = dirbase;

-    dirname << _T("/mime-info");
+    dirname << wxT("/mime-info");

 
     if ( !wxDir::Exists(dirname) )
         return;
 
     if ( !wxDir::Exists(dirname) )
         return;


@@ -405,65 +757,100 @@ void wxGNOMEIconHandler::LoadKeyFilesFromDir(const wxString& dirbase)
         return;
 
     // we will concatenate it with filename to get the full path below
         return;
 
     // we will concatenate it with filename to get the full path below

-    dirname += _T('/');
+    dirname += wxT('/');

 
     wxString filename;
 
     wxString filename;

-    bool cont = dir.GetFirst(&filename, _T("*.keys"), wxDIR_FILES);
+    bool cont;
+
+    cont = dir.GetFirst(&filename, wxT("*.mime"), wxDIR_FILES);

     while ( cont )
     {
     while ( cont )
     {

-        LoadIconsFromKeyFile(dirname + filename);
+        LoadGnomeMimeTypesFromMimeFile(dirname + filename);

 
         cont = dir.GetNext(&filename);
     }
 
         cont = dir.GetNext(&filename);
     }

-}
-
-void wxGNOMEIconHandler::Init()
-{
-    wxArrayString dirs;
-    dirs.Add(_T("/usr/share"));
-
-    wxString gnomedir;
-    wxGetHomeDir( &gnomedir );
-    gnomedir += _T("/.gnome");
-    dirs.Add( gnomedir );

 
 

-    size_t nDirs = dirs.GetCount();
-    for ( size_t nDir = 0; nDir < nDirs; nDir++ )
+    cont = dir.GetFirst(&filename, wxT("*.keys"), wxDIR_FILES);
+    while ( cont )

     {
     {

-        LoadKeyFilesFromDir(dirs[nDir]);
+        LoadGnomeDataFromKeyFile(dirname + filename, dirs);
+
+        cont = dir.GetNext(&filename);

     }
 
     }
 

-    m_inited = TRUE;
-}
+    // FIXME: Hack alert: We scan all icons and deduce the
+    //             mime-type from the file name.
+    dirname = dirbase;
+    dirname << wxT("/pixmaps/document-icons");

 
 

-bool wxGNOMEIconHandler::GetIcon(const wxString& mimetype, wxIcon *icon)
-{
-    if ( !m_inited )
+    // these are always empty in this file
+    wxArrayString strExtensions;
+    wxString strDesc;
+
+    if ( !wxDir::Exists(dirname) )

     {
     {

-        Init();
+        // Just test for default GPE dir also
+        dirname = wxT("/usr/share/gpe/pixmaps/default/filemanager/document-icons");
+
+        if ( !wxDir::Exists(dirname) )
+           return;

     }
 
     }
 

-    int index = ms_mimetypes.Index(mimetype);
-    if ( index == wxNOT_FOUND )
-        return FALSE;
+    wxDir dir2( dirname );

 
 

-    wxString iconname = ms_icons[(size_t)index];
+    cont = dir2.GetFirst(&filename, wxT("gnome-*.png"), wxDIR_FILES);
+    while ( cont )
+    {
+        wxString mimeType = filename;
+        mimeType.Remove( 0, 6 ); // remove "gnome-"
+        mimeType.Remove( mimeType.Len() - 4, 4 ); // remove ".png"
+        int pos = mimeType.Find( wxT("-") );
+        if (pos != wxNOT_FOUND)
+        {
+            mimeType.SetChar( pos, wxT('/') );
+            wxString iconFile = dirname;
+            iconFile << wxT("/");
+            iconFile << filename;
+            AddToMimeData( mimeType, iconFile, NULL, strExtensions, strDesc, true );
+        }

 
 

-#if wxUSE_GUI
-    *icon = wxIcon(iconname);
-#else
-    // helpful for testing in console mode
-    wxLogDebug(_T("Found GNOME icon for '%s': '%s'\n"),
-               mimetype.c_str(), iconname.c_str());
-#endif
+        cont = dir2.GetNext(&filename);
+    }
+}
+
+void wxMimeTypesManagerImpl::GetGnomeMimeInfo(const wxString& sExtraDir)
+{
+    wxArrayString dirs;
+
+    wxString gnomedir = wxGetenv( wxT("GNOMEDIR") );
+    if (!gnomedir.empty())
+    {
+        gnomedir << wxT("/share");
+        dirs.Add( gnomedir );
+    }
+
+    dirs.Add(wxT("/usr/share"));
+    dirs.Add(wxT("/usr/local/share"));
+
+    gnomedir = wxGetHomeDir();
+    gnomedir << wxT("/.gnome");
+    dirs.Add( gnomedir );
+
+    if (!sExtraDir.empty())
+        dirs.Add( sExtraDir );

 
 

-    return TRUE;
+    size_t nDirs = dirs.GetCount();
+    for ( size_t nDir = 0; nDir < nDirs; nDir++ )
+    {
+        LoadGnomeMimeFilesFromDir(dirs[nDir], dirs);
+    }

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxKDEIconHandler
+// KDE

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

+

 // KDE stores the icon info in its .kdelnk files. The file for mimetype/subtype
 // may be found in either of the following locations
 //
 // KDE stores the icon info in its .kdelnk files. The file for mimetype/subtype
 // may be found in either of the following locations
 //


@@ -474,117 +861,280 @@ bool wxGNOMEIconHandler::GetIcon(const wxString& mimetype, wxIcon *icon)
 // wxFileConfig, i.e. there are groups, comments and entries. The icon is the
 // value for the entry "Type"
 
 // wxFileConfig, i.e. there are groups, comments and entries. The icon is the
 // value for the entry "Type"
 

-void wxKDEIconHandler::LoadLinksForMimeSubtype(const wxString& dirbase,
+// kde writing; see http://webcvs.kde.org/cgi-bin/cvsweb.cgi/~checkout~/kdelibs/kio/DESKTOP_ENTRY_STANDARD
+// for now write to .kdelnk but should eventually do .desktop instead (in preference??)
+
+bool wxMimeTypesManagerImpl::CheckKDEDirsExist( const wxString &sOK, const wxString &sTest )
+{
+    if (sTest.empty())
+    {
+        return wxDir::Exists(sOK);
+    }
+    else
+    {
+        wxString sStart = sOK + wxT("/") + sTest.BeforeFirst(wxT('/'));
+        if (!wxDir::Exists(sStart))
+            wxMkdir(sStart);
+        wxString sEnd = sTest.AfterFirst(wxT('/'));
+        return CheckKDEDirsExist(sStart, sEnd);
+    }
+}
+
+bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index)
+{
+    wxMimeTextFile appoutfile, mimeoutfile;
+    wxString sHome = wxGetHomeDir();
+    wxString sTmp = wxT(".kde/share/mimelnk/");
+    wxString sMime = m_aTypes[index];
+    CheckKDEDirsExist(sHome, sTmp + sMime.BeforeFirst(wxT('/')) );
+    sTmp = sHome + wxT('/') + sTmp + sMime + wxT(".kdelnk");
+
+    bool bTemp;
+    bool bMimeExists = mimeoutfile.Open(sTmp);
+    if (!bMimeExists)
+    {
+        bTemp = mimeoutfile.Create(sTmp);
+        // some unknown error eg out of disk space
+        if (!bTemp)
+            return false;
+    }
+
+    sTmp = wxT(".kde/share/applnk/");
+    CheckKDEDirsExist(sHome, sTmp + sMime.AfterFirst(wxT('/')) );
+    sTmp = sHome + wxT('/') + sTmp + sMime.AfterFirst(wxT('/')) + wxT(".kdelnk");
+
+    bool bAppExists;
+    bAppExists = appoutfile.Open(sTmp);
+    if (!bAppExists)
+    {
+        bTemp = appoutfile.Create(sTmp);
+        // some unknown error eg out of disk space
+        if (!bTemp)
+            return false;
+    }
+
+    // fixed data; write if new file
+    if (!bMimeExists)
+    {
+        mimeoutfile.AddLine(wxT("#KDE Config File"));
+        mimeoutfile.AddLine(wxT("[KDE Desktop Entry]"));
+        mimeoutfile.AddLine(wxT("Version=1.0"));
+        mimeoutfile.AddLine(wxT("Type=MimeType"));
+        mimeoutfile.AddLine(wxT("MimeType=") + sMime);
+    }
+
+    if (!bAppExists)
+    {
+        mimeoutfile.AddLine(wxT("#KDE Config File"));
+        mimeoutfile.AddLine(wxT("[KDE Desktop Entry]"));
+        appoutfile.AddLine(wxT("Version=1.0"));
+        appoutfile.AddLine(wxT("Type=Application"));
+        appoutfile.AddLine(wxT("MimeType=") + sMime + wxT(';'));
+    }
+
+    // variable data
+    // ignore locale
+    mimeoutfile.CommentLine(wxT("Comment="));
+    if (!delete_index)
+        mimeoutfile.AddLine(wxT("Comment=") + m_aDescriptions[index]);
+    appoutfile.CommentLine(wxT("Name="));
+    if (!delete_index)
+        appoutfile.AddLine(wxT("Comment=") + m_aDescriptions[index]);
+
+    sTmp = m_aIcons[index];
+    // we can either give the full path, or the shortfilename if its in
+    // one of the directories we search
+    mimeoutfile.CommentLine(wxT("Icon=") );
+    if (!delete_index)
+        mimeoutfile.AddLine(wxT("Icon=") + sTmp );
+    appoutfile.CommentLine(wxT("Icon=") );
+    if (!delete_index)
+        appoutfile.AddLine(wxT("Icon=") + sTmp );
+
+    sTmp = wxT(" ") + m_aExtensions[index];
+
+    wxStringTokenizer tokenizer(sTmp, wxT(" "));
+    sTmp = wxT("Patterns=");
+    mimeoutfile.CommentLine(sTmp);
+    while ( tokenizer.HasMoreTokens() )
+    {
+        // holds an extension; need to change it to *.ext;
+        wxString e = wxT("*.") + tokenizer.GetNextToken() + wxT(";");
+        sTmp = sTmp + e;
+    }
+
+    if (!delete_index)
+        mimeoutfile.AddLine(sTmp);
+
+    wxMimeTypeCommands * entries = m_aEntries[index];
+    // if we don't find open just have an empty string ... FIX this
+    sTmp = entries->GetCommandForVerb(wxT("open"));
+    sTmp.Replace( wxT("%s"), wxT("%f") );
+
+    mimeoutfile.CommentLine(wxT("DefaultApp=") );
+    if (!delete_index)
+        mimeoutfile.AddLine(wxT("DefaultApp=") + sTmp);
+
+    sTmp.Replace( wxT("%f"), wxT("") );
+    appoutfile.CommentLine(wxT("Exec="));
+    if (!delete_index)
+        appoutfile.AddLine(wxT("Exec=") + sTmp);
+
+    if (entries->GetCount() > 1)
+    {
+        //other actions as well as open
+    }
+
+    bTemp = false;
+    if (mimeoutfile.Write())
+        bTemp = true;
+    mimeoutfile.Close();
+    if (appoutfile.Write())
+        bTemp = true;
+    appoutfile.Close();
+
+    return bTemp;
+}
+
+void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,

                                                const wxString& subdir,
                                                const wxString& filename,
                                                const wxArrayString& icondirs)
 {
                                                const wxString& subdir,
                                                const wxString& filename,
                                                const wxArrayString& icondirs)
 {

-    wxFFile file(dirbase + filename);
-    if ( !file.IsOpened() )
+    wxMimeTextFile file;
+    if ( !file.Open(dirbase + filename) )

         return;
 
         return;
 

-    // construct mimetype from the directory name and the basename of the
-    // file (it always has .kdelnk extension)
-    wxString mimetype;
-    mimetype << subdir << _T('/') << filename.BeforeLast(_T('.'));
+    wxLogTrace(TRACE_MIME, wxT("loading KDE file %s"),
+                           (dirbase + filename).c_str());

 
 

-    // these files are small, slurp the entire file at once
-    wxString text;
-    if ( !file.ReadAll(&text) )
-        return;
+    wxMimeTypeCommands * entry = new wxMimeTypeCommands;
+    wxArrayString sExts;
+    wxString mimetype, mime_desc, strIcon;

 
 

-    int pos;
-    const wxChar *pc;
+    int nIndex = file.pIndexOf( wxT("MimeType=") );
+    if (nIndex == wxNOT_FOUND)
+    {
+        // construct mimetype from the directory name and the basename of the
+        // file (it always has .kdelnk extension)
+        mimetype << subdir << wxT('/') << filename.BeforeLast( wxT('.') );
+    }
+    else
+        mimetype = file.GetCmd(nIndex);

 
 

-    // 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...)
+    // first find the description string: it is the value in either "Comment="
+    // line or "Comment[<locale_name>]=" one
+    nIndex = wxNOT_FOUND;

 
 

-    wxString mime_extension, mime_desc;
+    wxString comment;

 
 

-    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 wxUSE_INTL
+    wxLocale *locale = wxGetLocale();
+    if ( locale )

     {
     {

-        pc = text.c_str() + pos + mime_desc.Length();
-        mime_desc = wxEmptyString;
-        while ( *pc && *pc != _T('\n') ) mime_desc += *pc++;
+        // try "Comment[locale name]" first
+        comment << wxT("Comment[") + locale->GetName() + wxT("]=");
+        nIndex = file.pIndexOf(comment);

     }
     }

+#endif
+
+    if ( nIndex == wxNOT_FOUND )
+    {
+        comment = wxT("Comment=");
+        nIndex = file.pIndexOf(comment);
+    }
+
+    if ( nIndex != wxNOT_FOUND )
+        mime_desc = file.GetCmd(nIndex);
+    //else: no description
+
+    // next find the extensions
+    wxString mime_extension;

 
 

-    pos = text.Find(_T("Patterns="));
-    if (pos != wxNOT_FOUND)
+    nIndex = file.pIndexOf(wxT("Patterns="));
+    if ( nIndex != wxNOT_FOUND )

     {
     {

-        wxString exts;
-        pc = text.c_str() + pos + 9;
-        while ( *pc && *pc != _T('\n') ) exts += *pc++;
-        wxStringTokenizer tokenizer(exts, _T(";"));
-        wxString e;
+        wxString exts = file.GetCmd(nIndex);

 
 

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

         {
         {

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

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

-            mime_extension << _T(' ');

         }
         }

-        mime_extension.RemoveLast();

     }
 
     }
 

-    ms_infoTypes.Add(mimetype);
-    ms_infoDescriptions.Add(mime_desc);
-    ms_infoExtensions.Add(mime_extension);
+    sExts.Add(mime_extension);

 
     // 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 )
+    nIndex = file.pIndexOf(wxT("Icon="));
+    if ( nIndex != wxNOT_FOUND )

     {
     {

-        // no icon info
-        return;
+        strIcon = file.GetCmd(nIndex);
+
+        wxLogTrace(TRACE_MIME, wxT("  icon %s"), strIcon.c_str());
+
+        // it could be the real path, but more often a short name
+        if (!wxFileExists(strIcon))
+        {
+            // icon is just the short name
+            if ( !strIcon.empty() )
+            {
+                // we must check if the file exists because it may be stored
+                // in many locations, at least ~/.kde and $KDEDIR
+                size_t nDir, nDirs = icondirs.GetCount();
+                for ( nDir = 0; nDir < nDirs; nDir++ )
+                {
+                    wxFileName fnameIcon( strIcon );
+                    wxFileName fname( icondirs[nDir], fnameIcon.GetName() );
+                    fname.SetExt( wxT("png") );
+                    if (fname.FileExists())
+                    {
+                        strIcon = fname.GetFullPath();
+                        wxLogTrace(TRACE_MIME, wxT("  iconfile %s"), strIcon.c_str());
+                        break;
+                    }
+                }
+            }
+        }

     }
 
     }
 

-    wxString icon;
+    // now look for lines which know about the application
+    // exec= or DefaultApp=
+
+    nIndex = file.pIndexOf(wxT("DefaultApp"));

 
 

-    pc = text.c_str() + pos + 5;  // 5 == strlen("Icon=")
-    while ( *pc && *pc != _T('\n') )
+    if ( nIndex == wxNOT_FOUND )

     {
     {

-        icon += *pc++;
+        // no entry try exec
+        nIndex = file.pIndexOf(wxT("Exec"));

     }
 
     }
 

-    if ( !!icon )
+    if ( nIndex != wxNOT_FOUND )

     {
     {

-        // we must check if the file exists because it may be stored
-        // in many locations, at least ~/.kde and $KDEDIR
-        size_t nDir, nDirs = icondirs.GetCount();
-        for ( nDir = 0; nDir < nDirs; nDir++ )
-            if (wxFileExists(icondirs[nDir] + icon))
-            {
-                icon.Prepend(icondirs[nDir]);
-                break;
-            }
-        if (nDir == nDirs) return; //does not exist
-
-        // do we already have this MIME type?
-        int i = ms_mimetypes.Index(mimetype);
-        if ( i == wxNOT_FOUND )
-        {
-            // add it
-            size_t n = ms_mimetypes.Add(mimetype);
-            ms_icons.Insert(icon, n);
-        }
-        else
-        {
-            // replace the old value
-            ms_icons[(size_t)i] = icon;
-        }
+        // we expect %f; others including  %F and %U and %u are possible
+        wxString sTmp = file.GetCmd(nIndex);
+        if (0 == sTmp.Replace( wxT("%f"), wxT("%s") ))
+            sTmp = sTmp + wxT(" %s");
+        entry->AddOrReplaceVerb(wxString(wxT("open")), sTmp );

     }
     }

+
+    AddToMimeData(mimetype, strIcon, entry, sExts, mime_desc);

 }
 
 }
 

-void wxKDEIconHandler::LoadLinksForMimeType(const wxString& dirbase,
+void wxMimeTypesManagerImpl::LoadKDELinksForMimeType(const wxString& dirbase,

                                             const wxString& subdir,
                                             const wxArrayString& icondirs)
 {
                                             const wxString& subdir,
                                             const wxArrayString& icondirs)
 {


@@ -594,26 +1144,38 @@ void wxKDEIconHandler::LoadLinksForMimeType(const wxString& dirbase,
     if ( !dir.IsOpened() )
         return;
 
     if ( !dir.IsOpened() )
         return;
 

-    dirname += _T('/');
+    wxLogTrace(TRACE_MIME, wxT("--- Loading from KDE directory %s  ---"),
+                           dirname.c_str());
+
+    dirname += wxT('/');

 
     wxString filename;
 
     wxString filename;

-    bool cont = dir.GetFirst(&filename, _T("*.kdelnk"), wxDIR_FILES);
+    bool cont = dir.GetFirst(&filename, wxT("*.kdelnk"), wxDIR_FILES);

     while ( cont )
     {
     while ( cont )
     {

-        LoadLinksForMimeSubtype(dirname, subdir, filename, icondirs);
+        LoadKDELinksForMimeSubtype(dirname, subdir, filename, icondirs);
+
+        cont = dir.GetNext(&filename);
+    }
+
+    // new standard for Gnome and KDE
+    cont = dir.GetFirst(&filename, wxT("*.desktop"), wxDIR_FILES);
+    while ( cont )
+    {
+        LoadKDELinksForMimeSubtype(dirname, subdir, filename, icondirs);

 
         cont = dir.GetNext(&filename);
     }
 }
 
 
         cont = dir.GetNext(&filename);
     }
 }
 

-void wxKDEIconHandler::LoadLinkFilesFromDir(const wxString& dirbase,
+void wxMimeTypesManagerImpl::LoadKDELinkFilesFromDir(const wxString& dirbase,

                                             const wxArrayString& icondirs)
 {
                                             const wxArrayString& icondirs)
 {

-    wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
-                  _T("base directory shouldn't end with a slash") );
+    wxASSERT_MSG( !dirbase.empty() && !wxEndsWithPathSeparator(dirbase),
+                  wxT("base directory shouldn't end with a slash") );

 
     wxString dirname = dirbase;
 
     wxString dirname = dirbase;

-    dirname << _T("/mimelnk");
+    dirname << wxT("/mimelnk");

 
     if ( !wxDir::Exists(dirname) )
         return;
 
     if ( !wxDir::Exists(dirname) )
         return;


@@ -623,267 +1185,970 @@ void wxKDEIconHandler::LoadLinkFilesFromDir(const wxString& dirbase,
         return;
 
     // we will concatenate it with dir name to get the full path below
         return;
 
     // we will concatenate it with dir name to get the full path below

-    dirname += _T('/');
+    dirname += wxT('/');

 
     wxString subdir;
     bool cont = dir.GetFirst(&subdir, wxEmptyString, wxDIR_DIRS);
     while ( cont )
     {
 
     wxString subdir;
     bool cont = dir.GetFirst(&subdir, wxEmptyString, wxDIR_DIRS);
     while ( cont )
     {

-        LoadLinksForMimeType(dirname, subdir, icondirs);
+        LoadKDELinksForMimeType(dirname, subdir, icondirs);

 
         cont = dir.GetNext(&subdir);
     }
 }
 
 
         cont = dir.GetNext(&subdir);
     }
 }
 

-void wxKDEIconHandler::Init()
+void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)

 {
     wxArrayString dirs;
     wxArrayString icondirs;
 
 {
     wxArrayString dirs;
     wxArrayString icondirs;
 

+    // FIXME: This code is heavily broken. There are three bugs in it:
+    //        1) it uses only KDEDIR, which is deprecated, instead of using
+    //           list of paths from KDEDIRS and using KDEDIR only if KDEDIRS
+    //           is not set
+    //        2) it doesn't look into ~/.kde/share/config/kdeglobals where
+    //           user's settings are stored and thus *ignores* user's settings
+    //           instead of respecting them
+    //        3) it "tries to guess KDEDIR" and "tries a few likely theme
+    //           names", both of which is completely arbitrary; instead, the
+    //           code should give up if KDEDIR(S) is not set and/or the icon
+    //           theme cannot be determined, because it means that the user is
+    //           not using KDE (and thus is not interested in KDE icons anyway)
+
+    // the variable $KDEDIR is set when KDE is running
+    wxString kdedir = wxGetenv( wxT("KDEDIR") );
+
+    if (!kdedir.empty())
+    {
+        // $(KDEDIR)/share/config/kdeglobals holds info
+        // the current icons theme
+        wxFileName configFile( kdedir, wxEmptyString );
+        configFile.AppendDir( wxT("share") );
+        configFile.AppendDir( wxT("config") );
+        configFile.SetName( wxT("kdeglobals") );
+
+        wxTextFile config;
+        if (configFile.FileExists() && config.Open(configFile.GetFullPath()))
+        {
+            // $(KDEDIR)/share/config -> $(KDEDIR)/share
+            configFile.RemoveDir( configFile.GetDirCount() - 1 );
+            // $(KDEDIR)/share/ -> $(KDEDIR)/share/icons
+            configFile.AppendDir( wxT("icons") );
+
+            // Check for entry
+            wxString theme(wxT("default.kde"));
+            size_t cnt = config.GetLineCount();
+            for (size_t i = 0; i < cnt; i++)
+            {
+                if (config[i].StartsWith(wxT("Theme="), &theme/*rest*/))
+                    break;
+            }
+
+            configFile.AppendDir(theme);
+        }
+        else
+        {
+            // $(KDEDIR)/share/config -> $(KDEDIR)/share
+            configFile.RemoveDir( configFile.GetDirCount() - 1 );
+
+            // $(KDEDIR)/share/ -> $(KDEDIR)/share/icons
+            configFile.AppendDir( wxT("icons") );
+
+            // $(KDEDIR)/share/icons -> $(KDEDIR)/share/icons/default.kde
+            configFile.AppendDir( wxT("default.kde") );
+        }
+
+        configFile.SetName( wxEmptyString );
+        configFile.AppendDir( wxT("32x32") );
+        configFile.AppendDir( wxT("mimetypes") );
+
+        // Just try a few likely icons theme names
+
+        int pos = configFile.GetDirCount() - 3;
+
+        if (!wxDir::Exists(configFile.GetPath()))
+        {
+            configFile.RemoveDir( pos );
+            configFile.InsertDir( pos, wxT("default.kde") );
+        }
+
+        if (!wxDir::Exists(configFile.GetPath()))
+        {
+            configFile.RemoveDir( pos );
+            configFile.InsertDir( pos, wxT("default") );
+        }
+
+        if (!wxDir::Exists(configFile.GetPath()))
+        {
+            configFile.RemoveDir( pos );
+            configFile.InsertDir( pos, wxT("crystalsvg") );
+        }
+
+        if (!wxDir::Exists(configFile.GetPath()))
+        {
+            configFile.RemoveDir( pos );
+            configFile.InsertDir( pos, wxT("crystal") );
+        }
+
+        if (wxDir::Exists(configFile.GetPath()))
+            icondirs.Add( configFile.GetFullPath() );
+    }
+

     // settings in ~/.kde have maximal priority
     // settings in ~/.kde have maximal priority

-    dirs.Add(wxGetHomeDir() + _T("/.kde/share"));
-    icondirs.Add(wxGetHomeDir() + _T("/.kde/share/icons/"));
+    dirs.Add(wxGetHomeDir() + wxT("/.kde/share"));
+    icondirs.Add(wxGetHomeDir() + wxT("/.kde/share/icons/"));

 
 

-    // the variable KDEDIR is set when KDE is running
-    const char *kdedir = getenv("KDEDIR");
-    if ( kdedir )
+    if (kdedir)

     {
     {

-        dirs.Add(wxString(kdedir) + _T("/share"));
-        icondirs.Add(wxString(kdedir) + _T("/share/icons/"));
+        dirs.Add( wxString(kdedir) + wxT("/share") );
+        icondirs.Add( wxString(kdedir) + wxT("/share/icons/") );

     }
     else
     {
         // try to guess KDEDIR
     }
     else
     {
         // try to guess KDEDIR

-        dirs.Add(_T("/usr/share"));
-        dirs.Add(_T("/opt/kde/share"));
-        icondirs.Add(_T("/usr/share/icons/"));
-        icondirs.Add(_T("/opt/kde/share/icons/"));
+        dirs.Add(wxT("/usr/share"));
+        dirs.Add(wxT("/opt/kde/share"));
+        icondirs.Add(wxT("/usr/share/icons/"));
+        icondirs.Add(wxT("/usr/X11R6/share/icons/")); // Debian/Corel linux
+        icondirs.Add(wxT("/opt/kde/share/icons/"));

     }
 
     }
 

+    if (!sExtraDir.empty())
+        dirs.Add(sExtraDir);
+    icondirs.Add(sExtraDir + wxT("/icons"));
+

     size_t nDirs = dirs.GetCount();
     for ( size_t nDir = 0; nDir < nDirs; nDir++ )
     {
     size_t nDirs = dirs.GetCount();
     for ( size_t nDir = 0; nDir < nDirs; nDir++ )
     {

-        LoadLinkFilesFromDir(dirs[nDir], icondirs);
+        LoadKDELinkFilesFromDir(dirs[nDir], icondirs);

     }
     }

+}
+
+// ----------------------------------------------------------------------------
+// wxFileTypeImpl (Unix)
+// ----------------------------------------------------------------------------

 
 

-    m_inited = TRUE;
+wxString wxFileTypeImpl::GetExpandedCommand(const wxString & verb, const wxFileType::MessageParameters& params) const
+{
+    wxString sTmp;
+    size_t i = 0;
+    while ( (i < m_index.GetCount() ) && sTmp.empty() )
+    {
+        sTmp = m_manager->GetCommand( verb, m_index[i] );
+        i++;
+    }
+
+    return wxFileType::ExpandCommand(sTmp, params);

 }
 
 }
 

-bool wxKDEIconHandler::GetIcon(const wxString& mimetype, wxIcon *icon)
+bool wxFileTypeImpl::GetIcon(wxIconLocation *iconLoc) const

 {
 {

-    if ( !m_inited )
+    wxString sTmp;
+    size_t i = 0;
+    while ( (i < m_index.GetCount() ) && sTmp.empty() )

     {
     {

-        Init();
+        sTmp = m_manager->m_aIcons[m_index[i]];
+        i++;

     }
 
     }
 

-    int index = ms_mimetypes.Index(mimetype);
-    if ( index == wxNOT_FOUND )
-        return FALSE;
+    if ( sTmp.empty() )
+        return false;

 
 

-    wxString iconname = ms_icons[(size_t)index];
+    if ( iconLoc )
+    {
+        iconLoc->SetFileName(sTmp);
+    }

 
 

-#if wxUSE_GUI
-    *icon = wxIcon(iconname);
-#else
-    // helpful for testing in console mode
-    wxLogDebug(_T("Found KDE icon for '%s': '%s'\n"),
-               mimetype.c_str(), iconname.c_str());
-#endif
+    return true;
+}

 
 

-    return TRUE;
+bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
+{
+    mimeTypes.Clear();
+    for (size_t i = 0; i < m_index.GetCount(); i++)
+        mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);
+
+    return true;

 }
 
 }
 

+size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
+                                  wxArrayString *commands,
+                                  const wxFileType::MessageParameters& params) const
+{
+    wxString vrb, cmd, sTmp;
+    size_t count = 0;
+    wxMimeTypeCommands * sPairs;
+
+    // verbs and commands have been cleared already in mimecmn.cpp...
+    // if we find no entries in the exact match, try the inexact match
+    for (size_t n = 0; ((count == 0) && (n < m_index.GetCount())); n++)
+    {
+        // list of verb = command pairs for this mimetype
+        sPairs = m_manager->m_aEntries [m_index[n]];
+        size_t i;
+        for ( i = 0; i < sPairs->GetCount(); i++ )
+        {
+            vrb = sPairs->GetVerb(i);
+            // some gnome entries have "." inside
+            vrb = vrb.AfterLast(wxT('.'));
+            cmd = sPairs->GetCmd(i);
+            if (! cmd.empty() )
+            {
+                 cmd = wxFileType::ExpandCommand(cmd, params);
+                 count++;
+                 if ( vrb.IsSameAs(wxT("open")))
+                 {
+                     verbs->Insert(vrb, 0u);
+                     commands ->Insert(cmd, 0u);
+                 }
+                 else
+                 {
+                     verbs->Add(vrb);
+                     commands->Add(cmd);
+                 }
+             }
+        }
+    }
+
+    return count;
+}
+
+bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
+{
+    wxString strExtensions = m_manager->GetExtension(m_index[0]);
+    extensions.Empty();
+
+    // one extension in the space or comma-delimited list
+    wxString strExt;
+    for ( const wxChar *p = strExtensions; /* nothing */; p++ )
+    {
+        if ( *p == wxT(' ') || *p == wxT(',') || *p == wxT('\0') )
+        {
+            if ( !strExt.empty() )
+            {
+                extensions.Add(strExt);
+                strExt.Empty();
+            }
+            //else: repeated spaces
+            // (shouldn't happen, but it's not that important if it does happen)
+
+            if ( *p == wxT('\0') )
+                break;
+        }
+        else if ( *p == wxT('.') )
+        {
+            // remove the dot from extension (but only if it's the first char)
+            if ( !strExt.empty() )
+            {
+                strExt += wxT('.');
+            }
+            //else: no, don't append it
+        }
+        else
+        {
+            strExt += *p;
+        }
+    }
+
+    return true;
+}

 
 

-void wxKDEIconHandler::GetMimeInfoRecords(wxMimeTypesManagerImpl *manager)
+// set an arbitrary command:
+// could adjust the code to ask confirmation if it already exists and
+// overwriteprompt is true, but this is currently ignored as *Associate* has
+// no overwrite prompt
+bool
+wxFileTypeImpl::SetCommand(const wxString& cmd,
+                           const wxString& verb,
+                           bool WXUNUSED(overwriteprompt))

 {
 {

-    if ( !m_inited ) Init();
+    wxArrayString strExtensions;
+    wxString strDesc, strIcon;
+
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands();
+    entry->Add(verb + wxT("=")  + cmd + wxT(" %s "));

 
 

-    size_t cnt = ms_infoTypes.GetCount();
-    for (unsigned i = 0; i < cnt; i++)
-        manager -> AddMimeTypeInfo(ms_infoTypes[i], ms_infoExtensions[i], ms_infoDescriptions[i]);
+    wxArrayString strTypes;
+    GetMimeTypes(strTypes);
+    if (strTypes.GetCount() < 1)
+        return false;
+
+    size_t i;
+    bool ok = true;
+    for (i = 0; i < strTypes.GetCount(); i++)
+    {
+        if (!m_manager->DoAssociation(strTypes[i], strIcon, entry, strExtensions, strDesc))
+            ok = false;
+    }
+
+    return ok;

 }
 
 }
 

+// ignore index on the grouds that we only have one icon in a Unix file
+bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int WXUNUSED(index))
+{
+    if (strIcon.empty())
+        return false;
+
+    wxArrayString strExtensions;
+    wxString strDesc;
+
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands();
+
+    wxArrayString strTypes;
+    GetMimeTypes(strTypes);
+    if (strTypes.GetCount() < 1)
+        return false;
+
+    size_t i;
+    bool ok = true;
+    for (i = 0; i < strTypes.GetCount(); i++)
+    {
+        if (!m_manager->DoAssociation(strTypes[i], strIcon, entry, strExtensions, strDesc))
+            ok = false;
+    }
+
+    return ok;
+}

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

-// wxFileTypeImpl (Unix)
+// wxMimeTypesManagerImpl (Unix)

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

-MailCapEntry *
-wxFileTypeImpl::GetEntry(const wxFileType::MessageParameters& params) const
+wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()

 {
 {

-    wxString command;
-    MailCapEntry *entry = m_manager->m_aEntries[m_index];
-    while ( entry != NULL ) {
-        // notice that an empty command would always succeed (it's ok)
-        command = wxFileType::ExpandCommand(entry->GetTestCmd(), params);
-
-        if ( command.IsEmpty() || (wxSystem(command) == 0) ) {
-            // ok, passed
-            wxLogTrace(wxT("Test '%s' for mime type '%s' succeeded."),
-                       command.c_str(), params.GetMimeType().c_str());
-            break;
-        }
-        else {
-            wxLogTrace(wxT("Test '%s' for mime type '%s' failed."),
-                       command.c_str(), params.GetMimeType().c_str());
-        }
+    m_initialized = false;
+    m_mailcapStylesInited = 0;
+}
+
+void wxMimeTypesManagerImpl::InitIfNeeded()
+{
+    if ( !m_initialized )
+    {
+        // set the flag first to prevent recursion
+        m_initialized = true;

 
 

-        entry = entry->GetNext();
+#if 1
+    Initialize();
+#else
+    wxString wm = wxGetenv( wxT("WINDOWMANAGER") );
+
+    if (wm.Find( wxT("kde") ) != wxNOT_FOUND)
+        Initialize( wxMAILCAP_KDE | wxMAILCAP_STANDARD );
+    else if (wm.Find( wxT("gnome") ) != wxNOT_FOUND)
+        Initialize( wxMAILCAP_GNOME | wxMAILCAP_STANDARD );
+    else
+        Initialize();
+#endif

     }
     }

+}
+
+// read system and user mailcaps and other files
+void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
+                                        const wxString& sExtraDir)
+{
+    // read mimecap amd mime.types
+    if ( (mailcapStyles & wxMAILCAP_NETSCAPE) ||
+         (mailcapStyles & wxMAILCAP_STANDARD) )
+        GetMimeInfo(sExtraDir);

 
 

-    return entry;
+    // read GNOME tables
+    if (mailcapStyles & wxMAILCAP_GNOME)
+        GetGnomeMimeInfo(sExtraDir);
+
+    // read KDE tables
+    if (mailcapStyles & wxMAILCAP_KDE)
+        GetKDEMimeInfo(sExtraDir);
+
+    m_mailcapStylesInited |= mailcapStyles;

 }
 
 }
 

-bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
+// clear data so you can read another group of WM files
+void wxMimeTypesManagerImpl::ClearData()

 {
 {

-    wxString mimetype;
-    (void)GetMimeType(&mimetype);
+    m_aTypes.Clear();
+    m_aIcons.Clear();
+    m_aExtensions.Clear();
+    m_aDescriptions.Clear();

 
 

-    ArrayIconHandlers& handlers = m_manager->GetIconHandlers();
-    size_t count = handlers.GetCount();
-    for ( size_t n = 0; n < count; n++ )
+    WX_CLEAR_ARRAY(m_aEntries);
+    m_aEntries.Empty();
+
+    m_mailcapStylesInited = 0;
+}
+
+wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl()
+{
+    ClearData();
+}
+
+void wxMimeTypesManagerImpl::GetMimeInfo(const wxString& sExtraDir)
+{
+    // read this for netscape or Metamail formats
+
+    // directories where we look for mailcap and mime.types by default
+    // used by netscape and pine and other mailers, using 2 different formats!
+
+    // (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?)
+
+    wxString strHome = wxGetenv(wxT("HOME"));
+
+    wxArrayString dirs;
+    dirs.Add( strHome + wxT("/.") );
+    dirs.Add( wxT("/etc/") );
+    dirs.Add( wxT("/usr/etc/") );
+    dirs.Add( wxT("/usr/local/etc/") );
+    dirs.Add( wxT("/etc/mail/") );
+    dirs.Add( wxT("/usr/public/lib/") );
+    if (!sExtraDir.empty())
+        dirs.Add( sExtraDir + wxT("/") );
+
+    size_t nDirs = dirs.GetCount();
+    for ( size_t nDir = 0; nDir < nDirs; nDir++ )
+    {
+        wxString file = dirs[nDir] + wxT("mailcap");
+        if ( wxFile::Exists(file) )
+        {
+            ReadMailcap(file);
+        }
+
+        file = dirs[nDir] + wxT("mime.types");
+        if ( wxFile::Exists(file) )
+        {
+            ReadMimeTypes(file);
+        }
+    }
+}
+
+bool wxMimeTypesManagerImpl::WriteToMimeTypes(int index, bool delete_index)
+{
+    // check we have the right manager
+    if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD) )
+        return false;
+
+    bool bTemp;
+    wxString strHome = wxGetenv(wxT("HOME"));
+
+    // and now the users mailcap
+    wxString strUserMailcap = strHome + wxT("/.mime.types");
+
+    wxMimeTextFile file;
+    if ( wxFile::Exists(strUserMailcap) )

     {
     {

-        if ( handlers[n]->GetIcon(mimetype, icon) )
-            return TRUE;
+        bTemp = file.Open(strUserMailcap);

     }
     }

+    else
+    {
+        if (delete_index)
+            return false;

 
 

-    return FALSE;
+        bTemp = file.Create(strUserMailcap);
+    }
+
+    if (bTemp)
+    {
+        int nIndex;
+        // test for netscape's header and return false if its found
+        nIndex = file.pIndexOf(wxT("#--Netscape"));
+        if (nIndex != wxNOT_FOUND)
+        {
+            wxASSERT_MSG(false,wxT("Error in .mime.types \nTrying to mix Netscape and Metamail formats\nFile not modiifed"));
+            return false;
+        }
+
+        // write it in alternative format
+        // get rid of unwanted entries
+        wxString strType = m_aTypes[index];
+        nIndex = file.pIndexOf(strType);
+
+        // get rid of all the unwanted entries...
+        if (nIndex != wxNOT_FOUND)
+            file.CommentLine(nIndex);
+
+        if (!delete_index)
+        {
+            // add the new entries in
+            wxString sTmp = strType.Append( wxT(' '), 40 - strType.Len() );
+            sTmp = sTmp + m_aExtensions[index];
+            file.AddLine(sTmp);
+        }
+
+        bTemp = file.Write();
+        file.Close();
+    }
+
+    return bTemp;

 }
 
 }
 

-bool
-wxFileTypeImpl::GetExpandedCommand(wxString *expandedCmd,
-                                   const wxFileType::MessageParameters& params,
-                                   bool open) const
+bool wxMimeTypesManagerImpl::WriteToNSMimeTypes(int index, bool delete_index)

 {
 {

-    MailCapEntry *entry = GetEntry(params);
-    if ( entry == NULL ) {
-        // all tests failed...
-        return FALSE;
+    //check we have the right managers
+    if (! ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) )
+        return false;
+
+    bool bTemp;
+    wxString strHome = wxGetenv(wxT("HOME"));
+
+    // and now the users mailcap
+    wxString strUserMailcap = strHome + wxT("/.mime.types");
+
+    wxMimeTextFile file;
+    if ( wxFile::Exists(strUserMailcap) )
+    {
+        bTemp = file.Open(strUserMailcap);

     }
     }

+    else
+    {
+        if (delete_index)
+            return false;

 
 

-    wxString cmd = open ? entry->GetOpenCmd() : entry->GetPrintCmd();
-    if ( cmd.IsEmpty() ) {
-        // may happen, especially for "print"
-        return FALSE;
+        bTemp = file.Create(strUserMailcap);

     }
 
     }
 

-    *expandedCmd = wxFileType::ExpandCommand(cmd, params);
-    return TRUE;
+    if (bTemp)
+    {
+        // write it in the format that Netscape uses
+        int nIndex;
+        // test for netscape's header and insert if required...
+        // this is a comment so use true
+        nIndex = file.pIndexOf(wxT("#--Netscape"), true);
+        if (nIndex == wxNOT_FOUND)
+        {
+            // either empty file or metamail format
+            // at present we can't cope with mixed formats, so exit to preseve
+            // metamail entreies
+            if (file.GetLineCount() > 0)
+            {
+                wxASSERT_MSG(false, wxT(".mime.types File not in Netscape format\nNo entries written to\n.mime.types or to .mailcap"));
+                return false;
+            }
+
+            file.InsertLine(wxT( "#--Netscape Communications Corporation MIME Information" ), 0);
+            nIndex = 0;
+        }
+
+        wxString strType = wxT("type=") + m_aTypes[index];
+        nIndex = file.pIndexOf(strType);
+
+        // get rid of all the unwanted entries...
+        if (nIndex != wxNOT_FOUND)
+        {
+            wxString sOld = file[nIndex];
+            while ( (sOld.Contains(wxT("\\"))) && (nIndex < (int) file.GetLineCount()) )
+            {
+                file.CommentLine(nIndex);
+                sOld = file[nIndex];
+
+                wxLogTrace(TRACE_MIME, wxT("--- Deleting from mime.types line '%d %s' ---"), nIndex, sOld.c_str());
+
+                nIndex++;
+            }
+
+            if (nIndex < (int) file.GetLineCount())
+                file.CommentLine(nIndex);
+        }
+        else
+            nIndex = (int) file.GetLineCount();
+
+        wxString sTmp = strType + wxT(" \\");
+        if (!delete_index)
+            file.InsertLine(sTmp, nIndex);
+
+        if ( ! m_aDescriptions.Item(index).empty() )
+        {
+            sTmp = wxT("desc=\"") + m_aDescriptions[index]+ wxT("\" \\"); //.trim ??
+            if (!delete_index)
+            {
+                nIndex++;
+                file.InsertLine(sTmp, nIndex);
+            }
+        }
+
+        wxString sExts = m_aExtensions.Item(index);
+        sTmp = wxT("exts=\"") + sExts.Trim(false).Trim() + wxT("\"");
+        if (!delete_index)
+        {
+            nIndex++;
+            file.InsertLine(sTmp, nIndex);
+        }
+
+        bTemp = file.Write();
+        file.Close();
+    }
+
+    return bTemp;

 }
 
 }
 

-bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
+bool wxMimeTypesManagerImpl::WriteToMailCap(int index, bool delete_index)

 {
 {

-    wxString strExtensions = m_manager->GetExtension(m_index);
-    extensions.Empty();
+    //check we have the right managers
+    if ( !( ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) ||
+            ( m_mailcapStylesInited & wxMAILCAP_STANDARD) ) )
+        return false;

 
 

-    // one extension in the space or comma delimitid list
-    wxString strExt;
-    for ( const wxChar *p = strExtensions; ; p++ ) {
-        if ( *p == wxT(' ') || *p == wxT(',') || *p == wxT('\0') ) {
-            if ( !strExt.IsEmpty() ) {
-                extensions.Add(strExt);
-                strExt.Empty();
+    bool bTemp = false;
+    wxString strHome = wxGetenv(wxT("HOME"));
+
+    // and now the users mailcap
+    wxString strUserMailcap = strHome + wxT("/.mailcap");
+
+    wxMimeTextFile file;
+    if ( wxFile::Exists(strUserMailcap) )
+    {
+        bTemp = file.Open(strUserMailcap);
+    }
+    else
+    {
+        if (delete_index)
+            return false;
+
+        bTemp = file.Create(strUserMailcap);
+    }
+
+    if (bTemp)
+    {
+        // now got a file we can write to ....
+        wxMimeTypeCommands * entries = m_aEntries[index];
+        size_t iOpen;
+        wxString sCmd = entries->GetCommandForVerb(wxT("open"), &iOpen);
+        wxString sTmp;
+
+        sTmp = m_aTypes[index];
+        wxString sOld;
+        int nIndex = file.pIndexOf(sTmp);
+
+        // get rid of all the unwanted entries...
+        if (nIndex == wxNOT_FOUND)
+        {
+            nIndex = (int) file.GetLineCount();
+        }
+        else
+        {
+            sOld = file[nIndex];
+            wxLogTrace(TRACE_MIME, wxT("--- Deleting from mailcap line '%d' ---"), nIndex);
+
+            while ( (sOld.Contains(wxT("\\"))) && (nIndex < (int) file.GetLineCount()) )
+            {
+                file.CommentLine(nIndex);
+                if (nIndex < (int) file.GetLineCount())
+                    sOld = sOld + file[nIndex];

             }
             }

-            //else: repeated spaces (shouldn't happen, but it's not that
-            //      important if it does happen)

 
 

-            if ( *p == wxT('\0') )
-                break;
+            if (nIndex < (int)
+                file.GetLineCount()) file.CommentLine(nIndex);

         }
         }

-        else if ( *p == wxT('.') ) {
-            // remove the dot from extension (but only if it's the first char)
-            if ( !strExt.IsEmpty() ) {
-                strExt += wxT('.');
+
+        sTmp = sTmp + wxT(";") + sCmd; //includes wxT(" %s ");
+
+        // write it in the format that Netscape uses (default)
+        if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD ) )
+        {
+            if (! delete_index)
+                file.InsertLine(sTmp, nIndex);
+            nIndex++;
+        }
+        else
+        {
+            // write extended format
+
+            // TODO - FIX this code:
+            // ii) lost entries
+            // sOld holds all the entries, but our data store only has some
+            // eg test= is not stored
+
+            // so far we have written the mimetype and command out
+            wxStringTokenizer sT(sOld, wxT(";\\"));
+            if (sT.CountTokens() > 2)
+            {
+                // first one mimetype; second one command, rest unknown...
+                wxString s;
+                s = sT.GetNextToken();
+                s = sT.GetNextToken();
+
+                // first unknown
+                s = sT.GetNextToken();
+                while ( ! s.empty() )
+                {
+                    bool bKnownToken = false;
+                    if (s.Contains(wxT("description=")))
+                        bKnownToken = true;
+                    if (s.Contains(wxT("x11-bitmap=")))
+                        bKnownToken = true;
+
+                    size_t i;
+                    for (i=0; i < entries->GetCount(); i++)
+                    {
+                        if (s.Contains(entries->GetVerb(i)))
+                            bKnownToken = true;
+                    }
+
+                    if (!bKnownToken)
+                    {
+                        sTmp = sTmp + wxT("; \\");
+                        file.InsertLine(sTmp, nIndex);
+                        sTmp = s;
+                    }
+
+                    s = sT.GetNextToken();
+                }

             }
             }

-            //else: no, don't append it
+
+            if (! m_aDescriptions[index].empty() )
+            {
+                sTmp = sTmp + wxT("; \\");
+                file.InsertLine(sTmp, nIndex);
+                nIndex++;
+                sTmp = wxT("       description=\"") + m_aDescriptions[index] + wxT("\"");
+            }
+
+            if (! m_aIcons[index].empty() )
+            {
+                sTmp = sTmp + wxT("; \\");
+                file.InsertLine(sTmp, nIndex);
+                nIndex++;
+                sTmp = wxT("       x11-bitmap=\"") + m_aIcons[index] + wxT("\"");
+            }
+
+            if ( entries->GetCount() > 1 )
+            {
+                size_t i;
+                for (i=0; i < entries->GetCount(); i++)
+                    if ( i != iOpen )
+                    {
+                        sTmp = sTmp + wxT("; \\");
+                        file.InsertLine(sTmp, nIndex);
+                        nIndex++;
+                        sTmp = wxT("       ") + entries->GetVerbCmd(i);
+                    }
+            }
+
+            file.InsertLine(sTmp, nIndex);
+            nIndex++;

         }
         }

-        else {
-            strExt += *p;
+
+        bTemp = file.Write();
+        file.Close();
+    }
+
+    return bTemp;
+}
+
+wxFileType * wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
+{
+    InitIfNeeded();
+
+    wxString strType = ftInfo.GetMimeType();
+    wxString strDesc = ftInfo.GetDescription();
+    wxString strIcon = ftInfo.GetIconFile();
+
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands();
+
+    if ( ! ftInfo.GetOpenCommand().empty())
+        entry->Add(wxT("open=")  + ftInfo.GetOpenCommand() + wxT(" %s "));
+    if ( ! ftInfo.GetPrintCommand().empty())
+        entry->Add(wxT("print=") + ftInfo.GetPrintCommand() + wxT(" %s "));
+
+    // now find where these extensions are in the data store and remove them
+    wxArrayString sA_Exts = ftInfo.GetExtensions();
+    wxString sExt, sExtStore;
+    size_t i, nIndex;
+    for (i=0; i < sA_Exts.GetCount(); i++)
+    {
+        sExt = sA_Exts.Item(i);
+
+        // clean up to just a space before and after
+        sExt.Trim().Trim(false);
+        sExt = wxT(' ') + sExt + wxT(' ');
+        for (nIndex = 0; nIndex < m_aExtensions.GetCount(); nIndex++)
+        {
+            sExtStore = m_aExtensions.Item(nIndex);
+            if (sExtStore.Replace(sExt, wxT(" ") ) > 0)
+                m_aExtensions.Item(nIndex) = sExtStore;

         }
     }
 
         }
     }
 

-    return TRUE;
+    if ( !DoAssociation(strType, strIcon, entry, sA_Exts, strDesc) )
+        return NULL;
+
+    return GetFileTypeFromMimeType(strType);

 }
 
 }
 

-// ----------------------------------------------------------------------------
-// wxMimeTypesManagerImpl (Unix)
-// ----------------------------------------------------------------------------
+bool wxMimeTypesManagerImpl::DoAssociation(const wxString& strType,
+                                           const wxString& strIcon,
+                                           wxMimeTypeCommands *entry,
+                                           const wxArrayString& strExtensions,
+                                           const wxString& strDesc)
+{
+    int nIndex = AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, true);

 
 

-/* static */
-ArrayIconHandlers& wxMimeTypesManagerImpl::GetIconHandlers()
+    if ( nIndex == wxNOT_FOUND )
+        return false;
+
+    return WriteMimeInfo(nIndex, false);
+}
+
+bool wxMimeTypesManagerImpl::WriteMimeInfo(int nIndex, bool delete_mime )

 {
 {

-    if ( ms_iconHandlers.GetCount() == 0 )
+    bool ok = true;
+
+    if ( m_mailcapStylesInited & wxMAILCAP_STANDARD )
+    {
+        // write in metamail  format;
+        if (WriteToMimeTypes(nIndex, delete_mime) )
+            if ( WriteToMailCap(nIndex, delete_mime) )
+                ok = false;
+    }
+
+    if ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE )
+    {
+        // write in netsacpe format;
+        if (WriteToNSMimeTypes(nIndex, delete_mime) )
+            if ( WriteToMailCap(nIndex, delete_mime) )
+                ok = false;
+    }
+
+    if (m_mailcapStylesInited & wxMAILCAP_GNOME)
+    {
+        // write in Gnome format;
+        if (WriteGnomeMimeFile(nIndex, delete_mime) )
+            if (WriteGnomeKeyFile(nIndex, delete_mime) )
+                ok = false;
+    }
+
+    if (m_mailcapStylesInited & wxMAILCAP_KDE)

     {
     {

-        ms_iconHandlers.Add(&gs_iconHandlerGNOME);
-        ms_iconHandlers.Add(&gs_iconHandlerKDE);
+        // write in KDE format;
+        if (WriteKDEMimeFile(nIndex, delete_mime) )
+            ok = false;

     }
 
     }
 

-    return ms_iconHandlers;
+    return ok;

 }
 
 }
 

-// read system and user mailcaps (TODO implement mime.types support)
-wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
+int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType,
+                                          const wxString& strIcon,
+                                          wxMimeTypeCommands *entry,
+                                          const wxArrayString& strExtensions,
+                                          const wxString& strDesc,
+                                          bool replaceExisting)

 {
 {

-    // directories where we look for mailcap and mime.types by default
-    // (taken from metamail(1) sources)
-    static const wxChar *aStandardLocations[] =
+    InitIfNeeded();
+
+    // ensure mimetype is always lower case
+    wxString mimeType = strType.Lower();
+
+    // is this a known MIME type?
+    int nIndex = m_aTypes.Index(mimeType);
+    if ( nIndex == wxNOT_FOUND )

     {
     {

-        wxT("/etc"),
-        wxT("/usr/etc"),
-        wxT("/usr/local/etc"),
-        wxT("/etc/mail"),
-        wxT("/usr/public/lib")
-    };
+        // new file type
+        m_aTypes.Add(mimeType);
+        m_aIcons.Add(strIcon);
+        m_aEntries.Add(entry ? entry : new wxMimeTypeCommands);

 
 

-    // first read the system wide file(s)
-    size_t n;
-    for ( n = 0; n < WXSIZEOF(aStandardLocations); n++ ) {
-        wxString dir = aStandardLocations[n];
+        // change nIndex so we can use it below to add the extensions
+        m_aExtensions.Add(wxEmptyString);
+        nIndex = m_aExtensions.size() - 1;

 
 

-        wxString file = dir + wxT("/mailcap");
-        if ( wxFile::Exists(file) ) {
-            ReadMailcap(file);
+        m_aDescriptions.Add(strDesc);
+    }
+    else // yes, we already have it
+    {
+        if ( replaceExisting )
+        {
+            // if new description change it
+            if ( !strDesc.empty())
+                m_aDescriptions[nIndex] = strDesc;
+
+            // if new icon change it
+            if ( !strIcon.empty())
+                m_aIcons[nIndex] = strIcon;
+
+            if ( entry )
+            {
+                delete m_aEntries[nIndex];
+                m_aEntries[nIndex] = entry;
+            }

         }
         }

+        else // add data we don't already have ...
+        {
+            // if new description add only if none
+            if ( m_aDescriptions[nIndex].empty() )
+                m_aDescriptions[nIndex] = strDesc;

 
 

-        file = dir + wxT("/mime.types");
-        if ( wxFile::Exists(file) ) {
-            ReadMimeTypes(file);
+            // if new icon and no existing icon
+            if ( m_aIcons[nIndex].empty() )
+                m_aIcons[nIndex] = strIcon;
+
+            // add any new entries...
+            if ( entry )
+            {
+                wxMimeTypeCommands *entryOld = m_aEntries[nIndex];
+
+                size_t count = entry->GetCount();
+                for ( size_t i = 0; i < count; i++ )
+                {
+                    const wxString& verb = entry->GetVerb(i);
+                    if ( !entryOld->HasVerb(verb) )
+                    {
+                        entryOld->AddOrReplaceVerb(verb, entry->GetCmd(i));
+                    }
+                }
+
+                // as we don't store it anywhere, it won't be deleted later as
+                // usual -- do it immediately instead
+                delete entry;
+            }

         }
     }
 
         }
     }
 

-    wxString strHome = wxGetenv(wxT("HOME"));
+    // always add the extensions to this mimetype
+    wxString& exts = m_aExtensions[nIndex];

 
 

-    // and now the users mailcap
-    wxString strUserMailcap = strHome + wxT("/.mailcap");
-    if ( wxFile::Exists(strUserMailcap) ) {
-        ReadMailcap(strUserMailcap);
-    }
+    // add all extensions we don't have yet
+    size_t count = strExtensions.GetCount();
+    for ( size_t i = 0; i < count; i++ )
+    {
+        wxString ext = strExtensions[i] + wxT(' ');

 
 

-    // read the users mime.types
-    wxString strUserMimeTypes = strHome + wxT("/.mime.types");
-    if ( wxFile::Exists(strUserMimeTypes) ) {
-        ReadMimeTypes(strUserMimeTypes);
+        if ( exts.Find(ext) == wxNOT_FOUND )
+        {
+            exts += ext;
+        }

     }
 
     }
 

-    // read KDE/GNOME tables
-    ArrayIconHandlers& handlers = GetIconHandlers();
-    size_t count = handlers.GetCount();
-    for ( n = 0; n < count; n++ )
-        handlers[n]->GetMimeInfoRecords(this);
+    // check data integrity
+    wxASSERT( m_aTypes.Count() == m_aEntries.Count() &&
+              m_aTypes.Count() == m_aExtensions.Count() &&
+              m_aTypes.Count() == m_aIcons.Count() &&
+              m_aTypes.Count() == m_aDescriptions.Count() );
+
+    return nIndex;

 }
 
 }
 

-wxFileType *
-wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
+wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)

 {
 {

+    if (ext.empty() )
+        return NULL;
+
+    InitIfNeeded();
+

     size_t count = m_aExtensions.GetCount();
     size_t count = m_aExtensions.GetCount();

-    for ( size_t n = 0; n < count; n++ ) {
-        wxString extensions = m_aExtensions[n];
-        while ( !extensions.IsEmpty() ) {
-            wxString field = extensions.BeforeFirst(wxT(' '));
-            extensions = extensions.AfterFirst(wxT(' '));
+    for ( size_t n = 0; n < count; n++ )
+    {
+        wxStringTokenizer tk(m_aExtensions[n], wxT(' '));

 
 

+        while ( tk.HasMoreTokens() )
+        {

             // consider extensions as not being case-sensitive
             // consider extensions as not being case-sensitive

-            if ( field.IsSameAs(ext, FALSE /* no case */) ) {
+            if ( tk.GetNextToken().IsSameAs(ext, false /* no case */) )
+            {

                 // found
                 wxFileType *fileType = new wxFileType;
                 fileType->m_impl->Init(this, n);
                 // found
                 wxFileType *fileType = new wxFileType;
                 fileType->m_impl->Init(this, n);


@@ -893,56 +2158,86 @@ wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
         }
     }
 
         }
     }
 

-    // not found

     return NULL;
 }
 
     return NULL;
 }
 

-wxFileType *
-wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
+wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)

 {
 {

+    InitIfNeeded();
+
+    wxFileType * fileType = NULL;

     // mime types are not case-sensitive
     wxString mimetype(mimeType);
     mimetype.MakeLower();
 
     // first look for an exact match
     int index = m_aTypes.Index(mimetype);
     // mime types are not case-sensitive
     wxString mimetype(mimeType);
     mimetype.MakeLower();
 
     // first look for an exact match
     int index = m_aTypes.Index(mimetype);

-    if ( index == wxNOT_FOUND ) {
-        // 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(wxT('/'));
-
-        size_t nCount = m_aTypes.Count();
-        for ( size_t n = 0; n < nCount; n++ ) {
-            if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) &&
-                 m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") ) {
-                    index = n;
-                    break;
-            }
+    if ( index != wxNOT_FOUND )
+    {
+        fileType = new wxFileType;
+        fileType->m_impl->Init(this, index);
+    }
+
+    // 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.
+
+    index = wxNOT_FOUND;
+    wxString strCategory = mimetype.BeforeFirst(wxT('/'));
+
+    size_t nCount = m_aTypes.Count();
+    for ( size_t n = 0; n < nCount; n++ )
+    {
+        if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) &&
+                m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") )
+        {
+            index = n;
+            break;

         }
     }
 
         }
     }
 

-    if ( index != wxNOT_FOUND ) {
-        wxFileType *fileType = new wxFileType;
+    if ( index != wxNOT_FOUND )
+    {
+       // don't throw away fileType that was already found
+        if (!fileType)
+            fileType = new wxFileType;

         fileType->m_impl->Init(this, index);
         fileType->m_impl->Init(this, index);

-
-        return fileType;

     }
     }

-    else {
-        // not found...
-        return NULL;
+
+    return fileType;
+}
+
+wxString wxMimeTypesManagerImpl::GetCommand(const wxString & verb, size_t nIndex) const
+{
+    wxString command, testcmd, sV, sTmp;
+    sV = verb + wxT("=");
+
+    // list of verb = command pairs for this mimetype
+    wxMimeTypeCommands * sPairs = m_aEntries [nIndex];
+
+    size_t i;
+    for ( i = 0; i < sPairs->GetCount (); i++ )
+    {
+        sTmp = sPairs->GetVerbCmd (i);
+        if ( sTmp.Contains(sV) )
+            command = sTmp.AfterFirst(wxT('='));

     }
     }

+
+    return command;

 }
 
 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();

-    for ( size_t nExt = 0; nExt < nExts; nExt++ ) {
-        if ( nExt > 0 ) {
+    for ( size_t nExt = 0; nExt < nExts; nExt++ )
+    {
+        if ( nExt > 0 )

             extensions += wxT(' ');
             extensions += wxT(' ');

-        }
+

         extensions += exts[nExt];
     }
 
         extensions += exts[nExt];
     }
 


@@ -961,21 +2256,22 @@ void wxMimeTypesManagerImpl::AddMimeTypeInfo(const wxString& strMimeType,
                                              const wxString& strExtensions,
                                              const wxString& strDesc)
 {
                                              const wxString& strExtensions,
                                              const wxString& strDesc)
 {

-    int index = m_aTypes.Index(strMimeType);
-    if ( index == wxNOT_FOUND ) {
-        // add a new entry
-        m_aTypes.Add(strMimeType);
-        m_aEntries.Add(NULL);
-        m_aExtensions.Add(strExtensions);
-        m_aDescriptions.Add(strDesc);
-    }
-    else {
-        // modify an existing one
-        if ( !strDesc.IsEmpty() ) {
-            m_aDescriptions[index] = strDesc;   // replace old value
-        }
-        m_aExtensions[index] += ' ' + strExtensions;
+    // reading mailcap may find image/* , while
+    // reading mime.types finds image/gif and no match is made
+    // this means all the get functions don't work  fix this
+    wxString strIcon;
+    wxString sTmp = strExtensions;
+
+    wxArrayString sExts;
+    sTmp.Trim().Trim(false);
+
+    while (!sTmp.empty())
+    {
+        sExts.Add(sTmp.AfterLast(wxT(' ')));
+        sTmp = sTmp.BeforeLast(wxT(' '));

     }
     }

+
+    AddToMimeData(strMimeType, strIcon, NULL, sExts, strDesc, true);

 }
 
 void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
 }
 
 void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,


@@ -984,47 +2280,46 @@ void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
                                             const wxString& strTest,
                                             const wxString& strDesc)
 {
                                             const wxString& strTest,
                                             const wxString& strDesc)
 {

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

 
 

-    int nIndex = m_aTypes.Index(strType);
-    if ( nIndex == wxNOT_FOUND ) {
-        // new file type
-        m_aTypes.Add(strType);
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands;
+    entry->Add(wxT("open=")  + strOpenCmd);
+    entry->Add(wxT("print=") + strPrintCmd);
+    entry->Add(wxT("test=")  + strTest);

 
 

-        m_aEntries.Add(entry);
-        m_aExtensions.Add(wxT(""));
-        m_aDescriptions.Add(strDesc);
-    }
-    else {
-        // always append the entry in the tail of the list - info added with
-        // this function can only come from AddFallbacks()
-        MailCapEntry *entryOld = m_aEntries[nIndex];
-        if ( entryOld )
-            entry->Append(entryOld);
-        else
-            m_aEntries[nIndex] = entry;
-    }
+    wxString strIcon;
+    wxArrayString strExtensions;
+
+    AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, true);

 }
 
 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);
 
     wxTextFile file(strFileName);

+#if defined(__WXGTK20__) && wxUSE_UNICODE
+    if ( !file.Open(wxConvUTF8) )
+#else

     if ( !file.Open() )
     if ( !file.Open() )

-        return FALSE;
+#endif
+        return false;

 
     // the information we extract
     wxString strMimeType, strDesc, strExtensions;
 
     size_t nLineCount = file.GetLineCount();
     const wxChar *pc = NULL;
 
     // the information we extract
     wxString strMimeType, strDesc, strExtensions;
 
     size_t nLineCount = file.GetLineCount();
     const wxChar *pc = NULL;

-    for ( size_t nLine = 0; nLine < nLineCount; nLine++ ) {
-        if ( pc == NULL ) {
+    for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
+    {
+        if ( pc == NULL )
+        {

             // now we're at the start of the line
             pc = file[nLine].c_str();
         }
             // now we're at the start of the line
             pc = file[nLine].c_str();
         }

-        else {
+        else
+        {

             // we didn't finish with the previous line yet
             nLine--;
         }
             // we didn't finish with the previous line yet
             nLine--;
         }


@@ -1034,7 +2329,8 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
             pc++;
 
         // comment or blank line?
             pc++;
 
         // comment or blank line?

-        if ( *pc == wxT('#') || !*pc ) {
+        if ( *pc == wxT('#') || !*pc )
+        {

             // skip the whole line
             pc = NULL;
             continue;
             // skip the whole line
             pc = NULL;
             continue;


@@ -1042,12 +2338,14 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
 
         // detect file format
         const wxChar *pEqualSign = wxStrchr(pc, wxT('='));
 
         // detect file format
         const wxChar *pEqualSign = wxStrchr(pc, wxT('='));

-        if ( pEqualSign == NULL ) {
+        if ( pEqualSign == NULL )
+        {

             // brief format
             // ------------
 
             // first field is mime type
             // brief format
             // ------------
 
             // first field is mime type

-            for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != wxT('\0'); pc++ ) {
+            for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != wxT('\0'); pc++ )
+            {

                 strMimeType += *pc;
             }
 
                 strMimeType += *pc;
             }
 


@@ -1061,7 +2359,8 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
             // no description...
             strDesc.Empty();
         }
             // no description...
             strDesc.Empty();
         }

-        else {
+        else
+        {

             // expanded format
             // ---------------
 
             // expanded format
             // ---------------
 


@@ -1070,60 +2369,79 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
 
             // eat whitespace
             for ( pc = pEqualSign + 1; wxIsspace(*pc); pc++ )
 
             // eat whitespace
             for ( pc = pEqualSign + 1; wxIsspace(*pc); pc++ )

-                ;
+              ;

 
             const wxChar *pEnd;
 
             const wxChar *pEnd;

-            if ( *pc == wxT('"') ) {
+            if ( *pc == wxT('"') )
+            {

                 // the string is quoted and ends at the matching quote
                 pEnd = wxStrchr(++pc, wxT('"'));
                 // the string is quoted and ends at the matching quote
                 pEnd = wxStrchr(++pc, wxT('"'));

-                if ( pEnd == NULL ) {
-                    wxLogWarning(_("Mime.types file %s, line %d: unterminated "
-                                   "quoted string."),
+                if ( pEnd == NULL )
+                {
+                    wxLogWarning(wxT("Mime.types file %s, line %d: unterminated quoted string."),

                                  strFileName.c_str(), nLine + 1);
                 }
             }
                                  strFileName.c_str(), nLine + 1);
                 }
             }

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

             }
 
             // now we have the RHS (field value)
             wxString strRHS(pc, pEnd - pc);
 
             // check what follows this entry
             }
 
             // now we have the RHS (field value)
             wxString strRHS(pc, pEnd - pc);
 
             // check what follows this entry

-            if ( *pEnd == wxT('"') ) {
+            if ( *pEnd == wxT('"') )
+            {

                 // skip this quote
                 pEnd++;
             }
 
             for ( pc = pEnd; wxIsspace(*pc); pc++ )
                 // skip this quote
                 pEnd++;
             }
 
             for ( pc = pEnd; wxIsspace(*pc); pc++ )

-                ;
+              ;

 
             // if there is something left, it may be either a '\\' to continue
             // the line or the next field of the same entry
 
             // 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 == wxT('\0'),
-                 nextFieldOnSameLine = FALSE;
-            if ( !entryEnded ) {
+            bool entryEnded = *pc == wxT('\0');
+            bool nextFieldOnSameLine = false;
+            if ( !entryEnded )
+            {

                 nextFieldOnSameLine = ((*pc != wxT('\\')) || (pc[1] != wxT('\0')));
             }
 
             // now see what we got
                 nextFieldOnSameLine = ((*pc != wxT('\\')) || (pc[1] != wxT('\0')));
             }
 
             // now see what we got

-            if ( strLHS == wxT("type") ) {
+            if ( strLHS == wxT("type") )
+            {

                 strMimeType = strRHS;
             }
                 strMimeType = strRHS;
             }

-            else if ( strLHS == wxT("desc") ) {
+            else if ( strLHS.StartsWith(wxT("desc")) )
+            {

                 strDesc = strRHS;
             }
                 strDesc = strRHS;
             }

-            else if ( strLHS == wxT("exts") ) {
+            else if ( strLHS == wxT("exts") )
+            {

                 strExtensions = strRHS;
             }
                 strExtensions = strRHS;
             }

-            else {
-                wxLogWarning(_("Unknown field in file %s, line %d: '%s'."),
+            else if ( strLHS == wxT("icon") )
+            {
+                // this one is simply ignored: it usually refers to Netscape
+                // built in icons which are useless for us anyhow
+            }
+            else if ( !strLHS.StartsWith(wxT("x-")) )
+            {
+                // we suppose that all fields starting with "X-" are
+                // unregistered extensions according to the standard practice,
+                // but it may be worth telling the user about other junk in
+                // his mime.types file
+                wxLogWarning(wxT("Unknown field in file %s, line %d: '%s'."),

                              strFileName.c_str(), nLine + 1, strLHS.c_str());
             }
 
                              strFileName.c_str(), nLine + 1, strLHS.c_str());
             }
 

-            if ( !entryEnded ) {
+            if ( !entryEnded )
+            {

                 if ( !nextFieldOnSameLine )
                     pc = NULL;
                 //else: don't reset it
                 if ( !nextFieldOnSameLine )
                     pc = NULL;
                 //else: don't reset it


@@ -1135,50 +2453,168 @@ 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

-        if ( !strExtensions.IsEmpty() && strExtensions[0u] == wxT('.') )
+        if ( !strExtensions.empty() && strExtensions[0u] == wxT('.') )

         {
             strExtensions.erase(0, 1);
         }
 
         {
             strExtensions.erase(0, 1);
         }
 

+        wxLogTrace(TRACE_MIME, wxT("mime.types: '%s' => '%s' (%s)"),
+                   strExtensions.c_str(),
+                   strMimeType.c_str(),
+                   strDesc.c_str());
+

         AddMimeTypeInfo(strMimeType, strExtensions, strDesc);
 
         // finished with this line
         pc = NULL;
     }
 
         AddMimeTypeInfo(strMimeType, strExtensions, strDesc);
 
         // finished with this line
         pc = NULL;
     }
 

-    // check our data integriry
-    wxASSERT( m_aTypes.Count() == m_aEntries.Count() &&
-              m_aTypes.Count() == m_aExtensions.Count() &&
-              m_aTypes.Count() == m_aDescriptions.Count() );
+    return true;
+}
+
+// ----------------------------------------------------------------------------
+// UNIX mailcap files parsing
+// ----------------------------------------------------------------------------
+
+// the data for a single MIME type
+struct MailcapLineData
+{
+    // field values
+    wxString type,
+             cmdOpen,
+             test,
+             icon,
+             desc;
+
+    wxArrayString verbs,
+                  commands;
+
+    // flags
+    bool testfailed,
+         needsterminal,
+         copiousoutput;
+
+    MailcapLineData() { testfailed = needsterminal = copiousoutput = false; }
+};
+
+// process a non-standard (i.e. not the first or second one) mailcap field
+bool
+wxMimeTypesManagerImpl::ProcessOtherMailcapField(MailcapLineData& data,
+                                                 const wxString& curField)
+{
+    if ( curField.empty() )
+    {
+        // we don't care
+        return true;
+    }
+
+    // is this something of the form foo=bar?
+    const wxChar *pEq = wxStrchr(curField, wxT('='));
+    if ( pEq != NULL )
+    {
+        // split "LHS = RHS" in 2
+        wxString lhs = curField.BeforeFirst(wxT('=')),
+                 rhs = curField.AfterFirst(wxT('='));
+
+        lhs.Trim(true);     // from right
+        rhs.Trim(false);    // from left
+
+        // it might be quoted
+        if ( !rhs.empty() && rhs[0u] == wxT('"') && rhs.Last() == wxT('"') )
+        {
+            rhs = rhs.Mid(1, rhs.length() - 2);
+        }
+
+        // is it a command verb or something else?
+        if ( lhs == wxT("test") )
+        {
+            if ( wxSystem(rhs) == 0 )
+            {
+                // ok, test passed
+                wxLogTrace(TRACE_MIME_TEST,
+                           wxT("Test '%s' for mime type '%s' succeeded."),
+                           rhs.c_str(), data.type.c_str());
+            }
+            else
+            {
+                wxLogTrace(TRACE_MIME_TEST,
+                           wxT("Test '%s' for mime type '%s' failed, skipping."),
+                           rhs.c_str(), data.type.c_str());
+
+                data.testfailed = true;
+            }
+        }
+        else if ( lhs == wxT("desc") )
+        {
+            data.desc = rhs;
+        }
+        else if ( lhs == wxT("x11-bitmap") )
+        {
+            data.icon = rhs;
+        }
+        else if ( lhs == wxT("notes") )
+        {
+            // ignore
+        }
+        else // not a (recognized) special case, must be a verb (e.g. "print")
+        {
+            data.verbs.Add(lhs);
+            data.commands.Add(rhs);
+        }
+    }
+    else // '=' not found
+    {
+        // so it must be a simple flag
+        if ( curField == wxT("needsterminal") )
+        {
+            data.needsterminal = true;
+        }
+        else if ( curField == wxT("copiousoutput"))
+        {
+            // copiousoutput impies that the viewer is a console program
+            data.needsterminal =
+            data.copiousoutput = true;
+        }
+        else if ( !IsKnownUnimportantField(curField) )
+        {
+            return false;
+        }
+    }

 
 

-    return TRUE;
+    return true;

 }
 
 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);
 
     wxTextFile file(strFileName);

+#if defined(__WXGTK20__) && wxUSE_UNICODE
+    if ( !file.Open(wxConvUTF8) )
+#else

     if ( !file.Open() )
     if ( !file.Open() )

-        return FALSE;
+#endif
+        return false;
+
+    // indices of MIME types (in m_aTypes) we already found in this file
+    //
+    // (see the comments near the end of function for the reason we need this)
+    wxArrayInt aIndicesSeenHere;

 
 

-    // see the comments near the end of function for the reason we need these
-    // variables (search for the next occurence of them)
-        // indices of MIME types (in m_aTypes) we already found in this file
-    wxArrayInt aEntryIndices;
-        // aLastIndices[n] is the index of last element in
-        // m_aEntries[aEntryIndices[n]] from this file
-    wxArrayInt aLastIndices;
+    // accumulator for the current field
+    wxString curField;
+    curField.reserve(1024);

 
     size_t nLineCount = file.GetLineCount();
 
     size_t nLineCount = file.GetLineCount();

-    for ( size_t nLine = 0; nLine < nLineCount; nLine++ ) {
+    for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
+    {

         // now we're at the start of the line
         const wxChar *pc = file[nLine].c_str();
 
         // now we're at the start of the line
         const wxChar *pc = file[nLine].c_str();
 


@@ -1191,150 +2627,115 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
             continue;
 
         // no, do parse
             continue;
 
         // no, do parse

+        // ------------

 
         // what field are we currently in? The first 2 are fixed and there may
 
         // what field are we currently in? The first 2 are fixed and there may

-        // be an arbitrary number of other fields -- currently, we are not
-        // interested in any of them, but we should parse them as well...
+        // be an arbitrary number of other fields parsed by
+        // ProcessOtherMailcapField()
+        //
+        // the first field is the MIME type

         enum
         {
             Field_Type,
             Field_OpenCmd,
             Field_Other
         enum
         {
             Field_Type,
             Field_OpenCmd,
             Field_Other

-        } currentToken = Field_Type;
+        }
+        currentToken = Field_Type;

 
         // the flags and field values on the current line
 
         // the flags and field values on the current line

-        bool needsterminal = FALSE,
-             copiousoutput = FALSE;
-        wxString strType,
-                 strOpenCmd,
-                 strPrintCmd,
-                 strTest,
-                 strDesc,
-                 curField; // accumulator
-        for ( bool cont = TRUE; cont; pc++ ) {
-            switch ( *pc ) {
+        MailcapLineData data;
+
+        bool cont = true;
+        while ( cont )
+        {
+            switch ( *pc )
+            {

                 case wxT('\\'):
                     // interpret the next character literally (notice that
                     // backslash can be used for line continuation)
                 case wxT('\\'):
                     // interpret the next character literally (notice that
                     // backslash can be used for line continuation)

-                    if ( *++pc == wxT('\0') ) {
-                        // fetch the next line.
+                    if ( *++pc == wxT('\0') )
+                    {
+                        // 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 %lu: '\\' on the end of the last line ignored."),
+                                       strFileName.c_str(),
+                                       (unsigned long)nLine + 1);
+                        }
+                        else
+                        {
+                            // pass to the beginning of the next line
+                            pc = file[++nLine].c_str();

 
 

-                        // 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;
+                            // skip pc++ at the end of the loop
+                            continue;
+                        }

                     }
                     }

-                    else {
+                    else
+                    {

                         // just a normal character
                         curField += *pc;
                     }
                     break;
 
                 case wxT('\0'):
                         // just a normal character
                         curField += *pc;
                     }
                     break;
 
                 case wxT('\0'):

-                    cont = FALSE;   // end of line reached, exit the loop
+                    cont = false;   // end of line reached, exit the loop

 
 

-                    // fall through
+                    // fall through to still process this field

 
                 case wxT(';'):
 
                 case wxT(';'):

-                    // store this field and start looking for the next one
-

                     // trim whitespaces from both sides
                     // trim whitespaces from both sides

-                    curField.Trim(TRUE).Trim(FALSE);
+                    curField.Trim(true).Trim(false);

 
 

-                    switch ( currentToken ) {
+                    switch ( currentToken )
+                    {

                         case Field_Type:
                         case Field_Type:

-                            strType = curField;
-                            if ( strType.Find(wxT('/')) == wxNOT_FOUND ) {
+                            data.type = curField.Lower();
+                            if ( data.type.empty() )
+                            {
+                                // I don't think that this is a valid mailcap
+                                // entry, but try to interpret it somehow
+                                data.type = wxT('*');
+                            }
+
+                            if ( data.type.Find(wxT('/')) == wxNOT_FOUND )
+                            {

                                 // we interpret "type" as "type/*"
                                 // we interpret "type" as "type/*"

-                                strType += wxT("/*");
+                                data.type += wxT("/*");

                             }
 
                             currentToken = Field_OpenCmd;
                             break;
 
                         case Field_OpenCmd:
                             }
 
                             currentToken = Field_OpenCmd;
                             break;
 
                         case Field_OpenCmd:

-                            strOpenCmd = curField;
+                            data.cmdOpen = curField;

 
                             currentToken = Field_Other;
                             break;
 
                         case Field_Other:
 
                             currentToken = Field_Other;
                             break;
 
                         case Field_Other:

+                            if ( !ProcessOtherMailcapField(data, curField) )
+                            {
+                                // don't flood the user with error messages if
+                                // we don't understand something in his
+                                // mailcap, but give them in debug mode because
+                                // this might be useful for the programmer
+                                wxLogDebug
+                                (
+                                    wxT("Mailcap file %s, line %lu: unknown field '%s' for the MIME type '%s' ignored."),
+                                    strFileName.c_str(),
+                                    (unsigned long)nLine + 1,
+                                    curField.c_str(),
+                                    data.type.c_str()
+                                );
+                            }
+                            else if ( data.testfailed )

                             {
                             {

-                                // "good" mailcap entry?
-                                bool ok = TRUE;
-
-                                // is this something of the form foo=bar?
-                                const wxChar *pEq = wxStrchr(curField, wxT('='));
-                                if ( pEq != NULL ) {
-                                    wxString lhs = curField.BeforeFirst(wxT('=')),
-                                             rhs = curField.AfterFirst(wxT('='));
-
-                                    lhs.Trim(TRUE);     // from right
-                                    rhs.Trim(FALSE);    // from left
-
-                                    if ( lhs == wxT("print") )
-                                        strPrintCmd = rhs;
-                                    else if ( lhs == wxT("test") )
-                                        strTest = rhs;
-                                    else if ( lhs == wxT("description") ) {
-                                        // it might be quoted
-                                        if ( rhs[0u] == wxT('"') &&
-                                             rhs.Last() == wxT('"') ) {
-                                            strDesc = wxString(rhs.c_str() + 1,
-                                                               rhs.Len() - 2);
-                                        }
-                                        else {
-                                            strDesc = rhs;
-                                        }
-                                    }
-                                    else if ( lhs == wxT("compose") ||
-                                              lhs == wxT("composetyped") ||
-                                              lhs == wxT("notes") ||
-                                              lhs == wxT("edit") )
-                                        ;   // ignore
-                                    else
-                                        ok = FALSE;
-
-                                }
-                                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;
-                                    else if ( curField == wxT("copiousoutput") )
-                                        copiousoutput = TRUE;
-                                    else if ( curField == wxT("textualnewlines") )
-                                        ;   // ignore
-                                    else
-                                        ok = FALSE;
-                                }
-
-                                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=" )
-                                    {
-                                        // don't flood the user with error
-                                        // messages if we don't understand
-                                        // something in his mailcap, but give
-                                        // them in debug mode because this might
-                                        // be useful for the programmer
-                                        wxLogDebug
-                                        (
-                                          wxT("Mailcap file %s, line %d: "
-                                              "unknown field '%s' for the "
-                                              "MIME type '%s' ignored."),
-                                              strFileName.c_str(),
-                                              nLine + 1,
-                                              curField.c_str(),
-                                              strType.c_str()
-                                        );
-                                    }
-                                }
+                                // skip this entry entirely
+                                cont = false;

                             }
 
                             // it already has this value
                             }
 
                             // it already has this value


@@ -1352,93 +2753,102 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                 default:
                     curField += *pc;
             }
                 default:
                     curField += *pc;
             }

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

         }
 
         }
 

+        // we read the entire entry, check what have we got
+        // ------------------------------------------------
+

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

-        if ( currentToken == Field_Type || currentToken == Field_OpenCmd ) {
-            wxLogWarning(_("Mailcap file %s, line %d: incomplete entry "
-                           "ignored."),
+        if ( currentToken < Field_Other )
+        {
+            wxLogWarning(wxT("Mailcap file %s, line %d: incomplete entry ignored."),

                          strFileName.c_str(), nLine + 1);
                          strFileName.c_str(), nLine + 1);

+
+            continue;

         }
         }

-        else {
-            MailCapEntry *entry = new MailCapEntry(strOpenCmd,
-                                                   strPrintCmd,
-                                                   strTest);
-
-            // NB: because of complications below (we must get entries priority
-            //     right), we can't use AddMailcapInfo() here, unfortunately.
-            strType.MakeLower();
-            int nIndex = m_aTypes.Index(strType);
-            if ( nIndex == wxNOT_FOUND ) {
-                // new file type
-                m_aTypes.Add(strType);
-
-                m_aEntries.Add(entry);
-                m_aExtensions.Add(wxT(""));
-                m_aDescriptions.Add(strDesc);
-            }
-            else {
-                // modify the existing entry: the entries in one and the same
-                // file are read in top-to-bottom order, i.e. the entries read
-                // first should be tried before the entries below. However,
-                // the files read later should override the settings in the
-                // files read before (except if fallback is TRUE), thus we
-                // Insert() the new entry to the list if it has already
-                // occured in _this_ file, but Prepend() it if it occured in
-                // some of the previous ones and Append() to it in the
-                // fallback case
-
-                if ( fallback ) {
-                    // 'fallback' parameter prevents the entries from this
-                    // file from overriding the other ones - always append
-                    MailCapEntry *entryOld = m_aEntries[nIndex];
-                    if ( entryOld )
-                        entry->Append(entryOld);
-                    else
-                        m_aEntries[nIndex] = entry;
-                }
-                else {
-                    int entryIndex = aEntryIndices.Index(nIndex);
-                    if ( entryIndex == wxNOT_FOUND ) {
-                        // first time in this file
-                        aEntryIndices.Add(nIndex);
-                        aLastIndices.Add(0);
-
-                        entry->Prepend(m_aEntries[nIndex]);
-                        m_aEntries[nIndex] = entry;
-                    }
-                    else {
-                        // not the first time in _this_ file
-                        size_t nEntryIndex = (size_t)entryIndex;
-                        MailCapEntry *entryOld = m_aEntries[nIndex];
-                        if ( entryOld )
-                            entry->Insert(entryOld, aLastIndices[nEntryIndex]);
-                        else
-                            m_aEntries[nIndex] = entry;

 
 

-                        // the indices were shifted by 1
-                        aLastIndices[nEntryIndex]++;
-                    }
-                }
+        // if the test command failed, it's as if the entry were not there at all
+        if ( data.testfailed )
+        {
+            continue;
+        }

 
 

-                if ( !strDesc.IsEmpty() ) {
-                    // replace the old one - what else can we do??
-                    m_aDescriptions[nIndex] = strDesc;
-                }
-            }
+        // 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 ( data.copiousoutput )
+        {
+            const wxChar *p = wxGetenv(wxT("PAGER"));
+            data.cmdOpen << wxT(" | ") << (p ? p : wxT("more"));
+        }
+
+        if ( data.needsterminal )
+        {
+            data.cmdOpen = wxString::Format(wxT("xterm -e sh -c '%s'"),
+                                            data.cmdOpen.c_str());
+        }
+
+        if ( !data.cmdOpen.empty() )
+        {
+            data.verbs.Insert(wxT("open"), 0);
+            data.commands.Insert(data.cmdOpen, 0);
+        }
+
+        // we have to decide whether the new entry should replace any entries
+        // for the same MIME type we had previously found or not
+        bool overwrite;
+
+        // the fall back entries have the lowest priority, by definition
+        if ( fallback )
+        {
+            overwrite = false;
+        }
+        else
+        {
+            // have we seen this one before?
+            int nIndex = m_aTypes.Index(data.type);
+
+            // and if we have, was it in this file? if not, we should
+            // overwrite the previously seen one
+            overwrite = nIndex == wxNOT_FOUND ||
+                            aIndicesSeenHere.Index(nIndex) == wxNOT_FOUND;

         }
 
         }
 

-        // check our data integriry
-        wxASSERT( m_aTypes.Count() == m_aEntries.Count() &&
-                  m_aTypes.Count() == m_aExtensions.Count() &&
-                  m_aTypes.Count() == m_aDescriptions.Count() );
+        wxLogTrace(TRACE_MIME, wxT("mailcap %s: %s [%s]"),
+                   data.type.c_str(), data.cmdOpen.c_str(),
+                   overwrite ? wxT("replace") : wxT("add"));
+
+        int n = AddToMimeData
+                (
+                    data.type,
+                    data.icon,
+                    new wxMimeTypeCommands(data.verbs, data.commands),
+                    wxArrayString() /* extensions */,
+                    data.desc,
+                    overwrite
+                );
+
+        if ( overwrite )
+        {
+            aIndicesSeenHere.Add(n);
+        }

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 {
 }
 
 size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 {

+    InitIfNeeded();
+

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


@@ -1447,7 +2857,7 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
     {
         // don't return template types from here (i.e. anything containg '*')
         type = m_aTypes[n];
     {
         // don't return template types from here (i.e. anything containg '*')
         type = m_aTypes[n];

-        if ( type.Find(_T('*')) == wxNOT_FOUND )
+        if ( type.Find(wxT('*')) == wxNOT_FOUND )

         {
             mimetypes.Add(type);
         }
         {
             mimetypes.Add(type);
         }


@@ -1456,6 +2866,68 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
     return mimetypes.GetCount();
 }
 
     return mimetypes.GetCount();
 }
 

+// ----------------------------------------------------------------------------
+// writing to MIME type files
+// ----------------------------------------------------------------------------
+
+bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
+{
+    wxArrayString sMimeTypes;
+    ft->GetMimeTypes(sMimeTypes);
+
+    wxString sMime;
+    size_t i;
+    for (i = 0; i < sMimeTypes.GetCount(); i ++)
+    {
+        sMime = sMimeTypes.Item(i);
+        int nIndex = m_aTypes.Index(sMime);
+        if ( nIndex == wxNOT_FOUND)
+        {
+            // error if we get here ??
+            return false;
+        }
+        else
+        {
+            WriteMimeInfo(nIndex, true);
+            m_aTypes.RemoveAt(nIndex);
+            m_aEntries.RemoveAt(nIndex);
+            m_aExtensions.RemoveAt(nIndex);
+            m_aDescriptions.RemoveAt(nIndex);
+            m_aIcons.RemoveAt(nIndex);
+        }
+    }
+    // check data integrity
+    wxASSERT( m_aTypes.Count() == m_aEntries.Count() &&
+            m_aTypes.Count() == m_aExtensions.Count() &&
+            m_aTypes.Count() == m_aIcons.Count() &&
+            m_aTypes.Count() == m_aDescriptions.Count() );
+
+    return true;
+}
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+static bool IsKnownUnimportantField(const wxString& fieldAll)
+{
+    static const wxChar *knownFields[] =
+    {
+        wxT("x-mozilla-flags"),
+        wxT("nametemplate"),
+        wxT("textualnewlines"),
+    };
+
+    wxString field = fieldAll.BeforeFirst(wxT('='));
+    for ( size_t n = 0; n < WXSIZEOF(knownFields); n++ )
+    {
+        if ( field.CmpNoCase(knownFields[n]) == 0 )
+            return true;
+    }
+
+    return false;
+}
+

 #endif
 #endif

-  // wxUSE_FILE && wxUSE_TEXTFILE
+  // wxUSE_MIMETYPE && wxUSE_FILE && wxUSE_TEXTFILE