← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rawstudio/trusty-proposed

« back to all changes in this revision

Viewing changes to src/rs-store.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2008-10-18 17:58:00 UTC
  • mfrom: (2.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20081018175800-r1s7ke1xwy9wxv5b
Tags: 1.1.1-1
Merging upstream version 1.1.1.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/rs-store.c
22
22
#include <config.h>
23
23
#include <libxml/encoding.h>
24
24
#include <libxml/xmlwriter.h>
 
25
#include <glib.h>
25
26
#include "rawstudio.h"
26
27
#include "conf_interface.h"
27
28
#include "gettext.h"
82
83
 
83
84
enum {
84
85
        THUMB_ACTIVATED_SIGNAL,
 
86
        GROUP_ACTIVATED_SIGNAL,
85
87
        LAST_SIGNAL
86
88
};
87
89
 
111
113
static void cancel_clicked(GtkButton *button, gpointer user_data);
112
114
GList *find_loadable(const gchar *path, gboolean load_8bit, gboolean load_recursive);
113
115
void load_loadable(RSStore *store, GList *loadable, RS_PROGRESS *rsp);
 
116
void cairo_draw_thumbnail(cairo_t *cr, GdkPixbuf *pixbuf, gint x, gint y, gint width, gint height, gdouble alphas);
 
117
GdkPixbuf * store_group_update_pixbufs(GdkPixbuf *pixbuf, GdkPixbuf *pixbuf_clean);
114
118
void store_group_select_n(GtkListStore *store, GtkTreeIter iter, guint n);
115
119
gboolean store_iter_is_group(GtkListStore *store, GtkTreeIter *iter);
116
120
void store_save_groups(GtkListStore *store);
117
121
void store_load_groups(GtkListStore *store);
118
122
void store_group_photos_by_iters(GtkListStore *store, GList *members);
119
123
void store_group_photos_by_filenames(GtkListStore *store, GList *members);
 
124
static GList *store_iter_list_to_filename_list(GtkListStore *store, GList *iters);
 
125
void store_group_select_name(GtkListStore *store, const gchar *filename);
 
126
void store_group_find_name(GtkListStore *store, const gchar *name, GtkTreeIter *iter, gint *n);
 
127
void store_get_members(GtkListStore *store, GtkTreeIter *iter, GList **members);
 
128
void store_get_type(GtkListStore *store, GtkTreeIter *iter, gint *type);
 
129
void store_get_fullname(GtkListStore *store, GtkTreeIter *iter, gchar **fullname);
 
130
void store_set_members(GtkListStore *store, GtkTreeIter *iter, GList *members);
120
131
 
121
132
/**
122
133
 * Class initializer
139
150
                G_TYPE_NONE,
140
151
                1,
141
152
                G_TYPE_STRING);
 
153
        signals[GROUP_ACTIVATED_SIGNAL] = g_signal_new ("group-activated",
 
154
                G_TYPE_FROM_CLASS (klass),
 
155
                G_SIGNAL_RUN_FIRST,
 
156
                0,
 
157
                NULL, 
 
158
                NULL,                
 
159
                g_cclosure_marshal_VOID__POINTER,
 
160
                G_TYPE_NONE,
 
161
                1,
 
162
                G_TYPE_POINTER);
142
163
        if (!icon_priority_1)
143
164
        {
144
165
                icon_priority_1 = gdk_pixbuf_new_from_file(PACKAGE_DATA_DIR "/pixmaps/" PACKAGE "/overlay_priority1.png", NULL);
193
214
                g_object_set (cell_renderer,
194
215
                        "follow-state", TRUE,
195
216
                        "height", 130,  
196
 
                        "width", 130, 
 
217
                        "width", -1, 
197
218
                        "yalign", 0.5,
198
219
                        "xalign", 0.5,
199
220
                        NULL);
255
276
        }
256
277
 
257
278
        /* Load show filenames state from config */
258
 
        rs_conf_get_boolean_with_default(CONF_SHOW_FILENAMES, &show_filenames, FALSE);
 
279
        rs_conf_get_boolean_with_default(CONF_SHOW_FILENAMES, &show_filenames, DEFAULT_CONF_SHOW_FILENAMES);
259
280
        rs_store_set_show_filenames(store, show_filenames);
260
281
 
261
282
        /* Default to page 0 */
370
391
static void
371
392
selection_changed(GtkIconView *iconview, gpointer data)
372
393
{
 
394
        RSStore *store = RS_STORE(data);
 
395
        GtkTreeModel *model = GTK_TREE_MODEL(store->store);
 
396
        GtkTreeIter iter;
 
397
        gint type;
 
398
        gchar *name;
 
399
        GList *group_member_list;
 
400
        GList *filename_list;
373
401
        GList *selected = NULL;
374
402
        gint num_selected;
375
403
 
376
404
        /* Get list of selected icons */
377
 
        gtk_icon_view_selected_foreach(iconview, icon_get_selected_names, &selected);
378
 
 
 
405
        selected = rs_store_get_selected_iters(store);
379
406
        num_selected = g_list_length(selected);
380
407
 
381
408
        /* Emit signal if only one thumbnail is selected */
382
409
        if (num_selected == 1)
383
 
                g_signal_emit (G_OBJECT (data), signals[THUMB_ACTIVATED_SIGNAL], 0, g_list_nth_data(selected, 0));
 
410
        {
 
411
                iter = * (GtkTreeIter *) g_list_nth_data(selected, 0);
 
412
                /* Get type of row */
 
413
                gtk_tree_model_get(model, &iter, TYPE_COLUMN, &type, -1);
 
414
                switch (type)
 
415
                {
 
416
                        case RS_STORE_TYPE_GROUP:
 
417
                                gtk_tree_model_get(model, &iter, GROUP_LIST_COLUMN, &group_member_list, -1);
 
418
                                filename_list = store_iter_list_to_filename_list(store->store, group_member_list);
 
419
                                g_signal_emit(G_OBJECT(data), signals[GROUP_ACTIVATED_SIGNAL], 0, filename_list);
 
420
                                g_list_free(filename_list);
 
421
                                break;
 
422
                        default:
 
423
                                gtk_tree_model_get(GTK_TREE_MODEL(store->store), &iter, FULLNAME_COLUMN, &name, -1);
 
424
                                g_signal_emit(G_OBJECT(data), signals[THUMB_ACTIVATED_SIGNAL], 0, name);
 
425
                                break;
 
426
                }
 
427
        }
384
428
 
 
429
        g_list_foreach(selected, (GFunc)g_free, NULL);
385
430
        g_list_free(selected);
386
431
 
387
432
        predict_preload(data, FALSE);
843
888
                {
844
889
                        if (filetype->load)
845
890
                        {
846
 
                                pixbuf = NULL;
847
 
                                if (filetype->thumb)
848
 
                                        pixbuf = filetype->thumb(fullname);
 
891
                                pixbuf = rs_load_thumb(filetype, fullname);
849
892
                                if (pixbuf==NULL)
850
893
                                {
851
 
                                        pixbuf = missing_thumb;
 
894
                                        pixbuf = gdk_pixbuf_copy(missing_thumb);
852
895
                                        g_object_ref (pixbuf);
853
896
                                }
854
897
 
1403
1446
        return gtk_notebook_get_current_page(store->notebook);
1404
1447
}
1405
1448
 
 
1449
void
 
1450
cairo_draw_thumbnail(cairo_t *cr, GdkPixbuf *pixbuf, gint x, gint y, gint width, gint height, gdouble alpha)
 
1451
{
 
1452
        gdouble greyvalue = 1.0;
 
1453
 
 
1454
        cairo_set_source_rgba(cr, greyvalue, greyvalue, greyvalue, 0.5);
 
1455
        cairo_rectangle(cr, x, y, width, height);
 
1456
        cairo_fill(cr);
 
1457
 
 
1458
        gint pixbuf_height = gdk_pixbuf_get_height(pixbuf);
 
1459
        gint pixbuf_width = gdk_pixbuf_get_width(pixbuf);
 
1460
 
 
1461
        GdkPixbuf *pixbuf_scaled = gdk_pixbuf_scale_simple(pixbuf, (pixbuf_width-4), (pixbuf_height-4), GDK_INTERP_HYPER);
 
1462
        gdk_cairo_set_source_pixbuf(cr, pixbuf_scaled, (x+2), (y+2));
 
1463
        g_object_unref(pixbuf_scaled);
 
1464
        cairo_paint(cr);
 
1465
 
 
1466
        cairo_set_source_rgba(cr, 0.5, 0.5, 0.5, alpha);
 
1467
        cairo_rectangle(cr, x+1, y+1, width-2, height-2);
 
1468
        cairo_fill(cr);
 
1469
 
 
1470
        return;
 
1471
}
 
1472
 
 
1473
void
 
1474
calc_rotated_coordinats(gdouble a, gdouble b, gdouble R, gdouble *a2, gdouble *b2)
 
1475
{
 
1476
        gdouble c, A;
 
1477
 
 
1478
        c = sqrt(a*a+b*b);
 
1479
        A = atan(a/b)+R;
 
1480
        *a2 = sin(A)*c;
 
1481
        *b2 = cos(A)*c;
 
1482
}
 
1483
 
1406
1484
GdkPixbuf *
1407
1485
store_group_update_pixbufs(GdkPixbuf *pixbuf, GdkPixbuf *pixbuf_clean)
1408
1486
{
1409
 
        gint width, height, new_width, new_height;
1410
 
        guint rowstride;
1411
 
        guchar *pixels;
1412
 
        gint channels;
1413
 
        GdkPixbuf *new_pixbuf, *pixbuf_scaled;
 
1487
        gint width, height;
 
1488
        GdkPixbuf *new_pixbuf;
1414
1489
 
1415
1490
        width = gdk_pixbuf_get_width(pixbuf_clean);
1416
1491
        height = gdk_pixbuf_get_height(pixbuf_clean);
1417
 
        
 
1492
 
1418
1493
        new_pixbuf = gdk_pixbuf_new(gdk_pixbuf_get_colorspace(pixbuf_clean),
1419
1494
                                                                TRUE,
1420
1495
                                                                gdk_pixbuf_get_bits_per_sample(pixbuf_clean),
1421
1496
                                                                width,
1422
1497
                                                                height);
1423
1498
 
 
1499
#if GTK_CHECK_VERSION(2,8,0) && defined(EXPERIMENTAL)   
 
1500
 
 
1501
        gdouble a2, b2, scale, bb_x1, bb_x2, bb_y1, bb_y2, bb_height, bb_width, xoffset, yoffset, border = 1;
 
1502
 
 
1503
        /* We have a bit more room with landscape-mode photos than with portrait-mode*/
 
1504
        if (height > width)
 
1505
                scale = 0.9;
 
1506
        else
 
1507
                scale = 1.0;
 
1508
 
 
1509
        /* upper left of left rotation - we need a2 */
 
1510
        calc_rotated_coordinats((0-(width/2)), 128, -0.1, &a2, &b2);
 
1511
        bb_x1 = a2;
 
1512
 
 
1513
        /* upper left of right rotation - we need b2 */
 
1514
        calc_rotated_coordinats((0-(width/2)), 128, 0.2, &a2, &b2);
 
1515
        bb_y1 = b2;
 
1516
 
 
1517
        /* upper right of right rotation - we need b2 */
 
1518
        calc_rotated_coordinats((width/2), 128, 0.2, &a2, &b2);
 
1519
        bb_x2 = a2;
 
1520
 
 
1521
        /* lower right of right rotation - we need b2 */
 
1522
        calc_rotated_coordinats((width/2),(128-height), 0.2, &a2, &b2);
 
1523
        bb_y2 = b2;
 
1524
 
 
1525
        /* Calculate the magic numbers - it will work from scale 0.7 and up */
 
1526
        bb_height = ((bb_y1-bb_y2)+border*2)*scale;
 
1527
        bb_width = ((bb_x1*-1+bb_x2+10)+border*2)*scale;
 
1528
        xoffset = (bb_x2+bb_x1)/2/scale*-1;
 
1529
        yoffset = (128-(bb_y1-(128)))/scale*-1;
 
1530
 
 
1531
        cairo_surface_t *surface;
 
1532
        cairo_t *cr;
 
1533
 
 
1534
        surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, bb_width, bb_height);
 
1535
 
 
1536
        cr = cairo_create(surface);
 
1537
 
 
1538
        cairo_translate(cr, (bb_width/2), 128);
 
1539
        cairo_scale(cr, scale, scale);
 
1540
 
 
1541
        cairo_rotate(cr, -0.1);
 
1542
        cairo_draw_thumbnail(cr, pixbuf_clean, (width/-2)+xoffset, yoffset, width, height, 0.7);
 
1543
        cairo_rotate(cr, 0.2);
 
1544
        cairo_draw_thumbnail(cr, pixbuf_clean, (width/-2)+xoffset, yoffset, width, height, 0.7);
 
1545
        cairo_rotate(cr, 0.1);
 
1546
        cairo_draw_thumbnail(cr, pixbuf_clean, (width/-2)+xoffset, yoffset, width, height, 0.7);
 
1547
        cairo_rotate(cr, -0.2);
 
1548
        cairo_draw_thumbnail(cr, pixbuf_clean, (width/-2)+xoffset, yoffset, width, height, 0.0);
 
1549
 
 
1550
        cairo_destroy(cr);
 
1551
        new_pixbuf = cairo_convert_to_pixbuf(surface);
 
1552
#else
 
1553
 
 
1554
        guint rowstride;
 
1555
        guchar *pixels;
 
1556
        gint channels;
 
1557
        gint new_width, new_height;
 
1558
        GdkPixbuf *pixbuf_scaled;
 
1559
 
1424
1560
        width -= 6;
1425
1561
        height -= 6;
1426
1562
        
1457
1593
        gdk_pixbuf_copy_area(pixbuf_scaled,
1458
1594
                                                 0, 0, width, height,
1459
1595
                                                 new_pixbuf, 1, 1);
 
1596
 
 
1597
#endif
 
1598
 
1460
1599
        return new_pixbuf;
1461
1600
}
1462
1601
 
1472
1611
        guint priority;
1473
1612
        gboolean exported;
1474
1613
 
1475
 
        gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
1476
 
                                           GROUP_LIST_COLUMN, &members,
1477
 
                                           -1);
 
1614
        store_get_members(store, &iter, &members);
 
1615
 
1478
1616
        child_iter = (GtkTreeIter *) g_list_nth_data(members, n);
1479
1617
 
1480
1618
        gtk_tree_model_get(GTK_TREE_MODEL(store), child_iter,
1532
1670
                        s = selected->data;
1533
1671
                        if (store_iter_is_group(store->store, s))
1534
1672
                        {
1535
 
                                gtk_tree_model_get(GTK_TREE_MODEL(store->store), s,
1536
 
                                                                   GROUP_LIST_COLUMN, &members,
1537
 
                                                                   -1);
1538
 
 
 
1673
                                store_get_members(store->store, s, &members);
1539
1674
                                newmembers = g_list_concat(newmembers, members);
1540
1675
 
1541
1676
                                if (group)
1584
1719
                if (store_iter_is_group(store->store, g_list_nth_data(selected, n)))
1585
1720
                {
1586
1721
                        iter = (GtkTreeIter *) g_list_nth_data(selected, n);
1587
 
                        gtk_tree_model_get(GTK_TREE_MODEL(store->store), iter,
1588
 
                                                           GROUP_LIST_COLUMN, &members,
1589
 
                                                           -1);
 
1722
                        store_get_members(store->store, iter, &members);
 
1723
 
1590
1724
                        for( m = 0; m < g_list_length(members); m++)
1591
1725
                        {
1592
1726
                                child_iter = (GtkTreeIter *) g_list_nth_data(members, m);
1603
1737
gboolean
1604
1738
store_iter_is_group(GtkListStore *store, GtkTreeIter *iter)
1605
1739
{
1606
 
        guint t;
 
1740
        gint t;
1607
1741
 
1608
 
        gtk_tree_model_get (GTK_TREE_MODEL(store), iter, TYPE_COLUMN, &t, -1);
 
1742
        store_get_type(store, iter, &t);
1609
1743
        if (t == RS_STORE_TYPE_GROUP)
1610
1744
                return TRUE;
1611
1745
        else
1632
1766
        xmlTextWriterPtr writer;
1633
1767
 
1634
1768
        gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
1635
 
        gtk_tree_model_get (GTK_TREE_MODEL(store), &iter, FULLNAME_COLUMN, &filename, -1);
 
1769
        store_get_fullname(store, &iter, &filename);
1636
1770
 
1637
1771
        dotdir = rs_dotdir_get(filename);
1638
1772
        GString *gs = g_string_new(dotdir);
1653
1787
                {
1654
1788
                        if (store_iter_is_group(store, &iter))
1655
1789
                        {
1656
 
                                gchar *selected;
1657
 
                                GList *members;
 
1790
                                gchar *selected = NULL;
 
1791
                                GList *members, *filenames;
1658
1792
 
1659
1793
                                xmlTextWriterStartElement(writer, BAD_CAST "group");
1660
1794
 
1661
1795
                                // Find selected member and place this first in XML
1662
 
                                gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
1663
 
                                           FULLNAME_COLUMN, &selected,
1664
 
                                           -1);
 
1796
                                store_get_fullname(store, &iter, &selected);
 
1797
 
1665
1798
                                xmlTextWriterWriteFormatElement(writer, BAD_CAST "member", "%s", selected);
1666
1799
 
1667
 
                                gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
1668
 
                                           GROUP_LIST_COLUMN, &members,
1669
 
                                           -1);
 
1800
                                store_get_members(store, &iter, &members);
 
1801
 
1670
1802
                                gint m;
1671
 
                                for( m = 0; m < g_list_length(members); m++)
 
1803
                                filenames = store_iter_list_to_filename_list(store, members);
 
1804
 
 
1805
                                for( m = 0; m < g_list_length(filenames); m++)
1672
1806
                                {
1673
 
                                        GtkTreeIter *child_iter = (GtkTreeIter *) g_list_nth_data(members, m);
1674
 
                                        gtk_tree_model_get (GTK_TREE_MODEL(store), child_iter, FULLNAME_COLUMN, &filename, -1);
 
1807
                                        filename = g_list_nth_data(filenames, m);
1675
1808
                                        if (!g_str_equal(selected, filename))
1676
1809
                                                xmlTextWriterWriteFormatElement(writer, BAD_CAST "member", "%s", filename);
1677
1810
                                }
1697
1830
        g_assert(store != NULL);
1698
1831
 
1699
1832
        gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
1700
 
        gtk_tree_model_get (GTK_TREE_MODEL(store), &iter, FULLNAME_COLUMN, &filename, -1);
 
1833
 
 
1834
        /* Don't try opening groups when there is no loaded photos in the store. */
 
1835
          if(!gtk_list_store_iter_is_valid(store, &iter))
 
1836
                return;
 
1837
 
 
1838
        store_get_fullname(store, &iter, &filename);
1701
1839
        dotdir = rs_dotdir_get(filename);
1702
1840
 
1703
1841
        GString *gs = g_string_new(dotdir);
1795
1933
{
1796
1934
        return g_list_sort(selected, (GCompareFunc) g_utf8_collate);
1797
1935
}
 
1936
 
 
1937
void
 
1938
rs_store_auto_group(RSStore *store)
 
1939
{
 
1940
        RS_FILETYPE *filetype = NULL;
 
1941
        gchar *filename = NULL;
 
1942
        gint timestamp = 0, timestamp_old = 0;
 
1943
        gint exposure;
 
1944
        RS_METADATA *meta;
 
1945
        GList *filenames = NULL;
 
1946
        GtkTreeIter iter;
 
1947
 
 
1948
        // TODO: remove all existing groups in iconview.
 
1949
        
 
1950
        gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store->store), &iter);
 
1951
        do
 
1952
        {
 
1953
                store_get_fullname(GTK_LIST_STORE(store->store), &iter, &filename);
 
1954
                filetype = rs_filetype_get(filename, TRUE);
 
1955
                if (filetype)
 
1956
                {
 
1957
                        if(filetype->load_meta)
 
1958
                        {
 
1959
                                meta = rs_metadata_new();
 
1960
                                filetype->load_meta(filename, meta);
 
1961
                                
 
1962
                                if (!meta->timestamp)
 
1963
                                        return;
 
1964
                                
 
1965
                                timestamp = meta->timestamp;
 
1966
                                exposure = (1/meta->shutterspeed);
 
1967
 
 
1968
                                if (timestamp > timestamp_old + 1)
 
1969
                                {
 
1970
                                        if (g_list_length(filenames) > 1)
 
1971
                                                store_group_photos_by_filenames(store->store, filenames);
 
1972
                                        g_list_free(filenames);
 
1973
                                        filenames = NULL;
 
1974
                                }
 
1975
                                timestamp_old = timestamp + exposure;
 
1976
                                g_free(meta);
 
1977
                        }
 
1978
                }
 
1979
                filenames = g_list_append(filenames, filename);
 
1980
        } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store->store), &iter));
 
1981
 
 
1982
        store_group_photos_by_filenames(store->store, filenames);
 
1983
        g_list_free(filenames);
 
1984
        filenames = NULL;
 
1985
}
 
1986
 
 
1987
static GList *
 
1988
store_iter_list_to_filename_list(GtkListStore *store, GList *iters)
 
1989
{
 
1990
        gint n;
 
1991
        gchar *filename = NULL;
 
1992
        GList *filenames = NULL;
 
1993
 
 
1994
        for (n=0; n<g_list_length(iters); n++)
 
1995
        {
 
1996
                GtkTreeIter *iter = (GtkTreeIter *) g_list_nth_data(iters, n);
 
1997
                store_get_fullname(store, iter, &filename);
 
1998
                filenames = g_list_append(filenames, filename);
 
1999
        }
 
2000
 
 
2001
        return filenames;
 
2002
}
 
2003
 
 
2004
void
 
2005
store_group_select_name(GtkListStore *store, const gchar *filename)
 
2006
{
 
2007
        GtkTreeIter iter;
 
2008
        gint n = -1;
 
2009
 
 
2010
        store_group_find_name(store, filename, &iter, &n);
 
2011
        store_group_select_n(store, iter, n);
 
2012
}
 
2013
 
 
2014
void 
 
2015
store_group_find_name(GtkListStore *store, const gchar *name, GtkTreeIter *iter, gint *n)
 
2016
{
 
2017
        gint type;
 
2018
        gint i;
 
2019
        GList *members = NULL;
 
2020
        GList *filenames = NULL;
 
2021
 
 
2022
        gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), iter);
 
2023
        do
 
2024
        {
 
2025
                store_get_type(store, iter, &type);
 
2026
 
 
2027
                if (type == RS_STORE_TYPE_GROUP)
 
2028
                {
 
2029
                        store_get_members(store, iter, &members);
 
2030
                        filenames = store_iter_list_to_filename_list(store, members);
 
2031
 
 
2032
                        for(i = 0; i < g_list_length(filenames); i++)
 
2033
                        {
 
2034
                                if (g_str_equal(g_list_nth_data(filenames, i), name))
 
2035
                                {
 
2036
                                        *n = i;
 
2037
                                        return;
 
2038
                                }
 
2039
                        }
 
2040
                        g_list_free(filenames);
 
2041
                }
 
2042
        } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), iter));
 
2043
 
 
2044
        *n = -1;
 
2045
        return;
 
2046
}
 
2047
 
 
2048
void
 
2049
rs_store_group_select_name(RSStore *store, const gchar *filename)
 
2050
{
 
2051
        store_group_select_name(store->store, filename);
 
2052
}
 
2053
 
 
2054
void 
 
2055
store_group_ungroup_name(GtkListStore *store, const gchar *name)
 
2056
{
 
2057
        GtkTreeIter iter, *child_iter;
 
2058
        gint n = -1;
 
2059
        GList *members;
 
2060
 
 
2061
        store_group_find_name(store, name, &iter, &n);
 
2062
        
 
2063
        gtk_tree_model_get (GTK_TREE_MODEL(store), &iter, 
 
2064
                                                GROUP_LIST_COLUMN, &members,
 
2065
                                                -1);
 
2066
        
 
2067
        child_iter = (GtkTreeIter *) g_list_nth_data(members, n);
 
2068
        gtk_list_store_set(store, child_iter,
 
2069
                                                TYPE_COLUMN, RS_STORE_TYPE_FILE,
 
2070
                                           -1);
 
2071
 
 
2072
        members = g_list_remove(members, g_list_nth_data(members,n));
 
2073
 
 
2074
        /* If group now only has one member, we destroy the group */
 
2075
        if (g_list_length(members) == 1)
 
2076
        {
 
2077
                child_iter = (GtkTreeIter *) g_list_nth_data(members, 0);
 
2078
                gtk_list_store_set(store, child_iter,
 
2079
                                                        TYPE_COLUMN, RS_STORE_TYPE_FILE,
 
2080
                                                   -1);
 
2081
                gtk_list_store_remove (store, &iter);
 
2082
        }
 
2083
        store_set_members(store, &iter, members);
 
2084
        store_save_groups(store);
 
2085
}
 
2086
 
 
2087
void
 
2088
rs_store_group_ungroup_name(RSStore *store, const gchar *filename)
 
2089
{
 
2090
        store_group_ungroup_name(store->store, filename);
 
2091
}
 
2092
 
 
2093
void
 
2094
store_get_members(GtkListStore *store, GtkTreeIter *iter, GList **members)
 
2095
{
 
2096
        gtk_tree_model_get (GTK_TREE_MODEL(store), iter,
 
2097
                                                GROUP_LIST_COLUMN, members,
 
2098
                                                -1);
 
2099
}
 
2100
 
 
2101
void
 
2102
store_get_type(GtkListStore *store, GtkTreeIter *iter, gint *type)
 
2103
{
 
2104
        gtk_tree_model_get (GTK_TREE_MODEL(store), iter,
 
2105
                                                TYPE_COLUMN, type,
 
2106
                                                -1);
 
2107
}
 
2108
 
 
2109
void
 
2110
store_get_fullname(GtkListStore *store, GtkTreeIter *iter, gchar **fullname)
 
2111
{
 
2112
        gtk_tree_model_get (GTK_TREE_MODEL(store), iter, 
 
2113
                                                FULLNAME_COLUMN, fullname,
 
2114
                                                -1);
 
2115
}
 
2116
 
 
2117
void
 
2118
store_set_members(GtkListStore *store, GtkTreeIter *iter, GList *members)
 
2119
{
 
2120
        gtk_list_store_set (store, iter, 
 
2121
                                                GROUP_LIST_COLUMN, members,
 
2122
                                                -1);
 
2123
}