X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/7dc3cc31af71522b8fc55b7f97bcba7f5ef9eac5..ccdcde00d9ae27ca20ff6c3c9495918a0ec725aa:/src/msw/mimetype.cpp

diff --git a/src/msw/mimetype.cpp b/src/msw/mimetype.cpp
index 7d09acec8b..53a0551e81 100644
--- a/src/msw/mimetype.cpp
+++ b/src/msw/mimetype.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        common/mimetype.cpp
+// Name:        msw/mimetype.cpp
 // Purpose:     classes and functions to manage MIME types
 // Author:      Vadim Zeitlin
 // Modified by:
@@ -20,22 +20,19 @@
   #pragma hdrstop
 #endif
 
-#ifndef WX_PRECOMP
-  #include "wx/defs.h"
-#endif
+#if wxUSE_MIMETYPE
 
-#if (wxUSE_FILE && wxUSE_TEXTFILE) || defined(__WXMSW__)
+// Doesn't compile in WIN16 mode
+#ifndef __WIN16__
 
 #ifndef WX_PRECOMP
-  #include "wx/string.h"
-  #if wxUSE_GUI
-    #include "wx/icon.h"
-  #endif
+    #include "wx/string.h"
+    #if wxUSE_GUI
+        #include "wx/icon.h"
+        #include "wx/msgdlg.h"
+    #endif
 #endif //WX_PRECOMP
 
-// Doesn't compile in WIN16 mode
-#ifndef __WIN16__
-
 #include "wx/log.h"
 #include "wx/file.h"
 #include "wx/intl.h"
@@ -45,12 +42,6 @@
 #ifdef __WXMSW__
     #include "wx/msw/registry.h"
     #include "windows.h"
-#elif defined(__UNIX__)  || defined(__WXPM__)
-    #include "wx/ffile.h"
-    #include "wx/textfile.h"
-    #include "wx/dir.h"
-    #include "wx/utils.h"
-    #include "wx/tokenzr.h"
 #endif // OS
 
 #include "wx/msw/mimetype.h"
@@ -61,11 +52,10 @@
 // in case we're compiling in non-GUI mode
 class WXDLLEXPORT 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
-// 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.
@@ -86,8 +76,107 @@ class WXDLLEXPORT wxIcon;
 // location, uses it, so it isn't likely to change
 static const wxChar *MIME_DATABASE_KEY = wxT("MIME\\Database\\Content Type\\");
 
+void wxFileTypeImpl::Init(const wxString& strFileType, const wxString& ext)
+{
+    // VZ: does it? (FIXME)
+    wxCHECK_RET( !ext.IsEmpty(), _T("needs an extension") );
+
+    if ( ext[0u] != wxT('.') ) {
+        m_ext = wxT('.');
+    }
+    m_ext << ext;
 
+    m_strFileType = strFileType;
+    if ( !strFileType ) {
+        m_strFileType = m_ext.AfterFirst('.') + "_auto_file";
+    }
+}
+
+wxString wxFileTypeImpl::GetVerbPath(const wxString& verb) const
+{
+    wxString path;
+    path << m_strFileType << _T("\\shell\\") << verb << _T("\\command");
+    return path;
+}
+
+size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
+                                      wxArrayString *commands,
+                                      const wxFileType::MessageParameters& params) const
+{
+    wxCHECK_MSG( !m_ext.IsEmpty(), 0, _T("GetAllCommands() needs an extension") );
+
+    if ( m_strFileType.IsEmpty() )
+    {
+        // get it from the registry
+        wxFileTypeImpl *self = wxConstCast(this, wxFileTypeImpl);
+        wxRegKey rkey(wxRegKey::HKCR, m_ext);
+        if ( !rkey.Exists() || !rkey.QueryValue(_T(""), self->m_strFileType) )
+        {
+            wxLogDebug(_T("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  + _T("\\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(_T("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(_T(""), m_strFileType) )
+        {
+            wxLogError(_("Failed to create registry entry for '%s' files."),
+                       m_ext.c_str());
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+// ----------------------------------------------------------------------------
+// get the command to use
+// ----------------------------------------------------------------------------
 
 wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const
 {
@@ -133,6 +222,7 @@ wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const
                 }
             }
 
+#if wxUSE_IPC
             // look whether we must issue some DDE requests to the application
             // (and not just launch it)
             strKey += _T("\\DDEExec");
@@ -155,7 +245,9 @@ wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const
                         << _T('#') << ddeTopic
                         << _T('#') << ddeCommand;
             }
-            else if ( !foundFilename ) {
+            else
+#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)
@@ -175,13 +267,7 @@ wxFileTypeImpl::GetOpenCommand(wxString *openCmd,
                                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);
 
@@ -193,28 +279,21 @@ wxFileTypeImpl::GetPrintCommand(wxString *printCmd,
                                 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);
 
     return !printCmd->IsEmpty();
 }
 
+// ----------------------------------------------------------------------------
+// getting other stuff
+// ----------------------------------------------------------------------------
+
 // 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.IsEmpty() ) {
         // 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;
@@ -230,32 +309,33 @@ bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
 
 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;
-    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() && key.QueryValue(wxT("Content Type"), *mimeType);
 }
 
-bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
+bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
 {
-#if wxUSE_GUI
-    if ( m_info ) {
-        // we don't have icons in the fallback resources
+    wxString s;
+
+    if ( !GetMimeType(&s) )
+    {
         return FALSE;
     }
 
+    mimeTypes.Clear();
+    mimeTypes.Add(s);
+    return TRUE;
+}
+
+
+bool wxFileTypeImpl::GetIcon(wxIcon *icon,
+                             wxString *iconFile,
+                             int *iconIndex) const
+{
+#if wxUSE_GUI
     wxString strIconKey;
     strIconKey << m_strFileType << wxT("\\DefaultIcon");
 
@@ -281,6 +361,7 @@ bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
             }
 
             wxString strExpPath = wxExpandEnvVars(strFullPath);
+            // here we need C based counting!
             int nIndex = wxAtoi(strIndex);
 
             HICON hIcon = ExtractIcon(GetModuleHandle(NULL), strExpPath, nIndex);
@@ -293,6 +374,10 @@ bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
 
                 default:
                     icon->SetHICON((WXHICON)hIcon);
+                    if ( iconIndex )
+                        *iconIndex = nIndex;
+                    if ( iconFile )
+                        *iconFile = strFullPath;
                     return TRUE;
             }
         }
@@ -306,13 +391,6 @@ bool wxFileTypeImpl::GetIcon(wxIcon *icon) 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);
@@ -327,6 +405,15 @@ bool wxFileTypeImpl::GetDescription(wxString *desc) const
     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
 wxFileType *
 wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
@@ -349,10 +436,7 @@ wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
         // it's the default value of the key
         if ( key.QueryValue(wxT(""), strFileType) ) {
             // 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
@@ -362,32 +446,28 @@ wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& 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 ( 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 *
@@ -407,20 +487,6 @@ wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
         }
     }
 
-    // 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;
 }
@@ -443,9 +509,325 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
     return mimetypes.GetCount();
 }
 
+// ----------------------------------------------------------------------------
+// create a new association
+// ----------------------------------------------------------------------------
 
+wxFileType *wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
+{
+    wxCHECK_MSG( !ftInfo.GetExtensions().IsEmpty(), NULL,
+                 _T("Associate() needs extension") );
+
+    bool ok = FALSE ;
+    int iExtCount = 0 ;
+    wxString filetype;
+    wxString extWithDot;
+
+    wxString ext = ftInfo.GetExtensions()[iExtCount];
+
+    wxCHECK_MSG( !ext.empty(), NULL,
+                 _T("Associate() needs non empty extension") );
+
+    if ( ext[0u] != _T('.') )
+        extWithDot = _T('.');
+    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 << _T("_file");
+            }
+            else
+            {
+                // just use the provided one
+                filetype = filetypeOrig;
+            }
+
+            ok = key.SetValue(_T(""), filetype);
+        }
+        }
+        else
+        {
+            // key already exists, maybe we want to change it ??
+            if (!filetypeOrig.empty())
+                {
+                    filetype = filetypeOrig;
+                    ok = key.SetValue(_T(""), filetype);
+                }
+            else
+                {
+                    ok = key.QueryValue(_T(""), 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(_T("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
+                    ok = keyMIME.SetValue(_T("Extension"), extWithDot);
+                }
+            }
+        }
+
+
+    // now make other extensions have the same filetype
+
+    for (iExtCount=1; iExtCount < ftInfo.GetExtensionsCount(); iExtCount++ )
+        {
+            ext = ftInfo.GetExtensions()[iExtCount];
+            if ( ext[0u] != _T('.') )
+               extWithDot = _T('.');
+            extWithDot += ext;
+
+            wxRegKey key(wxRegKey::HKCR, extWithDot);
+            if ( !key.Exists() ) ok = key.Create();
+            ok = key.SetValue(_T(""), filetype);
+
+        // now set any mimetypes we may have, but ignore it if none
+        const wxString& mimetype = ftInfo.GetMimeType();
+        if ( !mimetype.empty() )
+        {
+            // set the MIME type
+            ok = key.SetValue(_T("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
+                    ok = keyMIME.SetValue(_T("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);
+    ok = keyFT.Create();
+
+    wxFileType *ft = NULL;
+    ft = CreateFileType(filetype, extWithDot);
+
+    if (ft)
+    {
+            if (! ftInfo.GetOpenCommand ().IsEmpty() ) ft->SetCommand (ftInfo.GetOpenCommand (), wxT("open"  ) );
+            if (! ftInfo.GetPrintCommand().IsEmpty() ) ft->SetCommand (ftInfo.GetPrintCommand(), wxT("print" ) );
+            // chris: I don't like the ->m_impl-> here FIX this ??
+            if (! ftInfo.GetDescription ().IsEmpty() ) ft->m_impl->SetDescription (ftInfo.GetDescription ()) ;
+            if (! ftInfo.GetIconFile().IsEmpty() ) ft->SetDefaultIcon (ftInfo.GetIconFile(), ftInfo.GetIconIndex() );
+
+        }
+    return ft;
+}
+
+bool wxFileTypeImpl::SetCommand(const wxString& cmd,
+                                const wxString& verb,
+                                bool WXUNUSED(overwriteprompt))
+{
+    wxCHECK_MSG( !m_ext.IsEmpty() && !verb.IsEmpty(), FALSE,
+                 _T("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(wxT(""), 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
-  // wxUSE_FILE && wxUSE_TEXTFILE
+    // TODO:
+    // 1. translate '%s' to '%1' instead of always adding it
+    // 2. create DDEExec value if needed (undo GetCommand)
+    return rkey.Create() && rkey.SetValue(_T(""), cmd + _T(" \"%1\"") );
+}
+
+/* // no longer used
+bool wxFileTypeImpl::SetMimeType(const wxString& mimeTypeOrig)
+{
+    wxCHECK_MSG( !m_ext.IsEmpty(), FALSE, _T("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;
+        wxSplitPath(GetCommand(_T("open")), NULL, &cmd, NULL);
+        mimeType << _T("application/x-") << cmd;
+    }
+    else
+    {
+        mimeType = mimeTypeOrig;
+    }
+
+    wxRegKey rkey(wxRegKey::HKCR, m_ext);
+    return rkey.Create() && rkey.SetValue(_T("Content Type"), mimeType);
+}
+*/
+
+bool wxFileTypeImpl::SetDefaultIcon(const wxString& cmd, int index)
+{
+    wxCHECK_MSG( !m_ext.IsEmpty(), FALSE, _T("SetDefaultIcon() needs extension") );
+    wxCHECK_MSG( !m_strFileType.IsEmpty(), FALSE, _T("File key not found") );
+//    the next line fails on a SMBshare, I think because it is case mangled
+//    wxCHECK_MSG( !wxFileExists(cmd), FALSE, _T("Icon file not found.") );
+
+    if ( !EnsureExtKeyExists() )
+        return FALSE;
+
+    wxRegKey rkey(wxRegKey::HKCR, m_strFileType + _T("\\DefaultIcon"));
+
+    return rkey.Create() &&
+           rkey.SetValue(_T(""),
+                         wxString::Format(_T("%s,%d"), cmd.c_str(), index));
+}
+
+bool wxFileTypeImpl::SetDescription (const wxString& desc)
+{
+    wxCHECK_MSG( !m_strFileType.IsEmpty(), FALSE, _T("File key not found") );
+    wxCHECK_MSG( !desc.IsEmpty(), FALSE, _T("No file description supplied") );
+
+    if ( !EnsureExtKeyExists() )
+        return FALSE;
+
+    wxRegKey rkey(wxRegKey::HKCR, m_strFileType );
+
+    return rkey.Create() &&
+           rkey.SetValue(_T(""), 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(_T("open"));
+}
+
+bool wxFileTypeImpl::RemoveCommand(const wxString& verb)
+{
+    wxCHECK_MSG( !m_ext.IsEmpty() && !verb.IsEmpty(), FALSE,
+                 _T("RemoveCommand() needs an extension and a verb") );
+
+    wxString  sKey = m_strFileType;
+    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.IsEmpty(), FALSE, _T("RemoveMimeType() needs extension") );
+
+    wxRegKey rkey(wxRegKey::HKCR, m_ext);
+    return !rkey.Exists() || rkey.DeleteSelf();
+}
+
+bool wxFileTypeImpl::RemoveDefaultIcon()
+{
+    wxCHECK_MSG( !m_ext.IsEmpty(), FALSE,
+                 _T("RemoveDefaultIcon() needs extension") );
+
+    wxRegKey rkey (wxRegKey::HKCR, m_strFileType  + _T("\\DefaultIcon"));
+    return !rkey.Exists() || rkey.DeleteSelf();
+}
+
+bool wxFileTypeImpl::RemoveDescription()
+{
+    wxCHECK_MSG( !m_ext.IsEmpty(), FALSE,
+                 _T("RemoveDescription() needs extension") );
+
+    wxRegKey rkey (wxRegKey::HKCR, m_strFileType );
+    return !rkey.Exists() || rkey.DeleteSelf();
+}
 
 #endif
   // __WIN16__
+
+#endif // wxUSE_MIMETYPE