← Back to branch summary

~elementary-os/elementaryos/os-patch-mutter-bionic

« back to all changes in this revision

Viewing changes to src/tests/meta-monitor-manager-test.c

  • Committer: RabbitBot
  • Date: 2018-04-11 14:49:36 UTC
  • Revision ID: rabbitbot@elementary.io-20180411144936-hgymqa9d8d1xfpbh
Initial import, version 3.28.0-2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tests/meta-monitor-manager-test.c
 
1
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
 
2
 
 
3
/*
 
4
 * Copyright (C) 2016 Red Hat, Inc.
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU General Public License as
 
8
 * published by the Free Software Foundation; either version 2 of the
 
9
 * License, or (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful, but
 
12
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
 * General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 
18
 */
 
19
 
 
20
#include "config.h"
 
21
 
 
22
#include "tests/meta-monitor-manager-test.h"
 
23
 
 
24
#include "backends/meta-backend-private.h"
 
25
#include "backends/meta-crtc.h"
 
26
#include "backends/meta-gpu.h"
 
27
#include "backends/meta-monitor-config-manager.h"
 
28
#include "backends/meta-output.h"
 
29
 
 
30
struct _MetaMonitorManagerTest
 
31
{
 
32
  MetaMonitorManager parent;
 
33
 
 
34
  MetaGpu *gpu;
 
35
 
 
36
  gboolean is_lid_closed;
 
37
  gboolean handles_transforms;
 
38
 
 
39
  int tiled_monitor_count;
 
40
 
 
41
  MetaMonitorTestSetup *test_setup;
 
42
};
 
43
 
 
44
G_DEFINE_TYPE (MetaMonitorManagerTest, meta_monitor_manager_test,
 
45
               META_TYPE_MONITOR_MANAGER)
 
46
 
 
47
struct _MetaGpuTest
 
48
{
 
49
  MetaGpu parent;
 
50
};
 
51
 
 
52
G_DEFINE_TYPE (MetaGpuTest, meta_gpu_test, META_TYPE_GPU)
 
53
 
 
54
static MetaMonitorTestSetup *_initial_test_setup = NULL;
 
55
 
 
56
void
 
57
meta_monitor_manager_test_init_test_setup (MetaMonitorTestSetup *test_setup)
 
58
{
 
59
  _initial_test_setup = test_setup;
 
60
}
 
61
 
 
62
MetaGpu *
 
63
meta_monitor_manager_test_get_gpu (MetaMonitorManagerTest *manager_test)
 
64
{
 
65
  return manager_test->gpu;
 
66
}
 
67
 
 
68
void
 
69
meta_monitor_manager_test_emulate_hotplug (MetaMonitorManagerTest *manager_test,
 
70
                                           MetaMonitorTestSetup   *test_setup)
 
71
{
 
72
  MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_test);
 
73
  MetaMonitorTestSetup *old_test_setup;
 
74
 
 
75
  old_test_setup = manager_test->test_setup;
 
76
  manager_test->test_setup = test_setup;
 
77
 
 
78
  meta_monitor_manager_read_current_state (manager);
 
79
  meta_monitor_manager_on_hotplug (manager);
 
80
 
 
81
  g_free (old_test_setup);
 
82
}
 
83
 
 
84
void
 
85
meta_monitor_manager_test_set_is_lid_closed (MetaMonitorManagerTest *manager_test,
 
86
                                             gboolean                is_lid_closed)
 
87
{
 
88
  manager_test->is_lid_closed = is_lid_closed;
 
89
}
 
90
 
 
91
void
 
92
meta_monitor_manager_test_set_handles_transforms (MetaMonitorManagerTest *manager_test,
 
93
                                                  gboolean                handles_transforms)
 
94
{
 
95
  g_assert (handles_transforms || meta_is_stage_views_enabled());
 
96
 
 
97
  manager_test->handles_transforms = handles_transforms;
 
98
}
 
99
 
 
100
int
 
101
meta_monitor_manager_test_get_tiled_monitor_count (MetaMonitorManagerTest *manager_test)
 
102
{
 
103
  return manager_test->tiled_monitor_count;
 
104
}
 
105
 
 
106
static void
 
107
meta_monitor_manager_test_read_current (MetaMonitorManager *manager)
 
108
{
 
109
  MetaMonitorManagerTest *manager_test = META_MONITOR_MANAGER_TEST (manager);
 
110
  MetaGpu *gpu = manager_test->gpu;
 
111
  GList *l;
 
112
 
 
113
  g_assert (manager_test->test_setup);
 
114
 
 
115
  for (l = manager_test->test_setup->outputs; l; l = l->next)
 
116
    META_OUTPUT (l->data)->gpu = gpu;
 
117
  for (l = manager_test->test_setup->crtcs; l; l = l->next)
 
118
    META_CRTC (l->data)->gpu = gpu;
 
119
 
 
120
  meta_gpu_take_modes (manager_test->gpu,
 
121
                       manager_test->test_setup->modes);
 
122
 
 
123
  meta_gpu_take_crtcs (manager_test->gpu,
 
124
                       manager_test->test_setup->crtcs);
 
125
 
 
126
  meta_gpu_take_outputs (manager_test->gpu,
 
127
                         manager_test->test_setup->outputs);
 
128
}
 
129
 
 
130
static gboolean
 
131
meta_monitor_manager_test_is_lid_closed (MetaMonitorManager *manager)
 
132
{
 
133
  MetaMonitorManagerTest *manager_test = META_MONITOR_MANAGER_TEST (manager);
 
134
 
 
135
  return manager_test->is_lid_closed;
 
136
}
 
137
 
 
138
static void
 
139
meta_monitor_manager_test_ensure_initial_config (MetaMonitorManager *manager)
 
140
{
 
141
  MetaMonitorsConfig *config;
 
142
 
 
143
  config = meta_monitor_manager_ensure_configured (manager);
 
144
 
 
145
  if (meta_is_stage_views_enabled ())
 
146
    {
 
147
      meta_monitor_manager_update_logical_state (manager, config);
 
148
    }
 
149
  else
 
150
    {
 
151
      meta_monitor_manager_update_logical_state_derived (manager, NULL);
 
152
    }
 
153
}
 
154
 
 
155
static void
 
156
apply_crtc_assignments (MetaMonitorManager *manager,
 
157
                        MetaCrtcInfo      **crtcs,
 
158
                        unsigned int        n_crtcs,
 
159
                        MetaOutputInfo    **outputs,
 
160
                        unsigned int        n_outputs)
 
161
{
 
162
  MetaMonitorManagerTest *manager_test = META_MONITOR_MANAGER_TEST (manager);
 
163
  GList *l;
 
164
  unsigned int i;
 
165
 
 
166
  for (i = 0; i < n_crtcs; i++)
 
167
    {
 
168
      MetaCrtcInfo *crtc_info = crtcs[i];
 
169
      MetaCrtc *crtc = crtc_info->crtc;
 
170
      crtc->is_dirty = TRUE;
 
171
 
 
172
      if (crtc_info->mode == NULL)
 
173
        {
 
174
          crtc->rect.x = 0;
 
175
          crtc->rect.y = 0;
 
176
          crtc->rect.width = 0;
 
177
          crtc->rect.height = 0;
 
178
          crtc->current_mode = NULL;
 
179
        }
 
180
      else
 
181
        {
 
182
          MetaCrtcMode *mode;
 
183
          MetaOutput *output;
 
184
          unsigned int j;
 
185
          int width, height;
 
186
 
 
187
          mode = crtc_info->mode;
 
188
 
 
189
          if (meta_monitor_transform_is_rotated (crtc_info->transform))
 
190
            {
 
191
              width = mode->height;
 
192
              height = mode->width;
 
193
            }
 
194
          else
 
195
            {
 
196
              width = mode->width;
 
197
              height = mode->height;
 
198
            }
 
199
 
 
200
          crtc->rect.x = crtc_info->x;
 
201
          crtc->rect.y = crtc_info->y;
 
202
          crtc->rect.width = width;
 
203
          crtc->rect.height = height;
 
204
          crtc->current_mode = mode;
 
205
          crtc->transform = crtc_info->transform;
 
206
 
 
207
          for (j = 0; j < crtc_info->outputs->len; j++)
 
208
            {
 
209
              output = ((MetaOutput**)crtc_info->outputs->pdata)[j];
 
210
 
 
211
              output->is_dirty = TRUE;
 
212
              output->crtc = crtc;
 
213
            }
 
214
        }
 
215
    }
 
216
 
 
217
  for (i = 0; i < n_outputs; i++)
 
218
    {
 
219
      MetaOutputInfo *output_info = outputs[i];
 
220
      MetaOutput *output = output_info->output;
 
221
 
 
222
      output->is_primary = output_info->is_primary;
 
223
      output->is_presentation = output_info->is_presentation;
 
224
      output->is_underscanning = output_info->is_underscanning;
 
225
    }
 
226
 
 
227
  /* Disable CRTCs not mentioned in the list */
 
228
  for (l = meta_gpu_get_crtcs (manager_test->gpu); l; l = l->next)
 
229
    {
 
230
      MetaCrtc *crtc = l->data;
 
231
 
 
232
      crtc->logical_monitor = NULL;
 
233
 
 
234
      if (crtc->is_dirty)
 
235
        {
 
236
          crtc->is_dirty = FALSE;
 
237
          continue;
 
238
        }
 
239
 
 
240
      crtc->rect.x = 0;
 
241
      crtc->rect.y = 0;
 
242
      crtc->rect.width = 0;
 
243
      crtc->rect.height = 0;
 
244
      crtc->current_mode = NULL;
 
245
    }
 
246
 
 
247
  /* Disable outputs not mentioned in the list */
 
248
  for (l = meta_gpu_get_outputs (manager_test->gpu); l; l = l->next)
 
249
    {
 
250
      MetaOutput *output = l->data;
 
251
 
 
252
      if (output->is_dirty)
 
253
        {
 
254
          output->is_dirty = FALSE;
 
255
          continue;
 
256
        }
 
257
 
 
258
      output->crtc = NULL;
 
259
      output->is_primary = FALSE;
 
260
    }
 
261
}
 
262
 
 
263
static void
 
264
update_screen_size (MetaMonitorManager *manager,
 
265
                    MetaMonitorsConfig *config)
 
266
{
 
267
  GList *l;
 
268
  int screen_width = 0;
 
269
  int screen_height = 0;
 
270
 
 
271
  for (l = config->logical_monitor_configs; l; l = l->next)
 
272
    {
 
273
      MetaLogicalMonitorConfig *logical_monitor_config = l->data;
 
274
      int right_edge;
 
275
      int bottom_edge;
 
276
 
 
277
      right_edge = (logical_monitor_config->layout.width +
 
278
                    logical_monitor_config->layout.x);
 
279
      if (right_edge > screen_width)
 
280
        screen_width = right_edge;
 
281
 
 
282
      bottom_edge = (logical_monitor_config->layout.height +
 
283
                     logical_monitor_config->layout.y);
 
284
      if (bottom_edge > screen_height)
 
285
        screen_height = bottom_edge;
 
286
    }
 
287
 
 
288
  manager->screen_width = screen_width;
 
289
  manager->screen_height = screen_height;
 
290
}
 
291
 
 
292
static gboolean
 
293
meta_monitor_manager_test_apply_monitors_config (MetaMonitorManager      *manager,
 
294
                                                 MetaMonitorsConfig      *config,
 
295
                                                 MetaMonitorsConfigMethod method,
 
296
                                                 GError                 **error)
 
297
{
 
298
  GPtrArray *crtc_infos;
 
299
  GPtrArray *output_infos;
 
300
 
 
301
  if (!config)
 
302
    {
 
303
      manager->screen_width = META_MONITOR_MANAGER_MIN_SCREEN_WIDTH;
 
304
      manager->screen_height = META_MONITOR_MANAGER_MIN_SCREEN_HEIGHT;
 
305
 
 
306
      if (meta_is_stage_views_enabled ())
 
307
        meta_monitor_manager_rebuild (manager, NULL);
 
308
      else
 
309
        meta_monitor_manager_rebuild_derived (manager, config);
 
310
 
 
311
      return TRUE;
 
312
    }
 
313
 
 
314
  if (!meta_monitor_config_manager_assign (manager, config,
 
315
                                           &crtc_infos,
 
316
                                           &output_infos,
 
317
                                           error))
 
318
    return FALSE;
 
319
 
 
320
  if (method == META_MONITORS_CONFIG_METHOD_VERIFY)
 
321
    {
 
322
      g_ptr_array_free (crtc_infos, TRUE);
 
323
      g_ptr_array_free (output_infos, TRUE);
 
324
      return TRUE;
 
325
    }
 
326
 
 
327
  apply_crtc_assignments (manager,
 
328
                          (MetaCrtcInfo **) crtc_infos->pdata,
 
329
                          crtc_infos->len,
 
330
                          (MetaOutputInfo **) output_infos->pdata,
 
331
                          output_infos->len);
 
332
 
 
333
  g_ptr_array_free (crtc_infos, TRUE);
 
334
  g_ptr_array_free (output_infos, TRUE);
 
335
 
 
336
  update_screen_size (manager, config);
 
337
 
 
338
  if (meta_is_stage_views_enabled ())
 
339
    meta_monitor_manager_rebuild (manager, config);
 
340
  else
 
341
    meta_monitor_manager_rebuild_derived (manager, config);
 
342
 
 
343
  return TRUE;
 
344
}
 
345
 
 
346
static void
 
347
meta_monitor_manager_test_tiled_monitor_added (MetaMonitorManager *manager,
 
348
                                               MetaMonitor        *monitor)
 
349
{
 
350
  MetaMonitorManagerTest *manager_test = META_MONITOR_MANAGER_TEST (manager);
 
351
 
 
352
  manager_test->tiled_monitor_count++;
 
353
}
 
354
 
 
355
static void
 
356
meta_monitor_manager_test_tiled_monitor_removed (MetaMonitorManager *manager,
 
357
                                                 MetaMonitor        *monitor)
 
358
{
 
359
  MetaMonitorManagerTest *manager_test = META_MONITOR_MANAGER_TEST (manager);
 
360
 
 
361
  manager_test->tiled_monitor_count--;
 
362
}
 
363
 
 
364
static gboolean
 
365
meta_monitor_manager_test_is_transform_handled (MetaMonitorManager  *manager,
 
366
                                                MetaCrtc            *crtc,
 
367
                                                MetaMonitorTransform transform)
 
368
{
 
369
  MetaMonitorManagerTest *manager_test = META_MONITOR_MANAGER_TEST (manager);
 
370
 
 
371
  return manager_test->handles_transforms;
 
372
}
 
373
 
 
374
static float
 
375
meta_monitor_manager_test_calculate_monitor_mode_scale (MetaMonitorManager *manager,
 
376
                                                        MetaMonitor        *monitor,
 
377
                                                        MetaMonitorMode    *monitor_mode)
 
378
{
 
379
  MetaOutput *output;
 
380
  MetaOutputTest *output_test;
 
381
 
 
382
  output = meta_monitor_get_main_output (monitor);
 
383
  output_test = output->driver_private;
 
384
 
 
385
  if (output_test)
 
386
    return output_test->scale;
 
387
  else
 
388
    return 1;
 
389
}
 
390
 
 
391
static float *
 
392
meta_monitor_manager_test_calculate_supported_scales (MetaMonitorManager          *manager,
 
393
                                                      MetaLogicalMonitorLayoutMode layout_mode,
 
394
                                                      MetaMonitor                 *monitor,
 
395
                                                      MetaMonitorMode             *monitor_mode,
 
396
                                                      int                         *n_supported_scales)
 
397
{
 
398
  MetaMonitorScalesConstraint constraints =
 
399
    META_MONITOR_SCALES_CONSTRAINT_NONE;
 
400
 
 
401
  switch (layout_mode)
 
402
    {
 
403
    case META_LOGICAL_MONITOR_LAYOUT_MODE_LOGICAL:
 
404
      break;
 
405
    case META_LOGICAL_MONITOR_LAYOUT_MODE_PHYSICAL:
 
406
      constraints |= META_MONITOR_SCALES_CONSTRAINT_NO_FRAC;
 
407
      break;
 
408
    }
 
409
 
 
410
  return meta_monitor_calculate_supported_scales (monitor, monitor_mode,
 
411
                                                  constraints,
 
412
                                                  n_supported_scales);
 
413
}
 
414
 
 
415
static gboolean
 
416
is_monitor_framebuffer_scaled (void)
 
417
{
 
418
  MetaBackend *backend = meta_get_backend ();
 
419
  MetaSettings *settings = meta_backend_get_settings (backend);
 
420
 
 
421
  return meta_settings_is_experimental_feature_enabled (
 
422
    settings,
 
423
    META_EXPERIMENTAL_FEATURE_SCALE_MONITOR_FRAMEBUFFER);
 
424
}
 
425
 
 
426
static MetaMonitorManagerCapability
 
427
meta_monitor_manager_test_get_capabilities (MetaMonitorManager *manager)
 
428
{
 
429
  MetaMonitorManagerCapability capabilities =
 
430
    META_MONITOR_MANAGER_CAPABILITY_NONE;
 
431
 
 
432
  capabilities |= META_MONITOR_MANAGER_CAPABILITY_MIRRORING;
 
433
 
 
434
  if (is_monitor_framebuffer_scaled ())
 
435
    capabilities |= META_MONITOR_MANAGER_CAPABILITY_LAYOUT_MODE;
 
436
 
 
437
  return capabilities;
 
438
}
 
439
 
 
440
static gboolean
 
441
meta_monitor_manager_test_get_max_screen_size (MetaMonitorManager *manager,
 
442
                                               int                *max_width,
 
443
                                               int                *max_height)
 
444
{
 
445
  if (meta_is_stage_views_enabled ())
 
446
    return FALSE;
 
447
 
 
448
  *max_width = 65535;
 
449
  *max_height = 65535;
 
450
 
 
451
  return TRUE;
 
452
}
 
453
 
 
454
static MetaLogicalMonitorLayoutMode
 
455
meta_monitor_manager_test_get_default_layout_mode (MetaMonitorManager *manager)
 
456
{
 
457
  if (!meta_is_stage_views_enabled ())
 
458
    return META_LOGICAL_MONITOR_LAYOUT_MODE_PHYSICAL;
 
459
 
 
460
  if (is_monitor_framebuffer_scaled ())
 
461
    return META_LOGICAL_MONITOR_LAYOUT_MODE_LOGICAL;
 
462
  else
 
463
    return META_LOGICAL_MONITOR_LAYOUT_MODE_PHYSICAL;
 
464
}
 
465
 
 
466
static void
 
467
meta_monitor_manager_test_dispose (GObject *object)
 
468
{
 
469
  MetaMonitorManagerTest *manager_test = META_MONITOR_MANAGER_TEST (object);
 
470
 
 
471
  g_clear_pointer (&manager_test->test_setup, g_free);
 
472
}
 
473
 
 
474
static void
 
475
meta_monitor_manager_test_init (MetaMonitorManagerTest *manager_test)
 
476
{
 
477
  MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_test);
 
478
 
 
479
  g_assert (_initial_test_setup);
 
480
 
 
481
  manager_test->handles_transforms = TRUE;
 
482
 
 
483
  manager_test->test_setup = _initial_test_setup;
 
484
 
 
485
  manager_test->gpu = g_object_new (META_TYPE_GPU_TEST,
 
486
                                    "monitor-manager", manager,
 
487
                                    NULL);
 
488
  meta_monitor_manager_add_gpu (manager, manager_test->gpu);
 
489
}
 
490
 
 
491
static void
 
492
meta_monitor_manager_test_class_init (MetaMonitorManagerTestClass *klass)
 
493
{
 
494
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
495
  MetaMonitorManagerClass *manager_class = META_MONITOR_MANAGER_CLASS (klass);
 
496
 
 
497
  object_class->dispose = meta_monitor_manager_test_dispose;
 
498
 
 
499
  manager_class->is_lid_closed = meta_monitor_manager_test_is_lid_closed;
 
500
  manager_class->ensure_initial_config = meta_monitor_manager_test_ensure_initial_config;
 
501
  manager_class->apply_monitors_config = meta_monitor_manager_test_apply_monitors_config;
 
502
  manager_class->tiled_monitor_added = meta_monitor_manager_test_tiled_monitor_added;
 
503
  manager_class->tiled_monitor_removed = meta_monitor_manager_test_tiled_monitor_removed;
 
504
  manager_class->is_transform_handled = meta_monitor_manager_test_is_transform_handled;
 
505
  manager_class->calculate_monitor_mode_scale = meta_monitor_manager_test_calculate_monitor_mode_scale;
 
506
  manager_class->calculate_supported_scales = meta_monitor_manager_test_calculate_supported_scales;
 
507
  manager_class->get_capabilities = meta_monitor_manager_test_get_capabilities;
 
508
  manager_class->get_max_screen_size = meta_monitor_manager_test_get_max_screen_size;
 
509
  manager_class->get_default_layout_mode = meta_monitor_manager_test_get_default_layout_mode;
 
510
}
 
511
 
 
512
static gboolean
 
513
meta_gpu_test_read_current (MetaGpu  *gpu,
 
514
                            GError  **error)
 
515
{
 
516
  MetaMonitorManager *manager = meta_gpu_get_monitor_manager (gpu);
 
517
 
 
518
  meta_monitor_manager_test_read_current (manager);
 
519
 
 
520
  return TRUE;
 
521
}
 
522
 
 
523
static void
 
524
meta_gpu_test_init (MetaGpuTest *gpu_test)
 
525
{
 
526
}
 
527
 
 
528
static void
 
529
meta_gpu_test_class_init (MetaGpuTestClass *klass)
 
530
{
 
531
  MetaGpuClass *gpu_class = META_GPU_CLASS (klass);
 
532
 
 
533
  gpu_class->read_current = meta_gpu_test_read_current;
 
534
}