// Licence: wxWindows license (part of wxExtra library)
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
-#pragma implementation "mimetype.h"
+// known bugs; there may be others!! chris elliott, biol75@york.ac.uk 27 Mar 01
+
+// 1) .mailcap and .mimetypes can be either in a netscape or metamail format
+// and entries may get confused during writing (I've tried to fix this; please let me know
+// any files that fail)
+// 2) KDE and Gnome do not yet fully support international read/write
+// 3) Gnome key lines like open.latex."LaTeX this file"=latex %f will have odd results
+// 4) writing to files comments out the existing data; I hope this avoids losing
+// any data which we could not read, and data which we did not store like test=
+// 5) results from reading files with multiple entries (especially matches with type/* )
+// may (or may not) work for getXXX commands
+// 6) Loading the png icons in Gnome doesn't work for me...
+// 7) In Gnome, if keys.mime exists but keys.users does not, there is
+// an error message in debug mode, but the file is still written OK
+// 8) Deleting entries is only allowed from the user file; sytem wide entries
+// will be preserved during unassociate
+// 9) KDE does not yet handle multiple actions; Netscape mode never will
+
+/*
+ TODO: this file is a mess, we need to split it and reformet/review
+ everything (VZ)
+ */
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#ifdef __GNUG__
+ #pragma implementation "mimetype.h"
#endif
// for compilers that support precompilation, includes "wx.h".
#include "wx/defs.h"
#endif
-#if (wxUSE_FILE && wxUSE_TEXTFILE) || defined(__WXMSW__)
+#if wxUSE_MIMETYPE && wxUSE_FILE && wxUSE_TEXTFILE
#ifndef WX_PRECOMP
#include "wx/string.h"
#if wxUSE_GUI
#include "wx/icon.h"
+
#endif
#endif //WX_PRECOMP
// other standard headers
#include <ctype.h>
+#ifdef __VMS
+/* silence warnings for comparing unsigned int's <0 */
+# pragma message disable unscomzer
+#endif
+
+// wxMimeTypeCommands stores the verbs defined for the given MIME type with
+// their values
+class wxMimeTypeCommands
+{
+public:
+ wxMimeTypeCommands() { }
+
+ wxMimeTypeCommands(const wxArrayString& verbs,
+ const wxArrayString& commands)
+ : m_verbs(verbs),
+ m_commands(commands)
+ {
+ }
+
+ // add a new verb with the command or replace the old value
+ void AddOrReplaceVerb(const wxString& verb, const wxString& cmd)
+ {
+ int n = m_verbs.Index(verb, FALSE /* ignore case */);
+ if ( n == wxNOT_FOUND )
+ {
+ m_verbs.Add(verb);
+ m_commands.Add(cmd);
+ }
+ else
+ {
+ m_commands[n] = cmd;
+ }
+ }
+
+ void Add(const wxString& s)
+ {
+ m_verbs.Add(s.BeforeFirst(_T('=')));
+ m_commands.Add(s.AfterFirst(_T('=')));
+ }
+
+ // access the commands
+ size_t GetCount() const { return m_verbs.GetCount(); }
+ const wxString& GetVerb(size_t n) const { return m_verbs[n]; }
+ const wxString& GetCmd(size_t n) const { return m_commands[n]; }
+
+ bool HasVerb(const wxString& verb) const
+ { return m_verbs.Index(verb) != wxNOT_FOUND; }
+
+ wxString GetCommandForVerb(const wxString& verb, size_t *idx = NULL) const
+ {
+ wxString s;
+
+ int n = m_verbs.Index(verb);
+ if ( n != wxNOT_FOUND )
+ {
+ s = m_commands[(size_t)n];
+ if ( idx )
+ *idx = n;
+ }
+
+ return s;
+ }
+
+ // get a "verb=command" string
+ wxString GetVerbCmd(size_t n) const
+ {
+ return m_verbs[n] + _T('=') + m_commands[n];
+ }
+
+private:
+ wxArrayString m_verbs,
+ m_commands;
+};
+
+// this class extends wxTextFile
+//
+// VZ: ???
+class wxMimeTextFile : public wxTextFile
+{
+public:
+ // constructors
+ wxMimeTextFile () : wxTextFile () {};
+ wxMimeTextFile (const wxString& strFile) : wxTextFile (strFile) { };
+
+ int pIndexOf(const wxString & sSearch, bool bIncludeComments = FALSE, int iStart = 0)
+ {
+ size_t i = iStart;
+ int nResult = wxNOT_FOUND;
+ if (i>=GetLineCount()) return wxNOT_FOUND;
+
+ wxString sTest = sSearch;
+ sTest.MakeLower();
+ wxString sLine;
+
+ if (bIncludeComments)
+ {
+ while ( (i < GetLineCount()) )
+ {
+ sLine = GetLine (i);
+ sLine.MakeLower();
+ if (sLine.Contains(sTest)) nResult = (int) i;
+ i++;
+ }
+ }
+ else
+ {
+ while ( (i < GetLineCount()) )
+ {
+ sLine = GetLine (i);
+ sLine.MakeLower();
+ if ( ! sLine.StartsWith(wxT("#")))
+ {
+ if (sLine.Contains(sTest)) nResult = (int) i;
+ }
+ i++;
+ }
+ }
+ return nResult;
+ }
+
+ bool CommentLine(int nIndex)
+ {
+ if (nIndex <0) return FALSE;
+ if (nIndex >= (int)GetLineCount() ) return FALSE;
+ GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
+ return TRUE;
+ }
+
+ bool CommentLine(const wxString & sTest)
+ {
+ int nIndex = pIndexOf(sTest);
+ if (nIndex <0) return FALSE;
+ if (nIndex >= (int)GetLineCount() ) return FALSE;
+ GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
+ return TRUE;
+ }
+
+ wxString GetVerb (size_t i)
+ {
+ if (i > GetLineCount() ) return wxEmptyString;
+ wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
+ return sTmp;
+ }
+
+ wxString GetCmd (size_t i)
+ {
+ if (i > GetLineCount() ) return wxEmptyString;
+ wxString sTmp = GetLine(i).AfterFirst(wxT('='));
+ return sTmp;
+ }
+};
+
// in case we're compiling in non-GUI mode
class WXDLLEXPORT wxIcon;
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+// MIME code tracing mask
+#define TRACE_MIME _T("mime")
+
+// give trace messages about the results of mailcap tests
+#define TRACE_MIME_TEST _T("mimetest")
+
+// ----------------------------------------------------------------------------
+// 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
+// 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.
+// 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 <field1>;<field2>;...;<fieldN>.
// * 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 console must be created for the viewer
+// * 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
// * 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 xpansion:
+// 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
// * %{parameter} is replaced with the value of parameter taken from
// Content-type header line of the message.
//
-// FIXME any docs with real descriptions of these files??
//
// There are 2 possible formats for mime.types file, one entry per line (used
-// for global mime.types) and "expanded" format where an entry takes multiple
-// lines (used for users mime.types).
+// 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:
// <mime type> <space separated list of extensions>
// b) for "expanded" format:
-// type=<mime type> \ desc="<description>" \ exts="ext"
+// type=<mime type> BACKSLASH
+// desc="<description>" BACKSLASH
+// exts="<comma separated list of extensions>"
+//
+// (where BACKSLASH is a literal '\\' which we can't put here because cpp
+// misinterprets it)
//
// 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
-{
-public:
- // ctor
- MailCapEntry(const wxString& openCmd,
- const wxString& printCmd,
- const wxString& testCmd)
- : m_openCmd(openCmd), m_printCmd(printCmd), m_testCmd(testCmd)
- {
- m_next = NULL;
- }
- // accessors
- const wxString& GetOpenCmd() const { return m_openCmd; }
- const wxString& GetPrintCmd() const { return m_printCmd; }
- const wxString& GetTestCmd() const { return m_testCmd; }
+// ----------------------------------------------------------------------------
+// wxGNOME
+// ----------------------------------------------------------------------------
+
+// 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.
- MailCapEntry *GetNext() const { return m_next; }
- // 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)
+bool wxMimeTypesManagerImpl::CheckGnomeDirsExist ()
+{
+ wxString gnomedir;
+ wxGetHomeDir( &gnomedir );
+ wxString sTmp = gnomedir;
+ sTmp = sTmp + "/.gnome";
+ if (! wxDir::Exists ( sTmp ) )
{
- // FIXME slooow...
- MailCapEntry *cur;
- size_t n = 0;
- for ( cur = next; cur != NULL; cur = cur->m_next, n++ ) {
- if ( n == pos )
- break;
+ if (!wxMkdir ( sTmp ))
+ {
+ wxFAIL_MSG (wxString ("Failed to create directory\n.gnome in \nCheckGnomeDirsExist") + sTmp );
+ return FALSE;
}
-
- wxASSERT_MSG( n == pos, wxT("invalid position in MailCapEntry::Insert") );
-
- m_next = cur->m_next;
- cur->m_next = this;
}
- // append this element to the list
- void Append(MailCapEntry *next)
+ sTmp = sTmp + "/mime-info";
+ if (! wxDir::Exists ( sTmp ) )
{
- wxCHECK_RET( next != NULL, wxT("Append()ing to what?") );
-
- // FIXME slooow...
- MailCapEntry *cur;
- for ( cur = next; cur->m_next != NULL; cur = cur->m_next )
- ;
-
- cur->m_next = this;
-
- wxASSERT_MSG( !m_next, wxT("Append()ing element already in the list?") );
+ if (!wxMkdir ( sTmp ))
+ {
+ wxFAIL_MSG (wxString ("Failed to create directory\nmime-info in \nCheckGnomeDirsExist") + sTmp );
+ return FALSE;
+ }
}
+ return TRUE;
-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
-};
-// the base class which may be used to find an icon for the MIME type
-class wxMimeTypeIconHandler
+bool wxMimeTypesManagerImpl::WriteGnomeKeyFile(int index, bool delete_index)
{
-public:
- virtual bool GetIcon(const wxString& mimetype, wxIcon *icon) = 0;
-
- // 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;
-};
+ wxString gnomedir;
+ wxGetHomeDir( &gnomedir );
+ wxMimeTextFile outfile ( gnomedir + "/.gnome/mime-info/user.keys");
+ // if this fails probably Gnome is not installed ??
+ // create it anyway as a private mime store
-// the icon handler which uses GNOME MIME database
-class wxGNOMEIconHandler : public wxMimeTypeIconHandler
-{
-public:
- virtual bool GetIcon(const wxString& mimetype, wxIcon *icon);
- virtual void GetMimeInfoRecords(wxMimeTypesManagerImpl *manager);
+ if (! outfile.Open () )
+ {
+ if (delete_index) return FALSE;
+ if (!CheckGnomeDirsExist() ) return FALSE;
+ outfile.Create ();
+ }
-private:
- void Init();
- void LoadIconsFromKeyFile(const wxString& filename);
- void LoadKeyFilesFromDir(const wxString& dirbase);
+ wxString sTmp, strType = m_aTypes[index];
+ int nIndex = outfile.pIndexOf(strType);
+ if ( nIndex == wxNOT_FOUND )
+ {
+ outfile.AddLine ( strType + wxT(':') );
+ // see file:/usr/doc/gnome-libs-devel-1.0.40/devel-docs/mime-type-handling.txt
+ // as this does not deal with internationalisation
+ // wxT( "\t[en_US]") + verb + wxT ('=') + cmd + wxT(" %f");
+ wxMimeTypeCommands * entries = m_aEntries[index];
+ size_t count = entries->GetCount();
+ for ( size_t i = 0; i < count; i++ )
+ {
+ sTmp = entries->GetVerbCmd(i);
+ sTmp.Replace( wxT("%s"), wxT("%f") );
+ sTmp = wxT ( "\t") + sTmp;
+ outfile.AddLine ( sTmp );
+ }
+ //for international use do something like this
+ //outfile.AddLine ( wxString( "\t[en_US]icon-filename=") + cmd );
+ outfile.AddLine ( wxT( "\ticon-filename=") + m_aIcons[index] );
+ }
+ else
+ {
+ if (delete_index)
+ outfile.CommentLine(nIndex);
- void LoadMimeTypesFromMimeFile(const wxString& filename, wxMimeTypesManagerImpl *manager);
- void LoadMimeFilesFromDir(const wxString& dirbase, wxMimeTypesManagerImpl *manager);
+ wxMimeTypeCommands sOld;
+ size_t nOld = nIndex + 1;
+ bool oldEntryEnd = FALSE;
+ while ( (nOld < outfile.GetLineCount() )&& (oldEntryEnd == FALSE ))
+ {
+ sTmp = outfile.GetLine(nOld);
+ if ( (sTmp[0u] == wxT('\t')) || (sTmp[0u] == wxT('#')) )
+ {
+ // we have another line to deal with
+ outfile.CommentLine(nOld);
+ nOld ++;
+ // add the line to our store
+ if ((!delete_index) && (sTmp[0u] == wxT('\t')))
+ sOld.Add(sTmp);
+ }
+ // next mimetpye ??or blank line
+ else
+ oldEntryEnd = TRUE;
+ }
+ // list of entries in our data; these should all be in sOld,
+ // though sOld may also contain other entries , eg flags
+ if (!delete_index)
+ {
+ wxMimeTypeCommands * entries = m_aEntries[index];
+ size_t i;
+ for (i=0; i < entries->GetCount(); i++)
+ {
+ // replace any entries in sold that match verbs we know
+ sOld.AddOrReplaceVerb ( entries->GetVerb(i), entries->GetCmd (i) );
+ }
+ //sOld should also contain the icon
+ if ( !m_aIcons[index].empty() )
+ sOld.AddOrReplaceVerb ( wxT( "icon-filename"), m_aIcons[index] );
- static bool m_inited;
+ for (i=0; i < sOld.GetCount(); i++)
+ {
+ sTmp = sOld.GetVerbCmd(i);
+ sTmp.Replace( wxT("%s"), wxT("%f") );
+ sTmp = wxT ( "\t") + sTmp;
+ nIndex ++;
+ outfile.InsertLine ( sTmp, nIndex );
+ }
+ }
+ }
+ bool bTmp = outfile.Write ();
+ return bTmp;
+}
- static wxSortedArrayString ms_mimetypes;
- static wxArrayString ms_icons;
-};
-// the icon handler which uses KDE MIME database
-class wxKDEIconHandler : public wxMimeTypeIconHandler
+bool wxMimeTypesManagerImpl::WriteGnomeMimeFile(int index, bool delete_index)
{
-public:
- virtual bool GetIcon(const wxString& mimetype, wxIcon *icon);
- virtual void GetMimeInfoRecords(wxMimeTypesManagerImpl *manager);
+ wxString gnomedir;
+ wxGetHomeDir( &gnomedir );
-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;
-};
+ wxMimeTextFile outfile ( gnomedir + "/.gnome/mime-info/user.mime");
+ // if this fails probably Gnome is not installed ??
+ // create it anyway as a private mime store
+ if (! outfile.Open () )
+ {
+ if (delete_index) return FALSE;
+ if (!CheckGnomeDirsExist() ) return FALSE;
+ outfile.Create ();
+ }
+ wxString strType = m_aTypes[index];
+ int nIndex = outfile.pIndexOf(strType);
+ if ( nIndex == wxNOT_FOUND )
+ {
+ outfile.AddLine ( strType );
+ outfile.AddLine ( wxT( "\text:") + m_aExtensions.Item(index) );
+ }
+ else
+ {
+ if (delete_index)
+ {
+ outfile.CommentLine(nIndex);
+ outfile.CommentLine(nIndex+1);
+ }
+ else
+ {// check for next line being the right one to replace ??
+ wxString sOld = outfile.GetLine(nIndex+1);
+ if (sOld.Contains(wxT("\text: ")))
+ {
+ outfile.GetLine(nIndex+1) = wxT( "\text: ") + m_aExtensions.Item(index);
+ }
+ else
+ {
+ outfile.InsertLine(wxT( "\text: ") + m_aExtensions.Item(index), nIndex + 1 );
+ }
+ }
+ }
+ bool bTmp = outfile.Write ();
+ return bTmp;
+}
+void wxMimeTypesManagerImpl::LoadGnomeDataFromKeyFile(const wxString& filename)
+{
+ wxTextFile textfile(filename);
+ if ( !textfile.Open() )
+ return;
+ wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s ---"),
+ filename.c_str());
-// ----------------------------------------------------------------------------
-// various statics
-// ----------------------------------------------------------------------------
+ // values for the entry being parsed
+ wxString curMimeType, curIconFile;
+ wxMimeTypeCommands * entry = new wxMimeTypeCommands;
-static wxGNOMEIconHandler gs_iconHandlerGNOME;
-static wxKDEIconHandler gs_iconHandlerKDE;
+ // these are always empty in this file
+ wxArrayString strExtensions;
+ wxString strDesc;
-bool wxGNOMEIconHandler::m_inited = FALSE;
-wxSortedArrayString wxGNOMEIconHandler::ms_mimetypes;
-wxArrayString wxGNOMEIconHandler::ms_icons;
+ const wxChar *pc;
+ size_t nLineCount = textfile.GetLineCount();
+ size_t nLine = 0;
+ while ( nLine < nLineCount)
+ {
+ pc = textfile[nLine].c_str();
+ if ( *pc != _T('#') )
+ {
-bool wxKDEIconHandler::m_inited = FALSE;
-wxSortedArrayString wxKDEIconHandler::ms_mimetypes;
-wxArrayString wxKDEIconHandler::ms_icons;
+ wxLogTrace(TRACE_MIME, wxT("--- Reading from Gnome file %s '%s' ---"),
+ filename.c_str(),pc);
+
+ wxString sTmp(pc);
+ if (sTmp.Contains(wxT("=")) )
+ {
+ if (sTmp.Contains( wxT("icon-filename=") ) )
+ {
+ curIconFile = sTmp.AfterFirst(wxT('='));
+ }
+ else //: some other field,
+ {
+ //may contain lines like this (RH7)
+ // \t[lang]open.tex."TeX this file"=tex %f
+ // \tflags.tex.flags=needsterminal
+ // \topen.latex."LaTeX this file"=latex %f
+ // \tflags.latex.flags=needsterminal
+
+ // \topen=xdvi %f
+ // \tview=xdvi %f
+ // \topen.convert.Convert file to Postscript=dvips %f -o `basename %f .dvi`.ps
+
+ // for now ignore lines with flags in...FIX
+ sTmp = sTmp.AfterLast(wxT(']'));
+ sTmp = sTmp.AfterLast(wxT('\t'));
+ sTmp.Trim(FALSE).Trim();
+ if (0 == sTmp.Replace ( wxT("%f"), wxT("%s") )) sTmp = sTmp + wxT(" %s");
+ entry->Add(sTmp);
-wxArrayString wxKDEIconHandler::ms_infoTypes;
-wxArrayString wxKDEIconHandler::ms_infoDescriptions;
-wxArrayString wxKDEIconHandler::ms_infoExtensions;
+ }
+ } // emd of has an equals sign
+ else
+ {
+ // not a comment and not an equals sign
+ if (sTmp.Contains(wxT('/')))
+ {
+ // this is the start of the new mimetype
+ // overwrite any existing data
+ if (! curMimeType.empty())
+ {
+ AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
+
+ // now get ready for next bit
+ entry = new wxMimeTypeCommands;
+ }
+ curMimeType = sTmp.BeforeFirst(wxT(':'));
+ }
+ }
+ } // end of not a comment
+ // ignore blank lines
+ nLine ++;
+ } // end of while, save any data
+ if (! curMimeType.empty())
+ {
+ AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
+ }
-ArrayIconHandlers wxMimeTypesManagerImpl::ms_iconHandlers;
+}
-// ----------------------------------------------------------------------------
-// wxGNOMEIconHandler
-// ----------------------------------------------------------------------------
-// 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.
-void wxGNOMEIconHandler::LoadIconsFromKeyFile(const wxString& filename)
+void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& filename)
{
wxTextFile textfile(filename);
if ( !textfile.Open() )
return;
+ wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s ---"),
+ filename.c_str());
// values for the entry being parsed
- wxString curMimeType, curIconFile;
+ wxString curMimeType, curExtList;
const wxChar *pc;
size_t nLineCount = textfile.GetLineCount();
- for ( size_t nLine = 0; ; nLine++ )
+ for ( size_t nLine = 0;; nLine++ )
{
if ( nLine < nLineCount )
{
if ( !pc || !*pc )
{
// end of the entry
- if ( !!curMimeType && !!curIconFile )
+ if ( !!curMimeType && !!curExtList )
{
- // 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;
- }
+ wxLogTrace(TRACE_MIME, wxT("--- At end of Gnome file finding mimetype %s ---"),
+ curMimeType.c_str());
+
+ AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
}
if ( !pc )
break;
}
- curIconFile.Empty();
+ curExtList.Empty();
continue;
}
// this is a field=value ling
pc++; // skip leading TAB
- static const int lenField = 13; // strlen("icon-filename")
- if ( wxStrncmp(pc, _T("icon-filename"), lenField) == 0 )
+ static const int lenField = 4; // strlen("ext:")
+ if ( wxStrncmp(pc, _T("ext:"), lenField) == 0 )
{
- // skip '=' which follows and take everything left until the end
+ // skip ' ' which follows and take everything left until the end
// of line
- curIconFile = pc + lenField + 1;
+ curExtList = pc + lenField + 1;
}
//else: some other field, we don't care
}
else
{
// this is the start of the new section
+ wxLogTrace(TRACE_MIME, wxT("--- In Gnome file finding mimetype %s ---"),
+ curMimeType.c_str());
+
+ if (! curMimeType.empty())
+ AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
+
curMimeType.Empty();
while ( *pc != _T(':') && *pc != _T('\0') )
}
}
-void wxGNOMEIconHandler::LoadKeyFilesFromDir(const wxString& dirbase)
+
+void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(const wxString& dirbase)
{
wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
_T("base directory shouldn't end with a slash") );
dirname += _T('/');
wxString filename;
- bool cont = dir.GetFirst(&filename, _T("*.keys"), wxDIR_FILES);
+ bool cont = dir.GetFirst(&filename, _T("*.mime"), wxDIR_FILES);
+ while ( cont )
+ {
+ LoadGnomeMimeTypesFromMimeFile(dirname + filename);
+
+ cont = dir.GetNext(&filename);
+ }
+
+ cont = dir.GetFirst(&filename, _T("*.keys"), wxDIR_FILES);
while ( cont )
{
- LoadIconsFromKeyFile(dirname + filename);
+ LoadGnomeDataFromKeyFile(dirname + filename);
cont = dir.GetNext(&filename);
}
}
-void wxGNOMEIconHandler::LoadMimeTypesFromMimeFile(const wxString& filename, wxMimeTypesManagerImpl *manager)
+
+
+void wxMimeTypesManagerImpl::GetGnomeMimeInfo(const wxString& sExtraDir)
{
- wxTextFile textfile(filename);
- if ( !textfile.Open() )
- return;
- // values for the entry being parsed
- wxString curMimeType, curExtList;
+ wxArrayString dirs;
+ dirs.Add(_T("/usr/share"));
+ dirs.Add(_T("/usr/local/share"));
- const wxChar *pc;
- size_t nLineCount = textfile.GetLineCount();
- for ( size_t nLine = 0; ; nLine++ )
+ wxString gnomedir;
+ wxGetHomeDir( &gnomedir );
+ gnomedir += _T("/.gnome");
+ dirs.Add( gnomedir );
+ if (!sExtraDir.empty()) dirs.Add( sExtraDir );
+
+ size_t nDirs = dirs.GetCount();
+ for ( size_t nDir = 0; nDir < nDirs; nDir++ )
{
- if ( nLine < nLineCount )
- {
- pc = textfile[nLine].c_str();
- if ( *pc == _T('#') )
- {
- // skip comments
- continue;
- }
- }
- else
- {
- // so that we will fall into the "if" below
- pc = NULL;
- }
+ LoadGnomeMimeFilesFromDir(dirs[nDir]);
+ }
+}
- if ( !pc || !*pc )
- {
- // end of the entry
- if ( !!curMimeType && !!curExtList )
- {
- manager -> AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
- }
+// ----------------------------------------------------------------------------
+// KDE
+// ----------------------------------------------------------------------------
- if ( !pc )
- {
- // the end - this can only happen if nLine == nLineCount
- break;
- }
- curExtList.Empty();
+// 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"
- continue;
- }
+// kde writing; see http://webcvs.kde.org/cgi-bin/cvsweb.cgi/~checkout~/kdelibs/kio/DESKTOP_ENTRY_STANDARD
+// for now write to .kdelnk but should eventually do .desktop instead (in preference??)
- // what do we have here?
- if ( *pc == _T('\t') )
- {
- // this is a field=value ling
- pc++; // skip leading TAB
+bool wxMimeTypesManagerImpl::CheckKDEDirsExist ( const wxString & sOK, const wxString & sTest )
- 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
- }
- else
+ {
+ if (sTest.empty())
{
- // this is the start of the new section
- curMimeType.Empty();
-
- while ( *pc != _T(':') && *pc != _T('\0') )
- {
- curMimeType += *pc++;
- }
+ if (wxDir::Exists(sOK)) return TRUE;
+ else return FALSE;
}
+ else
+ {
+ wxString sStart = sOK + wxT("/") + sTest.BeforeFirst(wxT('/'));
+ if (!wxDir::Exists(sStart)) wxMkdir(sStart);
+ wxString sEnd = sTest.AfterFirst(wxT('/'));
+ return CheckKDEDirsExist(sStart, sEnd);
}
}
-
-void wxGNOMEIconHandler::LoadMimeFilesFromDir(const wxString& dirbase, wxMimeTypesManagerImpl *manager)
+bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index)
{
- wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
- _T("base directory shouldn't end with a slash") );
-
- wxString dirname = dirbase;
- dirname << _T("/mime-info");
-
- if ( !wxDir::Exists(dirname) )
- return;
-
- wxDir dir(dirname);
- if ( !dir.IsOpened() )
- return;
-
- // we will concatenate it with filename to get the full path below
- dirname += _T('/');
-
- wxString filename;
- bool cont = dir.GetFirst(&filename, _T("*.mime"), wxDIR_FILES);
- while ( cont )
+ wxMimeTextFile appoutfile, mimeoutfile;
+ wxString sHome = wxGetHomeDir();
+ wxString sTmp = wxT(".kde/share/mimelnk/");
+ wxString sMime = m_aTypes[index];
+ CheckKDEDirsExist (sHome, sTmp + sMime.BeforeFirst(wxT('/')) );
+ sTmp = sHome + wxT('/') + sTmp + sMime + wxT(".kdelnk");
+
+ bool bTemp;
+ bool bMimeExists = mimeoutfile.Open (sTmp);
+ if (!bMimeExists)
{
- LoadMimeTypesFromMimeFile(dirname + filename, manager);
-
- cont = dir.GetNext(&filename);
+ bTemp = mimeoutfile.Create (sTmp);
+ // some unknown error eg out of disk space
+ if (!bTemp) return FALSE;
}
-}
+ sTmp = wxT(".kde/share/applnk/");
+ CheckKDEDirsExist (sHome, sTmp + sMime.AfterFirst(wxT('/')) );
+ sTmp = sHome + wxT('/') + sTmp + sMime.AfterFirst(wxT('/')) + wxT(".kdelnk");
-void wxGNOMEIconHandler::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++ )
+ bool bAppExists;
+ bAppExists = appoutfile.Open (sTmp);
+ if (!bAppExists)
{
- LoadKeyFilesFromDir(dirs[nDir]);
+ bTemp = appoutfile.Create (sTmp);
+ // some unknown error eg out of disk space
+ if (!bTemp) return FALSE;
}
- m_inited = TRUE;
-}
-
-
-void wxGNOMEIconHandler::GetMimeInfoRecords(wxMimeTypesManagerImpl *manager)
-{
- if ( !m_inited )
+ // fixed data; write if new file
+ if (!bMimeExists)
{
- Init();
+ mimeoutfile.AddLine(wxT("#KDE Config File"));
+ mimeoutfile.AddLine(wxT("[KDE Desktop Entry]"));
+ mimeoutfile.AddLine(wxT("Version=1.0"));
+ mimeoutfile.AddLine(wxT("Type=MimeType"));
+ mimeoutfile.AddLine(wxT("MimeType=") + sMime);
}
-
- 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++ )
+ if (!bAppExists)
{
- LoadMimeFilesFromDir(dirs[nDir], manager);
+ mimeoutfile.AddLine(wxT("#KDE Config File"));
+ mimeoutfile.AddLine(wxT("[KDE Desktop Entry]"));
+ appoutfile.AddLine(wxT("Version=1.0"));
+ appoutfile.AddLine(wxT("Type=Application"));
+ appoutfile.AddLine(wxT("MimeType=") + sMime + wxT(';'));
}
-}
-#if wxUSE_GUI
- #define WXUNUSED_UNLESS_GUI(p) p
-#else
- #define WXUNUSED_UNLESS_GUI(p)
-#endif
-
-bool wxGNOMEIconHandler::GetIcon(const wxString& mimetype,
- wxIcon * WXUNUSED_UNLESS_GUI(icon))
-{
- if ( !m_inited )
+ // variable data
+ // ignore locale
+ mimeoutfile.CommentLine(wxT("Comment="));
+ if (!delete_index)
+ mimeoutfile.AddLine(wxT("Comment=") + m_aDescriptions[index]);
+ appoutfile.CommentLine(wxT("Name="));
+ if (!delete_index)
+ appoutfile.AddLine(wxT("Comment=") + m_aDescriptions[index]);
+
+ sTmp = m_aIcons[index];
+ // we can either give the full path, or the shortfilename if its in
+ // one of the directories we search
+ mimeoutfile.CommentLine(wxT("Icon=") );
+ if (!delete_index) mimeoutfile.AddLine(wxT("Icon=") + sTmp );
+ appoutfile.CommentLine(wxT("Icon=") );
+ if (!delete_index) appoutfile.AddLine(wxT("Icon=") + sTmp );
+
+ sTmp = wxT(" ") + m_aExtensions[index];
+
+ wxStringTokenizer tokenizer(sTmp, _T(" "));
+ sTmp = wxT("Patterns=");
+ mimeoutfile.CommentLine(sTmp);
+ while ( tokenizer.HasMoreTokens() )
{
- Init();
+ // holds an extension; need to change it to *.ext;
+ wxString e = wxT("*.") + tokenizer.GetNextToken() + wxT(";");
+ sTmp = sTmp + e;
}
+ if (!delete_index) mimeoutfile.AddLine(sTmp);
- int index = ms_mimetypes.Index(mimetype);
- if ( index == wxNOT_FOUND )
- return FALSE;
+ wxMimeTypeCommands * entries = m_aEntries[index];
+ // if we don't find open just have an empty string ... FIX this
+ sTmp = entries->GetCommandForVerb(_T("open"));
+ sTmp.Replace( wxT("%s"), wxT("%f") );
- wxString iconname = ms_icons[(size_t)index];
+ mimeoutfile.CommentLine(wxT("DefaultApp=") );
+ if (!delete_index) mimeoutfile.AddLine(wxT("DefaultApp=") + sTmp);
-#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;
+ sTmp.Replace( wxT("%f"), wxT("") );
+ appoutfile.CommentLine(wxT("Exec="));
+ if (!delete_index) appoutfile.AddLine(wxT("Exec=") + sTmp);
- if ( icon )
- *icon = icn;
-#else
- // helpful for testing in console mode
- wxLogDebug(_T("Found GNOME icon for '%s': '%s'\n"),
- mimetype.c_str(), iconname.c_str());
-#endif
+ if (entries->GetCount() > 1)
+ {
+ //other actions as well as open
- return TRUE;
-}
+ }
+ bTemp = FALSE;
+ if (mimeoutfile.Write ()) bTemp = TRUE;
+ mimeoutfile.Close ();
+ if (appoutfile.Write ()) bTemp = TRUE;
+ appoutfile.Close ();
-// ----------------------------------------------------------------------------
-// wxKDEIconHandler
-// ----------------------------------------------------------------------------
+ return bTemp;
-// 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,
+}
+
+void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(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('.'));
+ wxMimeTextFile file;
+ if ( !file.Open(dirbase + filename) ) return;
- // these files are small, slurp the entire file at once
- wxString text;
- if ( !file.ReadAll(&text) )
- return;
+ wxMimeTypeCommands * entry = new wxMimeTypeCommands;
+ wxArrayString sExts;
+ wxString mimetype, mime_desc, strIcon;
- int pos;
- const wxChar *pc;
+ int nIndex = file.pIndexOf ("MimeType=");
+ if (nIndex == wxNOT_FOUND)
+ {
+ // construct mimetype from the directory name and the basename of the
+ // file (it always has .kdelnk extension)
+ mimetype << subdir << _T('/') << filename.BeforeLast(_T('.'));
+ }
+ else mimetype = file.GetCmd (nIndex);
- // before trying to find an icon, grab mimetype information
- // (because BFU's machine would hardly have well-edited mime.types but (s)he might
- // have edited it in control panel...)
+ // first find the description string: it is the value in either "Comment="
+ // line or "Comment[<locale_name>]=" one
+ nIndex = wxNOT_FOUND;
- wxString mime_extension, mime_desc;
+ wxString comment;
+#if wxUSE_INTL
+ wxLocale *locale = wxGetLocale();
+ if ( locale )
+ {
+ // try "Comment[locale name]" first
+ comment << _T("Comment[") + locale->GetName() + _T("]=");
+ nIndex = file.pIndexOf(comment);
+ }
+#endif // wxUSE_INTL
- pos = wxNOT_FOUND;
- if (wxGetLocale() != NULL)
- mime_desc = _T("Comment[") + wxGetLocale()->GetName() + _T("]=");
- if (pos == wxNOT_FOUND) mime_desc = _T("Comment=");
- pos = text.Find(mime_desc);
- if (pos == wxNOT_FOUND) mime_desc = wxEmptyString;
- else
+ if ( nIndex == wxNOT_FOUND )
{
- pc = text.c_str() + pos + mime_desc.Length();
- mime_desc = wxEmptyString;
- while ( *pc && *pc != _T('\n') ) mime_desc += *pc++;
+ comment = _T("Comment=");
+ nIndex = file.pIndexOf(comment);
}
- pos = text.Find(_T("Patterns="));
- if (pos != wxNOT_FOUND)
+ if ( nIndex != wxNOT_FOUND ) mime_desc = file.GetCmd(nIndex);
+ //else: no description
+
+ // next find the extensions
+ wxString mime_extension;
+
+ nIndex = file.pIndexOf(_T("Patterns="));
+ if ( nIndex != wxNOT_FOUND )
{
- wxString exts;
- pc = text.c_str() + pos + 9;
- while ( *pc && *pc != _T('\n') ) exts += *pc++;
- wxStringTokenizer tokenizer(exts, _T(";"));
- wxString e;
+ wxString exts = file.GetCmd (nIndex);;
- while (tokenizer.HasMoreTokens())
+ wxStringTokenizer tokenizer(exts, _T(";"));
+ while ( tokenizer.HasMoreTokens() )
{
- e = tokenizer.GetNextToken();
- if (e.Left(2) != _T("*.")) continue; // don't support too difficult patterns
+ wxString e = tokenizer.GetNextToken();
+ if ( e.Left(2) != _T("*.") )
+ continue; // don't support too difficult patterns
+
+ if ( !mime_extension.empty() )
+ {
+ // separate from the previous ext
+ mime_extension << _T(' ');
+ }
+
mime_extension << e.Mid(2);
- mime_extension << _T(' ');
}
- mime_extension.RemoveLast();
}
+ sExts.Add(mime_extension);
- ms_infoTypes.Add(mimetype);
- ms_infoDescriptions.Add(mime_desc);
- ms_infoExtensions.Add(mime_extension);
// ok, now we can take care of icon:
- pos = text.Find(_T("Icon="));
- if ( pos == wxNOT_FOUND )
+ nIndex = file.pIndexOf(_T("Icon="));
+ if ( nIndex != wxNOT_FOUND )
{
- // no icon info
- return;
+ strIcon = file.GetCmd(nIndex);
+ //it could be the real path, but more often a short name
+ if (!wxFileExists(strIcon))
+ {
+ // icon is just the short name
+ if ( !strIcon.empty() )
+ {
+ // 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] + strIcon))
+ {
+ strIcon.Prepend(icondirs[nDir]);
+ break;
+ }
+ }
+ }
}
+ // now look for lines which know about the application
+ // exec= or DefaultApp=
- wxString icon;
+ nIndex = file.pIndexOf(wxT("DefaultApp"));
- pc = text.c_str() + pos + 5; // 5 == strlen("Icon=")
- while ( *pc && *pc != _T('\n') )
+ if ( nIndex == wxNOT_FOUND )
{
- icon += *pc++;
+ // no entry try exec
+ nIndex = file.pIndexOf(wxT("Exec"));
}
- if ( !!icon )
+ if ( nIndex != wxNOT_FOUND )
{
- // 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;
- }
- 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;
- }
+ wxString sTmp = file.GetCmd(nIndex);
+ // we expect %f; others including %F and %U and %u are possible
+ if (0 == sTmp.Replace ( wxT("%f"), wxT("%s") ))
+ sTmp = sTmp + wxT(" %s");
+ entry->AddOrReplaceVerb (wxString(wxT("open")), sTmp );
}
+
+ AddToMimeData (mimetype, strIcon, entry, sExts, mime_desc);
}
-void wxKDEIconHandler::LoadLinksForMimeType(const wxString& dirbase,
+void wxMimeTypesManagerImpl::LoadKDELinksForMimeType(const wxString& dirbase,
const wxString& subdir,
const wxArrayString& icondirs)
{
bool cont = dir.GetFirst(&filename, _T("*.kdelnk"), wxDIR_FILES);
while ( cont )
{
- LoadLinksForMimeSubtype(dirname, subdir, filename, icondirs);
+ LoadKDELinksForMimeSubtype(dirname, subdir, filename, icondirs);
+
+ cont = dir.GetNext(&filename);
+ }
+ // new standard for Gnome and KDE
+ cont = dir.GetFirst(&filename, _T("*.desktop"), wxDIR_FILES);
+ while ( cont )
+ {
+ LoadKDELinksForMimeSubtype(dirname, subdir, filename, icondirs);
cont = dir.GetNext(&filename);
}
}
-void wxKDEIconHandler::LoadLinkFilesFromDir(const wxString& dirbase,
+void wxMimeTypesManagerImpl::LoadKDELinkFilesFromDir(const wxString& dirbase,
const wxArrayString& icondirs)
{
wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
bool cont = dir.GetFirst(&subdir, wxEmptyString, wxDIR_DIRS);
while ( cont )
{
- LoadLinksForMimeType(dirname, subdir, icondirs);
+ LoadKDELinksForMimeType(dirname, subdir, icondirs);
cont = dir.GetNext(&subdir);
}
}
-void wxKDEIconHandler::Init()
+void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)
{
wxArrayString dirs;
wxArrayString icondirs;
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/"));
}
+ if (!sExtraDir.empty()) dirs.Add (sExtraDir);
+ icondirs.Add(sExtraDir + wxT("/icons"));
+
size_t nDirs = dirs.GetCount();
for ( size_t nDir = 0; nDir < nDirs; nDir++ )
{
- LoadLinkFilesFromDir(dirs[nDir], icondirs);
+ LoadKDELinkFilesFromDir(dirs[nDir], icondirs);
}
-
- m_inited = TRUE;
}
-bool wxKDEIconHandler::GetIcon(const wxString& mimetype,
- wxIcon * WXUNUSED_UNLESS_GUI(icon))
+// ----------------------------------------------------------------------------
+// wxFileTypeImpl (Unix)
+// ----------------------------------------------------------------------------
+
+wxString wxFileTypeImpl::GetExpandedCommand(const wxString & verb, const wxFileType::MessageParameters& params) const
{
- if ( !m_inited )
+ wxString sTmp;
+ size_t i = 0;
+ while ( (i < m_index.GetCount() ) && sTmp.empty() )
{
- Init();
+ sTmp = m_manager->GetCommand ( verb, m_index[i] );
+ i ++;
}
- int index = ms_mimetypes.Index(mimetype);
- if ( index == wxNOT_FOUND )
- return FALSE;
+ return wxFileType::ExpandCommand(sTmp, params);
+}
- wxString iconname = ms_icons[(size_t)index];
+bool wxFileTypeImpl::GetIcon(wxIcon *icon,
+ wxString *iconFile /*= NULL */,
+ int *iconIndex /*= NULL*/) const
+{
#if wxUSE_GUI
- wxLogNull nolog;
+ 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;
+
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 (sTmp.Right(4).MakeUpper() == _T(".XPM"))
+ icn = wxIcon(sTmp);
+ else
+ icn = wxIcon(sTmp, wxBITMAP_TYPE_ANY);
- if ( icon )
+ if ( icn.Ok() )
+ {
*icon = icn;
-#else
- // helpful for testing in console mode
- wxLogDebug(_T("Found KDE icon for '%s': '%s'\n"),
- mimetype.c_str(), iconname.c_str());
-#endif
+ if (iconFile) *iconFile = sTmp;
+ if (iconIndex) *iconIndex = 0;
+ return TRUE;
+ }
+#endif // wxUSE_GUI
+ 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;
}
-void wxKDEIconHandler::GetMimeInfoRecords(wxMimeTypesManagerImpl *manager)
+size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
+ wxArrayString *commands,
+ const wxFileType::MessageParameters& params) const
{
- 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]);
-}
+ wxString vrb, cmd, sTmp;
+ size_t count = 0;
+ wxMimeTypeCommands * sPairs;
+ // 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++)
+ {
+ // 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++ )
+ {
+ vrb = sPairs->GetVerb(i);
+ // some gnome entries have . inside
+ vrb = vrb.AfterLast(wxT('.'));
+ cmd = sPairs->GetCmd (i);
+ if (! cmd.empty() )
+ {
+ cmd = wxFileType::ExpandCommand(cmd, params);
+ count ++;
+ if ( vrb.IsSameAs (wxT("open")))
+ {
+ verbs->Insert(vrb,0u);
+ commands ->Insert(cmd,0u);
+ }
+ else
+ {
+ verbs->Add (vrb);
+ commands->Add (cmd);
+ }
+ }
-// ----------------------------------------------------------------------------
-// wxFileTypeImpl (Unix)
-// ----------------------------------------------------------------------------
+ }
+
+ }
+ return count;
-MailCapEntry *
-wxFileTypeImpl::GetEntry(const wxFileType::MessageParameters& params) const
+}
+
+bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
{
- wxString command;
- MailCapEntry *entry = m_manager->m_aEntries[m_index[0]];
- while ( entry != NULL ) {
- // notice that an empty command would always succeed (it's ok)
- command = wxFileType::ExpandCommand(entry->GetTestCmd(), params);
-
- if ( command.IsEmpty() || (wxSystem(command) == 0) ) {
- // ok, passed
- wxLogTrace(wxT("Test '%s' for mime type '%s' succeeded."),
- command.c_str(), params.GetMimeType().c_str());
- break;
+ 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.empty() ) {
+ 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.empty() ) {
+ strExt += wxT('.');
+ }
+ //else: no, don't append it
}
else {
- wxLogTrace(wxT("Test '%s' for mime type '%s' failed."),
- command.c_str(), params.GetMimeType().c_str());
+ strExt += *p;
}
+ }
- entry = entry->GetNext();
+ 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 overwriteprompt /*= TRUE*/)
+{
+ wxArrayString strExtensions;
+ wxString strDesc, strIcon;
+
+ wxMimeTypeCommands *entry = new wxMimeTypeCommands ();
+ entry->Add(verb + wxT("=") + cmd + wxT(" %s "));
+
+ wxArrayString strTypes;
+ GetMimeTypes (strTypes);
+ if (strTypes.GetCount() < 1) return FALSE;
+
+ size_t i;
+ bool Ok = TRUE;
+ for (i = 0; i < strTypes.GetCount(); i++)
+ {
+ if (!m_manager->DoAssociation (strTypes[i], strIcon, entry, strExtensions, strDesc))
+ Ok = FALSE;
}
- return entry;
+ return Ok;
}
-bool wxFileTypeImpl::GetIcon(wxIcon *icon) const
+// ignore index on the grouds that we only have one icon in a Unix file
+bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon /*= wxEmptyString*/, int /*index = 0*/)
{
- wxArrayString mimetypes;
- GetMimeTypes(mimetypes);
+ if (strIcon.empty()) return FALSE;
+ wxArrayString strExtensions;
+ wxString strDesc;
- ArrayIconHandlers& handlers = m_manager->GetIconHandlers();
- size_t count = handlers.GetCount();
- size_t counttypes = mimetypes.GetCount();
- for ( size_t n = 0; n < count; n++ )
+ wxMimeTypeCommands *entry = new wxMimeTypeCommands ();
+
+ wxArrayString strTypes;
+ GetMimeTypes (strTypes);
+ if (strTypes.GetCount() < 1) return FALSE;
+
+ size_t i;
+ bool Ok = TRUE;
+ for (i = 0; i < strTypes.GetCount(); i++)
{
- for ( size_t n2 = 0; n2 < counttypes; n2++ )
- {
- if ( handlers[n]->GetIcon(mimetypes[n2], icon) )
- return TRUE;
+ if (!m_manager->DoAssociation (strTypes[i], strIcon, entry, strExtensions, strDesc))
+ Ok = FALSE;
+ }
+
+ return Ok;
+}
+
+// ----------------------------------------------------------------------------
+// wxMimeTypesManagerImpl (Unix)
+// ----------------------------------------------------------------------------
+
+
+wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
+{
+ m_initialized = FALSE;
+ m_mailcapStylesInited = 0;
+}
+
+// read system and user mailcaps and other files
+void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
+ const wxString& sExtraDir)
+{
+ // read mimecap amd mime.types
+ if ( (mailcapStyles & wxMAILCAP_NETSCAPE) ||
+ (mailcapStyles & wxMAILCAP_STANDARD) )
+ GetMimeInfo(sExtraDir);
+
+ // read GNOME tables
+ if ( mailcapStyles & wxMAILCAP_GNOME)
+ GetGnomeMimeInfo(sExtraDir);
+
+ // read KDE tables
+ if ( mailcapStyles & wxMAILCAP_KDE)
+ GetKDEMimeInfo(sExtraDir);
+
+ m_mailcapStylesInited |= mailcapStyles;
+}
+
+// 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 ();
+
+ m_aEntries.Empty();
+
+ m_mailcapStylesInited = 0;
+}
+
+wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl()
+{
+ ClearData();
+
+ WX_CLEAR_ARRAY(m_aEntries);
+}
+
+
+void wxMimeTypesManagerImpl::GetMimeInfo (const wxString& sExtraDir)
+{
+ // read this for netscape or Metamail formats
+
+ // directories where we look for mailcap and mime.types by default
+ // used by netscape and pine and other mailers, using 2 different formats!
+
+ // (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?)
+
+ wxString strHome = wxGetenv(wxT("HOME"));
+
+ wxArrayString dirs;
+ dirs.Add ( strHome + wxT("/.") );
+ dirs.Add ( wxT("/etc/") );
+ dirs.Add ( wxT("/usr/etc/") );
+ dirs.Add ( wxT("/usr/local/etc/") );
+ dirs.Add ( wxT("/etc/mail/") );
+ dirs.Add ( wxT("/usr/public/lib/") );
+ if (!sExtraDir.empty()) dirs.Add ( sExtraDir + wxT("/") );
+
+ size_t nDirs = dirs.GetCount();
+ for ( size_t nDir = 0; nDir < nDirs; nDir++ )
+ {
+ wxString file = dirs[nDir] + wxT("mailcap");
+ if ( wxFile::Exists(file) ) {
+ ReadMailcap(file);
+ }
+
+ file = dirs[nDir] + wxT("mime.types");
+ if ( wxFile::Exists(file) ) {
+ ReadMimeTypes(file);
}
}
- return FALSE;
}
+bool wxMimeTypesManagerImpl::WriteToMimeTypes (int index, bool delete_index)
+{
+ // check we have the right manager
+ if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD) )
+ return FALSE;
-bool
-wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
+ bool bTemp;
+ wxString strHome = wxGetenv(wxT("HOME"));
+
+ // and now the users mailcap
+ wxString strUserMailcap = strHome + wxT("/.mime.types");
+
+ wxMimeTextFile file;
+ if ( wxFile::Exists(strUserMailcap) )
+ {
+ bTemp = file.Open(strUserMailcap);
+ }
+ else
+ {
+ if (delete_index) return FALSE;
+ bTemp = file.Create(strUserMailcap);
+ }
+ if (bTemp)
+ {
+ int nIndex;
+ // test for netscape's header and return FALSE if its found
+ nIndex = file.pIndexOf (wxT("#--Netscape"));
+ if (nIndex != wxNOT_FOUND)
+ {
+ wxASSERT_MSG(FALSE,wxT("Error in .mime.types \nTrying to mix Netscape and Metamail formats\nFile not modiifed"));
+ return FALSE;
+ }
+ // write it in alternative format
+ // get rid of unwanted entries
+ wxString strType = m_aTypes[index];
+ nIndex = file.pIndexOf (strType);
+ // get rid of all the unwanted entries...
+ if (nIndex != wxNOT_FOUND) file.CommentLine (nIndex);
+
+ if (!delete_index)
+ {
+ // add the new entries in
+ wxString sTmp = strType.Append (wxT(' '), 40-strType.Len() );
+ sTmp = sTmp + m_aExtensions[index];
+ file.AddLine (sTmp);
+ }
+
+
+ bTemp = file.Write ();
+ file.Close ();
+ }
+ return bTemp;
+}
+
+bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
{
- mimeTypes.Clear();
- for (size_t i = 0; i < m_index.GetCount(); i++)
- mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);
- return TRUE;
+ //check we have the right managers
+ if (! ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) )
+ return FALSE;
+
+ bool bTemp;
+ wxString strHome = wxGetenv(wxT("HOME"));
+
+ // and now the users mailcap
+ wxString strUserMailcap = strHome + wxT("/.mime.types");
+
+ wxMimeTextFile file;
+ if ( wxFile::Exists(strUserMailcap) )
+ {
+ bTemp = file.Open(strUserMailcap);
+ }
+ else
+ {
+ if (delete_index) return FALSE;
+ bTemp = file.Create(strUserMailcap);
+ }
+ if (bTemp)
+ {
+
+ // write it in the format that Netscape uses
+ int nIndex;
+ // test for netscape's header and insert if required...
+ // this is a comment so use TRUE
+ nIndex = file.pIndexOf (wxT("#--Netscape"), TRUE);
+ if (nIndex == wxNOT_FOUND)
+ {
+ // either empty file or metamail format
+ // at present we can't cope with mixed formats, so exit to preseve
+ // metamail entreies
+ if (file.GetLineCount () > 0)
+ {
+ wxASSERT_MSG(FALSE, wxT(".mime.types File not in Netscape format\nNo entries written to\n.mime.types or to .mailcap"));
+ return FALSE;
+ }
+ file.InsertLine (wxT( "#--Netscape Communications Corporation MIME Information" ), 0);
+ nIndex = 0;
+ }
+
+ wxString strType = wxT("type=") + m_aTypes[index];
+ nIndex = file.pIndexOf (strType);
+ // get rid of all the unwanted entries...
+ if (nIndex != wxNOT_FOUND)
+ {
+ wxString sOld = file[nIndex];
+ while ( (sOld.Contains(wxT("\\"))) && (nIndex < (int) file.GetLineCount()) )
+ {
+ file.CommentLine(nIndex);
+ sOld = file[nIndex];
+ wxLogTrace(TRACE_MIME, wxT("--- Deleting from mime.types line '%d %s' ---"), nIndex, sOld.c_str());
+ nIndex ++;
+ }
+ if (nIndex < (int) file.GetLineCount()) file.CommentLine (nIndex);
+ }
+ else nIndex = (int) file.GetLineCount();
+
+ wxString sTmp = strType + wxT(" \\");
+ if (!delete_index) file.InsertLine (sTmp, nIndex);
+ if ( ! m_aDescriptions.Item(index).empty() )
+ {
+ sTmp = wxT("desc=\"") + m_aDescriptions[index]+ wxT("\" \\"); //.trim ??
+ if (!delete_index)
+ {
+ nIndex ++;
+ file.InsertLine (sTmp, nIndex);
+ }
+ }
+ wxString sExts = m_aExtensions.Item(index);
+ sTmp = wxT("exts=\"") + sExts.Trim(FALSE).Trim() + wxT("\"");
+ if (!delete_index)
+ {
+ nIndex ++;
+ file.InsertLine (sTmp, nIndex);
+ }
+
+ bTemp = file.Write ();
+ file.Close ();
+ }
+ return bTemp;
}
-bool
-wxFileTypeImpl::GetExpandedCommand(wxString *expandedCmd,
- const wxFileType::MessageParameters& params,
- bool open) const
+bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
{
- MailCapEntry *entry = GetEntry(params);
- if ( entry == NULL ) {
- // all tests failed...
+ //check we have the right managers
+ if ( !( ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) ||
+ ( m_mailcapStylesInited & wxMAILCAP_STANDARD) ) )
return FALSE;
+
+ bool bTemp;
+ wxString strHome = wxGetenv(wxT("HOME"));
+
+ // and now the users mailcap
+ wxString strUserMailcap = strHome + wxT("/.mailcap");
+
+ wxMimeTextFile file;
+ if ( wxFile::Exists(strUserMailcap) )
+ {
+ bTemp = file.Open(strUserMailcap);
+ }
+ else
+ {
+ if (delete_index) return FALSE;
+ bTemp = file.Create(strUserMailcap);
+ }
+ if (bTemp)
+ {
+ // now got a file we can write to ....
+ wxMimeTypeCommands * entries = m_aEntries[index];
+ size_t iOpen;
+ wxString sCmd = entries->GetCommandForVerb(_T("open"), &iOpen);
+ wxString sTmp;
+
+ sTmp = m_aTypes[index];
+ wxString sOld;
+ int nIndex = file.pIndexOf(sTmp);
+ // get rid of all the unwanted entries...
+ if (nIndex == wxNOT_FOUND)
+ {
+ nIndex = (int) file.GetLineCount();
+ }
+ else
+ {
+ sOld = file[nIndex];
+ wxLogTrace(TRACE_MIME, wxT("--- Deleting from mailcap line '%d' ---"), nIndex);
+
+ while ( (sOld.Contains(wxT("\\"))) && (nIndex < (int) file.GetLineCount()) )
+ {
+ file.CommentLine(nIndex);
+ if (nIndex < (int) file.GetLineCount()) sOld = sOld + file[nIndex];
+ }
+ if (nIndex < (int) file.GetLineCount()) file.CommentLine (nIndex);
+ }
+
+ sTmp = sTmp + wxT(";") + sCmd; //includes wxT(" %s ");
+
+ // write it in the format that Netscape uses (default)
+ if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD ) )
+ {
+ if (! delete_index) file.InsertLine (sTmp, nIndex);
+ nIndex ++;
+ }
+
+ // write extended format
+ else
+ {
+ // todo FIX this code;
+ // ii) lost entries
+ // sOld holds all the entries, but our data store only has some
+ // eg test= is not stored
+
+ // so far we have written the mimetype and command out
+ wxStringTokenizer sT (sOld, wxT(";\\"));
+ if (sT.CountTokens () > 2)
+ {
+ // first one mimetype; second one command, rest unknown...
+ wxString s;
+ s = sT.GetNextToken();
+ s = sT.GetNextToken();
+
+ // first unknown
+ s = sT.GetNextToken();
+ while ( ! s.empty() )
+ {
+ bool bKnownToken = FALSE;
+ if (s.Contains(wxT("description="))) bKnownToken = TRUE;
+ if (s.Contains(wxT("x11-bitmap="))) bKnownToken = TRUE;
+ size_t i;
+ for (i=0; i < entries->GetCount(); i++)
+ {
+ if (s.Contains(entries->GetVerb(i))) bKnownToken = TRUE;
+ }
+ if (!bKnownToken)
+ {
+ sTmp = sTmp + wxT("; \\");
+ file.InsertLine (sTmp, nIndex);
+ sTmp = s;
+ }
+ s = sT.GetNextToken ();
+ }
+
+ }
+
+ if (! m_aDescriptions[index].empty() )
+ {
+ sTmp = sTmp + wxT("; \\");
+ file.InsertLine (sTmp, nIndex);
+ nIndex ++;
+ sTmp = wxT(" description=\"") + m_aDescriptions[index] + wxT("\"");
+ }
+
+ if (! m_aIcons[index].empty() )
+ {
+ sTmp = sTmp + wxT("; \\");
+ file.InsertLine (sTmp, nIndex);
+ nIndex ++;
+ sTmp = wxT(" x11-bitmap=\"") + m_aIcons[index] + wxT("\"");
+ }
+ if ( entries->GetCount() > 1 )
+
+ {
+ size_t i;
+ for (i=0; i < entries->GetCount(); i++)
+ if ( i != iOpen )
+ {
+ sTmp = sTmp + wxT("; \\");
+ file.InsertLine (sTmp, nIndex);
+ nIndex ++;
+ sTmp = wxT(" ") + entries->GetVerbCmd(i);
+ }
+ }
+
+ file.InsertLine (sTmp, nIndex);
+ nIndex ++;
+
+ }
+ bTemp = file.Write ();
+ file.Close ();
+ }
+ return bTemp;
+}
+
+wxFileType *
+wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
+{
+ InitIfNeeded();
+
+ wxString strType = ftInfo.GetMimeType ();
+ wxString strDesc = ftInfo.GetDescription ();
+ wxString strIcon = ftInfo.GetIconFile ();
+
+ wxMimeTypeCommands *entry = new wxMimeTypeCommands ();
+
+ if ( ! ftInfo.GetOpenCommand().empty())
+ entry->Add(wxT("open=") + ftInfo.GetOpenCommand () + wxT(" %s "));
+ if ( ! ftInfo.GetPrintCommand ().empty())
+ entry->Add(wxT("print=") + ftInfo.GetPrintCommand () + wxT(" %s "));
+
+ // 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;
+ for (i=0; i < sA_Exts.GetCount(); i++)
+ {
+ sExt = sA_Exts.Item(i);
+ //clean up to just a space before and after
+ sExt.Trim().Trim(FALSE);
+ sExt = wxT(' ') + sExt + wxT(' ');
+ for (nIndex = 0; nIndex < m_aExtensions.GetCount(); nIndex ++)
+ {
+ sExtStore = m_aExtensions.Item(nIndex);
+ if (sExtStore.Replace(sExt, wxT(" ") ) > 0) m_aExtensions.Item(nIndex) = sExtStore;
}
- wxString cmd = open ? entry->GetOpenCmd() : entry->GetPrintCmd();
- if ( cmd.IsEmpty() ) {
- // may happen, especially for "print"
+ }
+
+ if ( !DoAssociation (strType, strIcon, entry, sA_Exts, strDesc) )
+ return NULL;
+
+ return GetFileTypeFromMimeType(strType);
+}
+
+
+bool wxMimeTypesManagerImpl::DoAssociation(const wxString& strType,
+ const wxString& strIcon,
+ wxMimeTypeCommands *entry,
+ const wxArrayString& strExtensions,
+ const wxString& strDesc)
+{
+ int nIndex = AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, TRUE);
+
+ if ( nIndex == wxNOT_FOUND )
return FALSE;
- }
- *expandedCmd = wxFileType::ExpandCommand(cmd, params);
- return TRUE;
+ return WriteMimeInfo (nIndex, FALSE);
}
-bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
+bool wxMimeTypesManagerImpl::WriteMimeInfo(int nIndex, bool delete_mime )
{
- 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)
+ bool ok = TRUE;
- 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;
- }
+ if ( m_mailcapStylesInited & wxMAILCAP_STANDARD )
+ {
+ // write in metamail format;
+ if (WriteToMimeTypes (nIndex, delete_mime) )
+ if ( WriteToMailCap (nIndex, delete_mime) )
+ ok = FALSE;
+ }
+ if ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE )
+ {
+ // write in netsacpe format;
+ if (WriteToNSMimeTypes (nIndex, delete_mime) )
+ if ( WriteToMailCap (nIndex, delete_mime) )
+ ok = FALSE;
+ }
+ if (m_mailcapStylesInited & wxMAILCAP_GNOME)
+ {
+ // write in Gnome format;
+ if (WriteGnomeMimeFile (nIndex, delete_mime) )
+ if (WriteGnomeKeyFile (nIndex, delete_mime) )
+ ok = FALSE;
+ }
+ if (m_mailcapStylesInited & wxMAILCAP_KDE)
+ {
+ // write in KDE format;
+ if (WriteKDEMimeFile (nIndex, delete_mime) )
+ ok = FALSE;
}
- return TRUE;
+ return ok;
}
-// ----------------------------------------------------------------------------
-// wxMimeTypesManagerImpl (Unix)
-// ----------------------------------------------------------------------------
-
-/* static */
-ArrayIconHandlers& wxMimeTypesManagerImpl::GetIconHandlers()
+int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType,
+ const wxString& strIcon,
+ wxMimeTypeCommands *entry,
+ const wxArrayString& strExtensions,
+ const wxString& strDesc,
+ bool replaceExisting)
{
- if ( ms_iconHandlers.GetCount() == 0 )
+ InitIfNeeded();
+
+ // ensure mimetype is always lower case
+ wxString mimeType = strType.Lower();
+
+ // is this a known MIME type?
+ int nIndex = m_aTypes.Index(mimeType);
+ if ( nIndex == wxNOT_FOUND )
{
- ms_iconHandlers.Add(&gs_iconHandlerGNOME);
- ms_iconHandlers.Add(&gs_iconHandlerKDE);
- }
+ // new file type
+ m_aTypes.Add(mimeType);
+ m_aIcons.Add(strIcon);
+ m_aEntries.Add(entry ? entry : new wxMimeTypeCommands);
- return ms_iconHandlers;
-}
+ // change nIndex so we can use it below to add the extensions
+ nIndex = m_aExtensions.Add(wxEmptyString);
-// read system and user mailcaps (TODO implement mime.types support)
-wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
-{
- // directories where we look for mailcap and mime.types by default
- // (taken from metamail(1) sources)
- static const wxChar *aStandardLocations[] =
+ m_aDescriptions.Add(strDesc);
+ }
+ else // yes, we already have it
{
- wxT("/etc"),
- wxT("/usr/etc"),
- wxT("/usr/local/etc"),
- wxT("/etc/mail"),
- wxT("/usr/public/lib")
- };
+ if ( replaceExisting )
+ {
+ // if new description change it
+ if ( !strDesc.empty())
+ m_aDescriptions[nIndex] = strDesc;
- // first read the system wide file(s)
- size_t n;
- for ( n = 0; n < WXSIZEOF(aStandardLocations); n++ ) {
- wxString dir = aStandardLocations[n];
+ // if new icon change it
+ if ( !strIcon.empty())
+ m_aIcons[nIndex] = strIcon;
- wxString file = dir + wxT("/mailcap");
- if ( wxFile::Exists(file) ) {
- ReadMailcap(file);
+ if ( entry )
+ {
+ delete m_aEntries[nIndex];
+ m_aEntries[nIndex] = entry;
+ }
}
+ else // add data we don't already have ...
+ {
+ // if new description add only if none
+ if ( m_aDescriptions[nIndex].empty() )
+ m_aDescriptions[nIndex] = strDesc;
- file = dir + wxT("/mime.types");
- if ( wxFile::Exists(file) ) {
- ReadMimeTypes(file);
+ // if new icon and no existing icon
+ if ( m_aIcons[nIndex].empty () )
+ m_aIcons[nIndex] = strIcon;
+
+ // add any new entries...
+ if ( entry )
+ {
+ wxMimeTypeCommands *entryOld = m_aEntries[nIndex];
+
+ 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));
+ }
+ }
+ }
}
}
- wxString strHome = wxGetenv(wxT("HOME"));
+ // always add the extensions to this mimetype
+ wxString& exts = m_aExtensions[nIndex];
- // and now the users mailcap
- wxString strUserMailcap = strHome + wxT("/.mailcap");
- if ( wxFile::Exists(strUserMailcap) ) {
- ReadMailcap(strUserMailcap);
- }
+ // add all extensions we don't have yet
+ size_t count = strExtensions.GetCount();
+ for ( size_t i = 0; i < count; i++ )
+ {
+ wxString ext = strExtensions[i] + _T(' ');
- // read the users mime.types
- wxString strUserMimeTypes = strHome + wxT("/.mime.types");
- if ( wxFile::Exists(strUserMimeTypes) ) {
- ReadMimeTypes(strUserMimeTypes);
+ if ( exts.Find(ext) == wxNOT_FOUND )
+ {
+ exts += ext;
+ }
}
- // read KDE/GNOME tables
- ArrayIconHandlers& handlers = GetIconHandlers();
- size_t count = handlers.GetCount();
- for ( size_t hn = 0; hn < count; hn++ )
- handlers[hn]->GetMimeInfoRecords(this);
+ // check data integrity
+ wxASSERT( m_aTypes.Count() == m_aEntries.Count() &&
+ m_aTypes.Count() == m_aExtensions.Count() &&
+ m_aTypes.Count() == m_aIcons.Count() &&
+ m_aTypes.Count() == m_aDescriptions.Count() );
+
+ return nIndex;
}
+
wxFileType *
wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
{
- wxFileType *fileType = NULL;
+ if (ext.empty() )
+ return NULL;
+
+ InitIfNeeded();
+
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(' '));
+ for ( size_t n = 0; n < count; n++ )
+ {
+ wxStringTokenizer tk(m_aExtensions[n], _T(' '));
+ while ( tk.HasMoreTokens() )
+ {
// consider extensions as not being case-sensitive
- if ( field.IsSameAs(ext, FALSE /* no case */) ) {
+ if ( tk.GetNextToken().IsSameAs(ext, FALSE /* no case */) )
+ {
// found
- if (fileType == NULL) fileType = new wxFileType;
+ wxFileType *fileType = new wxFileType;
fileType->m_impl->Init(this, n);
- // adds this mime type to _list_ of mime types with this extension
+
+ return fileType;
}
}
}
- return fileType;
+ return NULL;
}
wxFileType *
wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
{
+ InitIfNeeded();
+
+ wxFileType * fileType = NULL;
// mime types are not case-sensitive
wxString mimetype(mimeType);
mimetype.MakeLower();
// 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;
- }
+ if ( index != wxNOT_FOUND )
+ {
+ fileType = new wxFileType;
+ fileType->m_impl->Init(this, index);
+ }
+
+ // 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.
+
+ index = wxNOT_FOUND;
+ 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;
}
+
}
- if ( index != wxNOT_FOUND ) {
- wxFileType *fileType = new wxFileType;
+ if ( index != wxNOT_FOUND )
+ {
+ fileType = new wxFileType;
fileType->m_impl->Init(this, index);
-
- return fileType;
}
- else {
- // not found...
- return NULL;
+ return fileType;
+}
+
+
+wxString wxMimeTypesManagerImpl::GetCommand(const wxString & verb, size_t nIndex) const
+{
+ wxString command, testcmd, sV, sTmp;
+ sV = verb + wxT("=");
+ // list of verb = command pairs for this mimetype
+ wxMimeTypeCommands * sPairs = m_aEntries [nIndex];
+
+ size_t i;
+ for ( i = 0; i < sPairs->GetCount (); i++ )
+ {
+ sTmp = sPairs->GetVerbCmd (i);
+ if ( sTmp.Contains(sV) )
+ command = sTmp.AfterFirst(wxT('='));
}
+ return command;
}
void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype)
{
+ InitIfNeeded();
+
wxString extensions;
const wxArrayString& exts = filetype.GetExtensions();
size_t nExts = exts.GetCount();
const wxString& strExtensions,
const wxString& strDesc)
{
- 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;
+ // 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;
+
+ wxArrayString sExts;
+ sTmp.Trim().Trim(FALSE);
+
+ while (!sTmp.empty())
+ {
+ sExts.Add (sTmp.AfterLast(wxT(' ')));
+ sTmp = sTmp.BeforeLast(wxT(' '));
}
+
+ AddToMimeData (strMimeType, strIcon, NULL, sExts, strDesc, TRUE);
}
void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
const wxString& strTest,
const wxString& strDesc)
{
- MailCapEntry *entry = new MailCapEntry(strOpenCmd, strPrintCmd, strTest);
+ InitIfNeeded();
- int nIndex = m_aTypes.Index(strType);
- if ( nIndex == wxNOT_FOUND ) {
- // new file type
- m_aTypes.Add(strType);
+ wxMimeTypeCommands *entry = new wxMimeTypeCommands;
+ entry->Add(wxT("open=") + strOpenCmd);
+ entry->Add(wxT("print=") + strPrintCmd);
+ entry->Add(wxT("test=") + strTest);
+
+ wxString strIcon;
+ wxArrayString strExtensions;
+
+ AddToMimeData (strType, strIcon, entry, strExtensions, strDesc, TRUE);
- 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(wxT("--- Parsing mime.types file '%s' ---"), strFileName.c_str());
+ wxLogTrace(TRACE_MIME, wxT("--- Parsing mime.types file '%s' ---"),
+ strFileName.c_str());
wxTextFile file(strFileName);
if ( !file.Open() )
// eat whitespace
for ( pc = pEqualSign + 1; wxIsspace(*pc); pc++ )
- ;
+ ;
const wxChar *pEnd;
if ( *pc == wxT('"') ) {
}
}
else {
- // unquoted string ends at the first space
- for ( pEnd = pc; !wxIsspace(*pEnd); pEnd++ )
- ;
+ // unquoted string ends at the first space or at the end of
+ // line
+ for ( pEnd = pc; *pEnd && !wxIsspace(*pEnd); pEnd++ )
+ ;
}
// now we have the RHS (field value)
}
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
if ( strLHS == wxT("type") ) {
strMimeType = strRHS;
}
- else if ( strLHS == wxT("desc") ) {
+ else if ( strLHS.StartsWith(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());
+ // this one is simply ignored: it usually refers to Netscape
+ // built in icons which are useless for us anyhow
+ if ( strLHS != _T("icon") )
+ {
+ wxLogWarning(_("Unknown field in file %s, line %d: '%s'."),
+ strFileName.c_str(), nLine + 1, strLHS.c_str());
+ }
}
if ( !entryEnded ) {
}
}
- // although it doesn't seem to be covered by RFCs, some programs
- // (notably Netscape) create their entries with several comma
- // separated extensions (RFC mention the spaces only)
+ // 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('.') )
+ if ( !strExtensions.empty() && strExtensions[0u] == wxT('.') )
{
strExtensions.erase(0, 1);
}
+ wxLogTrace(TRACE_MIME, wxT("mime.types: '%s' => '%s' (%s)"),
+ strExtensions.c_str(),
+ strMimeType.c_str(),
+ strDesc.c_str());
+
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;
+}
+
+// ----------------------------------------------------------------------------
+// UNIX mailcap files parsing
+// ----------------------------------------------------------------------------
+
+// the data for a single MIME type
+struct MailcapLineData
+{
+ // field values
+ wxString type,
+ cmdOpen,
+ test,
+ icon,
+ desc;
+
+ wxArrayString verbs,
+ commands;
+
+ // flags
+ bool testfailed,
+ needsterminal,
+ copiousoutput;
+
+ MailcapLineData() { testfailed = needsterminal = copiousoutput = FALSE; }
+};
+
+// process a non-standard (i.e. not the first or second one) mailcap field
+bool
+wxMimeTypesManagerImpl::ProcessOtherMailcapField(MailcapLineData& data,
+ const wxString& curField)
+{
+ if ( curField.empty() )
+ {
+ // we don't care
+ return TRUE;
+ }
+
+ // is this something of the form foo=bar?
+ const wxChar *pEq = wxStrchr(curField, wxT('='));
+ if ( pEq != NULL )
+ {
+ // split "LHS = RHS" in 2
+ wxString lhs = curField.BeforeFirst(wxT('=')),
+ rhs = curField.AfterFirst(wxT('='));
+
+ lhs.Trim(TRUE); // from right
+ rhs.Trim(FALSE); // from left
+
+ // it might be quoted
+ if ( !rhs.empty() && rhs[0u] == wxT('"') && rhs.Last() == wxT('"') )
+ {
+ rhs = rhs.Mid(1, rhs.length() - 2);
+ }
+
+ // is it a command verb or something else?
+ if ( lhs == wxT("test") )
+ {
+ if ( wxSystem(rhs) == 0 )
+ {
+ // ok, test passed
+ wxLogTrace(TRACE_MIME_TEST,
+ wxT("Test '%s' for mime type '%s' succeeded."),
+ rhs.c_str(), data.type.c_str());
+
+ }
+ else
+ {
+ wxLogTrace(TRACE_MIME_TEST,
+ wxT("Test '%s' for mime type '%s' failed, skipping."),
+ rhs.c_str(), data.type.c_str());
+
+ data.testfailed = TRUE;
+ }
+ }
+ else if ( lhs == wxT("desc") )
+ {
+ data.desc = rhs;
+ }
+ else if ( lhs == wxT("x11-bitmap") )
+ {
+ data.icon = rhs;
+ }
+ else if ( lhs == wxT("notes") )
+ {
+ // ignore
+ }
+ else // not a (recognized) special case, must be a verb (e.g. "print")
+ {
+ data.verbs.Add(lhs);
+ data.commands.Add(rhs);
+ }
+ }
+ else // '=' not found
+ {
+ // so it must be a simple flag
+ if ( curField == wxT("needsterminal") )
+ {
+ data.needsterminal = TRUE;
+ }
+ else if ( curField == wxT("copiousoutput"))
+ {
+ // copiousoutput impies that the viewer is a console program
+ data.needsterminal =
+ data.copiousoutput = TRUE;
+ }
+ else if ( !IsKnownUnimportantField(curField) )
+ {
+ return FALSE;
+ }
+ }
return TRUE;
}
bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
bool fallback)
{
- wxLogTrace(wxT("--- Parsing mailcap file '%s' ---"), strFileName.c_str());
+ 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;
+ // indices of MIME types (in m_aTypes) we already found in this file
+ //
+ // (see the comments near the end of function for the reason we need this)
+ wxArrayInt aIndicesSeenHere;
+
+ // accumulator for the current field
+ wxString curField;
+ curField.reserve(1024);
size_t nLineCount = file.GetLineCount();
- for ( size_t nLine = 0; nLine < nLineCount; nLine++ ) {
+ for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
+ {
// now we're at the start of the line
const wxChar *pc = file[nLine].c_str();
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...
+ // be an arbitrary number of other fields parsed by
+ // ProcessOtherMailcapField()
+ //
+ // the first field is the MIME type
enum
{
Field_Type,
} 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
- for ( bool cont = TRUE; cont; pc++ ) {
- switch ( *pc ) {
+ MailcapLineData data;
+
+ 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 ( *++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();
- // pc currently points to nowhere, but after the next
- // pc++ in the for line it will point to the beginning
- // of the next line in the file
- pc = file[++nLine].c_str() - 1;
+ // skip pc++ at the end of the loop
+ continue;
+ }
}
- else {
+ else
+ {
// just a normal character
curField += *pc;
}
case wxT('\0'):
cont = FALSE; // end of line reached, exit the loop
- // fall through
+ // fall through to still process this field
case wxT(';'):
- // store this field and start looking for the next one
-
// trim whitespaces from both sides
curField.Trim(TRUE).Trim(FALSE);
- switch ( currentToken ) {
+ switch ( currentToken )
+ {
case Field_Type:
- strType = curField;
- if ( strType.Find(wxT('/')) == wxNOT_FOUND ) {
+ data.type = curField.Lower();
+ if ( data.type.empty() )
+ {
+ // I don't think that this is a valid mailcap
+ // entry, but try to interpret it somehow
+ data.type = _T('*');
+ }
+
+ if ( data.type.Find(wxT('/')) == wxNOT_FOUND )
+ {
// we interpret "type" as "type/*"
- strType += wxT("/*");
+ data.type += wxT("/*");
}
currentToken = Field_OpenCmd;
break;
case Field_OpenCmd:
- strOpenCmd = curField;
+ data.cmdOpen = curField;
currentToken = Field_Other;
break;
case Field_Other:
+ if ( !ProcessOtherMailcapField(data, 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(),
+ data.type.c_str()
+ );
+ }
+ else if ( data.testfailed )
{
- // "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
- // TODO support the flags:
- // 1. create an xterm for 'needsterminal'
- // 2. append "| $PAGER" for 'copiousoutput'
- if ( curField == wxT("needsterminal") )
- needsterminal = TRUE;
- else if ( curField == wxT("copiousoutput") )
- copiousoutput = TRUE;
- else if ( curField == wxT("textualnewlines") )
- ; // ignore
- else
- ok = FALSE;
- }
-
- if ( !ok )
- {
- // we don't understand this field, but
- // Netscape stores info in it, so don't warn
- // about it
- if ( curField.Left(16u) != "x-mozilla-flags=" )
- {
- // 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()
- );
- }
- }
+ // skip this entry entirely
+ cont = FALSE;
}
// it already has this value
default:
curField += *pc;
}
+
+ // continue in the same line
+ pc++;
}
+ // we read the entire entry, check what have we got
+ // ------------------------------------------------
+
// check that we really read something reasonable
- if ( currentToken == Field_Type || currentToken == Field_OpenCmd ) {
+ if ( currentToken < Field_Other )
+ {
wxLogWarning(_("Mailcap file %s, line %d: incomplete entry "
"ignored."),
strFileName.c_str(), nLine + 1);
+
+ continue;
}
- else {
- 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 the test command failed, it's as if the entry were not there at
+ // all
+ if ( data.testfailed )
+ {
+ continue;
+ }
- if ( !strDesc.IsEmpty() ) {
- // replace the old one - what else can we do??
- m_aDescriptions[nIndex] = strDesc;
- }
- }
+ // 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 ( data.copiousoutput )
+ {
+ const wxChar *p = wxGetenv(_T("PAGER"));
+ data.cmdOpen << _T(" | ") << (p ? p : _T("more"));
+ }
+
+ if ( data.needsterminal )
+ {
+ data.cmdOpen.Printf(_T("xterm -e sh -c '%s'"), data.cmdOpen.c_str());
+ }
+
+ if ( !data.cmdOpen.empty() )
+ {
+ data.verbs.Insert(_T("open"), 0);
+ data.commands.Insert(data.cmdOpen, 0);
+ }
+
+ // we have to decide whether the new entry should replace any entries
+ // for the same MIME type we had previously found or not
+ bool overwrite;
+
+ // the fall back entries have the lowest priority, by definition
+ if ( fallback )
+ {
+ overwrite = FALSE;
+ }
+ else
+ {
+ // have we seen this one before?
+ int nIndex = m_aTypes.Index(data.type);
+
+ // and if we have, was it in this file?
+ overwrite = nIndex == wxNOT_FOUND ||
+ aIndicesSeenHere.Index(nIndex) != wxNOT_FOUND;
}
- // check our data integriry
- wxASSERT( m_aTypes.Count() == m_aEntries.Count() &&
- m_aTypes.Count() == m_aExtensions.Count() &&
- m_aTypes.Count() == m_aDescriptions.Count() );
+ wxLogTrace(TRACE_MIME, _T("mailcap %s: %s [%s]"),
+ data.type.c_str(), data.cmdOpen.c_str(),
+ overwrite ? _T("replace") : _T("add"));
+
+ int n = AddToMimeData
+ (
+ data.type,
+ data.icon,
+ new wxMimeTypeCommands(data.verbs, data.commands),
+ wxArrayString() /* extensions */,
+ data.desc,
+ overwrite
+ );
+
+ if ( overwrite )
+ {
+ aIndicesSeenHere.Add(n);
+ }
}
return TRUE;
size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
{
+ InitIfNeeded();
+
mimetypes.Empty();
wxString type;
return mimetypes.GetCount();
}
+// ----------------------------------------------------------------------------
+// writing to MIME type files
+// ----------------------------------------------------------------------------
+
+bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
+{
+ wxArrayString sMimeTypes;
+ ft->GetMimeTypes (sMimeTypes);
+
+ wxString sMime;
+ size_t i;
+ for (i = 0; i < sMimeTypes.GetCount(); i ++)
+ {
+ sMime = sMimeTypes.Item(i);
+ int nIndex = m_aTypes.Index (sMime);
+ if ( nIndex == wxNOT_FOUND)
+ {
+ // error if we get here ??
+ return FALSE;
+ }
+ else
+ {
+ WriteMimeInfo(nIndex, TRUE );
+ 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.Count() == m_aEntries.Count() &&
+ m_aTypes.Count() == m_aExtensions.Count() &&
+ m_aTypes.Count() == m_aIcons.Count() &&
+ m_aTypes.Count() == m_aDescriptions.Count() );
+
+ return TRUE;
+}
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+static bool IsKnownUnimportantField(const wxString& fieldAll)
+{
+ static const wxChar *knownFields[] =
+ {
+ _T("x-mozilla-flags"),
+ _T("nametemplate"),
+ _T("textualnewlines"),
+ };
+
+ wxString field = fieldAll.BeforeFirst(_T('='));
+ for ( size_t n = 0; n < WXSIZEOF(knownFields); n++ )
+ {
+ if ( field.CmpNoCase(knownFields[n]) == 0 )
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
#endif
- // wxUSE_FILE && wxUSE_TEXTFILE
+ // wxUSE_MIMETYPE && wxUSE_FILE && wxUSE_TEXTFILE
projects / wxWidgets.git / blobdiff