<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_SETTINGS</NAME>
#define HILDON_TYPE_FILE_SYSTEM_SETTINGS (hildon_file_system_settings_get_type())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_SETTINGS</NAME>
#define HILDON_FILE_SYSTEM_SETTINGS(object) \
  (G_TYPE_CHECK_INSTANCE_CAST((object), HILDON_TYPE_FILE_SYSTEM_SETTINGS, \
  HildonFileSystemSettings))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_SETTINGSClass</NAME>
#define HILDON_FILE_SYSTEM_SETTINGSClass(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass), HILDON_TYPE_FILE_SYSTEM_SETTINGS, \
  HildonFileSystemSettingsClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_SETTINGS</NAME>
#define HILDON_IS_FILE_SYSTEM_SETTINGS(object) \
  (G_TYPE_CHECK_INSTANCE_TYPE((object), HILDON_TYPE_FILE_SYSTEM_SETTINGS))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_SETTINGS_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_SETTINGS_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass), HILDON_TYPE_FILE_SYSTEM_SETTINGS))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_SETTINGS_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_SETTINGS_GET_CLASS(object) \
  (G_TYPE_INSTANCE_GET_CLASS((object), HILDON_TYPE_FILE_SYSTEM_SETTINGS, \
  HildonFileSystemSettingsClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemSettings</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemSettingsClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemSettingsPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemSettings</NAME>
struct _HildonFileSystemSettings
{
  GObject parent;  
  HildonFileSystemSettingsPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemSettingsClass</NAME>
struct _HildonFileSystemSettingsClass
{
  GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_settings_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_open_user_settings</NAME>
<RETURNS>GKeyFile *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_write_user_settings</NAME>
<RETURNS>void </RETURNS>
GKeyFile *
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_STORAGE_DIALOG</NAME>
#define HILDON_TYPE_FILE_SYSTEM_STORAGE_DIALOG         (hildon_file_system_storage_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_STORAGE_DIALOG</NAME>
#define HILDON_FILE_SYSTEM_STORAGE_DIALOG(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), HILDON_TYPE_FILE_SYSTEM_STORAGE_DIALOG, HildonFileSystemStorageDialog))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_STORAGE_DIALOG_CLASS</NAME>
#define HILDON_FILE_SYSTEM_STORAGE_DIALOG_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), HILDON_TYPE_FILE_SYSTEM_STORAGE_DIALOG, HildonFileSystemStorageDialogClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_STORAGE_DIALOG</NAME>
#define HILDON_IS_FILE_SYSTEM_STORAGE_DIALOG(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), HILDON_TYPE_FILE_SYSTEM_STORAGE_DIALOG))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_STORAGE_DIALOG_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_STORAGE_DIALOG_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), HILDON_TYPE_FILE_SYSTEM_STORAGE_DIALOG))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_STORAGE_DIALOG_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_STORAGE_DIALOG_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), HILDON_TYPE_FILE_SYSTEM_STORAGE_DIALOG, HildonFileSystemStorageDialogClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemStorageDialog</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemStorageDialogClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemStorageDialogPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemStorageDialog</NAME>
struct _HildonFileSystemStorageDialog {
	GtkDialog      parent;
};

</STRUCT>
<STRUCT>
<NAME>HildonFileSystemStorageDialogClass</NAME>
struct _HildonFileSystemStorageDialogClass {
	GtkDialogClass parent_class;
};

</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_storage_dialog_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_storage_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow   *parent,const gchar *uri_str
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_storage_dialog_set_uri</NAME>
<RETURNS>void       </RETURNS>
GtkWidget   *widget,const gchar *uri_str
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_LOCAL_DEVICE</NAME>
#define HILDON_TYPE_FILE_SYSTEM_LOCAL_DEVICE            (hildon_file_system_local_device_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_LOCAL_DEVICE</NAME>
#define HILDON_FILE_SYSTEM_LOCAL_DEVICE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), HILDON_TYPE_FILE_SYSTEM_LOCAL_DEVICE, HildonFileSystemLocalDevice))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_LOCAL_DEVICE_CLASS</NAME>
#define HILDON_FILE_SYSTEM_LOCAL_DEVICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_SYSTEM_LOCAL_DEVICE, HildonFileSystemLocalDeviceClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_LOCAL_DEVICE</NAME>
#define HILDON_IS_FILE_SYSTEM_LOCAL_DEVICE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HILDON_TYPE_FILE_SYSTEM_LOCAL_DEVICE))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_LOCAL_DEVICE_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_LOCAL_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SYSTEM_LOCAL_DEVICE))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_LOCAL_DEVICE_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_LOCAL_DEVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), HILDON_TYPE_FILE_SYSTEM_LOCAL_DEVICE, HildonFileSystemLocalDeviceClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemLocalDevice</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemLocalDeviceClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemLocalDevice</NAME>
struct _HildonFileSystemLocalDevice
{
    HildonFileSystemSpecialLocation parent_instance;

    /* private */
    gulong signal_handler_id;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemLocalDeviceClass</NAME>
struct _HildonFileSystemLocalDeviceClass
{
    HildonFileSystemSpecialLocationClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_local_device_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_SMB</NAME>
#define HILDON_TYPE_FILE_SYSTEM_SMB            (hildon_file_system_smb_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_SMB</NAME>
#define HILDON_FILE_SYSTEM_SMB(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), HILDON_TYPE_FILE_SYSTEM_SMB, HildonFileSystemSmb))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_SMB_CLASS</NAME>
#define HILDON_FILE_SYSTEM_SMB_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_SYSTEM_SMB, HildonFileSystemSmbClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_SMB</NAME>
#define HILDON_IS_FILE_SYSTEM_SMB(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HILDON_TYPE_FILE_SYSTEM_SMB))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_SMB_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_SMB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SYSTEM_SMB))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_SMB_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_SMB_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), HILDON_TYPE_FILE_SYSTEM_SMB, HildonFileSystemSmbClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemSmb</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemSmbClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemSmb</NAME>
struct _HildonFileSystemSmb
{
    HildonFileSystemRemoteDevice parent_instance;
    gint connected_handler_id;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemSmbClass</NAME>
struct _HildonFileSystemSmbClass
{
    HildonFileSystemRemoteDeviceClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_smb_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SELECTION</NAME>
#define HILDON_TYPE_FILE_SELECTION (hildon_file_selection_get_type())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SELECTION</NAME>
#define HILDON_FILE_SELECTION(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST (obj, HILDON_TYPE_FILE_SELECTION, HildonFileSelection))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SELECTION_CLASS</NAME>
#define HILDON_FILE_SELECTION_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SELECTION, \
  HildonFileSelectionClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SELECTION</NAME>
#define HILDON_IS_FILE_SELECTION(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE (obj, HILDON_TYPE_FILE_SELECTION))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SELECTION_CLASS</NAME>
#define HILDON_IS_FILE_SELECTION_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SELECTION))
</MACRO>
<ENUM>
<NAME>HildonFileSelectionMode</NAME>
    typedef enum {
    HILDON_FILE_SELECTION_MODE_LIST,
    HILDON_FILE_SELECTION_MODE_THUMBNAILS
} HildonFileSelectionMode;
</ENUM>
<ENUM>
<NAME>HildonFileSelectionSortKey</NAME>
typedef enum {
    HILDON_FILE_SELECTION_SORT_NAME = 0,
    HILDON_FILE_SELECTION_SORT_TYPE,
    HILDON_FILE_SELECTION_SORT_MODIFIED,
    HILDON_FILE_SELECTION_SORT_SIZE
} HildonFileSelectionSortKey;
</ENUM>
<ENUM>
<NAME>HildonFileSelectionPane</NAME>
typedef enum {
    HILDON_FILE_SELECTION_PANE_NAVIGATION = 0,
    HILDON_FILE_SELECTION_PANE_CONTENT
} HildonFileSelectionPane;
</ENUM>
<ENUM>
<NAME>HildonFileSelectionVisibleColumns</NAME>
typedef enum {
    HILDON_FILE_SELECTION_SHOW_NAME = 1,
    HILDON_FILE_SELECTION_SHOW_MODIFIED = 2,
    HILDON_FILE_SELECTION_SHOW_SIZE = 4,
    HILDON_FILE_SELECTION_SHOW_ALL = 7
} HildonFileSelectionVisibleColumns;
</ENUM>
<STRUCT>
<NAME>HildonFileSelection</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSelectionClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSelectionPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSelection</NAME>
struct _HildonFileSelection {
    GtkContainer parent;
    HildonFileSelectionPrivate *priv;
};

</STRUCT>
<STRUCT>
<NAME>HildonFileSelectionClass</NAME>
struct _HildonFileSelectionClass {
    GtkContainerClass parent_class;

    /* Application can hook the following signals to get informad about
       interesting events */
    void (*current_folder_changed) (HildonFileSelection * self);
    void (*file_activated) (HildonFileSelection * self);
    void (*selection_changed) (HildonFileSelection * self);
    void (*navigation_pane_context_menu) (HildonFileSelection * self);
    void (*content_pane_context_menu) (HildonFileSelection * self);
    void (*uris_dropped) (HildonFileSelection * self,
			  const char *destination, GSList * sources);
    void (*location_insensitive) (HildonFileSelection *self, GtkTreeIter *iter);
};

</STRUCT>
<FUNCTION>
<NAME>hildon_file_selection_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_new_with_model</NAME>
<RETURNS>GtkWidget *</RETURNS>
HildonFileSystemModel *model
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_set_empty_text</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection *file_selection,const gchar         *empty_text
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_set_mode</NAME>
<DEPRECATED/>
<RETURNS>void </RETURNS>
HildonFileSelection * self,HildonFileSelectionMode mode
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_mode</NAME>
<DEPRECATED/>
<RETURNS>HildonFileSelectionMode </RETURNS>
HildonFileSelection* self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_set_sort_key</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection * self,HildonFileSelectionSortKey key,GtkSortType order
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_sort_key</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection * self,HildonFileSelectionSortKey * key,GtkSortType * order
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_set_current_folder_uri</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSelection *self,const char *folder,GError ** error
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_current_folder_uri</NAME>
<RETURNS>char *</RETURNS>
HildonFileSelection *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_current_content_iter</NAME>
<DEPRECATED/>
<RETURNS>gboolean </RETURNS>
HildonFileSelection* self,GtkTreeIter *iter
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_current_folder_iter</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSelection* self,GtkTreeIter * iter
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_set_current_folder_iter</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection * self,GtkTreeIter * main_iter
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_active_content_iter</NAME>
<DEPRECATED/>
<RETURNS>gboolean </RETURNS>
HildonFileSelection*self, GtkTreeIter *iter
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_content_iter_is_selected</NAME>
<DEPRECATED/>
<RETURNS>gboolean </RETURNS>
HildonFileSelection *self,GtkTreeIter *iter
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_select_uri</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSelection *self,const char *uri,GError ** error
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_unselect_uri</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection *self,const char *uri
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_select_all</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_unselect_all</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_clear_multi_selection</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_selected_uris</NAME>
<RETURNS>GSList *</RETURNS>
HildonFileSelection *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_set_select_multiple</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection * self,gboolean select_multiple
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_select_multiple</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSelection *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_set_column_headers_visible</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection *self,gboolean visible
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_column_headers_visible</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSelection*self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_set_filter</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection * self,GtkFileFilter * filter
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_filter</NAME>
<RETURNS>GtkFileFilter *</RETURNS>
HildonFileSelection *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_dim_current_selection</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_undim_all</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_active_pane</NAME>
<RETURNS>HildonFileSelectionPane </RETURNS>
HildonFileSelection *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_hide_navigation_pane</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection * self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_hide_content_pane</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection * self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_show_content_pane</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection * self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_move_cursor_to_uri</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection *self,const gchar *uri
</FUNCTION>
<ENUM>
<NAME>HildonFileSystemModelItemType</NAME>
typedef enum {
    HILDON_FILE_SYSTEM_MODEL_UNKNOWN,
    HILDON_FILE_SYSTEM_MODEL_FILE,
    HILDON_FILE_SYSTEM_MODEL_FOLDER,
    HILDON_FILE_SYSTEM_MODEL_SAFE_FOLDER_IMAGES,
    HILDON_FILE_SYSTEM_MODEL_SAFE_FOLDER_VIDEOS,
    HILDON_FILE_SYSTEM_MODEL_SAFE_FOLDER_SOUNDS,
    HILDON_FILE_SYSTEM_MODEL_SAFE_FOLDER_DOCUMENTS,
    HILDON_FILE_SYSTEM_MODEL_SAFE_FOLDER_CAMERA,
    HILDON_FILE_SYSTEM_MODEL_MMC,
    HILDON_FILE_SYSTEM_MODEL_GATEWAY,
    HILDON_FILE_SYSTEM_MODEL_LOCAL_DEVICE
} HildonFileSystemModelItemType;
</ENUM>
<FUNCTION>
<NAME>hildon_file_system_create_backend</NAME>
<DEPRECATED/>
<RETURNS>GtkFileSystem *</RETURNS>
const gchar *name, gboolean use_fallback
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_DETAILS_DIALOG</NAME>
#define HILDON_TYPE_FILE_DETAILS_DIALOG \
  (hildon_file_details_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_DETAILS_DIALOG</NAME>
#define HILDON_FILE_DETAILS_DIALOG(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), HILDON_TYPE_FILE_DETAILS_DIALOG,\
   HildonFileDetailsDialog))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_DETAILS_DIALOG_CLASS</NAME>
#define HILDON_FILE_DETAILS_DIALOG_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_DETAILS_DIALOG,\
   HildonFileDetailsDialogClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_DETAILS_DIALOG</NAME>
#define HILDON_IS_FILE_DETAILS_DIALOG(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HILDON_TYPE_FILE_DETAILS_DIALOG))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_DETAILS_DIALOG_CLASS</NAME>
#define HILDON_IS_FILE_DETAILS_DIALOG_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_DETAILS_DIALOG))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_DETAILS_DIALOG_GET_CLASS</NAME>
#define HILDON_FILE_DETAILS_DIALOG_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), HILDON_TYPE_FILE_DETAILS_DIALOG,\
   HildonFileDetailsDialogClass))
</MACRO>
<STRUCT>
<NAME>HildonFileDetailsDialog</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileDetailsDialogPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileDetailsDialogClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileDetailsDialog</NAME>
struct _HildonFileDetailsDialog {
  GtkDialog parent;
  HildonFileDetailsDialogPrivate *priv;
};

</STRUCT>
<STRUCT>
<NAME>HildonFileDetailsDialogClass</NAME>
struct _HildonFileDetailsDialogClass {
  GtkDialogClass parent_class;
};

</STRUCT>
<FUNCTION>
<NAME>hildon_file_details_dialog_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_details_dialog_new</NAME>
<DEPRECATED/>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow * parent,const gchar * filename
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_details_dialog_new_with_model</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow *parent,HildonFileSystemModel *model
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_details_dialog_set_file_iter</NAME>
<RETURNS>void </RETURNS>
HildonFileDetailsDialog *self, GtkTreeIter *iter
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_details_dialog_get_file_iter</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileDetailsDialog *self, GtkTreeIter *iter
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_details_dialog_add_label_with_value</NAME>
<RETURNS>GtkWidget  *</RETURNS>
HildonFileDetailsDialog *dialog,const gchar             *label,const gchar             *value
</FUNCTION>
<FUNCTION>
<NAME>hildon_format_file_size_for_display</NAME>
<RETURNS>gchar  *</RETURNS>
gint64 size
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_ROOT</NAME>
#define HILDON_TYPE_FILE_SYSTEM_ROOT            (hildon_file_system_root_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_ROOT</NAME>
#define HILDON_FILE_SYSTEM_ROOT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), HILDON_TYPE_FILE_SYSTEM_ROOT, HildonFileSystemRoot))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_ROOT_CLASS</NAME>
#define HILDON_FILE_SYSTEM_ROOT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_SYSTEM_ROOT, HildonFileSystemRootClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_ROOT</NAME>
#define HILDON_IS_FILE_SYSTEM_ROOT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HILDON_TYPE_FILE_SYSTEM_ROOT))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_ROOT_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_ROOT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SYSTEM_ROOT))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_ROOT_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_ROOT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), HILDON_TYPE_FILE_SYSTEM_ROOT, HildonFileSystemRootClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemRoot</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemRootClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemRootPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemRoot</NAME>
struct _HildonFileSystemRoot
{
    HildonFileSystemSpecialLocation parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemRootClass</NAME>
struct _HildonFileSystemRootClass
{
    HildonFileSystemSpecialLocationClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_root_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>HildonFileSystemInfoHandle</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemInfo</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>HildonFileSystemInfoCallback</NAME>
<RETURNS>void </RETURNS>
HildonFileSystemInfoHandle *handle,
                                              HildonFileSystemInfo *info,
                                              const GError *error, gpointer data
</USER_FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_info_async_new</NAME>
<RETURNS>HildonFileSystemInfoHandle *</RETURNS>
const gchar *uri,HildonFileSystemInfoCallback callback, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_info_get_display_name</NAME>
<RETURNS>const gchar *</RETURNS>
HildonFileSystemInfo *info
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_info_get_icon</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
HildonFileSystemInfo *info, GtkWidget *ref_widget
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_info_get_icon_at_size</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
HildonFileSystemInfo *info,GtkWidget *ref_widget,gint size
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_info_async_cancel</NAME>
<RETURNS>void </RETURNS>
HildonFileSystemInfoHandle *handle
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_info_new</NAME>
<DEPRECATED/>
<RETURNS>HildonFileSystemInfo *</RETURNS>
const gchar *uri, GError **error
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_info_free</NAME>
<DEPRECATED/>
<RETURNS>void </RETURNS>
HildonFileSystemInfo *info
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_set_current_folder</NAME>
<DEPRECATED/>
<RETURNS>gboolean </RETURNS>
HildonFileSelection *self,const GtkFilePath *folder,GError **error
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_current_folder</NAME>
<RETURNS>GtkFilePath *</RETURNS>
HildonFileSelection *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_select_path</NAME>
<DEPRECATED/>
<RETURNS>gboolean </RETURNS>
HildonFileSelection *self,const GtkFilePath *path,GError **error
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_unselect_path</NAME>
<DEPRECATED/>
<RETURNS>void </RETURNS>
HildonFileSelection *self,const GtkFilePath *path
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_selected_paths</NAME>
<RETURNS>GSList *</RETURNS>
HildonFileSelection *self
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_UPNP</NAME>
#define HILDON_TYPE_FILE_SYSTEM_UPNP            (hildon_file_system_upnp_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_UPNP</NAME>
#define HILDON_FILE_SYSTEM_UPNP(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), HILDON_TYPE_FILE_SYSTEM_UPNP, HildonFileSystemUpnp))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_UPNP_CLASS</NAME>
#define HILDON_FILE_SYSTEM_UPNP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_SYSTEM_UPNP, HildonFileSystemUpnpClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_UPNP</NAME>
#define HILDON_IS_FILE_SYSTEM_UPNP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HILDON_TYPE_FILE_SYSTEM_UPNP))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_UPNP_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_UPNP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SYSTEM_UPNP))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_UPNP_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_UPNP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), HILDON_TYPE_FILE_SYSTEM_UPNP, HildonFileSystemUpnpClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemUpnp</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemUpnpClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemUpnp</NAME>
struct _HildonFileSystemUpnp
{
    HildonFileSystemRemoteDevice parent_instance;
    gint connected_handler_id;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemUpnpClass</NAME>
struct _HildonFileSystemUpnpClass
{
    HildonFileSystemRemoteDeviceClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_upnp_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_OBEX</NAME>
#define HILDON_TYPE_FILE_SYSTEM_OBEX            (hildon_file_system_obex_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_OBEX</NAME>
#define HILDON_FILE_SYSTEM_OBEX(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
                                                HILDON_TYPE_FILE_SYSTEM_OBEX, \
                                                HildonFileSystemObex))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_OBEX_CLASS</NAME>
#define HILDON_FILE_SYSTEM_OBEX_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), \
                                                HILDON_TYPE_FILE_SYSTEM_OBEX, \
                                                HildonFileSystemObexClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_OBEX</NAME>
#define HILDON_IS_FILE_SYSTEM_OBEX(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
                                                HILDON_TYPE_FILE_SYSTEM_OBEX))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_OBEX_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_OBEX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), \
                                                HILDON_TYPE_FILE_SYSTEM_OBEX))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_OBEX_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_OBEX_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
                                                HILDON_TYPE_FILE_SYSTEM_OBEX, \
                                                HildonFileSystemObexClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemObex</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemObexClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemObex</NAME>
struct _HildonFileSystemObex
{
    HildonFileSystemRemoteDevice parent_instance;
    gint bonding_handler_id;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemObexClass</NAME>
struct _HildonFileSystemObexClass
{
    HildonFileSystemRemoteDeviceClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_obex_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>TREE_ICON_SIZE</NAME>
#define TREE_ICON_SIZE 26 /* Left side icons */
</MACRO>
<FUNCTION>
<NAME>hildon_file_system_unescape_string</NAME>
<RETURNS>char *</RETURNS>
const char *escaped
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_MODEL</NAME>
#define HILDON_TYPE_FILE_SYSTEM_MODEL (hildon_file_system_model_get_type())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_MODEL</NAME>
#define HILDON_FILE_SYSTEM_MODEL(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST (obj, HILDON_TYPE_FILE_SYSTEM_MODEL, \
  HildonFileSystemModel))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_MODEL_CLASS</NAME>
#define HILDON_FILE_SYSTEM_MODEL_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_SYSTEM_MODEL, \
  HildonFileSystemModelClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_MODEL</NAME>
#define HILDON_IS_FILE_SYSTEM_MODEL(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE (obj, HILDON_TYPE_FILE_SYSTEM_MODEL))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_MODEL_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_MODEL_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SYSTEM_MODEL))
</MACRO>
<ENUM>
<NAME>HildonFileSystemModelColumns</NAME>
typedef enum {
    HILDON_FILE_SYSTEM_MODEL_COLUMN_GTK_PATH_INTERNAL = 0,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_LOCAL_PATH,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_URI,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_FILE_NAME,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_DISPLAY_NAME,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_SORT_KEY,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_MIME_TYPE,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_FILE_SIZE,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_FILE_TIME,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_IS_FOLDER,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_IS_AVAILABLE,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_IS_READONLY,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_HAS_LOCAL_PATH,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_TYPE,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_ICON,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_ICON_EXPANDED,  /* Normal icon with
                                                       expanded emblem */
    HILDON_FILE_SYSTEM_MODEL_COLUMN_ICON_COLLAPSED, /* Normal icon with 
                                                       collapsed emblem */
    HILDON_FILE_SYSTEM_MODEL_COLUMN_THUMBNAIL,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_LOAD_READY,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_FREE_SPACE, /* Only for devices */

    HILDON_FILE_SYSTEM_MODEL_COLUMN_TITLE,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_AUTHOR,

    HILDON_FILE_SYSTEM_MODEL_COLUMN_IS_HIDDEN,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_UNAVAILABLE_REASON,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_FAILED_ACCESS_MESSAGE,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_SORT_WEIGHT,
    HILDON_FILE_SYSTEM_MODEL_COLUMN_EXTRA_INFO,

    HILDON_FILE_SYSTEM_MODEL_COLUMN_IS_DRIVE,

    HILDON_FILE_SYSTEM_MODEL_COLUMN_ALBUM,

    HILDON_FILE_SYSTEM_MODEL_NUM_COLUMNS
} HildonFileSystemModelColumns;
</ENUM>
<USER_FUNCTION>
<NAME>HildonFileSystemModelThumbnailCallback</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *
                                                           uri,
                                                           const gchar *
                                                           path,
                                                           const gchar *
                                                           thumbnail_file
</USER_FUNCTION>
<STRUCT>
<NAME>HildonFileSystemModelPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemModel</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemModel</NAME>
struct _HildonFileSystemModel {
    GObject parent;
    HildonFileSystemModelPrivate *priv;
};

</STRUCT>
<STRUCT>
<NAME>HildonFileSystemModelClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemModelClass</NAME>
struct _HildonFileSystemModelClass {
    GObjectClass parent_class;

    void (*finished_loading) (HildonFileSystemModel *model, GtkTreeIter *iter);
    void (*device_disconnected) (HildonFileSystemModel *model, 
      GtkTreeIter *iter);
};

</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_model_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>hildon_file_system_model_create_backend</NAME>
#define hildon_file_system_model_create_backend hildon_file_system_create_backend
</MACRO>
<FUNCTION>
<NAME>hildon_file_system_model_finished_loading</NAME>
<DEPRECATED/>
<RETURNS>gboolean </RETURNS>
HildonFileSystemModel *model
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_model_search_local_path</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSystemModel *model,const gchar * path,GtkTreeIter * iter,GtkTreeIter *start_iter,gboolean recursive
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_model_search_uri</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSystemModel * model,const gchar * uri,GtkTreeIter * iter,GtkTreeIter * start_iter,gboolean recursive
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_model_search_path</NAME>
<DEPRECATED/>
<RETURNS>gboolean </RETURNS>
HildonFileSystemModel *model,const GtkFilePath * path,GtkTreeIter * iter,GtkTreeIter * start_iter,gboolean recursive
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_model_load_local_path</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSystemModel * model,const gchar * path,GtkTreeIter * iter
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_model_load_uri</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSystemModel * model,const gchar * uri,GtkTreeIter * iter
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_model_load_path</NAME>
<DEPRECATED/>
<RETURNS>gboolean </RETURNS>
HildonFileSystemModel * model,const GtkFilePath * path,GtkTreeIter * iter
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_model_new_item</NAME>
<RETURNS>gchar *</RETURNS>
HildonFileSystemModel * model,GtkTreeIter * parent,const gchar * stub_name,const gchar * extension
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_model_autoname_uri</NAME>
<RETURNS>gchar *</RETURNS>
HildonFileSystemModel *model,const gchar *uri, GError **error
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_model_iter_available</NAME>
<RETURNS>void </RETURNS>
HildonFileSystemModel *model,GtkTreeIter *iter, gboolean available
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_model_reset_available</NAME>
<RETURNS>void </RETURNS>
HildonFileSystemModel *model
</FUNCTION>
<FUNCTION>
<NAME>rescan_local_device_folders</NAME>
<RETURNS>void </RETURNS>
HildonFileSystemModel *model
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_DYNAMIC_DEVICE</NAME>
#define HILDON_TYPE_FILE_SYSTEM_DYNAMIC_DEVICE            (hildon_file_system_dynamic_device_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_DYNAMIC_DEVICE</NAME>
#define HILDON_FILE_SYSTEM_DYNAMIC_DEVICE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), HILDON_TYPE_FILE_SYSTEM_DYNAMIC_DEVICE, HildonFileSystemDynamicDevice))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_DYNAMIC_DEVICE_CLASS</NAME>
#define HILDON_FILE_SYSTEM_DYNAMIC_DEVICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_SYSTEM_DYNAMIC_DEVICE, HildonFileSystemDynamicDeviceClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_DYNAMIC_DEVICE</NAME>
#define HILDON_IS_FILE_SYSTEM_DYNAMIC_DEVICE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HILDON_TYPE_FILE_SYSTEM_DYNAMIC_DEVICE))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_DYNAMIC_DEVICE_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_DYNAMIC_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SYSTEM_DYNAMIC_DEVICE))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_DYNAMIC_DEVICE_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_DYNAMIC_DEVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), HILDON_TYPE_FILE_SYSTEM_DYNAMIC_DEVICE, HildonFileSystemDynamicDeviceClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemDynamicDevice</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemDynamicDeviceClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemDynamicDevice</NAME>
struct _HildonFileSystemDynamicDevice
{
    HildonFileSystemRemoteDevice parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemDynamicDeviceClass</NAME>
struct _HildonFileSystemDynamicDeviceClass
{
    HildonFileSystemRemoteDeviceClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_dynamic_device_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_mode_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SELECTION_MODE</NAME>
#define HILDON_TYPE_FILE_SELECTION_MODE (hildon_file_selection_mode_get_type())
</MACRO>
<FUNCTION>
<NAME>hildon_file_selection_sort_key_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SELECTION_SORT_KEY</NAME>
#define HILDON_TYPE_FILE_SELECTION_SORT_KEY (hildon_file_selection_sort_key_get_type())
</MACRO>
<FUNCTION>
<NAME>hildon_file_selection_pane_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SELECTION_PANE</NAME>
#define HILDON_TYPE_FILE_SELECTION_PANE (hildon_file_selection_pane_get_type())
</MACRO>
<FUNCTION>
<NAME>hildon_file_selection_visible_columns_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SELECTION_VISIBLE_COLUMNS</NAME>
#define HILDON_TYPE_FILE_SELECTION_VISIBLE_COLUMNS (hildon_file_selection_visible_columns_get_type())
</MACRO>
<FUNCTION>
<NAME>hildon_file_system_model_columns_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_MODEL_COLUMNS</NAME>
#define HILDON_TYPE_FILE_SYSTEM_MODEL_COLUMNS (hildon_file_system_model_columns_get_type())
</MACRO>
<FUNCTION>
<NAME>hildon_file_system_model_item_type_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_MODEL_ITEM_TYPE</NAME>
#define HILDON_TYPE_FILE_SYSTEM_MODEL_ITEM_TYPE (hildon_file_system_model_item_type_get_type())
</MACRO>
<FUNCTION>
<NAME>voldev_t_voldev_t_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_VOLDEV_T</NAME>
#define HILDON_TYPE_VOLDEV_T (voldev_t_voldev_t_get_type())
</MACRO>
<MACRO>
<NAME>HILDON_TYPE_FILE_CHOOSER_DIALOG</NAME>
#define HILDON_TYPE_FILE_CHOOSER_DIALOG \
  ( hildon_file_chooser_dialog_get_type() )
</MACRO>
<MACRO>
<NAME>HILDON_FILE_CHOOSER_DIALOG</NAME>
#define HILDON_FILE_CHOOSER_DIALOG(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST (obj, HILDON_TYPE_FILE_CHOOSER_DIALOG,\
   HildonFileChooserDialog))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_CHOOSER_DIALOG_CLASS</NAME>
#define HILDON_FILE_CHOOSER_DIALOG_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_CHOOSER_DIALOG, \
  HildonFileChooserDialogClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_CHOOSER_DIALOG</NAME>
#define HILDON_IS_FILE_CHOOSER_DIALOG(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE (obj, HILDON_TYPE_FILE_CHOOSER_DIALOG))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_CHOOSER_DIALOG_CLASS</NAME>
#define HILDON_IS_FILE_CHOOSER_DIALOG_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_CHOOSER_DIALOG))
</MACRO>
<STRUCT>
<NAME>HildonFileChooserDialog</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileChooserDialogClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileChooserDialog</NAME>
struct _HildonFileChooserDialog {
    GtkDialog parent;
    HildonFileChooserDialogPrivate *priv;
};

</STRUCT>
<STRUCT>
<NAME>HildonFileChooserDialogClass</NAME>
struct _HildonFileChooserDialogClass {
    GtkDialogClass parent_class;
};

</STRUCT>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow * parent,GtkFileChooserAction action
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_new_with_properties</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow *parent,const gchar *first_property,...
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_focus_to_input</NAME>
<RETURNS>void </RETURNS>
HildonFileChooserDialog *d
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_set_safe_folder</NAME>
<RETURNS>void </RETURNS>
HildonFileChooserDialog *self, const gchar *local_path
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_set_safe_folder_uri</NAME>
<RETURNS>void </RETURNS>
HildonFileChooserDialog *self, const gchar *uri
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_get_safe_folder</NAME>
<RETURNS>gchar *</RETURNS>
HildonFileChooserDialog *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_get_safe_folder_uri</NAME>
<RETURNS>gchar *</RETURNS>
HildonFileChooserDialog *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_set_show_upnp</NAME>
<RETURNS>void     </RETURNS>
HildonFileChooserDialog *self, gboolean value
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_get_show_upnp</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileChooserDialog *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_add_extra</NAME>
<RETURNS>void </RETURNS>
HildonFileChooserDialog *self,GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_add_extensions_combo</NAME>
<RETURNS>GtkWidget  *</RETURNS>
HildonFileChooserDialog *self,char **extensions,char **ext_names
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_get_extension</NAME>
<RETURNS>gchar *</RETURNS>
HildonFileChooserDialog *self
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_chooser_dialog_set_extension</NAME>
<RETURNS>void </RETURNS>
HildonFileChooserDialog *self,const gchar *extension
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_SPECIAL_LOCATION</NAME>
#define HILDON_TYPE_FILE_SYSTEM_SPECIAL_LOCATION \
        (hildon_file_system_special_location_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_SPECIAL_LOCATION</NAME>
#define HILDON_FILE_SYSTEM_SPECIAL_LOCATION(obj) \
        (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
         HILDON_TYPE_FILE_SYSTEM_SPECIAL_LOCATION, \
         HildonFileSystemSpecialLocation))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_SPECIAL_LOCATION_CLASS</NAME>
#define HILDON_FILE_SYSTEM_SPECIAL_LOCATION_CLASS(klass) \
        (G_TYPE_CHECK_CLASS_CAST ((klass), \
         HILDON_TYPE_FILE_SYSTEM_SPECIAL_LOCATION, \
         HildonFileSystemSpecialLocationClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_SPECIAL_LOCATION</NAME>
#define HILDON_IS_FILE_SYSTEM_SPECIAL_LOCATION(obj) \
        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
         HILDON_TYPE_FILE_SYSTEM_SPECIAL_LOCATION))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_SPECIAL_LOCATION_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_SPECIAL_LOCATION_CLASS(klass) \
        (G_TYPE_CHECK_CLASS_TYPE ((klass), \
         HILDON_TYPE_FILE_SYSTEM_SPECIAL_LOCATION))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_SPECIAL_LOCATION_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_SPECIAL_LOCATION_GET_CLASS(obj) \
        (G_TYPE_INSTANCE_GET_CLASS ((obj), \
         HILDON_TYPE_FILE_SYSTEM_SPECIAL_LOCATION, \
         HildonFileSystemSpecialLocationClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemSpecialLocation</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemSpecialLocation</NAME>
struct _HildonFileSystemSpecialLocation
{
    GObject parent_instance;
    gchar *basepath;    /* Path as uri */
    gchar *fixed_icon;  /* Icon name as string. NULL for no fixed icon */
    gchar *fixed_title; /* Text for fixed display name as string */
    const gchar *failed_access_message; /* Default failed accessa message */
    gint  sort_weight;  /* How the location behaves while sorting */
    HildonFileSystemModelItemType compatibility_type; /* For backwards compatibility */
    gboolean permanent;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemSpecialLocationClass</NAME>
struct _HildonFileSystemSpecialLocationClass
{
  GObjectClass parent_class;

  #ifndef HILDON_DISABLE_DEPRECATED
  /* private */
  gchar* (*get_display_name) (HildonFileSystemSpecialLocation *location, GtkFileSystem *fs);
  gchar* (*get_extra_info) (HildonFileSystemSpecialLocation *location);
  GdkPixbuf* (*get_icon) (HildonFileSystemSpecialLocation *location,
			  GtkFileSystem *fs, GtkWidget *ref_widget, int size);
  gboolean (*is_available) (HildonFileSystemSpecialLocation *location);
  gboolean (*is_visible) (HildonFileSystemSpecialLocation *location,
			  gboolean has_children);
  gchar* (*get_unavailable_reason) (HildonFileSystemSpecialLocation *location);
  gboolean (*requires_access) (HildonFileSystemSpecialLocation *location);
  gboolean (*failed_access) (HildonFileSystemSpecialLocation *location);
  HildonFileSystemSpecialLocation* (*create_child_location) (HildonFileSystemSpecialLocation *location, gchar *uri);
  void (*volumes_changed) (HildonFileSystemSpecialLocation *location,
                             GtkFileSystem *fs);

  GtkFileSystemHandle * (*get_folder)  (HildonFileSystemSpecialLocation *location,
					GtkFileSystem                  *file_system,
					const GtkFilePath              *path,
					GtkFileInfoType                 types,
					GtkFileSystemGetFolderCallback  callback,
					gpointer                        data);

  GtkFilePath *(*rewrite_path) (HildonFileSystemSpecialLocation *location,
				GtkFileSystem                  *file_system,
				const GtkFilePath              *path);

  /* signals */
  void (*changed) (GObject *obj);
  void (*connection_state) (GObject *obj);
  void (*rescan) (GObject *obj);
  #endif
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_special_location_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_get_display_name</NAME>
<DEPRECATED/>
<RETURNS>gchar *</RETURNS>
HildonFileSystemSpecialLocation *location, GtkFileSystem *fs
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_get_extra_info</NAME>
<RETURNS>gchar *</RETURNS>
HildonFileSystemSpecialLocation *location
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_get_icon</NAME>
<DEPRECATED/>
<RETURNS>GdkPixbuf *</RETURNS>
HildonFileSystemSpecialLocation *location, GtkFileSystem *fs, GtkWidget *ref_widget, int size
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_is_available</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSystemSpecialLocation *location
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_is_visible</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSystemSpecialLocation *location, gboolean has_children
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_get_unavailable_reason</NAME>
<RETURNS>gchar *</RETURNS>
HildonFileSystemSpecialLocation *location
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_requires_access</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSystemSpecialLocation *location
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_failed_access</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSystemSpecialLocation *location
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_create_child_location</NAME>
<RETURNS>HildonFileSystemSpecialLocation  *</RETURNS>
HildonFileSystemSpecialLocation *location, gchar *uri
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_volumes_changed</NAME>
<DEPRECATED/>
<RETURNS>void </RETURNS>
HildonFileSystemSpecialLocation *location, GtkFileSystem *fs
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_get_folder</NAME>
<DEPRECATED/>
<RETURNS>GtkFileSystemHandle  *</RETURNS>
HildonFileSystemSpecialLocation *location,GtkFileSystem                  *file_system,const GtkFilePath              *path,GtkFileInfoType                 types,GtkFileSystemGetFolderCallback  callback,gpointer                        data
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_set_display_name</NAME>
<RETURNS>void </RETURNS>
HildonFileSystemSpecialLocation *location, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_set_icon</NAME>
<RETURNS>void </RETURNS>
HildonFileSystemSpecialLocation *location, const gchar *icon_name
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_rewrite_path</NAME>
<DEPRECATED/>
<RETURNS>GtkFilePath *</RETURNS>
HildonFileSystemSpecialLocation *location,GtkFileSystem                  *file_system,const GtkFilePath              *path
</FUNCTION>
<MACRO>
<NAME>_</NAME>
#define _(String) dgettext("hildon-fm", String)
</MACRO>
<MACRO>
<NAME>N_</NAME>
#define N_(String) String
</MACRO>
<MACRO>
<NAME>HCS</NAME>
#define HCS(String) dgettext("hildon-common-strings", String)
</MACRO>
<MACRO>
<NAME>KE</NAME>
#define KE(String) dgettext("ke-recv", String)
</MACRO>
<MACRO>
<NAME>FM</NAME>
#define FM(String) dgettext("osso-filemanager", String)
</MACRO>
<MACRO>
<NAME>MAX_FILENAME_LENGTH_DEFAULT</NAME>
#define MAX_FILENAME_LENGTH_DEFAULT 255
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_FILE</NAME>
#define SORT_WEIGHT_FILE   10
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_FOLDER</NAME>
#define SORT_WEIGHT_FOLDER -10
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_DEVICE</NAME>
#define SORT_WEIGHT_DEVICE        -20
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_INTERNAL_MMC</NAME>
#define SORT_WEIGHT_INTERNAL_MMC  -19
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_EXTERNAL_MMC</NAME>
#define SORT_WEIGHT_EXTERNAL_MMC  -18
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_USB</NAME>
#define SORT_WEIGHT_USB           -17
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_REMOTE_DEVICE</NAME>
#define SORT_WEIGHT_REMOTE_DEVICE -16
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_OBEX</NAME>
#define SORT_WEIGHT_OBEX          -15
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_SMB</NAME>
#define SORT_WEIGHT_SMB           -14
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_UPNP</NAME>
#define SORT_WEIGHT_UPNP          -13
</MACRO>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_VOLDEV</NAME>
#define HILDON_TYPE_FILE_SYSTEM_VOLDEV            (hildon_file_system_voldev_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_VOLDEV</NAME>
#define HILDON_FILE_SYSTEM_VOLDEV(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), HILDON_TYPE_FILE_SYSTEM_VOLDEV, HildonFileSystemVoldev))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_VOLDEV_CLASS</NAME>
#define HILDON_FILE_SYSTEM_VOLDEV_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_SYSTEM_VOLDEV, HildonFileSystemVoldevClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_VOLDEV</NAME>
#define HILDON_IS_FILE_SYSTEM_VOLDEV(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HILDON_TYPE_FILE_SYSTEM_VOLDEV))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_VOLDEV_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_VOLDEV_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SYSTEM_VOLDEV))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_VOLDEV_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_VOLDEV_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), HILDON_TYPE_FILE_SYSTEM_VOLDEV, HildonFileSystemVoldevClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemVoldev</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemVoldevClass</NAME>
</STRUCT>
<ENUM>
<NAME>voldev_t</NAME>
typedef enum
{
  EXT_CARD,
  INT_CARD,
  USB_STORAGE
} voldev_t;
</ENUM>
<STRUCT>
<NAME>HildonFileSystemVoldev</NAME>
struct _HildonFileSystemVoldev
{
  HildonFileSystemSpecialLocation parent_instance;
  GnomeVFSVolume *volume;
  GnomeVFSDrive *drive;
  gboolean used_over_usb;
  voldev_t vol_type;
  gboolean vol_type_valid;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemVoldevClass</NAME>
struct _HildonFileSystemVoldevClass
{
    HildonFileSystemRemoteDeviceClass parent_class;
    GConfClient *gconf;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_voldev_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>find_volume</NAME>
<RETURNS>GnomeVFSVolume *</RETURNS>
const char *uri
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_voldev_is_visible</NAME>
<RETURNS>gboolean </RETURNS>
HildonFileSystemSpecialLocation *location,gboolean has_children
</FUNCTION>
<MACRO>
<NAME>HILDON_TYPE_FILE_SYSTEM_REMOTE_DEVICE</NAME>
#define HILDON_TYPE_FILE_SYSTEM_REMOTE_DEVICE            (hildon_file_system_remote_device_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_REMOTE_DEVICE</NAME>
#define HILDON_FILE_SYSTEM_REMOTE_DEVICE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), HILDON_TYPE_FILE_SYSTEM_REMOTE_DEVICE, HildonFileSystemRemoteDevice))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_REMOTE_DEVICE_CLASS</NAME>
#define HILDON_FILE_SYSTEM_REMOTE_DEVICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_SYSTEM_REMOTE_DEVICE, HildonFileSystemRemoteDeviceClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_REMOTE_DEVICE</NAME>
#define HILDON_IS_FILE_SYSTEM_REMOTE_DEVICE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HILDON_TYPE_FILE_SYSTEM_REMOTE_DEVICE))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_REMOTE_DEVICE_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_REMOTE_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SYSTEM_REMOTE_DEVICE))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_REMOTE_DEVICE_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_REMOTE_DEVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), HILDON_TYPE_FILE_SYSTEM_REMOTE_DEVICE, HildonFileSystemRemoteDeviceClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemRemoteDevice</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemRemoteDevice</NAME>
struct _HildonFileSystemRemoteDevice
{
    HildonFileSystemSpecialLocation parent_instance;

    /* private */
    gulong signal_handler_id;
    gboolean accessible;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemRemoteDeviceClass</NAME>
struct _HildonFileSystemRemoteDeviceClass
{
    HildonFileSystemSpecialLocationClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_remote_device_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkQuery</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngine</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_FILE_CHOOSER_GET_IFACE</NAME>
#define GTK_FILE_CHOOSER_GET_IFACE(inst)  (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_FILE_CHOOSER, GtkFileChooserIface))
</MACRO>
<STRUCT>
<NAME>GtkFileChooserIface</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFileChooserIface</NAME>
struct _GtkFileChooserIface
{
  GTypeInterface base_iface;

  /* Methods
   */
  gboolean       (*set_current_folder) 	   (GtkFileChooser    *chooser,
					    GFile             *file,
					    GError           **error);
  GFile *        (*get_current_folder) 	   (GtkFileChooser    *chooser);
  void           (*set_current_name)   	   (GtkFileChooser    *chooser,
					    const gchar       *name);
  gboolean       (*select_file)        	   (GtkFileChooser    *chooser,
					    GFile             *file,
					    GError           **error);
  void           (*unselect_file)      	   (GtkFileChooser    *chooser,
					    GFile             *file);
  void           (*select_all)         	   (GtkFileChooser    *chooser);
  void           (*unselect_all)       	   (GtkFileChooser    *chooser);
  GSList *       (*get_files)          	   (GtkFileChooser    *chooser);
  GFile *        (*get_preview_file)   	   (GtkFileChooser    *chooser);
  GtkFileSystem *(*get_file_system)    	   (GtkFileChooser    *chooser);
  void           (*add_filter)         	   (GtkFileChooser    *chooser,
					    GtkFileFilter     *filter);
  void           (*remove_filter)      	   (GtkFileChooser    *chooser,
					    GtkFileFilter     *filter);
  GSList *       (*list_filters)       	   (GtkFileChooser    *chooser);
  gboolean       (*add_shortcut_folder)    (GtkFileChooser    *chooser,
					    GFile             *file,
					    GError           **error);
  gboolean       (*remove_shortcut_folder) (GtkFileChooser    *chooser,
					    GFile             *file,
					    GError           **error);
  GSList *       (*list_shortcut_folders)  (GtkFileChooser    *chooser);
  
  /* Signals
   */
  void (*current_folder_changed) (GtkFileChooser *chooser);
  void (*selection_changed)      (GtkFileChooser *chooser);
  void (*update_preview)         (GtkFileChooser *chooser);
  void (*file_activated)         (GtkFileChooser *chooser);
  GtkFileChooserConfirmation (*confirm_overwrite) (GtkFileChooser *chooser);
};
</STRUCT>
<STRUCT>
<NAME>FileModelNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFileSystemModel</NAME>
struct _GtkFileSystemModel
{
  GObject parent_instance;

  GtkFileSystem  *file_system;
  GtkFileInfoType types;
  FileModelNode  *roots;
  GtkFileFolder  *root_folder;
  GtkFilePath    *root_path;

  GtkFileSystemModelFilter filter_func;
  gpointer filter_data;

  GSList *idle_clears;
  GSource *idle_clear_source;

  gushort max_depth;

  GSList *pending_handles;
  
  guint show_hidden : 1;
  guint show_folders : 1;
  guint show_files : 1;
  guint folders_only : 1;
  guint has_editable : 1;
};
</STRUCT>
<STRUCT>
<NAME>FileModelNode</NAME>
struct _FileModelNode
{
  GtkFilePath *path;
  FileModelNode *next;

  GtkFileInfo *info;
  GtkFileFolder *folder;
  
  FileModelNode *children;
  FileModelNode *parent;
  GtkFileSystemModel *model;

  guint ref_count;
  guint n_referenced_children;

  gushort depth;

  guint has_dummy : 1;
  guint is_dummy : 1;
  guint is_visible : 1;
  guint loaded : 1;
  guint idle_clear : 1;
  guint load_pending : 1;
};
</STRUCT>
<TYPEDEF>
<NAME>GtkFileTime</NAME>
typedef gint64 GtkFileTime;
</TYPEDEF>
<STRUCT>
<NAME>GtkFileFolder</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFileFolderIface</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFileInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFileSystem</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFileSystemIface</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFileSystemVolume</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFilePath</NAME>
</STRUCT>
<ENUM>
<NAME>GtkFileInfoType</NAME>
typedef enum {
  GTK_FILE_INFO_DISPLAY_NAME      = 1 << 0,
  GTK_FILE_INFO_IS_FOLDER         = 1 << 1,
  GTK_FILE_INFO_IS_HIDDEN         = 1 << 2,
  GTK_FILE_INFO_MIME_TYPE         = 1 << 3,
  GTK_FILE_INFO_MODIFICATION_TIME = 1 << 4,
  GTK_FILE_INFO_SIZE              = 1 << 5,
  GTK_FILE_INFO_ICON              = 1 << 6,
  GTK_FILE_INFO_ALL               = (1 << 7) - 1
} GtkFileInfoType;
</ENUM>
<MACRO>
<NAME>GTK_FILE_SYSTEM_ERROR</NAME>
#define GTK_FILE_SYSTEM_ERROR (gtk_file_system_error_quark ())
</MACRO>
<ENUM>
<NAME>GtkFileSystemError</NAME>
typedef enum
{
  GTK_FILE_SYSTEM_ERROR_NONEXISTENT,
  GTK_FILE_SYSTEM_ERROR_NOT_FOLDER,
  GTK_FILE_SYSTEM_ERROR_INVALID_URI,
  GTK_FILE_SYSTEM_ERROR_BAD_FILENAME,
  GTK_FILE_SYSTEM_ERROR_FAILED,
  GTK_FILE_SYSTEM_ERROR_ALREADY_EXISTS
#ifdef MAEMO_CHANGES
  , GTK_FILE_SYSTEM_ERROR_TIMEOUT
#endif /* MAEMO_CHANGES */
} GtkFileSystemError;
</ENUM>
<FUNCTION>
<NAME>gtk_file_system_error_quark</NAME>
<RETURNS>GQuark     </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FILE_INFO</NAME>
#define GTK_TYPE_FILE_INFO (gtk_file_info_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_file_info_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_new</NAME>
<RETURNS>GtkFileInfo *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_copy</NAME>
<RETURNS>GtkFileInfo *</RETURNS>
GtkFileInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_free</NAME>
<RETURNS>void         </RETURNS>
GtkFileInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_get_display_name</NAME>
<RETURNS>G_CONST_RETURN gchar *</RETURNS>
const GtkFileInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_get_display_key</NAME>
<RETURNS>G_CONST_RETURN gchar *</RETURNS>
const GtkFileInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_set_display_name</NAME>
<RETURNS>void                  </RETURNS>
GtkFileInfo       *info,const gchar       *display_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_get_is_folder</NAME>
<RETURNS>gboolean              </RETURNS>
const GtkFileInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_set_is_folder</NAME>
<RETURNS>void                  </RETURNS>
GtkFileInfo       *info,gboolean           is_folder
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_get_is_hidden</NAME>
<RETURNS>gboolean              </RETURNS>
const GtkFileInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_set_is_hidden</NAME>
<RETURNS>void                  </RETURNS>
GtkFileInfo       *info,gboolean           is_hidden
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_get_mime_type</NAME>
<RETURNS>G_CONST_RETURN gchar *</RETURNS>
const GtkFileInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_set_mime_type</NAME>
<RETURNS>void                  </RETURNS>
GtkFileInfo       *info,const gchar       *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_get_modification_time</NAME>
<RETURNS>GtkFileTime           </RETURNS>
const GtkFileInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_set_modification_time</NAME>
<RETURNS>void                  </RETURNS>
GtkFileInfo       *info,GtkFileTime        modification_time
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_get_size</NAME>
<RETURNS>gint64                </RETURNS>
const GtkFileInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_set_size</NAME>
<RETURNS>void                  </RETURNS>
GtkFileInfo       *info,gint64             size
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_set_icon_name</NAME>
<RETURNS>void                  </RETURNS>
GtkFileInfo       *info,const gchar       *con_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_get_icon_name</NAME>
<RETURNS>G_CONST_RETURN gchar *</RETURNS>
const GtkFileInfo *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_render_icon</NAME>
<RETURNS>GdkPixbuf            *</RETURNS>
const GtkFileInfo *info,GtkWidget         *widget,gint               pixel_size,GError           **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_info_set_icon_pixbuf</NAME>
<RETURNS>void                  </RETURNS>
GtkFileInfo *info,GdkPixbuf   *icon_pixbuf
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FILE_SYSTEM_HANDLE</NAME>
#define GTK_TYPE_FILE_SYSTEM_HANDLE            (gtk_file_system_handle_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_HANDLE</NAME>
#define GTK_FILE_SYSTEM_HANDLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_SYSTEM_HANDLE, GtkFileSystemHandle))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_SYSTEM_HANDLE</NAME>
#define GTK_IS_FILE_SYSTEM_HANDLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_SYSTEM_HANDLE))
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_HANDLE_CLASS</NAME>
#define GTK_FILE_SYSTEM_HANDLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_SYSTEM_HANDLE, GtkFileSystemHandleUnixClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_SYSTEM_HANDLE_CLASS</NAME>
#define GTK_IS_FILE_SYSTEM_HANDLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_SYSTEM_HANDLE))
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_HANDLE_GET_CLASS</NAME>
#define GTK_FILE_SYSTEM_HANDLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_SYSTEM_HANDLE, GtkFileSystemHandleClass))
</MACRO>
<STRUCT>
<NAME>GtkFileSystemHandle</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFileSystemHandleClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFileSystemHandle</NAME>
struct _GtkFileSystemHandle
{
  GObject parent_instance;

  GtkFileSystem *file_system;

  guint cancelled : 1;
};
</STRUCT>
<STRUCT>
<NAME>GtkFileSystemHandleClass</NAME>
struct _GtkFileSystemHandleClass
{
  GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_file_system_handle_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FILE_SYSTEM</NAME>
#define GTK_TYPE_FILE_SYSTEM             (gtk_file_system_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM</NAME>
#define GTK_FILE_SYSTEM(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_SYSTEM, GtkFileSystem))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_SYSTEM</NAME>
#define GTK_IS_FILE_SYSTEM(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_SYSTEM))
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_GET_IFACE</NAME>
#define GTK_FILE_SYSTEM_GET_IFACE(inst)  (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_FILE_SYSTEM, GtkFileSystemIface))
</MACRO>
<USER_FUNCTION>
<NAME>GtkFileSystemGetInfoCallback</NAME>
<RETURNS>void </RETURNS>
GtkFileSystemHandle *handle,
					       const GtkFileInfo   *file_info,
					       const GError        *error,
					       gpointer             data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkFileSystemGetFolderCallback</NAME>
<RETURNS>void </RETURNS>
GtkFileSystemHandle *handle,
						 GtkFileFolder       *folder,
						 const GError        *error,
						 gpointer             data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkFileSystemCreateFolderCallback</NAME>
<RETURNS>void </RETURNS>
GtkFileSystemHandle *handle,
						    const GtkFilePath   *path,
						    const GError        *error,
						    gpointer             data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkFileSystemVolumeMountCallback</NAME>
<RETURNS>void </RETURNS>
GtkFileSystemHandle *handle,
						   GtkFileSystemVolume *volume,
						   const GError        *error,
						   gpointer             data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkFileSystemIface</NAME>
struct _GtkFileSystemIface
{
  GTypeInterface base_iface;

  /* Methods
   */
  GSList *              (*list_volumes)        (GtkFileSystem     *file_system);
  GtkFileSystemVolume * (*get_volume_for_path) (GtkFileSystem     *file_system,
						const GtkFilePath *path);

  GtkFileSystemHandle * (*get_folder)  (GtkFileSystem                  *file_system,
					const GtkFilePath              *path,
					GtkFileInfoType                 types,
					GtkFileSystemGetFolderCallback  callback,
					gpointer                        data);
  GtkFileSystemHandle * (*get_info) (GtkFileSystem                *file_system,
				     const GtkFilePath            *path,
				     GtkFileInfoType               types,
				     GtkFileSystemGetInfoCallback  callback,
				     gpointer                      data);
  GtkFileSystemHandle * (*create_folder)  (GtkFileSystem                     *file_system,
					   const GtkFilePath                 *path,
					   GtkFileSystemCreateFolderCallback  callback,
					   gpointer                           data);

  void               (*cancel_operation) (GtkFileSystemHandle *handle);

  /* Volumes
   */
  void          (*volume_free)             (GtkFileSystem        *file_system,
					    GtkFileSystemVolume  *volume);
  GtkFilePath * (*volume_get_base_path)    (GtkFileSystem        *file_system,
					    GtkFileSystemVolume  *volume);
  gboolean      (*volume_get_is_mounted)   (GtkFileSystem        *file_system,
					    GtkFileSystemVolume  *volume);
  GtkFileSystemHandle * (*volume_mount)    (GtkFileSystem                    *file_system,
					    GtkFileSystemVolume              *volume,
					    GtkFileSystemVolumeMountCallback  callback,
					    gpointer                          data);
  char *        (*volume_get_display_name) (GtkFileSystem        *file_system,
					    GtkFileSystemVolume  *volume);
  gchar *       (*volume_get_icon_name)    (GtkFileSystem        *file_system,
					    GtkFileSystemVolume  *volume,
					    GError              **error);

  /* Path Manipulation
   */
  gboolean      (*get_parent)      (GtkFileSystem      *file_system,
				    const GtkFilePath  *path,
				    GtkFilePath       **parent,
				    GError            **error);
  GtkFilePath * (*make_path)        (GtkFileSystem     *file_system,
				     const GtkFilePath *base_path,
				     const gchar       *display_name,
				     GError           **error);
  gboolean      (*parse)            (GtkFileSystem     *file_system,
				     const GtkFilePath *base_path,
				     const gchar       *str,
				     GtkFilePath      **folder,
				     gchar            **file_part,
				     GError           **error);
  gchar *      (*path_to_uri)      (GtkFileSystem      *file_system,
				    const GtkFilePath  *path);
  gchar *      (*path_to_filename) (GtkFileSystem      *file_system,
				    const GtkFilePath  *path);
  GtkFilePath *(*uri_to_path)      (GtkFileSystem      *file_system,
				    const gchar        *uri);
  GtkFilePath *(*filename_to_path) (GtkFileSystem      *file_system,
				    const gchar        *path);

  /* Bookmarks 
   */
  gboolean       (*insert_bookmark)        (GtkFileSystem     *file_system,
					    const GtkFilePath *path,
					    gint               position,
					    GError           **error);
  gboolean       (*remove_bookmark)        (GtkFileSystem     *file_system,
					    const GtkFilePath *path,
					    GError           **error);
  GSList *       (*list_bookmarks)         (GtkFileSystem     *file_system);

  /* Signals 
   */
  void (*volumes_changed)   (GtkFileSystem *file_system);
  void (*bookmarks_changed) (GtkFileSystem *file_system);

  /* Bookmark labels 
   */
  gchar *        (*get_bookmark_label)     (GtkFileSystem     *file_system,
					    const GtkFilePath *path);
  void           (*set_bookmark_label)     (GtkFileSystem     *file_system,
					    const GtkFilePath *path,
					    const gchar       *label);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_file_system_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_list_volumes</NAME>
<RETURNS>GSList *</RETURNS>
GtkFileSystem     *file_system
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_get_volume_for_path</NAME>
<RETURNS>GtkFileSystemVolume *</RETURNS>
GtkFileSystem     *file_system,const GtkFilePath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_volume_free</NAME>
<RETURNS>void              </RETURNS>
GtkFileSystem        *file_system,GtkFileSystemVolume  *volume
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_volume_get_base_path</NAME>
<RETURNS>GtkFilePath *</RETURNS>
GtkFileSystem        *file_system,GtkFileSystemVolume  *volume
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_volume_get_is_mounted</NAME>
<RETURNS>gboolean          </RETURNS>
GtkFileSystem        *file_system,GtkFileSystemVolume  *volume
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_volume_mount</NAME>
<RETURNS>GtkFileSystemHandle *</RETURNS>
GtkFileSystem                    *file_system,GtkFileSystemVolume              *volume,GtkFileSystemVolumeMountCallback  callback,gpointer                          data
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_volume_get_display_name</NAME>
<RETURNS>char *</RETURNS>
GtkFileSystem        *file_system,GtkFileSystemVolume  *volume
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_volume_render_icon</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GtkFileSystem        *file_system,GtkFileSystemVolume  *volume,GtkWidget            *widget,gint                  pixel_size,GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_volume_get_icon_name</NAME>
<RETURNS>gchar *</RETURNS>
GtkFileSystem        *file_system,GtkFileSystemVolume  *volume,GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_get_parent</NAME>
<RETURNS>gboolean          </RETURNS>
GtkFileSystem     *file_system,const GtkFilePath *path,GtkFilePath      **parent,GError           **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_get_folder</NAME>
<RETURNS>GtkFileSystemHandle *</RETURNS>
GtkFileSystem                  *file_system,const GtkFilePath              *path,GtkFileInfoType                 types,GtkFileSystemGetFolderCallback  callback,gpointer                        data
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_get_info</NAME>
<RETURNS>GtkFileSystemHandle *</RETURNS>
GtkFileSystem                  *file_system,const GtkFilePath              *path,GtkFileInfoType                 types,GtkFileSystemGetInfoCallback    callback,gpointer                        data
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_create_folder</NAME>
<RETURNS>GtkFileSystemHandle *</RETURNS>
GtkFileSystem                     *file_system,const GtkFilePath                 *path,GtkFileSystemCreateFolderCallback  callback,gpointer                           data
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_cancel_operation</NAME>
<RETURNS>void              </RETURNS>
GtkFileSystemHandle *handle
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_make_path</NAME>
<RETURNS>GtkFilePath *</RETURNS>
GtkFileSystem     *file_system,const GtkFilePath *base_path,const gchar       *display_name,GError           **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_parse</NAME>
<RETURNS>gboolean          </RETURNS>
GtkFileSystem     *file_system,const GtkFilePath *base_path,const gchar       *str,GtkFilePath      **folder,gchar            **file_part,GError           **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_path_to_uri</NAME>
<RETURNS>gchar *</RETURNS>
GtkFileSystem     *file_system,const GtkFilePath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_path_to_filename</NAME>
<RETURNS>gchar *</RETURNS>
GtkFileSystem     *file_system,const GtkFilePath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_uri_to_path</NAME>
<RETURNS>GtkFilePath *</RETURNS>
GtkFileSystem     *file_system,const gchar       *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_filename_to_path</NAME>
<RETURNS>GtkFilePath *</RETURNS>
GtkFileSystem     *file_system,const gchar       *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_path_is_local</NAME>
<RETURNS>gboolean     </RETURNS>
GtkFileSystem     *filesystem,const GtkFilePath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_insert_bookmark</NAME>
<RETURNS>gboolean </RETURNS>
GtkFileSystem     *file_system,const GtkFilePath *path,gint               position,GError           **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_remove_bookmark</NAME>
<RETURNS>gboolean </RETURNS>
GtkFileSystem     *file_system,const GtkFilePath *path,GError           **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_list_bookmarks</NAME>
<RETURNS>GSList  *</RETURNS>
GtkFileSystem     *file_system
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_get_bookmark_label</NAME>
<RETURNS>gchar   *</RETURNS>
GtkFileSystem     *file_system,const GtkFilePath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_set_bookmark_label</NAME>
<RETURNS>void     </RETURNS>
GtkFileSystem     *file_system,const GtkFilePath *path,const gchar       *label
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FILE_FOLDER</NAME>
#define GTK_TYPE_FILE_FOLDER             (gtk_file_folder_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_FOLDER</NAME>
#define GTK_FILE_FOLDER(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_FOLDER, GtkFileFolder))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_FOLDER</NAME>
#define GTK_IS_FILE_FOLDER(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_FOLDER))
</MACRO>
<MACRO>
<NAME>GTK_FILE_FOLDER_GET_IFACE</NAME>
#define GTK_FILE_FOLDER_GET_IFACE(inst)  (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_FILE_FOLDER, GtkFileFolderIface))
</MACRO>
<STRUCT>
<NAME>GtkFileFolderIface</NAME>
struct _GtkFileFolderIface
{
  GTypeInterface base_iface;

  /* Methods
   */
  GtkFileInfo *      (*get_info)       (GtkFileFolder     *folder,
					const GtkFilePath *path,
				        GError           **error);
  gboolean           (*list_children)  (GtkFileFolder     *folder,
				        GSList           **children,
				        GError           **error);

  /* ??? refresh() ??? */

  /* Signals
   */
  void (*deleted)       (GtkFileFolder *monitor);
  void (*files_added)   (GtkFileFolder *monitor,
			 GSList        *paths);
  void (*files_changed) (GtkFileFolder *monitor,
			 GSList        *paths);
  void (*files_removed) (GtkFileFolder *monitor,
			 GSList        *paths);

  /* Method / signal */
  gboolean (*is_finished_loading) (GtkFileFolder *folder);
  void     (*finished_loading)    (GtkFileFolder *folder);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_file_folder_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_folder_list_children</NAME>
<RETURNS>gboolean     </RETURNS>
GtkFileFolder      *folder,GSList            **children,GError            **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_folder_get_info</NAME>
<RETURNS>GtkFileInfo *</RETURNS>
GtkFileFolder      *folder,const GtkFilePath  *path,GError            **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_folder_is_finished_loading</NAME>
<RETURNS>gboolean     </RETURNS>
GtkFileFolder *folder
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FILE_PATH</NAME>
#define GTK_TYPE_FILE_PATH             (gtk_file_path_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_file_path_get_type</NAME>
<RETURNS>GType   </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>gtk_file_path_new_dup</NAME>
#define gtk_file_path_new_dup(str) \
 ({ const gchar *__s = (str); (GtkFilePath *)g_strdup(__s); })
</MACRO>
<MACRO>
<NAME>gtk_file_path_new_steal</NAME>
#define gtk_file_path_new_steal(str) \
 ({ gchar *__s = (str); (GtkFilePath *)__s; })
</MACRO>
<MACRO>
<NAME>gtk_file_path_get_string</NAME>
#define gtk_file_path_get_string(path) \
 ({ const GtkFilePath *__p = (path); (const gchar *)__p; })
</MACRO>
<MACRO>
<NAME>gtk_file_path_free</NAME>
#define gtk_file_path_free(path) \
 ({ GtkFilePath *__p = (path); g_free (__p); })
</MACRO>
<MACRO>
<NAME>gtk_file_path_new_dup</NAME>
#define gtk_file_path_new_dup(str)     ((GtkFilePath *)g_strdup(str))
</MACRO>
<MACRO>
<NAME>gtk_file_path_new_steal</NAME>
#define gtk_file_path_new_steal(str)   ((GtkFilePath *)(str))
</MACRO>
<MACRO>
<NAME>gtk_file_path_get_string</NAME>
#define gtk_file_path_get_string(str) ((const gchar *)(str))
</MACRO>
<MACRO>
<NAME>gtk_file_path_free</NAME>
#define gtk_file_path_free(path)       g_free (path)
</MACRO>
<MACRO>
<NAME>gtk_file_path_copy</NAME>
#define gtk_file_path_copy(path)       gtk_file_path_new_dup (gtk_file_path_get_string(path))
</MACRO>
<MACRO>
<NAME>gtk_file_path_compare</NAME>
#define gtk_file_path_compare(path1,path2) \
  _gtk_file_system_win32_path_compare (gtk_file_path_get_string (path1), \
	                               gtk_file_path_get_string (path2))
</MACRO>
<MACRO>
<NAME>gtk_file_path_compare</NAME>
#define gtk_file_path_compare(path1,path2) strcmp (gtk_file_path_get_string (path1), \
						   gtk_file_path_get_string (path2))
</MACRO>
<FUNCTION>
<NAME>gtk_file_paths_sort</NAME>
<RETURNS>GSList *</RETURNS>
GSList *paths
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_paths_copy</NAME>
<RETURNS>GSList *</RETURNS>
GSList *paths
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_paths_free</NAME>
<RETURNS>void    </RETURNS>
GSList *paths
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_create</NAME>
<RETURNS>GtkFileSystem  *</RETURNS>
const char *file_system_name
</FUNCTION>
<FUNCTION>
<NAME>hildon_gtk_file_system_create</NAME>
<RETURNS>GtkFileSystem *</RETURNS>
const char         *file_system_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_render_icon</NAME>
<RETURNS>GdkPixbuf     *</RETURNS>
GtkFileSystem      *file_system,const GtkFilePath  *path,GtkWidget          *widget,gint                pixel_size,GError            **error
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FILE_SYSTEM_MODEL</NAME>
#define GTK_TYPE_FILE_SYSTEM_MODEL             (_gtk_file_system_model_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_MODEL</NAME>
#define GTK_FILE_SYSTEM_MODEL(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_SYSTEM_MODEL, GtkFileSystemModel))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_SYSTEM_MODEL</NAME>
#define GTK_IS_FILE_SYSTEM_MODEL(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_SYSTEM_MODEL))
</MACRO>
<STRUCT>
<NAME>GtkFileSystemModel</NAME>
</STRUCT>
<ENUM>
<NAME>GtkFileSystemModelColumns</NAME>
typedef enum {
  GTK_FILE_SYSTEM_MODEL_INFO,
  GTK_FILE_SYSTEM_MODEL_DISPLAY_NAME,
  GTK_FILE_SYSTEM_MODEL_N_COLUMNS
} GtkFileSystemModelColumns;
</ENUM>
<USER_FUNCTION>
<NAME>GtkFileSystemModelFilter</NAME>
<RETURNS>gboolean </RETURNS>
GtkFileSystemModel *model,
					      GtkFilePath        *path,
					      const GtkFileInfo  *info,
					      gpointer            user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkFileSystemModelPathFunc</NAME>
<RETURNS>void </RETURNS>
GtkFileSystemModel *model,
					    GtkTreePath        *path,
					    GtkTreeIter        *iter,
					    gpointer            user_data
</USER_FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FILE_SYSTEM_UNIX</NAME>
#define GTK_TYPE_FILE_SYSTEM_UNIX             (gtk_file_system_unix_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_UNIX</NAME>
#define GTK_FILE_SYSTEM_UNIX(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_SYSTEM_UNIX, GtkFileSystemUnix))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_SYSTEM_UNIX</NAME>
#define GTK_IS_FILE_SYSTEM_UNIX(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_SYSTEM_UNIX))
</MACRO>
<STRUCT>
<NAME>GtkFileSystemUnix</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_file_system_unix_new</NAME>
<RETURNS>GtkFileSystem *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_system_unix_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_FILE_CHOOSER_DELEGATE_QUARK</NAME>
#define GTK_FILE_CHOOSER_DELEGATE_QUARK	  (_gtk_file_chooser_delegate_get_quark ())
</MACRO>
<ENUM>
<NAME>GtkFileChooserProp</NAME>
typedef enum {
  GTK_FILE_CHOOSER_PROP_FIRST                  = 0x1000,
  GTK_FILE_CHOOSER_PROP_ACTION                 = GTK_FILE_CHOOSER_PROP_FIRST,
  GTK_FILE_CHOOSER_PROP_FILE_SYSTEM_BACKEND,
  GTK_FILE_CHOOSER_PROP_FILTER,
  GTK_FILE_CHOOSER_PROP_LOCAL_ONLY,
  GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET, 
  GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET_ACTIVE,
  GTK_FILE_CHOOSER_PROP_USE_PREVIEW_LABEL,
  GTK_FILE_CHOOSER_PROP_EXTRA_WIDGET,
  GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE,
  GTK_FILE_CHOOSER_PROP_SHOW_HIDDEN,
  GTK_FILE_CHOOSER_PROP_DO_OVERWRITE_CONFIRMATION,
  GTK_FILE_CHOOSER_PROP_LAST                   = GTK_FILE_CHOOSER_PROP_DO_OVERWRITE_CONFIRMATION
} GtkFileChooserProp;
</ENUM>
<FUNCTION>
<NAME>hildon_gtk_file_chooser_install_properties</NAME>
<RETURNS>void </RETURNS>
GObjectClass *klass
</FUNCTION>
<TYPEDEF>
<NAME>XdgAliasList</NAME>
typedef struct XdgAliasList XdgAliasList;
</TYPEDEF>
<STRUCT>
<NAME>XdgMimeCache</NAME>
</STRUCT>
<TYPEDEF>
<NAME>XdgParentList</NAME>
typedef struct XdgParentList XdgParentList;
</TYPEDEF>
<MACRO>
<NAME>XDG_ENTRY</NAME>
#define XDG_ENTRY(func) _XDG_ENTRY2(XDG_PREFIX,func)
</MACRO>
<USER_FUNCTION>
<NAME>XdgMimeCallback</NAME>
<RETURNS>void </RETURNS>
void *user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>XdgMimeDestroy</NAME>
<RETURNS>void </RETURNS>
void *user_data
</USER_FUNCTION>
<MACRO>
<NAME>xdg_mime_get_mime_type_for_data</NAME>
#define xdg_mime_get_mime_type_for_data       XDG_ENTRY(get_mime_type_for_data)
</MACRO>
<MACRO>
<NAME>xdg_mime_get_mime_type_for_file</NAME>
#define xdg_mime_get_mime_type_for_file       XDG_ENTRY(get_mime_type_for_file)
</MACRO>
<MACRO>
<NAME>xdg_mime_get_mime_type_from_file_name</NAME>
#define xdg_mime_get_mime_type_from_file_name XDG_ENTRY(get_mime_type_from_file_name)
</MACRO>
<MACRO>
<NAME>xdg_mime_get_mime_types_from_file_name</NAME>
#define xdg_mime_get_mime_types_from_file_name XDG_ENTRY(get_mime_types_from_file_name)
</MACRO>
<MACRO>
<NAME>xdg_mime_is_valid_mime_type</NAME>
#define xdg_mime_is_valid_mime_type           XDG_ENTRY(is_valid_mime_type)
</MACRO>
<MACRO>
<NAME>xdg_mime_mime_type_equal</NAME>
#define xdg_mime_mime_type_equal              XDG_ENTRY(mime_type_equal)
</MACRO>
<MACRO>
<NAME>xdg_mime_media_type_equal</NAME>
#define xdg_mime_media_type_equal             XDG_ENTRY(media_type_equal)
</MACRO>
<MACRO>
<NAME>xdg_mime_mime_type_subclass</NAME>
#define xdg_mime_mime_type_subclass           XDG_ENTRY(mime_type_subclass)
</MACRO>
<MACRO>
<NAME>xdg_mime_get_mime_parents</NAME>
#define xdg_mime_get_mime_parents             XDG_ENTRY(get_mime_parents)
</MACRO>
<MACRO>
<NAME>xdg_mime_list_mime_parents</NAME>
#define xdg_mime_list_mime_parents            XDG_ENTRY(list_mime_parents)
</MACRO>
<MACRO>
<NAME>xdg_mime_unalias_mime_type</NAME>
#define xdg_mime_unalias_mime_type            XDG_ENTRY(unalias_mime_type)
</MACRO>
<MACRO>
<NAME>xdg_mime_get_max_buffer_extents</NAME>
#define xdg_mime_get_max_buffer_extents       XDG_ENTRY(get_max_buffer_extents)
</MACRO>
<MACRO>
<NAME>xdg_mime_shutdown</NAME>
#define xdg_mime_shutdown                     XDG_ENTRY(shutdown)
</MACRO>
<MACRO>
<NAME>xdg_mime_dump</NAME>
#define xdg_mime_dump                         XDG_ENTRY(dump)
</MACRO>
<MACRO>
<NAME>xdg_mime_register_reload_callback</NAME>
#define xdg_mime_register_reload_callback     XDG_ENTRY(register_reload_callback)
</MACRO>
<MACRO>
<NAME>xdg_mime_remove_callback</NAME>
#define xdg_mime_remove_callback              XDG_ENTRY(remove_callback)
</MACRO>
<MACRO>
<NAME>xdg_mime_type_unknown</NAME>
#define xdg_mime_type_unknown                 XDG_ENTRY(type_unknown)
</MACRO>
<MACRO>
<NAME>XDG_MIME_TYPE_UNKNOWN</NAME>
#define XDG_MIME_TYPE_UNKNOWN xdg_mime_type_unknown
</MACRO>
<FUNCTION>
<NAME>xdg_mime_get_mime_type_for_data</NAME>
<RETURNS>const char  *</RETURNS>
const void *data,size_t      len,int        *result_prio
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_get_mime_type_for_file</NAME>
<RETURNS>const char  *</RETURNS>
const char *file_name,struct stat *statbuf
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_get_mime_type_from_file_name</NAME>
<RETURNS>const char  *</RETURNS>
const char *file_name
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_get_mime_types_from_file_name</NAME>
<RETURNS>int          </RETURNS>
const char *file_name,const char *mime_types[],int         n_mime_types
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_is_valid_mime_type</NAME>
<RETURNS>int          </RETURNS>
const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_mime_type_equal</NAME>
<RETURNS>int          </RETURNS>
const char *mime_a,const char *mime_b
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_media_type_equal</NAME>
<RETURNS>int          </RETURNS>
const char *mime_a,const char *mime_b
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_mime_type_subclass</NAME>
<RETURNS>int          </RETURNS>
const char *mime_a,const char *mime_b
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_get_mime_parents</NAME>
<RETURNS>const char **</RETURNS>
const char *mime
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_list_mime_parents</NAME>
<RETURNS>char **</RETURNS>
const char *mime
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_unalias_mime_type</NAME>
<RETURNS>const char  *</RETURNS>
const char *mime
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_get_max_buffer_extents</NAME>
<RETURNS>int          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_shutdown</NAME>
<RETURNS>void         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_dump</NAME>
<RETURNS>void         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_register_reload_callback</NAME>
<RETURNS>int          </RETURNS>
XdgMimeCallback  callback,void            *data,XdgMimeDestroy   destroy
</FUNCTION>
<FUNCTION>
<NAME>xdg_mime_remove_callback</NAME>
<RETURNS>void         </RETURNS>
int              callback_id
</FUNCTION>
<TYPEDEF>
<NAME>xdg_unichar_t</NAME>
typedef unsigned int   xdg_unichar_t;
</TYPEDEF>
<TYPEDEF>
<NAME>xdg_uchar8_t</NAME>
typedef unsigned char  xdg_uchar8_t;
</TYPEDEF>
<TYPEDEF>
<NAME>xdg_uint16_t</NAME>
typedef unsigned short xdg_uint16_t;
</TYPEDEF>
<TYPEDEF>
<NAME>xdg_uint32_t</NAME>
typedef unsigned int   xdg_uint32_t;
</TYPEDEF>
<MACRO>
<NAME>SWAP_BE16_TO_LE16</NAME>
#define SWAP_BE16_TO_LE16(val) (xdg_uint16_t)(((xdg_uint16_t)(val) << 8)|((xdg_uint16_t)(val) >> 8))
</MACRO>
<MACRO>
<NAME>SWAP_BE32_TO_LE32</NAME>
#define SWAP_BE32_TO_LE32(val) (xdg_uint32_t)((((xdg_uint32_t)(val) & 0xFF000000U) >> 24) |	\
					      (((xdg_uint32_t)(val) & 0x00FF0000U) >> 8) |	\
					      (((xdg_uint32_t)(val) & 0x0000FF00U) << 8) |	\
					      (((xdg_uint32_t)(val) & 0x000000FFU) << 24))
</MACRO>
<TYPEDEF>
<NAME>XdgGlobHash</NAME>
typedef struct XdgGlobHash XdgGlobHash;
</TYPEDEF>
<ENUM>
<NAME>XdgGlobType</NAME>
typedef enum
{
  XDG_GLOB_LITERAL, /* Makefile */
  XDG_GLOB_SIMPLE,  /* *.gif */
  XDG_GLOB_FULL     /* x*.[ch] */
} XdgGlobType;
</ENUM>
<TYPEDEF>
<NAME>XdgMimeMagic</NAME>
typedef struct XdgMimeMagic XdgMimeMagic;
</TYPEDEF>
