"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 1997 by eXept Software AG 

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libview2' }"

"{ NameSpace: Smalltalk }"

Object subclass:#MIMETypes

	instanceVariableNames:''

	classVariableNames:'CharSetToFontMapping DefaultCommandPerMIMEPerOS

		DefaultPrintCommandPerMIMEPerOS

		FileSuffixToImageReaderClassMapping FileSuffixToTypeMapping

		FilenameToTypeMapping LastSuffix LastType

		SuffixToCommentStringMapping SuffixToParenthesisSpecMapping

		TypeFromContentsDetectors TypeToCommentStringMapping

		TypeToFileSuffixMapping TypeToImageReaderClassMapping

		TypeToInfoMapping TypeToParenthesisSpecMapping

		TypeToViewerApplicationMapping TypeToAudioReaderClassMapping

		FileSuffixToAudioReaderClassMapping'

	poolDictionaries:''

	category:'Net-Communication-Support'

!

ImmutableString variableByteSubclass:#MIMEType

	instanceVariableNames:''

	classVariableNames:'CachedTypes'

	poolDictionaries:''

	privateIn:MIMETypes

!

!MIMETypes class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1997 by eXept Software AG 

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    just a place to keep MIME information

    (avoid spreading things at many places)

    MIMETypes is abstract and functional.

    Actually, in some OperatingSystems, this information may

    be found in some config files (or registries).

    Therefore, this class may have to be extended to support this

    and fetch the information from there eventually.

    [author:]

        Claus Gittinger

"

!

examples

"

                                                                            [exBegin]

    MIMETypes mimeTypeFromString:'text/plain'

                                                                            [exEnd]

                                                                            [exBegin]

    MIMETypes mimeTypeFromString:'application/x-expecco-testsuite'

                                                                            [exEnd]

                                                                            [exBegin]

    MIMETypes mimeTypeForSuffix:'gif'

    MIMETypes mimeTypeForSuffix:'ets'

    MIMETypes mimeTypeForSuffix:'xlsx'

                                                                            [exEnd]

"

!

knownTypes

"

    simply a reminder for me ...

    application         mime                            file extentsions

        powerpoint      application/ms-powerpoint       .pot, .ppz, .ppt, .pps,

                        application/mspowerpoint

                        application/vnd.ms-powerpoint

                        application/x-mspowerpoint

        shockwave       application/x-shockwave-flash   .swf

        futuresplash    application/futuresplash        .spl

"

! !

!MIMETypes class methodsFor:'initialization'!

addMimeTypeDetector:aMimeTypeFromContentsDetectorBlock

    "any class (especially: image readers) may add a block

     that detects the MIME type from a given content.

     The block is called with two arguments, some data (usually the first few kilobytes

     of a file) and the suffix of the file, or nil if unknown.

     The block should return the MIME type or nil."

    TypeFromContentsDetectors isNil ifTrue:[ TypeFromContentsDetectors := OrderedCollection new ].

    TypeFromContentsDetectors add:aMimeTypeFromContentsDetectorBlock.

    "Modified (comment): / 01-03-2018 / 19:06:46 / mawalch"

!

initialize

    "initialize wellKnown facts"

    MIMEType initialize. "must be initialized first"

    LastSuffix := LastType := nil.

    self initializeFileNameToMimeTypeMapping.

    self initializeImageReaderMappings.

    self initializeAudioReaderMappings.

    self initializeCommentStringMappings.

    self initializeParenthesisSpecMappings.

    "

     self initialize

    "

    "Modified: / 10-04-2007 / 15:16:44 / cg"

    "Modified (comment): / 29-11-2011 / 19:11:51 / cg"

!

initializeAudioReaderMappings

    "these are used so select an audio reader, based on a file's MIME type"

    |rdr|

    FileSuffixToAudioReaderClassMapping isNil ifTrue:[

        FileSuffixToAudioReaderClassMapping := Dictionary new

    ].

    "MIME" TypeToAudioReaderClassMapping isNil ifTrue:[

        TypeToAudioReaderClassMapping := Dictionary new

    ].

    "/ setup mimeType to image reader class mapping ...

    self audioReaderForType:'audio/basic' put:AUFileReader.

    "/ setup suffix to image reader class mapping ...

    (rdr := Smalltalk at:#AUFileReader) notNil ifTrue:[

        self imageReaderForSuffix:'au'  put:rdr.

        self imageReaderForSuffix:'snd' put:rdr.

    ].

    (rdr := Smalltalk at:#WAVFileReader) notNil ifTrue:[

        self imageReaderForSuffix:'wav'  put:rdr.

    ].

    (rdr := Smalltalk at:#AIFFFileReader) notNil ifTrue:[

        self imageReaderForSuffix:'aiff' put:rdr.

    ].

!

initializeCommentStringMappings

    "these are used by the editor's comment/uncomment functions"

    TypeToCommentStringMapping := Dictionary new.

    SuffixToCommentStringMapping := Dictionary new.

    TypeToCommentStringMapping

        at:'application/x-make'

        put:#('#' (nil nil)).           "/ '#' EOL comments only

    TypeToCommentStringMapping

        at:'application/x-sh'

        put:#('#' (nil nil)).           "/ '#' EOL comments only

    #('text/html' 'text/xml'

      'application/xml'

      'application/x-expecco-testsuite'

      'application/x-expecco-logfile'

    )

    do:[:eachXMLType |

        TypeToCommentStringMapping

            at:eachXMLType

            put:#(nil ('<!!-- ' ' -->')). "/ '<!!-- ... -->' delimited comments only

    ].

    TypeToCommentStringMapping

        at:'text/css'

        put:#('//' ('/*' '*/')).

    TypeToCommentStringMapping

        at:'application/x-batch-script'

        put:#('@REM ' '@rem ' 'REM ' 'rem ' (nil nil)).         "/ 'rem ' for EOL comments only

    "/ the following is ST/X specific

    TypeToCommentStringMapping

        at:'application/x-smalltalk-source'

        put:#('"/' ('"' '"')).           "/ '"/ ' for EOL; ".." for delimited comments

    "/ this is for standard smalltalk

"/    TypeToCommentStringMapping

"/        at:'application/x-smalltalk-source'

"/        put:#(nil ('"' '"')).            "/ ".." for delimited comments only

    TypeToCommentStringMapping

        at:'application/x-pascal-source'

        put:#(nil ('{' '}')).           "/ '{'..'}' for delimited comments

    "/ this is ANSI-c

    TypeToCommentStringMapping

        at:'application/x-c-source'

        put:#('//' ('/*' '*/')).

    TypeToCommentStringMapping

        at:'application/x-cpp-source'

        put:#('//' ('/*' '*/')).

    TypeToCommentStringMapping

        at:'application/x-csharp-source'

        put:#('//' ('/*' '*/')).

    TypeToCommentStringMapping

        at:'application/x-java-source'

        put:#('//' ('/*' '*/')).

    TypeToCommentStringMapping

        at:'application/x-javascript'

        put:#('//' ('/*' '*/')).

    TypeToCommentStringMapping

        at:'application/x-scheme-source'

        put:#(';' ('#| ' ' |#')).           "/ ';' for EOL comments only

    TypeToCommentStringMapping

        at:'application/x-lisp-source'

        put:#(';' (nil nil)).           "/ ';' for EOL comments only

    TypeToCommentStringMapping

        at:'application/x-python-source'

        put:#('#' (nil nil)).           "/ '#' for EOL comments only

    TypeToCommentStringMapping

        at:'application/x-asn1-source'

        put:#('--' ('--' '--')).

    "/ st/x support files

    SuffixToCommentStringMapping

        at:'style'

        put:#(';' (nil nil)).

    SuffixToCommentStringMapping

        at:'rs'

        put:#(';' (nil nil)).

    "Modified: / 06-09-2011 / 10:46:27 / cg"

!

initializeDefaultCommands

    "these are used to select an application to be opened when a file of a particular

     type is double clicked in the browser.

     TODO: move this to OS"

    |unixCommands win32Commands unixPrintCommands win32PrintCommands listToTry|

    DefaultCommandPerMIMEPerOS := Dictionary new.

    DefaultCommandPerMIMEPerOS at:#unix  put:(unixCommands := Dictionary new).

    DefaultCommandPerMIMEPerOS at:#win32 put:(win32Commands := Dictionary new).

    unixCommands at:'application/x-tar-compressed' put:'tar tvf -'.

    OperatingSystem isMSWINDOWSlike ifFalse:[ |cmd|

        OperatingSystem isOSXlike ifTrue:[

            "/ unixCommands at:'text/html' put:('open -a Safari "%1"').

            unixCommands at:'text/html' put:('open -a Firefox "%1"').

            unixCommands at:'application/pdf' put:('open -a Preview "%1"').

        ] ifFalse:[

            listToTry := #('firefox' 'chrome' 'chromium' 'konqueror' 'opera').

            cmd := listToTry

                        detect:[:aCmd| (OperatingSystem pathOfCommand:aCmd) notEmptyOrNil ]

                        ifNone:nil.

            cmd notNil ifTrue:[

                unixCommands at:'text/html' put:(cmd, ' "%1"')

            ].

            listToTry := #('acroread' 'okular' 'evince' 'kpdf' 'xpdf').

            cmd := listToTry

                        detect:[:aCmd| (OperatingSystem pathOfCommand:aCmd) notEmptyOrNil ]

                        ifNone:nil.

            cmd notNil ifTrue:[

                unixCommands at:'application/pdf' put:(cmd, ' "%1"')

            ].

            listToTry := #('xdg-open').

            cmd := listToTry

                        detect:[:aCmd| (OperatingSystem pathOfCommand:aCmd) notEmptyOrNil ]

                        ifNone:nil.

            cmd notNil ifTrue:[

                unixCommands at:'text/plain' put:(cmd , ' "%1"')

            ].

        ].

    ].

    DefaultPrintCommandPerMIMEPerOS := Dictionary new.

    DefaultPrintCommandPerMIMEPerOS at:#unix  put:(unixPrintCommands := Dictionary new).

    DefaultPrintCommandPerMIMEPerOS at:#win32 put:(win32PrintCommands := Dictionary new).

    "/ if you have a good (intelligent) spooler ;-)

    unixPrintCommands at:'application/pdf'         put:'lpr "%1"'.

    "/ if not, you may need more...

    "/ unixPrintCommands at:'application/pdf'         put:'pdfToPS %1 | lpr'.

    "

     self initializeDefaultCommands

    "

    "Modified: / 12-05-2004 / 11:43:23 / cg"

    "Modified: / 01-03-2018 / 18:42:42 / mawalch"

    "Modified: / 07-02-2019 / 17:53:24 / Claus Gittinger"

!

initializeFileInfoMappings

    "these are used by the file browser if a 'file' command is not present in the OS"

    TypeToInfoMapping := Dictionary new.

    TypeToInfoMapping at:'application/x-smalltalk-source' put:'Smalltalk source'.

    TypeToInfoMapping at:'text/html' put:'HTML document'.

    TypeToInfoMapping at:'text/xml' put:'XML document'.

    TypeToInfoMapping at:'application/xml' put:'XML document'.

    TypeToInfoMapping at:'application/x-c-source' put:'C source'.

    TypeToInfoMapping at:'application/x-c-header' put:'C header file'.

    TypeToInfoMapping at:'application/x-cpp-source' put:'C++ source'.

    TypeToInfoMapping at:'application/x-csharp-source' put:'C# source'.

    TypeToInfoMapping at:'application/x-java-source' put:'Java source'.

    TypeToInfoMapping at:'application/x-javascript' put:'JavaScript source'.

    TypeToInfoMapping at:'application/x-lisp-source' put:'Lisp source'.

    TypeToInfoMapping at:'application/x-scheme-source' put:'Scheme source'.

    TypeToInfoMapping at:'application/x-python-source' put:'Python source'.

    TypeToInfoMapping at:'application/x-ruby-source' put:'Ruby source'.

    TypeToInfoMapping at:'application/x-make' put:'make rules'.

    TypeToInfoMapping at:'application/binary' put:'binary object file'.

    "

     self initializeFileInfoMappings

     'foo.H' asFilename mimeTypeFromName

     'foo.o' asFilename mimeTypeFromName

    "

    "Modified: / 30-11-2017 / 07:54:23 / mawalch"

!

initializeFileNameToMimeTypeMapping

    "initialize wellKnown facts"

    |types|

    FileSuffixToTypeMapping isNil ifTrue:[

        FileSuffixToTypeMapping := Dictionary new:270.

    ].

    TypeToFileSuffixMapping isNil ifTrue:[

        TypeToFileSuffixMapping := Dictionary new:105.

    ].

    FilenameToTypeMapping isNil ifTrue:[

        FilenameToTypeMapping := Dictionary new:16.

    ].

    types := OrderedCollection new.

    types addAll:self textTypeList.

    types addAll:self imageTypeList.

    types addAll:self videoTypeList.

    types addAll:self audioTypeList.

    types addAll:self applicationTypeList.

    types addAll:self osSpecificTypeList.

    types pairWiseDo:[:suff :typeString|

        |mimeType|

        mimeType := MIMEType fromString:typeString.

        suff isArray ifTrue:[

            suff do:[:s |FileSuffixToTypeMapping at:s put:mimeType].

            TypeToFileSuffixMapping at:mimeType put:suff first.

        ] ifFalse:[

            FileSuffixToTypeMapping at:suff put:mimeType.

            TypeToFileSuffixMapping at:mimeType put:suff.

        ].

    ].

    self miscFilenameList pairWiseDo:[:suffixes :typeString|

        |mimeType|

        mimeType := MIMEType fromString:typeString.

        suffixes isArray ifTrue:[

            suffixes do:[:eachSuffix | FilenameToTypeMapping at:eachSuffix put:mimeType]

        ] ifFalse:[

            FilenameToTypeMapping at:suffixes put:mimeType

        ]

    ].

    "

     self initializeFileNameToMimeTypeMapping

    "

    "Modified (format): / 09-02-2017 / 14:59:33 / stefan"

!

initializeImageReaderMappings

    "these are used so select an image reader, based on a bitmap image's MIME type"

    |rdr|

    FileSuffixToImageReaderClassMapping isNil ifTrue:[

        FileSuffixToImageReaderClassMapping := Dictionary new

    ].

    "MIME" TypeToImageReaderClassMapping isNil ifTrue:[

        TypeToImageReaderClassMapping := Dictionary new

    ].

    "/ setup mimeType to image reader class mapping ...

    self imageReaderForType:'image/jpeg' put:JPEGReader.

    self imageReaderForType:'image/gif'  put:GIFReader.

    self imageReaderForType:'image/tiff' put:TIFFReader.

    self imageReaderForType:'image/x-adobe-dng' put:TIFFReader.

    self imageReaderForType:'image/png'  put:PNGReader.

    self imageReaderForType:'image/icns' put:MacOSXIconReader.

    "/ setup suffix to image reader class mapping ...

    self imageReaderForSuffix:'jpg'  put:JPEGReader.

    self imageReaderForSuffix:'jpeg' put:JPEGReader.

    self imageReaderForSuffix:'gif'  put:GIFReader.

    self imageReaderForSuffix:'tif'  put:TIFFReader.

    self imageReaderForSuffix:'tiff' put:TIFFReader.

    self imageReaderForSuffix:'png'  put:PNGReader.

    self imageReaderForSuffix:'icns' put:MacOSXIconReader.

    "/ some 'used-to-be-optional' readers

    (rdr := Smalltalk at:#WindowsIconReader) notNil ifTrue:[

        self imageReaderForType:'image/bmp'      put:rdr.

        self imageReaderForType:'image/x-MS-bmp' put:rdr.

        self imageReaderForType:'image/x-ms-bmp' put:rdr.

        self imageReaderForType:'image/x-MS-ico' put:rdr.

        self imageReaderForType:'image/x-ms-ico' put:rdr.

        self imageReaderForSuffix:'bmp'            put:rdr.

        self imageReaderForSuffix:'ico'            put:rdr.

    ].

    (rdr := Smalltalk at:#XBMReader) notNil ifTrue:[

        self imageReaderForType:'image/x-xbitmap' put:rdr.

        self imageReaderForSuffix:'xbm'             put:rdr.

    ].

    (rdr := Smalltalk at:#XPMReader) notNil ifTrue:[

        self imageReaderForType:'image/x-xpixmap' put:rdr.

        self imageReaderForSuffix:'pm'              put:rdr.

    ].

    (rdr := Smalltalk at:#PBMReader) notNil ifTrue:[

        self imageReaderForType:'image/x-portable-pixmap'  put:rdr.

        self imageReaderForType:'image/x-portable-bitmap'  put:rdr.

        self imageReaderForType:'image/x-portable-graymap' put:rdr.

        self imageReaderForType:'image/x-portable-anymap'  put:rdr.

        self imageReaderForSuffix:'ppm'                      put:rdr.

        self imageReaderForSuffix:'pbm'                      put:rdr.

        self imageReaderForSuffix:'pgm'                      put:rdr.

        self imageReaderForSuffix:'pnm'                      put:rdr.

    ].

    (rdr := Smalltalk at:#PCXReader) notNil ifTrue:[

        self imageReaderForType:'image/x-pcx' put:rdr.

        self imageReaderForSuffix:'pcx'         put:rdr.

    ].

    (rdr := Smalltalk at:#TargaReader) notNil ifTrue:[

        self imageReaderForType:'image/x-targa' put:rdr.

        self imageReaderForSuffix:'tga'           put:rdr.

    ].