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