Applied [ 1613294 ] wxGetMouseState/wxIsKeyDown bug

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

diff --git a/src/unix/mimetype.cpp b/src/unix/mimetype.cpp
index d5f44157847b65a1c491d3169d2f1d785d534b98..9aa4adaf07e89b71778203c43c9036a59f1c2dc5 100644 (file)
--- a/src/unix/mimetype.cpp
+++ b/src/unix/mimetype.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        unix/mimetype.cpp
+// Name:        src/unix/mimetype.cpp

 // Purpose:     classes and functions to manage MIME types
 // Author:      Vadim Zeitlin
 // Modified by:
 // Purpose:     classes and functions to manage MIME types
 // Author:      Vadim Zeitlin
 // Modified by:


@@ -27,209 +27,133 @@
 //    will be preserved during unassociate
 // 9) KDE does not yet handle multiple actions; Netscape mode never will
 
 //    will be preserved during unassociate
 // 9) KDE does not yet handle multiple actions; Netscape mode never will
 

-/*
-    TODO: this file is a mess, we need to split it and reformet/review
-          everything (VZ)
- */
-
-// ============================================================================
-// declarations
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "mimetype.h"
-#endif
+// TODO: this file is a mess, we need to split it and review everything (VZ)

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

-  #pragma hdrstop
-#endif
-
-#ifndef WX_PRECOMP
-  #include "wx/defs.h"
+    #pragma hdrstop

 #endif
 
 #if wxUSE_MIMETYPE && wxUSE_FILE && wxUSE_TEXTFILE
 
 #endif
 
 #if wxUSE_MIMETYPE && wxUSE_FILE && wxUSE_TEXTFILE
 

-#ifndef WX_PRECOMP
-  #include "wx/string.h"
-#endif //WX_PRECOMP
+#include "wx/unix/mimetype.h"

 
 

+#ifndef WX_PRECOMP
+    #include "wx/dynarray.h"
+    #include "wx/string.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"
+    #include "wx/utils.h"
+#endif

 
 

-#include "wx/log.h"

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

-#include "wx/intl.h"
-#include "wx/dynarray.h"

 #include "wx/confbase.h"
 
 #include "wx/ffile.h"
 #include "wx/textfile.h"
 #include "wx/dir.h"
 #include "wx/confbase.h"
 
 #include "wx/ffile.h"
 #include "wx/textfile.h"
 #include "wx/dir.h"

-#include "wx/utils.h"

 #include "wx/tokenzr.h"
 #include "wx/iconloc.h"
 #include "wx/tokenzr.h"
 #include "wx/iconloc.h"

+#include "wx/filename.h"
+#include "wx/app.h"
+#include "wx/apptrait.h"

 
 

-#include "wx/unix/mimetype.h"
+#if wxUSE_LIBGNOMEVFS
+    // Not GUI dependent
+    #include "wx/gtk/gnome/gvfs.h"
+#endif

 
 // other standard headers
 #include <ctype.h>
 
 
 // other standard headers
 #include <ctype.h>
 

-#ifdef __VMS
-/* silence warnings for comparing unsigned int's <0 */
-# pragma message disable unscomzer
-#endif
-
-// wxMimeTypeCommands stores the verbs defined for the given MIME type with
-// their values
-class wxMimeTypeCommands
-{
-public:
-    wxMimeTypeCommands() { }
-
-    wxMimeTypeCommands(const wxArrayString& verbs,
-                       const wxArrayString& commands)
-        : m_verbs(verbs),
-          m_commands(commands)
-    {
-    }
-
-    // add a new verb with the command or replace the old value
-    void AddOrReplaceVerb(const wxString& verb, const wxString& cmd)
-    {
-        int n = m_verbs.Index(verb, FALSE /* ignore case */);
-        if ( n == wxNOT_FOUND )
-        {
-            m_verbs.Add(verb);
-            m_commands.Add(cmd);
-        }
-        else
-        {
-            m_commands[n] = cmd;
-        }
-    }
-
-    void Add(const wxString& s)
-    {
-        m_verbs.Add(s.BeforeFirst(_T('=')));
-        m_commands.Add(s.AfterFirst(_T('=')));
-    }
-
-    // access the commands
-    size_t GetCount() const { return m_verbs.GetCount(); }
-    const wxString& GetVerb(size_t n) const { return m_verbs[n]; }
-    const wxString& GetCmd(size_t n) const { return m_commands[n]; }
-
-    bool HasVerb(const wxString& verb) const
-        { return m_verbs.Index(verb) != wxNOT_FOUND; }
-
-    wxString GetCommandForVerb(const wxString& verb, size_t *idx = NULL) const
-    {
-        wxString s;
-
-        int n = m_verbs.Index(verb);
-        if ( n != wxNOT_FOUND )
-        {
-            s = m_commands[(size_t)n];
-            if ( idx )
-                *idx = n;
-        }
-
-        return s;
-    }
-
-    // get a "verb=command" string
-    wxString GetVerbCmd(size_t n) const
-    {
-        return m_verbs[n] + _T('=') + m_commands[n];
-    }
-
-private:
-    wxArrayString m_verbs,
-                  m_commands;
-};
-
-// this class extends wxTextFile
+// this class is a wxTextFile specialization for dealing with files storing
+// various MIME-related information

 //
 //

-// VZ: ???
+// it should be used instead of wxTextFile even if none of its additional
+// methods are used just because it handles files with mixed encodings (often
+// the case for MIME files which contain strings for different languages)
+// correctly, see OnRead()

 class wxMimeTextFile : public wxTextFile
 {
 public:
     // constructors
 class wxMimeTextFile : public wxTextFile
 {
 public:
     // constructors

-    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;
-        if (i>=GetLineCount()) return wxNOT_FOUND;
-

         wxString sTest = sSearch;
         sTest.MakeLower();
         wxString sTest = sSearch;
         sTest.MakeLower();

-        wxString sLine;
-
-        if (bIncludeComments)
+        for(size_t i = iStart; i < GetLineCount(); i++)

         {
         {

-            while ( (i < GetLineCount())   )
+            wxString sLine = GetLine(i).Trim(false);
+            if(bIncludeComments || ! sLine.StartsWith(wxT("#")))

             {
             {

-                sLine = GetLine (i);

                 sLine.MakeLower();
                 sLine.MakeLower();

-                if (sLine.Contains(sTest)) nResult = (int) i;
-                i++;
+                if(sLine.StartsWith(sTest))
+                    return (int)i;

             }
         }
             }
         }

-        else
-        {
-            while ( (i < GetLineCount()) )
-            {
-                sLine = GetLine (i);
-                sLine.MakeLower();
-                if ( ! sLine.StartsWith(wxT("#")))
-                {
-                    if (sLine.Contains(sTest)) nResult = (int) i;
-                }
-                i++;
-            }
-        }
-        return  nResult;
+        return wxNOT_FOUND;

     }
 
     bool CommentLine(int nIndex)
     {
     }
 
     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 > GetLineCount() ) return wxEmptyString;
+        if (i > GetLineCount() )
+            return wxEmptyString;
+

         wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
         return sTmp;
     }
 
         wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
         return sTmp;
     }
 

-    wxString GetCmd (size_t i)
+    wxString GetCmd(size_t i)

     {
     {

-        if (i > GetLineCount() ) return wxEmptyString;
+        if (i > GetLineCount() )
+            return wxEmptyString;
+

         wxString sTmp = GetLine(i).AfterFirst(wxT('='));
         return sTmp;
     }
         wxString sTmp = GetLine(i).AfterFirst(wxT('='));
         return sTmp;
     }

+
+protected:
+    // we override this virtual method because we want to always use UTF-8
+    // conversion allowing for invalid characters as MIME information files
+    // often contain lines in different encodings and can't be read using any
+    // single conversion in Unicode build, so we just try to read what we can
+    // suing the most common encoding (UTF-8 is almost ubiquitous nowadays) and
+    // ignore the rest
+    virtual bool OnRead(const wxMBConv& WXUNUSED(conv))
+    {
+        return wxTextFile::OnRead(
+                    wxMBConvUTF8(wxMBConvUTF8::MAP_INVALID_UTF8_TO_PUA));
+    }

 };
 
 // in case we're compiling in non-GUI mode
 };
 
 // in case we're compiling in non-GUI mode


@@ -240,10 +164,10 @@ class WXDLLEXPORT wxIcon;
 // ----------------------------------------------------------------------------
 
 // MIME code tracing mask
 // ----------------------------------------------------------------------------
 
 // MIME code tracing mask

-#define TRACE_MIME _T("mime")
+#define TRACE_MIME wxT("mime")

 
 // give trace messages about the results of mailcap tests
 
 // give trace messages about the results of mailcap tests

-#define TRACE_MIME_TEST _T("mimetest")
+#define TRACE_MIME_TEST wxT("mimetest")

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


@@ -343,267 +267,118 @@ static bool IsKnownUnimportantField(const wxString& field);
 //  1. xxx.keys files under /usr/share/mime-info
 //  2. xxx.keys files under ~/.gnome/mime-info
 //
 //  1. xxx.keys files under /usr/share/mime-info
 //  2. xxx.keys files under ~/.gnome/mime-info
 //

-// The format of xxx.keys file is the following:
-//
-// mimetype/subtype:
-//      field=value
-//
-// with blank lines separating the entries and indented lines starting with
-// TABs. We're interested in the field icon-filename whose value is the path
-// containing the icon.
-//

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

-bool wxMimeTypesManagerImpl::CheckGnomeDirsExist ()
-{
-    wxString gnomedir;
-    wxGetHomeDir( &gnomedir );
-    wxString sTmp = gnomedir;
-    sTmp = sTmp + wxT("/.gnome");
-    if (! wxDir::Exists ( sTmp ) )
-    {
-        if (!wxMkdir ( sTmp ))
-        {
-            wxLogError(_("Failed to create directory %s/.gnome."), sTmp.c_str());
-            return FALSE;
-        }
-    }
-    sTmp = sTmp + wxT("/mime-info");
-    if (! wxDir::Exists ( sTmp ) )
-    {
-        if (!wxMkdir ( sTmp ))
-        {
-            wxLogError(_("Failed to create directory %s/mime-info."), sTmp.c_str());
-            return FALSE;
-        }
-    }
-    return TRUE;
-
-}
-
-
-
-bool wxMimeTypesManagerImpl::WriteGnomeKeyFile(int index, bool delete_index)
-{
-    wxString gnomedir;
-    wxGetHomeDir( &gnomedir );
-
-    wxMimeTextFile outfile ( gnomedir + wxT("/.gnome/mime-info/user.keys"));
-    // if this fails probably Gnome is not installed ??
-    // create it anyway as a private mime store
-
-#if defined(__WXGTK20__) && wxUSE_UNICODE
-    if (! outfile.Open ( wxConvUTF8) )
-#else
-    if (! outfile.Open () )
-#endif
-    {
-        if (delete_index) return FALSE;
-        if (!CheckGnomeDirsExist() ) return FALSE;
-        outfile.Create ();
-    }
-
-    wxString sTmp, strType = m_aTypes[index];
-    int nIndex = outfile.pIndexOf(strType);
-    if ( nIndex == wxNOT_FOUND )
-    {
-        outfile.AddLine ( strType + wxT(':') );
-        // see file:/usr/doc/gnome-libs-devel-1.0.40/devel-docs/mime-type-handling.txt
-        // as this does not deal with internationalisation
-        //        wxT( "\t[en_US]") + verb + wxT ('=') + cmd + wxT(" %f");
-        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 );
-        }
-        //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);
-
-        wxMimeTypeCommands sOld;
-        size_t nOld = nIndex + 1;
-        bool oldEntryEnd = FALSE;
-        while ( (nOld < outfile.GetLineCount() )&& (oldEntryEnd == FALSE ))
-        {
-            sTmp = outfile.GetLine(nOld);
-            if ( (sTmp[0u] == wxT('\t')) || (sTmp[0u] == wxT('#')) )
-            {
-                // we have another line to deal with
-                outfile.CommentLine(nOld);
-                nOld ++;
-                // add the line to our store
-                if ((!delete_index) && (sTmp[0u] == wxT('\t')))
-                    sOld.Add(sTmp);
-            }
-            // next mimetpye ??or blank line
-            else
-                oldEntryEnd = TRUE;
-        }
-        // list of entries in our data; these should all be in sOld,
-        // though sOld may also contain other entries , eg flags
-        if (!delete_index)
-        {
-            wxMimeTypeCommands * entries = m_aEntries[index];
-            size_t i;
-            for (i=0; i < entries->GetCount(); i++)
-            {
-                // replace any entries in sold that match verbs we know
-                sOld.AddOrReplaceVerb ( entries->GetVerb(i), entries->GetCmd (i) );
-            }
-            //sOld should also contain the icon
-            if ( !m_aIcons[index].empty() )
-                sOld.AddOrReplaceVerb ( wxT("icon-filename"), m_aIcons[index] );
-
-            for (i=0; i < sOld.GetCount(); i++)
-            {
-                sTmp = sOld.GetVerbCmd(i);
-                sTmp.Replace( wxT("%s"), wxT("%f") );
-                sTmp = wxT("\t") + sTmp;
-                nIndex ++;
-                outfile.InsertLine ( sTmp, nIndex );
-            }
-        }
-    }
-    bool bTmp = outfile.Write ();
-    return bTmp;
-}
-
-
-bool wxMimeTypesManagerImpl::WriteGnomeMimeFile(int index, bool delete_index)
-{
-    wxString gnomedir;
-    wxGetHomeDir( &gnomedir );
-
-    wxMimeTextFile outfile ( gnomedir + wxT("/.gnome/mime-info/user.mime"));
-    // if this fails probably Gnome is not installed ??
-    // create it anyway as a private mime store
-    if (! outfile.Open () )
-    {
-        if (delete_index) return FALSE;
-        if (!CheckGnomeDirsExist() ) return FALSE;
-        outfile.Create ();
-    }
-    wxString strType = m_aTypes[index];
-    int nIndex = outfile.pIndexOf(strType);
-    if ( nIndex == wxNOT_FOUND )
-    {
-        outfile.AddLine ( strType );
-        outfile.AddLine ( wxT("\text:") + m_aExtensions.Item(index) );
-    }
-    else
-    {
-        if (delete_index)
-        {
-            outfile.CommentLine(nIndex);
-            outfile.CommentLine(nIndex+1);
-        }
-        else
-        {// check for next line being the right one to replace ??
-            wxString sOld = outfile.GetLine(nIndex+1);
-            if (sOld.Contains( wxT("\text: ")))
-            {
-                outfile.GetLine(nIndex+1) = wxT("\text: ") + m_aExtensions.Item(index);
-            }
-            else
-            {
-                outfile.InsertLine( wxT("\text: ") + m_aExtensions.Item(index), nIndex + 1 );
-            }
-        }
-    }
-    bool bTmp = outfile.Write ();
-    return bTmp;
-}
-
-

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

-    wxTextFile textfile(filename);
-#if defined(__WXGTK20__) && wxUSE_UNICODE
-    if ( !textfile.Open( wxConvUTF8) )
-#else
+    wxMimeTextFile textfile(filename);

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

-#endif

         return;
         return;

+

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

+    wxArrayString search_dirs( dirs );
+

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

-    // these are always empty in this file

     wxArrayString strExtensions;
     wxString strDesc;
 
     const wxChar *pc;
     size_t nLineCount = textfile.GetLineCount();
     size_t nLine = 0;
     wxArrayString strExtensions;
     wxString strDesc;
 
     const wxChar *pc;
     size_t nLineCount = textfile.GetLineCount();
     size_t nLine = 0;

-    while ( nLine < nLineCount)
+    while ( nLine < nLineCount )

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

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

         {
 
             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);
+
+            // trim trailing space and tab
+            while ((*pc == wxT(' ')) || (*pc == wxT('\t')))
+                pc++;

 
             wxString sTmp(pc);
 
             wxString sTmp(pc);

-            if (sTmp.Contains(wxT("=")) )
+            int equal_pos = sTmp.Find( wxT('=') );
+            if (equal_pos > 0)

             {
             {

-                // GNOME 1:
-                if (sTmp.Contains( wxT("icon-filename=") ) )
-                {
-                    curIconFile = sTmp.AfterFirst(wxT('='));
-                }
-                // GNOME 2:
-                else if (sTmp.Contains( wxT("icon_filename=") ) )
+                wxString left_of_equal = sTmp.Left( equal_pos );
+                const wxChar *right_of_equal = pc;
+                right_of_equal += equal_pos+1;
+
+                if (left_of_equal == wxT("icon_filename"))

                 {
                 {

-                    curIconFile = sTmp.AfterFirst(wxT('='));
-                    if (!wxFileExists(curIconFile))
+                    // GNOME 2:
+                    curIconFile = right_of_equal;
+
+                    wxFileName newFile( curIconFile );
+                    if (newFile.IsRelative() || newFile.FileExists())

                     {
                     {

-                        size_t nDirs = dirs.GetCount();
+                        size_t nDirs = search_dirs.GetCount();
+

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

-                            wxString newFile;
-                            newFile.Printf(wxT("%s/pixmaps/document-icons/%s.png"),
-                                           dirs[nDir].c_str(),
-                                           curIconFile.c_str());
-                            if (wxFileExists(newFile))
-                                curIconFile = newFile;
+                            newFile.SetPath( search_dirs[nDir] );
+                            newFile.AppendDir( wxT("pixmaps") );
+                            newFile.AppendDir( wxT("document-icons") );
+                            newFile.SetExt( wxT("png") );
+                            if (newFile.FileExists())
+                            {
+                                curIconFile = newFile.GetFullPath();
+                                // reorder search_dirs for speedup (fewer
+                                // calls to FileExist() required)
+                                if (nDir != 0)
+                                {
+                                    const wxString &tmp = search_dirs[nDir];
+                                    search_dirs.RemoveAt( nDir );
+                                    search_dirs.Insert( tmp, 0 );
+                                }
+                                break;
+                            }

                         }
                     }
                 }
                         }
                     }
                 }

-                else //: some other field,
+                else if (left_of_equal == wxT("open"))

                 {
                 {

-                    //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");
+                    sTmp = right_of_equal;
+                    sTmp.Replace( wxT("%f"), wxT("%s") );
+                    sTmp.Prepend( wxT("open=") );
+                    entry->Add(sTmp);
+                }
+                else if (left_of_equal == wxT("view"))
+                {
+                    sTmp = right_of_equal;
+                    sTmp.Replace( wxT("%f"), wxT("%s") );
+                    sTmp.Prepend( wxT("view=") );
+                    entry->Add(sTmp);
+                }
+                else if (left_of_equal == wxT("print"))
+                {
+                    sTmp = right_of_equal;
+                    sTmp.Replace( wxT("%f"), wxT("%s") );
+                    sTmp.Prepend( wxT("print=") );
+                    entry->Add(sTmp);
+                }
+                else if (left_of_equal == wxT("description"))
+                {
+                    strDesc = right_of_equal;
+                }
+                else if (left_of_equal == wxT("short_list_application_ids_for_novice_user_level"))
+                {
+                    sTmp = right_of_equal;
+                    if (sTmp.Contains( wxT(",") ))
+                        sTmp = sTmp.BeforeFirst( wxT(',') );
+                    sTmp.Prepend( wxT("open=") );
+                    sTmp.Append( wxT(" %s") );

                     entry->Add(sTmp);
                     entry->Add(sTmp);

-

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


@@ -616,30 +391,30 @@ void wxMimeTypesManagerImpl::LoadGnomeDataFromKeyFile(const wxString& filename,
                     // overwrite any existing data
                     if (! curMimeType.empty())
                     {
                     // overwrite any existing data
                     if (! curMimeType.empty())
                     {

-                        AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
+                        AddToMimeData( curMimeType, curIconFile, entry, strExtensions, strDesc );

 
                         // now get ready for next bit
                         entry = new wxMimeTypeCommands;
                     }
 
                         // now get ready for next bit
                         entry = new wxMimeTypeCommands;
                     }

+

                     curMimeType = sTmp.BeforeFirst(wxT(':'));
                 }
             }
         } // end of not a comment
                     curMimeType = sTmp.BeforeFirst(wxT(':'));
                 }
             }
         } // end of not a comment

+

         // ignore blank lines
         // ignore blank lines

-        nLine ++;
+        nLine++;

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

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

 
 

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

 }
 
 }
 

-
-

 void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& filename)
 {
 void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& filename)
 {

-    wxTextFile textfile(filename);
+    wxMimeTextFile textfile(filename);

     if ( !textfile.Open() )
         return;
 
     if ( !textfile.Open() )
         return;
 


@@ -652,7 +427,7 @@ void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& file
 
     const wxChar *pc;
     size_t nLineCount = textfile.GetLineCount();
 
     const wxChar *pc;
     size_t nLineCount = textfile.GetLineCount();

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

     {
         if ( nLine < nLineCount )
         {
     {
         if ( nLine < nLineCount )
         {


@@ -672,7 +447,7 @@ 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  ---"),
             {
                  wxLogTrace(TRACE_MIME,
                             wxT("--- At end of Gnome file  finding mimetype %s  ---"),


@@ -683,7 +458,7 @@ void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& file
 
             if ( !pc )
             {
 
             if ( !pc )
             {

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

                 break;
             }
 
                 break;
             }
 


@@ -730,8 +505,8 @@ void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& file
 void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(
                       const wxString& dirbase, const wxArrayString& dirs)
 {
 void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(
                       const wxString& dirbase, const wxArrayString& dirs)
 {

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

 
     wxString dirname = dirbase;
     dirname << wxT("/mime-info");
 
     wxString dirname = dirbase;
     dirname << wxT("/mime-info");


@@ -747,7 +522,9 @@ void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(
     dirname += wxT('/');
 
     wxString filename;
     dirname += wxT('/');
 
     wxString filename;

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

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


@@ -755,29 +532,74 @@ void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(
         cont = dir.GetNext(&filename);
     }
 
         cont = dir.GetNext(&filename);
     }
 

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

     while ( cont )
     {
         LoadGnomeDataFromKeyFile(dirname + filename, dirs);
 
         cont = dir.GetNext(&filename);
     }
     while ( cont )
     {
         LoadGnomeDataFromKeyFile(dirname + filename, dirs);
 
         cont = dir.GetNext(&filename);
     }

-}

 
 

+    // FIXME: 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) )
+    {
+        // Just 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)
 {
     wxArrayString dirs;
 
 void wxMimeTypesManagerImpl::GetGnomeMimeInfo(const wxString& sExtraDir)
 {
     wxArrayString dirs;

+
+    wxString gnomedir = wxGetenv( wxT("GNOMEDIR") );
+    if (!gnomedir.empty())
+    {
+        gnomedir << wxT("/share");
+        dirs.Add( gnomedir );
+    }
+

     dirs.Add(wxT("/usr/share"));
     dirs.Add(wxT("/usr/local/share"));
 
     dirs.Add(wxT("/usr/share"));
     dirs.Add(wxT("/usr/local/share"));
 

-    wxString gnomedir;
-    wxGetHomeDir( &gnomedir );
-    gnomedir += wxT("/.gnome");
+    gnomedir = wxGetHomeDir();
+    gnomedir << wxT("/.gnome");

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

-    if (!sExtraDir.empty()) 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++ )


@@ -804,20 +626,19 @@ 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.empty())

-        {
-            if (wxDir::Exists(sOK)) return TRUE;
-            else return FALSE;
-        }
+    {
+        return wxDir::Exists(sOK);
+    }

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

     }
 }
 
     }
 }
 


@@ -827,29 +648,31 @@ bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index)
     wxString sHome = wxGetHomeDir();
     wxString sTmp = wxT(".kde/share/mimelnk/");
     wxString sMime = m_aTypes[index];
     wxString sHome = wxGetHomeDir();
     wxString sTmp = wxT(".kde/share/mimelnk/");
     wxString sMime = m_aTypes[index];

-    CheckKDEDirsExist (sHome, sTmp + sMime.BeforeFirst(wxT('/')) );
+    CheckKDEDirsExist(sHome, sTmp + sMime.BeforeFirst(wxT('/')) );

     sTmp = sHome + wxT('/') + sTmp + sMime + wxT(".kdelnk");
 
     bool bTemp;
     sTmp = sHome + wxT('/') + sTmp + sMime + wxT(".kdelnk");
 
     bool bTemp;

-    bool bMimeExists = mimeoutfile.Open (sTmp);
+    bool bMimeExists = mimeoutfile.Open(sTmp);

     if (!bMimeExists)
     {
     if (!bMimeExists)
     {

-        bTemp = mimeoutfile.Create (sTmp);
+        bTemp = mimeoutfile.Create(sTmp);

         // some unknown error eg out of disk space
         // some unknown error eg out of disk space

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

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

-    CheckKDEDirsExist (sHome, sTmp + sMime.AfterFirst(wxT('/')) );
+    CheckKDEDirsExist(sHome, sTmp + sMime.AfterFirst(wxT('/')) );

     sTmp = sHome + wxT('/') + sTmp + sMime.AfterFirst(wxT('/')) + wxT(".kdelnk");
 
     bool bAppExists;
     sTmp = sHome + wxT('/') + sTmp + sMime.AfterFirst(wxT('/')) + wxT(".kdelnk");
 
     bool bAppExists;

-    bAppExists = appoutfile.Open (sTmp);
+    bAppExists = appoutfile.Open(sTmp);

     if (!bAppExists)
     {
     if (!bAppExists)
     {

-        bTemp = appoutfile.Create (sTmp);
+        bTemp = appoutfile.Create(sTmp);

         // some unknown error eg out of disk space
         // 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


@@ -884,49 +707,55 @@ bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index)
     // we can either give the full path, or the shortfilename if its in
     // one of the directories we search
     mimeoutfile.CommentLine(wxT("Icon=") );
     // we can either give the full path, or the shortfilename if its in
     // one of the directories we search
     mimeoutfile.CommentLine(wxT("Icon=") );

-    if (!delete_index) mimeoutfile.AddLine(wxT("Icon=") + sTmp );
-    appoutfile.CommentLine(wxT("Icon=")  );
-    if (!delete_index) appoutfile.AddLine(wxT("Icon=") + sTmp );
+    if (!delete_index)
+        mimeoutfile.AddLine(wxT("Icon=") + sTmp );
+    appoutfile.CommentLine(wxT("Icon=") );
+    if (!delete_index)
+        appoutfile.AddLine(wxT("Icon=") + sTmp );

 
     sTmp = wxT(" ") + m_aExtensions[index];
 
 
     sTmp = wxT(" ") + m_aExtensions[index];
 

-    wxStringTokenizer tokenizer(sTmp, _T(" "));
+    wxStringTokenizer tokenizer(sTmp, wxT(" "));

     sTmp = wxT("Patterns=");
     mimeoutfile.CommentLine(sTmp);
     while ( tokenizer.HasMoreTokens() )
     {
         // holds an extension; need to change it to *.ext;
         wxString e = wxT("*.") + tokenizer.GetNextToken() + wxT(";");
     sTmp = wxT("Patterns=");
     mimeoutfile.CommentLine(sTmp);
     while ( tokenizer.HasMoreTokens() )
     {
         // holds an extension; need to change it to *.ext;
         wxString e = wxT("*.") + tokenizer.GetNextToken() + wxT(";");

-        sTmp = sTmp + e;
+        sTmp += e;

     }
     }

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

 
     wxMimeTypeCommands * entries = m_aEntries[index];
     // if we don't find open just have an empty string ... FIX this
 
     wxMimeTypeCommands * entries = m_aEntries[index];
     // if we don't find open just have an empty string ... FIX this

-    sTmp = entries->GetCommandForVerb(_T("open"));
+    sTmp = entries->GetCommandForVerb(wxT("open"));

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

-    if (!delete_index) mimeoutfile.AddLine(wxT("DefaultApp=") + sTmp);
+    if (!delete_index)
+        mimeoutfile.AddLine(wxT("DefaultApp=") + sTmp);

 
     sTmp.Replace( wxT("%f"), wxT("") );
     appoutfile.CommentLine(wxT("Exec="));
 
     sTmp.Replace( wxT("%f"), wxT("") );
     appoutfile.CommentLine(wxT("Exec="));

-    if (!delete_index) appoutfile.AddLine(wxT("Exec=") + sTmp);
+    if (!delete_index)
+        appoutfile.AddLine(wxT("Exec=") + sTmp);

 
     if (entries->GetCount() > 1)
     {
         //other actions as well as open
 
     if (entries->GetCount() > 1)
     {
         //other actions as well as open

-

     }
     }

-    bTemp = FALSE;
-    if (mimeoutfile.Write ()) bTemp = TRUE;
-    mimeoutfile.Close ();
-    if (appoutfile.Write ()) bTemp = TRUE;
-    appoutfile.Close ();
-
-    return bTemp;

 
 

+    bTemp = false;
+    if (mimeoutfile.Write())
+        bTemp = true;
+    mimeoutfile.Close();
+    if (appoutfile.Write())
+        bTemp = true;
+    appoutfile.Close();

 
 

+    return bTemp;

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


@@ -934,12 +763,14 @@ void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,
                                                const wxString& filename,
                                                const wxArrayString& icondirs)
 {
                                                const wxString& filename,
                                                const wxArrayString& icondirs)
 {

+    wxFileName fullname(dirbase, filename);
+    wxLogTrace(TRACE_MIME, wxT("loading KDE file %s"),
+                           fullname.GetFullPath().c_str());
+

     wxMimeTextFile file;
     wxMimeTextFile file;

-    if ( !file.Open(dirbase + filename) ) return;
+    if ( !file.Open(fullname.GetFullPath()) )
+        return;

 
 

-    wxLogTrace(TRACE_MIME, wxT("loading KDE file %s"),
-                           (dirbase+filename).c_str());
-    

     wxMimeTypeCommands * entry = new wxMimeTypeCommands;
     wxArrayString sExts;
     wxString mimetype, mime_desc, strIcon;
     wxMimeTypeCommands * entry = new wxMimeTypeCommands;
     wxArrayString sExts;
     wxString mimetype, mime_desc, strIcon;


@@ -951,67 +782,74 @@ void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,
         // file (it always has .kdelnk extension)
         mimetype << subdir << wxT('/') << filename.BeforeLast( wxT('.') );
     }
         // file (it always has .kdelnk extension)
         mimetype << subdir << wxT('/') << filename.BeforeLast( wxT('.') );
     }

-    else mimetype = file.GetCmd (nIndex);
+    else
+        mimetype = file.GetCmd(nIndex);

 
     // first find the description string: it is the value in either "Comment="
     // line or "Comment[<locale_name>]=" one
     nIndex = wxNOT_FOUND;
 
     wxString comment;
 
     // first find the description string: it is the value in either "Comment="
     // line or "Comment[<locale_name>]=" one
     nIndex = wxNOT_FOUND;
 
     wxString comment;

+

 #if wxUSE_INTL
     wxLocale *locale = wxGetLocale();
     if ( locale )
     {
         // try "Comment[locale name]" first
 #if wxUSE_INTL
     wxLocale *locale = wxGetLocale();
     if ( locale )
     {
         // try "Comment[locale name]" first

-        comment << _T("Comment[") + locale->GetName() + _T("]=");
+        comment << wxT("Comment[") + locale->GetName() + wxT("]=");

         nIndex = file.pIndexOf(comment);
     }
         nIndex = file.pIndexOf(comment);
     }

-#endif // wxUSE_INTL
+#endif

 
     if ( nIndex == wxNOT_FOUND )
     {
 
     if ( nIndex == wxNOT_FOUND )
     {

-        comment = _T("Comment=");
+        comment = wxT("Comment=");

         nIndex = file.pIndexOf(comment);
     }
 
         nIndex = file.pIndexOf(comment);
     }
 

-    if ( nIndex != wxNOT_FOUND ) mime_desc = file.GetCmd(nIndex);
+    if ( nIndex != wxNOT_FOUND )
+        mime_desc = file.GetCmd(nIndex);

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

-    nIndex = file.pIndexOf(_T("Patterns="));
+    nIndex = file.pIndexOf(wxT("Patterns="));

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

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

 
 

-        wxStringTokenizer tokenizer(exts, _T(";"));
+        wxStringTokenizer tokenizer(exts, wxT(";"));

         while ( tokenizer.HasMoreTokens() )
         {
             wxString e = tokenizer.GetNextToken();
         while ( tokenizer.HasMoreTokens() )
         {
             wxString e = tokenizer.GetNextToken();

-            if ( e.Left(2) != _T("*.") )
-                continue; // don't support too difficult patterns
+
+            // don't support too difficult patterns
+            if ( e.Left(2) != wxT("*.") )
+                continue;

 
             if ( !mime_extension.empty() )
             {
                 // separate from the previous ext
 
             if ( !mime_extension.empty() )
             {
                 // separate from the previous ext

-                mime_extension << _T(' ');
+                mime_extension << wxT(' ');

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

-    sExts.Add(mime_extension);

 
 

+    sExts.Add(mime_extension);

 
     // ok, now we can take care of icon:
 
 
     // ok, now we can take care of icon:
 

-    nIndex = file.pIndexOf(_T("Icon="));
+    nIndex = file.pIndexOf(wxT("Icon="));

     if ( nIndex != wxNOT_FOUND )
     {
         strIcon = file.GetCmd(nIndex);
     if ( nIndex != wxNOT_FOUND )
     {
         strIcon = file.GetCmd(nIndex);

+

         wxLogTrace(TRACE_MIME, wxT("  icon %s"), strIcon.c_str());
         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))
         {
             // icon is just the short name
         if (!wxFileExists(strIcon))
         {
             // icon is just the short name


@@ -1021,15 +859,21 @@ void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,
                 // in many locations, at least ~/.kde and $KDEDIR
                 size_t nDir, nDirs = icondirs.GetCount();
                 for ( nDir = 0; nDir < nDirs; nDir++ )
                 // 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))
+                {
+                    wxFileName fnameIcon( strIcon );
+                    wxFileName fname( icondirs[nDir], fnameIcon.GetName() );
+                    fname.SetExt( wxT("png") );
+                    if (fname.FileExists())

                     {
                     {

-                        strIcon.Prepend(icondirs[nDir]);
+                        strIcon = fname.GetFullPath();

                         wxLogTrace(TRACE_MIME, wxT("  iconfile %s"), strIcon.c_str());
                         break;
                     }
                         wxLogTrace(TRACE_MIME, wxT("  iconfile %s"), strIcon.c_str());
                         break;
                     }

+                }

             }
         }
     }
             }
         }
     }

+

     // now look for lines which know about the application
     // exec= or DefaultApp=
 
     // now look for lines which know about the application
     // exec= or DefaultApp=
 


@@ -1043,68 +887,56 @@ void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,
 
     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
         // 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->AddOrReplaceVerb (wxString(wxT("open")), sTmp );
+        wxString sTmp = file.GetCmd(nIndex);
+        if (0 == sTmp.Replace( wxT("%f"), wxT("%s") ))
+            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,
                                             const wxString& subdir,
                                             const wxArrayString& icondirs)
 {
 }
 
 void wxMimeTypesManagerImpl::LoadKDELinksForMimeType(const wxString& dirbase,
                                             const wxString& subdir,
                                             const wxArrayString& icondirs)
 {

-    wxString dirname = dirbase;
-    dirname += subdir;
-    wxDir dir(dirname);
-    if ( !dir.IsOpened() )
+    wxFileName dirname(dirbase, wxEmptyString);
+    dirname.AppendDir(subdir);
+    wxDir dir(dirname.GetPath());
+    if(! dir.IsOpened())

         return;
 
     wxLogTrace(TRACE_MIME, wxT("--- Loading from KDE directory %s  ---"),
         return;
 
     wxLogTrace(TRACE_MIME, wxT("--- Loading from KDE directory %s  ---"),

-                           dirname.c_str());
-    
-    dirname += _T('/');
+                           dirname.GetPath().c_str());

 
     wxString filename;
 
     wxString filename;

-    bool cont = dir.GetFirst(&filename, _T("*.kdelnk"), wxDIR_FILES);
-    while ( cont )
-    {
-        LoadKDELinksForMimeSubtype(dirname, subdir, filename, icondirs);
-
+    bool cont = dir.GetFirst(&filename, wxT("*.kdelnk"), wxDIR_FILES);
+    while(cont) {
+        LoadKDELinksForMimeSubtype(dirname.GetPath(), subdir,
+                                   filename, icondirs);

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

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

 
 

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

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

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

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

-    wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
-                  _T("base directory shouldn't end with a slash") );
-
-    wxString dirname = dirbase;
-    dirname << _T("/mimelnk");
-
-    if ( !wxDir::Exists(dirname) )
+    if(! wxDir::Exists(dirname))

         return;
 
     wxDir dir(dirname);
     if ( !dir.IsOpened() )
         return;
 
         return;
 
     wxDir dir(dirname);
     if ( !dir.IsOpened() )
         return;
 

-    // we will concatenate it with dir name to get the full path below
-    dirname += _T('/');
-

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


@@ -1115,42 +947,330 @@ void wxMimeTypesManagerImpl::LoadKDELinkFilesFromDir(const wxString& dirbase,
     }
 }
 
     }
 }
 

-void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)
+// Read a KDE .desktop file of type 'Application'
+void wxMimeTypesManagerImpl::LoadKDEApp(const wxString& filename)

 {
 {

-    wxArrayString dirs;
-    wxArrayString icondirs;
+    wxLogTrace(TRACE_MIME, wxT("loading KDE file %s"), filename.c_str());
+
+    wxMimeTextFile file;
+    if ( !file.Open(filename) )
+        return;

 
 

-    // settings in ~/.kde have maximal priority
-    dirs.Add(wxGetHomeDir() + wxT("/.kde/share"));
-    icondirs.Add(wxGetHomeDir() + wxT("/.kde/share/icons/"));
+    // Here, only type 'Application' should be considered.
+    int nIndex = file.pIndexOf( wxT("Type=") );
+    if (nIndex != wxNOT_FOUND &&
+        file.GetCmd(nIndex).Lower() != wxT("application"))
+        return;

 
 

-    // the variable KDEDIR is set when KDE is running
-    const wxChar *kdedir = wxGetenv( wxT("KDEDIR") );
-    if ( kdedir )
-    {
-        dirs.Add( wxString(kdedir) + wxT("/share") );
-        icondirs.Add( wxString(kdedir) + wxT("/share/icons/") );
+    // The hidden entry specifies a file to be ignored.
+    nIndex = file.pIndexOf( wxT("Hidden=") );
+    if (nIndex != wxNOT_FOUND && file.GetCmd(nIndex).Lower() == wxT("true"))
+        return;
+
+    // Semicolon separated list of mime types handled by the application.
+    nIndex = file.pIndexOf( wxT("MimeType=") );
+    if (nIndex == wxNOT_FOUND)
+        return;
+    wxString mimetypes = file.GetCmd (nIndex);
+
+    // Name of the application
+    wxString nameapp;
+    nIndex = wxNOT_FOUND;
+#if wxUSE_INTL // try "Name[locale name]" first
+    wxLocale *locale = wxGetLocale();
+    if ( locale )
+        nIndex = file.pIndexOf(_T("Name[")+locale->GetName()+_T("]="));
+#endif // wxUSE_INTL
+    if(nIndex == wxNOT_FOUND)
+        nIndex = file.pIndexOf( wxT("Name=") );
+    if(nIndex != wxNOT_FOUND)
+        nameapp = file.GetCmd(nIndex);
+
+    // Icon of the application.
+    wxString nameicon, namemini;
+    nIndex = wxNOT_FOUND;
+#if wxUSE_INTL // try "Icon[locale name]" first
+    if ( locale )
+        nIndex = file.pIndexOf(_T("Icon[")+locale->GetName()+_T("]="));
+#endif // wxUSE_INTL
+    if(nIndex == wxNOT_FOUND)
+        nIndex = file.pIndexOf( wxT("Icon=") );
+    if(nIndex != wxNOT_FOUND) {
+        nameicon = wxString(wxT("--icon ")) + file.GetCmd(nIndex);
+        namemini = wxString(wxT("--miniicon ")) + file.GetCmd(nIndex);

     }
     }

-    else
-    {
-        // try to guess KDEDIR
-        dirs.Add(_T("/usr/share"));
-        dirs.Add(_T("/opt/kde/share"));
-        icondirs.Add(_T("/usr/share/icons/"));
-        icondirs.Add(_T("/usr/X11R6/share/icons/")); // Debian/Corel linux
-        icondirs.Add(_T("/opt/kde/share/icons/"));
+
+    // Replace some of the field code in the 'Exec' entry.
+    // TODO: deal with %d, %D, %n, %N, %k and %v (but last one is deprecated)
+    nIndex = file.pIndexOf( wxT("Exec=") );
+    if (nIndex == wxNOT_FOUND)
+        return;
+    wxString sCmd = file.GetCmd(nIndex);
+    // we expect %f; others including  %F and %U and %u are possible
+    sCmd.Replace(wxT("%F"), wxT("%f"));
+    sCmd.Replace(wxT("%U"), wxT("%f"));
+    sCmd.Replace(wxT("%u"), wxT("%f"));
+    if (0 == sCmd.Replace ( wxT("%f"), wxT("%s") ))
+        sCmd = sCmd + wxT(" %s");
+    sCmd.Replace(wxT("%c"), nameapp);
+    sCmd.Replace(wxT("%i"), nameicon);
+    sCmd.Replace(wxT("%m"), namemini);
+
+    wxStringTokenizer tokenizer(mimetypes, _T(";"));
+    while(tokenizer.HasMoreTokens()) {
+        wxString mimetype = tokenizer.GetNextToken().Lower();
+        int nIndex = m_aTypes.Index(mimetype);
+        if(nIndex != wxNOT_FOUND) { // is this a known MIME type?
+            wxMimeTypeCommands* entry = m_aEntries[nIndex];
+            entry->AddOrReplaceVerb(wxT("open"), sCmd);
+        }

     }
     }

+}

 
 

-    if (!sExtraDir.empty()) dirs.Add (sExtraDir);
-    icondirs.Add(sExtraDir + wxT("/icons"));
+void wxMimeTypesManagerImpl::LoadKDEAppsFilesFromDir(const wxString& dirname)
+{
+    if(! wxDir::Exists(dirname))
+        return;
+    wxDir dir(dirname);
+    if ( !dir.IsOpened() )
+        return;

 
 

-    size_t nDirs = dirs.GetCount();
-    for ( size_t nDir = 0; nDir < nDirs; nDir++ )
+    wxString filename;
+    // Look into .desktop files
+    bool cont = dir.GetFirst(&filename, _T("*.desktop"), wxDIR_FILES);
+    while(cont) {
+        wxFileName p(dirname, filename);
+        LoadKDEApp( p.GetFullPath() );
+        cont = dir.GetNext(&filename);
+    }
+    // Look recursively into subdirs
+    cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
+    while(cont) {
+        wxFileName p(dirname, wxEmptyString);
+        p.AppendDir(filename);
+        LoadKDEAppsFilesFromDir( p.GetPath() );
+        cont = dir.GetNext(&filename);
+    }
+}
+
+// Return base KDE directories.
+// 1) Environment variable $KDEHOME, or "~/.kde" if not set.
+// 2) List of directories in colon separated environment variable $KDEDIRS.
+// 3) Environment variable $KDEDIR in case $KDEDIRS is not set.
+// Notice at least the local kde directory is added to the list. If it is the
+// only one, use later the application 'kde-config' to get additional paths.
+static void GetKDEBaseDirs(wxArrayString& basedirs)
+{
+    wxString env = wxGetenv( wxT("KDEHOME") );
+    if(env.IsEmpty())
+        env = wxGetHomeDir() + wxT("/.kde");
+    basedirs.Add(env);
+
+    env = wxGetenv( wxT("KDEDIRS") );
+    if(env.IsEmpty()) {
+        env = wxGetenv( wxT("KDEDIR") );
+        if(! env.IsEmpty())
+            basedirs.Add(env);
+    } else {
+        wxStringTokenizer tokenizer(env, wxT(":"));
+        while(tokenizer.HasMoreTokens())
+            basedirs.Add( tokenizer.GetNextToken() );
+    }
+}
+
+static wxString ReadPathFromKDEConfig(const wxString& request)
+{
+    wxString str;
+    wxArrayString output;
+    if(wxExecute(wxT("kde-config --path ")+request, output) == 0 &&
+       output.Count() > 0)
+        str = output.Item(0);
+    return str;
+}
+
+// Try to find the "Theme" entry in the configuration file, provided it exists.
+static wxString GetKDEThemeInFile(const wxFileName& filename)
+{
+    wxString theme;
+    wxMimeTextFile config;
+    if ( filename.FileExists() && config.Open(filename.GetFullPath()) )

     {
     {

-        LoadKDELinkFilesFromDir(dirs[nDir], icondirs);
+        size_t cnt = config.GetLineCount();
+        for ( size_t i = 0; i < cnt; i++ )
+        {
+            if ( config[i].StartsWith(wxT("Theme="), &theme) )
+                break;
+        }
+    }
+
+    return theme;
+}
+
+// Try to find a file "kdeglobals" in one of the directories and read the
+// "Theme" entry there.
+static wxString GetKDETheme(const wxArrayString& basedirs)
+{
+    wxString theme;
+    for(size_t i = 0; i < basedirs.Count(); i++) {
+        wxFileName filename(basedirs.Item(i), wxEmptyString);
+        filename.AppendDir( wxT("share") );
+        filename.AppendDir( wxT("config") );
+        filename.SetName( wxT("kdeglobals") );
+        theme = GetKDEThemeInFile(filename);
+        if(! theme.IsEmpty())
+            return theme;
+    }
+    // If $KDEDIRS and $KDEDIR were set, we try nothing more. Otherwise, we
+    // try to get the configuration file with 'kde-config'.
+    if(basedirs.Count() > 1)
+        return theme;
+    wxString paths = ReadPathFromKDEConfig(wxT("config"));
+    if(! paths.IsEmpty()) {
+        wxStringTokenizer tokenizer(paths, wxT(":"));
+        while( tokenizer.HasMoreTokens() ) {
+            wxFileName filename(tokenizer.GetNextToken(), wxT("kdeglobals"));
+            theme = GetKDEThemeInFile(filename);
+            if(! theme.IsEmpty())
+                return theme;
+        }
+    }
+    return theme;
+}
+
+// Get list of directories of icons.
+static void GetKDEIconDirs(const wxArrayString& basedirs,
+                           wxArrayString& icondirs)
+{
+    wxString theme = GetKDETheme(basedirs);
+    if(theme.IsEmpty())
+        theme = wxT("default.kde");
+
+    for(size_t i = 0; i < basedirs.Count(); i++) {
+        wxFileName dirname(basedirs.Item(i), wxEmptyString);
+        dirname.AppendDir( wxT("share") );
+        dirname.AppendDir( wxT("icons") );
+        dirname.AppendDir(theme);
+        dirname.AppendDir( wxT("32x32") );
+        dirname.AppendDir( wxT("mimetypes") );
+        if( wxDir::Exists( dirname.GetPath() ) )
+            icondirs.Add( dirname.GetPath() );
+    }
+
+    // If $KDEDIRS and $KDEDIR were not set, use 'kde-config'
+    if(basedirs.Count() > 1)
+        return;
+    wxString paths = ReadPathFromKDEConfig(wxT("icon"));
+    if(! paths.IsEmpty()) {
+        wxStringTokenizer tokenizer(paths, wxT(":"));
+        while( tokenizer.HasMoreTokens() ) {
+            wxFileName dirname(tokenizer.GetNextToken(), wxEmptyString);
+            dirname.AppendDir(theme);
+            dirname.AppendDir( wxT("32x32") );
+            dirname.AppendDir( wxT("mimetypes") );
+            if(icondirs.Index(dirname.GetPath()) == wxNOT_FOUND &&
+               wxDir::Exists( dirname.GetPath() ) )
+                icondirs.Add( dirname.GetPath() );
+        }
+    }
+}
+
+// Get list of directories of mime types.
+static void GetKDEMimeDirs(const wxArrayString& basedirs,
+                           wxArrayString& mimedirs)
+{
+    for(size_t i = 0; i < basedirs.Count(); i++) {
+        wxFileName dirname(basedirs.Item(i), wxEmptyString);
+        dirname.AppendDir( wxT("share") );
+        dirname.AppendDir( wxT("mimelnk") );
+        if( wxDir::Exists( dirname.GetPath() ) )
+            mimedirs.Add( dirname.GetPath() );
+    }
+
+    // If $KDEDIRS and $KDEDIR were not set, use 'kde-config'
+    if(basedirs.Count() > 1)
+        return;
+    wxString paths = ReadPathFromKDEConfig(wxT("mime"));
+    if(! paths.IsEmpty()) {
+        wxStringTokenizer tokenizer(paths, wxT(":"));
+        while( tokenizer.HasMoreTokens() ) {
+            wxFileName p(tokenizer.GetNextToken(), wxEmptyString);
+            wxString dirname = p.GetPath(); // To remove possible trailing '/'
+            if(mimedirs.Index(dirname) == wxNOT_FOUND &&
+               wxDir::Exists(dirname) )
+                mimedirs.Add(dirname);
+        }

     }
 }
 
     }
 }
 

+// Get list of directories of application desktop files.
+static void GetKDEAppsDirs(const wxArrayString& basedirs,
+                           wxArrayString& appsdirs)
+{
+    for(size_t i = 0; i < basedirs.Count(); i++) {
+        wxFileName dirname(basedirs.Item(i), wxEmptyString);
+        dirname.AppendDir( wxT("share") );
+        dirname.AppendDir( wxT("applnk") );
+        if( wxDir::Exists( dirname.GetPath() ) )
+            appsdirs.Add( dirname.GetPath() );
+    }
+
+    // If $KDEDIRS and $KDEDIR were not set, use 'kde-config'
+    if(basedirs.Count() > 1)
+        return;
+    wxString paths = ReadPathFromKDEConfig(wxT("apps"));
+    if(! paths.IsEmpty()) {
+        wxStringTokenizer tokenizer(paths, wxT(":"));
+        while( tokenizer.HasMoreTokens() ) {
+            wxFileName p(tokenizer.GetNextToken(), wxEmptyString);
+            wxString dirname = p.GetPath(); // To remove possible trailing '/'
+            if(appsdirs.Index(dirname) == wxNOT_FOUND &&
+               wxDir::Exists(dirname) )
+                appsdirs.Add(dirname);
+        }
+    }
+    paths = ReadPathFromKDEConfig(wxT("xdgdata-apps"));
+    if(! paths.IsEmpty()) {
+        wxStringTokenizer tokenizer(paths, wxT(":"));
+        while( tokenizer.HasMoreTokens() ) {
+            wxFileName p(tokenizer.GetNextToken(), wxEmptyString);
+            wxString dirname = p.GetPath(); // To remove possible trailing '/'
+            if(appsdirs.Index(dirname) == wxNOT_FOUND &&
+               wxDir::Exists(dirname) )
+                appsdirs.Add(dirname);
+        }
+    }
+}
+
+// Fill database with all mime types.
+void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)
+{
+    wxArrayString basedirs;
+    GetKDEBaseDirs(basedirs);
+
+    wxArrayString icondirs;
+    GetKDEIconDirs(basedirs, icondirs);
+    wxArrayString mimedirs;
+    GetKDEMimeDirs(basedirs, mimedirs);
+    wxArrayString appsdirs;
+    GetKDEAppsDirs(basedirs, appsdirs);
+
+    if(! sExtraDir.IsEmpty()) {
+        icondirs.Add(sExtraDir + wxT("/icons"));
+        mimedirs.Add(sExtraDir + wxT("/mimelnk"));
+        appsdirs.Add(sExtraDir + wxT("/applnk"));
+    }
+
+    // Load mime types
+    size_t nDirs = mimedirs.GetCount(), nDir;
+    for(nDir = 0; nDir < nDirs; nDir++)
+        LoadKDELinkFilesFromDir(mimedirs[nDir], icondirs);
+
+    // Load application files and associate them to corresponding mime types.
+    nDirs = appsdirs.GetCount();
+    for(nDir = 0; nDir < nDirs; nDir++)
+        LoadKDEAppsFilesFromDir(appsdirs[nDir]);
+}
+

 // ----------------------------------------------------------------------------
 // wxFileTypeImpl (Unix)
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxFileTypeImpl (Unix)
 // ----------------------------------------------------------------------------


@@ -1161,88 +1281,88 @@ wxString wxFileTypeImpl::GetExpandedCommand(const wxString & verb, const wxFileT
     size_t i = 0;
     while ( (i < m_index.GetCount() ) && sTmp.empty() )
     {
     size_t i = 0;
     while ( (i < m_index.GetCount() ) && sTmp.empty() )
     {

-            sTmp = m_manager->GetCommand ( verb, m_index[i] );
-            i ++;
+        sTmp = m_manager->GetCommand( verb, m_index[i] );
+        i++;

     }
 
     return wxFileType::ExpandCommand(sTmp, params);
 }
 
 bool wxFileTypeImpl::GetIcon(wxIconLocation *iconLoc) const
     }
 
     return wxFileType::ExpandCommand(sTmp, params);
 }
 
 bool wxFileTypeImpl::GetIcon(wxIconLocation *iconLoc) const

-

 {
     wxString sTmp;
     size_t i = 0;
     while ( (i < m_index.GetCount() ) && sTmp.empty() )
     {
         sTmp = m_manager->m_aIcons[m_index[i]];
 {
     wxString sTmp;
     size_t i = 0;
     while ( (i < m_index.GetCount() ) && sTmp.empty() )
     {
         sTmp = m_manager->m_aIcons[m_index[i]];

-        i ++;
+        i++;

     }
     }

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

 
     if ( iconLoc )
     {
         iconLoc->SetFileName(sTmp);
     }
 
 
     if ( iconLoc )
     {
         iconLoc->SetFileName(sTmp);
     }
 

-    return TRUE;
+    return true;

 }
 
 }
 

-
-bool
-wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
+bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const

 {
     mimeTypes.Clear();
 {
     mimeTypes.Clear();

-    for (size_t i = 0; i < m_index.GetCount(); i++)
+    size_t nCount = m_index.GetCount();
+    for (size_t i = 0; i < nCount; i++)

         mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);
         mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);

-    return TRUE;
-}

 
 

+    return true;
+}

 
 size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
                                   wxArrayString *commands,
                                   const wxFileType::MessageParameters& params) const
 {
 
 size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
                                   wxArrayString *commands,
                                   const wxFileType::MessageParameters& params) const
 {

-

     wxString vrb, cmd, sTmp;
     size_t count = 0;
     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
     wxString vrb, cmd, sTmp;
     size_t count = 0;
     wxMimeTypeCommands * sPairs;
 
     // verbs and commands have been cleared already in mimecmn.cpp...
     // if we find no entries in the exact match, try the inexact match

-    for (size_t n = 0; ((count ==0) && (n < m_index.GetCount())); n++)
+    for (size_t n = 0; ((count == 0) && (n < m_index.GetCount())); n++)

     {
         // list of verb = command pairs for this mimetype
         sPairs = m_manager->m_aEntries [m_index[n]];
         size_t i;
     {
         // list of verb = command pairs for this mimetype
         sPairs = m_manager->m_aEntries [m_index[n]];
         size_t i;

-        for ( i = 0; i < sPairs->GetCount (); i++ )
+        for ( i = 0; i < sPairs->GetCount(); i++ )
+        {
+            vrb = sPairs->GetVerb(i);
+            // some gnome entries have "." inside
+            vrb = vrb.AfterLast(wxT('.'));
+            cmd = sPairs->GetCmd(i);
+            if (! cmd.empty() )

             {
             {

-                vrb = sPairs->GetVerb(i);
-                // some gnome entries have . inside
-                vrb = vrb.AfterLast(wxT('.'));
-                cmd = sPairs->GetCmd (i);
-                if (! cmd.empty() )
-                     {
-                     cmd = wxFileType::ExpandCommand(cmd, params);
-                     count ++;
-                     if ( vrb.IsSameAs (wxT("open")))
-                         {
-                         verbs->Insert(vrb,0u);
-                         commands ->Insert(cmd,0u);
-                         }
-                     else
-                         {
-                         verbs->Add (vrb);
-                         commands->Add (cmd);
-                         }
-                     }
-
+                 cmd = wxFileType::ExpandCommand(cmd, params);
+                 count++;
+                 if ( vrb.IsSameAs(wxT("open")))
+                 {
+                     if ( verbs )
+                        verbs->Insert(vrb, 0u);
+                     if ( commands )
+                        commands ->Insert(cmd, 0u);
+                 }
+                 else
+                 {
+                     if ( verbs )
+                        verbs->Add(vrb);
+                     if ( commands )
+                        commands->Add(cmd);
+                 }
+             }

         }
         }

-

     }
     }

-    return count;

 
 

+    return count;

 }
 
 bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
 }
 
 bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)


@@ -1250,97 +1370,135 @@ bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
     wxString strExtensions = m_manager->GetExtension(m_index[0]);
     extensions.Empty();
 
     wxString strExtensions = m_manager->GetExtension(m_index[0]);
     extensions.Empty();
 

-    // one extension in the space or comma delimitid list
+    // one extension in the space or comma-delimited list

     wxString strExt;
     wxString strExt;

-    for ( const wxChar *p = strExtensions;; p++ ) {
-        if ( *p == wxT(' ') || *p == wxT(',') || *p == wxT('\0') ) {
-            if ( !strExt.empty() ) {
+    for ( const wxChar *p = strExtensions; /* nothing */; p++ )
+    {
+        if ( *p == wxT(' ') || *p == wxT(',') || *p == wxT('\0') )
+        {
+            if ( !strExt.empty() )
+            {

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

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

 
             if ( *p == wxT('\0') )
                 break;
         }
 
             if ( *p == wxT('\0') )
                 break;
         }

-        else if ( *p == wxT('.') ) {
+        else if ( *p == wxT('.') )
+        {

             // remove the dot from extension (but only if it's the first char)
             // remove the dot from extension (but only if it's the first char)

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

                 strExt += wxT('.');
             }
             //else: no, don't append it
         }
                 strExt += wxT('.');
             }
             //else: no, don't append it
         }

-        else {
+        else
+        {

             strExt += *p;
         }
     }
 
             strExt += *p;
         }
     }
 

-    return TRUE;
+    return true;

 }
 
 }
 

-// set an arbitrary command,
+// set an arbitrary command:

 // could adjust the code to ask confirmation if it already exists and
 // could adjust the code to ask confirmation if it already exists and

-// overwriteprompt is TRUE, but this is currently ignored as *Associate* has
+// overwriteprompt is true, but this is currently ignored as *Associate* has

 // no overwrite prompt
 // no overwrite prompt

-bool wxFileTypeImpl::SetCommand(const wxString& cmd, const wxString& verb, bool overwriteprompt /*= TRUE*/)
+bool
+wxFileTypeImpl::SetCommand(const wxString& cmd,
+                           const wxString& verb,
+                           bool WXUNUSED(overwriteprompt))

 {
     wxArrayString strExtensions;
     wxString strDesc, strIcon;
 
 {
     wxArrayString strExtensions;
     wxString strDesc, strIcon;
 

-    wxMimeTypeCommands *entry = new wxMimeTypeCommands ();
-    entry->Add(verb + wxT("=")  + cmd + wxT(" %s "));
-

     wxArrayString strTypes;
     wxArrayString strTypes;

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

 
 

-    size_t i;
-    bool Ok = TRUE;
-    for (i = 0; i < strTypes.GetCount(); i++)
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands();
+    entry->Add(verb + wxT("=")  + cmd + wxT(" %s "));
+
+    bool ok = true;
+    size_t nCount = strTypes.GetCount();
+    for ( size_t i = 0; i < nCount; i++ )

     {
     {

-        if (!m_manager->DoAssociation (strTypes[i], strIcon, entry, strExtensions, strDesc))
-            Ok = FALSE;
+        if (!m_manager->DoAssociation(strTypes[i], strIcon, entry, strExtensions, strDesc))
+            ok = false;

     }
 
     }
 

-    return Ok;
+    return ok;

 }
 
 }
 

-// 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*/)
+// ignore index on the grounds that we only have one icon in a Unix file
+bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int WXUNUSED(index))

 {
 {

-    if (strIcon.empty()) return FALSE;
+    if (strIcon.empty())
+        return false;
+

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

-    wxMimeTypeCommands *entry = new wxMimeTypeCommands ();
-

     wxArrayString strTypes;
     wxArrayString strTypes;

-    GetMimeTypes (strTypes);
-    if (strTypes.GetCount() < 1) return FALSE;
-
-    size_t i;
-    bool Ok = TRUE;
-    for (i = 0; i < strTypes.GetCount(); i++)
-    {
-        if (!m_manager->DoAssociation (strTypes[i], strIcon, entry, strExtensions, strDesc))
-            Ok = FALSE;
+    GetMimeTypes(strTypes);
+    if ( strTypes.IsEmpty() )
+        return false;
+
+    wxMimeTypeCommands *entry = new wxMimeTypeCommands();
+    bool ok = true;
+    size_t nCount = strTypes.GetCount();
+    for ( size_t i = 0; i < nCount; i++ )
+    {
+        if ( !m_manager->DoAssociation
+                         (
+                            strTypes[i],
+                            strIcon,
+                            entry,
+                            strExtensions,
+                            strDesc
+                         ) )
+        {
+            ok = false;
+        }

     }
 
     }
 

-    return Ok;
+    return ok;

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

-

 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;
+        
+        wxString wm = wxTheApp->GetTraits()->GetDesktopEnvironment();
+        
+        if (wm == wxT("KDE"))
+            Initialize( wxMAILCAP_KDE  );
+        else if (wm == wxT("GNOME"))
+            Initialize( wxMAILCAP_GNOME );
+        else
+            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)


@@ -1351,12 +1509,14 @@ 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);
 
         GetGnomeMimeInfo(sExtraDir);
 

-    // read KDE tables
-    if ( mailcapStyles & wxMAILCAP_KDE)
+    // read KDE tables which are never installed on OpenVMS
+#ifndef __VMS
+    if (mailcapStyles & wxMAILCAP_KDE)

         GetKDEMimeInfo(sExtraDir);
         GetKDEMimeInfo(sExtraDir);

+#endif

 
     m_mailcapStylesInited |= mailcapStyles;
 }
 
     m_mailcapStylesInited |= mailcapStyles;
 }


@@ -1364,10 +1524,10 @@ void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
 // clear data so you can read another group of WM files
 void wxMimeTypesManagerImpl::ClearData()
 {
 // clear data so you can read another group of WM files
 void wxMimeTypesManagerImpl::ClearData()
 {

-    m_aTypes.Clear ();
-    m_aIcons.Clear ();
-    m_aExtensions.Clear ();
-    m_aDescriptions.Clear ();
+    m_aTypes.Clear();
+    m_aIcons.Clear();
+    m_aExtensions.Clear();
+    m_aDescriptions.Clear();

 
     WX_CLEAR_ARRAY(m_aEntries);
     m_aEntries.Empty();
 
     WX_CLEAR_ARRAY(m_aEntries);
     m_aEntries.Empty();


@@ -1380,8 +1540,7 @@ wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl()
     ClearData();
 }
 
     ClearData();
 }
 

-
-void wxMimeTypesManagerImpl::GetMimeInfo (const wxString& sExtraDir)
+void wxMimeTypesManagerImpl::GetMimeInfo(const wxString& sExtraDir)

 {
     // read this for netscape or Metamail formats
 
 {
     // read this for netscape or Metamail formats
 


@@ -1399,35 +1558,38 @@ 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/") );
-    if (!sExtraDir.empty()) dirs.Add ( sExtraDir + wxT("/") );
-
+    dirs.Add( strHome + wxT("/.") );
+    dirs.Add( wxT("/etc/") );
+    dirs.Add( wxT("/usr/etc/") );
+    dirs.Add( wxT("/usr/local/etc/") );
+    dirs.Add( wxT("/etc/mail/") );
+    dirs.Add( wxT("/usr/public/lib/") );
+    if (!sExtraDir.empty())
+        dirs.Add( sExtraDir + wxT("/") );
+
+    wxString file;

     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++ )
     {

-        wxString file = dirs[nDir] + wxT("mailcap");
-        if ( wxFile::Exists(file) ) {
+        file = dirs[nDir];
+        file += wxT("mailcap");
+        if ( wxFile::Exists(file) )
+        {

             ReadMailcap(file);
         }
 
             ReadMailcap(file);
         }
 

-        file = dirs[nDir] + wxT("mime.types");
-        if ( wxFile::Exists(file) ) {
+        file = dirs[nDir];
+        file += wxT("mime.types");
+        if ( wxFile::Exists(file) )

             ReadMimeTypes(file);
             ReadMimeTypes(file);

-        }

     }
     }

-

 }
 
 }
 

-bool wxMimeTypesManagerImpl::WriteToMimeTypes (int index, bool delete_index)
+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"));


@@ -1438,50 +1600,56 @@ bool wxMimeTypesManagerImpl::WriteToMimeTypes (int index, bool delete_index)
     wxMimeTextFile file;
     if ( wxFile::Exists(strUserMailcap) )
     {
     wxMimeTextFile file;
     if ( wxFile::Exists(strUserMailcap) )
     {

-        bTemp =  file.Open(strUserMailcap);
+        bTemp = file.Open(strUserMailcap);

     }
     else
     {
     }
     else
     {

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

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

+

     if (bTemp)
     {
         int nIndex;
     if (bTemp)
     {
         int nIndex;

-        // test for netscape's header and return FALSE if its found
-        nIndex = file.pIndexOf (wxT("#--Netscape"));
+        // test for netscape's header and return false if its found
+        nIndex = file.pIndexOf(wxT("#--Netscape"));

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

-            wxASSERT_MSG(FALSE,wxT("Error in .mime.types \nTrying to mix Netscape and Metamail formats\nFile not modiifed"));
-            return FALSE;
+            wxFAIL_MSG(wxT("Error in .mime.types\nTrying to mix Netscape and Metamail formats\nFile not modified"));
+            return false;

         }
         }

+

         // write it in alternative format
         // get rid of unwanted entries
         wxString strType = m_aTypes[index];
         // write it in alternative format
         // get rid of unwanted entries
         wxString strType = m_aTypes[index];

-        nIndex = file.pIndexOf (strType);
+        nIndex = file.pIndexOf(strType);
+

         // get rid of all the unwanted entries...
         // get rid of all the unwanted entries...

-        if (nIndex != wxNOT_FOUND) file.CommentLine (nIndex);
+        if (nIndex != wxNOT_FOUND)
+            file.CommentLine(nIndex);

 
         if (!delete_index)
         {
             // add the new entries in
 
         if (!delete_index)
         {
             // add the new entries in

-            wxString sTmp = strType.Append (wxT(' '), 40-strType.Len() );
-            sTmp = sTmp + m_aExtensions[index];
-            file.AddLine (sTmp);
+            wxString sTmp = strType.Append( wxT(' '), 40 - strType.Len() );
+            sTmp += m_aExtensions[index];
+            file.AddLine(sTmp);

         }
 
         }
 

-
-        bTemp = file.Write ();
-        file.Close ();
+        bTemp = file.Write();
+        file.Close();

     }
     }

+

     return bTemp;
 }
 
     return bTemp;
 }
 

-bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
+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"));


@@ -1492,37 +1660,41 @@ bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
     wxMimeTextFile file;
     if ( wxFile::Exists(strUserMailcap) )
     {
     wxMimeTextFile file;
     if ( wxFile::Exists(strUserMailcap) )
     {

-        bTemp =  file.Open(strUserMailcap);
+        bTemp = file.Open(strUserMailcap);

     }
     else
     {
     }
     else
     {

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

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

+

     if (bTemp)
     {
     if (bTemp)
     {

-

         // 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
             // at present we can't cope with mixed formats, so exit to preseve
             // metamail entreies
         if (nIndex == wxNOT_FOUND)
         {
             // either empty file or metamail format
             // at present we can't cope with mixed formats, so exit to preseve
             // metamail entreies

-            if (file.GetLineCount () > 0)
+            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;
+                wxFAIL_MSG(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);
+
+            file.InsertLine(wxT( "#--Netscape Communications Corporation MIME Information" ), 0);

             nIndex = 0;
         }
 
         wxString strType = wxT("type=") + m_aTypes[index];
             nIndex = 0;
         }
 
         wxString strType = wxT("type=") + m_aTypes[index];

-        nIndex = file.pIndexOf (strType);
+        nIndex = file.pIndexOf(strType);
+

         // get rid of all the unwanted entries...
         if (nIndex != wxNOT_FOUND)
         {
         // get rid of all the unwanted entries...
         if (nIndex != wxNOT_FOUND)
         {


@@ -1531,47 +1703,55 @@ bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
             {
                 file.CommentLine(nIndex);
                 sOld = file[nIndex];
             {
                 file.CommentLine(nIndex);
                 sOld = file[nIndex];

+

                 wxLogTrace(TRACE_MIME, wxT("--- Deleting from mime.types line '%d %s' ---"), nIndex, sOld.c_str());
                 wxLogTrace(TRACE_MIME, wxT("--- Deleting from mime.types line '%d %s' ---"), nIndex, sOld.c_str());

-                nIndex ++;
+
+                nIndex++;

             }
             }

-            if (nIndex < (int) file.GetLineCount()) file.CommentLine (nIndex);
+
+            if (nIndex < (int) file.GetLineCount())
+                file.CommentLine(nIndex);

         }
         }

-        else nIndex = (int) file.GetLineCount();
+        else
+            nIndex = (int) file.GetLineCount();

 
         wxString sTmp = strType + wxT(" \\");
 
         wxString sTmp = strType + wxT(" \\");

-        if (!delete_index) file.InsertLine (sTmp, nIndex);
+        if (!delete_index)
+            file.InsertLine(sTmp, nIndex);
+

         if ( ! m_aDescriptions.Item(index).empty() )
         {
         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)
             {
             if (!delete_index)
             {

-                nIndex ++;
-                file.InsertLine (sTmp, nIndex);
+                nIndex++;
+                file.InsertLine(sTmp, nIndex);

             }
         }
             }
         }

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

         if (!delete_index)
         {
         if (!delete_index)
         {

-            nIndex ++;
-            file.InsertLine (sTmp, nIndex);
+            nIndex++;
+            file.InsertLine(sTmp, nIndex);

         }
 
         }
 

-        bTemp = file.Write ();
-        file.Close ();
+        bTemp = file.Write();
+        file.Close();

     }
     }

+

     return bTemp;
 }
 
     return bTemp;
 }
 

-
-bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
+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;
+    bool bTemp = false;

     wxString strHome = wxGetenv(wxT("HOME"));
 
     // and now the users mailcap
     wxString strHome = wxGetenv(wxT("HOME"));
 
     // and now the users mailcap


@@ -1580,24 +1760,28 @@ bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
     wxMimeTextFile file;
     if ( wxFile::Exists(strUserMailcap) )
     {
     wxMimeTextFile file;
     if ( wxFile::Exists(strUserMailcap) )
     {

-        bTemp =  file.Open(strUserMailcap);
+        bTemp = file.Open(strUserMailcap);

     }
     else
     {
     }
     else
     {

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

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

+

     if (bTemp)
     {
         // now got a file we can write to ....
         wxMimeTypeCommands * entries = m_aEntries[index];
         size_t iOpen;
     if (bTemp)
     {
         // now got a file we can write to ....
         wxMimeTypeCommands * entries = m_aEntries[index];
         size_t iOpen;

-        wxString sCmd = entries->GetCommandForVerb(_T("open"), &iOpen);
+        wxString sCmd = entries->GetCommandForVerb(wxT("open"), &iOpen);

         wxString sTmp;
 
         sTmp = m_aTypes[index];
         wxString sOld;
         int nIndex = file.pIndexOf(sTmp);
         wxString sTmp;
 
         sTmp = m_aTypes[index];
         wxString sOld;
         int nIndex = file.pIndexOf(sTmp);

+

         // get rid of all the unwanted entries...
         if (nIndex == wxNOT_FOUND)
         {
         // get rid of all the unwanted entries...
         if (nIndex == wxNOT_FOUND)
         {


@@ -1611,31 +1795,35 @@ bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
             while ( (sOld.Contains(wxT("\\"))) && (nIndex < (int) file.GetLineCount()) )
             {
                 file.CommentLine(nIndex);
             while ( (sOld.Contains(wxT("\\"))) && (nIndex < (int) file.GetLineCount()) )
             {
                 file.CommentLine(nIndex);

-                if (nIndex < (int) file.GetLineCount()) sOld = sOld + file[nIndex];
+                if (nIndex < (int) file.GetLineCount())
+                    sOld = sOld + file[nIndex];

             }
             }

-            if (nIndex < (int) file.GetLineCount()) file.CommentLine (nIndex);
+
+            if (nIndex < (int)
+                file.GetLineCount()) file.CommentLine(nIndex);

         }
 
         }
 

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

 
         // write it in the format that Netscape uses (default)
 
         // write it in the format that Netscape uses (default)

-        if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD  ) )
+        if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD ) )

         {
         {

-            if (! delete_index) file.InsertLine (sTmp, nIndex);
-            nIndex ++;
+            if (! delete_index)
+                file.InsertLine(sTmp, nIndex);
+            nIndex++;

         }
         }

-
-        // write extended format

         else
         {
         else
         {

-            // todo FIX this code;
+            // write extended format
+
+            // TODO - FIX this code:

             // ii) lost entries
             // sOld holds all the entries, but our data store only has some
             // eg test= is not stored
 
             // so far we have written the mimetype and command out
             // ii) lost entries
             // sOld holds all the entries, but our data store only has some
             // eg test= is not stored
 
             // so far we have written the mimetype and command out

-            wxStringTokenizer sT (sOld, wxT(";\\"));
-            if (sT.CountTokens () > 2)
+            wxStringTokenizer sT(sOld, wxT(";\\"));
+            if (sT.CountTokens() > 2)

             {
                 // first one mimetype; second one command, rest unknown...
                 wxString s;
             {
                 // first one mimetype; second one command, rest unknown...
                 wxString s;


@@ -1646,149 +1834,155 @@ bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
                 s = sT.GetNextToken();
                 while ( ! s.empty() )
                 {
                 s = sT.GetNextToken();
                 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;
                     size_t i;

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

                     {
                     {

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

                     }
                     }

+

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

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

                         sTmp = s;
                     }
                         sTmp = s;
                     }

-                    s = sT.GetNextToken ();
-                }

 
 

+                    s = sT.GetNextToken();
+                }

             }
 
             if (! m_aDescriptions[index].empty() )
             {
             }
 
             if (! m_aDescriptions[index].empty() )
             {

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

                 sTmp = wxT("       description=\"") + m_aDescriptions[index] + wxT("\"");
             }
 
             if (! m_aIcons[index].empty() )
             {
                 sTmp = wxT("       description=\"") + m_aDescriptions[index] + wxT("\"");
             }
 
             if (! m_aIcons[index].empty() )
             {

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

                 sTmp = wxT("       x11-bitmap=\"") + m_aIcons[index] + wxT("\"");
             }
                 sTmp = wxT("       x11-bitmap=\"") + m_aIcons[index] + wxT("\"");
             }

-            if ( entries->GetCount() > 1 )

 
 

+            if ( entries->GetCount() > 1 )

             {
                 size_t i;
                 for (i=0; i < entries->GetCount(); i++)
                     if ( i != iOpen )
                     {
             {
                 size_t i;
                 for (i=0; i < entries->GetCount(); i++)
                     if ( i != iOpen )
                     {

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

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

-            file.InsertLine (sTmp, nIndex);
-            nIndex ++;
-
+            file.InsertLine(sTmp, nIndex);
+            nIndex++;

         }
         }

-        bTemp = file.Write ();
-        file.Close ();
+
+        bTemp = file.Write();
+        file.Close();

     }
     }

+

     return bTemp;
 }
 
     return bTemp;
 }
 

-wxFileType *
-wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
+wxFileType * wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)

 {
     InitIfNeeded();
 
 {
     InitIfNeeded();
 

-    wxString strType = ftInfo.GetMimeType ();
-    wxString strDesc = ftInfo.GetDescription ();
-    wxString strIcon = ftInfo.GetIconFile ();
+    wxString strType = ftInfo.GetMimeType();
+    wxString strDesc = ftInfo.GetDescription();
+    wxString strIcon = ftInfo.GetIconFile();

 
 

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

 
     if ( ! ftInfo.GetOpenCommand().empty())
 
     if ( ! ftInfo.GetOpenCommand().empty())

-        entry->Add(wxT("open=")  + ftInfo.GetOpenCommand  () + wxT(" %s "));
-    if ( ! ftInfo.GetPrintCommand  ().empty())
-        entry->Add(wxT("print=") + ftInfo.GetPrintCommand () + wxT(" %s "));
+        entry->Add(wxT("open=")  + ftInfo.GetOpenCommand() + wxT(" %s "));
+    if ( ! ftInfo.GetPrintCommand().empty())
+        entry->Add(wxT("print=") + ftInfo.GetPrintCommand() + wxT(" %s "));

 
     // now find where these extensions are in the data store and remove them
 
     // now find where these extensions are in the data store and remove them

-    wxArrayString sA_Exts = ftInfo.GetExtensions ();
+    wxArrayString sA_Exts = ftInfo.GetExtensions();

     wxString sExt, sExtStore;
     size_t i, nIndex;
     wxString sExt, sExtStore;
     size_t i, nIndex;

-    for (i=0; i < sA_Exts.GetCount(); i++)
-        {
+    size_t nExtCount = sA_Exts.GetCount();
+    for (i=0; i < nExtCount; i++)
+    {

         sExt = sA_Exts.Item(i);
         sExt = sA_Exts.Item(i);

-        //clean up to just a space before and after
-        sExt.Trim().Trim(FALSE);
+
+        // clean up to just a space before and after
+        sExt.Trim().Trim(false);

         sExt = wxT(' ') + sExt + wxT(' ');
         sExt = wxT(' ') + sExt + wxT(' ');

-        for (nIndex = 0; nIndex < m_aExtensions.GetCount(); nIndex ++)
-            {
+        size_t nCount = m_aExtensions.GetCount();
+        for (nIndex = 0; nIndex < nCount; nIndex++)
+        {

             sExtStore = m_aExtensions.Item(nIndex);
             sExtStore = m_aExtensions.Item(nIndex);

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

     }
 
     }
 

-    if ( !DoAssociation (strType, strIcon, entry, sA_Exts, strDesc) )
+    if ( !DoAssociation(strType, strIcon, entry, sA_Exts, strDesc) )

         return NULL;
 
     return GetFileTypeFromMimeType(strType);
 }
 
         return NULL;
 
     return GetFileTypeFromMimeType(strType);
 }
 

-

 bool wxMimeTypesManagerImpl::DoAssociation(const wxString& strType,
                                            const wxString& strIcon,
                                            wxMimeTypeCommands *entry,
                                            const wxArrayString& strExtensions,
                                            const wxString& strDesc)
 {
 bool wxMimeTypesManagerImpl::DoAssociation(const wxString& strType,
                                            const wxString& strIcon,
                                            wxMimeTypeCommands *entry,
                                            const wxArrayString& strExtensions,
                                            const wxString& strDesc)
 {

-    int nIndex = AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, TRUE);
+    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 ( m_mailcapStylesInited & wxMAILCAP_STANDARD )
     {
         // write in metamail  format;

-        if (WriteToMimeTypes (nIndex, delete_mime) )
-            if ( WriteToMailCap   (nIndex, delete_mime) )
-                ok = FALSE;
+        if (WriteToMimeTypes(nIndex, delete_mime) )
+            if ( WriteToMailCap(nIndex, delete_mime) )
+                ok = false;

     }
     }

+

     if ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE )
     {
         // write in netsacpe format;
     if ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE )
     {
         // write in netsacpe format;

-        if (WriteToNSMimeTypes (nIndex, delete_mime) )
-            if ( WriteToMailCap   (nIndex, delete_mime) )
-                ok = FALSE;
-    }
-    if (m_mailcapStylesInited & wxMAILCAP_GNOME)
-    {
-        // write in Gnome format;
-        if (WriteGnomeMimeFile (nIndex, delete_mime) )
-            if (WriteGnomeKeyFile   (nIndex, delete_mime) )
-                ok = FALSE;
+        if (WriteToNSMimeTypes(nIndex, delete_mime) )
+            if ( WriteToMailCap(nIndex, delete_mime) )
+                ok = false;

     }
     }

+
+    // Don't write GNOME files here as this is not
+    // allowed and simply doesn't work
+

     if (m_mailcapStylesInited & wxMAILCAP_KDE)
     {
         // write in KDE format;
     if (m_mailcapStylesInited & wxMAILCAP_KDE)
     {
         // write in KDE format;

-        if (WriteKDEMimeFile (nIndex, delete_mime) )
-            ok = FALSE;
+        if (WriteKDEMimeFile(nIndex, delete_mime) )
+            ok = false;

     }
 
     return ok;
     }
 
     return ok;


@@ -1846,13 +2040,13 @@ int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType,
                 m_aDescriptions[nIndex] = strDesc;
 
             // if new icon and no existing icon
                 m_aDescriptions[nIndex] = strDesc;
 
             // if new icon and no existing icon

-            if ( m_aIcons[nIndex].empty () )
+            if ( m_aIcons[nIndex].empty() )

                 m_aIcons[nIndex] = strIcon;
 
             // add any new entries...
             if ( entry )
             {
                 m_aIcons[nIndex] = strIcon;
 
             // add any new entries...
             if ( entry )
             {

-                wxMimeTypeCommands *entryOld  =  m_aEntries[nIndex];
+                wxMimeTypeCommands *entryOld = m_aEntries[nIndex];

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


@@ -1875,10 +2069,12 @@ int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType,
     wxString& exts = m_aExtensions[nIndex];
 
     // add all extensions we don't have yet
     wxString& exts = m_aExtensions[nIndex];
 
     // add all extensions we don't have yet

+    wxString ext;

     size_t count = strExtensions.GetCount();
     for ( size_t i = 0; i < count; i++ )
     {
     size_t count = strExtensions.GetCount();
     for ( size_t i = 0; i < count; i++ )
     {

-        wxString ext = strExtensions[i] + _T(' ');
+        ext = strExtensions[i];
+        ext += wxT(' ');

 
         if ( exts.Find(ext) == wxNOT_FOUND )
         {
 
         if ( exts.Find(ext) == wxNOT_FOUND )
         {


@@ -1895,9 +2091,7 @@ int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType,
     return nIndex;
 }
 
     return nIndex;
 }
 

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

 {
     if (ext.empty() )
         return NULL;
 {
     if (ext.empty() )
         return NULL;


@@ -1907,12 +2101,12 @@ wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
     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++ )
     {

-        wxStringTokenizer tk(m_aExtensions[n], _T(' '));
+        wxStringTokenizer tk(m_aExtensions[n], wxT(' '));

 
         while ( tk.HasMoreTokens() )
         {
             // consider extensions as not being case-sensitive
 
         while ( tk.HasMoreTokens() )
         {
             // consider extensions as not being case-sensitive

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

             {
                 // found
                 wxFileType *fileType = new wxFileType;
             {
                 // found
                 wxFileType *fileType = new wxFileType;


@@ -1926,8 +2120,7 @@ wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
     return NULL;
 }
 
     return NULL;
 }
 

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

 {
     InitIfNeeded();
 
 {
     InitIfNeeded();
 


@@ -1952,38 +2145,44 @@ wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
     wxString strCategory = mimetype.BeforeFirst(wxT('/'));
 
     size_t nCount = m_aTypes.Count();
     wxString strCategory = mimetype.BeforeFirst(wxT('/'));
 
     size_t nCount = m_aTypes.Count();

-    for ( size_t n = 0; n < nCount; n++ ) {
+    for ( size_t n = 0; n < nCount; n++ )
+    {

         if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) &&
         if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) &&

-                m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") ) {
+                m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") )
+        {

             index = n;
             break;
         }
             index = n;
             break;
         }

-

     }
 
     if ( index != wxNOT_FOUND )
     {
     }
 
     if ( index != wxNOT_FOUND )
     {

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

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

+

     return fileType;
 }
 
     return fileType;
 }
 

-

 wxString wxMimeTypesManagerImpl::GetCommand(const wxString & verb, size_t nIndex) const
 {
     wxString command, testcmd, sV, sTmp;
     sV = verb + wxT("=");
 wxString wxMimeTypesManagerImpl::GetCommand(const wxString & verb, size_t nIndex) const
 {
     wxString command, testcmd, sV, sTmp;
     sV = verb + wxT("=");

+

     // list of verb = command pairs for this mimetype
     wxMimeTypeCommands * sPairs = m_aEntries [nIndex];
 
     size_t i;
     // list of verb = command pairs for this mimetype
     wxMimeTypeCommands * sPairs = m_aEntries [nIndex];
 
     size_t i;

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

     {
         sTmp = sPairs->GetVerbCmd (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;
 }
 


@@ -1994,10 +2193,11 @@ void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype)
     wxString extensions;
     const wxArrayString& exts = filetype.GetExtensions();
     size_t nExts = exts.GetCount();
     wxString extensions;
     const wxArrayString& exts = filetype.GetExtensions();
     size_t nExts = exts.GetCount();

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

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

-        }
+

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


@@ -2023,15 +2223,15 @@ void wxMimeTypesManagerImpl::AddMimeTypeInfo(const wxString& strMimeType,
     wxString sTmp = strExtensions;
 
     wxArrayString sExts;
     wxString sTmp = strExtensions;
 
     wxArrayString sExts;

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

 
     while (!sTmp.empty())
     {
 
     while (!sTmp.empty())
     {

-        sExts.Add (sTmp.AfterLast(wxT(' ')));
+        sExts.Add(sTmp.AfterLast(wxT(' ')));

         sTmp = sTmp.BeforeLast(wxT(' '));
     }
 
         sTmp = sTmp.BeforeLast(wxT(' '));
     }
 

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

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


@@ -2050,8 +2250,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);

 }
 
 bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
 }
 
 bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)


@@ -2059,13 +2258,9 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
     wxLogTrace(TRACE_MIME, wxT("--- Parsing mime.types file '%s' ---"),
                strFileName.c_str());
 
     wxLogTrace(TRACE_MIME, wxT("--- Parsing mime.types file '%s' ---"),
                strFileName.c_str());
 

-    wxTextFile file(strFileName);
-#if defined(__WXGTK20__) && wxUSE_UNICODE
-    if ( !file.Open( wxConvUTF8) )
-#else
+    wxMimeTextFile file(strFileName);

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

-#endif
-        return FALSE;
+        return false;

 
     // the information we extract
     wxString strMimeType, strDesc, strExtensions;
 
     // the information we extract
     wxString strMimeType, strDesc, strExtensions;


@@ -2074,11 +2269,13 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
     const wxChar *pc = NULL;
     for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
     {
     const wxChar *pc = NULL;
     for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
     {

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

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

-        else {
+        else
+        {

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


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

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

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


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

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

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

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

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


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

-        else {
+        else
+        {

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


@@ -2127,16 +2328,18 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
               ;
 
             const wxChar *pEnd;
               ;
 
             const wxChar *pEnd;

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

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

-                if ( pEnd == NULL ) {
-                    wxLogWarning(_("Mime.types file %s, line %d: unterminated "
-                                   "quoted string."),
-                                 strFileName.c_str(), nLine + 1);
+                if ( pEnd == NULL )
+                {
+                    wxLogWarning(wxT("Mime.types file %s, line %lu: unterminated quoted string."),
+                                 strFileName.c_str(), nLine + 1L);

                 }
             }
                 }
             }

-            else {
+            else
+            {

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


@@ -2147,7 +2350,8 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
             wxString strRHS(pc, pEnd - pc);
 
             // check what follows this entry
             wxString strRHS(pc, pEnd - pc);
 
             // check what follows this entry

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

                 // skip this quote
                 pEnd++;
             }
                 // skip this quote
                 pEnd++;
             }


@@ -2157,38 +2361,43 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
 
             // if there is something left, it may be either a '\\' to continue
             // the line or the next field of the same entry
 
             // if there is something left, it may be either a '\\' to continue
             // the line or the next field of the same entry

-            bool entryEnded = *pc == wxT('\0'),
-                 nextFieldOnSameLine = FALSE;
-            if ( !entryEnded ) {
+            bool entryEnded = *pc == wxT('\0');
+            bool nextFieldOnSameLine = false;
+            if ( !entryEnded )
+            {

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

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

                 strMimeType = strRHS;
             }
                 strMimeType = strRHS;
             }

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

                 strDesc = strRHS;
             }
                 strDesc = strRHS;
             }

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

                 strExtensions = strRHS;
             }
                 strExtensions = strRHS;
             }

-            else if ( strLHS == _T("icon") )
+            else if ( strLHS == wxT("icon") )

             {
                 // this one is simply ignored: it usually refers to Netscape
                 // built in icons which are useless for us anyhow
             }
             {
                 // 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-")) )
+            else if ( !strLHS.StartsWith(wxT("x-")) )

             {
                 // we suppose that all fields starting with "X-" are
                 // unregistered extensions according to the standard practice,
                 // but it may be worth telling the user about other junk in
                 // his mime.types file
             {
                 // 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(wxT("Unknown field in file %s, line %lu: '%s'."),
+                             strFileName.c_str(), nLine + 1L, strLHS.c_str());

             }
 
             }
 

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

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


@@ -2221,7 +2430,7 @@ bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
         pc = NULL;
     }
 
         pc = NULL;
     }
 

-    return TRUE;
+    return true;

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


@@ -2246,7 +2455,7 @@ struct MailcapLineData
          needsterminal,
          copiousoutput;
 
          needsterminal,
          copiousoutput;
 

-    MailcapLineData() { testfailed = needsterminal = copiousoutput = FALSE; }
+    MailcapLineData() { testfailed = needsterminal = copiousoutput = false; }

 };
 
 // process a non-standard (i.e. not the first or second one) mailcap field
 };
 
 // process a non-standard (i.e. not the first or second one) mailcap field


@@ -2257,7 +2466,7 @@ wxMimeTypesManagerImpl::ProcessOtherMailcapField(MailcapLineData& data,
     if ( curField.empty() )
     {
         // we don't care
     if ( curField.empty() )
     {
         // we don't care

-        return TRUE;
+        return true;

     }
 
     // is this something of the form foo=bar?
     }
 
     // is this something of the form foo=bar?


@@ -2268,8 +2477,8 @@ wxMimeTypesManagerImpl::ProcessOtherMailcapField(MailcapLineData& data,
         wxString lhs = curField.BeforeFirst(wxT('=')),
                  rhs = curField.AfterFirst(wxT('='));
 
         wxString lhs = curField.BeforeFirst(wxT('=')),
                  rhs = curField.AfterFirst(wxT('='));
 

-        lhs.Trim(TRUE);     // from right
-        rhs.Trim(FALSE);    // from left
+        lhs.Trim(true);     // from right
+        rhs.Trim(false);    // from left

 
         // it might be quoted
         if ( !rhs.empty() && rhs[0u] == wxT('"') && rhs.Last() == wxT('"') )
 
         // it might be quoted
         if ( !rhs.empty() && rhs[0u] == wxT('"') && rhs.Last() == wxT('"') )


@@ -2286,7 +2495,6 @@ wxMimeTypesManagerImpl::ProcessOtherMailcapField(MailcapLineData& data,
                 wxLogTrace(TRACE_MIME_TEST,
                            wxT("Test '%s' for mime type '%s' succeeded."),
                            rhs.c_str(), data.type.c_str());
                 wxLogTrace(TRACE_MIME_TEST,
                            wxT("Test '%s' for mime type '%s' succeeded."),
                            rhs.c_str(), data.type.c_str());

-

             }
             else
             {
             }
             else
             {


@@ -2294,7 +2502,7 @@ wxMimeTypesManagerImpl::ProcessOtherMailcapField(MailcapLineData& data,
                            wxT("Test '%s' for mime type '%s' failed, skipping."),
                            rhs.c_str(), data.type.c_str());
 
                            wxT("Test '%s' for mime type '%s' failed, skipping."),
                            rhs.c_str(), data.type.c_str());
 

-                data.testfailed = TRUE;
+                data.testfailed = true;

             }
         }
         else if ( lhs == wxT("desc") )
             }
         }
         else if ( lhs == wxT("desc") )


@@ -2320,21 +2528,21 @@ wxMimeTypesManagerImpl::ProcessOtherMailcapField(MailcapLineData& data,
         // so it must be a simple flag
         if ( curField == wxT("needsterminal") )
         {
         // so it must be a simple flag
         if ( curField == wxT("needsterminal") )
         {

-            data.needsterminal = TRUE;
+            data.needsterminal = true;

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

-            data.copiousoutput = TRUE;
+            data.copiousoutput = true;

         }
         else if ( !IsKnownUnimportantField(curField) )
         {
         }
         else if ( !IsKnownUnimportantField(curField) )
         {

-            return FALSE;
+            return false;

         }
     }
 
         }
     }
 

-    return TRUE;
+    return true;

 }
 
 bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
 }
 
 bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,


@@ -2343,13 +2551,9 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
     wxLogTrace(TRACE_MIME, wxT("--- Parsing mailcap file '%s' ---"),
                strFileName.c_str());
 
     wxLogTrace(TRACE_MIME, wxT("--- Parsing mailcap file '%s' ---"),
                strFileName.c_str());
 

-    wxTextFile file(strFileName);
-#if defined(__WXGTK20__) && wxUSE_UNICODE
-    if ( !file.Open( wxConvUTF8) )
-#else
+    wxMimeTextFile file(strFileName);

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

-#endif
-        return FALSE;
+        return false;

 
     // indices of MIME types (in m_aTypes) we already found in this file
     //
 
     // indices of MIME types (in m_aTypes) we already found in this file
     //


@@ -2360,6 +2564,10 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
     wxString curField;
     curField.reserve(1024);
 
     wxString curField;
     curField.reserve(1024);
 

+    const wxChar *pPagerEnv = wxGetenv(wxT("PAGER"));
+
+    const wxArrayString empty_extensions_list;
+

     size_t nLineCount = file.GetLineCount();
     for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
     {
     size_t nLineCount = file.GetLineCount();
     for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
     {


@@ -2387,12 +2595,13 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
             Field_Type,
             Field_OpenCmd,
             Field_Other
             Field_Type,
             Field_OpenCmd,
             Field_Other

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

 
         // the flags and field values on the current line
         MailcapLineData data;
 
 
         // the flags and field values on the current line
         MailcapLineData data;
 

-        bool cont = TRUE;
+        bool cont = true;

         while ( cont )
         {
             switch ( *pc )
         while ( cont )
         {
             switch ( *pc )


@@ -2406,13 +2615,11 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                         if ( nLine == nLineCount - 1 )
                         {
                             // something is wrong, bail out
                         if ( nLine == nLineCount - 1 )
                         {
                             // something is wrong, bail out

-                            cont = FALSE;
+                            cont = false;

 
 

-                            wxLogDebug(wxT("Mailcap file %s, line %lu: "
-                                           "'\\' 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(),

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

                         }
                         else
                         {
                         }
                         else
                         {


@@ -2431,13 +2638,13 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                     break;
 
                 case wxT('\0'):
                     break;
 
                 case wxT('\0'):

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

 
                     // fall through to still process this field
 
                 case wxT(';'):
                     // trim whitespaces from both sides
 
                     // fall through to still process this field
 
                 case wxT(';'):
                     // trim whitespaces from both sides

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

 
                     switch ( currentToken )
                     {
 
                     switch ( currentToken )
                     {


@@ -2447,7 +2654,7 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                             {
                                 // 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

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

                             }
 
                             if ( data.type.Find(wxT('/')) == wxNOT_FOUND )
                             }
 
                             if ( data.type.Find(wxT('/')) == wxNOT_FOUND )


@@ -2474,11 +2681,9 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                                 // this might be useful for the programmer
                                 wxLogDebug
                                 (
                                 // this might be useful for the programmer
                                 wxLogDebug
                                 (

-                                    wxT("Mailcap file %s, line %lu: "
-                                        "unknown field '%s' for the "
-                                        "MIME type '%s' ignored."),
+                                    wxT("Mailcap file %s, line %lu: unknown field '%s' for the MIME type '%s' ignored."),

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

-                                    (unsigned long)nLine + 1,
+                                    nLine + 1L,

                                     curField.c_str(),
                                     data.type.c_str()
                                 );
                                     curField.c_str(),
                                     data.type.c_str()
                                 );


@@ -2486,7 +2691,7 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
                             else if ( data.testfailed )
                             {
                                 // skip this entry entirely
                             else if ( data.testfailed )
                             {
                                 // skip this entry entirely

-                                cont = FALSE;
+                                cont = false;

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


@@ -2515,15 +2720,13 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
         // check that we really read something reasonable
         if ( currentToken < Field_Other )
         {
         // check that we really read something reasonable
         if ( currentToken < Field_Other )
         {

-            wxLogWarning(_("Mailcap file %s, line %d: incomplete entry "
-                           "ignored."),
-                         strFileName.c_str(), nLine + 1);
+            wxLogWarning(wxT("Mailcap file %s, line %lu: incomplete entry ignored."),
+                         strFileName.c_str(), nLine + 1L);

 
             continue;
         }
 
 
             continue;
         }
 

-        // if the test command failed, it's as if the entry were not there at
-        // all
+        // if the test command failed, it's as if the entry were not there at all

         if ( data.testfailed )
         {
             continue;
         if ( data.testfailed )
         {
             continue;


@@ -2539,19 +2742,18 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
         // is a bad idea (FIXME)
         if ( data.copiousoutput )
         {
         // is a bad idea (FIXME)
         if ( data.copiousoutput )
         {

-            const wxChar *p = wxGetenv(_T("PAGER"));
-            data.cmdOpen << _T(" | ") << (p ? p : _T("more"));
+            data.cmdOpen << wxT(" | ") << (pPagerEnv ? pPagerEnv : wxT("more"));

         }
 
         if ( data.needsterminal )
         {
         }
 
         if ( data.needsterminal )
         {

-            data.cmdOpen = wxString::Format(_T("xterm -e sh -c '%s'"),
-                                            data.cmdOpen.c_str());
+            data.cmdOpen.insert(0, wxT("xterm -e sh -c '"));
+            data.cmdOpen.append(wxT("'"));

         }
 
         if ( !data.cmdOpen.empty() )
         {
         }
 
         if ( !data.cmdOpen.empty() )
         {

-            data.verbs.Insert(_T("open"), 0);
+            data.verbs.Insert(wxT("open"), 0);

             data.commands.Insert(data.cmdOpen, 0);
         }
 
             data.commands.Insert(data.cmdOpen, 0);
         }
 


@@ -2562,28 +2764,29 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
         // the fall back entries have the lowest priority, by definition
         if ( fallback )
         {
         // the fall back entries have the lowest priority, by definition
         if ( fallback )
         {

-            overwrite = FALSE;
+            overwrite = false;

         }
         else
         {
             // have we seen this one before?
             int nIndex = m_aTypes.Index(data.type);
 
         }
         else
         {
             // have we seen this one before?
             int nIndex = m_aTypes.Index(data.type);
 

-            // and if we have, was it in this file?
+            // and if we have, was it in this file? if not, we should
+            // overwrite the previously seen one

             overwrite = nIndex == wxNOT_FOUND ||
             overwrite = nIndex == wxNOT_FOUND ||

-                            aIndicesSeenHere.Index(nIndex) != wxNOT_FOUND;
+                            aIndicesSeenHere.Index(nIndex) == wxNOT_FOUND;

         }
 
         }
 

-        wxLogTrace(TRACE_MIME, _T("mailcap %s: %s [%s]"),
+        wxLogTrace(TRACE_MIME, wxT("mailcap %s: %s [%s]"),

                    data.type.c_str(), data.cmdOpen.c_str(),
                    data.type.c_str(), data.cmdOpen.c_str(),

-                   overwrite ? _T("replace") : _T("add"));
+                   overwrite ? wxT("replace") : wxT("add"));

 
         int n = AddToMimeData
                 (
                     data.type,
                     data.icon,
                     new wxMimeTypeCommands(data.verbs, data.commands),
 
         int n = AddToMimeData
                 (
                     data.type,
                     data.icon,
                     new wxMimeTypeCommands(data.verbs, data.commands),

-                    wxArrayString() /* extensions */,
+                    empty_extensions_list,

                     data.desc,
                     overwrite
                 );
                     data.desc,
                     overwrite
                 );


@@ -2594,7 +2797,7 @@ bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
         }
     }
 
         }
     }
 

-    return TRUE;
+    return true;

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


@@ -2603,13 +2806,12 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 
     mimetypes.Empty();
 
 
     mimetypes.Empty();
 

-    wxString type;

     size_t count = m_aTypes.GetCount();
     for ( size_t n = 0; n < count; n++ )
     {
         // don't return template types from here (i.e. anything containg '*')
     size_t count = m_aTypes.GetCount();
     for ( size_t n = 0; n < count; n++ )
     {
         // don't return template types from here (i.e. anything containg '*')

-        type = m_aTypes[n];
-        if ( type.Find(_T('*')) == wxNOT_FOUND )
+        const wxString &type = m_aTypes[n];
+        if ( type.Find(wxT('*')) == wxNOT_FOUND )

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


@@ -2624,23 +2826,25 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 
 bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
 {
 
 bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
 {

+    InitIfNeeded();
+

     wxArrayString sMimeTypes;
     wxArrayString sMimeTypes;

-    ft->GetMimeTypes (sMimeTypes);
+    ft->GetMimeTypes(sMimeTypes);

 
 

-    wxString sMime;

     size_t i;
     size_t i;

-    for (i = 0; i < sMimeTypes.GetCount(); i ++)
+    size_t nCount = sMimeTypes.GetCount();
+    for (i = 0; i < nCount; i ++)

     {
     {

-        sMime = sMimeTypes.Item(i);
-        int nIndex = m_aTypes.Index (sMime);
+        const wxString &sMime = sMimeTypes.Item(i);
+        int nIndex = m_aTypes.Index(sMime);

         if ( nIndex == wxNOT_FOUND)
         {
             // error if we get here ??
         if ( nIndex == wxNOT_FOUND)
         {
             // error if we get here ??

-            return FALSE;
+            return false;

         }
         else
         {
         }
         else
         {

-            WriteMimeInfo(nIndex, TRUE );
+            WriteMimeInfo(nIndex, true);

             m_aTypes.RemoveAt(nIndex);
             m_aEntries.RemoveAt(nIndex);
             m_aExtensions.RemoveAt(nIndex);
             m_aTypes.RemoveAt(nIndex);
             m_aEntries.RemoveAt(nIndex);
             m_aExtensions.RemoveAt(nIndex);


@@ -2654,7 +2858,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;

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


@@ -2663,23 +2867,22 @@ bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
 
 static bool IsKnownUnimportantField(const wxString& fieldAll)
 {
 
 static bool IsKnownUnimportantField(const wxString& fieldAll)
 {

-    static const wxChar *knownFields[] =
+    static const wxChar * const knownFields[] =

     {
     {

-        _T("x-mozilla-flags"),
-        _T("nametemplate"),
-        _T("textualnewlines"),
+        wxT("x-mozilla-flags"),
+        wxT("nametemplate"),
+        wxT("textualnewlines"),

     };
 
     };
 

-    wxString field = fieldAll.BeforeFirst(_T('='));
+    wxString field = fieldAll.BeforeFirst(wxT('='));

     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
   // wxUSE_MIMETYPE && wxUSE_FILE && wxUSE_TEXTFILE
 }
 
 #endif
   // wxUSE_MIMETYPE && wxUSE_FILE && wxUSE_TEXTFILE

-