]> git.saurik.com Git - wxWidgets.git/blobdiff - src/unix/mimetype.cpp
Corrected some wxMac images
[wxWidgets.git] / src / unix / mimetype.cpp
index eda69158e70084e1a494c359a5623c4d3c235eec..9467a8c1b46852c6800a3e84fd9be9320ef1e3ae 100644 (file)
-
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        unix/mimetype.cpp
+// Name:        src/unix/mimetype.cpp
 // Purpose:     classes and functions to manage MIME types
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     23.09.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Purpose:     classes and functions to manage MIME types
 // Author:      Vadim Zeitlin
 // Modified by:
 // 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)
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 
-// 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 n??ever will
-
-// ============================================================================
-// declarations
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-
-#ifdef __GNUG__
-    #pragma implementation "mimetype.h"
-#endif
-
 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-  #pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #endif
 
-#ifndef WX_PRECOMP
-  #include "wx/defs.h"
-#endif
+#if wxUSE_MIMETYPE && wxUSE_FILE
 
 
-#if wxUSE_FILE && wxUSE_TEXTFILE
+#include "wx/unix/mimetype.h"
 
 #ifndef WX_PRECOMP
 
 #ifndef WX_PRECOMP
-  #include "wx/string.h"
-  #if wxUSE_GUI
-    #include "wx/icon.h"
-
-  #endif
-#endif //WX_PRECOMP
-
+    #include "wx/dynarray.h"
+    #include "wx/string.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"
+    #include "wx/utils.h"
+#endif
 
 
-#include "wx/log.h"
 #include "wx/file.h"
 #include "wx/file.h"
-#include "wx/intl.h"
-#include "wx/dynarray.h"
 #include "wx/confbase.h"
 
 #include "wx/ffile.h"
 #include "wx/confbase.h"
 
 #include "wx/ffile.h"
-#include "wx/textfile.h"
 #include "wx/dir.h"
 #include "wx/dir.h"
-#include "wx/utils.h"
 #include "wx/tokenzr.h"
 #include "wx/tokenzr.h"
-
-#include "wx/unix/mimetype.h"
+#include "wx/iconloc.h"
+#include "wx/filename.h"
+#include "wx/app.h"
+#include "wx/apptrait.h"
 
 // other standard headers
 #include <ctype.h>
 
 
 // other standard headers
 #include <ctype.h>
 
-#ifdef __VMS
-/* silence warnings for comparing unsigned int's <0 */
-# pragma message disable unscomzer
-#endif
-
-// this is a class to extend wxArrayString...
-class wxMimeArrayString : public wxArrayString
+class wxMimeTextFile
 {
 public:
 {
 public:
-    wxMimeArrayString ()
+    wxMimeTextFile()
     {
     {
-        wxArrayString ();
     }
 
     }
 
-    size_t pIndexOf (const wxString & verb)
+    wxMimeTextFile(const wxString& fname)
     {
     {
-        size_t i = 0;
-        wxString sTmp = verb;
-        // avoid a problem with modifying const parameter
-        sTmp.MakeLower();
-        while ( (i < GetCount()) && (! Item(i).MakeLower().Contains(sTmp)) )
-        {
-            i++;
-        }
-        if ( i==GetCount() ) i = (size_t)wxNOT_FOUND;
-        return i;
+       m_fname = fname;
     }
 
     }
 
-    bool ReplaceOrAddLineCmd (const wxString verb, const wxString & cmd)
+    bool Open()
     {
     {
-        size_t nIndex = pIndexOf (verb);
-        if (nIndex == (size_t)wxNOT_FOUND)
-            Add(verb + wxT("=") + cmd);
-        else
-            Item(nIndex) = verb + wxT("=") + cmd;
-        return TRUE;
-    }
+       wxFFile file( m_fname );
+       if (!file.IsOpened())
+          return false;
 
 
-    wxString GetVerb (size_t i)
-    {
-        if (i < 0) return wxEmptyString;
-        if (i > GetCount() ) return wxEmptyString;
-        wxString sTmp = Item(i).BeforeFirst(wxT('='));
-        return sTmp;
-    }
+       size_t size = file.Length();
+       wxCharBuffer buffer( size );
+       file.Read( (void*) (const char*) buffer, size );
 
 
-    wxString GetCmd (size_t i)
-    {
-        if (i < 0) return wxEmptyString;
-        if (i > GetCount() ) return wxEmptyString;
-        wxString sTmp = Item(i).AfterFirst(wxT('='));
-        return sTmp;
+       // Check for valid UTF-8 here?
+       wxString all = wxString::FromUTF8( buffer, size );
+
+       wxStringTokenizer tok( all, "\n" );
+       while (tok.HasMoreTokens())
+       {
+          wxString t = tok.GetNextToken();
+          t.MakeLower();
+          if ((!!t) && (t.Find( "comment" ) != 0) && (t.Find( "#" ) != 0) && (t.Find( "generic" ) != 0))
+             m_text.Add( t );
+       }
+       return true;
     }
     }
-};
 
 
-//this class extends wxTextFile
-class wxMimeTextFile : public wxTextFile
-{
-public:
-    // constructors
-    wxMimeTextFile () : wxTextFile () {};
-    wxMimeTextFile (const wxString& strFile) : wxTextFile (strFile)  {  };
+    unsigned int GetLineCount() const { return m_text.GetCount(); }
+    wxString &GetLine( unsigned int line ) { return m_text[line]; }
 
 
-    int pIndexOf(const wxString & sSearch, bool bIncludeComments = FALSE, int iStart = 0)
+    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 sTest = sSearch;
         sTest.MakeLower();
-        wxString sLine;
-
-        if (bIncludeComments)
+        for(size_t i = iStart; i < GetLineCount(); i++)
         {
         {
-            while ( (i < GetLineCount())   )
+            wxString sLine = GetLine(i);
+            if(bIncludeComments || ! sLine.StartsWith(wxT("#")))
             {
             {
-                sLine = GetLine (i);
-                sLine.MakeLower();
-                if (sLine.Contains(sTest)) nResult = (int) i;
-                i++;
+                if(sLine.StartsWith(sTest))
+                    return (int)i;
             }
         }
             }
         }
-        else
-        {
-            while ( (i < GetLineCount()) )
-            {
-                sLine = GetLine (i);
-                sLine.MakeLower();
-                if ( ! sLine.StartsWith(wxT("#")))
-                {
-                    if (sLine.Contains(sTest)) nResult = (int) i;
-                }
-                i++;
-            }
-        }
-        return  nResult;
+        return wxNOT_FOUND;
     }
 
     }
 
-    bool CommentLine(int nIndex)
+    wxString GetVerb(size_t i)
     {
     {
-        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;
-    }
+        if (i > GetLineCount() )
+            return wxEmptyString;
 
 
-    wxString GetVerb (size_t i)
-    {
-        if (i < 0) return wxEmptyString;
-        if (i > GetLineCount() ) return wxEmptyString;
         wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
         return sTmp;
     }
 
         wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
         return sTmp;
     }
 
-    wxString GetCmd (size_t i)
+    wxString GetCmd(size_t i)
     {
     {
-        if (i < 0) return wxEmptyString;
-        if (i > GetLineCount() ) return wxEmptyString;
+        if (i > GetLineCount() )
+            return wxEmptyString;
+
         wxString sTmp = GetLine(i).AfterFirst(wxT('='));
         return sTmp;
     }
         wxString sTmp = GetLine(i).AfterFirst(wxT('='));
         return sTmp;
     }
-};
 
 
-// in case we're compiling in non-GUI mode
-class WXDLLEXPORT wxIcon;
+private:
+    wxArrayString m_text;
+    wxString m_fname;
+};
 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
 // MIME code tracing mask
 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
 // MIME code tracing mask
-#define TRACE_MIME _T("mime")
-
-// ----------------------------------------------------------------------------
-// private functions
-// ----------------------------------------------------------------------------
-
-// there are some fields which we don't understand but for which we don't give
-// warnings as we know that they're not important - this function is used to
-// test for them
-static bool IsKnownUnimportantField(const wxString& field);
-
-// ----------------------------------------------------------------------------
-// private classes
-// ----------------------------------------------------------------------------
-
-
-
-// This class uses both mailcap and mime.types to gather information about file
-// types.
-//
-// 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>.
-// A backslash can be used to quote semicolons and newlines (and, in fact,
-// anything else including itself).
-//
-// The first field is always the MIME type in the form of type/subtype (see RFC
-// 822) where subtype may be '*' meaning "any". Following metamail, we accept
-// "type" which means the same as "type/*", although I'm not sure whether this
-// is standard.
-//
-// The second field is always the command to run. It is subject to
-// parameter/filename expansion described below.
-//
-// All the following fields are optional and may not be present at all. If
-// they're present they may appear in any order, although each of them should
-// appear only once. The optional fields are the following:
-//  * notes=xxx is an uninterpreted string which is silently ignored
-//  * test=xxx is the command to be used to determine whether this mailcap line
-//    applies to our data or not. The RHS of this field goes through the
-//    parameter/filename expansion (as the 2nd field) and the resulting string
-//    is executed. The line applies only if the command succeeds, i.e. returns 0
-//    exit code.
-//  * 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 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
-//    mechanism.
-//  * textualnewlines means not to perform CR/LF translation (not honored)
-//  * 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 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
-//    replaced by an array of (content-type, temporary file name) pairs for all
-//    message parts (TODO)
-//  * %{parameter} is replaced with the value of parameter taken from
-//    Content-type header line of the message.
-//
-//
-// There are 2 possible formats for mime.types file, one entry per line (used
-// 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:
-//      type=<mime type> \ 
-//      desc="<description>" \ 
-//      exts="<comma separated list of extensions>"
-//
-// We try to autodetect the format of mime.types: if a non-comment line starts
-// with "type=" we assume the second format, otherwise the first one.
-
-// 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.
-
-// ----------------------------------------------------------------------------
-// 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 ()
-    {
-    wxString gnomedir;
-    wxGetHomeDir( &gnomedir );
-    wxString sTmp = gnomedir;
-    sTmp = sTmp + "/.gnome" ;
-    if (! wxDir::Exists ( sTmp ) )
-        {
-        if (!wxMkdir ( sTmp ))
-            {
-            wxFAIL_MSG (wxString ("Failed to create directory\n.gnome in \nCheckGnomeDirsExist") + sTmp );
-            return FALSE;
-            }
-        }
-    sTmp = sTmp + "/mime-info";
-    if (! wxDir::Exists ( sTmp ) )
-        {
-        if (!wxMkdir ( sTmp ))
-        {
-            wxFAIL_MSG (wxString ("Failed to create directory\nmime-info in \nCheckGnomeDirsExist") + sTmp );
-            return FALSE;
-        }
-    }
-    return TRUE;
-
-}
-
-
-
-bool wxMimeTypesManagerImpl::WriteGnomeKeyFile(int index, bool delete_index)
-                {
-    wxString gnomedir;
-    wxGetHomeDir( &gnomedir );
-
-    wxMimeTextFile outfile ( gnomedir + "/.gnome/mime-info/user.keys");
-    // 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;
-        outfile.Create ();
-    }
-
-    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");
-        wxMimeArrayString * entries = m_aEntries[index];
-        size_t i;
-        for (i=0; i < entries->GetCount(); i++)
-            {
-            sTmp = entries->Item(i);
-            sTmp.Replace( wxT("%s"), wxT("%f") );
-            sTmp = wxT ( "\t") + sTmp;
-            outfile.AddLine ( sTmp );
-            }
-        //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);
-        wxMimeArrayString sOld;
-        size_t nOld = nIndex + 1;
-        bool oldEntryEnd = FALSE;
-        while ( (nOld < outfile.GetLineCount() )&& (oldEntryEnd == FALSE ))
-            {
-            sTmp = outfile.GetLine(nOld);
-            if ( (sTmp[0u] == wxT('\t')) || (sTmp[0u] == wxT('#')) )
-                {
-                // we have another line to deal with
-                outfile.CommentLine(nOld);
-                nOld ++;
-                // 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)
-            {
-            wxMimeArrayString * 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.ReplaceOrAddLineCmd ( entries->GetVerb(i), entries->GetCmd (i) );
-            }
-            //sOld should also contain the icon
-            if ( !m_aIcons[index].IsEmpty() )
-                sOld.ReplaceOrAddLineCmd ( wxT( "icon-filename"), m_aIcons[index] );
-
-            for (i=0; i < sOld.GetCount(); i++)
-                {
-                sTmp = sOld.Item(i);
-                sTmp.Replace( wxT("%s"), wxT("%f") );
-                sTmp = wxT ( "\t") + sTmp;
-                nIndex ++;
-                outfile.InsertLine ( sTmp, nIndex );
-                }
-            }
-        }
-    bool bTmp = outfile.Write ();
-    return bTmp;
-        }
-
-
-bool wxMimeTypesManagerImpl::WriteGnomeMimeFile(int index, bool delete_index)
-                {
-    wxString gnomedir;
-    wxGetHomeDir( &gnomedir );
-
-    wxMimeTextFile outfile ( gnomedir + "/.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;
-        outfile.Create ();
-    }
-    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 );
-            }
-        }
-    }
-    bool bTmp = outfile.Write ();
-    return bTmp;
-}
+#define TRACE_MIME wxT("mime")
 
 
 
 
-void wxMimeTypesManagerImpl::LoadGnomeDataFromKeyFile(const wxString& filename)
+// Read a XDG *.desktop file of type 'Application'
+void wxMimeTypesManagerImpl::LoadXDGApp(const wxString& filename)
 {
 {
-    wxTextFile textfile(filename);
-    if ( !textfile.Open() )
-        return;
-    wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s  ---"),
-                 filename.c_str());
-
-    // values for the entry being parsed
-    wxString curMimeType, curIconFile;
-    wxMimeArrayString * entry = new wxMimeArrayString;
-
-    // these are always empty in this file
-    wxArrayString strExtensions;
-    wxString strDesc;
-
-    const wxChar *pc;
-    size_t nLineCount = textfile.GetLineCount();
-    size_t nLine = 0;
-    while ( nLine < nLineCount)
-        {
-        pc = textfile[nLine].c_str();
-        if ( *pc != _T('#') )
-            {
-
-            wxLogTrace(TRACE_MIME, wxT("--- Reading from Gnome file %s '%s' ---"),
-                 filename.c_str(),pc);
-
-            wxString sTmp(pc);
-            if (sTmp.Contains(wxT("=")) )
-            {
-            if (sTmp.Contains( wxT("icon-filename=") ) )
-                {
-                curIconFile = sTmp.AfterFirst(wxT('='));
-                }
-            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.IsEmpty())
-                        {
-                        AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
-
-                        // now get ready for next bit
-                        entry = new wxMimeArrayString;
-                        }
-                    curMimeType = sTmp.BeforeFirst(wxT(':'));
-                    }
-    }
-        } // end of not a comment
-    // ignore blank lines
-    nLine ++;
-    } // end of while, save any data
-    if (! curMimeType.IsEmpty())
-        {
-        AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
-        }
-
-}
-
+    wxLogTrace(TRACE_MIME, wxT("loading XDG file %s"), filename.c_str());
 
 
-
-void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& filename)
-{
-    wxTextFile textfile(filename);
-    if ( !textfile.Open() )
+    wxMimeTextFile file(filename);
+    if ( !file.Open() )
         return;
         return;
-    wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s  ---"),
-                 filename.c_str());
-
-    // values for the entry being parsed
-    wxString curMimeType, curExtList;
-
-    const wxChar *pc;
-    size_t nLineCount = textfile.GetLineCount();
-    for ( size_t nLine = 0; ; nLine++ )
-    {
-        if ( nLine < nLineCount )
-        {
-            pc = textfile[nLine].c_str();
-            if ( *pc == _T('#') )
-            {
-                // skip comments
-                continue;
-            }
-        }
-        else
-        {
-            // so that we will fall into the "if" below
-            pc = NULL;
-        }
-
-        if ( !pc || !*pc )
-        {
-            // end of the entry
-            if ( !!curMimeType && !!curExtList )
-            {
-                 wxLogTrace(TRACE_MIME, wxT("--- At end of Gnome file  finding mimetype %s  ---"),
-                 curMimeType.c_str());
-
-                 AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
-            }
-
-            if ( !pc )
-            {
-                // the end - this can only happen if nLine == nLineCount
-                break;
-            }
-
-            curExtList.Empty();
 
 
-            continue;
-        }
-
-        // what do we have here?
-        if ( *pc == _T('\t') )
-        {
-            // this is a field=value ling
-            pc++; // skip leading TAB
-
-            static const int lenField = 4; // strlen("ext:")
-            if ( wxStrncmp(pc, _T("ext:"), lenField) == 0 )
-            {
-                // skip ' ' which follows and take everything left until the end
-                // of line
-                curExtList = pc + lenField + 1;
-            }
-            //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.IsEmpty()) AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
-
-            curMimeType.Empty();
-
-            while ( *pc != _T(':') && *pc != _T('\0') )
-            {
-                curMimeType += *pc++;
-            }
-        }
-    }
-}
-
-
-void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(const wxString& dirbase)
-{
-    wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
-                  _T("base directory shouldn't end with a slash") );
-
-    wxString dirname = dirbase;
-    dirname << _T("/mime-info");
-
-    if ( !wxDir::Exists(dirname) )
+    // Here, only type 'Application' should be considered.
+    int nIndex = file.pIndexOf( "Type=" );
+    if (nIndex != wxNOT_FOUND && file.GetCmd(nIndex) != "application")
         return;
 
         return;
 
-    wxDir dir(dirname);
-    if ( !dir.IsOpened() )
+    // The hidden entry specifies a file to be ignored.
+    nIndex = file.pIndexOf( "Hidden=" );
+    if (nIndex != wxNOT_FOUND && file.GetCmd(nIndex) == "true")
         return;
 
         return;
 
-    // we will concatenate it with filename to get the full path below
-    dirname += _T('/');
-
-    wxString filename;
-    bool cont = dir.GetFirst(&filename, _T("*.mime"), wxDIR_FILES);
-    while ( cont )
-    {
-        LoadGnomeMimeTypesFromMimeFile(dirname + filename);
-
-        cont = dir.GetNext(&filename);
-    }
-
-    cont = dir.GetFirst(&filename, _T("*.keys"), wxDIR_FILES);
-    while ( cont )
-    {
-        LoadGnomeDataFromKeyFile(dirname + filename);
-
-        cont = dir.GetNext(&filename);
-    }
-}
-
-
-
-
-void wxMimeTypesManagerImpl::GetGnomeMimeInfo(const wxString& sExtraDir)
-{
-
-    wxArrayString dirs;
-    dirs.Add(_T("/usr/share"));
-    dirs.Add(_T("/usr/local/share"));
-
-    wxString gnomedir;
-    wxGetHomeDir( &gnomedir );
-    gnomedir += _T("/.gnome");
-    dirs.Add( gnomedir );
-    if (!sExtraDir.IsEmpty()) dirs.Add( sExtraDir );
-
-    size_t nDirs = dirs.GetCount();
-    for ( size_t nDir = 0; nDir < nDirs; nDir++ )
-    {
-        LoadGnomeMimeFilesFromDir(dirs[nDir]);
-    }
-}
-
-
-
-
-// end of gnome
-
-// ----------------------------------------------------------------------------
-// wxKDE
-// ----------------------------------------------------------------------------
-
-// KDE stores the icon info in its .kdelnk files. The file for mimetype/subtype
-// may be found in either of the following locations
-//
-//  1. $KDEDIR/share/mimelnk/mimetype/subtype.kdelnk
-//  2. ~/.kde/share/mimelnk/mimetype/subtype.kdelnk
-//
-// The format of a .kdelnk file is almost the same as the one used by
-// wxFileConfig, i.e. there are groups, comments and entries. The icon is the
-// value for the entry "Type"
-
-// 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.IsEmpty())
-        {
-            if (wxDir::Exists(sOK)) return TRUE;
-            else return FALSE;
-        }
-    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, _T(" "));
-    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);
-
-    wxMimeArrayString * entries = m_aEntries[index];
-    // if we don't find open just have an empty string ... FIX this
-    size_t iOpen = entries->pIndexOf(wxT("open"));
-    sTmp = entries->GetCmd(iOpen);
-    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)
-{
-    wxMimeTextFile file;
-    if ( !file.Open(dirbase + filename) ) return;
-
-    wxMimeArrayString * entry = new wxMimeArrayString;
-    wxArrayString sExts;
-    wxString mimetype, mime_desc, strIcon;
-
-    int nIndex = file.pIndexOf ("MimeType=");
+    // Semicolon separated list of mime types handled by the application.
+    nIndex = file.pIndexOf( wxT("MimeType=") );
     if (nIndex == wxNOT_FOUND)
     if (nIndex == wxNOT_FOUND)
-        {
-    // construct mimetype from the directory name and the basename of the
-    // file (it always has .kdelnk extension)
-    mimetype << subdir << _T('/') << filename.BeforeLast(_T('.'));
-        }
-    else mimetype = file.GetCmd (nIndex);
+        return;
+    wxString mimetypes = file.GetCmd (nIndex);
 
 
-    // first find the description string: it is the value in either "Comment="
-    // line or "Comment[<locale_name>]=" one
+    // Name of the application
+    wxString nameapp;
     nIndex = wxNOT_FOUND;
     nIndex = wxNOT_FOUND;
-
-    wxString comment;
-#if wxUSE_INTL
+#if wxUSE_INTL // try "Name[locale name]" first
     wxLocale *locale = wxGetLocale();
     if ( locale )
     wxLocale *locale = wxGetLocale();
     if ( locale )
-    {
-        // try "Comment[locale name]" first
-        comment << _T("Comment[") + locale->GetName() + _T("]=");
-        nIndex = file.pIndexOf(comment);
-    }
+        nIndex = file.pIndexOf(_T("Name[")+locale->GetName()+_T("]="));
 #endif // wxUSE_INTL
 #endif // wxUSE_INTL
+    if(nIndex == wxNOT_FOUND)
+        nIndex = file.pIndexOf( wxT("Name=") );
+    if(nIndex != wxNOT_FOUND)
+        nameapp = file.GetCmd(nIndex);
 
 
-    if ( nIndex == wxNOT_FOUND )
-    {
-        comment = _T("Comment=");
-        nIndex = file.pIndexOf(comment);
-    }
-
-    if ( nIndex != wxNOT_FOUND ) mime_desc = file.GetCmd(nIndex);
-    //else: no description
-
-    // next find the extensions
-    wxString mime_extension;
-
-    nIndex = file.pIndexOf(_T("Patterns="));
-    if ( nIndex != wxNOT_FOUND )
-        {
-        wxString exts = file.GetCmd (nIndex) ;;
-
-        wxStringTokenizer tokenizer(exts, _T(";"));
-        while ( tokenizer.HasMoreTokens() )
-        {
-            wxString e = tokenizer.GetNextToken();
-            if ( e.Left(2) != _T("*.") )
-                continue; // don't support too difficult patterns
-
-            if ( !mime_extension.empty() )
-            {
-                // separate from the previous ext
-                mime_extension << _T(' ');
-            }
-
-            mime_extension << e.Mid(2);
-        }
+    // Icon of the application.
+    wxString nameicon, namemini;
+    nIndex = wxNOT_FOUND;
+#if wxUSE_INTL // try "Icon[locale name]" first
+    if ( locale )
+        nIndex = file.pIndexOf(_T("Icon[")+locale->GetName()+_T("]="));
+#endif // wxUSE_INTL
+    if(nIndex == wxNOT_FOUND)
+        nIndex = file.pIndexOf( wxT("Icon=") );
+    if(nIndex != wxNOT_FOUND) {
+        nameicon = wxString(wxT("--icon ")) + file.GetCmd(nIndex);
+        namemini = wxString(wxT("--miniicon ")) + file.GetCmd(nIndex);
     }
     }
-    sExts.Add(mime_extension);
-
 
 
-    // ok, now we can take care of icon:
-
-    nIndex = file.pIndexOf(_T("Icon="));
-    if ( nIndex != wxNOT_FOUND )
-    {
-        strIcon = file.GetCmd(nIndex);
-        //it could be the real path, but more often a short name
-        if (!wxFileExists(strIcon))
-    {
-            // icon is just the short name
-            if ( !strIcon.IsEmpty() )
-    {
-        // 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] + strIcon))
-            {
-                        strIcon.Prepend(icondirs[nDir]);
-                break;
-            }
-                }
-            }
-         }
-    // now look for lines which know about the application
-    // exec= or DefaultApp=
-
-    nIndex = file.pIndexOf(wxT("DefaultApp"));
+    // Replace some of the field code in the 'Exec' entry.
+    // TODO: deal with %d, %D, %n, %N, %k and %v (but last one is deprecated)
+    nIndex = file.pIndexOf( wxT("Exec=") );
+    if (nIndex == wxNOT_FOUND)
+        return;
+    wxString sCmd = file.GetCmd(nIndex);
+    // we expect %f; others including  %F and %U and %u are possible
+    sCmd.Replace(wxT("%F"), wxT("%f"));
+    sCmd.Replace(wxT("%U"), wxT("%f"));
+    sCmd.Replace(wxT("%u"), wxT("%f"));
+    if (0 == sCmd.Replace ( wxT("%f"), wxT("%s") ))
+        sCmd = sCmd + wxT(" %s");
+    sCmd.Replace(wxT("%c"), nameapp);
+    sCmd.Replace(wxT("%i"), nameicon);
+    sCmd.Replace(wxT("%m"), namemini);
 
 
-    if ( nIndex == wxNOT_FOUND )
-        {
-        // no entry try exec
-        nIndex = file.pIndexOf(wxT("Exec"));
+    wxStringTokenizer tokenizer(mimetypes, _T(";"));
+    while(tokenizer.HasMoreTokens()) {
+        wxString mimetype = tokenizer.GetNextToken().Lower();
+        nIndex = m_aTypes.Index(mimetype);
+        if(nIndex != wxNOT_FOUND) { // is this a known MIME type?
+            wxMimeTypeCommands* entry = m_aEntries[nIndex];
+            entry->AddOrReplaceVerb(wxT("open"), sCmd);
         }
         }
-
-    if ( nIndex != wxNOT_FOUND )
-        {
-        wxString sTmp = file.GetCmd(nIndex);
-        // we expect %f; others including  %F and %U and %u are possible
-        if (0 == sTmp.Replace ( wxT("%f"), wxT("%s") )) sTmp = sTmp + wxT(" %s");
-        entry->ReplaceOrAddLineCmd (wxString(wxT("open")), sTmp );
     }
     }
-
-    AddToMimeData (mimetype, strIcon, entry, sExts, mime_desc);
-
-
 }
 
 }
 
-void wxMimeTypesManagerImpl::LoadKDELinksForMimeType(const wxString& dirbase,
-                                            const wxString& subdir,
-                                            const wxArrayString& icondirs)
+void wxMimeTypesManagerImpl::LoadXDGAppsFilesFromDir(const wxString& dirname)
 {
 {
-    wxString dirname = dirbase;
-    dirname += subdir;
+    // Don't complain if we don't have permissions to read - it confuses users
+    wxLogNull logNull;
+
+    if(! wxDir::Exists(dirname))
+        return;
     wxDir dir(dirname);
     if ( !dir.IsOpened() )
         return;
 
     wxDir dir(dirname);
     if ( !dir.IsOpened() )
         return;
 
-    dirname += _T('/');
-
     wxString filename;
     wxString filename;
-    bool cont = dir.GetFirst(&filename, _T("*.kdelnk"), wxDIR_FILES);
-    while ( cont )
+    // Look into .desktop files
+    bool cont = dir.GetFirst(&filename, _T("*.desktop"), wxDIR_FILES);
+    while (cont)
     {
     {
-        LoadKDELinksForMimeSubtype(dirname, subdir, filename, icondirs);
-
+        wxFileName p(dirname, filename);
+        LoadXDGApp( p.GetFullPath() );
         cont = dir.GetNext(&filename);
     }
         cont = dir.GetNext(&filename);
     }
-    // new standard for Gnome and KDE
-    cont = dir.GetFirst(&filename, _T("*.desktop"), wxDIR_FILES);
-    while ( cont )
-    {
-        LoadKDELinksForMimeSubtype(dirname, subdir, filename, icondirs);
 
 
+#if 0
+    // RR: I'm not sure this makes any sense. On my system we'll just
+    //     scan the YAST2 and other useless directories
+
+    // Look recursively into subdirs
+    cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
+    while (cont)
+    {
+        wxFileName p(dirname, wxEmptyString);
+        p.AppendDir(filename);
+        LoadXDGAppsFilesFromDir( p.GetPath() );
         cont = dir.GetNext(&filename);
     }
         cont = dir.GetNext(&filename);
     }
+#endif
 }
 
 }
 
-void wxMimeTypesManagerImpl::LoadKDELinkFilesFromDir(const wxString& dirbase,
-                                            const wxArrayString& icondirs)
-{
-    wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
-                  _T("base directory shouldn't end with a slash") );
-
-    wxString dirname = dirbase;
-    dirname << _T("/mimelnk");
-
-    if ( !wxDir::Exists(dirname) )
-        return;
 
 
-    wxDir dir(dirname);
-    if ( !dir.IsOpened() )
+void wxMimeTypesManagerImpl::LoadXDGGlobs(const wxString& filename)
+{
+    if ( !wxFileName::FileExists(filename) )
         return;
 
         return;
 
-    // we will concatenate it with dir name to get the full path below
-    dirname += _T('/');
+    wxLogTrace(TRACE_MIME, wxT("loading XDG globs file from %s"), filename.c_str());
 
 
-    wxString subdir;
-    bool cont = dir.GetFirst(&subdir, wxEmptyString, wxDIR_DIRS);
-    while ( cont )
-    {
-        LoadKDELinksForMimeType(dirname, subdir, icondirs);
-
-        cont = dir.GetNext(&subdir);
-    }
-}
-
-void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)
-{
-    wxArrayString dirs;
-    wxArrayString icondirs;
-
-    // settings in ~/.kde have maximal priority
-    dirs.Add(wxGetHomeDir() + _T("/.kde/share"));
-    icondirs.Add(wxGetHomeDir() + _T("/.kde/share/icons/"));
+    wxMimeTextFile file(filename);
+    if ( !file.Open() )
+        return;
 
 
-    // the variable KDEDIR is set when KDE is running
-    const char *kdedir = getenv("KDEDIR");
-    if ( kdedir )
-    {
-        dirs.Add(wxString(kdedir) + _T("/share"));
-        icondirs.Add(wxString(kdedir) + _T("/share/icons/"));
-    }
-    else
+    size_t i;
+    for (i = 0; i < file.GetLineCount(); i++)
     {
     {
-        // try to guess KDEDIR
-        dirs.Add(_T("/usr/share"));
-        dirs.Add(_T("/opt/kde/share"));
-        icondirs.Add(_T("/usr/share/icons/"));
-        icondirs.Add(_T("/usr/X11R6/share/icons/")); // Debian/Corel linux
-        icondirs.Add(_T("/opt/kde/share/icons/"));
-    }
+       wxStringTokenizer tok( file.GetLine(i), ":" );
+       wxString mime = tok.GetNextToken();
+       wxString ext = tok.GetNextToken();
+       ext.Remove( 0, 2 );
+       wxArrayString exts;
+       exts.Add( ext );
 
 
-    if (!sExtraDir.IsEmpty()) dirs.Add (sExtraDir);
-    icondirs.Add(sExtraDir + wxT("/icons"));
-
-    size_t nDirs = dirs.GetCount();
-    for ( size_t nDir = 0; nDir < nDirs; nDir++ )
-    {
-        LoadKDELinkFilesFromDir(dirs[nDir], icondirs);
+       AddToMimeData(mime, wxEmptyString, NULL, exts, wxEmptyString, true );
     }
     }
-
-
 }
 
 }
 
-// end of KDE
-
 // ----------------------------------------------------------------------------
 // wxFileTypeImpl (Unix)
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxFileTypeImpl (Unix)
 // ----------------------------------------------------------------------------
 
-
 wxString wxFileTypeImpl::GetExpandedCommand(const wxString & verb, const wxFileType::MessageParameters& params) const
 {
     wxString sTmp;
     size_t i = 0;
 wxString wxFileTypeImpl::GetExpandedCommand(const wxString & verb, const wxFileType::MessageParameters& params) const
 {
     wxString sTmp;
     size_t i = 0;
-    while ( (i < m_index.GetCount() ) && sTmp.IsEmpty() )
+    while ( (i < m_index.GetCount() ) && sTmp.empty() )
     {
     {
-            sTmp = m_manager->GetCommand ( verb, m_index[i] );
-            i ++;
+        sTmp = m_manager->GetCommand( verb, m_index[i] );
+        i++;
     }
 
     return wxFileType::ExpandCommand(sTmp, params);
 }
 
     }
 
     return wxFileType::ExpandCommand(sTmp, params);
 }
 
-bool wxFileTypeImpl::GetIcon(wxIcon *icon,
-                             wxString *iconFile /*= NULL */,
-                             int *iconIndex /*= NULL*/) const
-
+bool wxFileTypeImpl::GetIcon(wxIconLocation *iconLoc) const
 {
 {
-#if wxUSE_GUI
     wxString sTmp;
     size_t i = 0;
     wxString sTmp;
     size_t i = 0;
-    while ( (i < m_index.GetCount() ) && sTmp.IsEmpty() )
+    while ( (i < m_index.GetCount() ) && sTmp.empty() )
     {
         sTmp = m_manager->m_aIcons[m_index[i]];
     {
         sTmp = m_manager->m_aIcons[m_index[i]];
-        i ++;
+        i++;
     }
     }
-    if ( sTmp.IsEmpty () ) return FALSE;
 
 
-    wxIcon icn;
+    if ( sTmp.empty() )
+        return false;
 
 
-    if (sTmp.Right(4).MakeUpper() == _T(".XPM"))
-        icn = wxIcon(sTmp);
-    else
-        icn = wxIcon(sTmp, wxBITMAP_TYPE_ANY);
-
-    if ( icn.Ok() )
+    if ( iconLoc )
     {
     {
-        *icon = icn;
-        if (iconFile) *iconFile = sTmp;
-        if (iconIndex) *iconIndex = 0;
-        return TRUE;
+        iconLoc->SetFileName(sTmp);
     }
     }
-#endif // wxUSE_GUI
 
 
-    return FALSE;
+    return true;
 }
 
 }
 
-
-bool
-wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
+bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
 {
     mimeTypes.Clear();
 {
     mimeTypes.Clear();
-    for (size_t i = 0; i < m_index.GetCount(); i++)
+    size_t nCount = m_index.GetCount();
+    for (size_t i = 0; i < nCount; i++)
         mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);
         mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);
-    return TRUE;
-}
 
 
+    return true;
+}
 
 size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
                                   wxArrayString *commands,
                                   const wxFileType::MessageParameters& params) const
 {
 
 size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
                                   wxArrayString *commands,
                                   const wxFileType::MessageParameters& params) const
 {
-
     wxString vrb, cmd, sTmp;
     size_t count = 0;
     wxString vrb, cmd, sTmp;
     size_t count = 0;
-    wxMimeArrayString * sPairs;
+    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
 
     // 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++)
+    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;
     {
         // 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++ )
+        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() )
             {
             {
-                vrb = sPairs->GetVerb(i);
-                // some gnome entries have . inside
-                vrb = vrb.AfterLast(wxT('.'));
-                cmd = sPairs->GetCmd (i);
-                if (! cmd.IsEmpty() )
-                     {
-                     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);
-                         }
-                     }
-
+                 cmd = wxFileType::ExpandCommand(cmd, params);
+                 count++;
+                 if ( vrb.IsSameAs(wxT("open")))
+                 {
+                     if ( verbs )
+                        verbs->Insert(vrb, 0u);
+                     if ( commands )
+                        commands ->Insert(cmd, 0u);
+                 }
+                 else
+                 {
+                     if ( verbs )
+                        verbs->Add(vrb);
+                     if ( commands )
+                        commands->Add(cmd);
+                 }
+             }
         }
         }
-
     }
     }
-    return count;
 
 
+    return count;
 }
 
 bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
 {
 }
 
 bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
 {
-    wxString strExtensions = m_manager->GetExtension(m_index[0]);
+    const wxString strExtensions = m_manager->GetExtension(m_index[0]);
     extensions.Empty();
 
     extensions.Empty();
 
-    // one extension in the space or comma delimitid list
+    // one extension in the space or comma-delimited list
     wxString strExt;
     wxString strExt;
-    for ( const wxChar *p = strExtensions; ; p++ ) {
-        if ( *p == wxT(' ') || *p == wxT(',') || *p == wxT('\0') ) {
-            if ( !strExt.IsEmpty() ) {
+    wxString::const_iterator end = strExtensions.end();
+    for ( wxString::const_iterator p = strExtensions.begin(); /* nothing */; ++p )
+    {
+        if ( p == end || *p == wxT(' ') || *p == wxT(',') )
+        {
+            if ( !strExt.empty() )
+            {
                 extensions.Add(strExt);
                 strExt.Empty();
             }
                 extensions.Add(strExt);
                 strExt.Empty();
             }
-            //else: repeated spaces (shouldn't happen, but it's not that
-            //      important if it does happen)
+            //else: repeated spaces
+            // (shouldn't happen, but it's not that important if it does happen)
 
 
-            if ( *p == wxT('\0') )
+            if ( p == end )
                 break;
         }
                 break;
         }
-        else if ( *p == wxT('.') ) {
+        else if ( *p == wxT('.') )
+        {
             // remove the dot from extension (but only if it's the first char)
             // remove the dot from extension (but only if it's the first char)
-            if ( !strExt.IsEmpty() ) {
+            if ( !strExt.empty() )
+            {
                 strExt += wxT('.');
             }
             //else: no, don't append it
         }
                 strExt += wxT('.');
             }
             //else: no, don't append it
         }
-        else {
+        else
+        {
             strExt += *p;
         }
     }
 
             strExt += *p;
         }
     }
 
-    return TRUE;
+    return true;
 }
 
 }
 
-// set an arbitrary command,
+// set an arbitrary command:
 // could adjust the code to ask confirmation if it already exists and
 // could adjust the code to ask confirmation if it already exists and
-// overwriteprompt is TRUE, but this is currently ignored as *Associate* has
+// overwriteprompt is true, but this is currently ignored as *Associate* has
 // no overwrite prompt
 // no overwrite prompt
-bool wxFileTypeImpl::SetCommand(const wxString& cmd, const wxString& verb, bool overwriteprompt /*= TRUE*/)
-    {
+bool
+wxFileTypeImpl::SetCommand(const wxString& cmd,
+                           const wxString& verb,
+                           bool WXUNUSED(overwriteprompt))
+{
     wxArrayString strExtensions;
     wxArrayString strExtensions;
-    wxString strDesc, strIcon ;
-
-    wxMimeArrayString *entry = new wxMimeArrayString ();
-    entry->Add(verb + wxT("=")  + cmd + wxT(" %s "));
+    wxString strDesc, strIcon;
 
     wxArrayString strTypes;
 
     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;
-        }
+    GetMimeTypes(strTypes);
+    if ( strTypes.IsEmpty() )
+        return false;
 
 
-    return Ok;
-    }
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands();
+    entry->Add(verb + wxT("=")  + cmd + wxT(" %s "));
 
 
-// ignore index on the grouds that we only have one icon in a Unix file
-bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon /*= wxEmptyString*/, int /*index = 0*/)
+    bool ok = false;
+    size_t nCount = strTypes.GetCount();
+    for ( size_t i = 0; i < nCount; i++ )
     {
     {
-    if (strIcon.IsEmpty()) return FALSE;
-    wxArrayString strExtensions;
-    wxString strDesc;
-
-    wxMimeArrayString *entry = new wxMimeArrayString ();
-
-    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
+                        ) )
         {
         {
-        if (!m_manager->DoAssociation (strTypes[i], strIcon, entry, strExtensions, strDesc))
-        Ok = FALSE;
+            // DoAssociation() took ownership of entry, don't delete it below
+            ok = true;
         }
         }
-
-    return Ok;
     }
     }
-// ----------------------------------------------------------------------------
-// wxMimeTypesManagerImpl (Unix)
-// ----------------------------------------------------------------------------
 
 
+    if ( !ok )
+        delete entry;
 
 
-wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
-{
-    m_initialized = FALSE;
-    m_mailcapStylesInited = 0;
+    return ok;
 }
 
 }
 
-// read system and user mailcaps and other files
-void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
-                                        const wxString& sExtraDir)
+// ignore index on the grounds that we only have one icon in a Unix file
+bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int WXUNUSED(index))
 {
 {
-    // read mimecap amd mime.types
-    if ( (mailcapStyles & wxMAILCAP_NETSCAPE) ||
-         (mailcapStyles & wxMAILCAP_STANDARD) )
-        GetMimeInfo(sExtraDir);
+    if (strIcon.empty())
+        return false;
 
 
-    // read GNOME tables
-    if ( mailcapStyles & wxMAILCAP_GNOME)
-        GetGnomeMimeInfo(sExtraDir);
-
-    // read KDE tables
-    if ( mailcapStyles & wxMAILCAP_KDE)
-        GetKDEMimeInfo(sExtraDir);
-
-    m_mailcapStylesInited |= mailcapStyles;
-}
+    wxArrayString strExtensions;
+    wxString strDesc;
 
 
-// clear data so you can read another group of WM files
-void wxMimeTypesManagerImpl::ClearData()
-{
-    m_aTypes.Clear ();
-    m_aIcons.Clear ();
-    m_aExtensions.Clear ();
-    m_aDescriptions.Clear ();
+    wxArrayString strTypes;
+    GetMimeTypes(strTypes);
+    if ( strTypes.IsEmpty() )
+        return false;
 
 
-    size_t cnt = m_aTypes.GetCount();
-    for (size_t i = 0; i < cnt; i++)
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands();
+    bool ok = false;
+    size_t nCount = strTypes.GetCount();
+    for ( size_t i = 0; i < nCount; i++ )
     {
     {
-        m_aEntries[i]->Clear ();
+        if ( m_manager->DoAssociation
+                        (
+                            strTypes[i],
+                            strIcon,
+                            entry,
+                            strExtensions,
+                            strDesc
+                        ) )
+        {
+            // we don't need to free entry now, DoAssociation() took ownership
+            // of it
+            ok = true;
+        }
     }
     }
-    m_aEntries.Clear ();
-    m_mailcapStylesInited = 0;
-}
 
 
-wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl()
-{
-    ClearData(); // do we need to delete the ArrayStrings too to avoid a leak
+    if ( !ok )
+        delete entry;
 
 
-//    delete m_aEntries //fix a leak here ?;
+    return ok;
 }
 
 }
 
+// ----------------------------------------------------------------------------
+// wxMimeTypesManagerImpl (Unix)
+// ----------------------------------------------------------------------------
 
 
-void wxMimeTypesManagerImpl::GetMimeInfo (const wxString& sExtraDir)
+wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
 {
 {
-    // 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 ( wxT("/etc/") );
-    dirs.Add ( wxT("/usr/etc/") );
-    dirs.Add ( wxT("/usr/local/etc/") );
-    dirs.Add ( wxT("/etc/mail/") );
-    dirs.Add ( wxT("/usr/public/lib/") );
-    dirs.Add ( strHome + wxT("/.") );
-    if (!sExtraDir.IsEmpty()) 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);
-        }
-    }
-
+    m_initialized = false;
 }
 
 }
 
-bool wxMimeTypesManagerImpl::WriteToMimeTypes (int index, bool delete_index)
+void wxMimeTypesManagerImpl::InitIfNeeded()
 {
 {
-    // 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) )
-    {
-        bTemp =  file.Open(strUserMailcap);
-    }
-    else
-    {
-        if (delete_index) return FALSE;
-        bTemp = file.Create(strUserMailcap);
-    }
-    if (bTemp)
+    if ( !m_initialized )
     {
     {
-        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);
-        }
+        // set the flag first to prevent recursion
+        m_initialized = true;
 
 
+        wxString wm = wxTheApp->GetTraits()->GetDesktopEnvironment();
 
 
-        bTemp = file.Write ();
-        file.Close ();
-    }
-    return bTemp;
-}
-
-bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
-{
-    //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;
-        bTemp = file.Create(strUserMailcap);
-    }
-    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).IsEmpty() )
-        {
-            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 ();
+        if (wm == wxT("KDE"))
+            Initialize( wxMAILCAP_KDE  );
+        else if (wm == wxT("GNOME"))
+            Initialize( wxMAILCAP_GNOME );
+        else
+            Initialize();
     }
     }
-    return bTemp;
 }
 
 
 }
 
 
-bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
-{
-    //check we have the right managers
-    if ( !( ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) ||
-            ( m_mailcapStylesInited & wxMAILCAP_STANDARD) ) )
-        return FALSE;
 
 
-    bool bTemp;
-    wxString strHome = wxGetenv(wxT("HOME"));
+// read system and user mailcaps and other files
+void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
+                                        const wxString& sExtraDir)
+{
+#ifdef __VMS
+    // XDG tables are never installed on OpenVMS
+    return;
+#endif
 
 
-    // and now the users mailcap
-    wxString strUserMailcap = strHome + wxT("/.mailcap");
+    // Read MIME type - extension associations
+    LoadXDGGlobs( "/usr/share/mime/globs" );
+    LoadXDGGlobs( "/usr/local/share/mime/globs" );
 
 
-    wxMimeTextFile file;
-    if ( wxFile::Exists(strUserMailcap) )
-    {
-        bTemp =  file.Open(strUserMailcap);
-    }
-    else
-    {
-        if (delete_index) return FALSE;
-        bTemp = file.Create(strUserMailcap);
-    }
-    if (bTemp)
+    // Load desktop files for XDG, and then override them with the defaults.
+    // We will override them one desktop file at a time, rather
+    // than one mime type at a time, but it should be a reasonable
+    // heuristic.
     {
     {
-        // now got a file we can write to ....
-        wxMimeArrayString * entries = m_aEntries[index];
-        size_t iOpen = entries->pIndexOf(wxT("open"));
-        wxString sCmd = entries->GetCmd(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)
+        wxString xdgDataHome = wxGetenv("XDG_DATA_HOME");
+        if ( xdgDataHome.empty() )
+            xdgDataHome = wxGetHomeDir() + "/.local/share";
+        wxString xdgDataDirs = wxGetenv("XDG_DATA_DIRS");
+        if ( xdgDataDirs.empty() )
         {
         {
-            nIndex = (int) file.GetLineCount();
+            xdgDataDirs = "/usr/local/share:/usr/share";
+            if (mailcapStyles & wxMAILCAP_GNOME)
+                xdgDataDirs += ":/usr/share/gnome:/opt/gnome/share";
+            if (mailcapStyles & wxMAILCAP_KDE)
+                xdgDataDirs += ":/usr/share/kde3:/opt/kde3/share";
         }
         }
-        else
+        if ( !sExtraDir.empty() )
+        {
+           xdgDataDirs += ':';
+           xdgDataDirs += sExtraDir;
+        }
+
+        wxArrayString dirs;
+        wxStringTokenizer tokenizer(xdgDataDirs, ":");
+        while ( tokenizer.HasMoreTokens() )
         {
         {
-            sOld = file[nIndex];
-            wxLogTrace(TRACE_MIME, wxT("--- Deleting from mailcap line '%d' ---"), nIndex);
+            wxString p = tokenizer.GetNextToken();
+            dirs.Add(p);
+        }
+        dirs.insert(dirs.begin(), xdgDataHome);
 
 
-            while ( (sOld.Contains(wxT("\\"))) && (nIndex < (int) file.GetLineCount()) )
+        wxString defaultsList;
+        size_t i;
+        for (i = 0; i < dirs.GetCount(); i++)
+        {
+            wxString f = dirs[i];
+            if (f.Last() != '/') f += '/';
+            f += "applications/defaults.list";
+            if (wxFileExists(f))
             {
             {
-                file.CommentLine(nIndex);
-                if (nIndex < (int) file.GetLineCount()) sOld = sOld + file[nIndex];
+                defaultsList = f;
+                break;
             }
             }
-            if (nIndex < (int) file.GetLineCount()) file.CommentLine (nIndex);
         }
 
         }
 
-        sTmp = sTmp + wxT(";") + sCmd ; //includes wxT(" %s ");
-
-        // write it in the format that Netscape uses (default)
-        if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD  ) )
+        // Load application files and associate them to corresponding mime types.
+        size_t nDirs = dirs.GetCount();
+        for (size_t nDir = 0; nDir < nDirs; nDir++)
         {
         {
-            if (! delete_index) file.InsertLine (sTmp, nIndex);
-            nIndex ++;
+            wxString dirStr = dirs[nDir];
+            if (dirStr.Last() != '/') dirStr += '/';
+            dirStr += "applications";
+            LoadXDGAppsFilesFromDir(dirStr);
         }
 
         }
 
-        // write extended format
-        else
+        if (!defaultsList.IsEmpty())
         {
         {
-            // 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)
+            wxArrayString deskTopFilesSeen;
+
+            wxMimeTextFile textfile(defaultsList);
+            if ( textfile.Open() )
             {
             {
-                // first one mimetype; second one command, rest unknown...
-                wxString s;
-                s = sT.GetNextToken();
-                s = sT.GetNextToken();
-
-                // first unknown
-                s = sT.GetNextToken();
-                while ( ! s.IsEmpty() )
+                int nIndex = textfile.pIndexOf( wxT("[Default Applications]") );
+                if (nIndex != wxNOT_FOUND)
                 {
                 {
-                    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)
+                    for (i = nIndex+1; i < textfile.GetLineCount(); i++)
                     {
                     {
-                        sTmp = sTmp + wxT("; \\");
-                        file.InsertLine (sTmp, nIndex);
-                        sTmp = s;
+                        if (textfile.GetLine(i).Find(wxT("=")) != wxNOT_FOUND)
+                        {
+                            wxString mimeType = textfile.GetVerb(i);
+                            wxString desktopFile = textfile.GetCmd(i);
+
+                            if (deskTopFilesSeen.Index(desktopFile) == wxNOT_FOUND)
+                            {
+                                deskTopFilesSeen.Add(desktopFile);
+                                size_t j;
+                                for (j = 0; j < dirs.GetCount(); j++)
+                                {
+                                    wxString desktopPath = dirs[j];
+                                    if (desktopPath.Last() != '/') desktopPath += '/';
+                                    desktopPath += "applications/";
+                                    desktopPath += desktopFile;
+
+                                    if (wxFileExists(desktopPath))
+                                        LoadXDGApp(desktopPath);
+                                }
+                            }
+                        }
                     }
                     }
-                    s = sT.GetNextToken ();
                 }
                 }
-
             }
             }
+        }
+    }
+}
 
 
-            if (! m_aDescriptions[index].IsEmpty() )
-            {
-                sTmp = sTmp + wxT("; \\");
-                file.InsertLine (sTmp, nIndex);
-                nIndex ++;
-                sTmp = wxT("       description=\"") + m_aDescriptions[index] + wxT("\"");
-            }
-
-            if (! m_aIcons[index].IsEmpty() )
-            {
-                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->Item(i);
-                    }
-            }
+// clear data so you can read another group of WM files
+void wxMimeTypesManagerImpl::ClearData()
+{
+    m_aTypes.Clear();
+    m_aIcons.Clear();
+    m_aExtensions.Clear();
+    m_aDescriptions.Clear();
 
 
-            file.InsertLine (sTmp, nIndex);
-            nIndex ++;
+    WX_CLEAR_ARRAY(m_aEntries);
+    m_aEntries.Empty();
+}
 
 
-        }
-        bTemp = file.Write ();
-        file.Close ();
-    }
-    return bTemp;
+wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl()
+{
+    ClearData();
 }
 
 }
 
-wxFileType *
-wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
+wxFileType * wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
 {
     InitIfNeeded();
 
 {
     InitIfNeeded();
 
-    wxString strType = ftInfo.GetMimeType ();
-    wxString strDesc = ftInfo.GetDescription ();
-    wxString strIcon = ftInfo.GetIconFile ();
+    wxString strType = ftInfo.GetMimeType();
+    wxString strDesc = ftInfo.GetDescription();
+    wxString strIcon = ftInfo.GetIconFile();
 
 
-    wxMimeArrayString *entry = new wxMimeArrayString ();
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands();
 
 
-    if ( ! ftInfo.GetOpenCommand().IsEmpty())
-        entry->Add(wxT("open=")  + ftInfo.GetOpenCommand  () + wxT(" %s "));
-    if ( ! ftInfo.GetPrintCommand  ().IsEmpty())
-        entry->Add(wxT("print=") + ftInfo.GetPrintCommand () + wxT(" %s "));
+    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
 
     // now find where these extensions are in the data store and remove them
-    wxArrayString sA_Exts = ftInfo.GetExtensions ();
+    wxArrayString sA_Exts = ftInfo.GetExtensions();
     wxString sExt, sExtStore;
     size_t i, nIndex;
     wxString sExt, sExtStore;
     size_t i, nIndex;
-    for (i=0; i < sA_Exts.GetCount(); i++)
-        {
+    size_t nExtCount = sA_Exts.GetCount();
+    for (i=0; i < nExtCount; i++)
+    {
         sExt = sA_Exts.Item(i);
         sExt = sA_Exts.Item(i);
-        //clean up to just a space before and after
-        sExt.Trim().Trim(FALSE);
+
+        // clean up to just a space before and after
+        sExt.Trim().Trim(false);
         sExt = wxT(' ') + sExt + wxT(' ');
         sExt = wxT(' ') + sExt + wxT(' ');
-        for (nIndex = 0; nIndex < m_aExtensions.GetCount(); nIndex ++)
-            {
+        size_t nCount = m_aExtensions.GetCount();
+        for (nIndex = 0; nIndex < nCount; nIndex++)
+        {
             sExtStore = m_aExtensions.Item(nIndex);
             sExtStore = m_aExtensions.Item(nIndex);
-            if (sExtStore.Replace(sExt, wxT(" ") ) > 0) m_aExtensions.Item(nIndex) = sExtStore ;
-    }
-
+            if (sExtStore.Replace(sExt, wxT(" ") ) > 0)
+                m_aExtensions.Item(nIndex) = sExtStore;
+        }
     }
 
     }
 
-    if ( !DoAssociation (strType, strIcon, entry, sA_Exts, strDesc) )
+    if ( !DoAssociation(strType, strIcon, entry, sA_Exts, strDesc) )
         return NULL;
 
     return GetFileTypeFromMimeType(strType);
 }
 
         return NULL;
 
     return GetFileTypeFromMimeType(strType);
 }
 
-
 bool wxMimeTypesManagerImpl::DoAssociation(const wxString& strType,
                                            const wxString& strIcon,
 bool wxMimeTypesManagerImpl::DoAssociation(const wxString& strType,
                                            const wxString& strIcon,
-                                           wxMimeArrayString *entry,
+                                           wxMimeTypeCommands *entry,
                                            const wxArrayString& strExtensions,
                                            const wxString& strDesc)
 {
                                            const wxArrayString& strExtensions,
                                            const wxString& strDesc)
 {
-    int nIndex = AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, TRUE);
+    int nIndex = AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, true);
 
     if ( nIndex == wxNOT_FOUND )
 
     if ( nIndex == wxNOT_FOUND )
-        return FALSE;
-
-    return WriteMimeInfo (nIndex, FALSE);
-}
+        return false;
 
 
-bool wxMimeTypesManagerImpl::WriteMimeInfo(int nIndex, bool delete_mime )
-{
-    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)
-    {
-        // write in KDE format;
-        if (WriteKDEMimeFile (nIndex, delete_mime) )
-            ok = FALSE;
-    }
-
-    return ok;
+    return true;
 }
 
 int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType,
                                           const wxString& strIcon,
 }
 
 int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType,
                                           const wxString& strIcon,
-                                          wxMimeArrayString *entry,
+                                          wxMimeTypeCommands *entry,
                                           const wxArrayString& strExtensions,
                                           const wxString& strDesc,
                                           const wxArrayString& strExtensions,
                                           const wxString& strDesc,
-                                          bool ReplaceExisting)
+                                          bool replaceExisting)
 {
     InitIfNeeded();
 
 {
     InitIfNeeded();
 
-    wxLogTrace(TRACE_MIME, wxT("In Add to Mime data '%s' with %d entries and %d exts ---"),
-            strType.c_str(), entry->GetCount(), strExtensions.GetCount() );
-
     // ensure mimetype is always lower case
     // ensure mimetype is always lower case
-    wxString mimeType = strType;
-    mimeType.MakeLower();
+    wxString mimeType = strType.Lower();
+
+    // is this a known MIME type?
     int nIndex = m_aTypes.Index(mimeType);
     if ( nIndex == wxNOT_FOUND )
     {
         // new file type
         m_aTypes.Add(mimeType);
         m_aIcons.Add(strIcon);
     int nIndex = m_aTypes.Index(mimeType);
     if ( nIndex == wxNOT_FOUND )
     {
         // new file type
         m_aTypes.Add(mimeType);
         m_aIcons.Add(strIcon);
-        m_aEntries.Add(entry);
-        size_t i;
-        // change nIndex so we can add to the correct line
-        nIndex = m_aExtensions.Add(wxT(' '));
-        for (i = 0; i < strExtensions.GetCount(); i ++)
-        {
-            if (! m_aExtensions.Item(nIndex).Contains(wxT(' ') + strExtensions.Item(i) + wxT(' ')))
-                m_aExtensions.Item(nIndex) +=  strExtensions.Item(i) + wxT(' ');
-        }
-        m_aDescriptions.Add(strDesc);
+        m_aEntries.Add(entry ? entry : new wxMimeTypeCommands);
 
 
+        // change nIndex so we can use it below to add the extensions
+        m_aExtensions.Add(wxEmptyString);
+        nIndex = m_aExtensions.size() - 1;
+
+        m_aDescriptions.Add(strDesc);
     }
     }
-    else
+    else // yes, we already have it
     {
     {
-        // nIndex has the existing data
-        // always add the extensions to this mimetype
-        size_t i;
-        for (i = 0; i < strExtensions.GetCount(); i ++)
-        {
-            if (! m_aExtensions.Item(nIndex).Contains(wxT(' ') + strExtensions.Item(i) + wxT(' ')))
-                m_aExtensions.Item(nIndex) +=  strExtensions.Item(i) + wxT(' ');
-        }
-        if (ReplaceExisting)
+        if ( replaceExisting )
         {
             // if new description change it
         {
             // if new description change it
-            if ( ! strDesc.IsEmpty())
+            if ( !strDesc.empty())
                 m_aDescriptions[nIndex] = strDesc;
 
             // if new icon change it
                 m_aDescriptions[nIndex] = strDesc;
 
             // if new icon change it
-            if ( ! strIcon.IsEmpty())
+            if ( !strIcon.empty())
                 m_aIcons[nIndex] = strIcon;
 
                 m_aIcons[nIndex] = strIcon;
 
-            wxMimeArrayString *entryOld  =  m_aEntries[nIndex];
-            // replace any matching entries...
-            for (i=0; i < entry->GetCount(); i++)
-                entryOld->ReplaceOrAddLineCmd (entry->GetVerb(i),
-                        entry->GetCmd (i) );
+            if ( entry )
+            {
+                delete m_aEntries[nIndex];
+                m_aEntries[nIndex] = entry;
+            }
         }
         }
-        else
+        else // add data we don't already have ...
         {
         {
-            // add data we don't already have ...
             // if new description add only if none
             // if new description add only if none
-            if ( ! strDesc.IsEmpty() && m_aDescriptions.Item(i).IsEmpty() )
+            if ( m_aDescriptions[nIndex].empty() )
                 m_aDescriptions[nIndex] = strDesc;
 
             // if new icon and no existing icon
                 m_aDescriptions[nIndex] = strDesc;
 
             // if new icon and no existing icon
-            if ( ! strIcon.IsEmpty() && m_aIcons.Item(i). IsEmpty () )
+            if ( m_aIcons[nIndex].empty() )
                 m_aIcons[nIndex] = strIcon;
 
                 m_aIcons[nIndex] = strIcon;
 
-            wxMimeArrayString *entryOld  =  m_aEntries[nIndex];
             // add any new entries...
             // add any new entries...
-            for (i=0; i < entry->GetCount(); i++)
+            if ( entry )
             {
             {
-                wxString sVerb = entry->GetVerb(i);
-                if ( entryOld->pIndexOf ( sVerb ) == (size_t) wxNOT_FOUND )
-                    entryOld->Add (entry->Item(i));
+                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;
             }
         }
     }
 
             }
         }
     }
 
+    // always add the extensions to this mimetype
+    wxString& exts = m_aExtensions[nIndex];
+
+    // add all extensions we don't have yet
+    wxString ext;
+    size_t count = strExtensions.GetCount();
+    for ( size_t i = 0; i < count; i++ )
+    {
+        ext = strExtensions[i];
+        ext += wxT(' ');
+
+        if ( exts.Find(ext) == wxNOT_FOUND )
+        {
+            exts += ext;
+        }
+    }
+
     // check data integrity
     // 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() );
+    wxASSERT( m_aTypes.GetCount() == m_aEntries.GetCount() &&
+              m_aTypes.GetCount() == m_aExtensions.GetCount() &&
+              m_aTypes.GetCount() == m_aIcons.GetCount() &&
+              m_aTypes.GetCount() == m_aDescriptions.GetCount() );
 
     return nIndex;
 }
 
 
     return nIndex;
 }
 
-
-wxFileType *
-wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
+wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
 {
 {
-    if (ext.IsEmpty() )
+    if (ext.empty() )
         return NULL;
 
     InitIfNeeded();
 
         return NULL;
 
     InitIfNeeded();
 
-    wxFileType *fileType = NULL;
     size_t count = m_aExtensions.GetCount();
     for ( size_t n = 0; n < count; n++ )
     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(' '));
+    {
+        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
                 // found
-                if (fileType == NULL) fileType = new wxFileType;
+                wxFileType *fileType = new wxFileType;
                 fileType->m_impl->Init(this, n);
                 fileType->m_impl->Init(this, n);
-                     // adds this mime type to _list_ of mime types with this extension
+
+                return fileType;
             }
         }
     }
 
             }
         }
     }
 
-    return fileType;
+    return NULL;
 }
 
 }
 
-wxFileType *
-wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
+wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
 {
     InitIfNeeded();
 
 {
     InitIfNeeded();
 
@@ -1887,6 +845,7 @@ wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
 
     // first look for an exact match
     int index = m_aTypes.Index(mimetype);
 
     // first look for an exact match
     int index = m_aTypes.Index(mimetype);
+
     if ( index != wxNOT_FOUND )
     {
         fileType = new wxFileType;
     if ( index != wxNOT_FOUND )
     {
         fileType = new wxFileType;
@@ -1900,38 +859,45 @@ wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
     index = wxNOT_FOUND;
     wxString strCategory = mimetype.BeforeFirst(wxT('/'));
 
     index = wxNOT_FOUND;
     wxString strCategory = mimetype.BeforeFirst(wxT('/'));
 
-    size_t nCount = m_aTypes.Count();
-    for ( size_t n = 0; n < nCount; n++ ) {
+    size_t nCount = m_aTypes.GetCount();
+    for ( size_t n = 0; n < nCount; n++ )
+    {
         if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) &&
         if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) &&
-                m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") ) {
+                m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") )
+        {
             index = n;
             break;
         }
             index = n;
             break;
         }
-
     }
 
     if ( index != wxNOT_FOUND )
     {
     }
 
     if ( index != wxNOT_FOUND )
     {
-        fileType = new wxFileType;
+       // 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;
 }
 
     return fileType;
 }
 
-
 wxString wxMimeTypesManagerImpl::GetCommand(const wxString & verb, size_t nIndex) const
 {
     wxString command, testcmd, sV, sTmp;
     sV = verb + wxT("=");
 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
     // list of verb = command pairs for this mimetype
-    wxMimeArrayString * sPairs = m_aEntries [nIndex];
+    wxMimeTypeCommands * sPairs = m_aEntries [nIndex];
 
     size_t i;
 
     size_t i;
-    for ( i = 0; i < sPairs->GetCount () ; i++ )
+    size_t nCount = sPairs->GetCount();
+    for ( i = 0; i < nCount; i++ )
     {
     {
-        sTmp = sPairs->Item (i);
-        if ( sTmp.Contains(sV) ) command = sTmp.AfterFirst(wxT('='));
+        sTmp = sPairs->GetVerbCmd (i);
+        if ( sTmp.Contains(sV) )
+            command = sTmp.AfterFirst(wxT('='));
     }
     }
+
     return command;
 }
 
     return command;
 }
 
@@ -1942,22 +908,17 @@ void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype)
     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];
     }
 
     AddMimeTypeInfo(filetype.GetMimeType(),
                     extensions,
                     filetype.GetDescription());
         extensions += exts[nExt];
     }
 
     AddMimeTypeInfo(filetype.GetMimeType(),
                     extensions,
                     filetype.GetDescription());
-
-    AddMailcapInfo(filetype.GetMimeType(),
-                   filetype.GetOpenCommand(),
-                   filetype.GetPrintCommand(),
-                   wxT(""),
-                   filetype.GetDescription());
 }
 
 void wxMimeTypesManagerImpl::AddMimeTypeInfo(const wxString& strMimeType,
 }
 
 void wxMimeTypesManagerImpl::AddMimeTypeInfo(const wxString& strMimeType,
@@ -1969,519 +930,17 @@ void wxMimeTypesManagerImpl::AddMimeTypeInfo(const wxString& strMimeType,
     // this means all the get functions don't work  fix this
     wxString strIcon;
     wxString sTmp = strExtensions;
     // this means all the get functions don't work  fix this
     wxString strIcon;
     wxString sTmp = strExtensions;
-    wxMimeArrayString * entry = new wxMimeArrayString () ;
 
     wxArrayString sExts;
 
     wxArrayString sExts;
-    sTmp.Trim().Trim(FALSE);
+    sTmp.Trim().Trim(false);
 
 
-    while (!sTmp.IsEmpty())
+    while (!sTmp.empty())
     {
     {
-        sExts.Add (sTmp.AfterLast(wxT(' ')));
+        sExts.Add(sTmp.AfterLast(wxT(' ')));
         sTmp = sTmp.BeforeLast(wxT(' '));
     }
 
         sTmp = sTmp.BeforeLast(wxT(' '));
     }
 
-    AddToMimeData (strMimeType, strIcon, entry, sExts, strDesc, (bool)TRUE);
-}
-
-void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
-                                            const wxString& strOpenCmd,
-                                            const wxString& strPrintCmd,
-                                            const wxString& strTest,
-                                            const wxString& strDesc)
-{
-    InitIfNeeded();
-
-    wxMimeArrayString *entry = new wxMimeArrayString;
-    entry->Add(wxT("open=")  + strOpenCmd);
-    entry->Add(wxT("print=") + strPrintCmd);
-    entry->Add(wxT("test=")  + strTest);
-
-    wxString strIcon;
-    wxArrayString strExtensions;
-
-    AddToMimeData (strType, strIcon, entry, strExtensions, strDesc, TRUE);
-
-}
-
-bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
-{
-    wxLogTrace(TRACE_MIME, wxT("--- Parsing mime.types file '%s' ---"),
-               strFileName.c_str());
-
-    wxTextFile file(strFileName);
-    if ( !file.Open() )
-        return FALSE;
-
-    // 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 ) {
-            // now we're at the start of the line
-            pc = file[nLine].c_str();
-        }
-        else {
-            // we didn't finish with the previous line yet
-            nLine--;
-        }
-
-        // skip whitespace
-        while ( wxIsspace(*pc) )
-            pc++;
-
-        // comment or blank line?
-        if ( *pc == wxT('#') || !*pc ) {
-            // skip the whole line
-            pc = NULL;
-            continue;
-        }
-
-        // detect file format
-        const wxChar *pEqualSign = wxStrchr(pc, wxT('='));
-        if ( pEqualSign == NULL ) {
-            // brief format
-            // ------------
-
-            // first field is mime type
-            for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != wxT('\0'); pc++ ) {
-                strMimeType += *pc;
-            }
-
-            // skip whitespace
-            while ( wxIsspace(*pc) )
-                pc++;
-
-            // take all the rest of the string
-            strExtensions = pc;
-
-            // no description...
-            strDesc.Empty();
-        }
-        else {
-            // expanded format
-            // ---------------
-
-            // the string on the left of '=' is the field name
-            wxString strLHS(pc, pEqualSign - pc);
-
-            // eat whitespace
-            for ( pc = pEqualSign + 1; wxIsspace(*pc); pc++ )
-               ;
-
-            const wxChar *pEnd;
-            if ( *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."),
-                                 strFileName.c_str(), nLine + 1);
-                }
-            }
-            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
-            if ( *pEnd == wxT('"') ) {
-                // 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
-            bool entryEnded = *pc == wxT('\0'),
-                 nextFieldOnSameLine = FALSE;
-            if ( !entryEnded ) {
-                nextFieldOnSameLine = ((*pc != wxT('\\')) || (pc[1] != wxT('\0')));
-            }
-
-            // now see what we got
-            if ( strLHS == wxT("type") ) {
-                strMimeType = strRHS;
-            }
-            else if ( strLHS == wxT("desc") ) {
-                strDesc = strRHS;
-            }
-            else if ( strLHS == wxT("exts") ) {
-                strExtensions = strRHS;
-            }
-            else {
-                wxLogWarning(_("Unknown field in file %s, line %d: '%s'."),
-                             strFileName.c_str(), nLine + 1, strLHS.c_str());
-            }
-
-            if ( !entryEnded ) {
-                if ( !nextFieldOnSameLine )
-                    pc = NULL;
-                //else: don't reset it
-
-                // as we don't reset strMimeType, the next field in this entry
-                // will be interpreted correctly.
-
-                continue;
-            }
-        }
-
-        // 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
-        if ( !strExtensions.IsEmpty() && strExtensions[0u] == wxT('.') )
-        {
-            strExtensions.erase(0, 1);
-        }
-
-    wxLogTrace(TRACE_MIME, wxT("--- Found Mimetype '%s' ---"),
-               strMimeType.c_str());
-
-        AddMimeTypeInfo(strMimeType, strExtensions, strDesc);
-
-        // finished with this line
-        pc = NULL;
-    }
-
-    return TRUE;
-}
-
-bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
-                                         bool fallback)
-{
-//    wxLog::AddTraceMask (TRACE_MIME);
-    wxLogTrace(TRACE_MIME, wxT("--- Parsing mailcap file '%s' ---"),
-               strFileName.c_str());
-
-    wxTextFile file(strFileName);
-    if ( !file.Open() )
-        return FALSE;
-
-    // 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;
-
-    size_t nLineCount = file.GetLineCount();
-    for ( size_t nLine = 0; nLine < nLineCount; nLine++ ) {
-        // now we're at the start of the line
-        const wxChar *pc = file[nLine].c_str();
-
-        // skip whitespace
-        while ( wxIsspace(*pc) )
-            pc++;
-
-        // comment or empty string?
-        if ( *pc == wxT('#') || *pc == wxT('\0') )
-            continue;
-
-        // no, do parse
-
-        // 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...
-        enum
-        {
-            Field_Type,
-            Field_OpenCmd,
-            Field_Other
-        } currentToken = Field_Type;
-
-        // the flags and field values on the current line
-        bool needsterminal = FALSE,
-             copiousoutput = FALSE;
-        wxMimeArrayString *entry = NULL; // suppress compiler warning
-
-        wxString strType,
-                 strOpenCmd,
-                 strIcon,
-                 strTest,
-                 strDesc,
-                 curField; // accumulator
-        bool cont = TRUE;
-        bool test_passed = TRUE;
-        while ( cont ) {
-            switch ( *pc ) {
-                case wxT('\\'):
-                    // interpret the next character literally (notice that
-                    // backslash can be used for line continuation)
-                    if ( *++pc == wxT('\0') ) {
-                        // fetch the next line if there is one
-                        if ( nLine == nLineCount - 1 ) {
-                            // something is wrong, bail out
-                            cont = FALSE;
-
-                            wxLogDebug(wxT("Mailcap file %s, line %d: "
-                                           "'\\' on the end of the last line "
-                                           "ignored."),
-                                       strFileName.c_str(),
-                                       nLine + 1);
-                        }
-                        else {
-                            // pass to the beginning of the next line
-                            pc = file[++nLine].c_str();
-
-                            // skip pc++ at the end of the loop
-                            continue;
-                        }
-                    }
-                    else {
-                        // just a normal character
-                        curField += *pc;
-                    }
-                    break;
-
-                case wxT('\0'):
-                    cont = FALSE;   // end of line reached, exit the loop
-
-                    // fall through
-
-                case wxT(';'):
-                    // store this field and start looking for the next one
-
-                    // trim whitespaces from both sides
-                    curField.Trim(TRUE).Trim(FALSE);
-
-                    switch ( currentToken ) {
-                        case Field_Type:
-                            strType = curField;
-                            if ( strType.empty() ) {
-                                // I don't think that this is a valid mailcap
-                                // entry, but try to interpret it somehow
-                                strType = _T('*');
-                            }
-
-                            if ( strType.Find(wxT('/')) == wxNOT_FOUND ) {
-                                // we interpret "type" as "type/*"
-                                strType += wxT("/*");
-                            }
-
-                            currentToken = Field_OpenCmd;
-                            break;
-
-                        case Field_OpenCmd:
-                            strOpenCmd = curField;
-                            entry = new wxMimeArrayString ();
-                            entry->Add(wxT("open=")  + strOpenCmd);
-
-                            currentToken = Field_Other;
-                            break;
-
-                        case Field_Other:
-                            if ( !curField.empty() ) {
-                                // "good" mailcap entry?
-                                bool ok = TRUE;
-
-                                if ( IsKnownUnimportantField(curField) ) ok = FALSE;
-
-                                // is this something of the form foo=bar?
-                                const wxChar *pEq = wxStrchr(curField, wxT('='));
-                                if (ok)
-                                {
-                                if ( pEq != NULL )
-                                    {
-                                    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[0u] == wxT('"') && rhs.Last() == wxT('"') )
-                                        {
-                                        wxString sTmp = wxString(rhs.c_str() + 1, rhs.Len() - 2);
-                                        rhs = sTmp;
-                                        }
-                                    bool verbfound = TRUE;
-                                    if ( lhs.Contains (wxT("test")))
-                                        {
-                                        if ( ! rhs.IsEmpty() )
-                                            {
-                                            if ( wxSystem(rhs) == 0 ) {
-                                                // ok, test passed
-                                                test_passed = TRUE;
-                                                wxLogTrace(TRACE_MIME,
-                                                           wxT("Test '%s' for mime type '%s' succeeded."),
-                                                           rhs.c_str(), strType.c_str());
-
-                                        }
-                                        else {
-                                                test_passed = FALSE;
-                                                wxLogTrace(TRACE_MIME,
-                                                           wxT("Test '%s' for mime type '%s' failed."),
-                                                           rhs.c_str(), strType.c_str());
-                                            }
-                                        }
-                                        verbfound = FALSE;
-                                        }
-                                    if ( lhs.Contains (wxT("desc")))
-                                        {
-                                            strDesc = rhs;
-                                        verbfound = FALSE;
-                                        }
-                                    if ( lhs.Contains (wxT("x11-bitmap")))
-                                        {
-                                        strIcon = rhs;
-                                        verbfound = FALSE;
-                                    }
-                                    if ( lhs.Contains (wxT("notes")))
-                                        {
-                                        // ignore
-                                        verbfound = FALSE;
-                                }
-                                    if (verbfound) entry->Add ( lhs + wxT('=') + rhs );
-                                    ok = TRUE;
-                                    }
-                                  else
-                                    {
-                                    // no, it's a simple flag
-                                        if ( curField == wxT("needsterminal") ) {
-                                        needsterminal = TRUE;
-                                            ok = TRUE;
-                                            }
-                                        if ( curField == wxT("copiousoutput")) {
-                                        // copiousoutput impies that the
-                                        // viewer is a console program
-                                        needsterminal =
-                                            copiousoutput =
-                                            ok = TRUE;
-
-                                if ( !ok )
-                                {
-                                        // 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()
-                                        );
-
-                                            }
-
-                                        }
-
-                                    }
-
-                                }
-
-                            }
-
-
-                            // it already has this value
-                            //currentToken = Field_Other;
-                            break;
-
-                        default:
-                            wxFAIL_MSG(wxT("unknown field type in mailcap"));
-                    }
-
-                    // next token starts immediately after ';'
-                    curField.Empty();
-                    break;
-
-                default:
-                    curField += *pc;
-            }
-
-            // continue in the same line
-            pc++;
-        }
-
-        // check that we really read something reasonable
-        if ( currentToken == Field_Type || currentToken == Field_OpenCmd ) {
-            wxLogWarning(_("Mailcap file %s, line %d: incomplete entry "
-                           "ignored."),
-                         strFileName.c_str(), nLine + 1);
-        }
-        else {
-            // support for flags:
-            //  1. create an xterm for 'needsterminal'
-            //  2. append "| $PAGER" for 'copiousoutput'
-            //
-            // Note that the RFC says that having both needsterminal and
-            // copiousoutput is probably a mistake, so it seems that running
-            // programs with copiousoutput inside an xterm as it is done now
-            // is a bad idea (FIXME)
-            if ( copiousoutput )
-               {
-                const wxChar *p = wxGetenv(_T("PAGER"));
-                strOpenCmd << _T(" | ") << (p ? p : _T("more"));
-                wxLogTrace(TRACE_MIME, wxT("Replacing .(for pager)...") + entry->Item(0u) + wxT("with") + strOpenCmd );
-
-                entry->ReplaceOrAddLineCmd (wxString(wxT("open")), strOpenCmd );
-            }
-
-            if ( needsterminal )
-            {
-                strOpenCmd.Printf(_T("xterm -e sh -c '%s'"), strOpenCmd.c_str());
-                wxLogTrace(TRACE_MIME, wxT("Replacing .(for needs term)...") + entry->Item(0u) + wxT("with") + strOpenCmd );
-
-                entry->ReplaceOrAddLineCmd (wxString(wxT("open")), strOpenCmd );
-            }
-
-            // NB: because of complications below (we must get entries priority
-            //     right), we can't use AddMailcapInfo() here, unfortunately.
-            if ( test_passed )
-                {
-            strType.MakeLower();
-                bool overwrite = TRUE;
-                int entryIndex ;
-                if (fallback)
-                    overwrite = FALSE;
-                    else
-                    {
-                    int nIndex = m_aTypes.Index(strType);
-                    entryIndex = aEntryIndices.Index(nIndex);
-                    if ( entryIndex == wxNOT_FOUND )
-                       {
-      //check this fix
-                        // first time in this file, so replace the icons, entries
-                        // and description (no extensions to replace so ignore these
-                        overwrite = TRUE;
-                        aEntryIndices.Add(nIndex);
-                        //aLastIndices.Add(0);
-                    }
-                    else {
-                        // not the first time in _this_ file
-                        // so we don't want to overwrite
-                        // existing entries,but want to add to them
-                        // so we don't alter the mimetype
-                        // the indices were shifted by 1
-                        overwrite = FALSE;
-                }
-
-
-                }
-                wxArrayString strExtensions;
-                AddToMimeData (strType, strIcon, entry, strExtensions, strDesc, !overwrite );
-                test_passed = TRUE;
-            }
-        }
-
-    }
-
-    return TRUE;
+    AddToMimeData(strMimeType, strIcon, NULL, sExts, strDesc, true);
 }
 
 size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 }
 
 size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
@@ -2490,13 +949,12 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 
     mimetypes.Empty();
 
 
     mimetypes.Empty();
 
-    wxString type;
     size_t count = m_aTypes.GetCount();
     for ( size_t n = 0; n < count; n++ )
     {
         // don't return template types from here (i.e. anything containg '*')
     size_t count = m_aTypes.GetCount();
     for ( size_t n = 0; n < count; n++ )
     {
         // don't return template types from here (i.e. anything containg '*')
-        type = m_aTypes[n];
-        if ( type.Find(_T('*')) == wxNOT_FOUND )
+        const wxString &type = m_aTypes[n];
+        if ( type.Find(wxT('*')) == wxNOT_FOUND )
         {
             mimetypes.Add(type);
         }
         {
             mimetypes.Add(type);
         }
@@ -2511,62 +969,39 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 
 bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
 {
 
 bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
 {
+    InitIfNeeded();
+
     wxArrayString sMimeTypes;
     wxArrayString sMimeTypes;
-    ft->GetMimeTypes (sMimeTypes);
+    ft->GetMimeTypes(sMimeTypes);
 
 
-    wxString sMime;
     size_t i;
     size_t i;
-    for (i = 0; i < sMimeTypes.GetCount(); i ++)
+    size_t nCount = sMimeTypes.GetCount();
+    for (i = 0; i < nCount; i ++)
     {
     {
-        sMime = sMimeTypes.Item(i);
-        int nIndex = m_aTypes.Index (sMime);
+        const wxString &sMime = sMimeTypes.Item(i);
+        int nIndex = m_aTypes.Index(sMime);
         if ( nIndex == wxNOT_FOUND)
         {
             // error if we get here ??
         if ( nIndex == wxNOT_FOUND)
         {
             // error if we get here ??
-            return FALSE;
+            return false;
         }
         else
         {
         }
         else
         {
-            WriteMimeInfo(nIndex, TRUE );
-            m_aTypes.Remove (nIndex);
-            m_aEntries.Remove (nIndex);
-            m_aExtensions.Remove (nIndex);
-            m_aDescriptions.Remove (nIndex);
-            m_aIcons.Remove (nIndex);
+            m_aTypes.RemoveAt(nIndex);
+            m_aEntries.RemoveAt(nIndex);
+            m_aExtensions.RemoveAt(nIndex);
+            m_aDescriptions.RemoveAt(nIndex);
+            m_aIcons.RemoveAt(nIndex);
         }
     }
     // check data integrity
         }
     }
     // 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[] =
-    {
-        _T("x-mozilla-flags"),
-        _T("nametemplate"),
-        _T("textualnewlines"),
-    };
+    wxASSERT( m_aTypes.GetCount() == m_aEntries.GetCount() &&
+            m_aTypes.GetCount() == m_aExtensions.GetCount() &&
+            m_aTypes.GetCount() == m_aIcons.GetCount() &&
+            m_aTypes.GetCount() == m_aDescriptions.GetCount() );
 
 
-    wxString field = fieldAll.BeforeFirst(_T('='));
-    for ( size_t n = 0; n < WXSIZEOF(knownFields); n++ )
-    {
-        if ( field.CmpNoCase(knownFields[n]) == 0 )
-            return TRUE;
-    }
-
-    return FALSE;
+    return true;
 }
 
 #endif
 }
 
 #endif
-  // wxUSE_FILE && wxUSE_TEXTFILE
-
+  // wxUSE_MIMETYPE && wxUSE_FILE