<ENUM>
<NAME>HeAboutDialogResponseType</NAME>
typedef enum {
    HE_ABOUT_RESPONSE_WEBSITE = 0,
    HE_ABOUT_RESPONSE_BUGTRACKER,
    HE_ABOUT_RESPONSE_DONATE,
} HeAboutDialogResponseType;
</ENUM>
<MACRO>
<NAME>HE_TYPE_ABOUT_DIALOG</NAME>
  #define                                         HE_TYPE_ABOUT_DIALOG \
                                                  (he_about_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>HE_ABOUT_DIALOG</NAME>
  #define                                         HE_ABOUT_DIALOG(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
                                                  HE_TYPE_ABOUT_DIALOG, HeAboutDialog))
</MACRO>
<MACRO>
<NAME>HE_ABOUT_DIALOG_CLASS</NAME>
  #define                                         HE_ABOUT_DIALOG_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_CAST ((vtable), \
                                                  HE_TYPE_ABOUT_DIALOG, HeAboutDialogClass))
</MACRO>
<MACRO>
<NAME>HE_IS_ABOUT_DIALOG</NAME>
  #define                                         HE_IS_ABOUT_DIALOG(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HE_TYPE_ABOUT_DIALOG))
</MACRO>
<MACRO>
<NAME>HE_IS_ABOUT_DIALOG_CLASS</NAME>
  #define                                         HE_IS_ABOUT_DIALOG_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_TYPE ((vtable), HE_TYPE_ABOUT_DIALOG))
</MACRO>
<MACRO>
<NAME>HE_ABOUT_DIALOG_GET_CLASS</NAME>
  #define                                         HE_ABOUT_DIALOG_GET_CLASS(inst) \
                                                  (G_TYPE_INSTANCE_GET_CLASS ((inst), \
                                                  HE_TYPE_ABOUT_DIALOG, HeAboutDialogClass))
</MACRO>
<STRUCT>
<NAME>HeAboutDialog</NAME>
</STRUCT>
<STRUCT>
<NAME>HeAboutDialogClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeAboutDialogPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeAboutDialog</NAME>
struct					_HeAboutDialog
{
	GtkDialog parent;
	/*< private > */
        HeAboutDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>HeAboutDialogClass</NAME>
struct					_HeAboutDialogClass
{
	GtkDialogClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>he_about_dialog_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_about_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_about_dialog_present</NAME>
<RETURNS>void </RETURNS>
GtkWindow* parent,const gchar* app_name,const gchar* icon_name,const gchar* version,const gchar* description,const gchar* copyright,const gchar* website_url,const gchar* bugtracker_url,const gchar* donate_url
</FUNCTION>
<FUNCTION>
<NAME>he_about_dialog_present_interop</NAME>
<RETURNS>void </RETURNS>
GdkNativeWindow parent_winid,const gchar* app_name,const gchar* icon_name,const gchar* version,const gchar* description,const gchar* copyright,const gchar* website_url,const gchar* bugtracker_url,const gchar* donate_url
</FUNCTION>
<FUNCTION>
<NAME>he_about_dialog_set_app_name</NAME>
<RETURNS>void </RETURNS>
HeAboutDialog* ad, const gchar* app_name
</FUNCTION>
<FUNCTION>
<NAME>he_about_dialog_set_icon_name</NAME>
<RETURNS>void </RETURNS>
HeAboutDialog* ad, const gchar* icon_name
</FUNCTION>
<FUNCTION>
<NAME>he_about_dialog_set_version</NAME>
<RETURNS>void </RETURNS>
HeAboutDialog* ad, const gchar* version
</FUNCTION>
<FUNCTION>
<NAME>he_about_dialog_set_description</NAME>
<RETURNS>void </RETURNS>
HeAboutDialog* ad, const gchar* description
</FUNCTION>
<FUNCTION>
<NAME>he_about_dialog_set_copyright</NAME>
<RETURNS>void </RETURNS>
HeAboutDialog* ad, const gchar* copyright
</FUNCTION>
<FUNCTION>
<NAME>he_about_dialog_set_website</NAME>
<RETURNS>void </RETURNS>
HeAboutDialog* ad, const gchar* url
</FUNCTION>
<FUNCTION>
<NAME>he_about_dialog_set_bugtracker</NAME>
<RETURNS>void </RETURNS>
HeAboutDialog* ad, const gchar* url
</FUNCTION>
<FUNCTION>
<NAME>he_about_dialog_set_donate_url</NAME>
<RETURNS>void </RETURNS>
HeAboutDialog* ad, const gchar* url
</FUNCTION>
<FUNCTION>
<NAME>he_helper_vibrate</NAME>
<RETURNS>void </RETURNS>
osso_context_t *context, const gchar *vibration_pattern, const gboolean activate
</FUNCTION>
<FUNCTION>
<NAME>he_helper_led</NAME>
<RETURNS>void </RETURNS>
osso_context_t *context, const gchar *led_pattern, const gboolean activate
</FUNCTION>
<FUNCTION>
<NAME>he_helper_accelerometer_enable</NAME>
<RETURNS>void </RETURNS>
osso_context_t *context
</FUNCTION>
<FUNCTION>
<NAME>he_helper_accelerometer_disable</NAME>
<RETURNS>void </RETURNS>
osso_context_t *context
</FUNCTION>
<FUNCTION>
<NAME>he_helper_request_orientation</NAME>
<RETURNS>gboolean </RETURNS>
osso_context_t *context
</FUNCTION>
<FUNCTION>
<NAME>he_helper_show_cursor</NAME>
<RETURNS>void </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>he_helper_hide_cursor</NAME>
<RETURNS>void </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>he_helper_tap_and_hold_setup</NAME>
<RETURNS>void </RETURNS>
GtkWidget *widget, gulong *tap_and_hold_id, gulong *button_press_event_id
</FUNCTION>
<MACRO>
<NAME>HE_FONT_SYSTEM_FONT</NAME>
#define HE_FONT_SYSTEM_FONT                  "SystemFont"
</MACRO>
<MACRO>
<NAME>HE_FONT_EMP_SYSTEM_FONT</NAME>
#define HE_FONT_EMP_SYSTEM_FONT              "EmpSystemFont"
</MACRO>
<MACRO>
<NAME>HE_FONT_SMALL_SYSTEM_FONT</NAME>
#define HE_FONT_SMALL_SYSTEM_FONT            "SmallSystemFont"
</MACRO>
<MACRO>
<NAME>HE_FONT_EMP_SMALL_SYSTEM_FONT</NAME>
#define HE_FONT_EMP_SMALL_SYSTEM_FONT        "EmpSmallSystemFont"
</MACRO>
<MACRO>
<NAME>HE_FONT_LARGE_SYSTEM_FONT</NAME>
#define HE_FONT_LARGE_SYSTEM_FONT            "LargeSystemFont"
</MACRO>
<MACRO>
<NAME>HE_FONT_X_LARGE_SYSTEM_FONT</NAME>
#define HE_FONT_X_LARGE_SYSTEM_FONT          "X-LargeSystemFont"
</MACRO>
<MACRO>
<NAME>HE_FONT_XX_LARGE_SYSTEM_FONT</NAME>
#define HE_FONT_XX_LARGE_SYSTEM_FONT         "XX-LargeSystemFont"
</MACRO>
<MACRO>
<NAME>HE_FONT_XXX_LARGE_SYSTEM_FONT</NAME>
#define HE_FONT_XXX_LARGE_SYSTEM_FONT        "XXX-LargeSystemFont"
</MACRO>
<MACRO>
<NAME>HE_FONT_HOME_SYSTEM_FONT</NAME>
#define HE_FONT_HOME_SYSTEM_FONT             "HomeSystemFont"
</MACRO>
<FUNCTION>
<NAME>he_helper_get_logical_font_desc</NAME>
<RETURNS>gchar  *</RETURNS>
const gchar *name
</FUNCTION>
<MACRO>
<NAME>HE_COLOR_DEFAULT_BACKGROUND</NAME>
#define HE_COLOR_DEFAULT_BACKGROUND          "DefaultBackgroundColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_DEFAULT_TEXT</NAME>
#define HE_COLOR_DEFAULT_TEXT                "DefaultTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_SECONDARY_TEXT</NAME>
#define HE_COLOR_SECONDARY_TEXT              "SecondaryTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_ACTIVE_TEXT</NAME>
#define HE_COLOR_ACTIVE_TEXT                 "ActiveTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_SELECTION</NAME>
#define HE_COLOR_SELECTION                   "SelectionColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_PAINTED_TEXT</NAME>
#define HE_COLOR_PAINTED_TEXT                "PaintedTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_DISABLED_TEXT</NAME>
#define HE_COLOR_DISABLED_TEXT               "DisabledTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_DEFAULT_BACKGROUND_REVERSED</NAME>
#define HE_COLOR_DEFAULT_BACKGROUND_REVERSED "ReversedDefaultBackgroundColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_DEFAULT_TEXT_REVERSED</NAME>
#define HE_COLOR_DEFAULT_TEXT_REVERSED       "ReversedDefaultTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_SECONDARY_TEXT_REVERSED</NAME>
#define HE_COLOR_SECONDARY_TEXT_REVERSED     "ReversedSecondaryTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_ACTIVE_TEXT_REVERSED</NAME>
#define HE_COLOR_ACTIVE_TEXT_REVERSED        "ReversedActiveTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_SELECTION_REVERSED</NAME>
#define HE_COLOR_SELECTION_REVERSED          "ReversedSelectionColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_PAINTED_TEXT_REVERSED</NAME>
#define HE_COLOR_PAINTED_TEXT_REVERSED       "ReversedPaintedTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_DISABLED_TEXT_REVERSED</NAME>
#define HE_COLOR_DISABLED_TEXT_REVERSED      "ReversedDisabledTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_CONTENT_BACKGROUND</NAME>
#define HE_COLOR_CONTENT_BACKGROUND          "ContentBackgroundColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_CONTENT_FRAME</NAME>
#define HE_COLOR_CONTENT_FRAME               "ContentFrameColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_CONTENT_SELECTION</NAME>
#define HE_COLOR_CONTENT_SELECTION           "ContentSelectionColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_TITLE_TEXT</NAME>
#define HE_COLOR_TITLE_TEXT                  "TitleTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_BUTTON_TEXT</NAME>
#define HE_COLOR_BUTTON_TEXT                 "ButtonTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_BUTTON_TEXT_PRESSED</NAME>
#define HE_COLOR_BUTTON_TEXT_PRESSED         "ButtonTextPressedColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_BUTTON_TEXT_DISABLED</NAME>
#define HE_COLOR_BUTTON_TEXT_DISABLED        "ButtonTextDisabledColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_ACCENT_1</NAME>
#define HE_COLOR_ACCENT_1                    "AccentColor1"
</MACRO>
<MACRO>
<NAME>HE_COLOR_ACCENT_2</NAME>
#define HE_COLOR_ACCENT_2                    "AccentColor2"
</MACRO>
<MACRO>
<NAME>HE_COLOR_ACCENT_3</NAME>
#define HE_COLOR_ACCENT_3                    "AccentColor3"
</MACRO>
<MACRO>
<NAME>HE_COLOR_ATTENTION</NAME>
#define HE_COLOR_ATTENTION                   "AttentionColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_NOTIFICATION_BACKGROUND</NAME>
#define HE_COLOR_NOTIFICATION_BACKGROUND     "NotificationBackgroundColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_NOTIFIACTION_TEXT</NAME>
#define HE_COLOR_NOTIFIACTION_TEXT           "NotificationTextColor"
</MACRO>
<MACRO>
<NAME>HE_COLOR_NOTIFICATION_SECONDARY_TEXT</NAME>
#define HE_COLOR_NOTIFICATION_SECONDARY_TEXT "NotificationSecondaryTextColor"
</MACRO>
<FUNCTION>
<NAME>he_helper_get_logical_font_color</NAME>
<RETURNS>gchar  *</RETURNS>
const gchar *name
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_FULLSCREEN_BUTTON</NAME>
#define						HE_TYPE_FULLSCREEN_BUTTON \
							(he_fullscreen_button_get_type())
</MACRO>
<MACRO>
<NAME>HE_FULLSCREEN_BUTTON</NAME>
#define						HE_FULLSCREEN_BUTTON(object) \
							(G_TYPE_CHECK_INSTANCE_CAST((object), \
							HE_TYPE_FULLSCREEN_BUTTON, HeFullscreenButton))
</MACRO>
<MACRO>
<NAME>HE_FULLSCREEN_BUTTON_CLASS</NAME>
#define						HE_FULLSCREEN_BUTTON_CLASS(klass) \
							(G_TYPE_CHECK_CLASS_CAST((klass), \
							HE_TYPE_FULLSCREEN_BUTTON, HeFullscreenButtonClass))
</MACRO>
<MACRO>
<NAME>HE_IS_FULLSCREEN_BUTTON</NAME>
#define						HE_IS_FULLSCREEN_BUTTON(object) \
							(G_TYPE_CHECK_INSTANCE_TYPE((object), \
							HE_TYPE_FULLSCREEN_BUTTON))
</MACRO>
<MACRO>
<NAME>HE_IS_FULLSCREEN_BUTTON_CLASS</NAME>
#define						HE_IS_FULLSCREEN_BUTTON_CLASS(klass) \
							(G_TYPE_CHECK_CLASS_TYPE((klass), \
							HE_TYPE_FULLSCREEN_BUTTON))
</MACRO>
<MACRO>
<NAME>HE_FULLSCREEN_BUTTON_GET_CLASS</NAME>
#define						HE_FULLSCREEN_BUTTON_GET_CLASS(obj) \
							(G_TYPE_INSTANCE_GET_CLASS((obj), \
							HE_TYPE_FULLSCREEN_BUTTON, HeFullscreenButtonClass))
</MACRO>
<STRUCT>
<NAME>HeFullscreenButton</NAME>
</STRUCT>
<STRUCT>
<NAME>HeFullscreenButtonClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeFullscreenButton</NAME>
struct _HeFullscreenButton
{
        GObject      parent;

        GtkWindow   *parent_window;
};
</STRUCT>
<STRUCT>
<NAME>HeFullscreenButtonClass</NAME>
struct _HeFullscreenButtonClass
{
        GObjectClass parent_class;

        void (*clicked) (HeFullscreenButton *manager);
};
</STRUCT>
<FUNCTION>
<NAME>he_fullscreen_button_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_fullscreen_button_new</NAME>
<RETURNS>HeFullscreenButton  *</RETURNS>
GtkWindow *parent_window
</FUNCTION>
<FUNCTION>
<NAME>he_fullscreen_button_disable</NAME>
<RETURNS>void </RETURNS>
HeFullscreenButton *self
</FUNCTION>
<FUNCTION>
<NAME>he_fullscreen_button_enable</NAME>
<RETURNS>void </RETURNS>
HeFullscreenButton *self
</FUNCTION>
<FUNCTION>
<NAME>he_fullscreen_button_get_overlay</NAME>
<RETURNS>GtkWidget  *</RETURNS>
HeFullscreenButton *self
</FUNCTION>
<FUNCTION>
<NAME>he_fullscreen_button_get_window</NAME>
<RETURNS>GtkWindow  *</RETURNS>
HeFullscreenButton *self
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_MENU_STORE</NAME>
#define HE_TYPE_MENU_STORE (he_menu_store_get_type())
</MACRO>
<MACRO>
<NAME>HE_MENU_STORE</NAME>
#define HE_MENU_STORE(object)           (G_TYPE_CHECK_INSTANCE_CAST((object), HE_TYPE_MENU_STORE, HeMenuStore))
</MACRO>
<MACRO>
<NAME>HE_MENU_STORE_CLASS</NAME>
#define HE_MENU_STORE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST((klass),     HE_TYPE_MENU_STORE, HeMenuStoreClass))
</MACRO>
<MACRO>
<NAME>HE_IS_MENU_STORE</NAME>
#define HE_IS_MENU_STORE(object)        (G_TYPE_CHECK_INSTANCE_TYPE((object), HE_TYPE_MENU_STORE))
</MACRO>
<MACRO>
<NAME>HE_IS_MENU_STORE_CLASS</NAME>
#define HE_IS_MENU_STORE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE((klass),     HE_TYPE_MENU_STORE))
</MACRO>
<MACRO>
<NAME>HE_MENU_STORE_GET_CLASS</NAME>
#define HE_MENU_STORE_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS((object),  HE_TYPE_MENU_STORE, HeMenuStoreClass))
</MACRO>
<STRUCT>
<NAME>HeMenuStore</NAME>
</STRUCT>
<STRUCT>
<NAME>HeMenuStoreClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeMenuStorePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeMenuStore</NAME>
struct _HeMenuStore
{
	GObject __parent_instance__;
	HeMenuStorePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>HeMenuStoreClass</NAME>
struct _HeMenuStoreClass
{
	GObjectClass __parent_class__;
	void (*gtk_menu_shell_insert)(GtkMenuShell *, GtkWidget *, gint);
};
</STRUCT>
<FUNCTION>
<NAME>he_menu_store_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_menu_store_new</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkMenu *menu
</FUNCTION>
<ENUM>
<NAME>HeMenuStoreColumn</NAME>
typedef enum {
	HE_MENU_STORE_IMAGE_PIXBUF,
	HE_MENU_STORE_IS_IMAGE_ITEM,
	HE_MENU_STORE_IS_CHECK_ITEM,
	HE_MENU_STORE_IS_RADIO_ITEM,
	HE_MENU_STORE_TEXT,
	HE_MENU_STORE_VISIBLE,
	HE_MENU_STORE_SENSITIVE,
	HE_MENU_STORE_ACTIVE,
	HE_MENU_STORE_INCONSISTENT,
	HE_MENU_STORE_MENU_WIDGET,
	HE_MENU_STORE_HAS_CHILDREN,
	HE_MENU_STORE_N_COLUMNS
} HeMenuStoreColumn;
</ENUM>
<MACRO>
<NAME>HE_TYPE_COLOR_SELECTOR</NAME>
  #define                                         HE_TYPE_COLOR_SELECTOR \
                                                  (he_color_selector_get_type ())
</MACRO>
<MACRO>
<NAME>HE_COLOR_SELECTOR</NAME>
  #define                                         HE_COLOR_SELECTOR(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
                                                  HE_TYPE_COLOR_SELECTOR, HeColorSelector))
</MACRO>
<MACRO>
<NAME>HE_COLOR_SELECTOR_CLASS</NAME>
  #define                                         HE_COLOR_SELECTOR_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_CAST ((vtable), \
                                                  HE_TYPE_COLOR_SELECTOR, HeColorSelectorClass))
</MACRO>
<MACRO>
<NAME>HE_IS_COLOR_SELECTOR</NAME>
  #define                                         HE_IS_COLOR_SELECTOR(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HE_TYPE_COLOR_SELECTOR))
</MACRO>
<MACRO>
<NAME>HE_IS_COLOR_SELECTOR_CLASS</NAME>
  #define                                         HE_IS_COLOR_SELECTOR_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_TYPE ((vtable), HE_TYPE_COLOR_SELECTOR))
</MACRO>
<MACRO>
<NAME>HE_COLOR_SELECTOR_GET_CLASS</NAME>
  #define                                         HE_COLOR_SELECTOR_GET_CLASS(inst) \
                                                  (G_TYPE_INSTANCE_GET_CLASS ((inst), \
                                                  HE_TYPE_COLOR_SELECTOR, HeColorSelectorClass))
</MACRO>
<STRUCT>
<NAME>HeColorSelector</NAME>
</STRUCT>
<STRUCT>
<NAME>HeColorSelectorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeColorSelectorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeColorSelector</NAME>
  struct                                          _HeColorSelector
  {
    GtkVBox parent_instance;
  
    /*< private > */
    HeColorSelectorPrivate *priv;
  };
</STRUCT>
<STRUCT>
<NAME>HeColorSelectorClass</NAME>
  struct                                          _HeColorSelectorClass
  {
    GtkVBoxClass parent_class;
  
    /* signals */
  };
</STRUCT>
<FUNCTION>
<NAME>he_color_selector_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_color_selector_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_color_selector_new_with_default_color</NAME>
<RETURNS>GtkWidget *</RETURNS>
GdkColor *default_color
</FUNCTION>
<FUNCTION>
<NAME>he_color_selector_select_red</NAME>
<RETURNS>gboolean </RETURNS>
HeColorSelector *selector,guint red
</FUNCTION>
<FUNCTION>
<NAME>he_color_selector_select_green</NAME>
<RETURNS>gboolean </RETURNS>
HeColorSelector *selector,guint green
</FUNCTION>
<FUNCTION>
<NAME>he_color_selector_select_blue</NAME>
<RETURNS>gboolean </RETURNS>
HeColorSelector *selector,guint blue
</FUNCTION>
<FUNCTION>
<NAME>he_color_selector_set_color</NAME>
<RETURNS>gboolean </RETURNS>
HeColorSelector *selector,GdkColor *color
</FUNCTION>
<FUNCTION>
<NAME>he_color_selector_get_color</NAME>
<RETURNS>void </RETURNS>
HeColorSelector *selector, GdkColor *color
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_ARROWED_ENTRY</NAME>
#define HE_TYPE_ARROWED_ENTRY (he_arrowed_entry_get_type ())
</MACRO>
<MACRO>
<NAME>HE_ARROWED_ENTRY</NAME>
#define HE_ARROWED_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
						HE_TYPE_ARROWED_ENTRY, HeArrowedEntry))
</MACRO>
<MACRO>
<NAME>HE_ARROWED_ENTRY_CLASS</NAME>
#define HE_ARROWED_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), \
						HE_TYPE_ARROWED_ENTRY, HeArrowedEntryClass))
</MACRO>
<MACRO>
<NAME>HE_IS_ARROWED_ENTRY</NAME>
#define HE_IS_ARROWED_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
						HE_TYPE_ARROWED_ENTRY))
</MACRO>
<MACRO>
<NAME>HE_IS_ARROWED_ENTRY_CLASS</NAME>
#define HE_IS_ARROWED_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), \
						HE_TYPE_ARROWED_ENTRY))
</MACRO>
<MACRO>
<NAME>HE_ARROWED_ENTRY_GET_CLASS</NAME>
#define HE_ARROWED_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), \
						HE_TYPE_ARROWED_ENTRY, HeArrowedEntryClass))
</MACRO>
<STRUCT>
<NAME>HeArrowedEntry</NAME>
</STRUCT>
<STRUCT>
<NAME>HeArrowedEntryClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeArrowedEntry</NAME>
struct _HeArrowedEntry
{
	GtkHBox parent;
};
</STRUCT>
<STRUCT>
<NAME>HeArrowedEntryClass</NAME>
struct _HeArrowedEntryClass
{
	GtkHBoxClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>he_arrowed_entry_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_arrowed_entry_new</NAME>
<RETURNS>GtkWidget*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_arrowed_entry_get_entry</NAME>
<RETURNS>GtkWidget*</RETURNS>
HeArrowedEntry *self
</FUNCTION>
<FUNCTION>
<NAME>he_arrowed_entry_get_button</NAME>
<RETURNS>GtkWidget*</RETURNS>
HeArrowedEntry *self
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_CELL_RENDERER_TOGGLE</NAME>
#define HE_TYPE_CELL_RENDERER_TOGGLE (he_cell_renderer_toggle_get_type())
</MACRO>
<MACRO>
<NAME>HE_CELL_RENDERER_TOGGLE</NAME>
#define HE_CELL_RENDERER_TOGGLE(object)           (G_TYPE_CHECK_INSTANCE_CAST((object), HE_TYPE_CELL_RENDERER_TOGGLE, HeCellRendererToggle))
</MACRO>
<MACRO>
<NAME>HE_CELL_RENDERER_TOGGLE_CLASS</NAME>
#define HE_CELL_RENDERER_TOGGLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST((klass),     HE_TYPE_CELL_RENDERER_TOGGLE, HeCellRendererToggleClass))
</MACRO>
<MACRO>
<NAME>HE_IS_CELL_RENDERER_TOGGLE</NAME>
#define HE_IS_CELL_RENDERER_TOGGLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE((object), HE_TYPE_CELL_RENDERER_TOGGLE))
</MACRO>
<MACRO>
<NAME>HE_IS_CELL_RENDERER_TOGGLE_CLASS</NAME>
#define HE_IS_CELL_RENDERER_TOGGLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE((klass),     HE_TYPE_CELL_RENDERER_TOGGLE))
</MACRO>
<MACRO>
<NAME>HE_CELL_RENDERER_TOGGLE_GET_CLASS</NAME>
#define HE_CELL_RENDERER_TOGGLE_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS((object),  HE_TYPE_CELL_RENDERER_TOGGLE, HeCellRendererToggleClass))
</MACRO>
<STRUCT>
<NAME>HeCellRendererToggle</NAME>
</STRUCT>
<STRUCT>
<NAME>HeCellRendererToggleClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>he_cell_renderer_toggle_get_type</NAME>
<RETURNS>GType </RETURNS>

</FUNCTION>
<MACRO>
<NAME>HE_TYPE_COLOR_BUTTON</NAME>
  #define                                         HE_TYPE_COLOR_BUTTON \
                                                  (he_color_button_get_type ())
</MACRO>
<MACRO>
<NAME>HE_COLOR_BUTTON</NAME>
  #define                                         HE_COLOR_BUTTON(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
                                                  HE_TYPE_COLOR_BUTTON, HeColorButton))
</MACRO>
<MACRO>
<NAME>HE_COLOR_BUTTON_CLASS</NAME>
  #define                                         HE_COLOR_BUTTON_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_CAST ((vtable), \
                                                  HE_TYPE_COLOR_BUTTON, HeColorButtonClass))
</MACRO>
<MACRO>
<NAME>HE_IS_COLOR_BUTTON</NAME>
  #define                                         HE_IS_COLOR_BUTTON(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HE_TYPE_COLOR_BUTTON))
</MACRO>
<MACRO>
<NAME>HE_IS_COLOR_BUTTON_CLASS</NAME>
  #define                                         HE_IS_COLOR_BUTTON_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_TYPE ((vtable), HE_TYPE_COLOR_BUTTON))
</MACRO>
<MACRO>
<NAME>HE_COLOR_BUTTON_GET_CLASS</NAME>
  #define                                         HE_COLOR_BUTTON_GET_CLASS(inst) \
                                                  (G_TYPE_INSTANCE_GET_CLASS ((inst), \
                                                  HE_TYPE_COLOR_BUTTON, HeColorButtonClass))
</MACRO>
<STRUCT>
<NAME>HeColorButton</NAME>
</STRUCT>
<STRUCT>
<NAME>HeColorButtonClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeColorButtonPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeColorButton</NAME>
struct					_HeColorButton
{
	GtkButton parent;
	/*< private > */
    HeColorButtonPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>HeColorButtonClass</NAME>
struct					_HeColorButtonClass
{
	GtkButtonClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>he_color_button_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_color_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_color_button_new_with_color</NAME>
<RETURNS>GtkWidget *</RETURNS>
const GdkColor *color
</FUNCTION>
<FUNCTION>
<NAME>he_color_button_get_color</NAME>
<RETURNS>void </RETURNS>
HeColorButton *cb,GdkColor *color
</FUNCTION>
<FUNCTION>
<NAME>he_color_button_set_color</NAME>
<RETURNS>void </RETURNS>
HeColorButton *cb,const GdkColor *color
</FUNCTION>
<FUNCTION>
<NAME>he_color_button_get_popup_shown</NAME>
<RETURNS>gboolean </RETURNS>
HeColorButton *cb
</FUNCTION>
<FUNCTION>
<NAME>he_color_button_popdown</NAME>
<RETURNS>void </RETURNS>
HeColorButton *cb
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_COLOR_DIALOG</NAME>
  #define                                         HE_TYPE_COLOR_DIALOG \
                                                  (he_color_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>HE_COLOR_DIALOG</NAME>
  #define                                         HE_COLOR_DIALOG(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
                                                  HE_TYPE_COLOR_DIALOG, HeColorDialog))
</MACRO>
<MACRO>
<NAME>HE_COLOR_DIALOG_CLASS</NAME>
  #define                                         HE_COLOR_DIALOG_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_CAST ((vtable), \
                                                  HE_TYPE_COLOR_DIALOG, HeColorDialogClass))
</MACRO>
<MACRO>
<NAME>HE_IS_COLOR_DIALOG</NAME>
  #define                                         HE_IS_COLOR_DIALOG(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HE_TYPE_COLOR_DIALOG))
</MACRO>
<MACRO>
<NAME>HE_IS_COLOR_DIALOG_CLASS</NAME>
  #define                                         HE_IS_COLOR_DIALOG_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_TYPE ((vtable), HE_TYPE_COLOR_DIALOG))
</MACRO>
<MACRO>
<NAME>HE_COLOR_DIALOG_GET_CLASS</NAME>
  #define                                         HE_COLOR_DIALOG_GET_CLASS(inst) \
                                                  (G_TYPE_INSTANCE_GET_CLASS ((inst), \
                                                  HE_TYPE_COLOR_DIALOG, HeColorDialogClass))
</MACRO>
<STRUCT>
<NAME>HeColorDialog</NAME>
</STRUCT>
<STRUCT>
<NAME>HeColorDialogClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeColorDialogPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeColorDialog</NAME>
struct					_HeColorDialog
{
	GtkDialog parent;
	/*< private > */
    HeColorDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>HeColorDialogClass</NAME>
struct					_HeColorDialogClass
{
	GtkDialogClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>he_color_dialog_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_color_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_color_dialog_get_color</NAME>
<RETURNS>void </RETURNS>
HeColorDialog *cd, GdkColor *color
</FUNCTION>
<FUNCTION>
<NAME>he_color_dialog_set_color</NAME>
<RETURNS>void </RETURNS>
HeColorDialog *cd, GdkColor *color
</FUNCTION>
<FUNCTION>
<NAME>he_color_dialog_present</NAME>
<RETURNS>GdkColor *</RETURNS>
GtkWindow *parent, GdkColor *default_color, gchar *title
</FUNCTION>
<FUNCTION>
<NAME>he_color_dialog_present_interop</NAME>
<RETURNS>GdkColor *</RETURNS>
GdkNativeWindow parent_winid, GdkColor *default_color, gchar *title
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_FONT_BUTTON</NAME>
  #define                                         HE_TYPE_FONT_BUTTON \
                                                  (he_font_button_get_type ())
</MACRO>
<MACRO>
<NAME>HE_FONT_BUTTON</NAME>
  #define                                         HE_FONT_BUTTON(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
                                                  HE_TYPE_FONT_BUTTON, HeFontButton))
</MACRO>
<MACRO>
<NAME>HE_FONT_BUTTON_CLASS</NAME>
  #define                                         HE_FONT_BUTTON_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_CAST ((vtable), \
                                                  HE_TYPE_FONT_BUTTON, HeFontButtonClass))
</MACRO>
<MACRO>
<NAME>HE_IS_FONT_BUTTON</NAME>
  #define                                         HE_IS_FONT_BUTTON(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HE_TYPE_FONT_BUTTON))
</MACRO>
<MACRO>
<NAME>HE_IS_FONT_BUTTON_CLASS</NAME>
  #define                                         HE_IS_FONT_BUTTON_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_TYPE ((vtable), HE_TYPE_FONT_BUTTON))
</MACRO>
<MACRO>
<NAME>HE_FONT_BUTTON_GET_CLASS</NAME>
  #define                                         HE_FONT_BUTTON_GET_CLASS(inst) \
                                                  (G_TYPE_INSTANCE_GET_CLASS ((inst), \
                                                  HE_TYPE_FONT_BUTTON, HeFontButtonClass))
</MACRO>
<STRUCT>
<NAME>HeFontButton</NAME>
</STRUCT>
<STRUCT>
<NAME>HeFontButtonClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeFontButtonPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeFontButton</NAME>
struct					_HeFontButton
{
	GtkButton parent;
	/*< private > */
    HeFontButtonPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>HeFontButtonClass</NAME>
struct					_HeFontButtonClass
{
	GtkButtonClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>he_font_button_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_font_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_font_button_new_with_font</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar *font_string
</FUNCTION>
<FUNCTION>
<NAME>he_font_button_get_font</NAME>
<RETURNS>gchar *</RETURNS>
HeFontButton *fb
</FUNCTION>
<FUNCTION>
<NAME>he_font_button_set_font</NAME>
<RETURNS>void </RETURNS>
HeFontButton *fb,const gchar *font_string
</FUNCTION>
<FUNCTION>
<NAME>he_font_button_get_popup_shown</NAME>
<RETURNS>gboolean </RETURNS>
HeFontButton *fb
</FUNCTION>
<FUNCTION>
<NAME>he_font_button_popdown</NAME>
<RETURNS>void </RETURNS>
HeFontButton *fb
</FUNCTION>
<TYPEDEF>
<NAME>HildonTimeZoneChooser</NAME>
typedef struct HildonTimeZoneChooser_ HildonTimeZoneChooser;
</TYPEDEF>
<ENUM>
<NAME>FeedbackDialogResponse</NAME>
typedef enum
{
	FEEDBACK_DIALOG_RESPONSE_CITY_CHOSEN = 1,
	FEEDBACK_DIALOG_RESPONSE_CANCELLED
} FeedbackDialogResponse;
</ENUM>
<FUNCTION>
<NAME>hildon_time_zone_chooser_new</NAME>
<RETURNS>HildonTimeZoneChooser*</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>hildon_time_zone_chooser_run</NAME>
<RETURNS>FeedbackDialogResponse </RETURNS>
HildonTimeZoneChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>hildon_time_zone_chooser_set_city</NAME>
<RETURNS>void </RETURNS>
HildonTimeZoneChooser *chooser, Cityinfo *cityinfo
</FUNCTION>
<FUNCTION>
<NAME>hildon_time_zone_chooser_get_city</NAME>
<RETURNS>Cityinfo*</RETURNS>
HildonTimeZoneChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>hildon_time_zone_chooser_free</NAME>
<RETURNS>void </RETURNS>
HildonTimeZoneChooser *chooser
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_CHECK_BUTTON</NAME>
#define                                         HE_TYPE_CHECK_BUTTON \
                                                (he_check_button_get_type())
</MACRO>
<MACRO>
<NAME>HE_CHECK_BUTTON</NAME>
#define                                         HE_CHECK_BUTTON(obj) \
                                                (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
                                                HE_TYPE_CHECK_BUTTON, HeCheckButton))
</MACRO>
<MACRO>
<NAME>HE_CHECK_BUTTON_CLASS</NAME>
#define                                         HE_CHECK_BUTTON_CLASS(klass) \
                                                (G_TYPE_CHECK_CLASS_CAST ((klass), \
                                                HE_TYPE_CHECK_BUTTON, HeCheckButtonClass))
</MACRO>
<MACRO>
<NAME>HE_IS_CHECK_BUTTON</NAME>
#define                                         HE_IS_CHECK_BUTTON(obj) \
                                                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HE_TYPE_CHECK_BUTTON))
</MACRO>
<MACRO>
<NAME>HE_IS_CHECK_BUTTON_CLASS</NAME>
#define                                         HE_IS_CHECK_BUTTON_CLASS(klass) \
                                                (G_TYPE_CHECK_CLASS_TYPE ((klass), HE_TYPE_CHECK_BUTTON))
</MACRO>
<MACRO>
<NAME>HE_CHECK_BUTTON_GET_CLASS</NAME>
#define                                         HE_CHECK_BUTTON_GET_CLASS(obj) \
                                                (G_TYPE_INSTANCE_GET_CLASS ((obj), \
                                                HE_TYPE_CHECK_BUTTON, HeCheckButtonClass))
</MACRO>
<STRUCT>
<NAME>HeCheckButton</NAME>
</STRUCT>
<STRUCT>
<NAME>HeCheckButtonClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeCheckButtonPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeCheckButtonClass</NAME>
struct                                          _HeCheckButtonClass
{
    GtkButtonClass parent_class;

    /* Signal handlers */
    void (* toggled)							(HeCheckButton *button);
};
</STRUCT>
<STRUCT>
<NAME>HeCheckButton</NAME>
struct                                          _HeCheckButton
{
    GtkButton parent;

    /* private */
    HeCheckButtonPrivate *priv;
};
</STRUCT>
<ENUM>
<NAME>HeCheckButtonArrangement</NAME>
typedef enum {
   HE_CHECK_BUTTON_ARRANGEMENT_HORIZONTAL,
   HE_CHECK_BUTTON_ARRANGEMENT_VERTICAL
}                                               HeCheckButtonArrangement;
</ENUM>
<ENUM>
<NAME>HeCheckButtonStyle</NAME>
typedef enum {
   HE_CHECK_BUTTON_STYLE_NORMAL,
   HE_CHECK_BUTTON_STYLE_PICKER
}                                               HeCheckButtonStyle;
</ENUM>
<FUNCTION>
<NAME>he_check_button_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_new</NAME>
<RETURNS>GtkWidget  *</RETURNS>
HildonSizeType          size,HeCheckButtonArrangement arrangement
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_new_with_text</NAME>
<RETURNS>GtkWidget  *</RETURNS>
HildonSizeType           size,HeCheckButtonArrangement  arrangement,const gchar              *title,const gchar              *value
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_set_title</NAME>
<RETURNS>void </RETURNS>
HeCheckButton *button,const gchar    *title
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_set_value</NAME>
<RETURNS>void </RETURNS>
HeCheckButton *button,const gchar    *value
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_get_title</NAME>
<RETURNS>const gchar  *</RETURNS>
HeCheckButton *button
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_get_value</NAME>
<RETURNS>const gchar  *</RETURNS>
HeCheckButton *button
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_set_text</NAME>
<RETURNS>void </RETURNS>
HeCheckButton *button,const gchar    *title,const gchar    *value
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_set_alignment</NAME>
<RETURNS>void </RETURNS>
HeCheckButton *button,gfloat          xalign,gfloat          yalign,gfloat          xscale,gfloat          yscale
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_set_title_alignment</NAME>
<RETURNS>void </RETURNS>
HeCheckButton *button,gfloat          xalign,gfloat          yalign
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_set_value_alignment</NAME>
<RETURNS>void </RETURNS>
HeCheckButton *button,gfloat          xalign,gfloat          yalign
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_add_title_size_group</NAME>
<RETURNS>void </RETURNS>
HeCheckButton *button,GtkSizeGroup   *size_group
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_add_value_size_group</NAME>
<RETURNS>void </RETURNS>
HeCheckButton *button,GtkSizeGroup   *size_group
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_add_size_groups</NAME>
<RETURNS>void </RETURNS>
HeCheckButton *button,GtkSizeGroup   *title_size_group,GtkSizeGroup   *value_size_group,GtkSizeGroup   *image_size_group
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_set_style</NAME>
<RETURNS>void </RETURNS>
HeCheckButton      *button,HeCheckButtonStyle  style
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_get_style</NAME>
<RETURNS>HeCheckButtonStyle </RETURNS>
HeCheckButton *button
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_toggled</NAME>
<RETURNS>void </RETURNS>
HeCheckButton *button
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_set_active</NAME>
<RETURNS>void </RETURNS>
HeCheckButton *button,gboolean       is_active
</FUNCTION>
<FUNCTION>
<NAME>he_check_button_get_active</NAME>
<RETURNS>gboolean </RETURNS>
HeCheckButton *button
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_MENU_VIEW</NAME>
#define HE_TYPE_MENU_VIEW (he_menu_view_get_type())
</MACRO>
<MACRO>
<NAME>HE_MENU_VIEW</NAME>
#define HE_MENU_VIEW(object)           (G_TYPE_CHECK_INSTANCE_CAST((object), HE_TYPE_MENU_VIEW, HeMenuView))
</MACRO>
<MACRO>
<NAME>HE_MENU_VIEW_CLASS</NAME>
#define HE_MENU_VIEW_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST((klass),     HE_TYPE_MENU_VIEW, HeMenuViewClass))
</MACRO>
<MACRO>
<NAME>HE_IS_MENU_VIEW</NAME>
#define HE_IS_MENU_VIEW(object)        (G_TYPE_CHECK_INSTANCE_TYPE((object), HE_TYPE_MENU_VIEW))
</MACRO>
<MACRO>
<NAME>HE_IS_MENU_VIEW_CLASS</NAME>
#define HE_IS_MENU_VIEW_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE((klass),     HE_TYPE_MENU_VIEW))
</MACRO>
<MACRO>
<NAME>HE_MENU_VIEW_GET_CLASS</NAME>
#define HE_MENU_VIEW_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS((object),  HE_TYPE_MENU_VIEW, HeMenuViewClass))
</MACRO>
<STRUCT>
<NAME>HeMenuView</NAME>
</STRUCT>
<STRUCT>
<NAME>HeMenuViewClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeMenuViewPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeMenuView</NAME>
struct _HeMenuView
{
	GtkFixed __parent_instance__;
	HeMenuViewPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>HeMenuViewClass</NAME>
struct _HeMenuViewClass
{
	GtkFixedClass __parent_class__;
};
</STRUCT>
<FUNCTION>
<NAME>he_menu_view_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_set_menu</NAME>
<RETURNS>void </RETURNS>
HeMenuView *hmv, GtkMenu *menu
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_get_menu</NAME>
<RETURNS>GtkWidget *</RETURNS>
HeMenuView *hmv
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_get_menu_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
HeMenuView *hmv
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_set_do_activate</NAME>
<RETURNS>void </RETURNS>
HeMenuView *hmv, gboolean do_activate
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_get_do_activate</NAME>
<RETURNS>gboolean </RETURNS>
HeMenuView *hmv
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_popup</NAME>
<RETURNS>void </RETURNS>
GtkMenu *menu, GtkWindow *parent
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_handle_hildon_windows</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_FONT_SELECTOR</NAME>
  #define                                         HE_TYPE_FONT_SELECTOR \
                                                  (he_font_selector_get_type ())
</MACRO>
<MACRO>
<NAME>HE_FONT_SELECTOR</NAME>
  #define                                         HE_FONT_SELECTOR(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
                                                  HE_TYPE_FONT_SELECTOR, HeFontSelector))
</MACRO>
<MACRO>
<NAME>HE_FONT_SELECTOR_CLASS</NAME>
  #define                                         HE_FONT_SELECTOR_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_CAST ((vtable), \
                                                  HE_TYPE_FONT_SELECTOR, HeFontSelectorClass))
</MACRO>
<MACRO>
<NAME>HE_IS_FONT_SELECTOR</NAME>
  #define                                         HE_IS_FONT_SELECTOR(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HE_TYPE_FONT_SELECTOR))
</MACRO>
<MACRO>
<NAME>HE_IS_FONT_SELECTOR_CLASS</NAME>
  #define                                         HE_IS_FONT_SELECTOR_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_TYPE ((vtable), HE_TYPE_FONT_SELECTOR))
</MACRO>
<MACRO>
<NAME>HE_FONT_SELECTOR_GET_CLASS</NAME>
  #define                                         HE_FONT_SELECTOR_GET_CLASS(inst) \
                                                  (G_TYPE_INSTANCE_GET_CLASS ((inst), \
                                                  HE_TYPE_FONT_SELECTOR, HeFontSelectorClass))
</MACRO>
<STRUCT>
<NAME>HeFontSelector</NAME>
</STRUCT>
<STRUCT>
<NAME>HeFontSelectorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeFontSelectorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeFontSelector</NAME>
  struct                                          _HeFontSelector
  {
    GtkVBox parent_instance;
  
    /*< private > */
    HeFontSelectorPrivate *priv;
  };
</STRUCT>
<STRUCT>
<NAME>HeFontSelectorClass</NAME>
  struct                                          _HeFontSelectorClass
  {
    GtkVBoxClass parent_class;
  
    /* signals */
  };
</STRUCT>
<FUNCTION>
<NAME>he_font_selector_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_font_selector_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_font_selector_new_with_default_font</NAME>
<RETURNS>GtkWidget *</RETURNS>
gchar *default_font
</FUNCTION>
<FUNCTION>
<NAME>he_font_selector_select_family</NAME>
<RETURNS>gboolean </RETURNS>
HeFontSelector *selector,gchar *family
</FUNCTION>
<FUNCTION>
<NAME>he_font_selector_select_size</NAME>
<RETURNS>gboolean </RETURNS>
HeFontSelector *selector,guint size
</FUNCTION>
<FUNCTION>
<NAME>he_font_selector_set_font</NAME>
<RETURNS>gboolean </RETURNS>
HeFontSelector *selector,gchar *font_string
</FUNCTION>
<FUNCTION>
<NAME>he_font_selector_get_font</NAME>
<RETURNS>gchar  *</RETURNS>
HeFontSelector *selector
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_SIMPLE_COLOR_DIALOG</NAME>
  #define                                         HE_TYPE_SIMPLE_COLOR_DIALOG \
                                                  (he_simple_color_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>HE_SIMPLE_COLOR_DIALOG</NAME>
  #define                                         HE_SIMPLE_COLOR_DIALOG(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
                                                  HE_TYPE_SIMPLE_COLOR_DIALOG, HeSimpleColorDialog))
</MACRO>
<MACRO>
<NAME>HE_SIMPLE_COLOR_DIALOG_CLASS</NAME>
  #define                                         HE_SIMPLE_COLOR_DIALOG_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_CAST ((vtable), \
                                                  HE_TYPE_SIMPLE_COLOR_DIALOG, HeSimpleColorDialogClass))
</MACRO>
<MACRO>
<NAME>HE_IS_SIMPLE_COLOR_DIALOG</NAME>
  #define                                         HE_IS_SIMPLE_COLOR_DIALOG(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HE_TYPE_SIMPLE_COLOR_DIALOG))
</MACRO>
<MACRO>
<NAME>HE_IS_SIMPLE_COLOR_DIALOG_CLASS</NAME>
  #define                                         HE_IS_SIMPLE_COLOR_DIALOG_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_TYPE ((vtable), HE_TYPE_SIMPLE_COLOR_DIALOG))
</MACRO>
<MACRO>
<NAME>HE_SIMPLE_COLOR_DIALOG_GET_CLASS</NAME>
  #define                                         HE_SIMPLE_COLOR_DIALOG_GET_CLASS(inst) \
                                                  (G_TYPE_INSTANCE_GET_CLASS ((inst), \
                                                  HE_TYPE_SIMPLE_COLOR_DIALOG, HeSimpleColorDialogClass))                                                
</MACRO>
<MACRO>
<NAME>HE_SIMPLE_COLOR_DIALOG_DEFAULT_TITLE</NAME>
  #define                                         HE_SIMPLE_COLOR_DIALOG_DEFAULT_TITLE "Select a color"
</MACRO>
<STRUCT>
<NAME>HeSimpleColorDialog</NAME>
</STRUCT>
<STRUCT>
<NAME>HeSimpleColorDialogClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeSimpleColorDialogPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeSimpleColorDialog</NAME>
struct					_HeSimpleColorDialog
{
	GtkDialog parent;
	/*< private > */
        HeSimpleColorDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>HeSimpleColorDialogClass</NAME>
struct					_HeSimpleColorDialogClass
{
	GtkDialogClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>he_simple_color_dialog_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_simple_color_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_simple_color_dialog_set_color</NAME>
<RETURNS>void </RETURNS>
HeSimpleColorDialog* scd, GdkColor* color
</FUNCTION>
<FUNCTION>
<NAME>he_simple_color_dialog_get_color</NAME>
<RETURNS>GdkColor *</RETURNS>
HeSimpleColorDialog* scd
</FUNCTION>
<FUNCTION>
<NAME>he_simple_color_dialog_add_advanced_button</NAME>
<RETURNS>void </RETURNS>
HeSimpleColorDialog* scd
</FUNCTION>
<FUNCTION>
<NAME>he_simple_color_dialog_present</NAME>
<RETURNS>GdkColor *</RETURNS>
GtkWindow* parent, gboolean add_advanced_button, GdkColor* default_color, gchar* title
</FUNCTION>
<FUNCTION>
<NAME>he_simple_color_dialog_present_interop</NAME>
<RETURNS>GdkColor *</RETURNS>
GdkNativeWindow parent_winid, gboolean add_advanced_button, GdkColor* default_color, gchar* title
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_FONT_DIALOG</NAME>
  #define                                         HE_TYPE_FONT_DIALOG \
                                                  (he_font_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>HE_FONT_DIALOG</NAME>
  #define                                         HE_FONT_DIALOG(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
                                                  HE_TYPE_FONT_DIALOG, HeFontDialog))
</MACRO>
<MACRO>
<NAME>HE_FONT_DIALOG_CLASS</NAME>
  #define                                         HE_FONT_DIALOG_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_CAST ((vtable), \
                                                  HE_TYPE_FONT_DIALOG, HeFontDialogClass))
</MACRO>
<MACRO>
<NAME>HE_IS_FONT_DIALOG</NAME>
  #define                                         HE_IS_FONT_DIALOG(obj) \
                                                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HE_TYPE_FONT_DIALOG))
</MACRO>
<MACRO>
<NAME>HE_IS_FONT_DIALOG_CLASS</NAME>
  #define                                         HE_IS_FONT_DIALOG_CLASS(vtable) \
                                                  (G_TYPE_CHECK_CLASS_TYPE ((vtable), HE_TYPE_FONT_DIALOG))
</MACRO>
<MACRO>
<NAME>HE_FONT_DIALOG_GET_CLASS</NAME>
  #define                                         HE_FONT_DIALOG_GET_CLASS(inst) \
                                                  (G_TYPE_INSTANCE_GET_CLASS ((inst), \
                                                  HE_TYPE_FONT_DIALOG, HeFontDialogClass))
</MACRO>
<STRUCT>
<NAME>HeFontDialog</NAME>
</STRUCT>
<STRUCT>
<NAME>HeFontDialogClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeFontDialogPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeFontDialog</NAME>
struct _HeFontDialog
{
    GtkDialog parent;
    /*< private > */
    HeFontDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>HeFontDialogClass</NAME>
struct _HeFontDialogClass
{
    GtkDialogClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>he_font_dialog_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_font_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>he_font_dialog_get_font</NAME>
<RETURNS>gchar *</RETURNS>
HeFontDialog *fd
</FUNCTION>
<FUNCTION>
<NAME>he_font_dialog_set_font</NAME>
<RETURNS>void </RETURNS>
HeFontDialog *fd, gchar *font_string
</FUNCTION>
<FUNCTION>
<NAME>he_font_dialog_present</NAME>
<RETURNS>gchar *</RETURNS>
GtkWindow *parent, gchar *default_font, gchar *title
</FUNCTION>
<FUNCTION>
<NAME>he_font_dialog_present_interop</NAME>
<RETURNS>gchar *</RETURNS>
GdkNativeWindow parent_winid, gchar *default_font, gchar *title
</FUNCTION>
<MACRO>
<NAME>HE_TYPE_MENU_VIEW_COLUMN</NAME>
#define HE_TYPE_MENU_VIEW_COLUMN (he_menu_view_column_get_type())
</MACRO>
<MACRO>
<NAME>HE_MENU_VIEW_COLUMN</NAME>
#define HE_MENU_VIEW_COLUMN(object)           (G_TYPE_CHECK_INSTANCE_CAST((object), HE_TYPE_MENU_VIEW_COLUMN, HeMenuViewColumn))
</MACRO>
<MACRO>
<NAME>HE_MENU_VIEW_COLUMN_CLASS</NAME>
#define HE_MENU_VIEW_COLUMN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST((klass),     HE_TYPE_MENU_VIEW_COLUMN, HeMenuViewColumnClass))
</MACRO>
<MACRO>
<NAME>HE_IS_MENU_VIEW_COLUMN</NAME>
#define HE_IS_MENU_VIEW_COLUMN(object)        (G_TYPE_CHECK_INSTANCE_TYPE((object), HE_TYPE_MENU_VIEW_COLUMN))
</MACRO>
<MACRO>
<NAME>HE_IS_MENU_VIEW_COLUMN_CLASS</NAME>
#define HE_IS_MENU_VIEW_COLUMN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE((klass),     HE_TYPE_MENU_VIEW_COLUMN))
</MACRO>
<MACRO>
<NAME>HE_GET_MENU_VIEW_COLUMN_CLASS</NAME>
#define HE_GET_MENU_VIEW_COLUMN_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS((object),  HE_TYPE_MENU_VIEW_COLUMN, HeMenuViewColumnClass))
</MACRO>
<STRUCT>
<NAME>HeMenuViewColumn</NAME>
</STRUCT>
<STRUCT>
<NAME>HeMenuViewColumnClass</NAME>
</STRUCT>
<STRUCT>
<NAME>HeMenuViewColumnPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>HeMenuViewColumn</NAME>
struct _HeMenuViewColumn
{
	HildonPannableArea __parent_instance__;
	HeMenuViewColumnPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>HeMenuViewColumnClass</NAME>
struct _HeMenuViewColumnClass
{
	HildonPannableAreaClass __parent_class__;
};
</STRUCT>
<FUNCTION>
<NAME>he_menu_view_column_get_type</NAME>
<RETURNS>GType </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_column_set_menu</NAME>
<RETURNS>void </RETURNS>
HeMenuViewColumn *hmvc, GtkMenu *menu
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_column_get_menu</NAME>
<RETURNS>GtkWidget *</RETURNS>
HeMenuViewColumn *hmvc
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_column_get_menu_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
HeMenuViewColumn *hmvc
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_column_set_do_activate</NAME>
<RETURNS>void </RETURNS>
HeMenuViewColumn *hmvc, gboolean do_activate
</FUNCTION>
<FUNCTION>
<NAME>he_menu_view_column_get_do_activate</NAME>
<RETURNS>gboolean </RETURNS>
HeMenuViewColumn *hmvc
</FUNCTION>
