← Back to branch summary

~ubuntu-branches/ubuntu/vivid/gnome-flashback/vivid

« back to all changes in this revision

Viewing changes to gnome-flashback/libidle-monitor/meta-backend.c

  • Committer: Package Import Robot
  • Author(s): Dmitry Shachnev
  • Date: 2014-09-19 17:09:43 UTC
  • Revision ID: package-import@ubuntu.com-20140919170943-oboafsedi6z69951
Tags: upstream-3.10.0
Import upstream version 3.10.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnome-flashback/libidle-monitor/meta-backend.c
 
1
/*
 
2
 * Copyright (C) 2014 Red Hat
 
3
 *
 
4
 * This program is free software: you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License as published by
 
6
 * the Free Software Foundation, either version 3 of the License, or
 
7
 * (at your option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 
16
 *
 
17
 * Written by:
 
18
 *     Jasper St. Pierre <jstpierre@mecheye.net>
 
19
 */
 
20
 
 
21
#include <gdk/gdkx.h>
 
22
 
 
23
#include "config.h"
 
24
#include "meta-backend.h"
 
25
#include "meta-idle-monitor-xsync.h"
 
26
 
 
27
static MetaBackend *backend = NULL;
 
28
 
 
29
G_DEFINE_TYPE (MetaBackend, meta_backend, G_TYPE_OBJECT);
 
30
 
 
31
static void
 
32
meta_backend_finalize (GObject *object)
 
33
{
 
34
  MetaBackend *backend = META_BACKEND (object);
 
35
  int i;
 
36
 
 
37
  for (i = 0; i <= backend->device_id_max; i++)
 
38
    {
 
39
      if (backend->device_monitors[i])
 
40
        g_object_unref (backend->device_monitors[i]);
 
41
    }
 
42
 
 
43
  G_OBJECT_CLASS (meta_backend_parent_class)->finalize (object);
 
44
}
 
45
 
 
46
static void
 
47
create_device_monitor (MetaBackend *backend,
 
48
                       int          device_id)
 
49
{
 
50
  g_assert (backend->device_monitors[device_id] == NULL);
 
51
 
 
52
  backend->device_monitors[device_id] = g_object_new (META_TYPE_IDLE_MONITOR_XSYNC,
 
53
                                                      "device-id", device_id,
 
54
                                                      NULL);
 
55
  backend->device_id_max = MAX (backend->device_id_max, device_id);
 
56
}
 
57
 
 
58
static void
 
59
destroy_device_monitor (MetaBackend *backend,
 
60
                        int          device_id)
 
61
{
 
62
  g_clear_object (&backend->device_monitors[device_id]);
 
63
 
 
64
  if (device_id == backend->device_id_max)
 
65
    {
 
66
      /* Reset the max device ID */
 
67
      int i, new_max = 0;
 
68
      for (i = 0; i < backend->device_id_max; i++)
 
69
        if (backend->device_monitors[i] != NULL)
 
70
          new_max = i;
 
71
      backend->device_id_max = new_max;
 
72
    }
 
73
}
 
74
 
 
75
static void
 
76
on_device_added (GdkDeviceManager *device_manager,
 
77
                 GdkDevice        *device,
 
78
                 gpointer          user_data)
 
79
{
 
80
  MetaBackend *backend = META_BACKEND (user_data);
 
81
  int device_id = gdk_x11_device_get_id (device);
 
82
 
 
83
  create_device_monitor (backend, device_id);
 
84
}
 
85
 
 
86
static void
 
87
on_device_removed (GdkDeviceManager *device_manager,
 
88
                   GdkDevice        *device,
 
89
                   gpointer          user_data)
 
90
{
 
91
  MetaBackend *backend = META_BACKEND (user_data);
 
92
  int device_id = gdk_x11_device_get_id (device);
 
93
 
 
94
  destroy_device_monitor (backend, device_id);
 
95
}
 
96
 
 
97
static void
 
98
on_device_changed (GdkDeviceManager *device_manager,
 
99
                   GdkDevice        *device,
 
100
                   gpointer          user_data)
 
101
{
 
102
    MetaBackend *backend = META_BACKEND (user_data);
 
103
 
 
104
        if (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_FLOATING)
 
105
                on_device_removed (device_manager, device, backend);
 
106
        else
 
107
                on_device_added (device_manager, device, backend);
 
108
}
 
109
 
 
110
static void
 
111
meta_backend_class_init (MetaBackendClass *klass)
 
112
{
 
113
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
114
 
 
115
  object_class->finalize = meta_backend_finalize;
 
116
}
 
117
 
 
118
static void
 
119
meta_backend_init (MetaBackend *backend)
 
120
{
 
121
        GdkDeviceManager *manager;
 
122
        GList *devices, *l;
 
123
 
 
124
        /* Create the core device monitor. */
 
125
        create_device_monitor (backend, 0);
 
126
 
 
127
        manager = gdk_display_get_device_manager (gdk_display_get_default ());
 
128
        g_signal_connect_object (manager, "device-added", G_CALLBACK (on_device_added), backend, 0);
 
129
        g_signal_connect_object (manager, "device-removed", G_CALLBACK (on_device_removed), backend, 0);
 
130
        g_signal_connect_object (manager, "device-changed", G_CALLBACK (on_device_changed), backend, 0);
 
131
 
 
132
        devices = gdk_device_manager_list_devices (manager, GDK_DEVICE_TYPE_MASTER);
 
133
        devices = g_list_concat (devices, gdk_device_manager_list_devices (manager, GDK_DEVICE_TYPE_SLAVE));
 
134
 
 
135
        for (l = devices; l != NULL; l = l->next) {
 
136
                GdkDevice *device = l->data;
 
137
                on_device_added (manager, device, backend);
 
138
        }
 
139
 
 
140
        g_list_free (devices);
 
141
}
 
142
 
 
143
MetaBackend *
 
144
meta_get_backend (void)
 
145
{
 
146
  if (!backend)
 
147
        backend = g_object_new (META_TYPE_BACKEND, NULL);
 
148
 
 
149
  return backend;
 
150
}
 
151
 
 
152
MetaIdleMonitor *
 
153
meta_backend_get_idle_monitor (MetaBackend *backend,
 
154
                               int          device_id)
 
155
{
 
156
  g_return_val_if_fail (device_id >= 0 && device_id < 256, NULL);
 
157
 
 
158
  return backend->device_monitors[device_id];
 
159
}