feedlist.js

   1 var _feed_cur_page = 0;
   2 var _infscroll_disable = 0;
   3 var _infscroll_request_sent = 0;
   4 var feed_under_pointer = undefined;
   5
   6 var counter_timeout_id = false;
   7
   8 var resize_enabled = false;
   9 var selection_disabled = false;
  10 var counters_last_request = 0;
  11
  12 var feeds_sort_by_unread = false;
  13 var feedlist_sortable_enabled = false;
  14
  15 function toggle_sortable_feedlist(enabled) {
  16 /*      try {
  17
  18                 if (enabled) {
  19                         Sortable.create('feedList', {onChange: feedlist_dragsorted, only: "feedCat"});
  20                 } else {
  21                         Sortable.destroy('feedList');
  22                 }
  23
  24         } catch (e) {
  25                 exception_error("toggle_sortable_feedlist", e);
  26         } */
  27 }
  28
  29 function viewCategory(cat) {
  30         viewfeed(cat, '', true);
  31         return false;
  32 }
  33
  34 function viewNextFeedPage() {
  35         try {
  36                 //if (!getActiveFeedId()) return;
  37
  38                 console.log("viewNextFeedPage: calling viewfeed(), p: " + parseInt(_feed_cur_page+1));
  39
  40                 viewfeed(getActiveFeedId(), '', activeFeedIsCat(), parseInt(_feed_cur_page+1));
  41
  42         } catch (e) {
  43                 exception_error("viewNextFeedPage", e);
  44         }
  45 }
  46
  47
  48 function viewfeed(feed, subop, is_cat, offset) {
  49         try {
  50                 if (is_cat == undefined) is_cat = false;
  51
  52 //              if (!offset) page_offset = 0;
  53
  54                 last_requested_article = 0;
  55                 //counters_last_request = 0;
  56
  57                 if (feed == getActiveFeedId()) {
  58                         cache_invalidate("F:" + feed);
  59                 }
  60
  61 /*              if (getInitParam("theme") == "" || getInitParam("theme") == "compact") {
  62                         if (getInitParam("hide_feedlist") == 1) {
  63                                 Element.hide("feeds-holder");
  64                         }
  65                 } */
  66
  67                 var force_nocache = false;
  68
  69                 var page_offset = 0;
  70
  71                 if (offset > 0) {
  72                         page_offset = offset;
  73                 } else {
  74                         page_offset = 0;
  75                         _feed_cur_page = 0;
  76                         _infscroll_disable = 0;
  77                 }
  78
  79                 if (getActiveFeedId() != feed) {
  80                         _feed_cur_page = 0;
  81                         active_post_id = 0;
  82                         _infscroll_disable = 0;
  83                 }
  84
  85                 if (page_offset != 0 && !subop) {
  86                         var date = new Date();
  87                         var timestamp = Math.round(date.getTime() / 1000);
  88
  89                         console.log(_infscroll_request_sent + " : " + timestamp);
  90
  91                         if (_infscroll_request_sent && _infscroll_request_sent + 30 > timestamp) {
  92                                 console.log("infscroll request in progress, aborting");
  93                                 return;
  94                         }
  95
  96                         _infscroll_request_sent = timestamp;
  97                 }
  98
  99                 enableHotkeys();
 100                 hideAuxDlg();
 101                 closeInfoBox();
 102
 103                 Form.enable("main_toolbar_form");
 104
 105                 var toolbar_form = document.forms["main_toolbar_form"];
 106                 var toolbar_query = Form.serialize("main_toolbar_form");
 107
 108                 if (toolbar_form.query) {
 109                         if (toolbar_form.query.value != "") {
 110                                 force_nocache = true;
 111                         }
 112                         toolbar_form.query.value = "";
 113                 }
 114
 115                 var query = "?op=viewfeed&feed=" + feed + "&" +
 116                         toolbar_query + "&subop=" + param_escape(subop);
 117
 118                 if ($("search_form")) {
 119                         var search_query = Form.serialize("search_form");
 120                         query = query + "&" + search_query;
 121                         $("search_form").query.value = "";
 122                         closeInfoBox(true);
 123                         force_nocache = true;
 124                 }
 125
 126 //              console.log("IS_CAT_STORED: " + activeFeedIsCat() + ", IS_CAT: " + is_cat);
 127
 128                 if (subop == "MarkAllRead") {
 129
 130                         var show_next_feed = getInitParam("on_catchup_show_next_feed") == "1";
 131
 132                         if (show_next_feed) {
 133
 134                                 if (!activeFeedIsCat()) {
 135
 136                                         var feedlist = $('feedList');
 137
 138                                         var next_unread_feed = getRelativeFeedId2(feed, false,
 139                                                         "next", true);
 140
 141                                         /* gRFI2 also returns categories which we don't really
 142                                          * need here, so we skip them */
 143
 144                                         while (next_unread_feed && next_unread_feed.match("CAT:"))
 145                                                 next_unread_feed = getRelativeFeedId2(
 146                                                                 next_unread_feed.replace("CAT:", ""),
 147                                                                 true, "next", true);
 148
 149                                         if (!next_unread_feed) {
 150                                                 next_unread_feed = getRelativeFeedId2(-3, true,
 151                                                         "next", true);
 152                                         }
 153
 154                                         if (next_unread_feed) {
 155                                                 query = query + "&nuf=" + param_escape(next_unread_feed);
 156                                                 //setActiveFeedId(next_unread_feed);
 157                                                 feed = next_unread_feed;
 158                                         }
 159                                 } else {
 160
 161                                         var next_unread_feed = getNextUnreadCat(feed);
 162
 163                                         /* we don't need to specify that our next feed is actually
 164                                         a category, because we're in the is_cat mode by definition
 165                                         already */
 166
 167                                         if (next_unread_feed && show_next_feed) {
 168                                                 query = query + "&nuf=" + param_escape(next_unread_feed);
 169                                                 feed = next_unread_feed;
 170                                         }
 171
 172                                 }
 173                         }
 174                 }
 175
 176                 if (is_cat) {
 177                         query = query + "&cat=1";
 178                 }
 179
 180                 if (page_offset != 0) {
 181                         query = query + "&skip=" + page_offset;
 182
 183                         // to prevent duplicate feed titles when showing grouped vfeeds
 184                         if (vgroup_last_feed) {
 185                                 query = query + "&vgrlf=" + param_escape(vgroup_last_feed);
 186                         }
 187                 }
 188
 189                 Form.enable("main_toolbar_form");
 190
 191                 console.log(query);
 192
 193                 var container = $("headlinesInnerContainer");
 194
 195                 var unread_ctr = -1;
 196
 197                 if (!is_cat) unread_ctr = get_feed_unread(feed);
 198
 199                 var cache_check = false;
 200
 201                 if (unread_ctr != -1 && !page_offset && !force_nocache && !subop) {
 202
 203                         var cache_prefix = "";
 204
 205                         if (is_cat) {
 206                                 cache_prefix = "C:";
 207                         } else {
 208                                 cache_prefix = "F:";
 209                         }
 210
 211                         cache_check = cache_check_param(cache_prefix + feed, unread_ctr);
 212                         console.log("headline cache check: " + cache_check);
 213                 }
 214
 215                 if (cache_check) {
 216
 217                         setActiveFeedId(feed, is_cat);
 218
 219                         $("headlines-frame").innerHTML = cache_find_param(cache_prefix + feed,
 220                                 unread_ctr);
 221
 222                         request_counters();
 223                         remove_splash();
 224
 225                 } else {
 226
 227                         if (!is_cat)
 228                                 setFeedExpandoIcon(feed, is_cat, 'images/indicator_white.gif');
 229
 230                         new Ajax.Request("backend.php", {
 231                                 parameters: query,
 232                                 onComplete: function(transport) {
 233                                         setFeedExpandoIcon(feed, is_cat, 'images/blank_icon.gif');
 234                                         headlines_callback2(transport, page_offset);
 235                                 } });
 236                 }
 237
 238         } catch (e) {
 239                 exception_error("viewfeed", e);
 240         }
 241 }
 242
 243
 244 function feedlist_dragsorted(ctr) {
 245         try {
 246                 var cats = $$("#feedList > li[id*=FCAT-]");
 247                 var ordered_cats = [];
 248
 249                 cats.each(function(cat) {
 250                         ordered_cats.push(cat.id.replace("FCAT-", ""));
 251                 });
 252
 253                 if (ordered_cats.length > 0) {
 254
 255                         var query = "?op=feeds&subop=catsort&corder=" +
 256                                 param_escape(ordered_cats.toString());
 257
 258                         //console.log(query);
 259
 260                         new Ajax.Request("backend.php", { parameters: query });
 261                 }
 262
 263         } catch (e) {
 264                 exception_error("feedlist_dragsorted", e);
 265         }
 266 }
 267
 268 function feedlist_init() {
 269         try {
 270                 loading_set_progress(90);
 271
 272                 console.log("in feedlist init");
 273
 274                 hideOrShowFeeds(getInitParam("hide_read_feeds") == 1);
 275                 document.onkeydown = hotkey_handler;
 276                 setTimeout("hotkey_prefix_timeout()", 5*1000);
 277
 278                  if (getActiveFeedId()) {
 279                         //console.log("some feed is open on feedlist refresh, reloading");
 280                         //setTimeout("viewCurrentFeed()", 100);
 281                 } else {
 282                         if (getInitParam("cdm_auto_catchup") != 1) {
 283                                 setTimeout("viewfeed(-3)", 100);
 284                         } else {
 285                                 setTimeout("viewfeed(-5)", 100);
 286                                 remove_splash();
 287                         }
 288                 }
 289
 290                 console.log("T:" +
 291                                 getInitParam("cdm_auto_catchup") + " " + get_feed_unread(-3));
 292
 293                 toggle_sortable_feedlist(isFeedlistSortable());
 294
 295         } catch (e) {
 296                 exception_error("feedlist/init", e);
 297         }
 298 }
 299
 300 function enable_selection(b) {
 301         selection_disabled = !b;
 302 }
 303
 304 function enable_resize(b) {
 305         resize_enabled = b;
 306 }
 307
 308 function request_counters_real() {
 309         try {
 310                 console.log("requesting counters...");
 311
 312                 var query = "?op=rpc&subop=getAllCounters&seq=" + next_seq();
 313
 314                 query = query + "&omode=flc";
 315
 316                 new Ajax.Request("backend.php", {
 317                         parameters: query,
 318                         onComplete: function(transport) {
 319                                 try {
 320                                         handle_rpc_reply(transport);
 321                                 } catch (e) {
 322                                         exception_error("viewfeed/getcounters", e);
 323                                 }
 324                         } });
 325
 326         } catch (e) {
 327                 exception_error("request_counters_real", e);
 328         }
 329 }
 330
 331
 332 function request_counters() {
 333
 334         try {
 335
 336                 if (getInitParam("bw_limit") == "1") return;
 337
 338                 var date = new Date();
 339                 var timestamp = Math.round(date.getTime() / 1000);
 340
 341                 if (timestamp - counters_last_request > 5) {
 342                         console.log("scheduling request of counters...");
 343
 344                         window.clearTimeout(counter_timeout_id);
 345                         counter_timeout_id = window.setTimeout("request_counters_real()", 1000);
 346
 347                         counters_last_request = timestamp;
 348                 } else {
 349                         console.log("request_counters: rate limit reached: " + (timestamp - counters_last_request));
 350                 }
 351
 352         } catch (e) {
 353                 exception_error("request_counters", e);
 354         }
 355 }
 356
 357 function displayNewContentPrompt(id) {
 358         try {
 359
 360                 var msg = "<a href='#' onclick='viewfeed("+id+")'>" +
 361                         __("New articles available in this feed (click to show)") + "</a>";
 362
 363                 msg = msg.replace("%s", getFeedName(id));
 364
 365                 $('auxDlg').innerHTML = msg;
 366
 367                 new Effect.Appear('auxDlg', {duration : 0.5});
 368
 369         } catch (e) {
 370                 exception_error("displayNewContentPrompt", e);
 371         }
 372 }
 373
 374 function parse_counters(reply, scheduled_call) {
 375         try {
 376
 377                 var feeds_found = 0;
 378
 379                 var elems = JSON.parse(reply.firstChild.nodeValue);
 380
 381                 for (var l = 0; l < elems.length; l++) {
 382
 383                         var id = elems[l].id
 384                         var kind = elems[l].kind;
 385                         var ctr = parseInt(elems[l].counter)
 386                         var error = elems[l].error;
 387                         var has_img = elems[l].has_img;
 388                         var updated = elems[l].updated;
 389                         var title = elems[l].title;
 390                         var xmsg = elems[l].xmsg;
 391
 392                         if (id == "global-unread") {
 393                                 global_unread = ctr;
 394                                 updateTitle();
 395                                 continue;
 396                         }
 397
 398                         if (id == "subscribed-feeds") {
 399                                 feeds_found = ctr;
 400                                 continue;
 401                         }
 402
 403                         var treeItem;
 404
 405                         setFeedUnread(id, (kind == "cat"), ctr);
 406
 407                         if (kind != "cat") {
 408                                 //setFeedValue(id, false, 'error', error);
 409                                 setFeedValue(id, false, 'updated', updated);
 410
 411                                 if (id > 0) {
 412                                         if (has_img) {
 413                                                 setFeedIcon(id, false,
 414                                                         getInitParam("icons_url") + "/" + id + ".ico");
 415                                         } else {
 416                                                 setFeedIcon(id, false, 'images/blank_icon.gif');
 417                                         }
 418                                 }
 419                         }
 420                 }
 421
 422                 hideOrShowFeeds(getInitParam("hide_read_feeds") == 1);
 423
 424                 var feeds_stored = number_of_feeds;
 425
 426                 if (feeds_stored != feeds_found) {
 427                         number_of_feeds = feeds_found;
 428
 429                         if (feeds_stored != 0 && feeds_found != 0) {
 430                                 console.log("Subscribed feed number changed, refreshing feedlist");
 431                                 setTimeout('updateFeedList()', 50);
 432                         }
 433                 }
 434
 435         } catch (e) {
 436                 exception_error("parse_counters", e);
 437         }
 438 }
 439
 440 function get_feed_unread(feed, is_cat) {
 441         try {
 442                 if (is_cat)
 443                         treeItem = treeModel.store._itemsByIdentity['CAT:' + feed];
 444                 else
 445                         treeItem = treeModel.store._itemsByIdentity['FEED:' + feed];
 446
 447                 if (treeItem)
 448                         return treeModel.store.getValue(treeItem, 'unread');
 449
 450         } catch (e) {
 451                 //
 452         }
 453
 454         return -1;
 455 }
 456
 457 function get_cat_unread(id) {
 458         return get_feed_unread(id, true);
 459 }
 460
 461 function get_feed_entry_unread(elem) {
 462
 463         var id = elem.id.replace("FEEDR-", "");
 464
 465         if (id <= 0) {
 466                 return -1;
 467         }
 468
 469         try {
 470                 return parseInt($("FEEDU-" + id).innerHTML);
 471         } catch (e) {
 472                 return -1;
 473         }
 474 }
 475
 476 function get_feed_entry_name(elem) {
 477         var id = elem.id.replace("FEEDR-", "");
 478         return getFeedName(id);
 479 }
 480
 481
 482 function resort_category(node, cat_mode) {
 483
 484         try {
 485
 486                 //console.log("resort_category: " + node + " CM=" + cat_mode);
 487
 488                 var by_unread = feedsSortByUnread();
 489
 490                 var list = node.getElementsByTagName("LI");
 491
 492                 for (i = 0; i < list.length; i++) {
 493
 494                         for (j = i+1; j < list.length; j++) {
 495
 496                                 var tmp_val = get_feed_entry_unread(list[i]);
 497                                 var cur_val = get_feed_entry_unread(list[j]);
 498
 499                                 //console.log(list[i].id + " vs " + list[j].id);
 500
 501                                 var tmp_name = get_feed_entry_name(list[i]).toLowerCase();
 502                                 var cur_name = get_feed_entry_name(list[j]).toLowerCase();
 503
 504                                 /* we don't want to match FEEDR-0 - e.g. Archived articles */
 505
 506                                 var valid_pair = cat_mode || (list[i].id.match(/FEEDR-[1-9]/) &&
 507                                                 list[j].id.match(/FEEDR-[1-9]/));
 508
 509                                 if (valid_pair && ((by_unread && (cur_val > tmp_val)) || (!by_unread && (cur_name < tmp_name)))) {
 510                                         tempnode_i = list[i].cloneNode(true);
 511                                         tempnode_j = list[j].cloneNode(true);
 512                                         node.replaceChild(tempnode_i, list[j]);
 513                                         node.replaceChild(tempnode_j, list[i]);
 514                                 }
 515                         }
 516                 }
 517
 518         } catch (e) {
 519                 exception_error("resort_category", e);
 520         }
 521
 522 }
 523
 524 function resort_feedlist() {
 525         return;
 526
 527         console.log("resort_feedlist");
 528
 529         if ($("FCATLIST--1")) {
 530
 531                 var lists = $$("#feedList ul[id*=FCATLIST]");
 532
 533                 lists.each(function(list) {
 534                                 if (list.id != "FCATLIST--1") resort_category(list, true);
 535                         });
 536
 537         } else {
 538                 resort_category($("feedList"), false);
 539         }
 540 }
 541
 542 function hideOrShowFeeds(hide) {
 543         var tree = dijit.byId("feedTree");
 544
 545         if (!tree) return;
 546
 547         if (getInitParam("enable_feed_cats")) {
 548
 549                 var cats = tree.model.store._arrayOfTopLevelItems;
 550
 551                 cats.each(function(cat) {
 552                         var cat_unread = hideOrShowFeedsCategory(cat.items, hide);
 553
 554                         var id = String(cat.id);
 555                         var node = tree._itemNodesMap[id];
 556
 557                         if (node) {
 558                                 if (hide && cat_unread == 0) {
 559                                         Effect.Fade(node[0].rowNode, {duration : 0.3,
 560                                                 queue: { position: 'end', scope: 'FFADE-' + id, limit: 1 }});
 561                                 } else {
 562                                         Element.show(node[0].rowNode);
 563                                         ++cat_unread;
 564                                 }
 565                         }
 566
 567                 });
 568
 569         } else {
 570                 hideOrShowFeedsCategory(tree.model.store._arrayOfTopLevelItems, hide);
 571         }
 572
 573 /*      try {
 574
 575                 if ($("FCATLIST--1")) {
 576
 577                         var lists = $$("#feedList ul[id*=FCATLIST]");
 578
 579                         lists.each(function(list) {
 580                                         hideOrShowFeedsCategory(list.id.replace("FCATLIST-", ""), hide);
 581                                 });
 582
 583                 } else {
 584                         hideOrShowFeedsCategory(null, hide);
 585                 }
 586
 587         } catch (e) {
 588                 exception_error("hideOrShowFeeds", e);
 589         } */
 590 }
 591
 592 function hideOrShowFeedsCategory(feeds, hide) {
 593         try {
 594                 //console.warn("hideOrShowFeedsCategory: function not implemented");
 595         var tree = dijit.byId("feedTree");
 596
 597         if (!tree) return;
 598
 599         var cat_unread = 0;
 600
 601         feeds.each(function(feed) {
 602                 var id = String(feed.id);
 603                 var bare_id = parseInt(id.substr(id.indexOf(":")+1));
 604
 605                 var unread = feed.unread[0];
 606                 var node = tree._itemNodesMap[id];
 607
 608                 if (node) {
 609                         if (hide && unread == 0 && (bare_id > 0 || !getInitParam("hide_read_shows_special"))) {
 610                                 Effect.Fade(node[0].rowNode, {duration : 0.3,
 611                                         queue: { position: 'end', scope: 'FFADE-' + id, limit: 1 }});
 612                         } else {
 613                                 Element.show(node[0].rowNode);
 614                                 ++cat_unread;
 615                         }
 616                 }
 617         });
 618
 619         return cat_unread;
 620
 621 /*              var nodes;
 622                 var cat_node;
 623
 624                 if (cat_id) {
 625                         nodes = $$("#FCATLIST-" + cat_id + " > li");
 626                         cat_node = $("FCAT-" + cat_id);
 627                 } else {
 628                         nodes = $$("#feedList li");
 629                 }
 630
 631                 var cat_unread = 0;
 632
 633                 nodes.each(function(node) {
 634
 635                         var is_unread = node.hasClassName("Unread") ||
 636                                 node.hasClassName("Selected") ||
 637                                 (node.hasClassName("virt") &&
 638                                         getInitParam("hide_read_shows_special"));
 639
 640                         if (hide && !is_unread) {
 641                                 Effect.Fade(node, {duration : 0.3,
 642                                         queue: { position: 'end', scope: 'FFADE-' + node.id, limit: 1 }});
 643                         } else {
 644                                 Element.show(node);
 645                                 ++cat_unread;
 646                         }
 647
 648                 });
 649
 650                 if (cat_node) {
 651                         if (hide && cat_unread == 0 && !cat_node.hasClassName("Selected")) {
 652                                 Effect.Fade(cat_node, {duration : 0.3,
 653                                         queue: { position: 'end', scope: 'CFADE-' + cat_node.id, limit: 1 }});
 654                         } else {
 655                                 Element.show(cat_node);
 656                         }
 657                 } */
 658
 659         } catch (e) {
 660                 exception_error("hideOrShowFeedsCategory", e);
 661         }
 662 }
 663
 664 function getFeedName(feed, is_cat) {
 665         return getFeedValue(feed, is_cat, 'name');
 666 }
 667
 668 function getFeedValue(feed, is_cat, key) {
 669
 670         try {
 671                 if (is_cat)
 672                         treeItem = treeModel.store._itemsByIdentity['CAT:' + feed];
 673                 else
 674                         treeItem = treeModel.store._itemsByIdentity['FEED:' + feed];
 675
 676                 if (treeItem)
 677                         return treeModel.store.getValue(treeItem, key);
 678
 679         } catch (e) {
 680                 //
 681         }
 682
 683         return '';
 684 }
 685
 686 function getNextUnreadCat(id) {
 687         try {
 688                 var rows = $$("#feedList li[id*=FCAT]");
 689                 var unread_cats = [];
 690
 691                 rows.each(function(row) {
 692                         var cat_id = row.id.replace("FCAT-", "");
 693
 694                         if (Element.visible(row) && get_cat_unread(cat_id) > 0)
 695                                 unread_cats.push(parseInt(cat_id));
 696                         });
 697
 698                 console.log(unread_cats);
 699
 700                 var idx = unread_cats.indexOf(id);
 701
 702                 if (idx != -1 && idx < unread_cats.length-1) {
 703                         return unread_cats[idx+1];
 704                 } else {
 705                         return unread_cats[0];
 706                 }
 707
 708         } catch (e) {
 709                 exception_error("getNextUnreadCat", e);
 710         }
 711 }
 712
 713 function getRelativeFeedId2(id, is_cat, direction, unread_only) {
 714         try {
 715
 716 //              alert(id + " IC: " + is_cat + " D: " + direction + " U: " + unread_only);
 717
 718                 var rows = $$("#feedList li");
 719                 var feeds = new Array();
 720
 721                 for (var i = 0; i < rows.length; i++) {
 722                         if (rows[i].id.match("FEEDR-")) {
 723
 724                                 if (rows[i].id == "FEEDR-" + id && !is_cat || (Element.visible(rows[i]) && Element.visible(rows[i].parentNode))) {
 725
 726                                         if (!unread_only ||
 727                                                         (rows[i].hasClassName("Unread") || rows[i].id == "FEEDR-" + id)) {
 728                                                 feeds.push(rows[i].id.replace("FEEDR-", ""));
 729                                         }
 730                                 }
 731                         }
 732
 733                         if (rows[i].id.match("FCAT-")) {
 734                                 if (rows[i].id == "FCAT-" + id && is_cat || (Element.visible(rows[i]) && Element.visible(rows[i].parentNode))) {
 735
 736                                         var cat_id = parseInt(rows[i].id.replace("FCAT-", ""));
 737
 738                                         if (cat_id >= 0) {
 739                                                 if (!unread_only || get_cat_unread(cat_id) > 0) {
 740                                                         feeds.push("CAT:"+cat_id);
 741                                                 }
 742                                         }
 743                                 }
 744                         }
 745                 }
 746
 747 //              alert(feeds.toString());
 748
 749                 if (!id) {
 750                         if (direction == "next") {
 751                                 return feeds.shift();
 752                         } else {
 753                                 return feeds.pop();
 754                         }
 755                 } else {
 756                         if (direction == "next") {
 757                                 if (is_cat) id = "CAT:" + id;
 758                                 var idx = feeds.indexOf(id);
 759                                 if (idx != -1 && idx < feeds.length) {
 760                                         return feeds[idx+1];
 761                                 } else {
 762                                         return getRelativeFeedId2(false, is_cat, direction, unread_only);
 763                                 }
 764                         } else {
 765                                 if (is_cat) id = "CAT:" + id;
 766                                 var idx = feeds.indexOf(id);
 767                                 if (idx > 0) {
 768                                         return feeds[idx-1];
 769                                 } else {
 770                                         return getRelativeFeedId2(false, is_cat, direction, unread_only);
 771                                 }
 772                         }
 773
 774                 }
 775
 776         } catch (e) {
 777                 exception_error("getRelativeFeedId2", e);
 778         }
 779 }
 780
 781 function feedsSortByUnread() {
 782         return feeds_sort_by_unread;
 783 }
 784
 785 function setFeedUnread(feed, is_cat, unread) {
 786         try {
 787                 setFeedValue(feed, is_cat, 'unread', parseInt(unread));
 788         } catch (e) {
 789                 exception_error("setFeedUnread", e);
 790         }
 791 }
 792
 793 function setFeedValue(feed, is_cat, key, value) {
 794         try {
 795                 if (!value) value = '';
 796
 797                 if (is_cat)
 798                         treeItem = treeModel.store._itemsByIdentity['CAT:' + feed];
 799                 else
 800                         treeItem = treeModel.store._itemsByIdentity['FEED:' + feed];
 801
 802                 if (treeItem)
 803                         treeModel.store.setValue(treeItem, key, value);
 804
 805         } catch (e) {
 806                 console.log(e);
 807                 //exception_error("setFeedValue", e);
 808         }
 809 }
 810
 811 function toggleCollapseCat(id) {
 812         console.warn("toggleCollapseCat: function not implemented");
 813 }
 814
 815 function selectFeed(feed, is_cat) {
 816         try {
 817                 var tree = dijit.byId("feedTree");
 818
 819                 if (!tree) return;
 820
 821                 if (is_cat)
 822                         treeNode = tree._itemNodesMap['CAT:' + feed];
 823                 else
 824                         treeNode = tree._itemNodesMap['FEED:' + feed];
 825
 826                 if (treeNode) {
 827                         treeNode = treeNode[0];
 828                         if (!is_cat) tree._expandNode(treeNode);
 829                         tree._selectNode(treeNode);
 830                 }
 831
 832         } catch (e) {
 833                 exception_error("selectFeed", e);
 834         }
 835 }
 836
 837 function setFeedIcon(feed, is_cat, src) {
 838         try {
 839                 var tree = dijit.byId("feedTree");
 840
 841                 if (!tree) return;
 842
 843                 if (is_cat)
 844                         treeNode = tree._itemNodesMap['CAT:' + feed];
 845                 else
 846                         treeNode = tree._itemNodesMap['FEED:' + feed];
 847
 848                 if (treeNode) {
 849                         treeNode = treeNode[0];
 850                         treeNode.iconNode.src = src;
 851                 }
 852
 853         } catch (e) {
 854                 exception_error("setFeedIcon", e);
 855         }
 856 }
 857
 858 function setFeedExpandoIcon(feed, is_cat, src) {
 859         try {
 860                 var tree = dijit.byId("feedTree");
 861
 862                 if (!tree) return;
 863
 864                 if (is_cat)
 865                         treeNode = tree._itemNodesMap['CAT:' + feed];
 866                 else
 867                         treeNode = tree._itemNodesMap['FEED:' + feed];
 868
 869                 if (treeNode) {
 870                         treeNode = treeNode[0];
 871                         treeNode.expandoNode.src = src;
 872                 }
 873
 874         } catch (e) {
 875                 exception_error("setFeedIcon", e);
 876         }
 877 }