X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/6e7ce6246c2952fd844f6b3f05f25719d82e0584..e4a8a172020d5e3ee08660420142e702799c7878:/src/msw/mimetype.cpp diff --git a/src/msw/mimetype.cpp b/src/msw/mimetype.cpp index e499d2b960..78eb544ea9 100644 --- a/src/msw/mimetype.cpp +++ b/src/msw/mimetype.cpp @@ -1,12 +1,12 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: common/mimetype.cpp +// Name: 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 -// Licence: wxWindows license (part of wxExtra library) +// Licence: wxWindows licence (part of wxExtra library) ///////////////////////////////////////////////////////////////////////////// #ifdef __GNUG__ @@ -20,37 +20,29 @@ #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/iconloc.h" #include "wx/intl.h" #include "wx/dynarray.h" #include "wx/confbase.h" #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" + #include "wx/msw/private.h" #endif // OS #include "wx/msw/mimetype.h" @@ -61,11 +53,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 +77,134 @@ class WXDLLEXPORT wxIcon; // location, uses it, so it isn't likely to change static const wxChar *MIME_DATABASE_KEY = wxT("MIME\\Database\\Content Type\\"); +// 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; + } + } + return foundFilename; +} +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('.') + _T("_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(wxEmptyString, 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(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 +// ---------------------------------------------------------------------------- wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const { @@ -111,42 +228,26 @@ wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const wxString command; if ( key.Open() ) { // 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) strKey += _T("\\DDEExec"); wxRegKey keyDDE(wxRegKey::HKCR, strKey); if ( keyDDE.Open() ) { wxString ddeCommand, ddeServer, ddeTopic; - keyDDE.QueryValue(_T(""), ddeCommand); + keyDDE.QueryValue(wxEmptyString, ddeCommand); ddeCommand.Replace(_T("%1"), _T("%s")); wxRegKey(wxRegKey::HKCR, strKey + _T("\\Application")). - QueryValue(_T(""), ddeServer); + QueryValue(wxEmptyString, ddeServer); wxRegKey(wxRegKey::HKCR, strKey + _T("\\Topic")). - QueryValue(_T(""), ddeTopic); + QueryValue(wxEmptyString, ddeTopic); + + if (ddeTopic.IsEmpty()) + ddeTopic = wxT("System"); // HACK: we use a special feature of wxExecute which exists // just because we need it here: it will establish DDE @@ -157,8 +258,9 @@ wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const << _T('#') << ddeCommand; } 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) @@ -178,13 +280,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); @@ -196,28 +292,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; @@ -233,32 +322,30 @@ 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(wxIconLocation *iconLoc) const +{ wxString strIconKey; strIconKey << m_strFileType << wxT("\\DefaultIcon"); @@ -269,7 +356,7 @@ bool wxFileTypeImpl::GetIcon(wxIcon *icon) const if ( key.Open() ) { 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: , // NB: icon index may be negative as well as positive and the full // path may contain the environment variables inside '%' @@ -283,46 +370,30 @@ bool wxFileTypeImpl::GetIcon(wxIcon *icon) const strIndex = wxT("0"); } - wxString strExpPath = wxExpandEnvVars(strFullPath); - int nIndex = wxAtoi(strIndex); + if ( iconLoc ) + { + iconLoc->SetFileName(wxExpandEnvVars(strFullPath)); - 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; - - default: - icon->SetHICON((WXHICON)hIcon); - return TRUE; + iconLoc->SetIndex(wxAtoi(strIndex)); } + + return TRUE; } } // no such file type or no value or incorrect icon entry -#endif // wxUSE_GUI - return FALSE; } 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); if ( key.Open() ) { // it's the default value of the key - if ( key.QueryValue(wxT(""), *desc) ) { + if ( key.QueryValue(wxEmptyString, *desc) ) { return TRUE; } } @@ -330,6 +401,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) @@ -350,12 +430,9 @@ wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext) wxRegKey key(wxRegKey::HKCR, str); if ( key.Open() ) { // it's the default value of the key - if ( key.QueryValue(wxT(""), strFileType) ) { + if ( key.QueryValue(wxEmptyString, 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 @@ -365,32 +442,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 * @@ -410,20 +483,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; } @@ -446,9 +505,324 @@ 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; + 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; + } + + 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(_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 + 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() ) key.Create(); + key.SetValue(wxEmptyString, 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 + 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); + keyFT.Create(); + + wxFileType *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(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 - // 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(wxEmptyString, 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(wxEmptyString, + 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(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(_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