]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/mimetype.cpp
Added ability to switch off more components of the size page UI
[wxWidgets.git] / src / msw / mimetype.cpp
index e78a77cac0f480246dc56a7b1286086c9e7bc2a8..70312302ab6825d6674528792fa7ece96bead472 100644 (file)
@@ -1,58 +1,56 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        msw/mimetype.cpp
+// Name:        src/msw/mimetype.cpp
 // Purpose:     classes and functions to manage MIME types
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     23.09.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Purpose:     classes and functions to manage MIME types
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     23.09.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// Licence:     wxWindows license (part of wxExtra library)
+// Licence:     wxWindows licence (part of wxExtra library)
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef    __GNUG__
-#pragma implementation "mimetype.h"
-#endif
-
 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-  #pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #endif
 
-// Doesn't compile in WIN16 mode
-#ifndef __WIN16__
+#if wxUSE_MIMETYPE
+
+#include "wx/msw/mimetype.h"
 
 #ifndef WX_PRECOMP
 
 #ifndef WX_PRECOMP
-  #include "wx/string.h"
-  #if wxUSE_GUI
-    #include "wx/icon.h"
-  #endif
+    #include "wx/dynarray.h"
+    #include "wx/string.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"
+    #include "wx/crt.h"
+    #if wxUSE_GUI
+        #include "wx/icon.h"
+        #include "wx/msgdlg.h"
+    #endif
 #endif //WX_PRECOMP
 
 #endif //WX_PRECOMP
 
-#include "wx/log.h"
 #include "wx/file.h"
 #include "wx/file.h"
-#include "wx/intl.h"
-#include "wx/dynarray.h"
+#include "wx/iconloc.h"
 #include "wx/confbase.h"
 
 #include "wx/confbase.h"
 
-#ifdef __WXMSW__
+#ifdef __WINDOWS__
     #include "wx/msw/registry.h"
     #include "wx/msw/registry.h"
-    #include "windows.h"
+    #include "wx/msw/private.h"
 #endif // OS
 
 #endif // OS
 
-#include "wx/msw/mimetype.h"
-
 // other standard headers
 #include <ctype.h>
 
 // in case we're compiling in non-GUI mode
 // other standard headers
 #include <ctype.h>
 
 // in case we're compiling in non-GUI mode
-class WXDLLEXPORT wxIcon;
+class WXDLLIMPEXP_FWD_CORE wxIcon;
 
 // These classes use Windows registry to retrieve the required information.
 //
 // Keys used (not all of them are documented, so it might actually stop working
 
 // These classes use Windows registry to retrieve the required information.
 //
 // Keys used (not all of them are documented, so it might actually stop working
-// in futur versions of Windows...):
+// in future versions of Windows...):
 //  1. "HKCR\MIME\Database\Content Type" contains subkeys for all known MIME
 //     types, each key has a string value "Extension" which gives (dot preceded)
 //     extension for the files of this MIME type.
 //  1. "HKCR\MIME\Database\Content Type" contains subkeys for all known MIME
 //     types, each key has a string value "Extension" which gives (dot preceded)
 //     extension for the files of this MIME type.
@@ -73,16 +71,204 @@ class WXDLLEXPORT wxIcon;
 // location, uses it, so it isn't likely to change
 static const wxChar *MIME_DATABASE_KEY = wxT("MIME\\Database\\Content Type\\");
 
 // location, uses it, so it isn't likely to change
 static const wxChar *MIME_DATABASE_KEY = wxT("MIME\\Database\\Content Type\\");
 
-wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const
+// this function replaces Microsoft %1 with Unix-like %s
+static bool CanonicalizeParams(wxString& command)
+{
+    // transform it from '%1' to '%s' style format string (now also test for %L
+    // as apparently MS started using it as well for the same purpose)
+
+    // NB: we don't make any attempt to verify that the string is valid, i.e.
+    //     doesn't contain %2, or second %1 or .... But we do make sure that we
+    //     return a string with _exactly_ one '%s'!
+    bool foundFilename = false;
+    size_t len = command.length();
+    for ( size_t n = 0; (n < len) && !foundFilename; n++ )
+    {
+        if ( command[n] == wxT('%') &&
+                (n + 1 < len) &&
+                (command[n + 1] == wxT('1') || command[n + 1] == wxT('L')) )
+        {
+            // replace it with '%s'
+            command[n + 1] = wxT('s');
+
+            foundFilename = true;
+        }
+    }
+
+    if ( foundFilename )
+    {
+        // Some values also contain an addition %* expansion string which is
+        // presumably supposed to be replaced with the names of the other files
+        // accepted by the command. As we don't support more than one file
+        // anyhow, simply ignore it.
+        command.Replace(" %*", "");
+    }
+
+    return foundFilename;
+}
+
+void wxFileTypeImpl::Init(const wxString& strFileType, const wxString& ext)
+{
+    // VZ: does it? (FIXME)
+    wxCHECK_RET( !ext.empty(), wxT("needs an extension") );
+
+    if ( ext[0u] != wxT('.') ) {
+        m_ext = wxT('.');
+    }
+    m_ext << ext;
+
+    m_strFileType = strFileType;
+    if ( !strFileType ) {
+        m_strFileType = m_ext.AfterFirst('.') + wxT("_auto_file");
+    }
+}
+
+wxString wxFileTypeImpl::GetVerbPath(const wxString& verb) const
+{
+    wxString path;
+    path << m_strFileType << wxT("\\shell\\") << verb << wxT("\\command");
+    return path;
+}
+
+size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
+                                      wxArrayString *commands,
+                                      const wxFileType::MessageParameters& params) const
+{
+    wxCHECK_MSG( !m_ext.empty(), 0, wxT("GetAllCommands() needs an extension") );
+
+    if ( m_strFileType.empty() )
+    {
+        // get it from the registry
+        wxFileTypeImpl *self = wxConstCast(this, wxFileTypeImpl);
+        wxRegKey rkey(wxRegKey::HKCR, m_ext);
+        if ( !rkey.Exists() || !rkey.QueryValue(wxEmptyString, self->m_strFileType) )
+        {
+            wxLogDebug(wxT("Can't get the filetype for extension '%s'."),
+                       m_ext.c_str());
+
+            return 0;
+        }
+    }
+
+    // enum all subkeys of HKCR\filetype\shell
+    size_t count = 0;
+    wxRegKey rkey(wxRegKey::HKCR, m_strFileType  + wxT("\\shell"));
+    long dummy;
+    wxString verb;
+    bool ok = rkey.GetFirstKey(verb, dummy);
+    while ( ok )
+    {
+        wxString command = wxFileType::ExpandCommand(GetCommand(verb), params);
+
+        // we want the open bverb to eb always the first
+
+        if ( verb.CmpNoCase(wxT("open")) == 0 )
+        {
+            if ( verbs )
+                verbs->Insert(verb, 0);
+            if ( commands )
+                commands->Insert(command, 0);
+        }
+        else // anything else than "open"
+        {
+            if ( verbs )
+                verbs->Add(verb);
+            if ( commands )
+                commands->Add(command);
+        }
+
+        count++;
+
+        ok = rkey.GetNextKey(verb, dummy);
+    }
+
+    return count;
+}
+
+// ----------------------------------------------------------------------------
+// modify the registry database
+// ----------------------------------------------------------------------------
+
+bool wxFileTypeImpl::EnsureExtKeyExists()
+{
+    wxRegKey rkey(wxRegKey::HKCR, m_ext);
+    if ( !rkey.Exists() )
+    {
+        if ( !rkey.Create() || !rkey.SetValue(wxEmptyString, m_strFileType) )
+        {
+            wxLogError(_("Failed to create registry entry for '%s' files."),
+                       m_ext.c_str());
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// ----------------------------------------------------------------------------
+// get the command to use
+// ----------------------------------------------------------------------------
+
+static wxString wxFileTypeImplGetCurVer(const wxString& progId)
+{
+    wxRegKey key(wxRegKey::HKCR, progId + wxT("\\CurVer"));
+    if (key.Exists())
+    {
+        wxString value;
+        if (key.QueryValue(wxEmptyString, value))
+            return value;
+    }
+    return progId;
+}
+
+wxString wxFileTypeImpl::GetCommand(const wxString& verb) const
 {
     // suppress possible error messages
     wxLogNull nolog;
     wxString strKey;
 
 {
     // suppress possible error messages
     wxLogNull nolog;
     wxString strKey;
 
-    if ( wxRegKey(wxRegKey::HKCR, m_ext + _T("\\shell")).Exists() )
+    // Since Windows Vista the association used by Explorer is different from
+    // the association information stored in the traditional part of the
+    // registry. Unfortunately the new schema doesn't seem to be documented
+    // anywhere so using it involves a bit of guesswork:
+    //
+    // The information is stored under Explorer-specific key whose path is
+    // below. The interesting part is UserChoice subkey which is the only one
+    // we use so far but there is also OpenWithProgids subkey which can exist
+    // even if UserChoice doesn't. However in practice there doesn't seem to be
+    // any cases when OpenWithProgids values for the given extension are
+    // different from those found directly under HKCR\.ext, so for now we don't
+    // bother to use this, apparently the programs registering their file type
+    // associations do it in both places. We do use UserChoice because when the
+    // association is manually changed by the user it's only recorded there and
+    // so must override whatever value was created under HKCR by the setup
+    // program.
+
+    {
+        wxRegKey explorerKey
+                 (
+                    wxRegKey::HKCU,
+                    wxT("Software\\Microsoft\\Windows\\CurrentVersion\\")
+                    wxT("Explorer\\FileExts\\") +
+                    m_ext +
+                    wxT("\\UserChoice")
+                 );
+        if ( explorerKey.Open(wxRegKey::Read) &&
+                explorerKey.QueryValue(wxT("Progid"), strKey) )
+        {
+            strKey = wxFileTypeImplGetCurVer(strKey);
+        }
+    }
+
+    if (!strKey && wxRegKey(wxRegKey::HKCR, m_ext + wxT("\\shell")).Exists())
         strKey = m_ext;
         strKey = m_ext;
-    if ( wxRegKey(wxRegKey::HKCR, m_strFileType + _T("\\shell")).Exists() )
-        strKey = m_strFileType;
+
+    if ( !strKey && !m_strFileType.empty())
+    {
+        wxString fileType = wxFileTypeImplGetCurVer(m_strFileType);
+        if (wxRegKey(wxRegKey::HKCR, fileType + wxT("\\shell")).Exists())
+            strKey = fileType;
+    }
 
     if ( !strKey )
     {
 
     if ( !strKey )
     {
@@ -91,58 +277,43 @@ wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const
     }
 
     strKey << wxT("\\shell\\") << verb;
     }
 
     strKey << wxT("\\shell\\") << verb;
-    wxRegKey key(wxRegKey::HKCR, strKey + _T("\\command"));
+    wxRegKey key(wxRegKey::HKCR, strKey + wxT("\\command"));
     wxString command;
     wxString command;
-    if ( key.Open() ) {
+    if ( key.Open(wxRegKey::Read) ) {
         // it's the default value of the key
         // it's the default value of the key
-        if ( key.QueryValue(wxT(""), command) ) {
-            // transform it from '%1' to '%s' style format string (now also
-            // test for %L - apparently MS started using it as well for the
-            // same purpose)
-
-            // NB: we don't make any attempt to verify that the string is valid,
-            //     i.e. doesn't contain %2, or second %1 or .... But we do make
-            //     sure that we return a string with _exactly_ one '%s'!
-            bool foundFilename = FALSE;
-            size_t len = command.Len();
-            for ( size_t n = 0; (n < len) && !foundFilename; n++ ) {
-                if ( command[n] == wxT('%') &&
-                     (n + 1 < len) &&
-                     (command[n + 1] == wxT('1') ||
-                      command[n + 1] == wxT('L')) ) {
-                    // replace it with '%s'
-                    command[n + 1] = wxT('s');
-
-                    foundFilename = TRUE;
-                }
-            }
+        if ( key.QueryValue(wxEmptyString, command) ) {
+            bool foundFilename = CanonicalizeParams(command);
 
 
-#if wxUSE_DDE
+#if wxUSE_IPC
             // look whether we must issue some DDE requests to the application
             // (and not just launch it)
             // look whether we must issue some DDE requests to the application
             // (and not just launch it)
-            strKey += _T("\\DDEExec");
+            strKey += wxT("\\DDEExec");
             wxRegKey keyDDE(wxRegKey::HKCR, strKey);
             wxRegKey keyDDE(wxRegKey::HKCR, strKey);
-            if ( keyDDE.Open() ) {
+            if ( keyDDE.Open(wxRegKey::Read) ) {
                 wxString ddeCommand, ddeServer, ddeTopic;
                 wxString ddeCommand, ddeServer, ddeTopic;
-                keyDDE.QueryValue(_T(""), ddeCommand);
-                ddeCommand.Replace(_T("%1"), _T("%s"));
+                keyDDE.QueryValue(wxEmptyString, ddeCommand);
+                ddeCommand.Replace(wxT("%1"), wxT("%s"));
+
+                wxRegKey keyServer(wxRegKey::HKCR, strKey + wxT("\\Application"));
+                keyServer.QueryValue(wxEmptyString, ddeServer);
+                wxRegKey keyTopic(wxRegKey::HKCR, strKey + wxT("\\Topic"));
+                keyTopic.QueryValue(wxEmptyString, ddeTopic);
 
 
-                wxRegKey(wxRegKey::HKCR, strKey + _T("\\Application")).
-                    QueryValue(_T(""), ddeServer);
-                wxRegKey(wxRegKey::HKCR, strKey + _T("\\Topic")).
-                    QueryValue(_T(""), ddeTopic);
+                if (ddeTopic.empty())
+                    ddeTopic = wxT("System");
 
                 // HACK: we use a special feature of wxExecute which exists
                 //       just because we need it here: it will establish DDE
                 //       conversation with the program it just launched
 
                 // HACK: we use a special feature of wxExecute which exists
                 //       just because we need it here: it will establish DDE
                 //       conversation with the program it just launched
-                command.Prepend(_T("WX_DDE#"));
-                command << _T('#') << ddeServer
-                        << _T('#') << ddeTopic
-                        << _T('#') << ddeCommand;
+                command.Prepend(wxT("WX_DDE#"));
+                command << wxT('#') << ddeServer
+                        << wxT('#') << ddeTopic
+                        << wxT('#') << ddeCommand;
             }
             else
             }
             else
-#endif // wxUSE_DDE
-                if ( !foundFilename ) {
+#endif // wxUSE_IPC
+            if ( !foundFilename )
+            {
                 // we didn't find any '%1' - the application doesn't know which
                 // file to open (note that we only do it if there is no DDEExec
                 // subkey)
                 // we didn't find any '%1' - the application doesn't know which
                 // file to open (note that we only do it if there is no DDEExec
                 // subkey)
@@ -162,17 +333,11 @@ wxFileTypeImpl::GetOpenCommand(wxString *openCmd,
                                const wxFileType::MessageParameters& params)
                                const
 {
                                const wxFileType::MessageParameters& params)
                                const
 {
-    wxString cmd;
-    if ( m_info ) {
-        cmd = m_info->GetOpenCommand();
-    }
-    else {
-        cmd = GetCommand(wxT("open"));
-    }
+    wxString cmd = GetCommand(wxT("open"));
 
     *openCmd = wxFileType::ExpandCommand(cmd, params);
 
 
     *openCmd = wxFileType::ExpandCommand(cmd, params);
 
-    return !openCmd->IsEmpty();
+    return !openCmd->empty();
 }
 
 bool
 }
 
 bool
@@ -180,85 +345,61 @@ wxFileTypeImpl::GetPrintCommand(wxString *printCmd,
                                 const wxFileType::MessageParameters& params)
                                 const
 {
                                 const wxFileType::MessageParameters& params)
                                 const
 {
-    wxString cmd;
-    if ( m_info ) {
-        cmd = m_info->GetPrintCommand();
-    }
-    else {
-        cmd = GetCommand(wxT("print"));
-    }
+    wxString cmd = GetCommand(wxT("print"));
 
     *printCmd = wxFileType::ExpandCommand(cmd, params);
 
 
     *printCmd = wxFileType::ExpandCommand(cmd, params);
 
-    return !printCmd->IsEmpty();
+    return !printCmd->empty();
 }
 
 }
 
+// ----------------------------------------------------------------------------
+// getting other stuff
+// ----------------------------------------------------------------------------
+
 // TODO this function is half implemented
 bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
 {
 // TODO this function is half implemented
 bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
 {
-    if ( m_info ) {
-        extensions = m_info->GetExtensions();
-
-        return TRUE;
-    }
-    else if ( m_ext.IsEmpty() ) {
+    if ( m_ext.empty() ) {
         // the only way to get the list of extensions from the file type is to
         // scan through all extensions in the registry - too slow...
         // the only way to get the list of extensions from the file type is to
         // scan through all extensions in the registry - too slow...
-        return FALSE;
+        return false;
     }
     else {
         extensions.Empty();
         extensions.Add(m_ext);
 
         // it's a lie too, we don't return _all_ extensions...
     }
     else {
         extensions.Empty();
         extensions.Add(m_ext);
 
         // it's a lie too, we don't return _all_ extensions...
-        return TRUE;
+        return true;
     }
 }
 
 bool wxFileTypeImpl::GetMimeType(wxString *mimeType) const
 {
     }
 }
 
 bool wxFileTypeImpl::GetMimeType(wxString *mimeType) const
 {
-    if ( m_info ) {
-        // we already have it
-        *mimeType = m_info->GetMimeType();
-
-        return TRUE;
-    }
-
     // suppress possible error messages
     wxLogNull nolog;
     // suppress possible error messages
     wxLogNull nolog;
-    wxRegKey key(wxRegKey::HKCR, wxT(".") + m_ext);
-    if ( key.Open() && key.QueryValue(wxT("Content Type"), *mimeType) ) {
-        return TRUE;
-    }
-    else {
-        return FALSE;
-    }
-}
+    wxRegKey key(wxRegKey::HKCR, m_ext);
 
 
+    return key.Open(wxRegKey::Read) &&
+                key.QueryValue(wxT("Content Type"), *mimeType);
+}
 
 bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
 {
     wxString s;
 
 bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
 {
     wxString s;
-    
-    if (GetMimeType(&s))
+
+    if ( !GetMimeType(&s) )
     {
     {
-        mimeTypes.Clear();
-        mimeTypes.Add(s);
-        return TRUE;
+        return false;
     }
     }
-    else 
-        return FALSE;
+
+    mimeTypes.Clear();
+    mimeTypes.Add(s);
+    return true;
 }
 
 
 }
 
 
-bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
+bool wxFileTypeImpl::GetIcon(wxIconLocation *iconLoc) const
 {
 {
-#if wxUSE_GUI
-    if ( m_info ) {
-        // we don't have icons in the fallback resources
-        return FALSE;
-    }
-
     wxString strIconKey;
     strIconKey << m_strFileType << wxT("\\DefaultIcon");
 
     wxString strIconKey;
     strIconKey << m_strFileType << wxT("\\DefaultIcon");
 
@@ -266,10 +407,10 @@ bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
     wxLogNull nolog;
     wxRegKey key(wxRegKey::HKCR, strIconKey);
 
     wxLogNull nolog;
     wxRegKey key(wxRegKey::HKCR, strIconKey);
 
-    if ( key.Open() ) {
+    if ( key.Open(wxRegKey::Read) ) {
         wxString strIcon;
         // it's the default value of the key
         wxString strIcon;
         // it's the default value of the key
-        if ( key.QueryValue(wxT(""), strIcon) ) {
+        if ( key.QueryValue(wxEmptyString, strIcon) ) {
             // the format is the following: <full path to file>, <icon index>
             // NB: icon index may be negative as well as positive and the full
             //     path may contain the environment variables inside '%'
             // the format is the following: <full path to file>, <icon index>
             // NB: icon index may be negative as well as positive and the full
             //     path may contain the environment variables inside '%'
@@ -278,56 +419,49 @@ bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
 
             // index may be omitted, in which case BeforeLast(',') is empty and
             // AfterLast(',') is the whole string
 
             // index may be omitted, in which case BeforeLast(',') is empty and
             // AfterLast(',') is the whole string
-            if ( strFullPath.IsEmpty() ) {
+            if ( strFullPath.empty() ) {
                 strFullPath = strIndex;
                 strIndex = wxT("0");
             }
 
                 strFullPath = strIndex;
                 strIndex = wxT("0");
             }
 
-            wxString strExpPath = wxExpandEnvVars(strFullPath);
-            int nIndex = wxAtoi(strIndex);
-
-            HICON hIcon = ExtractIcon(GetModuleHandle(NULL), strExpPath, nIndex);
-            switch ( (int)hIcon ) {
-                case 0: // means no icons were found
-                case 1: // means no such file or it wasn't a DLL/EXE/OCX/ICO/...
-                    wxLogDebug(wxT("incorrect registry entry '%s': no such icon."),
-                               key.GetName().c_str());
-                    break;
+            if ( iconLoc )
+            {
+                iconLoc->SetFileName(wxExpandEnvVars(strFullPath));
 
 
-                default:
-                    icon->SetHICON((WXHICON)hIcon);
-                    return TRUE;
+                iconLoc->SetIndex(wxAtoi(strIndex));
             }
             }
+
+            return true;
         }
     }
 
     // no such file type or no value or incorrect icon entry
         }
     }
 
     // no such file type or no value or incorrect icon entry
-#endif // wxUSE_GUI
-
-    return FALSE;
+    return false;
 }
 
 bool wxFileTypeImpl::GetDescription(wxString *desc) const
 {
 }
 
 bool wxFileTypeImpl::GetDescription(wxString *desc) const
 {
-    if ( m_info ) {
-        // we already have it
-        *desc = m_info->GetDescription();
-
-        return TRUE;
-    }
-
     // suppress possible error messages
     wxLogNull nolog;
     wxRegKey key(wxRegKey::HKCR, m_strFileType);
 
     // suppress possible error messages
     wxLogNull nolog;
     wxRegKey key(wxRegKey::HKCR, m_strFileType);
 
-    if ( key.Open() ) {
+    if ( key.Open(wxRegKey::Read) ) {
         // it's the default value of the key
         // it's the default value of the key
-        if ( key.QueryValue(wxT(""), *desc) ) {
-            return TRUE;
+        if ( key.QueryValue(wxEmptyString, *desc) ) {
+            return true;
         }
     }
 
         }
     }
 
-    return FALSE;
+    return false;
+}
+
+// helper function
+wxFileType *
+wxMimeTypesManagerImpl::CreateFileType(const wxString& filetype, const wxString& ext)
+{
+    wxFileType *fileType = new wxFileType;
+    fileType->m_impl->Init(filetype, ext);
+    return fileType;
 }
 
 // extension -> file type
 }
 
 // extension -> file type
@@ -344,53 +478,46 @@ wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
     // suppress possible error messages
     wxLogNull nolog;
 
     // suppress possible error messages
     wxLogNull nolog;
 
-    bool knownExtension = FALSE;
+    bool knownExtension = false;
 
     wxString strFileType;
     wxRegKey key(wxRegKey::HKCR, str);
 
     wxString strFileType;
     wxRegKey key(wxRegKey::HKCR, str);
-    if ( key.Open() ) {
+    if ( key.Open(wxRegKey::Read) ) {
         // it's the default value of the key
         // it's the default value of the key
-        if ( key.QueryValue(wxT(""), strFileType) ) {
+        if ( key.QueryValue(wxEmptyString, strFileType) ) {
             // create the new wxFileType object
             // create the new wxFileType object
-            wxFileType *fileType = new wxFileType;
-            fileType->m_impl->Init(strFileType, ext);
-
-            return fileType;
+            return CreateFileType(strFileType, ext);
         }
         else {
             // this extension doesn't have a filetype, but it's known to the
             // system and may be has some other useful keys (open command or
             // content-type), so still return a file type object for it
         }
         else {
             // this extension doesn't have a filetype, but it's known to the
             // system and may be has some other useful keys (open command or
             // content-type), so still return a file type object for it
-            knownExtension = TRUE;
+            knownExtension = true;
         }
     }
 
         }
     }
 
-    // check the fallbacks
-    // TODO linear search is potentially slow, perhaps we should use a sorted
-    //      array?
-    size_t count = m_fallbacks.GetCount();
-    for ( size_t n = 0; n < count; n++ ) {
-        if ( m_fallbacks[n].GetExtensions().Index(ext) != wxNOT_FOUND ) {
-            wxFileType *fileType = new wxFileType;
-            fileType->m_impl->Init(m_fallbacks[n]);
-
-            return fileType;
-        }
+    if ( !knownExtension )
+    {
+        // unknown extension
+        return NULL;
     }
 
     }
 
-    if ( knownExtension )
-    {
-        wxFileType *fileType = new wxFileType;
-        fileType->m_impl->Init(wxEmptyString, ext);
+    return CreateFileType(wxEmptyString, ext);
+}
 
 
-        return fileType;
-    }
-    else
+/*
+wxFileType *
+wxMimeTypesManagerImpl::GetOrAllocateFileTypeFromExtension(const wxString& ext)
+{
+    wxFileType *fileType = GetFileTypeFromExtension(ext);
+    if ( !fileType )
     {
     {
-        // unknown extension
-        return NULL;
+        fileType = CreateFileType(wxEmptyString, ext);
     }
     }
+
+    return fileType;
 }
 }
+*/
 
 // MIME type -> extension -> file type
 wxFileType *
 
 // MIME type -> extension -> file type
 wxFileType *
@@ -404,26 +531,12 @@ wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
 
     wxString ext;
     wxRegKey key(wxRegKey::HKCR, strKey);
 
     wxString ext;
     wxRegKey key(wxRegKey::HKCR, strKey);
-    if ( key.Open() ) {
+    if ( key.Open(wxRegKey::Read) ) {
         if ( key.QueryValue(wxT("Extension"), ext) ) {
             return GetFileTypeFromExtension(ext);
         }
     }
 
         if ( key.QueryValue(wxT("Extension"), ext) ) {
             return GetFileTypeFromExtension(ext);
         }
     }
 
-    // check the fallbacks
-    // TODO linear search is potentially slow, perhaps we should use a sorted
-    //      array?
-    size_t count = m_fallbacks.GetCount();
-    for ( size_t n = 0; n < count; n++ ) {
-        if ( wxMimeTypesManager::IsOfType(mimeType,
-                                          m_fallbacks[n].GetMimeType()) ) {
-            wxFileType *fileType = new wxFileType;
-            fileType->m_impl->Init(m_fallbacks[n]);
-
-            return fileType;
-        }
-    }
-
     // unknown MIME type
     return NULL;
 }
     // unknown MIME type
     return NULL;
 }
@@ -446,6 +559,322 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
     return mimetypes.GetCount();
 }
 
     return mimetypes.GetCount();
 }
 
+// ----------------------------------------------------------------------------
+// create a new association
+// ----------------------------------------------------------------------------
+
+wxFileType *wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
+{
+    wxCHECK_MSG( !ftInfo.GetExtensions().empty(), NULL,
+                 wxT("Associate() needs extension") );
+
+    bool ok;
+    size_t iExtCount = 0;
+    wxString filetype;
+    wxString extWithDot;
+
+    wxString ext = ftInfo.GetExtensions()[iExtCount];
 
 
+    wxCHECK_MSG( !ext.empty(), NULL,
+                 wxT("Associate() needs non empty extension") );
+
+    if ( ext[0u] != wxT('.') )
+        extWithDot = wxT('.');
+    extWithDot += ext;
+
+    // start by setting the HKCR\\.ext entries
+    // default is filetype; content type is mimetype
+    const wxString& filetypeOrig = ftInfo.GetShortDesc();
+
+    wxRegKey key(wxRegKey::HKCR, extWithDot);
+    if ( !key.Exists() )
+    {
+        // create the mapping from the extension to the filetype
+        ok = key.Create();
+        if ( ok )
+        {
+
+            if ( filetypeOrig.empty() )
+            {
+                // make it up from the extension
+                filetype << extWithDot.c_str() + 1 << wxT("_file");
+            }
+            else
+            {
+                // just use the provided one
+                filetype = filetypeOrig;
+            }
+
+            key.SetValue(wxEmptyString, filetype);
+        }
+    }
+    else
+    {
+        // key already exists, maybe we want to change it ??
+        if (!filetypeOrig.empty())
+        {
+            filetype = filetypeOrig;
+            key.SetValue(wxEmptyString, filetype);
+        }
+        else
+        {
+            key.QueryValue(wxEmptyString, filetype);
+        }
+    }
+
+    // now set a mimetypeif we have it, but ignore it if none
+    const wxString& mimetype = ftInfo.GetMimeType();
+    if ( !mimetype.empty() )
+    {
+        // set the MIME type
+        ok = key.SetValue(wxT("Content Type"), mimetype);
+
+        if ( ok )
+        {
+            // create the MIME key
+            wxString strKey = MIME_DATABASE_KEY;
+            strKey << mimetype;
+            wxRegKey keyMIME(wxRegKey::HKCR, strKey);
+            ok = keyMIME.Create();
+
+            if ( ok )
+            {
+                // and provide a back link to the extension
+                keyMIME.SetValue(wxT("Extension"), extWithDot);
+            }
+        }
+    }
+
+
+    // now make other extensions have the same filetype
+
+    for (iExtCount=1; iExtCount < ftInfo.GetExtensionsCount(); iExtCount++ )
+    {
+        ext = ftInfo.GetExtensions()[iExtCount];
+        if ( ext[0u] != wxT('.') )
+           extWithDot = wxT('.');
+        extWithDot += ext;
+
+        wxRegKey key2(wxRegKey::HKCR, extWithDot);
+        if ( !key2.Exists() )
+            key2.Create();
+        key2.SetValue(wxEmptyString, filetype);
+
+        // now set any mimetypes we may have, but ignore it if none
+        const wxString& mimetype2 = ftInfo.GetMimeType();
+        if ( !mimetype2.empty() )
+        {
+            // set the MIME type
+            ok = key2.SetValue(wxT("Content Type"), mimetype2);
+
+            if ( ok )
+            {
+                // create the MIME key
+                wxString strKey = MIME_DATABASE_KEY;
+                strKey << mimetype2;
+                wxRegKey keyMIME(wxRegKey::HKCR, strKey);
+                ok = keyMIME.Create();
+
+                if ( ok )
+                {
+                    // and provide a back link to the extension
+                    keyMIME.SetValue(wxT("Extension"), extWithDot);
+                }
+            }
+        }
+
+    } // end of for loop; all extensions now point to HKCR\.ext\Default
+
+    // create the filetype key itself (it will be empty for now, but
+    // SetCommand(), SetDefaultIcon() &c will use it later)
+    wxRegKey keyFT(wxRegKey::HKCR, filetype);
+    keyFT.Create();
+
+    wxFileType *ft = CreateFileType(filetype, extWithDot);
+
+    if (ft)
+    {
+        if (! ftInfo.GetOpenCommand ().empty() ) ft->SetCommand (ftInfo.GetOpenCommand (), wxT("open"  ) );
+        if (! ftInfo.GetPrintCommand().empty() ) ft->SetCommand (ftInfo.GetPrintCommand(), wxT("print" ) );
+        // chris: I don't like the ->m_impl-> here FIX this ??
+        if (! ftInfo.GetDescription ().empty() ) ft->m_impl->SetDescription (ftInfo.GetDescription ()) ;
+        if (! ftInfo.GetIconFile().empty() ) ft->SetDefaultIcon (ftInfo.GetIconFile(), ftInfo.GetIconIndex() );
+
+    }
+
+    return ft;
+}
+
+bool wxFileTypeImpl::SetCommand(const wxString& cmd,
+                                const wxString& verb,
+                                bool WXUNUSED(overwriteprompt))
+{
+    wxCHECK_MSG( !m_ext.empty() && !verb.empty(), false,
+                 wxT("SetCommand() needs an extension and a verb") );
+
+    if ( !EnsureExtKeyExists() )
+        return false;
+
+    wxRegKey rkey(wxRegKey::HKCR, GetVerbPath(verb));
+#if 0
+    if ( rkey.Exists() && overwriteprompt )
+    {
+#if wxUSE_GUI
+        wxString old;
+        rkey.QueryValue(wxEmptyString, old);
+        if ( wxMessageBox
+             (
+                wxString::Format(
+                    _("Do you want to overwrite the command used to %s "
+                      "files with extension \"%s\" ?\nCurrent value is \n%s, "
+                      "\nNew value is \n%s %1"), // bug here FIX need %1 ??
+                    verb.c_str(),
+                    m_ext.c_str(),
+                    old.c_str(),
+                    cmd.c_str()),
+                _("Confirm registry update"),
+                wxYES_NO | wxICON_QUESTION
+             ) != wxYES )
+#endif // wxUSE_GUI
+        {
+            // cancelled by user
+            return false;
+        }
+    }
 #endif
 #endif
-  // __WIN16__
+    // TODO:
+    // 1. translate '%s' to '%1' instead of always adding it
+    // 2. create DDEExec value if needed (undo GetCommand)
+    return rkey.Create() && rkey.SetValue(wxEmptyString, cmd + wxT(" \"%1\"") );
+}
+
+/* // no longer used
+bool wxFileTypeImpl::SetMimeType(const wxString& mimeTypeOrig)
+{
+    wxCHECK_MSG( !m_ext.empty(), false, wxT("SetMimeType() needs extension") );
+
+    if ( !EnsureExtKeyExists() )
+        return false;
+
+    // VZ: is this really useful? (FIXME)
+    wxString mimeType;
+    if ( !mimeTypeOrig )
+    {
+        // make up a default value for it
+        wxString cmd;
+        wxFileName::SplitPath(GetCommand(wxT("open")), NULL, &cmd, NULL);
+        mimeType << wxT("application/x-") << cmd;
+    }
+    else
+    {
+        mimeType = mimeTypeOrig;
+    }
+
+    wxRegKey rkey(wxRegKey::HKCR, m_ext);
+    return rkey.Create() && rkey.SetValue(wxT("Content Type"), mimeType);
+}
+*/
+
+bool wxFileTypeImpl::SetDefaultIcon(const wxString& cmd, int index)
+{
+    wxCHECK_MSG( !m_ext.empty(), false, wxT("SetDefaultIcon() needs extension") );
+    wxCHECK_MSG( !m_strFileType.empty(), false, wxT("File key not found") );
+//    the next line fails on a SMBshare, I think because it is case mangled
+//    wxCHECK_MSG( !wxFileExists(cmd), false, wxT("Icon file not found.") );
+
+    if ( !EnsureExtKeyExists() )
+        return false;
+
+    wxRegKey rkey(wxRegKey::HKCR, m_strFileType + wxT("\\DefaultIcon"));
+
+    return rkey.Create() &&
+           rkey.SetValue(wxEmptyString,
+                         wxString::Format(wxT("%s,%d"), cmd.c_str(), index));
+}
+
+bool wxFileTypeImpl::SetDescription (const wxString& desc)
+{
+    wxCHECK_MSG( !m_strFileType.empty(), false, wxT("File key not found") );
+    wxCHECK_MSG( !desc.empty(), false, wxT("No file description supplied") );
+
+    if ( !EnsureExtKeyExists() )
+        return false;
+
+    wxRegKey rkey(wxRegKey::HKCR, m_strFileType );
+
+    return rkey.Create() &&
+           rkey.SetValue(wxEmptyString, desc);
+}
+
+// ----------------------------------------------------------------------------
+// remove file association
+// ----------------------------------------------------------------------------
+
+bool wxFileTypeImpl::Unassociate()
+{
+    bool result = true;
+    if ( !RemoveOpenCommand() )
+        result = false;
+    if ( !RemoveDefaultIcon() )
+        result = false;
+    if ( !RemoveMimeType() )
+        result = false;
+    if ( !RemoveDescription() )
+        result = false;
+
+/*
+    //this might hold other keys, eg some have CSLID keys
+    if ( result )
+    {
+        // delete the root key
+        wxRegKey key(wxRegKey::HKCR, m_ext);
+        if ( key.Exists() )
+            result = key.DeleteSelf();
+    }
+*/
+    return result;
+}
+
+bool wxFileTypeImpl::RemoveOpenCommand()
+{
+   return RemoveCommand(wxT("open"));
+}
+
+bool wxFileTypeImpl::RemoveCommand(const wxString& verb)
+{
+    wxCHECK_MSG( !m_ext.empty() && !verb.empty(), false,
+                 wxT("RemoveCommand() needs an extension and a verb") );
+
+    wxRegKey rkey(wxRegKey::HKCR, GetVerbPath(verb));
+
+    // if the key already doesn't exist, it's a success
+    return !rkey.Exists() || rkey.DeleteSelf();
+}
+
+bool wxFileTypeImpl::RemoveMimeType()
+{
+    wxCHECK_MSG( !m_ext.empty(), false, wxT("RemoveMimeType() needs extension") );
+
+    wxRegKey rkey(wxRegKey::HKCR, m_ext);
+    return !rkey.Exists() || rkey.DeleteSelf();
+}
+
+bool wxFileTypeImpl::RemoveDefaultIcon()
+{
+    wxCHECK_MSG( !m_ext.empty(), false,
+                 wxT("RemoveDefaultIcon() needs extension") );
+
+    wxRegKey rkey (wxRegKey::HKCR, m_strFileType  + wxT("\\DefaultIcon"));
+    return !rkey.Exists() || rkey.DeleteSelf();
+}
+
+bool wxFileTypeImpl::RemoveDescription()
+{
+    wxCHECK_MSG( !m_ext.empty(), false,
+                 wxT("RemoveDescription() needs extension") );
+
+    wxRegKey rkey (wxRegKey::HKCR, m_strFileType );
+    return !rkey.Exists() || rkey.DeleteSelf();
+}
+
+#endif // wxUSE_MIMETYPE