{-# LANGUAGE DeriveDataTypeable #-}

{-# LINE 2 "./System/Gnome/VFS/BasicTypes.chs" #-}
{-# OPTIONS_HADDOCK hide #-}
-- GIMP Toolkit (GTK) Binding for Haskell: binding to libgnomevfs -*-haskell-*-
--
-- Author : Peter Gavin
-- Created: 1-Apr-2007
--
-- Copyright (c) 2007 Peter Gavin
--
-- 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:
--
-- GnomeVFS, 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 GnomeVFS documentation,
-- Copyright (c) 2001 Seth Nickell <snickell@stanford.edu>. The
-- documentation is covered by the GNU Free Documentation License,
-- version 1.2.

-- #hide

-- | Maintainer : gtk2hs-devel@lists.sourceforge.net
-- Stability : alpha
-- Portability : portable (depends on GHC)
module System.Gnome.VFS.BasicTypes (

  module System.Gnome.VFS.Constants,

  Handle(..),
  withHandle,

  Result(..),
  Error(..),

  OpenMode(..),
  SeekPosition(..),

  FileInfo(..),
  FileFlags(..),
  FileInfoFields(..),
  SetFileInfoMask(..),
  FileInfoOptions(..),
  FileSize,
  FileOffset,
  FileType(..),
  InodeNumber,
  IDs,

  MonitorHandle(..),
  withMonitorHandle,
  MonitorCallback,
  MonitorType,
  MonitorEventType,

  URI(..),
  TextURI,
  newURI,
  withURI,
  ToplevelURI(..),
  newToplevelURI,
  withToplevelURI,
  URIHideOptions(..),

  DirectoryHandle(..),
  withDirectoryHandle,

  MakeURIDirs(..),
  DirectoryVisitOptions(..),
  DirectoryVisitCallback,
  DirectoryVisitResult(..),
  FindDirectoryKind(..),

  XferOptions(..),
  XferProgressStatus(..),
  XferOverwriteMode(..),
  XferOverwriteAction(..),
  XferErrorMode(..),
  XferErrorAction(..),
  XferPhase(..),
  XferProgressInfo(..),
  XferProgressCallback,
  XferErrorCallback,
  XferOverwriteCallback,
  XferDuplicateCallback,

  Cancellation(..),
  newCancellation,
  withCancellation,

  VolumeOpSuccessCallback,
  VolumeOpFailureCallback,
  CVolumeOpCallback,
  VolumeType(..),
  DeviceType(..),


  MIMEType,


  -- module System.Gnome.VFS.Hierarchy,

  DriveID,
  newDrive,
  withDrive,

  VolumeID,
  newVolume,
  withVolume,

  wrapVolumeMonitor,
  withVolumeMonitor

  ) where

import Control.Exception (assert)
import Control.Monad
import Control.Monad.Reader
import Data.Typeable
import Data.Word (Word64)
import System.Glib.FFI
import System.Glib.Flags
import System.Glib.GObject (GObject(..),
                                GObjectClass,
                                toGObject,
                                unsafeCastGObject)
import System.Glib.GType (GType,
                              typeInstanceIsA)
-- {#import System.Gnome.VFS.Hierarchy#}
import System.Gnome.VFS.Types
{-# LINE 141 "./System/Gnome/VFS/BasicTypes.chs" #-}
import System.Gnome.VFS.Constants

import System.Posix.Types (DeviceID, EpochTime)

--------------------------------------------------------------------

gTypeCast :: (GObjectClass obj, GObjectClass obj') => GType -> String
                                                   -> (obj -> obj')
-- The usage of foreignPtrToPtr should be safe as the evaluation will only be
-- forced if the object is used afterwards
gTypeCast gtype objTypeName obj =
  case toGObject obj of
    gobj@(GObject objFPtr)
      | typeInstanceIsA ((unsafeForeignPtrToPtr.castForeignPtr) objFPtr) gtype
                  -> unsafeCastGObject gobj
      | otherwise -> error $ "Cannot cast object to " ++ objTypeName

--------------------------------------------------------------------

-- | The result of a file operation.
data Result = Ok
            | ErrorNotFound
            | ErrorGeneric
            | ErrorInternal
            | ErrorBadParameters
            | ErrorNotSupported
            | ErrorIo
            | ErrorCorruptedData
            | ErrorWrongFormat
            | ErrorBadFile
            | ErrorTooBig
            | ErrorNoSpace
            | ErrorReadOnly
            | ErrorInvalidUri
            | ErrorNotOpen
            | ErrorInvalidOpenMode
            | ErrorAccessDenied
            | ErrorTooManyOpenFiles
            | ErrorEof
            | ErrorNotADirectory
            | ErrorInProgress
            | ErrorInterrupted
            | ErrorFileExists
            | ErrorLoop
            | ErrorNotPermitted
            | ErrorIsDirectory
            | ErrorNoMemory
            | ErrorHostNotFound
            | ErrorInvalidHostName
            | ErrorHostHasNoAddress
            | ErrorLoginFailed
            | ErrorCancelled
            | ErrorDirectoryBusy
            | ErrorDirectoryNotEmpty
            | ErrorTooManyLinks
            | ErrorReadOnlyFileSystem
            | ErrorNotSameFileSystem
            | ErrorNameTooLong
            | ErrorServiceNotAvailable
            | ErrorServiceObsolete
            | ErrorProtocolError
            | ErrorNoMasterBrowser
            | ErrorNoDefault
            | ErrorNoHandler
            | ErrorParse
            | ErrorLaunch
            | ErrorTimeout
            | ErrorNameserver
            | ErrorLocked
            | ErrorDeprecatedFunction
            | ErrorInvalidFilename
            | ErrorNotASymbolicLink
            | NumErrors
            deriving (Enum,Eq,Bounded,Show,Typeable)

{-# LINE 162 "./System/Gnome/VFS/BasicTypes.chs" #-}

newtype Error = Error Result
                deriving (Show, Typeable)

-- | A handle to an open file
newtype Handle = Handle (ForeignPtr (Handle))
{-# LINE 168 "./System/Gnome/VFS/BasicTypes.chs" #-}
withHandle (Handle cHandle) = withForeignPtr cHandle

-- | Specifies the start position for a seek operation.
data SeekPosition = SeekStart
                  | SeekCurrent
                  | SeekEnd
                  deriving (Enum,Eq,Bounded,Show)

{-# LINE 172 "./System/Gnome/VFS/BasicTypes.chs" #-}
data OpenMode = OpenNone
              | OpenRead
              | OpenWrite
              | OpenRandom
              | OpenTruncate
              deriving (Eq,Bounded,Show)
instance Enum OpenMode where
  fromEnum OpenNone = 0
  fromEnum OpenRead = 1
  fromEnum OpenWrite = 2
  fromEnum OpenRandom = 4
  fromEnum OpenTruncate = 8

  toEnum 0 = OpenNone
  toEnum 1 = OpenRead
  toEnum 2 = OpenWrite
  toEnum 4 = OpenRandom
  toEnum 8 = OpenTruncate
  toEnum unmatched = error ("OpenMode.toEnum: Cannot match " ++ show unmatched)

  succ OpenNone = OpenRead
  succ OpenRead = OpenWrite
  succ OpenWrite = OpenRandom
  succ OpenRandom = OpenTruncate
  succ _ = undefined

  pred OpenRead = OpenNone
  pred OpenWrite = OpenRead
  pred OpenRandom = OpenWrite
  pred OpenTruncate = OpenRandom
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x OpenTruncate
  enumFromThen _ _ =     error "Enum OpenMode: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum OpenMode: enumFromThenTo not implemented"

{-# LINE 173 "./System/Gnome/VFS/BasicTypes.chs" #-}

--------------------------------------------------------------------

-- | A record type containing information about a file.
data FileInfo = FileInfo {
  fileInfoName :: Maybe String, -- ^ the name of the file,
                                                  -- without the path
  fileInfoType :: Maybe FileType, -- ^ the type of the file;
                                                  -- i.e. regular, directory,
                                                  -- block-device, etc.
  fileInfoPermissions :: Maybe [FilePermissions], -- ^ the permissions for the
                                                  -- file
  fileInfoFlags :: Maybe [FileFlags], -- ^ flags providing
                                                  -- additional information
                                                  -- about the file
  fileInfoDevice :: Maybe DeviceID, -- ^ the device the file
                                                  -- resides on
  fileInfoInode :: Maybe InodeNumber, -- ^ the inode number of the
                                                  -- file
  fileInfoLinkCount :: Maybe Int, -- ^ the total number of
                                                  -- hard links to the file
  fileInfoIDs :: Maybe IDs, -- ^ the user and group IDs
                                                  -- owning the file
  fileInfoSize :: Maybe FileSize, -- ^ the size of the file in
                                                  -- bytes
  fileInfoBlockCount :: Maybe FileSize, -- ^ the size of the file in
                                                  -- filesystem blocks
  fileInfoIOBlockSize :: Maybe FileSize, -- ^ the optimal buffer size
                                                  -- for reading from and
                                                  -- writing to the file
  fileInfoATime :: Maybe EpochTime, -- ^ the time of last access
  fileInfoMTime :: Maybe EpochTime, -- ^ the time of last modification
  fileInfoCTime :: Maybe EpochTime, -- ^ the time of last attribute modification
  fileInfoSymlinkName :: Maybe String -- ^ the location this
                                                  -- symlink points to, if
                                                  -- @fileInfoFlags@ contains 'FileFlagsSymlink'

  ,
  fileInfoMIMEType :: Maybe MIMEType -- ^ the MIME-type of the
                                                  -- file

  } deriving (Eq, Show)

data FileInfoFields = FileInfoFieldsNone
                    | FileInfoFieldsType
                    | FileInfoFieldsPermissions
                    | FileInfoFieldsFlags
                    | FileInfoFieldsDevice
                    | FileInfoFieldsInode
                    | FileInfoFieldsLinkCount
                    | FileInfoFieldsSize
                    | FileInfoFieldsBlockCount
                    | FileInfoFieldsIoBlockSize
                    | FileInfoFieldsAtime
                    | FileInfoFieldsMtime
                    | FileInfoFieldsCtime
                    | FileInfoFieldsSymlinkName
                    | FileInfoFieldsMimeType
                    | FileInfoFieldsAccess
                    | FileInfoFieldsIds
                    | FileInfoFieldsAcl
                    | FileInfoFieldsSelinuxContext
                    deriving (Eq,Bounded,Show)
instance Enum FileInfoFields where
  fromEnum FileInfoFieldsNone = 0
  fromEnum FileInfoFieldsType = 1
  fromEnum FileInfoFieldsPermissions = 2
  fromEnum FileInfoFieldsFlags = 4
  fromEnum FileInfoFieldsDevice = 8
  fromEnum FileInfoFieldsInode = 16
  fromEnum FileInfoFieldsLinkCount = 32
  fromEnum FileInfoFieldsSize = 64
  fromEnum FileInfoFieldsBlockCount = 128
  fromEnum FileInfoFieldsIoBlockSize = 256
  fromEnum FileInfoFieldsAtime = 512
  fromEnum FileInfoFieldsMtime = 1024
  fromEnum FileInfoFieldsCtime = 2048
  fromEnum FileInfoFieldsSymlinkName = 4096
  fromEnum FileInfoFieldsMimeType = 8192
  fromEnum FileInfoFieldsAccess = 16384
  fromEnum FileInfoFieldsIds = 32768
  fromEnum FileInfoFieldsAcl = 65536
  fromEnum FileInfoFieldsSelinuxContext = 131072

  toEnum 0 = FileInfoFieldsNone
  toEnum 1 = FileInfoFieldsType
  toEnum 2 = FileInfoFieldsPermissions
  toEnum 4 = FileInfoFieldsFlags
  toEnum 8 = FileInfoFieldsDevice
  toEnum 16 = FileInfoFieldsInode
  toEnum 32 = FileInfoFieldsLinkCount
  toEnum 64 = FileInfoFieldsSize
  toEnum 128 = FileInfoFieldsBlockCount
  toEnum 256 = FileInfoFieldsIoBlockSize
  toEnum 512 = FileInfoFieldsAtime
  toEnum 1024 = FileInfoFieldsMtime
  toEnum 2048 = FileInfoFieldsCtime
  toEnum 4096 = FileInfoFieldsSymlinkName
  toEnum 8192 = FileInfoFieldsMimeType
  toEnum 16384 = FileInfoFieldsAccess
  toEnum 32768 = FileInfoFieldsIds
  toEnum 65536 = FileInfoFieldsAcl
  toEnum 131072 = FileInfoFieldsSelinuxContext
  toEnum unmatched = error ("FileInfoFields.toEnum: Cannot match " ++ show unmatched)

  succ FileInfoFieldsNone = FileInfoFieldsType
  succ FileInfoFieldsType = FileInfoFieldsPermissions
  succ FileInfoFieldsPermissions = FileInfoFieldsFlags
  succ FileInfoFieldsFlags = FileInfoFieldsDevice
  succ FileInfoFieldsDevice = FileInfoFieldsInode
  succ FileInfoFieldsInode = FileInfoFieldsLinkCount
  succ FileInfoFieldsLinkCount = FileInfoFieldsSize
  succ FileInfoFieldsSize = FileInfoFieldsBlockCount
  succ FileInfoFieldsBlockCount = FileInfoFieldsIoBlockSize
  succ FileInfoFieldsIoBlockSize = FileInfoFieldsAtime
  succ FileInfoFieldsAtime = FileInfoFieldsMtime
  succ FileInfoFieldsMtime = FileInfoFieldsCtime
  succ FileInfoFieldsCtime = FileInfoFieldsSymlinkName
  succ FileInfoFieldsSymlinkName = FileInfoFieldsMimeType
  succ FileInfoFieldsMimeType = FileInfoFieldsAccess
  succ FileInfoFieldsAccess = FileInfoFieldsIds
  succ FileInfoFieldsIds = FileInfoFieldsAcl
  succ FileInfoFieldsAcl = FileInfoFieldsSelinuxContext
  succ _ = undefined

  pred FileInfoFieldsType = FileInfoFieldsNone
  pred FileInfoFieldsPermissions = FileInfoFieldsType
  pred FileInfoFieldsFlags = FileInfoFieldsPermissions
  pred FileInfoFieldsDevice = FileInfoFieldsFlags
  pred FileInfoFieldsInode = FileInfoFieldsDevice
  pred FileInfoFieldsLinkCount = FileInfoFieldsInode
  pred FileInfoFieldsSize = FileInfoFieldsLinkCount
  pred FileInfoFieldsBlockCount = FileInfoFieldsSize
  pred FileInfoFieldsIoBlockSize = FileInfoFieldsBlockCount
  pred FileInfoFieldsAtime = FileInfoFieldsIoBlockSize
  pred FileInfoFieldsMtime = FileInfoFieldsAtime
  pred FileInfoFieldsCtime = FileInfoFieldsMtime
  pred FileInfoFieldsSymlinkName = FileInfoFieldsCtime
  pred FileInfoFieldsMimeType = FileInfoFieldsSymlinkName
  pred FileInfoFieldsAccess = FileInfoFieldsMimeType
  pred FileInfoFieldsIds = FileInfoFieldsAccess
  pred FileInfoFieldsAcl = FileInfoFieldsIds
  pred FileInfoFieldsSelinuxContext = FileInfoFieldsAcl
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x FileInfoFieldsSelinuxContext
  enumFromThen _ _ =     error "Enum FileInfoFields: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum FileInfoFields: enumFromThenTo not implemented"

{-# LINE 217 "./System/Gnome/VFS/BasicTypes.chs" #-}

-- | Options for reading information from a file.
data FileInfoOptions = FileInfoDefault
                     | FileInfoGetMimeType
                     | FileInfoForceFastMimeType
                     | FileInfoForceSlowMimeType
                     | FileInfoFollowLinks
                     | FileInfoGetAccessRights
                     | FileInfoNameOnly
                     | FileInfoGetAcl
                     | FileInfoGetSelinuxContext
                     deriving (Eq,Bounded,Show)
instance Enum FileInfoOptions where
  fromEnum FileInfoDefault = 0
  fromEnum FileInfoGetMimeType = 1
  fromEnum FileInfoForceFastMimeType = 2
  fromEnum FileInfoForceSlowMimeType = 4
  fromEnum FileInfoFollowLinks = 8
  fromEnum FileInfoGetAccessRights = 16
  fromEnum FileInfoNameOnly = 32
  fromEnum FileInfoGetAcl = 64
  fromEnum FileInfoGetSelinuxContext = 128

  toEnum 0 = FileInfoDefault
  toEnum 1 = FileInfoGetMimeType
  toEnum 2 = FileInfoForceFastMimeType
  toEnum 4 = FileInfoForceSlowMimeType
  toEnum 8 = FileInfoFollowLinks
  toEnum 16 = FileInfoGetAccessRights
  toEnum 32 = FileInfoNameOnly
  toEnum 64 = FileInfoGetAcl
  toEnum 128 = FileInfoGetSelinuxContext
  toEnum unmatched = error ("FileInfoOptions.toEnum: Cannot match " ++ show unmatched)

  succ FileInfoDefault = FileInfoGetMimeType
  succ FileInfoGetMimeType = FileInfoForceFastMimeType
  succ FileInfoForceFastMimeType = FileInfoForceSlowMimeType
  succ FileInfoForceSlowMimeType = FileInfoFollowLinks
  succ FileInfoFollowLinks = FileInfoGetAccessRights
  succ FileInfoGetAccessRights = FileInfoNameOnly
  succ FileInfoNameOnly = FileInfoGetAcl
  succ FileInfoGetAcl = FileInfoGetSelinuxContext
  succ _ = undefined

  pred FileInfoGetMimeType = FileInfoDefault
  pred FileInfoForceFastMimeType = FileInfoGetMimeType
  pred FileInfoForceSlowMimeType = FileInfoForceFastMimeType
  pred FileInfoFollowLinks = FileInfoForceSlowMimeType
  pred FileInfoGetAccessRights = FileInfoFollowLinks
  pred FileInfoNameOnly = FileInfoGetAccessRights
  pred FileInfoGetAcl = FileInfoNameOnly
  pred FileInfoGetSelinuxContext = FileInfoGetAcl
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x FileInfoGetSelinuxContext
  enumFromThen _ _ =     error "Enum FileInfoOptions: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum FileInfoOptions: enumFromThenTo not implemented"

{-# LINE 220 "./System/Gnome/VFS/BasicTypes.chs" #-}

-- | Flags specifying additional information about a file.
data FileFlags = FileFlagsNone
               | FileFlagsSymlink
               | FileFlagsLocal
               deriving (Eq,Bounded,Show)
instance Enum FileFlags where
  fromEnum FileFlagsNone = 0
  fromEnum FileFlagsSymlink = 1
  fromEnum FileFlagsLocal = 2

  toEnum 0 = FileFlagsNone
  toEnum 1 = FileFlagsSymlink
  toEnum 2 = FileFlagsLocal
  toEnum unmatched = error ("FileFlags.toEnum: Cannot match " ++ show unmatched)

  succ FileFlagsNone = FileFlagsSymlink
  succ FileFlagsSymlink = FileFlagsLocal
  succ _ = undefined

  pred FileFlagsSymlink = FileFlagsNone
  pred FileFlagsLocal = FileFlagsSymlink
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x FileFlagsLocal
  enumFromThen _ _ =     error "Enum FileFlags: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum FileFlags: enumFromThenTo not implemented"

{-# LINE 223 "./System/Gnome/VFS/BasicTypes.chs" #-}

-- | Flags specifying the attributes of a file that should be changed.
data SetFileInfoMask = SetFileInfoNone
                     | SetFileInfoName
                     | SetFileInfoPermissions
                     | SetFileInfoOwner
                     | SetFileInfoTime
                     | SetFileInfoAcl
                     | SetFileInfoSelinuxContext
                     | SetFileInfoSymlinkName
                     deriving (Eq,Bounded,Show)
instance Enum SetFileInfoMask where
  fromEnum SetFileInfoNone = 0
  fromEnum SetFileInfoName = 1
  fromEnum SetFileInfoPermissions = 2
  fromEnum SetFileInfoOwner = 4
  fromEnum SetFileInfoTime = 8
  fromEnum SetFileInfoAcl = 16
  fromEnum SetFileInfoSelinuxContext = 32
  fromEnum SetFileInfoSymlinkName = 64

  toEnum 0 = SetFileInfoNone
  toEnum 1 = SetFileInfoName
  toEnum 2 = SetFileInfoPermissions
  toEnum 4 = SetFileInfoOwner
  toEnum 8 = SetFileInfoTime
  toEnum 16 = SetFileInfoAcl
  toEnum 32 = SetFileInfoSelinuxContext
  toEnum 64 = SetFileInfoSymlinkName
  toEnum unmatched = error ("SetFileInfoMask.toEnum: Cannot match " ++ show unmatched)

  succ SetFileInfoNone = SetFileInfoName
  succ SetFileInfoName = SetFileInfoPermissions
  succ SetFileInfoPermissions = SetFileInfoOwner
  succ SetFileInfoOwner = SetFileInfoTime
  succ SetFileInfoTime = SetFileInfoAcl
  succ SetFileInfoAcl = SetFileInfoSelinuxContext
  succ SetFileInfoSelinuxContext = SetFileInfoSymlinkName
  succ _ = undefined

  pred SetFileInfoName = SetFileInfoNone
  pred SetFileInfoPermissions = SetFileInfoName
  pred SetFileInfoOwner = SetFileInfoPermissions
  pred SetFileInfoTime = SetFileInfoOwner
  pred SetFileInfoAcl = SetFileInfoTime
  pred SetFileInfoSelinuxContext = SetFileInfoAcl
  pred SetFileInfoSymlinkName = SetFileInfoSelinuxContext
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x SetFileInfoSymlinkName
  enumFromThen _ _ =     error "Enum SetFileInfoMask: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum SetFileInfoMask: enumFromThenTo not implemented"

{-# LINE 226 "./System/Gnome/VFS/BasicTypes.chs" #-}

-- | Identifies the type of a file.
data FileType = FileTypeUnknown
              | FileTypeRegular
              | FileTypeDirectory
              | FileTypeFifo
              | FileTypeSocket
              | FileTypeCharacterDevice
              | FileTypeBlockDevice
              | FileTypeSymbolicLink
              deriving (Enum,Eq,Show)

{-# LINE 229 "./System/Gnome/VFS/BasicTypes.chs" #-}

instance Flags FileInfoOptions
instance Flags FileInfoFields
instance Flags FileFlags
instance Flags SetFileInfoMask

-- | An integral type wide enough to hold the size of a file.
type FileSize = Word64

-- | An integral type wide enough to hold an offset into a file.
type FileOffset = Word64

-- | An integral type wide enough to hold the inode number of a file.
type InodeNumber = Word64

-- | A pair holding the user ID and group ID of a file owner.
type IDs = (Int, Int)

--------------------------------------------------------------------

-- | A 'URI' is a semi-textual representation of a uniform
-- resource identifier. It contains the information about a resource
-- location encoded as canononicalized text, but also holds extra
-- information about the context in which the URI is used.
newtype URI = URI (ForeignPtr (URI))
{-# LINE 254 "./System/Gnome/VFS/BasicTypes.chs" #-}

newURI :: Ptr URI
       -> IO URI
newURI cURI | cURI /= nullPtr =
    liftM URI $ newForeignPtr cURI cURIFinalizer
wrapURI :: Ptr URI
        -> IO URI
wrapURI cURI | cURI /= nullPtr =
    liftM URI $ newForeignPtr_ cURI
foreign import ccall "&gnome_vfs_uri_unref"
  cURIFinalizer :: FunPtr (Ptr URI -> IO ())

withURI (URI cURI) = withForeignPtr cURI

-- | The toplevel URI element used to access resources stored on a
-- remote server.
newtype ToplevelURI = ToplevelURI (ForeignPtr (ToplevelURI))
{-# LINE 271 "./System/Gnome/VFS/BasicTypes.chs" #-}
withToplevelURI (ToplevelURI cToplevelURI) = withForeignPtr cToplevelURI
newToplevelURI :: Ptr ToplevelURI
               -> IO ToplevelURI
newToplevelURI cToplevelURI = liftM ToplevelURI $ newForeignPtr_ cToplevelURI

-- | Flags specifying which fields of a 'URI' should be hidden when
-- converted to a string using 'uriToString'.
data URIHideOptions = URIHideNone
                    | URIHideUserName
                    | URIHidePassword
                    | URIHideHostName
                    | URIHideHostPort
                    | URIHideToplevelMethod
                    | URIHideFragmentIdentifier
                    deriving (Eq,Bounded,Show)
instance Enum URIHideOptions where
  fromEnum URIHideNone = 0
  fromEnum URIHideUserName = 1
  fromEnum URIHidePassword = 2
  fromEnum URIHideHostName = 4
  fromEnum URIHideHostPort = 8
  fromEnum URIHideToplevelMethod = 16
  fromEnum URIHideFragmentIdentifier = 256

  toEnum 0 = URIHideNone
  toEnum 1 = URIHideUserName
  toEnum 2 = URIHidePassword
  toEnum 4 = URIHideHostName
  toEnum 8 = URIHideHostPort
  toEnum 16 = URIHideToplevelMethod
  toEnum 256 = URIHideFragmentIdentifier
  toEnum unmatched = error ("URIHideOptions.toEnum: Cannot match " ++ show unmatched)

  succ URIHideNone = URIHideUserName
  succ URIHideUserName = URIHidePassword
  succ URIHidePassword = URIHideHostName
  succ URIHideHostName = URIHideHostPort
  succ URIHideHostPort = URIHideToplevelMethod
  succ URIHideToplevelMethod = URIHideFragmentIdentifier
  succ _ = undefined

  pred URIHideUserName = URIHideNone
  pred URIHidePassword = URIHideUserName
  pred URIHideHostName = URIHidePassword
  pred URIHideHostPort = URIHideHostName
  pred URIHideToplevelMethod = URIHideHostPort
  pred URIHideFragmentIdentifier = URIHideToplevelMethod
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x URIHideFragmentIdentifier
  enumFromThen _ _ =     error "Enum URIHideOptions: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum URIHideOptions: enumFromThenTo not implemented"

{-# LINE 287 "./System/Gnome/VFS/BasicTypes.chs" #-}
instance Flags URIHideOptions

-- | A string that can be passed to 'uriFromString' to create a valid
-- 'URI'.
type TextURI = String

--------------------------------------------------------------------

-- | A handle to an open directory.
newtype DirectoryHandle = DirectoryHandle (ForeignPtr (DirectoryHandle))
{-# LINE 297 "./System/Gnome/VFS/BasicTypes.chs" #-}
withDirectoryHandle (DirectoryHandle cDirectoryHandle) = withForeignPtr cDirectoryHandle

-- | Options controlling the way in which a directories are visited.
data DirectoryVisitOptions = DirectoryVisitDefault
                           | DirectoryVisitSamefs
                           | DirectoryVisitLoopcheck
                           | DirectoryVisitIgnoreRecurseError
                           deriving (Eq,Bounded,Show)
instance Enum DirectoryVisitOptions where
  fromEnum DirectoryVisitDefault = 0
  fromEnum DirectoryVisitSamefs = 1
  fromEnum DirectoryVisitLoopcheck = 2
  fromEnum DirectoryVisitIgnoreRecurseError = 4

  toEnum 0 = DirectoryVisitDefault
  toEnum 1 = DirectoryVisitSamefs
  toEnum 2 = DirectoryVisitLoopcheck
  toEnum 4 = DirectoryVisitIgnoreRecurseError
  toEnum unmatched = error ("DirectoryVisitOptions.toEnum: Cannot match " ++ show unmatched)

  succ DirectoryVisitDefault = DirectoryVisitSamefs
  succ DirectoryVisitSamefs = DirectoryVisitLoopcheck
  succ DirectoryVisitLoopcheck = DirectoryVisitIgnoreRecurseError
  succ _ = undefined

  pred DirectoryVisitSamefs = DirectoryVisitDefault
  pred DirectoryVisitLoopcheck = DirectoryVisitSamefs
  pred DirectoryVisitIgnoreRecurseError = DirectoryVisitLoopcheck
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x DirectoryVisitIgnoreRecurseError
  enumFromThen _ _ =     error "Enum DirectoryVisitOptions: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum DirectoryVisitOptions: enumFromThenTo not implemented"

{-# LINE 301 "./System/Gnome/VFS/BasicTypes.chs" #-}
instance Flags DirectoryVisitOptions

-- | A callback that will be called for each entry when passed to
-- 'directoryVisit', 'directoryVisitURI', 'directoryVisitFiles', or
-- 'directoryVisitFilesAtURI'.
--
-- The parameters, from left to right, are:
-- * the path of the visited file, relative to the base directory,
-- * the 'FileInfo' for the visited file,
-- * 'True' if returning 'DirectoryVisitRecurse' will cause a loop, otherwise 'False'.
--
-- The callback must return the next action to be taken.
type DirectoryVisitCallback = String
                            -> FileInfo
                            -> Bool
                            -> IO DirectoryVisitResult

-- | An enumerated value that must be returned from a
-- 'DirectoryVisitCallback'. The 'directoryVisit' and related
-- functions will perform the action specified.
data DirectoryVisitResult = DirectoryVisitStop -- ^ stop visiting files
                          | DirectoryVisitContinue -- ^ continue as normal
                          | DirectoryVisitRecurse -- ^ recursively visit the current entry
                            deriving (Eq, Enum)

-- | Specifies which kind of directory 'findDirectory' should look for.
data FindDirectoryKind = DirectoryKindDesktop
                       | DirectoryKindTrash
                       deriving (Eq,Show)
instance Enum FindDirectoryKind where
  fromEnum DirectoryKindDesktop = 1000
  fromEnum DirectoryKindTrash = 1001

  toEnum 1000 = DirectoryKindDesktop
  toEnum 1001 = DirectoryKindTrash
  toEnum unmatched = error ("FindDirectoryKind.toEnum: Cannot match " ++ show unmatched)

  succ DirectoryKindDesktop = DirectoryKindTrash
  succ _ = undefined

  pred DirectoryKindTrash = DirectoryKindDesktop
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x DirectoryKindTrash
  enumFromThen _ _ =     error "Enum FindDirectoryKind: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum FindDirectoryKind: enumFromThenTo not implemented"

{-# LINE 328 "./System/Gnome/VFS/BasicTypes.chs" #-}

--------------------------------------------------------------------

-- | Flags that may be passed to 'makeURIFromInputWithDirs'. If the
-- path passed is non-absolute (i.e., a relative path), the
-- directories specified will be searched as well.
data MakeURIDirs = MakeUriDirNone
                 | MakeUriDirHomedir
                 | MakeUriDirCurrent
                 deriving (Eq,Bounded,Show)
instance Enum MakeURIDirs where
  fromEnum MakeUriDirNone = 0
  fromEnum MakeUriDirHomedir = 1
  fromEnum MakeUriDirCurrent = 2

  toEnum 0 = MakeUriDirNone
  toEnum 1 = MakeUriDirHomedir
  toEnum 2 = MakeUriDirCurrent
  toEnum unmatched = error ("MakeURIDirs.toEnum: Cannot match " ++ show unmatched)

  succ MakeUriDirNone = MakeUriDirHomedir
  succ MakeUriDirHomedir = MakeUriDirCurrent
  succ _ = undefined

  pred MakeUriDirHomedir = MakeUriDirNone
  pred MakeUriDirCurrent = MakeUriDirHomedir
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x MakeUriDirCurrent
  enumFromThen _ _ =     error "Enum MakeURIDirs: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum MakeURIDirs: enumFromThenTo not implemented"

{-# LINE 335 "./System/Gnome/VFS/BasicTypes.chs" #-}
instance Flags MakeURIDirs

--------------------------------------------------------------------

-- | A handle to a file-system monitor.
newtype MonitorHandle = MonitorHandle (ForeignPtr MonitorHandle, ((FunPtr ((Ptr ()) -> ((Ptr CChar) -> ((Ptr CChar) -> (CInt -> ((Ptr ()) -> (IO ())))))))))
withMonitorHandle (MonitorHandle (monitorHandleForeignPtr, _)) = withForeignPtr monitorHandleForeignPtr

-- | A callback that must be passed to 'monitorAdd'. It will be
-- called any time a file or directory is changed.
--
-- The parameters, from left to right, are:
-- * the handle to a filesystem monitor,
-- * the URI being monitored,
-- * the actual file that was modified,
-- * the event that occured.
type MonitorCallback = MonitorHandle
                     -> TextURI
                     -> TextURI
                     -> MonitorEventType
                     -> IO ()

-- | The type of filesystem object that is to be monitored.
data MonitorType = MonitorFile
                 | MonitorDirectory
                 deriving (Enum,Eq,Bounded,Show)

{-# LINE 359 "./System/Gnome/VFS/BasicTypes.chs" #-}

-- | The type of event that caused a 'MonitorCallback' to be called.
data MonitorEventType = MonitorEventChanged
                      | MonitorEventDeleted
                      | MonitorEventStartexecuting
                      | MonitorEventStopexecuting
                      | MonitorEventCreated
                      | MonitorEventMetadataChanged
                      deriving (Enum,Eq,Bounded,Show)

{-# LINE 362 "./System/Gnome/VFS/BasicTypes.chs" #-}
wrapMonitorHandle :: (Ptr MonitorHandle, ((FunPtr ((Ptr ()) -> ((Ptr CChar) -> ((Ptr CChar) -> (CInt -> ((Ptr ()) -> (IO ())))))))))
                  -> IO MonitorHandle
wrapMonitorHandle (cMonitorHandle, cMonitorCallback) =
    do monitorHandleForeignPtr <- newForeignPtr_ cMonitorHandle
       return $ MonitorHandle (monitorHandleForeignPtr, cMonitorCallback)

--------------------------------------------------------------------

-- | Options controlling how the 'System.Gnome.VFS.Xfer.xferURI' and related functions behave.
data XferOptions = XferDefault
                 | XferUnused1
                 | XferFollowLinks
                 | XferUnused2
                 | XferRecursive
                 | XferSamefs
                 | XferDeleteItems
                 | XferEmptyDirectories
                 | XferNewUniqueDirectory
                 | XferRemovesource
                 | XferUseUniqueNames
                 | XferLinkItems
                 | XferFollowLinksRecursive
                 | XferTargetDefaultPerms
                 deriving (Eq,Bounded,Show)
instance Enum XferOptions where
  fromEnum XferDefault = 0
  fromEnum XferUnused1 = 1
  fromEnum XferFollowLinks = 2
  fromEnum XferUnused2 = 4
  fromEnum XferRecursive = 8
  fromEnum XferSamefs = 16
  fromEnum XferDeleteItems = 32
  fromEnum XferEmptyDirectories = 64
  fromEnum XferNewUniqueDirectory = 128
  fromEnum XferRemovesource = 256
  fromEnum XferUseUniqueNames = 512
  fromEnum XferLinkItems = 1024
  fromEnum XferFollowLinksRecursive = 2048
  fromEnum XferTargetDefaultPerms = 4096

  toEnum 0 = XferDefault
  toEnum 1 = XferUnused1
  toEnum 2 = XferFollowLinks
  toEnum 4 = XferUnused2
  toEnum 8 = XferRecursive
  toEnum 16 = XferSamefs
  toEnum 32 = XferDeleteItems
  toEnum 64 = XferEmptyDirectories
  toEnum 128 = XferNewUniqueDirectory
  toEnum 256 = XferRemovesource
  toEnum 512 = XferUseUniqueNames
  toEnum 1024 = XferLinkItems
  toEnum 2048 = XferFollowLinksRecursive
  toEnum 4096 = XferTargetDefaultPerms
  toEnum unmatched = error ("XferOptions.toEnum: Cannot match " ++ show unmatched)

  succ XferDefault = XferUnused1
  succ XferUnused1 = XferFollowLinks
  succ XferFollowLinks = XferUnused2
  succ XferUnused2 = XferRecursive
  succ XferRecursive = XferSamefs
  succ XferSamefs = XferDeleteItems
  succ XferDeleteItems = XferEmptyDirectories
  succ XferEmptyDirectories = XferNewUniqueDirectory
  succ XferNewUniqueDirectory = XferRemovesource
  succ XferRemovesource = XferUseUniqueNames
  succ XferUseUniqueNames = XferLinkItems
  succ XferLinkItems = XferFollowLinksRecursive
  succ XferFollowLinksRecursive = XferTargetDefaultPerms
  succ _ = undefined

  pred XferUnused1 = XferDefault
  pred XferFollowLinks = XferUnused1
  pred XferUnused2 = XferFollowLinks
  pred XferRecursive = XferUnused2
  pred XferSamefs = XferRecursive
  pred XferDeleteItems = XferSamefs
  pred XferEmptyDirectories = XferDeleteItems
  pred XferNewUniqueDirectory = XferEmptyDirectories
  pred XferRemovesource = XferNewUniqueDirectory
  pred XferUseUniqueNames = XferRemovesource
  pred XferLinkItems = XferUseUniqueNames
  pred XferFollowLinksRecursive = XferLinkItems
  pred XferTargetDefaultPerms = XferFollowLinksRecursive
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x XferTargetDefaultPerms
  enumFromThen _ _ =     error "Enum XferOptions: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum XferOptions: enumFromThenTo not implemented"

{-# LINE 372 "./System/Gnome/VFS/BasicTypes.chs" #-}
instance Flags XferOptions

data XferProgressStatus = XferProgressStatusOk
                        | XferProgressStatusVfserror
                        | XferProgressStatusOverwrite
                        | XferProgressStatusDuplicate
                        deriving (Eq,Show)
instance Enum XferProgressStatus where
  fromEnum XferProgressStatusOk = 0
  fromEnum XferProgressStatusVfserror = 1
  fromEnum XferProgressStatusOverwrite = 2
  fromEnum XferProgressStatusDuplicate = 3

  toEnum 0 = XferProgressStatusOk
  toEnum 1 = XferProgressStatusVfserror
  toEnum 2 = XferProgressStatusOverwrite
  toEnum 3 = XferProgressStatusDuplicate
  toEnum unmatched = error ("XferProgressStatus.toEnum: Cannot match " ++ show unmatched)

  succ XferProgressStatusOk = XferProgressStatusVfserror
  succ XferProgressStatusVfserror = XferProgressStatusOverwrite
  succ XferProgressStatusOverwrite = XferProgressStatusDuplicate
  succ _ = undefined

  pred XferProgressStatusVfserror = XferProgressStatusOk
  pred XferProgressStatusOverwrite = XferProgressStatusVfserror
  pred XferProgressStatusDuplicate = XferProgressStatusOverwrite
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x XferProgressStatusDuplicate
  enumFromThen _ _ =     error "Enum XferProgressStatus: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum XferProgressStatus: enumFromThenTo not implemented"

{-# LINE 375 "./System/Gnome/VFS/BasicTypes.chs" #-}
data XferOverwriteMode = XferOverwriteModeAbort
                       | XferOverwriteModeQuery
                       | XferOverwriteModeReplace
                       | XferOverwriteModeSkip
                       deriving (Eq,Show)
instance Enum XferOverwriteMode where
  fromEnum XferOverwriteModeAbort = 0
  fromEnum XferOverwriteModeQuery = 1
  fromEnum XferOverwriteModeReplace = 2
  fromEnum XferOverwriteModeSkip = 3

  toEnum 0 = XferOverwriteModeAbort
  toEnum 1 = XferOverwriteModeQuery
  toEnum 2 = XferOverwriteModeReplace
  toEnum 3 = XferOverwriteModeSkip
  toEnum unmatched = error ("XferOverwriteMode.toEnum: Cannot match " ++ show unmatched)

  succ XferOverwriteModeAbort = XferOverwriteModeQuery
  succ XferOverwriteModeQuery = XferOverwriteModeReplace
  succ XferOverwriteModeReplace = XferOverwriteModeSkip
  succ _ = undefined

  pred XferOverwriteModeQuery = XferOverwriteModeAbort
  pred XferOverwriteModeReplace = XferOverwriteModeQuery
  pred XferOverwriteModeSkip = XferOverwriteModeReplace
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x XferOverwriteModeSkip
  enumFromThen _ _ =     error "Enum XferOverwriteMode: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum XferOverwriteMode: enumFromThenTo not implemented"

{-# LINE 376 "./System/Gnome/VFS/BasicTypes.chs" #-}
data XferOverwriteAction = XferOverwriteActionAbort
                         | XferOverwriteActionReplace
                         | XferOverwriteActionReplaceAll
                         | XferOverwriteActionSkip
                         | XferOverwriteActionSkipAll
                         deriving (Eq,Show)
instance Enum XferOverwriteAction where
  fromEnum XferOverwriteActionAbort = 0
  fromEnum XferOverwriteActionReplace = 1
  fromEnum XferOverwriteActionReplaceAll = 2
  fromEnum XferOverwriteActionSkip = 3
  fromEnum XferOverwriteActionSkipAll = 4

  toEnum 0 = XferOverwriteActionAbort
  toEnum 1 = XferOverwriteActionReplace
  toEnum 2 = XferOverwriteActionReplaceAll
  toEnum 3 = XferOverwriteActionSkip
  toEnum 4 = XferOverwriteActionSkipAll
  toEnum unmatched = error ("XferOverwriteAction.toEnum: Cannot match " ++ show unmatched)

  succ XferOverwriteActionAbort = XferOverwriteActionReplace
  succ XferOverwriteActionReplace = XferOverwriteActionReplaceAll
  succ XferOverwriteActionReplaceAll = XferOverwriteActionSkip
  succ XferOverwriteActionSkip = XferOverwriteActionSkipAll
  succ _ = undefined

  pred XferOverwriteActionReplace = XferOverwriteActionAbort
  pred XferOverwriteActionReplaceAll = XferOverwriteActionReplace
  pred XferOverwriteActionSkip = XferOverwriteActionReplaceAll
  pred XferOverwriteActionSkipAll = XferOverwriteActionSkip
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x XferOverwriteActionSkipAll
  enumFromThen _ _ =     error "Enum XferOverwriteAction: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum XferOverwriteAction: enumFromThenTo not implemented"

{-# LINE 377 "./System/Gnome/VFS/BasicTypes.chs" #-}
data XferErrorMode = XferErrorModeAbort
                   | XferErrorModeQuery
                   deriving (Eq,Show)
instance Enum XferErrorMode where
  fromEnum XferErrorModeAbort = 0
  fromEnum XferErrorModeQuery = 1

  toEnum 0 = XferErrorModeAbort
  toEnum 1 = XferErrorModeQuery
  toEnum unmatched = error ("XferErrorMode.toEnum: Cannot match " ++ show unmatched)

  succ XferErrorModeAbort = XferErrorModeQuery
  succ _ = undefined

  pred XferErrorModeQuery = XferErrorModeAbort
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x XferErrorModeQuery
  enumFromThen _ _ =     error "Enum XferErrorMode: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum XferErrorMode: enumFromThenTo not implemented"

{-# LINE 378 "./System/Gnome/VFS/BasicTypes.chs" #-}
data XferErrorAction = XferErrorActionAbort
                     | XferErrorActionRetry
                     | XferErrorActionSkip
                     deriving (Eq,Show)
instance Enum XferErrorAction where
  fromEnum XferErrorActionAbort = 0
  fromEnum XferErrorActionRetry = 1
  fromEnum XferErrorActionSkip = 2

  toEnum 0 = XferErrorActionAbort
  toEnum 1 = XferErrorActionRetry
  toEnum 2 = XferErrorActionSkip
  toEnum unmatched = error ("XferErrorAction.toEnum: Cannot match " ++ show unmatched)

  succ XferErrorActionAbort = XferErrorActionRetry
  succ XferErrorActionRetry = XferErrorActionSkip
  succ _ = undefined

  pred XferErrorActionRetry = XferErrorActionAbort
  pred XferErrorActionSkip = XferErrorActionRetry
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x XferErrorActionSkip
  enumFromThen _ _ =     error "Enum XferErrorAction: enumFromThen not implemented"
  enumFromThenTo _ _ _ =     error "Enum XferErrorAction: enumFromThenTo not implemented"

{-# LINE 379 "./System/Gnome/VFS/BasicTypes.chs" #-}
data XferPhase = XferPhaseInitial
               | XferCheckingDestination
               | XferPhaseCollecting
               | XferPhaseReadytogo
               | XferPhaseOpensource
               | XferPhaseOpentarget
               | XferPhaseCopying
               | XferPhaseMoving
               | XferPhaseReadsource
               | XferPhaseWritetarget
               | XferPhaseClosesource
               | XferPhaseClosetarget
               | XferPhaseDeletesource
               | XferPhaseSetattributes
               | XferPhaseFilecompleted
               | XferPhaseCleanup
               | XferPhaseCompleted
               | XferNumPhases
               deriving (Enum,Eq,Show)

{-# LINE 380 "./System/Gnome/VFS/BasicTypes.chs" #-}

data XferProgressInfo = XferProgressInfo {
    xferProgressInfoVFSStatus :: Result, -- ^ current VFS status
    xferProgressInfoPhase :: XferPhase, -- ^ phase of the transfer
    xferProgressInfoSourceName :: Maybe String, -- ^ currently transferring source URI
    xferProgressInfoTargetName :: Maybe String, -- ^ currently transferring target URI
    xferProgressInfoFileIndex :: Word, -- ^ index of the file currently being transferred
    xferProgressInfoFilesTotal :: Word, -- ^ total number of files being transferred
    xferProgressInfoBytesTotal :: FileSize, -- ^ total size of all files in bytes
    xferProgressInfoFileSize :: FileSize, -- ^ size of the file currently being transferred
    xferProgressInfoBytesCopied :: FileSize, -- ^ number of bytes already transferred in the current file
    xferProgressInfoTotalBytesCopied :: FileSize, -- ^ total number of bytes already transferred
    xferProgressInfoTopLevelItem :: Bool -- ^ 'True' if the file being transferred is a top-level item;
                                                      -- 'False' if it is inside a directory
    } deriving (Eq)

-- | The type of the first callback that is passed to
-- 'System.Gnome.VFS.Xfer.xferURI' and related functions. This
-- callback will be called periodically during transfers that are
-- progressing normally.
--
-- The callback must return 'Prelude.False' to abort the transfer, or 'Prelude.True' otherwise.
type XferProgressCallback = XferProgressInfo
                           -> IO Bool

-- | The type of the second callback that is passed to
-- 'System.Gnome.VFS.Xfer.xferURI'. This callback will be called
-- whenever an error occurs.
--
-- The callback must return the action to be performed in response to the error.
type XferErrorCallback = XferProgressInfo
                           -> IO XferErrorAction

-- | The type of the third callback that is passed to
-- 'System.Gnome.VFS.Xfer.xferURI'. This callback will be called
-- when a file would be overwritten.
--
-- The callback must return the action to be performed when the target file already exists.
type XferOverwriteCallback = XferProgressInfo
                           -> IO XferOverwriteAction

-- | The type of the fourth callback that is passed to
-- 'System.Gnome.VFS.Xfer.xferURI'. This callback will be called
-- when a duplicate filename is found.
--
-- The parameters, from left to right, are:
-- * @info@ - information about the progress of the current transfer,
-- * @duplicateName@ - the name of the target file,
-- * @duplicateCount@ - the number of duplicates that exist.
--
-- The callback must return the new filename that should be used, or 'Prelude.Nothing' to abort.
type XferDuplicateCallback = XferProgressInfo
                           -> String
                           -> Int
                           -> IO (Maybe String)

--------------------------------------------------------------------

-- | An object that can be used for signalling cancellation of an
-- operation.
newtype Cancellation = Cancellation (ForeignPtr (Cancellation))
{-# LINE 441 "./System/Gnome/VFS/BasicTypes.chs" #-}

newCancellation :: Ptr Cancellation
                -> IO Cancellation
newCancellation cCancellationPtr | cCancellationPtr /= nullPtr =
    liftM Cancellation $ newForeignPtr cCancellationPtr cancellationFinalizer
foreign import ccall unsafe "&gnome_vfs_cancellation_destroy"
  cancellationFinalizer :: FunPtr (Ptr Cancellation -> IO ())
withCancellation (Cancellation cCancellation) = withForeignPtr cCancellation

--------------------------------------------------------------------

withVolume (Volume cVolume) = withForeignPtr cVolume
newVolume :: Ptr Volume
          -> IO Volume
newVolume cVolume | cVolume /= nullPtr =
   liftM Volume $ newForeignPtr cVolume volumeFinalizer
foreign import ccall unsafe "&gnome_vfs_volume_unref"
  volumeFinalizer :: FunPtr (Ptr Volume -> IO ())

-- | An action to be performed when a volume operation completes successfully.
type VolumeOpSuccessCallback = IO ()
-- | An action to be performed when a volume operation fails.
type VolumeOpFailureCallback = String
                             -> String
                             -> IO ()

-- | Identifies the device type of a 'Volume' or 'Drive'.
data DeviceType = DeviceTypeUnknown
                | DeviceTypeAudioCd
                | DeviceTypeVideoDvd
                | DeviceTypeHarddrive
                | DeviceTypeCdrom
                | DeviceTypeFloppy
                | DeviceTypeZip
                | DeviceTypeJaz
                | DeviceTypeNfs
                | DeviceTypeAutofs
                | DeviceTypeCamera
                | DeviceTypeMemoryStick
                | DeviceTypeSmb
                | DeviceTypeApple
                | DeviceTypeMusicPlayer
                | DeviceTypeWindows
                | DeviceTypeLoopback
                | DeviceTypeNetwork
                deriving (Enum,Eq,Show)

{-# LINE 469 "./System/Gnome/VFS/BasicTypes.chs" #-}
-- | Identifies the type of a 'Volume'.
data VolumeType = VolumeTypeMountpoint
                | VolumeTypeVfsMount
                | VolumeTypeConnectedServer
                deriving (Enum,Eq,Show)

{-# LINE 471 "./System/Gnome/VFS/BasicTypes.chs" #-}

type CVolumeOpCallback = (CInt)
{-# LINE 473 "./System/Gnome/VFS/BasicTypes.chs" #-}
                       -> CString
                       -> CString
                       -> Ptr ()
                       -> IO ()

--------------------------------------------------------------------

-- | Identifies a 'Drive'
type DriveID = (CULong)
{-# LINE 482 "./System/Gnome/VFS/BasicTypes.chs" #-}

withDrive (Drive cDrive) = withForeignPtr cDrive
newDrive :: Ptr Drive
          -> IO Drive
newDrive cDrive | cDrive /= nullPtr =
   liftM Drive $ newForeignPtr cDrive driveFinalizer
foreign import ccall unsafe "&gnome_vfs_drive_unref"
  driveFinalizer :: FunPtr (Ptr Drive -> IO ())

--------------------------------------------------------------------

-- | Identifies a 'Volume'.
type VolumeID = (CULong)
{-# LINE 495 "./System/Gnome/VFS/BasicTypes.chs" #-}

withVolumeMonitor (VolumeMonitor cVolumeMonitor) = withForeignPtr cVolumeMonitor
wrapVolumeMonitor :: Ptr VolumeMonitor
                  -> IO VolumeMonitor
wrapVolumeMonitor cVolumeMonitor | cVolumeMonitor /= nullPtr =
   liftM VolumeMonitor $ newForeignPtr_ cVolumeMonitor

--------------------------------------------------------------------


-- | A string that will be treated as a MIME-type.
type MIMEType = String