X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/276c7463f35b7f3ec8dfdbe80b29448f2e503d93..88ec47bb129e7bc269c64f1c1c00ffc57648211c:/src/unix/mimetype.cpp diff --git a/src/unix/mimetype.cpp b/src/unix/mimetype.cpp index fffd9d50dd..51209e7f67 100644 --- a/src/unix/mimetype.cpp +++ b/src/unix/mimetype.cpp @@ -1,1214 +1,928 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: unix/mimetype.cpp +// Name: src/unix/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) ///////////////////////////////////////////////////////////////////////////// -// ============================================================================ -// declarations -// ============================================================================ - -// ---------------------------------------------------------------------------- -// headers -// ---------------------------------------------------------------------------- - -#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 && wxUSE_FILE -#if wxUSE_FILE && wxUSE_TEXTFILE +#include "wx/unix/mimetype.h" #ifndef WX_PRECOMP - #include "wx/string.h" - #if wxUSE_GUI - #include "wx/icon.h" - #endif -#endif //WX_PRECOMP - + #include "wx/dynarray.h" + #include "wx/string.h" + #include "wx/intl.h" + #include "wx/log.h" + #include "wx/utils.h" +#endif -#include "wx/log.h" #include "wx/file.h" -#include "wx/intl.h" -#include "wx/dynarray.h" #include "wx/confbase.h" #include "wx/ffile.h" -#include "wx/textfile.h" #include "wx/dir.h" -#include "wx/utils.h" #include "wx/tokenzr.h" - -#include "wx/unix/mimetype.h" +#include "wx/iconloc.h" +#include "wx/filename.h" +#include "wx/app.h" +#include "wx/apptrait.h" // other standard headers #include -// in case we're compiling in non-GUI mode -class WXDLLEXPORT wxIcon; - -// ---------------------------------------------------------------------------- -// constants -// ---------------------------------------------------------------------------- - -// MIME code tracing mask -#define TRACE_MIME _T("mime") - -// ---------------------------------------------------------------------------- -// private functions -// ---------------------------------------------------------------------------- - -// there are some fields which we don't understand but for which we don't give -// warnings as we know that they're not important - this function is used to -// test for them -static bool IsKnownUnimportantField(const wxString& field); - -// ---------------------------------------------------------------------------- -// private classes -// ---------------------------------------------------------------------------- - -// This class uses both mailcap and mime.types to gather information about file -// types. -// -// The information about mailcap file was extracted from metamail(1) sources -// and documentation and subsequently revised when I found the RFC 1524 -// describing it. -// -// Format of mailcap file: spaces are ignored, each line is either a comment -// (starts with '#') or a line of the form ;;...;. -// A backslash can be used to quote semicolons and newlines (and, in fact, -// anything else including itself). -// -// The first field is always the MIME type in the form of type/subtype (see RFC -// 822) where subtype may be '*' meaning "any". Following metamail, we accept -// "type" which means the same as "type/*", although I'm not sure whether this -// is standard. -// -// The second field is always the command to run. It is subject to -// parameter/filename expansion described below. -// -// All the following fields are optional and may not be present at all. If -// they're present they may appear in any order, although each of them should -// appear only once. The optional fields are the following: -// * notes=xxx is an uninterpreted string which is silently ignored -// * test=xxx is the command to be used to determine whether this mailcap line -// applies to our data or not. The RHS of this field goes through the -// parameter/filename expansion (as the 2nd field) and the resulting string -// is executed. The line applies only if the command succeeds, i.e. returns 0 -// exit code. -// * print=xxx is the command to be used to print (and not view) the data of -// this type (parameter/filename expansion is done here too) -// * edit=xxx is the command to open/edit the data of this type -// * needsterminal means that a new interactive console must be created for -// the viewer -// * copiousoutput means that the viewer doesn't interact with the user but -// produces (possibly) a lof of lines of output on stdout (i.e. "cat" is a -// good example), thus it might be a good idea to use some kind of paging -// mechanism. -// * textualnewlines means not to perform CR/LF translation (not honored) -// * compose and composetyped fields are used to determine the program to be -// called to create a new message pert in the specified format (unused). -// -// Parameter/filename expansion: -// * %s is replaced with the (full) file name -// * %t is replaced with MIME type/subtype of the entry -// * for multipart type only %n is replaced with the nnumber of parts and %F is -// replaced by an array of (content-type, temporary file name) pairs for all -// message parts (TODO) -// * %{parameter} is replaced with the value of parameter taken from -// Content-type header line of the message. -// -// -// There are 2 possible formats for mime.types file, one entry per line (used -// for global mime.types and called Mosaic format) and "expanded" format where -// an entry takes multiple lines (used for users mime.types and called -// Netscape format). -// -// For both formats spaces are ignored and lines starting with a '#' are -// comments. Each record has one of two following forms: -// a) for "brief" format: -// -// b) for "expanded" format: -// type= \ -// desc="" \ -// exts="" -// -// We try to autodetect the format of mime.types: if a non-comment line starts -// with "type=" we assume the second format, otherwise the first one. - -// there may be more than one entry for one and the same mime type, to -// choose the right one we have to run the command specified in the test -// field on our data. -class MailCapEntry +class wxMimeTextFile { public: - // ctor - MailCapEntry(const wxString& openCmd, - const wxString& printCmd, - const wxString& testCmd) - : m_openCmd(openCmd), m_printCmd(printCmd), m_testCmd(testCmd) + wxMimeTextFile() { - m_next = NULL; } - - ~MailCapEntry() + + wxMimeTextFile(const wxString& fname) { - if (m_next) delete m_next; + m_fname = fname; } - // accessors - const wxString& GetOpenCmd() const { return m_openCmd; } - const wxString& GetPrintCmd() const { return m_printCmd; } - const wxString& GetTestCmd() const { return m_testCmd; } + bool Open() + { + wxFFile file( m_fname ); + if (!file.IsOpened()) + return false; + + size_t size = file.Length(); + wxCharBuffer buffer( size ); + file.Read( (void*) (const char*) buffer, size ); + + // Check for valid UTF-8 here? + wxString all = wxString::FromUTF8( buffer, size ); + + wxStringTokenizer tok( all, "\n" ); + while (tok.HasMoreTokens()) + { + wxString t = tok.GetNextToken(); + t.MakeLower(); + if ((!!t) && (t.Find( "comment" ) != 0) && (t.Find( "#" ) != 0) && (t.Find( "generic" ) != 0)) + m_text.Add( t ); + } + return true; + } - MailCapEntry *GetNext() const { return m_next; } + unsigned int GetLineCount() const { return m_text.GetCount(); } + wxString &GetLine( unsigned int line ) { return m_text[line]; } - // operations - // prepend this element to the list - void Prepend(MailCapEntry *next) { m_next = next; } - // insert into the list at given position - void Insert(MailCapEntry *next, size_t pos) + int pIndexOf(const wxString& sSearch, + bool bIncludeComments = false, + int iStart = 0) { - // FIXME slooow... - MailCapEntry *cur; - size_t n = 0; - for ( cur = next; cur != NULL; cur = cur->m_next, n++ ) { - if ( n == pos ) - break; + wxString sTest = sSearch; + sTest.MakeLower(); + for(size_t i = iStart; i < GetLineCount(); i++) + { + wxString sLine = GetLine(i); + if(bIncludeComments || ! sLine.StartsWith(wxT("#"))) + { + if(sLine.StartsWith(sTest)) + return (int)i; + } } - - wxASSERT_MSG( n == pos, wxT("invalid position in MailCapEntry::Insert") ); - - m_next = cur->m_next; - cur->m_next = this; + return wxNOT_FOUND; } - // append this element to the list - void Append(MailCapEntry *next) + + wxString GetVerb(size_t i) { - wxCHECK_RET( next != NULL, wxT("Append()ing to what?") ); + if (i > GetLineCount() ) + return wxEmptyString; - // FIXME slooow... - MailCapEntry *cur; - for ( cur = next; cur->m_next != NULL; cur = cur->m_next ) - ; + wxString sTmp = GetLine(i).BeforeFirst(wxT('=')); + return sTmp; + } - cur->m_next = this; + wxString GetCmd(size_t i) + { + if (i > GetLineCount() ) + return wxEmptyString; - wxASSERT_MSG( !m_next, wxT("Append()ing element already in the list?") ); + wxString sTmp = GetLine(i).AfterFirst(wxT('=')); + return sTmp; } private: - wxString m_openCmd, // command to use to open/view the file - m_printCmd, // print - m_testCmd; // only apply this entry if test yields - // true (i.e. the command returns 0) - - MailCapEntry *m_next; // in the linked list + wxArrayString m_text; + wxString m_fname; }; +// ---------------------------------------------------------------------------- +// constants +// ---------------------------------------------------------------------------- + +// MIME code tracing mask +#define TRACE_MIME wxT("mime") + -// the base class which may be used to find an icon for the MIME type -class wxMimeTypeIconHandler +// Read a XDG *.desktop file of type 'Application' +void wxMimeTypesManagerImpl::LoadXDGApp(const wxString& filename) { -public: - virtual bool GetIcon(const wxString& mimetype, wxIcon *icon) = 0; + wxLogTrace(TRACE_MIME, wxT("loading XDG file %s"), filename.c_str()); - // this function fills manager with MIME types information gathered - // (as side effect) when searching for icons. This may be particularly - // useful if mime.types is incomplete (e.g. RedHat distributions). - virtual void GetMimeInfoRecords(wxMimeTypesManagerImpl *manager) = 0; -}; + wxMimeTextFile file(filename); + if ( !file.Open() ) + return; + + // Here, only type 'Application' should be considered. + int nIndex = file.pIndexOf( "Type=" ); + if (nIndex != wxNOT_FOUND && file.GetCmd(nIndex) != "application") + return; + + // The hidden entry specifies a file to be ignored. + nIndex = file.pIndexOf( "Hidden=" ); + if (nIndex != wxNOT_FOUND && file.GetCmd(nIndex) == "true") + return; + + // Semicolon separated list of mime types handled by the application. + nIndex = file.pIndexOf( wxT("MimeType=") ); + if (nIndex == wxNOT_FOUND) + return; + wxString mimetypes = file.GetCmd (nIndex); + // Name of the application + wxString nameapp; + nIndex = wxNOT_FOUND; +#if wxUSE_INTL // try "Name[locale name]" first + wxLocale *locale = wxGetLocale(); + if ( locale ) + nIndex = file.pIndexOf(wxT("Name[")+locale->GetName()+wxT("]=")); +#endif // wxUSE_INTL + if(nIndex == wxNOT_FOUND) + nIndex = file.pIndexOf( wxT("Name=") ); + if(nIndex != wxNOT_FOUND) + nameapp = file.GetCmd(nIndex); + + // Icon of the application. + wxString nameicon, namemini; + nIndex = wxNOT_FOUND; +#if wxUSE_INTL // try "Icon[locale name]" first + if ( locale ) + nIndex = file.pIndexOf(wxT("Icon[")+locale->GetName()+wxT("]=")); +#endif // wxUSE_INTL + if(nIndex == wxNOT_FOUND) + nIndex = file.pIndexOf( wxT("Icon=") ); + if(nIndex != wxNOT_FOUND) { + nameicon = wxString(wxT("--icon ")) + file.GetCmd(nIndex); + namemini = wxString(wxT("--miniicon ")) + file.GetCmd(nIndex); + } + + // Replace some of the field code in the 'Exec' entry. + // TODO: deal with %d, %D, %n, %N, %k and %v (but last one is deprecated) + nIndex = file.pIndexOf( wxT("Exec=") ); + if (nIndex == wxNOT_FOUND) + return; + wxString sCmd = file.GetCmd(nIndex); + // we expect %f; others including %F and %U and %u are possible + sCmd.Replace(wxT("%F"), wxT("%f")); + sCmd.Replace(wxT("%U"), wxT("%f")); + sCmd.Replace(wxT("%u"), wxT("%f")); + if (0 == sCmd.Replace ( wxT("%f"), wxT("%s") )) + sCmd = sCmd + wxT(" %s"); + sCmd.Replace(wxT("%c"), nameapp); + sCmd.Replace(wxT("%i"), nameicon); + sCmd.Replace(wxT("%m"), namemini); + + wxStringTokenizer tokenizer(mimetypes, wxT(";")); + while(tokenizer.HasMoreTokens()) { + wxString mimetype = tokenizer.GetNextToken().Lower(); + nIndex = m_aTypes.Index(mimetype); + if(nIndex != wxNOT_FOUND) { // is this a known MIME type? + wxMimeTypeCommands* entry = m_aEntries[nIndex]; + entry->AddOrReplaceVerb(wxT("open"), sCmd); + } + } +} -// the icon handler which uses GNOME MIME database -class wxGNOMEIconHandler : public wxMimeTypeIconHandler +void wxMimeTypesManagerImpl::LoadXDGAppsFilesFromDir(const wxString& dirname) { -public: - virtual bool GetIcon(const wxString& mimetype, wxIcon *icon); - virtual void GetMimeInfoRecords(wxMimeTypesManagerImpl *manager); + // Don't complain if we don't have permissions to read - it confuses users + wxLogNull logNull; -private: - void Init(); - void LoadIconsFromKeyFile(const wxString& filename); - void LoadKeyFilesFromDir(const wxString& dirbase); + if(! wxDir::Exists(dirname)) + return; + wxDir dir(dirname); + if ( !dir.IsOpened() ) + return; - void LoadMimeTypesFromMimeFile(const wxString& filename, wxMimeTypesManagerImpl *manager); - void LoadMimeFilesFromDir(const wxString& dirbase, wxMimeTypesManagerImpl *manager); + wxString filename; + // Look into .desktop files + bool cont = dir.GetFirst(&filename, wxT("*.desktop"), wxDIR_FILES); + while (cont) + { + wxFileName p(dirname, filename); + LoadXDGApp( p.GetFullPath() ); + cont = dir.GetNext(&filename); + } - static bool m_inited; +#if 0 + // RR: I'm not sure this makes any sense. On my system we'll just + // scan the YAST2 and other useless directories + + // Look recursively into subdirs + cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS); + while (cont) + { + wxFileName p(dirname, wxEmptyString); + p.AppendDir(filename); + LoadXDGAppsFilesFromDir( p.GetPath() ); + cont = dir.GetNext(&filename); + } +#endif +} - static wxSortedArrayString ms_mimetypes; - static wxArrayString ms_icons; -}; -// the icon handler which uses KDE MIME database -class wxKDEIconHandler : public wxMimeTypeIconHandler +void wxMimeTypesManagerImpl::LoadXDGGlobs(const wxString& filename) { -public: - virtual bool GetIcon(const wxString& mimetype, wxIcon *icon); - virtual void GetMimeInfoRecords(wxMimeTypesManagerImpl *manager); + if ( !wxFileName::FileExists(filename) ) + return; -private: - void LoadLinksForMimeSubtype(const wxString& dirbase, - const wxString& subdir, - const wxString& filename, - const wxArrayString& icondirs); - void LoadLinksForMimeType(const wxString& dirbase, - const wxString& subdir, - const wxArrayString& icondirs); - void LoadLinkFilesFromDir(const wxString& dirbase, - const wxArrayString& icondirs); - void Init(); - - static bool m_inited; - - static wxSortedArrayString ms_mimetypes; - static wxArrayString ms_icons; - - static wxArrayString ms_infoTypes; - static wxArrayString ms_infoDescriptions; - static wxArrayString ms_infoExtensions; -}; + wxLogTrace(TRACE_MIME, wxT("loading XDG globs file from %s"), filename.c_str()); + wxMimeTextFile file(filename); + if ( !file.Open() ) + return; + size_t i; + for (i = 0; i < file.GetLineCount(); i++) + { + wxStringTokenizer tok( file.GetLine(i), ":" ); + wxString mime = tok.GetNextToken(); + wxString ext = tok.GetNextToken(); + ext.Remove( 0, 2 ); + wxArrayString exts; + exts.Add( ext ); + + AddToMimeData(mime, wxEmptyString, NULL, exts, wxEmptyString, true ); + } +} // ---------------------------------------------------------------------------- -// various statics +// wxFileTypeImpl (Unix) // ---------------------------------------------------------------------------- -static wxGNOMEIconHandler gs_iconHandlerGNOME; -static wxKDEIconHandler gs_iconHandlerKDE; - -bool wxGNOMEIconHandler::m_inited = FALSE; -wxSortedArrayString wxGNOMEIconHandler::ms_mimetypes; -wxArrayString wxGNOMEIconHandler::ms_icons; +wxString wxFileTypeImpl::GetExpandedCommand(const wxString & verb, const wxFileType::MessageParameters& params) const +{ + wxString sTmp; + size_t i = 0; + while ( (i < m_index.GetCount() ) && sTmp.empty() ) + { + sTmp = m_manager->GetCommand( verb, m_index[i] ); + i++; + } -bool wxKDEIconHandler::m_inited = FALSE; -wxSortedArrayString wxKDEIconHandler::ms_mimetypes; -wxArrayString wxKDEIconHandler::ms_icons; + return wxFileType::ExpandCommand(sTmp, params); +} -wxArrayString wxKDEIconHandler::ms_infoTypes; -wxArrayString wxKDEIconHandler::ms_infoDescriptions; -wxArrayString wxKDEIconHandler::ms_infoExtensions; +bool wxFileTypeImpl::GetIcon(wxIconLocation *iconLoc) const +{ + wxString sTmp; + size_t i = 0; + while ( (i < m_index.GetCount() ) && sTmp.empty() ) + { + sTmp = m_manager->m_aIcons[m_index[i]]; + i++; + } + if ( sTmp.empty() ) + return false; -ArrayIconHandlers wxMimeTypesManagerImpl::ms_iconHandlers; + if ( iconLoc ) + { + iconLoc->SetFileName(sTmp); + } -// ---------------------------------------------------------------------------- -// wxGNOMEIconHandler -// ---------------------------------------------------------------------------- + return true; +} -// GNOME stores the info we're interested in in several locations: -// 1. xxx.keys files under /usr/share/mime-info -// 2. xxx.keys files under ~/.gnome/mime-info -// -// The format of xxx.keys file is the following: -// -// mimetype/subtype: -// field=value -// -// with blank lines separating the entries and indented lines starting with -// TABs. We're interested in the field icon-filename whose value is the path -// containing the icon. -// -// Update (Chris Elliott): apparently there may be an optional "[lang]" prefix -// just before the field name. - -void wxGNOMEIconHandler::LoadIconsFromKeyFile(const wxString& filename) +bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const { - wxTextFile textfile(filename); - if ( !textfile.Open() ) - return; + mimeTypes.Clear(); + size_t nCount = m_index.GetCount(); + for (size_t i = 0; i < nCount; i++) + mimeTypes.Add(m_manager->m_aTypes[m_index[i]]); + + return true; +} - // values for the entry being parsed - wxString curMimeType, curIconFile; +size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs, + wxArrayString *commands, + const wxFileType::MessageParameters& params) const +{ + wxString vrb, cmd, sTmp; + size_t count = 0; + wxMimeTypeCommands * sPairs; - const wxChar *pc; - size_t nLineCount = textfile.GetLineCount(); - for ( size_t nLine = 0; ; nLine++ ) + // verbs and commands have been cleared already in mimecmn.cpp... + // if we find no entries in the exact match, try the inexact match + for (size_t n = 0; ((count == 0) && (n < m_index.GetCount())); n++) { - if ( nLine < nLineCount ) + // list of verb = command pairs for this mimetype + sPairs = m_manager->m_aEntries [m_index[n]]; + size_t i; + for ( i = 0; i < sPairs->GetCount(); i++ ) { - pc = textfile[nLine].c_str(); - if ( *pc == _T('#') ) + vrb = sPairs->GetVerb(i); + // some gnome entries have "." inside + vrb = vrb.AfterLast(wxT('.')); + cmd = sPairs->GetCmd(i); + if (! cmd.empty() ) { - // skip comments - continue; - } - } - else - { - // so that we will fall into the "if" below - pc = NULL; + cmd = wxFileType::ExpandCommand(cmd, params); + count++; + if ( vrb.IsSameAs(wxT("open"))) + { + if ( verbs ) + verbs->Insert(vrb, 0u); + if ( commands ) + commands ->Insert(cmd, 0u); + } + else + { + if ( verbs ) + verbs->Add(vrb); + if ( commands ) + commands->Add(cmd); + } + } } + } + + return count; +} - if ( !pc || !*pc ) +bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions) +{ + const wxString strExtensions = m_manager->GetExtension(m_index[0]); + extensions.Empty(); + + // one extension in the space or comma-delimited list + wxString strExt; + wxString::const_iterator end = strExtensions.end(); + for ( wxString::const_iterator p = strExtensions.begin(); /* nothing */; ++p ) + { + if ( p == end || *p == wxT(' ') || *p == wxT(',') ) { - // end of the entry - if ( !!curMimeType && !!curIconFile ) + if ( !strExt.empty() ) { - // do we already know this mimetype? - int i = ms_mimetypes.Index(curMimeType); - if ( i == wxNOT_FOUND ) - { - // add a new entry - size_t n = ms_mimetypes.Add(curMimeType); - ms_icons.Insert(curIconFile, n); - } - else - { - // replace the existing one (this means that the directories - // should be searched in order of increased priority!) - ms_icons[(size_t)i] = curIconFile; - } + extensions.Add(strExt); + strExt.Empty(); } + //else: repeated spaces + // (shouldn't happen, but it's not that important if it does happen) - if ( !pc ) - { - // the end - this can only happen if nLine == nLineCount + if ( p == end ) break; - } - - curIconFile.Empty(); - - continue; } - - // what do we have here? - if ( *pc == _T('\t') ) + else if ( *p == wxT('.') ) { - // this is a field=value ling - pc++; // skip leading TAB - - // skip optional "[lang]" - if ( *pc == _T('[') ) - { - while ( *pc ) - { - if ( *pc++ == _T(']') ) - break; - } - } - - static const int lenField = 13; // strlen("icon-filename") - if ( wxStrncmp(pc, _T("icon-filename"), lenField) == 0 ) + // remove the dot from extension (but only if it's the first char) + if ( !strExt.empty() ) { - // skip '=' which follows and take everything left until the end - // of line - curIconFile = pc + lenField + 1; + strExt += wxT('.'); } - //else: some other field, we don't care + //else: no, don't append it } else { - // this is the start of the new section - curMimeType.Empty(); + strExt += *p; + } + } - while ( *pc != _T(':') && *pc != _T('\0') ) - { - curMimeType += *pc++; - } + return true; +} + +// set an arbitrary command: +// could adjust the code to ask confirmation if it already exists and +// overwriteprompt is true, but this is currently ignored as *Associate* has +// no overwrite prompt +bool +wxFileTypeImpl::SetCommand(const wxString& cmd, + const wxString& verb, + bool WXUNUSED(overwriteprompt)) +{ + wxArrayString strExtensions; + wxString strDesc, strIcon; + + wxArrayString strTypes; + GetMimeTypes(strTypes); + if ( strTypes.IsEmpty() ) + return false; + + wxMimeTypeCommands *entry = new wxMimeTypeCommands(); + entry->Add(verb + wxT("=") + cmd + wxT(" %s ")); + + bool ok = false; + size_t nCount = strTypes.GetCount(); + for ( size_t i = 0; i < nCount; i++ ) + { + if ( m_manager->DoAssociation + ( + strTypes[i], + strIcon, + entry, + strExtensions, + strDesc + ) ) + { + // DoAssociation() took ownership of entry, don't delete it below + ok = true; } } + + if ( !ok ) + delete entry; + + return ok; } -void wxGNOMEIconHandler::LoadKeyFilesFromDir(const wxString& dirbase) +// ignore index on the grounds that we only have one icon in a Unix file +bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int WXUNUSED(index)) { - wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase), - _T("base directory shouldn't end with a slash") ); + if (strIcon.empty()) + return false; - wxString dirname = dirbase; - dirname << _T("/mime-info"); + wxArrayString strExtensions; + wxString strDesc; - if ( !wxDir::Exists(dirname) ) - return; + wxArrayString strTypes; + GetMimeTypes(strTypes); + if ( strTypes.IsEmpty() ) + return false; - wxDir dir(dirname); - if ( !dir.IsOpened() ) - return; + wxMimeTypeCommands *entry = new wxMimeTypeCommands(); + bool ok = false; + size_t nCount = strTypes.GetCount(); + for ( size_t i = 0; i < nCount; i++ ) + { + if ( m_manager->DoAssociation + ( + strTypes[i], + strIcon, + entry, + strExtensions, + strDesc + ) ) + { + // we don't need to free entry now, DoAssociation() took ownership + // of it + ok = true; + } + } - // we will concatenate it with filename to get the full path below - dirname += _T('/'); + if ( !ok ) + delete entry; - wxString filename; - bool cont = dir.GetFirst(&filename, _T("*.keys"), wxDIR_FILES); - while ( cont ) + return ok; +} + +// ---------------------------------------------------------------------------- +// wxMimeTypesManagerImpl (Unix) +// ---------------------------------------------------------------------------- + +wxMimeTypesManagerImpl::wxMimeTypesManagerImpl() +{ + m_initialized = false; +} + +void wxMimeTypesManagerImpl::InitIfNeeded() +{ + if ( !m_initialized ) { - LoadIconsFromKeyFile(dirname + filename); + // set the flag first to prevent recursion + m_initialized = true; - cont = dir.GetNext(&filename); + int mailcapStyles = wxMAILCAP_ALL; + if ( wxAppTraits * const traits = wxApp::GetTraitsIfExists() ) + { + wxString wm = traits->GetDesktopEnvironment(); + + if ( wm == "KDE" ) + mailcapStyles = wxMAILCAP_KDE; + else if ( wm == "GNOME" ) + mailcapStyles = wxMAILCAP_GNOME; + //else: unknown, use the default + } + + Initialize(mailcapStyles); } } -void wxGNOMEIconHandler::LoadMimeTypesFromMimeFile(const wxString& filename, wxMimeTypesManagerImpl *manager) + +// read system and user mailcaps and other files +void wxMimeTypesManagerImpl::Initialize(int mailcapStyles, + const wxString& sExtraDir) { - wxTextFile textfile(filename); - if ( !textfile.Open() ) - return; +#ifdef __VMS + // XDG tables are never installed on OpenVMS + return; +#else - // values for the entry being parsed - wxString curMimeType, curExtList; + // Read MIME type - extension associations + LoadXDGGlobs( "/usr/share/mime/globs" ); + LoadXDGGlobs( "/usr/local/share/mime/globs" ); - const wxChar *pc; - size_t nLineCount = textfile.GetLineCount(); - for ( size_t nLine = 0; ; nLine++ ) + // Load desktop files for XDG, and then override them with the defaults. + // We will override them one desktop file at a time, rather + // than one mime type at a time, but it should be a reasonable + // heuristic. { - if ( nLine < nLineCount ) + wxString xdgDataHome = wxGetenv("XDG_DATA_HOME"); + if ( xdgDataHome.empty() ) + xdgDataHome = wxGetHomeDir() + "/.local/share"; + wxString xdgDataDirs = wxGetenv("XDG_DATA_DIRS"); + if ( xdgDataDirs.empty() ) { - pc = textfile[nLine].c_str(); - if ( *pc == _T('#') ) - { - // skip comments - continue; - } + xdgDataDirs = "/usr/local/share:/usr/share"; + if (mailcapStyles & wxMAILCAP_GNOME) + xdgDataDirs += ":/usr/share/gnome:/opt/gnome/share"; + if (mailcapStyles & wxMAILCAP_KDE) + xdgDataDirs += ":/usr/share/kde3:/opt/kde3/share"; } - else + if ( !sExtraDir.empty() ) { - // so that we will fall into the "if" below - pc = NULL; + xdgDataDirs += ':'; + xdgDataDirs += sExtraDir; } - if ( !pc || !*pc ) + wxArrayString dirs; + wxStringTokenizer tokenizer(xdgDataDirs, ":"); + while ( tokenizer.HasMoreTokens() ) { - // end of the entry - if ( !!curMimeType && !!curExtList ) - { - manager -> AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString); - } + wxString p = tokenizer.GetNextToken(); + dirs.Add(p); + } + dirs.insert(dirs.begin(), xdgDataHome); - if ( !pc ) + wxString defaultsList; + size_t i; + for (i = 0; i < dirs.GetCount(); i++) + { + wxString f = dirs[i]; + if (f.Last() != '/') f += '/'; + f += "applications/defaults.list"; + if (wxFileExists(f)) { - // the end - this can only happen if nLine == nLineCount + defaultsList = f; break; } - - curExtList.Empty(); - - continue; } - // what do we have here? - if ( *pc == _T('\t') ) + // Load application files and associate them to corresponding mime types. + size_t nDirs = dirs.GetCount(); + for (size_t nDir = 0; nDir < nDirs; nDir++) { - // this is a field=value ling - pc++; // skip leading TAB - - static const int lenField = 4; // strlen("ext:") - if ( wxStrncmp(pc, _T("ext:"), lenField) == 0 ) - { - // skip ' ' which follows and take everything left until the end - // of line - curExtList = pc + lenField + 1; - } - //else: some other field, we don't care + wxString dirStr = dirs[nDir]; + if (dirStr.Last() != '/') dirStr += '/'; + dirStr += "applications"; + LoadXDGAppsFilesFromDir(dirStr); } - else + + if (!defaultsList.IsEmpty()) { - // this is the start of the new section - curMimeType.Empty(); + wxArrayString deskTopFilesSeen; - while ( *pc != _T(':') && *pc != _T('\0') ) + wxMimeTextFile textfile(defaultsList); + if ( textfile.Open() ) { - curMimeType += *pc++; + int nIndex = textfile.pIndexOf( wxT("[Default Applications]") ); + if (nIndex != wxNOT_FOUND) + { + for (i = nIndex+1; i < textfile.GetLineCount(); i++) + { + if (textfile.GetLine(i).Find(wxT("=")) != wxNOT_FOUND) + { + wxString desktopFile = textfile.GetCmd(i); + + if (deskTopFilesSeen.Index(desktopFile) == wxNOT_FOUND) + { + deskTopFilesSeen.Add(desktopFile); + size_t j; + for (j = 0; j < dirs.GetCount(); j++) + { + wxString desktopPath = dirs[j]; + if (desktopPath.Last() != '/') desktopPath += '/'; + desktopPath += "applications/"; + desktopPath += desktopFile; + + if (wxFileExists(desktopPath)) + LoadXDGApp(desktopPath); + } + } + } + } + } } } } +#endif } +// clear data so you can read another group of WM files +void wxMimeTypesManagerImpl::ClearData() +{ + m_aTypes.Clear(); + m_aIcons.Clear(); + m_aExtensions.Clear(); + m_aDescriptions.Clear(); + + WX_CLEAR_ARRAY(m_aEntries); + m_aEntries.Empty(); +} -void wxGNOMEIconHandler::LoadMimeFilesFromDir(const wxString& dirbase, wxMimeTypesManagerImpl *manager) +wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl() { - wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase), - _T("base directory shouldn't end with a slash") ); + ClearData(); +} - wxString dirname = dirbase; - dirname << _T("/mime-info"); +wxFileType * wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo) +{ + InitIfNeeded(); - if ( !wxDir::Exists(dirname) ) - return; + wxString strType = ftInfo.GetMimeType(); + wxString strDesc = ftInfo.GetDescription(); + wxString strIcon = ftInfo.GetIconFile(); - wxDir dir(dirname); - if ( !dir.IsOpened() ) - return; + wxMimeTypeCommands *entry = new wxMimeTypeCommands(); - // we will concatenate it with filename to get the full path below - dirname += _T('/'); + if ( ! ftInfo.GetOpenCommand().empty()) + entry->Add(wxT("open=") + ftInfo.GetOpenCommand() + wxT(" %s ")); + if ( ! ftInfo.GetPrintCommand().empty()) + entry->Add(wxT("print=") + ftInfo.GetPrintCommand() + wxT(" %s ")); - wxString filename; - bool cont = dir.GetFirst(&filename, _T("*.mime"), wxDIR_FILES); - while ( cont ) + // now find where these extensions are in the data store and remove them + wxArrayString sA_Exts = ftInfo.GetExtensions(); + wxString sExt, sExtStore; + size_t i, nIndex; + size_t nExtCount = sA_Exts.GetCount(); + for (i=0; i < nExtCount; i++) { - LoadMimeTypesFromMimeFile(dirname + filename, manager); + sExt = sA_Exts.Item(i); - cont = dir.GetNext(&filename); + // clean up to just a space before and after + sExt.Trim().Trim(false); + sExt = wxT(' ') + sExt + wxT(' '); + size_t nCount = m_aExtensions.GetCount(); + for (nIndex = 0; nIndex < nCount; nIndex++) + { + sExtStore = m_aExtensions.Item(nIndex); + if (sExtStore.Replace(sExt, wxT(" ") ) > 0) + m_aExtensions.Item(nIndex) = sExtStore; + } } -} + if ( !DoAssociation(strType, strIcon, entry, sA_Exts, strDesc) ) + return NULL; + + return GetFileTypeFromMimeType(strType); +} -void wxGNOMEIconHandler::Init() +bool wxMimeTypesManagerImpl::DoAssociation(const wxString& strType, + const wxString& strIcon, + wxMimeTypeCommands *entry, + const wxArrayString& strExtensions, + const wxString& strDesc) { - wxArrayString dirs; - dirs.Add(_T("/usr/share")); - dirs.Add(_T("/usr/local/share")); + int nIndex = AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, true); - wxString gnomedir; - wxGetHomeDir( &gnomedir ); - gnomedir += _T("/.gnome"); - dirs.Add( gnomedir ); - - size_t nDirs = dirs.GetCount(); - for ( size_t nDir = 0; nDir < nDirs; nDir++ ) - { - LoadKeyFilesFromDir(dirs[nDir]); - } + if ( nIndex == wxNOT_FOUND ) + return false; - m_inited = TRUE; + return true; } - -void wxGNOMEIconHandler::GetMimeInfoRecords(wxMimeTypesManagerImpl *manager) +int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType, + const wxString& strIcon, + wxMimeTypeCommands *entry, + const wxArrayString& strExtensions, + const wxString& strDesc, + bool replaceExisting) { - if ( !m_inited ) - { - Init(); - } - - wxArrayString dirs; - dirs.Add(_T("/usr/share")); - dirs.Add(_T("/usr/local/share")); - - wxString gnomedir; - wxGetHomeDir( &gnomedir ); - gnomedir += _T("/.gnome"); - dirs.Add( gnomedir ); - - size_t nDirs = dirs.GetCount(); - for ( size_t nDir = 0; nDir < nDirs; nDir++ ) - { - LoadMimeFilesFromDir(dirs[nDir], manager); - } -} + InitIfNeeded(); -#if wxUSE_GUI - #define WXUNUSED_UNLESS_GUI(p) p -#else - #define WXUNUSED_UNLESS_GUI(p) -#endif + // ensure mimetype is always lower case + wxString mimeType = strType.Lower(); -bool wxGNOMEIconHandler::GetIcon(const wxString& mimetype, - wxIcon * WXUNUSED_UNLESS_GUI(icon)) -{ - if ( !m_inited ) + // is this a known MIME type? + int nIndex = m_aTypes.Index(mimeType); + if ( nIndex == wxNOT_FOUND ) { - Init(); - } - - int index = ms_mimetypes.Index(mimetype); - if ( index == wxNOT_FOUND ) - return FALSE; + // We put MIME types containing "application" at the end, so that + // if the MIME type for the extension "htm" is searched for, it will + // rather find "text/html" than "application/x-mozilla-bookmarks". + if (mimeType.Find( "application" ) == 0) + { + // new file type + m_aTypes.Add(mimeType); + m_aIcons.Add(strIcon); + m_aEntries.Add(entry ? entry : new wxMimeTypeCommands); - wxString iconname = ms_icons[(size_t)index]; + // change nIndex so we can use it below to add the extensions + m_aExtensions.Add(wxEmptyString); + nIndex = m_aExtensions.size() - 1; -#if wxUSE_GUI - wxLogNull nolog; - wxIcon icn; - if (iconname.Right(4).MakeUpper() == _T(".XPM")) - icn = wxIcon(iconname); - else - icn = wxIcon(iconname, wxBITMAP_TYPE_ANY); - if ( !icn.Ok() ) - return FALSE; + m_aDescriptions.Add(strDesc); + } + else + { + // new file type + m_aTypes.Insert(mimeType,0); + m_aIcons.Insert(strIcon,0); + m_aEntries.Insert(entry ? entry : new wxMimeTypeCommands,0); - if ( icon ) - *icon = icn; -#else - // helpful for testing in console mode - wxLogTrace(TRACE_MIME, _T("Found GNOME icon for '%s': '%s'\n"), - mimetype.c_str(), iconname.c_str()); -#endif + // change nIndex so we can use it below to add the extensions + m_aExtensions.Insert(wxEmptyString,0); + nIndex = 0; - return TRUE; -} - -// ---------------------------------------------------------------------------- -// wxKDEIconHandler -// ---------------------------------------------------------------------------- - -// KDE stores the icon info in its .kdelnk files. The file for mimetype/subtype -// may be found in either of the following locations -// -// 1. $KDEDIR/share/mimelnk/mimetype/subtype.kdelnk -// 2. ~/.kde/share/mimelnk/mimetype/subtype.kdelnk -// -// The format of a .kdelnk file is almost the same as the one used by -// wxFileConfig, i.e. there are groups, comments and entries. The icon is the -// value for the entry "Type" - -void wxKDEIconHandler::LoadLinksForMimeSubtype(const wxString& dirbase, - const wxString& subdir, - const wxString& filename, - const wxArrayString& icondirs) -{ - wxFFile file(dirbase + filename); - if ( !file.IsOpened() ) - return; - - // construct mimetype from the directory name and the basename of the - // file (it always has .kdelnk extension) - wxString mimetype; - mimetype << subdir << _T('/') << filename.BeforeLast(_T('.')); - - // these files are small, slurp the entire file at once - wxString text; - if ( !file.ReadAll(&text) ) - return; - - // first find the description string: it is the value in either "Comment=" - // line or "Comment[]=" one - int posComment = wxNOT_FOUND; - - wxString comment; -#if wxUSE_INTL - wxLocale *locale = wxGetLocale(); - if ( locale ) - { - // try "Comment[locale name]" first - comment << _T("Comment[") + locale->GetName() + _T("]="); - - posComment = text.Find(comment); - } -#endif // wxUSE_INTL - - if ( posComment == wxNOT_FOUND ) - { - comment = _T("Comment="); - - posComment = text.Find(comment); - } - - wxString mime_desc; - if ( posComment != wxNOT_FOUND ) - { - // found desc: it follows the comment until the end of line - const wxChar *pc = text.c_str() + posComment + comment.length(); - while ( *pc && *pc != _T('\n') ) - { - mime_desc += *pc++; + m_aDescriptions.Insert(strDesc,0); } } - //else: no description - - // next find the extensions - wxString mime_extension; - - int posExts = text.Find(_T("Patterns=")); - if ( posExts != wxNOT_FOUND ) + else // yes, we already have it { - wxString exts; - const wxChar *pc = text.c_str() + posExts + 9; // strlen("Patterns=") - while ( *pc && *pc != _T('\n') ) + if ( replaceExisting ) { - exts += *pc++; - } + // if new description change it + if ( !strDesc.empty()) + m_aDescriptions[nIndex] = strDesc; - wxStringTokenizer tokenizer(exts, _T(";")); - while ( tokenizer.HasMoreTokens() ) - { - wxString e = tokenizer.GetNextToken(); - if ( e.Left(2) != _T("*.") ) - continue; // don't support too difficult patterns + // if new icon change it + if ( !strIcon.empty()) + m_aIcons[nIndex] = strIcon; - if ( !mime_extension.empty() ) + if ( entry ) { - // separate from the previous ext - mime_extension << _T(' '); + delete m_aEntries[nIndex]; + m_aEntries[nIndex] = entry; } - - mime_extension << e.Mid(2); } - } - - ms_infoTypes.Add(mimetype); - ms_infoDescriptions.Add(mime_desc); - ms_infoExtensions.Add(mime_extension); - - // ok, now we can take care of icon: + else // add data we don't already have ... + { + // if new description add only if none + if ( m_aDescriptions[nIndex].empty() ) + m_aDescriptions[nIndex] = strDesc; - int posIcon = text.Find(_T("Icon=")); - if ( posIcon == wxNOT_FOUND ) - { - // no icon info - return; - } + // if new icon and no existing icon + if ( m_aIcons[nIndex].empty() ) + m_aIcons[nIndex] = strIcon; - wxString icon; + // add any new entries... + if ( entry ) + { + wxMimeTypeCommands *entryOld = m_aEntries[nIndex]; - const wxChar *pc = text.c_str() + posIcon + 5; // 5 == strlen("Icon=") - while ( *pc && *pc != _T('\n') ) - { - icon += *pc++; - } + size_t count = entry->GetCount(); + for ( size_t i = 0; i < count; i++ ) + { + const wxString& verb = entry->GetVerb(i); + if ( !entryOld->HasVerb(verb) ) + { + entryOld->AddOrReplaceVerb(verb, entry->GetCmd(i)); + } + } - if ( !!icon ) - { - // we must check if the file exists because it may be stored - // in many locations, at least ~/.kde and $KDEDIR - size_t nDir, nDirs = icondirs.GetCount(); - for ( nDir = 0; nDir < nDirs; nDir++ ) - if (wxFileExists(icondirs[nDir] + icon)) - { - icon.Prepend(icondirs[nDir]); - break; + // as we don't store it anywhere, it won't be deleted later as + // usual -- do it immediately instead + delete entry; } - if (nDir == nDirs) return; //does not exist - - // do we already have this MIME type? - int i = ms_mimetypes.Index(mimetype); - if ( i == wxNOT_FOUND ) - { - // add it - size_t n = ms_mimetypes.Add(mimetype); - ms_icons.Insert(icon, n); - } - else - { - // replace the old value - ms_icons[(size_t)i] = icon; } } -} - -void wxKDEIconHandler::LoadLinksForMimeType(const wxString& dirbase, - const wxString& subdir, - const wxArrayString& icondirs) -{ - wxString dirname = dirbase; - dirname += subdir; - wxDir dir(dirname); - if ( !dir.IsOpened() ) - return; - dirname += _T('/'); + // always add the extensions to this mimetype + wxString& exts = m_aExtensions[nIndex]; - wxString filename; - bool cont = dir.GetFirst(&filename, _T("*.kdelnk"), wxDIR_FILES); - while ( cont ) + // add all extensions we don't have yet + wxString ext; + size_t count = strExtensions.GetCount(); + for ( size_t i = 0; i < count; i++ ) { - LoadLinksForMimeSubtype(dirname, subdir, filename, icondirs); + ext = strExtensions[i]; + ext += wxT(' '); - cont = dir.GetNext(&filename); + if ( exts.Find(ext) == wxNOT_FOUND ) + { + exts += ext; + } } -} -void wxKDEIconHandler::LoadLinkFilesFromDir(const wxString& dirbase, - const wxArrayString& icondirs) -{ - wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase), - _T("base directory shouldn't end with a slash") ); + // check data integrity + wxASSERT( m_aTypes.GetCount() == m_aEntries.GetCount() && + m_aTypes.GetCount() == m_aExtensions.GetCount() && + m_aTypes.GetCount() == m_aIcons.GetCount() && + m_aTypes.GetCount() == m_aDescriptions.GetCount() ); - wxString dirname = dirbase; - dirname << _T("/mimelnk"); - - if ( !wxDir::Exists(dirname) ) - return; - - wxDir dir(dirname); - if ( !dir.IsOpened() ) - return; - - // we will concatenate it with dir name to get the full path below - dirname += _T('/'); - - wxString subdir; - bool cont = dir.GetFirst(&subdir, wxEmptyString, wxDIR_DIRS); - while ( cont ) - { - LoadLinksForMimeType(dirname, subdir, icondirs); - - cont = dir.GetNext(&subdir); - } + return nIndex; } -void wxKDEIconHandler::Init() +wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext) { - wxArrayString dirs; - wxArrayString icondirs; - - // settings in ~/.kde have maximal priority - dirs.Add(wxGetHomeDir() + _T("/.kde/share")); - icondirs.Add(wxGetHomeDir() + _T("/.kde/share/icons/")); - - // the variable KDEDIR is set when KDE is running - const char *kdedir = getenv("KDEDIR"); - if ( kdedir ) - { - dirs.Add(wxString(kdedir) + _T("/share")); - icondirs.Add(wxString(kdedir) + _T("/share/icons/")); - } - else - { - // try to guess KDEDIR - dirs.Add(_T("/usr/share")); - dirs.Add(_T("/opt/kde/share")); - icondirs.Add(_T("/usr/share/icons/")); - icondirs.Add(_T("/usr/X11R6/share/icons/")); // Debian/Corel linux - icondirs.Add(_T("/opt/kde/share/icons/")); - } - - size_t nDirs = dirs.GetCount(); - for ( size_t nDir = 0; nDir < nDirs; nDir++ ) - { - LoadLinkFilesFromDir(dirs[nDir], icondirs); - } + if (ext.empty() ) + return NULL; - m_inited = TRUE; -} + InitIfNeeded(); -bool wxKDEIconHandler::GetIcon(const wxString& mimetype, - wxIcon * WXUNUSED_UNLESS_GUI(icon)) -{ - if ( !m_inited ) + size_t count = m_aExtensions.GetCount(); + for ( size_t n = 0; n < count; n++ ) { - Init(); - } + wxStringTokenizer tk(m_aExtensions[n], wxT(' ')); - int index = ms_mimetypes.Index(mimetype); - if ( index == wxNOT_FOUND ) - return FALSE; - - wxString iconname = ms_icons[(size_t)index]; - -#if wxUSE_GUI - wxLogNull nolog; - wxIcon icn; - if (iconname.Right(4).MakeUpper() == _T(".XPM")) - icn = wxIcon(iconname); - else - icn = wxIcon(iconname, wxBITMAP_TYPE_ANY); - - if ( !icn.Ok() ) - return FALSE; - - if ( icon ) - *icon = icn; -#else - // helpful for testing in console mode - wxLogTrace(TRACE_MIME, _T("Found KDE icon for '%s': '%s'\n"), - mimetype.c_str(), iconname.c_str()); -#endif - - return TRUE; -} - - -void wxKDEIconHandler::GetMimeInfoRecords(wxMimeTypesManagerImpl *manager) -{ - if ( !m_inited ) Init(); - - size_t cnt = ms_infoTypes.GetCount(); - for (unsigned i = 0; i < cnt; i++) - manager -> AddMimeTypeInfo(ms_infoTypes[i], ms_infoExtensions[i], ms_infoDescriptions[i]); -} - - -// ---------------------------------------------------------------------------- -// wxFileTypeImpl (Unix) -// ---------------------------------------------------------------------------- - -MailCapEntry * -wxFileTypeImpl::GetEntry(const wxFileType::MessageParameters& params) const -{ - wxString command; - MailCapEntry *entry = m_manager->m_aEntries[m_index[0]]; - while ( entry != NULL ) { - // get the command to run as the test for this entry - command = wxFileType::ExpandCommand(entry->GetTestCmd(), params); - - // don't trace the test result if there is no test at all - if ( command.IsEmpty() ) + while ( tk.HasMoreTokens() ) { - // no test at all, ok - break; - } - - if ( wxSystem(command) == 0 ) { - // ok, test passed - wxLogTrace(TRACE_MIME, - wxT("Test '%s' for mime type '%s' succeeded."), - command.c_str(), params.GetMimeType().c_str()); - break; - } - else { - wxLogTrace(TRACE_MIME, - wxT("Test '%s' for mime type '%s' failed."), - command.c_str(), params.GetMimeType().c_str()); - } - - entry = entry->GetNext(); - } - - return entry; -} - -bool wxFileTypeImpl::GetIcon(wxIcon *icon) const -{ - wxArrayString mimetypes; - GetMimeTypes(mimetypes); + // consider extensions as not being case-sensitive + if ( tk.GetNextToken().IsSameAs(ext, false /* no case */) ) + { + // found + wxFileType *fileType = new wxFileType; + fileType->m_impl->Init(this, n); - ArrayIconHandlers& handlers = m_manager->GetIconHandlers(); - size_t count = handlers.GetCount(); - size_t counttypes = mimetypes.GetCount(); - for ( size_t n = 0; n < count; n++ ) - { - for ( size_t n2 = 0; n2 < counttypes; n2++ ) - { - if ( handlers[n]->GetIcon(mimetypes[n2], icon) ) - return TRUE; + return fileType; + } } } - return FALSE; -} - - -bool -wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const -{ - mimeTypes.Clear(); - for (size_t i = 0; i < m_index.GetCount(); i++) - mimeTypes.Add(m_manager->m_aTypes[m_index[i]]); - return TRUE; -} - - -bool -wxFileTypeImpl::GetExpandedCommand(wxString *expandedCmd, - const wxFileType::MessageParameters& params, - bool open) const -{ - MailCapEntry *entry = GetEntry(params); - if ( entry == NULL ) { - // all tests failed... - return FALSE; - } - - wxString cmd = open ? entry->GetOpenCmd() : entry->GetPrintCmd(); - if ( cmd.IsEmpty() ) { - // may happen, especially for "print" - return FALSE; - } - - *expandedCmd = wxFileType::ExpandCommand(cmd, params); - return TRUE; + return NULL; } -bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions) +wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType) { - wxString strExtensions = m_manager->GetExtension(m_index[0]); - extensions.Empty(); - - // one extension in the space or comma delimitid list - wxString strExt; - for ( const wxChar *p = strExtensions; ; p++ ) { - if ( *p == wxT(' ') || *p == wxT(',') || *p == wxT('\0') ) { - if ( !strExt.IsEmpty() ) { - extensions.Add(strExt); - strExt.Empty(); - } - //else: repeated spaces (shouldn't happen, but it's not that - // important if it does happen) - - if ( *p == wxT('\0') ) - break; - } - else if ( *p == wxT('.') ) { - // remove the dot from extension (but only if it's the first char) - if ( !strExt.IsEmpty() ) { - strExt += wxT('.'); - } - //else: no, don't append it - } - else { - strExt += *p; - } - } + InitIfNeeded(); - return TRUE; -} + wxFileType * fileType = NULL; + // mime types are not case-sensitive + wxString mimetype(mimeType); + mimetype.MakeLower(); -// ---------------------------------------------------------------------------- -// wxMimeTypesManagerImpl (Unix) -// ---------------------------------------------------------------------------- + // first look for an exact match + int index = m_aTypes.Index(mimetype); -/* static */ -ArrayIconHandlers& wxMimeTypesManagerImpl::GetIconHandlers() -{ - if ( ms_iconHandlers.GetCount() == 0 ) + if ( index != wxNOT_FOUND ) { - ms_iconHandlers.Add(&gs_iconHandlerGNOME); - ms_iconHandlers.Add(&gs_iconHandlerKDE); + fileType = new wxFileType; + fileType->m_impl->Init(this, index); } - return ms_iconHandlers; -} + // then try to find "text/*" as match for "text/plain" (for example) + // NB: if mimeType doesn't contain '/' at all, BeforeFirst() will return + // the whole string - ok. -wxMimeTypesManagerImpl::wxMimeTypesManagerImpl() -{ - m_initialized = FALSE; -} + index = wxNOT_FOUND; + wxString strCategory = mimetype.BeforeFirst(wxT('/')); -// read system and user mailcaps and other files -void wxMimeTypesManagerImpl::Initialize() -{ - // directories where we look for mailcap and mime.types by default - // (taken from metamail(1) sources) - // - // although RFC 1524 specifies the search path of - // /etc/:/usr/etc:/usr/local/etc only, it doesn't hurt to search in more - // places - OTOH, the RFC also says that this path can be changed with - // MAILCAPS environment variable (containing the colon separated full - // filenames to try) which is not done yet (TODO?) - static const wxChar *aStandardLocations[] = + size_t nCount = m_aTypes.GetCount(); + for ( size_t n = 0; n < nCount; n++ ) { - wxT("/etc"), - wxT("/usr/etc"), - wxT("/usr/local/etc"), - wxT("/etc/mail"), - wxT("/usr/public/lib") - }; - - // first read the system wide file(s) - size_t n; - for ( n = 0; n < WXSIZEOF(aStandardLocations); n++ ) { - wxString dir = aStandardLocations[n]; - - wxString file = dir + wxT("/mailcap"); - if ( wxFile::Exists(file) ) { - ReadMailcap(file); - } - - file = dir + wxT("/mime.types"); - if ( wxFile::Exists(file) ) { - ReadMimeTypes(file); + if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) && + m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") ) + { + index = n; + break; } } - wxString strHome = wxGetenv(wxT("HOME")); - - // and now the users mailcap - wxString strUserMailcap = strHome + wxT("/.mailcap"); - if ( wxFile::Exists(strUserMailcap) ) { - ReadMailcap(strUserMailcap); - } - - // read the users mime.types - wxString strUserMimeTypes = strHome + wxT("/.mime.types"); - if ( wxFile::Exists(strUserMimeTypes) ) { - ReadMimeTypes(strUserMimeTypes); - } - - // read KDE/GNOME tables - ArrayIconHandlers& handlers = GetIconHandlers(); - size_t count = handlers.GetCount(); - for ( size_t hn = 0; hn < count; hn++ ) - handlers[hn]->GetMimeInfoRecords(this); -} - - -wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl() -{ - size_t cnt = m_aEntries.GetCount(); - for (size_t i = 0; i < cnt; i++) - delete m_aEntries[i]; -} - -wxFileType * -wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo) -{ - wxFAIL_MSG( _T("unimplemented") ); // TODO - - return NULL; -} - -wxFileType * -wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext) -{ - InitIfNeeded(); - - wxFileType *fileType = NULL; - size_t count = m_aExtensions.GetCount(); - for ( size_t n = 0; n < count; n++ ) { - wxString extensions = m_aExtensions[n]; - while ( !extensions.IsEmpty() ) { - wxString field = extensions.BeforeFirst(wxT(' ')); - extensions = extensions.AfterFirst(wxT(' ')); - - // consider extensions as not being case-sensitive - if ( field.IsSameAs(ext, FALSE /* no case */) ) { - // found - if (fileType == NULL) fileType = new wxFileType; - fileType->m_impl->Init(this, n); - // adds this mime type to _list_ of mime types with this extension - } - } + if ( index != wxNOT_FOUND ) + { + // don't throw away fileType that was already found + if (!fileType) + fileType = new wxFileType; + fileType->m_impl->Init(this, index); } return fileType; } -wxFileType * -wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType) +wxString wxMimeTypesManagerImpl::GetCommand(const wxString & verb, size_t nIndex) const { - InitIfNeeded(); + wxString command, testcmd, sV, sTmp; + sV = verb + wxT("="); - // mime types are not case-sensitive - wxString mimetype(mimeType); - mimetype.MakeLower(); + // list of verb = command pairs for this mimetype + wxMimeTypeCommands * sPairs = m_aEntries [nIndex]; - // first look for an exact match - int index = m_aTypes.Index(mimetype); - if ( index == wxNOT_FOUND ) { - // then try to find "text/*" as match for "text/plain" (for example) - // NB: if mimeType doesn't contain '/' at all, BeforeFirst() will return - // the whole string - ok. - wxString strCategory = mimetype.BeforeFirst(wxT('/')); - - size_t nCount = m_aTypes.Count(); - for ( size_t n = 0; n < nCount; n++ ) { - if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) && - m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") ) { - index = n; - break; - } - } + size_t i; + size_t nCount = sPairs->GetCount(); + for ( i = 0; i < nCount; i++ ) + { + sTmp = sPairs->GetVerbCmd (i); + if ( sTmp.Contains(sV) ) + command = sTmp.AfterFirst(wxT('=')); } - if ( index != wxNOT_FOUND ) { - wxFileType *fileType = new wxFileType; - fileType->m_impl->Init(this, index); - - return fileType; - } - else { - // not found... - return NULL; - } + return command; } void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype) @@ -1218,547 +932,39 @@ void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype) wxString extensions; const wxArrayString& exts = filetype.GetExtensions(); size_t nExts = exts.GetCount(); - for ( size_t nExt = 0; nExt < nExts; nExt++ ) { - if ( nExt > 0 ) { + for ( size_t nExt = 0; nExt < nExts; nExt++ ) + { + if ( nExt > 0 ) extensions += wxT(' '); - } + extensions += exts[nExt]; } AddMimeTypeInfo(filetype.GetMimeType(), extensions, filetype.GetDescription()); - - AddMailcapInfo(filetype.GetMimeType(), - filetype.GetOpenCommand(), - filetype.GetPrintCommand(), - wxT(""), - filetype.GetDescription()); } void wxMimeTypesManagerImpl::AddMimeTypeInfo(const wxString& strMimeType, const wxString& strExtensions, const wxString& strDesc) { - InitIfNeeded(); - - int index = m_aTypes.Index(strMimeType); - if ( index == wxNOT_FOUND ) { - // add a new entry - m_aTypes.Add(strMimeType); - m_aEntries.Add(NULL); - m_aExtensions.Add(strExtensions); - m_aDescriptions.Add(strDesc); - } - else { - // modify an existing one - if ( !strDesc.IsEmpty() ) { - m_aDescriptions[index] = strDesc; // replace old value - } - m_aExtensions[index] += ' ' + strExtensions; - } -} - -void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType, - const wxString& strOpenCmd, - const wxString& strPrintCmd, - const wxString& strTest, - const wxString& strDesc) -{ - InitIfNeeded(); - - MailCapEntry *entry = new MailCapEntry(strOpenCmd, strPrintCmd, strTest); - - int nIndex = m_aTypes.Index(strType); - if ( nIndex == wxNOT_FOUND ) { - // new file type - m_aTypes.Add(strType); - - m_aEntries.Add(entry); - m_aExtensions.Add(wxT("")); - m_aDescriptions.Add(strDesc); - } - else { - // always append the entry in the tail of the list - info added with - // this function can only come from AddFallbacks() - MailCapEntry *entryOld = m_aEntries[nIndex]; - if ( entryOld ) - entry->Append(entryOld); - else - m_aEntries[nIndex] = entry; - } -} - -bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName) -{ - wxLogTrace(TRACE_MIME, wxT("--- Parsing mime.types file '%s' ---"), - strFileName.c_str()); - - wxTextFile file(strFileName); - if ( !file.Open() ) - return FALSE; - - // the information we extract - wxString strMimeType, strDesc, strExtensions; - - size_t nLineCount = file.GetLineCount(); - const wxChar *pc = NULL; - for ( size_t nLine = 0; nLine < nLineCount; nLine++ ) { - if ( pc == NULL ) { - // now we're at the start of the line - pc = file[nLine].c_str(); - } - else { - // we didn't finish with the previous line yet - nLine--; - } - - // skip whitespace - while ( wxIsspace(*pc) ) - pc++; - - // comment or blank line? - if ( *pc == wxT('#') || !*pc ) { - // skip the whole line - pc = NULL; - continue; - } - - // detect file format - const wxChar *pEqualSign = wxStrchr(pc, wxT('=')); - if ( pEqualSign == NULL ) { - // brief format - // ------------ - - // first field is mime type - for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != wxT('\0'); pc++ ) { - strMimeType += *pc; - } - - // skip whitespace - while ( wxIsspace(*pc) ) - pc++; - - // take all the rest of the string - strExtensions = pc; - - // no description... - strDesc.Empty(); - } - else { - // expanded format - // --------------- - - // the string on the left of '=' is the field name - wxString strLHS(pc, pEqualSign - pc); - - // eat whitespace - for ( pc = pEqualSign + 1; wxIsspace(*pc); pc++ ) - ; - - const wxChar *pEnd; - if ( *pc == wxT('"') ) { - // the string is quoted and ends at the matching quote - pEnd = wxStrchr(++pc, wxT('"')); - if ( pEnd == NULL ) { - wxLogWarning(_("Mime.types file %s, line %d: unterminated " - "quoted string."), - strFileName.c_str(), nLine + 1); - } - } - else { - // unquoted string ends at the first space or at the end of - // line - for ( pEnd = pc; *pEnd && !wxIsspace(*pEnd); pEnd++ ) - ; - } + // reading mailcap may find image/* , while + // reading mime.types finds image/gif and no match is made + // this means all the get functions don't work fix this + wxString strIcon; + wxString sTmp = strExtensions; - // now we have the RHS (field value) - wxString strRHS(pc, pEnd - pc); + wxArrayString sExts; + sTmp.Trim().Trim(false); - // check what follows this entry - if ( *pEnd == wxT('"') ) { - // skip this quote - pEnd++; - } - - for ( pc = pEnd; wxIsspace(*pc); pc++ ) - ; - - // if there is something left, it may be either a '\\' to continue - // the line or the next field of the same entry - bool entryEnded = *pc == wxT('\0'), - nextFieldOnSameLine = FALSE; - if ( !entryEnded ) { - nextFieldOnSameLine = ((*pc != wxT('\\')) || (pc[1] != wxT('\0'))); - } - - // now see what we got - if ( strLHS == wxT("type") ) { - strMimeType = strRHS; - } - else if ( strLHS == wxT("desc") ) { - strDesc = strRHS; - } - else if ( strLHS == wxT("exts") ) { - strExtensions = strRHS; - } - else { - wxLogWarning(_("Unknown field in file %s, line %d: '%s'."), - strFileName.c_str(), nLine + 1, strLHS.c_str()); - } - - if ( !entryEnded ) { - if ( !nextFieldOnSameLine ) - pc = NULL; - //else: don't reset it - - // as we don't reset strMimeType, the next field in this entry - // will be interpreted correctly. - - continue; - } - } - - // depending on the format (Mosaic or Netscape) either space or comma - // is used to separate the extensions - strExtensions.Replace(wxT(","), wxT(" ")); - - // also deal with the leading dot - if ( !strExtensions.IsEmpty() && strExtensions[0u] == wxT('.') ) - { - strExtensions.erase(0, 1); - } - - AddMimeTypeInfo(strMimeType, strExtensions, strDesc); - - // finished with this line - pc = NULL; - } - - // check our data integriry - wxASSERT( m_aTypes.Count() == m_aEntries.Count() && - m_aTypes.Count() == m_aExtensions.Count() && - m_aTypes.Count() == m_aDescriptions.Count() ); - - return TRUE; -} - -bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName, - bool fallback) -{ - wxLogTrace(TRACE_MIME, wxT("--- Parsing mailcap file '%s' ---"), - strFileName.c_str()); - - wxTextFile file(strFileName); - if ( !file.Open() ) - return FALSE; - - // see the comments near the end of function for the reason we need these - // variables (search for the next occurence of them) - // indices of MIME types (in m_aTypes) we already found in this file - wxArrayInt aEntryIndices; - // aLastIndices[n] is the index of last element in - // m_aEntries[aEntryIndices[n]] from this file - wxArrayInt aLastIndices; - - size_t nLineCount = file.GetLineCount(); - for ( size_t nLine = 0; nLine < nLineCount; nLine++ ) { - // now we're at the start of the line - const wxChar *pc = file[nLine].c_str(); - - // skip whitespace - while ( wxIsspace(*pc) ) - pc++; - - // comment or empty string? - if ( *pc == wxT('#') || *pc == wxT('\0') ) - continue; - - // no, do parse - - // what field are we currently in? The first 2 are fixed and there may - // be an arbitrary number of other fields -- currently, we are not - // interested in any of them, but we should parse them as well... - enum - { - Field_Type, - Field_OpenCmd, - Field_Other - } currentToken = Field_Type; - - // the flags and field values on the current line - bool needsterminal = FALSE, - copiousoutput = FALSE; - wxString strType, - strOpenCmd, - strPrintCmd, - strTest, - strDesc, - curField; // accumulator - bool cont = TRUE; - while ( cont ) { - switch ( *pc ) { - case wxT('\\'): - // interpret the next character literally (notice that - // backslash can be used for line continuation) - if ( *++pc == wxT('\0') ) { - // fetch the next line if there is one - if ( nLine == nLineCount - 1 ) { - // something is wrong, bail out - cont = FALSE; - - wxLogDebug(wxT("Mailcap file %s, line %d: " - "'\\' on the end of the last line " - "ignored."), - strFileName.c_str(), - nLine + 1); - } - else { - // pass to the beginning of the next line - pc = file[++nLine].c_str(); - - // skip pc++ at the end of the loop - continue; - } - } - else { - // just a normal character - curField += *pc; - } - break; - - case wxT('\0'): - cont = FALSE; // end of line reached, exit the loop - - // fall through - - case wxT(';'): - // store this field and start looking for the next one - - // trim whitespaces from both sides - curField.Trim(TRUE).Trim(FALSE); - - switch ( currentToken ) { - case Field_Type: - strType = curField; - if ( strType.empty() ) { - // I don't think that this is a valid mailcap - // entry, but try to interpret it somehow - strType = _T('*'); - } - - if ( strType.Find(wxT('/')) == wxNOT_FOUND ) { - // we interpret "type" as "type/*" - strType += wxT("/*"); - } - - currentToken = Field_OpenCmd; - break; - - case Field_OpenCmd: - strOpenCmd = curField; - - currentToken = Field_Other; - break; - - case Field_Other: - if ( !curField.empty() ) { - // "good" mailcap entry? - bool ok = TRUE; - - // is this something of the form foo=bar? - const wxChar *pEq = wxStrchr(curField, wxT('=')); - if ( pEq != NULL ) { - wxString lhs = curField.BeforeFirst(wxT('=')), - rhs = curField.AfterFirst(wxT('=')); - - lhs.Trim(TRUE); // from right - rhs.Trim(FALSE); // from left - - if ( lhs == wxT("print") ) - strPrintCmd = rhs; - else if ( lhs == wxT("test") ) - strTest = rhs; - else if ( lhs == wxT("description") ) { - // it might be quoted - if ( rhs[0u] == wxT('"') && - rhs.Last() == wxT('"') ) { - strDesc = wxString(rhs.c_str() + 1, - rhs.Len() - 2); - } - else { - strDesc = rhs; - } - } - else if ( lhs == wxT("compose") || - lhs == wxT("composetyped") || - lhs == wxT("notes") || - lhs == wxT("edit") ) - ; // ignore - else - ok = FALSE; - - } - else { - // no, it's a simple flag - if ( curField == wxT("needsterminal") ) - needsterminal = TRUE; - else if ( curField == wxT("copiousoutput")) { - // copiousoutput impies that the - // viewer is a console program - needsterminal = - copiousoutput = TRUE; - } - else { - // unknown flag - ok = FALSE; - } - } - - if ( !ok ) - { - if ( !IsKnownUnimportantField(curField) ) - { - // don't flood the user with error - // messages if we don't understand - // something in his mailcap, but give - // them in debug mode because this might - // be useful for the programmer - wxLogDebug - ( - wxT("Mailcap file %s, line %d: " - "unknown field '%s' for the " - "MIME type '%s' ignored."), - strFileName.c_str(), - nLine + 1, - curField.c_str(), - strType.c_str() - ); - } - } - } - //else: the field is empty, ignore silently - - // it already has this value - //currentToken = Field_Other; - break; - - default: - wxFAIL_MSG(wxT("unknown field type in mailcap")); - } - - // next token starts immediately after ';' - curField.Empty(); - break; - - default: - curField += *pc; - } - - // continue in the same line - pc++; - } - - // check that we really read something reasonable - if ( currentToken == Field_Type || currentToken == Field_OpenCmd ) { - wxLogWarning(_("Mailcap file %s, line %d: incomplete entry " - "ignored."), - strFileName.c_str(), nLine + 1); - } - else { - // support for flags: - // 1. create an xterm for 'needsterminal' - // 2. append "| $PAGER" for 'copiousoutput' - // - // Note that the RFC says that having both needsterminal and - // copiousoutput is probably a mistake, so it seems that running - // programs with copiousoutput inside an xterm as it is done now - // is a bad idea (FIXME) - if ( copiousoutput ) { - const wxChar *p = wxGetenv(_T("PAGER")); - strOpenCmd << _T(" | ") << (p ? p : _T("more")); - } - - if ( needsterminal ) { - strOpenCmd.Printf(_T("xterm -e sh -c '%s'"), - strOpenCmd.c_str()); - } - - MailCapEntry *entry = new MailCapEntry(strOpenCmd, - strPrintCmd, - strTest); - - // NB: because of complications below (we must get entries priority - // right), we can't use AddMailcapInfo() here, unfortunately. - strType.MakeLower(); - int nIndex = m_aTypes.Index(strType); - if ( nIndex == wxNOT_FOUND ) { - // new file type - m_aTypes.Add(strType); - - m_aEntries.Add(entry); - m_aExtensions.Add(wxT("")); - m_aDescriptions.Add(strDesc); - } - else { - // modify the existing entry: the entries in one and the same - // file are read in top-to-bottom order, i.e. the entries read - // first should be tried before the entries below. However, - // the files read later should override the settings in the - // files read before (except if fallback is TRUE), thus we - // Insert() the new entry to the list if it has already - // occured in _this_ file, but Prepend() it if it occured in - // some of the previous ones and Append() to it in the - // fallback case - - if ( fallback ) { - // 'fallback' parameter prevents the entries from this - // file from overriding the other ones - always append - MailCapEntry *entryOld = m_aEntries[nIndex]; - if ( entryOld ) - entry->Append(entryOld); - else - m_aEntries[nIndex] = entry; - } - else { - int entryIndex = aEntryIndices.Index(nIndex); - if ( entryIndex == wxNOT_FOUND ) { - // first time in this file - aEntryIndices.Add(nIndex); - aLastIndices.Add(0); - - entry->Prepend(m_aEntries[nIndex]); - m_aEntries[nIndex] = entry; - } - else { - // not the first time in _this_ file - size_t nEntryIndex = (size_t)entryIndex; - MailCapEntry *entryOld = m_aEntries[nIndex]; - if ( entryOld ) - entry->Insert(entryOld, aLastIndices[nEntryIndex]); - else - m_aEntries[nIndex] = entry; - - // the indices were shifted by 1 - aLastIndices[nEntryIndex]++; - } - } - - if ( !strDesc.IsEmpty() ) { - // replace the old one - what else can we do?? - m_aDescriptions[nIndex] = strDesc; - } - } - } - - // check our data integriry - wxASSERT( m_aTypes.Count() == m_aEntries.Count() && - m_aTypes.Count() == m_aExtensions.Count() && - m_aTypes.Count() == m_aDescriptions.Count() ); + while (!sTmp.empty()) + { + sExts.Add(sTmp.AfterLast(wxT(' '))); + sTmp = sTmp.BeforeLast(wxT(' ')); } - return TRUE; + AddToMimeData(strMimeType, strIcon, NULL, sExts, strDesc, true); } size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes) @@ -1767,13 +973,12 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes) mimetypes.Empty(); - wxString type; size_t count = m_aTypes.GetCount(); for ( size_t n = 0; n < count; n++ ) { // don't return template types from here (i.e. anything containg '*') - type = m_aTypes[n]; - if ( type.Find(_T('*')) == wxNOT_FOUND ) + const wxString &type = m_aTypes[n]; + if ( type.Find(wxT('*')) == wxNOT_FOUND ) { mimetypes.Add(type); } @@ -1786,36 +991,41 @@ size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes) // writing to MIME type files // ---------------------------------------------------------------------------- -bool wxFileTypeImpl::Unassociate() +bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft) { - wxFAIL_MSG( _T("unimplemented") ); // TODO - - return FALSE; -} - -// ---------------------------------------------------------------------------- -// private functions -// ---------------------------------------------------------------------------- + InitIfNeeded(); -static bool IsKnownUnimportantField(const wxString& fieldAll) -{ - static const wxChar *knownFields[] = - { - _T("x-mozilla-flags"), - _T("nametemplate"), - _T("textualnewlines"), - }; + wxArrayString sMimeTypes; + ft->GetMimeTypes(sMimeTypes); - wxString field = fieldAll.BeforeFirst(_T('=')); - for ( size_t n = 0; n < WXSIZEOF(knownFields); n++ ) + size_t i; + size_t nCount = sMimeTypes.GetCount(); + for (i = 0; i < nCount; i ++) { - if ( field.CmpNoCase(knownFields[n]) == 0 ) - return TRUE; + const wxString &sMime = sMimeTypes.Item(i); + int nIndex = m_aTypes.Index(sMime); + if ( nIndex == wxNOT_FOUND) + { + // error if we get here ?? + return false; + } + else + { + m_aTypes.RemoveAt(nIndex); + m_aEntries.RemoveAt(nIndex); + m_aExtensions.RemoveAt(nIndex); + m_aDescriptions.RemoveAt(nIndex); + m_aIcons.RemoveAt(nIndex); + } } + // check data integrity + wxASSERT( m_aTypes.GetCount() == m_aEntries.GetCount() && + m_aTypes.GetCount() == m_aExtensions.GetCount() && + m_aTypes.GetCount() == m_aIcons.GetCount() && + m_aTypes.GetCount() == m_aDescriptions.GetCount() ); - return FALSE; + return true; } #endif - // wxUSE_FILE && wxUSE_TEXTFILE - + // wxUSE_MIMETYPE && wxUSE_FILE