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