← Back to branch summary

~ubuntu-branches/ubuntu/vivid/liferea/vivid-proposed

« back to all changes in this revision

Viewing changes to src/itemset.c

  • Committer: Package Import Robot
  • Author(s): bojo42
  • Date: 2012-03-29 14:17:21 UTC
  • mfrom: (1.3.9) (3.2.5 sid)
  • Revision ID: package-import@ubuntu.com-20120329141721-tbfopcrc5797wxt7
Tags: 1.8.3-0.1ubuntu1
https://launchpad.net/bugs/290666
https://launchpad.net/bugs/371754
https://launchpad.net/bugs/741543
https://launchpad.net/bugs/716688
https://launchpad.net/bugs/935147
* New upstream release (LP: #290666, #371754, #741543, #716688)
* Merge from Debian unstable (LP: #935147), remaining changes:
* debian/patches:
  - drop gtk-status-icon.patch & notification-append as in upstream
  - drop fix_systray_behavior as mostly upstreamed and rest seems unused
  - 01_ubuntu_feedlists: update & rename, move planets to "Open Source"  
  - add_X-Ubuntu-Gettext-Domain: rebase
  - libunity.patch: rebase, apply before indicator patch (liferea_shell.c)
  - libindicate_increase_version.patch: exclude from libindicate.patch
  - deactivate libindicate.patch, seems partly upstreamed and needs rework
* debian/control: libindicate-dev, libindicate-gtk-dev & libunity-dev
* debian/liferea.indicate & liferea.install: ship indicator desktop file
* debian/rules: enable libindicate

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/itemset.c
1
1
/**
2
2
 * @file itemset.c handling sets of items
3
3
 * 
4
 
 * Copyright (C) 2005-2008 Lars Lindner <lars.lindner@gmail.com>
 
4
 * Copyright (C) 2005-2011 Lars Lindner <lars.lindner@gmail.com>
5
5
 * Copyright (C) 2005-2006 Nathan J. Conrad <t98502@users.sourceforge.net>
6
6
 *
7
7
 * This program is free software; you can redistribute it and/or modify
21
21
 
22
22
#include <string.h>
23
23
 
24
 
#include "conf.h"
25
24
#include "common.h"
26
25
#include "db.h"
27
26
#include "debug.h"
31
30
#include "itemset.h"
32
31
#include "metadata.h"
33
32
#include "node.h"
 
33
#include "rule.h"
 
34
#include "vfolder.h"
 
35
#include "fl_sources/node_source.h"
34
36
 
35
37
void
36
38
itemset_foreach (itemSetPtr itemSet, itemActionFunc callback)
67
69
 * @param maxChecks     maximum number of item checks
68
70
 * @param allowUpdates  TRUE if item content update is to be
69
71
 *                      allowed for existing items
 
72
 * @param allowStateChanges     TRUE if item state shall be
 
73
 *                              overwritten by source
70
74
 *
71
75
 * @returns TRUE if merging instead of updating is necessary) 
72
76
 */
73
77
static gboolean
74
 
itemset_generic_merge_check (GList *items, itemPtr newItem, gint maxChecks, gboolean allowUpdates)
 
78
itemset_generic_merge_check (GList *items, itemPtr newItem, gint maxChecks, gboolean allowUpdates, gboolean allowStateChanges)
75
79
{
76
80
        GList           *oldItemIdIter = items;
77
81
        itemPtr         oldItem = NULL;
78
82
        gboolean        found, equal = FALSE;
79
83
 
80
84
        /* determine if we should add it... */
81
 
        debug1 (DEBUG_CACHE, "check new item for merging: \"%s\"", item_get_title (newItem));
 
85
        debug3 (DEBUG_CACHE, "check new item for merging: \"%s\", %i, %i", item_get_title (newItem), allowUpdates, allowStateChanges);
82
86
                
83
87
        /* compare to every existing item in this feed */
84
88
        found = FALSE;
111
115
                if (item_get_id (oldItem)) {                    
112
116
                        if (0 == strcmp (item_get_id (oldItem), item_get_id (newItem))) {
113
117
                                found = TRUE;
 
118
 
 
119
                                /* found corresponding item, check if they are REALLY equal (eg, read status may have changed) */
 
120
                                if(oldItem->readStatus != newItem->readStatus) 
 
121
                                        equal = FALSE;
 
122
                                if(oldItem->flagStatus != newItem->flagStatus)
 
123
                                        equal = FALSE;
114
124
                                break;
115
125
                        } else {
116
126
                                /* different ids, but the content might be still equal (e.g. empty)
153
163
                                metadata_list_free (oldItem->metadata);
154
164
                                oldItem->metadata = newItem->metadata;
155
165
                                newItem->metadata = NULL;
 
166
 
 
167
                                /* Only update item state for feed sources where it is necessary
 
168
                                   which means online accounts we sync against, but not normal
 
169
                                   online feeds where items have no read status. */
 
170
                                if (allowStateChanges) {
 
171
                                        oldItem->readStatus = newItem->readStatus;
 
172
                                        oldItem->flagStatus = newItem->flagStatus;
 
173
                                }
 
174
                                
156
175
                                db_item_update (oldItem);
157
176
                                debug0 (DEBUG_CACHE, "-> item already existing and was updated");
158
177
                        } else {
169
188
static gboolean
170
189
itemset_merge_item (itemSetPtr itemSet, GList *items, itemPtr item, gint maxChecks, gboolean allowUpdates)
171
190
{
 
191
        gboolean        allowStateChanges = FALSE;
172
192
        gboolean        merge;
173
193
        nodePtr         node;
174
194
 
175
195
        debug2 (DEBUG_UPDATE, "trying to merge \"%s\" to node id \"%s\"", item_get_title (item), itemSet->nodeId);
 
196
 
 
197
        g_assert (itemSet->nodeId);
 
198
        node = node_from_id (itemSet->nodeId);
 
199
        if (node)
 
200
                allowStateChanges = NODE_SOURCE_TYPE (node)->capabilities & NODE_SOURCE_CAPABILITY_ITEM_STATE_SYNC;
176
201
        
177
202
        /* first try to merge with existing item */
178
 
        merge = itemset_generic_merge_check (items, item, maxChecks, allowUpdates);
 
203
        merge = itemset_generic_merge_check (items, item, maxChecks, allowUpdates, allowStateChanges);
179
204
 
180
205
        /* if it is a new item add it to the item set */        
181
206
        if (merge) {
182
 
                g_assert (itemSet->nodeId);
183
207
                g_assert (!item->nodeId);
184
208
                g_assert (!item->id);
185
209
                item->nodeId = g_strdup (itemSet->nodeId);
213
237
                }
214
238
 
215
239
                /* step 4: Check item for new enclosures to download */
216
 
                node = node_from_id (itemSet->nodeId);
217
240
                if (node && (((feedPtr)node->data)->encAutoDownload)) {
218
241
                        GSList *iter = metadata_list_get_values (item->metadata, "enclosure");
219
242
                        while (iter) {
352
375
                        item->readStatus = TRUE;
353
376
                        
354
377
                if (itemset_merge_item (itemSet, items, item, length, allowUpdates)) {
 
378
                        vfolder_foreach_data (vfolder_merge_item, item);
355
379
                        newCount++;
356
380
                        items = g_list_prepend (items, iter->data);
357
381
                }
358
382
                iter = g_list_previous (iter);
359
383
        }
360
384
        g_list_free (list);
 
385
 
 
386
        vfolder_foreach (node_update_counters);
361
387
        
362
388
        debug1(DEBUG_UPDATE, "added %d new items", newCount);
363
389
        
410
436
        return newCount;
411
437
}
412
438
 
 
439
gboolean
 
440
itemset_check_item (itemSetPtr itemSet, itemPtr item)
 
441
{
 
442
        gboolean        result = TRUE;
 
443
        GSList          *iter = itemSet->rules;
 
444
 
 
445
        while (iter) {
 
446
                rulePtr         rule = (rulePtr) iter->data;
 
447
                ruleCheckFunc   func = rule->ruleInfo->checkFunc;
 
448
                gboolean        ruleResult = FALSE;
 
449
                
 
450
                ruleResult = (*func) (rule, item);
 
451
                result &= (rule->additive)?ruleResult:!ruleResult;
 
452
                if (itemSet->anyMatch && result)
 
453
                        return TRUE;
 
454
 
 
455
                iter = g_slist_next (iter);
 
456
        }
 
457
 
 
458
        return result;
 
459
}
 
460
 
 
461
gboolean
 
462
itemset_has_item_id (itemSetPtr itemSet, gulong id)
 
463
{
 
464
        return (NULL != g_list_find (itemSet->ids, GUINT_TO_POINTER (id)));
 
465
}
 
466
 
 
467
void
 
468
itemset_add_rule (itemSetPtr itemSet,
 
469
                  const gchar *ruleId,
 
470
                  const gchar *value,
 
471
                  gboolean additive)
 
472
{
 
473
        rulePtr         rule;
 
474
        
 
475
        rule = rule_new (ruleId, value, additive);
 
476
        if (rule)
 
477
                itemSet->rules = g_slist_append (itemSet->rules, rule);
 
478
        else
 
479
                g_warning ("unknown search folder rule id: \"%s\"", ruleId);
 
480
}
 
481
 
413
482
void
414
483
itemset_free (itemSetPtr itemSet)
415
484
{
 
485
        GSList          *rule;
 
486
 
 
487
        if (!itemSet)
 
488
                return;
 
489
        
 
490
        rule = itemSet->rules;
 
491
        while (rule) {
 
492
                rule_free (rule->data);
 
493
                rule = g_slist_next (rule);
 
494
        }
 
495
        g_slist_free (itemSet->rules);
416
496
        g_list_free (itemSet->ids);
417
497
        g_free (itemSet);
418
498
}