isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2025-02-17 05:44:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename MetaMonitorInfo MetaLogicalMonitor

Browse Source 
In preparation for further refactorizations, rename the MetaMonitorInfo
struct to MetaLogicalMonitor. Eventually, part of MetaLogicalMonitor
will be split into a MetaMonitor type.

https://bugzilla.gnome.org/show_bug.cgi?id=777732
This commit is contained in:
Jonas Ådahl 2016-11-25 14:31:38 +08:00
parent e1b10769e5
commit 842ff5d6aa
31 changed files with 515 additions and 462 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/backends/meta-backend.c
View File

@ -114,11 +114,17 @@ static void
center_pointer (MetaBackend *backend) center_pointer (MetaBackend *backend)
{ {
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend); MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
MetaMonitorInfo *monitors, *primary; MetaMonitorManager *monitor_manager = priv->monitor_manager;
guint n_monitors; MetaLogicalMonitor *logical_monitors, *primary;
unsigned int n_logical_monitors;
int primary_monitor_index;
monitors = meta_monitor_manager_get_monitor_infos (priv->monitor_manager, &n_monitors); logical_monitors =
primary = &monitors[meta_monitor_manager_get_primary_index (priv->monitor_manager)]; meta_monitor_manager_get_logical_monitors (monitor_manager,
&n_logical_monitors);
primary_monitor_index =
meta_monitor_manager_get_primary_index (monitor_manager);
primary = &logical_monitors[primary_monitor_index];
meta_backend_warp_pointer (backend, meta_backend_warp_pointer (backend,
primary->rect.x + primary->rect.width / 2, primary->rect.x + primary->rect.width / 2,
primary->rect.y + primary->rect.height / 2); primary->rect.y + primary->rect.height / 2);

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

@ -125,8 +125,8 @@ MetaInputSettings * meta_input_settings_create (void);
GSettings * meta_input_settings_get_tablet_settings (MetaInputSettings *settings, GSettings * meta_input_settings_get_tablet_settings (MetaInputSettings *settings,
ClutterInputDevice *device); ClutterInputDevice *device);
MetaMonitorInfo * meta_input_settings_get_tablet_monitor_info (MetaInputSettings *settings, MetaLogicalMonitor * meta_input_settings_get_tablet_logical_monitor (MetaInputSettings *settings,
ClutterInputDevice *device); ClutterInputDevice *device);
GDesktopTabletMapping meta_input_settings_get_tablet_mapping (MetaInputSettings *settings, GDesktopTabletMapping meta_input_settings_get_tablet_mapping (MetaInputSettings *settings,
ClutterInputDevice *device); ClutterInputDevice *device);

6
src/backends/meta-input-settings.c
View File

@ -1425,9 +1425,9 @@ meta_input_settings_get_tablet_settings (MetaInputSettings *settings,
return info ? g_object_ref (info->settings) : NULL; return info ? g_object_ref (info->settings) : NULL;
} }
MetaMonitorInfo * MetaLogicalMonitor *
meta_input_settings_get_tablet_monitor_info (MetaInputSettings *settings, meta_input_settings_get_tablet_logical_monitor (MetaInputSettings *settings,
ClutterInputDevice *device) ClutterInputDevice *device)
{ {
MetaInputSettingsPrivate *priv; MetaInputSettingsPrivate *priv;
DeviceMappingInfo *info; DeviceMappingInfo *info;

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

@ -50,10 +50,11 @@
typedef struct _MetaMonitorConfigClass MetaMonitorConfigClass; typedef struct _MetaMonitorConfigClass MetaMonitorConfigClass;
typedef struct _MetaMonitorConfig MetaMonitorConfig; typedef struct _MetaMonitorConfig MetaMonitorConfig;
typedef struct _MetaLogicalMonitor MetaLogicalMonitor;
typedef struct _MetaCRTC MetaCRTC; typedef struct _MetaCRTC MetaCRTC;
typedef struct _MetaOutput MetaOutput; typedef struct _MetaOutput MetaOutput;
typedef struct _MetaMonitorMode MetaMonitorMode; typedef struct _MetaMonitorMode MetaMonitorMode;
typedef struct _MetaMonitorInfo MetaMonitorInfo;
typedef struct _MetaCRTCInfo MetaCRTCInfo; typedef struct _MetaCRTCInfo MetaCRTCInfo;
typedef struct _MetaOutputInfo MetaOutputInfo; typedef struct _MetaOutputInfo MetaOutputInfo;
typedef struct _MetaTileInfo MetaTileInfo; typedef struct _MetaTileInfo MetaTileInfo;
@ -136,7 +137,7 @@ struct _MetaOutput
gboolean is_dirty; gboolean is_dirty;
/* The low-level bits used to build the high-level info /* The low-level bits used to build the high-level info
in MetaMonitorInfo in MetaLogicalMonitor
XXX: flags maybe? XXX: flags maybe?
There is a lot of code that uses MonitorInfo->is_primary, There is a lot of code that uses MonitorInfo->is_primary,
@ -169,7 +170,7 @@ struct _MetaCRTC
/* Only used to build the logical configuration /* Only used to build the logical configuration
from the HW one from the HW one
*/ */
MetaMonitorInfo *logical_monitor; MetaLogicalMonitor *logical_monitor;
/* Used when changing configuration */ /* Used when changing configuration */
gboolean is_dirty; gboolean is_dirty;
@ -198,16 +199,14 @@ struct _MetaMonitorMode
#define META_MAX_OUTPUTS_PER_MONITOR 4 #define META_MAX_OUTPUTS_PER_MONITOR 4
/** /**
* MetaMonitorInfo: * MetaLogicalMonitor:
* *
* A structure with high-level information about monitors. * A structure with high-level information about regions of the whole screen
* This corresponds to a subset of the compositor coordinate space. * output. It corresponds to a subset of the compositor coordinate space, and
* Clones are only reported once, irrespective of the way * may have one or more actual monitors associated with it. No two logical
* they're implemented (two CRTCs configured for the same * monitors will cover the same screen output.
* coordinates or one CRTCs driving two outputs). Inactive CRTCs
* are ignored, and so are disabled outputs.
*/ */
struct _MetaMonitorInfo struct _MetaLogicalMonitor
{ {
int number; int number;
int xinerama_index; int xinerama_index;
@ -294,7 +293,7 @@ struct _MetaMonitorManager
/* Outputs refer to physical screens, /* Outputs refer to physical screens,
CRTCs refer to stuff that can drive outputs CRTCs refer to stuff that can drive outputs
(like encoders, but less tied to the HW), (like encoders, but less tied to the HW),
while monitor_infos refer to logical ones. while logical_monitors refer to logical ones.
*/ */
MetaOutput *outputs; MetaOutput *outputs;
unsigned int n_outputs; unsigned int n_outputs;
@ -305,8 +304,8 @@ struct _MetaMonitorManager
MetaCRTC *crtcs; MetaCRTC *crtcs;
unsigned int n_crtcs; unsigned int n_crtcs;
MetaMonitorInfo *monitor_infos; MetaLogicalMonitor *logical_monitors;
unsigned int n_monitor_infos; unsigned int n_logical_monitors;
int primary_monitor_index; int primary_monitor_index;
int dbus_name_id; int dbus_name_id;
@ -355,7 +354,7 @@ struct _MetaMonitorManagerClass
unsigned short *); unsigned short *);
void (*add_monitor) (MetaMonitorManager *, void (*add_monitor) (MetaMonitorManager *,
MetaMonitorInfo *); MetaLogicalMonitor *);
void (*delete_monitor) (MetaMonitorManager *, void (*delete_monitor) (MetaMonitorManager *,
int monitor_winsys_xid); int monitor_winsys_xid);
@ -364,8 +363,8 @@ struct _MetaMonitorManagerClass
void meta_monitor_manager_rebuild_derived (MetaMonitorManager *manager); void meta_monitor_manager_rebuild_derived (MetaMonitorManager *manager);
MetaMonitorInfo *meta_monitor_manager_get_monitor_infos (MetaMonitorManager *manager, MetaLogicalMonitor *meta_monitor_manager_get_logical_monitors (MetaMonitorManager *manager,
unsigned int *n_infos); unsigned int *n_logical_monitors);
MetaOutput *meta_monitor_manager_get_outputs (MetaMonitorManager *manager, MetaOutput *meta_monitor_manager_get_outputs (MetaMonitorManager *manager,
unsigned int *n_outputs); unsigned int *n_outputs);

211
src/backends/meta-monitor-manager.c
View File

@ -82,35 +82,37 @@ meta_monitor_manager_init (MetaMonitorManager *manager)
*/ */
static void static void
construct_tile_monitor (MetaMonitorManager *manager, construct_tile_monitor (MetaMonitorManager *manager,
GArray *monitor_infos, GArray *logical_monitors,
guint32 tile_group_id) uint32_t tile_group_id)
{ {
MetaMonitorInfo info; MetaLogicalMonitor new_logical_monitor;
unsigned i; unsigned i;
for (i = 0; i < monitor_infos->len; i++) for (i = 0; i < logical_monitors->len; i++)
{ {
MetaMonitorInfo *pinfo = &g_array_index (monitor_infos, MetaMonitorInfo, i); MetaLogicalMonitor *logical_monitor = &g_array_index (logical_monitors,
MetaLogicalMonitor,
i);
if (pinfo->tile_group_id == tile_group_id) if (logical_monitor->tile_group_id == tile_group_id)
return; return;
} }
/* didn't find it */ /* didn't find it */
info.number = monitor_infos->len; new_logical_monitor.number = logical_monitors->len;
info.tile_group_id = tile_group_id; new_logical_monitor.tile_group_id = tile_group_id;
info.is_presentation = FALSE; new_logical_monitor.is_presentation = FALSE;
info.refresh_rate = 0.0; new_logical_monitor.refresh_rate = 0.0;
info.width_mm = 0; new_logical_monitor.width_mm = 0;
info.height_mm = 0; new_logical_monitor.height_mm = 0;
info.is_primary = FALSE; new_logical_monitor.is_primary = FALSE;
info.rect.x = INT_MAX; new_logical_monitor.rect.x = INT_MAX;
info.rect.y = INT_MAX; new_logical_monitor.rect.y = INT_MAX;
info.rect.width = 0; new_logical_monitor.rect.width = 0;
info.rect.height = 0; new_logical_monitor.rect.height = 0;
info.winsys_id = 0; new_logical_monitor.winsys_id = 0;
info.n_outputs = 0; new_logical_monitor.n_outputs = 0;
info.monitor_winsys_xid = 0; new_logical_monitor.monitor_winsys_xid = 0;
for (i = 0; i < manager->n_outputs; i++) for (i = 0; i < manager->n_outputs; i++)
{ {
@ -131,42 +133,42 @@ construct_tile_monitor (MetaMonitorManager *manager,
if (output->tile_info.loc_h_tile == 0 && output->tile_info.loc_v_tile == 0) if (output->tile_info.loc_h_tile == 0 && output->tile_info.loc_v_tile == 0)
{ {
info.refresh_rate = output->crtc->current_mode->refresh_rate; new_logical_monitor.refresh_rate = output->crtc->current_mode->refresh_rate;
info.width_mm = output->width_mm; new_logical_monitor.width_mm = output->width_mm;
info.height_mm = output->height_mm; new_logical_monitor.height_mm = output->height_mm;
info.winsys_id = output->winsys_id; new_logical_monitor.winsys_id = output->winsys_id;
} }
/* hack */ /* hack */
if (output->crtc->rect.x < info.rect.x) if (output->crtc->rect.x < new_logical_monitor.rect.x)
info.rect.x = output->crtc->rect.x; new_logical_monitor.rect.x = output->crtc->rect.x;
if (output->crtc->rect.y < info.rect.y) if (output->crtc->rect.y < new_logical_monitor.rect.y)
info.rect.y = output->crtc->rect.y; new_logical_monitor.rect.y = output->crtc->rect.y;
if (output->tile_info.loc_h_tile == 0) if (output->tile_info.loc_h_tile == 0)
info.rect.height += output->tile_info.tile_h; new_logical_monitor.rect.height += output->tile_info.tile_h;
if (output->tile_info.loc_v_tile == 0) if (output->tile_info.loc_v_tile == 0)
info.rect.width += output->tile_info.tile_w; new_logical_monitor.rect.width += output->tile_info.tile_w;
if (info.n_outputs > META_MAX_OUTPUTS_PER_MONITOR) if (new_logical_monitor.n_outputs > META_MAX_OUTPUTS_PER_MONITOR)
continue; continue;
info.outputs[info.n_outputs++] = output; new_logical_monitor.outputs[new_logical_monitor.n_outputs++] = output;
} }
/* if we don't have a winsys id, i.e. we haven't found tile 0,0 /* if we don't have a winsys id, i.e. we haven't found tile 0,0
don't try and add this to the monitor infos */ don't try and add this to the monitor infos */
if (!info.winsys_id) if (!new_logical_monitor.winsys_id)
return; return;
g_array_append_val (monitor_infos, info); g_array_append_val (logical_monitors, new_logical_monitor);
} }
/* /*
* make_logical_config: * make_logical_config:
* *
* Turn outputs and CRTCs into logical MetaMonitorInfo, * Turn outputs and CRTCs into logical MetaLogicalMonitor,
* that will be used by the core and API layer (MetaScreen * that will be used by the core and API layer (MetaScreen
* and friends) * and friends)
*/ */
@ -174,13 +176,13 @@ static void
make_logical_config (MetaMonitorManager *manager) make_logical_config (MetaMonitorManager *manager)
{ {
MetaMonitorManagerClass *manager_class = META_MONITOR_MANAGER_GET_CLASS (manager); MetaMonitorManagerClass *manager_class = META_MONITOR_MANAGER_GET_CLASS (manager);
GArray *monitor_infos; GArray *logical_monitors;
unsigned int i, j; unsigned int i, j;
monitor_infos = g_array_sized_new (FALSE, TRUE, sizeof (MetaMonitorInfo), logical_monitors = g_array_sized_new (FALSE, TRUE, sizeof (MetaLogicalMonitor),
manager->n_crtcs); manager->n_crtcs);
/* Walk the list of MetaCRTCs, and build a MetaMonitorInfo /* Walk the list of MetaCRTCs, and build a MetaLogicalMonitor
for each of them, unless they reference a rectangle that for each of them, unless they reference a rectangle that
is already there. is already there.
*/ */
@ -190,7 +192,8 @@ make_logical_config (MetaMonitorManager *manager)
MetaOutput *output = &manager->outputs[i]; MetaOutput *output = &manager->outputs[i];
if (output->tile_info.group_id) if (output->tile_info.group_id)
construct_tile_monitor (manager, monitor_infos, output->tile_info.group_id); construct_tile_monitor (manager, logical_monitors,
output->tile_info.group_id);
} }
for (i = 0; i < manager->n_crtcs; i++) for (i = 0; i < manager->n_crtcs; i++)
@ -201,41 +204,43 @@ make_logical_config (MetaMonitorManager *manager)
if (crtc->current_mode == NULL) if (crtc->current_mode == NULL)
continue; continue;
for (j = 0; j < monitor_infos->len; j++) for (j = 0; j < logical_monitors->len; j++)
{ {
MetaMonitorInfo *info = &g_array_index (monitor_infos, MetaMonitorInfo, j); MetaLogicalMonitor *logical_monitor =
if (meta_rectangle_contains_rect (&info->rect, &g_array_index (logical_monitors, MetaLogicalMonitor, j);
if (meta_rectangle_contains_rect (&logical_monitor->rect,
&crtc->rect)) &crtc->rect))
{ {
crtc->logical_monitor = info; crtc->logical_monitor = logical_monitor;
break; break;
} }
} }
if (crtc->logical_monitor == NULL) if (crtc->logical_monitor == NULL)
{ {
MetaMonitorInfo info; MetaLogicalMonitor logical_monitor;
info.number = monitor_infos->len; logical_monitor.number = logical_monitors->len;
info.tile_group_id = 0; logical_monitor.tile_group_id = 0;
info.rect = crtc->rect; logical_monitor.rect = crtc->rect;
info.refresh_rate = crtc->current_mode->refresh_rate; logical_monitor.refresh_rate = crtc->current_mode->refresh_rate;
info.scale = 1; logical_monitor.scale = 1;
info.is_primary = FALSE; logical_monitor.is_primary = FALSE;
/* This starts true because we want /* This starts true because we want
is_presentation only if all outputs are is_presentation only if all outputs are
marked as such (while for primary it's enough marked as such (while for primary it's enough
that any is marked) that any is marked)
*/ */
info.is_presentation = TRUE; logical_monitor.is_presentation = TRUE;
info.in_fullscreen = -1; logical_monitor.in_fullscreen = -1;
info.winsys_id = 0; logical_monitor.winsys_id = 0;
info.n_outputs = 0; logical_monitor.n_outputs = 0;
info.monitor_winsys_xid = 0; logical_monitor.monitor_winsys_xid = 0;
g_array_append_val (monitor_infos, info); g_array_append_val (logical_monitors, logical_monitor);
crtc->logical_monitor = &g_array_index (monitor_infos, MetaMonitorInfo, crtc->logical_monitor = &g_array_index (logical_monitors,
info.number); MetaLogicalMonitor,
logical_monitor.number);
} }
} }
@ -245,7 +250,7 @@ make_logical_config (MetaMonitorManager *manager)
for (i = 0; i < manager->n_outputs; i++) for (i = 0; i < manager->n_outputs; i++)
{ {
MetaOutput *output; MetaOutput *output;
MetaMonitorInfo *info; MetaLogicalMonitor *logical_monitor;
output = &manager->outputs[i]; output = &manager->outputs[i];
@ -259,32 +264,34 @@ make_logical_config (MetaMonitorManager *manager)
/* We must have a logical monitor on every CRTC at this point */ /* We must have a logical monitor on every CRTC at this point */
g_assert (output->crtc->logical_monitor != NULL); g_assert (output->crtc->logical_monitor != NULL);
info = output->crtc->logical_monitor; logical_monitor = output->crtc->logical_monitor;
info->is_primary = info->is_primary || output->is_primary; logical_monitor->is_primary =
info->is_presentation = info->is_presentation && output->is_presentation; logical_monitor->is_primary || output->is_primary;
logical_monitor->is_presentation =
logical_monitor->is_presentation && output->is_presentation;
info->width_mm = output->width_mm; logical_monitor->width_mm = output->width_mm;
info->height_mm = output->height_mm; logical_monitor->height_mm = output->height_mm;
info->outputs[0] = output; logical_monitor->outputs[0] = output;
info->n_outputs = 1; logical_monitor->n_outputs = 1;
info->scale = output->scale; logical_monitor->scale = output->scale;
if (output->is_primary || info->winsys_id == 0) if (output->is_primary || logical_monitor->winsys_id == 0)
info->winsys_id = output->winsys_id; logical_monitor->winsys_id = output->winsys_id;
if (info->is_primary) if (logical_monitor->is_primary)
manager->primary_monitor_index = info->number; manager->primary_monitor_index = logical_monitor->number;
} }
manager->n_monitor_infos = monitor_infos->len; manager->n_logical_monitors = logical_monitors->len;
manager->monitor_infos = (void*)g_array_free (monitor_infos, FALSE); manager->logical_monitors = (void*)g_array_free (logical_monitors, FALSE);
if (manager_class->add_monitor) if (manager_class->add_monitor)
for (i = 0; i < manager->n_monitor_infos; i++) for (i = 0; i < manager->n_logical_monitors; i++)
manager_class->add_monitor (manager, &manager->monitor_infos[i]); manager_class->add_monitor (manager, &manager->logical_monitors[i]);
} }
static void static void
@ -426,7 +433,7 @@ meta_monitor_manager_finalize (GObject *object)
meta_monitor_manager_free_output_array (manager->outputs, manager->n_outputs); meta_monitor_manager_free_output_array (manager->outputs, manager->n_outputs);
meta_monitor_manager_free_mode_array (manager->modes, manager->n_modes); meta_monitor_manager_free_mode_array (manager->modes, manager->n_modes);
meta_monitor_manager_free_crtc_array (manager->crtcs, manager->n_crtcs); meta_monitor_manager_free_crtc_array (manager->crtcs, manager->n_crtcs);
g_free (manager->monitor_infos); g_free (manager->logical_monitors);
G_OBJECT_CLASS (meta_monitor_manager_parent_class)->finalize (object); G_OBJECT_CLASS (meta_monitor_manager_parent_class)->finalize (object);
} }
@ -1283,12 +1290,12 @@ meta_monitor_manager_get (void)
return meta_backend_get_monitor_manager (backend); return meta_backend_get_monitor_manager (backend);
} }
MetaMonitorInfo * MetaLogicalMonitor *
meta_monitor_manager_get_monitor_infos (MetaMonitorManager *manager, meta_monitor_manager_get_logical_monitors (MetaMonitorManager *manager,
unsigned int *n_infos) unsigned int *n_logical_monitors)
{ {
*n_infos = manager->n_monitor_infos; *n_logical_monitors = manager->n_logical_monitors;
return manager->monitor_infos; return manager->logical_monitors;
} }
MetaOutput * MetaOutput *
@ -1380,11 +1387,11 @@ meta_monitor_manager_rebuild_derived (MetaMonitorManager *manager)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = meta_get_backend ();
MetaMonitorManagerClass *manager_class = META_MONITOR_MANAGER_GET_CLASS (manager); MetaMonitorManagerClass *manager_class = META_MONITOR_MANAGER_GET_CLASS (manager);
MetaMonitorInfo *old_monitor_infos; MetaLogicalMonitor *old_logical_monitors;
unsigned old_n_monitor_infos; unsigned old_n_logical_monitors;
unsigned i, j; unsigned i, j;
old_monitor_infos = manager->monitor_infos; old_logical_monitors = manager->logical_monitors;
old_n_monitor_infos = manager->n_monitor_infos; old_n_logical_monitors = manager->n_logical_monitors;
if (manager->in_init) if (manager->in_init)
return; return;
@ -1393,19 +1400,25 @@ meta_monitor_manager_rebuild_derived (MetaMonitorManager *manager)
if (manager_class->delete_monitor) if (manager_class->delete_monitor)
{ {
for (i = 0; i < old_n_monitor_infos; i++) for (i = 0; i < old_n_logical_monitors; i++)
{ {
int old_monitor_winsys_xid =
old_logical_monitors[i].monitor_winsys_xid;
gboolean delete_mon = TRUE; gboolean delete_mon = TRUE;
for (j = 0; j < manager->n_monitor_infos; j++)
for (j = 0; j < manager->n_logical_monitors; j++)
{ {
if (manager->monitor_infos[j].monitor_winsys_xid == old_monitor_infos[i].monitor_winsys_xid) int new_monitor_winsys_xid =
manager->logical_monitors[j].monitor_winsys_xid;
if (new_monitor_winsys_xid == old_monitor_winsys_xid)
{ {
delete_mon = FALSE; delete_mon = FALSE;
break; break;
} }
} }
if (delete_mon) if (delete_mon)
manager_class->delete_monitor (manager, old_monitor_infos[i].monitor_winsys_xid); manager_class->delete_monitor (manager, old_monitor_winsys_xid);
} }
} }
@ -1417,7 +1430,7 @@ meta_monitor_manager_rebuild_derived (MetaMonitorManager *manager)
g_signal_emit_by_name (manager, "monitors-changed"); g_signal_emit_by_name (manager, "monitors-changed");
g_free (old_monitor_infos); g_free (old_logical_monitors);
} }
void void
@ -1576,8 +1589,8 @@ meta_monitor_manager_get_monitor_for_output (MetaMonitorManager *manager,
if (!output || !output->crtc) if (!output || !output->crtc)
return -1; return -1;
for (i = 0; i < manager->n_monitor_infos; i++) for (i = 0; i < manager->n_logical_monitors; i++)
if (meta_rectangle_contains_rect (&manager->monitor_infos[i].rect, if (meta_rectangle_contains_rect (&manager->logical_monitors[i].rect,
&output->crtc->rect)) &output->crtc->rect))
return i; return i;
@ -1591,15 +1604,15 @@ meta_monitor_manager_get_monitor_at_point (MetaMonitorManager *manager,
{ {
unsigned int i; unsigned int i;
for (i = 0; i < manager->n_monitor_infos; i++) for (i = 0; i < manager->n_logical_monitors; i++)
{ {
MetaMonitorInfo *monitor = &manager->monitor_infos[i]; MetaLogicalMonitor *logical_monitor = &manager->logical_monitors[i];
int left, right, top, bottom; int left, right, top, bottom;
left = monitor->rect.x; left = logical_monitor->rect.x;
right = left + monitor->rect.width; right = left + logical_monitor->rect.width;
top = monitor->rect.y; top = logical_monitor->rect.y;
bottom = top + monitor->rect.height; bottom = top + logical_monitor->rect.height;
if ((x >= left) && (x < right) && (y >= top) && (y < bottom)) if ((x >= left) && (x < right) && (y >= top) && (y < bottom))
return i; return i;

18
src/backends/meta-renderer-view.c
View File

@ -39,16 +39,16 @@ struct _MetaRendererView
ClutterStageViewCogl parent; ClutterStageViewCogl parent;
MetaMonitorTransform transform; MetaMonitorTransform transform;
MetaMonitorInfo *monitor_info; MetaLogicalMonitor *logical_monitor;
}; };
G_DEFINE_TYPE (MetaRendererView, meta_renderer_view, G_DEFINE_TYPE (MetaRendererView, meta_renderer_view,
CLUTTER_TYPE_STAGE_VIEW_COGL) CLUTTER_TYPE_STAGE_VIEW_COGL)
MetaMonitorInfo * MetaLogicalMonitor *
meta_renderer_view_get_monitor_info (MetaRendererView *view) meta_renderer_view_get_logical_monitor (MetaRendererView *view)
{ {
return view->monitor_info; return view->logical_monitor;
} }
static void static void
@ -128,7 +128,7 @@ meta_renderer_view_get_property (GObject *object,
switch (prop_id) switch (prop_id)
{ {
case PROP_MONITOR_INFO: case PROP_MONITOR_INFO:
g_value_set_pointer (value, view->monitor_info); g_value_set_pointer (value, view->logical_monitor);
break; break;
case PROP_TRANSFORM: case PROP_TRANSFORM:
g_value_set_uint (value, view->transform); g_value_set_uint (value, view->transform);
@ -150,7 +150,7 @@ meta_renderer_view_set_property (GObject *object,
switch (prop_id) switch (prop_id)
{ {
case PROP_MONITOR_INFO: case PROP_MONITOR_INFO:
view->monitor_info = g_value_get_pointer (value); view->logical_monitor = g_value_get_pointer (value);
break; break;
case PROP_TRANSFORM: case PROP_TRANSFORM:
meta_renderer_view_set_transform (view, g_value_get_uint (value)); meta_renderer_view_set_transform (view, g_value_get_uint (value));
@ -181,9 +181,9 @@ meta_renderer_view_class_init (MetaRendererViewClass *klass)
object_class->set_property = meta_renderer_view_set_property; object_class->set_property = meta_renderer_view_set_property;
obj_props[PROP_MONITOR_INFO] = obj_props[PROP_MONITOR_INFO] =
g_param_spec_pointer ("monitor-info", g_param_spec_pointer ("logical-monitor",
"MetaMonitorInfo", "MetaLogicalMonitor",
"The monitor info of the view", "The logical monitor of the view",
G_PARAM_READWRITE | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS | G_PARAM_STATIC_STRINGS |
G_PARAM_CONSTRUCT_ONLY); G_PARAM_CONSTRUCT_ONLY);

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

@ -26,6 +26,6 @@ G_DECLARE_FINAL_TYPE (MetaRendererView, meta_renderer_view,
META, RENDERER_VIEW, META, RENDERER_VIEW,
ClutterStageViewCogl) ClutterStageViewCogl)
MetaMonitorInfo *meta_renderer_view_get_monitor_info (MetaRendererView *view); MetaLogicalMonitor *meta_renderer_view_get_logical_monitor (MetaRendererView *view);
#endif /* META_RENDERER_VIEW_H */ #endif /* META_RENDERER_VIEW_H */

19
src/backends/meta-renderer.c
View File

@ -43,11 +43,11 @@ meta_renderer_create_cogl_renderer (MetaRenderer *renderer)
} }
static MetaRendererView * static MetaRendererView *
meta_renderer_create_view (MetaRenderer *renderer, meta_renderer_create_view (MetaRenderer *renderer,
MetaMonitorInfo *monitor_info) MetaLogicalMonitor *logical_monitor)
{ {
return META_RENDERER_GET_CLASS (renderer)->create_view (renderer, return META_RENDERER_GET_CLASS (renderer)->create_view (renderer,
monitor_info); logical_monitor);
} }
void void
@ -57,21 +57,22 @@ meta_renderer_rebuild_views (MetaRenderer *renderer)
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = meta_get_backend ();
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaMonitorInfo *monitor_infos; MetaLogicalMonitor *logical_monitors;
unsigned int num_monitor_infos; unsigned int n_logical_monitors;
unsigned int i; unsigned int i;
g_list_free_full (priv->views, g_object_unref); g_list_free_full (priv->views, g_object_unref);
priv->views = NULL; priv->views = NULL;
monitor_infos = meta_monitor_manager_get_monitor_infos (monitor_manager, logical_monitors =
&num_monitor_infos); meta_monitor_manager_get_logical_monitors (monitor_manager,
&n_logical_monitors);
for (i = 0; i < num_monitor_infos; i++) for (i = 0; i < n_logical_monitors; i++)
{ {
MetaRendererView *view; MetaRendererView *view;
view = meta_renderer_create_view (renderer, &monitor_infos[i]); view = meta_renderer_create_view (renderer, &logical_monitors[i]);
priv->views = g_list_append (priv->views, view); priv->views = g_list_append (priv->views, view);
} }
} }

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

@ -40,8 +40,8 @@ struct _MetaRendererClass
GObjectClass parent_class; GObjectClass parent_class;
CoglRenderer * (* create_cogl_renderer) (MetaRenderer *renderer); CoglRenderer * (* create_cogl_renderer) (MetaRenderer *renderer);
MetaRendererView * (* create_view) (MetaRenderer *renderer, MetaRendererView * (* create_view) (MetaRenderer *renderer,
MetaMonitorInfo *monitor_info); MetaLogicalMonitor *logical_monitor);
}; };
CoglRenderer * meta_renderer_create_cogl_renderer (MetaRenderer *renderer); CoglRenderer * meta_renderer_create_cogl_renderer (MetaRenderer *renderer);

32
src/backends/native/meta-backend-native.c
View File

@ -174,10 +174,10 @@ constrain_to_client_constraint (ClutterInputDevice *device,
static void static void
constrain_all_screen_monitors (ClutterInputDevice *device, constrain_all_screen_monitors (ClutterInputDevice *device,
MetaMonitorInfo *monitors, MetaLogicalMonitor *logical_monitors,
unsigned n_monitors, unsigned int n_logical_monitors,
float *x, float *x,
float *y) float *y)
{ {
ClutterPoint current; ClutterPoint current;
unsigned int i; unsigned int i;
@ -189,15 +189,15 @@ constrain_all_screen_monitors (ClutterInputDevice *device,
cy = current.y; cy = current.y;
/* if we're trying to escape, clamp to the CRTC we're coming from */ /* if we're trying to escape, clamp to the CRTC we're coming from */
for (i = 0; i < n_monitors; i++) for (i = 0; i < n_logical_monitors; i++)
{ {
MetaMonitorInfo *monitor = &monitors[i]; MetaLogicalMonitor *logical_monitor = &logical_monitors[i];
int left, right, top, bottom; int left, right, top, bottom;
left = monitor->rect.x; left = logical_monitor->rect.x;
right = left + monitor->rect.width; right = left + logical_monitor->rect.width;
top = monitor->rect.y; top = logical_monitor->rect.y;
bottom = top + monitor->rect.height; bottom = top + logical_monitor->rect.height;
if ((cx >= left) && (cx < right) && (cy >= top) && (cy < bottom)) if ((cx >= left) && (cx < right) && (cy >= top) && (cy < bottom))
{ {
@ -225,8 +225,8 @@ pointer_constrain_callback (ClutterInputDevice *device,
gpointer user_data) gpointer user_data)
{ {
MetaMonitorManager *monitor_manager; MetaMonitorManager *monitor_manager;
MetaMonitorInfo *monitors; MetaLogicalMonitor *logical_monitors;
unsigned int n_monitors; unsigned int n_logical_monitors;
/* Constrain to barriers */ /* Constrain to barriers */
constrain_to_barriers (device, time, new_x, new_y); constrain_to_barriers (device, time, new_x, new_y);
@ -235,14 +235,18 @@ pointer_constrain_callback (ClutterInputDevice *device,
constrain_to_client_constraint (device, time, prev_x, prev_y, new_x, new_y); constrain_to_client_constraint (device, time, prev_x, prev_y, new_x, new_y);
monitor_manager = meta_monitor_manager_get (); monitor_manager = meta_monitor_manager_get ();
monitors = meta_monitor_manager_get_monitor_infos (monitor_manager, &n_monitors); logical_monitors =
meta_monitor_manager_get_logical_monitors (monitor_manager,
&n_logical_monitors);
/* if we're moving inside a monitor, we're fine */ /* if we're moving inside a monitor, we're fine */
if (meta_monitor_manager_get_monitor_at_point (monitor_manager, *new_x, *new_y) >= 0) if (meta_monitor_manager_get_monitor_at_point (monitor_manager, *new_x, *new_y) >= 0)
return; return;
/* if we're trying to escape, clamp to the CRTC we're coming from */ /* if we're trying to escape, clamp to the CRTC we're coming from */
constrain_all_screen_monitors(device, monitors, n_monitors, new_x, new_y); constrain_all_screen_monitors (device,
logical_monitors, n_logical_monitors,
new_x, new_y);
} }
static ClutterBackend * static ClutterBackend *

64
src/backends/native/meta-renderer-native.c
View File

@ -617,7 +617,7 @@ meta_onscreen_native_set_crtc_modes (MetaOnscreenNative *onscreen_native)
META_MONITOR_MANAGER_KMS (monitor_manager); META_MONITOR_MANAGER_KMS (monitor_manager);
MetaRendererView *view = onscreen_native->view; MetaRendererView *view = onscreen_native->view;
uint32_t fb_id = 0; uint32_t fb_id = 0;
MetaMonitorInfo *monitor_info; MetaLogicalMonitor *logical_monitor;
switch (renderer_native->mode) switch (renderer_native->mode)
{ {
@ -633,18 +633,18 @@ meta_onscreen_native_set_crtc_modes (MetaOnscreenNative *onscreen_native)
g_assert (fb_id != 0); g_assert (fb_id != 0);
monitor_info = meta_renderer_view_get_monitor_info (view); logical_monitor = meta_renderer_view_get_logical_monitor (view);
if (monitor_info) if (logical_monitor)
{ {
unsigned int i; unsigned int i;
for (i = 0; i < monitor_manager->n_crtcs; i++) for (i = 0; i < monitor_manager->n_crtcs; i++)
{ {
MetaCRTC *crtc = &monitor_manager->crtcs[i]; MetaCRTC *crtc = &monitor_manager->crtcs[i];
int x = crtc->rect.x - monitor_info->rect.x; int x = crtc->rect.x - logical_monitor->rect.x;
int y = crtc->rect.y - monitor_info->rect.y; int y = crtc->rect.y - logical_monitor->rect.y;
if (crtc->logical_monitor != monitor_info) if (crtc->logical_monitor != logical_monitor)
continue; continue;
meta_monitor_manager_kms_apply_crtc_mode (monitor_manager_kms, meta_monitor_manager_kms_apply_crtc_mode (monitor_manager_kms,
@ -679,7 +679,7 @@ meta_onscreen_native_flip_crtcs (CoglOnscreen *onscreen)
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaRendererView *view = onscreen_native->view; MetaRendererView *view = onscreen_native->view;
GClosure *flip_closure; GClosure *flip_closure;
MetaMonitorInfo *monitor_info; MetaLogicalMonitor *logical_monitor;
gboolean fb_in_use = FALSE; gboolean fb_in_use = FALSE;
/* /*
@ -700,18 +700,18 @@ meta_onscreen_native_flip_crtcs (CoglOnscreen *onscreen)
/* Either flip the CRTC's of the monitor info, if we are drawing just part /* Either flip the CRTC's of the monitor info, if we are drawing just part
* of the stage, or all of the CRTC's if we are drawing the whole stage. * of the stage, or all of the CRTC's if we are drawing the whole stage.
*/ */
monitor_info = meta_renderer_view_get_monitor_info (view); logical_monitor = meta_renderer_view_get_logical_monitor (view);
if (monitor_info) if (logical_monitor)
{ {
unsigned int i; unsigned int i;
for (i = 0; i < monitor_manager->n_crtcs; i++) for (i = 0; i < monitor_manager->n_crtcs; i++)
{ {
MetaCRTC *crtc = &monitor_manager->crtcs[i]; MetaCRTC *crtc = &monitor_manager->crtcs[i];
int x = crtc->rect.x - monitor_info->rect.x; int x = crtc->rect.x - logical_monitor->rect.x;
int y = crtc->rect.y - monitor_info->rect.y; int y = crtc->rect.y - logical_monitor->rect.y;
if (crtc->logical_monitor != monitor_info) if (crtc->logical_monitor != logical_monitor)
continue; continue;
meta_onscreen_native_flip_crtc (onscreen_native, flip_closure, meta_onscreen_native_flip_crtc (onscreen_native, flip_closure,
@ -951,7 +951,7 @@ meta_renderer_native_create_surface_gbm (MetaRendererNative *renderer_native,
#ifdef HAVE_EGL_DEVICE #ifdef HAVE_EGL_DEVICE
static gboolean static gboolean
meta_renderer_native_create_surface_egl_device (MetaRendererNative *renderer_native, meta_renderer_native_create_surface_egl_device (MetaRendererNative *renderer_native,
MetaMonitorInfo *monitor_info, MetaLogicalMonitor *logical_monitor,
int width, int width,
int height, int height,
EGLStreamKHR *out_egl_stream, EGLStreamKHR *out_egl_stream,
@ -974,11 +974,11 @@ meta_renderer_native_create_surface_egl_device (MetaRendererNative *renderer_nat
EGLOutputLayerEXT output_layer; EGLOutputLayerEXT output_layer;
EGLAttrib output_attribs[] = { EGLAttrib output_attribs[] = {
/* /*
* An "monitor_info" may have multiple outputs/crtcs in case its tiled, * An "logical_monitor" may have multiple outputs/crtcs in case its tiled,
* but as far as I can tell, EGL only allows you to pass one crtc_id, so * but as far as I can tell, EGL only allows you to pass one crtc_id, so
* lets pass the first one. * lets pass the first one.
*/ */
EGL_DRM_CRTC_EXT, monitor_info->outputs[0]->crtc->crtc_id, EGL_DRM_CRTC_EXT, logical_monitor->outputs[0]->crtc->crtc_id,
EGL_NONE, EGL_NONE,
}; };
EGLint stream_attribs[] = { EGLint stream_attribs[] = {
@ -1222,7 +1222,7 @@ meta_onscreen_native_allocate (CoglOnscreen *onscreen,
int height; int height;
#ifdef HAVE_EGL_DEVICE #ifdef HAVE_EGL_DEVICE
MetaRendererView *view; MetaRendererView *view;
MetaMonitorInfo *monitor_info; MetaLogicalMonitor *logical_monitor;
EGLStreamKHR egl_stream; EGLStreamKHR egl_stream;
#endif #endif
@ -1258,9 +1258,9 @@ meta_onscreen_native_allocate (CoglOnscreen *onscreen,
return FALSE; return FALSE;
view = onscreen_native->view; view = onscreen_native->view;
monitor_info = meta_renderer_view_get_monitor_info (view); logical_monitor = meta_renderer_view_get_logical_monitor (view);
if (!meta_renderer_native_create_surface_egl_device (renderer_native, if (!meta_renderer_native_create_surface_egl_device (renderer_native,
monitor_info, logical_monitor,
width, height, width, height,
&egl_stream, &egl_stream,
&egl_surface, &egl_surface,
@ -1385,8 +1385,8 @@ meta_renderer_native_queue_modes_reset (MetaRendererNative *renderer_native)
} }
static MetaMonitorTransform static MetaMonitorTransform
meta_renderer_native_get_monitor_info_transform (MetaRenderer *renderer, meta_renderer_native_get_logical_monitor_transform (MetaRenderer *renderer,
MetaMonitorInfo *monitor_info) MetaLogicalMonitor *logical_monitor)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = meta_get_backend ();
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
@ -1394,10 +1394,10 @@ meta_renderer_native_get_monitor_info_transform (MetaRenderer *renderer,
MetaMonitorManagerKms *monitor_manager_kms = MetaMonitorManagerKms *monitor_manager_kms =
META_MONITOR_MANAGER_KMS (monitor_manager); META_MONITOR_MANAGER_KMS (monitor_manager);
g_assert (monitor_info->n_outputs > 0); g_assert (logical_monitor->n_outputs > 0);
return meta_monitor_manager_kms_get_view_transform (monitor_manager_kms, return meta_monitor_manager_kms_get_view_transform (monitor_manager_kms,
monitor_info->outputs[0]->crtc); logical_monitor->outputs[0]->crtc);
} }
static CoglOnscreen * static CoglOnscreen *
@ -1673,8 +1673,8 @@ meta_renderer_native_create_legacy_view (MetaRendererNative *renderer_native)
} }
static MetaRendererView * static MetaRendererView *
meta_renderer_native_create_view (MetaRenderer *renderer, meta_renderer_native_create_view (MetaRenderer *renderer,
MetaMonitorInfo *monitor_info) MetaLogicalMonitor *logical_monitor)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = meta_get_backend ();
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend); ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
@ -1688,14 +1688,14 @@ meta_renderer_native_create_view (MetaRenderer *renderer,
MetaRendererView *view; MetaRendererView *view;
GError *error = NULL; GError *error = NULL;
transform = meta_renderer_native_get_monitor_info_transform (renderer, transform = meta_renderer_native_get_logical_monitor_transform (renderer,
monitor_info); logical_monitor);
onscreen = meta_renderer_native_create_onscreen (META_RENDERER_NATIVE (renderer), onscreen = meta_renderer_native_create_onscreen (META_RENDERER_NATIVE (renderer),
cogl_context, cogl_context,
transform, transform,
monitor_info->rect.width, logical_monitor->rect.width,
monitor_info->rect.height); logical_monitor->rect.height);
if (!onscreen) if (!onscreen)
meta_fatal ("Failed to allocate onscreen framebuffer\n"); meta_fatal ("Failed to allocate onscreen framebuffer\n");
@ -1704,17 +1704,17 @@ meta_renderer_native_create_view (MetaRenderer *renderer,
offscreen = meta_renderer_native_create_offscreen (META_RENDERER_NATIVE (renderer), offscreen = meta_renderer_native_create_offscreen (META_RENDERER_NATIVE (renderer),
cogl_context, cogl_context,
transform, transform,
monitor_info->rect.width, logical_monitor->rect.width,
monitor_info->rect.height); logical_monitor->rect.height);
if (!offscreen) if (!offscreen)
meta_fatal ("Failed to allocate back buffer texture\n"); meta_fatal ("Failed to allocate back buffer texture\n");
} }
view = g_object_new (META_TYPE_RENDERER_VIEW, view = g_object_new (META_TYPE_RENDERER_VIEW,
"layout", &monitor_info->rect, "layout", &logical_monitor->rect,
"framebuffer", onscreen, "framebuffer", onscreen,
"offscreen", offscreen, "offscreen", offscreen,
"monitor-info", monitor_info, "logical-monitor", logical_monitor,
"transform", transform, "transform", transform,
NULL); NULL);
g_clear_pointer (&offscreen, cogl_object_unref); g_clear_pointer (&offscreen, cogl_object_unref);

32
src/backends/x11/meta-monitor-manager-xrandr.c
View File

@ -1332,8 +1332,8 @@ meta_monitor_manager_xrandr_set_crtc_gamma (MetaMonitorManager *manager,
#ifdef HAVE_XRANDR15 #ifdef HAVE_XRANDR15
static void static void
meta_monitor_manager_xrandr_add_monitor(MetaMonitorManager *manager, meta_monitor_manager_xrandr_add_monitor (MetaMonitorManager *manager,
MetaMonitorInfo *monitor) MetaLogicalMonitor *logical_monitor)
{ {
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager); MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
XRRMonitorInfo *m; XRRMonitorInfo *m;
@ -1344,25 +1344,29 @@ meta_monitor_manager_xrandr_add_monitor(MetaMonitorManager *manager,
if (manager_xrandr->has_randr15 == FALSE) if (manager_xrandr->has_randr15 == FALSE)
return; return;
if (monitor->n_outputs <= 1) if (logical_monitor->n_outputs <= 1)
return; return;
if (monitor->outputs[0]->product) if (logical_monitor->outputs[0]->product)
snprintf (name_buf, 40, "%s-%d", monitor->outputs[0]->product, monitor->outputs[0]->tile_info.group_id); snprintf (name_buf, 40, "%s-%d",
logical_monitor->outputs[0]->product,
logical_monitor->outputs[0]->tile_info.group_id);
else else
snprintf (name_buf, 40, "Tiled-%d", monitor->outputs[0]->tile_info.group_id); snprintf (name_buf, 40, "Tiled-%d",
logical_monitor->outputs[0]->tile_info.group_id);
name = XInternAtom (manager_xrandr->xdisplay, name_buf, False); name = XInternAtom (manager_xrandr->xdisplay, name_buf, False);
monitor->monitor_winsys_xid = name; logical_monitor->monitor_winsys_xid = name;
m = XRRAllocateMonitor (manager_xrandr->xdisplay, monitor->n_outputs); m = XRRAllocateMonitor (manager_xrandr->xdisplay,
logical_monitor->n_outputs);
if (!m) if (!m)
return; return;
m->name = name; m->name = name;
m->primary = monitor->is_primary; m->primary = logical_monitor->is_primary;
m->automatic = True; m->automatic = True;
for (o = 0; o < monitor->n_outputs; o++) { for (o = 0; o < logical_monitor->n_outputs; o++) {
MetaOutput *output = monitor->outputs[o]; MetaOutput *output = logical_monitor->outputs[o];
m->outputs[o] = output->winsys_id; m->outputs[o] = output->winsys_id;
} }
XRRSetMonitor (manager_xrandr->xdisplay, XRRSetMonitor (manager_xrandr->xdisplay,
@ -1372,8 +1376,8 @@ meta_monitor_manager_xrandr_add_monitor(MetaMonitorManager *manager,
} }
static void static void
meta_monitor_manager_xrandr_delete_monitor(MetaMonitorManager *manager, meta_monitor_manager_xrandr_delete_monitor (MetaMonitorManager *manager,
int monitor_winsys_xid) int monitor_winsys_xid)
{ {
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager); MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
@ -1385,7 +1389,7 @@ meta_monitor_manager_xrandr_delete_monitor(MetaMonitorManager *manager,
} }
static void static void
meta_monitor_manager_xrandr_init_monitors(MetaMonitorManagerXrandr *manager_xrandr) meta_monitor_manager_xrandr_init_monitors (MetaMonitorManagerXrandr *manager_xrandr)
{ {
XRRMonitorInfo *m; XRRMonitorInfo *m;
int n, i; int n, i;

10
src/backends/x11/meta-renderer-x11.c
View File

@ -69,8 +69,8 @@ meta_renderer_x11_create_cogl_renderer (MetaRenderer *renderer)
} }
static MetaRendererView * static MetaRendererView *
meta_renderer_x11_create_view (MetaRenderer *renderer, meta_renderer_x11_create_view (MetaRenderer *renderer,
MetaMonitorInfo *monitor_info) MetaLogicalMonitor *logical_monitor)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = meta_get_backend ();
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend); ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
@ -82,8 +82,8 @@ meta_renderer_x11_create_view (MetaRenderer *renderer,
g_assert (meta_is_wayland_compositor ()); g_assert (meta_is_wayland_compositor ());
width = monitor_info->rect.width; width = logical_monitor->rect.width;
height = monitor_info->rect.height; height = logical_monitor->rect.height;
texture_2d = cogl_texture_2d_new_with_size (cogl_context, width, height); texture_2d = cogl_texture_2d_new_with_size (cogl_context, width, height);
offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (texture_2d)); offscreen = cogl_offscreen_new_with_texture (COGL_TEXTURE (texture_2d));
@ -91,7 +91,7 @@ meta_renderer_x11_create_view (MetaRenderer *renderer,
meta_fatal ("Couldn't allocate framebuffer: %s", error->message); meta_fatal ("Couldn't allocate framebuffer: %s", error->message);
return g_object_new (META_TYPE_RENDERER_VIEW, return g_object_new (META_TYPE_RENDERER_VIEW,
"layout", &monitor_info->rect, "layout", &logical_monitor->rect,
"framebuffer", COGL_FRAMEBUFFER (offscreen), "framebuffer", COGL_FRAMEBUFFER (offscreen),
NULL); NULL);
} }

10
src/compositor/meta-surface-actor-wayland.c
View File

@ -267,7 +267,7 @@ meta_surface_actor_wayland_sync_state_recursive (MetaSurfaceActorWayland *self)
gboolean gboolean
meta_surface_actor_wayland_is_on_monitor (MetaSurfaceActorWayland *self, meta_surface_actor_wayland_is_on_monitor (MetaSurfaceActorWayland *self,
MetaMonitorInfo *monitor) MetaLogicalMonitor *logical_monitor)
{ {
float x, y, width, height; float x, y, width, height;
cairo_rectangle_int_t actor_rect; cairo_rectangle_int_t actor_rect;
@ -287,10 +287,10 @@ meta_surface_actor_wayland_is_on_monitor (MetaSurfaceActorWayland *self,
cairo_region_intersect_rectangle (region, cairo_region_intersect_rectangle (region,
&((cairo_rectangle_int_t) { &((cairo_rectangle_int_t) {
.x = monitor->rect.x, .x = logical_monitor->rect.x,
.y = monitor->rect.y, .y = logical_monitor->rect.y,
.width = monitor->rect.width, .width = logical_monitor->rect.width,
.height = monitor->rect.height, .height = logical_monitor->rect.height,
})); }));
is_on_monitor = !cairo_region_is_empty (region); is_on_monitor = !cairo_region_is_empty (region);

2
src/compositor/meta-surface-actor-wayland.h
View File

@ -74,7 +74,7 @@ void meta_surface_actor_wayland_sync_state_recursive (MetaSurfaceActorWayland *s
void meta_surface_actor_wayland_sync_subsurface_state (MetaSurfaceActorWayland *self); void meta_surface_actor_wayland_sync_subsurface_state (MetaSurfaceActorWayland *self);
gboolean meta_surface_actor_wayland_is_on_monitor (MetaSurfaceActorWayland *self, gboolean meta_surface_actor_wayland_is_on_monitor (MetaSurfaceActorWayland *self,
MetaMonitorInfo *monitor); MetaLogicalMonitor *logical_monitor);
void meta_surface_actor_wayland_add_frame_callbacks (MetaSurfaceActorWayland *self, void meta_surface_actor_wayland_add_frame_callbacks (MetaSurfaceActorWayland *self,
struct wl_list *frame_callbacks); struct wl_list *frame_callbacks);

40
src/core/constraints.c
View File

@ -328,7 +328,7 @@ setup_constraint_info (ConstraintInfo *info,
const MetaRectangle *orig, const MetaRectangle *orig,
MetaRectangle *new) MetaRectangle *new)
{ {
const MetaMonitorInfo *monitor_info; const MetaLogicalMonitor *logical_monitor;
MetaWorkspace *cur_workspace; MetaWorkspace *cur_workspace;
info->orig = *orig; info->orig = *orig;
@ -376,15 +376,15 @@ setup_constraint_info (ConstraintInfo *info,
if (!info->is_user_action) if (!info->is_user_action)
info->fixed_directions = FIXED_DIRECTION_NONE; info->fixed_directions = FIXED_DIRECTION_NONE;
monitor_info = logical_monitor =
meta_screen_get_monitor_for_rect (window->screen, &info->current); meta_screen_get_logical_monitor_for_rect (window->screen, &info->current);
meta_window_get_work_area_for_monitor (window, meta_window_get_work_area_for_monitor (window,
monitor_info->number, logical_monitor->number,
&info->work_area_monitor); &info->work_area_monitor);
if (!window->fullscreen || window->fullscreen_monitors[0] == -1) if (!window->fullscreen || window->fullscreen_monitors[0] == -1)
{ {
info->entire_monitor = monitor_info->rect; info->entire_monitor = logical_monitor->rect;
} }
else else
{ {
@ -393,12 +393,12 @@ setup_constraint_info (ConstraintInfo *info,
monitor = window->fullscreen_monitors[i]; monitor = window->fullscreen_monitors[i];
info->entire_monitor = info->entire_monitor =
window->screen->monitor_infos[monitor].rect; window->screen->logical_monitors[monitor].rect;
for (i = 1; i <= 3; i++) for (i = 1; i <= 3; i++)
{ {
monitor = window->fullscreen_monitors[i]; monitor = window->fullscreen_monitors[i];
meta_rectangle_union (&info->entire_monitor, meta_rectangle_union (&info->entire_monitor,
&window->screen->monitor_infos[monitor].rect, &window->screen->logical_monitors[monitor].rect,
&info->entire_monitor); &info->entire_monitor);
} }
} }
@ -408,7 +408,7 @@ setup_constraint_info (ConstraintInfo *info,
meta_workspace_get_onscreen_region (cur_workspace); meta_workspace_get_onscreen_region (cur_workspace);
info->usable_monitor_region = info->usable_monitor_region =
meta_workspace_get_onmonitor_region (cur_workspace, meta_workspace_get_onmonitor_region (cur_workspace,
monitor_info->number); logical_monitor->number);
/* Log all this information for debugging */ /* Log all this information for debugging */
meta_topic (META_DEBUG_GEOMETRY, meta_topic (META_DEBUG_GEOMETRY,
@ -463,7 +463,7 @@ place_window_if_needed(MetaWindow *window,
MetaRectangle orig_rect; MetaRectangle orig_rect;
MetaRectangle placed_rect; MetaRectangle placed_rect;
MetaWorkspace *cur_workspace; MetaWorkspace *cur_workspace;
const MetaMonitorInfo *monitor_info; const MetaLogicalMonitor *logical_monitor;
placed_rect = (MetaRectangle) { placed_rect = (MetaRectangle) {
.x = window->rect.x, .x = window->rect.x,
@ -481,16 +481,16 @@ place_window_if_needed(MetaWindow *window,
/* placing the window may have changed the monitor. Find the /* placing the window may have changed the monitor. Find the
* new monitor and update the ConstraintInfo * new monitor and update the ConstraintInfo
*/ */
monitor_info = logical_monitor =
meta_screen_get_monitor_for_rect (window->screen, &placed_rect); meta_screen_get_logical_monitor_for_rect (window->screen, &placed_rect);
info->entire_monitor = monitor_info->rect; info->entire_monitor = logical_monitor->rect;
meta_window_get_work_area_for_monitor (window, meta_window_get_work_area_for_monitor (window,
monitor_info->number, logical_monitor->number,
&info->work_area_monitor); &info->work_area_monitor);
cur_workspace = window->screen->active_workspace; cur_workspace = window->screen->active_workspace;
info->usable_monitor_region = info->usable_monitor_region =
meta_workspace_get_onmonitor_region (cur_workspace, meta_workspace_get_onmonitor_region (cur_workspace,
monitor_info->number); logical_monitor->number);
info->current.x = placed_rect.x; info->current.x = placed_rect.x;
info->current.y = placed_rect.y; info->current.y = placed_rect.y;
@ -1449,12 +1449,12 @@ constrain_to_single_monitor (MetaWindow *window,
* "onscreen" by their own strut) and we can't apply it to frameless windows * "onscreen" by their own strut) and we can't apply it to frameless windows
* or else users will be unable to move windows such as XMMS across monitors. * or else users will be unable to move windows such as XMMS across monitors.
*/ */
if (window->type == META_WINDOW_DESKTOP || if (window->type == META_WINDOW_DESKTOP ||
window->type == META_WINDOW_DOCK || window->type == META_WINDOW_DOCK ||
window->screen->n_monitor_infos == 1 || window->screen->n_logical_monitors == 1 ||
!window->require_on_single_monitor || !window->require_on_single_monitor ||
!window->frame || !window->frame ||
info->is_user_action || info->is_user_action ||
meta_window_get_placement_rule (window)) meta_window_get_placement_rule (window))
return TRUE; return TRUE;

12
src/core/display.c
View File

@ -3088,7 +3088,7 @@ meta_display_request_pad_osd (MetaDisplay *display,
MetaInputSettings *input_settings; MetaInputSettings *input_settings;
const gchar *layout_path = NULL; const gchar *layout_path = NULL;
ClutterActor *osd; ClutterActor *osd;
MetaMonitorInfo *monitor; MetaLogicalMonitor *logical_monitor;
gint monitor_idx; gint monitor_idx;
GSettings *settings; GSettings *settings;
#ifdef HAVE_LIBWACOM #ifdef HAVE_LIBWACOM
@ -3107,7 +3107,8 @@ meta_display_request_pad_osd (MetaDisplay *display,
if (input_settings) if (input_settings)
{ {
settings = meta_input_settings_get_tablet_settings (input_settings, pad); settings = meta_input_settings_get_tablet_settings (input_settings, pad);
monitor = meta_input_settings_get_tablet_monitor_info (input_settings, pad); logical_monitor =
meta_input_settings_get_tablet_logical_monitor (input_settings, pad);
#ifdef HAVE_LIBWACOM #ifdef HAVE_LIBWACOM
wacom_device = meta_input_settings_get_tablet_wacom_device (input_settings, wacom_device = meta_input_settings_get_tablet_wacom_device (input_settings,
pad); pad);
@ -3118,10 +3119,11 @@ meta_display_request_pad_osd (MetaDisplay *display,
if (!layout_path || !settings) if (!layout_path || !settings)
return; return;
if (monitor) if (logical_monitor)
{ {
monitor_idx = meta_screen_get_monitor_index_for_rect (display->screen, monitor_idx =
&monitor->rect); meta_screen_get_monitor_index_for_rect (display->screen,
&logical_monitor->rect);
} }
else else
{ {

2
src/core/keybindings.c
View File

@ -3155,7 +3155,7 @@ handle_move_to_monitor (MetaDisplay *display,
gpointer dummy) gpointer dummy)
{ {
gint which = binding->handler->data; gint which = binding->handler->data;
const MetaMonitorInfo *current, *new; const MetaLogicalMonitor *current, *new;
current = window->monitor; current = window->monitor;
new = meta_screen_get_monitor_neighbor (screen, current->number, which); new = meta_screen_get_monitor_neighbor (screen, current->number, which);

32
src/core/place.c
View File

@ -517,7 +517,7 @@ find_first_fit (MetaWindow *window,
#ifdef WITH_VERBOSE_MODE #ifdef WITH_VERBOSE_MODE
{ {
char monitor_location_string[RECT_LENGTH]; char monitor_location_string[RECT_LENGTH];
meta_rectangle_to_string (&window->screen->monitor_infos[monitor].rect, meta_rectangle_to_string (&window->screen->logical_monitors[monitor].rect,
monitor_location_string); monitor_location_string);
meta_topic (META_DEBUG_XINERAMA, meta_topic (META_DEBUG_XINERAMA,
"Natural monitor is %s\n", "Natural monitor is %s\n",
@ -661,7 +661,7 @@ meta_window_place (MetaWindow *window,
int *new_y) int *new_y)
{ {
GList *windows = NULL; GList *windows = NULL;
const MetaMonitorInfo *xi; const MetaLogicalMonitor *logical_monitor;
meta_topic (META_DEBUG_PLACEMENT, "Placing window %s\n", window->desc); meta_topic (META_DEBUG_PLACEMENT, "Placing window %s\n", window->desc);
@ -810,19 +810,19 @@ meta_window_place (MetaWindow *window,
meta_window_get_frame_rect (window, &frame_rect); meta_window_get_frame_rect (window, &frame_rect);
/* Warning, this function is a round trip! */ /* Warning, this function is a round trip! */
xi = meta_screen_get_current_monitor_info (window->screen); logical_monitor = meta_screen_get_current_logical_monitor (window->screen);
w = xi->rect.width; w = logical_monitor->rect.width;
h = xi->rect.height; h = logical_monitor->rect.height;
x = (w - frame_rect.width) / 2; x = (w - frame_rect.width) / 2;
y = (h - frame_rect.height) / 2; y = (h - frame_rect.height) / 2;
x += xi->rect.x; x += logical_monitor->rect.x;
y += xi->rect.y; y += logical_monitor->rect.y;
meta_topic (META_DEBUG_PLACEMENT, "Centered window %s on monitor %d\n", meta_topic (META_DEBUG_PLACEMENT, "Centered window %s on monitor %d\n",
window->desc, xi->number); window->desc, logical_monitor->number);
goto done_check_denied_focus; goto done_check_denied_focus;
} }
@ -855,7 +855,7 @@ meta_window_place (MetaWindow *window,
} }
/* Warning, this is a round trip! */ /* Warning, this is a round trip! */
xi = meta_screen_get_current_monitor_info (window->screen); logical_monitor = meta_screen_get_current_logical_monitor (window->screen);
/* Maximize windows if they are too big for their work area (bit of /* Maximize windows if they are too big for their work area (bit of
* a hack here). Assume undecorated windows probably don't intend to * a hack here). Assume undecorated windows probably don't intend to
@ -868,7 +868,7 @@ meta_window_place (MetaWindow *window,
MetaRectangle frame_rect; MetaRectangle frame_rect;
meta_window_get_work_area_for_monitor (window, meta_window_get_work_area_for_monitor (window,
xi->number, logical_monitor->number,
&workarea); &workarea);
meta_window_get_frame_rect (window, &frame_rect); meta_window_get_frame_rect (window, &frame_rect);
@ -883,11 +883,11 @@ meta_window_place (MetaWindow *window,
} }
/* "Origin" placement algorithm */ /* "Origin" placement algorithm */
x = xi->rect.x; x = logical_monitor->rect.x;
y = xi->rect.y; y = logical_monitor->rect.y;
if (find_first_fit (window, windows, if (find_first_fit (window, windows,
xi->number, logical_monitor->number,
x, y, &x, &y)) x, y, &x, &y))
goto done_check_denied_focus; goto done_check_denied_focus;
@ -920,11 +920,11 @@ meta_window_place (MetaWindow *window,
focus_window_list = g_list_prepend (NULL, focus_window); focus_window_list = g_list_prepend (NULL, focus_window);
/* Reset x and y ("origin" placement algorithm) */ /* Reset x and y ("origin" placement algorithm) */
x = xi->rect.x; x = logical_monitor->rect.x;
y = xi->rect.y; y = logical_monitor->rect.y;
found_fit = find_first_fit (window, focus_window_list, found_fit = find_first_fit (window, focus_window_list,
xi->number, logical_monitor->number,
x, y, &x, &y); x, y, &x, &y);
g_list_free (focus_window_list); g_list_free (focus_window_list);
} }

33
src/core/screen-private.h
View File

@ -75,8 +75,8 @@ struct _MetaScreen
Atom wm_sn_atom; Atom wm_sn_atom;
guint32 wm_sn_timestamp; guint32 wm_sn_timestamp;
MetaMonitorInfo *monitor_infos; MetaLogicalMonitor *logical_monitors;
int n_monitor_infos; int n_logical_monitors;
int primary_monitor_index; int primary_monitor_index;
gboolean has_xinerama_indices; gboolean has_xinerama_indices;
@ -136,23 +136,22 @@ void meta_screen_hide_tile_preview (MetaScreen *screen);
MetaWindow* meta_screen_get_mouse_window (MetaScreen *screen, MetaWindow* meta_screen_get_mouse_window (MetaScreen *screen,
MetaWindow *not_this_one); MetaWindow *not_this_one);
const MetaMonitorInfo* meta_screen_get_current_monitor_info (MetaScreen *screen); const MetaLogicalMonitor * meta_screen_get_current_logical_monitor (MetaScreen *screen);
const MetaMonitorInfo* meta_screen_get_current_monitor_info_for_pos (MetaScreen *screen, const MetaLogicalMonitor * meta_screen_get_current_logical_monitor_for_pos (MetaScreen *screen,
int x, int x,
int y); int y);
const MetaMonitorInfo* meta_screen_get_monitor_for_rect (MetaScreen *screen, const MetaLogicalMonitor * meta_screen_get_logical_monitor_for_rect (MetaScreen *screen,
MetaRectangle *rect); MetaRectangle *rect);
const MetaMonitorInfo* meta_screen_calculate_monitor_for_window (MetaScreen *screen, const MetaLogicalMonitor * meta_screen_calculate_logical_monitor_for_window (MetaScreen *screen,
MetaWindow *window); MetaWindow *window);
const MetaMonitorInfo* meta_screen_get_monitor_for_point (MetaScreen *screen, const MetaLogicalMonitor * meta_screen_get_logical_monitor_for_point (MetaScreen *screen,
int x, int x,
int y); int y);
const MetaLogicalMonitor * meta_screen_get_monitor_neighbor (MetaScreen *screen,
const MetaMonitorInfo* meta_screen_get_monitor_neighbor (MetaScreen *screen, int which_monitor,
int which_monitor, MetaScreenDirection dir);
MetaScreenDirection dir);
void meta_screen_update_workspace_layout (MetaScreen *screen); void meta_screen_update_workspace_layout (MetaScreen *screen);
void meta_screen_update_workspace_names (MetaScreen *screen); void meta_screen_update_workspace_names (MetaScreen *screen);

156
src/core/screen.c
View File

@ -358,15 +358,15 @@ meta_screen_ensure_xinerama_indices (MetaScreen *screen)
return; return;
} }
for (i = 0; i < screen->n_monitor_infos; ++i) for (i = 0; i < screen->n_logical_monitors; ++i)
{ {
for (j = 0; j < n_infos; ++j) for (j = 0; j < n_infos; ++j)
{ {
if (screen->monitor_infos[i].rect.x == infos[j].x_org && if (screen->logical_monitors[i].rect.x == infos[j].x_org &&
screen->monitor_infos[i].rect.y == infos[j].y_org && screen->logical_monitors[i].rect.y == infos[j].y_org &&
screen->monitor_infos[i].rect.width == infos[j].width && screen->logical_monitors[i].rect.width == infos[j].width &&
screen->monitor_infos[i].rect.height == infos[j].height) screen->logical_monitors[i].rect.height == infos[j].height)
screen->monitor_infos[i].xinerama_index = j; screen->logical_monitors[i].xinerama_index = j;
} }
} }
@ -377,11 +377,11 @@ int
meta_screen_monitor_index_to_xinerama_index (MetaScreen *screen, meta_screen_monitor_index_to_xinerama_index (MetaScreen *screen,
int index) int index)
{ {
g_return_val_if_fail (index >= 0 && index < screen->n_monitor_infos, -1); g_return_val_if_fail (index >= 0 && index < screen->n_logical_monitors, -1);
meta_screen_ensure_xinerama_indices (screen); meta_screen_ensure_xinerama_indices (screen);
return screen->monitor_infos[index].xinerama_index; return screen->logical_monitors[index].xinerama_index;
} }
int int
@ -392,18 +392,19 @@ meta_screen_xinerama_index_to_monitor_index (MetaScreen *screen,
meta_screen_ensure_xinerama_indices (screen); meta_screen_ensure_xinerama_indices (screen);
for (i = 0; i < screen->n_monitor_infos; i++) for (i = 0; i < screen->n_logical_monitors; i++)
if (screen->monitor_infos[i].xinerama_index == index) if (screen->logical_monitors[i].xinerama_index == index)
return i; return i;
return -1; return -1;
} }
static void static void
reload_monitor_infos (MetaScreen *screen) reload_logical_monitors (MetaScreen *screen)
{ {
GList *l; GList *l;
MetaMonitorManager *manager; MetaMonitorManager *manager;
unsigned int n_logical_monitors;
for (l = screen->workspaces; l != NULL; l = l->next) for (l = screen->workspaces; l != NULL; l = l->next)
{ {
@ -411,7 +412,7 @@ reload_monitor_infos (MetaScreen *screen)
meta_workspace_invalidate_work_area (space); meta_workspace_invalidate_work_area (space);
} }
/* Any previous screen->monitor_infos or screen->outputs is freed by the caller */ /* Any previous screen->logical_monitors or screen->outputs is freed by the caller */
screen->last_monitor_index = 0; screen->last_monitor_index = 0;
screen->has_xinerama_indices = FALSE; screen->has_xinerama_indices = FALSE;
@ -419,8 +420,9 @@ reload_monitor_infos (MetaScreen *screen)
manager = meta_monitor_manager_get (); manager = meta_monitor_manager_get ();
screen->monitor_infos = meta_monitor_manager_get_monitor_infos (manager, screen->logical_monitors =
(unsigned*)&screen->n_monitor_infos); meta_monitor_manager_get_logical_monitors (manager, &n_logical_monitors);
screen->n_logical_monitors = (unsigned int) n_logical_monitors;
screen->primary_monitor_index = meta_monitor_manager_get_primary_index (manager); screen->primary_monitor_index = meta_monitor_manager_get_primary_index (manager);
} }
@ -684,7 +686,7 @@ meta_screen_new (MetaDisplay *display,
* can close the helper that is holding on to it */ * can close the helper that is holding on to it */
meta_restart_finish (); meta_restart_finish ();
reload_monitor_infos (screen); reload_logical_monitors (screen);
meta_screen_set_cursor (screen, META_CURSOR_DEFAULT); meta_screen_set_cursor (screen, META_CURSOR_DEFAULT);
@ -805,7 +807,7 @@ meta_screen_free (MetaScreen *screen,
if (screen->check_fullscreen_later != 0) if (screen->check_fullscreen_later != 0)
meta_later_remove (screen->check_fullscreen_later); meta_later_remove (screen->check_fullscreen_later);
g_free (screen->monitor_infos); g_free (screen->logical_monitors);
if (screen->tile_preview_timeout_id) if (screen->tile_preview_timeout_id)
g_source_remove (screen->tile_preview_timeout_id); g_source_remove (screen->tile_preview_timeout_id);
@ -1228,13 +1230,13 @@ root_cursor_prepare_at (MetaCursorSprite *cursor_sprite,
int y, int y,
MetaScreen *screen) MetaScreen *screen)
{ {
const MetaMonitorInfo *monitor; const MetaLogicalMonitor *logical_monitor;
monitor = meta_screen_get_monitor_for_point (screen, x, y); logical_monitor = meta_screen_get_logical_monitor_for_point (screen, x, y);
/* Reload the cursor texture if the scale has changed. */ /* Reload the cursor texture if the scale has changed. */
if (monitor) if (logical_monitor)
meta_cursor_sprite_set_theme_scale (cursor_sprite, monitor->scale); meta_cursor_sprite_set_theme_scale (cursor_sprite, logical_monitor->scale);
} }
static void static void
@ -1388,21 +1390,21 @@ meta_screen_get_mouse_window (MetaScreen *screen,
return window; return window;
} }
const MetaMonitorInfo* const MetaLogicalMonitor *
meta_screen_get_monitor_for_rect (MetaScreen *screen, meta_screen_get_logical_monitor_for_rect (MetaScreen *screen,
MetaRectangle *rect) MetaRectangle *rect)
{ {
int i; int i;
int best_monitor, monitor_score, rect_area; int best_monitor, monitor_score, rect_area;
if (screen->n_monitor_infos == 1) if (screen->n_logical_monitors == 1)
return &screen->monitor_infos[0]; return &screen->logical_monitors[0];
best_monitor = 0; best_monitor = 0;
monitor_score = -1; monitor_score = -1;
rect_area = meta_rectangle_area (rect); rect_area = meta_rectangle_area (rect);
for (i = 0; i < screen->n_monitor_infos; i++) for (i = 0; i < screen->n_logical_monitors; i++)
{ {
gboolean result; gboolean result;
int cur; int cur;
@ -1410,14 +1412,14 @@ meta_screen_get_monitor_for_rect (MetaScreen *screen,
if (rect_area > 0) if (rect_area > 0)
{ {
MetaRectangle dest; MetaRectangle dest;
result = meta_rectangle_intersect (&screen->monitor_infos[i].rect, result = meta_rectangle_intersect (&screen->logical_monitors[i].rect,
rect, rect,
&dest); &dest);
cur = meta_rectangle_area (&dest); cur = meta_rectangle_area (&dest);
} }
else else
{ {
result = meta_rectangle_contains_rect (&screen->monitor_infos[i].rect, result = meta_rectangle_contains_rect (&screen->logical_monitors[i].rect,
rect); rect);
cur = rect_area; cur = rect_area;
} }
@ -1429,59 +1431,61 @@ meta_screen_get_monitor_for_rect (MetaScreen *screen,
} }
} }
return &screen->monitor_infos[best_monitor]; return &screen->logical_monitors[best_monitor];
} }
const MetaMonitorInfo* const MetaLogicalMonitor *
meta_screen_calculate_monitor_for_window (MetaScreen *screen, meta_screen_calculate_logical_monitor_for_window (MetaScreen *screen,
MetaWindow *window) MetaWindow *window)
{ {
MetaRectangle window_rect; MetaRectangle window_rect;
meta_window_get_frame_rect (window, &window_rect); meta_window_get_frame_rect (window, &window_rect);
return meta_screen_get_monitor_for_rect (screen, &window_rect); return meta_screen_get_logical_monitor_for_rect (screen, &window_rect);
} }
int int
meta_screen_get_monitor_index_for_rect (MetaScreen *screen, meta_screen_get_monitor_index_for_rect (MetaScreen *screen,
MetaRectangle *rect) MetaRectangle *rect)
{ {
const MetaMonitorInfo *monitor = meta_screen_get_monitor_for_rect (screen, rect); const MetaLogicalMonitor *monitor;
monitor = meta_screen_get_logical_monitor_for_rect (screen, rect);
return monitor->number; return monitor->number;
} }
const MetaMonitorInfo * const MetaLogicalMonitor *
meta_screen_get_monitor_for_point (MetaScreen *screen, meta_screen_get_logical_monitor_for_point (MetaScreen *screen,
int x, int x,
int y) int y)
{ {
int i; int i;
if (screen->n_monitor_infos == 1) if (screen->n_logical_monitors == 1)
return &screen->monitor_infos[0]; return &screen->logical_monitors[0];
for (i = 0; i < screen->n_monitor_infos; i++) for (i = 0; i < screen->n_logical_monitors; i++)
{ {
if (POINT_IN_RECT (x, y, screen->monitor_infos[i].rect)) if (POINT_IN_RECT (x, y, screen->logical_monitors[i].rect))
return &screen->monitor_infos[i]; return &screen->logical_monitors[i];
} }
return NULL; return NULL;
} }
const MetaMonitorInfo* const MetaLogicalMonitor *
meta_screen_get_monitor_neighbor (MetaScreen *screen, meta_screen_get_monitor_neighbor (MetaScreen *screen,
int which_monitor, int which_monitor,
MetaScreenDirection direction) MetaScreenDirection direction)
{ {
MetaMonitorInfo* input = screen->monitor_infos + which_monitor; MetaLogicalMonitor *input = screen->logical_monitors + which_monitor;
MetaMonitorInfo* current; MetaLogicalMonitor *current;
int i; int i;
for (i = 0; i < screen->n_monitor_infos; i++) for (i = 0; i < screen->n_logical_monitors; i++)
{ {
current = screen->monitor_infos + i; current = screen->logical_monitors + i;
if ((direction == META_SCREEN_RIGHT && if ((direction == META_SCREEN_RIGHT &&
current->rect.x == input->rect.x + input->rect.width && current->rect.x == input->rect.x + input->rect.width &&
@ -1508,27 +1512,32 @@ meta_screen_get_monitor_neighbor_index (MetaScreen *screen,
int which_monitor, int which_monitor,
MetaScreenDirection direction) MetaScreenDirection direction)
{ {
const MetaMonitorInfo *monitor; const MetaLogicalMonitor *logical_monitor;
monitor = meta_screen_get_monitor_neighbor (screen, which_monitor, direction);
return monitor ? monitor->number : -1; logical_monitor = meta_screen_get_monitor_neighbor (screen,
which_monitor,
direction);
return logical_monitor ? logical_monitor->number : -1;
} }
const MetaMonitorInfo* const MetaLogicalMonitor *
meta_screen_get_current_monitor_info (MetaScreen *screen) meta_screen_get_current_logical_monitor (MetaScreen *screen)
{ {
int monitor_index; int monitor_index;
monitor_index = meta_screen_get_current_monitor (screen); monitor_index = meta_screen_get_current_monitor (screen);
return &screen->monitor_infos[monitor_index]; return &screen->logical_monitors[monitor_index];
} }
const MetaMonitorInfo* const MetaLogicalMonitor *
meta_screen_get_current_monitor_info_for_pos (MetaScreen *screen, meta_screen_get_current_logical_monitor_for_pos (MetaScreen *screen,
int x, int x,
int y) int y)
{ {
int monitor_index; int monitor_index;
monitor_index = meta_screen_get_current_monitor_for_pos (screen, x, y); monitor_index = meta_screen_get_current_monitor_for_pos (screen, x, y);
return &screen->monitor_infos[monitor_index]; return &screen->logical_monitors[monitor_index];
} }
@ -1547,7 +1556,7 @@ meta_screen_get_current_monitor_for_pos (MetaScreen *screen,
int x, int x,
int y) int y)
{ {
if (screen->n_monitor_infos == 1) if (screen->n_logical_monitors == 1)
return 0; return 0;
else if (screen->display->monitor_cache_invalidated) else if (screen->display->monitor_cache_invalidated)
{ {
@ -1560,9 +1569,9 @@ meta_screen_get_current_monitor_for_pos (MetaScreen *screen,
screen->display->monitor_cache_invalidated = FALSE; screen->display->monitor_cache_invalidated = FALSE;
screen->last_monitor_index = 0; screen->last_monitor_index = 0;
for (i = 0; i < screen->n_monitor_infos; i++) for (i = 0; i < screen->n_logical_monitors; i++)
{ {
if (meta_rectangle_contains_rect (&screen->monitor_infos[i].rect, if (meta_rectangle_contains_rect (&screen->logical_monitors[i].rect,
&pointer_position)) &pointer_position))
{ {
screen->last_monitor_index = i; screen->last_monitor_index = i;
@ -1593,7 +1602,7 @@ meta_screen_get_current_monitor (MetaScreen *screen)
{ {
MetaCursorTracker *tracker = meta_cursor_tracker_get_for_screen (screen); MetaCursorTracker *tracker = meta_cursor_tracker_get_for_screen (screen);
if (screen->n_monitor_infos == 1) if (screen->n_logical_monitors == 1)
return 0; return 0;
/* Sadly, we have to do it this way. Yuck. /* Sadly, we have to do it this way. Yuck.
@ -1623,7 +1632,7 @@ meta_screen_get_n_monitors (MetaScreen *screen)
{ {
g_return_val_if_fail (META_IS_SCREEN (screen), 0); g_return_val_if_fail (META_IS_SCREEN (screen), 0);
return screen->n_monitor_infos; return screen->n_logical_monitors;
} }
/** /**
@ -1656,10 +1665,10 @@ meta_screen_get_monitor_geometry (MetaScreen *screen,
MetaRectangle *geometry) MetaRectangle *geometry)
{ {
g_return_if_fail (META_IS_SCREEN (screen)); g_return_if_fail (META_IS_SCREEN (screen));
g_return_if_fail (monitor >= 0 && monitor < screen->n_monitor_infos); g_return_if_fail (monitor >= 0 && monitor < screen->n_logical_monitors);
g_return_if_fail (geometry != NULL); g_return_if_fail (geometry != NULL);
*geometry = screen->monitor_infos[monitor].rect; *geometry = screen->logical_monitors[monitor].rect;
} }
#define _NET_WM_ORIENTATION_HORZ 0 #define _NET_WM_ORIENTATION_HORZ 0
@ -2286,7 +2295,7 @@ on_monitors_changed (MetaMonitorManager *manager,
&screen->rect.width, &screen->rect.width,
&screen->rect.height); &screen->rect.height);
reload_monitor_infos (screen); reload_logical_monitors (screen);
set_desktop_geometry_hint (screen); set_desktop_geometry_hint (screen);
/* Resize the guard window to fill the screen again. */ /* Resize the guard window to fill the screen again. */
@ -2779,13 +2788,13 @@ check_fullscreen_func (gpointer data)
g_slist_free (obscured_monitors); g_slist_free (obscured_monitors);
for (i = 0; i < screen->n_monitor_infos; i++) for (i = 0; i < screen->n_logical_monitors; i++)
{ {
MetaMonitorInfo *info = &screen->monitor_infos[i]; MetaLogicalMonitor *logical_monitor = &screen->logical_monitors[i];
gboolean in_fullscreen = g_slist_find (fullscreen_monitors, GINT_TO_POINTER (i + 1)) != NULL; gboolean in_fullscreen = g_slist_find (fullscreen_monitors, GINT_TO_POINTER (i + 1)) != NULL;
if (in_fullscreen != info->in_fullscreen) if (in_fullscreen != logical_monitor->in_fullscreen)
{ {
info->in_fullscreen = in_fullscreen; logical_monitor->in_fullscreen = in_fullscreen;
in_fullscreen_changed = TRUE; in_fullscreen_changed = TRUE;
} }
} }
@ -2834,10 +2843,11 @@ meta_screen_get_monitor_in_fullscreen (MetaScreen *screen,
int monitor) int monitor)
{ {
g_return_val_if_fail (META_IS_SCREEN (screen), FALSE); g_return_val_if_fail (META_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (monitor >= 0 && monitor < screen->n_monitor_infos, FALSE); g_return_val_if_fail (monitor >= 0 &&
monitor < screen->n_logical_monitors, FALSE);
/* We use -1 as a flag to mean "not known yet" for notification purposes */ /* We use -1 as a flag to mean "not known yet" for notification purposes */
return screen->monitor_infos[monitor].in_fullscreen == TRUE; return screen->logical_monitors[monitor].in_fullscreen == TRUE;
} }
gboolean gboolean

4
src/core/window-private.h
View File

@ -135,7 +135,7 @@ struct _MetaWindow
MetaDisplay *display; MetaDisplay *display;
MetaScreen *screen; MetaScreen *screen;
guint64 stamp; guint64 stamp;
const MetaMonitorInfo *monitor; const MetaLogicalMonitor *monitor;
MetaWorkspace *workspace; MetaWorkspace *workspace;
MetaWindowClientType client_type; MetaWindowClientType client_type;
MetaWaylandSurface *surface; MetaWaylandSurface *surface;
@ -527,7 +527,7 @@ struct _MetaWindowClass
uint32_t (*get_client_pid) (MetaWindow *window); uint32_t (*get_client_pid) (MetaWindow *window);
void (*update_main_monitor) (MetaWindow *window); void (*update_main_monitor) (MetaWindow *window);
void (*main_monitor_changed) (MetaWindow *window, void (*main_monitor_changed) (MetaWindow *window,
const MetaMonitorInfo *old); const MetaLogicalMonitor *old);
}; };
/* These differ from window->has_foo_func in that they consider /* These differ from window->has_foo_func in that they consider

51
src/core/window.c
View File

@ -816,8 +816,8 @@ meta_window_update_desc (MetaWindow *window)
} }
static void static void
meta_window_main_monitor_changed (MetaWindow *window, meta_window_main_monitor_changed (MetaWindow *window,
const MetaMonitorInfo *old) const MetaLogicalMonitor *old)
{ {
META_WINDOW_GET_CLASS (window)->main_monitor_changed (window, old); META_WINDOW_GET_CLASS (window)->main_monitor_changed (window, old);
@ -1027,8 +1027,8 @@ _meta_window_shared_new (MetaDisplay *display,
window->compositor_private = NULL; window->compositor_private = NULL;
window->monitor = meta_screen_calculate_monitor_for_window (window->screen, window->monitor =
window); meta_screen_calculate_logical_monitor_for_window (window->screen, window);
window->preferred_output_winsys_id = window->monitor->winsys_id; window->preferred_output_winsys_id = window->monitor->winsys_id;
window->tile_match = NULL; window->tile_match = NULL;
@ -1437,7 +1437,7 @@ meta_window_unmanage (MetaWindow *window,
if (window->monitor) if (window->monitor)
{ {
const MetaMonitorInfo *old = window->monitor; const MetaLogicalMonitor *old = window->monitor;
window->monitor = NULL; window->monitor = NULL;
meta_window_main_monitor_changed (window, old); meta_window_main_monitor_changed (window, old);
@ -2805,9 +2805,9 @@ meta_window_get_all_monitors (MetaWindow *window, gsize *length)
monitors = g_array_new (FALSE, FALSE, sizeof (int)); monitors = g_array_new (FALSE, FALSE, sizeof (int));
meta_window_get_frame_rect (window, &window_rect); meta_window_get_frame_rect (window, &window_rect);
for (i = 0; i < window->screen->n_monitor_infos; i++) for (i = 0; i < window->screen->n_logical_monitors; i++)
{ {
MetaRectangle *monitor_rect = &window->screen->monitor_infos[i].rect; MetaRectangle *monitor_rect = &window->screen->logical_monitors[i].rect;
if (meta_rectangle_overlap (&window_rect, monitor_rect)) if (meta_rectangle_overlap (&window_rect, monitor_rect))
g_array_append_val (monitors, i); g_array_append_val (monitors, i);
@ -3277,10 +3277,10 @@ meta_window_update_fullscreen_monitors (MetaWindow *window,
unsigned long left, unsigned long left,
unsigned long right) unsigned long right)
{ {
if ((int)top < window->screen->n_monitor_infos && if ((int) top < window->screen->n_logical_monitors &&
(int)bottom < window->screen->n_monitor_infos && (int) bottom < window->screen->n_logical_monitors &&
(int)left < window->screen->n_monitor_infos && (int) left < window->screen->n_logical_monitors &&
(int)right < window->screen->n_monitor_infos) (int) right < window->screen->n_logical_monitors)
{ {
window->fullscreen_monitors[0] = top; window->fullscreen_monitors[0] = top;
window->fullscreen_monitors[1] = bottom; window->fullscreen_monitors[1] = bottom;
@ -3516,18 +3516,18 @@ meta_window_get_monitor (MetaWindow *window)
return window->monitor->number; return window->monitor->number;
} }
static MetaMonitorInfo * static MetaLogicalMonitor *
find_monitor_by_winsys_id (MetaWindow *window, find_monitor_by_winsys_id (MetaWindow *window,
guint winsys_id) guint winsys_id)
{ {
int i; int i;
for (i = 0; i < window->screen->n_monitor_infos; i++) for (i = 0; i < window->screen->n_logical_monitors; i++)
{ {
MetaMonitorInfo *info = &window->screen->monitor_infos[i]; MetaLogicalMonitor *logical_monitor = &window->screen->logical_monitors[i];
if (info->winsys_id == winsys_id) if (logical_monitor->winsys_id == winsys_id)
return info; return logical_monitor;
} }
return NULL; return NULL;
@ -3538,7 +3538,7 @@ find_monitor_by_winsys_id (MetaWindow *window,
void void
meta_window_update_for_monitors_changed (MetaWindow *window) meta_window_update_for_monitors_changed (MetaWindow *window)
{ {
const MetaMonitorInfo *old, *new; const MetaLogicalMonitor *old, *new;
if (window->override_redirect || window->type == META_WINDOW_DESKTOP) if (window->override_redirect || window->type == META_WINDOW_DESKTOP)
{ {
@ -3557,14 +3557,14 @@ meta_window_update_for_monitors_changed (MetaWindow *window)
/* Fall back to primary if everything else failed */ /* Fall back to primary if everything else failed */
if (!new) if (!new)
new = &window->screen->monitor_infos[window->screen->primary_monitor_index]; new = &window->screen->logical_monitors[window->screen->primary_monitor_index];
if (window->tile_mode != META_TILE_NONE) if (window->tile_mode != META_TILE_NONE)
window->tile_monitor_number = new->number; window->tile_monitor_number = new->number;
/* This will eventually reach meta_window_update_monitor that /* This will eventually reach meta_window_update_monitor that
* will send leave/enter-monitor events. The old != new monitor * will send leave/enter-monitor events. The old != new monitor
* check will always fail (due to the new monitor_infos set) so * check will always fail (due to the new logical_monitors set) so
* we will always send the events, even if the new and old monitor * we will always send the events, even if the new and old monitor
* index is the same. That is right, since the enumeration of the * index is the same. That is right, since the enumeration of the
* monitors changed and the same index could be refereing * monitors changed and the same index could be refereing
@ -3578,7 +3578,7 @@ void
meta_window_update_monitor (MetaWindow *window, meta_window_update_monitor (MetaWindow *window,
gboolean user_op) gboolean user_op)
{ {
const MetaMonitorInfo *old; const MetaLogicalMonitor *old;
old = window->monitor; old = window->monitor;
META_WINDOW_GET_CLASS (window)->update_main_monitor (window); META_WINDOW_GET_CLASS (window)->update_main_monitor (window);
@ -5598,7 +5598,7 @@ update_move (MetaWindow *window,
!META_WINDOW_MAXIMIZED (window) && !META_WINDOW_MAXIMIZED (window) &&
!META_WINDOW_TILED_SIDE_BY_SIDE (window)) !META_WINDOW_TILED_SIDE_BY_SIDE (window))
{ {
const MetaMonitorInfo *monitor; const MetaLogicalMonitor *monitor;
MetaRectangle work_area; MetaRectangle work_area;
/* For side-by-side tiling we are interested in the inside vertical /* For side-by-side tiling we are interested in the inside vertical
@ -5614,7 +5614,8 @@ update_move (MetaWindow *window,
* refers to the monitor which contains the largest part of the window, * refers to the monitor which contains the largest part of the window,
* the latter to the one where the pointer is located. * the latter to the one where the pointer is located.
*/ */
monitor = meta_screen_get_current_monitor_info_for_pos (window->screen, x, y); monitor = meta_screen_get_current_logical_monitor_for_pos (window->screen,
x, y);
meta_window_get_work_area_for_monitor (window, meta_window_get_work_area_for_monitor (window,
monitor->number, monitor->number,
&work_area); &work_area);
@ -5686,14 +5687,14 @@ update_move (MetaWindow *window,
else if ((window->shaken_loose || META_WINDOW_MAXIMIZED (window)) && else if ((window->shaken_loose || META_WINDOW_MAXIMIZED (window)) &&
window->tile_mode != META_TILE_LEFT && window->tile_mode != META_TILE_RIGHT) window->tile_mode != META_TILE_LEFT && window->tile_mode != META_TILE_RIGHT)
{ {
const MetaMonitorInfo *wmonitor; const MetaLogicalMonitor *wmonitor;
MetaRectangle work_area; MetaRectangle work_area;
int monitor; int monitor;
window->tile_mode = META_TILE_NONE; window->tile_mode = META_TILE_NONE;
wmonitor = window->monitor; wmonitor = window->monitor;
for (monitor = 0; monitor < window->screen->n_monitor_infos; monitor++) for (monitor = 0; monitor < window->screen->n_logical_monitors; monitor++)
{ {
meta_window_get_work_area_for_monitor (window, monitor, &work_area); meta_window_get_work_area_for_monitor (window, monitor, &work_area);
@ -6068,7 +6069,7 @@ get_work_area_monitor (MetaWindow *window,
g_assert (which_monitor >= 0); g_assert (which_monitor >= 0);
/* Initialize to the whole monitor */ /* Initialize to the whole monitor */
*area = window->screen->monitor_infos[which_monitor].rect; *area = window->screen->logical_monitors[which_monitor].rect;
tmp = meta_window_get_workspaces (window); tmp = meta_window_get_workspaces (window);
while (tmp != NULL) while (tmp != NULL)

22
src/core/workspace.c
View File

@ -294,7 +294,7 @@ meta_workspace_remove (MetaWorkspace *workspace)
if (!workspace->work_areas_invalid) if (!workspace->work_areas_invalid)
{ {
workspace_free_all_struts (workspace); workspace_free_all_struts (workspace);
for (i = 0; i < screen->n_monitor_infos; i++) for (i = 0; i < screen->n_logical_monitors; i++)
meta_rectangle_free_list_and_elements (workspace->monitor_region[i]); meta_rectangle_free_list_and_elements (workspace->monitor_region[i]);
g_free (workspace->monitor_region); g_free (workspace->monitor_region);
meta_rectangle_free_list_and_elements (workspace->screen_region); meta_rectangle_free_list_and_elements (workspace->screen_region);
@ -704,7 +704,7 @@ meta_workspace_invalidate_work_area (MetaWorkspace *workspace)
workspace_free_all_struts (workspace); workspace_free_all_struts (workspace);
for (i = 0; i < workspace->screen->n_monitor_infos; i++) for (i = 0; i < workspace->screen->n_logical_monitors; i++)
meta_rectangle_free_list_and_elements (workspace->monitor_region[i]); meta_rectangle_free_list_and_elements (workspace->monitor_region[i]);
g_free (workspace->monitor_region); g_free (workspace->monitor_region);
meta_rectangle_free_list_and_elements (workspace->screen_region); meta_rectangle_free_list_and_elements (workspace->screen_region);
@ -789,12 +789,12 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
g_assert (workspace->screen_region == NULL); g_assert (workspace->screen_region == NULL);
workspace->monitor_region = g_new (GList*, workspace->monitor_region = g_new (GList*,
workspace->screen->n_monitor_infos); workspace->screen->n_logical_monitors);
for (i = 0; i < workspace->screen->n_monitor_infos; i++) for (i = 0; i < workspace->screen->n_logical_monitors; i++)
{ {
workspace->monitor_region[i] = workspace->monitor_region[i] =
meta_rectangle_get_minimal_spanning_set_for_region ( meta_rectangle_get_minimal_spanning_set_for_region (
&workspace->screen->monitor_infos[i].rect, &workspace->screen->logical_monitors[i].rect,
workspace->all_struts); workspace->all_struts);
} }
workspace->screen_region = workspace->screen_region =
@ -861,11 +861,11 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
/* Now find the work areas for each monitor */ /* Now find the work areas for each monitor */
g_free (workspace->work_area_monitor); g_free (workspace->work_area_monitor);
workspace->work_area_monitor = g_new (MetaRectangle, workspace->work_area_monitor = g_new (MetaRectangle,
workspace->screen->n_monitor_infos); workspace->screen->n_logical_monitors);
for (i = 0; i < workspace->screen->n_monitor_infos; i++) for (i = 0; i < workspace->screen->n_logical_monitors; i++)
{ {
work_area = workspace->screen->monitor_infos[i].rect; work_area = workspace->screen->logical_monitors[i].rect;
if (workspace->monitor_region[i] == NULL) if (workspace->monitor_region[i] == NULL)
/* FIXME: constraints.c untested with this, but it might be nice for /* FIXME: constraints.c untested with this, but it might be nice for
@ -907,8 +907,8 @@ ensure_work_areas_validated (MetaWorkspace *workspace)
meta_rectangle_find_onscreen_edges (&workspace->screen->rect, meta_rectangle_find_onscreen_edges (&workspace->screen->rect,
workspace->all_struts); workspace->all_struts);
tmp = NULL; tmp = NULL;
for (i = 0; i < workspace->screen->n_monitor_infos; i++) for (i = 0; i < workspace->screen->n_logical_monitors; i++)
tmp = g_list_prepend (tmp, &workspace->screen->monitor_infos[i].rect); tmp = g_list_prepend (tmp, &workspace->screen->logical_monitors[i].rect);
workspace->monitor_edges = workspace->monitor_edges =
meta_rectangle_find_nonintersected_monitor_edges (tmp, meta_rectangle_find_nonintersected_monitor_edges (tmp,
workspace->all_struts); workspace->all_struts);
@ -1016,7 +1016,7 @@ meta_workspace_get_work_area_for_monitor (MetaWorkspace *workspace,
g_assert (which_monitor >= 0); g_assert (which_monitor >= 0);
ensure_work_areas_validated (workspace); ensure_work_areas_validated (workspace);
g_assert (which_monitor < workspace->screen->n_monitor_infos); g_assert (which_monitor < workspace->screen->n_logical_monitors);
*area = workspace->work_area_monitor[which_monitor]; *area = workspace->work_area_monitor[which_monitor];
} }

100
src/wayland/meta-wayland-outputs.c
View File

@ -56,23 +56,21 @@ output_resource_destroy (struct wl_resource *res)
static void static void
send_output_events (struct wl_resource *resource, send_output_events (struct wl_resource *resource,
MetaWaylandOutput *wayland_output, MetaWaylandOutput *wayland_output,
MetaMonitorInfo *monitor_info, MetaLogicalMonitor *logical_monitor,
gboolean need_all_events) gboolean need_all_events)
{ {
int version = wl_resource_get_version (resource); int version = wl_resource_get_version (resource);
MetaOutput *output = logical_monitor->outputs[0];
MetaOutput *output = monitor_info->outputs[0];
guint mode_flags = WL_OUTPUT_MODE_CURRENT; guint mode_flags = WL_OUTPUT_MODE_CURRENT;
MetaLogicalMonitor *old_logical_monitor = wayland_output->logical_monitor;
MetaMonitorInfo *old_monitor_info = wayland_output->monitor_info;
guint old_mode_flags = wayland_output->mode_flags; guint old_mode_flags = wayland_output->mode_flags;
gint old_scale = wayland_output->scale; gint old_scale = wayland_output->scale;
gboolean need_done = FALSE; gboolean need_done = FALSE;
if (need_all_events || if (need_all_events ||
old_monitor_info->rect.x != monitor_info->rect.x || old_logical_monitor->rect.x != logical_monitor->rect.x ||
old_monitor_info->rect.y != monitor_info->rect.y) old_logical_monitor->rect.y != logical_monitor->rect.y)
{ {
/* /*
* TODO: When we support wl_surface.set_buffer_transform, pass along * TODO: When we support wl_surface.set_buffer_transform, pass along
@ -81,10 +79,10 @@ send_output_events (struct wl_resource *resource,
* transform other than 'normal'. * transform other than 'normal'.
*/ */
wl_output_send_geometry (resource, wl_output_send_geometry (resource,
(int)monitor_info->rect.x, logical_monitor->rect.x,
(int)monitor_info->rect.y, logical_monitor->rect.y,
monitor_info->width_mm, logical_monitor->width_mm,
monitor_info->height_mm, logical_monitor->height_mm,
output->subpixel_order, output->subpixel_order,
output->vendor, output->vendor,
output->product, output->product,
@ -96,16 +94,16 @@ send_output_events (struct wl_resource *resource,
mode_flags |= WL_OUTPUT_MODE_PREFERRED; mode_flags |= WL_OUTPUT_MODE_PREFERRED;
if (need_all_events || if (need_all_events ||
old_monitor_info->rect.width != monitor_info->rect.width || old_logical_monitor->rect.width != logical_monitor->rect.width ||
old_monitor_info->rect.height != monitor_info->rect.height || old_logical_monitor->rect.height != logical_monitor->rect.height ||
old_monitor_info->refresh_rate != monitor_info->refresh_rate || old_logical_monitor->refresh_rate != logical_monitor->refresh_rate ||
old_mode_flags != mode_flags) old_mode_flags != mode_flags)
{ {
wl_output_send_mode (resource, wl_output_send_mode (resource,
mode_flags, mode_flags,
(int)monitor_info->rect.width, logical_monitor->rect.width,
(int)monitor_info->rect.height, logical_monitor->rect.height,
(int)(monitor_info->refresh_rate * 1000)); (int32_t) (logical_monitor->refresh_rate * 1000));
need_done = TRUE; need_done = TRUE;
} }
@ -130,9 +128,9 @@ bind_output (struct wl_client *client,
guint32 id) guint32 id)
{ {
MetaWaylandOutput *wayland_output = data; MetaWaylandOutput *wayland_output = data;
MetaMonitorInfo *monitor_info = wayland_output->monitor_info; MetaLogicalMonitor *logical_monitor = wayland_output->logical_monitor;
struct wl_resource *resource; struct wl_resource *resource;
MetaOutput *output = monitor_info->outputs[0]; MetaOutput *output = logical_monitor->outputs[0];
resource = wl_resource_create (client, &wl_output_interface, version, id); resource = wl_resource_create (client, &wl_output_interface, version, id);
wayland_output->resources = g_list_prepend (wayland_output->resources, resource); wayland_output->resources = g_list_prepend (wayland_output->resources, resource);
@ -141,12 +139,12 @@ bind_output (struct wl_client *client,
wl_resource_set_destructor (resource, output_resource_destroy); wl_resource_set_destructor (resource, output_resource_destroy);
meta_verbose ("Binding monitor %p/%s (%u, %u, %u, %u) x %f\n", meta_verbose ("Binding monitor %p/%s (%u, %u, %u, %u) x %f\n",
monitor_info, output->name, logical_monitor, output->name,
monitor_info->rect.x, monitor_info->rect.y, logical_monitor->rect.x, logical_monitor->rect.y,
monitor_info->rect.width, monitor_info->rect.height, logical_monitor->rect.width, logical_monitor->rect.height,
monitor_info->refresh_rate); logical_monitor->refresh_rate);
send_output_events (resource, wayland_output, monitor_info, TRUE); send_output_events (resource, wayland_output, logical_monitor, TRUE);
} }
static void static void
@ -159,12 +157,12 @@ wayland_output_destroy_notify (gpointer data)
} }
static void static void
wayland_output_set_monitor_info (MetaWaylandOutput *wayland_output, meta_wayland_output_set_logical_monitor (MetaWaylandOutput *wayland_output,
MetaMonitorInfo *monitor_info) MetaLogicalMonitor *logical_monitor)
{ {
MetaOutput *output = monitor_info->outputs[0]; MetaOutput *output = logical_monitor->outputs[0];
wayland_output->monitor_info = monitor_info; wayland_output->logical_monitor = logical_monitor;
wayland_output->mode_flags = WL_OUTPUT_MODE_CURRENT; wayland_output->mode_flags = WL_OUTPUT_MODE_CURRENT;
if (output->crtc->current_mode == output->preferred_mode) if (output->crtc->current_mode == output->preferred_mode)
wayland_output->mode_flags |= WL_OUTPUT_MODE_PREFERRED; wayland_output->mode_flags |= WL_OUTPUT_MODE_PREFERRED;
@ -172,25 +170,25 @@ wayland_output_set_monitor_info (MetaWaylandOutput *wayland_output,
} }
static void static void
wayland_output_update_for_output (MetaWaylandOutput *wayland_output, wayland_output_update_for_output (MetaWaylandOutput *wayland_output,
MetaMonitorInfo *monitor_info) MetaLogicalMonitor *logical_monitor)
{ {
GList *iter; GList *iter;
for (iter = wayland_output->resources; iter; iter = iter->next) for (iter = wayland_output->resources; iter; iter = iter->next)
{ {
struct wl_resource *resource = iter->data; struct wl_resource *resource = iter->data;
send_output_events (resource, wayland_output, monitor_info, FALSE); send_output_events (resource, wayland_output, logical_monitor, FALSE);
} }
/* It's very important that we change the output pointer here, as /* It's very important that we change the output pointer here, as
the old structure is about to be freed by MetaMonitorManager */ the old structure is about to be freed by MetaMonitorManager */
wayland_output_set_monitor_info (wayland_output, monitor_info); meta_wayland_output_set_logical_monitor (wayland_output, logical_monitor);
} }
static MetaWaylandOutput * static MetaWaylandOutput *
meta_wayland_output_new (MetaWaylandCompositor *compositor, meta_wayland_output_new (MetaWaylandCompositor *compositor,
MetaMonitorInfo *monitor_info) MetaLogicalMonitor *logical_monitor)
{ {
MetaWaylandOutput *wayland_output; MetaWaylandOutput *wayland_output;
@ -199,7 +197,7 @@ meta_wayland_output_new (MetaWaylandCompositor *compositor,
&wl_output_interface, &wl_output_interface,
META_WL_OUTPUT_VERSION, META_WL_OUTPUT_VERSION,
wayland_output, bind_output); wayland_output, bind_output);
wayland_output_set_monitor_info (wayland_output, monitor_info); meta_wayland_output_set_logical_monitor (wayland_output, logical_monitor);
return wayland_output; return wayland_output;
} }
@ -210,30 +208,40 @@ meta_wayland_compositor_update_outputs (MetaWaylandCompositor *compositor,
{ {
unsigned int i; unsigned int i;
GHashTable *new_table; GHashTable *new_table;
MetaMonitorInfo *monitor_infos; MetaLogicalMonitor *logical_monitors;
unsigned int n_monitor_infos; unsigned int n_logical_monitors;
monitor_infos = meta_monitor_manager_get_monitor_infos (monitors, &n_monitor_infos); logical_monitors = meta_monitor_manager_get_logical_monitors (monitors,
new_table = g_hash_table_new_full (NULL, NULL, NULL, wayland_output_destroy_notify); &n_logical_monitors);
new_table = g_hash_table_new_full (NULL, NULL, NULL,
wayland_output_destroy_notify);
for (i = 0; i < n_monitor_infos; i++) for (i = 0; i < n_logical_monitors; i++)
{ {
MetaMonitorInfo *info = &monitor_infos[i]; MetaLogicalMonitor *logical_monitor = &logical_monitors[i];
MetaWaylandOutput *wayland_output; MetaWaylandOutput *wayland_output;
if (info->winsys_id == 0) if (logical_monitor->winsys_id == 0)
continue; continue;
wayland_output = g_hash_table_lookup (compositor->outputs, GSIZE_TO_POINTER (info->winsys_id));
wayland_output =
g_hash_table_lookup (compositor->outputs,
GSIZE_TO_POINTER (logical_monitor->winsys_id));
if (wayland_output) if (wayland_output)
{ {
g_hash_table_steal (compositor->outputs, GSIZE_TO_POINTER (info->winsys_id)); g_hash_table_steal (compositor->outputs,
GSIZE_TO_POINTER (logical_monitor->winsys_id));
} }
else else
wayland_output = meta_wayland_output_new (compositor, info); {
wayland_output = meta_wayland_output_new (compositor, logical_monitor);
}
wayland_output_update_for_output (wayland_output, info); wayland_output_update_for_output (wayland_output, logical_monitor);
g_hash_table_insert (new_table, GSIZE_TO_POINTER (info->winsys_id), wayland_output); g_hash_table_insert (new_table,
GSIZE_TO_POINTER (logical_monitor->winsys_id),
wayland_output);
} }
g_hash_table_destroy (compositor->outputs); g_hash_table_destroy (compositor->outputs);

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

@ -37,7 +37,7 @@ struct _MetaWaylandOutput
GObject parent; GObject parent;
struct wl_global *global; struct wl_global *global;
MetaMonitorInfo *monitor_info; MetaLogicalMonitor *logical_monitor;
guint mode_flags; guint mode_flags;
gint scale; gint scale;

20
src/wayland/meta-wayland-surface-role-cursor.c
View File

@ -98,14 +98,20 @@ cursor_sprite_prepare_at (MetaCursorSprite *cursor_sprite,
MetaWaylandSurface *surface = meta_wayland_surface_role_get_surface (role); MetaWaylandSurface *surface = meta_wayland_surface_role_get_surface (role);
MetaDisplay *display = meta_get_display (); MetaDisplay *display = meta_get_display ();
MetaScreen *screen = display->screen; MetaScreen *screen = display->screen;
const MetaMonitorInfo *monitor;
if (!meta_xwayland_is_xwayland_surface (surface)) if (!meta_xwayland_is_xwayland_surface (surface))
{ {
monitor = meta_screen_get_monitor_for_point (screen, x, y); const MetaLogicalMonitor *logical_monitor;
if (monitor)
meta_cursor_sprite_set_texture_scale (cursor_sprite, logical_monitor = meta_screen_get_logical_monitor_for_point (screen,
(float) monitor->scale / surface->scale); x, y);
if (logical_monitor)
{
float texture_scale;
texture_scale = (float) logical_monitor->scale / surface->scale;
meta_cursor_sprite_set_texture_scale (cursor_sprite, texture_scale);
}
} }
meta_wayland_surface_update_outputs (surface); meta_wayland_surface_update_outputs (surface);
} }
@ -172,7 +178,7 @@ cursor_surface_role_commit (MetaWaylandSurfaceRole *surface_role,
static gboolean static gboolean
cursor_surface_role_is_on_output (MetaWaylandSurfaceRole *role, cursor_surface_role_is_on_output (MetaWaylandSurfaceRole *role,
MetaMonitorInfo *monitor) MetaLogicalMonitor *logical_monitor)
{ {
MetaWaylandSurface *surface = MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (role); meta_wayland_surface_role_get_surface (role);
@ -184,7 +190,7 @@ cursor_surface_role_is_on_output (MetaWaylandSurfaceRole *role,
rect = meta_cursor_renderer_calculate_rect (priv->cursor_renderer, rect = meta_cursor_renderer_calculate_rect (priv->cursor_renderer,
priv->cursor_sprite); priv->cursor_sprite);
return meta_rectangle_overlap (&rect, &monitor->rect); return meta_rectangle_overlap (&rect, &logical_monitor->rect);
} }
static void static void

18
src/wayland/meta-wayland-surface.c
View File

@ -148,7 +148,7 @@ meta_wayland_surface_role_commit (MetaWaylandSurfaceRole *surface_role,
static gboolean static gboolean
meta_wayland_surface_role_is_on_output (MetaWaylandSurfaceRole *surface_role, meta_wayland_surface_role_is_on_output (MetaWaylandSurfaceRole *surface_role,
MetaMonitorInfo *info); MetaLogicalMonitor *logical_monitor);
static MetaWaylandSurface * static MetaWaylandSurface *
meta_wayland_surface_role_get_toplevel (MetaWaylandSurfaceRole *surface_role); meta_wayland_surface_role_get_toplevel (MetaWaylandSurfaceRole *surface_role);
@ -1171,14 +1171,14 @@ set_surface_is_on_output (MetaWaylandSurface *surface,
static gboolean static gboolean
actor_surface_is_on_output (MetaWaylandSurfaceRole *surface_role, actor_surface_is_on_output (MetaWaylandSurfaceRole *surface_role,
MetaMonitorInfo *monitor) MetaLogicalMonitor *logical_monitor)
{ {
MetaWaylandSurface *surface = MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (surface_role); meta_wayland_surface_role_get_surface (surface_role);
MetaSurfaceActorWayland *actor = MetaSurfaceActorWayland *actor =
META_SURFACE_ACTOR_WAYLAND (surface->surface_actor); META_SURFACE_ACTOR_WAYLAND (surface->surface_actor);
return meta_surface_actor_wayland_is_on_monitor (actor, monitor); return meta_surface_actor_wayland_is_on_monitor (actor, logical_monitor);
} }
static void static void
@ -1186,19 +1186,19 @@ update_surface_output_state (gpointer key, gpointer value, gpointer user_data)
{ {
MetaWaylandOutput *wayland_output = value; MetaWaylandOutput *wayland_output = value;
MetaWaylandSurface *surface = user_data; MetaWaylandSurface *surface = user_data;
MetaMonitorInfo *monitor; MetaLogicalMonitor *logical_monitor;
gboolean is_on_output; gboolean is_on_output;
g_assert (surface->role); g_assert (surface->role);
monitor = wayland_output->monitor_info; logical_monitor = wayland_output->logical_monitor;
if (!monitor) if (!logical_monitor)
{ {
set_surface_is_on_output (surface, wayland_output, FALSE); set_surface_is_on_output (surface, wayland_output, FALSE);
return; return;
} }
is_on_output = meta_wayland_surface_role_is_on_output (surface->role, monitor); is_on_output = meta_wayland_surface_role_is_on_output (surface->role, logical_monitor);
set_surface_is_on_output (surface, wayland_output, is_on_output); set_surface_is_on_output (surface, wayland_output, is_on_output);
} }
@ -1925,13 +1925,13 @@ meta_wayland_surface_role_commit (MetaWaylandSurfaceRole *surface_role,
static gboolean static gboolean
meta_wayland_surface_role_is_on_output (MetaWaylandSurfaceRole *surface_role, meta_wayland_surface_role_is_on_output (MetaWaylandSurfaceRole *surface_role,
MetaMonitorInfo *monitor) MetaLogicalMonitor *logical_monitor)
{ {
MetaWaylandSurfaceRoleClass *klass; MetaWaylandSurfaceRoleClass *klass;
klass = META_WAYLAND_SURFACE_ROLE_GET_CLASS (surface_role); klass = META_WAYLAND_SURFACE_ROLE_GET_CLASS (surface_role);
if (klass->is_on_output) if (klass->is_on_output)
return klass->is_on_output (surface_role, monitor); return klass->is_on_output (surface_role, logical_monitor);
else else
return FALSE; return FALSE;
} }

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

@ -61,7 +61,7 @@ struct _MetaWaylandSurfaceRoleClass
void (*commit) (MetaWaylandSurfaceRole *surface_role, void (*commit) (MetaWaylandSurfaceRole *surface_role,
MetaWaylandPendingState *pending); MetaWaylandPendingState *pending);
gboolean (*is_on_output) (MetaWaylandSurfaceRole *surface_role, gboolean (*is_on_output) (MetaWaylandSurfaceRole *surface_role,
MetaMonitorInfo *monitor); MetaLogicalMonitor *logical_monitor);
MetaWaylandSurface * (*get_toplevel) (MetaWaylandSurfaceRole *surface_role); MetaWaylandSurface * (*get_toplevel) (MetaWaylandSurfaceRole *surface_role);
}; };

14
src/wayland/meta-window-wayland.c
View File

@ -335,9 +335,9 @@ static void
meta_window_wayland_update_main_monitor (MetaWindow *window) meta_window_wayland_update_main_monitor (MetaWindow *window)
{ {
MetaWindow *toplevel_window; MetaWindow *toplevel_window;
const MetaMonitorInfo *from; const MetaLogicalMonitor *from;
const MetaMonitorInfo *to; const MetaLogicalMonitor *to;
const MetaMonitorInfo *scaled_new; const MetaLogicalMonitor *scaled_new;
float scale; float scale;
MetaRectangle rect; MetaRectangle rect;
@ -357,7 +357,7 @@ meta_window_wayland_update_main_monitor (MetaWindow *window)
* needed to avoid jumping back and forth between the new and the old, since * needed to avoid jumping back and forth between the new and the old, since
* changing main monitor may cause the window to be resized so that it no * changing main monitor may cause the window to be resized so that it no
* longer have that same new main monitor. */ * longer have that same new main monitor. */
to = meta_screen_calculate_monitor_for_window (window->screen, window); to = meta_screen_calculate_logical_monitor_for_window (window->screen, window);
if (from == to) if (from == to)
return; return;
@ -376,7 +376,7 @@ meta_window_wayland_update_main_monitor (MetaWindow *window)
scale = (float)to->scale / from->scale; scale = (float)to->scale / from->scale;
rect = window->rect; rect = window->rect;
scale_rect_size (&rect, scale); scale_rect_size (&rect, scale);
scaled_new = meta_screen_get_monitor_for_rect (window->screen, &rect); scaled_new = meta_screen_get_logical_monitor_for_rect (window->screen, &rect);
if (to != scaled_new) if (to != scaled_new)
return; return;
@ -384,8 +384,8 @@ meta_window_wayland_update_main_monitor (MetaWindow *window)
} }
static void static void
meta_window_wayland_main_monitor_changed (MetaWindow *window, meta_window_wayland_main_monitor_changed (MetaWindow *window,
const MetaMonitorInfo *old) const MetaLogicalMonitor *old)
{ {
float scale_factor; float scale_factor;
MetaWaylandSurface *surface; MetaWaylandSurface *surface;

8
src/x11/window-x11.c
View File

@ -1457,13 +1457,13 @@ meta_window_x11_update_icon (MetaWindow *window,
static void static void
meta_window_x11_update_main_monitor (MetaWindow *window) meta_window_x11_update_main_monitor (MetaWindow *window)
{ {
window->monitor = meta_screen_calculate_monitor_for_window (window->screen, window->monitor =
window); meta_screen_calculate_logical_monitor_for_window (window->screen, window);
} }
static void static void
meta_window_x11_main_monitor_changed (MetaWindow *window, meta_window_x11_main_monitor_changed (MetaWindow *window,
const MetaMonitorInfo *old) const MetaLogicalMonitor *old)
{ {
} }