/* plank.h generated by valac 0.48.10, the Vala compiler, do not modify */

#ifndef __LIB_PLANK_H__
#define __LIB_PLANK_H__

#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include <gdk/gdk.h>
#include <gee.h>
#include <gtk/gtk.h>
#include <gio/gio.h>
#include <cairo-gobject.h>
#include <float.h>
#include <math.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <libbamf/libbamf.h>

G_BEGIN_DECLS

#define PLANK_TYPE_DBUS_MANAGER (plank_dbus_manager_get_type ())
#define PLANK_DBUS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DBUS_MANAGER, PlankDBusManager))
#define PLANK_DBUS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DBUS_MANAGER, PlankDBusManagerClass))
#define PLANK_IS_DBUS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DBUS_MANAGER))
#define PLANK_IS_DBUS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DBUS_MANAGER))
#define PLANK_DBUS_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DBUS_MANAGER, PlankDBusManagerClass))

typedef struct _PlankDBusManager PlankDBusManager;
typedef struct _PlankDBusManagerClass PlankDBusManagerClass;
typedef struct _PlankDBusManagerPrivate PlankDBusManagerPrivate;

#define PLANK_TYPE_DOCK_ELEMENT (plank_dock_element_get_type ())
#define PLANK_DOCK_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_ELEMENT, PlankDockElement))
#define PLANK_DOCK_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_ELEMENT, PlankDockElementClass))
#define PLANK_IS_DOCK_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_ELEMENT))
#define PLANK_IS_DOCK_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_ELEMENT))
#define PLANK_DOCK_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_ELEMENT, PlankDockElementClass))

typedef struct _PlankDockElement PlankDockElement;
typedef struct _PlankDockElementClass PlankDockElementClass;

#define PLANK_TYPE_DOCK_CONTAINER (plank_dock_container_get_type ())
#define PLANK_DOCK_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_CONTAINER, PlankDockContainer))
#define PLANK_DOCK_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_CONTAINER, PlankDockContainerClass))
#define PLANK_IS_DOCK_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_CONTAINER))
#define PLANK_IS_DOCK_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_CONTAINER))
#define PLANK_DOCK_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_CONTAINER, PlankDockContainerClass))

typedef struct _PlankDockContainer PlankDockContainer;
typedef struct _PlankDockContainerClass PlankDockContainerClass;

#define PLANK_TYPE_DOCK_CONTROLLER (plank_dock_controller_get_type ())
#define PLANK_DOCK_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_CONTROLLER, PlankDockController))
#define PLANK_DOCK_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_CONTROLLER, PlankDockControllerClass))
#define PLANK_IS_DOCK_CONTROLLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_CONTROLLER))
#define PLANK_IS_DOCK_CONTROLLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_CONTROLLER))
#define PLANK_DOCK_CONTROLLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_CONTROLLER, PlankDockControllerClass))

typedef struct _PlankDockController PlankDockController;
typedef struct _PlankDockControllerClass PlankDockControllerClass;
typedef struct _PlankDockElementPrivate PlankDockElementPrivate;
typedef enum  {
	PLANK_POPUP_BUTTON_NONE = 1 << 0,
	PLANK_POPUP_BUTTON_LEFT = 1 << 1,
	PLANK_POPUP_BUTTON_MIDDLE = 1 << 2,
	PLANK_POPUP_BUTTON_RIGHT = 1 << 3
} PlankPopupButton;

#define PLANK_TYPE_POPUP_BUTTON (plank_popup_button_get_type ())
typedef enum  {
	PLANK_ANIMATION_TYPE_NONE,
	PLANK_ANIMATION_TYPE_BOUNCE,
	PLANK_ANIMATION_TYPE_DARKEN,
	PLANK_ANIMATION_TYPE_LIGHTEN
} PlankAnimationType;

#define PLANK_TYPE_ANIMATION_TYPE (plank_animation_type_get_type ())
typedef struct _PlankDockContainerPrivate PlankDockContainerPrivate;
typedef struct _PlankDockControllerPrivate PlankDockControllerPrivate;

#define PLANK_TYPE_SETTINGS (plank_settings_get_type ())
#define PLANK_SETTINGS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_SETTINGS, PlankSettings))
#define PLANK_SETTINGS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_SETTINGS, PlankSettingsClass))
#define PLANK_IS_SETTINGS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_SETTINGS))
#define PLANK_IS_SETTINGS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_SETTINGS))
#define PLANK_SETTINGS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_SETTINGS, PlankSettingsClass))

typedef struct _PlankSettings PlankSettings;
typedef struct _PlankSettingsClass PlankSettingsClass;

#define PLANK_TYPE_DOCK_PREFERENCES (plank_dock_preferences_get_type ())
#define PLANK_DOCK_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_PREFERENCES, PlankDockPreferences))
#define PLANK_DOCK_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_PREFERENCES, PlankDockPreferencesClass))
#define PLANK_IS_DOCK_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_PREFERENCES))
#define PLANK_IS_DOCK_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_PREFERENCES))
#define PLANK_DOCK_PREFERENCES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_PREFERENCES, PlankDockPreferencesClass))

typedef struct _PlankDockPreferences PlankDockPreferences;
typedef struct _PlankDockPreferencesClass PlankDockPreferencesClass;

#define PLANK_TYPE_DRAG_MANAGER (plank_drag_manager_get_type ())
#define PLANK_DRAG_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DRAG_MANAGER, PlankDragManager))
#define PLANK_DRAG_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DRAG_MANAGER, PlankDragManagerClass))
#define PLANK_IS_DRAG_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DRAG_MANAGER))
#define PLANK_IS_DRAG_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DRAG_MANAGER))
#define PLANK_DRAG_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DRAG_MANAGER, PlankDragManagerClass))

typedef struct _PlankDragManager PlankDragManager;
typedef struct _PlankDragManagerClass PlankDragManagerClass;

#define PLANK_TYPE_HIDE_MANAGER (plank_hide_manager_get_type ())
#define PLANK_HIDE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_HIDE_MANAGER, PlankHideManager))
#define PLANK_HIDE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_HIDE_MANAGER, PlankHideManagerClass))
#define PLANK_IS_HIDE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_HIDE_MANAGER))
#define PLANK_IS_HIDE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_HIDE_MANAGER))
#define PLANK_HIDE_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_HIDE_MANAGER, PlankHideManagerClass))

typedef struct _PlankHideManager PlankHideManager;
typedef struct _PlankHideManagerClass PlankHideManagerClass;

#define PLANK_TYPE_POSITION_MANAGER (plank_position_manager_get_type ())
#define PLANK_POSITION_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_POSITION_MANAGER, PlankPositionManager))
#define PLANK_POSITION_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_POSITION_MANAGER, PlankPositionManagerClass))
#define PLANK_IS_POSITION_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_POSITION_MANAGER))
#define PLANK_IS_POSITION_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_POSITION_MANAGER))
#define PLANK_POSITION_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_POSITION_MANAGER, PlankPositionManagerClass))

typedef struct _PlankPositionManager PlankPositionManager;
typedef struct _PlankPositionManagerClass PlankPositionManagerClass;

#define PLANK_TYPE_RENDERER (plank_renderer_get_type ())
#define PLANK_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_RENDERER, PlankRenderer))
#define PLANK_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_RENDERER, PlankRendererClass))
#define PLANK_IS_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_RENDERER))
#define PLANK_IS_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_RENDERER))
#define PLANK_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_RENDERER, PlankRendererClass))

typedef struct _PlankRenderer PlankRenderer;
typedef struct _PlankRendererClass PlankRendererClass;

#define PLANK_TYPE_DOCK_RENDERER (plank_dock_renderer_get_type ())
#define PLANK_DOCK_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_RENDERER, PlankDockRenderer))
#define PLANK_DOCK_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_RENDERER, PlankDockRendererClass))
#define PLANK_IS_DOCK_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_RENDERER))
#define PLANK_IS_DOCK_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_RENDERER))
#define PLANK_DOCK_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_RENDERER, PlankDockRendererClass))

typedef struct _PlankDockRenderer PlankDockRenderer;
typedef struct _PlankDockRendererClass PlankDockRendererClass;

#define PLANK_TYPE_COMPOSITED_WINDOW (plank_composited_window_get_type ())
#define PLANK_COMPOSITED_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_COMPOSITED_WINDOW, PlankCompositedWindow))
#define PLANK_COMPOSITED_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_COMPOSITED_WINDOW, PlankCompositedWindowClass))
#define PLANK_IS_COMPOSITED_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_COMPOSITED_WINDOW))
#define PLANK_IS_COMPOSITED_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_COMPOSITED_WINDOW))
#define PLANK_COMPOSITED_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_COMPOSITED_WINDOW, PlankCompositedWindowClass))

typedef struct _PlankCompositedWindow PlankCompositedWindow;
typedef struct _PlankCompositedWindowClass PlankCompositedWindowClass;

#define PLANK_TYPE_DOCK_WINDOW (plank_dock_window_get_type ())
#define PLANK_DOCK_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_WINDOW, PlankDockWindow))
#define PLANK_DOCK_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_WINDOW, PlankDockWindowClass))
#define PLANK_IS_DOCK_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_WINDOW))
#define PLANK_IS_DOCK_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_WINDOW))
#define PLANK_DOCK_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_WINDOW, PlankDockWindowClass))

typedef struct _PlankDockWindow PlankDockWindow;
typedef struct _PlankDockWindowClass PlankDockWindowClass;

#define PLANK_TYPE_HOVER_WINDOW (plank_hover_window_get_type ())
#define PLANK_HOVER_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_HOVER_WINDOW, PlankHoverWindow))
#define PLANK_HOVER_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_HOVER_WINDOW, PlankHoverWindowClass))
#define PLANK_IS_HOVER_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_HOVER_WINDOW))
#define PLANK_IS_HOVER_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_HOVER_WINDOW))
#define PLANK_HOVER_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_HOVER_WINDOW, PlankHoverWindowClass))

typedef struct _PlankHoverWindow PlankHoverWindow;
typedef struct _PlankHoverWindowClass PlankHoverWindowClass;

#define PLANK_TYPE_DOCK_ITEM_PROVIDER (plank_dock_item_provider_get_type ())
#define PLANK_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_ITEM_PROVIDER, PlankDockItemProvider))
#define PLANK_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_ITEM_PROVIDER, PlankDockItemProviderClass))
#define PLANK_IS_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_ITEM_PROVIDER))
#define PLANK_IS_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_ITEM_PROVIDER))
#define PLANK_DOCK_ITEM_PROVIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_ITEM_PROVIDER, PlankDockItemProviderClass))

typedef struct _PlankDockItemProvider PlankDockItemProvider;
typedef struct _PlankDockItemProviderClass PlankDockItemProviderClass;

#define PLANK_TYPE_DOCK_ITEM (plank_dock_item_get_type ())
#define PLANK_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_ITEM, PlankDockItem))
#define PLANK_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_ITEM, PlankDockItemClass))
#define PLANK_IS_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_ITEM))
#define PLANK_IS_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_ITEM))
#define PLANK_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_ITEM, PlankDockItemClass))

typedef struct _PlankDockItem PlankDockItem;
typedef struct _PlankDockItemClass PlankDockItemClass;
typedef struct _PlankSettingsPrivate PlankSettingsPrivate;
typedef struct _PlankDockPreferencesPrivate PlankDockPreferencesPrivate;
typedef enum  {
	PLANK_HIDE_TYPE_NONE,
	PLANK_HIDE_TYPE_INTELLIGENT,
	PLANK_HIDE_TYPE_AUTO,
	PLANK_HIDE_TYPE_DODGE_MAXIMIZED,
	PLANK_HIDE_TYPE_WINDOW_DODGE,
	PLANK_HIDE_TYPE_DODGE_ACTIVE
} PlankHideType;

#define PLANK_TYPE_HIDE_TYPE (plank_hide_type_get_type ())
typedef struct _PlankRendererPrivate PlankRendererPrivate;
typedef struct _PlankDockRendererPrivate PlankDockRendererPrivate;

#define PLANK_TYPE_PREFERENCES (plank_preferences_get_type ())
#define PLANK_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_PREFERENCES, PlankPreferences))
#define PLANK_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_PREFERENCES, PlankPreferencesClass))
#define PLANK_IS_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_PREFERENCES))
#define PLANK_IS_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_PREFERENCES))
#define PLANK_PREFERENCES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_PREFERENCES, PlankPreferencesClass))

typedef struct _PlankPreferences PlankPreferences;
typedef struct _PlankPreferencesClass PlankPreferencesClass;

#define PLANK_TYPE_THEME (plank_theme_get_type ())
#define PLANK_THEME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_THEME, PlankTheme))
#define PLANK_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_THEME, PlankThemeClass))
#define PLANK_IS_THEME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_THEME))
#define PLANK_IS_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_THEME))
#define PLANK_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_THEME, PlankThemeClass))

typedef struct _PlankTheme PlankTheme;
typedef struct _PlankThemeClass PlankThemeClass;

#define PLANK_TYPE_DOCK_THEME (plank_dock_theme_get_type ())
#define PLANK_DOCK_THEME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_THEME, PlankDockTheme))
#define PLANK_DOCK_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_THEME, PlankDockThemeClass))
#define PLANK_IS_DOCK_THEME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_THEME))
#define PLANK_IS_DOCK_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_THEME))
#define PLANK_DOCK_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_THEME, PlankDockThemeClass))

typedef struct _PlankDockTheme PlankDockTheme;
typedef struct _PlankDockThemeClass PlankDockThemeClass;
typedef struct _PlankDragManagerPrivate PlankDragManagerPrivate;
typedef struct _PlankHideManagerPrivate PlankHideManagerPrivate;
typedef struct _PlankPositionManagerPrivate PlankPositionManagerPrivate;

#define PLANK_TYPE_DOCK_ITEM_DRAW_VALUE (plank_dock_item_draw_value_get_type ())
#define PLANK_DOCK_ITEM_DRAW_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_ITEM_DRAW_VALUE, PlankDockItemDrawValue))
#define PLANK_DOCK_ITEM_DRAW_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_ITEM_DRAW_VALUE, PlankDockItemDrawValueClass))
#define PLANK_IS_DOCK_ITEM_DRAW_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_ITEM_DRAW_VALUE))
#define PLANK_IS_DOCK_ITEM_DRAW_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_ITEM_DRAW_VALUE))
#define PLANK_DOCK_ITEM_DRAW_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_ITEM_DRAW_VALUE, PlankDockItemDrawValueClass))

typedef struct _PlankDockItemDrawValue PlankDockItemDrawValue;
typedef struct _PlankDockItemDrawValueClass PlankDockItemDrawValueClass;
typedef void (*PlankDrawValueFunc) (PlankDockItem* item, PlankDockItemDrawValue* draw_value, gpointer user_data);
typedef void (*PlankDrawValuesFunc) (GeeHashMap* draw_values, gpointer user_data);

#define PLANK_TYPE_APPLICATION_DOCK_ITEM (plank_application_dock_item_get_type ())
#define PLANK_APPLICATION_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM, PlankApplicationDockItem))
#define PLANK_APPLICATION_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_APPLICATION_DOCK_ITEM, PlankApplicationDockItemClass))
#define PLANK_IS_APPLICATION_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM))
#define PLANK_IS_APPLICATION_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_APPLICATION_DOCK_ITEM))
#define PLANK_APPLICATION_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM, PlankApplicationDockItemClass))

typedef struct _PlankApplicationDockItem PlankApplicationDockItem;
typedef struct _PlankApplicationDockItemClass PlankApplicationDockItemClass;

#define PLANK_TYPE_DBUS_CLIENT (plank_dbus_client_get_type ())
#define PLANK_DBUS_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DBUS_CLIENT, PlankDBusClient))
#define PLANK_DBUS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DBUS_CLIENT, PlankDBusClientClass))
#define PLANK_IS_DBUS_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DBUS_CLIENT))
#define PLANK_IS_DBUS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DBUS_CLIENT))
#define PLANK_DBUS_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DBUS_CLIENT, PlankDBusClientClass))

typedef struct _PlankDBusClient PlankDBusClient;
typedef struct _PlankDBusClientClass PlankDBusClientClass;
typedef struct _PlankDBusClientPrivate PlankDBusClientPrivate;

#define PLANK_TYPE_DOCKLET (plank_docklet_get_type ())
#define PLANK_DOCKLET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCKLET, PlankDocklet))
#define PLANK_IS_DOCKLET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCKLET))
#define PLANK_DOCKLET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), PLANK_TYPE_DOCKLET, PlankDockletIface))

typedef struct _PlankDocklet PlankDocklet;
typedef struct _PlankDockletIface PlankDockletIface;
typedef struct _PlankDockItemPrivate PlankDockItemPrivate;

#define PLANK_TYPE_SURFACE (plank_surface_get_type ())
#define PLANK_SURFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_SURFACE, PlankSurface))
#define PLANK_SURFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_SURFACE, PlankSurfaceClass))
#define PLANK_IS_SURFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_SURFACE))
#define PLANK_IS_SURFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_SURFACE))
#define PLANK_SURFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_SURFACE, PlankSurfaceClass))

typedef struct _PlankSurface PlankSurface;
typedef struct _PlankSurfaceClass PlankSurfaceClass;

#define PLANK_TYPE_DOCKLET_ITEM (plank_docklet_item_get_type ())
#define PLANK_DOCKLET_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCKLET_ITEM, PlankDockletItem))
#define PLANK_DOCKLET_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCKLET_ITEM, PlankDockletItemClass))
#define PLANK_IS_DOCKLET_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCKLET_ITEM))
#define PLANK_IS_DOCKLET_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCKLET_ITEM))
#define PLANK_DOCKLET_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCKLET_ITEM, PlankDockletItemClass))

typedef struct _PlankDockletItem PlankDockletItem;
typedef struct _PlankDockletItemClass PlankDockletItemClass;
typedef struct _PlankDockletItemPrivate PlankDockletItemPrivate;

#define PLANK_TYPE_DOCKLET_MANAGER (plank_docklet_manager_get_type ())
#define PLANK_DOCKLET_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCKLET_MANAGER, PlankDockletManager))
#define PLANK_DOCKLET_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCKLET_MANAGER, PlankDockletManagerClass))
#define PLANK_IS_DOCKLET_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCKLET_MANAGER))
#define PLANK_IS_DOCKLET_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCKLET_MANAGER))
#define PLANK_DOCKLET_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCKLET_MANAGER, PlankDockletManagerClass))

typedef struct _PlankDockletManager PlankDockletManager;
typedef struct _PlankDockletManagerClass PlankDockletManagerClass;
typedef void (*PlankDockletInitFunc) (PlankDockletManager* manager, gpointer user_data);
typedef struct _PlankDockletManagerPrivate PlankDockletManagerPrivate;

#define PLANK_TYPE_COLOR (plank_color_get_type ())
typedef GdkRGBA PlankColor;

#define PLANK_TYPE_DRAWING_SERVICE (plank_drawing_service_get_type ())
#define PLANK_DRAWING_SERVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DRAWING_SERVICE, PlankDrawingService))
#define PLANK_DRAWING_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DRAWING_SERVICE, PlankDrawingServiceClass))
#define PLANK_IS_DRAWING_SERVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DRAWING_SERVICE))
#define PLANK_IS_DRAWING_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DRAWING_SERVICE))
#define PLANK_DRAWING_SERVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DRAWING_SERVICE, PlankDrawingServiceClass))

typedef struct _PlankDrawingService PlankDrawingService;
typedef struct _PlankDrawingServiceClass PlankDrawingServiceClass;
typedef struct _PlankDrawingServicePrivate PlankDrawingServicePrivate;
typedef struct _PlankPreferencesPrivate PlankPreferencesPrivate;
typedef struct _PlankThemePrivate PlankThemePrivate;
typedef struct _PlankDockThemePrivate PlankDockThemePrivate;
typedef enum  {
	PLANK_ANIMATION_MODE_CUSTOM = 0,
	PLANK_ANIMATION_MODE_LINEAR,
	PLANK_ANIMATION_MODE_EASE_IN_QUAD,
	PLANK_ANIMATION_MODE_EASE_OUT_QUAD,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_QUAD,
	PLANK_ANIMATION_MODE_EASE_IN_CUBIC,
	PLANK_ANIMATION_MODE_EASE_OUT_CUBIC,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_CUBIC,
	PLANK_ANIMATION_MODE_EASE_IN_QUART,
	PLANK_ANIMATION_MODE_EASE_OUT_QUART,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_QUART,
	PLANK_ANIMATION_MODE_EASE_IN_QUINT,
	PLANK_ANIMATION_MODE_EASE_OUT_QUINT,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_QUINT,
	PLANK_ANIMATION_MODE_EASE_IN_SINE,
	PLANK_ANIMATION_MODE_EASE_OUT_SINE,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_SINE,
	PLANK_ANIMATION_MODE_EASE_IN_EXPO,
	PLANK_ANIMATION_MODE_EASE_OUT_EXPO,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_EXPO,
	PLANK_ANIMATION_MODE_EASE_IN_CIRC,
	PLANK_ANIMATION_MODE_EASE_OUT_CIRC,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_CIRC,
	PLANK_ANIMATION_MODE_EASE_IN_ELASTIC,
	PLANK_ANIMATION_MODE_EASE_OUT_ELASTIC,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_ELASTIC,
	PLANK_ANIMATION_MODE_EASE_IN_BACK,
	PLANK_ANIMATION_MODE_EASE_OUT_BACK,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_BACK,
	PLANK_ANIMATION_MODE_EASE_IN_BOUNCE,
	PLANK_ANIMATION_MODE_EASE_OUT_BOUNCE,
	PLANK_ANIMATION_MODE_EASE_IN_OUT_BOUNCE,
	PLANK_ANIMATION_MODE_LAST
} PlankAnimationMode;

#define PLANK_TYPE_ANIMATION_MODE (plank_animation_mode_get_type ())
typedef struct _PlankSurfacePrivate PlankSurfacePrivate;
typedef PlankSurface* (*PlankDrawDataFunc) (gint width, gint height, PlankSurface* model, gconstpointer data, gpointer user_data);
typedef PlankSurface* (*PlankDrawFunc) (gint width, gint height, PlankSurface* model, PlankDrawDataFunc draw_data_func, gpointer draw_data_func_target, gpointer user_data);
typedef enum  {
	PLANK_SURFACE_CACHE_FLAGS_NONE = 0,
	PLANK_SURFACE_CACHE_FLAGS_ALLOW_DOWNSCALE = 1 << 0,
	PLANK_SURFACE_CACHE_FLAGS_ALLOW_UPSCALE = 1 << 1,
	PLANK_SURFACE_CACHE_FLAGS_ALLOW_SCALE = PLANK_SURFACE_CACHE_FLAGS_ALLOW_UPSCALE | PLANK_SURFACE_CACHE_FLAGS_ALLOW_DOWNSCALE,
	PLANK_SURFACE_CACHE_FLAGS_ADAPTIVE_SCALE = 1 << 2
} PlankSurfaceCacheFlags;

#define PLANK_TYPE_SURFACE_CACHE_FLAGS (plank_surface_cache_flags_get_type ())

#define PLANK_TYPE_SURFACE_CACHE (plank_surface_cache_get_type ())
#define PLANK_SURFACE_CACHE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_SURFACE_CACHE, PlankSurfaceCache))
#define PLANK_SURFACE_CACHE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_SURFACE_CACHE, PlankSurfaceCacheClass))
#define PLANK_IS_SURFACE_CACHE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_SURFACE_CACHE))
#define PLANK_IS_SURFACE_CACHE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_SURFACE_CACHE))
#define PLANK_SURFACE_CACHE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_SURFACE_CACHE, PlankSurfaceCacheClass))

typedef struct _PlankSurfaceCache PlankSurfaceCache;
typedef struct _PlankSurfaceCacheClass PlankSurfaceCacheClass;
typedef struct _PlankSurfaceCachePrivate PlankSurfaceCachePrivate;

#define PLANK_TYPE_ABSTRACT_MAIN (plank_abstract_main_get_type ())
#define PLANK_ABSTRACT_MAIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_ABSTRACT_MAIN, PlankAbstractMain))
#define PLANK_ABSTRACT_MAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_ABSTRACT_MAIN, PlankAbstractMainClass))
#define PLANK_IS_ABSTRACT_MAIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_ABSTRACT_MAIN))
#define PLANK_IS_ABSTRACT_MAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_ABSTRACT_MAIN))
#define PLANK_ABSTRACT_MAIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_ABSTRACT_MAIN, PlankAbstractMainClass))

typedef struct _PlankAbstractMain PlankAbstractMain;
typedef struct _PlankAbstractMainClass PlankAbstractMainClass;
typedef struct _PlankAbstractMainPrivate PlankAbstractMainPrivate;

#define PLANK_TYPE_FACTORY (plank_factory_get_type ())
#define PLANK_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_FACTORY, PlankFactory))
#define PLANK_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_FACTORY, PlankFactoryClass))
#define PLANK_IS_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_FACTORY))
#define PLANK_IS_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_FACTORY))
#define PLANK_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_FACTORY, PlankFactoryClass))

typedef struct _PlankFactory PlankFactory;
typedef struct _PlankFactoryClass PlankFactoryClass;
typedef struct _PlankFactoryPrivate PlankFactoryPrivate;

#define PLANK_TYPE_ITEM_FACTORY (plank_item_factory_get_type ())
#define PLANK_ITEM_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_ITEM_FACTORY, PlankItemFactory))
#define PLANK_ITEM_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_ITEM_FACTORY, PlankItemFactoryClass))
#define PLANK_IS_ITEM_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_ITEM_FACTORY))
#define PLANK_IS_ITEM_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_ITEM_FACTORY))
#define PLANK_ITEM_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_ITEM_FACTORY, PlankItemFactoryClass))

typedef struct _PlankItemFactory PlankItemFactory;
typedef struct _PlankItemFactoryClass PlankItemFactoryClass;
typedef struct _PlankItemFactoryPrivate PlankItemFactoryPrivate;
typedef struct _PlankApplicationDockItemPrivate PlankApplicationDockItemPrivate;
typedef struct _PlankDockItemProviderPrivate PlankDockItemProviderPrivate;

#define PLANK_TYPE_UNITY_CLIENT (plank_unity_client_get_type ())
#define PLANK_UNITY_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_UNITY_CLIENT, PlankUnityClient))
#define PLANK_IS_UNITY_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_UNITY_CLIENT))
#define PLANK_UNITY_CLIENT_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), PLANK_TYPE_UNITY_CLIENT, PlankUnityClientIface))

typedef struct _PlankUnityClient PlankUnityClient;
typedef struct _PlankUnityClientIface PlankUnityClientIface;

#define PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER (plank_application_dock_item_provider_get_type ())
#define PLANK_APPLICATION_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER, PlankApplicationDockItemProvider))
#define PLANK_APPLICATION_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER, PlankApplicationDockItemProviderClass))
#define PLANK_IS_APPLICATION_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER))
#define PLANK_IS_APPLICATION_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER))
#define PLANK_APPLICATION_DOCK_ITEM_PROVIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_APPLICATION_DOCK_ITEM_PROVIDER, PlankApplicationDockItemProviderClass))

typedef struct _PlankApplicationDockItemProvider PlankApplicationDockItemProvider;
typedef struct _PlankApplicationDockItemProviderClass PlankApplicationDockItemProviderClass;
typedef struct _PlankApplicationDockItemProviderPrivate PlankApplicationDockItemProviderPrivate;

#define PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER (plank_default_application_dock_item_provider_get_type ())
#define PLANK_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER, PlankDefaultApplicationDockItemProvider))
#define PLANK_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER, PlankDefaultApplicationDockItemProviderClass))
#define PLANK_IS_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER))
#define PLANK_IS_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER))
#define PLANK_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DEFAULT_APPLICATION_DOCK_ITEM_PROVIDER, PlankDefaultApplicationDockItemProviderClass))

typedef struct _PlankDefaultApplicationDockItemProvider PlankDefaultApplicationDockItemProvider;
typedef struct _PlankDefaultApplicationDockItemProviderClass PlankDefaultApplicationDockItemProviderClass;
typedef struct _PlankDefaultApplicationDockItemProviderPrivate PlankDefaultApplicationDockItemProviderPrivate;

#define PLANK_TYPE_PLACEHOLDER_DOCK_ITEM (plank_placeholder_dock_item_get_type ())
#define PLANK_PLACEHOLDER_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_PLACEHOLDER_DOCK_ITEM, PlankPlaceholderDockItem))
#define PLANK_PLACEHOLDER_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_PLACEHOLDER_DOCK_ITEM, PlankPlaceholderDockItemClass))
#define PLANK_IS_PLACEHOLDER_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_PLACEHOLDER_DOCK_ITEM))
#define PLANK_IS_PLACEHOLDER_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_PLACEHOLDER_DOCK_ITEM))
#define PLANK_PLACEHOLDER_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_PLACEHOLDER_DOCK_ITEM, PlankPlaceholderDockItemClass))

typedef struct _PlankPlaceholderDockItem PlankPlaceholderDockItem;
typedef struct _PlankPlaceholderDockItemClass PlankPlaceholderDockItemClass;
typedef enum  {
	PLANK_ITEM_STATE_NORMAL = 1 << 0,
	PLANK_ITEM_STATE_ACTIVE = 1 << 1,
	PLANK_ITEM_STATE_URGENT = 1 << 2,
	PLANK_ITEM_STATE_MOVE = 1 << 3,
	PLANK_ITEM_STATE_INVALID = 1 << 4
} PlankItemState;

#define PLANK_TYPE_ITEM_STATE (plank_item_state_get_type ())
typedef enum  {
	PLANK_INDICATOR_STATE_NONE,
	PLANK_INDICATOR_STATE_SINGLE,
	PLANK_INDICATOR_STATE_SINGLE_PLUS
} PlankIndicatorState;

#define PLANK_TYPE_INDICATOR_STATE (plank_indicator_state_get_type ())

#define PLANK_TYPE_DOCK_ITEM_PREFERENCES (plank_dock_item_preferences_get_type ())
#define PLANK_DOCK_ITEM_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_DOCK_ITEM_PREFERENCES, PlankDockItemPreferences))
#define PLANK_DOCK_ITEM_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_DOCK_ITEM_PREFERENCES, PlankDockItemPreferencesClass))
#define PLANK_IS_DOCK_ITEM_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_DOCK_ITEM_PREFERENCES))
#define PLANK_IS_DOCK_ITEM_PREFERENCES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_DOCK_ITEM_PREFERENCES))
#define PLANK_DOCK_ITEM_PREFERENCES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_DOCK_ITEM_PREFERENCES, PlankDockItemPreferencesClass))

typedef struct _PlankDockItemPreferences PlankDockItemPreferences;
typedef struct _PlankDockItemPreferencesClass PlankDockItemPreferencesClass;

#define PLANK_TYPE_POINT_D (plank_point_d_get_type ())
typedef struct _PlankPointD PlankPointD;
typedef struct _PlankDockItemDrawValuePrivate PlankDockItemDrawValuePrivate;
typedef struct _PlankDockItemPreferencesPrivate PlankDockItemPreferencesPrivate;

#define PLANK_TYPE_FILE_DOCK_ITEM (plank_file_dock_item_get_type ())
#define PLANK_FILE_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_FILE_DOCK_ITEM, PlankFileDockItem))
#define PLANK_FILE_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_FILE_DOCK_ITEM, PlankFileDockItemClass))
#define PLANK_IS_FILE_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_FILE_DOCK_ITEM))
#define PLANK_IS_FILE_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_FILE_DOCK_ITEM))
#define PLANK_FILE_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_FILE_DOCK_ITEM, PlankFileDockItemClass))

typedef struct _PlankFileDockItem PlankFileDockItem;
typedef struct _PlankFileDockItemClass PlankFileDockItemClass;
typedef struct _PlankFileDockItemPrivate PlankFileDockItemPrivate;
typedef struct _PlankPlaceholderDockItemPrivate PlankPlaceholderDockItemPrivate;

#define PLANK_TYPE_PLANK_DOCK_ITEM (plank_plank_dock_item_get_type ())
#define PLANK_PLANK_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_PLANK_DOCK_ITEM, PlankPlankDockItem))
#define PLANK_PLANK_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_PLANK_DOCK_ITEM, PlankPlankDockItemClass))
#define PLANK_IS_PLANK_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_PLANK_DOCK_ITEM))
#define PLANK_IS_PLANK_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_PLANK_DOCK_ITEM))
#define PLANK_PLANK_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_PLANK_DOCK_ITEM, PlankPlankDockItemClass))

typedef struct _PlankPlankDockItem PlankPlankDockItem;
typedef struct _PlankPlankDockItemClass PlankPlankDockItemClass;
typedef struct _PlankPlankDockItemPrivate PlankPlankDockItemPrivate;

#define PLANK_TYPE_TRANSIENT_DOCK_ITEM (plank_transient_dock_item_get_type ())
#define PLANK_TRANSIENT_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_TRANSIENT_DOCK_ITEM, PlankTransientDockItem))
#define PLANK_TRANSIENT_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_TRANSIENT_DOCK_ITEM, PlankTransientDockItemClass))
#define PLANK_IS_TRANSIENT_DOCK_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_TRANSIENT_DOCK_ITEM))
#define PLANK_IS_TRANSIENT_DOCK_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_TRANSIENT_DOCK_ITEM))
#define PLANK_TRANSIENT_DOCK_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_TRANSIENT_DOCK_ITEM, PlankTransientDockItemClass))

typedef struct _PlankTransientDockItem PlankTransientDockItem;
typedef struct _PlankTransientDockItemClass PlankTransientDockItemClass;
typedef struct _PlankTransientDockItemPrivate PlankTransientDockItemPrivate;
typedef enum  {
	PLANK_XDG_SESSION_CLASS_USER,
	PLANK_XDG_SESSION_CLASS_GREETER,
	PLANK_XDG_SESSION_CLASS_LOCK_SCREEN,
	PLANK_XDG_SESSION_CLASS_BACKGROUND
} PlankXdgSessionClass;

#define PLANK_TYPE_XDG_SESSION_CLASS (plank_xdg_session_class_get_type ())
typedef enum  {
	PLANK_XDG_SESSION_DESKTOP_GNOME = 1 << 0,
	PLANK_XDG_SESSION_DESKTOP_KDE = 1 << 1,
	PLANK_XDG_SESSION_DESKTOP_LXDE = 1 << 2,
	PLANK_XDG_SESSION_DESKTOP_MATE = 1 << 3,
	PLANK_XDG_SESSION_DESKTOP_RAZOR = 1 << 4,
	PLANK_XDG_SESSION_DESKTOP_ROX = 1 << 5,
	PLANK_XDG_SESSION_DESKTOP_TDE = 1 << 6,
	PLANK_XDG_SESSION_DESKTOP_UNITY = 1 << 7,
	PLANK_XDG_SESSION_DESKTOP_XFCE = 1 << 8,
	PLANK_XDG_SESSION_DESKTOP_EDE = 1 << 9,
	PLANK_XDG_SESSION_DESKTOP_CINNAMON = 1 << 10,
	PLANK_XDG_SESSION_DESKTOP_PANTHEON = 1 << 11,
	PLANK_XDG_SESSION_DESKTOP_OLD = 1 << 12,
	PLANK_XDG_SESSION_DESKTOP_UBUNTU = 1 << 13
} PlankXdgSessionDesktop;

#define PLANK_TYPE_XDG_SESSION_DESKTOP (plank_xdg_session_desktop_get_type ())
typedef enum  {
	PLANK_XDG_SESSION_TYPE_UNSPECIFIED,
	PLANK_XDG_SESSION_TYPE_TTY,
	PLANK_XDG_SESSION_TYPE_X11,
	PLANK_XDG_SESSION_TYPE_WAYLAND,
	PLANK_XDG_SESSION_TYPE_MIR
} PlankXdgSessionType;

#define PLANK_TYPE_XDG_SESSION_TYPE (plank_xdg_session_type_get_type ())
typedef enum  {
	PLANK_LOG_LEVEL_VERBOSE,
	PLANK_LOG_LEVEL_DEBUG,
	PLANK_LOG_LEVEL_INFO,
	PLANK_LOG_LEVEL_NOTIFY,
	PLANK_LOG_LEVEL_WARN,
	PLANK_LOG_LEVEL_CRITICAL,
	PLANK_LOG_LEVEL_ERROR
} PlankLogLevel;

#define PLANK_TYPE_LOG_LEVEL (plank_log_level_get_type ())

#define PLANK_TYPE_LOGGER (plank_logger_get_type ())
#define PLANK_LOGGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_LOGGER, PlankLogger))
#define PLANK_LOGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_LOGGER, PlankLoggerClass))
#define PLANK_IS_LOGGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_LOGGER))
#define PLANK_IS_LOGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_LOGGER))
#define PLANK_LOGGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_LOGGER, PlankLoggerClass))

typedef struct _PlankLogger PlankLogger;
typedef struct _PlankLoggerClass PlankLoggerClass;
typedef struct _PlankLoggerPrivate PlankLoggerPrivate;

#define PLANK_TYPE_PATHS (plank_paths_get_type ())
#define PLANK_PATHS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_PATHS, PlankPaths))
#define PLANK_PATHS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_PATHS, PlankPathsClass))
#define PLANK_IS_PATHS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_PATHS))
#define PLANK_IS_PATHS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_PATHS))
#define PLANK_PATHS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_PATHS, PlankPathsClass))

typedef struct _PlankPaths PlankPaths;
typedef struct _PlankPathsClass PlankPathsClass;
typedef struct _PlankPathsPrivate PlankPathsPrivate;

#define PLANK_TYPE_SERIALIZABLE (plank_serializable_get_type ())
#define PLANK_SERIALIZABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_SERIALIZABLE, PlankSerializable))
#define PLANK_IS_SERIALIZABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_SERIALIZABLE))
#define PLANK_SERIALIZABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), PLANK_TYPE_SERIALIZABLE, PlankSerializableIface))

typedef struct _PlankSerializable PlankSerializable;
typedef struct _PlankSerializableIface PlankSerializableIface;

#define PLANK_TYPE_SYSTEM (plank_system_get_type ())
#define PLANK_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_SYSTEM, PlankSystem))
#define PLANK_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_SYSTEM, PlankSystemClass))
#define PLANK_IS_SYSTEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_SYSTEM))
#define PLANK_IS_SYSTEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_SYSTEM))
#define PLANK_SYSTEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_SYSTEM, PlankSystemClass))

typedef struct _PlankSystem PlankSystem;
typedef struct _PlankSystemClass PlankSystemClass;
typedef struct _PlankSystemPrivate PlankSystemPrivate;

#define PLANK_TYPE_UNITY (plank_unity_get_type ())
#define PLANK_UNITY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_UNITY, PlankUnity))
#define PLANK_UNITY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_UNITY, PlankUnityClass))
#define PLANK_IS_UNITY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_UNITY))
#define PLANK_IS_UNITY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_UNITY))
#define PLANK_UNITY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_UNITY, PlankUnityClass))

typedef struct _PlankUnity PlankUnity;
typedef struct _PlankUnityClass PlankUnityClass;
typedef struct _PlankUnityPrivate PlankUnityPrivate;
typedef enum  {
	PLANK_TASK_PRIORITY_LOW,
	PLANK_TASK_PRIORITY_DEFAULT,
	PLANK_TASK_PRIORITY_HIGH
} PlankTaskPriority;

#define PLANK_TYPE_TASK_PRIORITY (plank_task_priority_get_type ())
typedef gpointer (*PlankTaskFunc) (gpointer user_data, GError** error);

#define PLANK_TYPE_WORKER (plank_worker_get_type ())
#define PLANK_WORKER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_WORKER, PlankWorker))
#define PLANK_WORKER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_WORKER, PlankWorkerClass))
#define PLANK_IS_WORKER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_WORKER))
#define PLANK_IS_WORKER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_WORKER))
#define PLANK_WORKER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_WORKER, PlankWorkerClass))

typedef struct _PlankWorker PlankWorker;
typedef struct _PlankWorkerClass PlankWorkerClass;
typedef struct _PlankWorkerPrivate PlankWorkerPrivate;
typedef struct _PlankCompositedWindowPrivate PlankCompositedWindowPrivate;
typedef struct _PlankDockWindowPrivate PlankDockWindowPrivate;
typedef struct _PlankHoverWindowPrivate PlankHoverWindowPrivate;

#define PLANK_TYPE_POOF_WINDOW (plank_poof_window_get_type ())
#define PLANK_POOF_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_POOF_WINDOW, PlankPoofWindow))
#define PLANK_POOF_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_POOF_WINDOW, PlankPoofWindowClass))
#define PLANK_IS_POOF_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_POOF_WINDOW))
#define PLANK_IS_POOF_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_POOF_WINDOW))
#define PLANK_POOF_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_POOF_WINDOW, PlankPoofWindowClass))

typedef struct _PlankPoofWindow PlankPoofWindow;
typedef struct _PlankPoofWindowClass PlankPoofWindowClass;
typedef struct _PlankPoofWindowPrivate PlankPoofWindowPrivate;

#define PLANK_TYPE_PREFERENCES_WINDOW (plank_preferences_window_get_type ())
#define PLANK_PREFERENCES_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANK_TYPE_PREFERENCES_WINDOW, PlankPreferencesWindow))
#define PLANK_PREFERENCES_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANK_TYPE_PREFERENCES_WINDOW, PlankPreferencesWindowClass))
#define PLANK_IS_PREFERENCES_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANK_TYPE_PREFERENCES_WINDOW))
#define PLANK_IS_PREFERENCES_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANK_TYPE_PREFERENCES_WINDOW))
#define PLANK_PREFERENCES_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANK_TYPE_PREFERENCES_WINDOW, PlankPreferencesWindowClass))

typedef struct _PlankPreferencesWindow PlankPreferencesWindow;
typedef struct _PlankPreferencesWindowClass PlankPreferencesWindowClass;
typedef struct _PlankPreferencesWindowPrivate PlankPreferencesWindowPrivate;

struct _PlankDBusManager {
	GObject parent_instance;
	PlankDBusManagerPrivate * priv;
};

struct _PlankDBusManagerClass {
	GObjectClass parent_class;
};

struct _PlankDockElement {
	GObject parent_instance;
	PlankDockElementPrivate * priv;
};

struct _PlankDockElementClass {
	GObjectClass parent_class;
	PlankAnimationType (*on_clicked) (PlankDockElement* self, PlankPopupButton button, GdkModifierType mod, guint32 event_time);
	PlankAnimationType (*on_hovered) (PlankDockElement* self);
	PlankAnimationType (*on_scrolled) (PlankDockElement* self, GdkScrollDirection direction, GdkModifierType mod, guint32 event_time);
	GeeArrayList* (*get_menu_items) (PlankDockElement* self);
	gchar* (*get_drop_text) (PlankDockElement* self);
	gboolean (*can_be_removed) (PlankDockElement* self);
	gboolean (*can_accept_drop) (PlankDockElement* self, GeeArrayList* uris);
	gboolean (*accept_drop) (PlankDockElement* self, GeeArrayList* uris);
	gchar* (*unique_id) (PlankDockElement* self);
	void (*reset_buffers) (PlankDockElement* self);
};

struct _PlankDockContainer {
	PlankDockElement parent_instance;
	PlankDockContainerPrivate * priv;
	GeeArrayList* visible_elements;
	GeeArrayList* internal_elements;
};

struct _PlankDockContainerClass {
	PlankDockElementClass parent_class;
	void (*prepare) (PlankDockContainer* self);
	void (*update_visible_elements) (PlankDockContainer* self);
	gboolean (*move_to) (PlankDockContainer* self, PlankDockElement* move, PlankDockElement* target);
	gboolean (*replace) (PlankDockContainer* self, PlankDockElement* new_element, PlankDockElement* old_element);
	void (*connect_element) (PlankDockContainer* self, PlankDockElement* element);
	void (*disconnect_element) (PlankDockContainer* self, PlankDockElement* element);
};

struct _PlankDockController {
	PlankDockContainer parent_instance;
	PlankDockControllerPrivate * priv;
};

struct _PlankDockControllerClass {
	PlankDockContainerClass parent_class;
};

struct _PlankSettings {
	GObject parent_instance;
	PlankSettingsPrivate * priv;
};

struct _PlankSettingsClass {
	GObjectClass parent_class;
	void (*verify) (PlankSettings* self, const gchar* name);
};

struct _PlankDockPreferences {
	PlankSettings parent_instance;
	PlankDockPreferencesPrivate * priv;
};

struct _PlankDockPreferencesClass {
	PlankSettingsClass parent_class;
};

struct _PlankRenderer {
	GObject parent_instance;
	PlankRendererPrivate * priv;
};

struct _PlankRendererClass {
	GObjectClass parent_class;
	gboolean (*animation_needed) (PlankRenderer* self, gint64 frame_time);
	void (*initialize_frame) (PlankRenderer* self, gint64 frame_time);
	void (*draw) (PlankRenderer* self, cairo_t* cr, gint64 frame_time);
};

struct _PlankDockRenderer {
	PlankRenderer parent_instance;
	PlankDockRendererPrivate * priv;
};

struct _PlankDockRendererClass {
	PlankRendererClass parent_class;
};

struct _PlankDragManager {
	GObject parent_instance;
	PlankDragManagerPrivate * priv;
};

struct _PlankDragManagerClass {
	GObjectClass parent_class;
};

struct _PlankHideManager {
	GObject parent_instance;
	PlankHideManagerPrivate * priv;
};

struct _PlankHideManagerClass {
	GObjectClass parent_class;
};

struct _PlankPositionManager {
	GObject parent_instance;
	PlankPositionManagerPrivate * priv;
};

struct _PlankPositionManagerClass {
	GObjectClass parent_class;
};

struct _PlankDBusClient {
	GObject parent_instance;
	PlankDBusClientPrivate * priv;
};

struct _PlankDBusClientClass {
	GObjectClass parent_class;
};

struct _PlankDockletIface {
	GTypeInterface parent_iface;
	const gchar* (*get_id) (PlankDocklet* self);
	const gchar* (*get_name) (PlankDocklet* self);
	const gchar* (*get_description) (PlankDocklet* self);
	const gchar* (*get_icon) (PlankDocklet* self);
	gboolean (*is_supported) (PlankDocklet* self);
	PlankDockElement* (*make_element) (PlankDocklet* self, const gchar* launcher, GFile* file);
};

struct _PlankDockItem {
	PlankDockElement parent_instance;
	PlankDockItemPrivate * priv;
};

struct _PlankDockItemClass {
	PlankDockElementClass parent_class;
	void (*load_from_launcher) (PlankDockItem* self);
	void (*draw_icon) (PlankDockItem* self, PlankSurface* surface);
	void (*draw_icon_fast) (PlankDockItem* self, PlankSurface* surface);
	gboolean (*is_valid) (PlankDockItem* self);
};

struct _PlankDockletItem {
	PlankDockItem parent_instance;
	PlankDockletItemPrivate * priv;
};

struct _PlankDockletItemClass {
	PlankDockItemClass parent_class;
};

struct _PlankDockletManager {
	GObject parent_instance;
	PlankDockletManagerPrivate * priv;
};

struct _PlankDockletManagerClass {
	GObjectClass parent_class;
};

struct _PlankDrawingService {
	GObject parent_instance;
	PlankDrawingServicePrivate * priv;
};

struct _PlankDrawingServiceClass {
	GObjectClass parent_class;
};

struct _PlankPreferences {
	GObject parent_instance;
	PlankPreferencesPrivate * priv;
};

struct _PlankPreferencesClass {
	GObjectClass parent_class;
	void (*verify) (PlankPreferences* self, const gchar* prop);
	void (*reset_properties) (PlankPreferences* self);
};

struct _PlankTheme {
	PlankPreferences parent_instance;
	PlankThemePrivate * priv;
};

struct _PlankThemeClass {
	PlankPreferencesClass parent_class;
};

struct _PlankDockTheme {
	PlankTheme parent_instance;
	PlankDockThemePrivate * priv;
};

struct _PlankDockThemeClass {
	PlankThemeClass parent_class;
};

struct _PlankSurface {
	GObject parent_instance;
	PlankSurfacePrivate * priv;
};

struct _PlankSurfaceClass {
	GObjectClass parent_class;
};

struct _PlankSurfaceCache {
	GObject parent_instance;
	PlankSurfaceCachePrivate * priv;
};

struct _PlankSurfaceCacheClass {
	GObjectClass parent_class;
};

struct _PlankAbstractMain {
	GtkApplication parent_instance;
	PlankAbstractMainPrivate * priv;
};

struct _PlankAbstractMainClass {
	GtkApplicationClass parent_class;
	void (*initialize) (PlankAbstractMain* self);
	void (*create_docks) (PlankAbstractMain* self);
	void (*create_actions) (PlankAbstractMain* self);
};

struct _PlankFactory {
	GObject parent_instance;
	PlankFactoryPrivate * priv;
};

struct _PlankFactoryClass {
	GObjectClass parent_class;
};

struct _PlankItemFactory {
	GObject parent_instance;
	PlankItemFactoryPrivate * priv;
	GFile* launchers_dir;
};

struct _PlankItemFactoryClass {
	GObjectClass parent_class;
	PlankDockElement* (*make_element) (PlankItemFactory* self, GFile* file);
	PlankDockItem* (*get_item_for_dock) (PlankItemFactory* self);
};

struct _PlankApplicationDockItem {
	PlankDockItem parent_instance;
	PlankApplicationDockItemPrivate * priv;
};

struct _PlankApplicationDockItemClass {
	PlankDockItemClass parent_class;
};

struct _PlankDockItemProvider {
	PlankDockContainer parent_instance;
	PlankDockItemProviderPrivate * priv;
};

struct _PlankDockItemProviderClass {
	PlankDockContainerClass parent_class;
	gboolean (*item_exists_for_uri) (PlankDockItemProvider* self, const gchar* uri);
	PlankDockItem* (*item_for_uri) (PlankDockItemProvider* self, const gchar* uri);
	gboolean (*add_item_with_uri) (PlankDockItemProvider* self, const gchar* uri, PlankDockItem* target);
	void (*handle_item_deleted) (PlankDockItemProvider* self, PlankDockItem* item);
	gchar** (*get_dockitem_filenames) (PlankDockItemProvider* self, gint* result_length1);
};

struct _PlankUnityClientIface {
	GTypeInterface parent_iface;
	void (*update_launcher_entry) (PlankUnityClient* self, const gchar* sender_name, GVariant* parameters, gboolean is_retry);
	void (*remove_launcher_entry) (PlankUnityClient* self, const gchar* sender_name);
};

struct _PlankApplicationDockItemProvider {
	PlankDockItemProvider parent_instance;
	PlankApplicationDockItemProviderPrivate * priv;
};

struct _PlankApplicationDockItemProviderClass {
	PlankDockItemProviderClass parent_class;
	void (*app_opened) (PlankApplicationDockItemProvider* self, BamfApplication* app);
};

struct _PlankDefaultApplicationDockItemProvider {
	PlankApplicationDockItemProvider parent_instance;
	PlankDefaultApplicationDockItemProviderPrivate * priv;
};

struct _PlankDefaultApplicationDockItemProviderClass {
	PlankApplicationDockItemProviderClass parent_class;
};

struct _PlankPointD {
	gdouble x;
	gdouble y;
};

struct _PlankDockItemDrawValue {
	GTypeInstance parent_instance;
	volatile int ref_count;
	PlankDockItemDrawValuePrivate * priv;
	PlankPointD center;
	PlankPointD static_center;
	gdouble icon_size;
	GdkRectangle hover_region;
	GdkRectangle draw_region;
	GdkRectangle background_region;
	gdouble zoom;
	gdouble opacity;
	gdouble darken;
	gdouble lighten;
	gboolean show_indicator;
};

struct _PlankDockItemDrawValueClass {
	GTypeClass parent_class;
	void (*finalize) (PlankDockItemDrawValue *self);
};

struct _PlankDockItemPreferences {
	PlankPreferences parent_instance;
	PlankDockItemPreferencesPrivate * priv;
};

struct _PlankDockItemPreferencesClass {
	PlankPreferencesClass parent_class;
};

struct _PlankFileDockItem {
	PlankDockItem parent_instance;
	PlankFileDockItemPrivate * priv;
};

struct _PlankFileDockItemClass {
	PlankDockItemClass parent_class;
};

struct _PlankPlaceholderDockItem {
	PlankDockItem parent_instance;
	PlankPlaceholderDockItemPrivate * priv;
};

struct _PlankPlaceholderDockItemClass {
	PlankDockItemClass parent_class;
};

struct _PlankPlankDockItem {
	PlankDockItem parent_instance;
	PlankPlankDockItemPrivate * priv;
};

struct _PlankPlankDockItemClass {
	PlankDockItemClass parent_class;
};

struct _PlankTransientDockItem {
	PlankApplicationDockItem parent_instance;
	PlankTransientDockItemPrivate * priv;
};

struct _PlankTransientDockItemClass {
	PlankApplicationDockItemClass parent_class;
};

struct _PlankLogger {
	GObject parent_instance;
	PlankLoggerPrivate * priv;
};

struct _PlankLoggerClass {
	GObjectClass parent_class;
};

struct _PlankPaths {
	GObject parent_instance;
	PlankPathsPrivate * priv;
};

struct _PlankPathsClass {
	GObjectClass parent_class;
};

struct _PlankSerializableIface {
	GTypeInterface parent_iface;
	gchar* (*serialize) (PlankSerializable* self);
	void (*deserialize) (PlankSerializable* self, const gchar* s);
};

struct _PlankSystem {
	GObject parent_instance;
	PlankSystemPrivate * priv;
};

struct _PlankSystemClass {
	GObjectClass parent_class;
};

struct _PlankUnity {
	GObject parent_instance;
	PlankUnityPrivate * priv;
};

struct _PlankUnityClass {
	GObjectClass parent_class;
};

struct _PlankWorker {
	GObject parent_instance;
	PlankWorkerPrivate * priv;
};

struct _PlankWorkerClass {
	GObjectClass parent_class;
};

struct _PlankCompositedWindow {
	GtkWindow parent_instance;
	PlankCompositedWindowPrivate * priv;
};

struct _PlankCompositedWindowClass {
	GtkWindowClass parent_class;
};

struct _PlankDockWindow {
	PlankCompositedWindow parent_instance;
	PlankDockWindowPrivate * priv;
};

struct _PlankDockWindowClass {
	PlankCompositedWindowClass parent_class;
};

struct _PlankHoverWindow {
	GtkWindow parent_instance;
	PlankHoverWindowPrivate * priv;
};

struct _PlankHoverWindowClass {
	GtkWindowClass parent_class;
};

struct _PlankPoofWindow {
	PlankCompositedWindow parent_instance;
	PlankPoofWindowPrivate * priv;
};

struct _PlankPoofWindowClass {
	PlankCompositedWindowClass parent_class;
};

struct _PlankPreferencesWindow {
	GtkWindow parent_instance;
	PlankPreferencesWindowPrivate * priv;
};

struct _PlankPreferencesWindowClass {
	GtkWindowClass parent_class;
};

GType plank_dbus_manager_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDBusManager, g_object_unref)
GType plank_dock_element_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockElement, g_object_unref)
GType plank_dock_container_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockContainer, g_object_unref)
GType plank_dock_controller_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockController, g_object_unref)
PlankDBusManager* plank_dbus_manager_new (PlankDockController* controller);
PlankDBusManager* plank_dbus_manager_construct (GType object_type,
                                                PlankDockController* controller);
#define PLANK_G_RESOURCE_PATH "/net/launchpad/plank"
GType plank_popup_button_get_type (void) G_GNUC_CONST;
GType plank_animation_type_get_type (void) G_GNUC_CONST;
PlankDockController* plank_dock_controller_new (const gchar* dock_name,
                                                GFile* config_folder);
PlankDockController* plank_dock_controller_construct (GType object_type,
                                                      const gchar* dock_name,
                                                      GFile* config_folder);
void plank_dock_controller_initialize (PlankDockController* self);
void plank_dock_controller_add_default_provider (PlankDockController* self);
const gchar* plank_dock_controller_get_name (PlankDockController* self);
GFile* plank_dock_controller_get_config_folder (PlankDockController* self);
GFile* plank_dock_controller_get_launchers_folder (PlankDockController* self);
GType plank_settings_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankSettings, g_object_unref)
GType plank_dock_preferences_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockPreferences, g_object_unref)
PlankDockPreferences* plank_dock_controller_get_prefs (PlankDockController* self);
GType plank_drag_manager_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDragManager, g_object_unref)
PlankDragManager* plank_dock_controller_get_drag_manager (PlankDockController* self);
void plank_dock_controller_set_drag_manager (PlankDockController* self,
                                             PlankDragManager* value);
GType plank_hide_manager_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankHideManager, g_object_unref)
PlankHideManager* plank_dock_controller_get_hide_manager (PlankDockController* self);
void plank_dock_controller_set_hide_manager (PlankDockController* self,
                                             PlankHideManager* value);
GType plank_position_manager_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankPositionManager, g_object_unref)
PlankPositionManager* plank_dock_controller_get_position_manager (PlankDockController* self);
void plank_dock_controller_set_position_manager (PlankDockController* self,
                                                 PlankPositionManager* value);
GType plank_renderer_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankRenderer, g_object_unref)
GType plank_dock_renderer_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockRenderer, g_object_unref)
PlankDockRenderer* plank_dock_controller_get_renderer (PlankDockController* self);
void plank_dock_controller_set_renderer (PlankDockController* self,
                                         PlankDockRenderer* value);
GType plank_composited_window_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankCompositedWindow, g_object_unref)
GType plank_dock_window_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockWindow, g_object_unref)
PlankDockWindow* plank_dock_controller_get_window (PlankDockController* self);
void plank_dock_controller_set_window (PlankDockController* self,
                                       PlankDockWindow* value);
GType plank_hover_window_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankHoverWindow, g_object_unref)
PlankHoverWindow* plank_dock_controller_get_hover (PlankDockController* self);
void plank_dock_controller_set_hover (PlankDockController* self,
                                      PlankHoverWindow* value);
GType plank_dock_item_provider_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockItemProvider, g_object_unref)
PlankDockItemProvider* plank_dock_controller_get_default_provider (PlankDockController* self);
GType plank_dock_item_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockItem, g_object_unref)
GeeArrayList* plank_dock_controller_get_Items (PlankDockController* self);
GeeArrayList* plank_dock_controller_get_VisibleItems (PlankDockController* self);
#define PLANK_DOCK_PREFERENCES_MIN_ICON_SIZE 24
#define PLANK_DOCK_PREFERENCES_MAX_ICON_SIZE 128
#define PLANK_DOCK_PREFERENCES_MIN_ICON_ZOOM 100
#define PLANK_DOCK_PREFERENCES_MAX_ICON_ZOOM 200
PlankDockPreferences* plank_dock_preferences_new (const gchar* name);
PlankDockPreferences* plank_dock_preferences_construct (GType object_type,
                                                        const gchar* name);
void plank_dock_preferences_increase_icon_size (PlankDockPreferences* self);
void plank_dock_preferences_decrease_icon_size (PlankDockPreferences* self);
gboolean plank_dock_preferences_is_horizontal_dock (PlankDockPreferences* self);
gboolean plank_dock_preferences_get_CurrentWorkspaceOnly (PlankDockPreferences* self);
void plank_dock_preferences_set_CurrentWorkspaceOnly (PlankDockPreferences* self,
                                                      gboolean value);
gint plank_dock_preferences_get_IconSize (PlankDockPreferences* self);
void plank_dock_preferences_set_IconSize (PlankDockPreferences* self,
                                          gint value);
GType plank_hide_type_get_type (void) G_GNUC_CONST;
PlankHideType plank_dock_preferences_get_HideMode (PlankDockPreferences* self);
void plank_dock_preferences_set_HideMode (PlankDockPreferences* self,
                                          PlankHideType value);
guint plank_dock_preferences_get_UnhideDelay (PlankDockPreferences* self);
void plank_dock_preferences_set_UnhideDelay (PlankDockPreferences* self,
                                             guint value);
guint plank_dock_preferences_get_HideDelay (PlankDockPreferences* self);
void plank_dock_preferences_set_HideDelay (PlankDockPreferences* self,
                                           guint value);
const gchar* plank_dock_preferences_get_Monitor (PlankDockPreferences* self);
void plank_dock_preferences_set_Monitor (PlankDockPreferences* self,
                                         const gchar* value);
gchar** plank_dock_preferences_get_DockItems (PlankDockPreferences* self,
                                              gint* result_length1);
void plank_dock_preferences_set_DockItems (PlankDockPreferences* self,
                                           gchar** value,
                                           gint value_length1);
GtkPositionType plank_dock_preferences_get_Position (PlankDockPreferences* self);
void plank_dock_preferences_set_Position (PlankDockPreferences* self,
                                          GtkPositionType value);
gint plank_dock_preferences_get_Offset (PlankDockPreferences* self);
void plank_dock_preferences_set_Offset (PlankDockPreferences* self,
                                        gint value);
const gchar* plank_dock_preferences_get_Theme (PlankDockPreferences* self);
void plank_dock_preferences_set_Theme (PlankDockPreferences* self,
                                       const gchar* value);
GtkAlign plank_dock_preferences_get_Alignment (PlankDockPreferences* self);
void plank_dock_preferences_set_Alignment (PlankDockPreferences* self,
                                           GtkAlign value);
GtkAlign plank_dock_preferences_get_ItemsAlignment (PlankDockPreferences* self);
void plank_dock_preferences_set_ItemsAlignment (PlankDockPreferences* self,
                                                GtkAlign value);
gboolean plank_dock_preferences_get_LockItems (PlankDockPreferences* self);
void plank_dock_preferences_set_LockItems (PlankDockPreferences* self,
                                           gboolean value);
gboolean plank_dock_preferences_get_PressureReveal (PlankDockPreferences* self);
void plank_dock_preferences_set_PressureReveal (PlankDockPreferences* self,
                                                gboolean value);
gboolean plank_dock_preferences_get_PinnedOnly (PlankDockPreferences* self);
void plank_dock_preferences_set_PinnedOnly (PlankDockPreferences* self,
                                            gboolean value);
gboolean plank_dock_preferences_get_AutoPinning (PlankDockPreferences* self);
void plank_dock_preferences_set_AutoPinning (PlankDockPreferences* self,
                                             gboolean value);
gboolean plank_dock_preferences_get_ShowDockItem (PlankDockPreferences* self);
void plank_dock_preferences_set_ShowDockItem (PlankDockPreferences* self,
                                              gboolean value);
gboolean plank_dock_preferences_get_ZoomEnabled (PlankDockPreferences* self);
void plank_dock_preferences_set_ZoomEnabled (PlankDockPreferences* self,
                                             gboolean value);
guint plank_dock_preferences_get_ZoomPercent (PlankDockPreferences* self);
void plank_dock_preferences_set_ZoomPercent (PlankDockPreferences* self,
                                             guint value);
gboolean plank_dock_preferences_get_TooltipsEnabled (PlankDockPreferences* self);
void plank_dock_preferences_set_TooltipsEnabled (PlankDockPreferences* self,
                                                 gboolean value);
PlankDockRenderer* plank_dock_renderer_new (PlankDockController* controller,
                                            GtkWindow* window);
PlankDockRenderer* plank_dock_renderer_construct (GType object_type,
                                                  PlankDockController* controller,
                                                  GtkWindow* window);
void plank_dock_renderer_initialize (PlankDockRenderer* self);
void plank_dock_renderer_reset_buffers (PlankDockRenderer* self);
void plank_dock_renderer_update_local_cursor (PlankDockRenderer* self,
                                              gint x,
                                              gint y);
void plank_dock_renderer_animate_items (PlankDockRenderer* self,
                                        GeeList* elements);
GType plank_preferences_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankPreferences, g_object_unref)
GType plank_theme_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankTheme, g_object_unref)
GType plank_dock_theme_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockTheme, g_object_unref)
PlankDockTheme* plank_dock_renderer_get_theme (PlankDockRenderer* self);
gdouble plank_dock_renderer_get_hide_progress (PlankDockRenderer* self);
gdouble plank_dock_renderer_get_zoom_in_progress (PlankDockRenderer* self);
void plank_dock_renderer_get_local_cursor (PlankDockRenderer* self,
                                           GdkPoint * result);
PlankDragManager* plank_drag_manager_new (PlankDockController* controller);
PlankDragManager* plank_drag_manager_construct (GType object_type,
                                                PlankDockController* controller);
void plank_drag_manager_initialize (PlankDragManager* self);
gboolean plank_drag_manager_drop_is_accepted_by (PlankDragManager* self,
                                                 PlankDockItem* item);
void plank_drag_manager_ensure_proxy (PlankDragManager* self);
gboolean plank_drag_manager_get_InternalDragActive (PlankDragManager* self);
PlankDockItem* plank_drag_manager_get_DragItem (PlankDragManager* self);
gboolean plank_drag_manager_get_DragNeedsCheck (PlankDragManager* self);
gboolean plank_drag_manager_get_ExternalDragActive (PlankDragManager* self);
gboolean plank_drag_manager_get_RepositionMode (PlankDragManager* self);
PlankHideManager* plank_hide_manager_new (PlankDockController* controller);
PlankHideManager* plank_hide_manager_construct (GType object_type,
                                                PlankDockController* controller);
void plank_hide_manager_initialize (PlankHideManager* self);
void plank_hide_manager_update_hovered (PlankHideManager* self);
void plank_hide_manager_update_hovered_with_coords (PlankHideManager* self,
                                                    gint x,
                                                    gint y);
gboolean plank_hide_manager_get_Hidden (PlankHideManager* self);
gboolean plank_hide_manager_get_Disabled (PlankHideManager* self);
gboolean plank_hide_manager_get_Hovered (PlankHideManager* self);
PlankPositionManager* plank_position_manager_new (PlankDockController* controller);
PlankPositionManager* plank_position_manager_construct (GType object_type,
                                                        PlankDockController* controller);
void plank_position_manager_initialize (PlankPositionManager* self);
gchar** plank_position_manager_get_monitor_plug_names (GdkScreen* screen,
                                                       gint* result_length1);
void plank_position_manager_update (PlankPositionManager* self,
                                    PlankDockTheme* theme);
gboolean plank_position_manager_is_horizontal_dock (PlankPositionManager* self);
void plank_position_manager_get_cursor_region (PlankPositionManager* self,
                                               GdkRectangle* result);
void plank_position_manager_get_static_dock_region (PlankPositionManager* self,
                                                    GdkRectangle* result);
void plank_position_manager_update_regions (PlankPositionManager* self);
gpointer plank_dock_item_draw_value_ref (gpointer instance);
void plank_dock_item_draw_value_unref (gpointer instance);
GParamSpec* plank_param_spec_dock_item_draw_value (const gchar* name,
                                                   const gchar* nick,
                                                   const gchar* blurb,
                                                   GType object_type,
                                                   GParamFlags flags);
void plank_value_set_dock_item_draw_value (GValue* value,
                                           gpointer v_object);
void plank_value_take_dock_item_draw_value (GValue* value,
                                            gpointer v_object);
gpointer plank_value_get_dock_item_draw_value (const GValue* value);
GType plank_dock_item_draw_value_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockItemDrawValue, plank_dock_item_draw_value_unref)
PlankDockItemDrawValue* plank_position_manager_get_draw_value_for_item (PlankPositionManager* self,
                                                                        PlankDockItem* item);
void plank_position_manager_update_draw_values (PlankPositionManager* self,
                                                GeeArrayList* items,
                                                PlankDrawValueFunc func,
                                                gpointer func_target,
                                                PlankDrawValuesFunc post_func,
                                                gpointer post_func_target);
void plank_position_manager_get_hover_region_for_element (PlankPositionManager* self,
                                                          PlankDockElement* element,
                                                          GdkRectangle* result);
PlankDockItem* plank_position_manager_get_nearest_item_at (PlankPositionManager* self,
                                                           gint x,
                                                           gint y,
                                                           PlankDockContainer* container);
PlankDockItem* plank_position_manager_get_current_target_item (PlankPositionManager* self,
                                                               PlankDockContainer* container);
void plank_position_manager_get_menu_position (PlankPositionManager* self,
                                               PlankDockItem* hovered,
                                               GtkRequisition* requisition,
                                               gint* x,
                                               gint* y);
void plank_position_manager_get_hover_position (PlankPositionManager* self,
                                                PlankDockItem* hovered,
                                                gint* x,
                                                gint* y);
void plank_position_manager_get_hover_position_at (PlankPositionManager* self,
                                                   gint* x,
                                                   gint* y);
void plank_position_manager_get_urgent_glow_position (PlankPositionManager* self,
                                                      PlankDockItem* item,
                                                      gint* x,
                                                      gint* y);
void plank_position_manager_update_dock_position (PlankPositionManager* self);
void plank_position_manager_get_dock_draw_position (PlankPositionManager* self,
                                                    gint* x,
                                                    gint* y);
void plank_position_manager_get_dock_window_region (PlankPositionManager* self,
                                                    GdkRectangle* result);
void plank_position_manager_get_background_padding (PlankPositionManager* self,
                                                    gint* x,
                                                    gint* y);
void plank_position_manager_get_background_region (PlankPositionManager* self,
                                                   GdkRectangle* result);
GType plank_application_dock_item_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankApplicationDockItem, g_object_unref)
void plank_position_manager_get_icon_geometry (PlankPositionManager* self,
                                               PlankApplicationDockItem* item,
                                               gboolean for_hidden,
                                               GdkRectangle* result);
void plank_position_manager_get_struts (PlankPositionManager* self,
                                        gulong** struts,
                                        gint* struts_length1);
gboolean plank_position_manager_get_screen_is_composited (PlankPositionManager* self);
gint plank_position_manager_get_LineWidth (PlankPositionManager* self);
gint plank_position_manager_get_IconSize (PlankPositionManager* self);
gint plank_position_manager_get_ZoomIconSize (PlankPositionManager* self);
GtkPositionType plank_position_manager_get_Position (PlankPositionManager* self);
GtkAlign plank_position_manager_get_Alignment (PlankPositionManager* self);
GtkAlign plank_position_manager_get_ItemsAlignment (PlankPositionManager* self);
gint plank_position_manager_get_Offset (PlankPositionManager* self);
gint plank_position_manager_get_IndicatorSize (PlankPositionManager* self);
gint plank_position_manager_get_IconShadowSize (PlankPositionManager* self);
gint plank_position_manager_get_GlowSize (PlankPositionManager* self);
gint plank_position_manager_get_HorizPadding (PlankPositionManager* self);
gint plank_position_manager_get_TopPadding (PlankPositionManager* self);
gint plank_position_manager_get_BottomPadding (PlankPositionManager* self);
gint plank_position_manager_get_ItemPadding (PlankPositionManager* self);
gint plank_position_manager_get_UrgentBounceHeight (PlankPositionManager* self);
gint plank_position_manager_get_LaunchBounceHeight (PlankPositionManager* self);
gint plank_position_manager_get_MaxItemCount (PlankPositionManager* self);
GType plank_dbus_client_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDBusClient, g_object_unref)
PlankDBusClient* plank_dbus_client_get_instance (void);
gboolean plank_dbus_client_add_item (PlankDBusClient* self,
                                     const gchar* uri);
gboolean plank_dbus_client_remove_item (PlankDBusClient* self,
                                        const gchar* uri);
gint plank_dbus_client_get_items_count (PlankDBusClient* self);
gchar** plank_dbus_client_get_persistent_applications (PlankDBusClient* self,
                                                       gint* result_length1);
gchar** plank_dbus_client_get_transient_applications (PlankDBusClient* self,
                                                      gint* result_length1);
gboolean plank_dbus_client_get_hover_position (PlankDBusClient* self,
                                               const gchar* uri,
                                               gint* x,
                                               gint* y,
                                               GtkPositionType* dock_position);
gboolean plank_dbus_client_get_is_connected (PlankDBusClient* self);
GType plank_docklet_get_type (void) G_GNUC_CONST;
const gchar* plank_docklet_get_id (PlankDocklet* self);
const gchar* plank_docklet_get_name (PlankDocklet* self);
const gchar* plank_docklet_get_description (PlankDocklet* self);
const gchar* plank_docklet_get_icon (PlankDocklet* self);
gboolean plank_docklet_is_supported (PlankDocklet* self);
PlankDockElement* plank_docklet_make_element (PlankDocklet* self,
                                              const gchar* launcher,
                                              GFile* file);
GType plank_surface_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankSurface, g_object_unref)
GType plank_docklet_item_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockletItem, g_object_unref)
PlankDockletItem* plank_docklet_item_construct (GType object_type);
#define PLANK_DOCKLET_ENTRY_POINT "docklet_init"
GType plank_docklet_manager_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockletManager, g_object_unref)
PlankDockletManager* plank_docklet_manager_get_default (void);
void plank_docklet_manager_load_docklets (PlankDockletManager* self);
void plank_docklet_manager_register_docklet (PlankDockletManager* self,
                                             GType type);
PlankDocklet* plank_docklet_manager_get_docklet_by_id (PlankDockletManager* self,
                                                       const gchar* id);
PlankDocklet* plank_docklet_manager_get_docklet_by_uri (PlankDockletManager* self,
                                                        const gchar* uri);
GeeCollection* plank_docklet_manager_list_docklets (PlankDockletManager* self);
GType plank_color_get_type (void) G_GNUC_CONST;
PlankColor* plank_color_dup (const PlankColor* self);
void plank_color_free (PlankColor* self);
void plank_color_from_hsv (gdouble h,
                           gdouble s,
                           gdouble v,
                           PlankColor* result);
void plank_color_from_hsl (gdouble h,
                           gdouble s,
                           gdouble l,
                           PlankColor* result);
void plank_color_set_hsv (PlankColor *self,
                          gdouble h,
                          gdouble s,
                          gdouble v);
void plank_color_set_hue (PlankColor *self,
                          gdouble hue);
void plank_color_set_sat (PlankColor *self,
                          gdouble sat);
void plank_color_set_val (PlankColor *self,
                          gdouble val);
void plank_color_get_hsv (PlankColor *self,
                          gdouble* h,
                          gdouble* s,
                          gdouble* v);
gdouble plank_color_get_hue (PlankColor *self);
gdouble plank_color_get_sat (PlankColor *self);
gdouble plank_color_get_val (PlankColor *self);
void plank_color_add_hue (PlankColor *self,
                          gdouble val);
void plank_color_set_min_sat (PlankColor *self,
                              gdouble sat);
void plank_color_set_min_val (PlankColor *self,
                              gdouble val);
void plank_color_set_max_sat (PlankColor *self,
                              gdouble sat);
void plank_color_set_max_val (PlankColor *self,
                              gdouble val);
void plank_color_multiply_sat (PlankColor *self,
                               gdouble amount);
void plank_color_brighten_val (PlankColor *self,
                               gdouble amount);
void plank_color_darken_val (PlankColor *self,
                             gdouble amount);
void plank_color_darken_by_sat (PlankColor *self,
                                gdouble amount);
void plank_color_get_hsl (PlankColor *self,
                          gdouble* h,
                          gdouble* s,
                          gdouble* l);
void plank_color_set_hsl (PlankColor *self,
                          gdouble h,
                          gdouble s,
                          gdouble v);
gchar* plank_color_to_prefs_string (PlankColor *self);
void plank_color_from_prefs_string (const gchar* s,
                                    PlankColor* result);
GType plank_drawing_service_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDrawingService, g_object_unref)
GtkIconTheme* plank_drawing_service_get_icon_theme (void);
gchar* plank_drawing_service_get_icon_from_file (GFile* file);
gchar* plank_drawing_service_get_icon_from_gicon (GIcon* icon);
GdkPixbuf* plank_drawing_service_load_icon (const gchar* names,
                                            gint width,
                                            gint height);
GFile* plank_drawing_service_try_get_icon_file (const gchar* name);
cairo_surface_t* plank_drawing_service_load_icon_for_scale (const gchar* names,
                                                            gint width,
                                                            gint height,
                                                            gint scale);
GdkPixbuf* plank_drawing_service_ar_scale (GdkPixbuf* source,
                                           gint width,
                                           gint height);
void plank_drawing_service_average_color (GdkPixbuf* source,
                                          PlankColor* result);
PlankDockTheme* plank_dock_theme_new (const gchar* name);
PlankDockTheme* plank_dock_theme_construct (GType object_type,
                                            const gchar* name);
PlankSurface* plank_dock_theme_create_background (PlankDockTheme* self,
                                                  gint width,
                                                  gint height,
                                                  GtkPositionType position,
                                                  PlankSurface* model);
PlankSurface* plank_dock_theme_create_indicator (PlankDockTheme* self,
                                                 gint size,
                                                 PlankColor* color,
                                                 PlankSurface* model);
PlankSurface* plank_dock_theme_create_urgent_glow (PlankDockTheme* self,
                                                   gint size,
                                                   PlankColor* color,
                                                   PlankSurface* model);
void plank_dock_theme_draw_active_glow (PlankDockTheme* self,
                                        PlankSurface* surface,
                                        GdkRectangle* clip_rect,
                                        GdkRectangle* rect,
                                        PlankColor* color,
                                        gdouble opacity,
                                        GtkPositionType pos);
void plank_dock_theme_draw_item_count (PlankDockTheme* self,
                                       PlankSurface* surface,
                                       gint icon_size,
                                       PlankColor* color,
                                       gint64 count);
void plank_dock_theme_draw_item_progress (PlankDockTheme* self,
                                          PlankSurface* surface,
                                          gint icon_size,
                                          PlankColor* color,
                                          gdouble progress);
gdouble plank_dock_theme_get_HorizPadding (PlankDockTheme* self);
void plank_dock_theme_set_HorizPadding (PlankDockTheme* self,
                                        gdouble value);
gdouble plank_dock_theme_get_TopPadding (PlankDockTheme* self);
void plank_dock_theme_set_TopPadding (PlankDockTheme* self,
                                      gdouble value);
gdouble plank_dock_theme_get_BottomPadding (PlankDockTheme* self);
void plank_dock_theme_set_BottomPadding (PlankDockTheme* self,
                                         gdouble value);
gdouble plank_dock_theme_get_ItemPadding (PlankDockTheme* self);
void plank_dock_theme_set_ItemPadding (PlankDockTheme* self,
                                       gdouble value);
gdouble plank_dock_theme_get_IndicatorSize (PlankDockTheme* self);
void plank_dock_theme_set_IndicatorSize (PlankDockTheme* self,
                                         gdouble value);
gdouble plank_dock_theme_get_IconShadowSize (PlankDockTheme* self);
void plank_dock_theme_set_IconShadowSize (PlankDockTheme* self,
                                          gdouble value);
gdouble plank_dock_theme_get_UrgentBounceHeight (PlankDockTheme* self);
void plank_dock_theme_set_UrgentBounceHeight (PlankDockTheme* self,
                                              gdouble value);
gdouble plank_dock_theme_get_LaunchBounceHeight (PlankDockTheme* self);
void plank_dock_theme_set_LaunchBounceHeight (PlankDockTheme* self,
                                              gdouble value);
gdouble plank_dock_theme_get_FadeOpacity (PlankDockTheme* self);
void plank_dock_theme_set_FadeOpacity (PlankDockTheme* self,
                                       gdouble value);
gint plank_dock_theme_get_ClickTime (PlankDockTheme* self);
void plank_dock_theme_set_ClickTime (PlankDockTheme* self,
                                     gint value);
gint plank_dock_theme_get_UrgentBounceTime (PlankDockTheme* self);
void plank_dock_theme_set_UrgentBounceTime (PlankDockTheme* self,
                                            gint value);
gint plank_dock_theme_get_LaunchBounceTime (PlankDockTheme* self);
void plank_dock_theme_set_LaunchBounceTime (PlankDockTheme* self,
                                            gint value);
gint plank_dock_theme_get_ActiveTime (PlankDockTheme* self);
void plank_dock_theme_set_ActiveTime (PlankDockTheme* self,
                                      gint value);
gint plank_dock_theme_get_SlideTime (PlankDockTheme* self);
void plank_dock_theme_set_SlideTime (PlankDockTheme* self,
                                     gint value);
gint plank_dock_theme_get_FadeTime (PlankDockTheme* self);
void plank_dock_theme_set_FadeTime (PlankDockTheme* self,
                                    gint value);
gint plank_dock_theme_get_HideTime (PlankDockTheme* self);
void plank_dock_theme_set_HideTime (PlankDockTheme* self,
                                    gint value);
gint plank_dock_theme_get_GlowSize (PlankDockTheme* self);
void plank_dock_theme_set_GlowSize (PlankDockTheme* self,
                                    gint value);
gint plank_dock_theme_get_GlowTime (PlankDockTheme* self);
void plank_dock_theme_set_GlowTime (PlankDockTheme* self,
                                    gint value);
gint plank_dock_theme_get_GlowPulseTime (PlankDockTheme* self);
void plank_dock_theme_set_GlowPulseTime (PlankDockTheme* self,
                                         gint value);
gint plank_dock_theme_get_UrgentHueShift (PlankDockTheme* self);
void plank_dock_theme_set_UrgentHueShift (PlankDockTheme* self,
                                          gint value);
gint plank_dock_theme_get_ItemMoveTime (PlankDockTheme* self);
void plank_dock_theme_set_ItemMoveTime (PlankDockTheme* self,
                                        gint value);
gboolean plank_dock_theme_get_CascadeHide (PlankDockTheme* self);
void plank_dock_theme_set_CascadeHide (PlankDockTheme* self,
                                       gboolean value);
void plank_dock_theme_get_BadgeColor (PlankDockTheme* self,
                                      PlankColor * result);
void plank_dock_theme_set_BadgeColor (PlankDockTheme* self,
                                      PlankColor * value);
GType plank_animation_mode_get_type (void) G_GNUC_CONST;
gdouble plank_easing_for_mode (PlankAnimationMode mode,
                               gdouble t,
                               gdouble d);
PlankRenderer* plank_renderer_construct (GType object_type,
                                         GtkWidget* widget);
gboolean plank_renderer_animation_needed (PlankRenderer* self,
                                          gint64 frame_time);
void plank_renderer_initialize_frame (PlankRenderer* self,
                                      gint64 frame_time);
void plank_renderer_draw (PlankRenderer* self,
                          cairo_t* cr,
                          gint64 frame_time);
void plank_renderer_force_frame_time_update (PlankRenderer* self);
void plank_renderer_animated_draw (PlankRenderer* self);
GtkWidget* plank_renderer_get_widget (PlankRenderer* self);
gint64 plank_renderer_get_frame_time (PlankRenderer* self);
PlankSurface* plank_surface_new (gint width,
                                 gint height);
PlankSurface* plank_surface_construct (GType object_type,
                                       gint width,
                                       gint height);
PlankSurface* plank_surface_new_with_cairo_surface (gint width,
                                                    gint height,
                                                    cairo_surface_t* model);
PlankSurface* plank_surface_construct_with_cairo_surface (GType object_type,
                                                          gint width,
                                                          gint height,
                                                          cairo_surface_t* model);
PlankSurface* plank_surface_new_with_surface (gint width,
                                              gint height,
                                              PlankSurface* model);
PlankSurface* plank_surface_construct_with_surface (GType object_type,
                                                    gint width,
                                                    gint height,
                                                    PlankSurface* model);
PlankSurface* plank_surface_new_with_internal (cairo_surface_t* image);
PlankSurface* plank_surface_construct_with_internal (GType object_type,
                                                     cairo_surface_t* image);
void plank_surface_clear (PlankSurface* self);
PlankSurface* plank_surface_copy (PlankSurface* self);
PlankSurface* plank_surface_scaled_copy (PlankSurface* self,
                                         gint width,
                                         gint height);
GdkPixbuf* plank_surface_to_pixbuf (PlankSurface* self);
PlankSurface* plank_surface_create_mask (PlankSurface* self,
                                         gdouble threshold,
                                         GdkRectangle* extent);
void plank_surface_average_color (PlankSurface* self,
                                  PlankColor* result);
void plank_surface_fast_blur (PlankSurface* self,
                              gint radius,
                              gint process_count);
void plank_surface_exponential_blur (PlankSurface* self,
                                     gint radius);
void plank_surface_gaussian_blur (PlankSurface* self,
                                  gint radius);
cairo_surface_t* plank_surface_get_Internal (PlankSurface* self);
gint plank_surface_get_Width (PlankSurface* self);
gint plank_surface_get_Height (PlankSurface* self);
cairo_t* plank_surface_get_Context (PlankSurface* self);
GType plank_surface_cache_flags_get_type (void) G_GNUC_CONST;
GType plank_surface_cache_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankSurfaceCache, g_object_unref)
PlankSurfaceCache* plank_surface_cache_new (GType g_type,
                                            GBoxedCopyFunc g_dup_func,
                                            GDestroyNotify g_destroy_func,
                                            PlankSurfaceCacheFlags flags);
PlankSurfaceCache* plank_surface_cache_construct (GType object_type,
                                                  GType g_type,
                                                  GBoxedCopyFunc g_dup_func,
                                                  GDestroyNotify g_destroy_func,
                                                  PlankSurfaceCacheFlags flags);
PlankSurface* plank_surface_cache_get_surface (PlankSurfaceCache* self,
                                               GType g_type,
                                               GBoxedCopyFunc g_dup_func,
                                               GDestroyNotify g_destroy_func,
                                               gint width,
                                               gint height,
                                               PlankSurface* model,
                                               PlankDrawFunc draw_func,
                                               gpointer draw_func_target,
                                               PlankDrawDataFunc draw_data_func,
                                               gpointer draw_data_func_target);
void plank_surface_cache_clear (PlankSurfaceCache* self);
PlankSurfaceCacheFlags plank_surface_cache_get_flags (PlankSurfaceCache* self);
void plank_surface_cache_set_flags (PlankSurfaceCache* self,
                                    PlankSurfaceCacheFlags value);
#define PLANK_THEME_DEFAULT_NAME "Default"
#define PLANK_THEME_GTK_THEME_NAME "Gtk+"
GtkStyleContext* plank_theme_create_style_context (GType widget_type,
                                                   GtkStyleContext* parent_style,
                                                   GtkCssProvider* provider,
                                                   const gchar* object_name,
                                                   const gchar* first_class,
                                                   ...);
PlankTheme* plank_theme_construct (GType object_type);
PlankTheme* plank_theme_construct_with_name (GType object_type,
                                             const gchar* name);
GtkStyleContext* plank_theme_get_style_context (PlankTheme* self);
void plank_theme_load (PlankTheme* self,
                       const gchar* type);
gint plank_theme_get_top_offset (PlankTheme* self);
gint plank_theme_get_bottom_offset (PlankTheme* self);
void plank_theme_draw_background (PlankTheme* self,
                                  PlankSurface* surface);
void plank_theme_draw_inner_rect (PlankTheme* self,
                                  cairo_t* cr,
                                  gint width,
                                  gint height);
void plank_theme_draw_rounded_rect (cairo_t* cr,
                                    gdouble x,
                                    gdouble y,
                                    gdouble width,
                                    gdouble height,
                                    gdouble top_radius,
                                    gdouble bottom_radius,
                                    gdouble line_width);
void plank_theme_draw_rounded_line (cairo_t* cr,
                                    gdouble x,
                                    gdouble y,
                                    gdouble width,
                                    gdouble height,
                                    gboolean is_round_left,
                                    gboolean is_round_right,
                                    cairo_pattern_t* stroke,
                                    cairo_pattern_t* fill);
gchar** plank_theme_get_theme_list (gint* result_length1);
GFile* plank_theme_get_theme_folder (const gchar* name);
gint plank_theme_get_TopRoundness (PlankTheme* self);
void plank_theme_set_TopRoundness (PlankTheme* self,
                                   gint value);
gint plank_theme_get_BottomRoundness (PlankTheme* self);
void plank_theme_set_BottomRoundness (PlankTheme* self,
                                      gint value);
gint plank_theme_get_LineWidth (PlankTheme* self);
void plank_theme_set_LineWidth (PlankTheme* self,
                                gint value);
void plank_theme_get_OuterStrokeColor (PlankTheme* self,
                                       PlankColor * result);
void plank_theme_set_OuterStrokeColor (PlankTheme* self,
                                       PlankColor * value);
void plank_theme_get_FillStartColor (PlankTheme* self,
                                     PlankColor * result);
void plank_theme_set_FillStartColor (PlankTheme* self,
                                     PlankColor * value);
void plank_theme_get_FillEndColor (PlankTheme* self,
                                   PlankColor * result);
void plank_theme_set_FillEndColor (PlankTheme* self,
                                   PlankColor * value);
void plank_theme_get_InnerStrokeColor (PlankTheme* self,
                                       PlankColor * result);
void plank_theme_set_InnerStrokeColor (PlankTheme* self,
                                       PlankColor * value);
GType plank_abstract_main_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankAbstractMain, g_object_unref)
void plank_abstract_main_initialize (PlankAbstractMain* self);
void plank_abstract_main_create_docks (PlankAbstractMain* self);
void plank_abstract_main_create_actions (PlankAbstractMain* self);
gboolean plank_abstract_main_is_launcher_for_dock (PlankAbstractMain* self,
                                                   const gchar* launcher);
PlankAbstractMain* plank_abstract_main_construct (GType object_type);
const gchar* plank_abstract_main_get_build_data_dir (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_build_pkg_data_dir (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_build_release_name (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_build_version (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_build_version_info (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_program_name (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_exec_name (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_app_copyright (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_app_dbus (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_app_icon (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_app_launcher (PlankAbstractMain* self);
const gchar* plank_abstract_main_get_main_url (PlankAbstractMain* self);
void plank_abstract_main_set_main_url (PlankAbstractMain* self,
                                       const gchar* value);
const gchar* plank_abstract_main_get_help_url (PlankAbstractMain* self);
void plank_abstract_main_set_help_url (PlankAbstractMain* self,
                                       const gchar* value);
const gchar* plank_abstract_main_get_translate_url (PlankAbstractMain* self);
void plank_abstract_main_set_translate_url (PlankAbstractMain* self,
                                            const gchar* value);
gchar** plank_abstract_main_get_about_authors (PlankAbstractMain* self,
                                               gint* result_length1);
void plank_abstract_main_set_about_authors (PlankAbstractMain* self,
                                            gchar** value,
                                            gint value_length1);
gchar** plank_abstract_main_get_about_documenters (PlankAbstractMain* self,
                                                   gint* result_length1);
void plank_abstract_main_set_about_documenters (PlankAbstractMain* self,
                                                gchar** value,
                                                gint value_length1);
gchar** plank_abstract_main_get_about_artists (PlankAbstractMain* self,
                                               gint* result_length1);
void plank_abstract_main_set_about_artists (PlankAbstractMain* self,
                                            gchar** value,
                                            gint value_length1);
const gchar* plank_abstract_main_get_about_translators (PlankAbstractMain* self);
void plank_abstract_main_set_about_translators (PlankAbstractMain* self,
                                                const gchar* value);
GtkLicense plank_abstract_main_get_about_license_type (PlankAbstractMain* self);
void plank_abstract_main_set_about_license_type (PlankAbstractMain* self,
                                                 GtkLicense value);
GType plank_factory_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankFactory, g_object_unref)
extern PlankAbstractMain* plank_factory_main;
GType plank_item_factory_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankItemFactory, g_object_unref)
extern PlankItemFactory* plank_factory_item_factory;
void plank_factory_init (PlankAbstractMain* main_class,
                         PlankItemFactory* item);
PlankFactory* plank_factory_new (void);
PlankFactory* plank_factory_construct (GType object_type);
PlankDockElement* plank_item_factory_make_element (PlankItemFactory* self,
                                                   GFile* file);
PlankDockItem* plank_item_factory_get_item_for_dock (PlankItemFactory* self);
PlankDockElement* plank_item_factory_default_make_element (PlankItemFactory* self,
                                                           GFile* file,
                                                           const gchar* launcher);
gchar* plank_item_factory_get_launcher_from_dockitem (PlankItemFactory* self,
                                                      GFile* file);
GeeArrayList* plank_item_factory_load_elements (PlankItemFactory* self,
                                                GFile* source_dir,
                                                gchar** ordering,
                                                gint ordering_length1);
void plank_item_factory_make_default_items (PlankItemFactory* self);
GFile* plank_item_factory_make_dock_item (PlankItemFactory* self,
                                          const gchar* uri,
                                          GFile* target_dir);
PlankItemFactory* plank_item_factory_new (void);
PlankItemFactory* plank_item_factory_construct (GType object_type);
PlankApplicationDockItem* plank_application_dock_item_new_with_dockitem_file (GFile* file);
PlankApplicationDockItem* plank_application_dock_item_construct_with_dockitem_file (GType object_type,
                                                                                    GFile* file);
PlankApplicationDockItem* plank_application_dock_item_new_with_dockitem_filename (const gchar* filename);
PlankApplicationDockItem* plank_application_dock_item_construct_with_dockitem_filename (GType object_type,
                                                                                        const gchar* filename);
gboolean plank_application_dock_item_is_running (PlankApplicationDockItem* self);
gboolean plank_application_dock_item_is_window (PlankApplicationDockItem* self);
void plank_application_dock_item_set_urgent (PlankApplicationDockItem* self,
                                             gboolean is_urgent);
void plank_application_dock_item_parse_launcher (const gchar* launcher,
                                                 gchar* * icon,
                                                 gchar* * text,
                                                 GeeArrayList* actions,
                                                 GeeMap* actions_map,
                                                 GeeArrayList* mimes);
const gchar* plank_application_dock_item_get_unity_application_uri (PlankApplicationDockItem* self);
const gchar* plank_application_dock_item_get_unity_dbusname (PlankApplicationDockItem* self);
gboolean plank_application_dock_item_has_unity_info (PlankApplicationDockItem* self);
void plank_application_dock_item_unity_update (PlankApplicationDockItem* self,
                                               const gchar* sender_name,
                                               GVariantIter* prop_iter);
void plank_application_dock_item_unity_reset (PlankApplicationDockItem* self);
PlankApplicationDockItem* plank_application_dock_item_new (void);
PlankApplicationDockItem* plank_application_dock_item_construct (GType object_type);
GType plank_unity_client_get_type (void) G_GNUC_CONST;
GType plank_application_dock_item_provider_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankApplicationDockItemProvider, g_object_unref)
PlankApplicationDockItemProvider* plank_application_dock_item_provider_new (GFile* launchers_dir);
PlankApplicationDockItemProvider* plank_application_dock_item_provider_construct (GType object_type,
                                                                                  GFile* launchers_dir);
PlankApplicationDockItem* plank_application_dock_item_provider_item_for_application (PlankApplicationDockItemProvider* self,
                                                                                     BamfApplication* app);
void plank_application_dock_item_provider_app_opened (PlankApplicationDockItemProvider* self,
                                                      BamfApplication* app);
void plank_application_dock_item_provider_delay_items_monitor (PlankApplicationDockItemProvider* self);
void plank_application_dock_item_provider_resume_items_monitor (PlankApplicationDockItemProvider* self);
GFile* plank_application_dock_item_provider_get_LaunchersDir (PlankApplicationDockItemProvider* self);
GType plank_default_application_dock_item_provider_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDefaultApplicationDockItemProvider, g_object_unref)
PlankDefaultApplicationDockItemProvider* plank_default_application_dock_item_provider_new (PlankDockPreferences* prefs,
                                                                                           GFile* launchers_dir);
PlankDefaultApplicationDockItemProvider* plank_default_application_dock_item_provider_construct (GType object_type,
                                                                                                 PlankDockPreferences* prefs,
                                                                                                 GFile* launchers_dir);
void plank_default_application_dock_item_provider_pin_item (PlankDefaultApplicationDockItemProvider* self,
                                                            PlankDockItem* item);
PlankDockPreferences* plank_default_application_dock_item_provider_get_Prefs (PlankDefaultApplicationDockItemProvider* self);
GType plank_placeholder_dock_item_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankPlaceholderDockItem, g_object_unref)
extern PlankPlaceholderDockItem* plank_dock_container_placeholder_item;
PlankDockContainer* plank_dock_container_construct (GType object_type);
void plank_dock_container_prepare (PlankDockContainer* self);
gboolean plank_dock_container_add (PlankDockContainer* self,
                                   PlankDockElement* element,
                                   PlankDockElement* target);
void plank_dock_container_prepend (PlankDockContainer* self,
                                   PlankDockElement* element);
gboolean plank_dock_container_add_all (PlankDockContainer* self,
                                       GeeArrayList* elements);
gboolean plank_dock_container_remove (PlankDockContainer* self,
                                      PlankDockElement* element);
gboolean plank_dock_container_remove_all (PlankDockContainer* self,
                                          GeeArrayList* elements);
gboolean plank_dock_container_clear (PlankDockContainer* self);
void plank_dock_container_update_visible_elements (PlankDockContainer* self);
gboolean plank_dock_container_move_to (PlankDockContainer* self,
                                       PlankDockElement* move,
                                       PlankDockElement* target);
gboolean plank_dock_container_replace (PlankDockContainer* self,
                                       PlankDockElement* new_element,
                                       PlankDockElement* old_element);
void plank_dock_container_connect_element (PlankDockContainer* self,
                                           PlankDockElement* element);
void plank_dock_container_disconnect_element (PlankDockContainer* self,
                                              PlankDockElement* element);
void plank_dock_container_move_element (GeeList* elements,
                                        gint from,
                                        gint to,
                                        GeeList* moved);
GeeArrayList* plank_dock_container_get_VisibleElements (PlankDockContainer* self);
GeeArrayList* plank_dock_container_get_Elements (PlankDockContainer* self);
PlankDockItem* plank_dock_item_construct (GType object_type);
void plank_dock_item_load_from_launcher (PlankDockItem* self);
void plank_dock_item_delete (PlankDockItem* self);
void plank_dock_item_reset_icon_buffer (PlankDockItem* self);
void plank_dock_item_unset_move_state (PlankDockItem* self);
PlankSurface* plank_dock_item_get_surface (PlankDockItem* self,
                                           gint width,
                                           gint height,
                                           PlankSurface* model);
PlankSurface* plank_dock_item_get_background_surface (PlankDockItem* self,
                                                      gint width,
                                                      gint height,
                                                      PlankSurface* model,
                                                      PlankDrawDataFunc draw_data_func,
                                                      gpointer draw_data_func_target);
PlankSurface* plank_dock_item_get_foreground_surface (PlankDockItem* self,
                                                      gint width,
                                                      gint height,
                                                      PlankSurface* model,
                                                      PlankDrawDataFunc draw_data_func,
                                                      gpointer draw_data_func_target);
PlankSurface* plank_dock_item_get_surface_copy (PlankDockItem* self,
                                                gint width,
                                                gint height,
                                                PlankSurface* model);
void plank_dock_item_draw_icon (PlankDockItem* self,
                                PlankSurface* surface);
void plank_dock_item_draw_icon_fast (PlankDockItem* self,
                                     PlankSurface* surface);
gboolean plank_dock_item_is_valid (PlankDockItem* self);
void plank_dock_item_copy_values_to (PlankDockItem* self,
                                     PlankDockItem* target);
const gchar* plank_dock_item_get_Icon (PlankDockItem* self);
void plank_dock_item_set_Icon (PlankDockItem* self,
                               const gchar* value);
GdkPixbuf* plank_dock_item_get_ForcePixbuf (PlankDockItem* self);
void plank_dock_item_set_ForcePixbuf (PlankDockItem* self,
                                      GdkPixbuf* value);
gint64 plank_dock_item_get_Count (PlankDockItem* self);
void plank_dock_item_set_Count (PlankDockItem* self,
                                gint64 value);
gboolean plank_dock_item_get_CountVisible (PlankDockItem* self);
void plank_dock_item_set_CountVisible (PlankDockItem* self,
                                       gboolean value);
gdouble plank_dock_item_get_Progress (PlankDockItem* self);
void plank_dock_item_set_Progress (PlankDockItem* self,
                                   gdouble value);
gboolean plank_dock_item_get_ProgressVisible (PlankDockItem* self);
void plank_dock_item_set_ProgressVisible (PlankDockItem* self,
                                          gboolean value);
gint plank_dock_item_get_Position (PlankDockItem* self);
void plank_dock_item_set_Position (PlankDockItem* self,
                                   gint value);
gint plank_dock_item_get_LastPosition (PlankDockItem* self);
void plank_dock_item_set_LastPosition (PlankDockItem* self,
                                       gint value);
GType plank_item_state_get_type (void) G_GNUC_CONST;
PlankItemState plank_dock_item_get_State (PlankDockItem* self);
void plank_dock_item_set_State (PlankDockItem* self,
                                PlankItemState value);
GType plank_indicator_state_get_type (void) G_GNUC_CONST;
PlankIndicatorState plank_dock_item_get_Indicator (PlankDockItem* self);
void plank_dock_item_set_Indicator (PlankDockItem* self,
                                    PlankIndicatorState value);
void plank_dock_item_get_AverageIconColor (PlankDockItem* self,
                                           PlankColor * result);
void plank_dock_item_set_AverageIconColor (PlankDockItem* self,
                                           PlankColor * value);
gchar* plank_dock_item_get_DockItemFilename (PlankDockItem* self);
const gchar* plank_dock_item_get_Launcher (PlankDockItem* self);
GType plank_dock_item_preferences_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankDockItemPreferences, g_object_unref)
PlankDockItemPreferences* plank_dock_item_get_Prefs (PlankDockItem* self);
GType plank_point_d_get_type (void) G_GNUC_CONST;
PlankPointD* plank_point_d_dup (const PlankPointD* self);
void plank_point_d_free (PlankPointD* self);
void plank_dock_item_draw_value_move_in (PlankDockItemDrawValue* self,
                                         GtkPositionType position,
                                         gdouble damount);
void plank_dock_item_draw_value_move_right (PlankDockItemDrawValue* self,
                                            GtkPositionType position,
                                            gdouble damount);
PlankDockItemDrawValue* plank_dock_item_draw_value_new (void);
PlankDockItemDrawValue* plank_dock_item_draw_value_construct (GType object_type);
PlankDockItemProvider* plank_dock_item_provider_new (void);
PlankDockItemProvider* plank_dock_item_provider_construct (GType object_type);
gboolean plank_dock_item_provider_item_exists_for_uri (PlankDockItemProvider* self,
                                                       const gchar* uri);
PlankDockItem* plank_dock_item_provider_item_for_uri (PlankDockItemProvider* self,
                                                      const gchar* uri);
gboolean plank_dock_item_provider_add_item_with_uri (PlankDockItemProvider* self,
                                                     const gchar* uri,
                                                     PlankDockItem* target);
void plank_dock_item_provider_handle_item_deleted (PlankDockItemProvider* self,
                                                   PlankDockItem* item);
gchar** plank_dock_item_provider_get_dockitem_filenames (PlankDockItemProvider* self,
                                                         gint* result_length1);
PlankDockItemPreferences* plank_dock_item_preferences_new_with_launcher (const gchar* launcher);
PlankDockItemPreferences* plank_dock_item_preferences_construct_with_launcher (GType object_type,
                                                                               const gchar* launcher);
PlankDockItemPreferences* plank_dock_item_preferences_new_with_file (GFile* file);
PlankDockItemPreferences* plank_dock_item_preferences_construct_with_file (GType object_type,
                                                                           GFile* file);
PlankDockItemPreferences* plank_dock_item_preferences_new_with_filename (const gchar* filename);
PlankDockItemPreferences* plank_dock_item_preferences_construct_with_filename (GType object_type,
                                                                               const gchar* filename);
PlankDockItemPreferences* plank_dock_item_preferences_new (void);
PlankDockItemPreferences* plank_dock_item_preferences_construct (GType object_type);
const gchar* plank_dock_item_preferences_get_Launcher (PlankDockItemPreferences* self);
void plank_dock_item_preferences_set_Launcher (PlankDockItemPreferences* self,
                                               const gchar* value);
void plank_dock_element_clicked (PlankDockElement* self,
                                 PlankPopupButton button,
                                 GdkModifierType mod,
                                 guint32 event_time);
PlankAnimationType plank_dock_element_on_clicked (PlankDockElement* self,
                                                  PlankPopupButton button,
                                                  GdkModifierType mod,
                                                  guint32 event_time);
void plank_dock_element_hovered (PlankDockElement* self);
PlankAnimationType plank_dock_element_on_hovered (PlankDockElement* self);
void plank_dock_element_scrolled (PlankDockElement* self,
                                  GdkScrollDirection direction,
                                  GdkModifierType mod,
                                  guint32 event_time);
PlankAnimationType plank_dock_element_on_scrolled (PlankDockElement* self,
                                                   GdkScrollDirection direction,
                                                   GdkModifierType mod,
                                                   guint32 event_time);
PlankDockController* plank_dock_element_get_dock (PlankDockElement* self);
GeeArrayList* plank_dock_element_get_menu_items (PlankDockElement* self);
gchar* plank_dock_element_get_drop_text (PlankDockElement* self);
gboolean plank_dock_element_can_be_removed (PlankDockElement* self);
gboolean plank_dock_element_can_accept_drop (PlankDockElement* self,
                                             GeeArrayList* uris);
gboolean plank_dock_element_accept_drop (PlankDockElement* self,
                                         GeeArrayList* uris);
gchar* plank_dock_element_unique_id (PlankDockElement* self);
gchar* plank_dock_element_as_uri (PlankDockElement* self);
void plank_dock_element_reset_buffers (PlankDockElement* self);
GtkMenuItem* plank_dock_element_create_menu_item (const gchar* title,
                                                  const gchar* icon,
                                                  gboolean force_show_icon);
GtkMenuItem* plank_dock_element_create_menu_item_with_pixbuf (const gchar* title,
                                                              GdkPixbuf* pixbuf,
                                                              gboolean force_show_icon);
GtkMenuItem* plank_dock_element_create_literal_menu_item (const gchar* title,
                                                          const gchar* icon,
                                                          gboolean force_show_icon);
GtkMenuItem* plank_dock_element_create_literal_menu_item_with_pixbuf (const gchar* title,
                                                                      GdkPixbuf* pixbuf,
                                                                      gboolean force_show_icon);
PlankDockElement* plank_dock_element_construct (GType object_type);
PlankDockContainer* plank_dock_element_get_Container (PlankDockElement* self);
void plank_dock_element_set_Container (PlankDockElement* self,
                                       PlankDockContainer* value);
const gchar* plank_dock_element_get_Text (PlankDockElement* self);
void plank_dock_element_set_Text (PlankDockElement* self,
                                  const gchar* value);
gboolean plank_dock_element_get_IsAttached (PlankDockElement* self);
void plank_dock_element_set_IsAttached (PlankDockElement* self,
                                        gboolean value);
gboolean plank_dock_element_get_IsVisible (PlankDockElement* self);
void plank_dock_element_set_IsVisible (PlankDockElement* self,
                                       gboolean value);
PlankPopupButton plank_dock_element_get_Button (PlankDockElement* self);
void plank_dock_element_set_Button (PlankDockElement* self,
                                    PlankPopupButton value);
PlankAnimationType plank_dock_element_get_ClickedAnimation (PlankDockElement* self);
void plank_dock_element_set_ClickedAnimation (PlankDockElement* self,
                                              PlankAnimationType value);
PlankAnimationType plank_dock_element_get_HoveredAnimation (PlankDockElement* self);
void plank_dock_element_set_HoveredAnimation (PlankDockElement* self,
                                              PlankAnimationType value);
PlankAnimationType plank_dock_element_get_ScrolledAnimation (PlankDockElement* self);
void plank_dock_element_set_ScrolledAnimation (PlankDockElement* self,
                                               PlankAnimationType value);
gint64 plank_dock_element_get_AddTime (PlankDockElement* self);
void plank_dock_element_set_AddTime (PlankDockElement* self,
                                     gint64 value);
gint64 plank_dock_element_get_RemoveTime (PlankDockElement* self);
void plank_dock_element_set_RemoveTime (PlankDockElement* self,
                                        gint64 value);
gint64 plank_dock_element_get_LastClicked (PlankDockElement* self);
void plank_dock_element_set_LastClicked (PlankDockElement* self,
                                         gint64 value);
gint64 plank_dock_element_get_LastHovered (PlankDockElement* self);
void plank_dock_element_set_LastHovered (PlankDockElement* self,
                                         gint64 value);
gint64 plank_dock_element_get_LastScrolled (PlankDockElement* self);
void plank_dock_element_set_LastScrolled (PlankDockElement* self,
                                          gint64 value);
gint64 plank_dock_element_get_LastUrgent (PlankDockElement* self);
void plank_dock_element_set_LastUrgent (PlankDockElement* self,
                                        gint64 value);
gint64 plank_dock_element_get_LastActive (PlankDockElement* self);
void plank_dock_element_set_LastActive (PlankDockElement* self,
                                        gint64 value);
gint64 plank_dock_element_get_LastMove (PlankDockElement* self);
void plank_dock_element_set_LastMove (PlankDockElement* self,
                                      gint64 value);
gint64 plank_dock_element_get_LastValid (PlankDockElement* self);
void plank_dock_element_set_LastValid (PlankDockElement* self,
                                       gint64 value);
PlankPopupButton plank_popup_button_from_event_button (GdkEventButton* event);
GType plank_file_dock_item_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankFileDockItem, g_object_unref)
PlankFileDockItem* plank_file_dock_item_new_with_file (GFile* file);
PlankFileDockItem* plank_file_dock_item_construct_with_file (GType object_type,
                                                             GFile* file);
PlankFileDockItem* plank_file_dock_item_new_with_dockitem_file (GFile* file);
PlankFileDockItem* plank_file_dock_item_construct_with_dockitem_file (GType object_type,
                                                                      GFile* file);
PlankFileDockItem* plank_file_dock_item_new_with_dockitem_filename (const gchar* filename);
PlankFileDockItem* plank_file_dock_item_construct_with_dockitem_filename (GType object_type,
                                                                          const gchar* filename);
void plank_file_dock_item_launch (PlankFileDockItem* self);
PlankFileDockItem* plank_file_dock_item_new (void);
PlankFileDockItem* plank_file_dock_item_construct (GType object_type);
GFile* plank_file_dock_item_get_OwnedFile (PlankFileDockItem* self);
void plank_file_dock_item_set_OwnedFile (PlankFileDockItem* self,
                                         GFile* value);
PlankPlaceholderDockItem* plank_placeholder_dock_item_new (void);
PlankPlaceholderDockItem* plank_placeholder_dock_item_construct (GType object_type);
GType plank_plank_dock_item_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankPlankDockItem, g_object_unref)
PlankPlankDockItem* plank_plank_dock_item_get_instance (void);
GType plank_transient_dock_item_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankTransientDockItem, g_object_unref)
PlankTransientDockItem* plank_transient_dock_item_new_with_launcher (const gchar* launcher_uri);
PlankTransientDockItem* plank_transient_dock_item_construct_with_launcher (GType object_type,
                                                                           const gchar* launcher_uri);
PlankTransientDockItem* plank_transient_dock_item_new (void);
PlankTransientDockItem* plank_transient_dock_item_construct (GType object_type);
GType plank_xdg_session_class_get_type (void) G_GNUC_CONST;
PlankXdgSessionClass plank_xdg_session_class_from_string (const gchar* s);
GType plank_xdg_session_desktop_get_type (void) G_GNUC_CONST;
PlankXdgSessionDesktop plank_xdg_session_desktop_from_string (const gchar* s);
GType plank_xdg_session_type_get_type (void) G_GNUC_CONST;
PlankXdgSessionType plank_xdg_session_type_from_string (const gchar* s);
void plank_environment_initialize (void);
gboolean plank_environment_is_session_class (PlankXdgSessionClass type);
gboolean plank_environment_is_session_desktop (PlankXdgSessionDesktop type);
gboolean plank_environment_is_session_type (PlankXdgSessionType type);
GType plank_log_level_get_type (void) G_GNUC_CONST;
GType plank_logger_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankLogger, g_object_unref)
void plank_logger_initialize (const gchar* app_name);
void plank_logger_notification (const gchar* msg,
                                const gchar* icon);
void plank_logger_verbose (const gchar* msg,
                           ...);
PlankLogLevel plank_logger_get_DisplayLevel (void);
void plank_logger_set_DisplayLevel (PlankLogLevel value);
GType plank_paths_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankPaths, g_object_unref)
void plank_paths_initialize (const gchar* app_name,
                             const gchar* data_folder);
gboolean plank_paths_ensure_directory_exists (GFile* dir);
GFile* plank_paths_get_HomeFolder (void);
void plank_paths_set_HomeFolder (GFile* value);
GFile* plank_paths_get_DataFolder (void);
void plank_paths_set_DataFolder (GFile* value);
GFile* plank_paths_get_ThemeFolder (void);
void plank_paths_set_ThemeFolder (GFile* value);
GFile* plank_paths_get_ConfigHomeFolder (void);
void plank_paths_set_ConfigHomeFolder (GFile* value);
GFile* plank_paths_get_DataHomeFolder (void);
void plank_paths_set_DataHomeFolder (GFile* value);
GFile* plank_paths_get_CacheHomeFolder (void);
void plank_paths_set_CacheHomeFolder (GFile* value);
GeeArrayList* plank_paths_get_DataDirFolders (void);
void plank_paths_set_DataDirFolders (GeeArrayList* value);
GFile* plank_paths_get_AppConfigFolder (void);
void plank_paths_set_AppConfigFolder (GFile* value);
GFile* plank_paths_get_AppDataFolder (void);
void plank_paths_set_AppDataFolder (GFile* value);
GFile* plank_paths_get_AppThemeFolder (void);
void plank_paths_set_AppThemeFolder (GFile* value);
GFile* plank_paths_get_AppCacheFolder (void);
void plank_paths_set_AppCacheFolder (GFile* value);
const gchar* plank_paths_get_AppName (void);
void plank_paths_set_AppName (const gchar* value);
GType plank_serializable_get_type (void) G_GNUC_CONST;
gchar* plank_serializable_serialize (PlankSerializable* self);
void plank_serializable_deserialize (PlankSerializable* self,
                                     const gchar* s);
PlankPreferences* plank_preferences_construct (GType object_type);
void plank_preferences_verify (PlankPreferences* self,
                               const gchar* prop);
void plank_preferences_reset_properties (PlankPreferences* self);
PlankPreferences* plank_preferences_construct_with_file (GType object_type,
                                                         GFile* file);
PlankPreferences* plank_preferences_construct_with_filename (GType object_type,
                                                             const gchar* filename);
void plank_preferences_init_from_file (PlankPreferences* self,
                                       GFile* file);
void plank_preferences_init_from_filename (PlankPreferences* self,
                                           const gchar* filename);
void plank_preferences_delay (PlankPreferences* self);
void plank_preferences_apply (PlankPreferences* self);
gchar* plank_preferences_get_filename (PlankPreferences* self);
GFile* plank_preferences_get_backing_file (PlankPreferences* self);
void plank_preferences_delete (PlankPreferences* self);
PlankSettings* plank_settings_construct (GType object_type,
                                         const gchar* schema);
PlankSettings* plank_settings_construct_with_path (GType object_type,
                                                   const gchar* schema,
                                                   const gchar* path);
void plank_settings_verify (PlankSettings* self,
                            const gchar* name);
void plank_settings_reset_all (PlankSettings* self);
void plank_settings_delay (PlankSettings* self);
void plank_settings_apply (PlankSettings* self);
GSettings* plank_settings_get_settings (PlankSettings* self);
GSettingsBindFlags plank_settings_get_bind_flags (PlankSettings* self);
GType plank_system_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankSystem, g_object_unref)
PlankSystem* plank_system_get_default (void);
PlankSystem* plank_system_new (GAppLaunchContext* context);
PlankSystem* plank_system_construct (GType object_type,
                                     GAppLaunchContext* context);
void plank_system_open_uri (PlankSystem* self,
                            const gchar* uri);
void plank_system_open (PlankSystem* self,
                        GFile* file);
void plank_system_open_files (PlankSystem* self,
                              GFile** files,
                              gint files_length1);
void plank_system_launch (PlankSystem* self,
                          GFile* app);
void plank_system_launch_with_files (PlankSystem* self,
                                     GFile* app,
                                     GFile** files,
                                     gint files_length1);
GAppLaunchContext* plank_system_get_context (PlankSystem* self);
void plank_unity_client_update_launcher_entry (PlankUnityClient* self,
                                               const gchar* sender_name,
                                               GVariant* parameters,
                                               gboolean is_retry);
void plank_unity_client_remove_launcher_entry (PlankUnityClient* self,
                                               const gchar* sender_name);
GType plank_unity_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankUnity, g_object_unref)
PlankUnity* plank_unity_get_default (void);
void plank_unity_add_client (PlankUnity* self,
                             PlankUnityClient* client);
void plank_unity_remove_client (PlankUnity* self,
                                PlankUnityClient* client);
GType plank_task_priority_get_type (void) G_GNUC_CONST;
GType plank_worker_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankWorker, g_object_unref)
PlankWorker* plank_worker_get_default (void);
void plank_worker_add_task (PlankWorker* self,
                            GThreadFunc func,
                            gpointer func_target,
                            PlankTaskPriority priority);
void plank_worker_add_task_with_result (PlankWorker* self,
                                        GType g_type,
                                        GBoxedCopyFunc g_dup_func,
                                        GDestroyNotify g_destroy_func,
                                        PlankTaskFunc func,
                                        gpointer func_target,
                                        GDestroyNotify func_target_destroy_notify,
                                        PlankTaskPriority priority,
                                        GAsyncReadyCallback _callback_,
                                        gpointer _user_data_);
gpointer plank_worker_add_task_with_result_finish (PlankWorker* self,
                                                   GAsyncResult* _res_,
                                                   GError** error);
PlankCompositedWindow* plank_composited_window_new (void);
PlankCompositedWindow* plank_composited_window_construct (GType object_type);
PlankCompositedWindow* plank_composited_window_new_with_type (GtkWindowType window_type);
PlankCompositedWindow* plank_composited_window_construct_with_type (GType object_type,
                                                                    GtkWindowType window_type);
PlankDockWindow* plank_dock_window_new (PlankDockController* controller);
PlankDockWindow* plank_dock_window_construct (GType object_type,
                                              PlankDockController* controller);
gboolean plank_dock_window_update_hovered (PlankDockWindow* self,
                                           gint x,
                                           gint y);
void plank_dock_window_update_size_and_position (PlankDockWindow* self);
void plank_dock_window_update_icon_regions (PlankDockWindow* self);
void plank_dock_window_update_icon_region (PlankDockWindow* self,
                                           PlankApplicationDockItem* appitem);
gboolean plank_dock_window_menu_is_visible (PlankDockWindow* self);
PlankDockItem* plank_dock_window_get_HoveredItem (PlankDockWindow* self);
PlankDockItemProvider* plank_dock_window_get_HoveredItemProvider (PlankDockWindow* self);
PlankHoverWindow* plank_hover_window_new (void);
PlankHoverWindow* plank_hover_window_construct (GType object_type);
void plank_hover_window_show_at (PlankHoverWindow* self,
                                 gint x,
                                 gint y,
                                 GtkPositionType position);
void plank_hover_window_set_text (PlankHoverWindow* self,
                                  const gchar* text);
GType plank_poof_window_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankPoofWindow, g_object_unref)
PlankPoofWindow* plank_poof_window_get_default (void);
PlankPoofWindow* plank_poof_window_new (void);
PlankPoofWindow* plank_poof_window_construct (GType object_type);
void plank_poof_window_show_at (PlankPoofWindow* self,
                                gint x,
                                gint y);
GType plank_preferences_window_get_type (void) G_GNUC_CONST;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlankPreferencesWindow, g_object_unref)
PlankPreferencesWindow* plank_preferences_window_new (PlankDockController* controller);
PlankPreferencesWindow* plank_preferences_window_construct (GType object_type,
                                                            PlankDockController* controller);
PlankDockController* plank_preferences_window_get_controller (PlankPreferencesWindow* self);
void plank_preferences_window_set_controller (PlankPreferencesWindow* self,
                                              PlankDockController* value);
#define PLANK_MAJOR_VERSION 0
#define PLANK_MINOR_VERSION 11
#define PLANK_MICRO_VERSION 89
#define PLANK_NANO_VERSION 0
guint plank_get_major_version (void);
guint plank_get_minor_version (void);
guint plank_get_micro_version (void);
guint plank_get_nano_version (void);
const gchar* plank_check_version (guint required_major,
                                  guint required_minor,
                                  guint required_micro);

G_END_DECLS

#endif
