///////////////////////////////////////////////////////////////////////////// // Name: 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) ///////////////////////////////////////////////////////////////////////////// // 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 n??ever will // ============================================================================ // 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 #endif #ifndef WX_PRECOMP #include "wx/defs.h" #endif #if wxUSE_FILE && wxUSE_TEXTFILE #ifndef WX_PRECOMP #include "wx/string.h" #if wxUSE_GUI #include "wx/icon.h" #endif #endif //WX_PRECOMP #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" // other standard headers #include // this is a class to extend wxArrayString... class wxMimeArrayString : public wxArrayString { public: wxMimeArrayString () { wxArrayString (); } size_t pIndexOf (const wxString & verb) { size_t i = 0; wxString sTmp = verb; // avoid a problem with modifying const parameter sTmp.MakeLower(); while ( (i < GetCount()) && (! Item(i).MakeLower().Contains(sTmp)) ) { i++; } if ( i==GetCount() ) i = (size_t)wxNOT_FOUND; return i; } bool ReplaceOrAddLineCmd (const wxString verb, const wxString & cmd) { size_t nIndex = pIndexOf (verb); if (nIndex == (size_t)wxNOT_FOUND) Add(verb + wxT("=") + cmd); else Item(nIndex) = verb + wxT("=") + cmd; return TRUE; } wxString GetVerb (size_t i) { if (i < 0) return wxEmptyString; if (i > GetCount() ) return wxEmptyString; wxString sTmp = Item(i).BeforeFirst(wxT('=')); return sTmp; } wxString GetCmd (size_t i) { if (i < 0) return wxEmptyString; if (i > GetCount() ) return wxEmptyString; wxString sTmp = Item(i).AfterFirst(wxT('=')); return sTmp; } }; //this class extends wxTextFile 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 < 0) return wxEmptyString; if (i > GetLineCount() ) return wxEmptyString; wxString sTmp = GetLine(i).BeforeFirst(wxT('=')); return sTmp; } wxString GetCmd (size_t i) { if (i < 0) return wxEmptyString; 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") // ---------------------------------------------------------------------------- // 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. // ---------------------------------------------------------------------------- // 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. bool wxMimeTypesManagerImpl::CheckGnomeDirsExist () { wxString gnomedir; wxGetHomeDir( &gnomedir ); wxString sTmp = gnomedir; sTmp = sTmp + "/.gnome" ; if (! wxDir::Exists ( sTmp ) ) { if (!wxMkdir ( sTmp )) { wxFAIL_MSG (wxString ("Failed to create directory\n.gnome in \nCheckGnomeDirsExist") + sTmp ); return FALSE; } } sTmp = sTmp + "/mime-info"; if (! wxDir::Exists ( sTmp ) ) { if (!wxMkdir ( sTmp )) { wxFAIL_MSG (wxString ("Failed to create directory\nmime-info in \nCheckGnomeDirsExist") + sTmp ); return FALSE; } } return TRUE; } bool wxMimeTypesManagerImpl::WriteGnomeKeyFile(int index, bool delete_index) { 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 if (! outfile.Open () ) { if (delete_index) return FALSE; if (!CheckGnomeDirsExist() ) return FALSE; outfile.Create (); } 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"); wxMimeArrayString * entries = m_aEntries[index]; size_t i; for (i=0; i < entries->GetCount(); i++) { sTmp = entries->Item(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); wxMimeArrayString 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) { wxMimeArrayString * 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.ReplaceOrAddLineCmd ( entries->GetVerb(i), entries->GetCmd (i) ); } //sOld should also contain the icon if ( !m_aIcons[index].IsEmpty() ) sOld.ReplaceOrAddLineCmd ( wxT( "icon-filename"), m_aIcons[index] ); for (i=0; i < sOld.GetCount(); i++) { sTmp = sOld.Item(i); sTmp.Replace( wxT("%s"), wxT("%f") ); sTmp = wxT ( "\t") + sTmp; nIndex ++; outfile.InsertLine ( sTmp, nIndex ); } } } bool bTmp = outfile.Write (); return bTmp; } bool wxMimeTypesManagerImpl::WriteGnomeMimeFile(int index, bool delete_index) { wxString gnomedir; wxGetHomeDir( &gnomedir ); 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()); // values for the entry being parsed wxString curMimeType, curIconFile; wxMimeArrayString * entry = new wxMimeArrayString; // these are always empty in this file wxArrayString strExtensions; wxString strDesc; const wxChar *pc; size_t nLineCount = textfile.GetLineCount(); size_t nLine = 0; while ( nLine < nLineCount) { pc = textfile[nLine].c_str(); if ( *pc != _T('#') ) { 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); } } // 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.IsEmpty()) { AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc); // now get ready for next bit entry = new wxMimeArrayString; } curMimeType = sTmp.BeforeFirst(wxT(':')); } } } // end of not a comment // ignore blank lines nLine ++; } // end of while, save any data if (! curMimeType.IsEmpty()) { AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc); } } 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, curExtList; const wxChar *pc; size_t nLineCount = textfile.GetLineCount(); for ( size_t nLine = 0; ; nLine++ ) { 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; } if ( !pc || !*pc ) { // end of the entry if ( !!curMimeType && !!curExtList ) { wxLogTrace(TRACE_MIME, wxT("--- At end of Gnome file finding mimetype %s ---"), curMimeType.c_str()); AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString); } if ( !pc ) { // the end - this can only happen if nLine == nLineCount break; } curExtList.Empty(); continue; } // what do we have here? if ( *pc == _T('\t') ) { // 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 } else { // this is the start of the new section wxLogTrace(TRACE_MIME, wxT("--- In Gnome file finding mimetype %s ---"), curMimeType.c_str()); if (! curMimeType.IsEmpty()) AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString); curMimeType.Empty(); while ( *pc != _T(':') && *pc != _T('\0') ) { curMimeType += *pc++; } } } } void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(const wxString& dirbase) { 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 ) { LoadGnomeMimeTypesFromMimeFile(dirname + filename); cont = dir.GetNext(&filename); } cont = dir.GetFirst(&filename, _T("*.keys"), wxDIR_FILES); while ( cont ) { LoadGnomeDataFromKeyFile(dirname + filename); cont = dir.GetNext(&filename); } } void wxMimeTypesManagerImpl::GetGnomeMimeInfo(const wxString& sExtraDir) { wxArrayString dirs; dirs.Add(_T("/usr/share")); dirs.Add(_T("/usr/local/share")); wxString gnomedir; wxGetHomeDir( &gnomedir ); gnomedir += _T("/.gnome"); dirs.Add( gnomedir ); if (!sExtraDir.IsEmpty()) dirs.Add( sExtraDir ); size_t nDirs = dirs.GetCount(); for ( size_t nDir = 0; nDir < nDirs; nDir++ ) { LoadGnomeMimeFilesFromDir(dirs[nDir]); } } // end of gnome // ---------------------------------------------------------------------------- // wxKDE // ---------------------------------------------------------------------------- // 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" // 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??) bool wxMimeTypesManagerImpl::CheckKDEDirsExist ( const wxString & sOK, const wxString & sTest ) { if (sTest.IsEmpty()) { 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); } } bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index) { 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) { 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"); bool bAppExists; bAppExists = appoutfile.Open (sTmp); if (!bAppExists) { bTemp = appoutfile.Create (sTmp); // some unknown error eg out of disk space if (!bTemp) return FALSE; } // fixed data; write if new file if (!bMimeExists) { 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); } if (!bAppExists) { 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(';')); } // 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() ) { // holds an extension; need to change it to *.ext; wxString e = wxT("*.") + tokenizer.GetNextToken() + wxT(";"); sTmp = sTmp + e; } if (!delete_index) mimeoutfile.AddLine(sTmp); wxMimeArrayString * entries = m_aEntries[index]; // if we don't find open just have an empty string ... FIX this size_t iOpen = entries->pIndexOf(wxT("open")); sTmp = entries->GetCmd(iOpen); sTmp.Replace( wxT("%s"), wxT("%f") ); mimeoutfile.CommentLine(wxT("DefaultApp=") ); if (!delete_index) mimeoutfile.AddLine(wxT("DefaultApp=") + sTmp); sTmp.Replace( wxT("%f"), wxT("") ); appoutfile.CommentLine(wxT("Exec=")); if (!delete_index) appoutfile.AddLine(wxT("Exec=") + sTmp); if (entries->GetCount() > 1) { //other actions as well as open } bTemp = FALSE; if (mimeoutfile.Write ()) bTemp = TRUE; mimeoutfile.Close (); if (appoutfile.Write ()) bTemp = TRUE; appoutfile.Close (); return bTemp; } void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase, const wxString& subdir, const wxString& filename, const wxArrayString& icondirs) { wxMimeTextFile file; if ( !file.Open(dirbase + filename) ) return; wxMimeArrayString * entry = new wxMimeArrayString; wxArrayString sExts; wxString mimetype, mime_desc, strIcon; 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); // first find the description string: it is the value in either "Comment=" // line or "Comment[]=" one nIndex = wxNOT_FOUND; 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 if ( nIndex == wxNOT_FOUND ) { comment = _T("Comment="); nIndex = file.pIndexOf(comment); } 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 = file.GetCmd (nIndex) ;; wxStringTokenizer tokenizer(exts, _T(";")); while ( tokenizer.HasMoreTokens() ) { 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); } } sExts.Add(mime_extension); // ok, now we can take care of icon: nIndex = file.pIndexOf(_T("Icon=")); if ( nIndex != wxNOT_FOUND ) { 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.IsEmpty() ) { // 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= nIndex = file.pIndexOf(wxT("DefaultApp")); if ( nIndex == wxNOT_FOUND ) { // no entry try exec nIndex = file.pIndexOf(wxT("Exec")); } if ( nIndex != wxNOT_FOUND ) { 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->ReplaceOrAddLineCmd (wxString(wxT("open")), sTmp ); } AddToMimeData (mimetype, strIcon, entry, sExts, mime_desc); } void wxMimeTypesManagerImpl::LoadKDELinksForMimeType(const wxString& dirbase, const wxString& subdir, const wxArrayString& icondirs) { wxString dirname = dirbase; dirname += subdir; wxDir dir(dirname); if ( !dir.IsOpened() ) return; dirname += _T('/'); wxString filename; bool cont = dir.GetFirst(&filename, _T("*.kdelnk"), wxDIR_FILES); while ( cont ) { 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 wxMimeTypesManagerImpl::LoadKDELinkFilesFromDir(const wxString& dirbase, const wxArrayString& icondirs) { wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase), _T("base directory shouldn't end with a slash") ); 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 ) { LoadKDELinksForMimeType(dirname, subdir, icondirs); cont = dir.GetNext(&subdir); } } void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir) { 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/")); } if (!sExtraDir.IsEmpty()) dirs.Add (sExtraDir); icondirs.Add(sExtraDir + wxT("/icons")); size_t nDirs = dirs.GetCount(); for ( size_t nDir = 0; nDir < nDirs; nDir++ ) { LoadKDELinkFilesFromDir(dirs[nDir], icondirs); } } // end of KDE // ---------------------------------------------------------------------------- // wxFileTypeImpl (Unix) // ---------------------------------------------------------------------------- wxString wxFileTypeImpl::GetExpandedCommand(const wxString & verb, const wxFileType::MessageParameters& params) const { wxString sTmp; size_t i = 0; while ( (i < m_index.GetCount() ) && sTmp.IsEmpty() ) { sTmp = m_manager->GetCommand ( verb, m_index[i] ); i ++; } return wxFileType::ExpandCommand(sTmp, params); } bool wxFileTypeImpl::GetIcon(wxIcon *icon, wxString *iconFile /*= NULL */, int *iconIndex /*= NULL*/) const { wxString sTmp; size_t i = 0; while ( (i < m_index.GetCount() ) && sTmp.IsEmpty() ) { sTmp = m_manager->m_aIcons[m_index[i]]; i ++; } if ( sTmp.IsEmpty () ) return FALSE; wxIcon icn; if (sTmp.Right(4).MakeUpper() == _T(".XPM")) icn = wxIcon(sTmp); else icn = wxIcon(sTmp, wxBITMAP_TYPE_ANY); if ( icn.Ok() ) { *icon = icn; if (iconFile) *iconFile = sTmp; if (iconIndex) *iconIndex = 0; return TRUE; } 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; } size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs, wxArrayString *commands, const wxFileType::MessageParameters& params) const { wxString vrb, cmd, sTmp; size_t count = 0; wxMimeArrayString * 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.IsEmpty() ) { 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); } } } } return count; } bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions) { 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; } } 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 ; wxMimeArrayString *entry = new wxMimeArrayString (); 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 Ok; } // 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*/) { if (strIcon.IsEmpty()) return FALSE; wxArrayString strExtensions; wxString strDesc; wxMimeArrayString *entry = new wxMimeArrayString (); 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 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_BASE) ) 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 (); size_t cnt = m_aTypes.GetCount(); for (size_t i = 0; i < cnt; i++) { m_aEntries[i]->Clear (); } m_aEntries.Clear (); m_mailcapStylesInited = 0; } wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl() { ClearData(); // do we need to delete the ArrayStrings too to avoid a leak // delete m_aEntries //fix a leak here ?; } 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 ( wxT("/etc/") ); dirs.Add ( wxT("/usr/etc/") ); dirs.Add ( wxT("/usr/local/etc/") ); dirs.Add ( wxT("/etc/mail/") ); dirs.Add ( wxT("/usr/public/lib/") ); dirs.Add ( strHome + wxT("/.") ); if (!sExtraDir.IsEmpty()) 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); } } } bool wxMimeTypesManagerImpl::WriteToMimeTypes (int index, bool delete_index) { // check we have the right manager if (! ( m_mailcapStylesInited & wxMAILCAP_BASE) ) 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) { 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) { //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).IsEmpty() ) { 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 wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index) { //check we have the right managers if ( !( ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) || ( m_mailcapStylesInited & wxMAILCAP_BASE) ) ) 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 .... wxMimeArrayString * entries = m_aEntries[index]; size_t iOpen = entries->pIndexOf(wxT("open")); wxString sCmd = entries->GetCmd(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_BASE ) ) { 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.IsEmpty() ) { 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].IsEmpty() ) { sTmp = sTmp + wxT("; \\"); file.InsertLine (sTmp, nIndex); nIndex ++; sTmp = wxT(" description=\"") + m_aDescriptions[index] + wxT("\""); } if (! m_aIcons[index].IsEmpty() ) { 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->Item(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 (); wxMimeArrayString *entry = new wxMimeArrayString (); if ( ! ftInfo.GetOpenCommand().IsEmpty()) entry->Add(wxT("open=") + ftInfo.GetOpenCommand () + wxT(" %s ")); if ( ! ftInfo.GetPrintCommand ().IsEmpty()) 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 ; } } if ( !DoAssociation (strType, strIcon, entry, sA_Exts, strDesc) ) return NULL; return GetFileTypeFromMimeType(strType); } bool wxMimeTypesManagerImpl::DoAssociation(const wxString& strType, const wxString& strIcon, wxMimeArrayString *entry, const wxArrayString& strExtensions, const wxString& strDesc) { int nIndex = AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, TRUE); if ( nIndex == wxNOT_FOUND ) return FALSE; return WriteMimeInfo (nIndex, FALSE); } bool wxMimeTypesManagerImpl::WriteMimeInfo(int nIndex, bool delete_mime ) { bool ok = TRUE; if ( m_mailcapStylesInited & wxMAILCAP_BASE ) { // 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 ok; } int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType, const wxString& strIcon, wxMimeArrayString *entry, const wxArrayString& strExtensions, const wxString& strDesc, bool ReplaceExisting) { InitIfNeeded(); wxLogTrace(TRACE_MIME, wxT("In Add to Mime data '%s' with %d entries and %d exts ---"), strType.c_str(), entry->GetCount(), strExtensions.GetCount() ); // ensure mimetype is always lower case wxString mimeType = strType; mimeType.MakeLower(); int nIndex = m_aTypes.Index(mimeType); if ( nIndex == wxNOT_FOUND ) { // new file type m_aTypes.Add(mimeType); m_aIcons.Add(strIcon); m_aEntries.Add(entry); size_t i; // change nIndex so we can add to the correct line nIndex = m_aExtensions.Add(wxT(' ')); for (i = 0; i < strExtensions.GetCount(); i ++) { if (! m_aExtensions.Item(nIndex).Contains(wxT(' ') + strExtensions.Item(i) + wxT(' '))) m_aExtensions.Item(nIndex) += strExtensions.Item(i) + wxT(' '); } m_aDescriptions.Add(strDesc); } else { // nIndex has the existing data // always add the extensions to this mimetype size_t i; for (i = 0; i < strExtensions.GetCount(); i ++) { if (! m_aExtensions.Item(nIndex).Contains(wxT(' ') + strExtensions.Item(i) + wxT(' '))) m_aExtensions.Item(nIndex) += strExtensions.Item(i) + wxT(' '); } if (ReplaceExisting) { // if new description change it if ( ! strDesc.IsEmpty()) m_aDescriptions[nIndex] = strDesc; // if new icon change it if ( ! strIcon.IsEmpty()) m_aIcons[nIndex] = strIcon; wxMimeArrayString *entryOld = m_aEntries[nIndex]; // replace any matching entries... for (i=0; i < entry->GetCount(); i++) entryOld->ReplaceOrAddLineCmd (entry->GetVerb(i), entry->GetCmd (i) ); } else { // add data we don't already have ... // if new description add only if none if ( ! strDesc.IsEmpty() && m_aDescriptions.Item(i).IsEmpty() ) m_aDescriptions[nIndex] = strDesc; // if new icon and no existing icon if ( ! strIcon.IsEmpty() && m_aIcons.Item(i). IsEmpty () ) m_aIcons[nIndex] = strIcon; wxMimeArrayString *entryOld = m_aEntries[nIndex]; // add any new entries... for (i=0; i < entry->GetCount(); i++) { wxString sVerb = entry->GetVerb(i); if ( entryOld->pIndexOf ( sVerb ) == (size_t) wxNOT_FOUND ) entryOld->Add (entry->Item(i)); } } } // 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) { if (ext.IsEmpty() ) return NULL; 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 } } } return fileType; } 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 ) { 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 ) { fileType = new wxFileType; fileType->m_impl->Init(this, index); } 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 wxMimeArrayString * sPairs = m_aEntries [nIndex]; size_t i; for ( i = 0; i < sPairs->GetCount () ; i++ ) { sTmp = sPairs->Item (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(); 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) { // 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; wxMimeArrayString * entry = new wxMimeArrayString () ; wxArrayString sExts; sTmp.Trim().Trim(FALSE); while (!sTmp.IsEmpty()) { sExts.Add (sTmp.AfterLast(wxT(' '))); sTmp = sTmp.BeforeLast(wxT(' ')); } AddToMimeData (strMimeType, strIcon, entry, sExts, strDesc, (bool)TRUE); } void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType, const wxString& strOpenCmd, const wxString& strPrintCmd, const wxString& strTest, const wxString& strDesc) { InitIfNeeded(); wxMimeArrayString *entry = new wxMimeArrayString; 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); } 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++ ) ; } // now we have the RHS (field value) wxString strRHS(pc, pEnd - pc); // 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); } wxLogTrace(TRACE_MIME, wxT("--- Found Mimetype '%s' ---"), strMimeType.c_str()); AddMimeTypeInfo(strMimeType, strExtensions, strDesc); // finished with this line pc = NULL; } return TRUE; } bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName, bool fallback) { // wxLog::AddTraceMask (TRACE_MIME); 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; wxMimeArrayString *entry; wxString strType, strOpenCmd, strIcon, strTest, strDesc, curField; // accumulator bool cont = TRUE; bool test_passed = 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; entry = new wxMimeArrayString (); entry->Add(wxT("open=") + strOpenCmd); currentToken = Field_Other; break; case Field_Other: if ( !curField.empty() ) { // "good" mailcap entry? bool ok = TRUE; if ( IsKnownUnimportantField(curField) ) ok = FALSE; // is this something of the form foo=bar? const wxChar *pEq = wxStrchr(curField, wxT('=')); if (ok) { if ( pEq != NULL ) { 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[0u] == wxT('"') && rhs.Last() == wxT('"') ) { wxString sTmp = wxString(rhs.c_str() + 1, rhs.Len() - 2); rhs = sTmp; } bool verbfound = TRUE; if ( lhs.Contains (wxT("test"))) { if ( ! rhs.IsEmpty() ) { if ( wxSystem(rhs) == 0 ) { // ok, test passed test_passed = TRUE; wxLogTrace(TRACE_MIME, wxT("Test '%s' for mime type '%s' succeeded."), rhs.c_str(), strType.c_str()); } else { test_passed = FALSE; wxLogTrace(TRACE_MIME, wxT("Test '%s' for mime type '%s' failed."), rhs.c_str(), strType.c_str()); } } verbfound = FALSE; } if ( lhs.Contains (wxT("desc"))) { strDesc = rhs; verbfound = FALSE; } if ( lhs.Contains (wxT("x11-bitmap"))) { strIcon = rhs; verbfound = FALSE; } if ( lhs.Contains (wxT("notes"))) { // ignore verbfound = FALSE; } if (verbfound) entry->Add ( lhs + wxT('=') + rhs ); ok = TRUE; } else { // no, it's a simple flag if ( curField == wxT("needsterminal") ) { needsterminal = TRUE; ok = TRUE; } if ( curField == wxT("copiousoutput")) { // copiousoutput impies that the // viewer is a console program needsterminal = copiousoutput = ok = TRUE; if ( !ok ) { // 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() ); } } } } } // 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")); wxLogTrace(TRACE_MIME, wxT("Replacing .(for pager)...") + entry->Item(0u) + wxT("with") + strOpenCmd ); entry->ReplaceOrAddLineCmd (wxString(wxT("open")), strOpenCmd ); } if ( needsterminal ) { strOpenCmd.Printf(_T("xterm -e sh -c '%s'"), strOpenCmd.c_str()); wxLogTrace(TRACE_MIME, wxT("Replacing .(for needs term)...") + entry->Item(0u) + wxT("with") + strOpenCmd ); entry->ReplaceOrAddLineCmd (wxString(wxT("open")), strOpenCmd ); } // NB: because of complications below (we must get entries priority // right), we can't use AddMailcapInfo() here, unfortunately. if ( test_passed ) { strType.MakeLower(); bool overwrite = TRUE; int entryIndex ; if (fallback) overwrite = FALSE; else { int nIndex = m_aTypes.Index(strType); entryIndex = aEntryIndices.Index(nIndex); if ( entryIndex == wxNOT_FOUND ) { //check this fix // first time in this file, so replace the icons, entries // and description (no extensions to replace so ignore these overwrite = TRUE; aEntryIndices.Add(nIndex); //aLastIndices.Add(0); } else { // not the first time in _this_ file // so we don't want to overwrite // existing entries,but want to add to them // so we don't alter the mimetype // the indices were shifted by 1 overwrite = FALSE; } } wxArrayString strExtensions; AddToMimeData (strType, strIcon, entry, strExtensions, strDesc, !overwrite ); test_passed = TRUE; } } } return TRUE; } size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes) { InitIfNeeded(); 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 ) { mimetypes.Add(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.Remove (nIndex); m_aEntries.Remove (nIndex); m_aExtensions.Remove (nIndex); m_aDescriptions.Remove (nIndex); m_aIcons.Remove (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