{-# LINE 2 "./System/GIO/File/ContentType.chs" #-}
-- GIMP Toolkit (GTK) Binding for Haskell: binding to gio -*-haskell-*-
--
-- Author : Andy Stewart
-- Created: 30-Apirl-2010
--
-- Copyright (c) 2010 Andy Stewart
--
-- This library is free software: you can redistribute it and/or
-- modify it under the terms of the GNU Lesser General Public License
-- as published by the Free Software Foundation, either version 3 of
-- the License, or (at your option) any later version.
--
-- This library is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- Lesser General Public License for more details.
--
-- You should have received a copy of the GNU Lesser General Public
-- License along with this program. If not, see
-- <http:
--
-- GIO, the C library which this Haskell library depends on, is
-- available under LGPL Version 2. The documentation included with
-- this library is based on the original GIO documentation.
--
-- | Maintainer : gtk2hs-devel@lists.sourceforge.net
-- Stability : alpha
-- Portability : portable (depends on GHC)
module System.GIO.File.ContentType (
-- * Details
--
-- | A content type is a platform specific string that defines the type of a file. On 1 it is a mime
-- type, on win32 it is an extension string like ".doc", ".txt" or a percieved string like
-- "audio". Such strings can be looked up in the registry at HkeyClassesRoot.

-- * Methods
    contentTypeEquals,
    contentTypeIsA,
    contentTypeIsUnknown,
    contentTypeGetDescription,
    contentTypeGetMimeType,
    contentTypeGetIcon,
    contentTypeCanBeExecutable,

    contentTypeFromMimeType,

    contentTypeGuess,

    contentTypeGuessForTree,

    contentTypesGetRegistered,
    ) where

import Control.Monad
import System.GIO.Enums
import System.Glib.FFI
import System.Glib.Flags
import System.Glib.GError
import System.Glib.GList
import System.Glib.GObject
import System.Glib.UTFString
import System.GIO.Types
{-# LINE 64 "./System/GIO/File/ContentType.chs" #-}


{-# LINE 66 "./System/GIO/File/ContentType.chs" #-}

-- | Compares two content types for equality.
contentTypeEquals ::
   String
 -> String
 -> Bool -- ^ returns 'True' if the two strings are identical or equivalent, 'False' otherwise.
contentTypeEquals type1 type2 =
  toBool $ unsafePerformIO $
  withUTFString type1 $ \ type1Ptr ->
  withUTFString type2 $ \ type2Ptr ->
  g_content_type_equals type1Ptr type2Ptr

-- | Determines if type is a subset of supertype.
contentTypeIsA ::
   String
 -> String
 -> Bool -- ^ returns 'True' if type is a kind of supertype, 'False' otherwise.
contentTypeIsA type1 supertype =
  toBool $ unsafePerformIO $
  withUTFString type1 $ \ type1Ptr ->
  withUTFString supertype $ \ supertypePtr ->
  g_content_type_equals type1Ptr supertypePtr

-- | Checks if the content type is the generic "unknown" type. On 1 this is the
-- "application/octet-stream" mimetype, while on win32 it is \"*\".
contentTypeIsUnknown :: String
 -> Bool -- ^ returns 'True' if the type is the unknown type.
contentTypeIsUnknown typ =
  toBool $ unsafePerformIO $
  withUTFString typ $ \ typPtr ->
  g_content_type_is_unknown typPtr

-- | Gets the human readable description of the content type.
contentTypeGetDescription ::
   String
 -> String -- ^ returns a short description of the content type type.
contentTypeGetDescription typ =
  unsafePerformIO $
  withUTFString typ $ \ typPtr ->
  g_content_type_get_description typPtr
  >>= readUTFString

-- | Gets the mime-type for the content type. If one is registered
contentTypeGetMimeType ::
   String
 -> String -- ^ returns the registered mime-type for the given type, or 'Nothing' if unknown.
contentTypeGetMimeType typ =
  unsafePerformIO $
  withUTFString typ $ \ typPtr ->
  g_content_type_get_mime_type typPtr
  >>= readUTFString

-- | Gets the icon for a content type.
contentTypeGetIcon :: String
 -> Icon -- ^ returns 'Icon' corresponding to the content type.
contentTypeGetIcon typ =
  unsafePerformIO $ wrapNewGObject mkIcon $
  withUTFString typ $ \ typPtr ->
  g_content_type_get_icon typPtr

-- | Checks if a content type can be executable. Note that for instance things like text files can be
-- executables (i.e. scripts and batch files).
contentTypeCanBeExecutable :: String
 -> Bool -- ^ returns 'True' if the file type corresponds to a type that can be executable, 'False' otherwise.
contentTypeCanBeExecutable typ =
  toBool $ unsafePerformIO $
  withUTFString typ $ \ typPtr ->
  g_content_type_can_be_executable typPtr


-- | Tries to find a content type based on the mime type name.
contentTypeFromMimeType ::
   String -- ^ @mimeType@ a mime type string.
 -> String
contentTypeFromMimeType mimeType =
  unsafePerformIO $
  withUTFString mimeType $ \ mimeTypePtr ->
  g_content_type_from_mime_type mimeTypePtr
  >>= readUTFString


-- | Guesses the content type based on example data. If the function is uncertain, @resultUncertain@ will
-- be set to 'True'. Either filename or data may be 'Nothing', in which case the guess will be based solely on
-- the other argument.
contentTypeGuess :: String
 -> String -- ^ @data@ a stream of data,
 -> Int -- ^ @dataSize@ the size of data
 -> IO (Bool, String) -- ^ returns a string indicating a guessed content type for the given data.
contentTypeGuess filename dat dataSize =
  withUTFString filename $ \ filenamePtr ->
  withUTFString dat $ \ datPtr ->
  alloca $ \ resultUncertainPtr -> do
  strPtr <- g_content_type_guess
{-# LINE 159 "./System/GIO/File/ContentType.chs" #-}
           filenamePtr
           (castPtr datPtr)
           (fromIntegral dataSize)
           (castPtr resultUncertainPtr)
  resultUncertain <- peek resultUncertainPtr
  str <- readUTFString strPtr
  return (resultUncertain, str)


-- | Tries to guess the type of the tree with root root, by looking at the files it contains. The result
-- is an array of content types, with the best guess coming first.
--
-- The types returned all have the form x-content/foo, e.g. x-content/audio-cdda (for audio CDs) or
-- x-content/image-dcf (for a camera memory card). See the shared-mime-info specification for more on
-- x-content types.
--
-- This function is useful in the implementation of 'mountGuessContentType'.
contentTypeGuessForTree :: FileClass file
 => file -- ^ @root@ the root of the tree to guess a type for
 -> IO [String] -- ^ returns a list of possible content types
contentTypeGuessForTree root =
  (\(File arg1) -> withForeignPtr arg1 $ \argPtr1 ->g_content_type_guess_for_tree argPtr1) (toFile root)
  >>= readUTFStringArray0


-- | Gets a list of strings containing all the registered content types known to the system.
contentTypesGetRegistered ::
 IO [String] -- ^ returns GList of the registered content types.
contentTypesGetRegistered = do
  glistPtr <- g_content_types_get_registered
{-# LINE 189 "./System/GIO/File/ContentType.chs" #-}
  strPtrs <- fromGList glistPtr
  mapM readUTFString strPtrs

foreign import ccall safe "g_content_type_equals"
  g_content_type_equals :: ((Ptr CChar) -> ((Ptr CChar) -> (IO CInt)))

foreign import ccall safe "g_content_type_is_unknown"
  g_content_type_is_unknown :: ((Ptr CChar) -> (IO CInt))

foreign import ccall safe "g_content_type_get_description"
  g_content_type_get_description :: ((Ptr CChar) -> (IO (Ptr CChar)))

foreign import ccall safe "g_content_type_get_mime_type"
  g_content_type_get_mime_type :: ((Ptr CChar) -> (IO (Ptr CChar)))

foreign import ccall safe "g_content_type_get_icon"
  g_content_type_get_icon :: ((Ptr CChar) -> (IO (Ptr Icon)))

foreign import ccall safe "g_content_type_can_be_executable"
  g_content_type_can_be_executable :: ((Ptr CChar) -> (IO CInt))

foreign import ccall safe "g_content_type_from_mime_type"
  g_content_type_from_mime_type :: ((Ptr CChar) -> (IO (Ptr CChar)))

foreign import ccall safe "g_content_type_guess"
  g_content_type_guess :: ((Ptr CChar) -> ((Ptr CUChar) -> (CUInt -> ((Ptr CInt) -> (IO (Ptr CChar))))))

foreign import ccall safe "g_content_type_guess_for_tree"
  g_content_type_guess_for_tree :: ((Ptr File) -> (IO (Ptr (Ptr CChar))))

foreign import ccall safe "g_content_types_get_registered"
  g_content_types_get_registered :: (IO (Ptr ()))