]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/unix/mimetype.cpp
check that the version of __sync_sub_and_fetch that returns a value is supported...
[wxWidgets.git] / src / unix / mimetype.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/unix/mimetype.cpp
3// Purpose: classes and functions to manage MIME types
4// Author: Vadim Zeitlin
5// Modified by:
6// Created: 23.09.98
7// RCS-ID: $Id$
8// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9// Licence: wxWindows licence (part of wxExtra library)
10/////////////////////////////////////////////////////////////////////////////
11
12// known bugs; there may be others!! chris elliott, biol75@york.ac.uk 27 Mar 01
13
14// 1) .mailcap and .mimetypes can be either in a netscape or metamail format
15// and entries may get confused during writing (I've tried to fix this; please let me know
16// any files that fail)
17// 2) KDE and Gnome do not yet fully support international read/write
18// 3) Gnome key lines like open.latex."LaTeX this file"=latex %f will have odd results
19// 4) writing to files comments out the existing data; I hope this avoids losing
20// any data which we could not read, and data which we did not store like test=
21// 5) results from reading files with multiple entries (especially matches with type/* )
22// may (or may not) work for getXXX commands
23// 6) Loading the png icons in Gnome doesn't work for me...
24// 7) In Gnome, if keys.mime exists but keys.users does not, there is
25// an error message in debug mode, but the file is still written OK
26// 8) Deleting entries is only allowed from the user file; sytem wide entries
27// will be preserved during unassociate
28// 9) KDE does not yet handle multiple actions; Netscape mode never will
29
30// TODO: this file is a mess, we need to split it and review everything (VZ)
31
32// for compilers that support precompilation, includes "wx.h".
33#include "wx/wxprec.h"
34
35#ifdef __BORLANDC__
36 #pragma hdrstop
37#endif
38
39#if wxUSE_MIMETYPE && wxUSE_FILE && wxUSE_TEXTFILE
40
41#include "wx/unix/mimetype.h"
42
43#ifndef WX_PRECOMP
44 #include "wx/dynarray.h"
45 #include "wx/string.h"
46 #include "wx/intl.h"
47 #include "wx/log.h"
48 #include "wx/utils.h"
49#endif
50
51#include "wx/file.h"
52#include "wx/confbase.h"
53
54#include "wx/ffile.h"
55#include "wx/textfile.h"
56#include "wx/dir.h"
57#include "wx/tokenzr.h"
58#include "wx/iconloc.h"
59#include "wx/filename.h"
60#include "wx/app.h"
61#include "wx/apptrait.h"
62
63#if wxUSE_LIBGNOMEVFS
64 // Not GUI dependent
65 #include "wx/gtk/gnome/gvfs.h"
66#endif
67
68// other standard headers
69#include <ctype.h>
70
71// this class is a wxTextFile specialization for dealing with files storing
72// various MIME-related information
73//
74// it should be used instead of wxTextFile even if none of its additional
75// methods are used just because it handles files with mixed encodings (often
76// the case for MIME files which contain strings for different languages)
77// correctly, see OnRead()
78class wxMimeTextFile : public wxTextFile
79{
80public:
81 // constructors
82 wxMimeTextFile () : wxTextFile () { }
83 wxMimeTextFile(const wxString& strFile) : wxTextFile(strFile) { }
84
85 int pIndexOf(const wxString& sSearch,
86 bool bIncludeComments = false,
87 int iStart = 0)
88 {
89 wxString sTest = sSearch;
90 sTest.MakeLower();
91 for(size_t i = iStart; i < GetLineCount(); i++)
92 {
93 wxString sLine = GetLine(i).Trim(false);
94 if(bIncludeComments || ! sLine.StartsWith(wxT("#")))
95 {
96 sLine.MakeLower();
97 if(sLine.StartsWith(sTest))
98 return (int)i;
99 }
100 }
101 return wxNOT_FOUND;
102 }
103
104 bool CommentLine(int nIndex)
105 {
106 if (nIndex < 0)
107 return false;
108 if (nIndex >= (int)GetLineCount() )
109 return false;
110
111 GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
112 return true;
113 }
114
115 bool CommentLine(const wxString & sTest)
116 {
117 int nIndex = pIndexOf(sTest);
118 if (nIndex < 0)
119 return false;
120 if (nIndex >= (int)GetLineCount() )
121 return false;
122
123 GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
124 return true;
125 }
126
127 wxString GetVerb(size_t i)
128 {
129 if (i > GetLineCount() )
130 return wxEmptyString;
131
132 wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
133 return sTmp;
134 }
135
136 wxString GetCmd(size_t i)
137 {
138 if (i > GetLineCount() )
139 return wxEmptyString;
140
141 wxString sTmp = GetLine(i).AfterFirst(wxT('='));
142 return sTmp;
143 }
144};
145
146// ----------------------------------------------------------------------------
147// constants
148// ----------------------------------------------------------------------------
149
150// MIME code tracing mask
151#define TRACE_MIME wxT("mime")
152
153// give trace messages about the results of mailcap tests
154#define TRACE_MIME_TEST wxT("mimetest")
155
156// ----------------------------------------------------------------------------
157// private functions
158// ----------------------------------------------------------------------------
159
160// there are some fields which we don't understand but for which we don't give
161// warnings as we know that they're not important - this function is used to
162// test for them
163static bool IsKnownUnimportantField(const wxString& field);
164
165// ----------------------------------------------------------------------------
166// private classes
167// ----------------------------------------------------------------------------
168
169
170// This class uses both mailcap and mime.types to gather information about file
171// types.
172//
173// The information about mailcap file was extracted from metamail(1) sources
174// and documentation and subsequently revised when I found the RFC 1524
175// describing it.
176//
177// Format of mailcap file: spaces are ignored, each line is either a comment
178// (starts with '#') or a line of the form <field1>;<field2>;...;<fieldN>.
179// A backslash can be used to quote semicolons and newlines (and, in fact,
180// anything else including itself).
181//
182// The first field is always the MIME type in the form of type/subtype (see RFC
183// 822) where subtype may be '*' meaning "any". Following metamail, we accept
184// "type" which means the same as "type/*", although I'm not sure whether this
185// is standard.
186//
187// The second field is always the command to run. It is subject to
188// parameter/filename expansion described below.
189//
190// All the following fields are optional and may not be present at all. If
191// they're present they may appear in any order, although each of them should
192// appear only once. The optional fields are the following:
193// * notes=xxx is an uninterpreted string which is silently ignored
194// * test=xxx is the command to be used to determine whether this mailcap line
195// applies to our data or not. The RHS of this field goes through the
196// parameter/filename expansion (as the 2nd field) and the resulting string
197// is executed. The line applies only if the command succeeds, i.e. returns 0
198// exit code.
199// * print=xxx is the command to be used to print (and not view) the data of
200// this type (parameter/filename expansion is done here too)
201// * edit=xxx is the command to open/edit the data of this type
202// * needsterminal means that a new interactive console must be created for
203// the viewer
204// * copiousoutput means that the viewer doesn't interact with the user but
205// produces (possibly) a lof of lines of output on stdout (i.e. "cat" is a
206// good example), thus it might be a good idea to use some kind of paging
207// mechanism.
208// * textualnewlines means not to perform CR/LF translation (not honored)
209// * compose and composetyped fields are used to determine the program to be
210// called to create a new message pert in the specified format (unused).
211//
212// Parameter/filename expansion:
213// * %s is replaced with the (full) file name
214// * %t is replaced with MIME type/subtype of the entry
215// * for multipart type only %n is replaced with the nnumber of parts and %F is
216// replaced by an array of (content-type, temporary file name) pairs for all
217// message parts (TODO)
218// * %{parameter} is replaced with the value of parameter taken from
219// Content-type header line of the message.
220//
221//
222// There are 2 possible formats for mime.types file, one entry per line (used
223// for global mime.types and called Mosaic format) and "expanded" format where
224// an entry takes multiple lines (used for users mime.types and called
225// Netscape format).
226//
227// For both formats spaces are ignored and lines starting with a '#' are
228// comments. Each record has one of two following forms:
229// a) for "brief" format:
230// <mime type> <space separated list of extensions>
231// b) for "expanded" format:
232// type=<mime type> BACKSLASH
233// desc="<description>" BACKSLASH
234// exts="<comma separated list of extensions>"
235//
236// (where BACKSLASH is a literal '\\' which we can't put here because cpp
237// misinterprets it)
238//
239// We try to autodetect the format of mime.types: if a non-comment line starts
240// with "type=" we assume the second format, otherwise the first one.
241
242// there may be more than one entry for one and the same mime type, to
243// choose the right one we have to run the command specified in the test
244// field on our data.
245
246// ----------------------------------------------------------------------------
247// wxGNOME
248// ----------------------------------------------------------------------------
249
250// GNOME stores the info we're interested in in several locations:
251// 1. xxx.keys files under /usr/share/mime-info
252// 2. xxx.keys files under ~/.gnome/mime-info
253//
254// Update (Chris Elliott): apparently there may be an optional "[lang]" prefix
255// just before the field name.
256
257
258void wxMimeTypesManagerImpl::LoadGnomeDataFromKeyFile(const wxString& filename,
259 const wxArrayString& dirs)
260{
261 wxMimeTextFile textfile(filename);
262 if ( !textfile.Open() )
263 return;
264
265 wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s ---"),
266 filename.c_str());
267
268 wxArrayString search_dirs( dirs );
269
270 // values for the entry being parsed
271 wxString curMimeType, curIconFile;
272 wxMimeTypeCommands * entry = new wxMimeTypeCommands;
273
274 wxArrayString strExtensions;
275 wxString strDesc;
276
277 const wxChar *pc;
278 size_t nLineCount = textfile.GetLineCount();
279 size_t nLine = 0;
280 while ( nLine < nLineCount )
281 {
282 pc = textfile[nLine].c_str();
283 if ( *pc != wxT('#') )
284 {
285
286 wxLogTrace(TRACE_MIME, wxT("--- Reading from Gnome file %s '%s' ---"),
287 filename.c_str(), pc);
288
289 // trim trailing space and tab
290 while ((*pc == wxT(' ')) || (*pc == wxT('\t')))
291 pc++;
292
293 wxString sTmp(pc);
294 int equal_pos = sTmp.Find( wxT('=') );
295 if (equal_pos > 0)
296 {
297 wxString left_of_equal = sTmp.Left( equal_pos );
298 const wxChar *right_of_equal = pc;
299 right_of_equal += equal_pos+1;
300
301 if (left_of_equal == wxT("icon_filename"))
302 {
303 // GNOME 2:
304 curIconFile = right_of_equal;
305
306 wxFileName newFile( curIconFile );
307 if (newFile.IsRelative() || newFile.FileExists())
308 {
309 size_t nDirs = search_dirs.GetCount();
310
311 for (size_t nDir = 0; nDir < nDirs; nDir++)
312 {
313 newFile.SetPath( search_dirs[nDir] );
314 newFile.AppendDir( wxT("pixmaps") );
315 newFile.AppendDir( wxT("document-icons") );
316 newFile.SetExt( wxT("png") );
317 if (newFile.FileExists())
318 {
319 curIconFile = newFile.GetFullPath();
320 // reorder search_dirs for speedup (fewer
321 // calls to FileExist() required)
322 if (nDir != 0)
323 {
324 const wxString &tmp = search_dirs[nDir];
325 search_dirs.RemoveAt( nDir );
326 search_dirs.Insert( tmp, 0 );
327 }
328 break;
329 }
330 }
331 }
332 }
333 else if (left_of_equal == wxT("open"))
334 {
335 sTmp = right_of_equal;
336 sTmp.Replace( wxT("%f"), wxT("%s") );
337 sTmp.Prepend( wxT("open=") );
338 entry->Add(sTmp);
339 }
340 else if (left_of_equal == wxT("view"))
341 {
342 sTmp = right_of_equal;
343 sTmp.Replace( wxT("%f"), wxT("%s") );
344 sTmp.Prepend( wxT("view=") );
345 entry->Add(sTmp);
346 }
347 else if (left_of_equal == wxT("print"))
348 {
349 sTmp = right_of_equal;
350 sTmp.Replace( wxT("%f"), wxT("%s") );
351 sTmp.Prepend( wxT("print=") );
352 entry->Add(sTmp);
353 }
354 else if (left_of_equal == wxT("description"))
355 {
356 strDesc = right_of_equal;
357 }
358 else if (left_of_equal == wxT("short_list_application_ids_for_novice_user_level"))
359 {
360 sTmp = right_of_equal;
361 if (sTmp.Contains( wxT(",") ))
362 sTmp = sTmp.BeforeFirst( wxT(',') );
363 sTmp.Prepend( wxT("open=") );
364 sTmp.Append( wxT(" %s") );
365 entry->Add(sTmp);
366 }
367
368 } // emd of has an equals sign
369 else
370 {
371 // not a comment and not an equals sign
372 if (sTmp.Contains(wxT('/')))
373 {
374 // this is the start of the new mimetype
375 // overwrite any existing data
376 if (! curMimeType.empty())
377 {
378 AddToMimeData( curMimeType, curIconFile, entry, strExtensions, strDesc );
379
380 // now get ready for next bit
381 entry = new wxMimeTypeCommands;
382 }
383
384 curMimeType = sTmp.BeforeFirst(wxT(':'));
385 }
386 }
387 } // end of not a comment
388
389 // ignore blank lines
390 nLine++;
391 } // end of while, save any data
392
393 if ( curMimeType.empty() )
394 delete entry;
395 else
396 AddToMimeData( curMimeType, curIconFile, entry, strExtensions, strDesc);
397}
398
399void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& filename)
400{
401 wxMimeTextFile textfile(filename);
402 if ( !textfile.Open() )
403 return;
404
405 wxLogTrace(TRACE_MIME,
406 wxT("--- Opened Gnome file %s ---"),
407 filename.c_str());
408
409 // values for the entry being parsed
410 wxString curMimeType, curExtList;
411
412 const wxChar *pc;
413 size_t nLineCount = textfile.GetLineCount();
414 for ( size_t nLine = 0; /* nothing */; nLine++ )
415 {
416 if ( nLine < nLineCount )
417 {
418 pc = textfile[nLine].c_str();
419 if ( *pc == wxT('#') )
420 {
421 // skip comments
422 continue;
423 }
424 }
425 else
426 {
427 // so that we will fall into the "if" below
428 pc = NULL;
429 }
430
431 if ( !pc || !*pc )
432 {
433 // end of the entry
434 if ( !curMimeType.empty() && !curExtList.empty() )
435 {
436 wxLogTrace(TRACE_MIME,
437 wxT("--- At end of Gnome file finding mimetype %s ---"),
438 curMimeType.c_str());
439
440 AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
441 }
442
443 if ( !pc )
444 {
445 // the end: this can only happen if nLine == nLineCount
446 break;
447 }
448
449 curExtList.Empty();
450
451 continue;
452 }
453
454 // what do we have here?
455 if ( *pc == wxT('\t') )
456 {
457 // this is a field=value ling
458 pc++; // skip leading TAB
459
460 static const int lenField = 5; // strlen("ext: ")
461 if ( wxStrncmp(pc, wxT("ext: "), lenField) == 0 )
462 {
463 // skip it and take everything left until the end of line
464 curExtList = pc + lenField;
465 }
466 //else: some other field, we don't care
467 }
468 else
469 {
470 // this is the start of the new section
471 wxLogTrace(TRACE_MIME,
472 wxT("--- In Gnome file finding mimetype %s ---"),
473 curMimeType.c_str());
474
475 if (! curMimeType.empty())
476 AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
477
478 curMimeType.Empty();
479
480 while ( *pc != wxT(':') && *pc != wxT('\0') )
481 {
482 curMimeType += *pc++;
483 }
484 }
485 }
486}
487
488
489void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(
490 const wxString& dirbase, const wxArrayString& dirs)
491{
492 wxASSERT_MSG( !dirbase.empty() && !wxEndsWithPathSeparator(dirbase),
493 wxT("base directory shouldn't end with a slash") );
494
495 wxString dirname = dirbase;
496 dirname << wxT("/mime-info");
497
498 if ( !wxDir::Exists(dirname) )
499 return;
500
501 wxDir dir(dirname);
502 if ( !dir.IsOpened() )
503 return;
504
505 // we will concatenate it with filename to get the full path below
506 dirname += wxT('/');
507
508 wxString filename;
509 bool cont;
510
511 cont = dir.GetFirst(&filename, wxT("*.mime"), wxDIR_FILES);
512 while ( cont )
513 {
514 LoadGnomeMimeTypesFromMimeFile(dirname + filename);
515
516 cont = dir.GetNext(&filename);
517 }
518
519 cont = dir.GetFirst(&filename, wxT("*.keys"), wxDIR_FILES);
520 while ( cont )
521 {
522 LoadGnomeDataFromKeyFile(dirname + filename, dirs);
523
524 cont = dir.GetNext(&filename);
525 }
526
527 // FIXME: Hack alert: We scan all icons and deduce the
528 // mime-type from the file name.
529 dirname = dirbase;
530 dirname << wxT("/pixmaps/document-icons");
531
532 // these are always empty in this file
533 wxArrayString strExtensions;
534 wxString strDesc;
535
536 if ( !wxDir::Exists(dirname) )
537 {
538 // Just test for default GPE dir also
539 dirname = wxT("/usr/share/gpe/pixmaps/default/filemanager/document-icons");
540
541 if ( !wxDir::Exists(dirname) )
542 return;
543 }
544
545 wxDir dir2( dirname );
546
547 cont = dir2.GetFirst(&filename, wxT("gnome-*.png"), wxDIR_FILES);
548 while ( cont )
549 {
550 wxString mimeType = filename;
551 mimeType.Remove( 0, 6 ); // remove "gnome-"
552 mimeType.Remove( mimeType.Len() - 4, 4 ); // remove ".png"
553 int pos = mimeType.Find( wxT("-") );
554 if (pos != wxNOT_FOUND)
555 {
556 mimeType.SetChar( pos, wxT('/') );
557 wxString iconFile = dirname;
558 iconFile << wxT("/");
559 iconFile << filename;
560 AddToMimeData( mimeType, iconFile, NULL, strExtensions, strDesc, true );
561 }
562
563 cont = dir2.GetNext(&filename);
564 }
565}
566
567void wxMimeTypesManagerImpl::GetGnomeMimeInfo(const wxString& sExtraDir)
568{
569 wxArrayString dirs;
570
571 wxString gnomedir = wxGetenv( wxT("GNOMEDIR") );
572 if (!gnomedir.empty())
573 {
574 gnomedir << wxT("/share");
575 dirs.Add( gnomedir );
576 }
577
578 dirs.Add(wxT("/usr/share"));
579 dirs.Add(wxT("/usr/local/share"));
580
581 gnomedir = wxGetHomeDir();
582 gnomedir << wxT("/.gnome");
583 dirs.Add( gnomedir );
584
585 if (!sExtraDir.empty())
586 dirs.Add( sExtraDir );
587
588 size_t nDirs = dirs.GetCount();
589 for ( size_t nDir = 0; nDir < nDirs; nDir++ )
590 {
591 LoadGnomeMimeFilesFromDir(dirs[nDir], dirs);
592 }
593}
594
595// ----------------------------------------------------------------------------
596// KDE
597// ----------------------------------------------------------------------------
598
599
600// KDE stores the icon info in its .kdelnk files. The file for mimetype/subtype
601// may be found in either of the following locations
602//
603// 1. $KDEDIR/share/mimelnk/mimetype/subtype.kdelnk
604// 2. ~/.kde/share/mimelnk/mimetype/subtype.kdelnk
605//
606// The format of a .kdelnk file is almost the same as the one used by
607// wxFileConfig, i.e. there are groups, comments and entries. The icon is the
608// value for the entry "Type"
609
610// kde writing; see http://webcvs.kde.org/cgi-bin/cvsweb.cgi/~checkout~/kdelibs/kio/DESKTOP_ENTRY_STANDARD
611// for now write to .kdelnk but should eventually do .desktop instead (in preference??)
612
613bool wxMimeTypesManagerImpl::CheckKDEDirsExist( const wxString &sOK, const wxString &sTest )
614{
615 if (sTest.empty())
616 {
617 return wxDir::Exists(sOK);
618 }
619 else
620 {
621 wxString sStart = sOK + wxT("/") + sTest.BeforeFirst(wxT('/'));
622 if (!wxDir::Exists(sStart))
623 wxMkdir(sStart);
624 wxString sEnd = sTest.AfterFirst(wxT('/'));
625 return CheckKDEDirsExist(sStart, sEnd);
626 }
627}
628
629bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index)
630{
631 wxMimeTextFile appoutfile, mimeoutfile;
632 wxString sHome = wxGetHomeDir();
633 wxString sTmp = wxT(".kde/share/mimelnk/");
634 wxString sMime = m_aTypes[index];
635 CheckKDEDirsExist(sHome, sTmp + sMime.BeforeFirst(wxT('/')) );
636 sTmp = sHome + wxT('/') + sTmp + sMime + wxT(".kdelnk");
637
638 bool bTemp;
639 bool bMimeExists = mimeoutfile.Open(sTmp);
640 if (!bMimeExists)
641 {
642 bTemp = mimeoutfile.Create(sTmp);
643 // some unknown error eg out of disk space
644 if (!bTemp)
645 return false;
646 }
647
648 sTmp = wxT(".kde/share/applnk/");
649 CheckKDEDirsExist(sHome, sTmp + sMime.AfterFirst(wxT('/')) );
650 sTmp = sHome + wxT('/') + sTmp + sMime.AfterFirst(wxT('/')) + wxT(".kdelnk");
651
652 bool bAppExists;
653 bAppExists = appoutfile.Open(sTmp);
654 if (!bAppExists)
655 {
656 bTemp = appoutfile.Create(sTmp);
657 // some unknown error eg out of disk space
658 if (!bTemp)
659 return false;
660 }
661
662 // fixed data; write if new file
663 if (!bMimeExists)
664 {
665 mimeoutfile.AddLine(wxT("#KDE Config File"));
666 mimeoutfile.AddLine(wxT("[KDE Desktop Entry]"));
667 mimeoutfile.AddLine(wxT("Version=1.0"));
668 mimeoutfile.AddLine(wxT("Type=MimeType"));
669 mimeoutfile.AddLine(wxT("MimeType=") + sMime);
670 }
671
672 if (!bAppExists)
673 {
674 mimeoutfile.AddLine(wxT("#KDE Config File"));
675 mimeoutfile.AddLine(wxT("[KDE Desktop Entry]"));
676 appoutfile.AddLine(wxT("Version=1.0"));
677 appoutfile.AddLine(wxT("Type=Application"));
678 appoutfile.AddLine(wxT("MimeType=") + sMime + wxT(';'));
679 }
680
681 // variable data
682 // ignore locale
683 mimeoutfile.CommentLine(wxT("Comment="));
684 if (!delete_index)
685 mimeoutfile.AddLine(wxT("Comment=") + m_aDescriptions[index]);
686 appoutfile.CommentLine(wxT("Name="));
687 if (!delete_index)
688 appoutfile.AddLine(wxT("Comment=") + m_aDescriptions[index]);
689
690 sTmp = m_aIcons[index];
691 // we can either give the full path, or the shortfilename if its in
692 // one of the directories we search
693 mimeoutfile.CommentLine(wxT("Icon=") );
694 if (!delete_index)
695 mimeoutfile.AddLine(wxT("Icon=") + sTmp );
696 appoutfile.CommentLine(wxT("Icon=") );
697 if (!delete_index)
698 appoutfile.AddLine(wxT("Icon=") + sTmp );
699
700 sTmp = wxT(" ") + m_aExtensions[index];
701
702 wxStringTokenizer tokenizer(sTmp, wxT(" "));
703 sTmp = wxT("Patterns=");
704 mimeoutfile.CommentLine(sTmp);
705 while ( tokenizer.HasMoreTokens() )
706 {
707 // holds an extension; need to change it to *.ext;
708 wxString e = wxT("*.") + tokenizer.GetNextToken() + wxT(";");
709 sTmp += e;
710 }
711
712 if (!delete_index)
713 mimeoutfile.AddLine(sTmp);
714
715 wxMimeTypeCommands * entries = m_aEntries[index];
716 // if we don't find open just have an empty string ... FIX this
717 sTmp = entries->GetCommandForVerb(wxT("open"));
718 sTmp.Replace( wxT("%s"), wxT("%f") );
719
720 mimeoutfile.CommentLine(wxT("DefaultApp=") );
721 if (!delete_index)
722 mimeoutfile.AddLine(wxT("DefaultApp=") + sTmp);
723
724 sTmp.Replace( wxT("%f"), wxT("") );
725 appoutfile.CommentLine(wxT("Exec="));
726 if (!delete_index)
727 appoutfile.AddLine(wxT("Exec=") + sTmp);
728
729 if (entries->GetCount() > 1)
730 {
731 //other actions as well as open
732 }
733
734 bTemp = false;
735 if (mimeoutfile.Write())
736 bTemp = true;
737 mimeoutfile.Close();
738 if (appoutfile.Write())
739 bTemp = true;
740 appoutfile.Close();
741
742 return bTemp;
743}
744
745void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,
746 const wxString& subdir,
747 const wxString& filename,
748 const wxArrayString& icondirs)
749{
750 wxFileName fullname(dirbase, filename);
751 wxLogTrace(TRACE_MIME, wxT("loading KDE file %s"),
752 fullname.GetFullPath().c_str());
753
754 wxMimeTextFile file;
755 if ( !file.Open(fullname.GetFullPath()) )
756 return;
757
758 wxMimeTypeCommands * entry = new wxMimeTypeCommands;
759 wxArrayString sExts;
760 wxString mimetype, mime_desc, strIcon;
761
762 int nIndex = file.pIndexOf( wxT("MimeType=") );
763 if (nIndex == wxNOT_FOUND)
764 {
765 // construct mimetype from the directory name and the basename of the
766 // file (it always has .kdelnk extension)
767 mimetype << subdir << wxT('/') << filename.BeforeLast( wxT('.') );
768 }
769 else
770 mimetype = file.GetCmd(nIndex);
771
772 // first find the description string: it is the value in either "Comment="
773 // line or "Comment[<locale_name>]=" one
774 nIndex = wxNOT_FOUND;
775
776 wxString comment;
777
778#if wxUSE_INTL
779 wxLocale *locale = wxGetLocale();
780 if ( locale )
781 {
782 // try "Comment[locale name]" first
783 comment << wxT("Comment[") + locale->GetName() + wxT("]=");
784 nIndex = file.pIndexOf(comment);
785 }
786#endif
787
788 if ( nIndex == wxNOT_FOUND )
789 {
790 comment = wxT("Comment=");
791 nIndex = file.pIndexOf(comment);
792 }
793
794 if ( nIndex != wxNOT_FOUND )
795 mime_desc = file.GetCmd(nIndex);
796 //else: no description
797
798 // next find the extensions
799 wxString mime_extension;
800
801 nIndex = file.pIndexOf(wxT("Patterns="));
802 if ( nIndex != wxNOT_FOUND )
803 {
804 wxString exts = file.GetCmd(nIndex);
805
806 wxStringTokenizer tokenizer(exts, wxT(";"));
807 while ( tokenizer.HasMoreTokens() )
808 {
809 wxString e = tokenizer.GetNextToken();
810
811 // don't support too difficult patterns
812 if ( e.Left(2) != wxT("*.") )
813 continue;
814
815 if ( !mime_extension.empty() )
816 {
817 // separate from the previous ext
818 mime_extension << wxT(' ');
819 }
820
821 mime_extension << e.Mid(2);
822 }
823 }
824
825 sExts.Add(mime_extension);
826
827 // ok, now we can take care of icon:
828
829 nIndex = file.pIndexOf(wxT("Icon="));
830 if ( nIndex != wxNOT_FOUND )
831 {
832 strIcon = file.GetCmd(nIndex);
833
834 wxLogTrace(TRACE_MIME, wxT(" icon %s"), strIcon.c_str());
835
836 // it could be the real path, but more often a short name
837 if (!wxFileExists(strIcon))
838 {
839 // icon is just the short name
840 if ( !strIcon.empty() )
841 {
842 // we must check if the file exists because it may be stored
843 // in many locations, at least ~/.kde and $KDEDIR
844 size_t nDir, nDirs = icondirs.GetCount();
845 for ( nDir = 0; nDir < nDirs; nDir++ )
846 {
847 wxFileName fnameIcon( strIcon );
848 wxFileName fname( icondirs[nDir], fnameIcon.GetName() );
849 fname.SetExt( wxT("png") );
850 if (fname.FileExists())
851 {
852 strIcon = fname.GetFullPath();
853 wxLogTrace(TRACE_MIME, wxT(" iconfile %s"), strIcon.c_str());
854 break;
855 }
856 }
857 }
858 }
859 }
860
861 // now look for lines which know about the application
862 // exec= or DefaultApp=
863
864 nIndex = file.pIndexOf(wxT("DefaultApp"));
865
866 if ( nIndex == wxNOT_FOUND )
867 {
868 // no entry try exec
869 nIndex = file.pIndexOf(wxT("Exec"));
870 }
871
872 if ( nIndex != wxNOT_FOUND )
873 {
874 // we expect %f; others including %F and %U and %u are possible
875 wxString sTmp = file.GetCmd(nIndex);
876 if (0 == sTmp.Replace( wxT("%f"), wxT("%s") ))
877 sTmp += wxT(" %s");
878 entry->AddOrReplaceVerb(wxString(wxT("open")), sTmp );
879 }
880
881 AddToMimeData(mimetype, strIcon, entry, sExts, mime_desc);
882}
883
884void wxMimeTypesManagerImpl::LoadKDELinksForMimeType(const wxString& dirbase,
885 const wxString& subdir,
886 const wxArrayString& icondirs)
887{
888 wxFileName dirname(dirbase, wxEmptyString);
889 dirname.AppendDir(subdir);
890 wxDir dir(dirname.GetPath());
891 if(! dir.IsOpened())
892 return;
893
894 wxLogTrace(TRACE_MIME, wxT("--- Loading from KDE directory %s ---"),
895 dirname.GetPath().c_str());
896
897 wxString filename;
898 bool cont = dir.GetFirst(&filename, wxT("*.kdelnk"), wxDIR_FILES);
899 while(cont) {
900 LoadKDELinksForMimeSubtype(dirname.GetPath(), subdir,
901 filename, icondirs);
902 cont = dir.GetNext(&filename);
903 }
904
905 // new standard for Gnome and KDE
906 cont = dir.GetFirst(&filename, wxT("*.desktop"), wxDIR_FILES);
907 while(cont) {
908 LoadKDELinksForMimeSubtype(dirname.GetPath(), subdir,
909 filename, icondirs);
910 cont = dir.GetNext(&filename);
911 }
912}
913
914void wxMimeTypesManagerImpl::LoadKDELinkFilesFromDir(const wxString& dirname,
915 const wxArrayString& icondirs)
916{
917 if(! wxDir::Exists(dirname))
918 return;
919
920 wxDir dir(dirname);
921 if ( !dir.IsOpened() )
922 return;
923
924 wxString subdir;
925 bool cont = dir.GetFirst(&subdir, wxEmptyString, wxDIR_DIRS);
926 while ( cont )
927 {
928 LoadKDELinksForMimeType(dirname, subdir, icondirs);
929
930 cont = dir.GetNext(&subdir);
931 }
932}
933
934// Read a KDE .desktop file of type 'Application'
935void wxMimeTypesManagerImpl::LoadKDEApp(const wxString& filename)
936{
937 wxLogTrace(TRACE_MIME, wxT("loading KDE file %s"), filename.c_str());
938
939 wxMimeTextFile file;
940 if ( !file.Open(filename) )
941 return;
942
943 // Here, only type 'Application' should be considered.
944 int nIndex = file.pIndexOf( wxT("Type=") );
945 if (nIndex != wxNOT_FOUND &&
946 file.GetCmd(nIndex).Lower() != wxT("application"))
947 return;
948
949 // The hidden entry specifies a file to be ignored.
950 nIndex = file.pIndexOf( wxT("Hidden=") );
951 if (nIndex != wxNOT_FOUND && file.GetCmd(nIndex).Lower() == wxT("true"))
952 return;
953
954 // Semicolon separated list of mime types handled by the application.
955 nIndex = file.pIndexOf( wxT("MimeType=") );
956 if (nIndex == wxNOT_FOUND)
957 return;
958 wxString mimetypes = file.GetCmd (nIndex);
959
960 // Name of the application
961 wxString nameapp;
962 nIndex = wxNOT_FOUND;
963#if wxUSE_INTL // try "Name[locale name]" first
964 wxLocale *locale = wxGetLocale();
965 if ( locale )
966 nIndex = file.pIndexOf(_T("Name[")+locale->GetName()+_T("]="));
967#endif // wxUSE_INTL
968 if(nIndex == wxNOT_FOUND)
969 nIndex = file.pIndexOf( wxT("Name=") );
970 if(nIndex != wxNOT_FOUND)
971 nameapp = file.GetCmd(nIndex);
972
973 // Icon of the application.
974 wxString nameicon, namemini;
975 nIndex = wxNOT_FOUND;
976#if wxUSE_INTL // try "Icon[locale name]" first
977 if ( locale )
978 nIndex = file.pIndexOf(_T("Icon[")+locale->GetName()+_T("]="));
979#endif // wxUSE_INTL
980 if(nIndex == wxNOT_FOUND)
981 nIndex = file.pIndexOf( wxT("Icon=") );
982 if(nIndex != wxNOT_FOUND) {
983 nameicon = wxString(wxT("--icon ")) + file.GetCmd(nIndex);
984 namemini = wxString(wxT("--miniicon ")) + file.GetCmd(nIndex);
985 }
986
987 // Replace some of the field code in the 'Exec' entry.
988 // TODO: deal with %d, %D, %n, %N, %k and %v (but last one is deprecated)
989 nIndex = file.pIndexOf( wxT("Exec=") );
990 if (nIndex == wxNOT_FOUND)
991 return;
992 wxString sCmd = file.GetCmd(nIndex);
993 // we expect %f; others including %F and %U and %u are possible
994 sCmd.Replace(wxT("%F"), wxT("%f"));
995 sCmd.Replace(wxT("%U"), wxT("%f"));
996 sCmd.Replace(wxT("%u"), wxT("%f"));
997 if (0 == sCmd.Replace ( wxT("%f"), wxT("%s") ))
998 sCmd = sCmd + wxT(" %s");
999 sCmd.Replace(wxT("%c"), nameapp);
1000 sCmd.Replace(wxT("%i"), nameicon);
1001 sCmd.Replace(wxT("%m"), namemini);
1002
1003 wxStringTokenizer tokenizer(mimetypes, _T(";"));
1004 while(tokenizer.HasMoreTokens()) {
1005 wxString mimetype = tokenizer.GetNextToken().Lower();
1006 nIndex = m_aTypes.Index(mimetype);
1007 if(nIndex != wxNOT_FOUND) { // is this a known MIME type?
1008 wxMimeTypeCommands* entry = m_aEntries[nIndex];
1009 entry->AddOrReplaceVerb(wxT("open"), sCmd);
1010 }
1011 }
1012}
1013
1014void wxMimeTypesManagerImpl::LoadKDEAppsFilesFromDir(const wxString& dirname)
1015{
1016 if(! wxDir::Exists(dirname))
1017 return;
1018 wxDir dir(dirname);
1019 if ( !dir.IsOpened() )
1020 return;
1021
1022 wxString filename;
1023 // Look into .desktop files
1024 bool cont = dir.GetFirst(&filename, _T("*.desktop"), wxDIR_FILES);
1025 while(cont) {
1026 wxFileName p(dirname, filename);
1027 LoadKDEApp( p.GetFullPath() );
1028 cont = dir.GetNext(&filename);
1029 }
1030 // Look recursively into subdirs
1031 cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
1032 while(cont) {
1033 wxFileName p(dirname, wxEmptyString);
1034 p.AppendDir(filename);
1035 LoadKDEAppsFilesFromDir( p.GetPath() );
1036 cont = dir.GetNext(&filename);
1037 }
1038}
1039
1040// Return base KDE directories.
1041// 1) Environment variable $KDEHOME, or "~/.kde" if not set.
1042// 2) List of directories in colon separated environment variable $KDEDIRS.
1043// 3) Environment variable $KDEDIR in case $KDEDIRS is not set.
1044// Notice at least the local kde directory is added to the list. If it is the
1045// only one, use later the application 'kde-config' to get additional paths.
1046static void GetKDEBaseDirs(wxArrayString& basedirs)
1047{
1048 wxString env = wxGetenv( wxT("KDEHOME") );
1049 if(env.IsEmpty())
1050 env = wxGetHomeDir() + wxT("/.kde");
1051 basedirs.Add(env);
1052
1053 env = wxGetenv( wxT("KDEDIRS") );
1054 if(env.IsEmpty()) {
1055 env = wxGetenv( wxT("KDEDIR") );
1056 if(! env.IsEmpty())
1057 basedirs.Add(env);
1058 } else {
1059 wxStringTokenizer tokenizer(env, wxT(":"));
1060 while(tokenizer.HasMoreTokens())
1061 basedirs.Add( tokenizer.GetNextToken() );
1062 }
1063}
1064
1065static wxString ReadPathFromKDEConfig(const wxString& request)
1066{
1067 wxString str;
1068 wxArrayString output;
1069 if(wxExecute(wxT("kde-config --path ")+request, output) == 0 &&
1070 output.GetCount() > 0)
1071 str = output.Item(0);
1072 return str;
1073}
1074
1075// Try to find the "Theme" entry in the configuration file, provided it exists.
1076static wxString GetKDEThemeInFile(const wxFileName& filename)
1077{
1078 wxString theme;
1079 wxMimeTextFile config;
1080 if ( filename.FileExists() && config.Open(filename.GetFullPath()) )
1081 {
1082 size_t cnt = config.GetLineCount();
1083 for ( size_t i = 0; i < cnt; i++ )
1084 {
1085 if ( config[i].StartsWith(wxT("Theme="), &theme) )
1086 break;
1087 }
1088 }
1089
1090 return theme;
1091}
1092
1093// Try to find a file "kdeglobals" in one of the directories and read the
1094// "Theme" entry there.
1095static wxString GetKDETheme(const wxArrayString& basedirs)
1096{
1097 wxString theme;
1098 for(size_t i = 0; i < basedirs.GetCount(); i++) {
1099 wxFileName filename(basedirs.Item(i), wxEmptyString);
1100 filename.AppendDir( wxT("share") );
1101 filename.AppendDir( wxT("config") );
1102 filename.SetName( wxT("kdeglobals") );
1103 theme = GetKDEThemeInFile(filename);
1104 if(! theme.IsEmpty())
1105 return theme;
1106 }
1107 // If $KDEDIRS and $KDEDIR were set, we try nothing more. Otherwise, we
1108 // try to get the configuration file with 'kde-config'.
1109 if(basedirs.GetCount() > 1)
1110 return theme;
1111 wxString paths = ReadPathFromKDEConfig(wxT("config"));
1112 if(! paths.IsEmpty()) {
1113 wxStringTokenizer tokenizer(paths, wxT(":"));
1114 while( tokenizer.HasMoreTokens() ) {
1115 wxFileName filename(tokenizer.GetNextToken(), wxT("kdeglobals"));
1116 theme = GetKDEThemeInFile(filename);
1117 if(! theme.IsEmpty())
1118 return theme;
1119 }
1120 }
1121 return theme;
1122}
1123
1124// Get list of directories of icons.
1125static void GetKDEIconDirs(const wxArrayString& basedirs,
1126 wxArrayString& icondirs)
1127{
1128 wxString theme = GetKDETheme(basedirs);
1129 if(theme.IsEmpty())
1130 theme = wxT("default.kde");
1131
1132 for(size_t i = 0; i < basedirs.GetCount(); i++) {
1133 wxFileName dirname(basedirs.Item(i), wxEmptyString);
1134 dirname.AppendDir( wxT("share") );
1135 dirname.AppendDir( wxT("icons") );
1136 dirname.AppendDir(theme);
1137 dirname.AppendDir( wxT("32x32") );
1138 dirname.AppendDir( wxT("mimetypes") );
1139 if( wxDir::Exists( dirname.GetPath() ) )
1140 icondirs.Add( dirname.GetPath() );
1141 }
1142
1143 // If $KDEDIRS and $KDEDIR were not set, use 'kde-config'
1144 if(basedirs.GetCount() > 1)
1145 return;
1146 wxString paths = ReadPathFromKDEConfig(wxT("icon"));
1147 if(! paths.IsEmpty()) {
1148 wxStringTokenizer tokenizer(paths, wxT(":"));
1149 while( tokenizer.HasMoreTokens() ) {
1150 wxFileName dirname(tokenizer.GetNextToken(), wxEmptyString);
1151 dirname.AppendDir(theme);
1152 dirname.AppendDir( wxT("32x32") );
1153 dirname.AppendDir( wxT("mimetypes") );
1154 if(icondirs.Index(dirname.GetPath()) == wxNOT_FOUND &&
1155 wxDir::Exists( dirname.GetPath() ) )
1156 icondirs.Add( dirname.GetPath() );
1157 }
1158 }
1159}
1160
1161// Get list of directories of mime types.
1162static void GetKDEMimeDirs(const wxArrayString& basedirs,
1163 wxArrayString& mimedirs)
1164{
1165 for(size_t i = 0; i < basedirs.GetCount(); i++) {
1166 wxFileName dirname(basedirs.Item(i), wxEmptyString);
1167 dirname.AppendDir( wxT("share") );
1168 dirname.AppendDir( wxT("mimelnk") );
1169 if( wxDir::Exists( dirname.GetPath() ) )
1170 mimedirs.Add( dirname.GetPath() );
1171 }
1172
1173 // If $KDEDIRS and $KDEDIR were not set, use 'kde-config'
1174 if(basedirs.GetCount() > 1)
1175 return;
1176 wxString paths = ReadPathFromKDEConfig(wxT("mime"));
1177 if(! paths.IsEmpty()) {
1178 wxStringTokenizer tokenizer(paths, wxT(":"));
1179 while( tokenizer.HasMoreTokens() ) {
1180 wxFileName p(tokenizer.GetNextToken(), wxEmptyString);
1181 wxString dirname = p.GetPath(); // To remove possible trailing '/'
1182 if(mimedirs.Index(dirname) == wxNOT_FOUND &&
1183 wxDir::Exists(dirname) )
1184 mimedirs.Add(dirname);
1185 }
1186 }
1187}
1188
1189// Get list of directories of application desktop files.
1190static void GetKDEAppsDirs(const wxArrayString& basedirs,
1191 wxArrayString& appsdirs)
1192{
1193 for(size_t i = 0; i < basedirs.GetCount(); i++) {
1194 wxFileName dirname(basedirs.Item(i), wxEmptyString);
1195 dirname.AppendDir( wxT("share") );
1196 dirname.AppendDir( wxT("applnk") );
1197 if( wxDir::Exists( dirname.GetPath() ) )
1198 appsdirs.Add( dirname.GetPath() );
1199 }
1200
1201 // If $KDEDIRS and $KDEDIR were not set, use 'kde-config'
1202 if(basedirs.GetCount() > 1)
1203 return;
1204 wxString paths = ReadPathFromKDEConfig(wxT("apps"));
1205 if(! paths.IsEmpty()) {
1206 wxStringTokenizer tokenizer(paths, wxT(":"));
1207 while( tokenizer.HasMoreTokens() ) {
1208 wxFileName p(tokenizer.GetNextToken(), wxEmptyString);
1209 wxString dirname = p.GetPath(); // To remove possible trailing '/'
1210 if(appsdirs.Index(dirname) == wxNOT_FOUND &&
1211 wxDir::Exists(dirname) )
1212 appsdirs.Add(dirname);
1213 }
1214 }
1215 paths = ReadPathFromKDEConfig(wxT("xdgdata-apps"));
1216 if(! paths.IsEmpty()) {
1217 wxStringTokenizer tokenizer(paths, wxT(":"));
1218 while( tokenizer.HasMoreTokens() ) {
1219 wxFileName p(tokenizer.GetNextToken(), wxEmptyString);
1220 wxString dirname = p.GetPath(); // To remove possible trailing '/'
1221 if(appsdirs.Index(dirname) == wxNOT_FOUND &&
1222 wxDir::Exists(dirname) )
1223 appsdirs.Add(dirname);
1224 }
1225 }
1226}
1227
1228// Fill database with all mime types.
1229void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)
1230{
1231 wxArrayString basedirs;
1232 GetKDEBaseDirs(basedirs);
1233
1234 wxArrayString icondirs;
1235 GetKDEIconDirs(basedirs, icondirs);
1236 wxArrayString mimedirs;
1237 GetKDEMimeDirs(basedirs, mimedirs);
1238 wxArrayString appsdirs;
1239 GetKDEAppsDirs(basedirs, appsdirs);
1240
1241 if(! sExtraDir.IsEmpty()) {
1242 icondirs.Add(sExtraDir + wxT("/icons"));
1243 mimedirs.Add(sExtraDir + wxT("/mimelnk"));
1244 appsdirs.Add(sExtraDir + wxT("/applnk"));
1245 }
1246
1247 // Load mime types
1248 size_t nDirs = mimedirs.GetCount(), nDir;
1249 for(nDir = 0; nDir < nDirs; nDir++)
1250 LoadKDELinkFilesFromDir(mimedirs[nDir], icondirs);
1251
1252 // Load application files and associate them to corresponding mime types.
1253 nDirs = appsdirs.GetCount();
1254 for(nDir = 0; nDir < nDirs; nDir++)
1255 LoadKDEAppsFilesFromDir(appsdirs[nDir]);
1256}
1257
1258// ----------------------------------------------------------------------------
1259// wxFileTypeImpl (Unix)
1260// ----------------------------------------------------------------------------
1261
1262wxString wxFileTypeImpl::GetExpandedCommand(const wxString & verb, const wxFileType::MessageParameters& params) const
1263{
1264 wxString sTmp;
1265 size_t i = 0;
1266 while ( (i < m_index.GetCount() ) && sTmp.empty() )
1267 {
1268 sTmp = m_manager->GetCommand( verb, m_index[i] );
1269 i++;
1270 }
1271
1272 return wxFileType::ExpandCommand(sTmp, params);
1273}
1274
1275bool wxFileTypeImpl::GetIcon(wxIconLocation *iconLoc) const
1276{
1277 wxString sTmp;
1278 size_t i = 0;
1279 while ( (i < m_index.GetCount() ) && sTmp.empty() )
1280 {
1281 sTmp = m_manager->m_aIcons[m_index[i]];
1282 i++;
1283 }
1284
1285 if ( sTmp.empty() )
1286 return false;
1287
1288 if ( iconLoc )
1289 {
1290 iconLoc->SetFileName(sTmp);
1291 }
1292
1293 return true;
1294}
1295
1296bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
1297{
1298 mimeTypes.Clear();
1299 size_t nCount = m_index.GetCount();
1300 for (size_t i = 0; i < nCount; i++)
1301 mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);
1302
1303 return true;
1304}
1305
1306size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
1307 wxArrayString *commands,
1308 const wxFileType::MessageParameters& params) const
1309{
1310 wxString vrb, cmd, sTmp;
1311 size_t count = 0;
1312 wxMimeTypeCommands * sPairs;
1313
1314 // verbs and commands have been cleared already in mimecmn.cpp...
1315 // if we find no entries in the exact match, try the inexact match
1316 for (size_t n = 0; ((count == 0) && (n < m_index.GetCount())); n++)
1317 {
1318 // list of verb = command pairs for this mimetype
1319 sPairs = m_manager->m_aEntries [m_index[n]];
1320 size_t i;
1321 for ( i = 0; i < sPairs->GetCount(); i++ )
1322 {
1323 vrb = sPairs->GetVerb(i);
1324 // some gnome entries have "." inside
1325 vrb = vrb.AfterLast(wxT('.'));
1326 cmd = sPairs->GetCmd(i);
1327 if (! cmd.empty() )
1328 {
1329 cmd = wxFileType::ExpandCommand(cmd, params);
1330 count++;
1331 if ( vrb.IsSameAs(wxT("open")))
1332 {
1333 if ( verbs )
1334 verbs->Insert(vrb, 0u);
1335 if ( commands )
1336 commands ->Insert(cmd, 0u);
1337 }
1338 else
1339 {
1340 if ( verbs )
1341 verbs->Add(vrb);
1342 if ( commands )
1343 commands->Add(cmd);
1344 }
1345 }
1346 }
1347 }
1348
1349 return count;
1350}
1351
1352bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
1353{
1354 const wxString strExtensions = m_manager->GetExtension(m_index[0]);
1355 extensions.Empty();
1356
1357 // one extension in the space or comma-delimited list
1358 wxString strExt;
1359 wxString::const_iterator end = strExtensions.end();
1360 for ( wxString::const_iterator p = strExtensions.begin(); /* nothing */; ++p )
1361 {
1362 if ( p == end || *p == wxT(' ') || *p == wxT(',') )
1363 {
1364 if ( !strExt.empty() )
1365 {
1366 extensions.Add(strExt);
1367 strExt.Empty();
1368 }
1369 //else: repeated spaces
1370 // (shouldn't happen, but it's not that important if it does happen)
1371
1372 if ( p == end )
1373 break;
1374 }
1375 else if ( *p == wxT('.') )
1376 {
1377 // remove the dot from extension (but only if it's the first char)
1378 if ( !strExt.empty() )
1379 {
1380 strExt += wxT('.');
1381 }
1382 //else: no, don't append it
1383 }
1384 else
1385 {
1386 strExt += *p;
1387 }
1388 }
1389
1390 return true;
1391}
1392
1393// set an arbitrary command:
1394// could adjust the code to ask confirmation if it already exists and
1395// overwriteprompt is true, but this is currently ignored as *Associate* has
1396// no overwrite prompt
1397bool
1398wxFileTypeImpl::SetCommand(const wxString& cmd,
1399 const wxString& verb,
1400 bool WXUNUSED(overwriteprompt))
1401{
1402 wxArrayString strExtensions;
1403 wxString strDesc, strIcon;
1404
1405 wxArrayString strTypes;
1406 GetMimeTypes(strTypes);
1407 if ( strTypes.IsEmpty() )
1408 return false;
1409
1410 wxMimeTypeCommands *entry = new wxMimeTypeCommands();
1411 entry->Add(verb + wxT("=") + cmd + wxT(" %s "));
1412
1413 bool ok = false;
1414 size_t nCount = strTypes.GetCount();
1415 for ( size_t i = 0; i < nCount; i++ )
1416 {
1417 if ( m_manager->DoAssociation
1418 (
1419 strTypes[i],
1420 strIcon,
1421 entry,
1422 strExtensions,
1423 strDesc
1424 ) )
1425 {
1426 // DoAssociation() took ownership of entry, don't delete it below
1427 ok = true;
1428 }
1429 }
1430
1431 if ( !ok )
1432 delete entry;
1433
1434 return ok;
1435}
1436
1437// ignore index on the grounds that we only have one icon in a Unix file
1438bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int WXUNUSED(index))
1439{
1440 if (strIcon.empty())
1441 return false;
1442
1443 wxArrayString strExtensions;
1444 wxString strDesc;
1445
1446 wxArrayString strTypes;
1447 GetMimeTypes(strTypes);
1448 if ( strTypes.IsEmpty() )
1449 return false;
1450
1451 wxMimeTypeCommands *entry = new wxMimeTypeCommands();
1452 bool ok = false;
1453 size_t nCount = strTypes.GetCount();
1454 for ( size_t i = 0; i < nCount; i++ )
1455 {
1456 if ( m_manager->DoAssociation
1457 (
1458 strTypes[i],
1459 strIcon,
1460 entry,
1461 strExtensions,
1462 strDesc
1463 ) )
1464 {
1465 // we don't need to free entry now, DoAssociation() took ownership
1466 // of it
1467 ok = true;
1468 }
1469 }
1470
1471 if ( !ok )
1472 delete entry;
1473
1474 return ok;
1475}
1476
1477// ----------------------------------------------------------------------------
1478// wxMimeTypesManagerImpl (Unix)
1479// ----------------------------------------------------------------------------
1480
1481wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
1482{
1483 m_initialized = false;
1484 m_mailcapStylesInited = 0;
1485}
1486
1487void wxMimeTypesManagerImpl::InitIfNeeded()
1488{
1489 if ( !m_initialized )
1490 {
1491 // set the flag first to prevent recursion
1492 m_initialized = true;
1493
1494 wxString wm = wxTheApp->GetTraits()->GetDesktopEnvironment();
1495
1496 if (wm == wxT("KDE"))
1497 Initialize( wxMAILCAP_KDE );
1498 else if (wm == wxT("GNOME"))
1499 Initialize( wxMAILCAP_GNOME );
1500 else
1501 Initialize();
1502 }
1503}
1504
1505// read system and user mailcaps and other files
1506void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
1507 const wxString& sExtraDir)
1508{
1509 // read mimecap amd mime.types
1510 if ( (mailcapStyles & wxMAILCAP_NETSCAPE) ||
1511 (mailcapStyles & wxMAILCAP_STANDARD) )
1512 GetMimeInfo(sExtraDir);
1513
1514 // read GNOME tables
1515 if (mailcapStyles & wxMAILCAP_GNOME)
1516 GetGnomeMimeInfo(sExtraDir);
1517
1518 // read KDE tables which are never installed on OpenVMS
1519#ifndef __VMS
1520 if (mailcapStyles & wxMAILCAP_KDE)
1521 GetKDEMimeInfo(sExtraDir);
1522#endif
1523
1524 m_mailcapStylesInited |= mailcapStyles;
1525}
1526
1527// clear data so you can read another group of WM files
1528void wxMimeTypesManagerImpl::ClearData()
1529{
1530 m_aTypes.Clear();
1531 m_aIcons.Clear();
1532 m_aExtensions.Clear();
1533 m_aDescriptions.Clear();
1534
1535 WX_CLEAR_ARRAY(m_aEntries);
1536 m_aEntries.Empty();
1537
1538 m_mailcapStylesInited = 0;
1539}
1540
1541wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl()
1542{
1543 ClearData();
1544}
1545
1546void wxMimeTypesManagerImpl::GetMimeInfo(const wxString& sExtraDir)
1547{
1548 // read this for netscape or Metamail formats
1549
1550 // directories where we look for mailcap and mime.types by default
1551 // used by netscape and pine and other mailers, using 2 different formats!
1552
1553 // (taken from metamail(1) sources)
1554 //
1555 // although RFC 1524 specifies the search path of
1556 // /etc/:/usr/etc:/usr/local/etc only, it doesn't hurt to search in more
1557 // places - OTOH, the RFC also says that this path can be changed with
1558 // MAILCAPS environment variable (containing the colon separated full
1559 // filenames to try) which is not done yet (TODO?)
1560
1561 wxString strHome = wxGetenv(wxT("HOME"));
1562
1563 wxArrayString dirs;
1564 dirs.Add( strHome + wxT("/.") );
1565 dirs.Add( wxT("/etc/") );
1566 dirs.Add( wxT("/usr/etc/") );
1567 dirs.Add( wxT("/usr/local/etc/") );
1568 dirs.Add( wxT("/etc/mail/") );
1569 dirs.Add( wxT("/usr/public/lib/") );
1570 if (!sExtraDir.empty())
1571 dirs.Add( sExtraDir + wxT("/") );
1572
1573 wxString file;
1574 size_t nDirs = dirs.GetCount();
1575 for ( size_t nDir = 0; nDir < nDirs; nDir++ )
1576 {
1577 file = dirs[nDir];
1578 file += wxT("mailcap");
1579 if ( wxFile::Exists(file) )
1580 {
1581 ReadMailcap(file);
1582 }
1583
1584 file = dirs[nDir];
1585 file += wxT("mime.types");
1586 if ( wxFile::Exists(file) )
1587 ReadMimeTypes(file);
1588 }
1589}
1590
1591bool wxMimeTypesManagerImpl::WriteToMimeTypes(int index, bool delete_index)
1592{
1593 // check we have the right manager
1594 if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD) )
1595 return false;
1596
1597 bool bTemp;
1598 wxString strHome = wxGetenv(wxT("HOME"));
1599
1600 // and now the users mailcap
1601 wxString strUserMailcap = strHome + wxT("/.mime.types");
1602
1603 wxMimeTextFile file;
1604 if ( wxFile::Exists(strUserMailcap) )
1605 {
1606 bTemp = file.Open(strUserMailcap);
1607 }
1608 else
1609 {
1610 if (delete_index)
1611 return false;
1612
1613 bTemp = file.Create(strUserMailcap);
1614 }
1615
1616 if (bTemp)
1617 {
1618 int nIndex;
1619 // test for netscape's header and return false if its found
1620 nIndex = file.pIndexOf(wxT("#--Netscape"));
1621 if (nIndex != wxNOT_FOUND)
1622 {
1623 wxFAIL_MSG(wxT("Error in .mime.types\nTrying to mix Netscape and Metamail formats\nFile not modified"));
1624 return false;
1625 }
1626
1627 // write it in alternative format
1628 // get rid of unwanted entries
1629 wxString strType = m_aTypes[index];
1630 nIndex = file.pIndexOf(strType);
1631
1632 // get rid of all the unwanted entries...
1633 if (nIndex != wxNOT_FOUND)
1634 file.CommentLine(nIndex);
1635
1636 if (!delete_index)
1637 {
1638 // add the new entries in
1639 wxString sTmp = strType.Append( wxT(' '), 40 - strType.Len() );
1640 sTmp += m_aExtensions[index];
1641 file.AddLine(sTmp);
1642 }
1643
1644 bTemp = file.Write();
1645 file.Close();
1646 }
1647
1648 return bTemp;
1649}
1650
1651bool wxMimeTypesManagerImpl::WriteToNSMimeTypes(int index, bool delete_index)
1652{
1653 //check we have the right managers
1654 if (! ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) )
1655 return false;
1656
1657 bool bTemp;
1658 wxString strHome = wxGetenv(wxT("HOME"));
1659
1660 // and now the users mailcap
1661 wxString strUserMailcap = strHome + wxT("/.mime.types");
1662
1663 wxMimeTextFile file;
1664 if ( wxFile::Exists(strUserMailcap) )
1665 {
1666 bTemp = file.Open(strUserMailcap);
1667 }
1668 else
1669 {
1670 if (delete_index)
1671 return false;
1672
1673 bTemp = file.Create(strUserMailcap);
1674 }
1675
1676 if (bTemp)
1677 {
1678 // write it in the format that Netscape uses
1679 int nIndex;
1680 // test for netscape's header and insert if required...
1681 // this is a comment so use true
1682 nIndex = file.pIndexOf(wxT("#--Netscape"), true);
1683 if (nIndex == wxNOT_FOUND)
1684 {
1685 // either empty file or metamail format
1686 // at present we can't cope with mixed formats, so exit to preseve
1687 // metamail entreies
1688 if (file.GetLineCount() > 0)
1689 {
1690 wxFAIL_MSG(wxT(".mime.types File not in Netscape format\nNo entries written to\n.mime.types or to .mailcap"));
1691 return false;
1692 }
1693
1694 file.InsertLine(wxT( "#--Netscape Communications Corporation MIME Information" ), 0);
1695 nIndex = 0;
1696 }
1697
1698 wxString strType = wxT("type=") + m_aTypes[index];
1699 nIndex = file.pIndexOf(strType);
1700
1701 // get rid of all the unwanted entries...
1702 if (nIndex != wxNOT_FOUND)
1703 {
1704 wxString sOld = file[nIndex];
1705 while ( (sOld.Contains(wxT("\\"))) && (nIndex < (int) file.GetLineCount()) )
1706 {
1707 file.CommentLine(nIndex);
1708 sOld = file[nIndex];
1709
1710 wxLogTrace(TRACE_MIME, wxT("--- Deleting from mime.types line '%d %s' ---"), nIndex, sOld.c_str());
1711
1712 nIndex++;
1713 }
1714
1715 if (nIndex < (int) file.GetLineCount())
1716 file.CommentLine(nIndex);
1717 }
1718 else
1719 nIndex = (int) file.GetLineCount();
1720
1721 wxString sTmp = strType + wxT(" \\");
1722 if (!delete_index)
1723 file.InsertLine(sTmp, nIndex);
1724
1725 if ( ! m_aDescriptions.Item(index).empty() )
1726 {
1727 sTmp = wxT("desc=\"") + m_aDescriptions[index]+ wxT("\" \\"); //.trim ??
1728 if (!delete_index)
1729 {
1730 nIndex++;
1731 file.InsertLine(sTmp, nIndex);
1732 }
1733 }
1734
1735 wxString sExts = m_aExtensions.Item(index);
1736 sTmp = wxT("exts=\"") + sExts.Trim(false).Trim() + wxT("\"");
1737 if (!delete_index)
1738 {
1739 nIndex++;
1740 file.InsertLine(sTmp, nIndex);
1741 }
1742
1743 bTemp = file.Write();
1744 file.Close();
1745 }
1746
1747 return bTemp;
1748}
1749
1750bool wxMimeTypesManagerImpl::WriteToMailCap(int index, bool delete_index)
1751{
1752 //check we have the right managers
1753 if ( !( ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) ||
1754 ( m_mailcapStylesInited & wxMAILCAP_STANDARD) ) )
1755 return false;
1756
1757 bool bTemp = false;
1758 wxString strHome = wxGetenv(wxT("HOME"));
1759
1760 // and now the users mailcap
1761 wxString strUserMailcap = strHome + wxT("/.mailcap");
1762
1763 wxMimeTextFile file;
1764 if ( wxFile::Exists(strUserMailcap) )
1765 {
1766 bTemp = file.Open(strUserMailcap);
1767 }
1768 else
1769 {
1770 if (delete_index)
1771 return false;
1772
1773 bTemp = file.Create(strUserMailcap);
1774 }
1775
1776 if (bTemp)
1777 {
1778 // now got a file we can write to ....
1779 wxMimeTypeCommands * entries = m_aEntries[index];
1780 size_t iOpen;
1781 wxString sCmd = entries->GetCommandForVerb(wxT("open"), &iOpen);
1782 wxString sTmp;
1783
1784 sTmp = m_aTypes[index];
1785 wxString sOld;
1786 int nIndex = file.pIndexOf(sTmp);
1787
1788 // get rid of all the unwanted entries...
1789 if (nIndex == wxNOT_FOUND)
1790 {
1791 nIndex = (int) file.GetLineCount();
1792 }
1793 else
1794 {
1795 sOld = file[nIndex];
1796 wxLogTrace(TRACE_MIME, wxT("--- Deleting from mailcap line '%d' ---"), nIndex);
1797
1798 while ( (sOld.Contains(wxT("\\"))) && (nIndex < (int) file.GetLineCount()) )
1799 {
1800 file.CommentLine(nIndex);
1801 if (nIndex < (int) file.GetLineCount())
1802 sOld = sOld + file[nIndex];
1803 }
1804
1805 if (nIndex < (int)
1806 file.GetLineCount()) file.CommentLine(nIndex);
1807 }
1808
1809 sTmp += wxT(";") + sCmd; //includes wxT(" %s ");
1810
1811 // write it in the format that Netscape uses (default)
1812 if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD ) )
1813 {
1814 if (! delete_index)
1815 file.InsertLine(sTmp, nIndex);
1816 nIndex++;
1817 }
1818 else
1819 {
1820 // write extended format
1821
1822 // TODO - FIX this code:
1823 // ii) lost entries
1824 // sOld holds all the entries, but our data store only has some
1825 // eg test= is not stored
1826
1827 // so far we have written the mimetype and command out
1828 wxStringTokenizer sT(sOld, wxT(";\\"));
1829 if (sT.CountTokens() > 2)
1830 {
1831 // first one mimetype; second one command, rest unknown...
1832 wxString s;
1833 s = sT.GetNextToken();
1834 s = sT.GetNextToken();
1835
1836 // first unknown
1837 s = sT.GetNextToken();
1838 while ( ! s.empty() )
1839 {
1840 bool bKnownToken = false;
1841 if (s.Contains(wxT("description=")))
1842 bKnownToken = true;
1843 if (s.Contains(wxT("x11-bitmap=")))
1844 bKnownToken = true;
1845
1846 size_t i;
1847 size_t nCount = entries->GetCount();
1848 for (i=0; i < nCount; i++)
1849 {
1850 if (s.Contains(entries->GetVerb(i)))
1851 bKnownToken = true;
1852 }
1853
1854 if (!bKnownToken)
1855 {
1856 sTmp += wxT("; \\");
1857 file.InsertLine(sTmp, nIndex);
1858 sTmp = s;
1859 }
1860
1861 s = sT.GetNextToken();
1862 }
1863 }
1864
1865 if (! m_aDescriptions[index].empty() )
1866 {
1867 sTmp += wxT("; \\");
1868 file.InsertLine(sTmp, nIndex);
1869 nIndex++;
1870 sTmp = wxT(" description=\"") + m_aDescriptions[index] + wxT("\"");
1871 }
1872
1873 if (! m_aIcons[index].empty() )
1874 {
1875 sTmp += wxT("; \\");
1876 file.InsertLine(sTmp, nIndex);
1877 nIndex++;
1878 sTmp = wxT(" x11-bitmap=\"") + m_aIcons[index] + wxT("\"");
1879 }
1880
1881 if ( entries->GetCount() > 1 )
1882 {
1883 size_t i;
1884 for (i=0; i < entries->GetCount(); i++)
1885 if ( i != iOpen )
1886 {
1887 sTmp += wxT("; \\");
1888 file.InsertLine(sTmp, nIndex);
1889 nIndex++;
1890 sTmp = wxT(" ") + entries->GetVerbCmd(i);
1891 }
1892 }
1893
1894 file.InsertLine(sTmp, nIndex);
1895 nIndex++;
1896 }
1897
1898 bTemp = file.Write();
1899 file.Close();
1900 }
1901
1902 return bTemp;
1903}
1904
1905wxFileType * wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
1906{
1907 InitIfNeeded();
1908
1909 wxString strType = ftInfo.GetMimeType();
1910 wxString strDesc = ftInfo.GetDescription();
1911 wxString strIcon = ftInfo.GetIconFile();
1912
1913 wxMimeTypeCommands *entry = new wxMimeTypeCommands();
1914
1915 if ( ! ftInfo.GetOpenCommand().empty())
1916 entry->Add(wxT("open=") + ftInfo.GetOpenCommand() + wxT(" %s "));
1917 if ( ! ftInfo.GetPrintCommand().empty())
1918 entry->Add(wxT("print=") + ftInfo.GetPrintCommand() + wxT(" %s "));
1919
1920 // now find where these extensions are in the data store and remove them
1921 wxArrayString sA_Exts = ftInfo.GetExtensions();
1922 wxString sExt, sExtStore;
1923 size_t i, nIndex;
1924 size_t nExtCount = sA_Exts.GetCount();
1925 for (i=0; i < nExtCount; i++)
1926 {
1927 sExt = sA_Exts.Item(i);
1928
1929 // clean up to just a space before and after
1930 sExt.Trim().Trim(false);
1931 sExt = wxT(' ') + sExt + wxT(' ');
1932 size_t nCount = m_aExtensions.GetCount();
1933 for (nIndex = 0; nIndex < nCount; nIndex++)
1934 {
1935 sExtStore = m_aExtensions.Item(nIndex);
1936 if (sExtStore.Replace(sExt, wxT(" ") ) > 0)
1937 m_aExtensions.Item(nIndex) = sExtStore;
1938 }
1939 }
1940
1941 if ( !DoAssociation(strType, strIcon, entry, sA_Exts, strDesc) )
1942 return NULL;
1943
1944 return GetFileTypeFromMimeType(strType);
1945}
1946
1947bool wxMimeTypesManagerImpl::DoAssociation(const wxString& strType,
1948 const wxString& strIcon,
1949 wxMimeTypeCommands *entry,
1950 const wxArrayString& strExtensions,
1951 const wxString& strDesc)
1952{
1953 int nIndex = AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, true);
1954
1955 if ( nIndex == wxNOT_FOUND )
1956 return false;
1957
1958 return WriteMimeInfo(nIndex, false);
1959}
1960
1961bool wxMimeTypesManagerImpl::WriteMimeInfo(int nIndex, bool delete_mime )
1962{
1963 bool ok = true;
1964
1965 if ( m_mailcapStylesInited & wxMAILCAP_STANDARD )
1966 {
1967 // write in metamail format;
1968 if (WriteToMimeTypes(nIndex, delete_mime) )
1969 if ( WriteToMailCap(nIndex, delete_mime) )
1970 ok = false;
1971 }
1972
1973 if ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE )
1974 {
1975 // write in netsacpe format;
1976 if (WriteToNSMimeTypes(nIndex, delete_mime) )
1977 if ( WriteToMailCap(nIndex, delete_mime) )
1978 ok = false;
1979 }
1980
1981 // Don't write GNOME files here as this is not
1982 // allowed and simply doesn't work
1983
1984 if (m_mailcapStylesInited & wxMAILCAP_KDE)
1985 {
1986 // write in KDE format;
1987 if (WriteKDEMimeFile(nIndex, delete_mime) )
1988 ok = false;
1989 }
1990
1991 return ok;
1992}
1993
1994int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType,
1995 const wxString& strIcon,
1996 wxMimeTypeCommands *entry,
1997 const wxArrayString& strExtensions,
1998 const wxString& strDesc,
1999 bool replaceExisting)
2000{
2001 InitIfNeeded();
2002
2003 // ensure mimetype is always lower case
2004 wxString mimeType = strType.Lower();
2005
2006 // is this a known MIME type?
2007 int nIndex = m_aTypes.Index(mimeType);
2008 if ( nIndex == wxNOT_FOUND )
2009 {
2010 // new file type
2011 m_aTypes.Add(mimeType);
2012 m_aIcons.Add(strIcon);
2013 m_aEntries.Add(entry ? entry : new wxMimeTypeCommands);
2014
2015 // change nIndex so we can use it below to add the extensions
2016 m_aExtensions.Add(wxEmptyString);
2017 nIndex = m_aExtensions.size() - 1;
2018
2019 m_aDescriptions.Add(strDesc);
2020 }
2021 else // yes, we already have it
2022 {
2023 if ( replaceExisting )
2024 {
2025 // if new description change it
2026 if ( !strDesc.empty())
2027 m_aDescriptions[nIndex] = strDesc;
2028
2029 // if new icon change it
2030 if ( !strIcon.empty())
2031 m_aIcons[nIndex] = strIcon;
2032
2033 if ( entry )
2034 {
2035 delete m_aEntries[nIndex];
2036 m_aEntries[nIndex] = entry;
2037 }
2038 }
2039 else // add data we don't already have ...
2040 {
2041 // if new description add only if none
2042 if ( m_aDescriptions[nIndex].empty() )
2043 m_aDescriptions[nIndex] = strDesc;
2044
2045 // if new icon and no existing icon
2046 if ( m_aIcons[nIndex].empty() )
2047 m_aIcons[nIndex] = strIcon;
2048
2049 // add any new entries...
2050 if ( entry )
2051 {
2052 wxMimeTypeCommands *entryOld = m_aEntries[nIndex];
2053
2054 size_t count = entry->GetCount();
2055 for ( size_t i = 0; i < count; i++ )
2056 {
2057 const wxString& verb = entry->GetVerb(i);
2058 if ( !entryOld->HasVerb(verb) )
2059 {
2060 entryOld->AddOrReplaceVerb(verb, entry->GetCmd(i));
2061 }
2062 }
2063
2064 // as we don't store it anywhere, it won't be deleted later as
2065 // usual -- do it immediately instead
2066 delete entry;
2067 }
2068 }
2069 }
2070
2071 // always add the extensions to this mimetype
2072 wxString& exts = m_aExtensions[nIndex];
2073
2074 // add all extensions we don't have yet
2075 wxString ext;
2076 size_t count = strExtensions.GetCount();
2077 for ( size_t i = 0; i < count; i++ )
2078 {
2079 ext = strExtensions[i];
2080 ext += wxT(' ');
2081
2082 if ( exts.Find(ext) == wxNOT_FOUND )
2083 {
2084 exts += ext;
2085 }
2086 }
2087
2088 // check data integrity
2089 wxASSERT( m_aTypes.GetCount() == m_aEntries.GetCount() &&
2090 m_aTypes.GetCount() == m_aExtensions.GetCount() &&
2091 m_aTypes.GetCount() == m_aIcons.GetCount() &&
2092 m_aTypes.GetCount() == m_aDescriptions.GetCount() );
2093
2094 return nIndex;
2095}
2096
2097wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
2098{
2099 if (ext.empty() )
2100 return NULL;
2101
2102 InitIfNeeded();
2103
2104 size_t count = m_aExtensions.GetCount();
2105 for ( size_t n = 0; n < count; n++ )
2106 {
2107 wxStringTokenizer tk(m_aExtensions[n], wxT(' '));
2108
2109 while ( tk.HasMoreTokens() )
2110 {
2111 // consider extensions as not being case-sensitive
2112 if ( tk.GetNextToken().IsSameAs(ext, false /* no case */) )
2113 {
2114 // found
2115 wxFileType *fileType = new wxFileType;
2116 fileType->m_impl->Init(this, n);
2117
2118 return fileType;
2119 }
2120 }
2121 }
2122
2123 return NULL;
2124}
2125
2126wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
2127{
2128 InitIfNeeded();
2129
2130 wxFileType * fileType = NULL;
2131 // mime types are not case-sensitive
2132 wxString mimetype(mimeType);
2133 mimetype.MakeLower();
2134
2135 // first look for an exact match
2136 int index = m_aTypes.Index(mimetype);
2137 if ( index != wxNOT_FOUND )
2138 {
2139 fileType = new wxFileType;
2140 fileType->m_impl->Init(this, index);
2141 }
2142
2143 // then try to find "text/*" as match for "text/plain" (for example)
2144 // NB: if mimeType doesn't contain '/' at all, BeforeFirst() will return
2145 // the whole string - ok.
2146
2147 index = wxNOT_FOUND;
2148 wxString strCategory = mimetype.BeforeFirst(wxT('/'));
2149
2150 size_t nCount = m_aTypes.GetCount();
2151 for ( size_t n = 0; n < nCount; n++ )
2152 {
2153 if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) &&
2154 m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") )
2155 {
2156 index = n;
2157 break;
2158 }
2159 }
2160
2161 if ( index != wxNOT_FOUND )
2162 {
2163 // don't throw away fileType that was already found
2164 if (!fileType)
2165 fileType = new wxFileType;
2166 fileType->m_impl->Init(this, index);
2167 }
2168
2169 return fileType;
2170}
2171
2172wxString wxMimeTypesManagerImpl::GetCommand(const wxString & verb, size_t nIndex) const
2173{
2174 wxString command, testcmd, sV, sTmp;
2175 sV = verb + wxT("=");
2176
2177 // list of verb = command pairs for this mimetype
2178 wxMimeTypeCommands * sPairs = m_aEntries [nIndex];
2179
2180 size_t i;
2181 size_t nCount = sPairs->GetCount();
2182 for ( i = 0; i < nCount; i++ )
2183 {
2184 sTmp = sPairs->GetVerbCmd (i);
2185 if ( sTmp.Contains(sV) )
2186 command = sTmp.AfterFirst(wxT('='));
2187 }
2188
2189 return command;
2190}
2191
2192void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype)
2193{
2194 InitIfNeeded();
2195
2196 wxString extensions;
2197 const wxArrayString& exts = filetype.GetExtensions();
2198 size_t nExts = exts.GetCount();
2199 for ( size_t nExt = 0; nExt < nExts; nExt++ )
2200 {
2201 if ( nExt > 0 )
2202 extensions += wxT(' ');
2203
2204 extensions += exts[nExt];
2205 }
2206
2207 AddMimeTypeInfo(filetype.GetMimeType(),
2208 extensions,
2209 filetype.GetDescription());
2210
2211 AddMailcapInfo(filetype.GetMimeType(),
2212 filetype.GetOpenCommand(),
2213 filetype.GetPrintCommand(),
2214 wxT(""),
2215 filetype.GetDescription());
2216}
2217
2218void wxMimeTypesManagerImpl::AddMimeTypeInfo(const wxString& strMimeType,
2219 const wxString& strExtensions,
2220 const wxString& strDesc)
2221{
2222 // reading mailcap may find image/* , while
2223 // reading mime.types finds image/gif and no match is made
2224 // this means all the get functions don't work fix this
2225 wxString strIcon;
2226 wxString sTmp = strExtensions;
2227
2228 wxArrayString sExts;
2229 sTmp.Trim().Trim(false);
2230
2231 while (!sTmp.empty())
2232 {
2233 sExts.Add(sTmp.AfterLast(wxT(' ')));
2234 sTmp = sTmp.BeforeLast(wxT(' '));
2235 }
2236
2237 AddToMimeData(strMimeType, strIcon, NULL, sExts, strDesc, true);
2238}
2239
2240void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
2241 const wxString& strOpenCmd,
2242 const wxString& strPrintCmd,
2243 const wxString& strTest,
2244 const wxString& strDesc)
2245{
2246 InitIfNeeded();
2247
2248 wxMimeTypeCommands *entry = new wxMimeTypeCommands;
2249 entry->Add(wxT("open=") + strOpenCmd);
2250 entry->Add(wxT("print=") + strPrintCmd);
2251 entry->Add(wxT("test=") + strTest);
2252
2253 wxString strIcon;
2254 wxArrayString strExtensions;
2255
2256 AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, true);
2257}
2258
2259bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
2260{
2261 wxLogTrace(TRACE_MIME, wxT("--- Parsing mime.types file '%s' ---"),
2262 strFileName.c_str());
2263
2264 wxMimeTextFile file(strFileName);
2265 if ( !file.Open() )
2266 return false;
2267
2268 // the information we extract
2269 wxString strMimeType, strDesc, strExtensions;
2270
2271 size_t nLineCount = file.GetLineCount();
2272 const wxChar *pc = NULL;
2273 for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
2274 {
2275 if ( pc == NULL )
2276 {
2277 // now we're at the start of the line
2278 pc = file[nLine].c_str();
2279 }
2280 else
2281 {
2282 // we didn't finish with the previous line yet
2283 nLine--;
2284 }
2285
2286 // skip whitespace
2287 while ( wxIsspace(*pc) )
2288 pc++;
2289
2290 // comment or blank line?
2291 if ( *pc == wxT('#') || !*pc )
2292 {
2293 // skip the whole line
2294 pc = NULL;
2295 continue;
2296 }
2297
2298 // detect file format
2299 const wxChar *pEqualSign = wxStrchr(pc, wxT('='));
2300 if ( pEqualSign == NULL )
2301 {
2302 // brief format
2303 // ------------
2304
2305 // first field is mime type
2306 for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != wxT('\0'); pc++ )
2307 {
2308 strMimeType += *pc;
2309 }
2310
2311 // skip whitespace
2312 while ( wxIsspace(*pc) )
2313 pc++;
2314
2315 // take all the rest of the string
2316 strExtensions = pc;
2317
2318 // no description...
2319 strDesc.Empty();
2320 }
2321 else
2322 {
2323 // expanded format
2324 // ---------------
2325
2326 // the string on the left of '=' is the field name
2327 wxString strLHS(pc, pEqualSign - pc);
2328
2329 // eat whitespace
2330 for ( pc = pEqualSign + 1; wxIsspace(*pc); pc++ )
2331 ;
2332
2333 const wxChar *pEnd;
2334 if ( *pc == wxT('"') )
2335 {
2336 // the string is quoted and ends at the matching quote
2337 pEnd = wxStrchr(++pc, wxT('"'));
2338 if ( pEnd == NULL )
2339 {
2340 wxLogWarning(wxT("Mime.types file %s, line %lu: unterminated quoted string."),
2341 strFileName.c_str(), nLine + 1L);
2342 }
2343 }
2344 else
2345 {
2346 // unquoted string ends at the first space or at the end of
2347 // line
2348 for ( pEnd = pc; *pEnd && !wxIsspace(*pEnd); pEnd++ )
2349 ;
2350 }
2351
2352 // now we have the RHS (field value)
2353 wxString strRHS(pc, pEnd - pc);
2354
2355 // check what follows this entry
2356 if ( *pEnd == wxT('"') )
2357 {
2358 // skip this quote
2359 pEnd++;
2360 }
2361
2362 for ( pc = pEnd; wxIsspace(*pc); pc++ )
2363 ;
2364
2365 // if there is something left, it may be either a '\\' to continue
2366 // the line or the next field of the same entry
2367 bool entryEnded = *pc == wxT('\0');
2368 bool nextFieldOnSameLine = false;
2369 if ( !entryEnded )
2370 {
2371 nextFieldOnSameLine = ((*pc != wxT('\\')) || (pc[1] != wxT('\0')));
2372 }
2373
2374 // now see what we got
2375 if ( strLHS == wxT("type") )
2376 {
2377 strMimeType = strRHS;
2378 }
2379 else if ( strLHS.StartsWith(wxT("desc")) )
2380 {
2381 strDesc = strRHS;
2382 }
2383 else if ( strLHS == wxT("exts") )
2384 {
2385 strExtensions = strRHS;
2386 }
2387 else if ( strLHS == wxT("icon") )
2388 {
2389 // this one is simply ignored: it usually refers to Netscape
2390 // built in icons which are useless for us anyhow
2391 }
2392 else if ( !strLHS.StartsWith(wxT("x-")) )
2393 {
2394 // we suppose that all fields starting with "X-" are
2395 // unregistered extensions according to the standard practice,
2396 // but it may be worth telling the user about other junk in
2397 // his mime.types file
2398 wxLogWarning(wxT("Unknown field in file %s, line %lu: '%s'."),
2399 strFileName.c_str(), nLine + 1L, strLHS.c_str());
2400 }
2401
2402 if ( !entryEnded )
2403 {
2404 if ( !nextFieldOnSameLine )
2405 pc = NULL;
2406 //else: don't reset it
2407
2408 // as we don't reset strMimeType, the next field in this entry
2409 // will be interpreted correctly.
2410
2411 continue;
2412 }
2413 }
2414
2415 // depending on the format (Mosaic or Netscape) either space or comma
2416 // is used to separate the extensions
2417 strExtensions.Replace(wxT(","), wxT(" "));
2418
2419 // also deal with the leading dot
2420 if ( !strExtensions.empty() && strExtensions[0u] == wxT('.') )
2421 {
2422 strExtensions.erase(0, 1);
2423 }
2424
2425 wxLogTrace(TRACE_MIME, wxT("mime.types: '%s' => '%s' (%s)"),
2426 strExtensions.c_str(),
2427 strMimeType.c_str(),
2428 strDesc.c_str());
2429
2430 AddMimeTypeInfo(strMimeType, strExtensions, strDesc);
2431
2432 // finished with this line
2433 pc = NULL;
2434 }
2435
2436 return true;
2437}
2438
2439// ----------------------------------------------------------------------------
2440// UNIX mailcap files parsing
2441// ----------------------------------------------------------------------------
2442
2443// the data for a single MIME type
2444struct MailcapLineData
2445{
2446 // field values
2447 wxString type,
2448 cmdOpen,
2449 test,
2450 icon,
2451 desc;
2452
2453 wxArrayString verbs,
2454 commands;
2455
2456 // flags
2457 bool testfailed,
2458 needsterminal,
2459 copiousoutput;
2460
2461 MailcapLineData() { testfailed = needsterminal = copiousoutput = false; }
2462};
2463
2464// process a non-standard (i.e. not the first or second one) mailcap field
2465bool
2466wxMimeTypesManagerImpl::ProcessOtherMailcapField(MailcapLineData& data,
2467 const wxString& curField)
2468{
2469 if ( curField.empty() )
2470 {
2471 // we don't care
2472 return true;
2473 }
2474
2475 // is this something of the form foo=bar?
2476 if ( curField.find('=') != wxString::npos )
2477 {
2478 // split "LHS = RHS" in 2
2479 wxString lhs = curField.BeforeFirst(wxT('=')),
2480 rhs = curField.AfterFirst(wxT('='));
2481
2482 lhs.Trim(true); // from right
2483 rhs.Trim(false); // from left
2484
2485 // it might be quoted
2486 if ( !rhs.empty() && rhs[0u] == wxT('"') && rhs.Last() == wxT('"') )
2487 {
2488 rhs = rhs.Mid(1, rhs.length() - 2);
2489 }
2490
2491 // is it a command verb or something else?
2492 if ( lhs == wxT("test") )
2493 {
2494 if ( wxSystem(rhs) == 0 )
2495 {
2496 // ok, test passed
2497 wxLogTrace(TRACE_MIME_TEST,
2498 wxT("Test '%s' for mime type '%s' succeeded."),
2499 rhs.c_str(), data.type.c_str());
2500 }
2501 else
2502 {
2503 wxLogTrace(TRACE_MIME_TEST,
2504 wxT("Test '%s' for mime type '%s' failed, skipping."),
2505 rhs.c_str(), data.type.c_str());
2506
2507 data.testfailed = true;
2508 }
2509 }
2510 else if ( lhs == wxT("desc") )
2511 {
2512 data.desc = rhs;
2513 }
2514 else if ( lhs == wxT("x11-bitmap") )
2515 {
2516 data.icon = rhs;
2517 }
2518 else if ( lhs == wxT("notes") )
2519 {
2520 // ignore
2521 }
2522 else // not a (recognized) special case, must be a verb (e.g. "print")
2523 {
2524 data.verbs.Add(lhs);
2525 data.commands.Add(rhs);
2526 }
2527 }
2528 else // '=' not found
2529 {
2530 // so it must be a simple flag
2531 if ( curField == wxT("needsterminal") )
2532 {
2533 data.needsterminal = true;
2534 }
2535 else if ( curField == wxT("copiousoutput"))
2536 {
2537 // copiousoutput impies that the viewer is a console program
2538 data.needsterminal =
2539 data.copiousoutput = true;
2540 }
2541 else if ( !IsKnownUnimportantField(curField) )
2542 {
2543 return false;
2544 }
2545 }
2546
2547 return true;
2548}
2549
2550bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
2551 bool fallback)
2552{
2553 wxLogTrace(TRACE_MIME, wxT("--- Parsing mailcap file '%s' ---"),
2554 strFileName.c_str());
2555
2556 wxMimeTextFile file(strFileName);
2557 if ( !file.Open() )
2558 return false;
2559
2560 // indices of MIME types (in m_aTypes) we already found in this file
2561 //
2562 // (see the comments near the end of function for the reason we need this)
2563 wxArrayInt aIndicesSeenHere;
2564
2565 // accumulator for the current field
2566 wxString curField;
2567 curField.reserve(1024);
2568
2569 const wxChar *pPagerEnv = wxGetenv(wxT("PAGER"));
2570
2571 const wxArrayString empty_extensions_list;
2572
2573 size_t nLineCount = file.GetLineCount();
2574 for ( size_t nLine = 0; nLine < nLineCount; nLine++ )
2575 {
2576 // now we're at the start of the line
2577 const wxChar *pc = file[nLine].c_str();
2578
2579 // skip whitespace
2580 while ( wxIsspace(*pc) )
2581 pc++;
2582
2583 // comment or empty string?
2584 if ( *pc == wxT('#') || *pc == wxT('\0') )
2585 continue;
2586
2587 // no, do parse
2588 // ------------
2589
2590 // what field are we currently in? The first 2 are fixed and there may
2591 // be an arbitrary number of other fields parsed by
2592 // ProcessOtherMailcapField()
2593 //
2594 // the first field is the MIME type
2595 enum
2596 {
2597 Field_Type,
2598 Field_OpenCmd,
2599 Field_Other
2600 } currentToken = Field_Type;
2601
2602 // the flags and field values on the current line
2603 MailcapLineData data;
2604
2605 bool cont = true;
2606 while ( cont )
2607 {
2608 switch ( *pc )
2609 {
2610 case wxT('\\'):
2611 // interpret the next character literally (notice that
2612 // backslash can be used for line continuation)
2613 if ( *++pc == wxT('\0') )
2614 {
2615 // fetch the next line if there is one
2616 if ( nLine == nLineCount - 1 )
2617 {
2618 // something is wrong, bail out
2619 cont = false;
2620
2621 wxLogDebug(wxT("Mailcap file %s, line %lu: '\\' on the end of the last line ignored."),
2622 strFileName.c_str(),
2623 nLine + 1L);
2624 }
2625 else
2626 {
2627 // pass to the beginning of the next line
2628 pc = file[++nLine].c_str();
2629
2630 // skip pc++ at the end of the loop
2631 continue;
2632 }
2633 }
2634 else
2635 {
2636 // just a normal character
2637 curField += *pc;
2638 }
2639 break;
2640
2641 case wxT('\0'):
2642 cont = false; // end of line reached, exit the loop
2643
2644 // fall through to still process this field
2645
2646 case wxT(';'):
2647 // trim whitespaces from both sides
2648 curField.Trim(true).Trim(false);
2649
2650 switch ( currentToken )
2651 {
2652 case Field_Type:
2653 data.type = curField.Lower();
2654 if ( data.type.empty() )
2655 {
2656 // I don't think that this is a valid mailcap
2657 // entry, but try to interpret it somehow
2658 data.type = wxT('*');
2659 }
2660
2661 if ( data.type.Find(wxT('/')) == wxNOT_FOUND )
2662 {
2663 // we interpret "type" as "type/*"
2664 data.type += wxT("/*");
2665 }
2666
2667 currentToken = Field_OpenCmd;
2668 break;
2669
2670 case Field_OpenCmd:
2671 data.cmdOpen = curField;
2672
2673 currentToken = Field_Other;
2674 break;
2675
2676 case Field_Other:
2677 if ( !ProcessOtherMailcapField(data, curField) )
2678 {
2679 // don't flood the user with error messages if
2680 // we don't understand something in his
2681 // mailcap, but give them in debug mode because
2682 // this might be useful for the programmer
2683 wxLogDebug
2684 (
2685 wxT("Mailcap file %s, line %lu: unknown field '%s' for the MIME type '%s' ignored."),
2686 strFileName.c_str(),
2687 nLine + 1L,
2688 curField.c_str(),
2689 data.type.c_str()
2690 );
2691 }
2692 else if ( data.testfailed )
2693 {
2694 // skip this entry entirely
2695 cont = false;
2696 }
2697
2698 // it already has this value
2699 //currentToken = Field_Other;
2700 break;
2701
2702 default:
2703 wxFAIL_MSG(wxT("unknown field type in mailcap"));
2704 }
2705
2706 // next token starts immediately after ';'
2707 curField.Empty();
2708 break;
2709
2710 default:
2711 curField += *pc;
2712 }
2713
2714 // continue in the same line
2715 pc++;
2716 }
2717
2718 // we read the entire entry, check what have we got
2719 // ------------------------------------------------
2720
2721 // check that we really read something reasonable
2722 if ( currentToken < Field_Other )
2723 {
2724 wxLogWarning(wxT("Mailcap file %s, line %lu: incomplete entry ignored."),
2725 strFileName.c_str(), nLine + 1L);
2726
2727 continue;
2728 }
2729
2730 // if the test command failed, it's as if the entry were not there at all
2731 if ( data.testfailed )
2732 {
2733 continue;
2734 }
2735
2736 // support for flags:
2737 // 1. create an xterm for 'needsterminal'
2738 // 2. append "| $PAGER" for 'copiousoutput'
2739 //
2740 // Note that the RFC says that having both needsterminal and
2741 // copiousoutput is probably a mistake, so it seems that running
2742 // programs with copiousoutput inside an xterm as it is done now
2743 // is a bad idea (FIXME)
2744 if ( data.copiousoutput )
2745 {
2746 data.cmdOpen << wxT(" | ") << (pPagerEnv ? pPagerEnv : wxT("more"));
2747 }
2748
2749 if ( data.needsterminal )
2750 {
2751 data.cmdOpen.insert(0, wxT("xterm -e sh -c '"));
2752 data.cmdOpen.append(wxT("'"));
2753 }
2754
2755 if ( !data.cmdOpen.empty() )
2756 {
2757 data.verbs.Insert(wxT("open"), 0);
2758 data.commands.Insert(data.cmdOpen, 0);
2759 }
2760
2761 // we have to decide whether the new entry should replace any entries
2762 // for the same MIME type we had previously found or not
2763 bool overwrite;
2764
2765 // the fall back entries have the lowest priority, by definition
2766 if ( fallback )
2767 {
2768 overwrite = false;
2769 }
2770 else
2771 {
2772 // have we seen this one before?
2773 int nIndex = m_aTypes.Index(data.type);
2774
2775 // and if we have, was it in this file? if not, we should
2776 // overwrite the previously seen one
2777 overwrite = nIndex == wxNOT_FOUND ||
2778 aIndicesSeenHere.Index(nIndex) == wxNOT_FOUND;
2779 }
2780
2781 wxLogTrace(TRACE_MIME, wxT("mailcap %s: %s [%s]"),
2782 data.type.c_str(), data.cmdOpen.c_str(),
2783 overwrite ? wxT("replace") : wxT("add"));
2784
2785 int n = AddToMimeData
2786 (
2787 data.type,
2788 data.icon,
2789 new wxMimeTypeCommands(data.verbs, data.commands),
2790 empty_extensions_list,
2791 data.desc,
2792 overwrite
2793 );
2794
2795 if ( overwrite )
2796 {
2797 aIndicesSeenHere.Add(n);
2798 }
2799 }
2800
2801 return true;
2802}
2803
2804size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
2805{
2806 InitIfNeeded();
2807
2808 mimetypes.Empty();
2809
2810 size_t count = m_aTypes.GetCount();
2811 for ( size_t n = 0; n < count; n++ )
2812 {
2813 // don't return template types from here (i.e. anything containg '*')
2814 const wxString &type = m_aTypes[n];
2815 if ( type.Find(wxT('*')) == wxNOT_FOUND )
2816 {
2817 mimetypes.Add(type);
2818 }
2819 }
2820
2821 return mimetypes.GetCount();
2822}
2823
2824// ----------------------------------------------------------------------------
2825// writing to MIME type files
2826// ----------------------------------------------------------------------------
2827
2828bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
2829{
2830 InitIfNeeded();
2831
2832 wxArrayString sMimeTypes;
2833 ft->GetMimeTypes(sMimeTypes);
2834
2835 size_t i;
2836 size_t nCount = sMimeTypes.GetCount();
2837 for (i = 0; i < nCount; i ++)
2838 {
2839 const wxString &sMime = sMimeTypes.Item(i);
2840 int nIndex = m_aTypes.Index(sMime);
2841 if ( nIndex == wxNOT_FOUND)
2842 {
2843 // error if we get here ??
2844 return false;
2845 }
2846 else
2847 {
2848 WriteMimeInfo(nIndex, true);
2849 m_aTypes.RemoveAt(nIndex);
2850 m_aEntries.RemoveAt(nIndex);
2851 m_aExtensions.RemoveAt(nIndex);
2852 m_aDescriptions.RemoveAt(nIndex);
2853 m_aIcons.RemoveAt(nIndex);
2854 }
2855 }
2856 // check data integrity
2857 wxASSERT( m_aTypes.GetCount() == m_aEntries.GetCount() &&
2858 m_aTypes.GetCount() == m_aExtensions.GetCount() &&
2859 m_aTypes.GetCount() == m_aIcons.GetCount() &&
2860 m_aTypes.GetCount() == m_aDescriptions.GetCount() );
2861
2862 return true;
2863}
2864
2865// ----------------------------------------------------------------------------
2866// private functions
2867// ----------------------------------------------------------------------------
2868
2869static bool IsKnownUnimportantField(const wxString& fieldAll)
2870{
2871 static const wxChar * const knownFields[] =
2872 {
2873 wxT("x-mozilla-flags"),
2874 wxT("nametemplate"),
2875 wxT("textualnewlines"),
2876 };
2877
2878 wxString field = fieldAll.BeforeFirst(wxT('='));
2879 for ( size_t n = 0; n < WXSIZEOF(knownFields); n++ )
2880 {
2881 if ( field.CmpNoCase(knownFields[n]) == 0 )
2882 return true;
2883 }
2884
2885 return false;
2886}
2887
2888#endif
2889 // wxUSE_MIMETYPE && wxUSE_FILE && wxUSE_TEXTFILE