/////////////////////////////////////////////////////////////////////////////
-// Name: unix/mimetype.cpp
+// Name: src/unix/mimetype.cpp
// Purpose: classes and functions to manage MIME types
// Author: Vadim Zeitlin
// Modified by:
// 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
+// TODO: this file is a mess, we need to split it and review everything (VZ)
// for compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
- #pragma hdrstop
-#endif
-
-#ifndef WX_PRECOMP
- #include "wx/defs.h"
+ #pragma hdrstop
#endif
#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
+#include "wx/unix/mimetype.h"
+#ifndef WX_PRECOMP
+ #include "wx/dynarray.h"
+ #include "wx/string.h"
+ #include "wx/intl.h"
+ #include "wx/log.h"
+ #include "wx/utils.h"
+#endif
-#include "wx/log.h"
#include "wx/file.h"
-#include "wx/intl.h"
-#include "wx/dynarray.h"
#include "wx/confbase.h"
#include "wx/ffile.h"
#include "wx/textfile.h"
#include "wx/dir.h"
-#include "wx/utils.h"
#include "wx/tokenzr.h"
-
-#include "wx/unix/mimetype.h"
+#include "wx/iconloc.h"
+#include "wx/filename.h"
+#include "wx/app.h"
+#include "wx/apptrait.h"
+
+#if wxUSE_LIBGNOMEVFS
+ // Not GUI dependent
+ #include "wx/gtk/gnome/gvfs.h"
+#endif
// 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
+// this class is a wxTextFile specialization for dealing with files storing
+// various MIME-related information
//
-// VZ: ???
+// it should be used instead of wxTextFile even if none of its additional
+// methods are used just because it handles files with mixed encodings (often
+// the case for MIME files which contain strings for different languages)
+// correctly, see OnRead()
class wxMimeTextFile : public wxTextFile
{
public:
// constructors
- wxMimeTextFile () : wxTextFile () {};
- wxMimeTextFile (const wxString& strFile) : wxTextFile (strFile) { };
+ wxMimeTextFile () : wxTextFile () { }
+ wxMimeTextFile(const wxString& strFile) : wxTextFile(strFile) { }
- int pIndexOf(const wxString & sSearch, bool bIncludeComments = FALSE, int iStart = 0)
+ 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)
+ for(size_t i = iStart; i < GetLineCount(); i++)
{
- while ( (i < GetLineCount()) )
+ wxString sLine = GetLine(i).Trim(false);
+ if(bIncludeComments || ! sLine.StartsWith(wxT("#")))
{
- sLine = GetLine (i);
sLine.MakeLower();
- if (sLine.Contains(sTest)) nResult = (int) i;
- i++;
+ if(sLine.StartsWith(sTest))
+ return (int)i;
}
}
- else
- {
- while ( (i < GetLineCount()) )
- {
- sLine = GetLine (i);
- sLine.MakeLower();
- if ( ! sLine.StartsWith(wxT("#")))
- {
- if (sLine.Contains(sTest)) nResult = (int) i;
- }
- i++;
- }
- }
- return nResult;
+ return wxNOT_FOUND;
}
bool CommentLine(int nIndex)
{
- if (nIndex <0) return FALSE;
- if (nIndex >= (int)GetLineCount() ) return FALSE;
+ if (nIndex < 0)
+ return false;
+ if (nIndex >= (int)GetLineCount() )
+ return false;
+
GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
- return TRUE;
+ return true;
}
bool CommentLine(const wxString & sTest)
{
int nIndex = pIndexOf(sTest);
- if (nIndex <0) return FALSE;
- if (nIndex >= (int)GetLineCount() ) return FALSE;
+ if (nIndex < 0)
+ return false;
+ if (nIndex >= (int)GetLineCount() )
+ return false;
+
GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
- return TRUE;
+ return true;
}
- wxString GetVerb (size_t i)
+ wxString GetVerb(size_t i)
{
- if (i > GetLineCount() ) return wxEmptyString;
+ if (i > GetLineCount() )
+ return wxEmptyString;
+
wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
return sTmp;
}
- wxString GetCmd (size_t i)
+ wxString GetCmd(size_t i)
{
- if (i > GetLineCount() ) 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")
+#define TRACE_MIME wxT("mime")
// give trace messages about the results of mailcap tests
-#define TRACE_MIME_TEST _T("mimetest")
+#define TRACE_MIME_TEST wxT("mimetest")
// ----------------------------------------------------------------------------
// private functions
// 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 + wxT("/.gnome");
- if (! wxDir::Exists ( sTmp ) )
- {
- if (!wxMkdir ( sTmp ))
- {
- wxLogError(_("Failed to create directory %s/.gnome."), sTmp.c_str());
- return FALSE;
- }
- }
- sTmp = sTmp + wxT("/mime-info");
- if (! wxDir::Exists ( sTmp ) )
- {
- if (!wxMkdir ( sTmp ))
- {
- wxLogError(_("Failed to create directory %s/mime-info."), sTmp.c_str());
- return FALSE;
- }
- }
- return TRUE;
-
-}
-
-
-
-bool wxMimeTypesManagerImpl::WriteGnomeKeyFile(int index, bool delete_index)
-{
- wxString gnomedir;
- wxGetHomeDir( &gnomedir );
-
- wxMimeTextFile outfile ( gnomedir + wxT("/.gnome/mime-info/user.keys"));
- // if this fails probably Gnome is not installed ??
- // create it anyway as a private mime store
-
-#if defined(__WXGTK20__) && wxUSE_UNICODE
- if (! outfile.Open ( wxConvUTF8) )
-#else
- if (! outfile.Open () )
-#endif
- {
- 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");
- 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);
-
- 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] );
-
- 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;
-}
-
-
-bool wxMimeTypesManagerImpl::WriteGnomeMimeFile(int index, bool delete_index)
-{
- wxString gnomedir;
- wxGetHomeDir( &gnomedir );
-
- wxMimeTextFile outfile ( gnomedir + wxT("/.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,
const wxArrayString& dirs)
{
- wxTextFile textfile(filename);
-#if defined(__WXGTK20__) && wxUSE_UNICODE
- if ( !textfile.Open( wxConvUTF8) )
-#else
+ wxMimeTextFile textfile(filename);
if ( !textfile.Open() )
-#endif
return;
+
wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s ---"),
filename.c_str());
+ wxArrayString search_dirs( dirs );
+
// values for the entry being parsed
wxString curMimeType, curIconFile;
wxMimeTypeCommands * entry = new wxMimeTypeCommands;
- // 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)
+ while ( nLine < nLineCount )
{
pc = textfile[nLine].c_str();
- if ( *pc != _T('#') )
+ if ( *pc != wxT('#') )
{
wxLogTrace(TRACE_MIME, wxT("--- Reading from Gnome file %s '%s' ---"),
- filename.c_str(),pc);
+ filename.c_str(), pc);
+
+ // trim trailing space and tab
+ while ((*pc == wxT(' ')) || (*pc == wxT('\t')))
+ pc++;
wxString sTmp(pc);
- if (sTmp.Contains(wxT("=")) )
+ int equal_pos = sTmp.Find( wxT('=') );
+ if (equal_pos > 0)
{
- // GNOME 1:
- if (sTmp.Contains( wxT("icon-filename=") ) )
- {
- curIconFile = sTmp.AfterFirst(wxT('='));
- }
- // GNOME 2:
- else if (sTmp.Contains( wxT("icon_filename=") ) )
+ wxString left_of_equal = sTmp.Left( equal_pos );
+ const wxChar *right_of_equal = pc;
+ right_of_equal += equal_pos+1;
+
+ if (left_of_equal == wxT("icon_filename"))
{
- curIconFile = sTmp.AfterFirst(wxT('='));
- if (!wxFileExists(curIconFile))
+ // GNOME 2:
+ curIconFile = right_of_equal;
+
+ wxFileName newFile( curIconFile );
+ if (newFile.IsRelative() || newFile.FileExists())
{
- size_t nDirs = dirs.GetCount();
+ size_t nDirs = search_dirs.GetCount();
+
for (size_t nDir = 0; nDir < nDirs; nDir++)
{
- wxString newFile;
- newFile.Printf(wxT("%s/pixmaps/document-icons/%s.png"),
- dirs[nDir].c_str(),
- curIconFile.c_str());
- if (wxFileExists(newFile))
- curIconFile = newFile;
+ newFile.SetPath( search_dirs[nDir] );
+ newFile.AppendDir( wxT("pixmaps") );
+ newFile.AppendDir( wxT("document-icons") );
+ newFile.SetExt( wxT("png") );
+ if (newFile.FileExists())
+ {
+ curIconFile = newFile.GetFullPath();
+ // reorder search_dirs for speedup (fewer
+ // calls to FileExist() required)
+ if (nDir != 0)
+ {
+ const wxString &tmp = search_dirs[nDir];
+ search_dirs.RemoveAt( nDir );
+ search_dirs.Insert( tmp, 0 );
+ }
+ break;
+ }
}
}
}
- else //: some other field,
+ else if (left_of_equal == wxT("open"))
{
- //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");
+ sTmp = right_of_equal;
+ sTmp.Replace( wxT("%f"), wxT("%s") );
+ sTmp.Prepend( wxT("open=") );
+ entry->Add(sTmp);
+ }
+ else if (left_of_equal == wxT("view"))
+ {
+ sTmp = right_of_equal;
+ sTmp.Replace( wxT("%f"), wxT("%s") );
+ sTmp.Prepend( wxT("view=") );
+ entry->Add(sTmp);
+ }
+ else if (left_of_equal == wxT("print"))
+ {
+ sTmp = right_of_equal;
+ sTmp.Replace( wxT("%f"), wxT("%s") );
+ sTmp.Prepend( wxT("print=") );
+ entry->Add(sTmp);
+ }
+ else if (left_of_equal == wxT("description"))
+ {
+ strDesc = right_of_equal;
+ }
+ else if (left_of_equal == wxT("short_list_application_ids_for_novice_user_level"))
+ {
+ sTmp = right_of_equal;
+ if (sTmp.Contains( wxT(",") ))
+ sTmp = sTmp.BeforeFirst( wxT(',') );
+ sTmp.Prepend( wxT("open=") );
+ sTmp.Append( wxT(" %s") );
entry->Add(sTmp);
-
}
} // emd of has an equals sign
// overwrite any existing data
if (! curMimeType.empty())
{
- AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
+ 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 ++;
+ nLine++;
} // end of while, save any data
- if (! curMimeType.empty())
- {
- AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
- }
+ if ( curMimeType.empty() )
+ delete entry;
+ else
+ AddToMimeData( curMimeType, curIconFile, entry, strExtensions, strDesc);
}
-
-
void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& filename)
{
- wxTextFile textfile(filename);
-#if defined(__WXGTK20__) && wxUSE_UNICODE
- if ( !textfile.Open( wxConvUTF8) )
-#else
+ wxMimeTextFile textfile(filename);
if ( !textfile.Open() )
-#endif
return;
- wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s ---"),
- filename.c_str());
+
+ 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++ )
+ for ( size_t nLine = 0; /* nothing */; nLine++ )
{
if ( nLine < nLineCount )
{
if ( !pc || !*pc )
{
// end of the entry
- if ( !!curMimeType && !!curExtList )
+ if ( !curMimeType.empty() && !curExtList.empty() )
{
- wxLogTrace(TRACE_MIME, wxT("--- At end of Gnome file finding mimetype %s ---"),
- curMimeType.c_str());
+ 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
+ // the end: this can only happen if nLine == nLineCount
break;
}
// this is a field=value ling
pc++; // skip leading TAB
- static const int lenField = 4; // strlen("ext:")
- if ( wxStrncmp(pc, wxT("ext:"), lenField) == 0 )
+ static const int lenField = 5; // strlen("ext: ")
+ if ( wxStrncmp(pc, wxT("ext: "), lenField) == 0 )
{
- // skip ' ' which follows and take everything left until the end
- // of line
- curExtList = pc + lenField + 1;
+ // skip it and take everything left until the end of line
+ curExtList = pc + lenField;
}
//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());
+ wxLogTrace(TRACE_MIME,
+ wxT("--- In Gnome file finding mimetype %s ---"),
+ curMimeType.c_str());
if (! curMimeType.empty())
AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(
const wxString& dirbase, const wxArrayString& dirs)
{
- wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
- _T("base directory shouldn't end with a slash") );
+ wxASSERT_MSG( !dirbase.empty() && !wxEndsWithPathSeparator(dirbase),
+ wxT("base directory shouldn't end with a slash") );
wxString dirname = dirbase;
dirname << wxT("/mime-info");
dirname += wxT('/');
wxString filename;
- bool cont = dir.GetFirst(&filename, _T("*.mime"), wxDIR_FILES);
+ bool cont;
+
+ cont = dir.GetFirst(&filename, wxT("*.mime"), wxDIR_FILES);
while ( cont )
{
LoadGnomeMimeTypesFromMimeFile(dirname + filename);
cont = dir.GetNext(&filename);
}
- cont = dir.GetFirst(&filename, _T("*.keys"), wxDIR_FILES);
+ cont = dir.GetFirst(&filename, wxT("*.keys"), wxDIR_FILES);
while ( cont )
{
LoadGnomeDataFromKeyFile(dirname + filename, dirs);
cont = dir.GetNext(&filename);
}
-}
+ // FIXME: Hack alert: We scan all icons and deduce the
+ // mime-type from the file name.
+ dirname = dirbase;
+ dirname << wxT("/pixmaps/document-icons");
+ // these are always empty in this file
+ wxArrayString strExtensions;
+ wxString strDesc;
+ if ( !wxDir::Exists(dirname) )
+ {
+ // Just test for default GPE dir also
+ dirname = wxT("/usr/share/gpe/pixmaps/default/filemanager/document-icons");
+
+ if ( !wxDir::Exists(dirname) )
+ return;
+ }
+
+ wxDir dir2( dirname );
+
+ cont = dir2.GetFirst(&filename, wxT("gnome-*.png"), wxDIR_FILES);
+ while ( cont )
+ {
+ wxString mimeType = filename;
+ mimeType.Remove( 0, 6 ); // remove "gnome-"
+ mimeType.Remove( mimeType.Len() - 4, 4 ); // remove ".png"
+ int pos = mimeType.Find( wxT("-") );
+ if (pos != wxNOT_FOUND)
+ {
+ mimeType.SetChar( pos, wxT('/') );
+ wxString iconFile = dirname;
+ iconFile << wxT("/");
+ iconFile << filename;
+ AddToMimeData( mimeType, iconFile, NULL, strExtensions, strDesc, true );
+ }
+
+ cont = dir2.GetNext(&filename);
+ }
+}
void wxMimeTypesManagerImpl::GetGnomeMimeInfo(const wxString& sExtraDir)
{
wxArrayString dirs;
+
+ wxString gnomedir = wxGetenv( wxT("GNOMEDIR") );
+ if (!gnomedir.empty())
+ {
+ gnomedir << wxT("/share");
+ dirs.Add( gnomedir );
+ }
+
dirs.Add(wxT("/usr/share"));
dirs.Add(wxT("/usr/local/share"));
- wxString gnomedir;
- wxGetHomeDir( &gnomedir );
- gnomedir += wxT("/.gnome");
+ gnomedir = wxGetHomeDir();
+ gnomedir << wxT("/.gnome");
dirs.Add( gnomedir );
- if (!sExtraDir.empty()) dirs.Add( sExtraDir );
+
+ if (!sExtraDir.empty())
+ dirs.Add( sExtraDir );
size_t nDirs = dirs.GetCount();
for ( size_t nDir = 0; nDir < nDirs; nDir++ )
// 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 )
-
- {
+bool wxMimeTypesManagerImpl::CheckKDEDirsExist( const wxString &sOK, const wxString &sTest )
+{
if (sTest.empty())
- {
- if (wxDir::Exists(sOK)) return TRUE;
- else return FALSE;
- }
+ {
+ return wxDir::Exists(sOK);
+ }
else
- {
- wxString sStart = sOK + wxT("/") + sTest.BeforeFirst(wxT('/'));
- if (!wxDir::Exists(sStart)) wxMkdir(sStart);
- wxString sEnd = sTest.AfterFirst(wxT('/'));
- return CheckKDEDirsExist(sStart, sEnd);
+ {
+ wxString sStart = sOK + wxT("/") + sTest.BeforeFirst(wxT('/'));
+ if (!wxDir::Exists(sStart))
+ wxMkdir(sStart);
+ wxString sEnd = sTest.AfterFirst(wxT('/'));
+ return CheckKDEDirsExist(sStart, sEnd);
}
}
wxString sHome = wxGetHomeDir();
wxString sTmp = wxT(".kde/share/mimelnk/");
wxString sMime = m_aTypes[index];
- CheckKDEDirsExist (sHome, sTmp + sMime.BeforeFirst(wxT('/')) );
+ CheckKDEDirsExist(sHome, sTmp + sMime.BeforeFirst(wxT('/')) );
sTmp = sHome + wxT('/') + sTmp + sMime + wxT(".kdelnk");
bool bTemp;
- bool bMimeExists = mimeoutfile.Open (sTmp);
+ bool bMimeExists = mimeoutfile.Open(sTmp);
if (!bMimeExists)
{
- bTemp = mimeoutfile.Create (sTmp);
+ bTemp = mimeoutfile.Create(sTmp);
// some unknown error eg out of disk space
- if (!bTemp) return FALSE;
+ if (!bTemp)
+ return false;
}
sTmp = wxT(".kde/share/applnk/");
- CheckKDEDirsExist (sHome, sTmp + sMime.AfterFirst(wxT('/')) );
+ CheckKDEDirsExist(sHome, sTmp + sMime.AfterFirst(wxT('/')) );
sTmp = sHome + wxT('/') + sTmp + sMime.AfterFirst(wxT('/')) + wxT(".kdelnk");
bool bAppExists;
- bAppExists = appoutfile.Open (sTmp);
+ bAppExists = appoutfile.Open(sTmp);
if (!bAppExists)
{
- bTemp = appoutfile.Create (sTmp);
+ bTemp = appoutfile.Create(sTmp);
// some unknown error eg out of disk space
- if (!bTemp) return FALSE;
+ if (!bTemp)
+ return false;
}
// fixed data; write if new file
// 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 );
+ 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(" "));
+ wxStringTokenizer tokenizer(sTmp, wxT(" "));
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;
+ sTmp += e;
}
- if (!delete_index) mimeoutfile.AddLine(sTmp);
+
+ if (!delete_index)
+ mimeoutfile.AddLine(sTmp);
wxMimeTypeCommands * entries = m_aEntries[index];
// if we don't find open just have an empty string ... FIX this
- sTmp = entries->GetCommandForVerb(_T("open"));
+ sTmp = entries->GetCommandForVerb(wxT("open"));
sTmp.Replace( wxT("%s"), wxT("%f") );
mimeoutfile.CommentLine(wxT("DefaultApp=") );
- if (!delete_index) mimeoutfile.AddLine(wxT("DefaultApp=") + sTmp);
+ 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 (!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;
+ 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& filename,
const wxArrayString& icondirs)
{
+ wxFileName fullname(dirbase, filename);
+ wxLogTrace(TRACE_MIME, wxT("loading KDE file %s"),
+ fullname.GetFullPath().c_str());
+
wxMimeTextFile file;
- if ( !file.Open(dirbase + filename) ) return;
+ if ( !file.Open(fullname.GetFullPath()) )
+ return;
- wxLogTrace(TRACE_MIME, wxT("loading KDE file %s"),
- (dirbase+filename).c_str());
-
wxMimeTypeCommands * entry = new wxMimeTypeCommands;
wxArrayString sExts;
wxString mimetype, mime_desc, strIcon;
// file (it always has .kdelnk extension)
mimetype << subdir << wxT('/') << filename.BeforeLast( wxT('.') );
}
- else mimetype = file.GetCmd (nIndex);
+ else
+ mimetype = file.GetCmd(nIndex);
// first find the description string: it is the value in either "Comment="
// line or "Comment[<locale_name>]=" 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("]=");
+ comment << wxT("Comment[") + locale->GetName() + wxT("]=");
nIndex = file.pIndexOf(comment);
}
-#endif // wxUSE_INTL
+#endif
if ( nIndex == wxNOT_FOUND )
{
- comment = _T("Comment=");
+ comment = wxT("Comment=");
nIndex = file.pIndexOf(comment);
}
- if ( nIndex != wxNOT_FOUND ) mime_desc = file.GetCmd(nIndex);
+ if ( nIndex != wxNOT_FOUND )
+ mime_desc = file.GetCmd(nIndex);
//else: no description
// next find the extensions
wxString mime_extension;
- nIndex = file.pIndexOf(_T("Patterns="));
+ nIndex = file.pIndexOf(wxT("Patterns="));
if ( nIndex != wxNOT_FOUND )
{
- wxString exts = file.GetCmd (nIndex);;
+ wxString exts = file.GetCmd(nIndex);
- wxStringTokenizer tokenizer(exts, _T(";"));
+ wxStringTokenizer tokenizer(exts, wxT(";"));
while ( tokenizer.HasMoreTokens() )
{
wxString e = tokenizer.GetNextToken();
- if ( e.Left(2) != _T("*.") )
- continue; // don't support too difficult patterns
+
+ // don't support too difficult patterns
+ if ( e.Left(2) != wxT("*.") )
+ continue;
if ( !mime_extension.empty() )
{
// separate from the previous ext
- mime_extension << _T(' ');
+ mime_extension << wxT(' ');
}
mime_extension << e.Mid(2);
}
}
- sExts.Add(mime_extension);
+ sExts.Add(mime_extension);
// ok, now we can take care of icon:
- nIndex = file.pIndexOf(_T("Icon="));
+ nIndex = file.pIndexOf(wxT("Icon="));
if ( nIndex != wxNOT_FOUND )
{
strIcon = file.GetCmd(nIndex);
+
wxLogTrace(TRACE_MIME, wxT(" icon %s"), strIcon.c_str());
- //it could be the real path, but more often a short name
+
+ // it could be the real path, but more often a short name
if (!wxFileExists(strIcon))
{
// icon is just the short name
// 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))
+ {
+ wxFileName fnameIcon( strIcon );
+ wxFileName fname( icondirs[nDir], fnameIcon.GetName() );
+ fname.SetExt( wxT("png") );
+ if (fname.FileExists())
{
- strIcon.Prepend(icondirs[nDir]);
+ strIcon = fname.GetFullPath();
wxLogTrace(TRACE_MIME, wxT(" iconfile %s"), strIcon.c_str());
break;
}
+ }
}
}
}
+
// now look for lines which know about the application
// exec= or DefaultApp=
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->AddOrReplaceVerb (wxString(wxT("open")), sTmp );
+ wxString sTmp = file.GetCmd(nIndex);
+ if (0 == sTmp.Replace( wxT("%f"), wxT("%s") ))
+ sTmp += wxT(" %s");
+ entry->AddOrReplaceVerb(wxString(wxT("open")), sTmp );
}
- AddToMimeData (mimetype, strIcon, entry, sExts, mime_desc);
+ 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() )
+ wxFileName dirname(dirbase, wxEmptyString);
+ dirname.AppendDir(subdir);
+ wxDir dir(dirname.GetPath());
+ if(! dir.IsOpened())
return;
wxLogTrace(TRACE_MIME, wxT("--- Loading from KDE directory %s ---"),
- dirname.c_str());
-
- dirname += _T('/');
+ dirname.GetPath().c_str());
wxString filename;
- bool cont = dir.GetFirst(&filename, _T("*.kdelnk"), wxDIR_FILES);
- while ( cont )
- {
- LoadKDELinksForMimeSubtype(dirname, subdir, filename, icondirs);
-
+ bool cont = dir.GetFirst(&filename, wxT("*.kdelnk"), wxDIR_FILES);
+ while(cont) {
+ LoadKDELinksForMimeSubtype(dirname.GetPath(), 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);
+ // new standard for Gnome and KDE
+ cont = dir.GetFirst(&filename, wxT("*.desktop"), wxDIR_FILES);
+ while(cont) {
+ LoadKDELinksForMimeSubtype(dirname.GetPath(), subdir,
+ filename, icondirs);
cont = dir.GetNext(&filename);
}
}
-void wxMimeTypesManagerImpl::LoadKDELinkFilesFromDir(const wxString& dirbase,
+void wxMimeTypesManagerImpl::LoadKDELinkFilesFromDir(const wxString& dirname,
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) )
+ 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 )
}
}
-void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)
+// Read a KDE .desktop file of type 'Application'
+void wxMimeTypesManagerImpl::LoadKDEApp(const wxString& filename)
{
- wxArrayString dirs;
- wxArrayString icondirs;
+ wxLogTrace(TRACE_MIME, wxT("loading KDE file %s"), filename.c_str());
- // settings in ~/.kde have maximal priority
- dirs.Add(wxGetHomeDir() + wxT("/.kde/share"));
- icondirs.Add(wxGetHomeDir() + wxT("/.kde/share/icons/"));
+ wxMimeTextFile file;
+ if ( !file.Open(filename) )
+ return;
- // the variable KDEDIR is set when KDE is running
- const wxChar *kdedir = wxGetenv( wxT("KDEDIR") );
- if ( kdedir )
- {
- dirs.Add( wxString(kdedir) + wxT("/share") );
- icondirs.Add( wxString(kdedir) + wxT("/share/icons/") );
+ // Here, only type 'Application' should be considered.
+ int nIndex = file.pIndexOf( wxT("Type=") );
+ if (nIndex != wxNOT_FOUND &&
+ file.GetCmd(nIndex).Lower() != wxT("application"))
+ return;
+
+ // The hidden entry specifies a file to be ignored.
+ nIndex = file.pIndexOf( wxT("Hidden=") );
+ if (nIndex != wxNOT_FOUND && file.GetCmd(nIndex).Lower() == wxT("true"))
+ return;
+
+ // Semicolon separated list of mime types handled by the application.
+ nIndex = file.pIndexOf( wxT("MimeType=") );
+ if (nIndex == wxNOT_FOUND)
+ return;
+ wxString mimetypes = file.GetCmd (nIndex);
+
+ // Name of the application
+ wxString nameapp;
+ nIndex = wxNOT_FOUND;
+#if wxUSE_INTL // try "Name[locale name]" first
+ wxLocale *locale = wxGetLocale();
+ if ( locale )
+ nIndex = file.pIndexOf(_T("Name[")+locale->GetName()+_T("]="));
+#endif // wxUSE_INTL
+ if(nIndex == wxNOT_FOUND)
+ nIndex = file.pIndexOf( wxT("Name=") );
+ if(nIndex != wxNOT_FOUND)
+ nameapp = file.GetCmd(nIndex);
+
+ // Icon of the application.
+ wxString nameicon, namemini;
+ nIndex = wxNOT_FOUND;
+#if wxUSE_INTL // try "Icon[locale name]" first
+ if ( locale )
+ nIndex = file.pIndexOf(_T("Icon[")+locale->GetName()+_T("]="));
+#endif // wxUSE_INTL
+ if(nIndex == wxNOT_FOUND)
+ nIndex = file.pIndexOf( wxT("Icon=") );
+ if(nIndex != wxNOT_FOUND) {
+ nameicon = wxString(wxT("--icon ")) + file.GetCmd(nIndex);
+ namemini = wxString(wxT("--miniicon ")) + file.GetCmd(nIndex);
}
- 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/"));
+
+ // Replace some of the field code in the 'Exec' entry.
+ // TODO: deal with %d, %D, %n, %N, %k and %v (but last one is deprecated)
+ nIndex = file.pIndexOf( wxT("Exec=") );
+ if (nIndex == wxNOT_FOUND)
+ return;
+ wxString sCmd = file.GetCmd(nIndex);
+ // we expect %f; others including %F and %U and %u are possible
+ sCmd.Replace(wxT("%F"), wxT("%f"));
+ sCmd.Replace(wxT("%U"), wxT("%f"));
+ sCmd.Replace(wxT("%u"), wxT("%f"));
+ if (0 == sCmd.Replace ( wxT("%f"), wxT("%s") ))
+ sCmd = sCmd + wxT(" %s");
+ sCmd.Replace(wxT("%c"), nameapp);
+ sCmd.Replace(wxT("%i"), nameicon);
+ sCmd.Replace(wxT("%m"), namemini);
+
+ wxStringTokenizer tokenizer(mimetypes, _T(";"));
+ while(tokenizer.HasMoreTokens()) {
+ wxString mimetype = tokenizer.GetNextToken().Lower();
+ nIndex = m_aTypes.Index(mimetype);
+ if(nIndex != wxNOT_FOUND) { // is this a known MIME type?
+ wxMimeTypeCommands* entry = m_aEntries[nIndex];
+ entry->AddOrReplaceVerb(wxT("open"), sCmd);
+ }
}
+}
- if (!sExtraDir.empty()) dirs.Add (sExtraDir);
- icondirs.Add(sExtraDir + wxT("/icons"));
+void wxMimeTypesManagerImpl::LoadKDEAppsFilesFromDir(const wxString& dirname)
+{
+ if(! wxDir::Exists(dirname))
+ return;
+ wxDir dir(dirname);
+ if ( !dir.IsOpened() )
+ return;
- size_t nDirs = dirs.GetCount();
- for ( size_t nDir = 0; nDir < nDirs; nDir++ )
+ wxString filename;
+ // Look into .desktop files
+ bool cont = dir.GetFirst(&filename, _T("*.desktop"), wxDIR_FILES);
+ while(cont) {
+ wxFileName p(dirname, filename);
+ LoadKDEApp( p.GetFullPath() );
+ cont = dir.GetNext(&filename);
+ }
+ // Look recursively into subdirs
+ cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
+ while(cont) {
+ wxFileName p(dirname, wxEmptyString);
+ p.AppendDir(filename);
+ LoadKDEAppsFilesFromDir( p.GetPath() );
+ cont = dir.GetNext(&filename);
+ }
+}
+
+// Return base KDE directories.
+// 1) Environment variable $KDEHOME, or "~/.kde" if not set.
+// 2) List of directories in colon separated environment variable $KDEDIRS.
+// 3) Environment variable $KDEDIR in case $KDEDIRS is not set.
+// Notice at least the local kde directory is added to the list. If it is the
+// only one, use later the application 'kde-config' to get additional paths.
+static void GetKDEBaseDirs(wxArrayString& basedirs)
+{
+ wxString env = wxGetenv( wxT("KDEHOME") );
+ if(env.IsEmpty())
+ env = wxGetHomeDir() + wxT("/.kde");
+ basedirs.Add(env);
+
+ env = wxGetenv( wxT("KDEDIRS") );
+ if(env.IsEmpty()) {
+ env = wxGetenv( wxT("KDEDIR") );
+ if(! env.IsEmpty())
+ basedirs.Add(env);
+ } else {
+ wxStringTokenizer tokenizer(env, wxT(":"));
+ while(tokenizer.HasMoreTokens())
+ basedirs.Add( tokenizer.GetNextToken() );
+ }
+}
+
+static wxString ReadPathFromKDEConfig(const wxString& request)
+{
+ wxString str;
+ wxArrayString output;
+ if(wxExecute(wxT("kde-config --path ")+request, output) == 0 &&
+ output.GetCount() > 0)
+ str = output.Item(0);
+ return str;
+}
+
+// Try to find the "Theme" entry in the configuration file, provided it exists.
+static wxString GetKDEThemeInFile(const wxFileName& filename)
+{
+ wxString theme;
+ wxMimeTextFile config;
+ if ( filename.FileExists() && config.Open(filename.GetFullPath()) )
{
- LoadKDELinkFilesFromDir(dirs[nDir], icondirs);
+ size_t cnt = config.GetLineCount();
+ for ( size_t i = 0; i < cnt; i++ )
+ {
+ if ( config[i].StartsWith(wxT("Theme="), &theme) )
+ break;
+ }
+ }
+
+ return theme;
+}
+
+// Try to find a file "kdeglobals" in one of the directories and read the
+// "Theme" entry there.
+static wxString GetKDETheme(const wxArrayString& basedirs)
+{
+ wxString theme;
+ for(size_t i = 0; i < basedirs.GetCount(); i++) {
+ wxFileName filename(basedirs.Item(i), wxEmptyString);
+ filename.AppendDir( wxT("share") );
+ filename.AppendDir( wxT("config") );
+ filename.SetName( wxT("kdeglobals") );
+ theme = GetKDEThemeInFile(filename);
+ if(! theme.IsEmpty())
+ return theme;
+ }
+ // If $KDEDIRS and $KDEDIR were set, we try nothing more. Otherwise, we
+ // try to get the configuration file with 'kde-config'.
+ if(basedirs.GetCount() > 1)
+ return theme;
+ wxString paths = ReadPathFromKDEConfig(wxT("config"));
+ if(! paths.IsEmpty()) {
+ wxStringTokenizer tokenizer(paths, wxT(":"));
+ while( tokenizer.HasMoreTokens() ) {
+ wxFileName filename(tokenizer.GetNextToken(), wxT("kdeglobals"));
+ theme = GetKDEThemeInFile(filename);
+ if(! theme.IsEmpty())
+ return theme;
+ }
+ }
+ return theme;
+}
+
+// Get list of directories of icons.
+static void GetKDEIconDirs(const wxArrayString& basedirs,
+ wxArrayString& icondirs)
+{
+ wxString theme = GetKDETheme(basedirs);
+ if(theme.IsEmpty())
+ theme = wxT("default.kde");
+
+ for(size_t i = 0; i < basedirs.GetCount(); i++) {
+ wxFileName dirname(basedirs.Item(i), wxEmptyString);
+ dirname.AppendDir( wxT("share") );
+ dirname.AppendDir( wxT("icons") );
+ dirname.AppendDir(theme);
+ dirname.AppendDir( wxT("32x32") );
+ dirname.AppendDir( wxT("mimetypes") );
+ if( wxDir::Exists( dirname.GetPath() ) )
+ icondirs.Add( dirname.GetPath() );
+ }
+
+ // If $KDEDIRS and $KDEDIR were not set, use 'kde-config'
+ if(basedirs.GetCount() > 1)
+ return;
+ wxString paths = ReadPathFromKDEConfig(wxT("icon"));
+ if(! paths.IsEmpty()) {
+ wxStringTokenizer tokenizer(paths, wxT(":"));
+ while( tokenizer.HasMoreTokens() ) {
+ wxFileName dirname(tokenizer.GetNextToken(), wxEmptyString);
+ dirname.AppendDir(theme);
+ dirname.AppendDir( wxT("32x32") );
+ dirname.AppendDir( wxT("mimetypes") );
+ if(icondirs.Index(dirname.GetPath()) == wxNOT_FOUND &&
+ wxDir::Exists( dirname.GetPath() ) )
+ icondirs.Add( dirname.GetPath() );
+ }
+ }
+}
+
+// Get list of directories of mime types.
+static void GetKDEMimeDirs(const wxArrayString& basedirs,
+ wxArrayString& mimedirs)
+{
+ for(size_t i = 0; i < basedirs.GetCount(); i++) {
+ wxFileName dirname(basedirs.Item(i), wxEmptyString);
+ dirname.AppendDir( wxT("share") );
+ dirname.AppendDir( wxT("mimelnk") );
+ if( wxDir::Exists( dirname.GetPath() ) )
+ mimedirs.Add( dirname.GetPath() );
}
+
+ // If $KDEDIRS and $KDEDIR were not set, use 'kde-config'
+ if(basedirs.GetCount() > 1)
+ return;
+ wxString paths = ReadPathFromKDEConfig(wxT("mime"));
+ if(! paths.IsEmpty()) {
+ wxStringTokenizer tokenizer(paths, wxT(":"));
+ while( tokenizer.HasMoreTokens() ) {
+ wxFileName p(tokenizer.GetNextToken(), wxEmptyString);
+ wxString dirname = p.GetPath(); // To remove possible trailing '/'
+ if(mimedirs.Index(dirname) == wxNOT_FOUND &&
+ wxDir::Exists(dirname) )
+ mimedirs.Add(dirname);
+ }
+ }
+}
+
+// Get list of directories of application desktop files.
+static void GetKDEAppsDirs(const wxArrayString& basedirs,
+ wxArrayString& appsdirs)
+{
+ for(size_t i = 0; i < basedirs.GetCount(); i++) {
+ wxFileName dirname(basedirs.Item(i), wxEmptyString);
+ dirname.AppendDir( wxT("share") );
+ dirname.AppendDir( wxT("applnk") );
+ if( wxDir::Exists( dirname.GetPath() ) )
+ appsdirs.Add( dirname.GetPath() );
+ }
+
+ // If $KDEDIRS and $KDEDIR were not set, use 'kde-config'
+ if(basedirs.GetCount() > 1)
+ return;
+ wxString paths = ReadPathFromKDEConfig(wxT("apps"));
+ if(! paths.IsEmpty()) {
+ wxStringTokenizer tokenizer(paths, wxT(":"));
+ while( tokenizer.HasMoreTokens() ) {
+ wxFileName p(tokenizer.GetNextToken(), wxEmptyString);
+ wxString dirname = p.GetPath(); // To remove possible trailing '/'
+ if(appsdirs.Index(dirname) == wxNOT_FOUND &&
+ wxDir::Exists(dirname) )
+ appsdirs.Add(dirname);
+ }
+ }
+ paths = ReadPathFromKDEConfig(wxT("xdgdata-apps"));
+ if(! paths.IsEmpty()) {
+ wxStringTokenizer tokenizer(paths, wxT(":"));
+ while( tokenizer.HasMoreTokens() ) {
+ wxFileName p(tokenizer.GetNextToken(), wxEmptyString);
+ wxString dirname = p.GetPath(); // To remove possible trailing '/'
+ if(appsdirs.Index(dirname) == wxNOT_FOUND &&
+ wxDir::Exists(dirname) )
+ appsdirs.Add(dirname);
+ }
+ }
+}
+
+// Fill database with all mime types.
+void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)
+{
+ wxArrayString basedirs;
+ GetKDEBaseDirs(basedirs);
+
+ wxArrayString icondirs;
+ GetKDEIconDirs(basedirs, icondirs);
+ wxArrayString mimedirs;
+ GetKDEMimeDirs(basedirs, mimedirs);
+ wxArrayString appsdirs;
+ GetKDEAppsDirs(basedirs, appsdirs);
+
+ if(! sExtraDir.IsEmpty()) {
+ icondirs.Add(sExtraDir + wxT("/icons"));
+ mimedirs.Add(sExtraDir + wxT("/mimelnk"));
+ appsdirs.Add(sExtraDir + wxT("/applnk"));
+ }
+
+ // Load mime types
+ size_t nDirs = mimedirs.GetCount(), nDir;
+ for(nDir = 0; nDir < nDirs; nDir++)
+ LoadKDELinkFilesFromDir(mimedirs[nDir], icondirs);
+
+ // Load application files and associate them to corresponding mime types.
+ nDirs = appsdirs.GetCount();
+ for(nDir = 0; nDir < nDirs; nDir++)
+ LoadKDEAppsFilesFromDir(appsdirs[nDir]);
}
// ----------------------------------------------------------------------------
size_t i = 0;
while ( (i < m_index.GetCount() ) && sTmp.empty() )
{
- sTmp = m_manager->GetCommand ( verb, m_index[i] );
- i ++;
+ 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
-
+bool wxFileTypeImpl::GetIcon(wxIconLocation *iconLoc) const
{
-#if wxUSE_GUI
wxString sTmp;
size_t i = 0;
while ( (i < m_index.GetCount() ) && sTmp.empty() )
{
sTmp = m_manager->m_aIcons[m_index[i]];
- i ++;
+ i++;
}
- if ( sTmp.empty () ) return FALSE;
- wxIcon icn;
+ if ( sTmp.empty() )
+ return false;
- if (sTmp.Right(4).MakeUpper() == _T(".XPM"))
- icn = wxIcon(sTmp);
- else
- icn = wxIcon(sTmp, wxBITMAP_TYPE_ANY);
-
- if ( icn.Ok() )
+ if ( iconLoc )
{
- *icon = icn;
- if (iconFile) *iconFile = sTmp;
- if (iconIndex) *iconIndex = 0;
- return TRUE;
+ iconLoc->SetFileName(sTmp);
}
-#endif // wxUSE_GUI
- return FALSE;
+ return true;
}
-
-bool
-wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
+bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
{
mimeTypes.Clear();
- for (size_t i = 0; i < m_index.GetCount(); i++)
+ size_t nCount = m_index.GetCount();
+ for (size_t i = 0; i < nCount; i++)
mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);
- return TRUE;
-}
+ return true;
+}
size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
wxArrayString *commands,
const wxFileType::MessageParameters& params) const
{
-
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++)
+ 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++ )
+ 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() )
{
- 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);
- }
- }
-
+ cmd = wxFileType::ExpandCommand(cmd, params);
+ count++;
+ if ( vrb.IsSameAs(wxT("open")))
+ {
+ if ( verbs )
+ verbs->Insert(vrb, 0u);
+ if ( commands )
+ commands ->Insert(cmd, 0u);
+ }
+ else
+ {
+ if ( verbs )
+ verbs->Add(vrb);
+ if ( commands )
+ commands->Add(cmd);
+ }
+ }
}
-
}
- return count;
+ return count;
}
bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
{
- wxString strExtensions = m_manager->GetExtension(m_index[0]);
+ const wxString strExtensions = m_manager->GetExtension(m_index[0]);
extensions.Empty();
- // one extension in the space or comma delimitid list
+ // one extension in the space or comma-delimited list
wxString strExt;
- for ( const wxChar *p = strExtensions;; p++ ) {
- if ( *p == wxT(' ') || *p == wxT(',') || *p == wxT('\0') ) {
- if ( !strExt.empty() ) {
+ wxString::const_iterator end = strExtensions.end();
+ for ( wxString::const_iterator p = strExtensions.begin(); /* nothing */; ++p )
+ {
+ if ( p == end || *p == wxT(' ') || *p == wxT(',') )
+ {
+ if ( !strExt.empty() )
+ {
extensions.Add(strExt);
strExt.Empty();
}
- //else: repeated spaces (shouldn't happen, but it's not that
- // important if it does happen)
+ //else: repeated spaces
+ // (shouldn't happen, but it's not that important if it does happen)
- if ( *p == wxT('\0') )
+ if ( p == end )
break;
}
- else if ( *p == wxT('.') ) {
+ else if ( *p == wxT('.') )
+ {
// remove the dot from extension (but only if it's the first char)
- if ( !strExt.empty() ) {
+ if ( !strExt.empty() )
+ {
strExt += wxT('.');
}
//else: no, don't append it
}
- else {
+ else
+ {
strExt += *p;
}
}
- return TRUE;
+ return true;
}
-// set an arbitrary command,
+// 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
+// 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*/)
+bool
+wxFileTypeImpl::SetCommand(const wxString& cmd,
+ const wxString& verb,
+ bool WXUNUSED(overwriteprompt))
{
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;
+ GetMimeTypes(strTypes);
+ if ( strTypes.IsEmpty() )
+ 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;
+ wxMimeTypeCommands *entry = new wxMimeTypeCommands();
+ entry->Add(verb + wxT("=") + cmd + wxT(" %s "));
+
+ bool ok = false;
+ size_t nCount = strTypes.GetCount();
+ for ( size_t i = 0; i < nCount; i++ )
+ {
+ if ( m_manager->DoAssociation
+ (
+ strTypes[i],
+ strIcon,
+ entry,
+ strExtensions,
+ strDesc
+ ) )
+ {
+ // DoAssociation() took ownership of entry, don't delete it below
+ ok = true;
+ }
}
- return Ok;
+ if ( !ok )
+ delete entry;
+
+ 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*/)
+// ignore index on the grounds that we only have one icon in a Unix file
+bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int WXUNUSED(index))
{
- if (strIcon.empty()) return FALSE;
+ if (strIcon.empty())
+ return false;
+
wxArrayString strExtensions;
wxString strDesc;
- 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++)
- {
- if (!m_manager->DoAssociation (strTypes[i], strIcon, entry, strExtensions, strDesc))
- Ok = FALSE;
+ GetMimeTypes(strTypes);
+ if ( strTypes.IsEmpty() )
+ return false;
+
+ wxMimeTypeCommands *entry = new wxMimeTypeCommands();
+ bool ok = false;
+ size_t nCount = strTypes.GetCount();
+ for ( size_t i = 0; i < nCount; i++ )
+ {
+ if ( m_manager->DoAssociation
+ (
+ strTypes[i],
+ strIcon,
+ entry,
+ strExtensions,
+ strDesc
+ ) )
+ {
+ // we don't need to free entry now, DoAssociation() took ownership
+ // of it
+ ok = true;
+ }
}
- return Ok;
+ if ( !ok )
+ delete entry;
+
+ return ok;
}
// ----------------------------------------------------------------------------
// wxMimeTypesManagerImpl (Unix)
// ----------------------------------------------------------------------------
-
wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
{
- m_initialized = FALSE;
+ m_initialized = false;
m_mailcapStylesInited = 0;
}
+void wxMimeTypesManagerImpl::InitIfNeeded()
+{
+ if ( !m_initialized )
+ {
+ // set the flag first to prevent recursion
+ m_initialized = true;
+
+ wxString wm = wxTheApp->GetTraits()->GetDesktopEnvironment();
+
+ if (wm == wxT("KDE"))
+ Initialize( wxMAILCAP_KDE );
+ else if (wm == wxT("GNOME"))
+ Initialize( wxMAILCAP_GNOME );
+ else
+ Initialize();
+ }
+}
+
// read system and user mailcaps and other files
void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
const wxString& sExtraDir)
GetMimeInfo(sExtraDir);
// read GNOME tables
- if ( mailcapStyles & wxMAILCAP_GNOME)
+ if (mailcapStyles & wxMAILCAP_GNOME)
GetGnomeMimeInfo(sExtraDir);
- // read KDE tables
- if ( mailcapStyles & wxMAILCAP_KDE)
+ // read KDE tables which are never installed on OpenVMS
+#ifndef __VMS
+ if (mailcapStyles & wxMAILCAP_KDE)
GetKDEMimeInfo(sExtraDir);
+#endif
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_aTypes.Clear();
+ m_aIcons.Clear();
+ m_aExtensions.Clear();
+ m_aDescriptions.Clear();
WX_CLEAR_ARRAY(m_aEntries);
m_aEntries.Empty();
ClearData();
}
-
-void wxMimeTypesManagerImpl::GetMimeInfo (const wxString& sExtraDir)
+void wxMimeTypesManagerImpl::GetMimeInfo(const wxString& sExtraDir)
{
// read this for netscape or Metamail formats
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("/") );
-
+ 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("/") );
+
+ wxString file;
size_t nDirs = dirs.GetCount();
for ( size_t nDir = 0; nDir < nDirs; nDir++ )
{
- wxString file = dirs[nDir] + wxT("mailcap");
- if ( wxFile::Exists(file) ) {
+ file = dirs[nDir];
+ file += wxT("mailcap");
+ if ( wxFile::Exists(file) )
+ {
ReadMailcap(file);
}
- file = dirs[nDir] + wxT("mime.types");
- if ( wxFile::Exists(file) ) {
+ file = dirs[nDir];
+ file += wxT("mime.types");
+ if ( wxFile::Exists(file) )
ReadMimeTypes(file);
- }
}
-
}
-bool wxMimeTypesManagerImpl::WriteToMimeTypes (int index, bool delete_index)
+bool wxMimeTypesManagerImpl::WriteToMimeTypes(int index, bool delete_index)
{
// check we have the right manager
if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD) )
- return FALSE;
+ return false;
bool bTemp;
wxString strHome = wxGetenv(wxT("HOME"));
wxMimeTextFile file;
if ( wxFile::Exists(strUserMailcap) )
{
- bTemp = file.Open(strUserMailcap);
+ bTemp = file.Open(strUserMailcap);
}
else
{
- if (delete_index) return FALSE;
+ 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"));
+ // 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;
+ wxFAIL_MSG(wxT("Error in .mime.types\nTrying to mix Netscape and Metamail formats\nFile not modified"));
+ return false;
}
+
// write it in alternative format
// get rid of unwanted entries
wxString strType = m_aTypes[index];
- nIndex = file.pIndexOf (strType);
+ nIndex = file.pIndexOf(strType);
+
// get rid of all the unwanted entries...
- if (nIndex != wxNOT_FOUND) file.CommentLine (nIndex);
+ 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);
+ wxString sTmp = strType.Append( wxT(' '), 40 - strType.Len() );
+ sTmp += m_aExtensions[index];
+ file.AddLine(sTmp);
}
-
- bTemp = file.Write ();
- file.Close ();
+ bTemp = file.Write();
+ file.Close();
}
+
return bTemp;
}
-bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
+bool wxMimeTypesManagerImpl::WriteToNSMimeTypes(int index, bool delete_index)
{
//check we have the right managers
if (! ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) )
- return FALSE;
+ return false;
bool bTemp;
wxString strHome = wxGetenv(wxT("HOME"));
wxMimeTextFile file;
if ( wxFile::Exists(strUserMailcap) )
{
- bTemp = file.Open(strUserMailcap);
+ bTemp = file.Open(strUserMailcap);
}
else
{
- if (delete_index) return FALSE;
+ 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);
+ // 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)
+ 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;
+ wxFAIL_MSG(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);
+
+ file.InsertLine(wxT( "#--Netscape Communications Corporation MIME Information" ), 0);
nIndex = 0;
}
wxString strType = wxT("type=") + m_aTypes[index];
- nIndex = file.pIndexOf (strType);
+ nIndex = file.pIndexOf(strType);
+
// get rid of all the unwanted entries...
if (nIndex != wxNOT_FOUND)
{
{
file.CommentLine(nIndex);
sOld = file[nIndex];
+
wxLogTrace(TRACE_MIME, wxT("--- Deleting from mime.types line '%d %s' ---"), nIndex, sOld.c_str());
- nIndex ++;
+
+ nIndex++;
}
- if (nIndex < (int) file.GetLineCount()) file.CommentLine (nIndex);
+
+ if (nIndex < (int) file.GetLineCount())
+ file.CommentLine(nIndex);
}
- else nIndex = (int) file.GetLineCount();
+ else
+ nIndex = (int) file.GetLineCount();
wxString sTmp = strType + wxT(" \\");
- if (!delete_index) file.InsertLine (sTmp, nIndex);
+ if (!delete_index)
+ file.InsertLine(sTmp, nIndex);
+
if ( ! m_aDescriptions.Item(index).empty() )
{
- sTmp = wxT("desc=\"") + m_aDescriptions[index]+ wxT("\" \\"); //.trim ??
+ sTmp = wxT("desc=\"") + m_aDescriptions[index]+ wxT("\" \\"); //.trim ??
if (!delete_index)
{
- nIndex ++;
- file.InsertLine (sTmp, nIndex);
+ nIndex++;
+ file.InsertLine(sTmp, nIndex);
}
}
- wxString sExts = m_aExtensions.Item(index);
- sTmp = wxT("exts=\"") + sExts.Trim(FALSE).Trim() + wxT("\"");
+
+ wxString sExts = m_aExtensions.Item(index);
+ sTmp = wxT("exts=\"") + sExts.Trim(false).Trim() + wxT("\"");
if (!delete_index)
{
- nIndex ++;
- file.InsertLine (sTmp, nIndex);
+ nIndex++;
+ file.InsertLine(sTmp, nIndex);
}
- bTemp = file.Write ();
- file.Close ();
+ bTemp = file.Write();
+ file.Close();
}
+
return bTemp;
}
-
-bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
+bool wxMimeTypesManagerImpl::WriteToMailCap(int index, bool delete_index)
{
//check we have the right managers
if ( !( ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) ||
( m_mailcapStylesInited & wxMAILCAP_STANDARD) ) )
- return FALSE;
+ return false;
- bool bTemp;
+ bool bTemp = false;
wxString strHome = wxGetenv(wxT("HOME"));
// and now the users mailcap
wxMimeTextFile file;
if ( wxFile::Exists(strUserMailcap) )
{
- bTemp = file.Open(strUserMailcap);
+ bTemp = file.Open(strUserMailcap);
}
else
{
- if (delete_index) return FALSE;
+ 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 sCmd = entries->GetCommandForVerb(wxT("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)
{
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())
+ sOld = sOld + file[nIndex];
}
- if (nIndex < (int) file.GetLineCount()) file.CommentLine (nIndex);
+
+ if (nIndex < (int)
+ file.GetLineCount()) file.CommentLine(nIndex);
}
- sTmp = sTmp + wxT(";") + sCmd; //includes wxT(" %s ");
+ sTmp += wxT(";") + sCmd; //includes wxT(" %s ");
// write it in the format that Netscape uses (default)
- if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD ) )
+ if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD ) )
{
- if (! delete_index) file.InsertLine (sTmp, nIndex);
- nIndex ++;
+ if (! delete_index)
+ file.InsertLine(sTmp, nIndex);
+ nIndex++;
}
-
- // write extended format
else
{
- // todo FIX this code;
+ // write extended format
+
+ // 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)
+ wxStringTokenizer sT(sOld, wxT(";\\"));
+ if (sT.CountTokens() > 2)
{
// first one mimetype; second one command, rest unknown...
wxString s;
s = sT.GetNextToken();
while ( ! s.empty() )
{
- bool bKnownToken = FALSE;
- if (s.Contains(wxT("description="))) bKnownToken = TRUE;
- if (s.Contains(wxT("x11-bitmap="))) bKnownToken = TRUE;
+ 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++)
+ size_t nCount = entries->GetCount();
+ for (i=0; i < nCount; i++)
{
- if (s.Contains(entries->GetVerb(i))) bKnownToken = TRUE;
+ if (s.Contains(entries->GetVerb(i)))
+ bKnownToken = true;
}
+
if (!bKnownToken)
{
- sTmp = sTmp + wxT("; \\");
- file.InsertLine (sTmp, nIndex);
+ sTmp += wxT("; \\");
+ file.InsertLine(sTmp, nIndex);
sTmp = s;
}
- s = sT.GetNextToken ();
- }
+ s = sT.GetNextToken();
+ }
}
if (! m_aDescriptions[index].empty() )
{
- sTmp = sTmp + wxT("; \\");
- file.InsertLine (sTmp, nIndex);
- nIndex ++;
+ 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("; \\");
+ file.InsertLine(sTmp, nIndex);
+ nIndex++;
sTmp = wxT(" x11-bitmap=\"") + m_aIcons[index] + wxT("\"");
}
- if ( entries->GetCount() > 1 )
+ 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("; \\");
+ file.InsertLine(sTmp, nIndex);
+ nIndex++;
sTmp = wxT(" ") + entries->GetVerbCmd(i);
}
}
- file.InsertLine (sTmp, nIndex);
- nIndex ++;
-
+ file.InsertLine(sTmp, nIndex);
+ nIndex++;
}
- bTemp = file.Write ();
- file.Close ();
+
+ bTemp = file.Write();
+ file.Close();
}
+
return bTemp;
}
-wxFileType *
-wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
+wxFileType * wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
{
InitIfNeeded();
- wxString strType = ftInfo.GetMimeType ();
- wxString strDesc = ftInfo.GetDescription ();
- wxString strIcon = ftInfo.GetIconFile ();
+ wxString strType = ftInfo.GetMimeType();
+ wxString strDesc = ftInfo.GetDescription();
+ wxString strIcon = ftInfo.GetIconFile();
- wxMimeTypeCommands *entry = new wxMimeTypeCommands ();
+ 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 "));
+ 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 ();
+ wxArrayString sA_Exts = ftInfo.GetExtensions();
wxString sExt, sExtStore;
size_t i, nIndex;
- for (i=0; i < sA_Exts.GetCount(); i++)
- {
+ size_t nExtCount = sA_Exts.GetCount();
+ for (i=0; i < nExtCount; i++)
+ {
sExt = sA_Exts.Item(i);
- //clean up to just a space before and after
- sExt.Trim().Trim(FALSE);
+
+ // 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 ++)
- {
+ size_t nCount = m_aExtensions.GetCount();
+ for (nIndex = 0; nIndex < nCount; nIndex++)
+ {
sExtStore = m_aExtensions.Item(nIndex);
- if (sExtStore.Replace(sExt, wxT(" ") ) > 0) m_aExtensions.Item(nIndex) = sExtStore;
- }
-
+ if (sExtStore.Replace(sExt, wxT(" ") ) > 0)
+ m_aExtensions.Item(nIndex) = sExtStore;
+ }
}
- if ( !DoAssociation (strType, strIcon, entry, sA_Exts, strDesc) )
+ 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);
+ int nIndex = AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, true);
if ( nIndex == wxNOT_FOUND )
- return FALSE;
+ return false;
- return WriteMimeInfo (nIndex, FALSE);
+ return WriteMimeInfo(nIndex, false);
}
bool wxMimeTypesManagerImpl::WriteMimeInfo(int nIndex, bool delete_mime )
{
- bool ok = TRUE;
+ bool ok = true;
if ( m_mailcapStylesInited & wxMAILCAP_STANDARD )
{
// write in metamail format;
- if (WriteToMimeTypes (nIndex, delete_mime) )
- if ( WriteToMailCap (nIndex, delete_mime) )
- ok = FALSE;
+ 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 (WriteToNSMimeTypes(nIndex, delete_mime) )
+ if ( WriteToMailCap(nIndex, delete_mime) )
+ ok = false;
}
+
+ // Don't write GNOME files here as this is not
+ // allowed and simply doesn't work
+
if (m_mailcapStylesInited & wxMAILCAP_KDE)
{
// write in KDE format;
- if (WriteKDEMimeFile (nIndex, delete_mime) )
- ok = FALSE;
+ if (WriteKDEMimeFile(nIndex, delete_mime) )
+ ok = false;
}
return ok;
m_aEntries.Add(entry ? entry : new wxMimeTypeCommands);
// change nIndex so we can use it below to add the extensions
- nIndex = m_aExtensions.Add(wxEmptyString);
+ m_aExtensions.Add(wxEmptyString);
+ nIndex = m_aExtensions.size() - 1;
m_aDescriptions.Add(strDesc);
}
m_aDescriptions[nIndex] = strDesc;
// if new icon and no existing icon
- if ( m_aIcons[nIndex].empty () )
+ if ( m_aIcons[nIndex].empty() )
m_aIcons[nIndex] = strIcon;
// add any new entries...
if ( entry )
{
- wxMimeTypeCommands *entryOld = m_aEntries[nIndex];
+ wxMimeTypeCommands *entryOld = m_aEntries[nIndex];
size_t count = entry->GetCount();
for ( size_t i = 0; i < count; i++ )
wxString& exts = m_aExtensions[nIndex];
// add all extensions we don't have yet
+ wxString ext;
size_t count = strExtensions.GetCount();
for ( size_t i = 0; i < count; i++ )
{
- wxString ext = strExtensions[i] + _T(' ');
+ ext = strExtensions[i];
+ ext += wxT(' ');
if ( exts.Find(ext) == wxNOT_FOUND )
{
}
// 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() );
+ wxASSERT( m_aTypes.GetCount() == m_aEntries.GetCount() &&
+ m_aTypes.GetCount() == m_aExtensions.GetCount() &&
+ m_aTypes.GetCount() == m_aIcons.GetCount() &&
+ m_aTypes.GetCount() == m_aDescriptions.GetCount() );
return nIndex;
}
-
-wxFileType *
-wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
+wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
{
if (ext.empty() )
return NULL;
size_t count = m_aExtensions.GetCount();
for ( size_t n = 0; n < count; n++ )
{
- wxStringTokenizer tk(m_aExtensions[n], _T(' '));
+ wxStringTokenizer tk(m_aExtensions[n], wxT(' '));
while ( tk.HasMoreTokens() )
{
// consider extensions as not being case-sensitive
- if ( tk.GetNextToken().IsSameAs(ext, FALSE /* no case */) )
+ if ( tk.GetNextToken().IsSameAs(ext, false /* no case */) )
{
// found
wxFileType *fileType = new wxFileType;
return NULL;
}
-wxFileType *
-wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
+wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
{
InitIfNeeded();
index = wxNOT_FOUND;
wxString strCategory = mimetype.BeforeFirst(wxT('/'));
- size_t nCount = m_aTypes.Count();
- for ( size_t n = 0; n < nCount; n++ ) {
+ size_t nCount = m_aTypes.GetCount();
+ for ( size_t n = 0; n < nCount; n++ )
+ {
if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) &&
- m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") ) {
+ m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") )
+ {
index = n;
break;
}
-
}
if ( index != wxNOT_FOUND )
{
- fileType = new wxFileType;
+ // don't throw away fileType that was already found
+ if (!fileType)
+ 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
wxMimeTypeCommands * sPairs = m_aEntries [nIndex];
size_t i;
- for ( i = 0; i < sPairs->GetCount (); i++ )
+ size_t nCount = sPairs->GetCount();
+ for ( i = 0; i < nCount; i++ )
{
sTmp = sPairs->GetVerbCmd (i);
if ( sTmp.Contains(sV) )
command = sTmp.AfterFirst(wxT('='));
}
+
return command;
}
wxString extensions;
const wxArrayString& exts = filetype.GetExtensions();
size_t nExts = exts.GetCount();
- for ( size_t nExt = 0; nExt < nExts; nExt++ ) {
- if ( nExt > 0 ) {
+ for ( size_t nExt = 0; nExt < nExts; nExt++ )
+ {
+ if ( nExt > 0 )
extensions += wxT(' ');
- }
+
extensions += exts[nExt];
}
wxString sTmp = strExtensions;
wxArrayString sExts;
- sTmp.Trim().Trim(FALSE);
+ sTmp.Trim().Trim(false);
while (!sTmp.empty())
{
- sExts.Add (sTmp.AfterLast(wxT(' ')));
+ sExts.Add(sTmp.AfterLast(wxT(' ')));
sTmp = sTmp.BeforeLast(wxT(' '));
}
- AddToMimeData (strMimeType, strIcon, NULL, sExts, strDesc, TRUE);
+ AddToMimeData(strMimeType, strIcon, NULL, sExts, strDesc, true);
}
void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
wxString strIcon;
wxArrayString strExtensions;
- AddToMimeData (strType, strIcon, entry, strExtensions, strDesc, TRUE);
-
+ 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 defined(__WXGTK20__) && wxUSE_UNICODE
- if ( !file.Open( wxConvUTF8) )
-#else
+ wxMimeTextFile file(strFileName);
if ( !file.Open() )
-#endif
- return FALSE;
+ return false;
// the information we extract
wxString strMimeType, strDesc, strExtensions;
const wxChar *pc = NULL;
for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
{
- if ( pc == NULL ) {
+ if ( pc == NULL )
+ {
// now we're at the start of the line
pc = file[nLine].c_str();
}
- else {
+ else
+ {
// we didn't finish with the previous line yet
nLine--;
}
pc++;
// comment or blank line?
- if ( *pc == wxT('#') || !*pc ) {
+ if ( *pc == wxT('#') || !*pc )
+ {
// skip the whole line
pc = NULL;
continue;
// detect file format
const wxChar *pEqualSign = wxStrchr(pc, wxT('='));
- if ( pEqualSign == NULL ) {
+ if ( pEqualSign == NULL )
+ {
// brief format
// ------------
// first field is mime type
- for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != wxT('\0'); pc++ ) {
+ for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != wxT('\0'); pc++ )
+ {
strMimeType += *pc;
}
// no description...
strDesc.Empty();
}
- else {
+ else
+ {
// expanded format
// ---------------
;
const wxChar *pEnd;
- if ( *pc == wxT('"') ) {
+ 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);
+ if ( pEnd == NULL )
+ {
+ wxLogWarning(wxT("Mime.types file %s, line %lu: unterminated quoted string."),
+ strFileName.c_str(), nLine + 1L);
}
}
- else {
+ else
+ {
// unquoted string ends at the first space or at the end of
// line
for ( pEnd = pc; *pEnd && !wxIsspace(*pEnd); pEnd++ )
wxString strRHS(pc, pEnd - pc);
// check what follows this entry
- if ( *pEnd == wxT('"') ) {
+ if ( *pEnd == wxT('"') )
+ {
// skip this quote
pEnd++;
}
// 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 ) {
+ bool entryEnded = *pc == wxT('\0');
+ bool nextFieldOnSameLine = false;
+ if ( !entryEnded )
+ {
nextFieldOnSameLine = ((*pc != wxT('\\')) || (pc[1] != wxT('\0')));
}
// now see what we got
- if ( strLHS == wxT("type") ) {
+ if ( strLHS == wxT("type") )
+ {
strMimeType = strRHS;
}
- else if ( strLHS.StartsWith(wxT("desc")) ) {
+ else if ( strLHS.StartsWith(wxT("desc")) )
+ {
strDesc = strRHS;
}
- else if ( strLHS == wxT("exts") ) {
+ else if ( strLHS == wxT("exts") )
+ {
strExtensions = strRHS;
}
- else if ( strLHS != _T("icon") )
+ else if ( strLHS == wxT("icon") )
{
// this one is simply ignored: it usually refers to Netscape
// built in icons which are useless for us anyhow
}
- else if ( !strLHS.StartsWith(_T("x-")) )
+ else if ( !strLHS.StartsWith(wxT("x-")) )
{
// we suppose that all fields starting with "X-" are
// unregistered extensions according to the standard practice,
// but it may be worth telling the user about other junk in
// his mime.types file
- wxLogWarning(_("Unknown field in file %s, line %d: '%s'."),
- strFileName.c_str(), nLine + 1, strLHS.c_str());
+ wxLogWarning(wxT("Unknown field in file %s, line %lu: '%s'."),
+ strFileName.c_str(), nLine + 1L, strLHS.c_str());
}
- if ( !entryEnded ) {
+ if ( !entryEnded )
+ {
if ( !nextFieldOnSameLine )
pc = NULL;
//else: don't reset it
pc = NULL;
}
- return TRUE;
+ return true;
}
// ----------------------------------------------------------------------------
needsterminal,
copiousoutput;
- MailcapLineData() { testfailed = needsterminal = copiousoutput = FALSE; }
+ MailcapLineData() { testfailed = needsterminal = copiousoutput = false; }
};
// process a non-standard (i.e. not the first or second one) mailcap field
if ( curField.empty() )
{
// we don't care
- return TRUE;
+ return true;
}
// is this something of the form foo=bar?
- const wxChar *pEq = wxStrchr(curField, wxT('='));
- if ( pEq != NULL )
+ if ( curField.find('=') != wxString::npos )
{
// split "LHS = RHS" in 2
wxString lhs = curField.BeforeFirst(wxT('=')),
rhs = curField.AfterFirst(wxT('='));
- lhs.Trim(TRUE); // from right
- rhs.Trim(FALSE); // from left
+ lhs.Trim(true); // from right
+ rhs.Trim(false); // from left
// it might be quoted
if ( !rhs.empty() && rhs[0u] == wxT('"') && rhs.Last() == wxT('"') )
wxLogTrace(TRACE_MIME_TEST,
wxT("Test '%s' for mime type '%s' succeeded."),
rhs.c_str(), data.type.c_str());
-
}
else
{
wxT("Test '%s' for mime type '%s' failed, skipping."),
rhs.c_str(), data.type.c_str());
- data.testfailed = TRUE;
+ data.testfailed = true;
}
}
else if ( lhs == wxT("desc") )
// so it must be a simple flag
if ( curField == wxT("needsterminal") )
{
- data.needsterminal = TRUE;
+ data.needsterminal = true;
}
else if ( curField == wxT("copiousoutput"))
{
// copiousoutput impies that the viewer is a console program
data.needsterminal =
- data.copiousoutput = TRUE;
+ data.copiousoutput = true;
}
else if ( !IsKnownUnimportantField(curField) )
{
- return FALSE;
+ return false;
}
}
- return TRUE;
+ return true;
}
bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
wxLogTrace(TRACE_MIME, wxT("--- Parsing mailcap file '%s' ---"),
strFileName.c_str());
- wxTextFile file(strFileName);
-#if defined(__WXGTK20__) && wxUSE_UNICODE
- if ( !file.Open( wxConvUTF8) )
-#else
+ wxMimeTextFile file(strFileName);
if ( !file.Open() )
-#endif
- return FALSE;
+ return false;
// indices of MIME types (in m_aTypes) we already found in this file
//
wxString curField;
curField.reserve(1024);
+ const wxChar *pPagerEnv = wxGetenv(wxT("PAGER"));
+
+ const wxArrayString empty_extensions_list;
+
size_t nLineCount = file.GetLineCount();
for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
{
// the flags and field values on the current line
MailcapLineData data;
- bool cont = TRUE;
+ bool cont = true;
while ( cont )
{
switch ( *pc )
if ( nLine == nLineCount - 1 )
{
// something is wrong, bail out
- cont = FALSE;
+ cont = false;
- wxLogDebug(wxT("Mailcap file %s, line %lu: "
- "'\\' on the end of the last line "
- "ignored."),
+ wxLogDebug(wxT("Mailcap file %s, line %lu: '\\' on the end of the last line ignored."),
strFileName.c_str(),
- (unsigned long)nLine + 1);
+ nLine + 1L);
}
else
{
break;
case wxT('\0'):
- cont = FALSE; // end of line reached, exit the loop
+ cont = false; // end of line reached, exit the loop
// fall through to still process this field
case wxT(';'):
// trim whitespaces from both sides
- curField.Trim(TRUE).Trim(FALSE);
+ curField.Trim(true).Trim(false);
switch ( currentToken )
{
{
// I don't think that this is a valid mailcap
// entry, but try to interpret it somehow
- data.type = _T('*');
+ data.type = wxT('*');
}
if ( data.type.Find(wxT('/')) == wxNOT_FOUND )
// this might be useful for the programmer
wxLogDebug
(
- wxT("Mailcap file %s, line %lu: "
- "unknown field '%s' for the "
- "MIME type '%s' ignored."),
+ wxT("Mailcap file %s, line %lu: unknown field '%s' for the MIME type '%s' ignored."),
strFileName.c_str(),
- (unsigned long)nLine + 1,
+ nLine + 1L,
curField.c_str(),
data.type.c_str()
);
else if ( data.testfailed )
{
// skip this entry entirely
- cont = FALSE;
+ cont = false;
}
// it already has this value
// check that we really read something reasonable
if ( currentToken < Field_Other )
{
- wxLogWarning(_("Mailcap file %s, line %d: incomplete entry "
- "ignored."),
- strFileName.c_str(), nLine + 1);
+ wxLogWarning(wxT("Mailcap file %s, line %lu: incomplete entry ignored."),
+ strFileName.c_str(), nLine + 1L);
continue;
}
- // if the test command failed, it's as if the entry were not there at
- // all
+ // if the test command failed, it's as if the entry were not there at all
if ( data.testfailed )
{
continue;
// is a bad idea (FIXME)
if ( data.copiousoutput )
{
- const wxChar *p = wxGetenv(_T("PAGER"));
- data.cmdOpen << _T(" | ") << (p ? p : _T("more"));
+ data.cmdOpen << wxT(" | ") << (pPagerEnv ? pPagerEnv : wxT("more"));
}
if ( data.needsterminal )
{
- data.cmdOpen = wxString::Format(_T("xterm -e sh -c '%s'"),
- data.cmdOpen.c_str());
+ data.cmdOpen.insert(0, wxT("xterm -e sh -c '"));
+ data.cmdOpen.append(wxT("'"));
}
if ( !data.cmdOpen.empty() )
{
- data.verbs.Insert(_T("open"), 0);
+ data.verbs.Insert(wxT("open"), 0);
data.commands.Insert(data.cmdOpen, 0);
}
// the fall back entries have the lowest priority, by definition
if ( fallback )
{
- overwrite = FALSE;
+ 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?
+ // and if we have, was it in this file? if not, we should
+ // overwrite the previously seen one
overwrite = nIndex == wxNOT_FOUND ||
- aIndicesSeenHere.Index(nIndex) != wxNOT_FOUND;
+ aIndicesSeenHere.Index(nIndex) == wxNOT_FOUND;
}
- wxLogTrace(TRACE_MIME, _T("mailcap %s: %s [%s]"),
+ wxLogTrace(TRACE_MIME, wxT("mailcap %s: %s [%s]"),
data.type.c_str(), data.cmdOpen.c_str(),
- overwrite ? _T("replace") : _T("add"));
+ overwrite ? wxT("replace") : wxT("add"));
int n = AddToMimeData
(
data.type,
data.icon,
new wxMimeTypeCommands(data.verbs, data.commands),
- wxArrayString() /* extensions */,
+ empty_extensions_list,
data.desc,
overwrite
);
}
}
- return TRUE;
+ return true;
}
size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
mimetypes.Empty();
- wxString type;
size_t count = m_aTypes.GetCount();
for ( size_t n = 0; n < count; n++ )
{
// don't return template types from here (i.e. anything containg '*')
- type = m_aTypes[n];
- if ( type.Find(_T('*')) == wxNOT_FOUND )
+ const wxString &type = m_aTypes[n];
+ if ( type.Find(wxT('*')) == wxNOT_FOUND )
{
mimetypes.Add(type);
}
bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
{
+ InitIfNeeded();
+
wxArrayString sMimeTypes;
- ft->GetMimeTypes (sMimeTypes);
+ ft->GetMimeTypes(sMimeTypes);
- wxString sMime;
size_t i;
- for (i = 0; i < sMimeTypes.GetCount(); i ++)
+ size_t nCount = sMimeTypes.GetCount();
+ for (i = 0; i < nCount; i ++)
{
- sMime = sMimeTypes.Item(i);
- int nIndex = m_aTypes.Index (sMime);
+ const wxString &sMime = sMimeTypes.Item(i);
+ int nIndex = m_aTypes.Index(sMime);
if ( nIndex == wxNOT_FOUND)
{
// error if we get here ??
- return FALSE;
+ return false;
}
else
{
- WriteMimeInfo(nIndex, TRUE );
+ WriteMimeInfo(nIndex, true);
m_aTypes.RemoveAt(nIndex);
m_aEntries.RemoveAt(nIndex);
m_aExtensions.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() );
+ wxASSERT( m_aTypes.GetCount() == m_aEntries.GetCount() &&
+ m_aTypes.GetCount() == m_aExtensions.GetCount() &&
+ m_aTypes.GetCount() == m_aIcons.GetCount() &&
+ m_aTypes.GetCount() == m_aDescriptions.GetCount() );
- return TRUE;
+ return true;
}
// ----------------------------------------------------------------------------
static bool IsKnownUnimportantField(const wxString& fieldAll)
{
- static const wxChar *knownFields[] =
+ static const wxChar * const knownFields[] =
{
- _T("x-mozilla-flags"),
- _T("nametemplate"),
- _T("textualnewlines"),
+ wxT("x-mozilla-flags"),
+ wxT("nametemplate"),
+ wxT("textualnewlines"),
};
- wxString field = fieldAll.BeforeFirst(_T('='));
+ wxString field = fieldAll.BeforeFirst(wxT('='));
for ( size_t n = 0; n < WXSIZEOF(knownFields); n++ )
{
if ( field.CmpNoCase(knownFields[n]) == 0 )
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
#endif
// wxUSE_MIMETYPE && wxUSE_FILE && wxUSE_TEXTFILE
-
projects / wxWidgets.git / blobdiff