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