sungmg/mutter-performance-source
1
0
Fork 0
Code Activity

mtk: Move MetaMonitorTransform to Mtk

Browse source 
This makes it possible to use MtkMonitorTransform in Clutter which will
be used to track the transform in ClutterStageView.

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/3930>
This commit is contained in:
Sebastian Wick 2024-08-07 22:02:44 +02:00 committed by Marge Bot
parent 54b2abfe1b
commit 89af55d8aa
70 changed files with 692 additions and 681 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
mtk/mtk/meson.build
View file

@ -5,11 +5,13 @@ mtk_headers = [
'mtk-macros.h',
'mtk-rectangle.h',
'mtk-region.h',
'mtk-monitor-transform.h',
]
mtk_sources = [
'mtk-rectangle.c',
'mtk-region.c',
'mtk-monitor-transform.c',
]
if have_x11_client

132
src/backends/meta-monitor-transform.c → mtk/mtk/mtk-monitor-transform.c
View file

@ -1,4 +1,8 @@
/*
* Mtk
*
* A low-level base library.
*
* Copyright (C) 2018 Robert Mader
*
* This program is free software; you can redistribute it and/or
@ -17,85 +21,85 @@
#include "config.h"
#include "backends/meta-monitor-transform.h"
#include "mtk/mtk-monitor-transform.h"
MetaMonitorTransform
meta_monitor_transform_invert (MetaMonitorTransform transform)
MtkMonitorTransform
mtk_monitor_transform_invert (MtkMonitorTransform transform)
{
switch (transform)
{
case META_MONITOR_TRANSFORM_90:
return META_MONITOR_TRANSFORM_270;
case META_MONITOR_TRANSFORM_270:
return META_MONITOR_TRANSFORM_90;
case META_MONITOR_TRANSFORM_NORMAL:
case META_MONITOR_TRANSFORM_180:
case META_MONITOR_TRANSFORM_FLIPPED:
case META_MONITOR_TRANSFORM_FLIPPED_90:
case META_MONITOR_TRANSFORM_FLIPPED_180:
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_90:
return MTK_MONITOR_TRANSFORM_270;
case MTK_MONITOR_TRANSFORM_270:
return MTK_MONITOR_TRANSFORM_90;
case MTK_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
return transform;
}
g_assert_not_reached ();
return 0;
}
static MetaMonitorTransform
meta_monitor_transform_flip (MetaMonitorTransform transform)
static MtkMonitorTransform
mtk_monitor_transform_flip (MtkMonitorTransform transform)
{
switch (transform)
{
case META_MONITOR_TRANSFORM_NORMAL:
return META_MONITOR_TRANSFORM_FLIPPED;
case META_MONITOR_TRANSFORM_90:
return META_MONITOR_TRANSFORM_FLIPPED_270;
case META_MONITOR_TRANSFORM_180:
return META_MONITOR_TRANSFORM_FLIPPED_180;
case META_MONITOR_TRANSFORM_270:
return META_MONITOR_TRANSFORM_FLIPPED_90;
case META_MONITOR_TRANSFORM_FLIPPED:
return META_MONITOR_TRANSFORM_NORMAL;
case META_MONITOR_TRANSFORM_FLIPPED_90:
return META_MONITOR_TRANSFORM_270;
case META_MONITOR_TRANSFORM_FLIPPED_180:
return META_MONITOR_TRANSFORM_180;
case META_MONITOR_TRANSFORM_FLIPPED_270:
return META_MONITOR_TRANSFORM_90;
case MTK_MONITOR_TRANSFORM_NORMAL:
return MTK_MONITOR_TRANSFORM_FLIPPED;
case MTK_MONITOR_TRANSFORM_90:
return MTK_MONITOR_TRANSFORM_FLIPPED_270;
case MTK_MONITOR_TRANSFORM_180:
return MTK_MONITOR_TRANSFORM_FLIPPED_180;
case MTK_MONITOR_TRANSFORM_270:
return MTK_MONITOR_TRANSFORM_FLIPPED_90;
case MTK_MONITOR_TRANSFORM_FLIPPED:
return MTK_MONITOR_TRANSFORM_NORMAL;
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
return MTK_MONITOR_TRANSFORM_270;
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
return MTK_MONITOR_TRANSFORM_180;
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
return MTK_MONITOR_TRANSFORM_90;
}
g_assert_not_reached ();
return 0;
}
MetaMonitorTransform
meta_monitor_transform_transform (MetaMonitorTransform transform,
MetaMonitorTransform other)
MtkMonitorTransform
mtk_monitor_transform_transform (MtkMonitorTransform transform,
MtkMonitorTransform other)
{
MetaMonitorTransform new_transform;
MtkMonitorTransform new_transform;
gboolean needs_flip = FALSE;
if (meta_monitor_transform_is_flipped (other))
new_transform = meta_monitor_transform_flip (transform);
if (mtk_monitor_transform_is_flipped (other))
new_transform = mtk_monitor_transform_flip (transform);
else
new_transform = transform;
if (meta_monitor_transform_is_flipped (new_transform))
if (mtk_monitor_transform_is_flipped (new_transform))
needs_flip = TRUE;
new_transform += other;
new_transform %= META_MONITOR_TRANSFORM_FLIPPED;
new_transform %= MTK_MONITOR_TRANSFORM_FLIPPED;
if (needs_flip)
new_transform += META_MONITOR_TRANSFORM_FLIPPED;
new_transform += MTK_MONITOR_TRANSFORM_FLIPPED;
return new_transform;
}
void
meta_monitor_transform_transform_point (MetaMonitorTransform transform,
int *area_width,
int *area_height,
int *point_x,
int *point_y)
mtk_monitor_transform_transform_point (MtkMonitorTransform transform,
int *area_width,
int *area_height,
int *point_x,
int *point_y)
{
int old_x = *point_x;
int old_y = *point_y;
@ -108,49 +112,49 @@ meta_monitor_transform_transform_point (MetaMonitorTransform transform,
switch (transform)
{
case META_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_NORMAL:
new_x = old_x;
new_y = old_y;
new_width = old_width;
new_height = old_height;
break;
case META_MONITOR_TRANSFORM_90:
case MTK_MONITOR_TRANSFORM_90:
new_x = old_y;
new_y = old_width - old_x;
new_width = old_height;
new_height = old_width;
break;
case META_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_180:
new_x = old_width - old_x;
new_y = old_height - old_y;
new_width = old_width;
new_height = old_height;
break;
case META_MONITOR_TRANSFORM_270:
case MTK_MONITOR_TRANSFORM_270:
new_x = old_height - old_y;
new_y = old_x;
new_width = old_height;
new_height = old_width;
break;
case META_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_FLIPPED:
new_x = old_width - old_x;
new_y = old_y;
new_width = old_width;
new_height = old_height;
break;
case META_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
new_x = old_y;
new_y = old_x;
new_width = old_height;
new_height = old_width;
break;
case META_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
new_x = old_x;
new_y = old_height - old_y;
new_width = old_width;
new_height = old_height;
break;
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
new_x = old_height - old_y;
new_y = old_width - old_x;
new_width = old_height;
@ -165,47 +169,47 @@ meta_monitor_transform_transform_point (MetaMonitorTransform transform,
}
void
meta_monitor_transform_transform_matrix (MetaMonitorTransform transform,
graphene_matrix_t *matrix)
mtk_monitor_transform_transform_matrix (MtkMonitorTransform transform,
graphene_matrix_t *matrix)
{
graphene_euler_t euler;
if (transform == META_MONITOR_TRANSFORM_NORMAL)
if (transform == MTK_MONITOR_TRANSFORM_NORMAL)
return;
graphene_matrix_translate (matrix,
&GRAPHENE_POINT3D_INIT (-0.5, -0.5, 0.0));
switch (transform)
{
case META_MONITOR_TRANSFORM_90:
case MTK_MONITOR_TRANSFORM_90:
graphene_euler_init_with_order (&euler, 0.0, 0.0, 270.0,
GRAPHENE_EULER_ORDER_SYXZ);
break;
case META_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_180:
graphene_euler_init_with_order (&euler, 0.0, 0.0, 180.0,
GRAPHENE_EULER_ORDER_SYXZ);
break;
case META_MONITOR_TRANSFORM_270:
case MTK_MONITOR_TRANSFORM_270:
graphene_euler_init_with_order (&euler, 0.0, 0.0, 90.0,
GRAPHENE_EULER_ORDER_SYXZ);
break;
case META_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_FLIPPED:
graphene_euler_init_with_order (&euler, 0.0, 180.0, 0.0,
GRAPHENE_EULER_ORDER_SYXZ);
break;
case META_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
graphene_euler_init_with_order (&euler, 0.0, 180.0, 90.0,
GRAPHENE_EULER_ORDER_SYXZ);
break;
case META_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
graphene_euler_init_with_order (&euler, 0.0, 180.0, 180.0,
GRAPHENE_EULER_ORDER_SYXZ);
break;
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
graphene_euler_init_with_order (&euler, 0.0, 180.0, 270.0,
GRAPHENE_EULER_ORDER_SYXZ);
break;
case META_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_NORMAL:
g_assert_not_reached ();
}
graphene_matrix_rotate_euler (matrix, &euler);

77
mtk/mtk/mtk-monitor-transform.h Normal file
View file

@ -0,0 +1,77 @@
/*
* Mtk
*
* A low-level base library.
*
* Copyright (C) 2013 Red Hat Inc.
* Copyright (C) 2018 Robert Mader
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <glib-object.h>
#include <graphene.h>
#include "mtk/mtk-macros.h"
typedef enum _MtkMonitorTransform
{
MTK_MONITOR_TRANSFORM_NORMAL,
MTK_MONITOR_TRANSFORM_90,
MTK_MONITOR_TRANSFORM_180,
MTK_MONITOR_TRANSFORM_270,
MTK_MONITOR_TRANSFORM_FLIPPED,
MTK_MONITOR_TRANSFORM_FLIPPED_90,
MTK_MONITOR_TRANSFORM_FLIPPED_180,
MTK_MONITOR_TRANSFORM_FLIPPED_270,
} MtkMonitorTransform;
#define MTK_MONITOR_N_TRANSFORMS (MTK_MONITOR_TRANSFORM_FLIPPED_270 + 1)
#define MTK_MONITOR_ALL_TRANSFORMS ((1 << MTK_MONITOR_N_TRANSFORMS) - 1)
/* Returns true if transform causes width and height to be inverted
This is true for the odd transforms in the enum */
static inline gboolean
mtk_monitor_transform_is_rotated (MtkMonitorTransform transform)
{
return (transform % 2);
}
/* Returns true if transform involves flipping */
static inline gboolean
mtk_monitor_transform_is_flipped (MtkMonitorTransform transform)
{
return (transform >= MTK_MONITOR_TRANSFORM_FLIPPED);
}
MTK_EXPORT
MtkMonitorTransform mtk_monitor_transform_invert (MtkMonitorTransform transform);
MTK_EXPORT
MtkMonitorTransform mtk_monitor_transform_transform (MtkMonitorTransform transform,
MtkMonitorTransform other);
MTK_EXPORT
void mtk_monitor_transform_transform_point (MtkMonitorTransform transform,
int *area_width,
int *area_height,
int *point_x,
int *point_y);
MTK_EXPORT
void mtk_monitor_transform_transform_matrix (MtkMonitorTransform transform,
graphene_matrix_t *matrix);

1
mtk/mtk/mtk.h
View file

@ -26,5 +26,6 @@
#include "mtk/mtk-rectangle.h"
#include "mtk/mtk-region.h"
#include "mtk/mtk-macros.h"
#include "mtk/mtk-monitor-transform.h"
#undef __MTK_H_INSIDE__

2
src/backends/meta-backend-types.h
View file

@ -44,8 +44,6 @@ typedef struct _MetaMonitorTiled MetaMonitorTiled;
typedef struct _MetaMonitorSpec MetaMonitorSpec;
typedef struct _MetaLogicalMonitor MetaLogicalMonitor;
typedef enum _MetaMonitorTransform MetaMonitorTransform;
typedef struct _MetaMonitorMode MetaMonitorMode;
typedef struct _MetaGpu MetaGpu;

16
src/backends/meta-crtc.c
View file

@ -42,7 +42,7 @@ typedef struct _MetaCrtcPrivate
MetaBackend *backend;
MetaGpu *gpu;
MetaMonitorTransform all_transforms;
MtkMonitorTransform all_transforms;
GList *outputs;
MetaCrtcConfig *config;
@ -102,7 +102,7 @@ meta_crtc_unassign_output (MetaCrtc *crtc,
priv->outputs = g_list_remove (priv->outputs, output);
}
MetaMonitorTransform
MtkMonitorTransform
meta_crtc_get_all_transforms (MetaCrtc *crtc)
{
MetaCrtcPrivate *priv = meta_crtc_get_instance_private (crtc);
@ -419,7 +419,7 @@ meta_crtc_init (MetaCrtc *crtc)
{
MetaCrtcPrivate *priv = meta_crtc_get_instance_private (crtc);
priv->all_transforms = META_MONITOR_ALL_TRANSFORMS;
priv->all_transforms = MTK_MONITOR_ALL_TRANSFORMS;
}
static void
@ -452,8 +452,8 @@ meta_crtc_class_init (MetaCrtcClass *klass)
obj_props[PROP_ALL_TRANSFORMS] =
g_param_spec_uint ("all-transforms", NULL, NULL,
0,
META_MONITOR_ALL_TRANSFORMS,
META_MONITOR_ALL_TRANSFORMS,
MTK_MONITOR_ALL_TRANSFORMS,
MTK_MONITOR_ALL_TRANSFORMS,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
@ -461,9 +461,9 @@ meta_crtc_class_init (MetaCrtcClass *klass)
}
MetaCrtcConfig *
meta_crtc_config_new (graphene_rect_t *layout,
MetaCrtcMode *mode,
MetaMonitorTransform transform)
meta_crtc_config_new (graphene_rect_t *layout,
MetaCrtcMode *mode,
MtkMonitorTransform transform)
{
MetaCrtcConfig *config;

12
src/backends/meta-crtc.h
View file

@ -21,14 +21,14 @@
#include "backends/meta-backend-types.h"
#include "backends/meta-crtc-mode.h"
#include "backends/meta-monitor-transform.h"
#include "core/util-private.h"
#include "meta/boxes.h"
#include "mtk/mtk.h"
typedef struct _MetaCrtcConfig
{
graphene_rect_t layout;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
MetaCrtcMode *mode;
} MetaCrtcConfig;
@ -80,7 +80,7 @@ META_EXPORT_TEST
void meta_crtc_unassign_output (MetaCrtc *crtc,
MetaOutput *output);
MetaMonitorTransform meta_crtc_get_all_transforms (MetaCrtc *crtc);
MtkMonitorTransform meta_crtc_get_all_transforms (MetaCrtc *crtc);
META_EXPORT_TEST
void meta_crtc_set_config (MetaCrtc *crtc,
@ -132,9 +132,9 @@ gboolean meta_gamma_lut_equal (const MetaGammaLut *gamma,
const MetaGammaLut *other_gamma);
META_EXPORT_TEST
MetaCrtcConfig * meta_crtc_config_new (graphene_rect_t *layout,
MetaCrtcMode *mode,
MetaMonitorTransform transform);
MetaCrtcConfig * meta_crtc_config_new (graphene_rect_t *layout,
MetaCrtcMode *mode,
MtkMonitorTransform transform);
gboolean meta_crtc_is_leased (MetaCrtc *crtc);

2
src/backends/meta-cursor-renderer.c
View file

@ -136,7 +136,7 @@ meta_cursor_renderer_update_stage_overlay (MetaCursorRenderer *renderer,
ClutterActor *stage = meta_backend_get_stage (priv->backend);
CoglTexture *texture = NULL;
graphene_rect_t rect = GRAPHENE_RECT_INIT_ZERO;
MetaMonitorTransform buffer_transform = META_MONITOR_TRANSFORM_NORMAL;
MtkMonitorTransform buffer_transform = MTK_MONITOR_TRANSFORM_NORMAL;
g_set_object (&priv->overlay_cursor, cursor_sprite);

10
src/backends/meta-cursor.c
View file

@ -55,7 +55,7 @@ typedef struct _MetaCursorSpritePrivate
CoglTexture2D *texture;
float texture_scale;
MetaMonitorTransform texture_transform;
MtkMonitorTransform texture_transform;
int hot_x, hot_y;
ClutterColorState *color_state;
@ -137,8 +137,8 @@ meta_cursor_sprite_set_texture_scale (MetaCursorSprite *sprite,
}
void
meta_cursor_sprite_set_texture_transform (MetaCursorSprite *sprite,
MetaMonitorTransform transform)
meta_cursor_sprite_set_texture_transform (MetaCursorSprite *sprite,
MtkMonitorTransform transform)
{
MetaCursorSpritePrivate *priv =
meta_cursor_sprite_get_instance_private (sprite);
@ -197,7 +197,7 @@ meta_cursor_sprite_get_texture_scale (MetaCursorSprite *sprite)
return priv->texture_scale;
}
MetaMonitorTransform
MtkMonitorTransform
meta_cursor_sprite_get_texture_transform (MetaCursorSprite *sprite)
{
MetaCursorSpritePrivate *priv =
@ -253,7 +253,7 @@ meta_cursor_sprite_init (MetaCursorSprite *sprite)
meta_cursor_sprite_get_instance_private (sprite);
priv->texture_scale = 1.0f;
priv->texture_transform = META_MONITOR_TRANSFORM_NORMAL;
priv->texture_transform = MTK_MONITOR_TRANSFORM_NORMAL;
}
static void

8
src/backends/meta-cursor.h
View file

@ -22,8 +22,10 @@
#pragma once
#include "backends/meta-backend-types.h"
#include "core/util-private.h"
#include "meta/common.h"
#include "meta/boxes.h"
#include "mtk/mtk.h"
#define META_TYPE_CURSOR_SPRITE (meta_cursor_sprite_get_type ())
G_DECLARE_DERIVABLE_TYPE (MetaCursorSprite,
@ -70,8 +72,8 @@ void meta_cursor_sprite_set_texture (MetaCursorSprite *sprite,
void meta_cursor_sprite_set_texture_scale (MetaCursorSprite *sprite,
float scale);
void meta_cursor_sprite_set_texture_transform (MetaCursorSprite *sprite,
MetaMonitorTransform transform);
void meta_cursor_sprite_set_texture_transform (MetaCursorSprite *sprite,
MtkMonitorTransform transform);
CoglTexture *meta_cursor_sprite_get_cogl_texture (MetaCursorSprite *sprite);
@ -85,7 +87,7 @@ int meta_cursor_sprite_get_height (MetaCursorSprite *sprite);
float meta_cursor_sprite_get_texture_scale (MetaCursorSprite *sprite);
MetaMonitorTransform meta_cursor_sprite_get_texture_transform (MetaCursorSprite *sprite);
MtkMonitorTransform meta_cursor_sprite_get_texture_transform (MetaCursorSprite *sprite);
gboolean meta_cursor_sprite_is_animated (MetaCursorSprite *sprite);

8
src/backends/meta-logical-monitor.c
View file

@ -101,13 +101,13 @@ meta_logical_monitor_new (MetaMonitorManager *monitor_manager,
return logical_monitor;
}
static MetaMonitorTransform
static MtkMonitorTransform
derive_monitor_transform (MetaMonitor *monitor)
{
MetaOutput *main_output;
MetaCrtc *crtc;
const MetaCrtcConfig *crtc_config;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
main_output = meta_monitor_get_main_output (monitor);
crtc = meta_output_get_assigned_crtc (main_output);
@ -125,7 +125,7 @@ meta_logical_monitor_new_derived (MetaMonitorManager *monitor_manager,
int monitor_number)
{
MetaLogicalMonitor *logical_monitor;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
logical_monitor = g_object_new (META_TYPE_LOGICAL_MONITOR, NULL);
@ -220,7 +220,7 @@ meta_logical_monitor_get_scale (MetaLogicalMonitor *logical_monitor)
return logical_monitor->scale;
}
MetaMonitorTransform
MtkMonitorTransform
meta_logical_monitor_get_transform (MetaLogicalMonitor *logical_monitor)
{
return logical_monitor->transform;

4
src/backends/meta-logical-monitor.h
View file

@ -39,7 +39,7 @@ struct _MetaLogicalMonitor
gboolean is_presentation; /* XXX: not yet used */
gboolean in_fullscreen;
float scale;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
GList *monitors;
};
@ -77,7 +77,7 @@ void meta_logical_monitor_make_primary (MetaLogicalMonitor *logical_monitor);
float meta_logical_monitor_get_scale (MetaLogicalMonitor *logical_monitor);
MetaMonitorTransform meta_logical_monitor_get_transform (MetaLogicalMonitor *logical_monitor);
MtkMonitorTransform meta_logical_monitor_get_transform (MetaLogicalMonitor *logical_monitor);
META_EXPORT_TEST
MtkRectangle meta_logical_monitor_get_layout (MetaLogicalMonitor *logical_monitor);

30
src/backends/meta-monitor-config-manager.c
View file

@ -178,8 +178,8 @@ assign_monitor_crtc (MetaMonitor *monitor,
MonitorAssignmentData *data = user_data;
MetaOutput *output;
MetaCrtc *crtc;
MetaMonitorTransform transform;
MetaMonitorTransform crtc_transform;
MtkMonitorTransform transform;
MtkMonitorTransform crtc_transform;
int crtc_x, crtc_y;
float x_offset, y_offset;
float scale = 0.0;
@ -231,7 +231,7 @@ assign_monitor_crtc (MetaMonitor *monitor,
crtc_mode = monitor_crtc_mode->crtc_mode;
crtc_mode_info = meta_crtc_mode_get_info (monitor_crtc_mode->crtc_mode);
if (meta_monitor_transform_is_rotated (crtc_transform))
if (mtk_monitor_transform_is_rotated (crtc_transform))
{
width = crtc_mode_info->height / scale;
height = crtc_mode_info->width / scale;
@ -697,7 +697,7 @@ create_monitor_config (MetaMonitor *monitor,
return monitor_config;
}
static MetaMonitorTransform
static MtkMonitorTransform
get_monitor_transform (MetaMonitorManager *monitor_manager,
MetaMonitor *monitor)
{
@ -707,7 +707,7 @@ get_monitor_transform (MetaMonitorManager *monitor_manager,
if (!meta_monitor_is_laptop_panel (monitor) ||
!meta_monitor_manager_get_panel_orientation_managed (monitor_manager))
return META_MONITOR_TRANSFORM_NORMAL;
return MTK_MONITOR_TRANSFORM_NORMAL;
backend = meta_monitor_manager_get_backend (monitor_manager);
orientation_manager = meta_backend_get_orientation_manager (backend);
@ -749,7 +749,7 @@ create_preferred_logical_monitor_config (MetaMonitorManager *monitor_ma
{
MetaMonitorMode *mode;
int width, height;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
MetaMonitorConfig *monitor_config;
MetaLogicalMonitorConfig *logical_monitor_config;
@ -761,7 +761,7 @@ create_preferred_logical_monitor_config (MetaMonitorManager *monitor_ma
monitor_config = create_monitor_config (monitor, mode);
transform = get_monitor_transform (monitor_manager, monitor);
if (meta_monitor_transform_is_rotated (transform))
if (mtk_monitor_transform_is_rotated (transform))
{
int temp = width;
width = height;
@ -1120,7 +1120,7 @@ static MetaMonitorsConfig *
create_for_builtin_display_rotation (MetaMonitorConfigManager *config_manager,
MetaMonitorsConfig *base_config,
gboolean rotate,
MetaMonitorTransform transform)
MtkMonitorTransform transform)
{
MetaMonitorManager *monitor_manager = config_manager->monitor_manager;
MetaLogicalMonitorConfig *logical_monitor_config;
@ -1138,7 +1138,7 @@ create_for_builtin_display_rotation (MetaMonitorConfigManager *config_manager,
return NULL;
if (rotate)
transform = (current_logical_monitor_config->transform + 1) % META_MONITOR_TRANSFORM_FLIPPED;
transform = (current_logical_monitor_config->transform + 1) % MTK_MONITOR_TRANSFORM_FLIPPED;
else
{
/*
@ -1164,8 +1164,8 @@ create_for_builtin_display_rotation (MetaMonitorConfigManager *config_manager,
logical_monitor_configs);
logical_monitor_config->transform = transform;
if (meta_monitor_transform_is_rotated (current_logical_monitor_config->transform) !=
meta_monitor_transform_is_rotated (logical_monitor_config->transform))
if (mtk_monitor_transform_is_rotated (current_logical_monitor_config->transform) !=
mtk_monitor_transform_is_rotated (logical_monitor_config->transform))
{
int temp = logical_monitor_config->layout.width;
logical_monitor_config->layout.width = logical_monitor_config->layout.height;
@ -1185,7 +1185,7 @@ create_for_builtin_display_rotation (MetaMonitorConfigManager *config_manager,
MetaMonitorsConfig *
meta_monitor_config_manager_create_for_orientation (MetaMonitorConfigManager *config_manager,
MetaMonitorsConfig *base_config,
MetaMonitorTransform transform)
MtkMonitorTransform transform)
{
return create_for_builtin_display_rotation (config_manager, base_config,
FALSE, transform);
@ -1196,7 +1196,7 @@ meta_monitor_config_manager_create_for_builtin_orientation (MetaMonitorConfigMan
MetaMonitorsConfig *base_config)
{
MetaMonitorManager *monitor_manager = config_manager->monitor_manager;
MetaMonitorTransform current_transform;
MtkMonitorTransform current_transform;
MetaMonitor *laptop_panel;
g_return_val_if_fail (
@ -1218,7 +1218,7 @@ meta_monitor_config_manager_create_for_rotate_monitor (MetaMonitorConfigManager
return create_for_builtin_display_rotation (config_manager,
config_manager->current_config,
TRUE,
META_MONITOR_TRANSFORM_NORMAL);
MTK_MONITOR_TRANSFORM_NORMAL);
}
static MetaMonitorsConfig *
@ -1837,7 +1837,7 @@ meta_verify_logical_monitor_config (MetaLogicalMonitorConfig *logical_monitor
return FALSE;
}
if (meta_monitor_transform_is_rotated (logical_monitor_config->transform))
if (mtk_monitor_transform_is_rotated (logical_monitor_config->transform))
{
expected_mode_width = logical_monitor_config->layout.height;
expected_mode_height = logical_monitor_config->layout.width;

4
src/backends/meta-monitor-config-manager.h
View file

@ -40,7 +40,7 @@ typedef struct _MetaLogicalMonitorConfig
{
MtkRectangle layout;
GList *monitor_configs;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
float scale;
gboolean is_primary;
gboolean is_presentation;
@ -107,7 +107,7 @@ MetaMonitorsConfig * meta_monitor_config_manager_create_suggested (MetaMonitorCo
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_create_for_orientation (MetaMonitorConfigManager *config_manager,
MetaMonitorsConfig *base_config,
MetaMonitorTransform transform);
MtkMonitorTransform transform);
META_EXPORT_TEST
MetaMonitorsConfig * meta_monitor_config_manager_create_for_builtin_orientation (MetaMonitorConfigManager *config_manager,

32
src/backends/meta-monitor-config-migration.c
View file

@ -69,7 +69,7 @@ typedef struct
gboolean enabled;
MtkRectangle rect;
float refresh_rate;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
gboolean is_primary;
gboolean is_presentation;
@ -579,20 +579,20 @@ handle_text (GMarkupParseContext *context,
else if (strcmp (parser->output_field, "rotation") == 0)
{
if (strncmp (text, "normal", text_len) == 0)
parser->output.transform = META_MONITOR_TRANSFORM_NORMAL;
parser->output.transform = MTK_MONITOR_TRANSFORM_NORMAL;
else if (strncmp (text, "left", text_len) == 0)
parser->output.transform = META_MONITOR_TRANSFORM_90;
parser->output.transform = MTK_MONITOR_TRANSFORM_90;
else if (strncmp (text, "upside_down", text_len) == 0)
parser->output.transform = META_MONITOR_TRANSFORM_180;
parser->output.transform = MTK_MONITOR_TRANSFORM_180;
else if (strncmp (text, "right", text_len) == 0)
parser->output.transform = META_MONITOR_TRANSFORM_270;
parser->output.transform = MTK_MONITOR_TRANSFORM_270;
else
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"Invalid rotation type %.*s", (int)text_len, text);
}
else if (strcmp (parser->output_field, "reflect_x") == 0)
parser->output.transform += read_bool (text, text_len, error) ?
META_MONITOR_TRANSFORM_FLIPPED : 0;
MTK_MONITOR_TRANSFORM_FLIPPED : 0;
else if (strcmp (parser->output_field, "reflect_y") == 0)
{
if (read_bool (text, text_len, error))
@ -728,7 +728,7 @@ try_derive_tiled_monitor_config (MetaLegacyMonitorsConfig *config,
MonitorTile bottom_left_tile = { 0 };
MonitorTile bottom_right_tile = { 0 };
MonitorTile origin_tile = { 0 };
MetaMonitorTransform transform = output_config->transform;
MtkMonitorTransform transform = output_config->transform;
unsigned int i;
int max_x = 0;
int min_x = INT_MAX;
@ -810,42 +810,42 @@ try_derive_tiled_monitor_config (MetaLegacyMonitorsConfig *config,
switch (transform)
{
case META_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_NORMAL:
origin_tile = top_left_tile;
mode_width = max_x - min_x;
mode_height = max_y - min_y;
break;
case META_MONITOR_TRANSFORM_90:
case MTK_MONITOR_TRANSFORM_90:
origin_tile = bottom_left_tile;
mode_width = max_y - min_y;
mode_height = max_x - min_x;
break;
case META_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_180:
origin_tile = bottom_right_tile;
mode_width = max_x - min_x;
mode_height = max_y - min_y;
break;
case META_MONITOR_TRANSFORM_270:
case MTK_MONITOR_TRANSFORM_270:
origin_tile = top_right_tile;
mode_width = max_y - min_y;
mode_height = max_x - min_x;
break;
case META_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_FLIPPED:
origin_tile = bottom_left_tile;
mode_width = max_x - min_x;
mode_height = max_y - min_y;
break;
case META_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
origin_tile = bottom_right_tile;
mode_width = max_y - min_y;
mode_height = max_x - min_x;
break;
case META_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
origin_tile = top_right_tile;
mode_width = max_x - min_x;
mode_height = max_y - min_y;
break;
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
origin_tile = top_left_tile;
mode_width = max_y - min_y;
mode_height = max_x - min_x;
@ -891,7 +891,7 @@ derive_monitor_config (MetaOutputKey *output_key,
int mode_height;
MetaMonitorConfig *monitor_config;
if (meta_monitor_transform_is_rotated (output_config->transform))
if (mtk_monitor_transform_is_rotated (output_config->transform))
{
mode_width = output_config->rect.height;
mode_height = output_config->rect.width;

34
src/backends/meta-monitor-config-store.c
View file

@ -189,7 +189,7 @@ typedef struct
GList *current_logical_monitor_configs;
MetaMonitorSpec *current_monitor_spec;
gboolean current_transform_flipped;
MetaMonitorTransform current_transform;
MtkMonitorTransform current_transform;
MetaMonitorModeSpec *current_monitor_mode_spec;
MetaMonitorConfig *current_monitor_config;
MetaLogicalMonitorConfig *current_logical_monitor_config;
@ -701,7 +701,7 @@ derive_logical_monitor_layout (MetaLogicalMonitorConfig *logical_monitor_conf
}
}
if (meta_monitor_transform_is_rotated (logical_monitor_config->transform))
if (mtk_monitor_transform_is_rotated (logical_monitor_config->transform))
{
width = mode_height;
height = mode_width;
@ -793,10 +793,10 @@ handle_end_element (GMarkupParseContext *context,
if (parser->current_transform_flipped)
{
parser->current_logical_monitor_config->transform +=
META_MONITOR_TRANSFORM_FLIPPED;
MTK_MONITOR_TRANSFORM_FLIPPED;
}
parser->current_transform = META_MONITOR_TRANSFORM_NORMAL;
parser->current_transform = MTK_MONITOR_TRANSFORM_NORMAL;
parser->current_transform_flipped = FALSE;
parser->state = STATE_LOGICAL_MONITOR;
@ -1303,13 +1303,13 @@ handle_text (GMarkupParseContext *context,
case STATE_TRANSFORM_ROTATION:
{
if (text_equals (text, text_len, "normal"))
parser->current_transform = META_MONITOR_TRANSFORM_NORMAL;
parser->current_transform = MTK_MONITOR_TRANSFORM_NORMAL;
else if (text_equals (text, text_len, "left"))
parser->current_transform = META_MONITOR_TRANSFORM_90;
parser->current_transform = MTK_MONITOR_TRANSFORM_90;
else if (text_equals (text, text_len, "upside_down"))
parser->current_transform = META_MONITOR_TRANSFORM_180;
parser->current_transform = MTK_MONITOR_TRANSFORM_180;
else if (text_equals (text, text_len, "right"))
parser->current_transform = META_MONITOR_TRANSFORM_270;
parser->current_transform = MTK_MONITOR_TRANSFORM_270;
else
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
"Invalid rotation type %.*s", (int)text_len, text);
@ -1653,37 +1653,37 @@ bool_to_string (gboolean value)
static void
append_transform (GString *buffer,
MetaMonitorTransform transform)
MtkMonitorTransform transform)
{
const char *rotation = NULL;
gboolean flipped = FALSE;
switch (transform)
{
case META_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_NORMAL:
return;
case META_MONITOR_TRANSFORM_90:
case MTK_MONITOR_TRANSFORM_90:
rotation = "left";
break;
case META_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_180:
rotation = "upside_down";
break;
case META_MONITOR_TRANSFORM_270:
case MTK_MONITOR_TRANSFORM_270:
rotation = "right";
break;
case META_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_FLIPPED:
rotation = "normal";
flipped = TRUE;
break;
case META_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
rotation = "left";
flipped = TRUE;
break;
case META_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
rotation = "upside_down";
flipped = TRUE;
break;
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
rotation = "right";
flipped = TRUE;
break;

4
src/backends/meta-monitor-manager-private.h
View file

@ -34,11 +34,11 @@
#include "backends/meta-crtc.h"
#include "backends/meta-cursor.h"
#include "backends/meta-display-config-shared.h"
#include "backends/meta-monitor-transform.h"
#include "backends/meta-viewport-info.h"
#include "core/util-private.h"
#include "meta/display.h"
#include "meta/meta-monitor-manager.h"
#include "mtk/mtk.h"
#define META_MONITOR_MANAGER_MIN_SCREEN_WIDTH 640
#define META_MONITOR_MANAGER_MIN_SCREEN_HEIGHT 480
@ -85,7 +85,7 @@ struct _MetaCrtcAssignment
MetaCrtc *crtc;
MetaCrtcMode *mode;
graphene_rect_t layout;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
GPtrArray *outputs;
gpointer backend_private;

30
src/backends/meta-monitor-manager.c
View file

@ -92,7 +92,7 @@ enum
SIGNALS_LAST
};
/* Array index matches MetaMonitorTransform */
/* Array index matches MtkMonitorTransform */
static gfloat transform_matrices[][6] = {
{ 1, 0, 0, 0, 1, 0 }, /* normal */
{ 0, -1, 1, 1, 0, 0 }, /* 90° */
@ -887,8 +887,8 @@ handle_orientation_change (MetaOrientationManager *orientation_manager,
MetaMonitorManager *manager)
{
MetaOrientation orientation;
MetaMonitorTransform transform;
MetaMonitorTransform panel_transform;
MtkMonitorTransform transform;
MtkMonitorTransform panel_transform;
GError *error = NULL;
MetaMonitorsConfig *config;
MetaMonitor *laptop_panel;
@ -1643,7 +1643,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
const MetaCrtcConfig *crtc_config;
g_variant_builder_init (&transforms, G_VARIANT_TYPE ("au"));
for (j = 0; j <= META_MONITOR_TRANSFORM_FLIPPED_270; j++)
for (j = 0; j <= MTK_MONITOR_TRANSFORM_FLIPPED_270; j++)
{
if (meta_crtc_get_all_transforms (crtc) & (1 << j))
g_variant_builder_add (&transforms, "u", j);
@ -1677,7 +1677,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
0,
0,
-1,
(uint32_t) META_MONITOR_TRANSFORM_NORMAL,
(uint32_t) MTK_MONITOR_TRANSFORM_NORMAL,
&transforms,
NULL /* properties */);
}
@ -2506,17 +2506,17 @@ find_monitor_mode_scale (MetaMonitorManager *manager,
}
static gboolean
derive_logical_monitor_size (MetaMonitorConfig *monitor_config,
int *out_width,
int *out_height,
float scale,
MetaMonitorTransform transform,
MetaLogicalMonitorLayoutMode layout_mode,
GError **error)
derive_logical_monitor_size (MetaMonitorConfig *monitor_config,
int *out_width,
int *out_height,
float scale,
MtkMonitorTransform transform,
MetaLogicalMonitorLayoutMode layout_mode,
GError **error)
{
int width, height;
if (meta_monitor_transform_is_rotated (transform))
if (mtk_monitor_transform_is_rotated (transform))
{
width = monitor_config->mode_spec->height;
height = monitor_config->mode_spec->width;
@ -2553,7 +2553,7 @@ create_logical_monitor_config_from_variant (MetaMonitorManager *manager
int x, y, width, height;
double scale_d;
float scale;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
gboolean is_primary;
GVariantIter *monitor_configs_iter;
GList *monitor_configs = NULL;
@ -3773,7 +3773,7 @@ meta_monitor_manager_get_monitor_matrix (MetaMonitorManager *manager,
MetaLogicalMonitor *logical_monitor,
gfloat matrix[6])
{
MetaMonitorTransform transform;
MtkMonitorTransform transform;
gfloat viewport[9];
if (!calculate_viewport_matrix (manager, logical_monitor, viewport))

70
src/backends/meta-monitor-transform.h
View file

@ -1,70 +0,0 @@
/*
* Copyright (C) 2013 Red Hat Inc.
* Copyright (C) 2018 Robert Mader
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <glib-object.h>
#include "backends/meta-backend-types.h"
#include "meta/meta-orientation-manager.h"
#include "core/util-private.h"
enum _MetaMonitorTransform
{
META_MONITOR_TRANSFORM_NORMAL,
META_MONITOR_TRANSFORM_90,
META_MONITOR_TRANSFORM_180,
META_MONITOR_TRANSFORM_270,
META_MONITOR_TRANSFORM_FLIPPED,
META_MONITOR_TRANSFORM_FLIPPED_90,
META_MONITOR_TRANSFORM_FLIPPED_180,
META_MONITOR_TRANSFORM_FLIPPED_270,
};
#define META_MONITOR_N_TRANSFORMS (META_MONITOR_TRANSFORM_FLIPPED_270 + 1)
#define META_MONITOR_ALL_TRANSFORMS ((1 << META_MONITOR_N_TRANSFORMS) - 1)
/* Returns true if transform causes width and height to be inverted
This is true for the odd transforms in the enum */
static inline gboolean
meta_monitor_transform_is_rotated (MetaMonitorTransform transform)
{
return (transform % 2);
}
/* Returns true if transform involves flipping */
static inline gboolean
meta_monitor_transform_is_flipped (MetaMonitorTransform transform)
{
return (transform >= META_MONITOR_TRANSFORM_FLIPPED);
}
META_EXPORT_TEST
MetaMonitorTransform meta_monitor_transform_invert (MetaMonitorTransform transform);
META_EXPORT_TEST
MetaMonitorTransform meta_monitor_transform_transform (MetaMonitorTransform transform,
MetaMonitorTransform other);
void meta_monitor_transform_transform_point (MetaMonitorTransform transform,
int *area_width,
int *area_height,
int *point_x,
int *point_y);
void meta_monitor_transform_transform_matrix (MetaMonitorTransform transform,
graphene_matrix_t *matrix);

66
src/backends/meta-monitor.c
View file

@ -545,18 +545,18 @@ meta_monitor_get_connector_type (MetaMonitor *monitor)
return output_info->connector_type;
}
MetaMonitorTransform
MtkMonitorTransform
meta_monitor_logical_to_crtc_transform (MetaMonitor *monitor,
MetaMonitorTransform transform)
MtkMonitorTransform transform)
{
MetaOutput *output = meta_monitor_get_main_output (monitor);
return meta_output_logical_to_crtc_transform (output, transform);
}
MetaMonitorTransform
meta_monitor_crtc_to_logical_transform (MetaMonitor *monitor,
MetaMonitorTransform transform)
MtkMonitorTransform
meta_monitor_crtc_to_logical_transform (MetaMonitor *monitor,
MtkMonitorTransform transform)
{
MetaOutput *output = meta_monitor_get_main_output (monitor);
@ -665,7 +665,7 @@ meta_monitor_create_spec (MetaMonitor *monitor,
const MetaCrtcModeInfo *crtc_mode_info =
meta_crtc_mode_get_info (crtc_mode);
if (meta_monitor_transform_is_rotated (output_info->panel_orientation_transform))
if (mtk_monitor_transform_is_rotated (output_info->panel_orientation_transform))
{
int temp = width;
width = height;
@ -893,12 +893,12 @@ meta_monitor_normal_get_suggested_position (MetaMonitor *monitor,
}
static void
meta_monitor_normal_calculate_crtc_pos (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
MetaOutput *output,
MetaMonitorTransform crtc_transform,
int *out_x,
int *out_y)
meta_monitor_normal_calculate_crtc_pos (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
MetaOutput *output,
MtkMonitorTransform crtc_transform,
int *out_x,
int *out_y)
{
*out_x = 0;
*out_y = 0;
@ -968,7 +968,7 @@ add_tiled_monitor_outputs (MetaGpu *gpu,
static void
calculate_tile_coordinate (MetaMonitor *monitor,
MetaOutput *output,
MetaMonitorTransform crtc_transform,
MtkMonitorTransform crtc_transform,
int *out_x,
int *out_y)
{
@ -985,8 +985,8 @@ calculate_tile_coordinate (MetaMonitor *monitor,
switch (crtc_transform)
{
case META_MONITOR_TRANSFORM_NORMAL:
case META_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_FLIPPED:
if ((other_output_info->tile_info.loc_v_tile ==
output_info->tile_info.loc_v_tile) &&
(other_output_info->tile_info.loc_h_tile <
@ -998,8 +998,8 @@ calculate_tile_coordinate (MetaMonitor *monitor,
output_info->tile_info.loc_v_tile))
y += other_output_info->tile_info.tile_h;
break;
case META_MONITOR_TRANSFORM_180:
case META_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
if ((other_output_info->tile_info.loc_v_tile ==
output_info->tile_info.loc_v_tile) &&
(other_output_info->tile_info.loc_h_tile >
@ -1011,8 +1011,8 @@ calculate_tile_coordinate (MetaMonitor *monitor,
output_info->tile_info.loc_v_tile))
y += other_output_info->tile_info.tile_h;
break;
case META_MONITOR_TRANSFORM_270:
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_270:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
if ((other_output_info->tile_info.loc_v_tile ==
output_info->tile_info.loc_v_tile) &&
(other_output_info->tile_info.loc_h_tile >
@ -1024,8 +1024,8 @@ calculate_tile_coordinate (MetaMonitor *monitor,
output_info->tile_info.loc_v_tile))
x += other_output_info->tile_info.tile_h;
break;
case META_MONITOR_TRANSFORM_90:
case META_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
if ((other_output_info->tile_info.loc_v_tile ==
output_info->tile_info.loc_v_tile) &&
(other_output_info->tile_info.loc_h_tile <
@ -1623,12 +1623,12 @@ meta_monitor_tiled_get_suggested_position (MetaMonitor *monitor,
}
static void
meta_monitor_tiled_calculate_crtc_pos (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
MetaOutput *output,
MetaMonitorTransform crtc_transform,
int *out_x,
int *out_y)
meta_monitor_tiled_calculate_crtc_pos (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
MetaOutput *output,
MtkMonitorTransform crtc_transform,
int *out_x,
int *out_y)
{
MetaMonitorModeTiled *mode_tiled = (MetaMonitorModeTiled *) monitor_mode;
@ -1827,12 +1827,12 @@ meta_monitor_get_modes (MetaMonitor *monitor)
}
void
meta_monitor_calculate_crtc_pos (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
MetaOutput *output,
MetaMonitorTransform crtc_transform,
int *out_x,
int *out_y)
meta_monitor_calculate_crtc_pos (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
MetaOutput *output,
MtkMonitorTransform crtc_transform,
int *out_x,
int *out_y)
{
META_MONITOR_GET_CLASS (monitor)->calculate_crtc_pos (monitor,
monitor_mode,

32
src/backends/meta-monitor.h
View file

@ -73,12 +73,12 @@ struct _MetaMonitorClass
MetaOutput * (* get_main_output) (MetaMonitor *monitor);
void (* derive_layout) (MetaMonitor *monitor,
MtkRectangle *layout);
void (* calculate_crtc_pos) (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
MetaOutput *output,
MetaMonitorTransform crtc_transform,
int *out_x,
int *out_y);
void (* calculate_crtc_pos) (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
MetaOutput *output,
MtkMonitorTransform crtc_transform,
int *out_x,
int *out_y);
gboolean (* get_suggested_position) (MetaMonitor *monitor,
int *width,
int *height);
@ -171,15 +171,15 @@ MetaConnectorType meta_monitor_get_connector_type (MetaMonitor *monitor);
/* This function returns the transform corrected for the panel orientation */
META_EXPORT_TEST
MetaMonitorTransform meta_monitor_logical_to_crtc_transform (MetaMonitor *monitor,
MetaMonitorTransform transform);
MtkMonitorTransform meta_monitor_logical_to_crtc_transform (MetaMonitor *monitor,
MtkMonitorTransform transform);
/*
* This function converts a transform corrected for the panel orientation
* to its logical (user-visible) transform.
*/
META_EXPORT_TEST
MetaMonitorTransform meta_monitor_crtc_to_logical_transform (MetaMonitor *monitor,
MetaMonitorTransform transform);
MtkMonitorTransform meta_monitor_crtc_to_logical_transform (MetaMonitor *monitor,
MtkMonitorTransform transform);
META_EXPORT_TEST
uint32_t meta_monitor_tiled_get_tile_group_id (MetaMonitorTiled *monitor_tiled);
@ -221,12 +221,12 @@ META_EXPORT_TEST
GList * meta_monitor_get_modes (MetaMonitor *monitor);
META_EXPORT_TEST
void meta_monitor_calculate_crtc_pos (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
MetaOutput *output,
MetaMonitorTransform crtc_transform,
int *out_x,
int *out_y);
void meta_monitor_calculate_crtc_pos (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
MetaOutput *output,
MtkMonitorTransform crtc_transform,
int *out_x,
int *out_y);
META_EXPORT_TEST
float meta_monitor_calculate_mode_scale (MetaMonitor *monitor,

10
src/backends/meta-orientation-manager.c
View file

@ -75,21 +75,21 @@ G_DEFINE_TYPE (MetaOrientationManager, meta_orientation_manager, G_TYPE_OBJECT)
#define CONF_SCHEMA "org.gnome.settings-daemon.peripherals.touchscreen"
#define ORIENTATION_LOCK_KEY "orientation-lock"
MetaMonitorTransform
MtkMonitorTransform
meta_orientation_to_transform (MetaOrientation orientation)
{
switch (orientation)
{
case META_ORIENTATION_BOTTOM_UP:
return META_MONITOR_TRANSFORM_180;
return MTK_MONITOR_TRANSFORM_180;
case META_ORIENTATION_LEFT_UP:
return META_MONITOR_TRANSFORM_90;
return MTK_MONITOR_TRANSFORM_90;
case META_ORIENTATION_RIGHT_UP:
return META_MONITOR_TRANSFORM_270;
return MTK_MONITOR_TRANSFORM_270;
case META_ORIENTATION_UNDEFINED:
case META_ORIENTATION_NORMAL:
default:
return META_MONITOR_TRANSFORM_NORMAL;
return MTK_MONITOR_TRANSFORM_NORMAL;
}
}

26
src/backends/meta-output.c
View file

@ -300,29 +300,29 @@ meta_output_get_assigned_crtc (MetaOutput *output)
return priv->crtc;
}
MetaMonitorTransform
meta_output_logical_to_crtc_transform (MetaOutput *output,
MetaMonitorTransform transform)
MtkMonitorTransform
meta_output_logical_to_crtc_transform (MetaOutput *output,
MtkMonitorTransform transform)
{
MetaOutputPrivate *priv = meta_output_get_instance_private (output);
MetaMonitorTransform panel_orientation_transform;
MtkMonitorTransform panel_orientation_transform;
panel_orientation_transform = priv->info->panel_orientation_transform;
return meta_monitor_transform_transform (transform,
panel_orientation_transform);
return mtk_monitor_transform_transform (transform,
panel_orientation_transform);
}
MetaMonitorTransform
meta_output_crtc_to_logical_transform (MetaOutput *output,
MetaMonitorTransform transform)
MtkMonitorTransform
meta_output_crtc_to_logical_transform (MetaOutput *output,
MtkMonitorTransform transform)
{
MetaOutputPrivate *priv = meta_output_get_instance_private (output);
MetaMonitorTransform inverted_panel_orientation_transform;
MtkMonitorTransform inverted_panel_orientation_transform;
inverted_panel_orientation_transform =
meta_monitor_transform_invert (priv->info->panel_orientation_transform);
return meta_monitor_transform_transform (transform,
inverted_panel_orientation_transform);
mtk_monitor_transform_invert (priv->info->panel_orientation_transform);
return mtk_monitor_transform_transform (transform,
inverted_panel_orientation_transform);
}
static void

10
src/backends/meta-output.h
View file

@ -144,7 +144,7 @@ typedef struct _MetaOutputInfo
MetaSubpixelOrder subpixel_order;
MetaConnectorType connector_type;
MetaMonitorTransform panel_orientation_transform;
MtkMonitorTransform panel_orientation_transform;
MetaCrtcMode *preferred_mode;
MetaCrtcMode **modes;
@ -303,11 +303,11 @@ void meta_output_unassign_crtc (MetaOutput *output);
META_EXPORT_TEST
MetaCrtc * meta_output_get_assigned_crtc (MetaOutput *output);
MetaMonitorTransform meta_output_logical_to_crtc_transform (MetaOutput *output,
MetaMonitorTransform transform);
MtkMonitorTransform meta_output_logical_to_crtc_transform (MetaOutput *output,
MtkMonitorTransform transform);
MetaMonitorTransform meta_output_crtc_to_logical_transform (MetaOutput *output,
MetaMonitorTransform transform);
MtkMonitorTransform meta_output_crtc_to_logical_transform (MetaOutput *output,
MtkMonitorTransform transform);
void meta_output_update_modes (MetaOutput *output,
MetaCrtcMode *preferred_mode,

21
src/backends/meta-renderer-view.c
View file

@ -24,7 +24,7 @@
* global stage, or more precisely: the part that matches what can be seen on a
* #MetaLogicalMonitor. By splitting up the rendering into different parts and
* attaching it to a #MetaLogicalMonitor, we can do the rendering so that each
* renderer view is responsible for applying the right #MetaMonitorTransform
* renderer view is responsible for applying the right #MtkMonitorTransform
* and the right scaling.
*/
@ -51,15 +51,14 @@ static GParamSpec *obj_props[PROP_LAST];
typedef struct _MetaRendererViewPrivate
{
MetaMonitorTransform transform;
MtkMonitorTransform transform;
MetaCrtc *crtc;
} MetaRendererViewPrivate;
G_DEFINE_TYPE_WITH_PRIVATE (MetaRendererView, meta_renderer_view,
META_TYPE_STAGE_VIEW)
MetaMonitorTransform
MtkMonitorTransform
meta_renderer_view_get_transform (MetaRendererView *view)
{
MetaRendererViewPrivate *priv =
@ -87,8 +86,8 @@ meta_renderer_view_get_offscreen_transformation_matrix (ClutterStageView *view,
graphene_matrix_init_identity (matrix);
meta_monitor_transform_transform_matrix (
meta_monitor_transform_invert (priv->transform), matrix);
mtk_monitor_transform_transform_matrix (
mtk_monitor_transform_invert (priv->transform), matrix);
}
static void
@ -120,8 +119,8 @@ meta_renderer_view_transform_rect_to_onscreen (ClutterStageView *view,
}
static void
meta_renderer_view_set_transform (MetaRendererView *view,
MetaMonitorTransform transform)
meta_renderer_view_set_transform (MetaRendererView *view,
MtkMonitorTransform transform)
{
MetaRendererViewPrivate *priv =
meta_renderer_view_get_instance_private (view);
@ -204,9 +203,9 @@ meta_renderer_view_class_init (MetaRendererViewClass *klass)
obj_props[PROP_TRANSFORM] =
g_param_spec_uint ("transform", NULL, NULL,
META_MONITOR_TRANSFORM_NORMAL,
META_MONITOR_TRANSFORM_FLIPPED_270,
META_MONITOR_TRANSFORM_NORMAL,
MTK_MONITOR_TRANSFORM_NORMAL,
MTK_MONITOR_TRANSFORM_FLIPPED_270,
MTK_MONITOR_TRANSFORM_NORMAL,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);

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

@ -32,7 +32,7 @@ struct _MetaRendererViewClass
MetaStageViewClass parent_class;
};
MetaMonitorTransform meta_renderer_view_get_transform (MetaRendererView *view);
MtkMonitorTransform meta_renderer_view_get_transform (MetaRendererView *view);
META_EXPORT_TEST
MetaCrtc *meta_renderer_view_get_crtc (MetaRendererView *view);

2
src/backends/meta-screen-cast-area-stream-src.c
View file

@ -672,7 +672,7 @@ meta_screen_cast_area_stream_src_set_cursor_metadata (MetaScreenCastStreamSrc *s
float scale;
float cursor_scale;
float metadata_scale;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
scale = meta_screen_cast_area_stream_get_scale (area_stream);
cursor_scale = meta_cursor_sprite_get_texture_scale (cursor_sprite);

2
src/backends/meta-screen-cast-monitor-stream-src.c
View file

@ -856,7 +856,7 @@ meta_screen_cast_monitor_stream_src_set_cursor_metadata (MetaScreenCastStreamSrc
float view_scale;
float cursor_scale;
float scale;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
view_scale = get_view_scale (monitor_src);
cursor_scale = meta_cursor_sprite_get_texture_scale (cursor_sprite);

12
src/backends/meta-screen-cast-stream-src.c
View file

@ -320,7 +320,7 @@ draw_cursor_sprite_via_offscreen (MetaScreenCastStreamSrc *src,
CoglTexture *cursor_texture,
int bitmap_width,
int bitmap_height,
MetaMonitorTransform transform,
MtkMonitorTransform transform,
uint8_t *bitmap_data,
GError **error)
{
@ -364,8 +364,8 @@ draw_cursor_sprite_via_offscreen (MetaScreenCastStreamSrc *src,
COGL_PIPELINE_FILTER_LINEAR);
graphene_matrix_init_identity (&matrix);
meta_monitor_transform_transform_matrix (transform,
&matrix);
mtk_monitor_transform_transform_matrix (transform,
&matrix);
cogl_pipeline_set_layer_matrix (pipeline, 0, &matrix);
cogl_color_init_from_4f (&clear_color, 0.0, 0.0, 0.0, 0.0);
@ -388,7 +388,7 @@ gboolean
meta_screen_cast_stream_src_draw_cursor_into (MetaScreenCastStreamSrc *src,
CoglTexture *cursor_texture,
float scale,
MetaMonitorTransform transform,
MtkMonitorTransform transform,
uint8_t *data,
GError **error)
{
@ -402,7 +402,7 @@ meta_screen_cast_stream_src_draw_cursor_into (MetaScreenCastStreamSrc *src,
if (texture_width == width &&
texture_height == height &&
transform == META_MONITOR_TRANSFORM_NORMAL)
transform == MTK_MONITOR_TRANSFORM_NORMAL)
{
cogl_texture_get_data (cursor_texture,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
@ -478,7 +478,7 @@ meta_screen_cast_stream_src_set_cursor_sprite_metadata (MetaScreenCastStreamSrc
int x,
int y,
float scale,
MetaMonitorTransform transform)
MtkMonitorTransform transform)
{
CoglTexture *cursor_texture;
struct spa_meta_bitmap *spa_meta_bitmap;

4
src/backends/meta-screen-cast-stream-src.h
View file

@ -119,7 +119,7 @@ MetaScreenCastStream * meta_screen_cast_stream_src_get_stream (MetaScreenCastStr
gboolean meta_screen_cast_stream_src_draw_cursor_into (MetaScreenCastStreamSrc *src,
CoglTexture *cursor_texture,
float scale,
MetaMonitorTransform transform,
MtkMonitorTransform transform,
uint8_t *data,
GError **error);
@ -142,7 +142,7 @@ void meta_screen_cast_stream_src_set_cursor_sprite_metadata (MetaScreenCastStrea
int x,
int y,
float scale,
MetaMonitorTransform transform);
MtkMonitorTransform transform);
gboolean meta_screen_cast_stream_src_uses_dma_bufs (MetaScreenCastStreamSrc *src);

2
src/backends/meta-screen-cast-virtual-stream-src.c
View file

@ -610,7 +610,7 @@ meta_screen_cast_virtual_stream_src_set_cursor_metadata (MetaScreenCastStreamSrc
float view_scale;
float cursor_scale;
float scale;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
stage_view = view_from_src (src);
view_scale = clutter_stage_view_get_scale (stage_view);

10
src/backends/meta-screen-cast-window-stream-src.c
View file

@ -134,7 +134,7 @@ maybe_draw_cursor_sprite (MetaScreenCastWindowStreamSrc *window_src,
cairo_surface_t *stream_surface;
int width, height;
float scale;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
int hotspot_x, hotspot_y;
cairo_t *cr;
@ -215,7 +215,7 @@ maybe_blit_cursor_sprite (MetaScreenCastWindowStreamSrc *window_src,
CoglPipeline *pipeline;
int width, height;
float scale;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
int hotspot_x, hotspot_y;
float x, y;
graphene_matrix_t matrix;
@ -252,8 +252,8 @@ maybe_blit_cursor_sprite (MetaScreenCastWindowStreamSrc *window_src,
COGL_PIPELINE_FILTER_LINEAR);
graphene_matrix_init_identity (&matrix);
meta_monitor_transform_transform_matrix (transform,
&matrix);
mtk_monitor_transform_transform_matrix (transform,
&matrix);
cogl_pipeline_set_layer_matrix (pipeline, 0, &matrix);
cogl_framebuffer_draw_rectangle (framebuffer,
@ -636,7 +636,7 @@ meta_screen_cast_window_stream_src_set_cursor_metadata (MetaScreenCastStreamSrc
MetaCursorSprite *cursor_sprite;
graphene_point_t cursor_position;
float scale;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
graphene_point_t relative_cursor_position;
int x, y;

2
src/backends/meta-screen-cast-window.c
View file

@ -54,7 +54,7 @@ meta_screen_cast_window_transform_cursor_position (MetaScreenCastWindow *screen_
MetaCursorSprite *cursor_sprite,
graphene_point_t *cursor_position,
float *out_cursor_scale,
MetaMonitorTransform *out_cursor_transform,
MtkMonitorTransform *out_cursor_transform,
graphene_point_t *out_relative_cursor_position)
{
MetaScreenCastWindowInterface *iface =

4
src/backends/meta-screen-cast-window.h
View file

@ -47,7 +47,7 @@ struct _MetaScreenCastWindowInterface
MetaCursorSprite *cursor_sprite,
graphene_point_t *cursor_position,
float *out_cursor_scale,
MetaMonitorTransform *out_cursor_transform,
MtkMonitorTransform *out_cursor_transform,
graphene_point_t *out_relative_cursor_position);
void (*capture_into) (MetaScreenCastWindow *screen_cast_window,
@ -77,7 +77,7 @@ gboolean meta_screen_cast_window_transform_cursor_position (MetaScreenCastWindow
MetaCursorSprite *cursor_sprite,
graphene_point_t *cursor_position,
float *out_cursor_scale,
MetaMonitorTransform *out_cursor_transform,
MtkMonitorTransform *out_cursor_transform,
graphene_point_t *out_relative_cursor_position);
void meta_screen_cast_window_capture_into (MetaScreenCastWindow *screen_cast_window,

10
src/backends/meta-stage-private.h
View file

@ -48,11 +48,11 @@ MetaOverlay *meta_stage_create_cursor_overlay (MetaStage *stage);
void meta_stage_remove_cursor_overlay (MetaStage *stage,
MetaOverlay *overlay);
void meta_stage_update_cursor_overlay (MetaStage *stage,
MetaOverlay *overlay,
CoglTexture *texture,
graphene_rect_t *rect,
MetaMonitorTransform buffer_transform);
void meta_stage_update_cursor_overlay (MetaStage *stage,
MetaOverlay *overlay,
CoglTexture *texture,
graphene_rect_t *rect,
MtkMonitorTransform buffer_transform);
void meta_overlay_set_visible (MetaOverlay *overlay,
gboolean is_visible);

24
src/backends/meta-stage.c
View file

@ -47,7 +47,7 @@ struct _MetaOverlay
CoglPipeline *pipeline;
CoglTexture *texture;
MetaMonitorTransform buffer_transform;
MtkMonitorTransform buffer_transform;
graphene_rect_t current_rect;
graphene_rect_t previous_rect;
@ -92,10 +92,10 @@ meta_overlay_free (MetaOverlay *overlay)
}
static void
meta_overlay_set (MetaOverlay *overlay,
CoglTexture *texture,
graphene_rect_t *rect,
MetaMonitorTransform buffer_transform)
meta_overlay_set (MetaOverlay *overlay,
CoglTexture *texture,
graphene_rect_t *rect,
MtkMonitorTransform buffer_transform)
{
if (overlay->texture != texture)
{
@ -112,8 +112,8 @@ meta_overlay_set (MetaOverlay *overlay,
graphene_matrix_t matrix;
graphene_matrix_init_identity (&matrix);
meta_monitor_transform_transform_matrix (buffer_transform,
&matrix);
mtk_monitor_transform_transform_matrix (buffer_transform,
&matrix);
cogl_pipeline_set_layer_matrix (overlay->pipeline, 0, &matrix);
overlay->buffer_transform = buffer_transform;
@ -431,11 +431,11 @@ meta_stage_remove_cursor_overlay (MetaStage *stage,
}
void
meta_stage_update_cursor_overlay (MetaStage *stage,
MetaOverlay *overlay,
CoglTexture *texture,
graphene_rect_t *rect,
MetaMonitorTransform buffer_transform)
meta_stage_update_cursor_overlay (MetaStage *stage,
MetaOverlay *overlay,
CoglTexture *texture,
graphene_rect_t *rect,
MtkMonitorTransform buffer_transform)
{
meta_overlay_set (overlay, texture, rect, buffer_transform);
queue_redraw_for_overlay (stage, overlay);

4
src/backends/native/meta-crtc-kms.c
View file

@ -379,8 +379,8 @@ meta_crtc_kms_unset_config (MetaCrtc *crtc)
}
static gboolean
meta_crtc_kms_is_transform_handled (MetaCrtcNative *crtc_native,
MetaMonitorTransform transform)
meta_crtc_kms_is_transform_handled (MetaCrtcNative *crtc_native,
MtkMonitorTransform transform)
{
MetaCrtcKms *crtc_kms = META_CRTC_KMS (crtc_native);

4
src/backends/native/meta-crtc-native.c
View file

@ -23,8 +23,8 @@ G_DEFINE_ABSTRACT_TYPE (MetaCrtcNative, meta_crtc_native,
META_TYPE_CRTC)
gboolean
meta_crtc_native_is_transform_handled (MetaCrtcNative *crtc_native,
MetaMonitorTransform transform)
meta_crtc_native_is_transform_handled (MetaCrtcNative *crtc_native,
MtkMonitorTransform transform)
{
MetaCrtcNativeClass *klass = META_CRTC_NATIVE_GET_CLASS (crtc_native);

8
src/backends/native/meta-crtc-native.h
View file

@ -29,12 +29,12 @@ struct _MetaCrtcNativeClass
{
MetaCrtcClass parent_class;
gboolean (* is_transform_handled) (MetaCrtcNative *crtc_native,
MetaMonitorTransform monitor_transform);
gboolean (* is_transform_handled) (MetaCrtcNative *crtc_native,
MtkMonitorTransform monitor_transform);
gboolean (* is_hw_cursor_supported) (MetaCrtcNative *crtc_native);
};
gboolean meta_crtc_native_is_transform_handled (MetaCrtcNative *crtc_native,
MetaMonitorTransform transform);
gboolean meta_crtc_native_is_transform_handled (MetaCrtcNative *crtc_native,
MtkMonitorTransform transform);
gboolean meta_crtc_native_is_hw_cursor_supported (MetaCrtcNative *crtc_native);

6
src/backends/native/meta-crtc-virtual.c
View file

@ -58,10 +58,10 @@ meta_crtc_virtual_set_gamma_lut (MetaCrtc *crtc,
}
static gboolean
meta_crtc_virtual_is_transform_handled (MetaCrtcNative *crtc_native,
MetaMonitorTransform transform)
meta_crtc_virtual_is_transform_handled (MetaCrtcNative *crtc_native,
MtkMonitorTransform transform)
{
return transform == META_MONITOR_TRANSFORM_NORMAL;
return transform == MTK_MONITOR_TRANSFORM_NORMAL;
}
static gboolean

70
src/backends/native/meta-cursor-renderer-native.c
View file

@ -107,7 +107,7 @@ typedef struct _MetaCursorNativePrivate
struct {
gboolean can_preprocess;
float current_relative_scale;
MetaMonitorTransform current_relative_transform;
MtkMonitorTransform current_relative_transform;
} preprocess_state;
} MetaCursorNativePrivate;
@ -391,7 +391,7 @@ meta_cursor_renderer_native_update_cursor (MetaCursorRenderer *cursor_renderer,
meta_kms_cursor_manager_update_sprite (kms_cursor_manager,
kms_crtc,
NULL,
META_MONITOR_TRANSFORM_NORMAL,
MTK_MONITOR_TRANSFORM_NORMAL,
NULL);
}
}
@ -578,10 +578,10 @@ create_cursor_drm_buffer (MetaGpuKms *gpu_kms,
}
static void
calculate_crtc_cursor_hotspot (MetaCursorSprite *cursor_sprite,
float scale,
MetaMonitorTransform transform,
graphene_point_t *hotspot)
calculate_crtc_cursor_hotspot (MetaCursorSprite *cursor_sprite,
float scale,
MtkMonitorTransform transform,
graphene_point_t *hotspot)
{
int hot_x, hot_y;
int width, height;
@ -589,9 +589,9 @@ calculate_crtc_cursor_hotspot (MetaCursorSprite *cursor_sprite,
meta_cursor_sprite_get_hotspot (cursor_sprite, &hot_x, &hot_y);
width = meta_cursor_sprite_get_width (cursor_sprite);
height = meta_cursor_sprite_get_height (cursor_sprite);
meta_monitor_transform_transform_point (transform,
&width, &height,
&hot_x, &hot_y);
mtk_monitor_transform_transform_point (transform,
&width, &height,
&hot_x, &hot_y);
*hotspot = GRAPHENE_POINT_INIT (hot_x * scale, hot_y * scale);
}
@ -696,7 +696,7 @@ load_cursor_sprite_gbm_buffer_for_crtc (MetaCursorRendererNative *native,
uint height,
int rowstride,
float scale,
MetaMonitorTransform transform,
MtkMonitorTransform transform,
uint32_t gbm_format)
{
MetaCursorRendererNativePrivate *priv =
@ -762,17 +762,17 @@ load_cursor_sprite_gbm_buffer_for_crtc (MetaCursorRendererNative *native,
}
static CoglTexture *
scale_and_transform_cursor_sprite_cpu (MetaCursorRendererNative *cursor_renderer_native,
ClutterColorState *target_color_state,
MetaCursorSprite *cursor_sprite,
uint8_t *pixels,
CoglPixelFormat pixel_format,
int width,
int height,
int rowstride,
float scale,
MetaMonitorTransform transform,
GError **error)
scale_and_transform_cursor_sprite_cpu (MetaCursorRendererNative *cursor_renderer_native,
ClutterColorState *target_color_state,
MetaCursorSprite *cursor_sprite,
uint8_t *pixels,
CoglPixelFormat pixel_format,
int width,
int height,
int rowstride,
float scale,
MtkMonitorTransform transform,
GError **error)
{
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
@ -784,7 +784,7 @@ scale_and_transform_cursor_sprite_cpu (MetaCursorRendererNative *cursor_renderer
g_autoptr (CoglOffscreen) offscreen = NULL;
g_autoptr (CoglPipeline) pipeline = NULL;
graphene_matrix_t matrix;
MetaMonitorTransform pipeline_transform;
MtkMonitorTransform pipeline_transform;
ClutterColorState *color_state;
int dst_width;
int dst_height;
@ -812,8 +812,8 @@ scale_and_transform_cursor_sprite_cpu (MetaCursorRendererNative *cursor_renderer
pipeline = cogl_pipeline_new (cogl_context);
graphene_matrix_init_identity (&matrix);
pipeline_transform = meta_monitor_transform_invert (transform);
meta_monitor_transform_transform_matrix (pipeline_transform, &matrix);
pipeline_transform = mtk_monitor_transform_invert (transform);
mtk_monitor_transform_transform_matrix (pipeline_transform, &matrix);
cogl_pipeline_set_layer_texture (pipeline, 0, src_texture);
cogl_pipeline_set_layer_matrix (pipeline, 0, &matrix);
@ -841,7 +841,7 @@ load_scaled_and_transformed_cursor_sprite (MetaCursorRendererNative *native,
ClutterColorState *target_color_state,
MetaCursorSprite *cursor_sprite,
float relative_scale,
MetaMonitorTransform relative_transform,
MtkMonitorTransform relative_transform,
uint8_t *data,
int width,
int height,
@ -854,7 +854,7 @@ load_scaled_and_transformed_cursor_sprite (MetaCursorRendererNative *native,
cursor_color_state = meta_cursor_sprite_get_color_state (cursor_sprite);
if (!G_APPROX_VALUE (relative_scale, 1.f, FLT_EPSILON) ||
relative_transform != META_MONITOR_TRANSFORM_NORMAL ||
relative_transform != MTK_MONITOR_TRANSFORM_NORMAL ||
gbm_format != GBM_FORMAT_ARGB8888 ||
!clutter_color_state_equals (cursor_color_state, target_color_state))
{
@ -966,13 +966,13 @@ realize_cursor_sprite_from_wl_buffer_for_crtc (MetaCursorRenderer *renderer
int rowstride = wl_shm_buffer_get_stride (shm_buffer);
uint8_t *buffer_data;
float relative_scale;
MetaMonitorTransform relative_transform;
MtkMonitorTransform relative_transform;
uint32_t gbm_format;
MetaCrtc *crtc = META_CRTC (crtc_kms);
MetaLogicalMonitor *logical_monitor;
MetaMonitor *monitor;
MetaMonitorTransform logical_transform;
MtkMonitorTransform logical_transform;
gboolean retval;
monitor = meta_output_get_monitor (meta_crtc_get_outputs (crtc)->data);
@ -983,8 +983,8 @@ realize_cursor_sprite_from_wl_buffer_for_crtc (MetaCursorRenderer *renderer
logical_monitor);
logical_transform = meta_logical_monitor_get_transform (logical_monitor);
relative_transform = meta_monitor_transform_transform (
meta_monitor_transform_invert (
relative_transform = mtk_monitor_transform_transform (
mtk_monitor_transform_invert (
meta_cursor_sprite_get_texture_transform (cursor_sprite)),
meta_monitor_logical_to_crtc_transform (monitor, logical_transform));
@ -1097,7 +1097,7 @@ realize_cursor_sprite_from_wl_buffer_for_crtc (MetaCursorRenderer *renderer
meta_kms_cursor_manager_update_sprite (kms_cursor_manager,
kms_crtc,
META_DRM_BUFFER (buffer_gbm),
META_MONITOR_TRANSFORM_NORMAL,
MTK_MONITOR_TRANSFORM_NORMAL,
&GRAPHENE_POINT_INIT (hot_x, hot_y));
return TRUE;
@ -1118,10 +1118,10 @@ realize_cursor_sprite_from_xcursor_for_crtc (MetaCursorRenderer *renderer,
MetaCrtc *crtc = META_CRTC (crtc_kms);
MetaLogicalMonitor *logical_monitor;
MetaMonitor *monitor;
MetaMonitorTransform logical_transform;
MtkMonitorTransform logical_transform;
XcursorImage *xc_image;
float relative_scale;
MetaMonitorTransform relative_transform;
MtkMonitorTransform relative_transform;
monitor = meta_output_get_monitor (meta_crtc_get_outputs (crtc)->data);
logical_monitor = meta_monitor_get_logical_monitor (monitor);
@ -1131,8 +1131,8 @@ realize_cursor_sprite_from_xcursor_for_crtc (MetaCursorRenderer *renderer,
logical_monitor);
logical_transform = meta_logical_monitor_get_transform (logical_monitor);
relative_transform = meta_monitor_transform_transform (
meta_monitor_transform_invert (
relative_transform = mtk_monitor_transform_transform (
mtk_monitor_transform_invert (
meta_cursor_sprite_get_texture_transform (cursor_sprite)),
meta_monitor_logical_to_crtc_transform (monitor, logical_transform));

10
src/backends/native/meta-kms-connector.c
View file

@ -221,22 +221,22 @@ static void
set_panel_orientation (MetaKmsConnectorState *state,
MetaKmsProp *panel_orientation)
{
MetaMonitorTransform transform;
MtkMonitorTransform transform;
MetaKmsConnectorPanelOrientation orientation = panel_orientation->value;
switch (orientation)
{
case META_KMS_CONNECTOR_PANEL_ORIENTATION_UPSIDE_DOWN:
transform = META_MONITOR_TRANSFORM_180;
transform = MTK_MONITOR_TRANSFORM_180;
break;
case META_KMS_CONNECTOR_PANEL_ORIENTATION_LEFT_SIDE_UP:
transform = META_MONITOR_TRANSFORM_90;
transform = MTK_MONITOR_TRANSFORM_90;
break;
case META_KMS_CONNECTOR_PANEL_ORIENTATION_RIGHT_SIDE_UP:
transform = META_MONITOR_TRANSFORM_270;
transform = MTK_MONITOR_TRANSFORM_270;
break;
default:
transform = META_MONITOR_TRANSFORM_NORMAL;
transform = MTK_MONITOR_TRANSFORM_NORMAL;
break;
}

2
src/backends/native/meta-kms-connector.h
View file

@ -55,7 +55,7 @@ typedef struct _MetaKmsConnectorState
int suggested_y;
gboolean hotplug_mode_update;
MetaMonitorTransform panel_orientation_transform;
MtkMonitorTransform panel_orientation_transform;
struct {
uint64_t value;

12
src/backends/native/meta-kms-cursor-manager.c
View file

@ -48,7 +48,7 @@ typedef struct _CrtcStateImpl
MetaKmsPlane *cursor_plane;
graphene_rect_t layout;
float scale;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
MetaDrmBuffer *buffer;
graphene_point_t hotspot;
@ -275,9 +275,9 @@ calculate_cursor_rect (CrtcStateImpl *crtc_state_impl,
crtc_height = (int) roundf (crtc_state_impl->layout.size.height *
crtc_state_impl->scale);
meta_monitor_transform_transform_point (crtc_state_impl->transform,
&crtc_width, &crtc_height,
&crtc_x, &crtc_y);
mtk_monitor_transform_transform_point (crtc_state_impl->transform,
&crtc_width, &crtc_height,
&crtc_x, &crtc_y);
buffer_width = meta_drm_buffer_get_width (buffer);
buffer_height = meta_drm_buffer_get_height (buffer);
@ -732,7 +732,7 @@ typedef struct
{
MetaKmsCrtc *crtc;
MetaDrmBuffer *buffer;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
graphene_point_t hotspot;
} UpdateSpriteData;
@ -779,7 +779,7 @@ void
meta_kms_cursor_manager_update_sprite (MetaKmsCursorManager *cursor_manager,
MetaKmsCrtc *crtc,
MetaDrmBuffer *buffer,
MetaMonitorTransform transform,
MtkMonitorTransform transform,
const graphene_point_t *hotspot)
{
UpdateSpriteData *data;

4
src/backends/native/meta-kms-cursor-manager.h
View file

@ -20,10 +20,10 @@
#include <glib-object.h>
#include <graphene.h>
#include "backends/meta-monitor-transform.h"
#include "backends/native/meta-backend-native-types.h"
#include "backends/native/meta-kms-types.h"
#include "core/util-private.h"
#include "mtk/mtk.h"
typedef struct _MetaKmsCrtcLayout
{
@ -54,7 +54,7 @@ void meta_kms_cursor_manager_position_changed_in_input_impl (MetaKmsCursorManage
void meta_kms_cursor_manager_update_sprite (MetaKmsCursorManager *cursor_manager,
MetaKmsCrtc *crtc,
MetaDrmBuffer *buffer,
MetaMonitorTransform transform,
MtkMonitorTransform transform,
const graphene_point_t *hotspot);
META_EXPORT_TEST

39
src/backends/native/meta-kms-plane.c
View file

@ -23,7 +23,6 @@
#include <drm_fourcc.h>
#include <stdio.h>
#include "backends/meta-monitor-transform.h"
#include "backends/native/meta-kms-crtc.h"
#include "backends/native/meta-kms-impl-device.h"
#include "backends/native/meta-kms-impl-device-atomic.h"
@ -134,7 +133,7 @@ meta_kms_plane_get_prop_drm_value (MetaKmsPlane *plane,
void
meta_kms_plane_update_set_rotation (MetaKmsPlane *plane,
MetaKmsPlaneAssignment *plane_assignment,
MetaMonitorTransform transform)
MtkMonitorTransform transform)
{
MetaKmsPlaneRotation kms_rotation = 0;
@ -142,31 +141,31 @@ meta_kms_plane_update_set_rotation (MetaKmsPlane *plane,
switch (transform)
{
case META_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_NORMAL:
kms_rotation = META_KMS_PLANE_ROTATION_ROTATE_0;
break;
case META_MONITOR_TRANSFORM_90:
case MTK_MONITOR_TRANSFORM_90:
kms_rotation = META_KMS_PLANE_ROTATION_ROTATE_90;
break;
case META_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_180:
kms_rotation = META_KMS_PLANE_ROTATION_ROTATE_180;
break;
case META_MONITOR_TRANSFORM_270:
case MTK_MONITOR_TRANSFORM_270:
kms_rotation = META_KMS_PLANE_ROTATION_ROTATE_270;
break;
case META_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_FLIPPED:
kms_rotation = META_KMS_PLANE_ROTATION_ROTATE_0 |
META_KMS_PLANE_ROTATION_REFLECT_X;
break;
case META_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
kms_rotation = META_KMS_PLANE_ROTATION_ROTATE_90 |
META_KMS_PLANE_ROTATION_REFLECT_X;
break;
case META_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
kms_rotation = META_KMS_PLANE_ROTATION_ROTATE_0 |
META_KMS_PLANE_ROTATION_REFLECT_Y;
break;
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
kms_rotation = META_KMS_PLANE_ROTATION_ROTATE_270 |
META_KMS_PLANE_ROTATION_REFLECT_X;
break;
@ -178,19 +177,19 @@ meta_kms_plane_update_set_rotation (MetaKmsPlane *plane,
}
gboolean
meta_kms_plane_is_transform_handled (MetaKmsPlane *plane,
MetaMonitorTransform transform)
meta_kms_plane_is_transform_handled (MetaKmsPlane *plane,
MtkMonitorTransform transform)
{
switch (transform)
{
case META_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_NORMAL:
return plane->rotations & META_KMS_PLANE_ROTATION_ROTATE_0;
case META_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_180:
return plane->rotations & META_KMS_PLANE_ROTATION_ROTATE_180;
case META_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_FLIPPED:
return (plane->rotations & META_KMS_PLANE_ROTATION_ROTATE_0) &&
(plane->rotations & META_KMS_PLANE_ROTATION_REFLECT_X);
case META_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
return (plane->rotations & META_KMS_PLANE_ROTATION_ROTATE_0) &&
(plane->rotations & META_KMS_PLANE_ROTATION_REFLECT_Y);
/*
@ -199,10 +198,10 @@ meta_kms_plane_is_transform_handled (MetaKmsPlane *plane,
* less optimal due to the complexity dealing with rotation at scan-out,
* potentially resulting in higher power consumption.
*/
case META_MONITOR_TRANSFORM_90:
case META_MONITOR_TRANSFORM_270:
case META_MONITOR_TRANSFORM_FLIPPED_90:
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_90:
case MTK_MONITOR_TRANSFORM_270:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
return FALSE;
}

9
src/backends/native/meta-kms-plane.h
View file

@ -22,7 +22,8 @@
#include <xf86drmMode.h>
#include "backends/native/meta-kms-types.h"
#include "backends/meta-monitor-transform.h"
#include "core/util-private.h"
#include "mtk/mtk-monitor-transform.h"
enum _MetaKmsPlaneType
{
@ -55,8 +56,8 @@ MetaKmsPlaneType meta_kms_plane_get_plane_type (MetaKmsPlane *plane);
const MetaKmsPlaneCursorSizeHints *
meta_kms_plane_get_cursor_size_hints (MetaKmsPlane *plane);
gboolean meta_kms_plane_is_transform_handled (MetaKmsPlane *plane,
MetaMonitorTransform transform);
gboolean meta_kms_plane_is_transform_handled (MetaKmsPlane *plane,
MtkMonitorTransform transform);
gboolean meta_kms_plane_supports_cursor_hotspot (MetaKmsPlane *plane);
@ -74,4 +75,4 @@ gboolean meta_kms_plane_is_usable_with (MetaKmsPlane *plane,
void meta_kms_plane_update_set_rotation (MetaKmsPlane *plane,
MetaKmsPlaneAssignment *plane_assignment,
MetaMonitorTransform transform);
MtkMonitorTransform transform);

2
src/backends/native/meta-kms-update.h
View file

@ -22,11 +22,11 @@
#include <stdint.h>
#include <xf86drmMode.h>
#include "backends/meta-monitor-transform.h"
#include "backends/meta-output.h"
#include "backends/native/meta-drm-buffer.h"
#include "backends/native/meta-kms-types.h"
#include "meta/boxes.h"
#include "mtk/mtk.h"
typedef enum _MetaKmsFeedbackResult
{

4
src/backends/native/meta-onscreen-native.c
View file

@ -444,13 +444,13 @@ apply_transform (MetaCrtcKms *crtc_kms,
{
MetaCrtc *crtc = META_CRTC (crtc_kms);
const MetaCrtcConfig *crtc_config;
MetaMonitorTransform hw_transform;
MtkMonitorTransform hw_transform;
crtc_config = meta_crtc_get_config (crtc);
hw_transform = crtc_config->transform;
if (!meta_kms_plane_is_transform_handled (kms_plane, hw_transform))
hw_transform = META_MONITOR_TRANSFORM_NORMAL;
hw_transform = MTK_MONITOR_TRANSFORM_NORMAL;
if (!meta_kms_plane_is_transform_handled (kms_plane, hw_transform))
return;

2
src/backends/native/meta-output-kms.c
View file

@ -379,7 +379,7 @@ meta_output_kms_new (MetaGpuKms *gpu_kms,
output_info->panel_orientation_transform =
connector_state->panel_orientation_transform;
if (meta_monitor_transform_is_rotated (output_info->panel_orientation_transform))
if (mtk_monitor_transform_is_rotated (output_info->panel_orientation_transform))
{
output_info->width_mm = connector_state->height_mm;
output_info->height_mm = connector_state->width_mm;

12
src/backends/native/meta-renderer-native.c
View file

@ -1323,13 +1323,13 @@ meta_renderer_native_create_cogl_renderer (MetaRenderer *renderer)
return cogl_renderer;
}
static MetaMonitorTransform
static MtkMonitorTransform
calculate_view_transform (MetaMonitorManager *monitor_manager,
MetaLogicalMonitor *logical_monitor,
MetaOutput *output,
MetaCrtc *crtc)
{
MetaMonitorTransform crtc_transform;
MtkMonitorTransform crtc_transform;
crtc = meta_output_get_assigned_crtc (output);
crtc_transform =
@ -1337,7 +1337,7 @@ calculate_view_transform (MetaMonitorManager *monitor_manager,
if (meta_crtc_native_is_transform_handled (META_CRTC_NATIVE (crtc),
crtc_transform))
return META_MONITOR_TRANSFORM_NORMAL;
return MTK_MONITOR_TRANSFORM_NORMAL;
else
return crtc_transform;
}
@ -1423,7 +1423,7 @@ meta_renderer_native_create_view (MetaRenderer *renderer,
gboolean force_linear;
g_autoptr (ClutterColorState) color_state = NULL;
g_autoptr (ClutterColorState) blending_color_state = NULL;
MetaMonitorTransform view_transform;
MtkMonitorTransform view_transform;
g_autoptr (CoglFramebuffer) framebuffer = NULL;
g_autoptr (CoglOffscreen) offscreen = NULL;
gboolean use_shadowfb;
@ -1532,7 +1532,7 @@ meta_renderer_native_create_view (MetaRenderer *renderer,
output,
crtc);
if (view_transform != META_MONITOR_TRANSFORM_NORMAL ||
if (view_transform != MTK_MONITOR_TRANSFORM_NORMAL ||
!clutter_color_state_equals (color_state, blending_color_state))
{
int offscreen_width;
@ -1557,7 +1557,7 @@ meta_renderer_native_create_view (MetaRenderer *renderer,
formats[n_formats++] = COGL_PIXEL_FORMAT_ABGR_FP_16161616_PRE;
}
if (meta_monitor_transform_is_rotated (view_transform))
if (mtk_monitor_transform_is_rotated (view_transform))
{
offscreen_width = onscreen_height;
offscreen_height = onscreen_width;

56
src/backends/x11/meta-crtc-xrandr.c
View file

@ -49,7 +49,7 @@ struct _MetaCrtcXrandr
MetaCrtc parent;
MtkRectangle rect;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
MetaCrtcMode *current_mode;
};
@ -111,31 +111,31 @@ meta_crtc_xrandr_set_config (MetaCrtcXrandr *crtc_xrandr,
return TRUE;
}
static MetaMonitorTransform
meta_monitor_transform_from_xrandr (Rotation rotation)
static MtkMonitorTransform
mtk_monitor_transform_from_xrandr (Rotation rotation)
{
static const MetaMonitorTransform y_reflected_map[4] = {
META_MONITOR_TRANSFORM_FLIPPED_180,
META_MONITOR_TRANSFORM_FLIPPED_90,
META_MONITOR_TRANSFORM_FLIPPED,
META_MONITOR_TRANSFORM_FLIPPED_270
static const MtkMonitorTransform y_reflected_map[4] = {
MTK_MONITOR_TRANSFORM_FLIPPED_180,
MTK_MONITOR_TRANSFORM_FLIPPED_90,
MTK_MONITOR_TRANSFORM_FLIPPED,
MTK_MONITOR_TRANSFORM_FLIPPED_270
};
MetaMonitorTransform ret;
MtkMonitorTransform ret;
switch (rotation & 0x7F)
{
default:
case RR_Rotate_0:
ret = META_MONITOR_TRANSFORM_NORMAL;
ret = MTK_MONITOR_TRANSFORM_NORMAL;
break;
case RR_Rotate_90:
ret = META_MONITOR_TRANSFORM_90;
ret = MTK_MONITOR_TRANSFORM_90;
break;
case RR_Rotate_180:
ret = META_MONITOR_TRANSFORM_180;
ret = MTK_MONITOR_TRANSFORM_180;
break;
case RR_Rotate_270:
ret = META_MONITOR_TRANSFORM_270;
ret = MTK_MONITOR_TRANSFORM_270;
break;
}
@ -149,35 +149,35 @@ meta_monitor_transform_from_xrandr (Rotation rotation)
#define ALL_ROTATIONS (RR_Rotate_0 | RR_Rotate_90 | RR_Rotate_180 | RR_Rotate_270)
static MetaMonitorTransform
meta_monitor_transform_from_xrandr_all (Rotation rotation)
static MtkMonitorTransform
mtk_monitor_transform_from_xrandr_all (Rotation rotation)
{
unsigned ret;
/* Handle the common cases first (none or all) */
if (rotation == 0 || rotation == RR_Rotate_0)
return (1 << META_MONITOR_TRANSFORM_NORMAL);
return (1 << MTK_MONITOR_TRANSFORM_NORMAL);
/* All rotations and one reflection -> all of them by composition */
if ((rotation & ALL_ROTATIONS) &&
((rotation & RR_Reflect_X) || (rotation & RR_Reflect_Y)))
return META_MONITOR_ALL_TRANSFORMS;
return MTK_MONITOR_ALL_TRANSFORMS;
ret = 1 << META_MONITOR_TRANSFORM_NORMAL;
ret = 1 << MTK_MONITOR_TRANSFORM_NORMAL;
if (rotation & RR_Rotate_90)
ret |= 1 << META_MONITOR_TRANSFORM_90;
ret |= 1 << MTK_MONITOR_TRANSFORM_90;
if (rotation & RR_Rotate_180)
ret |= 1 << META_MONITOR_TRANSFORM_180;
ret |= 1 << MTK_MONITOR_TRANSFORM_180;
if (rotation & RR_Rotate_270)
ret |= 1 << META_MONITOR_TRANSFORM_270;
ret |= 1 << MTK_MONITOR_TRANSFORM_270;
if (rotation & (RR_Rotate_0 | RR_Reflect_X))
ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED;
ret |= 1 << MTK_MONITOR_TRANSFORM_FLIPPED;
if (rotation & (RR_Rotate_90 | RR_Reflect_X))
ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED_90;
ret |= 1 << MTK_MONITOR_TRANSFORM_FLIPPED_90;
if (rotation & (RR_Rotate_180 | RR_Reflect_X))
ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED_180;
ret |= 1 << MTK_MONITOR_TRANSFORM_FLIPPED_180;
if (rotation & (RR_Rotate_270 | RR_Reflect_X))
ret |= 1 << META_MONITOR_TRANSFORM_FLIPPED_270;
ret |= 1 << MTK_MONITOR_TRANSFORM_FLIPPED_270;
return ret;
}
@ -233,14 +233,14 @@ meta_crtc_xrandr_new (MetaGpuXrandr *gpu_xrandr,
META_MONITOR_MANAGER_XRANDR (monitor_manager);
Display *xdisplay =
meta_monitor_manager_xrandr_get_xdisplay (monitor_manager_xrandr);
MetaMonitorTransform all_transforms;
MtkMonitorTransform all_transforms;
MetaCrtcXrandr *crtc_xrandr;
XRRPanning *panning;
unsigned int i;
GList *modes;
all_transforms =
meta_monitor_transform_from_xrandr_all (xrandr_crtc->rotations);
mtk_monitor_transform_from_xrandr_all (xrandr_crtc->rotations);
crtc_xrandr = g_object_new (META_TYPE_CRTC_XRANDR,
"id", (uint64_t) crtc_id,
"backend", backend,
@ -249,7 +249,7 @@ meta_crtc_xrandr_new (MetaGpuXrandr *gpu_xrandr,
NULL);
crtc_xrandr->transform =
meta_monitor_transform_from_xrandr (xrandr_crtc->rotation);
mtk_monitor_transform_from_xrandr (xrandr_crtc->rotation);
panning = XRRGetPanning (xdisplay, resources, crtc_id);
if (panning && panning->width > 0 && panning->height > 0)

20
src/backends/x11/meta-monitor-manager-xrandr.c
View file

@ -192,25 +192,25 @@ meta_monitor_manager_xrandr_set_power_save_mode (MetaMonitorManager *manager,
}
static xcb_randr_rotation_t
meta_monitor_transform_to_xrandr (MetaMonitorTransform transform)
mtk_monitor_transform_to_xrandr (MtkMonitorTransform transform)
{
switch (transform)
{
case META_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_NORMAL:
return XCB_RANDR_ROTATION_ROTATE_0;
case META_MONITOR_TRANSFORM_90:
case MTK_MONITOR_TRANSFORM_90:
return XCB_RANDR_ROTATION_ROTATE_90;
case META_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_180:
return XCB_RANDR_ROTATION_ROTATE_180;
case META_MONITOR_TRANSFORM_270:
case MTK_MONITOR_TRANSFORM_270:
return XCB_RANDR_ROTATION_ROTATE_270;
case META_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_FLIPPED:
return XCB_RANDR_ROTATION_REFLECT_X | XCB_RANDR_ROTATION_ROTATE_0;
case META_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
return XCB_RANDR_ROTATION_REFLECT_X | XCB_RANDR_ROTATION_ROTATE_90;
case META_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
return XCB_RANDR_ROTATION_REFLECT_X | XCB_RANDR_ROTATION_ROTATE_180;
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
return XCB_RANDR_ROTATION_REFLECT_X | XCB_RANDR_ROTATION_ROTATE_270;
}
@ -531,7 +531,7 @@ apply_crtc_assignments (MetaMonitorManager *manager,
x = (int) roundf (crtc_assignment->layout.origin.x);
y = (int) roundf (crtc_assignment->layout.origin.y);
rotation =
meta_monitor_transform_to_xrandr (crtc_assignment->transform);
mtk_monitor_transform_to_xrandr (crtc_assignment->transform);
mode = meta_crtc_mode_get_id (crtc_mode);
if (!xrandr_set_crtc_config (manager_xrandr,
crtc,

12
src/backends/x11/meta-output-xrandr.c
View file

@ -825,19 +825,19 @@ output_get_panel_orientation_transform (Display *xdisplay,
&nitems, &bytes_after, &buffer);
if (actual_type != XA_ATOM || actual_format != 32 || nitems < 1)
return META_MONITOR_TRANSFORM_NORMAL;
return MTK_MONITOR_TRANSFORM_NORMAL;
str = XGetAtomName (xdisplay, *(Atom *)buffer);
if (strcmp (str, "Upside Down") == 0)
return META_MONITOR_TRANSFORM_180;
return MTK_MONITOR_TRANSFORM_180;
if (strcmp (str, "Left Side Up") == 0)
return META_MONITOR_TRANSFORM_90;
return MTK_MONITOR_TRANSFORM_90;
if (strcmp (str, "Right Side Up") == 0)
return META_MONITOR_TRANSFORM_270;
return MTK_MONITOR_TRANSFORM_270;
return META_MONITOR_TRANSFORM_NORMAL;
return MTK_MONITOR_TRANSFORM_NORMAL;
}
static void
@ -996,7 +996,7 @@ meta_output_xrandr_new (MetaGpuXrandr *gpu_xrandr,
output_info->panel_orientation_transform =
output_get_panel_orientation_transform (xdisplay, output_id);
if (meta_monitor_transform_is_rotated (output_info->panel_orientation_transform))
if (mtk_monitor_transform_is_rotated (output_info->panel_orientation_transform))
{
output_info->width_mm = xrandr_output->mm_height;
output_info->height_mm = xrandr_output->mm_width;

2
src/backends/x11/nested/meta-renderer-x11-nested.c
View file

@ -102,7 +102,7 @@ meta_renderer_x11_nested_create_view (MetaRenderer *renderer,
"crtc", crtc,
"refresh-rate", mode_info->refresh_rate,
"framebuffer", COGL_FRAMEBUFFER (fake_onscreen),
"transform", META_MONITOR_TRANSFORM_NORMAL,
"transform", MTK_MONITOR_TRANSFORM_NORMAL,
"scale", view_scale,
NULL);
g_object_set_data (G_OBJECT (view), "crtc", crtc);

2
src/compositor/meta-shaped-texture-private.h
View file

@ -44,7 +44,7 @@ MtkRegion * meta_shaped_texture_get_opaque_region (MetaShapedTexture *stex);
gboolean meta_shaped_texture_is_opaque (MetaShapedTexture *stex);
gboolean meta_shaped_texture_has_alpha (MetaShapedTexture *stex);
void meta_shaped_texture_set_transform (MetaShapedTexture *stex,
MetaMonitorTransform transform);
MtkMonitorTransform transform);
void meta_shaped_texture_set_viewport_src_rect (MetaShapedTexture *stex,
graphene_rect_t *src_rect);
void meta_shaped_texture_reset_viewport_src_rect (MetaShapedTexture *stex);

44
src/compositor/meta-shaped-texture.c
View file

@ -28,16 +28,16 @@
*
* A MetaShapedTexture draws a #CoglTexture (often provided from a client
* surface) in such a way that it matches any required transformations that
* give its final shape, such as a #MetaMonitorTransform, y-invertedness, or a
* give its final shape, such as a #MtkMonitorTransform, y-invertedness, or a
* crop-and-scale operation.
*/
#include "config.h"
#include "backends/meta-monitor-transform.h"
#include "compositor/meta-multi-texture-format-private.h"
#include "compositor/meta-shaped-texture-private.h"
#include "core/boxes-private.h"
#include "mtk/mtk.h"
#include <math.h>
@ -112,7 +112,7 @@ struct _MetaShapedTexture
MtkRegion *clip_region;
gboolean size_invalid;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
gboolean has_viewport_src_rect;
graphene_rect_t viewport_src_rect;
gboolean has_viewport_dst_size;
@ -221,7 +221,7 @@ meta_shaped_texture_init (MetaShapedTexture *stex)
stex->mask_texture = NULL;
stex->create_mipmaps = TRUE;
stex->is_y_inverted = TRUE;
stex->transform = META_MONITOR_TRANSFORM_NORMAL;
stex->transform = MTK_MONITOR_TRANSFORM_NORMAL;
}
static void
@ -243,7 +243,7 @@ update_size (MetaShapedTexture *stex)
}
else
{
if (meta_monitor_transform_is_rotated (stex->transform))
if (mtk_monitor_transform_is_rotated (stex->transform))
{
if (stex->texture)
{
@ -382,7 +382,7 @@ get_base_pipeline (MetaShapedTexture *stex,
0);
graphene_matrix_translate (&matrix, &p);
if (meta_monitor_transform_is_rotated (stex->transform))
if (mtk_monitor_transform_is_rotated (stex->transform))
{
graphene_matrix_scale (&matrix,
stex->viewport_src_rect.size.width /
@ -402,8 +402,8 @@ get_base_pipeline (MetaShapedTexture *stex,
}
}
meta_monitor_transform_transform_matrix (stex->transform,
&matrix);
mtk_monitor_transform_transform_matrix (stex->transform,
&matrix);
cogl_pipeline_set_layer_matrix (pipeline, 1, &matrix);
@ -873,7 +873,7 @@ do_paint_content (MetaShapedTexture *stex,
sample_width = texture_width;
sample_height = texture_height;
}
if (meta_monitor_transform_is_rotated (stex->transform))
if (mtk_monitor_transform_is_rotated (stex->transform))
flip_ints (&sample_width, &sample_height);
if (meta_actor_painting_untransformed (framebuffer,
@ -1211,7 +1211,7 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
int height,
MtkRectangle *clip)
{
MetaMonitorTransform inverted_transform;
MtkMonitorTransform inverted_transform;
MtkRectangle buffer_rect;
int scaled_and_transformed_width;
int scaled_and_transformed_height;
@ -1241,7 +1241,7 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
MTK_ROUNDING_STRATEGY_GROW,
clip);
if (meta_monitor_transform_is_rotated (stex->transform))
if (mtk_monitor_transform_is_rotated (stex->transform))
{
scaled_and_transformed_width = stex->tex_height / stex->buffer_scale;
scaled_and_transformed_height = stex->tex_width / stex->buffer_scale;
@ -1251,7 +1251,7 @@ meta_shaped_texture_update_area (MetaShapedTexture *stex,
scaled_and_transformed_width = stex->tex_width / stex->buffer_scale;
scaled_and_transformed_height = stex->tex_height / stex->buffer_scale;
}
inverted_transform = meta_monitor_transform_invert (stex->transform);
inverted_transform = mtk_monitor_transform_invert (stex->transform);
meta_rectangle_transform (clip,
inverted_transform,
scaled_and_transformed_width,
@ -1475,7 +1475,7 @@ meta_shaped_texture_is_opaque (MetaShapedTexture *stex)
void
meta_shaped_texture_set_transform (MetaShapedTexture *stex,
MetaMonitorTransform transform)
MtkMonitorTransform transform)
{
if (stex->transform == transform)
return;
@ -1597,15 +1597,15 @@ meta_shaped_texture_should_get_via_offscreen (MetaShapedTexture *stex)
switch (stex->transform)
{
case META_MONITOR_TRANSFORM_90:
case META_MONITOR_TRANSFORM_180:
case META_MONITOR_TRANSFORM_270:
case META_MONITOR_TRANSFORM_FLIPPED:
case META_MONITOR_TRANSFORM_FLIPPED_90:
case META_MONITOR_TRANSFORM_FLIPPED_180:
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_90:
case MTK_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_270:
case MTK_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
return TRUE;
case META_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_NORMAL:
break;
}
@ -1793,7 +1793,7 @@ get_unscaled_size (MetaShapedTexture *stex)
};
}
if (meta_monitor_transform_is_rotated (stex->transform))
if (mtk_monitor_transform_is_rotated (stex->transform))
{
return (graphene_size_t) {
.width = buffer_size.height,

2
src/compositor/meta-window-actor.c
View file

@ -1281,7 +1281,7 @@ meta_window_actor_transform_cursor_position (MetaScreenCastWindow *screen_cast_w
MetaCursorSprite *cursor_sprite,
graphene_point_t *cursor_position,
float *out_cursor_scale,
MetaMonitorTransform *out_cursor_transform,
MtkMonitorTransform *out_cursor_transform,
graphene_point_t *out_relative_cursor_position)
{
MetaWindowActor *window_actor = META_WINDOW_ACTOR (screen_cast_window);

11
src/core/boxes-private.h
View file

@ -27,6 +27,7 @@
#include "core/util-private.h"
#include "meta/boxes.h"
#include "meta/common.h"
#include "mtk/mtk.h"
#define BOX_LEFT(box) ((box).x) /* Leftmost pixel of rect */
#define BOX_RIGHT(box) ((box).x + (box).width) /* One pixel past right */
@ -238,8 +239,8 @@ GList* meta_rectangle_find_nonintersected_monitor_edges (
const GSList *all_struts);
META_EXPORT_TEST
void meta_rectangle_transform (const MtkRectangle *rect,
MetaMonitorTransform transform,
int width,
int height,
MtkRectangle *dest);
void meta_rectangle_transform (const MtkRectangle *rect,
MtkMonitorTransform transform,
int width,
int height,
MtkRectangle *dest);

30
src/core/boxes.c
View file

@ -24,8 +24,8 @@
#include "config.h"
#include "backends/meta-monitor-transform.h"
#include "core/boxes-private.h"
#include "mtk/mtk.h"
#include <math.h>
@ -1829,7 +1829,7 @@ meta_rectangle_find_nonintersected_monitor_edges (
/**
* meta_rectangle_transform:
* @rect: the #MtkRectangle to be transformed
* @transform: the #MetaMonitorTransform
* @transform: the #MtkMonitorTransform
* @width: the width of the target space
* @height: the height of the target space
* @dest: the transformed #MtkRectangle
@ -1840,18 +1840,18 @@ meta_rectangle_find_nonintersected_monitor_edges (
* an anti-clockwise rotation has to be applied to @rect.
*/
void
meta_rectangle_transform (const MtkRectangle *rect,
MetaMonitorTransform transform,
int width,
int height,
MtkRectangle *dest)
meta_rectangle_transform (const MtkRectangle *rect,
MtkMonitorTransform transform,
int width,
int height,
MtkRectangle *dest)
{
switch (transform)
{
case META_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_NORMAL:
*dest = *rect;
break;
case META_MONITOR_TRANSFORM_90:
case MTK_MONITOR_TRANSFORM_90:
*dest = (MtkRectangle) {
.x = rect->y,
.y = height - (rect->x + rect->width),
@ -1859,7 +1859,7 @@ meta_rectangle_transform (const MtkRectangle *rect,
.height = rect->width,
};
break;
case META_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_180:
*dest = (MtkRectangle) {
.x = width - (rect->x + rect->width),
.y = height - (rect->y + rect->height),
@ -1867,7 +1867,7 @@ meta_rectangle_transform (const MtkRectangle *rect,
.height = rect->height,
};
break;
case META_MONITOR_TRANSFORM_270:
case MTK_MONITOR_TRANSFORM_270:
*dest = (MtkRectangle) {
.x = width - (rect->y + rect->height),
.y = rect->x,
@ -1875,7 +1875,7 @@ meta_rectangle_transform (const MtkRectangle *rect,
.height = rect->width,
};
break;
case META_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_FLIPPED:
*dest = (MtkRectangle) {
.x = width - (rect->x + rect->width),
.y = rect->y,
@ -1883,7 +1883,7 @@ meta_rectangle_transform (const MtkRectangle *rect,
.height = rect->height,
};
break;
case META_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
*dest = (MtkRectangle) {
.x = rect->y,
.y = rect->x,
@ -1891,7 +1891,7 @@ meta_rectangle_transform (const MtkRectangle *rect,
.height = rect->width,
};
break;
case META_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
*dest = (MtkRectangle) {
.x = rect->x,
.y = height - (rect->y + rect->height),
@ -1899,7 +1899,7 @@ meta_rectangle_transform (const MtkRectangle *rect,
.height = rect->height,
};
break;
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
*dest = (MtkRectangle) {
.x = width - (rect->y + rect->height),
.y = height - (rect->x + rect->width),

2
src/meson.build
View file

@ -259,8 +259,6 @@ mutter_sources = [
'backends/meta-monitor-manager-dummy.c',
'backends/meta-monitor-manager-dummy.h',
'backends/meta-monitor-manager-private.h',
'backends/meta-monitor-transform.c',
'backends/meta-monitor-transform.h',
'backends/meta-orientation-manager.c',
'backends/meta-output.c',
'backends/meta-output.h',

7
src/meta/meta-orientation-manager.h
View file

@ -21,9 +21,8 @@
#include <glib-object.h>
#include "backends/meta-monitor-transform.h"
#include "core/util-private.h"
#include "meta/common.h"
#include "mtk/mtk.h"
typedef enum
{
@ -50,5 +49,5 @@ MetaOrientation meta_orientation_manager_get_orientation (MetaOrientationManager
META_EXPORT
gboolean meta_orientation_manager_has_accelerometer (MetaOrientationManager *self);
META_EXPORT_TEST
MetaMonitorTransform meta_orientation_to_transform (MetaOrientation orientation);
META_EXPORT
MtkMonitorTransform meta_orientation_to_transform (MetaOrientation orientation);

4
src/tests/meta-crtc-test.c
View file

@ -71,8 +71,8 @@ meta_crtc_test_set_gamma_lut (MetaCrtc *crtc,
}
static gboolean
meta_crtc_test_is_transform_handled (MetaCrtcNative *crtc_native,
MetaMonitorTransform monitor_transform)
meta_crtc_test_is_transform_handled (MetaCrtcNative *crtc_native,
MtkMonitorTransform monitor_transform)
{
MetaCrtcTest *crtc_test = META_CRTC_TEST (crtc_native);

6
src/tests/meta-monitor-test-utils.h
View file

@ -109,7 +109,7 @@ typedef struct _MonitorTestCaseOutput
unsigned int max_bpc;
MetaOutputRGBRange rgb_range;
const char *serial;
MetaMonitorTransform panel_orientation_transform;
MtkMonitorTransform panel_orientation_transform;
gboolean hotplug_mode;
int suggested_x;
int suggested_y;
@ -173,12 +173,12 @@ typedef struct _MonitorTestCaseLogicalMonitor
float scale;
int monitors[MAX_N_MONITORS];
int n_monitors;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
} MonitorTestCaseLogicalMonitor;
typedef struct _MonitorTestCaseCrtcExpect
{
MetaMonitorTransform transform;
MtkMonitorTransform transform;
int current_mode;
float x;
float y;

10
src/tests/monitor-store-unit-tests.c
View file

@ -57,7 +57,7 @@ typedef struct _MonitorStoreTestCaseLogicalMonitor
{
MtkRectangle layout;
float scale;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
gboolean is_primary;
gboolean is_presentation;
MonitorStoreTestCaseMonitor monitors[MAX_N_MONITORS];
@ -856,7 +856,7 @@ meta_test_monitor_store_first_rotated (void)
.height = 1024
},
.scale = 1,
.transform = META_MONITOR_TRANSFORM_270,
.transform = MTK_MONITOR_TRANSFORM_270,
.is_primary = TRUE,
.is_presentation = FALSE,
.monitors = {
@ -883,7 +883,7 @@ meta_test_monitor_store_first_rotated (void)
.height = 768
},
.scale = 1,
.transform = META_MONITOR_TRANSFORM_NORMAL,
.transform = MTK_MONITOR_TRANSFORM_NORMAL,
.is_primary = FALSE,
.is_presentation = FALSE,
.monitors = {
@ -929,7 +929,7 @@ meta_test_monitor_store_second_rotated (void)
.height = 768
},
.scale = 1,
.transform = META_MONITOR_TRANSFORM_NORMAL,
.transform = MTK_MONITOR_TRANSFORM_NORMAL,
.is_primary = TRUE,
.is_presentation = FALSE,
.monitors = {
@ -956,7 +956,7 @@ meta_test_monitor_store_second_rotated (void)
.height = 1024
},
.scale = 1,
.transform = META_MONITOR_TRANSFORM_90,
.transform = MTK_MONITOR_TRANSFORM_90,
.is_primary = FALSE,
.is_presentation = FALSE,
.monitors = {

104
src/tests/monitor-transform-tests.c
View file

@ -19,105 +19,105 @@
#include "tests/monitor-transform-tests.h"
#include "backends/meta-monitor-transform.h"
#include "mtk/mtk.h"
static void
test_transform (void)
{
const struct
{
MetaMonitorTransform transform;
MetaMonitorTransform other;
MetaMonitorTransform expect;
MtkMonitorTransform transform;
MtkMonitorTransform other;
MtkMonitorTransform expect;
} tests[] = {
{
.transform = META_MONITOR_TRANSFORM_NORMAL,
.other = META_MONITOR_TRANSFORM_90,
.expect = META_MONITOR_TRANSFORM_90,
.transform = MTK_MONITOR_TRANSFORM_NORMAL,
.other = MTK_MONITOR_TRANSFORM_90,
.expect = MTK_MONITOR_TRANSFORM_90,
},
{
.transform = META_MONITOR_TRANSFORM_NORMAL,
.other = META_MONITOR_TRANSFORM_FLIPPED_90,
.expect = META_MONITOR_TRANSFORM_FLIPPED_90,
.transform = MTK_MONITOR_TRANSFORM_NORMAL,
.other = MTK_MONITOR_TRANSFORM_FLIPPED_90,
.expect = MTK_MONITOR_TRANSFORM_FLIPPED_90,
},
{
.transform = META_MONITOR_TRANSFORM_90,
.other = META_MONITOR_TRANSFORM_90,
.expect = META_MONITOR_TRANSFORM_180,
.transform = MTK_MONITOR_TRANSFORM_90,
.other = MTK_MONITOR_TRANSFORM_90,
.expect = MTK_MONITOR_TRANSFORM_180,
},
{
.transform = META_MONITOR_TRANSFORM_FLIPPED_90,
.other = META_MONITOR_TRANSFORM_90,
.expect = META_MONITOR_TRANSFORM_FLIPPED_180,
.transform = MTK_MONITOR_TRANSFORM_FLIPPED_90,
.other = MTK_MONITOR_TRANSFORM_90,
.expect = MTK_MONITOR_TRANSFORM_FLIPPED_180,
},
{
.transform = META_MONITOR_TRANSFORM_FLIPPED_90,
.other = META_MONITOR_TRANSFORM_180,
.expect = META_MONITOR_TRANSFORM_FLIPPED_270,
.transform = MTK_MONITOR_TRANSFORM_FLIPPED_90,
.other = MTK_MONITOR_TRANSFORM_180,
.expect = MTK_MONITOR_TRANSFORM_FLIPPED_270,
},
{
.transform = META_MONITOR_TRANSFORM_FLIPPED_180,
.other = META_MONITOR_TRANSFORM_FLIPPED_180,
.expect = META_MONITOR_TRANSFORM_NORMAL,
.transform = MTK_MONITOR_TRANSFORM_FLIPPED_180,
.other = MTK_MONITOR_TRANSFORM_FLIPPED_180,
.expect = MTK_MONITOR_TRANSFORM_NORMAL,
},
{
.transform = META_MONITOR_TRANSFORM_NORMAL,
.other = meta_monitor_transform_invert (META_MONITOR_TRANSFORM_90),
.expect = META_MONITOR_TRANSFORM_270,
.transform = MTK_MONITOR_TRANSFORM_NORMAL,
.other = mtk_monitor_transform_invert (MTK_MONITOR_TRANSFORM_90),
.expect = MTK_MONITOR_TRANSFORM_270,
},
{
.transform = META_MONITOR_TRANSFORM_FLIPPED,
.other = meta_monitor_transform_invert (META_MONITOR_TRANSFORM_90),
.expect = META_MONITOR_TRANSFORM_FLIPPED_270,
.transform = MTK_MONITOR_TRANSFORM_FLIPPED,
.other = mtk_monitor_transform_invert (MTK_MONITOR_TRANSFORM_90),
.expect = MTK_MONITOR_TRANSFORM_FLIPPED_270,
},
{
.transform = META_MONITOR_TRANSFORM_FLIPPED_180,
.other = meta_monitor_transform_invert (META_MONITOR_TRANSFORM_270),
.expect = META_MONITOR_TRANSFORM_FLIPPED_270,
.transform = MTK_MONITOR_TRANSFORM_FLIPPED_180,
.other = mtk_monitor_transform_invert (MTK_MONITOR_TRANSFORM_270),
.expect = MTK_MONITOR_TRANSFORM_FLIPPED_270,
},
{
.transform = META_MONITOR_TRANSFORM_FLIPPED_180,
.transform = MTK_MONITOR_TRANSFORM_FLIPPED_180,
.other =
meta_monitor_transform_invert (META_MONITOR_TRANSFORM_FLIPPED_180),
.expect = META_MONITOR_TRANSFORM_NORMAL,
mtk_monitor_transform_invert (MTK_MONITOR_TRANSFORM_FLIPPED_180),
.expect = MTK_MONITOR_TRANSFORM_NORMAL,
},
};
int i;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
for (i = 0; i < G_N_ELEMENTS (tests); i++)
{
MetaMonitorTransform result;
MtkMonitorTransform result;
result = meta_monitor_transform_transform (tests[i].transform,
tests[i].other);
result = mtk_monitor_transform_transform (tests[i].transform,
tests[i].other);
g_assert_cmpint (result, ==, tests[i].expect);
}
for (transform = 0; transform <= META_MONITOR_TRANSFORM_FLIPPED_270; transform++)
for (transform = 0; transform <= MTK_MONITOR_TRANSFORM_FLIPPED_270; transform++)
{
MetaMonitorTransform other;
MetaMonitorTransform result1;
MtkMonitorTransform other;
MtkMonitorTransform result1;
result1 =
meta_monitor_transform_transform (transform,
meta_monitor_transform_invert (transform));
g_assert_cmpint (result1, ==, META_MONITOR_TRANSFORM_NORMAL);
mtk_monitor_transform_transform (transform,
mtk_monitor_transform_invert (transform));
g_assert_cmpint (result1, ==, MTK_MONITOR_TRANSFORM_NORMAL);
for (other = 0; other <= META_MONITOR_TRANSFORM_FLIPPED_270; other++)
for (other = 0; other <= MTK_MONITOR_TRANSFORM_FLIPPED_270; other++)
{
MetaMonitorTransform result2;
MtkMonitorTransform result2;
result1 = meta_monitor_transform_transform (transform, other);
result1 = mtk_monitor_transform_transform (transform, other);
result2 =
meta_monitor_transform_transform (result1,
meta_monitor_transform_invert (other));
mtk_monitor_transform_transform (result1,
mtk_monitor_transform_invert (other));
g_assert_cmpint (result2, ==, transform);
result1 =
meta_monitor_transform_transform (meta_monitor_transform_invert (transform),
other);
result2 = meta_monitor_transform_transform (transform, result1);
mtk_monitor_transform_transform (mtk_monitor_transform_invert (transform),
other);
result2 = mtk_monitor_transform_transform (transform, result1);
g_assert_cmpint (result2, ==, other);
}
}

80
src/tests/monitor-unit-tests.c
View file

@ -3650,7 +3650,7 @@ meta_test_monitor_non_upright_panel (void)
test_case.setup.outputs[0].modes[0] = 1;
test_case.setup.outputs[0].preferred_mode = 1;
test_case.setup.outputs[0].panel_orientation_transform =
META_MONITOR_TRANSFORM_90;
MTK_MONITOR_TRANSFORM_90;
/*
* Note we do not swap outputs[0].width_mm and height_mm, because these get
* swapped for rotated panels inside the xrandr / kms code and we directly
@ -3660,7 +3660,7 @@ meta_test_monitor_non_upright_panel (void)
test_case.expect.monitors[0].modes[0].crtc_modes[0].crtc_mode = 1;
test_case.expect.crtcs[0].current_mode = 1;
test_case.expect.crtcs[0].transform = META_MONITOR_TRANSFORM_90;
test_case.expect.crtcs[0].transform = MTK_MONITOR_TRANSFORM_90;
test_setup = meta_create_monitor_test_setup (test_backend,
&test_case.setup,
@ -4080,8 +4080,8 @@ check_monitor_configuration_per_orientation (MonitorTestCase *test_case,
int width,
int height)
{
MetaMonitorTransform transform;
MetaMonitorTransform output_transform;
MtkMonitorTransform transform;
MtkMonitorTransform output_transform;
MonitorTestCaseExpect expect = test_case->expect;
MonitorTestCaseSetup *setup = &test_case->setup;
int i = 0;
@ -4089,11 +4089,11 @@ check_monitor_configuration_per_orientation (MonitorTestCase *test_case,
transform = meta_orientation_to_transform (orientation);
output_transform = setup->outputs[monitor_index].panel_orientation_transform;
expect.logical_monitors[monitor_index].transform =
meta_monitor_transform_transform (transform,
meta_monitor_transform_invert (output_transform));
mtk_monitor_transform_transform (transform,
mtk_monitor_transform_invert (output_transform));
expect.crtcs[monitor_index].transform = transform;
if (meta_monitor_transform_is_rotated (transform))
if (mtk_monitor_transform_is_rotated (transform))
{
expect.logical_monitors[monitor_index].layout.width = height;
expect.logical_monitors[monitor_index].layout.height = width;
@ -5082,7 +5082,7 @@ meta_test_monitor_orientation_changes_for_transformed_panel (void)
.width_mm = 222,
.height_mm = 125,
.is_laptop_panel = TRUE,
.panel_orientation_transform = META_MONITOR_TRANSFORM_90,
.panel_orientation_transform = MTK_MONITOR_TRANSFORM_90,
},
},
.n_outputs = 1,
@ -5386,7 +5386,7 @@ meta_test_monitor_orientation_changes_with_hotplugging (void)
.n_monitors = 1,
.layout = { .x = 1024, .y = 0, .width = 1024, .height = 768 },
.scale = 1,
.transform = META_MONITOR_TRANSFORM_NORMAL,
.transform = MTK_MONITOR_TRANSFORM_NORMAL,
}
},
.n_logical_monitors = 1, /* Second is hotplugged later */
@ -5398,7 +5398,7 @@ meta_test_monitor_orientation_changes_with_hotplugging (void)
},
{
.current_mode = -1,
.transform = META_MONITOR_TRANSFORM_NORMAL,
.transform = MTK_MONITOR_TRANSFORM_NORMAL,
}
},
.n_crtcs = 2,
@ -7223,7 +7223,7 @@ meta_test_monitor_custom_first_rotated_config (void)
.n_monitors = 1,
.layout = { .x = 0, .y = 0, .width = 768, .height = 1024 },
.scale = 1,
.transform = META_MONITOR_TRANSFORM_270
.transform = MTK_MONITOR_TRANSFORM_270
},
{
.monitors = { 1 },
@ -7238,7 +7238,7 @@ meta_test_monitor_custom_first_rotated_config (void)
.crtcs = {
{
.current_mode = 0,
.transform = META_MONITOR_TRANSFORM_270
.transform = MTK_MONITOR_TRANSFORM_270
},
{
.current_mode = 0,
@ -7370,7 +7370,7 @@ meta_test_monitor_custom_second_rotated_config (void)
.n_monitors = 1,
.layout = { .x = 1024, .y = 0, .width = 768, .height = 1024 },
.scale = 1,
.transform = META_MONITOR_TRANSFORM_90
.transform = MTK_MONITOR_TRANSFORM_90
}
},
.n_logical_monitors = 2,
@ -7383,7 +7383,7 @@ meta_test_monitor_custom_second_rotated_config (void)
},
{
.current_mode = 0,
.transform = META_MONITOR_TRANSFORM_90,
.transform = MTK_MONITOR_TRANSFORM_90,
.x = 1024,
}
},
@ -7553,7 +7553,7 @@ meta_test_monitor_custom_second_rotated_tiled_config (void)
.n_monitors = 1,
.layout = { .x = 1024, .y = 0, .width = 600, .height = 800 },
.scale = 1,
.transform = META_MONITOR_TRANSFORM_90
.transform = MTK_MONITOR_TRANSFORM_90
}
},
.n_logical_monitors = 2,
@ -7566,13 +7566,13 @@ meta_test_monitor_custom_second_rotated_tiled_config (void)
},
{
.current_mode = 1,
.transform = META_MONITOR_TRANSFORM_90,
.transform = MTK_MONITOR_TRANSFORM_90,
.x = 1024,
.y = 0,
},
{
.current_mode = 1,
.transform = META_MONITOR_TRANSFORM_90,
.transform = MTK_MONITOR_TRANSFORM_90,
.x = 1024,
.y = 400,
}
@ -7752,7 +7752,7 @@ meta_test_monitor_custom_second_rotated_nonnative_tiled_config (void)
.n_monitors = 1,
.layout = { .x = 1024, .y = 0, .width = 600, .height = 800 },
.scale = 1,
.transform = META_MONITOR_TRANSFORM_90
.transform = MTK_MONITOR_TRANSFORM_90
}
},
.n_logical_monitors = 2,
@ -7765,13 +7765,13 @@ meta_test_monitor_custom_second_rotated_nonnative_tiled_config (void)
},
{
.current_mode = 1,
.transform = META_MONITOR_TRANSFORM_90,
.transform = MTK_MONITOR_TRANSFORM_90,
.x = 1024,
.y = 0,
},
{
.current_mode = 1,
.transform = META_MONITOR_TRANSFORM_90,
.transform = MTK_MONITOR_TRANSFORM_90,
.x = 1024,
.y = 400,
}
@ -7910,7 +7910,7 @@ meta_test_monitor_custom_second_rotated_nonnative_config (void)
.n_monitors = 1,
.layout = { .x = 1024, .y = 0, .width = 768, .height = 1024 },
.scale = 1,
.transform = META_MONITOR_TRANSFORM_90
.transform = MTK_MONITOR_TRANSFORM_90
}
},
.n_logical_monitors = 2,
@ -7923,7 +7923,7 @@ meta_test_monitor_custom_second_rotated_nonnative_config (void)
},
{
.current_mode = 0,
.transform = META_MONITOR_TRANSFORM_90,
.transform = MTK_MONITOR_TRANSFORM_90,
.x = 1024,
}
},
@ -8169,7 +8169,7 @@ meta_test_monitor_custom_oneoff (void)
.n_monitors = 1,
.layout = { .x = 0, .y = 0, .width = 800, .height = 600 },
.scale = 1,
.transform = META_MONITOR_TRANSFORM_NORMAL
.transform = MTK_MONITOR_TRANSFORM_NORMAL
},
},
.n_logical_monitors = 1,
@ -8304,7 +8304,7 @@ meta_test_monitor_custom_lid_switch_config (void)
.n_monitors = 1,
.layout = { .x = 0, .y = 0, .width = 768, .height = 1024 },
.scale = 1,
.transform = META_MONITOR_TRANSFORM_270
.transform = MTK_MONITOR_TRANSFORM_270
},
{
.monitors = { 1 },
@ -8319,7 +8319,7 @@ meta_test_monitor_custom_lid_switch_config (void)
.crtcs = {
{
.current_mode = 0,
.transform = META_MONITOR_TRANSFORM_270
.transform = MTK_MONITOR_TRANSFORM_270
},
{
.current_mode = -1,
@ -8348,14 +8348,14 @@ meta_test_monitor_custom_lid_switch_config (void)
test_case.setup.n_outputs = 2;
test_case.expect.n_monitors = 2;
test_case.expect.n_outputs = 2;
test_case.expect.crtcs[0].transform = META_MONITOR_TRANSFORM_NORMAL;
test_case.expect.crtcs[0].transform = MTK_MONITOR_TRANSFORM_NORMAL;
test_case.expect.crtcs[1].current_mode = 0;
test_case.expect.crtcs[1].x = 1024;
test_case.expect.crtcs[1].transform = META_MONITOR_TRANSFORM_270;
test_case.expect.crtcs[1].transform = MTK_MONITOR_TRANSFORM_270;
test_case.expect.logical_monitors[0].layout =
(MtkRectangle) { .width = 1024, .height = 768 };
test_case.expect.logical_monitors[0].transform = META_MONITOR_TRANSFORM_NORMAL;
test_case.expect.logical_monitors[1].transform = META_MONITOR_TRANSFORM_270;
test_case.expect.logical_monitors[0].transform = MTK_MONITOR_TRANSFORM_NORMAL;
test_case.expect.logical_monitors[1].transform = MTK_MONITOR_TRANSFORM_270;
test_case.expect.n_logical_monitors = 2;
test_case.expect.screen_width = 1024 + 768;
@ -8371,13 +8371,13 @@ meta_test_monitor_custom_lid_switch_config (void)
/* Lid was closed */
test_case.expect.crtcs[0].current_mode = -1;
test_case.expect.crtcs[1].transform = META_MONITOR_TRANSFORM_90;
test_case.expect.crtcs[1].transform = MTK_MONITOR_TRANSFORM_90;
test_case.expect.crtcs[1].x = 0;
test_case.expect.monitors[0].current_mode = -1;
test_case.expect.logical_monitors[0].layout =
(MtkRectangle) { .width = 768, .height = 1024 };
test_case.expect.logical_monitors[0].monitors[0] = 1;
test_case.expect.logical_monitors[0].transform = META_MONITOR_TRANSFORM_90;
test_case.expect.logical_monitors[0].transform = MTK_MONITOR_TRANSFORM_90;
test_case.expect.n_logical_monitors = 1;
test_case.expect.screen_width = 768;
meta_backend_test_set_is_lid_closed (META_BACKEND_TEST (backend), TRUE);
@ -8394,16 +8394,16 @@ meta_test_monitor_custom_lid_switch_config (void)
/* Lid was opened */
test_case.expect.crtcs[0].current_mode = 0;
test_case.expect.crtcs[0].transform = META_MONITOR_TRANSFORM_NORMAL;
test_case.expect.crtcs[0].transform = MTK_MONITOR_TRANSFORM_NORMAL;
test_case.expect.crtcs[1].current_mode = 0;
test_case.expect.crtcs[1].transform = META_MONITOR_TRANSFORM_270;
test_case.expect.crtcs[1].transform = MTK_MONITOR_TRANSFORM_270;
test_case.expect.crtcs[1].x = 1024;
test_case.expect.monitors[0].current_mode = 0;
test_case.expect.logical_monitors[0].layout =
(MtkRectangle) { .width = 1024, .height = 768 };
test_case.expect.logical_monitors[0].monitors[0] = 0;
test_case.expect.logical_monitors[0].transform = META_MONITOR_TRANSFORM_NORMAL;
test_case.expect.logical_monitors[1].transform = META_MONITOR_TRANSFORM_270;
test_case.expect.logical_monitors[0].transform = MTK_MONITOR_TRANSFORM_NORMAL;
test_case.expect.logical_monitors[1].transform = MTK_MONITOR_TRANSFORM_270;
test_case.expect.n_logical_monitors = 2;
test_case.expect.screen_width = 1024 + 768;
meta_backend_test_set_is_lid_closed (META_BACKEND_TEST (backend), FALSE);
@ -8484,7 +8484,7 @@ meta_test_monitor_migrated_rotated (void)
.n_monitors = 1,
.layout = { .x = 0, .y = 0, .width = 600, .height = 800 },
.scale = 1,
.transform = META_MONITOR_TRANSFORM_270
.transform = MTK_MONITOR_TRANSFORM_270
},
},
.n_logical_monitors = 1,
@ -8493,7 +8493,7 @@ meta_test_monitor_migrated_rotated (void)
.crtcs = {
{
.current_mode = 0,
.transform = META_MONITOR_TRANSFORM_270
.transform = MTK_MONITOR_TRANSFORM_270
}
},
.n_crtcs = 1,
@ -8631,7 +8631,7 @@ meta_test_monitor_migrated_wiggle_discard (void)
.n_monitors = 1,
.layout = { .x = 0, .y = 0, .width = 800, .height = 600 },
.scale = 1,
.transform = META_MONITOR_TRANSFORM_NORMAL
.transform = MTK_MONITOR_TRANSFORM_NORMAL
},
},
.n_logical_monitors = 1,
@ -8913,7 +8913,7 @@ meta_test_monitor_migrated_wiggle (void)
.n_monitors = 1,
.layout = { .x = 0, .y = 0, .width = 600, .height = 800 },
.scale = 1,
.transform = META_MONITOR_TRANSFORM_90
.transform = MTK_MONITOR_TRANSFORM_90
},
},
.n_logical_monitors = 1,
@ -8922,7 +8922,7 @@ meta_test_monitor_migrated_wiggle (void)
.crtcs = {
{
.current_mode = 0,
.transform = META_MONITOR_TRANSFORM_90
.transform = MTK_MONITOR_TRANSFORM_90
}
},
.n_crtcs = 1,

24
src/wayland/meta-wayland-outputs.c
View file

@ -57,7 +57,7 @@ struct _MetaWaylandOutput
/* Protocol state */
MtkRectangle layout;
MetaSubpixelOrder subpixel_order;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
MetaMonitorMode *mode;
MetaMonitorMode *preferred_mode;
float scale;
@ -133,25 +133,25 @@ meta_subpixel_order_to_wl_output_subpixel (MetaSubpixelOrder subpixel_order)
}
static enum wl_output_transform
wl_output_transform_from_transform (MetaMonitorTransform transform)
wl_output_transform_from_transform (MtkMonitorTransform transform)
{
switch (transform)
{
case META_MONITOR_TRANSFORM_NORMAL:
case MTK_MONITOR_TRANSFORM_NORMAL:
return WL_OUTPUT_TRANSFORM_NORMAL;
case META_MONITOR_TRANSFORM_90:
case MTK_MONITOR_TRANSFORM_90:
return WL_OUTPUT_TRANSFORM_90;
case META_MONITOR_TRANSFORM_180:
case MTK_MONITOR_TRANSFORM_180:
return WL_OUTPUT_TRANSFORM_180;
case META_MONITOR_TRANSFORM_270:
case MTK_MONITOR_TRANSFORM_270:
return WL_OUTPUT_TRANSFORM_270;
case META_MONITOR_TRANSFORM_FLIPPED:
case MTK_MONITOR_TRANSFORM_FLIPPED:
return WL_OUTPUT_TRANSFORM_FLIPPED;
case META_MONITOR_TRANSFORM_FLIPPED_90:
case MTK_MONITOR_TRANSFORM_FLIPPED_90:
return WL_OUTPUT_TRANSFORM_FLIPPED_90;
case META_MONITOR_TRANSFORM_FLIPPED_180:
case MTK_MONITOR_TRANSFORM_FLIPPED_180:
return WL_OUTPUT_TRANSFORM_FLIPPED_180;
case META_MONITOR_TRANSFORM_FLIPPED_270:
case MTK_MONITOR_TRANSFORM_FLIPPED_270:
return WL_OUTPUT_TRANSFORM_FLIPPED_270;
}
g_assert_not_reached ();
@ -169,8 +169,8 @@ send_output_events (struct wl_resource *resource,
int version = wl_resource_get_version (resource);
MtkRectangle layout;
MtkRectangle old_layout;
MetaMonitorTransform transform;
MetaMonitorTransform old_transform;
MtkMonitorTransform transform;
MtkMonitorTransform old_transform;
MetaMonitorMode *mode;
MetaMonitorMode *old_mode;
MetaMonitorMode *preferred_mode;

6
src/wayland/meta-wayland-surface-private.h
View file

@ -110,7 +110,7 @@ struct _MetaWaylandSurfaceState
int new_max_height;
gboolean has_new_buffer_transform;
MetaMonitorTransform buffer_transform;
MtkMonitorTransform buffer_transform;
gboolean has_new_viewport_src_rect;
graphene_rect_t viewport_src_rect;
gboolean has_new_viewport_dst_size;
@ -167,10 +167,10 @@ struct _MetaWaylandSurface
MtkRegion *opaque_region;
int32_t offset_x, offset_y;
GHashTable *outputs;
MetaMonitorTransform buffer_transform;
MtkMonitorTransform buffer_transform;
int preferred_scale;
MetaMonitorTransform preferred_transform;
MtkMonitorTransform preferred_transform;
/* Buffer reference state. */
MetaWaylandBuffer *buffer;

46
src/wayland/meta-wayland-surface.c
View file

@ -260,16 +260,16 @@ meta_wayland_surface_assign_role (MetaWaylandSurface *surface,
}
static MtkRegion *
region_transform (const MtkRegion *region,
MetaMonitorTransform transform,
int width,
int height)
region_transform (const MtkRegion *region,
MtkMonitorTransform transform,
int width,
int height)
{
MtkRegion *transformed_region;
MtkRectangle *rects;
int n_rects, i;
if (transform == META_MONITOR_TRANSFORM_NORMAL)
if (transform == MTK_MONITOR_TRANSFORM_NORMAL)
return mtk_region_copy (region);
n_rects = mtk_region_num_rectangles (region);
@ -344,7 +344,7 @@ surface_process_damage (MetaWaylandSurface *surface,
{
int width, height;
if (meta_monitor_transform_is_rotated (surface->buffer_transform))
if (mtk_monitor_transform_is_rotated (surface->buffer_transform))
{
width = meta_wayland_surface_get_buffer_height (surface);
height = meta_wayland_surface_get_buffer_width (surface);
@ -1199,7 +1199,7 @@ wl_surface_commit (struct wl_client *client,
meta_wayland_surface_commit (surface);
}
static MetaMonitorTransform
static MtkMonitorTransform
transform_from_wl_output_transform (int32_t transform_value)
{
enum wl_output_transform transform = transform_value;
@ -1207,21 +1207,21 @@ transform_from_wl_output_transform (int32_t transform_value)
switch (transform)
{
case WL_OUTPUT_TRANSFORM_NORMAL:
return META_MONITOR_TRANSFORM_NORMAL;
return MTK_MONITOR_TRANSFORM_NORMAL;
case WL_OUTPUT_TRANSFORM_90:
return META_MONITOR_TRANSFORM_90;
return MTK_MONITOR_TRANSFORM_90;
case WL_OUTPUT_TRANSFORM_180:
return META_MONITOR_TRANSFORM_180;
return MTK_MONITOR_TRANSFORM_180;
case WL_OUTPUT_TRANSFORM_270:
return META_MONITOR_TRANSFORM_270;
return MTK_MONITOR_TRANSFORM_270;
case WL_OUTPUT_TRANSFORM_FLIPPED:
return META_MONITOR_TRANSFORM_FLIPPED;
return MTK_MONITOR_TRANSFORM_FLIPPED;
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
return META_MONITOR_TRANSFORM_FLIPPED_90;
return MTK_MONITOR_TRANSFORM_FLIPPED_90;
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
return META_MONITOR_TRANSFORM_FLIPPED_180;
return MTK_MONITOR_TRANSFORM_FLIPPED_180;
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
return META_MONITOR_TRANSFORM_FLIPPED_270;
return MTK_MONITOR_TRANSFORM_FLIPPED_270;
default:
return -1;
}
@ -1234,7 +1234,7 @@ wl_surface_set_buffer_transform (struct wl_client *client,
{
MetaWaylandSurface *surface = wl_resource_get_user_data (resource);
MetaWaylandSurfaceState *pending = surface->pending_state;
MetaMonitorTransform buffer_transform;
MtkMonitorTransform buffer_transform;
buffer_transform = transform_from_wl_output_transform (transform);
@ -1456,10 +1456,10 @@ out:
return scale;
}
static MetaMonitorTransform
static MtkMonitorTransform
meta_wayland_surface_get_output_transform (MetaWaylandSurface *surface)
{
MetaMonitorTransform transform = META_MONITOR_TRANSFORM_NORMAL;
MtkMonitorTransform transform = MTK_MONITOR_TRANSFORM_NORMAL;
MetaWindow *window;
MetaLogicalMonitor *logical_monitor;
@ -2249,7 +2249,7 @@ meta_wayland_surface_get_width (MetaWaylandSurface *surface)
{
int width;
if (meta_monitor_transform_is_rotated (surface->buffer_transform))
if (mtk_monitor_transform_is_rotated (surface->buffer_transform))
width = meta_wayland_surface_get_buffer_height (surface);
else
width = meta_wayland_surface_get_buffer_width (surface);
@ -2273,7 +2273,7 @@ meta_wayland_surface_get_height (MetaWaylandSurface *surface)
{
int height;
if (meta_monitor_transform_is_rotated (surface->buffer_transform))
if (mtk_monitor_transform_is_rotated (surface->buffer_transform))
height = meta_wayland_surface_get_buffer_width (surface);
else
height = meta_wayland_surface_get_buffer_height (surface);
@ -2311,7 +2311,7 @@ meta_wayland_surface_try_acquire_scanout (MetaWaylandSurface *surface,
{
MetaRendererView *renderer_view;
MetaSurfaceActor *surface_actor;
MetaMonitorTransform view_transform;
MtkMonitorTransform view_transform;
ClutterActorBox actor_box;
MtkRectangle *dst_rect_ptr = NULL;
MtkRectangle dst_rect;
@ -2353,7 +2353,7 @@ meta_wayland_surface_try_acquire_scanout (MetaWaylandSurface *surface,
.height = (int) roundf ((actor_box.y2 - actor_box.y1) * view_scale),
};
if (meta_monitor_transform_is_rotated (view_transform))
if (mtk_monitor_transform_is_rotated (view_transform))
{
untransformed_view_width = view_rect.height;
untransformed_view_height = view_rect.width;
@ -2462,7 +2462,7 @@ committed_state_handle_highest_scale_monitor (MetaWaylandSurface *surface)
WL_SURFACE_PREFERRED_BUFFER_SCALE_SINCE_VERSION)
{
int ceiled_scale;
MetaMonitorTransform transform;
MtkMonitorTransform transform;
ceiled_scale = (int) ceil (scale);
if (ceiled_scale > 0 && ceiled_scale != surface->preferred_scale)