/////////////////////////////////////////////////////////////////////////////
-// Name: common/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>
-// 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__
- #pragma hdrstop
+ #pragma hdrstop
#endif
-#ifndef WX_PRECOMP
- #include "wx/defs.h"
-#endif
+#if wxUSE_MIMETYPE
-#if (wxUSE_FILE && wxUSE_TEXTFILE) || defined(__WXMSW__)
+#include "wx/msw/mimetype.h"
#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
-// Doesn't compile in WIN16 mode
-#ifndef __WIN16__
-
-#include "wx/log.h"
#include "wx/file.h"
-#include "wx/intl.h"
-#include "wx/dynarray.h"
+#include "wx/iconloc.h"
#include "wx/confbase.h"
-#ifdef __WXMSW__
+#ifdef __WINDOWS__
#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"
-
// 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
-// 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.
// 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;
+ }
+ }
+
+ 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
+// ----------------------------------------------------------------------------
-wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const
+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;
- 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;
- 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 )
{
}
strKey << wxT("\\shell\\") << verb;
- wxRegKey key(wxRegKey::HKCR, strKey + _T("\\command"));
+ wxRegKey key(wxRegKey::HKCR, strKey + wxT("\\command"));
wxString command;
- if ( key.Open() ) {
+ if ( key.Open(wxRegKey::Read) ) {
// 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");
+ strKey += wxT("\\DDEExec");
wxRegKey keyDDE(wxRegKey::HKCR, strKey);
- if ( keyDDE.Open() ) {
+ if ( keyDDE.Open(wxRegKey::Read) ) {
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
- 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
-#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)
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);
- return !openCmd->IsEmpty();
+ return !openCmd->empty();
}
bool
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();
+ return !printCmd->empty();
}
+// ----------------------------------------------------------------------------
+// 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.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...
- return FALSE;
+ return false;
}
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
{
- 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(wxRegKey::Read) &&
+ 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
- return FALSE;
+ 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");
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
- 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 '%'
// 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");
}
- 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
-#endif // wxUSE_GUI
-
- return FALSE;
+ 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() ) {
+ if ( key.Open(wxRegKey::Read) ) {
// 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
// suppress possible error messages
wxLogNull nolog;
- bool knownExtension = FALSE;
+ bool knownExtension = false;
wxString strFileType;
wxRegKey key(wxRegKey::HKCR, str);
- if ( key.Open() ) {
+ if ( key.Open(wxRegKey::Read) ) {
// 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
// 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 *
wxString ext;
wxRegKey key(wxRegKey::HKCR, strKey);
- if ( key.Open() ) {
+ if ( key.Open(wxRegKey::Read) ) {
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;
}
return mimetypes.GetCount();
}
+// ----------------------------------------------------------------------------
+// create a new association
+// ----------------------------------------------------------------------------
-#endif
- // wxUSE_FILE && wxUSE_TEXTFILE
+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
- // __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
projects / wxWidgets.git / blobdiff