« back to all changes in this revision
Viewing changes to src/alarms-list.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Chow Loong Jin
- Date: 2009-05-30 23:24:27 UTC
- Revision ID: james.westby@ubuntu.com-20090530232427-88on1j2ily4ajxdz
Tags: upstream-0.2.6
Import upstream version 0.2.6
- files added:
- src
- src/icons
- src/tests
- src/ui
added
removed
src/alarms-list.c
1
/*
2
* alarms-list.d -- List alarms dialog
3
*
4
* Copyright (C) 2007-2008 Johannes H. Jensen <joh@pseudoberries.com>
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
8
* as published by the Free Software Foundation; either version 2
9
* of the License, or (at your option) any later version.
10
*
11
* This program is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
* GNU 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, write to the Free Software
18
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19
*
20
* Authors:
21
* Johannes H. Jensen <joh@pseudoberries.com>
22
*/
23
24
#include "alarms-list.h"
25
#include "edit-alarm.h"
26
27
static void
28
list_alarms_toggled_cb (GtkCellRendererToggle *cell_renderer,
29
gchar *path,
30
gpointer data)
31
{
32
GtkListStore *model = GTK_LIST_STORE (data);
33
GtkTreeIter iter;
34
Alarm *alarm;
35
36
gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (model), &iter, path);
37
gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, 0, &alarm, -1);
38
39
g_debug ("list_alarms_toggled %s: #%d", path, alarm->id);
40
41
alarm_set_enabled (alarm, !(alarm->active));
42
43
/*
44
* gtk_tree_model_get () will increase the reference count
45
* of the alarms each time it's called. We dereference it
46
* here so they can be properly freed later with g_object_unref()
47
*/
48
g_object_unref (alarm);
49
}
50
51
typedef struct _AlarmModelChangedArg {
52
GtkListStore *store;
53
GtkTreeIter iter;
54
Alarm *alarm;
55
} AlarmModelChangedArg;
56
57
static void
58
list_alarms_clear_args (AlarmApplet *applet)
59
{
60
GList *l;
61
AlarmModelChangedArg *arg;
62
63
/*
64
* Free old list of arguments
65
*/
66
for (l = applet->list_alarms_args; l; l = l->next) {
67
arg = (AlarmModelChangedArg *)l->data;
68
69
// Remove any callbacks
70
g_source_remove_by_user_data (arg);
71
72
// Free argument
73
g_free (arg);
74
}
75
76
g_list_free (applet->list_alarms_args);
77
applet->list_alarms_args = NULL;
78
}
79
80
static gboolean
81
list_alarms_update_timer (gpointer data)
82
{
83
AlarmModelChangedArg *arg = (AlarmModelChangedArg *)data;
84
GtkTreePath *path;
85
86
if (!GTK_IS_TREE_MODEL (arg->store)) {
87
// Dialog is closed, free args
88
g_free (arg);
89
return FALSE;
90
}
91
92
if (!arg->alarm->active)
93
return FALSE;
94
95
path = gtk_tree_model_get_path (GTK_TREE_MODEL (arg->store), &(arg->iter));
96
97
gtk_tree_model_row_changed (GTK_TREE_MODEL (arg->store), path, &(arg->iter));
98
99
gtk_tree_path_free (path);
100
}
101
102
static void
103
list_alarms_add_timer (AlarmModelChangedArg *arg)
104
{
105
g_source_remove_by_user_data (arg);
106
g_timeout_add_seconds (1, (GSourceFunc) list_alarms_update_timer, arg);
107
}
108
109
static void
110
alarm_model_changed (AlarmModelChangedArg *arg)
111
{
112
GtkTreePath *path;
113
114
// TODO: Only update on the actual fields we're interested?
115
116
path = gtk_tree_model_get_path (GTK_TREE_MODEL (arg->store), &(arg->iter));
117
118
gtk_tree_model_row_changed (GTK_TREE_MODEL (arg->store), path, &(arg->iter));
119
120
gtk_tree_path_free (path);
121
}
122
123
/*
124
* Callback for when an alarm changes
125
* Emits model-row-changed
126
*/
127
static void
128
alarm_changed (GObject *object,
129
GParamSpec *param,
130
gpointer data)
131
{
132
AlarmModelChangedArg *arg = (AlarmModelChangedArg *)data;
133
Alarm *a = ALARM (object);
134
135
alarm_model_changed (arg);
136
137
// If alarm is active, update the view every second for remaining time
138
if (strcmp (param->name, "active") == 0 && a->active) {
139
list_alarms_add_timer (arg);
140
}
141
}
142
143
/*
144
* Callback for when the alarm player changes
145
*/
146
static void
147
alarm_player_changed (Alarm *a, MediaPlayerState state, gpointer data)
148
{
149
g_debug ("alarm_player_changed: %d", state);
150
alarm_model_changed ((AlarmModelChangedArg *)data);
151
}
152
153
/*
154
* Update list of alarms (VIEW)
155
*/
156
void
157
list_alarms_update (AlarmApplet *applet)
158
{
159
GtkListStore *store = applet->list_alarms_store;
160
GtkTreeIter iter;
161
GList *l = NULL, *args = NULL;
162
Alarm *a;
163
AlarmModelChangedArg *arg;
164
165
g_debug ("list_alarms_update ()");
166
167
g_assert (store);
168
169
/*
170
* Clear model
171
*/
172
gtk_list_store_clear (store);
173
174
/*
175
* Insert alarms
176
*/
177
for (l = applet->alarms; l; l = l->next) {
178
a = ALARM (l->data);
179
180
gtk_list_store_append (store, &iter);
181
182
gtk_list_store_set (store, &iter, 0, a, -1);
183
184
// Create arg
185
arg = g_new (AlarmModelChangedArg, 1);
186
arg->store = store;
187
arg->iter = iter;
188
arg->alarm = a;
189
190
// Append to argument list
191
args = g_list_append (args, arg);
192
193
// Disconnect old handlers, if any
194
g_signal_handlers_disconnect_matched (a, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, alarm_changed, NULL);
195
196
// Notify us of changes to the alarm
197
g_signal_connect (a, "notify", G_CALLBACK (alarm_changed), arg);
198
199
// Notify us of changes to the alarm player
200
g_signal_connect (a, "player_changed", G_CALLBACK (alarm_player_changed), arg);
201
202
// If alarm is active, update the view every second for remaining time
203
if (a->active) {
204
list_alarms_add_timer (arg);
205
}
206
207
g_print ("Alarm #%d (%p): %s [ref=%d]\n", a->id, a, a->message, G_OBJECT (a)->ref_count);
208
}
209
210
/* Clear old arguments */
211
list_alarms_clear_args (applet);
212
213
/* Update with new list of args */
214
applet->list_alarms_args = args;
215
}
216
217
static void
218
alarm_update_renderer (GtkTreeViewColumn *tree_column,
219
GtkCellRenderer *renderer,
220
GtkTreeModel *model,
221
GtkTreeIter *iter,
222
gpointer data)
223
{
224
AlarmColumn col = (AlarmColumn)data;
225
Alarm *a;
226
time_t hour, min, sec, now;
227
struct tm *tm;
228
gchar *tmp;
229
230
gtk_tree_model_get (model, iter, 0, &a, -1);
231
232
switch (col) {
233
case TYPE_COLUMN:
234
if (a->type == ALARM_TYPE_TIMER) {
235
g_object_set (renderer, "icon-name", TIMER_ICON, NULL);
236
} else {
237
g_object_set (renderer, "icon-name", ALARM_ICON, NULL);
238
}
239
break;
240
case ACTIVE_COLUMN:
241
g_object_set (renderer, "active", a->active, NULL);
242
break;
243
case TIME_COLUMN:
244
/* If alarm is running (active), show remaining time */
245
if (a->active) {
246
tm = alarm_get_remain (a);
247
} else {
248
tm = alarm_get_time (a);
249
}
250
251
tmp = g_strdup_printf(_("%02d:%02d:%02d"), tm->tm_hour, tm->tm_min, tm->tm_sec);
252
253
g_object_set (renderer, "text", tmp, NULL);
254
255
g_free (tmp);
256
break;
257
case LABEL_COLUMN:
258
g_object_set (renderer, "text", a->message, NULL);
259
break;
260
case PLAYING_COLUMN:
261
if (alarm_is_playing (a)) {
262
g_object_set (renderer, "icon-name", "audio-volume-high", NULL);
263
} else {
264
g_object_set (renderer, "icon-name", NULL, NULL);
265
}
266
break;
267
default:
268
break;
269
}
270
271
/*
272
* gtk_tree_model_get () will increase the reference count
273
* of the alarms each time it's called. We dereference it
274
* here so they can be properly freed later with g_object_unref()
275
*/
276
g_object_unref (a);
277
278
//g_debug ("alarm_update_render: alarm #%d (%p), col %d, ref=%d", a->id, a, col, G_OBJECT (a)->ref_count);
279
}
280
281
static void
282
list_alarms_dialog_response_cb (GtkDialog *dialog,
283
gint rid,
284
AlarmApplet *applet)
285
{
286
list_alarms_dialog_close (applet);
287
}
288
289
static void
290
add_button_cb (GtkButton *button, gpointer data)
291
{
292
Alarm *alarm;
293
AlarmApplet *applet = (AlarmApplet *)data;
294
AlarmListEntry *entry;
295
296
/*
297
* Create new alarm, will fall back to defaults.
298
*/
299
alarm = alarm_new (ALARM_GCONF_DIR, -1);
300
301
/*
302
* Set first sound / app in list
303
*/
304
if (applet->sounds != NULL) {
305
entry = (AlarmListEntry *)applet->sounds->data;
306
g_object_set (alarm, "sound-file", entry->data, NULL);
307
}
308
309
if (applet->apps != NULL) {
310
entry = (AlarmListEntry *)applet->apps->data;
311
g_object_set (alarm, "command", entry->data, NULL);
312
}
313
314
// Add alarm to list of alarms
315
alarm_applet_alarms_add (applet, alarm);
316
317
// Show edit alarm dialog
318
display_edit_alarm_dialog (applet, alarm);
319
320
/*
321
* Update alarms list view
322
*/
323
list_alarms_update (applet);
324
}
325
326
static Alarm *
327
get_selected_alarm (AlarmApplet *applet)
328
{
329
GtkTreeSelection *selection;
330
GtkTreeIter iter;
331
GtkTreeModel *model;
332
Alarm *a;
333
334
g_assert (applet);
335
g_assert (applet->list_alarms_view);
336
337
/* Fetch selection */
338
selection = gtk_tree_view_get_selection (applet->list_alarms_view);
339
340
if (!gtk_tree_selection_get_selected(selection, &model, &iter)) {
341
/* No alarms selected */
342
g_debug ("get_selected_alarm: No alarms selected");
343
return NULL;
344
}
345
346
gtk_tree_model_get (model, &iter, 0, &a, -1);
347
348
/*
349
* gtk_tree_model_get () will increase the reference count
350
* of the alarms each time it's called. We dereference it
351
* here so they can be properly freed later with g_object_unref()
352
*/
353
g_object_unref (a);
354
355
return a;
356
}
357
358
static void
359
edit_button_cb (GtkButton *button, gpointer data)
360
{
361
AlarmApplet *applet = (AlarmApplet *)data;
362
Alarm *a = get_selected_alarm (applet);
363
364
if (!a) {
365
/* No alarms selected */
366
return;
367
}
368
369
// Clear any running alarms
370
alarm_clear (a);
371
372
display_edit_alarm_dialog (applet, a);
373
}
374
375
static void
376
delete_button_cb (GtkButton *button, gpointer data)
377
{
378
AlarmApplet *applet = (AlarmApplet *)data;
379
Alarm *a = get_selected_alarm (applet);
380
381
GtkWidget *dialog;
382
gint response;
383
384
if (!a) {
385
/* No alarms selected */
386
return;
387
}
388
389
// Clear any running alarms
390
alarm_clear (a);
391
392
dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (applet->list_alarms_dialog),
393
GTK_DIALOG_DESTROY_WITH_PARENT,
394
GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE,
395
_("<big><b>Delete alarm '%s'?</b></big>"),
396
a->message);
397
g_object_set (dialog,
398
"title", _("Delete Alarm?"),
399
"icon-name", ALARM_ICON,
400
NULL);
401
402
gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog),
403
_("Are you sure you want to delete\nalarm <b>#%d</b> labeled '<b>%s</b>'?"),
404
a->id, a->message);
405
406
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
407
gtk_dialog_add_buttons(GTK_DIALOG (dialog),
408
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
409
GTK_STOCK_DELETE, GTK_RESPONSE_ACCEPT,
410
NULL);
411
response = gtk_dialog_run (GTK_DIALOG (dialog));
412
gtk_widget_destroy (dialog);
413
414
if (response == GTK_RESPONSE_ACCEPT) {
415
g_debug ("delete_button_cb: GTK_RESPONSE_ACCEPT");
416
417
/*
418
* Delete GCONF
419
*/
420
alarm_delete (a);
421
422
/* If there's a settings dialog open for this
423
* alarm, destroy it.
424
*/
425
AlarmSettingsDialog *sdialog = g_hash_table_lookup (applet->edit_alarm_dialogs, (gconstpointer)a->id);
426
if (sdialog) {
427
alarm_settings_dialog_close (sdialog);
428
}
429
430
/*
431
* Remove from applet list
432
*/
433
alarm_applet_alarms_remove (applet, a);
434
435
/*
436
* Fill store with alarms
437
*/
438
list_alarms_update (applet);
439
} else {
440
g_debug ("delete_button_cb: GTK_RESPONSE_CANCEL");
441
}
442
}
443
444
static void
445
list_alarm_selected_cb (GtkTreeView *view,
446
GtkTreePath *path,
447
GtkTreeViewColumn *column,
448
gpointer data)
449
{
450
GtkTreeIter iter;
451
GtkTreeModel *model;
452
Alarm *a;
453
AlarmApplet *applet = (AlarmApplet *)data;
454
455
model = gtk_tree_view_get_model (view);
456
457
if (!gtk_tree_model_get_iter (model, &iter, path)) {
458
g_warning ("Could not get iter.");
459
return;
460
}
461
462
gtk_tree_model_get (model, &iter, 0, &a, -1);
463
464
/*
465
* gtk_tree_model_get () will increase the reference count
466
* of the alarms each time it's called. We dereference it
467
* here so they can be properly freed later with g_object_unref()
468
*/
469
g_object_unref (a);
470
471
// Clear any running alarms
472
alarm_clear (a);
473
474
display_edit_alarm_dialog (applet, a);
475
}
476
477
void
478
list_alarms_dialog_close (AlarmApplet *applet)
479
{
480
GList *l;
481
Alarm *a;
482
483
g_assert (applet->list_alarms_dialog);
484
485
// Destroy dialog
486
gtk_widget_destroy (GTK_WIDGET (applet->list_alarms_dialog));
487
applet->list_alarms_dialog = NULL;
488
489
// Free list store
490
g_object_unref (applet->list_alarms_store);
491
applet->list_alarms_store = NULL;
492
493
/* g_object_unref (applet->list_alarms_view);*/
494
applet->list_alarms_view = NULL;
495
496
// Disconnect notify handlers
497
for (l = applet->alarms; l != NULL; l = l->next) {
498
a = ALARM (l->data);
499
g_signal_handlers_disconnect_matched (a, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, alarm_changed, NULL);
500
g_signal_handlers_disconnect_matched (a, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, alarm_player_changed, NULL);
501
}
502
503
/* Clear old arguments */
504
list_alarms_clear_args (applet);
505
}
506
507
void
508
list_alarms_dialog_display (AlarmApplet *applet)
509
{
510
if (applet->list_alarms_dialog != NULL) {
511
// Dialog already open.
512
gtk_window_present (GTK_WINDOW (applet->list_alarms_dialog));
513
return;
514
}
515
516
gchar *tmp;
517
GList *l; /* List of alarms */
518
Alarm *a;
519
520
GtkListStore *store;
521
GtkTreeView *view;
522
GtkTreeIter iter;
523
GdkPixbuf *type_alarm_icon, *type_timer_icon;
524
GtkCellRenderer *type_renderer, *active_renderer,
525
*time_renderer, *label_renderer,
526
*playing_renderer;
527
528
GtkTreeViewColumn *type_col, *active_col,
529
*time_col, *label_col,
530
*playing_col;
531
532
GladeXML *ui;
533
GtkButton *add_button, *edit_button, *delete_button;
534
535
/*
536
* Fetch widgets
537
*/
538
ui = glade_xml_new (ALARM_UI_XML, "list-alarms", NULL);
539
540
applet->list_alarms_dialog = GTK_DIALOG (glade_xml_get_widget (ui, "list-alarms"));
541
view = GTK_TREE_VIEW (glade_xml_get_widget (ui, "list-alarms-view"));
542
applet->list_alarms_view = view;
543
544
g_signal_connect (applet->list_alarms_dialog, "response",
545
G_CALLBACK (list_alarms_dialog_response_cb), applet);
546
547
// Buttons
548
add_button = GTK_BUTTON (glade_xml_get_widget (ui, "add-button"));
549
edit_button = GTK_BUTTON (glade_xml_get_widget (ui, "edit-button"));
550
delete_button = GTK_BUTTON (glade_xml_get_widget (ui, "delete-button"));
551
552
g_signal_connect (add_button, "clicked",
553
G_CALLBACK (add_button_cb), applet);
554
g_signal_connect (edit_button, "clicked",
555
G_CALLBACK (edit_button_cb), applet);
556
g_signal_connect (delete_button, "clicked",
557
G_CALLBACK (delete_button_cb), applet);
558
559
/*
560
* Create list store model
561
*/
562
store = gtk_list_store_new (1, TYPE_ALARM);
563
applet->list_alarms_store = store;
564
565
/*
566
* Fill store with alarms
567
*/
568
list_alarms_update (applet);
569
570
/*
571
* Create view cell renderers
572
*/
573
type_renderer = gtk_cell_renderer_pixbuf_new ();
574
575
active_renderer = gtk_cell_renderer_toggle_new ();
576
g_object_set (active_renderer,
577
/*"mode", GTK_CELL_RENDERER_MODE_EDITABLE,*/
578
"activatable", TRUE,
579
NULL);
580
g_signal_connect (active_renderer, "toggled", G_CALLBACK (list_alarms_toggled_cb), store);
581
582
time_renderer = gtk_cell_renderer_text_new ();
583
584
label_renderer = gtk_cell_renderer_text_new ();
585
g_object_set (label_renderer,
586
"weight", 1000,
587
"mode", GTK_CELL_RENDERER_MODE_EDITABLE,
588
NULL);
589
590
playing_renderer = gtk_cell_renderer_pixbuf_new ();
591
592
/*
593
* Create view columns
594
*/
595
type_col = gtk_tree_view_column_new_with_attributes(
596
_("Type"), type_renderer,
597
NULL);
598
599
gtk_tree_view_column_set_cell_data_func (type_col, type_renderer,
600
alarm_update_renderer,
601
TYPE_COLUMN, NULL);
602
603
604
active_col = gtk_tree_view_column_new_with_attributes(
605
_("Active"), active_renderer,
606
NULL);
607
608
gtk_tree_view_column_set_cell_data_func (active_col, active_renderer,
609
alarm_update_renderer,
610
ACTIVE_COLUMN, NULL);
611
612
613
time_col = gtk_tree_view_column_new_with_attributes(
614
_("Time"), time_renderer,
615
NULL);
616
617
gtk_tree_view_column_set_cell_data_func(time_col, time_renderer,
618
alarm_update_renderer,
619
TIME_COLUMN, NULL);
620
621
622
label_col = gtk_tree_view_column_new_with_attributes(
623
_("Label"), label_renderer,
624
NULL);
625
626
gtk_tree_view_column_set_cell_data_func(label_col, label_renderer,
627
alarm_update_renderer,
628
LABEL_COLUMN, NULL);
629
630
playing_col = gtk_tree_view_column_new_with_attributes(
631
_("Playing"), playing_renderer,
632
NULL);
633
634
gtk_tree_view_column_set_cell_data_func (playing_col, playing_renderer,
635
alarm_update_renderer,
636
PLAYING_COLUMN, NULL);
637
638
/*
639
* Set up tree view
640
*/
641
gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));
642
643
gtk_tree_view_append_column (view, type_col);
644
gtk_tree_view_append_column (view, active_col);
645
gtk_tree_view_append_column (view, time_col);
646
gtk_tree_view_append_column (view, label_col);
647
gtk_tree_view_append_column (view, playing_col);
648
649
/*
650
* Set up signal handlers
651
*/
652
g_signal_connect (view, "row-activated", G_CALLBACK (list_alarm_selected_cb), applet);
653
654
// TODO: Calculate a good initial size for the window
655
656
//gtk_container_add (GTK_CONTAINER (list_alarms_box), GTK_WIDGET (view));
657
//gtk_box_pack_start_defaults (GTK_BOX (list_alarms_scrol), GTK_WIDGET (view));
658
659
gtk_widget_show_all (GTK_WIDGET (applet->list_alarms_dialog));
660
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1