avoid trying to link QA if not required

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

diff --git a/src/unix/mimetype.cpp b/src/unix/mimetype.cpp
index eda69158e70084e1a494c359a5623c4d3c235eec..e0bce49d8d4c0d12a8782bd71a9a28620294beb6 100644 (file)
--- a/src/unix/mimetype.cpp
+++ b/src/unix/mimetype.cpp
@@ -1,4 +1,3 @@
-

 /////////////////////////////////////////////////////////////////////////////
 // Name:        unix/mimetype.cpp
 // Purpose:     classes and functions to manage MIME types
 /////////////////////////////////////////////////////////////////////////////
 // Name:        unix/mimetype.cpp
 // Purpose:     classes and functions to manage MIME types


@@ -7,7 +6,7 @@
 // Created:     23.09.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     23.09.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

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

 /////////////////////////////////////////////////////////////////////////////
 
 // known bugs; there may be others!! chris elliott, biol75@york.ac.uk 27 Mar 01
 /////////////////////////////////////////////////////////////////////////////
 
 // known bugs; there may be others!! chris elliott, biol75@york.ac.uk 27 Mar 01


@@ -26,7 +25,12 @@
 //    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
 //    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
+// 9) KDE does not yet handle multiple actions; Netscape mode never will
+
+/*
+    TODO: this file is a mess, we need to split it and reformet/review
+          everything (VZ)
+ */

 
 // ============================================================================
 // declarations
 
 // ============================================================================
 // declarations


@@ -36,10 +40,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "mimetype.h"
-#endif
-

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


@@ -51,14 +51,10 @@
   #include "wx/defs.h"
 #endif
 
   #include "wx/defs.h"
 #endif
 

-#if wxUSE_FILE && wxUSE_TEXTFILE
+#if wxUSE_MIMETYPE && wxUSE_FILE && wxUSE_TEXTFILE

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

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

 #endif //WX_PRECOMP
 
 
 #endif //WX_PRECOMP
 
 


@@ -73,6 +69,8 @@
 #include "wx/dir.h"
 #include "wx/utils.h"
 #include "wx/tokenzr.h"
 #include "wx/dir.h"
 #include "wx/utils.h"
 #include "wx/tokenzr.h"

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

 
 #include "wx/unix/mimetype.h"
 
 
 #include "wx/unix/mimetype.h"
 


@@ -84,57 +82,78 @@
 # pragma message disable unscomzer
 #endif
 
 # pragma message disable unscomzer
 #endif
 

-// this is a class to extend wxArrayString...
-class wxMimeArrayString : public wxArrayString
+// wxMimeTypeCommands stores the verbs defined for the given MIME type with
+// their values
+class wxMimeTypeCommands

 {
 public:
 {
 public:

-    wxMimeArrayString ()
+    wxMimeTypeCommands() { }
+
+    wxMimeTypeCommands(const wxArrayString& verbs,
+                       const wxArrayString& commands)
+        : m_verbs(verbs),
+          m_commands(commands)

     {
     {

-        wxArrayString ();

     }
 
     }
 

-    size_t pIndexOf (const wxString & verb)
+    // add a new verb with the command or replace the old value
+    void AddOrReplaceVerb(const wxString& verb, const wxString& cmd)

     {
     {

-        size_t i = 0;
-        wxString sTmp = verb;
-        // avoid a problem with modifying const parameter
-        sTmp.MakeLower();
-        while ( (i < GetCount()) && (! Item(i).MakeLower().Contains(sTmp)) )
+        int n = m_verbs.Index(verb, false /* ignore case */);
+        if ( n == wxNOT_FOUND )

         {
         {

-            i++;
+            m_verbs.Add(verb);
+            m_commands.Add(cmd);
+        }
+        else
+        {
+            m_commands[n] = cmd;

         }
         }

-        if ( i==GetCount() ) i = (size_t)wxNOT_FOUND;
-        return i;

     }
 
     }
 

-    bool ReplaceOrAddLineCmd (const wxString verb, const wxString & cmd)
+    void Add(const wxString& s)

     {
     {

-        size_t nIndex = pIndexOf (verb);
-        if (nIndex == (size_t)wxNOT_FOUND)
-            Add(verb + wxT("=") + cmd);
-        else
-            Item(nIndex) = verb + wxT("=") + cmd;
-        return TRUE;
+        m_verbs.Add(s.BeforeFirst(_T('=')));
+        m_commands.Add(s.AfterFirst(_T('=')));

     }
 
     }
 

-    wxString GetVerb (size_t i)
+    // access the commands
+    size_t GetCount() const { return m_verbs.GetCount(); }
+    const wxString& GetVerb(size_t n) const { return m_verbs[n]; }
+    const wxString& GetCmd(size_t n) const { return m_commands[n]; }
+
+    bool HasVerb(const wxString& verb) const
+        { return m_verbs.Index(verb) != wxNOT_FOUND; }
+
+    wxString GetCommandForVerb(const wxString& verb, size_t *idx = NULL) const

     {
     {

-        if (i < 0) return wxEmptyString;
-        if (i > GetCount() ) return wxEmptyString;
-        wxString sTmp = Item(i).BeforeFirst(wxT('='));
-        return sTmp;
+        wxString s;
+
+        int n = m_verbs.Index(verb);
+        if ( n != wxNOT_FOUND )
+        {
+            s = m_commands[(size_t)n];
+            if ( idx )
+                *idx = n;
+        }
+
+        return s;

     }
 
     }
 

-    wxString GetCmd (size_t i)
+    // get a "verb=command" string
+    wxString GetVerbCmd(size_t n) const

     {
     {

-        if (i < 0) return wxEmptyString;
-        if (i > GetCount() ) return wxEmptyString;
-        wxString sTmp = Item(i).AfterFirst(wxT('='));
-        return sTmp;
+        return m_verbs[n] + _T('=') + m_commands[n];

     }
     }

+
+private:
+    wxArrayString m_verbs,
+                  m_commands;

 };
 
 };
 

-//this class extends wxTextFile
+// this class extends wxTextFile
+//
+// VZ: ???

 class wxMimeTextFile : public wxTextFile
 {
 public:
 class wxMimeTextFile : public wxTextFile
 {
 public:


@@ -142,7 +161,7 @@ public:
     wxMimeTextFile () : wxTextFile () {};
     wxMimeTextFile (const wxString& strFile) : wxTextFile (strFile)  {  };
 
     wxMimeTextFile () : wxTextFile () {};
     wxMimeTextFile (const wxString& strFile) : wxTextFile (strFile)  {  };
 

-    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;
     {
         size_t i = iStart;
         int nResult = wxNOT_FOUND;


@@ -180,24 +199,23 @@ public:
 
     bool CommentLine(int nIndex)
     {
 
     bool CommentLine(int nIndex)
     {

-        if (nIndex <0) return FALSE;
-        if (nIndex >= (int)GetLineCount() ) return FALSE;
+        if (nIndex <0) return false;
+        if (nIndex >= (int)GetLineCount() ) return false;

         GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
         GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));

-        return TRUE;
+        return true;

     }
 
     bool CommentLine(const wxString & sTest)
     {
         int nIndex = pIndexOf(sTest);
     }
 
     bool CommentLine(const wxString & sTest)
     {
         int nIndex = pIndexOf(sTest);

-        if (nIndex <0) return FALSE;
-        if (nIndex >= (int)GetLineCount() ) return FALSE;
+        if (nIndex <0) return false;
+        if (nIndex >= (int)GetLineCount() ) return false;

         GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
         GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));

-        return TRUE;
+        return true;

     }
 
     wxString GetVerb (size_t i)
     {
     }
 
     wxString GetVerb (size_t i)
     {

-        if (i < 0) return wxEmptyString;

         if (i > GetLineCount() ) return wxEmptyString;
         wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
         return sTmp;
         if (i > GetLineCount() ) return wxEmptyString;
         wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
         return sTmp;


@@ -205,7 +223,6 @@ public:
 
     wxString GetCmd (size_t i)
     {
 
     wxString GetCmd (size_t i)
     {

-        if (i < 0) return wxEmptyString;

         if (i > GetLineCount() ) return wxEmptyString;
         wxString sTmp = GetLine(i).AfterFirst(wxT('='));
         return sTmp;
         if (i > GetLineCount() ) return wxEmptyString;
         wxString sTmp = GetLine(i).AfterFirst(wxT('='));
         return sTmp;


@@ -222,6 +239,9 @@ class WXDLLEXPORT wxIcon;
 // MIME code tracing mask
 #define TRACE_MIME _T("mime")
 
 // MIME code tracing mask
 #define TRACE_MIME _T("mime")
 

+// give trace messages about the results of mailcap tests
+#define TRACE_MIME_TEST _T("mimetest")
+

 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------


@@ -236,7 +256,6 @@ static bool IsKnownUnimportantField(const wxString& field);
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 
 

-

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


@@ -299,10 +318,13 @@ static bool IsKnownUnimportantField(const wxString& field);
 //  a) for "brief" format:
 //      <mime type>  <space separated list of extensions>
 //  b) for "expanded" format:
 //  a) for "brief" format:
 //      <mime type>  <space separated list of extensions>
 //  b) for "expanded" format:

-//      type=<mime type> \ 
-//      desc="<description>" \ 
+//      type=<mime type> BACKSLASH
+//      desc="<description>" BACKSLASH

 //      exts="<comma separated list of extensions>"
 //
 //      exts="<comma separated list of extensions>"
 //

+// (where BACKSLASH is a literal '\\' which we can't put here because cpp
+// misinterprets it)
+//

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


@@ -332,159 +354,167 @@ static bool IsKnownUnimportantField(const wxString& field);
 
 
 bool wxMimeTypesManagerImpl::CheckGnomeDirsExist ()
 
 
 bool wxMimeTypesManagerImpl::CheckGnomeDirsExist ()

-    {
+{

     wxString gnomedir;
     wxGetHomeDir( &gnomedir );
     wxString sTmp = gnomedir;
     wxString gnomedir;
     wxGetHomeDir( &gnomedir );
     wxString sTmp = gnomedir;

-    sTmp = sTmp + "/.gnome" ;
+    sTmp = sTmp + wxT("/.gnome");

     if (! wxDir::Exists ( sTmp ) )
     if (! wxDir::Exists ( sTmp ) )

-        {
+    {

         if (!wxMkdir ( sTmp ))
         if (!wxMkdir ( sTmp ))

-            {
-            wxFAIL_MSG (wxString ("Failed to create directory\n.gnome in \nCheckGnomeDirsExist") + sTmp );
-            return FALSE;
-            }
+        {
+            wxLogError(_("Failed to create directory %s/.gnome."), sTmp.c_str());
+            return false;

         }
         }

-    sTmp = sTmp + "/mime-info";
+    }
+    sTmp = sTmp + wxT("/mime-info");

     if (! wxDir::Exists ( sTmp ) )
     if (! wxDir::Exists ( sTmp ) )

-        {
+    {

         if (!wxMkdir ( sTmp ))
         {
         if (!wxMkdir ( sTmp ))
         {

-            wxFAIL_MSG (wxString ("Failed to create directory\nmime-info in \nCheckGnomeDirsExist") + sTmp );
-            return FALSE;
+            wxLogError(_("Failed to create directory %s/mime-info."), sTmp.c_str());
+            return false;

         }
     }
         }
     }

-    return TRUE;
+    return true;

 
 }
 
 
 
 bool wxMimeTypesManagerImpl::WriteGnomeKeyFile(int index, bool delete_index)
 
 }
 
 
 
 bool wxMimeTypesManagerImpl::WriteGnomeKeyFile(int index, bool delete_index)

-                {
+{

     wxString gnomedir;
     wxGetHomeDir( &gnomedir );
 
     wxString gnomedir;
     wxGetHomeDir( &gnomedir );
 

-    wxMimeTextFile outfile ( gnomedir + "/.gnome/mime-info/user.keys");
+    wxMimeTextFile outfile ( gnomedir + wxT("/.gnome/mime-info/user.keys"));

     // if this fails probably Gnome is not installed ??
     // create it anyway as a private mime store
 
     // if this fails probably Gnome is not installed ??
     // create it anyway as a private mime store
 

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

     if (! outfile.Open () )
     if (! outfile.Open () )

+#endif

     {
     {

-        if (delete_index) return FALSE;
-        if (!CheckGnomeDirsExist() ) return FALSE;
+        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.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");
         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);
+        wxMimeTypeCommands * entries = m_aEntries[index];
+        size_t count = entries->GetCount();
+        for ( size_t i = 0; i < count; i++ )
+        {
+            sTmp = entries->GetVerbCmd(i);

             sTmp.Replace( wxT("%s"), wxT("%f") );
             sTmp = wxT ( "\t") + sTmp;
             outfile.AddLine ( sTmp );
             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] );
         //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;
+    }
+    else
+    {
+        if (delete_index)
+            outfile.CommentLine(nIndex);
+
+        wxMimeTypeCommands sOld;

         size_t nOld = nIndex + 1;
         size_t nOld = nIndex + 1;

-        bool oldEntryEnd = FALSE;
-        while ( (nOld < outfile.GetLineCount() )&& (oldEntryEnd == FALSE ))
-            {
+        bool oldEntryEnd = false;
+        while ( (nOld < outfile.GetLineCount() )&& (!oldEntryEnd))
+        {

             sTmp = outfile.GetLine(nOld);
             if ( (sTmp[0u] == wxT('\t')) || (sTmp[0u] == wxT('#')) )
             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
                 // 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;
+                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)
         // 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];
+        {
+            wxMimeTypeCommands * entries = m_aEntries[index];

             size_t i;
             for (i=0; i < entries->GetCount(); i++)
             size_t i;
             for (i=0; i < entries->GetCount(); i++)

-                {
+            {

                 // replace any entries in sold that match verbs we know
                 // replace any entries in sold that match verbs we know

-                sOld.ReplaceOrAddLineCmd ( entries->GetVerb(i), entries->GetCmd (i) );
+                sOld.AddOrReplaceVerb ( entries->GetVerb(i), entries->GetCmd (i) );

             }
             //sOld should also contain the icon
             }
             //sOld should also contain the icon

-            if ( !m_aIcons[index].IsEmpty() )
-                sOld.ReplaceOrAddLineCmd ( wxT( "icon-filename"), m_aIcons[index] );
+            if ( !m_aIcons[index].empty() )
+                sOld.AddOrReplaceVerb ( wxT("icon-filename"), m_aIcons[index] );

 
             for (i=0; i < sOld.GetCount(); i++)
 
             for (i=0; i < sOld.GetCount(); i++)

-                {
-                sTmp = sOld.Item(i);
+            {
+                sTmp = sOld.GetVerbCmd(i);

                 sTmp.Replace( wxT("%s"), wxT("%f") );
                 sTmp.Replace( wxT("%s"), wxT("%f") );

-                sTmp = wxT ( "\t") + sTmp;
+                sTmp = wxT("\t") + sTmp;

                 nIndex ++;
                 outfile.InsertLine ( sTmp, nIndex );
                 nIndex ++;
                 outfile.InsertLine ( sTmp, nIndex );

-                }

             }
         }
             }
         }

+    }

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

-        }
+}

 
 
 bool wxMimeTypesManagerImpl::WriteGnomeMimeFile(int index, bool delete_index)
 
 
 bool wxMimeTypesManagerImpl::WriteGnomeMimeFile(int index, bool delete_index)

-                {
+{

     wxString gnomedir;
     wxGetHomeDir( &gnomedir );
 
     wxString gnomedir;
     wxGetHomeDir( &gnomedir );
 

-    wxMimeTextFile outfile ( gnomedir + "/.gnome/mime-info/user.mime");
+    wxMimeTextFile outfile ( gnomedir + wxT("/.gnome/mime-info/user.mime"));

     // if this fails probably Gnome is not installed ??
     // create it anyway as a private mime store
     if (! outfile.Open () )
     {
     // if 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;
+        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.Create ();
     }
     wxString strType = m_aTypes[index];
     int nIndex = outfile.pIndexOf(strType);
     if ( nIndex == wxNOT_FOUND )

-            {
+    {

         outfile.AddLine ( strType );
         outfile.AddLine ( strType );

-        outfile.AddLine ( wxT( "\text:") + m_aExtensions.Item(index) );
-            }
+        outfile.AddLine ( wxT("\text:") + m_aExtensions.Item(index) );
+    }

     else
     else

-        {
+    {

         if (delete_index)
         if (delete_index)

-            {
+        {

             outfile.CommentLine(nIndex);
             outfile.CommentLine(nIndex+1);
         }
         else
             outfile.CommentLine(nIndex);
             outfile.CommentLine(nIndex+1);
         }
         else

-            {// check for next line being the right one to replace ??
+        {// check for next line being the right one to replace ??

             wxString sOld = outfile.GetLine(nIndex+1);
             wxString sOld = outfile.GetLine(nIndex+1);

-            if (sOld.Contains(wxT("\text: ")))
-        {
-                outfile.GetLine(nIndex+1) = wxT( "\text: ") + m_aExtensions.Item(index);
-                }
+            if (sOld.Contains( wxT("\text: ")))
+            {
+                outfile.GetLine(nIndex+1) = wxT("\text: ") + m_aExtensions.Item(index);
+            }

             else
             {
             else
             {

-                outfile.InsertLine(wxT( "\text: ") + m_aExtensions.Item(index), nIndex + 1 );
+                outfile.InsertLine( wxT("\text: ") + m_aExtensions.Item(index), nIndex + 1 );

             }
         }
     }
             }
         }
     }


@@ -493,17 +523,22 @@ bool wxMimeTypesManagerImpl::WriteGnomeMimeFile(int index, bool delete_index)
 }
 
 
 }
 
 

-void wxMimeTypesManagerImpl::LoadGnomeDataFromKeyFile(const wxString& filename)
+void wxMimeTypesManagerImpl::LoadGnomeDataFromKeyFile(const wxString& filename,
+                                                      const wxArrayString& dirs)

 {
     wxTextFile textfile(filename);
 {
     wxTextFile textfile(filename);

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

     if ( !textfile.Open() )
     if ( !textfile.Open() )

+#endif

         return;
     wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s  ---"),
         return;
     wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s  ---"),

-                 filename.c_str());
+            filename.c_str());

 
     // values for the entry being parsed
     wxString curMimeType, curIconFile;
 
     // values for the entry being parsed
     wxString curMimeType, curIconFile;

-    wxMimeArrayString * entry = new wxMimeArrayString;
+    wxMimeTypeCommands * entry = new wxMimeTypeCommands;

 
     // these are always empty in this file
     wxArrayString strExtensions;
 
     // these are always empty in this file
     wxArrayString strExtensions;


@@ -513,69 +548,88 @@ void wxMimeTypesManagerImpl::LoadGnomeDataFromKeyFile(const wxString& filename)
     size_t nLineCount = textfile.GetLineCount();
     size_t nLine = 0;
     while ( nLine < nLineCount)
     size_t nLineCount = textfile.GetLineCount();
     size_t nLine = 0;
     while ( nLine < nLineCount)

-        {
+    {

         pc = textfile[nLine].c_str();
         if ( *pc != _T('#') )
         pc = textfile[nLine].c_str();
         if ( *pc != _T('#') )

-            {
+        {

 
             wxLogTrace(TRACE_MIME, wxT("--- Reading from Gnome file %s '%s' ---"),
 
             wxLogTrace(TRACE_MIME, wxT("--- Reading from Gnome file %s '%s' ---"),

-                 filename.c_str(),pc);
+                    filename.c_str(),pc);

 
             wxString sTmp(pc);
             if (sTmp.Contains(wxT("=")) )
             {
 
             wxString sTmp(pc);
             if (sTmp.Contains(wxT("=")) )
             {

-            if (sTmp.Contains( wxT("icon-filename=") ) )
+                // GNOME 1:
+                if (sTmp.Contains( wxT("icon-filename=") ) )

                 {
                 {

-                curIconFile = sTmp.AfterFirst(wxT('='));
+                    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
+                // GNOME 2:
+                else if (sTmp.Contains( wxT("icon_filename=") ) )
+                {
+                    curIconFile = sTmp.AfterFirst(wxT('='));

 
 

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

 
                 }
 
             } // emd of has an equals sign
             else
 
                 }
 
             } // emd of has an equals sign
             else

-                {
+            {

                 // not a comment and not an equals sign
                 if (sTmp.Contains(wxT('/')))
                 // not a comment and not an equals sign
                 if (sTmp.Contains(wxT('/')))

-                    {
+                {

                     // this is the start of the new mimetype
                     // overwrite any existing data
                     // this is the start of the new mimetype
                     // overwrite any existing data

-                    if (! curMimeType.IsEmpty())
-                        {
+                    if (! curMimeType.empty())
+                    {

                         AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
 
                         // now get ready for next bit
                         AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
 
                         // now get ready for next bit

-                        entry = new wxMimeArrayString;
-                        }
-                    curMimeType = sTmp.BeforeFirst(wxT(':'));
+                        entry = new wxMimeTypeCommands;

                     }
                     }

-    }
+                    curMimeType = sTmp.BeforeFirst(wxT(':'));
+                }
+            }

         } // end of not a comment
         } // end of not a comment

-    // ignore blank lines
-    nLine ++;
+        // ignore blank lines
+        nLine ++;

     } // end of while, save any data
     } // end of while, save any data

-    if (! curMimeType.IsEmpty())
-        {
-        AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
-        }

 
 

+    if (! curMimeType.empty())
+        AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);

 }
 
 
 }
 
 


@@ -585,20 +639,22 @@ void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& file
     wxTextFile textfile(filename);
     if ( !textfile.Open() )
         return;
     wxTextFile textfile(filename);
     if ( !textfile.Open() )
         return;

-    wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s  ---"),
-                 filename.c_str());
+
+    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();
 
     // values for the entry being parsed
     wxString curMimeType, curExtList;
 
     const wxChar *pc;
     size_t nLineCount = textfile.GetLineCount();

-    for ( size_t nLine = 0; ; nLine++ )
+    for ( size_t nLine = 0;; nLine++ )

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

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

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


@@ -613,10 +669,11 @@ void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& file
         if ( !pc || !*pc )
         {
             // end of the entry
         if ( !pc || !*pc )
         {
             // end of the entry

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

             {
             {

-                 wxLogTrace(TRACE_MIME, wxT("--- At end of Gnome file  finding mimetype %s  ---"),
-                 curMimeType.c_str());
+                 wxLogTrace(TRACE_MIME,
+                            wxT("--- At end of Gnome file  finding mimetype %s  ---"),
+                            curMimeType.c_str());

 
                  AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
             }
 
                  AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
             }


@@ -633,31 +690,32 @@ void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& file
         }
 
         // what do we have here?
         }
 
         // what do we have here?

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

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

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

             {
             {

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

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

-            wxLogTrace(TRACE_MIME, wxT("--- In Gnome file  finding mimetype %s  ---"),
-                 curMimeType.c_str());
+            wxLogTrace(TRACE_MIME,
+                       wxT("--- In Gnome file  finding mimetype %s  ---"),
+                       curMimeType.c_str());

 
 

-            if (! curMimeType.IsEmpty()) AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
+            if (! curMimeType.empty())
+                AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);

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

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

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


@@ -666,13 +724,14 @@ void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& file
 }
 
 
 }
 
 

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

 {
 {

-    wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
+    wxASSERT_MSG( !dirbase.empty() && !wxEndsWithPathSeparator(dirbase),

                   _T("base directory shouldn't end with a slash") );
 
     wxString dirname = dirbase;
                   _T("base directory shouldn't end with a slash") );
 
     wxString dirname = dirbase;

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

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


@@ -682,10 +741,11 @@ void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(const wxString& dirbase)
         return;
 
     // we will concatenate it with filename to get the full path below
         return;
 
     // we will concatenate it with filename to get the full path below

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

 
     wxString filename;
 
     wxString filename;

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

     while ( cont )
     {
         LoadGnomeMimeTypesFromMimeFile(dirname + filename);
     while ( cont )
     {
         LoadGnomeMimeTypesFromMimeFile(dirname + filename);


@@ -696,44 +756,83 @@ void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(const wxString& dirbase)
     cont = dir.GetFirst(&filename, _T("*.keys"), wxDIR_FILES);
     while ( cont )
     {
     cont = dir.GetFirst(&filename, _T("*.keys"), wxDIR_FILES);
     while ( cont )
     {

-        LoadGnomeDataFromKeyFile(dirname + filename);
+        LoadGnomeDataFromKeyFile(dirname + filename, dirs);

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

-}

 
 

+    // Hack alert: We scan all icons and deduce the
+    //             mime-type from the file name.
+    dirname = dirbase;
+    dirname << wxT("/pixmaps/document-icons");
+
+    // these are always empty in this file
+    wxArrayString strExtensions;
+    wxString strDesc;
+
+    if ( !wxDir::Exists(dirname) )
+    {
+        // Jst test for default GPE dir also
+        dirname = wxT("/usr/share/gpe/pixmaps/default/filemanager/document-icons");

 
 

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

 
 

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

 
 void wxMimeTypesManagerImpl::GetGnomeMimeInfo(const wxString& sExtraDir)
 {
 
 void wxMimeTypesManagerImpl::GetGnomeMimeInfo(const wxString& sExtraDir)
 {

-

     wxArrayString dirs;
     wxArrayString dirs;

-    dirs.Add(_T("/usr/share"));
-    dirs.Add(_T("/usr/local/share"));

 
 

-    wxString gnomedir;
-    wxGetHomeDir( &gnomedir );
-    gnomedir += _T("/.gnome");
+    wxString gnomedir = wxGetenv( wxT("GNOMEDIR") );;
+    if (!gnomedir.empty())
+    {
+        gnomedir << wxT("/share");
+        dirs.Add( gnomedir );
+    }
+
+    dirs.Add(wxT("/usr/share"));
+    dirs.Add(wxT("/usr/local/share"));
+
+    gnomedir = wxGetHomeDir();
+    gnomedir << wxT("/.gnome");

     dirs.Add( gnomedir );
     dirs.Add( gnomedir );

-    if (!sExtraDir.IsEmpty()) dirs.Add( sExtraDir );
+
+    if (!sExtraDir.empty()) dirs.Add( sExtraDir );

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

-        LoadGnomeMimeFilesFromDir(dirs[nDir]);
+        LoadGnomeMimeFilesFromDir(dirs[nDir], dirs);

     }
 }
 
     }
 }
 

-
-
-
-// end of gnome
-

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

-// wxKDE
+// KDE

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

+

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


@@ -747,20 +846,21 @@ void wxMimeTypesManagerImpl::GetGnomeMimeInfo(const wxString& sExtraDir)
 // 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??)
 
 // 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 )
-
+bool wxMimeTypesManagerImpl::CheckKDEDirsExist ( const wxString &sOK, const wxString &sTest )
+{
+    if (sTest.empty())

     {
     {

-    if (sTest.IsEmpty())
-        {
-            if (wxDir::Exists(sOK)) return TRUE;
-            else return FALSE;
-        }
+        if (wxDir::Exists(sOK))
+            return true;
+        else
+            return false;
+    }

     else
     else

-        {
-            wxString sStart = sOK + wxT("/") + sTest.BeforeFirst(wxT('/'));
-            if (!wxDir::Exists(sStart))  wxMkdir(sStart);
-            wxString sEnd = sTest.AfterFirst(wxT('/'));
-            return CheckKDEDirsExist(sStart, sEnd);
+    {
+        wxString sStart = sOK + wxT("/") + sTest.BeforeFirst(wxT('/'));
+        if (!wxDir::Exists(sStart))  wxMkdir(sStart);
+        wxString sEnd = sTest.AfterFirst(wxT('/'));
+        return CheckKDEDirsExist(sStart, sEnd);

     }
 }
 
     }
 }
 


@@ -769,7 +869,7 @@ bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index)
     wxMimeTextFile appoutfile, mimeoutfile;
     wxString sHome = wxGetHomeDir();
     wxString sTmp = wxT(".kde/share/mimelnk/");
     wxMimeTextFile appoutfile, mimeoutfile;
     wxString sHome = wxGetHomeDir();
     wxString sTmp = wxT(".kde/share/mimelnk/");

-    wxString sMime = m_aTypes[index] ;
+    wxString sMime = m_aTypes[index];

     CheckKDEDirsExist (sHome, sTmp + sMime.BeforeFirst(wxT('/')) );
     sTmp = sHome + wxT('/') + sTmp + sMime + wxT(".kdelnk");
 
     CheckKDEDirsExist (sHome, sTmp + sMime.BeforeFirst(wxT('/')) );
     sTmp = sHome + wxT('/') + sTmp + sMime + wxT(".kdelnk");
 


@@ -777,9 +877,9 @@ bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index)
     bool bMimeExists = mimeoutfile.Open (sTmp);
     if (!bMimeExists)
     {
     bool bMimeExists = mimeoutfile.Open (sTmp);
     if (!bMimeExists)
     {

-       bTemp = mimeoutfile.Create (sTmp);
-       // some unknown error eg out of disk space
-       if (!bTemp) return FALSE;
+        bTemp = mimeoutfile.Create (sTmp);
+        // some unknown error eg out of disk space
+        if (!bTemp) return false;

     }
 
     sTmp = wxT(".kde/share/applnk/");
     }
 
     sTmp = wxT(".kde/share/applnk/");


@@ -792,7 +892,7 @@ bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index)
     {
         bTemp = appoutfile.Create (sTmp);
         // some unknown error eg out of disk space
     {
         bTemp = appoutfile.Create (sTmp);
         // some unknown error eg out of disk space

-        if (!bTemp) return FALSE;
+        if (!bTemp) return false;

     }
 
     // fixed data; write if new file
     }
 
     // fixed data; write if new file


@@ -841,13 +941,12 @@ bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index)
         // holds an extension; need to change it to *.ext;
         wxString e = wxT("*.") + tokenizer.GetNextToken() + wxT(";");
         sTmp = sTmp + e;
         // holds an extension; need to change it to *.ext;
         wxString e = wxT("*.") + tokenizer.GetNextToken() + wxT(";");
         sTmp = sTmp + e;

-}
+    }

     if (!delete_index) mimeoutfile.AddLine(sTmp);
 
     if (!delete_index) mimeoutfile.AddLine(sTmp);
 

-    wxMimeArrayString * entries = m_aEntries[index];
+    wxMimeTypeCommands * entries = m_aEntries[index];

     // if we don't find open just have an empty string ... FIX this
     // 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 = entries->GetCommandForVerb(_T("open"));

     sTmp.Replace( wxT("%s"), wxT("%f") );
 
     mimeoutfile.CommentLine(wxT("DefaultApp=") );
     sTmp.Replace( wxT("%s"), wxT("%f") );
 
     mimeoutfile.CommentLine(wxT("DefaultApp=") );


@@ -858,19 +957,17 @@ bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index)
     if (!delete_index) appoutfile.AddLine(wxT("Exec=") + sTmp);
 
     if (entries->GetCount() > 1)
     if (!delete_index) appoutfile.AddLine(wxT("Exec=") + sTmp);
 
     if (entries->GetCount() > 1)

-        {
-            //other actions as well as open
+    {
+        //other actions as well as open

 
 

-        }
-    bTemp = FALSE;
-    if (mimeoutfile.Write ()) bTemp = TRUE;
+    }
+    bTemp = false;
+    if (mimeoutfile.Write ()) bTemp = true;

     mimeoutfile.Close ();
     mimeoutfile.Close ();

-    if (appoutfile.Write ()) bTemp = TRUE;
+    if (appoutfile.Write ()) bTemp = true;

     appoutfile.Close ();
 
     return bTemp;
     appoutfile.Close ();
 
     return bTemp;

-
-

 }
 
 void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,
 }
 
 void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,


@@ -881,17 +978,20 @@ void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,
     wxMimeTextFile file;
     if ( !file.Open(dirbase + filename) ) return;
 
     wxMimeTextFile file;
     if ( !file.Open(dirbase + filename) ) return;
 

-    wxMimeArrayString * entry = new wxMimeArrayString;
+    wxLogTrace(TRACE_MIME, wxT("loading KDE file %s"),
+                           (dirbase+filename).c_str());
+
+    wxMimeTypeCommands * entry = new wxMimeTypeCommands;

     wxArrayString sExts;
     wxString mimetype, mime_desc, strIcon;
 
     wxArrayString sExts;
     wxString mimetype, mime_desc, strIcon;
 

-    int nIndex = file.pIndexOf ("MimeType=");
+    int 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('.'));
-        }
+    {
+        // construct mimetype from the directory name and the basename of the
+        // file (it always has .kdelnk extension)
+        mimetype << subdir << wxT('/') << filename.BeforeLast( wxT('.') );
+    }

     else mimetype = file.GetCmd (nIndex);
 
     // first find the description string: it is the value in either "Comment="
     else mimetype = file.GetCmd (nIndex);
 
     // first find the description string: it is the value in either "Comment="


@@ -923,8 +1023,8 @@ void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,
 
     nIndex = file.pIndexOf(_T("Patterns="));
     if ( nIndex != wxNOT_FOUND )
 
     nIndex = file.pIndexOf(_T("Patterns="));
     if ( nIndex != wxNOT_FOUND )

-        {
-        wxString exts = file.GetCmd (nIndex) ;;
+    {
+        wxString exts = file.GetCmd (nIndex);

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


@@ -944,53 +1044,60 @@ void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,
     }
     sExts.Add(mime_extension);
 
     }
     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);
     // ok, now we can take care of icon:
 
     nIndex = file.pIndexOf(_T("Icon="));
     if ( nIndex != wxNOT_FOUND )
     {
         strIcon = file.GetCmd(nIndex);

+        wxLogTrace(TRACE_MIME, wxT("  icon %s"), strIcon.c_str());

         //it could be the real path, but more often a short name
         //it could be the real path, but more often a short name

+
+

         if (!wxFileExists(strIcon))
         if (!wxFileExists(strIcon))

-    {
+        {

             // icon is just the short name
             // 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))
+            if ( !strIcon.empty() )

             {
             {

-                        strIcon.Prepend(icondirs[nDir]);
-                break;
-            }
+                // we must check if the file exists because it may be stored
+                // in many locations, at least ~/.kde and $KDEDIR
+                size_t nDir, nDirs = icondirs.GetCount();
+                for ( nDir = 0; nDir < nDirs; nDir++ )
+                {
+                    wxFileName fnameIcon( strIcon );
+                    wxFileName fname( icondirs[nDir], fnameIcon.GetName() );
+                    fname.SetExt( wxT("png") );
+                    if (fname.FileExists())
+                    {
+                        strIcon = fname.GetFullPath();
+                        wxLogTrace(TRACE_MIME, wxT("  iconfile %s"), strIcon.c_str());
+                        break;
+                    }

                 }
             }
                 }
             }

-         }
+        }
+    }

     // now look for lines which know about the application
     // exec= or DefaultApp=
 
     nIndex = file.pIndexOf(wxT("DefaultApp"));
 
     if ( nIndex == wxNOT_FOUND )
     // now look for lines which know about the application
     // exec= or DefaultApp=
 
     nIndex = file.pIndexOf(wxT("DefaultApp"));
 
     if ( nIndex == wxNOT_FOUND )

-        {
+    {

         // no entry try exec
         nIndex = file.pIndexOf(wxT("Exec"));
         // no entry try exec
         nIndex = file.pIndexOf(wxT("Exec"));

-        }
+    }

 
     if ( nIndex != wxNOT_FOUND )
 
     if ( nIndex != wxNOT_FOUND )

-        {
+    {

         wxString sTmp = file.GetCmd(nIndex);
         // we expect %f; others including  %F and %U and %u are possible
         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 );
+        if (0 == sTmp.Replace ( wxT("%f"), wxT("%s") ))
+            sTmp = sTmp + wxT(" %s");
+        entry->AddOrReplaceVerb (wxString(wxT("open")), sTmp );

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

-
-

 }
 
 void wxMimeTypesManagerImpl::LoadKDELinksForMimeType(const wxString& dirbase,
 }
 
 void wxMimeTypesManagerImpl::LoadKDELinksForMimeType(const wxString& dirbase,


@@ -1003,6 +1110,9 @@ void wxMimeTypesManagerImpl::LoadKDELinksForMimeType(const wxString& dirbase,
     if ( !dir.IsOpened() )
         return;
 
     if ( !dir.IsOpened() )
         return;
 

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

     dirname += _T('/');
 
     wxString filename;
     dirname += _T('/');
 
     wxString filename;


@@ -1026,7 +1136,7 @@ void wxMimeTypesManagerImpl::LoadKDELinksForMimeType(const wxString& dirbase,
 void wxMimeTypesManagerImpl::LoadKDELinkFilesFromDir(const wxString& dirbase,
                                             const wxArrayString& icondirs)
 {
 void wxMimeTypesManagerImpl::LoadKDELinkFilesFromDir(const wxString& dirbase,
                                             const wxArrayString& icondirs)
 {

-    wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
+    wxASSERT_MSG( !dirbase.empty() && !wxEndsWithPathSeparator(dirbase),

                   _T("base directory shouldn't end with a slash") );
 
     wxString dirname = dirbase;
                   _T("base directory shouldn't end with a slash") );
 
     wxString dirname = dirbase;


@@ -1057,16 +1167,103 @@ void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)
     wxArrayString dirs;
     wxArrayString icondirs;
 
     wxArrayString dirs;
     wxArrayString icondirs;
 

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

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

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

 
 

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

     {
     {

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

     }
     else
     {
     }
     else
     {


@@ -1078,7 +1275,7 @@ void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)
         icondirs.Add(_T("/opt/kde/share/icons/"));
     }
 
         icondirs.Add(_T("/opt/kde/share/icons/"));
     }
 

-    if (!sExtraDir.IsEmpty()) dirs.Add (sExtraDir);
+    if (!sExtraDir.empty()) dirs.Add (sExtraDir);

     icondirs.Add(sExtraDir + wxT("/icons"));
 
     size_t nDirs = dirs.GetCount();
     icondirs.Add(sExtraDir + wxT("/icons"));
 
     size_t nDirs = dirs.GetCount();


@@ -1086,22 +1283,17 @@ void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)
     {
         LoadKDELinkFilesFromDir(dirs[nDir], icondirs);
     }
     {
         LoadKDELinkFilesFromDir(dirs[nDir], icondirs);
     }

-
-

 }
 
 }
 

-// 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 ++;


@@ -1110,38 +1302,25 @@ wxString wxFileTypeImpl::GetExpandedCommand(const wxString & verb, const wxFileT
     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]];
         i ++;
     }
     {
         sTmp = m_manager->m_aIcons[m_index[i]];
         i ++;
     }

-    if ( sTmp.IsEmpty () ) return FALSE;
+    if ( sTmp.empty () )
+        return false;

 
 

-    wxIcon icn;
-
-    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;

 }
 
 
 }
 
 


@@ -1151,7 +1330,7 @@ wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
     mimeTypes.Clear();
     for (size_t i = 0; i < m_index.GetCount(); i++)
         mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);
     mimeTypes.Clear();
     for (size_t i = 0; i < m_index.GetCount(); i++)
         mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);

-    return TRUE;
+    return true;

 }
 
 
 }
 
 


@@ -1162,7 +1341,7 @@ size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
 
     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


@@ -1171,13 +1350,13 @@ size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
         // 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);
             {
                 vrb = sPairs->GetVerb(i);
                 // some gnome entries have . inside
                 vrb = vrb.AfterLast(wxT('.'));
                 cmd = sPairs->GetCmd (i);

-                if (! cmd.IsEmpty() )
+                if (! cmd.empty() )

                      {
                      cmd = wxFileType::ExpandCommand(cmd, params);
                      count ++;
                      {
                      cmd = wxFileType::ExpandCommand(cmd, params);
                      count ++;


@@ -1207,9 +1386,9 @@ bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
 
     // one extension in the space or comma delimitid list
     wxString strExt;
 
     // one extension in the space or comma delimitid list
     wxString strExt;

-    for ( const wxChar *p = strExtensions; ; p++ ) {
+    for ( const wxChar *p = strExtensions;; p++ ) {

         if ( *p == wxT(' ') || *p == wxT(',') || *p == wxT('\0') ) {
         if ( *p == wxT(' ') || *p == wxT(',') || *p == wxT('\0') ) {

-            if ( !strExt.IsEmpty() ) {
+            if ( !strExt.empty() ) {

                 extensions.Add(strExt);
                 strExt.Empty();
             }
                 extensions.Add(strExt);
                 strExt.Empty();
             }


@@ -1221,7 +1400,7 @@ bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
         }
         else if ( *p == wxT('.') ) {
             // remove the dot from extension (but only if it's the first char)
         }
         else if ( *p == wxT('.') ) {
             // 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


@@ -1231,59 +1410,63 @@ bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
         }
     }
 
         }
     }
 

-    return TRUE;
+    return true;

 }
 
 // set an arbitrary command,
 // could adjust the code to ask confirmation if it already exists and
 }
 
 // set an arbitrary command,
 // could adjust the code to ask confirmation if it already exists and

-// overwriteprompt is TRUE, but this is currently ignored as *Associate* has
+// 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 ;
+    wxString strDesc, strIcon;

 
 

-    wxMimeArrayString *entry = new wxMimeArrayString ();
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands ();

     entry->Add(verb + wxT("=")  + cmd + wxT(" %s "));
 
     wxArrayString strTypes;
     GetMimeTypes (strTypes);
     entry->Add(verb + wxT("=")  + cmd + wxT(" %s "));
 
     wxArrayString strTypes;
     GetMimeTypes (strTypes);

-    if (strTypes.GetCount() < 1) return FALSE;
+    if (strTypes.GetCount() < 1) return false;

 
     size_t i;
 
     size_t i;

-    bool Ok = TRUE;
+    bool Ok = true;

     for (i = 0; i < strTypes.GetCount(); i++)
     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;
-        }
+            Ok = false;
+    }

 
     return Ok;
 
     return Ok;

-    }
+}

 
 // ignore index on the grouds that we only have one icon in a Unix file
 
 // 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*/)
-    {
-    if (strIcon.IsEmpty()) return FALSE;
+bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int WXUNUSED(index))
+{
+    if (strIcon.empty()) return false;

     wxArrayString strExtensions;
     wxString strDesc;
 
     wxArrayString strExtensions;
     wxString strDesc;
 

-    wxMimeArrayString *entry = new wxMimeArrayString ();
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands ();

 
     wxArrayString strTypes;
     GetMimeTypes (strTypes);
 
     wxArrayString strTypes;
     GetMimeTypes (strTypes);

-    if (strTypes.GetCount() < 1) return FALSE;
+    if (strTypes.GetCount() < 1) return false;

 
     size_t i;
 
     size_t i;

-    bool Ok = TRUE;
+    bool Ok = true;

     for (i = 0; i < strTypes.GetCount(); i++)
     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;
-        }
+            Ok = false;
+    }

 
     return Ok;
 
     return Ok;

-    }
+}
+

 // ----------------------------------------------------------------------------
 // wxMimeTypesManagerImpl (Unix)
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxMimeTypesManagerImpl (Unix)
 // ----------------------------------------------------------------------------


@@ -1291,10 +1474,30 @@ bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon /*= wxEmptyString*/,
 
 wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
 {
 
 wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
 {

-    m_initialized = FALSE;
+    m_initialized = false;

     m_mailcapStylesInited = 0;
 }
 
     m_mailcapStylesInited = 0;
 }
 

+void wxMimeTypesManagerImpl::InitIfNeeded()
+{
+    if ( !m_initialized )
+    {
+        // set the flag first to prevent recursion
+        m_initialized = true;
+
+#if 0
+    wxString wm = wxGetenv( wxT("WINDOWMANAGER") );
+
+    if (wm.Find( wxT("kde") ) != wxNOT_FOUND)
+        Initialize( wxMAILCAP_KDE|wxMAILCAP_STANDARD );
+    else if (wm.Find( wxT("gnome") ) != wxNOT_FOUND)
+        Initialize( wxMAILCAP_GNOME|wxMAILCAP_STANDARD );
+    else
+#endif
+            Initialize();
+    }
+}
+

 // read system and user mailcaps and other files
 void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
                                         const wxString& sExtraDir)
 // read system and user mailcaps and other files
 void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
                                         const wxString& sExtraDir)


@@ -1305,11 +1508,11 @@ void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
         GetMimeInfo(sExtraDir);
 
     // read GNOME tables
         GetMimeInfo(sExtraDir);
 
     // read GNOME tables

-    if ( mailcapStyles & wxMAILCAP_GNOME)
+    if (mailcapStyles & wxMAILCAP_GNOME)

         GetGnomeMimeInfo(sExtraDir);
 
     // read KDE tables
         GetGnomeMimeInfo(sExtraDir);
 
     // read KDE tables

-    if ( mailcapStyles & wxMAILCAP_KDE)
+    if (mailcapStyles & wxMAILCAP_KDE)

         GetKDEMimeInfo(sExtraDir);
 
     m_mailcapStylesInited |= mailcapStyles;
         GetKDEMimeInfo(sExtraDir);
 
     m_mailcapStylesInited |= mailcapStyles;


@@ -1323,20 +1526,15 @@ void wxMimeTypesManagerImpl::ClearData()
     m_aExtensions.Clear ();
     m_aDescriptions.Clear ();
 
     m_aExtensions.Clear ();
     m_aDescriptions.Clear ();
 

-    size_t cnt = m_aTypes.GetCount();
-    for (size_t i = 0; i < cnt; i++)
-    {
-        m_aEntries[i]->Clear ();
-    }
-    m_aEntries.Clear ();
+    WX_CLEAR_ARRAY(m_aEntries);
+    m_aEntries.Empty();
+

     m_mailcapStylesInited = 0;
 }
 
 wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl()
 {
     m_mailcapStylesInited = 0;
 }
 
 wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl()
 {

-    ClearData(); // do we need to delete the ArrayStrings too to avoid a leak
-
-//    delete m_aEntries //fix a leak here ?;
+    ClearData();

 }
 
 
 }
 
 


@@ -1358,13 +1556,13 @@ void wxMimeTypesManagerImpl::GetMimeInfo (const wxString& sExtraDir)
     wxString strHome = wxGetenv(wxT("HOME"));
 
     wxArrayString dirs;
     wxString strHome = wxGetenv(wxT("HOME"));
 
     wxArrayString dirs;

+    dirs.Add ( strHome + wxT("/.") );

     dirs.Add ( wxT("/etc/") );
     dirs.Add ( wxT("/usr/etc/") );
     dirs.Add ( wxT("/usr/local/etc/") );
     dirs.Add ( wxT("/etc/mail/") );
     dirs.Add ( wxT("/usr/public/lib/") );
     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("/") );
+    if (!sExtraDir.empty()) dirs.Add ( sExtraDir + wxT("/") );

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


@@ -1386,7 +1584,7 @@ bool wxMimeTypesManagerImpl::WriteToMimeTypes (int index, bool delete_index)
 {
     // check we have the right manager
     if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD) )
 {
     // check we have the right manager
     if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD) )

-        return FALSE;
+        return false;

 
     bool bTemp;
     wxString strHome = wxGetenv(wxT("HOME"));
 
     bool bTemp;
     wxString strHome = wxGetenv(wxT("HOME"));


@@ -1401,18 +1599,18 @@ bool wxMimeTypesManagerImpl::WriteToMimeTypes (int index, bool delete_index)
     }
     else
     {
     }
     else
     {

-        if (delete_index) return FALSE;
+        if (delete_index) return false;

         bTemp = file.Create(strUserMailcap);
     }
     if (bTemp)
     {
         int nIndex;
         bTemp = file.Create(strUserMailcap);
     }
     if (bTemp)
     {
         int nIndex;

-        // test for netscape's header and return FALSE if its found
+        // test for netscape's header and return false if its found

         nIndex = file.pIndexOf (wxT("#--Netscape"));
         if (nIndex != wxNOT_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;
+            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
         }
         // write it in alternative format
         // get rid of unwanted entries


@@ -1440,7 +1638,7 @@ bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
 {
     //check we have the right managers
     if (! ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) )
 {
     //check we have the right managers
     if (! ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) )

-        return FALSE;
+        return false;

 
     bool bTemp;
     wxString strHome = wxGetenv(wxT("HOME"));
 
     bool bTemp;
     wxString strHome = wxGetenv(wxT("HOME"));


@@ -1455,7 +1653,7 @@ bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
     }
     else
     {
     }
     else
     {

-        if (delete_index) return FALSE;
+        if (delete_index) return false;

         bTemp = file.Create(strUserMailcap);
     }
     if (bTemp)
         bTemp = file.Create(strUserMailcap);
     }
     if (bTemp)


@@ -1464,8 +1662,8 @@ bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
         // write it in the format that Netscape uses
         int nIndex;
         // test for netscape's header and insert if required...
         // 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);
+        // this is a comment so use true
+        nIndex = file.pIndexOf (wxT("#--Netscape"), true);

         if (nIndex == wxNOT_FOUND)
         {
             // either empty file or metamail format
         if (nIndex == wxNOT_FOUND)
         {
             // either empty file or metamail format


@@ -1473,8 +1671,8 @@ bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
             // metamail entreies
             if (file.GetLineCount () > 0)
             {
             // 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;
+                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;
             }
             file.InsertLine (wxT( "#--Netscape Communications Corporation MIME Information" ), 0);
             nIndex = 0;


@@ -1499,9 +1697,9 @@ bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
 
         wxString sTmp = strType + wxT(" \\");
         if (!delete_index) file.InsertLine (sTmp, nIndex);
 
         wxString sTmp = strType + wxT(" \\");
         if (!delete_index) file.InsertLine (sTmp, nIndex);

-        if ( ! m_aDescriptions.Item(index).IsEmpty() )
+        if ( ! m_aDescriptions.Item(index).empty() )

         {
         {

-            sTmp =     wxT("desc=\"") + m_aDescriptions[index]+ wxT("\" \\") ; //.trim ??
+            sTmp =     wxT("desc=\"") + m_aDescriptions[index]+ wxT("\" \\"); //.trim ??

             if (!delete_index)
             {
                 nIndex ++;
             if (!delete_index)
             {
                 nIndex ++;


@@ -1509,7 +1707,7 @@ bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
             }
         }
         wxString sExts =  m_aExtensions.Item(index);
             }
         }
         wxString sExts =  m_aExtensions.Item(index);

-        sTmp =     wxT("exts=\"") + sExts.Trim(FALSE).Trim() + wxT("\"");
+        sTmp =     wxT("exts=\"") + sExts.Trim(false).Trim() + wxT("\"");

         if (!delete_index)
         {
             nIndex ++;
         if (!delete_index)
         {
             nIndex ++;


@@ -1528,7 +1726,7 @@ bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
     //check we have the right managers
     if ( !( ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) ||
             ( m_mailcapStylesInited & wxMAILCAP_STANDARD) ) )
     //check we have the right managers
     if ( !( ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) ||
             ( m_mailcapStylesInited & wxMAILCAP_STANDARD) ) )

-        return FALSE;
+        return false;

 
     bool bTemp;
     wxString strHome = wxGetenv(wxT("HOME"));
 
     bool bTemp;
     wxString strHome = wxGetenv(wxT("HOME"));


@@ -1543,15 +1741,15 @@ bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
     }
     else
     {
     }
     else
     {

-        if (delete_index) return FALSE;
+        if (delete_index) return false;

         bTemp = file.Create(strUserMailcap);
     }
     if (bTemp)
     {
         // now got a file we can write to ....
         bTemp = file.Create(strUserMailcap);
     }
     if (bTemp)
     {
         // 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);
+        wxMimeTypeCommands * entries = m_aEntries[index];
+        size_t iOpen;
+        wxString sCmd = entries->GetCommandForVerb(_T("open"), &iOpen);

         wxString sTmp;
 
         sTmp = m_aTypes[index];
         wxString sTmp;
 
         sTmp = m_aTypes[index];


@@ -1575,7 +1773,7 @@ bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
             if (nIndex < (int) file.GetLineCount()) file.CommentLine (nIndex);
         }
 
             if (nIndex < (int) file.GetLineCount()) file.CommentLine (nIndex);
         }
 

-        sTmp = sTmp + wxT(";") + sCmd ; //includes wxT(" %s ");
+        sTmp = sTmp + wxT(";") + sCmd; //includes wxT(" %s ");

 
         // write it in the format that Netscape uses (default)
         if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD  ) )
 
         // write it in the format that Netscape uses (default)
         if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD  ) )


@@ -1603,15 +1801,15 @@ bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
 
                 // first unknown
                 s = sT.GetNextToken();
 
                 // first unknown
                 s = sT.GetNextToken();

-                while ( ! s.IsEmpty() )
+                while ( ! s.empty() )

                 {
                 {

-                    bool bKnownToken = FALSE;
-                    if (s.Contains(wxT("description="))) bKnownToken = TRUE;
-                    if (s.Contains(wxT("x11-bitmap="))) bKnownToken = TRUE;
+                    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++)
                     {
                     size_t i;
                     for (i=0; i < entries->GetCount(); i++)
                     {

-                        if (s.Contains(entries->GetVerb(i))) bKnownToken = TRUE;
+                        if (s.Contains(entries->GetVerb(i))) bKnownToken = true;

                     }
                     if (!bKnownToken)
                     {
                     }
                     if (!bKnownToken)
                     {


@@ -1624,7 +1822,7 @@ bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
 
             }
 
 
             }
 

-            if (! m_aDescriptions[index].IsEmpty() )
+            if (! m_aDescriptions[index].empty() )

             {
                 sTmp = sTmp + wxT("; \\");
                 file.InsertLine (sTmp, nIndex);
             {
                 sTmp = sTmp + wxT("; \\");
                 file.InsertLine (sTmp, nIndex);


@@ -1632,7 +1830,7 @@ bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
                 sTmp = wxT("       description=\"") + m_aDescriptions[index] + wxT("\"");
             }
 
                 sTmp = wxT("       description=\"") + m_aDescriptions[index] + wxT("\"");
             }
 

-            if (! m_aIcons[index].IsEmpty() )
+            if (! m_aIcons[index].empty() )

             {
                 sTmp = sTmp + wxT("; \\");
                 file.InsertLine (sTmp, nIndex);
             {
                 sTmp = sTmp + wxT("; \\");
                 file.InsertLine (sTmp, nIndex);


@@ -1649,7 +1847,7 @@ bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
                         sTmp = sTmp + wxT("; \\");
                         file.InsertLine (sTmp, nIndex);
                         nIndex ++;
                         sTmp = sTmp + wxT("; \\");
                         file.InsertLine (sTmp, nIndex);
                         nIndex ++;

-                        sTmp = wxT("       ") + entries->Item(i);
+                        sTmp = wxT("       ") + entries->GetVerbCmd(i);

                     }
             }
 
                     }
             }
 


@@ -1672,11 +1870,11 @@ wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
     wxString strDesc = ftInfo.GetDescription ();
     wxString strIcon = ftInfo.GetIconFile ();
 
     wxString strDesc = ftInfo.GetDescription ();
     wxString strIcon = ftInfo.GetIconFile ();
 

-    wxMimeArrayString *entry = new wxMimeArrayString ();
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands ();

 
 

-    if ( ! ftInfo.GetOpenCommand().IsEmpty())
+    if ( ! ftInfo.GetOpenCommand().empty())

         entry->Add(wxT("open=")  + ftInfo.GetOpenCommand  () + wxT(" %s "));
         entry->Add(wxT("open=")  + ftInfo.GetOpenCommand  () + wxT(" %s "));

-    if ( ! ftInfo.GetPrintCommand  ().IsEmpty())
+    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
         entry->Add(wxT("print=") + ftInfo.GetPrintCommand () + wxT(" %s "));
 
     // now find where these extensions are in the data store and remove them


@@ -1687,12 +1885,12 @@ wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
         {
         sExt = sA_Exts.Item(i);
         //clean up to just a space before and after
         {
         sExt = sA_Exts.Item(i);
         //clean up to just a space before and after

-        sExt.Trim().Trim(FALSE);
+        sExt.Trim().Trim(false);

         sExt = wxT(' ') + sExt + wxT(' ');
         for (nIndex = 0; nIndex < m_aExtensions.GetCount(); nIndex ++)
             {
             sExtStore = m_aExtensions.Item(nIndex);
         sExt = wxT(' ') + sExt + wxT(' ');
         for (nIndex = 0; nIndex < m_aExtensions.GetCount(); nIndex ++)
             {
             sExtStore = m_aExtensions.Item(nIndex);

-            if (sExtStore.Replace(sExt, wxT(" ") ) > 0) m_aExtensions.Item(nIndex) = sExtStore ;
+            if (sExtStore.Replace(sExt, wxT(" ") ) > 0) m_aExtensions.Item(nIndex) = sExtStore;

     }
 
     }
     }
 
     }


@@ -1706,48 +1904,48 @@ wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
 
 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 false;

 
 

-    return WriteMimeInfo (nIndex, FALSE);
+    return WriteMimeInfo (nIndex, false);

 }
 
 bool wxMimeTypesManagerImpl::WriteMimeInfo(int nIndex, bool delete_mime )
 {
 }
 
 bool wxMimeTypesManagerImpl::WriteMimeInfo(int nIndex, bool delete_mime )
 {

-    bool ok = TRUE;
+    bool ok = true;

 
     if ( m_mailcapStylesInited & wxMAILCAP_STANDARD )
     {
         // write in metamail  format;
         if (WriteToMimeTypes (nIndex, delete_mime) )
             if ( WriteToMailCap   (nIndex, delete_mime) )
 
     if ( m_mailcapStylesInited & wxMAILCAP_STANDARD )
     {
         // write in metamail  format;
         if (WriteToMimeTypes (nIndex, delete_mime) )
             if ( WriteToMailCap   (nIndex, delete_mime) )

-                ok = FALSE;
+                ok = false;

     }
     if ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE )
     {
         // write in netsacpe format;
         if (WriteToNSMimeTypes (nIndex, delete_mime) )
             if ( WriteToMailCap   (nIndex, delete_mime) )
     }
     if ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE )
     {
         // write in netsacpe format;
         if (WriteToNSMimeTypes (nIndex, delete_mime) )
             if ( WriteToMailCap   (nIndex, delete_mime) )

-                ok = FALSE;
+                ok = false;

     }
     if (m_mailcapStylesInited & wxMAILCAP_GNOME)
     {
         // write in Gnome format;
         if (WriteGnomeMimeFile (nIndex, delete_mime) )
             if (WriteGnomeKeyFile   (nIndex, delete_mime) )
     }
     if (m_mailcapStylesInited & wxMAILCAP_GNOME)
     {
         // write in Gnome format;
         if (WriteGnomeMimeFile (nIndex, delete_mime) )
             if (WriteGnomeKeyFile   (nIndex, delete_mime) )

-                ok = FALSE;
+                ok = false;

     }
     if (m_mailcapStylesInited & wxMAILCAP_KDE)
     {
         // write in KDE format;
         if (WriteKDEMimeFile (nIndex, delete_mime) )
     }
     if (m_mailcapStylesInited & wxMAILCAP_KDE)
     {
         // write in KDE format;
         if (WriteKDEMimeFile (nIndex, delete_mime) )

-            ok = FALSE;
+            ok = false;

     }
 
     return ok;
     }
 
     return ok;


@@ -1755,90 +1953,101 @@ bool wxMimeTypesManagerImpl::WriteMimeInfo(int nIndex, bool delete_mime )
 
 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
+    size_t count = strExtensions.GetCount();
+    for ( size_t i = 0; i < count; i++ )
+    {
+        wxString ext = strExtensions[i] + _T(' ');
+
+        if ( exts.Find(ext) == wxNOT_FOUND )
+        {
+            exts += ext;
+        }
+    }
+

     // check data integrity
     wxASSERT( m_aTypes.Count() == m_aEntries.Count() &&
     // 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() );
+              m_aTypes.Count() == m_aExtensions.Count() &&
+              m_aTypes.Count() == m_aIcons.Count() &&
+              m_aTypes.Count() == m_aDescriptions.Count() );

 
     return nIndex;
 }
 
     return nIndex;
 }


@@ -1847,32 +2056,31 @@ int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType,
 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], _T(' '));

 
 

+        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 *
 }
 
 wxFileType *


@@ -1924,13 +2132,14 @@ wxString wxMimeTypesManagerImpl::GetCommand(const wxString & verb, size_t nIndex
     wxString command, testcmd, sV, sTmp;
     sV = verb + wxT("=");
     // list of verb = command pairs for this mimetype
     wxString command, testcmd, sV, sTmp;
     sV = verb + wxT("=");
     // 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++ )
+    for ( i = 0; i < sPairs->GetCount (); 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;
 }


@@ -1969,18 +2178,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(' ')));
         sTmp = sTmp.BeforeLast(wxT(' '));
     }
 
     {
         sExts.Add (sTmp.AfterLast(wxT(' ')));
         sTmp = sTmp.BeforeLast(wxT(' '));
     }
 

-    AddToMimeData (strMimeType, strIcon, entry, sExts, strDesc, (bool)TRUE);
+    AddToMimeData (strMimeType, strIcon, NULL, sExts, strDesc, true);

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


@@ -1991,7 +2199,7 @@ void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
 {
     InitIfNeeded();
 
 {
     InitIfNeeded();
 

-    wxMimeArrayString *entry = new wxMimeArrayString;
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands;

     entry->Add(wxT("open=")  + strOpenCmd);
     entry->Add(wxT("print=") + strPrintCmd);
     entry->Add(wxT("test=")  + strTest);
     entry->Add(wxT("open=")  + strOpenCmd);
     entry->Add(wxT("print=") + strPrintCmd);
     entry->Add(wxT("test=")  + strTest);


@@ -1999,7 +2207,7 @@ void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
     wxString strIcon;
     wxArrayString strExtensions;
 
     wxString strIcon;
     wxArrayString strExtensions;
 

-    AddToMimeData (strType, strIcon, entry, strExtensions, strDesc, TRUE);
+    AddToMimeData (strType, strIcon, entry, strExtensions, strDesc, true);

 
 }
 
 
 }
 


@@ -2009,15 +2217,20 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
                strFileName.c_str());
 
     wxTextFile file(strFileName);
                strFileName.c_str());
 
     wxTextFile file(strFileName);

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

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

-        return FALSE;
+#endif
+        return false;

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

-    for ( size_t nLine = 0; nLine < nLineCount; nLine++ ) {
+    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();
         if ( pc == NULL ) {
             // now we're at the start of the line
             pc = file[nLine].c_str();


@@ -2068,15 +2281,14 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
 
             // eat whitespace
             for ( pc = pEqualSign + 1; wxIsspace(*pc); pc++ )
 
             // eat whitespace
             for ( pc = pEqualSign + 1; wxIsspace(*pc); pc++ )

-               ;
+              ;

 
             const wxChar *pEnd;
             if ( *pc == wxT('"') ) {
                 // the string is quoted and ends at the matching quote
                 pEnd = wxStrchr(++pc, wxT('"'));
                 if ( pEnd == NULL ) {
 
             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."),
+                    wxLogWarning(_("Mime.types file %s, line %d: unterminated quoted string."),

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


@@ -2084,7 +2296,7 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
                 // unquoted string ends at the first space or at the end of
                 // line
                 for ( pEnd = pc; *pEnd && !wxIsspace(*pEnd); pEnd++ )
                 // 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)
             }
 
             // now we have the RHS (field value)


@@ -2097,12 +2309,12 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
             }
 
             for ( pc = pEnd; wxIsspace(*pc); pc++ )
             }
 
             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'),
 
             // 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;
+                 nextFieldOnSameLine = false;

             if ( !entryEnded ) {
                 nextFieldOnSameLine = ((*pc != wxT('\\')) || (pc[1] != wxT('\0')));
             }
             if ( !entryEnded ) {
                 nextFieldOnSameLine = ((*pc != wxT('\\')) || (pc[1] != wxT('\0')));
             }


@@ -2111,13 +2323,23 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
             if ( strLHS == wxT("type") ) {
                 strMimeType = strRHS;
             }
             if ( strLHS == wxT("type") ) {
                 strMimeType = strRHS;
             }

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

                 strDesc = strRHS;
             }
             else if ( strLHS == wxT("exts") ) {
                 strExtensions = strRHS;
             }
                 strDesc = strRHS;
             }
             else if ( strLHS == wxT("exts") ) {
                 strExtensions = strRHS;
             }

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

                 wxLogWarning(_("Unknown field in file %s, line %d: '%s'."),
                              strFileName.c_str(), nLine + 1, strLHS.c_str());
             }
                 wxLogWarning(_("Unknown field in file %s, line %d: '%s'."),
                              strFileName.c_str(), nLine + 1, strLHS.c_str());
             }


@@ -2139,13 +2361,15 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
         strExtensions.Replace(wxT(","), wxT(" "));
 
         // also deal with the leading dot
         strExtensions.Replace(wxT(","), wxT(" "));
 
         // also deal with the leading dot

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

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

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

 
         AddMimeTypeInfo(strMimeType, strExtensions, strDesc);
 
 
         AddMimeTypeInfo(strMimeType, strExtensions, strDesc);
 


@@ -2153,30 +2377,148 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
         pc = NULL;
     }
 
         pc = NULL;
     }
 

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

 }
 
 bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                                          bool fallback)
 {
 }
 
 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);
     wxLogTrace(TRACE_MIME, wxT("--- Parsing mailcap file '%s' ---"),
                strFileName.c_str());
 
     wxTextFile file(strFileName);

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

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

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

 
 

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

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

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

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


@@ -2189,10 +2531,13 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
             continue;
 
         // no, do parse
             continue;
 
         // no, do parse

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

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

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

         enum
         {
             Field_Type,
         enum
         {
             Field_Type,


@@ -2201,36 +2546,30 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
         } currentToken = Field_Type;
 
         // the flags and field values on the current line
         } 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 ) {
+        MailcapLineData data;
+
+        bool cont = true;
+        while ( cont )
+        {
+            switch ( *pc )
+            {

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

-                    if ( *++pc == wxT('\0') ) {
+                    if ( *++pc == wxT('\0') )
+                    {

                         // fetch the next line if there is one
                         // fetch the next line if there is one

-                        if ( nLine == nLineCount - 1 ) {
+                        if ( nLine == nLineCount - 1 )
+                        {

                             // something is wrong, bail out
                             // something is wrong, bail out

-                            cont = FALSE;
+                            cont = false;

 
 

-                            wxLogDebug(wxT("Mailcap file %s, line %d: "
-                                           "'\\' on the end of the last line "
-                                           "ignored."),
+                            wxLogDebug(wxT("Mailcap file %s, line %lu: '\\' on the end of the last line ignored."),

                                        strFileName.c_str(),
                                        strFileName.c_str(),

-                                       nLine + 1);
+                                       (unsigned long)nLine + 1);

                         }
                         }

-                        else {
+                        else
+                        {

                             // pass to the beginning of the next line
                             pc = file[++nLine].c_str();
 
                             // pass to the beginning of the next line
                             pc = file[++nLine].c_str();
 


@@ -2238,155 +2577,69 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                             continue;
                         }
                     }
                             continue;
                         }
                     }

-                    else {
+                    else
+                    {

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

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

 
 

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

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

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

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

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

 
 

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

                         case Field_Type:
                         case Field_Type:

-                            strType = curField;
-                            if ( strType.empty() ) {
+                            data.type = curField.Lower();
+                            if ( data.type.empty() )
+                            {

                                 // I don't think that this is a valid mailcap
                                 // entry, but try to interpret it somehow
                                 // I don't think that this is a valid mailcap
                                 // entry, but try to interpret it somehow

-                                strType = _T('*');
+                                data.type = _T('*');

                             }
 
                             }
 

-                            if ( strType.Find(wxT('/')) == wxNOT_FOUND ) {
+                            if ( data.type.Find(wxT('/')) == wxNOT_FOUND )
+                            {

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

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

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

-                            strOpenCmd = curField;
-                            entry = new wxMimeArrayString ();
-                            entry->Add(wxT("open=")  + strOpenCmd);
+                            data.cmdOpen = curField;

 
                             currentToken = Field_Other;
                             break;
 
                         case Field_Other:
 
                             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()
-                                        );
-
-                                            }
-
-                                        }
-
-                                    }
-
-                                }
-
+                            if ( !ProcessOtherMailcapField(data, curField) )
+                            {
+                                // don't flood the user with error messages if
+                                // we don't understand something in his
+                                // mailcap, but give them in debug mode because
+                                // this might be useful for the programmer
+                                wxLogDebug
+                                (
+                                    wxT("Mailcap file %s, line %lu: unknown field '%s' for the MIME type '%s' ignored."),
+                                    strFileName.c_str(),
+                                    (unsigned long)nLine + 1,
+                                    curField.c_str(),
+                                    data.type.c_str()
+                                );
+                            }
+                            else if ( data.testfailed )
+                            {
+                                // skip this entry entirely
+                                cont = false;

                             }
                             }

-

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


@@ -2408,80 +2661,92 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
             pc++;
         }
 
             pc++;
         }
 

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

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

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

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

+
+            continue;

         }
         }

-        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 );
+        // if the test command failed, it's as if the entry were not there at
+        // all
+        if ( data.testfailed )
+        {
+            continue;
+        }

 
 

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

 
 

-            // 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;
-                }
+        if ( data.needsterminal )
+        {
+            data.cmdOpen = wxString::Format(_T("xterm -e sh -c '%s'"),
+                                            data.cmdOpen.c_str());
+        }

 
 

+        if ( !data.cmdOpen.empty() )
+        {
+            data.verbs.Insert(_T("open"), 0);
+            data.commands.Insert(data.cmdOpen, 0);
+        }

 
 

-                }
-                wxArrayString strExtensions;
-                AddToMimeData (strType, strIcon, entry, strExtensions, strDesc, !overwrite );
-                test_passed = TRUE;
-            }
+        // we have to decide whether the new entry should replace any entries
+        // for the same MIME type we had previously found or not
+        bool overwrite;
+
+        // the fall back entries have the lowest priority, by definition
+        if ( fallback )
+        {
+            overwrite = false;
+        }
+        else
+        {
+            // have we seen this one before?
+            int nIndex = m_aTypes.Index(data.type);
+
+            // and if we have, was it in this file? if not, we should
+            // overwrite the previously seen one
+            overwrite = nIndex == wxNOT_FOUND ||
+                            aIndicesSeenHere.Index(nIndex) == wxNOT_FOUND;

         }
 
         }
 

+        wxLogTrace(TRACE_MIME, _T("mailcap %s: %s [%s]"),
+                   data.type.c_str(), data.cmdOpen.c_str(),
+                   overwrite ? _T("replace") : _T("add"));
+
+        int n = AddToMimeData
+                (
+                    data.type,
+                    data.icon,
+                    new wxMimeTypeCommands(data.verbs, data.commands),
+                    wxArrayString() /* extensions */,
+                    data.desc,
+                    overwrite
+                );
+
+        if ( overwrite )
+        {
+            aIndicesSeenHere.Add(n);
+        }

     }
 
     }
 

-    return TRUE;
+    return true;

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


@@ -2523,16 +2788,16 @@ bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
         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);
+            WriteMimeInfo(nIndex, true );
+            m_aTypes.RemoveAt(nIndex);
+            m_aEntries.RemoveAt(nIndex);
+            m_aExtensions.RemoveAt(nIndex);
+            m_aDescriptions.RemoveAt(nIndex);
+            m_aIcons.RemoveAt(nIndex);

         }
     }
     // check data integrity
         }
     }
     // check data integrity


@@ -2541,7 +2806,7 @@ bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
             m_aTypes.Count() == m_aIcons.Count() &&
             m_aTypes.Count() == m_aDescriptions.Count() );
 
             m_aTypes.Count() == m_aIcons.Count() &&
             m_aTypes.Count() == m_aDescriptions.Count() );
 

-    return TRUE;
+    return true;

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


@@ -2561,12 +2826,12 @@ static bool IsKnownUnimportantField(const wxString& fieldAll)
     for ( size_t n = 0; n < WXSIZEOF(knownFields); n++ )
     {
         if ( field.CmpNoCase(knownFields[n]) == 0 )
     for ( size_t n = 0; n < WXSIZEOF(knownFields); n++ )
     {
         if ( field.CmpNoCase(knownFields[n]) == 0 )

-            return TRUE;
+            return true;

     }
 
     }
 

-    return FALSE;
+    return false;

 }
 
 #endif
 }
 
 #endif

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