<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) \
  (GTK_CHECK_CAST (obj, HILDON_TYPE_FILE_CHOOSER_DIALOG,\
   HildonFileChooserDialog))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_CHOOSER_DIALOG_CLASS</NAME>
#define HILDON_FILE_CHOOSER_DIALOG_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_CHOOSER_DIALOG, \
  HildonFileChooserDialogClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_CHOOSER_DIALOG</NAME>
#define HILDON_IS_FILE_CHOOSER_DIALOG(obj) \
  (GTK_CHECK_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) \
  (GTK_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>
<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>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 -5
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_INTERNAL_MMC</NAME>
#define SORT_WEIGHT_INTERNAL_MMC -8
</MACRO>
<MACRO>
<NAME>SORT_WEIGHT_EXTERNAL_MMC</NAME>
#define SORT_WEIGHT_EXTERNAL_MMC -7
</MACRO>
<MACRO>
<NAME>TRACE</NAME>
#define TRACE ULOG_DEBUG_F("entered")
</MACRO>
<MACRO>
<NAME>TRACE</NAME>
#define TRACE
</MACRO>
<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>
<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) \
  (GTK_CHECK_CAST (obj, HILDON_TYPE_FILE_SELECTION, HildonFileSelection))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SELECTION_CLASS</NAME>
#define HILDON_FILE_SELECTION_CLASS(klass) \
  (GTK_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_SELECTION, \
  HildonFileSelectionClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SELECTION</NAME>
#define HILDON_IS_FILE_SELECTION(obj) \
  (GTK_CHECK_TYPE (obj, HILDON_TYPE_FILE_SELECTION))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SELECTION_CLASS</NAME>
#define HILDON_IS_FILE_SELECTION_CLASS(klass) \
  (GTK_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_mode</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection * self,HildonFileSelectionMode mode
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_mode</NAME>
<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_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, gbooleanvisible
</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_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>
<MACRO>
<NAME>GTK_FILE_SYSTEM_ENABLE_UNSUPPORTED</NAME>
#define GTK_FILE_SYSTEM_ENABLE_UNSUPPORTED
</MACRO>
<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_GAMES,
    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>
<RETURNS>GtkFileSystem *</RETURNS>
const gchar *name, gboolean use_fallback
</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>
<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>
<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_MMC</NAME>
#define HILDON_TYPE_FILE_SYSTEM_MMC            (hildon_file_system_mmc_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_MMC</NAME>
#define HILDON_FILE_SYSTEM_MMC(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), HILDON_TYPE_FILE_SYSTEM_MMC, HildonFileSystemMMC))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_MMC_CLASS</NAME>
#define HILDON_FILE_SYSTEM_MMC_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_SYSTEM_MMC, HildonFileSystemMMCClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_MMC</NAME>
#define HILDON_IS_FILE_SYSTEM_MMC(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HILDON_TYPE_FILE_SYSTEM_MMC))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_MMC_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_MMC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SYSTEM_MMC))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_MMC_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_MMC_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), HILDON_TYPE_FILE_SYSTEM_MMC, HildonFileSystemMMCClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemMMC</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemMMCClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemMMCPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemMMC</NAME>
struct _HildonFileSystemMMC
{
    HildonFileSystemSpecialLocation parent_instance;
    HildonFileSystemMMCPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemMMCClass</NAME>
struct _HildonFileSystemMMCClass
{
    HildonFileSystemSpecialLocationClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_mmc_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</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_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_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>
<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>
<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>
<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;
    gboolean has_children;
    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>HILDON_TYPE_FILE_SYSTEM_OLD_GATEWAY</NAME>
#define HILDON_TYPE_FILE_SYSTEM_OLD_GATEWAY            (hildon_file_system_old_gateway_get_type ())
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_OLD_GATEWAY</NAME>
#define HILDON_FILE_SYSTEM_OLD_GATEWAY(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), HILDON_TYPE_FILE_SYSTEM_OLD_GATEWAY, HildonFileSystemOldGateway))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_OLD_GATEWAY_CLASS</NAME>
#define HILDON_FILE_SYSTEM_OLD_GATEWAY_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), HILDON_TYPE_FILE_SYSTEM_OLD_GATEWAY, HildonFileSystemOldGatewayClass))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_OLD_GATEWAY</NAME>
#define HILDON_IS_FILE_SYSTEM_OLD_GATEWAY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HILDON_TYPE_FILE_SYSTEM_OLD_GATEWAY))
</MACRO>
<MACRO>
<NAME>HILDON_IS_FILE_SYSTEM_OLD_GATEWAY_CLASS</NAME>
#define HILDON_IS_FILE_SYSTEM_OLD_GATEWAY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HILDON_TYPE_FILE_SYSTEM_OLD_GATEWAY))
</MACRO>
<MACRO>
<NAME>HILDON_FILE_SYSTEM_OLD_GATEWAY_GET_CLASS</NAME>
#define HILDON_FILE_SYSTEM_OLD_GATEWAY_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), HILDON_TYPE_FILE_SYSTEM_OLD_GATEWAY, HildonFileSystemOldGatewayClass))
</MACRO>
<STRUCT>
<NAME>HildonFileSystemOldGateway</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemOldGatewayClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemOldGateway</NAME>
struct _HildonFileSystemOldGateway
{
    HildonFileSystemRemoteDevice parent_instance;

    /* private */
    gboolean visible;
    gboolean available;
    gulong signal_handler_id;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemOldGatewayClass</NAME>
struct _HildonFileSystemOldGatewayClass
{
    HildonFileSystemRemoteDeviceClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_old_gateway_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>TREE_ICON_SIZE</NAME>
#define TREE_ICON_SIZE 26 /* Left side icons */
</MACRO>
<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>
<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>
<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>
<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;
    gboolean has_children;
    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_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 */
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemSpecialLocationClass</NAME>
struct _HildonFileSystemSpecialLocationClass
{
  GObjectClass parent_class;

  /* 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);
  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);

    /* signals */
    void (*changed) (GObject *obj);
    void (*connection_state) (GObject *obj);
    void (*rescan) (GObject *obj);
};
</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>
<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>
<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
</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>
<RETURNS>void</RETURNS>
HildonFileSystemSpecialLocation *location, GtkFileSystem *fs
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_system_special_location_get_folder</NAME>
<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>
<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;
    gboolean has_children;
    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_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>
<STRUCT>
<NAME>HildonFileSystemVoldev</NAME>
struct _HildonFileSystemVoldev
{
  HildonFileSystemSpecialLocation parent_instance;
  GnomeVFSVolume *volume;
  GnomeVFSDrive *drive;
};
</STRUCT>
<STRUCT>
<NAME>HildonFileSystemVoldevClass</NAME>
struct _HildonFileSystemVoldevClass
{
    HildonFileSystemRemoteDeviceClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>hildon_file_system_voldev_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_set_current_folder</NAME>
<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>
<RETURNS>gboolean </RETURNS>
HildonFileSelection *self,const GtkFilePath *path,GError **error
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_unselect_path</NAME>
<RETURNS>void </RETURNS>
HildonFileSelection *self,const GtkFilePath *path
</FUNCTION>
<FUNCTION>
<NAME>hildon_file_selection_get_selected_paths</NAME>
<RETURNS>GSList *</RETURNS>
HildonFileSelection *self
</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>
