meta: Hide libmutter symbols by default and selectively export them

Make meson link libmutter using -fvisibility=hidden, and introduce META_EXPORT
and META_EXPORT_TEST defines to mark a symbols as visible.
The TEST version is meant to be used to flag symbols that are only used
internally by mutter tests, but that should not be considered public API.

This allows us to be more precise in selecting what is exported and what is
not, without the need of a version-script file that would be more complicated
to maintain.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/395
This commit is contained in:
Marco Trevisan (Treviño) 2019-01-23 03:25:35 +01:00
parent e352011830
commit e02fef8e2f
66 changed files with 952 additions and 12 deletions

View File

@ -50,6 +50,7 @@
#define DEFAULT_XKB_MODEL "pc105+inet" #define DEFAULT_XKB_MODEL "pc105+inet"
#define META_TYPE_BACKEND (meta_backend_get_type ()) #define META_TYPE_BACKEND (meta_backend_get_type ())
META_EXPORT
G_DECLARE_DERIVABLE_TYPE (MetaBackend, meta_backend, META, BACKEND, GObject) G_DECLARE_DERIVABLE_TYPE (MetaBackend, meta_backend, META, BACKEND, GObject)
struct _MetaBackendClass struct _MetaBackendClass
@ -118,10 +119,12 @@ void meta_backend_foreach_device_monitor (MetaBackend *backend,
GFunc func, GFunc func,
gpointer user_data); gpointer user_data);
META_EXPORT_TEST
MetaMonitorManager * meta_backend_get_monitor_manager (MetaBackend *backend); MetaMonitorManager * meta_backend_get_monitor_manager (MetaBackend *backend);
MetaOrientationManager * meta_backend_get_orientation_manager (MetaBackend *backend); MetaOrientationManager * meta_backend_get_orientation_manager (MetaBackend *backend);
MetaCursorTracker * meta_backend_get_cursor_tracker (MetaBackend *backend); MetaCursorTracker * meta_backend_get_cursor_tracker (MetaBackend *backend);
MetaCursorRenderer * meta_backend_get_cursor_renderer (MetaBackend *backend); MetaCursorRenderer * meta_backend_get_cursor_renderer (MetaBackend *backend);
META_EXPORT_TEST
MetaRenderer * meta_backend_get_renderer (MetaBackend *backend); MetaRenderer * meta_backend_get_renderer (MetaBackend *backend);
MetaEgl * meta_backend_get_egl (MetaBackend *backend); MetaEgl * meta_backend_get_egl (MetaBackend *backend);
@ -164,6 +167,7 @@ void meta_backend_set_client_pointer_constraint (MetaBackend *backend,
void meta_backend_monitors_changed (MetaBackend *backend); void meta_backend_monitors_changed (MetaBackend *backend);
META_EXPORT_TEST
gboolean meta_is_stage_views_enabled (void); gboolean meta_is_stage_views_enabled (void);
gboolean meta_is_stage_views_scaled (void); gboolean meta_is_stage_views_scaled (void);

View File

@ -24,6 +24,7 @@
#include "backends/meta-backend-types.h" #include "backends/meta-backend-types.h"
#include "backends/meta-monitor-transform.h" #include "backends/meta-monitor-transform.h"
#include "core/util-private.h"
#include "meta/boxes.h" #include "meta/boxes.h"
/* Same as KMS mode flags and X11 randr flags */ /* Same as KMS mode flags and X11 randr flags */
@ -90,10 +91,10 @@ struct _MetaCrtcMode
}; };
#define META_TYPE_CRTC (meta_crtc_get_type ()) #define META_TYPE_CRTC (meta_crtc_get_type ())
G_DECLARE_FINAL_TYPE (MetaCrtc, meta_crtc, META, CRTC, GObject) META_EXPORT_TEST G_DECLARE_FINAL_TYPE (MetaCrtc, meta_crtc, META, CRTC, GObject)
#define META_TYPE_CRTC_MODE (meta_crtc_mode_get_type ()) #define META_TYPE_CRTC_MODE (meta_crtc_mode_get_type ())
G_DECLARE_FINAL_TYPE (MetaCrtcMode, meta_crtc_mode, META, CRTC_MODE, GObject) META_EXPORT_TEST G_DECLARE_FINAL_TYPE (MetaCrtcMode, meta_crtc_mode, META, CRTC_MODE, GObject)
MetaGpu * meta_crtc_get_gpu (MetaCrtc *crtc); MetaGpu * meta_crtc_get_gpu (MetaCrtc *crtc);

View File

@ -27,6 +27,7 @@
#include "backends/meta-monitor-manager-private.h" #include "backends/meta-monitor-manager-private.h"
#define META_TYPE_GPU (meta_gpu_get_type ()) #define META_TYPE_GPU (meta_gpu_get_type ())
META_EXPORT_TEST
G_DECLARE_DERIVABLE_TYPE (MetaGpu, meta_gpu, META, GPU, GObject) G_DECLARE_DERIVABLE_TYPE (MetaGpu, meta_gpu, META, GPU, GObject)
struct _MetaGpuClass struct _MetaGpuClass
@ -37,27 +38,37 @@ struct _MetaGpuClass
GError **error); GError **error);
}; };
META_EXPORT_TEST
const char * meta_gpu_get_kms_file_path (MetaGpu *gpu); const char * meta_gpu_get_kms_file_path (MetaGpu *gpu);
META_EXPORT_TEST
gboolean meta_gpu_read_current (MetaGpu *gpu, gboolean meta_gpu_read_current (MetaGpu *gpu,
GError **error); GError **error);
META_EXPORT_TEST
gboolean meta_gpu_has_hotplug_mode_update (MetaGpu *gpu); gboolean meta_gpu_has_hotplug_mode_update (MetaGpu *gpu);
META_EXPORT_TEST
MetaMonitorManager * meta_gpu_get_monitor_manager (MetaGpu *gpu); MetaMonitorManager * meta_gpu_get_monitor_manager (MetaGpu *gpu);
META_EXPORT_TEST
GList * meta_gpu_get_outputs (MetaGpu *gpu); GList * meta_gpu_get_outputs (MetaGpu *gpu);
META_EXPORT_TEST
GList * meta_gpu_get_crtcs (MetaGpu *gpu); GList * meta_gpu_get_crtcs (MetaGpu *gpu);
META_EXPORT_TEST
GList * meta_gpu_get_modes (MetaGpu *gpu); GList * meta_gpu_get_modes (MetaGpu *gpu);
META_EXPORT_TEST
void meta_gpu_take_outputs (MetaGpu *gpu, void meta_gpu_take_outputs (MetaGpu *gpu,
GList *outputs); GList *outputs);
META_EXPORT_TEST
void meta_gpu_take_crtcs (MetaGpu *gpu, void meta_gpu_take_crtcs (MetaGpu *gpu,
GList *crtcs); GList *crtcs);
META_EXPORT_TEST
void meta_gpu_take_modes (MetaGpu *gpu, void meta_gpu_take_modes (MetaGpu *gpu,
GList *modes); GList *modes);

View File

@ -27,6 +27,7 @@
#include "backends/meta-monitor.h" #include "backends/meta-monitor.h"
#include "backends/meta-monitor-config-manager.h" #include "backends/meta-monitor-config-manager.h"
#include "backends/meta-monitor-manager-private.h" #include "backends/meta-monitor-manager-private.h"
#include "core/util-private.h"
#include "meta/boxes.h" #include "meta/boxes.h"
#define META_MAX_OUTPUTS_PER_MONITOR 4 #define META_MAX_OUTPUTS_PER_MONITOR 4
@ -78,6 +79,7 @@ MetaLogicalMonitor * meta_logical_monitor_new_derived (MetaMonitorManager *monit
void meta_logical_monitor_add_monitor (MetaLogicalMonitor *logical_monitor, void meta_logical_monitor_add_monitor (MetaLogicalMonitor *logical_monitor,
MetaMonitor *monitor); MetaMonitor *monitor);
META_EXPORT_TEST
gboolean meta_logical_monitor_is_primary (MetaLogicalMonitor *logical_monitor); gboolean meta_logical_monitor_is_primary (MetaLogicalMonitor *logical_monitor);
void meta_logical_monitor_make_primary (MetaLogicalMonitor *logical_monitor); void meta_logical_monitor_make_primary (MetaLogicalMonitor *logical_monitor);
@ -88,6 +90,7 @@ MetaMonitorTransform meta_logical_monitor_get_transform (MetaLogicalMonitor *log
MetaRectangle meta_logical_monitor_get_layout (MetaLogicalMonitor *logical_monitor); MetaRectangle meta_logical_monitor_get_layout (MetaLogicalMonitor *logical_monitor);
META_EXPORT_TEST
GList * meta_logical_monitor_get_monitors (MetaLogicalMonitor *logical_monitor); GList * meta_logical_monitor_get_monitors (MetaLogicalMonitor *logical_monitor);
gboolean meta_logical_monitor_has_neighbor (MetaLogicalMonitor *logical_monitor, gboolean meta_logical_monitor_has_neighbor (MetaLogicalMonitor *logical_monitor,

View File

@ -77,90 +77,122 @@ struct _MetaMonitorsConfig
G_DECLARE_FINAL_TYPE (MetaMonitorsConfig, meta_monitors_config, G_DECLARE_FINAL_TYPE (MetaMonitorsConfig, meta_monitors_config,
META, MONITORS_CONFIG, GObject) META, MONITORS_CONFIG, GObject)
META_EXPORT_TEST
MetaMonitorConfigManager * meta_monitor_config_manager_new (MetaMonitorManager *monitor_manager); MetaMonitorConfigManager * meta_monitor_config_manager_new (MetaMonitorManager *monitor_manager);
META_EXPORT_TEST
MetaMonitorConfigStore * meta_monitor_config_manager_get_store (MetaMonitorConfigManager *config_manager); MetaMonitorConfigStore * meta_monitor_config_manager_get_store (MetaMonitorConfigManager *config_manager);
META_EXPORT_TEST
gboolean meta_monitor_config_manager_assign (MetaMonitorManager *manager, gboolean meta_monitor_config_manager_assign (MetaMonitorManager *manager,
MetaMonitorsConfig *config, MetaMonitorsConfig *config,
GPtrArray **crtc_infos, GPtrArray **crtc_infos,
GPtrArray **output_infos, GPtrArray **output_infos,
GError **error); GError **error);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_get_stored (MetaMonitorConfigManager *config_manager); MetaMonitorsConfig * meta_monitor_config_manager_get_stored (MetaMonitorConfigManager *config_manager);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_create_linear (MetaMonitorConfigManager *config_manager); MetaMonitorsConfig * meta_monitor_config_manager_create_linear (MetaMonitorConfigManager *config_manager);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_create_fallback (MetaMonitorConfigManager *config_manager); MetaMonitorsConfig * meta_monitor_config_manager_create_fallback (MetaMonitorConfigManager *config_manager);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_create_suggested (MetaMonitorConfigManager *config_manager); MetaMonitorsConfig * meta_monitor_config_manager_create_suggested (MetaMonitorConfigManager *config_manager);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_create_for_orientation (MetaMonitorConfigManager *config_manager, MetaMonitorsConfig * meta_monitor_config_manager_create_for_orientation (MetaMonitorConfigManager *config_manager,
MetaMonitorTransform transform); MetaMonitorTransform transform);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_create_for_rotate_monitor (MetaMonitorConfigManager *config_manager); MetaMonitorsConfig * meta_monitor_config_manager_create_for_rotate_monitor (MetaMonitorConfigManager *config_manager);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_create_for_switch_config (MetaMonitorConfigManager *config_manager, MetaMonitorsConfig * meta_monitor_config_manager_create_for_switch_config (MetaMonitorConfigManager *config_manager,
MetaMonitorSwitchConfigType config_type); MetaMonitorSwitchConfigType config_type);
META_EXPORT_TEST
void meta_monitor_config_manager_set_current (MetaMonitorConfigManager *config_manager, void meta_monitor_config_manager_set_current (MetaMonitorConfigManager *config_manager,
MetaMonitorsConfig *config); MetaMonitorsConfig *config);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_get_current (MetaMonitorConfigManager *config_manager); MetaMonitorsConfig * meta_monitor_config_manager_get_current (MetaMonitorConfigManager *config_manager);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_pop_previous (MetaMonitorConfigManager *config_manager); MetaMonitorsConfig * meta_monitor_config_manager_pop_previous (MetaMonitorConfigManager *config_manager);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_get_previous (MetaMonitorConfigManager *config_manager); MetaMonitorsConfig * meta_monitor_config_manager_get_previous (MetaMonitorConfigManager *config_manager);
META_EXPORT_TEST
void meta_monitor_config_manager_clear_history (MetaMonitorConfigManager *config_manager); void meta_monitor_config_manager_clear_history (MetaMonitorConfigManager *config_manager);
META_EXPORT_TEST
void meta_monitor_config_manager_save_current (MetaMonitorConfigManager *config_manager); void meta_monitor_config_manager_save_current (MetaMonitorConfigManager *config_manager);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitors_config_new_full (GList *logical_monitor_configs, MetaMonitorsConfig * meta_monitors_config_new_full (GList *logical_monitor_configs,
GList *disabled_monitors, GList *disabled_monitors,
MetaLogicalMonitorLayoutMode layout_mode, MetaLogicalMonitorLayoutMode layout_mode,
MetaMonitorsConfigFlag flags); MetaMonitorsConfigFlag flags);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitors_config_new (MetaMonitorManager *monitor_manager, MetaMonitorsConfig * meta_monitors_config_new (MetaMonitorManager *monitor_manager,
GList *logical_monitor_configs, GList *logical_monitor_configs,
MetaLogicalMonitorLayoutMode layout_mode, MetaLogicalMonitorLayoutMode layout_mode,
MetaMonitorsConfigFlag flags); MetaMonitorsConfigFlag flags);
META_EXPORT_TEST
MetaMonitorSwitchConfigType meta_monitors_config_get_switch_config (MetaMonitorsConfig *config); MetaMonitorSwitchConfigType meta_monitors_config_get_switch_config (MetaMonitorsConfig *config);
META_EXPORT_TEST
void meta_monitors_config_set_switch_config (MetaMonitorsConfig *config, void meta_monitors_config_set_switch_config (MetaMonitorsConfig *config,
MetaMonitorSwitchConfigType switch_config); MetaMonitorSwitchConfigType switch_config);
META_EXPORT_TEST
unsigned int meta_monitors_config_key_hash (gconstpointer config_key); unsigned int meta_monitors_config_key_hash (gconstpointer config_key);
META_EXPORT_TEST
gboolean meta_monitors_config_key_equal (gconstpointer config_key_a, gboolean meta_monitors_config_key_equal (gconstpointer config_key_a,
gconstpointer config_key_b); gconstpointer config_key_b);
META_EXPORT_TEST
void meta_monitors_config_key_free (MetaMonitorsConfigKey *config_key); void meta_monitors_config_key_free (MetaMonitorsConfigKey *config_key);
META_EXPORT_TEST
void meta_logical_monitor_config_free (MetaLogicalMonitorConfig *logical_monitor_config); void meta_logical_monitor_config_free (MetaLogicalMonitorConfig *logical_monitor_config);
META_EXPORT_TEST
void meta_monitor_config_free (MetaMonitorConfig *monitor_config); void meta_monitor_config_free (MetaMonitorConfig *monitor_config);
META_EXPORT_TEST
MetaMonitorsConfigKey * meta_create_monitors_config_key_for_current_state (MetaMonitorManager *monitor_manager); MetaMonitorsConfigKey * meta_create_monitors_config_key_for_current_state (MetaMonitorManager *monitor_manager);
META_EXPORT_TEST
gboolean meta_logical_monitor_configs_have_monitor (GList *logical_monitor_configs, gboolean meta_logical_monitor_configs_have_monitor (GList *logical_monitor_configs,
MetaMonitorSpec *monitor_spec); MetaMonitorSpec *monitor_spec);
META_EXPORT_TEST
gboolean meta_verify_monitor_mode_spec (MetaMonitorModeSpec *monitor_mode_spec, gboolean meta_verify_monitor_mode_spec (MetaMonitorModeSpec *monitor_mode_spec,
GError **error); GError **error);
META_EXPORT_TEST
gboolean meta_verify_monitor_spec (MetaMonitorSpec *monitor_spec, gboolean meta_verify_monitor_spec (MetaMonitorSpec *monitor_spec,
GError **error); GError **error);
META_EXPORT_TEST
gboolean meta_verify_monitor_config (MetaMonitorConfig *monitor_config, gboolean meta_verify_monitor_config (MetaMonitorConfig *monitor_config,
GError **error); GError **error);
META_EXPORT_TEST
gboolean meta_verify_logical_monitor_config (MetaLogicalMonitorConfig *logical_monitor_config, gboolean meta_verify_logical_monitor_config (MetaLogicalMonitorConfig *logical_monitor_config,
MetaLogicalMonitorLayoutMode layout_mode, MetaLogicalMonitorLayoutMode layout_mode,
MetaMonitorManager *monitor_manager, MetaMonitorManager *monitor_manager,
GError **error); GError **error);
META_EXPORT_TEST
gboolean meta_verify_monitors_config (MetaMonitorsConfig *config, gboolean meta_verify_monitors_config (MetaMonitorsConfig *config,
MetaMonitorManager *monitor_manager, MetaMonitorManager *monitor_manager,
GError **error); GError **error);

View File

@ -24,13 +24,16 @@
#include "backends/meta-monitor-manager-private.h" #include "backends/meta-monitor-manager-private.h"
META_EXPORT_TEST
gboolean meta_migrate_old_monitors_config (MetaMonitorConfigStore *config_store, gboolean meta_migrate_old_monitors_config (MetaMonitorConfigStore *config_store,
GFile *in_file, GFile *in_file,
GError **error); GError **error);
META_EXPORT_TEST
gboolean meta_migrate_old_user_monitors_config (MetaMonitorConfigStore *config_store, gboolean meta_migrate_old_user_monitors_config (MetaMonitorConfigStore *config_store,
GError **error); GError **error);
META_EXPORT_TEST
gboolean meta_finish_monitors_config_migration (MetaMonitorManager *monitor_manager, gboolean meta_finish_monitors_config_migration (MetaMonitorManager *monitor_manager,
MetaMonitorsConfig *config, MetaMonitorsConfig *config,
GError **error); GError **error);

View File

@ -30,24 +30,31 @@
G_DECLARE_FINAL_TYPE (MetaMonitorConfigStore, meta_monitor_config_store, G_DECLARE_FINAL_TYPE (MetaMonitorConfigStore, meta_monitor_config_store,
META, MONITOR_CONFIG_STORE, GObject) META, MONITOR_CONFIG_STORE, GObject)
META_EXPORT_TEST
MetaMonitorConfigStore * meta_monitor_config_store_new (MetaMonitorManager *monitor_manager); MetaMonitorConfigStore * meta_monitor_config_store_new (MetaMonitorManager *monitor_manager);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_store_lookup (MetaMonitorConfigStore *config_store, MetaMonitorsConfig * meta_monitor_config_store_lookup (MetaMonitorConfigStore *config_store,
MetaMonitorsConfigKey *key); MetaMonitorsConfigKey *key);
META_EXPORT_TEST
void meta_monitor_config_store_add (MetaMonitorConfigStore *config_store, void meta_monitor_config_store_add (MetaMonitorConfigStore *config_store,
MetaMonitorsConfig *config); MetaMonitorsConfig *config);
META_EXPORT_TEST
void meta_monitor_config_store_remove (MetaMonitorConfigStore *config_store, void meta_monitor_config_store_remove (MetaMonitorConfigStore *config_store,
MetaMonitorsConfig *config); MetaMonitorsConfig *config);
META_EXPORT_TEST
gboolean meta_monitor_config_store_set_custom (MetaMonitorConfigStore *config_store, gboolean meta_monitor_config_store_set_custom (MetaMonitorConfigStore *config_store,
const char *read_path, const char *read_path,
const char *write_path, const char *write_path,
GError **error); GError **error);
META_EXPORT_TEST
int meta_monitor_config_store_get_config_count (MetaMonitorConfigStore *config_store); int meta_monitor_config_store_get_config_count (MetaMonitorConfigStore *config_store);
META_EXPORT_TEST
MetaMonitorManager * meta_monitor_config_store_get_monitor_manager (MetaMonitorConfigStore *config_store); MetaMonitorManager * meta_monitor_config_store_get_monitor_manager (MetaMonitorConfigStore *config_store);
#endif /* META_MONITOR_CONFIG_STORE_H */ #endif /* META_MONITOR_CONFIG_STORE_H */

View File

@ -30,6 +30,7 @@
#include "backends/meta-cursor.h" #include "backends/meta-cursor.h"
#include "backends/meta-display-config-shared.h" #include "backends/meta-display-config-shared.h"
#include "backends/meta-monitor-transform.h" #include "backends/meta-monitor-transform.h"
#include "core/util-private.h"
#include "meta/display.h" #include "meta/display.h"
#include "meta/meta-monitor-manager.h" #include "meta/meta-monitor-manager.h"
@ -251,13 +252,18 @@ MetaBackend * meta_monitor_manager_get_backend (MetaMonitorManager *manage
void meta_monitor_manager_setup (MetaMonitorManager *manager); void meta_monitor_manager_setup (MetaMonitorManager *manager);
META_EXPORT_TEST
void meta_monitor_manager_rebuild (MetaMonitorManager *manager, void meta_monitor_manager_rebuild (MetaMonitorManager *manager,
MetaMonitorsConfig *config); MetaMonitorsConfig *config);
META_EXPORT_TEST
void meta_monitor_manager_rebuild_derived (MetaMonitorManager *manager, void meta_monitor_manager_rebuild_derived (MetaMonitorManager *manager,
MetaMonitorsConfig *config); MetaMonitorsConfig *config);
META_EXPORT_TEST
int meta_monitor_manager_get_num_logical_monitors (MetaMonitorManager *manager); int meta_monitor_manager_get_num_logical_monitors (MetaMonitorManager *manager);
META_EXPORT_TEST
GList * meta_monitor_manager_get_logical_monitors (MetaMonitorManager *manager); GList * meta_monitor_manager_get_logical_monitors (MetaMonitorManager *manager);
MetaLogicalMonitor *meta_monitor_manager_get_logical_monitor_from_number (MetaMonitorManager *manager, MetaLogicalMonitor *meta_monitor_manager_get_logical_monitor_from_number (MetaMonitorManager *manager,
@ -286,11 +292,13 @@ MetaMonitor * meta_monitor_manager_get_monitor_from_spec (MetaMonitorManag
MetaMonitor * meta_monitor_manager_get_monitor_from_connector (MetaMonitorManager *manager, MetaMonitor * meta_monitor_manager_get_monitor_from_connector (MetaMonitorManager *manager,
const char *connector); const char *connector);
META_EXPORT_TEST
GList * meta_monitor_manager_get_monitors (MetaMonitorManager *manager); GList * meta_monitor_manager_get_monitors (MetaMonitorManager *manager);
META_EXPORT_TEST
void meta_monitor_manager_add_gpu (MetaMonitorManager *manager, void meta_monitor_manager_add_gpu (MetaMonitorManager *manager,
MetaGpu *gpu); MetaGpu *gpu);
META_EXPORT_TEST
GList * meta_monitor_manager_get_gpus (MetaMonitorManager *manager); GList * meta_monitor_manager_get_gpus (MetaMonitorManager *manager);
void meta_monitor_manager_get_screen_size (MetaMonitorManager *manager, void meta_monitor_manager_get_screen_size (MetaMonitorManager *manager,
@ -305,7 +313,11 @@ void meta_output_parse_edid (MetaOutput *output,
gboolean meta_output_is_laptop (MetaOutput *output); gboolean meta_output_is_laptop (MetaOutput *output);
gboolean meta_monitor_manager_has_hotplug_mode_update (MetaMonitorManager *manager); gboolean meta_monitor_manager_has_hotplug_mode_update (MetaMonitorManager *manager);
META_EXPORT_TEST
void meta_monitor_manager_read_current_state (MetaMonitorManager *manager); void meta_monitor_manager_read_current_state (MetaMonitorManager *manager);
META_EXPORT_TEST
void meta_monitor_manager_on_hotplug (MetaMonitorManager *manager); void meta_monitor_manager_on_hotplug (MetaMonitorManager *manager);
gboolean meta_monitor_manager_get_monitor_matrix (MetaMonitorManager *manager, gboolean meta_monitor_manager_get_monitor_matrix (MetaMonitorManager *manager,
@ -322,13 +334,18 @@ gboolean meta_monitor_manager_is_transform_handled (MetaMonitorManager
MetaCrtc *crtc, MetaCrtc *crtc,
MetaMonitorTransform transform); MetaMonitorTransform transform);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_manager_ensure_configured (MetaMonitorManager *manager); MetaMonitorsConfig * meta_monitor_manager_ensure_configured (MetaMonitorManager *manager);
META_EXPORT_TEST
void meta_monitor_manager_update_logical_state (MetaMonitorManager *manager, void meta_monitor_manager_update_logical_state (MetaMonitorManager *manager,
MetaMonitorsConfig *config); MetaMonitorsConfig *config);
META_EXPORT_TEST
void meta_monitor_manager_update_logical_state_derived (MetaMonitorManager *manager, void meta_monitor_manager_update_logical_state_derived (MetaMonitorManager *manager,
MetaMonitorsConfig *config); MetaMonitorsConfig *config);
META_EXPORT_TEST
void meta_monitor_manager_lid_is_closed_changed (MetaMonitorManager *manager); void meta_monitor_manager_lid_is_closed_changed (MetaMonitorManager *manager);
gboolean meta_monitor_manager_is_headless (MetaMonitorManager *manager); gboolean meta_monitor_manager_is_headless (MetaMonitorManager *manager);

View File

@ -95,91 +95,125 @@ G_DECLARE_FINAL_TYPE (MetaMonitorTiled, meta_monitor_tiled,
META, MONITOR_TILED, META, MONITOR_TILED,
MetaMonitor) MetaMonitor)
META_EXPORT_TEST
MetaMonitorTiled * meta_monitor_tiled_new (MetaGpu *gpu, MetaMonitorTiled * meta_monitor_tiled_new (MetaGpu *gpu,
MetaOutput *output); MetaOutput *output);
META_EXPORT_TEST
MetaMonitorNormal * meta_monitor_normal_new (MetaGpu *gpu, MetaMonitorNormal * meta_monitor_normal_new (MetaGpu *gpu,
MetaOutput *output); MetaOutput *output);
META_EXPORT_TEST
MetaMonitorSpec * meta_monitor_get_spec (MetaMonitor *monitor); MetaMonitorSpec * meta_monitor_get_spec (MetaMonitor *monitor);
META_EXPORT_TEST
MetaGpu * meta_monitor_get_gpu (MetaMonitor *monitor); MetaGpu * meta_monitor_get_gpu (MetaMonitor *monitor);
META_EXPORT_TEST
gboolean meta_monitor_is_active (MetaMonitor *monitor); gboolean meta_monitor_is_active (MetaMonitor *monitor);
META_EXPORT_TEST
MetaOutput * meta_monitor_get_main_output (MetaMonitor *monitor); MetaOutput * meta_monitor_get_main_output (MetaMonitor *monitor);
META_EXPORT_TEST
gboolean meta_monitor_is_primary (MetaMonitor *monitor); gboolean meta_monitor_is_primary (MetaMonitor *monitor);
META_EXPORT_TEST
gboolean meta_monitor_supports_underscanning (MetaMonitor *monitor); gboolean meta_monitor_supports_underscanning (MetaMonitor *monitor);
META_EXPORT_TEST
gboolean meta_monitor_is_underscanning (MetaMonitor *monitor); gboolean meta_monitor_is_underscanning (MetaMonitor *monitor);
META_EXPORT_TEST
gboolean meta_monitor_is_laptop_panel (MetaMonitor *monitor); gboolean meta_monitor_is_laptop_panel (MetaMonitor *monitor);
META_EXPORT_TEST
gboolean meta_monitor_is_same_as (MetaMonitor *monitor, gboolean meta_monitor_is_same_as (MetaMonitor *monitor,
MetaMonitor *other_monitor); MetaMonitor *other_monitor);
META_EXPORT_TEST
GList * meta_monitor_get_outputs (MetaMonitor *monitor); GList * meta_monitor_get_outputs (MetaMonitor *monitor);
META_EXPORT_TEST
void meta_monitor_get_current_resolution (MetaMonitor *monitor, void meta_monitor_get_current_resolution (MetaMonitor *monitor,
int *width, int *width,
int *height); int *height);
META_EXPORT_TEST
void meta_monitor_derive_layout (MetaMonitor *monitor, void meta_monitor_derive_layout (MetaMonitor *monitor,
MetaRectangle *layout); MetaRectangle *layout);
META_EXPORT_TEST
void meta_monitor_get_physical_dimensions (MetaMonitor *monitor, void meta_monitor_get_physical_dimensions (MetaMonitor *monitor,
int *width_mm, int *width_mm,
int *height_mm); int *height_mm);
META_EXPORT_TEST
CoglSubpixelOrder meta_monitor_get_subpixel_order (MetaMonitor *monitor); CoglSubpixelOrder meta_monitor_get_subpixel_order (MetaMonitor *monitor);
META_EXPORT_TEST
const char * meta_monitor_get_connector (MetaMonitor *monitor); const char * meta_monitor_get_connector (MetaMonitor *monitor);
META_EXPORT_TEST
const char * meta_monitor_get_vendor (MetaMonitor *monitor); const char * meta_monitor_get_vendor (MetaMonitor *monitor);
META_EXPORT_TEST
const char * meta_monitor_get_product (MetaMonitor *monitor); const char * meta_monitor_get_product (MetaMonitor *monitor);
META_EXPORT_TEST
const char * meta_monitor_get_serial (MetaMonitor *monitor); const char * meta_monitor_get_serial (MetaMonitor *monitor);
META_EXPORT_TEST
MetaConnectorType meta_monitor_get_connector_type (MetaMonitor *monitor); MetaConnectorType meta_monitor_get_connector_type (MetaMonitor *monitor);
/* This function returns the transform corrected for the panel orientation */ /* This function returns the transform corrected for the panel orientation */
META_EXPORT_TEST
MetaMonitorTransform meta_monitor_logical_to_crtc_transform (MetaMonitor *monitor, MetaMonitorTransform meta_monitor_logical_to_crtc_transform (MetaMonitor *monitor,
MetaMonitorTransform transform); MetaMonitorTransform transform);
/* /*
* This function converts a transform corrected for the panel orientation * This function converts a transform corrected for the panel orientation
* to its logical (user-visible) transform. * to its logical (user-visible) transform.
*/ */
META_EXPORT_TEST
MetaMonitorTransform meta_monitor_crtc_to_logical_transform (MetaMonitor *monitor, MetaMonitorTransform meta_monitor_crtc_to_logical_transform (MetaMonitor *monitor,
MetaMonitorTransform transform); MetaMonitorTransform transform);
META_EXPORT_TEST
uint32_t meta_monitor_tiled_get_tile_group_id (MetaMonitorTiled *monitor_tiled); uint32_t meta_monitor_tiled_get_tile_group_id (MetaMonitorTiled *monitor_tiled);
META_EXPORT_TEST
gboolean meta_monitor_get_suggested_position (MetaMonitor *monitor, gboolean meta_monitor_get_suggested_position (MetaMonitor *monitor,
int *x, int *x,
int *y); int *y);
META_EXPORT_TEST
MetaLogicalMonitor * meta_monitor_get_logical_monitor (MetaMonitor *monitor); MetaLogicalMonitor * meta_monitor_get_logical_monitor (MetaMonitor *monitor);
META_EXPORT_TEST
MetaMonitorMode * meta_monitor_get_mode_from_id (MetaMonitor *monitor, MetaMonitorMode * meta_monitor_get_mode_from_id (MetaMonitor *monitor,
const char *monitor_mode_id); const char *monitor_mode_id);
META_EXPORT_TEST
MetaMonitorMode * meta_monitor_get_mode_from_spec (MetaMonitor *monitor, MetaMonitorMode * meta_monitor_get_mode_from_spec (MetaMonitor *monitor,
MetaMonitorModeSpec *monitor_mode_spec); MetaMonitorModeSpec *monitor_mode_spec);
META_EXPORT_TEST
MetaMonitorMode * meta_monitor_get_preferred_mode (MetaMonitor *monitor); MetaMonitorMode * meta_monitor_get_preferred_mode (MetaMonitor *monitor);
META_EXPORT_TEST
MetaMonitorMode * meta_monitor_get_current_mode (MetaMonitor *monitor); MetaMonitorMode * meta_monitor_get_current_mode (MetaMonitor *monitor);
META_EXPORT_TEST
void meta_monitor_derive_current_mode (MetaMonitor *monitor); void meta_monitor_derive_current_mode (MetaMonitor *monitor);
META_EXPORT_TEST
void meta_monitor_set_current_mode (MetaMonitor *monitor, void meta_monitor_set_current_mode (MetaMonitor *monitor,
MetaMonitorMode *mode); MetaMonitorMode *mode);
META_EXPORT_TEST
GList * meta_monitor_get_modes (MetaMonitor *monitor); GList * meta_monitor_get_modes (MetaMonitor *monitor);
META_EXPORT_TEST
void meta_monitor_calculate_crtc_pos (MetaMonitor *monitor, void meta_monitor_calculate_crtc_pos (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode, MetaMonitorMode *monitor_mode,
MetaOutput *output, MetaOutput *output,
@ -187,48 +221,62 @@ void meta_monitor_calculate_crtc_pos (MetaMonitor *monitor,
int *out_x, int *out_x,
int *out_y); int *out_y);
META_EXPORT_TEST
float meta_monitor_calculate_mode_scale (MetaMonitor *monitor, float meta_monitor_calculate_mode_scale (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode); MetaMonitorMode *monitor_mode);
META_EXPORT_TEST
float * meta_monitor_calculate_supported_scales (MetaMonitor *monitor, float * meta_monitor_calculate_supported_scales (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode, MetaMonitorMode *monitor_mode,
MetaMonitorScalesConstraint constraints, MetaMonitorScalesConstraint constraints,
int *n_supported_scales); int *n_supported_scales);
META_EXPORT_TEST
const char * meta_monitor_mode_get_id (MetaMonitorMode *monitor_mode); const char * meta_monitor_mode_get_id (MetaMonitorMode *monitor_mode);
META_EXPORT_TEST
MetaMonitorModeSpec * meta_monitor_mode_get_spec (MetaMonitorMode *monitor_mode); MetaMonitorModeSpec * meta_monitor_mode_get_spec (MetaMonitorMode *monitor_mode);
META_EXPORT_TEST
void meta_monitor_mode_get_resolution (MetaMonitorMode *monitor_mode, void meta_monitor_mode_get_resolution (MetaMonitorMode *monitor_mode,
int *width, int *width,
int *height); int *height);
META_EXPORT_TEST
float meta_monitor_mode_get_refresh_rate (MetaMonitorMode *monitor_mode); float meta_monitor_mode_get_refresh_rate (MetaMonitorMode *monitor_mode);
META_EXPORT_TEST
MetaCrtcModeFlag meta_monitor_mode_get_flags (MetaMonitorMode *monitor_mode); MetaCrtcModeFlag meta_monitor_mode_get_flags (MetaMonitorMode *monitor_mode);
META_EXPORT_TEST
gboolean meta_monitor_mode_foreach_crtc (MetaMonitor *monitor, gboolean meta_monitor_mode_foreach_crtc (MetaMonitor *monitor,
MetaMonitorMode *mode, MetaMonitorMode *mode,
MetaMonitorModeFunc func, MetaMonitorModeFunc func,
gpointer user_data, gpointer user_data,
GError **error); GError **error);
META_EXPORT_TEST
gboolean meta_monitor_mode_foreach_output (MetaMonitor *monitor, gboolean meta_monitor_mode_foreach_output (MetaMonitor *monitor,
MetaMonitorMode *mode, MetaMonitorMode *mode,
MetaMonitorModeFunc func, MetaMonitorModeFunc func,
gpointer user_data, gpointer user_data,
GError **error); GError **error);
META_EXPORT_TEST
gboolean meta_monitor_mode_should_be_advertised (MetaMonitorMode *monitor_mode); gboolean meta_monitor_mode_should_be_advertised (MetaMonitorMode *monitor_mode);
META_EXPORT_TEST
MetaMonitorSpec * meta_monitor_spec_clone (MetaMonitorSpec *monitor_id); MetaMonitorSpec * meta_monitor_spec_clone (MetaMonitorSpec *monitor_id);
META_EXPORT_TEST
gboolean meta_monitor_spec_equals (MetaMonitorSpec *monitor_id, gboolean meta_monitor_spec_equals (MetaMonitorSpec *monitor_id,
MetaMonitorSpec *other_monitor_id); MetaMonitorSpec *other_monitor_id);
META_EXPORT_TEST
int meta_monitor_spec_compare (MetaMonitorSpec *monitor_spec_a, int meta_monitor_spec_compare (MetaMonitorSpec *monitor_spec_a,
MetaMonitorSpec *monitor_spec_b); MetaMonitorSpec *monitor_spec_b);
META_EXPORT_TEST
void meta_monitor_spec_free (MetaMonitorSpec *monitor_id); void meta_monitor_spec_free (MetaMonitorSpec *monitor_id);
#endif /* META_MONITOR_H */ #endif /* META_MONITOR_H */

View File

@ -24,6 +24,7 @@
#include "backends/meta-backend-types.h" #include "backends/meta-backend-types.h"
#include "backends/meta-gpu.h" #include "backends/meta-gpu.h"
#include "core/util-private.h"
struct _MetaTileInfo struct _MetaTileInfo
{ {
@ -116,15 +117,19 @@ struct _MetaOutput
}; };
#define META_TYPE_OUTPUT (meta_output_get_type ()) #define META_TYPE_OUTPUT (meta_output_get_type ())
G_DECLARE_FINAL_TYPE (MetaOutput, meta_output, META, OUTPUT, GObject) META_EXPORT_TEST G_DECLARE_FINAL_TYPE (MetaOutput, meta_output, META, OUTPUT, GObject)
META_EXPORT_TEST
MetaGpu * meta_output_get_gpu (MetaOutput *output); MetaGpu * meta_output_get_gpu (MetaOutput *output);
META_EXPORT_TEST
void meta_output_assign_crtc (MetaOutput *output, void meta_output_assign_crtc (MetaOutput *output,
MetaCrtc *crtc); MetaCrtc *crtc);
META_EXPORT_TEST
void meta_output_unassign_crtc (MetaOutput *output); void meta_output_unassign_crtc (MetaOutput *output);
META_EXPORT_TEST
MetaCrtc * meta_output_get_assigned_crtc (MetaOutput *output); MetaCrtc * meta_output_get_assigned_crtc (MetaOutput *output);
#endif /* META_OUTPUT_H */ #endif /* META_OUTPUT_H */

View File

@ -29,6 +29,7 @@
#include "backends/meta-monitor-manager-private.h" #include "backends/meta-monitor-manager-private.h"
#include "backends/meta-renderer-view.h" #include "backends/meta-renderer-view.h"
#include "core/util-private.h"
#include "clutter/clutter-mutter.h" #include "clutter/clutter-mutter.h"
#include "cogl/cogl.h" #include "cogl/cogl.h"
@ -51,6 +52,7 @@ void meta_renderer_rebuild_views (MetaRenderer *renderer);
void meta_renderer_set_legacy_view (MetaRenderer *renderer, void meta_renderer_set_legacy_view (MetaRenderer *renderer,
MetaRendererView *legacy_view); MetaRendererView *legacy_view);
META_EXPORT_TEST
GList * meta_renderer_get_views (MetaRenderer *renderer); GList * meta_renderer_get_views (MetaRenderer *renderer);
MetaRendererView * meta_renderer_get_view_from_logical_monitor (MetaRenderer *renderer, MetaRendererView * meta_renderer_get_view_from_logical_monitor (MetaRenderer *renderer,

View File

@ -26,6 +26,7 @@
#include "meta/meta-settings.h" #include "meta/meta-settings.h"
#include "meta/types.h" #include "meta/types.h"
#include "core/util-private.h"
typedef enum _MetaExperimentalFeature typedef enum _MetaExperimentalFeature
{ {
@ -47,13 +48,16 @@ void meta_settings_update_ui_scaling_factor (MetaSettings *settings);
gboolean meta_settings_get_global_scaling_factor (MetaSettings *settings, gboolean meta_settings_get_global_scaling_factor (MetaSettings *settings,
int *scaing_factor); int *scaing_factor);
META_EXPORT_TEST
gboolean meta_settings_is_experimental_feature_enabled (MetaSettings *settings, gboolean meta_settings_is_experimental_feature_enabled (MetaSettings *settings,
MetaExperimentalFeature feature); MetaExperimentalFeature feature);
MetaExperimentalFeature meta_settings_get_experimental_features (MetaSettings *settings); MetaExperimentalFeature meta_settings_get_experimental_features (MetaSettings *settings);
META_EXPORT_TEST
void meta_settings_override_experimental_features (MetaSettings *settings); void meta_settings_override_experimental_features (MetaSettings *settings);
META_EXPORT_TEST
void meta_settings_enable_experimental_feature (MetaSettings *settings, void meta_settings_enable_experimental_feature (MetaSettings *settings,
MetaExperimentalFeature feature); MetaExperimentalFeature feature);

View File

@ -23,8 +23,10 @@
#include <glib-object.h> #include <glib-object.h>
#include "backends/x11/meta-backend-x11.h" #include "backends/x11/meta-backend-x11.h"
#include "core/util-private.h"
#define META_TYPE_BACKEND_X11_NESTED (meta_backend_x11_nested_get_type ()) #define META_TYPE_BACKEND_X11_NESTED (meta_backend_x11_nested_get_type ())
META_EXPORT_TEST
G_DECLARE_DERIVABLE_TYPE (MetaBackendX11Nested, meta_backend_x11_nested, G_DECLARE_DERIVABLE_TYPE (MetaBackendX11Nested, meta_backend_x11_nested,
META, BACKEND_X11_NESTED, MetaBackendX11) META, BACKEND_X11_NESTED, MetaBackendX11)

View File

@ -22,6 +22,7 @@
#ifndef META_PLUGIN_MANAGER_H_ #ifndef META_PLUGIN_MANAGER_H_
#define META_PLUGIN_MANAGER_H_ #define META_PLUGIN_MANAGER_H_
#include "core/util-private.h"
#include "meta/meta-plugin.h" #include "meta/meta-plugin.h"
#include "meta/types.h" #include "meta/types.h"
@ -43,6 +44,7 @@ typedef struct MetaPluginManager MetaPluginManager;
MetaPluginManager * meta_plugin_manager_new (MetaCompositor *compositor); MetaPluginManager * meta_plugin_manager_new (MetaCompositor *compositor);
META_EXPORT_TEST
void meta_plugin_manager_load (const gchar *plugin_name); void meta_plugin_manager_load (const gchar *plugin_name);
gboolean meta_plugin_manager_event_simple (MetaPluginManager *mgr, gboolean meta_plugin_manager_event_simple (MetaPluginManager *mgr,

View File

@ -25,6 +25,7 @@
#include <glib-object.h> #include <glib-object.h>
#include "backends/meta-backend-types.h" #include "backends/meta-backend-types.h"
#include "core/util-private.h"
#include "meta/boxes.h" #include "meta/boxes.h"
#include "meta/common.h" #include "meta/common.h"
@ -75,6 +76,7 @@ char* meta_rectangle_edge_list_to_string (
* Also, I lied a little bit--technically, you could use it in a MoveResize * Also, I lied a little bit--technically, you could use it in a MoveResize
* operation if you muck with old_rect just right). * operation if you muck with old_rect just right).
*/ */
META_EXPORT_TEST
void meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect, void meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect,
MetaRectangle *rect, MetaRectangle *rect,
int gravity, int gravity,
@ -92,6 +94,7 @@ void meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect,
* *
* See boxes.c for more details. * See boxes.c for more details.
*/ */
META_EXPORT_TEST
GList* meta_rectangle_get_minimal_spanning_set_for_region ( GList* meta_rectangle_get_minimal_spanning_set_for_region (
const MetaRectangle *basic_rect, const MetaRectangle *basic_rect,
const GSList *all_struts); const GSList *all_struts);
@ -118,6 +121,7 @@ GList* meta_rectangle_expand_region_conditionally (
* overlapping struts oriented orthognal to the expansion direction. (Think * overlapping struts oriented orthognal to the expansion direction. (Think
* horizontal or vertical maximization) * horizontal or vertical maximization)
*/ */
META_EXPORT_TEST
void meta_rectangle_expand_to_avoiding_struts ( void meta_rectangle_expand_to_avoiding_struts (
MetaRectangle *rect, MetaRectangle *rect,
const MetaRectangle *expand_to, const MetaRectangle *expand_to,
@ -131,18 +135,24 @@ void meta_rectangle_expand_to_avoiding_struts (
* or * or
* meta_rectangle_find_nonintersected_monitor_edges() * meta_rectangle_find_nonintersected_monitor_edges()
*/ */
META_EXPORT_TEST
void meta_rectangle_free_list_and_elements (GList *filled_list); void meta_rectangle_free_list_and_elements (GList *filled_list);
/* could_fit_in_region determines whether one of the spanning_rects is /* could_fit_in_region determines whether one of the spanning_rects is
* big enough to contain rect. contained_in_region checks whether one * big enough to contain rect. contained_in_region checks whether one
* actually contains it. * actually contains it.
*/ */
META_EXPORT_TEST
gboolean meta_rectangle_could_fit_in_region ( gboolean meta_rectangle_could_fit_in_region (
const GList *spanning_rects, const GList *spanning_rects,
const MetaRectangle *rect); const MetaRectangle *rect);
META_EXPORT_TEST
gboolean meta_rectangle_contained_in_region ( gboolean meta_rectangle_contained_in_region (
const GList *spanning_rects, const GList *spanning_rects,
const MetaRectangle *rect); const MetaRectangle *rect);
META_EXPORT_TEST
gboolean meta_rectangle_overlaps_with_region ( gboolean meta_rectangle_overlaps_with_region (
const GList *spanning_rects, const GList *spanning_rects,
const MetaRectangle *rect); const MetaRectangle *rect);
@ -150,6 +160,7 @@ gboolean meta_rectangle_overlaps_with_region (
/* Make the rectangle small enough to fit into one of the spanning_rects, /* Make the rectangle small enough to fit into one of the spanning_rects,
* but make it no smaller than min_size. * but make it no smaller than min_size.
*/ */
META_EXPORT_TEST
void meta_rectangle_clamp_to_fit_into_region ( void meta_rectangle_clamp_to_fit_into_region (
const GList *spanning_rects, const GList *spanning_rects,
FixedDirections fixed_directions, FixedDirections fixed_directions,
@ -159,6 +170,7 @@ void meta_rectangle_clamp_to_fit_into_region (
/* Clip the rectangle so that it fits into one of the spanning_rects, assuming /* Clip the rectangle so that it fits into one of the spanning_rects, assuming
* it overlaps with at least one of them * it overlaps with at least one of them
*/ */
META_EXPORT_TEST
void meta_rectangle_clip_to_region (const GList *spanning_rects, void meta_rectangle_clip_to_region (const GList *spanning_rects,
FixedDirections fixed_directions, FixedDirections fixed_directions,
MetaRectangle *rect); MetaRectangle *rect);
@ -166,6 +178,7 @@ void meta_rectangle_clip_to_region (const GList *spanning_rects,
/* Shove the rectangle into one of the spanning_rects, assuming it fits in /* Shove the rectangle into one of the spanning_rects, assuming it fits in
* one of them. * one of them.
*/ */
META_EXPORT_TEST
void meta_rectangle_shove_into_region( void meta_rectangle_shove_into_region(
const GList *spanning_rects, const GList *spanning_rects,
FixedDirections fixed_directions, FixedDirections fixed_directions,
@ -175,6 +188,7 @@ void meta_rectangle_shove_into_region(
* to (px, py). Useful for finding an optimal rectangle size when given a * to (px, py). Useful for finding an optimal rectangle size when given a
* range between two sizes that are all candidates. * range between two sizes that are all candidates.
*/ */
META_EXPORT_TEST
void meta_rectangle_find_linepoint_closest_to_point (double x1, double y1, void meta_rectangle_find_linepoint_closest_to_point (double x1, double y1,
double x2, double y2, double x2, double y2,
double px, double py, double px, double py,
@ -189,18 +203,21 @@ void meta_rectangle_find_linepoint_closest_to_point (double x1, double y1,
/* Return whether an edge overlaps or is adjacent to the rectangle in the /* Return whether an edge overlaps or is adjacent to the rectangle in the
* nonzero-width dimension of the edge. * nonzero-width dimension of the edge.
*/ */
META_EXPORT_TEST
gboolean meta_rectangle_edge_aligns (const MetaRectangle *rect, gboolean meta_rectangle_edge_aligns (const MetaRectangle *rect,
const MetaEdge *edge); const MetaEdge *edge);
/* Compare two edges, so that sorting functions can put a list of edges in /* Compare two edges, so that sorting functions can put a list of edges in
* canonical order. * canonical order.
*/ */
META_EXPORT_TEST
gint meta_rectangle_edge_cmp (gconstpointer a, gconstpointer b); gint meta_rectangle_edge_cmp (gconstpointer a, gconstpointer b);
/* Compare two edges, so that sorting functions can put a list of edges in /* Compare two edges, so that sorting functions can put a list of edges in
* order. This function doesn't separate left edges first, then right edges, * order. This function doesn't separate left edges first, then right edges,
* etc., but rather compares only upon location. * etc., but rather compares only upon location.
*/ */
META_EXPORT_TEST
gint meta_rectangle_edge_cmp_ignore_type (gconstpointer a, gconstpointer b); gint meta_rectangle_edge_cmp_ignore_type (gconstpointer a, gconstpointer b);
/* Removes an parts of edges in the given list that intersect any box in the /* Removes an parts of edges in the given list that intersect any box in the
@ -213,19 +230,23 @@ GList* meta_rectangle_remove_intersections_with_boxes_from_edges (
/* Finds all the edges of an onscreen region, returning a GList* of /* Finds all the edges of an onscreen region, returning a GList* of
* MetaEdgeRect's. * MetaEdgeRect's.
*/ */
META_EXPORT_TEST
GList* meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect, GList* meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
const GSList *all_struts); const GSList *all_struts);
/* Finds edges between adjacent monitors which are not covered by the given /* Finds edges between adjacent monitors which are not covered by the given
* struts. * struts.
*/ */
META_EXPORT_TEST
GList* meta_rectangle_find_nonintersected_monitor_edges ( GList* meta_rectangle_find_nonintersected_monitor_edges (
const GList *monitor_rects, const GList *monitor_rects,
const GSList *all_struts); const GSList *all_struts);
META_EXPORT_TEST
gboolean meta_rectangle_is_adjecent_to (MetaRectangle *rect, gboolean meta_rectangle_is_adjecent_to (MetaRectangle *rect,
MetaRectangle *other); MetaRectangle *other);
META_EXPORT_TEST
void meta_rectangle_scale_double (const MetaRectangle *rect, void meta_rectangle_scale_double (const MetaRectangle *rect,
double scale, double scale,
MetaRoundingStrategy rounding_strategy, MetaRoundingStrategy rounding_strategy,
@ -246,6 +267,7 @@ meta_rectangle_to_clutter_rect (MetaRectangle *rect)
}; };
} }
META_EXPORT_TEST
void meta_rectangle_transform (const MetaRectangle *rect, void meta_rectangle_transform (const MetaRectangle *rect,
MetaMonitorTransform transform, MetaMonitorTransform transform,
int width, int width,

View File

@ -287,8 +287,9 @@ void meta_display_unregister_stamp (MetaDisplay *display,
guint64 stamp); guint64 stamp);
/* A "stack id" is a XID or a stamp */ /* A "stack id" is a XID or a stamp */
#define META_STACK_ID_IS_X11(id) ((id) < G_GUINT64_CONSTANT(0x100000000)) #define META_STACK_ID_IS_X11(id) ((id) < G_GUINT64_CONSTANT(0x100000000))
META_EXPORT_TEST
MetaWindow* meta_display_lookup_stack_id (MetaDisplay *display, MetaWindow* meta_display_lookup_stack_id (MetaDisplay *display,
guint64 stack_id); guint64 stack_id);
@ -306,10 +307,13 @@ void meta_display_unregister_wayland_window (MetaDisplay *display,
void meta_display_notify_window_created (MetaDisplay *display, void meta_display_notify_window_created (MetaDisplay *display,
MetaWindow *window); MetaWindow *window);
META_EXPORT_TEST
GSList* meta_display_list_windows (MetaDisplay *display, GSList* meta_display_list_windows (MetaDisplay *display,
MetaListWindowsFlags flags); MetaListWindowsFlags flags);
MetaDisplay* meta_display_for_x_display (Display *xdisplay); MetaDisplay* meta_display_for_x_display (Display *xdisplay);
META_EXPORT_TEST
MetaDisplay* meta_get_display (void); MetaDisplay* meta_get_display (void);
void meta_display_reload_cursor (MetaDisplay *display); void meta_display_reload_cursor (MetaDisplay *display);

View File

@ -20,6 +20,8 @@
#ifndef META_MAIN_PRIVATE_H #ifndef META_MAIN_PRIVATE_H
#define META_MAIN_PRIVATE_H #define META_MAIN_PRIVATE_H
#include "core/util-private.h"
typedef enum _MetaCompositorType typedef enum _MetaCompositorType
{ {
#ifdef HAVE_WAYLAND #ifdef HAVE_WAYLAND
@ -28,6 +30,7 @@ typedef enum _MetaCompositorType
META_COMPOSITOR_TYPE_X11, META_COMPOSITOR_TYPE_X11,
} MetaCompositorType; } MetaCompositorType;
META_EXPORT_TEST
void meta_override_compositor_configuration (MetaCompositorType compositor_type, void meta_override_compositor_configuration (MetaCompositorType compositor_type,
GType backend_gtype); GType backend_gtype);

View File

@ -34,6 +34,7 @@
#ifndef META_STACK_TRACKER_H #ifndef META_STACK_TRACKER_H
#define META_STACK_TRACKER_H #define META_STACK_TRACKER_H
#include "core/util-private.h"
#include "meta/display.h" #include "meta/display.h"
#include "meta/window.h" #include "meta/window.h"
@ -75,6 +76,7 @@ void meta_stack_tracker_reparent_event (MetaStackTracker *tracker,
void meta_stack_tracker_configure_event (MetaStackTracker *tracker, void meta_stack_tracker_configure_event (MetaStackTracker *tracker,
XConfigureEvent *event); XConfigureEvent *event);
META_EXPORT_TEST
void meta_stack_tracker_get_stack (MetaStackTracker *tracker, void meta_stack_tracker_get_stack (MetaStackTracker *tracker,
guint64 **windows, guint64 **windows,
int *n_entries); int *n_entries);

View File

@ -37,10 +37,13 @@ struct _MetaStartupSequenceClass
void (* complete) (MetaStartupSequence *sequence); void (* complete) (MetaStartupSequence *sequence);
}; };
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaStartupNotification, G_DECLARE_FINAL_TYPE (MetaStartupNotification,
meta_startup_notification, meta_startup_notification,
META, STARTUP_NOTIFICATION, META, STARTUP_NOTIFICATION,
GObject) GObject)
META_EXPORT
G_DECLARE_DERIVABLE_TYPE (MetaStartupSequence, G_DECLARE_DERIVABLE_TYPE (MetaStartupSequence,
meta_startup_sequence, meta_startup_sequence,
META, STARTUP_SEQUENCE, META, STARTUP_SEQUENCE,

View File

@ -28,6 +28,11 @@
#include <glib/gi18n-lib.h> #include <glib/gi18n-lib.h>
#include "meta/util.h" #include "meta/util.h"
#include "meta/common.h"
/* META_EXPORT_TEST should be used to export symbols that are exported only
* for testability purposes */
#define META_EXPORT_TEST META_EXPORT
void meta_set_verbose (gboolean setting); void meta_set_verbose (gboolean setting);
void meta_set_debugging (gboolean setting); void meta_set_debugging (gboolean setting);

View File

@ -750,6 +750,7 @@ libmutter = shared_library(libmutter_name,
], ],
version: '0.0.0', version: '0.0.0',
soversion: 0, soversion: 0,
gnu_symbol_visibility: 'hidden',
include_directories: mutter_includes, include_directories: mutter_includes,
c_args: mutter_c_args, c_args: mutter_c_args,
dependencies: [ dependencies: [

View File

@ -48,10 +48,16 @@ struct _MetaBarrierClass
GObjectClass parent_class; GObjectClass parent_class;
}; };
META_EXPORT
GType meta_barrier_get_type (void) G_GNUC_CONST; GType meta_barrier_get_type (void) G_GNUC_CONST;
META_EXPORT
gboolean meta_barrier_is_active (MetaBarrier *barrier); gboolean meta_barrier_is_active (MetaBarrier *barrier);
META_EXPORT
void meta_barrier_destroy (MetaBarrier *barrier); void meta_barrier_destroy (MetaBarrier *barrier);
META_EXPORT
void meta_barrier_release (MetaBarrier *barrier, void meta_barrier_release (MetaBarrier *barrier,
MetaBarrierEvent *event); MetaBarrierEvent *event);
@ -108,6 +114,8 @@ struct _MetaBarrierEvent {
}; };
#define META_TYPE_BARRIER_EVENT (meta_barrier_event_get_type ()) #define META_TYPE_BARRIER_EVENT (meta_barrier_event_get_type ())
META_EXPORT
GType meta_barrier_event_get_type (void) G_GNUC_CONST; GType meta_barrier_event_get_type (void) G_GNUC_CONST;
G_END_DECLS G_END_DECLS

View File

@ -93,23 +93,34 @@ struct _MetaEdge
MetaEdgeType edge_type; MetaEdgeType edge_type;
}; };
META_EXPORT
GType meta_rectangle_get_type (void); GType meta_rectangle_get_type (void);
META_EXPORT
MetaRectangle *meta_rectangle_copy (const MetaRectangle *rect); MetaRectangle *meta_rectangle_copy (const MetaRectangle *rect);
META_EXPORT
void meta_rectangle_free (MetaRectangle *rect); void meta_rectangle_free (MetaRectangle *rect);
/* Function to make initializing a rect with a single line of code easy */ /* Function to make initializing a rect with a single line of code easy */
META_EXPORT
MetaRectangle meta_rect (int x, int y, int width, int height); MetaRectangle meta_rect (int x, int y, int width, int height);
/* Basic comparison functions */ /* Basic comparison functions */
META_EXPORT
int meta_rectangle_area (const MetaRectangle *rect); int meta_rectangle_area (const MetaRectangle *rect);
META_EXPORT
gboolean meta_rectangle_intersect (const MetaRectangle *src1, gboolean meta_rectangle_intersect (const MetaRectangle *src1,
const MetaRectangle *src2, const MetaRectangle *src2,
MetaRectangle *dest); MetaRectangle *dest);
META_EXPORT
gboolean meta_rectangle_equal (const MetaRectangle *src1, gboolean meta_rectangle_equal (const MetaRectangle *src1,
const MetaRectangle *src2); const MetaRectangle *src2);
/* Find the bounding box of the union of two rectangles */ /* Find the bounding box of the union of two rectangles */
META_EXPORT
void meta_rectangle_union (const MetaRectangle *rect1, void meta_rectangle_union (const MetaRectangle *rect1,
const MetaRectangle *rect2, const MetaRectangle *rect2,
MetaRectangle *dest); MetaRectangle *dest);
@ -117,6 +128,7 @@ void meta_rectangle_union (const MetaRectangle *rect1,
/* overlap is similar to intersect but doesn't provide location of /* overlap is similar to intersect but doesn't provide location of
* intersection information. * intersection information.
*/ */
META_EXPORT
gboolean meta_rectangle_overlap (const MetaRectangle *rect1, gboolean meta_rectangle_overlap (const MetaRectangle *rect1,
const MetaRectangle *rect2); const MetaRectangle *rect2);
@ -125,16 +137,22 @@ gboolean meta_rectangle_overlap (const MetaRectangle *rect1,
* exist a way to shift either rect horizontally so that the two rects * exist a way to shift either rect horizontally so that the two rects
* overlap?" horiz_overlap is similar. * overlap?" horiz_overlap is similar.
*/ */
META_EXPORT
gboolean meta_rectangle_vert_overlap (const MetaRectangle *rect1, gboolean meta_rectangle_vert_overlap (const MetaRectangle *rect1,
const MetaRectangle *rect2); const MetaRectangle *rect2);
META_EXPORT
gboolean meta_rectangle_horiz_overlap (const MetaRectangle *rect1, gboolean meta_rectangle_horiz_overlap (const MetaRectangle *rect1,
const MetaRectangle *rect2); const MetaRectangle *rect2);
/* could_fit_rect determines whether "outer_rect" is big enough to contain /* could_fit_rect determines whether "outer_rect" is big enough to contain
* inner_rect. contains_rect checks whether it actually contains it. * inner_rect. contains_rect checks whether it actually contains it.
*/ */
META_EXPORT
gboolean meta_rectangle_could_fit_rect (const MetaRectangle *outer_rect, gboolean meta_rectangle_could_fit_rect (const MetaRectangle *outer_rect,
const MetaRectangle *inner_rect); const MetaRectangle *inner_rect);
META_EXPORT
gboolean meta_rectangle_contains_rect (const MetaRectangle *outer_rect, gboolean meta_rectangle_contains_rect (const MetaRectangle *outer_rect,
const MetaRectangle *inner_rect); const MetaRectangle *inner_rect);

View File

@ -46,6 +46,8 @@
/* Replacement for X11 CurrentTime */ /* Replacement for X11 CurrentTime */
#define META_CURRENT_TIME 0L #define META_CURRENT_TIME 0L
#define META_EXPORT __attribute__((visibility("default"))) extern
/** /**
* MetaFrameFlags: * MetaFrameFlags:
* @META_FRAME_ALLOWS_DELETE: frame allows delete * @META_FRAME_ALLOWS_DELETE: frame allows delete
@ -447,6 +449,7 @@ struct _MetaFrameBorders
}; };
/* sets all dimensions to zero */ /* sets all dimensions to zero */
META_EXPORT
void meta_frame_borders_clear (MetaFrameBorders *self); void meta_frame_borders_clear (MetaFrameBorders *self);
/* should investigate changing these to whatever most apps use */ /* should investigate changing these to whatever most apps use */

View File

@ -32,21 +32,42 @@
#include "meta/types.h" #include "meta/types.h"
/* Public compositor API */ /* Public compositor API */
META_EXPORT
ClutterActor *meta_get_stage_for_display (MetaDisplay *display); ClutterActor *meta_get_stage_for_display (MetaDisplay *display);
META_EXPORT
Window meta_get_overlay_window (MetaDisplay *display); Window meta_get_overlay_window (MetaDisplay *display);
META_EXPORT
GList *meta_get_window_actors (MetaDisplay *display); GList *meta_get_window_actors (MetaDisplay *display);
META_EXPORT
ClutterActor *meta_get_window_group_for_display (MetaDisplay *display); ClutterActor *meta_get_window_group_for_display (MetaDisplay *display);
META_EXPORT
ClutterActor *meta_get_top_window_group_for_display (MetaDisplay *display); ClutterActor *meta_get_top_window_group_for_display (MetaDisplay *display);
META_EXPORT
ClutterActor *meta_get_feedback_group_for_display (MetaDisplay *display); ClutterActor *meta_get_feedback_group_for_display (MetaDisplay *display);
META_EXPORT
void meta_disable_unredirect_for_display (MetaDisplay *display); void meta_disable_unredirect_for_display (MetaDisplay *display);
META_EXPORT
void meta_enable_unredirect_for_display (MetaDisplay *display); void meta_enable_unredirect_for_display (MetaDisplay *display);
META_EXPORT
void meta_set_stage_input_region (MetaDisplay *display, void meta_set_stage_input_region (MetaDisplay *display,
XserverRegion region); XserverRegion region);
META_EXPORT
void meta_empty_stage_input_region (MetaDisplay *display); void meta_empty_stage_input_region (MetaDisplay *display);
META_EXPORT
void meta_focus_stage_window (MetaDisplay *display, void meta_focus_stage_window (MetaDisplay *display,
guint32 timestamp); guint32 timestamp);
META_EXPORT
gboolean meta_stage_is_focused (MetaDisplay *display); gboolean meta_stage_is_focused (MetaDisplay *display);
#endif #endif

View File

@ -61,72 +61,109 @@ typedef enum {
META_SIZE_CHANGE_UNFULLSCREEN, META_SIZE_CHANGE_UNFULLSCREEN,
} MetaSizeChange; } MetaSizeChange;
META_EXPORT
MetaCompositor *meta_compositor_new (MetaDisplay *display); MetaCompositor *meta_compositor_new (MetaDisplay *display);
META_EXPORT
void meta_compositor_destroy (MetaCompositor *compositor); void meta_compositor_destroy (MetaCompositor *compositor);
META_EXPORT
void meta_compositor_manage (MetaCompositor *compositor); void meta_compositor_manage (MetaCompositor *compositor);
META_EXPORT
void meta_compositor_unmanage (MetaCompositor *compositor); void meta_compositor_unmanage (MetaCompositor *compositor);
META_EXPORT
void meta_compositor_window_shape_changed (MetaCompositor *compositor, void meta_compositor_window_shape_changed (MetaCompositor *compositor,
MetaWindow *window); MetaWindow *window);
META_EXPORT
void meta_compositor_window_opacity_changed (MetaCompositor *compositor, void meta_compositor_window_opacity_changed (MetaCompositor *compositor,
MetaWindow *window); MetaWindow *window);
META_EXPORT
void meta_compositor_window_surface_changed (MetaCompositor *compositor, void meta_compositor_window_surface_changed (MetaCompositor *compositor,
MetaWindow *window); MetaWindow *window);
META_EXPORT
gboolean meta_compositor_process_event (MetaCompositor *compositor, gboolean meta_compositor_process_event (MetaCompositor *compositor,
XEvent *event, XEvent *event,
MetaWindow *window); MetaWindow *window);
META_EXPORT
gboolean meta_compositor_filter_keybinding (MetaCompositor *compositor, gboolean meta_compositor_filter_keybinding (MetaCompositor *compositor,
MetaKeyBinding *binding); MetaKeyBinding *binding);
META_EXPORT
void meta_compositor_add_window (MetaCompositor *compositor, void meta_compositor_add_window (MetaCompositor *compositor,
MetaWindow *window); MetaWindow *window);
META_EXPORT
void meta_compositor_remove_window (MetaCompositor *compositor, void meta_compositor_remove_window (MetaCompositor *compositor,
MetaWindow *window); MetaWindow *window);
META_EXPORT
void meta_compositor_show_window (MetaCompositor *compositor, void meta_compositor_show_window (MetaCompositor *compositor,
MetaWindow *window, MetaWindow *window,
MetaCompEffect effect); MetaCompEffect effect);
META_EXPORT
void meta_compositor_hide_window (MetaCompositor *compositor, void meta_compositor_hide_window (MetaCompositor *compositor,
MetaWindow *window, MetaWindow *window,
MetaCompEffect effect); MetaCompEffect effect);
META_EXPORT
void meta_compositor_switch_workspace (MetaCompositor *compositor, void meta_compositor_switch_workspace (MetaCompositor *compositor,
MetaWorkspace *from, MetaWorkspace *from,
MetaWorkspace *to, MetaWorkspace *to,
MetaMotionDirection direction); MetaMotionDirection direction);
META_EXPORT
void meta_compositor_size_change_window (MetaCompositor *compositor, void meta_compositor_size_change_window (MetaCompositor *compositor,
MetaWindow *window, MetaWindow *window,
MetaSizeChange which_change, MetaSizeChange which_change,
MetaRectangle *old_frame_rect, MetaRectangle *old_frame_rect,
MetaRectangle *old_buffer_rect); MetaRectangle *old_buffer_rect);
META_EXPORT
void meta_compositor_sync_window_geometry (MetaCompositor *compositor, void meta_compositor_sync_window_geometry (MetaCompositor *compositor,
MetaWindow *window, MetaWindow *window,
gboolean did_placement); gboolean did_placement);
META_EXPORT
void meta_compositor_sync_updates_frozen (MetaCompositor *compositor, void meta_compositor_sync_updates_frozen (MetaCompositor *compositor,
MetaWindow *window); MetaWindow *window);
META_EXPORT
void meta_compositor_queue_frame_drawn (MetaCompositor *compositor, void meta_compositor_queue_frame_drawn (MetaCompositor *compositor,
MetaWindow *window, MetaWindow *window,
gboolean no_delay_frame); gboolean no_delay_frame);
META_EXPORT
void meta_compositor_sync_stack (MetaCompositor *compositor, void meta_compositor_sync_stack (MetaCompositor *compositor,
GList *stack); GList *stack);
META_EXPORT
void meta_compositor_flash_display (MetaCompositor *compositor, void meta_compositor_flash_display (MetaCompositor *compositor,
MetaDisplay *display); MetaDisplay *display);
META_EXPORT
void meta_compositor_show_tile_preview (MetaCompositor *compositor, void meta_compositor_show_tile_preview (MetaCompositor *compositor,
MetaWindow *window, MetaWindow *window,
MetaRectangle *tile_rect, MetaRectangle *tile_rect,
int tile_monitor_number); int tile_monitor_number);
META_EXPORT
void meta_compositor_hide_tile_preview (MetaCompositor *compositor); void meta_compositor_hide_tile_preview (MetaCompositor *compositor);
META_EXPORT
void meta_compositor_show_window_menu (MetaCompositor *compositor, void meta_compositor_show_window_menu (MetaCompositor *compositor,
MetaWindow *window, MetaWindow *window,
MetaWindowMenuType menu, MetaWindowMenuType menu,
int x, int x,
int y); int y);
META_EXPORT
void meta_compositor_show_window_menu_for_rect (MetaCompositor *compositor, void meta_compositor_show_window_menu_for_rect (MetaCompositor *compositor,
MetaWindow *window, MetaWindow *window,
MetaWindowMenuType menu, MetaWindowMenuType menu,

View File

@ -72,42 +72,59 @@ typedef struct _MetaDisplayClass MetaDisplayClass;
#define META_IS_DISPLAY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_DISPLAY)) #define META_IS_DISPLAY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_DISPLAY))
#define META_DISPLAY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_DISPLAY, MetaDisplayClass)) #define META_DISPLAY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), META_TYPE_DISPLAY, MetaDisplayClass))
META_EXPORT
GType meta_display_get_type (void) G_GNUC_CONST; GType meta_display_get_type (void) G_GNUC_CONST;
#define meta_XFree(p) do { if ((p)) XFree ((p)); } while (0) #define meta_XFree(p) do { if ((p)) XFree ((p)); } while (0)
META_EXPORT
gboolean meta_display_supports_extended_barriers (MetaDisplay *display); gboolean meta_display_supports_extended_barriers (MetaDisplay *display);
META_EXPORT
void meta_display_close (MetaDisplay *display, void meta_display_close (MetaDisplay *display,
guint32 timestamp); guint32 timestamp);
META_EXPORT
MetaCompositor *meta_display_get_compositor (MetaDisplay *display); MetaCompositor *meta_display_get_compositor (MetaDisplay *display);
META_EXPORT
MetaX11Display *meta_display_get_x11_display (MetaDisplay *display); MetaX11Display *meta_display_get_x11_display (MetaDisplay *display);
META_EXPORT
MetaWindow *meta_display_get_focus_window (MetaDisplay *display); MetaWindow *meta_display_get_focus_window (MetaDisplay *display);
META_EXPORT
gboolean meta_display_xserver_time_is_before (MetaDisplay *display, gboolean meta_display_xserver_time_is_before (MetaDisplay *display,
guint32 time1, guint32 time1,
guint32 time2); guint32 time2);
META_EXPORT
guint32 meta_display_get_last_user_time (MetaDisplay *display); guint32 meta_display_get_last_user_time (MetaDisplay *display);
META_EXPORT
guint32 meta_display_get_current_time (MetaDisplay *display); guint32 meta_display_get_current_time (MetaDisplay *display);
META_EXPORT
guint32 meta_display_get_current_time_roundtrip (MetaDisplay *display); guint32 meta_display_get_current_time_roundtrip (MetaDisplay *display);
META_EXPORT
GList* meta_display_get_tab_list (MetaDisplay *display, GList* meta_display_get_tab_list (MetaDisplay *display,
MetaTabList type, MetaTabList type,
MetaWorkspace *workspace); MetaWorkspace *workspace);
META_EXPORT
MetaWindow* meta_display_get_tab_next (MetaDisplay *display, MetaWindow* meta_display_get_tab_next (MetaDisplay *display,
MetaTabList type, MetaTabList type,
MetaWorkspace *workspace, MetaWorkspace *workspace,
MetaWindow *window, MetaWindow *window,
gboolean backward); gboolean backward);
META_EXPORT
MetaWindow* meta_display_get_tab_current (MetaDisplay *display, MetaWindow* meta_display_get_tab_current (MetaDisplay *display,
MetaTabList type, MetaTabList type,
MetaWorkspace *workspace); MetaWorkspace *workspace);
META_EXPORT
gboolean meta_display_begin_grab_op (MetaDisplay *display, gboolean meta_display_begin_grab_op (MetaDisplay *display,
MetaWindow *window, MetaWindow *window,
MetaGrabOp op, MetaGrabOp op,
@ -118,11 +135,15 @@ gboolean meta_display_begin_grab_op (MetaDisplay *display,
guint32 timestamp, guint32 timestamp,
int root_x, int root_x,
int root_y); int root_y);
META_EXPORT
void meta_display_end_grab_op (MetaDisplay *display, void meta_display_end_grab_op (MetaDisplay *display,
guint32 timestamp); guint32 timestamp);
META_EXPORT
MetaGrabOp meta_display_get_grab_op (MetaDisplay *display); MetaGrabOp meta_display_get_grab_op (MetaDisplay *display);
META_EXPORT
guint meta_display_add_keybinding (MetaDisplay *display, guint meta_display_add_keybinding (MetaDisplay *display,
const char *name, const char *name,
GSettings *settings, GSettings *settings,
@ -130,47 +151,68 @@ guint meta_display_add_keybinding (MetaDisplay *display,
MetaKeyHandlerFunc handler, MetaKeyHandlerFunc handler,
gpointer user_data, gpointer user_data,
GDestroyNotify free_data); GDestroyNotify free_data);
META_EXPORT
gboolean meta_display_remove_keybinding (MetaDisplay *display, gboolean meta_display_remove_keybinding (MetaDisplay *display,
const char *name); const char *name);
META_EXPORT
guint meta_display_grab_accelerator (MetaDisplay *display, guint meta_display_grab_accelerator (MetaDisplay *display,
const char *accelerator); const char *accelerator);
META_EXPORT
gboolean meta_display_ungrab_accelerator (MetaDisplay *display, gboolean meta_display_ungrab_accelerator (MetaDisplay *display,
guint action_id); guint action_id);
META_EXPORT
guint meta_display_get_keybinding_action (MetaDisplay *display, guint meta_display_get_keybinding_action (MetaDisplay *display,
unsigned int keycode, unsigned int keycode,
unsigned long mask); unsigned long mask);
META_EXPORT
GSList *meta_display_sort_windows_by_stacking (MetaDisplay *display, GSList *meta_display_sort_windows_by_stacking (MetaDisplay *display,
GSList *windows); GSList *windows);
META_EXPORT
void meta_display_add_ignored_crossing_serial (MetaDisplay *display, void meta_display_add_ignored_crossing_serial (MetaDisplay *display,
unsigned long serial); unsigned long serial);
META_EXPORT
void meta_display_clear_mouse_mode (MetaDisplay *display); void meta_display_clear_mouse_mode (MetaDisplay *display);
META_EXPORT
void meta_display_freeze_keyboard (MetaDisplay *display, void meta_display_freeze_keyboard (MetaDisplay *display,
guint32 timestamp); guint32 timestamp);
META_EXPORT
void meta_display_ungrab_keyboard (MetaDisplay *display, void meta_display_ungrab_keyboard (MetaDisplay *display,
guint32 timestamp); guint32 timestamp);
META_EXPORT
void meta_display_unfreeze_keyboard (MetaDisplay *display, void meta_display_unfreeze_keyboard (MetaDisplay *display,
guint32 timestamp); guint32 timestamp);
META_EXPORT
gboolean meta_display_is_pointer_emulating_sequence (MetaDisplay *display, gboolean meta_display_is_pointer_emulating_sequence (MetaDisplay *display,
ClutterEventSequence *sequence); ClutterEventSequence *sequence);
META_EXPORT
void meta_display_request_pad_osd (MetaDisplay *display, void meta_display_request_pad_osd (MetaDisplay *display,
ClutterInputDevice *pad, ClutterInputDevice *pad,
gboolean edition_mode); gboolean edition_mode);
META_EXPORT
gchar * meta_display_get_pad_action_label (MetaDisplay *display, gchar * meta_display_get_pad_action_label (MetaDisplay *display,
ClutterInputDevice *pad, ClutterInputDevice *pad,
MetaPadActionType action_type, MetaPadActionType action_type,
guint action_number); guint action_number);
META_EXPORT
void meta_display_get_size (MetaDisplay *display, void meta_display_get_size (MetaDisplay *display,
int *width, int *width,
int *height); int *height);
META_EXPORT
void meta_display_set_cursor (MetaDisplay *display, void meta_display_set_cursor (MetaDisplay *display,
MetaCursor cursor); MetaCursor cursor);
@ -189,23 +231,34 @@ typedef enum
META_DISPLAY_RIGHT META_DISPLAY_RIGHT
} MetaDisplayDirection; } MetaDisplayDirection;
META_EXPORT
int meta_display_get_n_monitors (MetaDisplay *display); int meta_display_get_n_monitors (MetaDisplay *display);
META_EXPORT
int meta_display_get_primary_monitor (MetaDisplay *display); int meta_display_get_primary_monitor (MetaDisplay *display);
META_EXPORT
int meta_display_get_current_monitor (MetaDisplay *display); int meta_display_get_current_monitor (MetaDisplay *display);
META_EXPORT
void meta_display_get_monitor_geometry (MetaDisplay *display, void meta_display_get_monitor_geometry (MetaDisplay *display,
int monitor, int monitor,
MetaRectangle *geometry); MetaRectangle *geometry);
META_EXPORT
gboolean meta_display_get_monitor_in_fullscreen (MetaDisplay *display, gboolean meta_display_get_monitor_in_fullscreen (MetaDisplay *display,
int monitor); int monitor);
META_EXPORT
int meta_display_get_monitor_index_for_rect (MetaDisplay *display, int meta_display_get_monitor_index_for_rect (MetaDisplay *display,
MetaRectangle *rect); MetaRectangle *rect);
META_EXPORT
int meta_display_get_monitor_neighbor_index (MetaDisplay *display, int meta_display_get_monitor_neighbor_index (MetaDisplay *display,
int which_monitor, int which_monitor,
MetaDisplayDirection dir); MetaDisplayDirection dir);
META_EXPORT
void meta_display_focus_default_window (MetaDisplay *display, void meta_display_focus_default_window (MetaDisplay *display,
guint32 timestamp); guint32 timestamp);
@ -224,13 +277,16 @@ typedef enum
META_DISPLAY_BOTTOMRIGHT META_DISPLAY_BOTTOMRIGHT
} MetaDisplayCorner; } MetaDisplayCorner;
META_EXPORT
MetaWorkspaceManager *meta_display_get_workspace_manager (MetaDisplay *display); MetaWorkspaceManager *meta_display_get_workspace_manager (MetaDisplay *display);
/** /**
* meta_display_get_startup_notification: (skip) * meta_display_get_startup_notification: (skip)
*/ */
META_EXPORT
MetaStartupNotification * meta_display_get_startup_notification (MetaDisplay *display); MetaStartupNotification * meta_display_get_startup_notification (MetaDisplay *display);
META_EXPORT
MetaSoundPlayer * meta_display_get_sound_player (MetaDisplay *display); MetaSoundPlayer * meta_display_get_sound_player (MetaDisplay *display);
#endif #endif

View File

@ -24,27 +24,41 @@
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include <glib.h> #include <glib.h>
#include <meta/common.h>
#include <meta/types.h> #include <meta/types.h>
/* note, can return NULL */ /* note, can return NULL */
META_EXPORT
MetaGroup* meta_window_get_group (MetaWindow *window); MetaGroup* meta_window_get_group (MetaWindow *window);
META_EXPORT
void meta_window_compute_group (MetaWindow* window); void meta_window_compute_group (MetaWindow* window);
META_EXPORT
void meta_window_shutdown_group (MetaWindow *window); void meta_window_shutdown_group (MetaWindow *window);
META_EXPORT
void meta_window_group_leader_changed (MetaWindow *window); void meta_window_group_leader_changed (MetaWindow *window);
/* note, can return NULL */ /* note, can return NULL */
META_EXPORT
MetaGroup *meta_x11_display_lookup_group (MetaX11Display *x11_display, MetaGroup *meta_x11_display_lookup_group (MetaX11Display *x11_display,
Window group_leader); Window group_leader);
META_EXPORT
GSList* meta_group_list_windows (MetaGroup *group); GSList* meta_group_list_windows (MetaGroup *group);
META_EXPORT
void meta_group_update_layers (MetaGroup *group); void meta_group_update_layers (MetaGroup *group);
META_EXPORT
const char* meta_group_get_startup_id (MetaGroup *group); const char* meta_group_get_startup_id (MetaGroup *group);
META_EXPORT
int meta_group_get_size (MetaGroup *group); int meta_group_get_size (MetaGroup *group);
META_EXPORT
gboolean meta_group_property_notify (MetaGroup *group, gboolean meta_group_property_notify (MetaGroup *group,
XEvent *event); XEvent *event);

View File

@ -23,12 +23,22 @@
#define META_TYPE_KEY_BINDING (meta_key_binding_get_type ()) #define META_TYPE_KEY_BINDING (meta_key_binding_get_type ())
META_EXPORT
const char *meta_key_binding_get_name (MetaKeyBinding *binding); const char *meta_key_binding_get_name (MetaKeyBinding *binding);
META_EXPORT
MetaVirtualModifier meta_key_binding_get_modifiers (MetaKeyBinding *binding); MetaVirtualModifier meta_key_binding_get_modifiers (MetaKeyBinding *binding);
META_EXPORT
guint meta_key_binding_get_mask (MetaKeyBinding *binding); guint meta_key_binding_get_mask (MetaKeyBinding *binding);
META_EXPORT
gboolean meta_key_binding_is_builtin (MetaKeyBinding *binding); gboolean meta_key_binding_is_builtin (MetaKeyBinding *binding);
META_EXPORT
gboolean meta_key_binding_is_reversed (MetaKeyBinding *binding); gboolean meta_key_binding_is_reversed (MetaKeyBinding *binding);
META_EXPORT
gboolean meta_keybindings_set_custom_handler (const gchar *name, gboolean meta_keybindings_set_custom_handler (const gchar *name,
MetaKeyHandlerFunc handler, MetaKeyHandlerFunc handler,
gpointer user_data, gpointer user_data,

View File

@ -24,17 +24,36 @@
#include <glib.h> #include <glib.h>
#include <meta/common.h>
META_EXPORT
GOptionContext *meta_get_option_context (void); GOptionContext *meta_get_option_context (void);
META_EXPORT
void meta_init (void); void meta_init (void);
META_EXPORT
int meta_run (void); int meta_run (void);
META_EXPORT
void meta_register_with_session (void); void meta_register_with_session (void);
META_EXPORT
gboolean meta_activate_session (void); /* Actually defined in meta-backend.c */ gboolean meta_activate_session (void); /* Actually defined in meta-backend.c */
META_EXPORT
gboolean meta_get_replace_current_wm (void); /* Actually defined in util.c */ gboolean meta_get_replace_current_wm (void); /* Actually defined in util.c */
META_EXPORT
void meta_set_wm_name (const char *wm_name); void meta_set_wm_name (const char *wm_name);
META_EXPORT
void meta_set_gnome_wm_keybindings (const char *wm_keybindings); void meta_set_gnome_wm_keybindings (const char *wm_keybindings);
META_EXPORT
void meta_restart (const char *message); void meta_restart (const char *message);
META_EXPORT
gboolean meta_is_restart (void); gboolean meta_is_restart (void);
/** /**
@ -49,9 +68,11 @@ typedef enum
} MetaExitCode; } MetaExitCode;
/* exit immediately */ /* exit immediately */
META_EXPORT
void meta_exit (MetaExitCode code) G_GNUC_NORETURN; void meta_exit (MetaExitCode code) G_GNUC_NORETURN;
/* g_main_loop_quit() then fall out of main() */ /* g_main_loop_quit() then fall out of main() */
META_EXPORT
void meta_quit (MetaExitCode code); void meta_quit (MetaExitCode code);
#endif #endif

View File

@ -38,27 +38,36 @@ typedef struct _MetaBackendClass MetaBackendClass;
GType meta_backend_get_type (void); GType meta_backend_get_type (void);
#endif #endif
META_EXPORT
MetaBackend * meta_get_backend (void); MetaBackend * meta_get_backend (void);
META_EXPORT
void meta_backend_set_keymap (MetaBackend *backend, void meta_backend_set_keymap (MetaBackend *backend,
const char *layouts, const char *layouts,
const char *variants, const char *variants,
const char *options); const char *options);
META_EXPORT
void meta_backend_lock_layout_group (MetaBackend *backend, void meta_backend_lock_layout_group (MetaBackend *backend,
guint idx); guint idx);
META_EXPORT
void meta_backend_set_numlock (MetaBackend *backend, void meta_backend_set_numlock (MetaBackend *backend,
gboolean numlock_state); gboolean numlock_state);
META_EXPORT
ClutterActor *meta_backend_get_stage (MetaBackend *backend); ClutterActor *meta_backend_get_stage (MetaBackend *backend);
META_EXPORT
MetaDnd *meta_backend_get_dnd (MetaBackend *backend); MetaDnd *meta_backend_get_dnd (MetaBackend *backend);
META_EXPORT
MetaSettings *meta_backend_get_settings (MetaBackend *backend); MetaSettings *meta_backend_get_settings (MetaBackend *backend);
META_EXPORT
MetaRemoteAccessController * meta_backend_get_remote_access_controller (MetaBackend *backend); MetaRemoteAccessController * meta_backend_get_remote_access_controller (MetaBackend *backend);
META_EXPORT
void meta_clutter_init (void); void meta_clutter_init (void);
#endif /* META_BACKEND_H */ #endif /* META_BACKEND_H */

View File

@ -35,26 +35,33 @@
*/ */
#define META_TYPE_BACKGROUND_ACTOR (meta_background_actor_get_type ()) #define META_TYPE_BACKGROUND_ACTOR (meta_background_actor_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaBackgroundActor, G_DECLARE_FINAL_TYPE (MetaBackgroundActor,
meta_background_actor, meta_background_actor,
META, BACKGROUND_ACTOR, META, BACKGROUND_ACTOR,
ClutterActor) ClutterActor)
META_EXPORT
ClutterActor *meta_background_actor_new (MetaDisplay *display, ClutterActor *meta_background_actor_new (MetaDisplay *display,
int monitor); int monitor);
META_EXPORT
void meta_background_actor_set_background (MetaBackgroundActor *self, void meta_background_actor_set_background (MetaBackgroundActor *self,
MetaBackground *background); MetaBackground *background);
META_EXPORT
void meta_background_actor_set_gradient (MetaBackgroundActor *self, void meta_background_actor_set_gradient (MetaBackgroundActor *self,
gboolean enabled, gboolean enabled,
int height, int height,
double tone_start); double tone_start);
META_EXPORT
void meta_background_actor_set_monitor (MetaBackgroundActor *self, void meta_background_actor_set_monitor (MetaBackgroundActor *self,
int monitor); int monitor);
META_EXPORT
void meta_background_actor_set_vignette (MetaBackgroundActor *self, void meta_background_actor_set_vignette (MetaBackgroundActor *self,
gboolean enabled, gboolean enabled,
double brightness, double brightness,

View File

@ -5,12 +5,17 @@
#include "clutter/clutter.h" #include "clutter/clutter.h"
#include <meta/common.h>
#define META_TYPE_BACKGROUND_GROUP (meta_background_group_get_type ()) #define META_TYPE_BACKGROUND_GROUP (meta_background_group_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaBackgroundGroup, G_DECLARE_FINAL_TYPE (MetaBackgroundGroup,
meta_background_group, meta_background_group,
META, BACKGROUND_GROUP, META, BACKGROUND_GROUP,
ClutterActor) ClutterActor)
META_EXPORT
ClutterActor *meta_background_group_new (void); ClutterActor *meta_background_group_new (void);
#endif /* META_BACKGROUND_GROUP_H */ #endif /* META_BACKGROUND_GROUP_H */

View File

@ -30,26 +30,39 @@
#include "meta/display.h" #include "meta/display.h"
#define META_TYPE_BACKGROUND_IMAGE (meta_background_image_get_type ()) #define META_TYPE_BACKGROUND_IMAGE (meta_background_image_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaBackgroundImage, G_DECLARE_FINAL_TYPE (MetaBackgroundImage,
meta_background_image, meta_background_image,
META, BACKGROUND_IMAGE, META, BACKGROUND_IMAGE,
GObject) GObject)
META_EXPORT
gboolean meta_background_image_is_loaded (MetaBackgroundImage *image); gboolean meta_background_image_is_loaded (MetaBackgroundImage *image);
META_EXPORT
gboolean meta_background_image_get_success (MetaBackgroundImage *image); gboolean meta_background_image_get_success (MetaBackgroundImage *image);
META_EXPORT
CoglTexture *meta_background_image_get_texture (MetaBackgroundImage *image); CoglTexture *meta_background_image_get_texture (MetaBackgroundImage *image);
#define META_TYPE_BACKGROUND_IMAGE_CACHE (meta_background_image_cache_get_type ()) #define META_TYPE_BACKGROUND_IMAGE_CACHE (meta_background_image_cache_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaBackgroundImageCache, G_DECLARE_FINAL_TYPE (MetaBackgroundImageCache,
meta_background_image_cache, meta_background_image_cache,
META, BACKGROUND_IMAGE_CACHE, META, BACKGROUND_IMAGE_CACHE,
GObject) GObject)
META_EXPORT
MetaBackgroundImageCache *meta_background_image_cache_get_default (void); MetaBackgroundImageCache *meta_background_image_cache_get_default (void);
META_EXPORT
MetaBackgroundImage *meta_background_image_cache_load (MetaBackgroundImageCache *cache, MetaBackgroundImage *meta_background_image_cache_load (MetaBackgroundImageCache *cache,
GFile *file); GFile *file);
META_EXPORT
void meta_background_image_cache_purge (MetaBackgroundImageCache *cache, void meta_background_image_cache_purge (MetaBackgroundImageCache *cache,
GFile *file); GFile *file);

View File

@ -35,25 +35,36 @@
*/ */
#define META_TYPE_BACKGROUND (meta_background_get_type ()) #define META_TYPE_BACKGROUND (meta_background_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaBackground, G_DECLARE_FINAL_TYPE (MetaBackground,
meta_background, meta_background,
META, BACKGROUND, META, BACKGROUND,
GObject) GObject)
META_EXPORT
void meta_background_refresh_all (void); void meta_background_refresh_all (void);
META_EXPORT
MetaBackground *meta_background_new (MetaDisplay *display); MetaBackground *meta_background_new (MetaDisplay *display);
META_EXPORT
void meta_background_set_color (MetaBackground *self, void meta_background_set_color (MetaBackground *self,
ClutterColor *color); ClutterColor *color);
META_EXPORT
void meta_background_set_gradient (MetaBackground *self, void meta_background_set_gradient (MetaBackground *self,
GDesktopBackgroundShading shading_direction, GDesktopBackgroundShading shading_direction,
ClutterColor *color, ClutterColor *color,
ClutterColor *second_color); ClutterColor *second_color);
META_EXPORT
void meta_background_set_file (MetaBackground *self, void meta_background_set_file (MetaBackground *self,
GFile *file, GFile *file,
GDesktopBackgroundStyle style); GDesktopBackgroundStyle style);
META_EXPORT
void meta_background_set_blend (MetaBackground *self, void meta_background_set_blend (MetaBackground *self,
GFile *file1, GFile *file1,
GFile *file2, GFile *file2,

View File

@ -27,6 +27,7 @@
#define META_TYPE_CLOSE_DIALOG (meta_close_dialog_get_type ()) #define META_TYPE_CLOSE_DIALOG (meta_close_dialog_get_type ())
META_EXPORT
G_DECLARE_INTERFACE (MetaCloseDialog, meta_close_dialog, G_DECLARE_INTERFACE (MetaCloseDialog, meta_close_dialog,
META, CLOSE_DIALOG, GObject) META, CLOSE_DIALOG, GObject)
@ -45,11 +46,19 @@ struct _MetaCloseDialogInterface
void (* focus) (MetaCloseDialog *dialog); void (* focus) (MetaCloseDialog *dialog);
}; };
META_EXPORT
void meta_close_dialog_show (MetaCloseDialog *dialog); void meta_close_dialog_show (MetaCloseDialog *dialog);
META_EXPORT
void meta_close_dialog_hide (MetaCloseDialog *dialog); void meta_close_dialog_hide (MetaCloseDialog *dialog);
META_EXPORT
void meta_close_dialog_focus (MetaCloseDialog *dialog); void meta_close_dialog_focus (MetaCloseDialog *dialog);
META_EXPORT
gboolean meta_close_dialog_is_visible (MetaCloseDialog *dialog); gboolean meta_close_dialog_is_visible (MetaCloseDialog *dialog);
META_EXPORT
void meta_close_dialog_response (MetaCloseDialog *dialog, void meta_close_dialog_response (MetaCloseDialog *dialog,
MetaCloseDialogResponse response); MetaCloseDialogResponse response);

View File

@ -30,23 +30,32 @@
#include "meta/workspace.h" #include "meta/workspace.h"
#define META_TYPE_CURSOR_TRACKER (meta_cursor_tracker_get_type ()) #define META_TYPE_CURSOR_TRACKER (meta_cursor_tracker_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaCursorTracker, G_DECLARE_FINAL_TYPE (MetaCursorTracker,
meta_cursor_tracker, meta_cursor_tracker,
META, CURSOR_TRACKER, META, CURSOR_TRACKER,
GObject) GObject)
META_EXPORT
MetaCursorTracker *meta_cursor_tracker_get_for_display (MetaDisplay *display); MetaCursorTracker *meta_cursor_tracker_get_for_display (MetaDisplay *display);
META_EXPORT
void meta_cursor_tracker_get_hot (MetaCursorTracker *tracker, void meta_cursor_tracker_get_hot (MetaCursorTracker *tracker,
int *x, int *x,
int *y); int *y);
META_EXPORT
CoglTexture *meta_cursor_tracker_get_sprite (MetaCursorTracker *tracker); CoglTexture *meta_cursor_tracker_get_sprite (MetaCursorTracker *tracker);
META_EXPORT
void meta_cursor_tracker_get_pointer (MetaCursorTracker *tracker, void meta_cursor_tracker_get_pointer (MetaCursorTracker *tracker,
int *x, int *x,
int *y, int *y,
ClutterModifierType *mods); ClutterModifierType *mods);
META_EXPORT
void meta_cursor_tracker_set_pointer_visible (MetaCursorTracker *tracker, void meta_cursor_tracker_set_pointer_visible (MetaCursorTracker *tracker,
gboolean visible); gboolean visible);

View File

@ -23,9 +23,12 @@
#include <glib-object.h> #include <glib-object.h>
#include <string.h> #include <string.h>
#include "meta/types.h" #include <meta/common.h>
#include <meta/types.h>
#define META_TYPE_DND (meta_dnd_get_type ()) #define META_TYPE_DND (meta_dnd_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaDnd, meta_dnd, META, DND, GObject) G_DECLARE_FINAL_TYPE (MetaDnd, meta_dnd, META, DND, GObject)
#endif /* META_DND_H */ #endif /* META_DND_H */

View File

@ -3,6 +3,7 @@
#define __META_ENUM_TYPES_H__ #define __META_ENUM_TYPES_H__
#include <glib-object.h> #include <glib-object.h>
#include <meta/common.h>
G_BEGIN_DECLS G_BEGIN_DECLS
@ -19,7 +20,7 @@ G_END_DECLS
/*** END file-tail ***/ /*** END file-tail ***/
/*** BEGIN value-header ***/ /*** BEGIN value-header ***/
GType @enum_name@_get_type (void) G_GNUC_CONST; META_EXPORT GType @enum_name@_get_type (void) G_GNUC_CONST;
#define META_TYPE_@ENUMSHORT@ (@enum_name@_get_type()) #define META_TYPE_@ENUMSHORT@ (@enum_name@_get_type())
/*** END value-header ***/ /*** END value-header ***/

View File

@ -33,28 +33,37 @@
typedef struct _MetaIdleMonitor MetaIdleMonitor; typedef struct _MetaIdleMonitor MetaIdleMonitor;
typedef struct _MetaIdleMonitorClass MetaIdleMonitorClass; typedef struct _MetaIdleMonitorClass MetaIdleMonitorClass;
META_EXPORT
GType meta_idle_monitor_get_type (void); GType meta_idle_monitor_get_type (void);
typedef void (*MetaIdleMonitorWatchFunc) (MetaIdleMonitor *monitor, typedef void (*MetaIdleMonitorWatchFunc) (MetaIdleMonitor *monitor,
guint watch_id, guint watch_id,
gpointer user_data); gpointer user_data);
META_EXPORT
MetaIdleMonitor *meta_idle_monitor_get_core (void); MetaIdleMonitor *meta_idle_monitor_get_core (void);
META_EXPORT
MetaIdleMonitor *meta_idle_monitor_get_for_device (int device_id); MetaIdleMonitor *meta_idle_monitor_get_for_device (int device_id);
META_EXPORT
guint meta_idle_monitor_add_idle_watch (MetaIdleMonitor *monitor, guint meta_idle_monitor_add_idle_watch (MetaIdleMonitor *monitor,
guint64 interval_msec, guint64 interval_msec,
MetaIdleMonitorWatchFunc callback, MetaIdleMonitorWatchFunc callback,
gpointer user_data, gpointer user_data,
GDestroyNotify notify); GDestroyNotify notify);
META_EXPORT
guint meta_idle_monitor_add_user_active_watch (MetaIdleMonitor *monitor, guint meta_idle_monitor_add_user_active_watch (MetaIdleMonitor *monitor,
MetaIdleMonitorWatchFunc callback, MetaIdleMonitorWatchFunc callback,
gpointer user_data, gpointer user_data,
GDestroyNotify notify); GDestroyNotify notify);
META_EXPORT
void meta_idle_monitor_remove_watch (MetaIdleMonitor *monitor, void meta_idle_monitor_remove_watch (MetaIdleMonitor *monitor,
guint id); guint id);
META_EXPORT
gint64 meta_idle_monitor_get_idletime (MetaIdleMonitor *monitor); gint64 meta_idle_monitor_get_idletime (MetaIdleMonitor *monitor);
#endif #endif

View File

@ -23,6 +23,8 @@
#include <meta/window.h> #include <meta/window.h>
#define META_TYPE_INHIBIT_SHORTCUTS_DIALOG (meta_inhibit_shortcuts_dialog_get_type ()) #define META_TYPE_INHIBIT_SHORTCUTS_DIALOG (meta_inhibit_shortcuts_dialog_get_type ())
META_EXPORT
G_DECLARE_INTERFACE (MetaInhibitShortcutsDialog, meta_inhibit_shortcuts_dialog, G_DECLARE_INTERFACE (MetaInhibitShortcutsDialog, meta_inhibit_shortcuts_dialog,
META, INHIBIT_SHORTCUTS_DIALOG, GObject) META, INHIBIT_SHORTCUTS_DIALOG, GObject)
@ -40,9 +42,13 @@ struct _MetaInhibitShortcutsDialogInterface
void (* hide) (MetaInhibitShortcutsDialog *dialog); void (* hide) (MetaInhibitShortcutsDialog *dialog);
}; };
META_EXPORT
void meta_inhibit_shortcuts_dialog_show (MetaInhibitShortcutsDialog *dialog); void meta_inhibit_shortcuts_dialog_show (MetaInhibitShortcutsDialog *dialog);
META_EXPORT
void meta_inhibit_shortcuts_dialog_hide (MetaInhibitShortcutsDialog *dialog); void meta_inhibit_shortcuts_dialog_hide (MetaInhibitShortcutsDialog *dialog);
META_EXPORT
void meta_inhibit_shortcuts_dialog_response (MetaInhibitShortcutsDialog *dialog, void meta_inhibit_shortcuts_dialog_response (MetaInhibitShortcutsDialog *dialog,
MetaInhibitShortcutsDialogResponse response); MetaInhibitShortcutsDialogResponse response);

View File

@ -23,12 +23,16 @@
#include <meta/workspace.h> #include <meta/workspace.h>
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaLaunchContext, meta_launch_context, META, LAUNCH_CONTEXT, GAppLaunchContext) G_DECLARE_FINAL_TYPE (MetaLaunchContext, meta_launch_context, META, LAUNCH_CONTEXT, GAppLaunchContext)
#define META_TYPE_LAUNCH_CONTEXT (meta_launch_context_get_type ()) #define META_TYPE_LAUNCH_CONTEXT (meta_launch_context_get_type ())
META_EXPORT
void meta_launch_context_set_timestamp (MetaLaunchContext *context, void meta_launch_context_set_timestamp (MetaLaunchContext *context,
uint32_t timestamp); uint32_t timestamp);
META_EXPORT
void meta_launch_context_set_workspace (MetaLaunchContext *context, void meta_launch_context_set_workspace (MetaLaunchContext *context,
MetaWorkspace *workspace); MetaWorkspace *workspace);

View File

@ -36,22 +36,30 @@ typedef enum
typedef struct _MetaMonitorManagerClass MetaMonitorManagerClass; typedef struct _MetaMonitorManagerClass MetaMonitorManagerClass;
typedef struct _MetaMonitorManager MetaMonitorManager; typedef struct _MetaMonitorManager MetaMonitorManager;
META_EXPORT
GType meta_monitor_manager_get_type (void); GType meta_monitor_manager_get_type (void);
META_EXPORT
MetaMonitorManager *meta_monitor_manager_get (void); MetaMonitorManager *meta_monitor_manager_get (void);
META_EXPORT
gint meta_monitor_manager_get_monitor_for_connector (MetaMonitorManager *manager, gint meta_monitor_manager_get_monitor_for_connector (MetaMonitorManager *manager,
const char *connector); const char *connector);
META_EXPORT
gboolean meta_monitor_manager_get_is_builtin_display_on (MetaMonitorManager *manager); gboolean meta_monitor_manager_get_is_builtin_display_on (MetaMonitorManager *manager);
META_EXPORT
void meta_monitor_manager_switch_config (MetaMonitorManager *manager, void meta_monitor_manager_switch_config (MetaMonitorManager *manager,
MetaMonitorSwitchConfigType config_type); MetaMonitorSwitchConfigType config_type);
META_EXPORT
gboolean meta_monitor_manager_can_switch_config (MetaMonitorManager *manager); gboolean meta_monitor_manager_can_switch_config (MetaMonitorManager *manager);
META_EXPORT
MetaMonitorSwitchConfigType meta_monitor_manager_get_switch_config (MetaMonitorManager *manager); MetaMonitorSwitchConfigType meta_monitor_manager_get_switch_config (MetaMonitorManager *manager);
META_EXPORT
gint meta_monitor_manager_get_display_configuration_timeout (void); gint meta_monitor_manager_get_display_configuration_timeout (void);
#endif /* META_MONITOR_MANAGER_H */ #endif /* META_MONITOR_MANAGER_H */

View File

@ -34,6 +34,8 @@
#include "meta/types.h" #include "meta/types.h"
#define META_TYPE_PLUGIN (meta_plugin_get_type ()) #define META_TYPE_PLUGIN (meta_plugin_get_type ())
META_EXPORT
G_DECLARE_DERIVABLE_TYPE (MetaPlugin, meta_plugin, META, PLUGIN, GObject) G_DECLARE_DERIVABLE_TYPE (MetaPlugin, meta_plugin, META, PLUGIN, GObject)
typedef struct _MetaPluginVersion MetaPluginVersion; typedef struct _MetaPluginVersion MetaPluginVersion;
@ -256,6 +258,7 @@ struct _MetaPluginInfo
const gchar *description; const gchar *description;
}; };
META_EXPORT
const MetaPluginInfo * meta_plugin_get_info (MetaPlugin *plugin); const MetaPluginInfo * meta_plugin_get_info (MetaPlugin *plugin);
/** /**
@ -321,29 +324,36 @@ struct _MetaPluginVersion
#define META_PLUGIN_DECLARE(ObjectName, object_name) \ #define META_PLUGIN_DECLARE(ObjectName, object_name) \
META_PLUGIN_DECLARE_WITH_CODE(ObjectName, object_name, {}) META_PLUGIN_DECLARE_WITH_CODE(ObjectName, object_name, {})
META_EXPORT
void void
meta_plugin_switch_workspace_completed (MetaPlugin *plugin); meta_plugin_switch_workspace_completed (MetaPlugin *plugin);
META_EXPORT
void void
meta_plugin_minimize_completed (MetaPlugin *plugin, meta_plugin_minimize_completed (MetaPlugin *plugin,
MetaWindowActor *actor); MetaWindowActor *actor);
META_EXPORT
void void
meta_plugin_unminimize_completed (MetaPlugin *plugin, meta_plugin_unminimize_completed (MetaPlugin *plugin,
MetaWindowActor *actor); MetaWindowActor *actor);
META_EXPORT
void void
meta_plugin_size_change_completed (MetaPlugin *plugin, meta_plugin_size_change_completed (MetaPlugin *plugin,
MetaWindowActor *actor); MetaWindowActor *actor);
META_EXPORT
void void
meta_plugin_map_completed (MetaPlugin *plugin, meta_plugin_map_completed (MetaPlugin *plugin,
MetaWindowActor *actor); MetaWindowActor *actor);
META_EXPORT
void void
meta_plugin_destroy_completed (MetaPlugin *plugin, meta_plugin_destroy_completed (MetaPlugin *plugin,
MetaWindowActor *actor); MetaWindowActor *actor);
META_EXPORT
void void
meta_plugin_complete_display_change (MetaPlugin *plugin, meta_plugin_complete_display_change (MetaPlugin *plugin,
gboolean ok); gboolean ok);
@ -362,20 +372,24 @@ typedef enum {
META_MODAL_KEYBOARD_ALREADY_GRABBED = 1 << 1 META_MODAL_KEYBOARD_ALREADY_GRABBED = 1 << 1
} MetaModalOptions; } MetaModalOptions;
META_EXPORT
gboolean gboolean
meta_plugin_begin_modal (MetaPlugin *plugin, meta_plugin_begin_modal (MetaPlugin *plugin,
MetaModalOptions options, MetaModalOptions options,
guint32 timestamp); guint32 timestamp);
META_EXPORT
void void
meta_plugin_end_modal (MetaPlugin *plugin, meta_plugin_end_modal (MetaPlugin *plugin,
guint32 timestamp); guint32 timestamp);
META_EXPORT
MetaDisplay *meta_plugin_get_display (MetaPlugin *plugin); MetaDisplay *meta_plugin_get_display (MetaPlugin *plugin);
void _meta_plugin_set_compositor (MetaPlugin *plugin, MetaCompositor *compositor); void _meta_plugin_set_compositor (MetaPlugin *plugin, MetaCompositor *compositor);
/* XXX: Putting this in here so it's in the public header. */ /* XXX: Putting this in here so it's in the public header. */
META_EXPORT
void meta_plugin_manager_set_plugin_type (GType gtype); void meta_plugin_manager_set_plugin_type (GType gtype);
#endif /* META_PLUGIN_H_ */ #endif /* META_PLUGIN_H_ */

View File

@ -23,7 +23,11 @@
#include <glib-object.h> #include <glib-object.h>
#include <meta/common.h>
#define META_TYPE_REMOTE_ACCESS_HANDLE meta_remote_access_handle_get_type () #define META_TYPE_REMOTE_ACCESS_HANDLE meta_remote_access_handle_get_type ()
META_EXPORT
G_DECLARE_DERIVABLE_TYPE (MetaRemoteAccessHandle, G_DECLARE_DERIVABLE_TYPE (MetaRemoteAccessHandle,
meta_remote_access_handle, meta_remote_access_handle,
META, REMOTE_ACCESS_HANDLE, META, REMOTE_ACCESS_HANDLE,
@ -36,9 +40,12 @@ struct _MetaRemoteAccessHandleClass
void (*stop) (MetaRemoteAccessHandle *handle); void (*stop) (MetaRemoteAccessHandle *handle);
}; };
META_EXPORT
void meta_remote_access_handle_stop (MetaRemoteAccessHandle *handle); void meta_remote_access_handle_stop (MetaRemoteAccessHandle *handle);
#define META_TYPE_REMOTE_ACCESS_CONTROLLER meta_remote_access_controller_get_type () #define META_TYPE_REMOTE_ACCESS_CONTROLLER meta_remote_access_controller_get_type ()
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaRemoteAccessController, G_DECLARE_FINAL_TYPE (MetaRemoteAccessController,
meta_remote_access_controller, meta_remote_access_controller,
META, REMOTE_ACCESS_CONTROLLER, META, REMOTE_ACCESS_CONTROLLER,

View File

@ -22,10 +22,13 @@
#ifndef META_SETTINGS_H #ifndef META_SETTINGS_H
#define META_SETTINGS_H #define META_SETTINGS_H
#include "meta/types.h" #include <meta/common.h>
#include <meta/types.h>
META_EXPORT
int meta_settings_get_ui_scaling_factor (MetaSettings *settings); int meta_settings_get_ui_scaling_factor (MetaSettings *settings);
META_EXPORT
int meta_settings_get_font_dpi (MetaSettings *settings); int meta_settings_get_font_dpi (MetaSettings *settings);
#endif /* META_SETTINGS_H */ #endif /* META_SETTINGS_H */

View File

@ -29,6 +29,7 @@
#include "cogl/cogl.h" #include "cogl/cogl.h"
#include "meta/meta-window-shape.h" #include "meta/meta-window-shape.h"
META_EXPORT
GType meta_shadow_get_type (void) G_GNUC_CONST; GType meta_shadow_get_type (void) G_GNUC_CONST;
/** /**
@ -58,6 +59,8 @@ struct _MetaShadowParams
}; };
#define META_TYPE_SHADOW_FACTORY (meta_shadow_factory_get_type ()) #define META_TYPE_SHADOW_FACTORY (meta_shadow_factory_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaShadowFactory, G_DECLARE_FINAL_TYPE (MetaShadowFactory,
meta_shadow_factory, meta_shadow_factory,
META, SHADOW_FACTORY, META, SHADOW_FACTORY,
@ -70,13 +73,16 @@ G_DECLARE_FINAL_TYPE (MetaShadowFactory,
* so that multiple shadows created for the same shape with the same radius will * so that multiple shadows created for the same shape with the same radius will
* share the same MetaShadow. * share the same MetaShadow.
*/ */
META_EXPORT
MetaShadowFactory *meta_shadow_factory_get_default (void); MetaShadowFactory *meta_shadow_factory_get_default (void);
META_EXPORT
void meta_shadow_factory_set_params (MetaShadowFactory *factory, void meta_shadow_factory_set_params (MetaShadowFactory *factory,
const char *class_name, const char *class_name,
gboolean focused, gboolean focused,
MetaShadowParams *params); MetaShadowParams *params);
META_EXPORT
void meta_shadow_factory_get_params (MetaShadowFactory *factory, void meta_shadow_factory_get_params (MetaShadowFactory *factory,
const char *class_name, const char *class_name,
gboolean focused, gboolean focused,
@ -90,8 +96,13 @@ void meta_shadow_factory_get_params (MetaShadowFactory *factory,
*/ */
typedef struct _MetaShadow MetaShadow; typedef struct _MetaShadow MetaShadow;
META_EXPORT
MetaShadow *meta_shadow_ref (MetaShadow *shadow); MetaShadow *meta_shadow_ref (MetaShadow *shadow);
META_EXPORT
void meta_shadow_unref (MetaShadow *shadow); void meta_shadow_unref (MetaShadow *shadow);
META_EXPORT
void meta_shadow_paint (MetaShadow *shadow, void meta_shadow_paint (MetaShadow *shadow,
CoglFramebuffer *framebuffer, CoglFramebuffer *framebuffer,
int window_x, int window_x,
@ -101,6 +112,8 @@ void meta_shadow_paint (MetaShadow *shadow,
guint8 opacity, guint8 opacity,
cairo_region_t *clip, cairo_region_t *clip,
gboolean clip_strictly); gboolean clip_strictly);
META_EXPORT
void meta_shadow_get_bounds (MetaShadow *shadow, void meta_shadow_get_bounds (MetaShadow *shadow,
int window_x, int window_x,
int window_y, int window_y,
@ -108,8 +121,10 @@ void meta_shadow_get_bounds (MetaShadow *shadow,
int window_height, int window_height,
cairo_rectangle_int_t *bounds); cairo_rectangle_int_t *bounds);
META_EXPORT
MetaShadowFactory *meta_shadow_factory_new (void); MetaShadowFactory *meta_shadow_factory_new (void);
META_EXPORT
MetaShadow *meta_shadow_factory_get_shadow (MetaShadowFactory *factory, MetaShadow *meta_shadow_factory_get_shadow (MetaShadowFactory *factory,
MetaWindowShape *shape, MetaWindowShape *shape,
int width, int width,

View File

@ -27,32 +27,42 @@
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include "clutter/clutter.h" #include "clutter/clutter.h"
#include <meta/common.h>
G_BEGIN_DECLS G_BEGIN_DECLS
#define META_TYPE_SHAPED_TEXTURE (meta_shaped_texture_get_type ()) #define META_TYPE_SHAPED_TEXTURE (meta_shaped_texture_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaShapedTexture, G_DECLARE_FINAL_TYPE (MetaShapedTexture,
meta_shaped_texture, meta_shaped_texture,
META, SHAPED_TEXTURE, META, SHAPED_TEXTURE,
ClutterActor) ClutterActor)
META_EXPORT
void meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex, void meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex,
gboolean create_mipmaps); gboolean create_mipmaps);
META_EXPORT
gboolean meta_shaped_texture_update_area (MetaShapedTexture *stex, gboolean meta_shaped_texture_update_area (MetaShapedTexture *stex,
int x, int x,
int y, int y,
int width, int width,
int height); int height);
META_EXPORT
CoglTexture * meta_shaped_texture_get_texture (MetaShapedTexture *stex); CoglTexture * meta_shaped_texture_get_texture (MetaShapedTexture *stex);
META_EXPORT
void meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex, void meta_shaped_texture_set_mask_texture (MetaShapedTexture *stex,
CoglTexture *mask_texture); CoglTexture *mask_texture);
META_EXPORT
void meta_shaped_texture_set_opaque_region (MetaShapedTexture *stex, void meta_shaped_texture_set_opaque_region (MetaShapedTexture *stex,
cairo_region_t *opaque_region); cairo_region_t *opaque_region);
META_EXPORT
cairo_surface_t * meta_shaped_texture_get_image (MetaShapedTexture *stex, cairo_surface_t * meta_shaped_texture_get_image (MetaShapedTexture *stex,
cairo_rectangle_int_t *clip); cairo_rectangle_int_t *clip);

View File

@ -23,14 +23,21 @@
#include <gio/gio.h> #include <gio/gio.h>
#include <meta/common.h>
#define META_TYPE_SOUND_PLAYER (meta_sound_player_get_type ()) #define META_TYPE_SOUND_PLAYER (meta_sound_player_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaSoundPlayer, meta_sound_player, G_DECLARE_FINAL_TYPE (MetaSoundPlayer, meta_sound_player,
META, SOUND_PLAYER, GObject) META, SOUND_PLAYER, GObject)
META_EXPORT
void meta_sound_player_play_from_theme (MetaSoundPlayer *player, void meta_sound_player_play_from_theme (MetaSoundPlayer *player,
const char *name, const char *name,
const char *description, const char *description,
GCancellable *cancellable); GCancellable *cancellable);
META_EXPORT
void meta_sound_player_play_from_file (MetaSoundPlayer *player, void meta_sound_player_play_from_file (MetaSoundPlayer *player,
GFile *file, GFile *file,
const char *description, const char *description,

View File

@ -25,6 +25,8 @@
G_BEGIN_DECLS G_BEGIN_DECLS
#define META_TYPE_STAGE (meta_stage_get_type ()) #define META_TYPE_STAGE (meta_stage_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaStage, meta_stage, META, STAGE, ClutterStage) G_DECLARE_FINAL_TYPE (MetaStage, meta_stage, META, STAGE, ClutterStage)
G_END_DECLS G_END_DECLS

View File

@ -34,8 +34,10 @@ GType meta_startup_notification_get_type (void);
/** /**
* meta_startup_notification_get_sequences: (skip) * meta_startup_notification_get_sequences: (skip)
*/ */
META_EXPORT
GSList * meta_startup_notification_get_sequences (MetaStartupNotification *sn); GSList * meta_startup_notification_get_sequences (MetaStartupNotification *sn);
META_EXPORT
MetaLaunchContext * MetaLaunchContext *
meta_startup_notification_create_launcher (MetaStartupNotification *sn); meta_startup_notification_create_launcher (MetaStartupNotification *sn);
@ -43,15 +45,31 @@ MetaLaunchContext *
GType meta_startup_sequence_get_type (void); GType meta_startup_sequence_get_type (void);
#endif #endif
META_EXPORT
const char * meta_startup_sequence_get_id (MetaStartupSequence *sequence); const char * meta_startup_sequence_get_id (MetaStartupSequence *sequence);
META_EXPORT
gboolean meta_startup_sequence_get_completed (MetaStartupSequence *sequence); gboolean meta_startup_sequence_get_completed (MetaStartupSequence *sequence);
META_EXPORT
const char * meta_startup_sequence_get_name (MetaStartupSequence *sequence); const char * meta_startup_sequence_get_name (MetaStartupSequence *sequence);
META_EXPORT
int meta_startup_sequence_get_workspace (MetaStartupSequence *sequence); int meta_startup_sequence_get_workspace (MetaStartupSequence *sequence);
META_EXPORT
uint64_t meta_startup_sequence_get_timestamp (MetaStartupSequence *sequence); uint64_t meta_startup_sequence_get_timestamp (MetaStartupSequence *sequence);
META_EXPORT
const char * meta_startup_sequence_get_icon_name (MetaStartupSequence *sequence); const char * meta_startup_sequence_get_icon_name (MetaStartupSequence *sequence);
META_EXPORT
const char * meta_startup_sequence_get_application_id (MetaStartupSequence *sequence); const char * meta_startup_sequence_get_application_id (MetaStartupSequence *sequence);
META_EXPORT
const char * meta_startup_sequence_get_wmclass (MetaStartupSequence *sequence); const char * meta_startup_sequence_get_wmclass (MetaStartupSequence *sequence);
META_EXPORT
void meta_startup_sequence_complete (MetaStartupSequence *sequence); void meta_startup_sequence_complete (MetaStartupSequence *sequence);
#endif /* META_STARTUP_NOTIFICATION_H */ #endif /* META_STARTUP_NOTIFICATION_H */

View File

@ -29,15 +29,26 @@
#include "meta/compositor.h" #include "meta/compositor.h"
#define META_TYPE_WINDOW_ACTOR (meta_window_actor_get_type ()) #define META_TYPE_WINDOW_ACTOR (meta_window_actor_get_type ())
META_EXPORT
G_DECLARE_DERIVABLE_TYPE (MetaWindowActor, G_DECLARE_DERIVABLE_TYPE (MetaWindowActor,
meta_window_actor, meta_window_actor,
META, WINDOW_ACTOR, META, WINDOW_ACTOR,
ClutterActor) ClutterActor)
META_EXPORT
Window meta_window_actor_get_x_window (MetaWindowActor *self); Window meta_window_actor_get_x_window (MetaWindowActor *self);
META_EXPORT
MetaWindow * meta_window_actor_get_meta_window (MetaWindowActor *self); MetaWindow * meta_window_actor_get_meta_window (MetaWindowActor *self);
META_EXPORT
ClutterActor * meta_window_actor_get_texture (MetaWindowActor *self); ClutterActor * meta_window_actor_get_texture (MetaWindowActor *self);
META_EXPORT
void meta_window_actor_sync_visibility (MetaWindowActor *self); void meta_window_actor_sync_visibility (MetaWindowActor *self);
META_EXPORT
gboolean meta_window_actor_is_destroyed (MetaWindowActor *self); gboolean meta_window_actor_is_destroyed (MetaWindowActor *self);
typedef enum { typedef enum {

View File

@ -6,6 +6,8 @@
#include "clutter/clutter.h" #include "clutter/clutter.h"
#define META_TYPE_WINDOW_GROUP (meta_window_group_get_type()) #define META_TYPE_WINDOW_GROUP (meta_window_group_get_type())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaWindowGroup, G_DECLARE_FINAL_TYPE (MetaWindowGroup,
meta_window_group, meta_window_group,
META, WINDOW_GROUP, META, WINDOW_GROUP,

View File

@ -26,6 +26,9 @@
#include <cairo.h> #include <cairo.h>
#include <glib-object.h> #include <glib-object.h>
#include <meta/common.h>
META_EXPORT
GType meta_window_shape_get_type (void) G_GNUC_CONST; GType meta_window_shape_get_type (void) G_GNUC_CONST;
/** /**
@ -41,17 +44,30 @@ GType meta_window_shape_get_type (void) G_GNUC_CONST;
*/ */
typedef struct _MetaWindowShape MetaWindowShape; typedef struct _MetaWindowShape MetaWindowShape;
META_EXPORT
MetaWindowShape * meta_window_shape_new (cairo_region_t *region); MetaWindowShape * meta_window_shape_new (cairo_region_t *region);
META_EXPORT
MetaWindowShape * meta_window_shape_ref (MetaWindowShape *shape); MetaWindowShape * meta_window_shape_ref (MetaWindowShape *shape);
META_EXPORT
void meta_window_shape_unref (MetaWindowShape *shape); void meta_window_shape_unref (MetaWindowShape *shape);
META_EXPORT
guint meta_window_shape_hash (MetaWindowShape *shape); guint meta_window_shape_hash (MetaWindowShape *shape);
META_EXPORT
gboolean meta_window_shape_equal (MetaWindowShape *shape_a, gboolean meta_window_shape_equal (MetaWindowShape *shape_a,
MetaWindowShape *shape_b); MetaWindowShape *shape_b);
META_EXPORT
void meta_window_shape_get_borders (MetaWindowShape *shape, void meta_window_shape_get_borders (MetaWindowShape *shape,
int *border_top, int *border_top,
int *border_right, int *border_right,
int *border_bottom, int *border_bottom,
int *border_left); int *border_left);
META_EXPORT
cairo_region_t *meta_window_shape_to_region (MetaWindowShape *shape, cairo_region_t *meta_window_shape_to_region (MetaWindowShape *shape,
int center_width, int center_width,
int center_height); int center_height);

View File

@ -30,30 +30,40 @@
#include <meta/types.h> #include <meta/types.h>
#define META_TYPE_WORKSPACE_MANAGER (meta_workspace_manager_get_type ()) #define META_TYPE_WORKSPACE_MANAGER (meta_workspace_manager_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaWorkspaceManager, G_DECLARE_FINAL_TYPE (MetaWorkspaceManager,
meta_workspace_manager, meta_workspace_manager,
META, WORKSPACE_MANAGER, META, WORKSPACE_MANAGER,
GObject) GObject)
META_EXPORT
GList *meta_workspace_manager_get_workspaces (MetaWorkspaceManager *workspace_manager); GList *meta_workspace_manager_get_workspaces (MetaWorkspaceManager *workspace_manager);
META_EXPORT
int meta_workspace_manager_get_n_workspaces (MetaWorkspaceManager *workspace_manager); int meta_workspace_manager_get_n_workspaces (MetaWorkspaceManager *workspace_manager);
META_EXPORT
MetaWorkspace* meta_workspace_manager_get_workspace_by_index (MetaWorkspaceManager *workspace_manager, MetaWorkspace* meta_workspace_manager_get_workspace_by_index (MetaWorkspaceManager *workspace_manager,
int index); int index);
META_EXPORT
void meta_workspace_manager_remove_workspace (MetaWorkspaceManager *workspace_manager, void meta_workspace_manager_remove_workspace (MetaWorkspaceManager *workspace_manager,
MetaWorkspace *workspace, MetaWorkspace *workspace,
guint32 timestamp); guint32 timestamp);
META_EXPORT
MetaWorkspace *meta_workspace_manager_append_new_workspace (MetaWorkspaceManager *workspace_manager, MetaWorkspace *meta_workspace_manager_append_new_workspace (MetaWorkspaceManager *workspace_manager,
gboolean activate, gboolean activate,
guint32 timestamp); guint32 timestamp);
META_EXPORT
int meta_workspace_manager_get_active_workspace_index (MetaWorkspaceManager *workspace_manager); int meta_workspace_manager_get_active_workspace_index (MetaWorkspaceManager *workspace_manager);
META_EXPORT
MetaWorkspace *meta_workspace_manager_get_active_workspace (MetaWorkspaceManager *workspace_manager); MetaWorkspace *meta_workspace_manager_get_active_workspace (MetaWorkspaceManager *workspace_manager);
META_EXPORT
void meta_workspace_manager_override_workspace_layout (MetaWorkspaceManager *workspace_manager, void meta_workspace_manager_override_workspace_layout (MetaWorkspaceManager *workspace_manager,
MetaDisplayCorner starting_corner, MetaDisplayCorner starting_corner,
gboolean vertical_layout, gboolean vertical_layout,

View File

@ -28,21 +28,38 @@
#include <meta/types.h> #include <meta/types.h>
#define META_TYPE_X11_DISPLAY (meta_x11_display_get_type ()) #define META_TYPE_X11_DISPLAY (meta_x11_display_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaX11Display, meta_x11_display, META, X11_DISPLAY, GObject) G_DECLARE_FINAL_TYPE (MetaX11Display, meta_x11_display, META, X11_DISPLAY, GObject)
META_EXPORT
gboolean meta_x11_init_gdk_display (GError **error); gboolean meta_x11_init_gdk_display (GError **error);
META_EXPORT
int meta_x11_display_get_screen_number (MetaX11Display *x11_display); int meta_x11_display_get_screen_number (MetaX11Display *x11_display);
META_EXPORT
Display *meta_x11_display_get_xdisplay (MetaX11Display *x11_display); Display *meta_x11_display_get_xdisplay (MetaX11Display *x11_display);
META_EXPORT
Window meta_x11_display_get_xroot (MetaX11Display *x11_display); Window meta_x11_display_get_xroot (MetaX11Display *x11_display);
META_EXPORT
int meta_x11_display_get_xinput_opcode (MetaX11Display *x11_display); int meta_x11_display_get_xinput_opcode (MetaX11Display *x11_display);
META_EXPORT
int meta_x11_display_get_damage_event_base (MetaX11Display *x11_display); int meta_x11_display_get_damage_event_base (MetaX11Display *x11_display);
META_EXPORT
int meta_x11_display_get_shape_event_base (MetaX11Display *x11_display); int meta_x11_display_get_shape_event_base (MetaX11Display *x11_display);
META_EXPORT
gboolean meta_x11_display_has_shape (MetaX11Display *x11_display); gboolean meta_x11_display_has_shape (MetaX11Display *x11_display);
META_EXPORT
void meta_x11_display_set_cm_selection (MetaX11Display *x11_display); void meta_x11_display_set_cm_selection (MetaX11Display *x11_display);
META_EXPORT
gboolean meta_x11_display_xwindow_is_a_no_focus_window (MetaX11Display *x11_display, gboolean meta_x11_display_xwindow_is_a_no_focus_window (MetaX11Display *x11_display,
Window xwindow); Window xwindow);
@ -55,6 +72,7 @@ gboolean meta_x11_display_xwindow_is_a_no_focus_window (MetaX11Display *x11_disp
* whether a window should be allowed to be focused should depend * whether a window should be allowed to be focused should depend
* on user_time events (see bug 167358, comment 15 in particular) * on user_time events (see bug 167358, comment 15 in particular)
*/ */
META_EXPORT
void meta_x11_display_set_input_focus_window (MetaX11Display *x11_display, void meta_x11_display_set_input_focus_window (MetaX11Display *x11_display,
MetaWindow *window, MetaWindow *window,
gboolean focus_frame, gboolean focus_frame,
@ -64,6 +82,7 @@ void meta_x11_display_set_input_focus_window (MetaX11Display *x11_display,
* designated no_focus_window should be focused, but is otherwise the * designated no_focus_window should be focused, but is otherwise the
* same as meta_display_set_input_focus_window * same as meta_display_set_input_focus_window
*/ */
META_EXPORT
void meta_x11_display_focus_the_no_focus_window (MetaX11Display *x11_display, void meta_x11_display_focus_the_no_focus_window (MetaX11Display *x11_display,
guint32 timestamp); guint32 timestamp);

View File

@ -27,10 +27,14 @@
#include <meta/util.h> #include <meta/util.h>
#include <meta/meta-x11-display.h> #include <meta/meta-x11-display.h>
META_EXPORT
void meta_x11_error_trap_push (MetaX11Display *x11_display); void meta_x11_error_trap_push (MetaX11Display *x11_display);
META_EXPORT
void meta_x11_error_trap_pop (MetaX11Display *x11_display); void meta_x11_error_trap_pop (MetaX11Display *x11_display);
/* returns X error code, or 0 for no error */ /* returns X error code, or 0 for no error */
META_EXPORT
int meta_x11_error_trap_pop_with_return (MetaX11Display *x11_display); int meta_x11_error_trap_pop_with_return (MetaX11Display *x11_display);

View File

@ -108,62 +108,129 @@ typedef enum
typedef void (* MetaPrefsChangedFunc) (MetaPreference pref, typedef void (* MetaPrefsChangedFunc) (MetaPreference pref,
gpointer user_data); gpointer user_data);
META_EXPORT
void meta_prefs_add_listener (MetaPrefsChangedFunc func, void meta_prefs_add_listener (MetaPrefsChangedFunc func,
gpointer user_data); gpointer user_data);
META_EXPORT
void meta_prefs_remove_listener (MetaPrefsChangedFunc func, void meta_prefs_remove_listener (MetaPrefsChangedFunc func,
gpointer user_data); gpointer user_data);
META_EXPORT
void meta_prefs_init (void); void meta_prefs_init (void);
META_EXPORT
const char* meta_preference_to_string (MetaPreference pref); const char* meta_preference_to_string (MetaPreference pref);
META_EXPORT
MetaVirtualModifier meta_prefs_get_mouse_button_mods (void); MetaVirtualModifier meta_prefs_get_mouse_button_mods (void);
META_EXPORT
gint meta_prefs_get_mouse_button_resize (void); gint meta_prefs_get_mouse_button_resize (void);
META_EXPORT
gint meta_prefs_get_mouse_button_menu (void); gint meta_prefs_get_mouse_button_menu (void);
META_EXPORT
GDesktopFocusMode meta_prefs_get_focus_mode (void); GDesktopFocusMode meta_prefs_get_focus_mode (void);
META_EXPORT
GDesktopFocusNewWindows meta_prefs_get_focus_new_windows (void); GDesktopFocusNewWindows meta_prefs_get_focus_new_windows (void);
META_EXPORT
gboolean meta_prefs_get_attach_modal_dialogs (void); gboolean meta_prefs_get_attach_modal_dialogs (void);
META_EXPORT
gboolean meta_prefs_get_raise_on_click (void); gboolean meta_prefs_get_raise_on_click (void);
/* returns NULL if GTK default should be used */ /* returns NULL if GTK default should be used */
META_EXPORT
const PangoFontDescription* meta_prefs_get_titlebar_font (void); const PangoFontDescription* meta_prefs_get_titlebar_font (void);
META_EXPORT
int meta_prefs_get_num_workspaces (void); int meta_prefs_get_num_workspaces (void);
META_EXPORT
gboolean meta_prefs_get_dynamic_workspaces (void); gboolean meta_prefs_get_dynamic_workspaces (void);
META_EXPORT
gboolean meta_prefs_get_disable_workarounds (void); gboolean meta_prefs_get_disable_workarounds (void);
META_EXPORT
gboolean meta_prefs_get_auto_raise (void); gboolean meta_prefs_get_auto_raise (void);
META_EXPORT
int meta_prefs_get_auto_raise_delay (void); int meta_prefs_get_auto_raise_delay (void);
META_EXPORT
gboolean meta_prefs_get_focus_change_on_pointer_rest (void); gboolean meta_prefs_get_focus_change_on_pointer_rest (void);
META_EXPORT
gboolean meta_prefs_get_gnome_accessibility (void); gboolean meta_prefs_get_gnome_accessibility (void);
META_EXPORT
gboolean meta_prefs_get_gnome_animations (void); gboolean meta_prefs_get_gnome_animations (void);
META_EXPORT
gboolean meta_prefs_get_edge_tiling (void); gboolean meta_prefs_get_edge_tiling (void);
META_EXPORT
gboolean meta_prefs_get_auto_maximize (void); gboolean meta_prefs_get_auto_maximize (void);
META_EXPORT
gboolean meta_prefs_get_center_new_windows (void); gboolean meta_prefs_get_center_new_windows (void);
META_EXPORT
gboolean meta_prefs_get_show_fallback_app_menu (void); gboolean meta_prefs_get_show_fallback_app_menu (void);
META_EXPORT
void meta_prefs_set_show_fallback_app_menu (gboolean whether); void meta_prefs_set_show_fallback_app_menu (gboolean whether);
META_EXPORT
void meta_prefs_get_button_layout (MetaButtonLayout *button_layout); void meta_prefs_get_button_layout (MetaButtonLayout *button_layout);
/* Double, right, middle click can be configured to any titlebar meta-action */ /* Double, right, middle click can be configured to any titlebar meta-action */
META_EXPORT
GDesktopTitlebarAction meta_prefs_get_action_double_click_titlebar (void); GDesktopTitlebarAction meta_prefs_get_action_double_click_titlebar (void);
META_EXPORT
GDesktopTitlebarAction meta_prefs_get_action_middle_click_titlebar (void); GDesktopTitlebarAction meta_prefs_get_action_middle_click_titlebar (void);
META_EXPORT
GDesktopTitlebarAction meta_prefs_get_action_right_click_titlebar (void); GDesktopTitlebarAction meta_prefs_get_action_right_click_titlebar (void);
META_EXPORT
void meta_prefs_set_num_workspaces (int n_workspaces); void meta_prefs_set_num_workspaces (int n_workspaces);
META_EXPORT
const char* meta_prefs_get_workspace_name (int i); const char* meta_prefs_get_workspace_name (int i);
META_EXPORT
void meta_prefs_change_workspace_name (int i, void meta_prefs_change_workspace_name (int i,
const char *name); const char *name);
META_EXPORT
const char* meta_prefs_get_cursor_theme (void); const char* meta_prefs_get_cursor_theme (void);
META_EXPORT
int meta_prefs_get_cursor_size (void); int meta_prefs_get_cursor_size (void);
META_EXPORT
gboolean meta_prefs_get_compositing_manager (void); gboolean meta_prefs_get_compositing_manager (void);
META_EXPORT
gboolean meta_prefs_get_force_fullscreen (void); gboolean meta_prefs_get_force_fullscreen (void);
META_EXPORT
void meta_prefs_set_force_fullscreen (gboolean whether); void meta_prefs_set_force_fullscreen (gboolean whether);
META_EXPORT
gboolean meta_prefs_get_workspaces_only_on_primary (void); gboolean meta_prefs_get_workspaces_only_on_primary (void);
META_EXPORT
int meta_prefs_get_draggable_border_width (void); int meta_prefs_get_draggable_border_width (void);
META_EXPORT
int meta_prefs_get_drag_threshold (void); int meta_prefs_get_drag_threshold (void);
/** /**
@ -393,12 +460,19 @@ typedef void (* MetaKeyHandlerFunc) (MetaDisplay *display,
MetaKeyBinding *binding, MetaKeyBinding *binding,
gpointer user_data); gpointer user_data);
META_EXPORT
GType meta_key_binding_get_type (void); GType meta_key_binding_get_type (void);
META_EXPORT
MetaKeyBindingAction meta_prefs_get_keybinding_action (const char *name); MetaKeyBindingAction meta_prefs_get_keybinding_action (const char *name);
META_EXPORT
gboolean meta_prefs_get_visual_bell (void); gboolean meta_prefs_get_visual_bell (void);
META_EXPORT
gboolean meta_prefs_bell_is_audible (void); gboolean meta_prefs_bell_is_audible (void);
META_EXPORT
GDesktopVisualBellType meta_prefs_get_visual_bell_type (void); GDesktopVisualBellType meta_prefs_get_visual_bell_type (void);
#endif #endif

View File

@ -30,8 +30,12 @@
*/ */
typedef struct _MetaTheme MetaTheme; typedef struct _MetaTheme MetaTheme;
META_EXPORT
MetaTheme* meta_theme_get_default (void); MetaTheme* meta_theme_get_default (void);
META_EXPORT
MetaTheme* meta_theme_new (void); MetaTheme* meta_theme_new (void);
META_EXPORT
void meta_theme_free (MetaTheme *theme); void meta_theme_free (MetaTheme *theme);
#endif #endif

View File

@ -28,20 +28,35 @@
#include <meta/common.h> #include <meta/common.h>
META_EXPORT
gboolean meta_is_verbose (void); gboolean meta_is_verbose (void);
META_EXPORT
gboolean meta_is_debugging (void); gboolean meta_is_debugging (void);
META_EXPORT
gboolean meta_is_syncing (void); gboolean meta_is_syncing (void);
META_EXPORT
gboolean meta_is_wayland_compositor (void); gboolean meta_is_wayland_compositor (void);
META_EXPORT
void meta_debug_spew_real (const char *format, void meta_debug_spew_real (const char *format,
...) G_GNUC_PRINTF (1, 2); ...) G_GNUC_PRINTF (1, 2);
META_EXPORT
void meta_verbose_real (const char *format, void meta_verbose_real (const char *format,
...) G_GNUC_PRINTF (1, 2); ...) G_GNUC_PRINTF (1, 2);
META_EXPORT
void meta_bug (const char *format, void meta_bug (const char *format,
...) G_GNUC_PRINTF (1, 2); ...) G_GNUC_PRINTF (1, 2);
META_EXPORT
void meta_warning (const char *format, void meta_warning (const char *format,
...) G_GNUC_PRINTF (1, 2); ...) G_GNUC_PRINTF (1, 2);
META_EXPORT
void meta_fatal (const char *format, void meta_fatal (const char *format,
...) G_GNUC_PRINTF (1, 2) G_GNUC_NORETURN G_ANALYZER_NORETURN; ...) G_GNUC_PRINTF (1, 2) G_GNUC_NORETURN G_ANALYZER_NORETURN;
@ -99,28 +114,45 @@ typedef enum
META_DEBUG_DBUS = 1 << 22 META_DEBUG_DBUS = 1 << 22
} MetaDebugTopic; } MetaDebugTopic;
META_EXPORT
void meta_topic_real (MetaDebugTopic topic, void meta_topic_real (MetaDebugTopic topic,
const char *format, const char *format,
...) G_GNUC_PRINTF (2, 3); ...) G_GNUC_PRINTF (2, 3);
META_EXPORT
void meta_add_verbose_topic (MetaDebugTopic topic); void meta_add_verbose_topic (MetaDebugTopic topic);
META_EXPORT
void meta_remove_verbose_topic (MetaDebugTopic topic); void meta_remove_verbose_topic (MetaDebugTopic topic);
META_EXPORT
void meta_push_no_msg_prefix (void); void meta_push_no_msg_prefix (void);
META_EXPORT
void meta_pop_no_msg_prefix (void); void meta_pop_no_msg_prefix (void);
META_EXPORT
gint meta_unsigned_long_equal (gconstpointer v1, gint meta_unsigned_long_equal (gconstpointer v1,
gconstpointer v2); gconstpointer v2);
META_EXPORT
guint meta_unsigned_long_hash (gconstpointer v); guint meta_unsigned_long_hash (gconstpointer v);
META_EXPORT
const char* meta_frame_type_to_string (MetaFrameType type); const char* meta_frame_type_to_string (MetaFrameType type);
META_EXPORT
const char* meta_gravity_to_string (int gravity); const char* meta_gravity_to_string (int gravity);
META_EXPORT
char* meta_external_binding_name_for_action (guint keybinding_action); char* meta_external_binding_name_for_action (guint keybinding_action);
META_EXPORT
char* meta_g_utf8_strndup (const gchar *src, gsize n); char* meta_g_utf8_strndup (const gchar *src, gsize n);
META_EXPORT
void meta_free_gslist_and_elements (GSList *list_to_deep_free); void meta_free_gslist_and_elements (GSList *list_to_deep_free);
META_EXPORT
GPid meta_show_dialog (const char *type, GPid meta_show_dialog (const char *type,
const char *message, const char *message,
const char *timeout, const char *timeout,
@ -175,10 +207,13 @@ typedef enum {
META_LATER_IDLE META_LATER_IDLE
} MetaLaterType; } MetaLaterType;
META_EXPORT
guint meta_later_add (MetaLaterType when, guint meta_later_add (MetaLaterType when,
GSourceFunc func, GSourceFunc func,
gpointer data, gpointer data,
GDestroyNotify notify); GDestroyNotify notify);
META_EXPORT
void meta_later_remove (guint later_id); void meta_later_remove (guint later_id);
typedef enum typedef enum
@ -187,8 +222,7 @@ typedef enum
META_LOCALE_DIRECTION_RTL, META_LOCALE_DIRECTION_RTL,
} MetaLocaleDirection; } MetaLocaleDirection;
META_EXPORT
MetaLocaleDirection meta_get_locale_direction (void); MetaLocaleDirection meta_get_locale_direction (void);
#endif /* META_UTIL_H */ #endif /* META_UTIL_H */

View File

@ -100,167 +100,353 @@ typedef enum {
typedef struct _MetaWindowClass MetaWindowClass; typedef struct _MetaWindowClass MetaWindowClass;
META_EXPORT
GType meta_window_get_type (void); GType meta_window_get_type (void);
META_EXPORT
MetaFrame *meta_window_get_frame (MetaWindow *window); MetaFrame *meta_window_get_frame (MetaWindow *window);
META_EXPORT
gboolean meta_window_has_focus (MetaWindow *window); gboolean meta_window_has_focus (MetaWindow *window);
META_EXPORT
gboolean meta_window_appears_focused (MetaWindow *window); gboolean meta_window_appears_focused (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_shaded (MetaWindow *window); gboolean meta_window_is_shaded (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_override_redirect (MetaWindow *window); gboolean meta_window_is_override_redirect (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_skip_taskbar (MetaWindow *window); gboolean meta_window_is_skip_taskbar (MetaWindow *window);
META_EXPORT
void meta_window_get_buffer_rect (const MetaWindow *window, MetaRectangle *rect); void meta_window_get_buffer_rect (const MetaWindow *window, MetaRectangle *rect);
META_EXPORT
void meta_window_get_frame_rect (const MetaWindow *window, MetaRectangle *rect); void meta_window_get_frame_rect (const MetaWindow *window, MetaRectangle *rect);
META_EXPORT
void meta_window_client_rect_to_frame_rect (MetaWindow *window, void meta_window_client_rect_to_frame_rect (MetaWindow *window,
MetaRectangle *client_rect, MetaRectangle *client_rect,
MetaRectangle *frame_rect); MetaRectangle *frame_rect);
META_EXPORT
void meta_window_frame_rect_to_client_rect (MetaWindow *window, void meta_window_frame_rect_to_client_rect (MetaWindow *window,
MetaRectangle *frame_rect, MetaRectangle *frame_rect,
MetaRectangle *client_rect); MetaRectangle *client_rect);
META_EXPORT
MetaDisplay *meta_window_get_display (MetaWindow *window); MetaDisplay *meta_window_get_display (MetaWindow *window);
META_EXPORT
Window meta_window_get_xwindow (MetaWindow *window); Window meta_window_get_xwindow (MetaWindow *window);
META_EXPORT
MetaWindowType meta_window_get_window_type (MetaWindow *window); MetaWindowType meta_window_get_window_type (MetaWindow *window);
META_EXPORT
MetaWorkspace *meta_window_get_workspace (MetaWindow *window); MetaWorkspace *meta_window_get_workspace (MetaWindow *window);
META_EXPORT
int meta_window_get_monitor (MetaWindow *window); int meta_window_get_monitor (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_on_all_workspaces (MetaWindow *window); gboolean meta_window_is_on_all_workspaces (MetaWindow *window);
META_EXPORT
gboolean meta_window_located_on_workspace (MetaWindow *window, gboolean meta_window_located_on_workspace (MetaWindow *window,
MetaWorkspace *workspace); MetaWorkspace *workspace);
META_EXPORT
gboolean meta_window_is_hidden (MetaWindow *window); gboolean meta_window_is_hidden (MetaWindow *window);
META_EXPORT
void meta_window_activate (MetaWindow *window,guint32 current_time); void meta_window_activate (MetaWindow *window,guint32 current_time);
META_EXPORT
void meta_window_activate_with_workspace (MetaWindow *window, void meta_window_activate_with_workspace (MetaWindow *window,
guint32 current_time, guint32 current_time,
MetaWorkspace *workspace); MetaWorkspace *workspace);
META_EXPORT
const char * meta_window_get_description (MetaWindow *window); const char * meta_window_get_description (MetaWindow *window);
META_EXPORT
const char * meta_window_get_wm_class (MetaWindow *window); const char * meta_window_get_wm_class (MetaWindow *window);
META_EXPORT
const char * meta_window_get_wm_class_instance (MetaWindow *window); const char * meta_window_get_wm_class_instance (MetaWindow *window);
META_EXPORT
gboolean meta_window_showing_on_its_workspace (MetaWindow *window); gboolean meta_window_showing_on_its_workspace (MetaWindow *window);
META_EXPORT
const char * meta_window_get_sandboxed_app_id (MetaWindow *window); const char * meta_window_get_sandboxed_app_id (MetaWindow *window);
META_EXPORT
const char * meta_window_get_gtk_theme_variant (MetaWindow *window); const char * meta_window_get_gtk_theme_variant (MetaWindow *window);
META_EXPORT
const char * meta_window_get_gtk_application_id (MetaWindow *window); const char * meta_window_get_gtk_application_id (MetaWindow *window);
META_EXPORT
const char * meta_window_get_gtk_unique_bus_name (MetaWindow *window); const char * meta_window_get_gtk_unique_bus_name (MetaWindow *window);
META_EXPORT
const char * meta_window_get_gtk_application_object_path (MetaWindow *window); const char * meta_window_get_gtk_application_object_path (MetaWindow *window);
META_EXPORT
const char * meta_window_get_gtk_window_object_path (MetaWindow *window); const char * meta_window_get_gtk_window_object_path (MetaWindow *window);
META_EXPORT
const char * meta_window_get_gtk_app_menu_object_path (MetaWindow *window); const char * meta_window_get_gtk_app_menu_object_path (MetaWindow *window);
META_EXPORT
const char * meta_window_get_gtk_menubar_object_path (MetaWindow *window); const char * meta_window_get_gtk_menubar_object_path (MetaWindow *window);
META_EXPORT
void meta_window_move_frame(MetaWindow *window, gboolean user_op, int root_x_nw, int root_y_nw); void meta_window_move_frame(MetaWindow *window, gboolean user_op, int root_x_nw, int root_y_nw);
META_EXPORT
void meta_window_move_resize_frame (MetaWindow *window, gboolean user_op, int root_x_nw, int root_y_nw, int w, int h); void meta_window_move_resize_frame (MetaWindow *window, gboolean user_op, int root_x_nw, int root_y_nw, int w, int h);
META_EXPORT
void meta_window_move_to_monitor (MetaWindow *window, int monitor); void meta_window_move_to_monitor (MetaWindow *window, int monitor);
META_EXPORT
void meta_window_set_demands_attention (MetaWindow *window); void meta_window_set_demands_attention (MetaWindow *window);
META_EXPORT
void meta_window_unset_demands_attention (MetaWindow *window); void meta_window_unset_demands_attention (MetaWindow *window);
META_EXPORT
const char* meta_window_get_startup_id (MetaWindow *window); const char* meta_window_get_startup_id (MetaWindow *window);
META_EXPORT
void meta_window_change_workspace_by_index (MetaWindow *window, void meta_window_change_workspace_by_index (MetaWindow *window,
gint space_index, gint space_index,
gboolean append); gboolean append);
META_EXPORT
void meta_window_change_workspace (MetaWindow *window, void meta_window_change_workspace (MetaWindow *window,
MetaWorkspace *workspace); MetaWorkspace *workspace);
META_EXPORT
GObject *meta_window_get_compositor_private (MetaWindow *window); GObject *meta_window_get_compositor_private (MetaWindow *window);
META_EXPORT
void meta_window_set_compositor_private (MetaWindow *window, GObject *priv); void meta_window_set_compositor_private (MetaWindow *window, GObject *priv);
META_EXPORT
const char *meta_window_get_role (MetaWindow *window); const char *meta_window_get_role (MetaWindow *window);
META_EXPORT
MetaStackLayer meta_window_get_layer (MetaWindow *window); MetaStackLayer meta_window_get_layer (MetaWindow *window);
META_EXPORT
MetaWindow* meta_window_find_root_ancestor (MetaWindow *window); MetaWindow* meta_window_find_root_ancestor (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_ancestor_of_transient (MetaWindow *window, gboolean meta_window_is_ancestor_of_transient (MetaWindow *window,
MetaWindow *transient); MetaWindow *transient);
typedef gboolean (*MetaWindowForeachFunc) (MetaWindow *window, typedef gboolean (*MetaWindowForeachFunc) (MetaWindow *window,
void *user_data); void *user_data);
META_EXPORT
void meta_window_foreach_transient (MetaWindow *window, void meta_window_foreach_transient (MetaWindow *window,
MetaWindowForeachFunc func, MetaWindowForeachFunc func,
void *user_data); void *user_data);
META_EXPORT
void meta_window_foreach_ancestor (MetaWindow *window, void meta_window_foreach_ancestor (MetaWindow *window,
MetaWindowForeachFunc func, MetaWindowForeachFunc func,
void *user_data); void *user_data);
META_EXPORT
MetaMaximizeFlags meta_window_get_maximized (MetaWindow *window); MetaMaximizeFlags meta_window_get_maximized (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_fullscreen (MetaWindow *window); gboolean meta_window_is_fullscreen (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_screen_sized (MetaWindow *window); gboolean meta_window_is_screen_sized (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_monitor_sized (MetaWindow *window); gboolean meta_window_is_monitor_sized (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_on_primary_monitor (MetaWindow *window); gboolean meta_window_is_on_primary_monitor (MetaWindow *window);
META_EXPORT
gboolean meta_window_requested_bypass_compositor (MetaWindow *window); gboolean meta_window_requested_bypass_compositor (MetaWindow *window);
META_EXPORT
gboolean meta_window_requested_dont_bypass_compositor (MetaWindow *window); gboolean meta_window_requested_dont_bypass_compositor (MetaWindow *window);
META_EXPORT
gboolean meta_window_get_icon_geometry (MetaWindow *window, gboolean meta_window_get_icon_geometry (MetaWindow *window,
MetaRectangle *rect); MetaRectangle *rect);
META_EXPORT
void meta_window_set_icon_geometry (MetaWindow *window, void meta_window_set_icon_geometry (MetaWindow *window,
MetaRectangle *rect); MetaRectangle *rect);
META_EXPORT
void meta_window_maximize (MetaWindow *window, void meta_window_maximize (MetaWindow *window,
MetaMaximizeFlags directions); MetaMaximizeFlags directions);
META_EXPORT
void meta_window_unmaximize (MetaWindow *window, void meta_window_unmaximize (MetaWindow *window,
MetaMaximizeFlags directions); MetaMaximizeFlags directions);
META_EXPORT
void meta_window_minimize (MetaWindow *window); void meta_window_minimize (MetaWindow *window);
META_EXPORT
void meta_window_unminimize (MetaWindow *window); void meta_window_unminimize (MetaWindow *window);
META_EXPORT
void meta_window_raise (MetaWindow *window); void meta_window_raise (MetaWindow *window);
META_EXPORT
void meta_window_lower (MetaWindow *window); void meta_window_lower (MetaWindow *window);
META_EXPORT
const char *meta_window_get_title (MetaWindow *window); const char *meta_window_get_title (MetaWindow *window);
META_EXPORT
MetaWindow *meta_window_get_transient_for (MetaWindow *window); MetaWindow *meta_window_get_transient_for (MetaWindow *window);
META_EXPORT
void meta_window_delete (MetaWindow *window, void meta_window_delete (MetaWindow *window,
guint32 timestamp); guint32 timestamp);
META_EXPORT
guint meta_window_get_stable_sequence (MetaWindow *window); guint meta_window_get_stable_sequence (MetaWindow *window);
META_EXPORT
guint32 meta_window_get_user_time (MetaWindow *window); guint32 meta_window_get_user_time (MetaWindow *window);
META_EXPORT
int meta_window_get_pid (MetaWindow *window); int meta_window_get_pid (MetaWindow *window);
META_EXPORT
const char *meta_window_get_client_machine (MetaWindow *window); const char *meta_window_get_client_machine (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_remote (MetaWindow *window); gboolean meta_window_is_remote (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_attached_dialog (MetaWindow *window); gboolean meta_window_is_attached_dialog (MetaWindow *window);
META_EXPORT
const char *meta_window_get_mutter_hints (MetaWindow *window); const char *meta_window_get_mutter_hints (MetaWindow *window);
META_EXPORT
MetaFrameType meta_window_get_frame_type (MetaWindow *window); MetaFrameType meta_window_get_frame_type (MetaWindow *window);
META_EXPORT
cairo_region_t *meta_window_get_frame_bounds (MetaWindow *window); cairo_region_t *meta_window_get_frame_bounds (MetaWindow *window);
META_EXPORT
MetaWindow *meta_window_get_tile_match (MetaWindow *window); MetaWindow *meta_window_get_tile_match (MetaWindow *window);
META_EXPORT
void meta_window_make_fullscreen (MetaWindow *window); void meta_window_make_fullscreen (MetaWindow *window);
META_EXPORT
void meta_window_unmake_fullscreen (MetaWindow *window); void meta_window_unmake_fullscreen (MetaWindow *window);
META_EXPORT
void meta_window_make_above (MetaWindow *window); void meta_window_make_above (MetaWindow *window);
META_EXPORT
void meta_window_unmake_above (MetaWindow *window); void meta_window_unmake_above (MetaWindow *window);
META_EXPORT
void meta_window_shade (MetaWindow *window, void meta_window_shade (MetaWindow *window,
guint32 timestamp); guint32 timestamp);
META_EXPORT
void meta_window_unshade (MetaWindow *window, void meta_window_unshade (MetaWindow *window,
guint32 timestamp); guint32 timestamp);
META_EXPORT
void meta_window_stick (MetaWindow *window); void meta_window_stick (MetaWindow *window);
META_EXPORT
void meta_window_unstick (MetaWindow *window); void meta_window_unstick (MetaWindow *window);
META_EXPORT
void meta_window_kill (MetaWindow *window); void meta_window_kill (MetaWindow *window);
META_EXPORT
void meta_window_focus (MetaWindow *window, void meta_window_focus (MetaWindow *window,
guint32 timestamp); guint32 timestamp);
META_EXPORT
void meta_window_check_alive (MetaWindow *window, void meta_window_check_alive (MetaWindow *window,
guint32 timestamp); guint32 timestamp);
META_EXPORT
void meta_window_get_work_area_current_monitor (MetaWindow *window, void meta_window_get_work_area_current_monitor (MetaWindow *window,
MetaRectangle *area); MetaRectangle *area);
META_EXPORT
void meta_window_get_work_area_for_monitor (MetaWindow *window, void meta_window_get_work_area_for_monitor (MetaWindow *window,
int which_monitor, int which_monitor,
MetaRectangle *area); MetaRectangle *area);
META_EXPORT
void meta_window_get_work_area_all_monitors (MetaWindow *window, void meta_window_get_work_area_all_monitors (MetaWindow *window,
MetaRectangle *area); MetaRectangle *area);
META_EXPORT
void meta_window_begin_grab_op (MetaWindow *window, void meta_window_begin_grab_op (MetaWindow *window,
MetaGrabOp op, MetaGrabOp op,
gboolean frame_action, gboolean frame_action,
guint32 timestamp); guint32 timestamp);
META_EXPORT
gboolean meta_window_can_maximize (MetaWindow *window); gboolean meta_window_can_maximize (MetaWindow *window);
META_EXPORT
gboolean meta_window_can_minimize (MetaWindow *window); gboolean meta_window_can_minimize (MetaWindow *window);
META_EXPORT
gboolean meta_window_can_shade (MetaWindow *window); gboolean meta_window_can_shade (MetaWindow *window);
META_EXPORT
gboolean meta_window_can_close (MetaWindow *window); gboolean meta_window_can_close (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_always_on_all_workspaces (MetaWindow *window); gboolean meta_window_is_always_on_all_workspaces (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_above (MetaWindow *window); gboolean meta_window_is_above (MetaWindow *window);
META_EXPORT
gboolean meta_window_allows_move (MetaWindow *window); gboolean meta_window_allows_move (MetaWindow *window);
META_EXPORT
gboolean meta_window_allows_resize (MetaWindow *window); gboolean meta_window_allows_resize (MetaWindow *window);
META_EXPORT
gboolean meta_window_is_client_decorated (MetaWindow *window); gboolean meta_window_is_client_decorated (MetaWindow *window);
META_EXPORT
gboolean meta_window_titlebar_is_onscreen (MetaWindow *window); gboolean meta_window_titlebar_is_onscreen (MetaWindow *window);
META_EXPORT
void meta_window_shove_titlebar_onscreen (MetaWindow *window); void meta_window_shove_titlebar_onscreen (MetaWindow *window);
META_EXPORT
uint64_t meta_window_get_id (MetaWindow *window); uint64_t meta_window_get_id (MetaWindow *window);
META_EXPORT
MetaWindowClientType meta_window_get_client_type (MetaWindow *window); MetaWindowClientType meta_window_get_client_type (MetaWindow *window);
#endif #endif

View File

@ -33,24 +33,40 @@
typedef struct _MetaWorkspaceClass MetaWorkspaceClass; typedef struct _MetaWorkspaceClass MetaWorkspaceClass;
META_EXPORT
GType meta_workspace_get_type (void); GType meta_workspace_get_type (void);
META_EXPORT
int meta_workspace_index (MetaWorkspace *workspace); int meta_workspace_index (MetaWorkspace *workspace);
META_EXPORT
MetaDisplay *meta_workspace_get_display (MetaWorkspace *workspace); MetaDisplay *meta_workspace_get_display (MetaWorkspace *workspace);
META_EXPORT
GList* meta_workspace_list_windows (MetaWorkspace *workspace); GList* meta_workspace_list_windows (MetaWorkspace *workspace);
META_EXPORT
void meta_workspace_get_work_area_for_monitor (MetaWorkspace *workspace, void meta_workspace_get_work_area_for_monitor (MetaWorkspace *workspace,
int which_monitor, int which_monitor,
MetaRectangle *area); MetaRectangle *area);
META_EXPORT
void meta_workspace_get_work_area_all_monitors (MetaWorkspace *workspace, void meta_workspace_get_work_area_all_monitors (MetaWorkspace *workspace,
MetaRectangle *area); MetaRectangle *area);
META_EXPORT
void meta_workspace_activate (MetaWorkspace *workspace, guint32 timestamp); void meta_workspace_activate (MetaWorkspace *workspace, guint32 timestamp);
META_EXPORT
void meta_workspace_activate_with_focus (MetaWorkspace *workspace, void meta_workspace_activate_with_focus (MetaWorkspace *workspace,
MetaWindow *focus_this, MetaWindow *focus_this,
guint32 timestamp); guint32 timestamp);
META_EXPORT
void meta_workspace_set_builtin_struts (MetaWorkspace *workspace, void meta_workspace_set_builtin_struts (MetaWorkspace *workspace,
GSList *struts); GSList *struts);
META_EXPORT
MetaWorkspace* meta_workspace_get_neighbor (MetaWorkspace *workspace, MetaWorkspace* meta_workspace_get_neighbor (MetaWorkspace *workspace,
MetaMotionDirection direction); MetaMotionDirection direction);

View File

@ -28,7 +28,7 @@
#include <gdk-pixbuf/gdk-pixbuf.h> #include <gdk-pixbuf/gdk-pixbuf.h>
#include <glib.h> #include <glib.h>
#include "meta/common.h" #include "core/util-private.h"
#include "meta/types.h" #include "meta/types.h"
typedef struct _MetaUI MetaUI; typedef struct _MetaUI MetaUI;
@ -71,6 +71,8 @@ gboolean meta_ui_window_should_not_cause_focus (Display *xdisplay,
gboolean meta_ui_window_is_widget (MetaUI *ui, gboolean meta_ui_window_is_widget (MetaUI *ui,
Window xwindow); Window xwindow);
META_EXPORT_TEST
gboolean meta_ui_window_is_dummy (MetaUI *ui, gboolean meta_ui_window_is_dummy (MetaUI *ui,
Window xwindow); Window xwindow);

View File

@ -24,50 +24,70 @@
#define META_WAYLAND_H #define META_WAYLAND_H
#include "clutter/clutter.h" #include "clutter/clutter.h"
#include "core/util-private.h"
#include "meta/types.h" #include "meta/types.h"
#include "wayland/meta-wayland-types.h" #include "wayland/meta-wayland-types.h"
META_EXPORT_TEST
void meta_wayland_override_display_name (const char *display_name); void meta_wayland_override_display_name (const char *display_name);
META_EXPORT_TEST
void meta_wayland_pre_clutter_init (void); void meta_wayland_pre_clutter_init (void);
META_EXPORT_TEST
void meta_wayland_init (void); void meta_wayland_init (void);
META_EXPORT_TEST
void meta_wayland_finalize (void); void meta_wayland_finalize (void);
/* We maintain a singleton MetaWaylandCompositor which can be got at via this /* We maintain a singleton MetaWaylandCompositor which can be got at via this
* API after meta_wayland_init() has been called. */ * API after meta_wayland_init() has been called. */
META_EXPORT_TEST
MetaWaylandCompositor *meta_wayland_compositor_get_default (void); MetaWaylandCompositor *meta_wayland_compositor_get_default (void);
META_EXPORT_TEST
void meta_wayland_compositor_update (MetaWaylandCompositor *compositor, void meta_wayland_compositor_update (MetaWaylandCompositor *compositor,
const ClutterEvent *event); const ClutterEvent *event);
META_EXPORT_TEST
gboolean meta_wayland_compositor_handle_event (MetaWaylandCompositor *compositor, gboolean meta_wayland_compositor_handle_event (MetaWaylandCompositor *compositor,
const ClutterEvent *event); const ClutterEvent *event);
META_EXPORT_TEST
void meta_wayland_compositor_update_key_state (MetaWaylandCompositor *compositor, void meta_wayland_compositor_update_key_state (MetaWaylandCompositor *compositor,
char *key_vector, char *key_vector,
int key_vector_len, int key_vector_len,
int offset); int offset);
META_EXPORT_TEST
void meta_wayland_compositor_repick (MetaWaylandCompositor *compositor); void meta_wayland_compositor_repick (MetaWaylandCompositor *compositor);
META_EXPORT_TEST
void meta_wayland_compositor_set_input_focus (MetaWaylandCompositor *compositor, void meta_wayland_compositor_set_input_focus (MetaWaylandCompositor *compositor,
MetaWindow *window); MetaWindow *window);
META_EXPORT_TEST
void meta_wayland_compositor_paint_finished (MetaWaylandCompositor *compositor); void meta_wayland_compositor_paint_finished (MetaWaylandCompositor *compositor);
META_EXPORT_TEST
void meta_wayland_compositor_destroy_frame_callbacks (MetaWaylandCompositor *compositor, void meta_wayland_compositor_destroy_frame_callbacks (MetaWaylandCompositor *compositor,
MetaWaylandSurface *surface); MetaWaylandSurface *surface);
META_EXPORT_TEST
const char *meta_wayland_get_wayland_display_name (MetaWaylandCompositor *compositor); const char *meta_wayland_get_wayland_display_name (MetaWaylandCompositor *compositor);
META_EXPORT_TEST
const char *meta_wayland_get_xwayland_display_name (MetaWaylandCompositor *compositor); const char *meta_wayland_get_xwayland_display_name (MetaWaylandCompositor *compositor);
META_EXPORT_TEST
void meta_wayland_compositor_restore_shortcuts (MetaWaylandCompositor *compositor, void meta_wayland_compositor_restore_shortcuts (MetaWaylandCompositor *compositor,
ClutterInputDevice *source); ClutterInputDevice *source);
META_EXPORT_TEST
gboolean meta_wayland_compositor_is_shortcuts_inhibited (MetaWaylandCompositor *compositor, gboolean meta_wayland_compositor_is_shortcuts_inhibited (MetaWaylandCompositor *compositor,
ClutterInputDevice *source); ClutterInputDevice *source);
META_EXPORT_TEST
void meta_wayland_compositor_flush_clients (MetaWaylandCompositor *compositor); void meta_wayland_compositor_flush_clients (MetaWaylandCompositor *compositor);
META_EXPORT_TEST
void meta_wayland_compositor_schedule_surface_association (MetaWaylandCompositor *compositor, void meta_wayland_compositor_schedule_surface_association (MetaWaylandCompositor *compositor,
int id, int id,
MetaWindow *window); MetaWindow *window);
META_EXPORT_TEST
void meta_wayland_compositor_notify_surface_id (MetaWaylandCompositor *compositor, void meta_wayland_compositor_notify_surface_id (MetaWaylandCompositor *compositor,
int id, int id,
MetaWaylandSurface *surface); MetaWaylandSurface *surface);

View File

@ -27,9 +27,11 @@
#include <glib.h> #include <glib.h>
#include "core/util-private.h"
#include "meta/types.h" #include "meta/types.h"
#include "wayland/meta-wayland-types.h" #include "wayland/meta-wayland-types.h"
META_EXPORT_TEST
void void
meta_xwayland_override_display_number (int number); meta_xwayland_override_display_number (int number);

View File

@ -184,6 +184,7 @@ void meta_x11_display_unregister_sync_alarm (MetaX11Display *x11_display,
gboolean meta_x11_display_process_barrier_xevent (MetaX11Display *x11_display, gboolean meta_x11_display_process_barrier_xevent (MetaX11Display *x11_display,
XIEvent *event); XIEvent *event);
META_EXPORT
void meta_x11_display_set_alarm_filter (MetaX11Display *x11_display, void meta_x11_display_set_alarm_filter (MetaX11Display *x11_display,
MetaAlarmFilter filter, MetaAlarmFilter filter,
gpointer data); gpointer data);