isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-21 15:40:41 -05:00
Code Issues Packages Projects Releases Wiki Activity

meta: Hide libmutter symbols by default and selectively export them

Browse Source 
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/backends/meta-backend-private.h
View File

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

5
src/backends/meta-crtc.h
View File

@ -24,6 +24,7 @@
#include "backends/meta-backend-types.h"
#include "backends/meta-monitor-transform.h"
#include "core/util-private.h"
#include "meta/boxes.h"
/* Same as KMS mode flags and X11 randr flags */
@ -90,10 +91,10 @@ struct _MetaCrtcMode
};
#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 ())
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);

11
src/backends/meta-gpu.h
View File

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

3
src/backends/meta-logical-monitor.h
View File

@ -27,6 +27,7 @@
#include "backends/meta-monitor.h"
#include "backends/meta-monitor-config-manager.h"
#include "backends/meta-monitor-manager-private.h"
#include "core/util-private.h"
#include "meta/boxes.h"
#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,
MetaMonitor *monitor);
META_EXPORT_TEST
gboolean meta_logical_monitor_is_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);
META_EXPORT_TEST
GList * meta_logical_monitor_get_monitors (MetaLogicalMonitor *logical_monitor);
gboolean meta_logical_monitor_has_neighbor (MetaLogicalMonitor *logical_monitor,

32
src/backends/meta-monitor-config-manager.h
View File

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

3
src/backends/meta-monitor-config-migration.h
View File

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

7
src/backends/meta-monitor-config-store.h
View File

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

19
src/backends/meta-monitor-manager-private.h
View File

@ -30,6 +30,7 @@
#include "backends/meta-cursor.h"
#include "backends/meta-display-config-shared.h"
#include "backends/meta-monitor-transform.h"
#include "core/util-private.h"
#include "meta/display.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);
META_EXPORT_TEST
void meta_monitor_manager_rebuild (MetaMonitorManager *manager,
MetaMonitorsConfig *config);
META_EXPORT_TEST
void meta_monitor_manager_rebuild_derived (MetaMonitorManager *manager,
MetaMonitorsConfig *config);
META_EXPORT_TEST
int meta_monitor_manager_get_num_logical_monitors (MetaMonitorManager *manager);
META_EXPORT_TEST
GList * meta_monitor_manager_get_logical_monitors (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,
const char *connector);
META_EXPORT_TEST
GList * meta_monitor_manager_get_monitors (MetaMonitorManager *manager);
META_EXPORT_TEST
void meta_monitor_manager_add_gpu (MetaMonitorManager *manager,
MetaGpu *gpu);
META_EXPORT_TEST
GList * meta_monitor_manager_get_gpus (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_monitor_manager_has_hotplug_mode_update (MetaMonitorManager *manager);
META_EXPORT_TEST
void meta_monitor_manager_read_current_state (MetaMonitorManager *manager);
META_EXPORT_TEST
void meta_monitor_manager_on_hotplug (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,
MetaMonitorTransform transform);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_manager_ensure_configured (MetaMonitorManager *manager);
META_EXPORT_TEST
void meta_monitor_manager_update_logical_state (MetaMonitorManager *manager,
MetaMonitorsConfig *config);
META_EXPORT_TEST
void meta_monitor_manager_update_logical_state_derived (MetaMonitorManager *manager,
MetaMonitorsConfig *config);
META_EXPORT_TEST
void meta_monitor_manager_lid_is_closed_changed (MetaMonitorManager *manager);
gboolean meta_monitor_manager_is_headless (MetaMonitorManager *manager);

48
src/backends/meta-monitor.h
View File

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

7
src/backends/meta-output.h
View File

@ -24,6 +24,7 @@
#include "backends/meta-backend-types.h"
#include "backends/meta-gpu.h"
#include "core/util-private.h"
struct _MetaTileInfo
{
@ -116,15 +117,19 @@ struct _MetaOutput
};
#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);
META_EXPORT_TEST
void meta_output_assign_crtc (MetaOutput *output,
MetaCrtc *crtc);
META_EXPORT_TEST
void meta_output_unassign_crtc (MetaOutput *output);
META_EXPORT_TEST
MetaCrtc * meta_output_get_assigned_crtc (MetaOutput *output);
#endif /* META_OUTPUT_H */

2
src/backends/meta-renderer.h
View File

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

4
src/backends/meta-settings-private.h
View File

@ -26,6 +26,7 @@
#include "meta/meta-settings.h"
#include "meta/types.h"
#include "core/util-private.h"
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,
int *scaing_factor);
META_EXPORT_TEST
gboolean meta_settings_is_experimental_feature_enabled (MetaSettings *settings,
MetaExperimentalFeature feature);
MetaExperimentalFeature meta_settings_get_experimental_features (MetaSettings *settings);
META_EXPORT_TEST
void meta_settings_override_experimental_features (MetaSettings *settings);
META_EXPORT_TEST
void meta_settings_enable_experimental_feature (MetaSettings *settings,
MetaExperimentalFeature feature);

2
src/backends/x11/nested/meta-backend-x11-nested.h
View File

@ -23,8 +23,10 @@
#include <glib-object.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 ())
META_EXPORT_TEST
G_DECLARE_DERIVABLE_TYPE (MetaBackendX11Nested, meta_backend_x11_nested,
META, BACKEND_X11_NESTED, MetaBackendX11)

2
src/compositor/meta-plugin-manager.h
View File

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

22
src/core/boxes-private.h
View File

@ -25,6 +25,7 @@
#include <glib-object.h>
#include "backends/meta-backend-types.h"
#include "core/util-private.h"
#include "meta/boxes.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
* operation if you muck with old_rect just right).
*/
META_EXPORT_TEST
void meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect,
MetaRectangle *rect,
int gravity,
@ -92,6 +94,7 @@ void meta_rectangle_resize_with_gravity (const MetaRectangle *old_rect,
*
* See boxes.c for more details.
*/
META_EXPORT_TEST
GList* meta_rectangle_get_minimal_spanning_set_for_region (
const MetaRectangle *basic_rect,
const GSList *all_struts);
@ -118,6 +121,7 @@ GList* meta_rectangle_expand_region_conditionally (
* overlapping struts oriented orthognal to the expansion direction. (Think
* horizontal or vertical maximization)
*/
META_EXPORT_TEST
void meta_rectangle_expand_to_avoiding_struts (
MetaRectangle *rect,
const MetaRectangle *expand_to,
@ -131,18 +135,24 @@ void meta_rectangle_expand_to_avoiding_struts (
* or
* meta_rectangle_find_nonintersected_monitor_edges()
*/
META_EXPORT_TEST
void meta_rectangle_free_list_and_elements (GList *filled_list);
/* could_fit_in_region determines whether one of the spanning_rects is
* big enough to contain rect. contained_in_region checks whether one
* actually contains it.
*/
META_EXPORT_TEST
gboolean meta_rectangle_could_fit_in_region (
const GList *spanning_rects,
const MetaRectangle *rect);
META_EXPORT_TEST
gboolean meta_rectangle_contained_in_region (
const GList *spanning_rects,
const MetaRectangle *rect);
META_EXPORT_TEST
gboolean meta_rectangle_overlaps_with_region (
const GList *spanning_rects,
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,
* but make it no smaller than min_size.
*/
META_EXPORT_TEST
void meta_rectangle_clamp_to_fit_into_region (
const GList *spanning_rects,
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
* it overlaps with at least one of them
*/
META_EXPORT_TEST
void meta_rectangle_clip_to_region (const GList *spanning_rects,
FixedDirections fixed_directions,
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
* one of them.
*/
META_EXPORT_TEST
void meta_rectangle_shove_into_region(
const GList *spanning_rects,
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
* range between two sizes that are all candidates.
*/
META_EXPORT_TEST
void meta_rectangle_find_linepoint_closest_to_point (double x1, double y1,
double x2, double y2,
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
* nonzero-width dimension of the edge.
*/
META_EXPORT_TEST
gboolean meta_rectangle_edge_aligns (const MetaRectangle *rect,
const MetaEdge *edge);
/* Compare two edges, so that sorting functions can put a list of edges in
* canonical order.
*/
META_EXPORT_TEST
gint meta_rectangle_edge_cmp (gconstpointer a, gconstpointer b);
/* 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,
* etc., but rather compares only upon location.
*/
META_EXPORT_TEST
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
@ -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
* MetaEdgeRect's.
*/
META_EXPORT_TEST
GList* meta_rectangle_find_onscreen_edges (const MetaRectangle *basic_rect,
const GSList *all_struts);
/* Finds edges between adjacent monitors which are not covered by the given
* struts.
*/
META_EXPORT_TEST
GList* meta_rectangle_find_nonintersected_monitor_edges (
const GList *monitor_rects,
const GSList *all_struts);
META_EXPORT_TEST
gboolean meta_rectangle_is_adjecent_to (MetaRectangle *rect,
MetaRectangle *other);
META_EXPORT_TEST
void meta_rectangle_scale_double (const MetaRectangle *rect,
double scale,
MetaRoundingStrategy rounding_strategy,
@ -246,6 +267,7 @@ meta_rectangle_to_clutter_rect (MetaRectangle *rect)
};
}
META_EXPORT_TEST
void meta_rectangle_transform (const MetaRectangle *rect,
MetaMonitorTransform transform,
int width,

6
src/core/display-private.h
View File

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

3
src/core/main-private.h
View File

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

2
src/core/stack-tracker.h
View File

@ -34,6 +34,7 @@
#ifndef META_STACK_TRACKER_H
#define META_STACK_TRACKER_H
#include "core/util-private.h"
#include "meta/display.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,
XConfigureEvent *event);
META_EXPORT_TEST
void meta_stack_tracker_get_stack (MetaStackTracker *tracker,
guint64 **windows,
int *n_entries);

3
src/core/startup-notification-private.h
View File

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

5
src/core/util-private.h
View File

@ -28,6 +28,11 @@
#include <glib/gi18n-lib.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_debugging (gboolean setting);

1
src/meson.build
View File

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

8
src/meta/barrier.h
View File

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

18
src/meta/boxes.h
View File

@ -93,23 +93,34 @@ struct _MetaEdge
MetaEdgeType edge_type;
};
META_EXPORT
GType meta_rectangle_get_type (void);
META_EXPORT
MetaRectangle *meta_rectangle_copy (const MetaRectangle *rect);
META_EXPORT
void meta_rectangle_free (MetaRectangle *rect);
/* 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);
/* Basic comparison functions */
META_EXPORT
int meta_rectangle_area (const MetaRectangle *rect);
META_EXPORT
gboolean meta_rectangle_intersect (const MetaRectangle *src1,
const MetaRectangle *src2,
MetaRectangle *dest);
META_EXPORT
gboolean meta_rectangle_equal (const MetaRectangle *src1,
const MetaRectangle *src2);
/* Find the bounding box of the union of two rectangles */
META_EXPORT
void meta_rectangle_union (const MetaRectangle *rect1,
const MetaRectangle *rect2,
MetaRectangle *dest);
@ -117,6 +128,7 @@ void meta_rectangle_union (const MetaRectangle *rect1,
/* overlap is similar to intersect but doesn't provide location of
* intersection information.
*/
META_EXPORT
gboolean meta_rectangle_overlap (const MetaRectangle *rect1,
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
* overlap?" horiz_overlap is similar.
*/
META_EXPORT
gboolean meta_rectangle_vert_overlap (const MetaRectangle *rect1,
const MetaRectangle *rect2);
META_EXPORT
gboolean meta_rectangle_horiz_overlap (const MetaRectangle *rect1,
const MetaRectangle *rect2);
/* could_fit_rect determines whether "outer_rect" is big enough to contain
* inner_rect. contains_rect checks whether it actually contains it.
*/
META_EXPORT
gboolean meta_rectangle_could_fit_rect (const MetaRectangle *outer_rect,
const MetaRectangle *inner_rect);
META_EXPORT
gboolean meta_rectangle_contains_rect (const MetaRectangle *outer_rect,
const MetaRectangle *inner_rect);

3
src/meta/common.h
View File

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

21
src/meta/compositor-mutter.h
View File

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

37
src/meta/compositor.h
View File

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

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

14
src/meta/group.h
View File

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

10
src/meta/keybindings.h
View File

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

21
src/meta/main.h
View File

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

9
src/meta/meta-backend.h
View File

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

7
src/meta/meta-background-actor.h
View File

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

5
src/meta/meta-background-group.h
View File

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

13
src/meta/meta-background-image.h
View File

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

11
src/meta/meta-background.h
View File

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

9
src/meta/meta-close-dialog.h
View File

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

9
src/meta/meta-cursor-tracker.h
View File

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

5
src/meta/meta-dnd.h
View File

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

3
src/meta/meta-enum-types.h.in
View File

@ -3,6 +3,7 @@
#define __META_ENUM_TYPES_H__
#include <glib-object.h>
#include <meta/common.h>
G_BEGIN_DECLS
@ -19,7 +20,7 @@ G_END_DECLS
/*** END file-tail ***/
/*** 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())
/*** END value-header ***/

9
src/meta/meta-idle-monitor.h
View File

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

6
src/meta/meta-inhibit-shortcuts-dialog.h
View File

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

4
src/meta/meta-launch-context.h
View File

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

8
src/meta/meta-monitor-manager.h
View File

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

14
src/meta/meta-plugin.h
View File

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

7
src/meta/meta-remote-access-controller.h
View File

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

5
src/meta/meta-settings.h
View File

@ -22,10 +22,13 @@
#ifndef 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);
META_EXPORT
int meta_settings_get_font_dpi (MetaSettings *settings);
#endif /* META_SETTINGS_H */

17
src/meta/meta-shadow-factory.h
View File

@ -29,6 +29,7 @@
#include "cogl/cogl.h"
#include "meta/meta-window-shape.h"
META_EXPORT
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 ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaShadowFactory,
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
* share the same MetaShadow.
*/
META_EXPORT
MetaShadowFactory *meta_shadow_factory_get_default (void);
META_EXPORT
void meta_shadow_factory_set_params (MetaShadowFactory *factory,
const char *class_name,
gboolean focused,
MetaShadowParams *params);
META_EXPORT
void meta_shadow_factory_get_params (MetaShadowFactory *factory,
const char *class_name,
gboolean focused,
@ -90,8 +96,13 @@ void meta_shadow_factory_get_params (MetaShadowFactory *factory,
*/
typedef struct _MetaShadow MetaShadow;
META_EXPORT
MetaShadow *meta_shadow_ref (MetaShadow *shadow);
META_EXPORT
void meta_shadow_unref (MetaShadow *shadow);
META_EXPORT
void meta_shadow_paint (MetaShadow *shadow,
CoglFramebuffer *framebuffer,
int window_x,
@ -101,6 +112,8 @@ void meta_shadow_paint (MetaShadow *shadow,
guint8 opacity,
cairo_region_t *clip,
gboolean clip_strictly);
META_EXPORT
void meta_shadow_get_bounds (MetaShadow *shadow,
int window_x,
int window_y,
@ -108,8 +121,10 @@ void meta_shadow_get_bounds (MetaShadow *shadow,
int window_height,
cairo_rectangle_int_t *bounds);
META_EXPORT
MetaShadowFactory *meta_shadow_factory_new (void);
META_EXPORT
MetaShadow *meta_shadow_factory_get_shadow (MetaShadowFactory *factory,
MetaWindowShape *shape,
int width,

10
src/meta/meta-shaped-texture.h
View File

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

7
src/meta/meta-sound-player.h
View File

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

2
src/meta/meta-stage.h
View File

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

18
src/meta/meta-startup-notification.h
View File

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

11
src/meta/meta-window-actor.h
View File

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

2
src/meta/meta-window-group.h
View File

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

16
src/meta/meta-window-shape.h
View File

@ -26,6 +26,9 @@
#include <cairo.h>
#include <glib-object.h>
#include <meta/common.h>
META_EXPORT
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;
META_EXPORT
MetaWindowShape * meta_window_shape_new (cairo_region_t *region);
META_EXPORT
MetaWindowShape * meta_window_shape_ref (MetaWindowShape *shape);
META_EXPORT
void meta_window_shape_unref (MetaWindowShape *shape);
META_EXPORT
guint meta_window_shape_hash (MetaWindowShape *shape);
META_EXPORT
gboolean meta_window_shape_equal (MetaWindowShape *shape_a,
MetaWindowShape *shape_b);
META_EXPORT
void meta_window_shape_get_borders (MetaWindowShape *shape,
int *border_top,
int *border_right,
int *border_bottom,
int *border_left);
META_EXPORT
cairo_region_t *meta_window_shape_to_region (MetaWindowShape *shape,
int center_width,
int center_height);

10
src/meta/meta-workspace-manager.h
View File

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

19
src/meta/meta-x11-display.h
View File

@ -28,21 +28,38 @@
#include <meta/types.h>
#define META_TYPE_X11_DISPLAY (meta_x11_display_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaX11Display, meta_x11_display, META, X11_DISPLAY, GObject)
META_EXPORT
gboolean meta_x11_init_gdk_display (GError **error);
META_EXPORT
int meta_x11_display_get_screen_number (MetaX11Display *x11_display);
META_EXPORT
Display *meta_x11_display_get_xdisplay (MetaX11Display *x11_display);
META_EXPORT
Window meta_x11_display_get_xroot (MetaX11Display *x11_display);
META_EXPORT
int meta_x11_display_get_xinput_opcode (MetaX11Display *x11_display);
META_EXPORT
int meta_x11_display_get_damage_event_base (MetaX11Display *x11_display);
META_EXPORT
int meta_x11_display_get_shape_event_base (MetaX11Display *x11_display);
META_EXPORT
gboolean meta_x11_display_has_shape (MetaX11Display *x11_display);
META_EXPORT
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,
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
* on user_time events (see bug 167358, comment 15 in particular)
*/
META_EXPORT
void meta_x11_display_set_input_focus_window (MetaX11Display *x11_display,
MetaWindow *window,
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
* same as meta_display_set_input_focus_window
*/
META_EXPORT
void meta_x11_display_focus_the_no_focus_window (MetaX11Display *x11_display,
guint32 timestamp);

4
src/meta/meta-x11-errors.h
View File

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

74
src/meta/prefs.h
View File

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

4
src/meta/theme.h
View File

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

38
src/meta/util.h
View File

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

186
src/meta/window.h
View File

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

16
src/meta/workspace.h
View File

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

4
src/ui/ui.h
View File

@ -28,7 +28,7 @@
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <glib.h>
#include "meta/common.h"
#include "core/util-private.h"
#include "meta/types.h"
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,
Window xwindow);
META_EXPORT_TEST
gboolean meta_ui_window_is_dummy (MetaUI *ui,
Window xwindow);

20
src/wayland/meta-wayland.h
View File

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

2
src/wayland/meta-xwayland.h
View File

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

1
src/x11/meta-x11-display-private.h
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,
XIEvent *event);
META_EXPORT
void meta_x11_display_set_alarm_filter (MetaX11Display *x11_display,
MetaAlarmFilter filter,
gpointer data);