« back to all changes in this revision
Viewing changes to src/mediamarks.c
- browse files at revision 1.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 1.1.1
- Committer: Bazaar Package Importer
- Author(s): Siggi Langauf
- Date: 2005-01-05 01:49:18 UTC
- mto: (2.1.1 etch) (1.1.9 upstream)
- mto: This revision was merged to the branch mainline in revision 3.
- Revision ID: james.westby@ubuntu.com-20050105014918-wgldiqcd79ck2b0v
Tags: upstream-0.4.1
Import upstream version 0.4.1
- files added:
- config.rpath
- po
- files removed:
- src/actions.c
- files modified:
- ABOUT-NLS
added
removed
src/mediamarks.c
1
1
/*
2
* Copyright (C) 2002-2003 the xine-project
2
* Copyright (C) 2002-2004 the xine-project
3
3
*
4
4
* This program is free software; you can redistribute it and/or
5
5
* modify it under the terms of the GNU General Public License as
16
16
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
17
17
* USA
18
18
*
19
* $Id: mediamarks.c,v 1.18 2003/03/08 15:50:36 guenter Exp $
19
* $Id: mediamarks.c,v 1.37 2004/12/17 00:33:00 dsalt Exp $
20
20
*
21
21
* mediamarks - load
22
22
* - save
24
24
* functions
25
25
*/
26
26
27
#include "config.h"
27
#include "globals.h"
28
28
29
29
#include <stdio.h>
30
30
#include <stdlib.h>
31
31
#include <string.h>
32
#include <errno.h>
32
33
#include <gtk/gtk.h>
33
34
#include <gdk/gdk.h>
34
35
#include <glib.h>
35
36
36
#include "globals.h"
37
37
#include "utils.h"
38
#include "gtkxine.h"
39
#include "actions.h"
38
#include "engine.h"
40
39
#include "mediamarks.h"
40
#include "menu.h"
41
41
#include "playlist.h"
42
42
#include "play_item.h"
43
43
44
#define PLACEHOLDER "(---)"
45
46
44
static GtkTreeStore *mm_store;
47
static GtkWidget *manage_dlg, *cat_dlg, *cat_entry;
45
static GtkWidget *manage_dlg, *cat_dlg, *cat_entry, *mm_tree;
48
46
static GtkTreeIter cat_iter;
49
static int is_visible;
47
static gboolean is_visible, cat_edited;
50
48
51
49
static void menu_cb (GtkWidget* widget, gpointer data) {
52
50
58
56
59
57
item = play_item_copy (item_orig);
60
58
61
pos = playlist_add (item);
59
pos = playlist_add (item, -1);
62
60
playlist_play (pos);
63
61
}
64
62
}
81
79
iter, 0, &v);
82
80
id = g_value_peek_pointer (&v);
83
81
84
if (id && strcmp (id, PLACEHOLDER)) {
82
if (id) {
85
83
item = gtk_menu_item_new_with_label (id);
86
84
g_value_unset (&v);
87
85
126
124
GtkWidget *item;
127
125
GtkTreeIter iter;
128
126
127
if (!submenu)
128
return;
129
129
130
/*
130
131
* remove old items (if any)
131
132
*/
142
143
143
144
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (mm_store), &iter))
144
145
gen_items (submenu, &iter);
145
146
147
146
}
148
147
149
148
/*
151
150
*/
152
151
153
152
static void get_items (xml_node_t *node, int depth, GtkTreeIter *parent) {
153
/* assumption: *one* of (depth == 0) or (parent == NULL) */
154
154
155
155
while (node) {
156
156
157
157
if (!strcasecmp (node->name, "sub")) {
158
158
159
GtkTreeIter iter, placeholder;
159
GtkTreeIter iter;
160
160
char *id;
161
161
162
162
id = xml_parser_get_property (node, "name");
163
163
164
if (depth)
165
gtk_tree_store_append (mm_store, &iter, parent);
166
else
167
gtk_tree_store_append (mm_store, &iter, NULL);
164
gtk_tree_store_append (mm_store, &iter, parent);
168
165
gtk_tree_store_set (mm_store, &iter, 0, id, -1);
169
gtk_tree_store_append (mm_store, &placeholder, &iter);
170
gtk_tree_store_set (mm_store, &placeholder, 0, PLACEHOLDER, -1);
171
166
172
167
get_items (node->child, depth+1, &iter);
173
168
175
170
play_item_t *play_item = play_item_load (node->child);
176
171
GtkTreeIter iter;
177
172
178
if (depth)
179
gtk_tree_store_append (mm_store, &iter, parent);
180
else
181
gtk_tree_store_append (mm_store, &iter, NULL);
173
gtk_tree_store_append (mm_store, &iter, parent);
182
174
gtk_tree_store_set (mm_store, &iter, 0, play_item->title, 1,
183
175
play_item->mrl, 2, play_item, -1);
184
176
185
177
} else {
186
printf ("mediamarks: error, unknown node type %s\n", node->name);
178
printf (_("mediamarks: error, unknown node type %s\n"), node->name);
187
179
}
188
180
189
181
node = node->next;
196
188
197
189
get_items (node->child, 0, NULL);
198
190
} else {
199
printf ("mediamarks: ERROR, root node must be GXINEMM\n");
191
printf (_("mediamarks: ERROR, root node must be GXINEMM\n"));
200
192
}
201
193
}
202
194
236
228
depth = 0;
237
229
238
230
while (1) {
239
240
231
char *id, *str;
241
232
242
233
id = read_line (f);
245
236
246
237
if (!strncmp (id, "<sub>", 5)) {
247
238
248
GtkTreeIter placeholder;
249
/* sub-tree starts here */
250
251
if (depth)
252
gtk_tree_store_append (mm_store, &iter, &parent);
253
else
254
gtk_tree_store_append (mm_store, &iter, NULL);
239
gtk_tree_store_append (mm_store, &iter, depth ? &parent : NULL);
255
240
gtk_tree_store_set (mm_store, &iter, 0, &id[5], -1);
256
gtk_tree_store_append (mm_store, &placeholder, &iter);
257
gtk_tree_store_set (mm_store, &placeholder, 0, PLACEHOLDER, -1);
258
241
259
memcpy (&parent, &iter, sizeof (iter));
242
parent = iter;
260
243
depth++;
261
244
262
245
} else if (!strncmp (id, "</sub>", 6)) {
268
251
depth--;
269
252
if (depth<0) {
270
253
271
printf ("mediamarks: mediamarks file %s corrupted, ignoring rest of file\n",
254
printf (_("mediamarks: media marks file %s corrupted - ignoring rest of file\n"),
272
255
fname);
273
256
return;
274
257
}
275
memcpy (&parent, &iter, sizeof (iter));
258
parent = iter;
276
259
277
260
} else {
278
261
279
262
play_item_t *play_item;
280
263
char *mrl;
281
int time;
264
int time = 0;
282
265
283
266
mrl = read_line (f);
284
267
if (!mrl)
291
274
292
275
play_item = play_item_new (id, mrl, time);
293
276
294
if (depth)
295
gtk_tree_store_append (mm_store, &iter, &parent);
296
else
297
gtk_tree_store_append (mm_store, &iter, NULL);
277
gtk_tree_store_append (mm_store, &iter, depth ? &parent : NULL);
298
278
gtk_tree_store_set (mm_store, &iter, 0, id, 1, mrl, 2, play_item, -1);
299
279
}
300
280
306
286
fclose (f);
307
287
} else {
308
288
309
printf ("mediamarks: load failed!\n");
310
311
}
312
}
313
314
static void win_delete_cb (GtkWidget* widget, gpointer data) {
315
gtk_widget_hide (widget);
316
is_visible = 0;
317
}
318
319
static gboolean close_cb (GtkWidget* widget, gpointer data) {
320
gtk_widget_hide (manage_dlg);
321
is_visible = 0;
322
323
return TRUE;
324
}
325
326
static void cat_apply (void) {
327
const char *name = gtk_entry_get_text (GTK_ENTRY(cat_entry));
328
329
gtk_tree_store_set (mm_store, &cat_iter, 0, name, -1);
330
}
331
332
static void cat_delete_cb (GtkWidget* widget, gpointer data) {
333
gtk_widget_hide (widget);
334
cat_apply ();
335
}
336
337
static void cat_close_cb (GtkWidget* widget, gpointer data) {
338
gtk_widget_hide (data);
339
cat_apply ();
289
printf (_("mediamarks: load failed!\n"));
290
291
}
292
}
293
294
static void cat_response_cb (GtkDialog* widget, int response, gpointer data)
295
{
296
switch (response)
297
{
298
case GTK_RESPONSE_OK:
299
cat_edited = TRUE;
300
default:
301
gtk_widget_hide (cat_dlg);
302
gtk_main_quit();
303
}
304
}
305
306
static gboolean do_category_edit (void)
307
{
308
cat_edited = FALSE;
309
gtk_widget_show_all (cat_dlg);
310
if (!GTK_WINDOW(cat_dlg)->modal)
311
gtk_window_set_modal (GTK_WINDOW(cat_dlg), TRUE);
312
gtk_widget_grab_focus (cat_entry);
313
314
gtk_main();
315
316
return cat_edited;
340
317
}
341
318
342
319
static void edit_cb (GtkWidget* widget, gpointer data) {
343
320
344
GtkTreeView *tree = (GtkTreeView *) data;
321
GtkTreeView *tree = GTK_TREE_VIEW (mm_tree);
345
322
GtkTreeSelection *sel;
346
323
GtkTreeIter iter;
347
324
356
333
&iter, 2, &v);
357
334
play_item = g_value_peek_pointer (&v);
358
335
if (play_item) {
359
#ifdef LOG
360
printf ("mediamarks: got a play item\n");
361
#endif
362
363
play_item_edit (play_item);
364
365
#ifdef LOG
366
printf ("mediamarks: play item title after edit : %s\n",
367
play_item->title);
368
#endif
369
370
gtk_tree_store_set (mm_store, &iter,
371
0, play_item->title,
372
1, play_item->mrl, 2, play_item, -1);
373
374
336
logprintf ("mediamarks: got a play item\n");
337
if (play_item_edit (play_item, PLAY_ITEM_MEDIAMARK, NULL))
338
{
339
logprintf ("mediamarks: play item title after edit : %s\n",
340
play_item->title);
341
gtk_tree_store_set (mm_store, &iter,
342
0, play_item->title,
343
1, play_item->mrl, 2, play_item, -1);
344
}
375
345
} else {
376
346
GValue v;
377
347
char *name;
385
355
gtk_entry_set_text (GTK_ENTRY (cat_entry), name);
386
356
g_value_unset (&v);
387
357
388
gtk_widget_show_all (cat_dlg);
389
gtk_widget_map (cat_dlg);
390
gtk_widget_grab_focus (cat_entry);
358
if (do_category_edit ())
359
gtk_tree_store_set (mm_store, &cat_iter, 0,
360
gtk_entry_get_text (GTK_ENTRY(cat_entry)), -1);
391
361
}
392
362
g_value_unset (&v);
393
363
}
395
365
396
366
static void delete_cb (GtkWidget* widget, gpointer data) {
397
367
398
GtkTreeView *tree = (GtkTreeView *) data;
368
GtkTreeView *tree = GTK_TREE_VIEW (mm_tree);
399
369
GtkTreeSelection *sel;
400
370
GtkTreeIter iter;
401
371
402
372
sel = gtk_tree_view_get_selection (tree);
403
373
404
if (gtk_tree_selection_get_selected (sel, NULL, &iter)) {
405
GValue v;
406
char *id;
407
408
memset (&v, 0, sizeof (GValue));
409
410
gtk_tree_model_get_value (GTK_TREE_MODEL (mm_store),
411
&iter, 0, &v);
412
id = (char *) g_value_peek_pointer (&v);
413
414
if (!strcmp (id, PLACEHOLDER)) {
415
g_value_unset (&v);
416
return;
417
}
418
419
g_value_unset (&v);
420
374
if (gtk_tree_selection_get_selected (sel, NULL, &iter))
421
375
gtk_tree_store_remove (mm_store, &iter);
422
}
423
376
}
424
377
425
378
static void new_category_cb (GtkWidget* widget, gpointer data) {
426
379
427
GtkTreeView *tree = (GtkTreeView *) data;
380
GtkTreeView *tree = GTK_TREE_VIEW (mm_tree);
428
381
GtkTreeSelection *sel;
429
GtkTreeIter iter, parent;
430
int in_root;
382
GtkTreeIter iter, parent;
383
gboolean in_root = TRUE;
431
384
432
385
/*
433
386
* find out where to create the new section
434
387
*/
435
388
436
in_root = 1;
437
389
sel = gtk_tree_view_get_selection (tree);
438
390
439
391
if (gtk_tree_selection_get_selected (sel, NULL, &iter)) {
440
392
GValue v;
441
393
play_item_t *play_item;
442
394
443
memset (&v, 0, sizeof (GValue));
444
gtk_tree_model_get_value (GTK_TREE_MODEL (mm_store),
445
&iter, 0, &v);
446
447
g_value_unset (&v);
448
449
395
/*
450
396
* is this a section or a play item ?
451
397
*/
455
401
&iter, 2, &v);
456
402
play_item = g_value_peek_pointer (&v);
457
403
if (play_item) {
458
459
if (!gtk_tree_model_iter_parent (GTK_TREE_MODEL (mm_store),
460
&parent, &iter)) {
461
in_root = 1;
462
} else
463
in_root = 0;
404
in_root = !gtk_tree_model_iter_parent (GTK_TREE_MODEL (mm_store),
405
&parent, &iter);
464
406
} else {
465
407
GtkTreePath *path;
466
467
408
path = gtk_tree_model_get_path (GTK_TREE_MODEL (mm_store), &iter);
468
409
469
410
if (gtk_tree_view_row_expanded (tree, path)) {
470
471
411
in_root = 0;
472
412
memcpy (&parent, &iter, sizeof (iter));
473
474
413
} else {
475
476
if (!gtk_tree_model_iter_parent (GTK_TREE_MODEL (mm_store),
477
&parent, &iter)) {
478
in_root = 1;
479
} else
480
in_root = 0;
414
in_root = !gtk_tree_model_iter_parent (GTK_TREE_MODEL (mm_store),
415
&parent, &iter);
481
416
}
482
417
483
418
gtk_tree_path_free (path);
484
419
}
485
420
g_value_unset (&v);
486
} else {
487
in_root = 1;
488
421
}
489
422
490
423
/*
491
* create new category
492
*/
493
494
if (in_root)
495
gtk_tree_store_append (mm_store, &cat_iter, NULL);
496
else
497
gtk_tree_store_append (mm_store, &cat_iter, &parent);
498
gtk_tree_store_set (mm_store, &cat_iter, 0, "New Category", -1);
499
/* create dummy entry so d&d works */
500
gtk_tree_store_append (mm_store, &iter, &cat_iter);
501
gtk_tree_store_set (mm_store, &iter, 0, PLACEHOLDER, -1);
502
503
/*
504
424
* show dialog, ask for section name
505
425
*/
506
426
507
gtk_entry_set_text (GTK_ENTRY (cat_entry), "New Category");
508
gtk_widget_show_all (cat_dlg);
509
gtk_widget_map (cat_dlg);
510
gtk_widget_grab_focus (cat_entry);
427
gtk_entry_set_text (GTK_ENTRY (cat_entry), _("New Category"));
428
429
if (do_category_edit ())
430
{
431
/* create new category */
432
gtk_tree_store_append (mm_store, &cat_iter, in_root ? NULL : &parent);
433
gtk_tree_store_set (mm_store, &cat_iter, 0,
434
gtk_entry_get_text (GTK_ENTRY(cat_entry)), -1);
435
}
511
436
}
512
437
513
438
static void tree_changed_cb (GtkTreeModel *treemodel,
514
439
GtkTreePath *arg1,
515
440
gpointer user_data) {
516
update_menu (media_menu);
441
update_menu (media_menu[0]);
442
update_menu (media_menu[1]);
517
443
}
518
444
519
static int load_mediamarks (gchar *fname) {
520
521
char *mmfile;
522
523
mmfile = read_entire_file_ascii (fname);
445
static int load_mediamarks (gchar *fname)
446
{
447
char *mmfile = read_entire_file (fname, NULL);
524
448
525
449
if (mmfile) {
526
450
xml_node_t *node;
543
467
544
468
gchar *fname;
545
469
546
fname = modal_file_dialog ("Select mediamarks file to load...", NULL);
470
fname = modal_file_dialog (_("Select media marks file to load..."), NULL);
547
471
548
472
if (fname) {
549
473
550
if (!load_mediamarks (fname))
551
display_error ("Mediamarks load failed",
552
"Couldn't load mediamarks file"
553
"%s", fname);
474
if (!load_mediamarks (fname) && errno != ENOENT)
475
display_error (_("Media marks load failed"),
476
_("Couldn't load media marks file %s\n%s"),
477
fname, strerror (errno));
478
}
479
}
480
481
void mm_add_show () {
482
483
play_item_t *play_item;
484
GtkTreeIter iter;
485
int pos, pos_time, len;
486
char *dot;
487
const char *title = xine_get_meta_info (stream, XINE_META_INFO_TITLE);
488
489
play_item = play_item_copy (playlist_get_item (playlist_get_list_pos()));
490
491
/* default title? try to get title from meta-info */
492
dot = strrchr (play_item->mrl, '.');
493
if (!dot)
494
dot = play_item->mrl + strlen (play_item->mrl);
495
len = strlen (play_item->title);
496
if (title && dot - len > play_item->mrl &&
497
!strncmp (dot - len, play_item->title, len))
498
{
499
free (play_item->title);
500
play_item->title = strdup (title);
501
}
502
503
xine_get_pos_length (stream, &pos, &pos_time, &len);
504
play_item->start_time = (len >= 0) ? pos_time : 0;
505
506
if (play_item_edit (play_item, PLAY_ITEM_MEDIAMARK_NEW, title))
507
{
508
gtk_tree_store_append (mm_store, &iter, NULL);
509
gtk_tree_store_set (mm_store, &iter, 0, play_item->title,
510
1, play_item->mrl, 2, play_item, -1);
511
}
512
}
513
514
515
void mm_manage_show () {
516
517
if (is_visible) {
518
is_visible = FALSE;
519
gtk_widget_hide (manage_dlg);
520
mm_save();
521
} else {
522
is_visible = TRUE;
523
gtk_widget_show_all (manage_dlg);
524
}
525
}
526
527
static void print_depth (FILE *f, int depth) {
528
depth += 2;
529
530
while (depth) {
531
fprintf (f, " ");
532
depth --;
533
}
534
}
535
536
static void save_items (FILE *f, int depth, GtkTreeIter *iter) {
537
538
do {
539
540
GValue v;
541
play_item_t *play_item;
542
char *id;
543
544
memset (&v, 0, sizeof (GValue));
545
gtk_tree_model_get_value (GTK_TREE_MODEL (mm_store),
546
iter, 0, &v);
547
id = g_value_peek_pointer (&v);
548
549
if (id) {
550
551
GValue vi;
552
553
memset (&vi, 0, sizeof (GValue));
554
gtk_tree_model_get_value (GTK_TREE_MODEL (mm_store),
555
iter, 2, &vi);
556
play_item = g_value_peek_pointer (&vi);
557
558
if (play_item) {
559
560
play_item_save (play_item, f, depth);
561
562
} else {
563
564
GtkTreeIter children;
565
566
print_depth (f, depth);
567
fprintf (f, "<SUB NAME=\"%s\">\n", id);
568
569
if (gtk_tree_model_iter_children (GTK_TREE_MODEL(mm_store), &children, iter))
570
save_items (f, depth+2, &children);
571
572
print_depth (f, depth);
573
fprintf (f, "</SUB>\n");
574
575
}
576
577
g_value_unset (&vi);
578
}
579
580
g_value_unset (&v);
581
582
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL(mm_store), iter));
583
}
584
585
void mm_save (void) {
586
587
FILE *f;
588
gchar *fname;
589
590
fname = g_strconcat(g_get_home_dir(), "/.gxine/mediamarks", NULL);
591
592
f = fopen (fname, "w") ;
593
594
if (f) {
595
596
GtkTreeIter iter;
597
598
fprintf (f, "<GXINEMM VERSION=\"1\">\n");
599
600
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (mm_store), &iter))
601
save_items (f, 0, &iter);
602
603
fprintf (f, "</GXINEMM>\n");
604
605
if (ferror (f))
606
printf (_("mediamarks: save to '%s' failed: %s\n"),
607
fname, strerror (errno));
608
if (fclose (f))
609
printf (_("mediamarks: save to '%s' failed: %s\n"),
610
fname, strerror (errno));
611
} else
612
printf (_("mediamarks: save to '%s' failed: %s\n"),
613
fname, strerror (errno));
614
615
g_free(fname);
616
}
617
618
static JSBool js_mm_add_show (JSContext *cx, JSObject *obj, uintN argc,
619
jsval *argv, jsval *rval) {
620
621
/* se_t *se = (se_t *) JS_GetContextPrivate(cx); */
622
623
se_log_fncall ("mm_add_show");
624
625
mm_add_show ();
626
627
return JS_TRUE;
628
}
629
630
static JSBool js_mm_manage_show (JSContext *cx, JSObject *obj, uintN argc,
631
jsval *argv, jsval *rval) {
632
633
/* se_t *se = (se_t *) JS_GetContextPrivate(cx); */
634
635
se_log_fncall ("mm_manage_show");
636
637
mm_manage_show ();
638
639
return JS_TRUE;
640
}
641
642
static JSBool js_import_mediamarks (JSContext *cx, JSObject *obj, uintN argc,
643
jsval *argv, jsval *rval) {
644
645
/* se_t *se = (se_t *) JS_GetContextPrivate(cx); */
646
647
se_log_fncall ("import_mediamarks");
648
649
mm_import ();
650
651
return JS_TRUE;
652
}
653
654
static void mm_response_cb (GtkDialog *dbox, int response, gpointer data)
655
{
656
switch (response)
657
{
658
case GTK_RESPONSE_ACCEPT:
659
mm_save ();
660
break;
661
default:
662
is_visible = FALSE;
663
gtk_widget_hide (manage_dlg);
554
664
}
555
665
}
556
666
557
667
void mediamarks_init (void) {
558
668
559
GtkWidget *tree, *b, *scrolled_window, *hbox;
560
GtkWidget *button, *label;
669
GtkWidget *tree, *b, *scrolled_window, *hbox, *label;
561
670
gchar *fname;
562
671
GtkCellRenderer *cell;
563
672
GtkTreeViewColumn *column;
579
688
580
689
g_free (fname);
581
690
582
fname = g_strconcat (GXINE_MISCDIR, "/mediamarks", NULL);
691
fname = g_strconcat (miscdir, "/mediamarks", NULL);
583
692
load_mediamarks (fname);
584
693
}
585
694
596
705
g_signal_connect (G_OBJECT (mm_store), "rows-reordered",
597
706
G_CALLBACK (tree_changed_cb), NULL);
598
707
599
update_menu (media_menu);
600
708
update_menu (media_menu[0]);
709
update_menu (media_menu[1]);
601
710
602
711
/*
603
712
* create (for now invisible) mm_manage dialog
604
713
*/
605
714
606
manage_dlg = gtk_dialog_new ();
607
gtk_window_set_title (GTK_WINDOW (manage_dlg), "Manage Mediamarks...");
715
manage_dlg = gtk_dialog_new_with_buttons (_("Manage media marks..."), NULL, 0,
716
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
717
GTK_STOCK_CLOSE, GTK_RESPONSE_DELETE_EVENT,
718
NULL);
608
719
gtk_window_set_default_size (GTK_WINDOW (manage_dlg), 400, 250);
609
g_signal_connect( GTK_OBJECT (manage_dlg), "delete_event",
610
G_CALLBACK (win_delete_cb), NULL );
611
b = gtk_dialog_add_button (GTK_DIALOG (manage_dlg), GTK_STOCK_CLOSE, 1);
612
g_signal_connect (GTK_OBJECT(b), "clicked",
613
G_CALLBACK (close_cb),
614
manage_dlg);
720
g_signal_connect (GTK_OBJECT(manage_dlg), "response",
721
G_CALLBACK(mm_response_cb), NULL);
722
hide_on_delete (manage_dlg, &is_visible);
615
723
616
724
/* add a nice tree view widget here */
617
725
618
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(mm_store));
726
mm_tree = tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(mm_store));
619
727
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree), TRUE);
620
728
621
729
cell = gtk_cell_renderer_text_new ();
622
column = gtk_tree_view_column_new_with_attributes ("Mediamarks",
623
cell,
624
"text", 0,
625
NULL);
730
column = gtk_tree_view_column_new_with_attributes (_("Media mark"), cell,
731
"text", 0, NULL);
626
732
gtk_tree_view_append_column (GTK_TREE_VIEW (tree),
627
733
GTK_TREE_VIEW_COLUMN (column));
628
734
629
column = gtk_tree_view_column_new_with_attributes ("mrl",
630
cell,
631
"text", 1,
632
NULL);
735
column = gtk_tree_view_column_new_with_attributes ("MRL", cell,
736
"text", 1, NULL);
633
737
gtk_tree_view_append_column (GTK_TREE_VIEW (tree),
634
738
GTK_TREE_VIEW_COLUMN (column));
635
739
641
745
GTK_POLICY_AUTOMATIC);
642
746
gtk_container_add (GTK_CONTAINER (scrolled_window), tree);
643
747
748
g_signal_connect (GTK_OBJECT (tree), "row-activated",
749
G_CALLBACK (edit_cb), NULL);
750
751
/* add edit button bar */
752
hbox = gtk_hbox_new (FALSE, 2);
753
754
b = gtk_button_new_with_mnemonic (_("_New media mark"));
755
gtk_box_pack_start (GTK_BOX(hbox), b, FALSE, FALSE, 0);
756
g_signal_connect (GTK_OBJECT(b), "clicked",
757
G_CALLBACK(mm_add_show), NULL);
758
759
b = gtk_button_new_with_mnemonic (_("New _category"));
760
gtk_box_pack_start (GTK_BOX(hbox), b, FALSE, FALSE, 0);
761
g_signal_connect (GTK_OBJECT(b), "clicked",
762
G_CALLBACK(new_category_cb), tree);
763
764
b = gtk_button_new_with_mnemonic (_("_Edit"));
765
gtk_box_pack_start (GTK_BOX(hbox), b, FALSE, FALSE, 0);
766
g_signal_connect (GTK_OBJECT(b), "clicked",
767
G_CALLBACK(edit_cb), NULL);
768
769
b = gtk_button_new_from_stock (GTK_STOCK_DELETE);
770
gtk_box_pack_start (GTK_BOX(hbox), b, FALSE, FALSE, 0);
771
g_signal_connect (GTK_OBJECT(b), "clicked",
772
G_CALLBACK(delete_cb), NULL);
773
774
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(manage_dlg)->vbox), hbox,
775
FALSE, FALSE, 2);
776
644
777
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(manage_dlg)->vbox), scrolled_window,
645
778
TRUE, TRUE, 2);
646
779
647
/* add edit button bar */
648
hbox = gtk_hbox_new (2, 2);
649
650
button = gtk_button_new_with_label ("New Category...");
651
g_signal_connect (button, "clicked", G_CALLBACK(new_category_cb), tree);
652
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2);
653
654
button = gtk_button_new_with_label ("Edit...");
655
g_signal_connect (button, "clicked", G_CALLBACK(edit_cb), tree);
656
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2);
657
658
button = gtk_button_new_with_label ("Delete");
659
g_signal_connect (button, "clicked", G_CALLBACK(delete_cb), tree);
660
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2);
661
662
gtk_box_pack_end (GTK_BOX(GTK_DIALOG(manage_dlg)->vbox), hbox,
663
FALSE, FALSE, 2);
664
665
780
is_visible = FALSE;
666
781
667
782
/*
668
783
* create (for now invisible) category name entry dialog
669
784
*/
670
785
671
cat_dlg = gtk_dialog_new ();
672
gtk_window_set_title (GTK_WINDOW (cat_dlg), "Enter category name...");
673
g_signal_connect( GTK_OBJECT (cat_dlg), "delete_event",
674
G_CALLBACK (cat_delete_cb), NULL );
675
676
b = gtk_dialog_add_button (GTK_DIALOG (cat_dlg), GTK_STOCK_CLOSE, 1);
677
g_signal_connect (GTK_OBJECT(b), "clicked",
678
G_CALLBACK (cat_close_cb),
679
cat_dlg);
786
cat_dlg = gtk_dialog_new_with_buttons (_("Enter category name..."), NULL, 0,
787
GTK_STOCK_CANCEL, GTK_RESPONSE_DELETE_EVENT,
788
GTK_STOCK_OK, GTK_RESPONSE_OK,
789
NULL);
790
hide_on_delete (cat_dlg, NULL);
791
g_signal_connect (GTK_OBJECT (cat_dlg), "response",
792
G_CALLBACK (cat_response_cb), NULL);
793
gtk_dialog_set_default_response (GTK_DIALOG(cat_dlg), GTK_RESPONSE_OK);
680
794
681
795
/* all we have is a simple text entry */
682
796
683
797
hbox = gtk_hbox_new (2, 2);
684
798
685
label = gtk_label_new ("Category name:");
799
label = gtk_label_new (_("Category name:"));
686
800
687
801
gtk_box_pack_start (GTK_BOX (hbox), label,
688
802
FALSE, FALSE, 0);
689
690
cat_entry = gtk_entry_new ();
803
804
cat_entry = gtk_entry_new ();
805
/*
691
806
gtk_signal_connect (GTK_OBJECT(cat_entry), "activate",
692
807
GTK_SIGNAL_FUNC (cat_close_cb),
693
cat_dlg);
694
gtk_box_pack_start (GTK_BOX (hbox), cat_entry,
695
TRUE, TRUE, 0);
696
697
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cat_dlg)->vbox), hbox,
698
TRUE, TRUE, 0);
699
}
700
701
void mm_add_show () {
702
703
play_item_t *play_item;
704
GtkTreeIter iter;
705
int pos, pos_time, len;
706
707
play_item = play_item_copy (playlist_get_item (playlist_get_list_pos()));
708
709
gtk_xine_get_pos_length (GTK_XINE (gtx),
710
&pos, &pos_time, &len);
711
712
play_item->start_time = pos_time;
713
play_item_edit (play_item);
714
gtk_tree_store_append (mm_store, &iter, NULL);
715
gtk_tree_store_set (mm_store, &iter, 0, play_item->title,
716
1, play_item->mrl, 2, play_item, -1);
717
}
718
719
720
void mm_manage_show () {
721
722
if (is_visible) {
723
is_visible = FALSE;
724
gtk_widget_hide (manage_dlg);
725
} else {
726
is_visible = TRUE;
727
gtk_widget_show_all (manage_dlg);
728
gtk_widget_map (manage_dlg);
729
}
730
}
731
732
static void print_depth (FILE *f, int depth) {
733
depth += 2;
734
735
while (depth) {
736
fprintf (f, " ");
737
depth --;
738
}
739
}
740
741
static void save_items (FILE *f, int depth, GtkTreeIter *iter) {
742
743
do {
744
745
GValue v;
746
play_item_t *play_item;
747
char *id;
748
749
memset (&v, 0, sizeof (GValue));
750
gtk_tree_model_get_value (GTK_TREE_MODEL (mm_store),
751
iter, 0, &v);
752
id = g_value_peek_pointer (&v);
753
754
if (id && strcmp (id, PLACEHOLDER)) {
755
756
GValue vi;
757
758
memset (&vi, 0, sizeof (GValue));
759
gtk_tree_model_get_value (GTK_TREE_MODEL (mm_store),
760
iter, 2, &vi);
761
play_item = g_value_peek_pointer (&vi);
762
763
if (play_item) {
764
765
play_item_save (play_item, f, depth);
766
767
} else {
768
769
GtkTreeIter children;
770
771
print_depth (f, depth);
772
fprintf (f, "<SUB NAME=\"%s\">\n", id);
773
774
if (gtk_tree_model_iter_children (GTK_TREE_MODEL(mm_store), &children, iter))
775
save_items (f, depth+2, &children);
776
777
print_depth (f, depth);
778
fprintf (f, "</SUB>\n");
779
780
}
781
782
g_value_unset (&vi);
783
}
784
785
g_value_unset (&v);
786
787
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL(mm_store), iter));
788
}
789
790
void mm_save (void) {
791
792
FILE *f;
793
gchar *fname;
794
795
fname = g_strconcat(g_get_home_dir(), "/.gxine/mediamarks", NULL);
796
797
f = fopen (fname, "w") ;
798
799
if (f) {
800
801
GtkTreeIter iter;
802
803
fprintf (f, "<GXINEMM VERSION=\"1\">\n");
804
805
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (mm_store), &iter))
806
save_items (f, 0, &iter);
807
808
fprintf (f, "</GXINEMM>\n");
809
810
fclose (f);
811
} else
812
printf ("mediamarks: save to '%s' failed!\n", fname);
813
814
g_free(fname);
815
}
808
cat_dlg);
809
*/
810
gtk_box_pack_start_defaults (GTK_BOX (hbox), cat_entry);
811
812
gtk_box_pack_start_defaults (GTK_BOX (GTK_DIALOG (cat_dlg)->vbox), hbox);
813
814
/* script engine functions */
815
816
{
817
static const se_f_def_t defs[] = {
818
{ "mm_add_show", js_mm_add_show, 0, 0,
819
SE_GROUP_DIALOGUE, NULL, NULL },
820
{ "mm_manage_show", js_mm_manage_show, 0, 0,
821
SE_GROUP_DIALOGUE, NULL, NULL },
822
{ "import_mediamarks", js_import_mediamarks, 0, 0,
823
SE_GROUP_FILE, NULL, NULL },
824
{ NULL }
825
};
826
se_defuns (gse, NULL, defs);
827
}
828
}
829
Loggerhead is a web-based interface for Breezy
Version: 2.0.1