1 /* Copyright (c) 2006, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of the Nokia Corporation nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 #include "modest-debug.h"
31 #include "modest-ui-dimming-manager.h"
32 #include "modest-dimming-rules-group-priv.h"
34 static void modest_ui_dimming_manager_class_init (ModestUIDimmingManagerClass *klass);
35 static void modest_ui_dimming_manager_init (ModestUIDimmingManager *obj);
36 static void modest_ui_dimming_manager_finalize (GObject *obj);
37 static void modest_ui_dimming_manager_dispose (GObject *obj);
39 static void _process_all_rules (gpointer key, gpointer value, gpointer user_data);
41 #define WIDGET_DIMMING_MODE "widget-dimming-mode"
44 typedef struct _ModestUIDimmingManagerPrivate ModestUIDimmingManagerPrivate;
45 struct _ModestUIDimmingManagerPrivate {
46 GHashTable *groups_map;
47 GHashTable *delayed_calls;
50 #define MODEST_UI_DIMMING_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
51 MODEST_TYPE_UI_DIMMING_MANAGER, \
52 ModestUIDimmingManagerPrivate))
55 static GObjectClass *parent_class = NULL;
58 modest_ui_dimming_manager_get_type (void)
60 static GType my_type = 0;
62 static const GTypeInfo my_info = {
63 sizeof(ModestUIDimmingManagerClass),
65 NULL, /* base finalize */
66 (GClassInitFunc) modest_ui_dimming_manager_class_init,
67 NULL, /* class finalize */
68 NULL, /* class data */
69 sizeof(ModestUIDimmingManager),
71 (GInstanceInitFunc) modest_ui_dimming_manager_init,
74 my_type = g_type_register_static (G_TYPE_OBJECT,
75 "ModestUIDimmingManager",
82 modest_ui_dimming_manager_class_init (ModestUIDimmingManagerClass *klass)
84 GObjectClass *gobject_class;
85 gobject_class = (GObjectClass*) klass;
87 parent_class = g_type_class_peek_parent (klass);
88 gobject_class->finalize = modest_ui_dimming_manager_finalize;
89 gobject_class->dispose = modest_ui_dimming_manager_dispose;
91 g_type_class_add_private (gobject_class, sizeof(ModestUIDimmingManagerPrivate));
95 modest_ui_dimming_manager_init (ModestUIDimmingManager *obj)
97 ModestUIDimmingManagerPrivate *priv;
99 priv = MODEST_UI_DIMMING_MANAGER_GET_PRIVATE(obj);
101 priv->groups_map = g_hash_table_new_full ((GHashFunc) g_str_hash,
102 (GEqualFunc) g_str_equal,
103 (GDestroyNotify) g_free,
104 (GDestroyNotify) g_object_unref);
105 priv->delayed_calls = g_hash_table_new_full (g_str_hash,
112 remove_all_timeouts (gpointer key,
116 if (GPOINTER_TO_INT (value) > 0)
117 g_source_remove (GPOINTER_TO_INT (value));
121 modest_ui_dimming_manager_finalize (GObject *obj)
123 ModestUIDimmingManagerPrivate *priv;
125 priv = MODEST_UI_DIMMING_MANAGER_GET_PRIVATE(obj);
127 if (priv->groups_map != NULL)
128 g_hash_table_unref (priv->groups_map);
130 if (priv->delayed_calls != NULL) {
131 /* Remove all pending calls */
132 g_hash_table_foreach (priv->delayed_calls,
136 g_hash_table_unref (priv->delayed_calls);
139 G_OBJECT_CLASS(parent_class)->finalize (obj);
143 dispose_objects (gpointer key,
147 if (G_IS_OBJECT (value))
148 g_object_run_dispose (value);
152 modest_ui_dimming_manager_dispose (GObject *obj)
154 ModestUIDimmingManagerPrivate *priv;
156 priv = MODEST_UI_DIMMING_MANAGER_GET_PRIVATE(obj);
158 if (priv->delayed_calls != NULL && (g_hash_table_size (priv->delayed_calls) > 0)) {
159 /* Remove all pending calls */
160 g_hash_table_foreach (priv->delayed_calls,
163 g_hash_table_remove_all (priv->delayed_calls);
166 if (priv->groups_map) {
167 g_hash_table_foreach (priv->groups_map, dispose_objects, NULL);
168 g_hash_table_unref (priv->groups_map);
169 priv->groups_map = NULL;
172 G_OBJECT_CLASS(parent_class)->dispose (obj);
176 ModestUIDimmingManager*
177 modest_ui_dimming_manager_new()
179 ModestUIDimmingManager *obj;
181 obj = MODEST_UI_DIMMING_MANAGER(g_object_new(MODEST_TYPE_UI_DIMMING_MANAGER, NULL));
188 modest_ui_dimming_manager_insert_rules_group (ModestUIDimmingManager *self,
189 ModestDimmingRulesGroup *group)
191 ModestUIDimmingManagerPrivate *priv;
192 gchar *group_name = NULL;
193 gboolean unique = FALSE;
195 priv = MODEST_UI_DIMMING_MANAGER_GET_PRIVATE(self);
198 group_name = modest_dimming_rules_group_get_name (group);
200 /* Check group name is unique */
201 unique = g_hash_table_lookup (priv->groups_map, group_name) == NULL;
204 g_return_if_fail (unique);
208 /* Insert new dimming rules group */
209 g_hash_table_insert (priv->groups_map, group_name, g_object_ref(group));
213 modest_ui_dimming_manager_process_dimming_rules (ModestUIDimmingManager *self)
215 ModestUIDimmingManagerPrivate *priv;
217 priv = MODEST_UI_DIMMING_MANAGER_GET_PRIVATE(self);
219 /* Peforms a full dimming tules checking */
220 g_hash_table_foreach (priv->groups_map, _process_all_rules, NULL);
225 ModestDimmingRulesGroup *group;
226 ModestUIDimmingManager *manager;
229 } DelayedDimmingRules;
232 process_dimming_rules_delayed (gpointer data)
234 DelayedDimmingRules *helper = (DelayedDimmingRules *) data;
235 gpointer timeout_handler;
236 ModestUIDimmingManagerPrivate *priv;
238 /* Let the destroyer remove it from the hash table */
239 helper->delete = TRUE;
241 /* We remove the timeout here because the execute action could
242 take too much time, and so this will be called again */
243 priv = MODEST_UI_DIMMING_MANAGER_GET_PRIVATE(helper->manager);
244 timeout_handler = g_hash_table_lookup (priv->delayed_calls, helper->name);
246 if (GPOINTER_TO_INT (timeout_handler) > 0) {
247 g_source_remove (GPOINTER_TO_INT (timeout_handler));
250 gdk_threads_enter ();
251 modest_dimming_rules_group_execute (helper->group);
252 gdk_threads_leave ();
258 process_dimming_rules_delayed_destroyer (gpointer data)
260 DelayedDimmingRules *helper = (DelayedDimmingRules *) data;
261 ModestUIDimmingManagerPrivate *priv;
263 priv = MODEST_UI_DIMMING_MANAGER_GET_PRIVATE(helper->manager);
265 /* We can only destroy it if we had really executed it. If the
266 source is removed because the manager is finalized then we
267 cannot remove it because it removes the sources in a
268 foreach, that does not allow you to modify the hash table
271 g_hash_table_remove (priv->delayed_calls, helper->name);
273 g_free (helper->name);
274 g_object_unref (helper->manager);
275 g_slice_free (DelayedDimmingRules, helper);
279 modest_ui_dimming_manager_process_dimming_rules_group (ModestUIDimmingManager *self,
280 const gchar *group_name)
282 ModestDimmingRulesGroup *group = NULL;
283 ModestUIDimmingManagerPrivate *priv;
284 guint *handler, new_handler;
285 DelayedDimmingRules *helper;
287 g_return_if_fail (group_name != NULL);
289 priv = MODEST_UI_DIMMING_MANAGER_GET_PRIVATE(self);
291 /* Search group by name */
292 group = MODEST_DIMMING_RULES_GROUP(g_hash_table_lookup (priv->groups_map, group_name));
293 g_return_if_fail (group != NULL);
295 /* If there was another pending dimming operation check then ignore this */
296 handler = g_hash_table_lookup (priv->delayed_calls, group_name);
298 /* Create the helper and start the timeout */
299 helper = g_slice_new (DelayedDimmingRules);
300 helper->group = group;
301 helper->manager = g_object_ref (self);
302 helper->name = g_strdup (group_name);
303 helper->delete = FALSE;
304 new_handler = g_timeout_add_full (G_PRIORITY_DEFAULT, 100,
305 process_dimming_rules_delayed,
306 helper, process_dimming_rules_delayed_destroyer);
307 g_hash_table_insert (priv->delayed_calls,
308 g_strdup (group_name),
309 GINT_TO_POINTER (new_handler));
310 MODEST_DEBUG_BLOCK(g_print ("---------------------Adding %d\n", new_handler););
312 MODEST_DEBUG_BLOCK(g_print ("---------------------Ignoring\n"););
318 _process_all_rules (gpointer key, gpointer value, gpointer user_data)
320 g_return_if_fail (MODEST_IS_DIMMING_RULES_GROUP (value));
322 modest_dimming_rules_group_execute (MODEST_DIMMING_RULES_GROUP (value));
326 modest_ui_dimming_manager_set_widget_dimming_mode (GtkWidget *widget,
327 ModestUIDimmingMode mode)
329 g_return_if_fail (GTK_IS_WIDGET (widget));
331 g_object_set_data (G_OBJECT (widget), WIDGET_DIMMING_MODE, GINT_TO_POINTER (mode));
335 modest_ui_dimming_manager_get_widget_dimming_mode (GtkWidget *widget)
337 g_return_val_if_fail (GTK_IS_WIDGET (widget), MODEST_UI_DIMMING_MODE_DIM);
339 return (ModestUIDimmingMode) GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), WIDGET_DIMMING_MODE));