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                 if (getInitParam("theme") == "" ||
 294                                 getInitParam("theme_options").match("hide_footer")) {
 295                         setTimeout("hide_footer()", 5000);
 296                 }
 297
 298                 //init_collapsable_feedlist(getInitParam("theme"));
 299
 300                 toggle_sortable_feedlist(isFeedlistSortable());
 301
 302         } catch (e) {
 303                 exception_error("feedlist/init", e);
 304         }
 305 }
 306
 307 /* function hide_footer_af(effect) {
 308         try {
 309                 var c = $("content-frame");
 310
 311                 if (c) {
 312                         c.style.bottom = "0px";
 313
 314                         var ioa = $("inline_orig_article");
 315
 316                         if (ioa) {
 317                                 ioa.height = c.offsetHeight;
 318                         }
 319
 320                 } else {
 321                         var h = $("headlines-frame");
 322
 323                         if (h) {
 324                                 h.style.bottom = "0px";
 325                         }
 326                 }
 327
 328         } catch (e) {
 329                 exception_error("hide_footer_af", e);
 330         }
 331 } */
 332
 333 function hide_footer() {
 334         try {
 335                 /* if (Element.visible("footer")) {
 336
 337                         Element.hide("footer");
 338                         dijit.byId("main").resize();
 339
 340                         //new Effect.Fade("footer", { afterFinish: hide_footer_af });
 341                 } */
 342         } catch (e) {
 343                 exception_error("hide_footer", e);
 344         }
 345 }
 346
 347 function enable_selection(b) {
 348         selection_disabled = !b;
 349 }
 350
 351 function enable_resize(b) {
 352         resize_enabled = b;
 353 }
 354
 355 function request_counters_real() {
 356         try {
 357                 console.log("requesting counters...");
 358
 359                 var query = "?op=rpc&subop=getAllCounters&seq=" + next_seq();
 360
 361                 query = query + "&omode=flc";
 362
 363                 new Ajax.Request("backend.php", {
 364                         parameters: query,
 365                         onComplete: function(transport) {
 366                                 try {
 367                                         handle_rpc_reply(transport);
 368                                 } catch (e) {
 369                                         exception_error("viewfeed/getcounters", e);
 370                                 }
 371                         } });
 372
 373         } catch (e) {
 374                 exception_error("request_counters_real", e);
 375         }
 376 }
 377
 378
 379 function request_counters() {
 380
 381         try {
 382
 383                 if (getInitParam("bw_limit") == "1") return;
 384
 385                 var date = new Date();
 386                 var timestamp = Math.round(date.getTime() / 1000);
 387
 388                 if (timestamp - counters_last_request > 5) {
 389                         console.log("scheduling request of counters...");
 390
 391                         window.clearTimeout(counter_timeout_id);
 392                         counter_timeout_id = window.setTimeout("request_counters_real()", 1000);
 393
 394                         counters_last_request = timestamp;
 395                 } else {
 396                         console.log("request_counters: rate limit reached: " + (timestamp - counters_last_request));
 397                 }
 398
 399         } catch (e) {
 400                 exception_error("request_counters", e);
 401         }
 402 }
 403
 404 function displayNewContentPrompt(id) {
 405         try {
 406
 407                 var msg = "<a href='#' onclick='viewfeed("+id+")'>" +
 408                         __("New articles available in this feed (click to show)") + "</a>";
 409
 410                 msg = msg.replace("%s", getFeedName(id));
 411
 412                 $('auxDlg').innerHTML = msg;
 413
 414                 new Effect.Appear('auxDlg', {duration : 0.5});
 415
 416         } catch (e) {
 417                 exception_error("displayNewContentPrompt", e);
 418         }
 419 }
 420
 421 function parse_counters(reply, scheduled_call) {
 422         try {
 423
 424                 var feeds_found = 0;
 425
 426                 var elems = JSON.parse(reply.firstChild.nodeValue);
 427
 428                 for (var l = 0; l < elems.length; l++) {
 429
 430                         var id = elems[l].id
 431                         var kind = elems[l].kind;
 432                         var ctr = parseInt(elems[l].counter)
 433                         var error = elems[l].error;
 434                         var has_img = elems[l].has_img;
 435                         var updated = elems[l].updated;
 436                         var title = elems[l].title;
 437                         var xmsg = elems[l].xmsg;
 438
 439                         if (id == "global-unread") {
 440                                 global_unread = ctr;
 441                                 updateTitle();
 442                                 continue;
 443                         }
 444
 445                         if (id == "subscribed-feeds") {
 446                                 feeds_found = ctr;
 447                                 continue;
 448                         }
 449
 450                         var treeItem;
 451
 452                         setFeedUnread(id, (kind == "cat"), ctr);
 453
 454                         if (kind != "cat") {
 455                                 //setFeedValue(id, false, 'error', error);
 456                                 setFeedValue(id, false, 'updated', updated);
 457
 458                                 if (id > 0) {
 459                                         if (has_img) {
 460                                                 setFeedIcon(id, false,
 461                                                         getInitParam("icons_url") + "/" + id + ".ico");
 462                                         } else {
 463                                                 setFeedIcon(id, false, 'images/blank_icon.gif');
 464                                         }
 465                                 }
 466                         }
 467                 }
 468
 469                 hideOrShowFeeds(getInitParam("hide_read_feeds") == 1);
 470
 471                 var feeds_stored = number_of_feeds;
 472
 473                 if (feeds_stored != feeds_found) {
 474                         number_of_feeds = feeds_found;
 475
 476                         if (feeds_stored != 0 && feeds_found != 0) {
 477                                 console.log("Subscribed feed number changed, refreshing feedlist");
 478                                 setTimeout('updateFeedList()', 50);
 479                         }
 480                 }
 481
 482         } catch (e) {
 483                 exception_error("parse_counters", e);
 484         }
 485 }
 486
 487 function get_feed_unread(feed, is_cat) {
 488         try {
 489                 if (is_cat)
 490                         treeItem = treeModel.store._itemsByIdentity['CAT:' + feed];
 491                 else
 492                         treeItem = treeModel.store._itemsByIdentity['FEED:' + feed];
 493
 494                 if (treeItem)
 495                         return treeModel.store.getValue(treeItem, 'unread');
 496
 497         } catch (e) {
 498                 //
 499         }
 500
 501         return -1;
 502 }
 503
 504 function get_cat_unread(id) {
 505         return get_feed_unread(id, true);
 506 }
 507
 508 function get_feed_entry_unread(elem) {
 509
 510         var id = elem.id.replace("FEEDR-", "");
 511
 512         if (id <= 0) {
 513                 return -1;
 514         }
 515
 516         try {
 517                 return parseInt($("FEEDU-" + id).innerHTML);
 518         } catch (e) {
 519                 return -1;
 520         }
 521 }
 522
 523 function get_feed_entry_name(elem) {
 524         var id = elem.id.replace("FEEDR-", "");
 525         return getFeedName(id);
 526 }
 527
 528
 529 function resort_category(node, cat_mode) {
 530
 531         try {
 532
 533                 //console.log("resort_category: " + node + " CM=" + cat_mode);
 534
 535                 var by_unread = feedsSortByUnread();
 536
 537                 var list = node.getElementsByTagName("LI");
 538
 539                 for (i = 0; i < list.length; i++) {
 540
 541                         for (j = i+1; j < list.length; j++) {
 542
 543                                 var tmp_val = get_feed_entry_unread(list[i]);
 544                                 var cur_val = get_feed_entry_unread(list[j]);
 545
 546                                 //console.log(list[i].id + " vs " + list[j].id);
 547
 548                                 var tmp_name = get_feed_entry_name(list[i]).toLowerCase();
 549                                 var cur_name = get_feed_entry_name(list[j]).toLowerCase();
 550
 551                                 /* we don't want to match FEEDR-0 - e.g. Archived articles */
 552
 553                                 var valid_pair = cat_mode || (list[i].id.match(/FEEDR-[1-9]/) &&
 554                                                 list[j].id.match(/FEEDR-[1-9]/));
 555
 556                                 if (valid_pair && ((by_unread && (cur_val > tmp_val)) || (!by_unread && (cur_name < tmp_name)))) {
 557                                         tempnode_i = list[i].cloneNode(true);
 558                                         tempnode_j = list[j].cloneNode(true);
 559                                         node.replaceChild(tempnode_i, list[j]);
 560                                         node.replaceChild(tempnode_j, list[i]);
 561                                 }
 562                         }
 563                 }
 564
 565         } catch (e) {
 566                 exception_error("resort_category", e);
 567         }
 568
 569 }
 570
 571 function resort_feedlist() {
 572         return;
 573
 574         console.log("resort_feedlist");
 575
 576         if ($("FCATLIST--1")) {
 577
 578                 var lists = $$("#feedList ul[id*=FCATLIST]");
 579
 580                 lists.each(function(list) {
 581                                 if (list.id != "FCATLIST--1") resort_category(list, true);
 582                         });
 583
 584         } else {
 585                 resort_category($("feedList"), false);
 586         }
 587 }
 588
 589 function hideOrShowFeeds(hide) {
 590         var tree = dijit.byId("feedTree");
 591
 592         if (!tree) return;
 593
 594         if (getInitParam("enable_feed_cats")) {
 595
 596                 var cats = tree.model.store._arrayOfTopLevelItems;
 597
 598                 cats.each(function(cat) {
 599                         var cat_unread = hideOrShowFeedsCategory(cat.items, hide);
 600
 601                         var id = String(cat.id);
 602                         var node = tree._itemNodesMap[id];
 603
 604                         if (node) {
 605                                 if (hide && cat_unread == 0) {
 606                                         Effect.Fade(node[0].rowNode, {duration : 0.3,
 607                                                 queue: { position: 'end', scope: 'FFADE-' + id, limit: 1 }});
 608                                 } else {
 609                                         Element.show(node[0].rowNode);
 610                                         ++cat_unread;
 611                                 }
 612                         }
 613
 614                 });
 615
 616         } else {
 617                 hideOrShowFeedsCategory(tree.model.store._arrayOfTopLevelItems, hide);
 618         }
 619
 620 /*      try {
 621
 622                 if ($("FCATLIST--1")) {
 623
 624                         var lists = $$("#feedList ul[id*=FCATLIST]");
 625
 626                         lists.each(function(list) {
 627                                         hideOrShowFeedsCategory(list.id.replace("FCATLIST-", ""), hide);
 628                                 });
 629
 630                 } else {
 631                         hideOrShowFeedsCategory(null, hide);
 632                 }
 633
 634         } catch (e) {
 635                 exception_error("hideOrShowFeeds", e);
 636         } */
 637 }
 638
 639 function hideOrShowFeedsCategory(feeds, hide) {
 640         try {
 641                 //console.warn("hideOrShowFeedsCategory: function not implemented");
 642         var tree = dijit.byId("feedTree");
 643
 644         if (!tree) return;
 645
 646         var cat_unread = 0;
 647
 648         feeds.each(function(feed) {
 649                 var id = String(feed.id);
 650                 var bare_id = parseInt(id.substr(id.indexOf(":")+1));
 651
 652                 var unread = feed.unread[0];
 653                 var node = tree._itemNodesMap[id];
 654
 655                 if (node) {
 656                         if (hide && unread == 0 && (bare_id > 0 || !getInitParam("hide_read_shows_special"))) {
 657                                 Effect.Fade(node[0].rowNode, {duration : 0.3,
 658                                         queue: { position: 'end', scope: 'FFADE-' + id, limit: 1 }});
 659                         } else {
 660                                 Element.show(node[0].rowNode);
 661                                 ++cat_unread;
 662                         }
 663                 }
 664         });
 665
 666         return cat_unread;
 667
 668 /*              var nodes;
 669                 var cat_node;
 670
 671                 if (cat_id) {
 672                         nodes = $$("#FCATLIST-" + cat_id + " > li");
 673                         cat_node = $("FCAT-" + cat_id);
 674                 } else {
 675                         nodes = $$("#feedList li");
 676                 }
 677
 678                 var cat_unread = 0;
 679
 680                 nodes.each(function(node) {
 681
 682                         var is_unread = node.hasClassName("Unread") ||
 683                                 node.hasClassName("Selected") ||
 684                                 (node.hasClassName("virt") &&
 685                                         getInitParam("hide_read_shows_special"));
 686
 687                         if (hide && !is_unread) {
 688                                 Effect.Fade(node, {duration : 0.3,
 689                                         queue: { position: 'end', scope: 'FFADE-' + node.id, limit: 1 }});
 690                         } else {
 691                                 Element.show(node);
 692                                 ++cat_unread;
 693                         }
 694
 695                 });
 696
 697                 if (cat_node) {
 698                         if (hide && cat_unread == 0 && !cat_node.hasClassName("Selected")) {
 699                                 Effect.Fade(cat_node, {duration : 0.3,
 700                                         queue: { position: 'end', scope: 'CFADE-' + cat_node.id, limit: 1 }});
 701                         } else {
 702                                 Element.show(cat_node);
 703                         }
 704                 } */
 705
 706         } catch (e) {
 707                 exception_error("hideOrShowFeedsCategory", e);
 708         }
 709 }
 710
 711 function getFeedName(feed, is_cat) {
 712         return getFeedValue(feed, is_cat, 'name');
 713 }
 714
 715 function getFeedValue(feed, is_cat, key) {
 716
 717         try {
 718                 if (is_cat)
 719                         treeItem = treeModel.store._itemsByIdentity['CAT:' + feed];
 720                 else
 721                         treeItem = treeModel.store._itemsByIdentity['FEED:' + feed];
 722
 723                 if (treeItem)
 724                         return treeModel.store.getValue(treeItem, key);
 725
 726         } catch (e) {
 727                 //
 728         }
 729
 730         return '';
 731 }
 732
 733 function getNextUnreadCat(id) {
 734         try {
 735                 var rows = $$("#feedList li[id*=FCAT]");
 736                 var unread_cats = [];
 737
 738                 rows.each(function(row) {
 739                         var cat_id = row.id.replace("FCAT-", "");
 740
 741                         if (Element.visible(row) && get_cat_unread(cat_id) > 0)
 742                                 unread_cats.push(parseInt(cat_id));
 743                         });
 744
 745                 console.log(unread_cats);
 746
 747                 var idx = unread_cats.indexOf(id);
 748
 749                 if (idx != -1 && idx < unread_cats.length-1) {
 750                         return unread_cats[idx+1];
 751                 } else {
 752                         return unread_cats[0];
 753                 }
 754
 755         } catch (e) {
 756                 exception_error("getNextUnreadCat", e);
 757         }
 758 }
 759
 760 function getRelativeFeedId2(id, is_cat, direction, unread_only) {
 761         try {
 762
 763 //              alert(id + " IC: " + is_cat + " D: " + direction + " U: " + unread_only);
 764
 765                 var rows = $$("#feedList li");
 766                 var feeds = new Array();
 767
 768                 for (var i = 0; i < rows.length; i++) {
 769                         if (rows[i].id.match("FEEDR-")) {
 770
 771                                 if (rows[i].id == "FEEDR-" + id && !is_cat || (Element.visible(rows[i]) && Element.visible(rows[i].parentNode))) {
 772
 773                                         if (!unread_only ||
 774                                                         (rows[i].hasClassName("Unread") || rows[i].id == "FEEDR-" + id)) {
 775                                                 feeds.push(rows[i].id.replace("FEEDR-", ""));
 776                                         }
 777                                 }
 778                         }
 779
 780                         if (rows[i].id.match("FCAT-")) {
 781                                 if (rows[i].id == "FCAT-" + id && is_cat || (Element.visible(rows[i]) && Element.visible(rows[i].parentNode))) {
 782
 783                                         var cat_id = parseInt(rows[i].id.replace("FCAT-", ""));
 784
 785                                         if (cat_id >= 0) {
 786                                                 if (!unread_only || get_cat_unread(cat_id) > 0) {
 787                                                         feeds.push("CAT:"+cat_id);
 788                                                 }
 789                                         }
 790                                 }
 791                         }
 792                 }
 793
 794 //              alert(feeds.toString());
 795
 796                 if (!id) {
 797                         if (direction == "next") {
 798                                 return feeds.shift();
 799                         } else {
 800                                 return feeds.pop();
 801                         }
 802                 } else {
 803                         if (direction == "next") {
 804                                 if (is_cat) id = "CAT:" + id;
 805                                 var idx = feeds.indexOf(id);
 806                                 if (idx != -1 && idx < feeds.length) {
 807                                         return feeds[idx+1];
 808                                 } else {
 809                                         return getRelativeFeedId2(false, is_cat, direction, unread_only);
 810                                 }
 811                         } else {
 812                                 if (is_cat) id = "CAT:" + id;
 813                                 var idx = feeds.indexOf(id);
 814                                 if (idx > 0) {
 815                                         return feeds[idx-1];
 816                                 } else {
 817                                         return getRelativeFeedId2(false, is_cat, direction, unread_only);
 818                                 }
 819                         }
 820
 821                 }
 822
 823         } catch (e) {
 824                 exception_error("getRelativeFeedId2", e);
 825         }
 826 }
 827
 828 function feedsSortByUnread() {
 829         return feeds_sort_by_unread;
 830 }
 831
 832 function setFeedUnread(feed, is_cat, unread) {
 833         try {
 834                 setFeedValue(feed, is_cat, 'unread', parseInt(unread));
 835         } catch (e) {
 836                 exception_error("setFeedUnread", e);
 837         }
 838 }
 839
 840 function setFeedValue(feed, is_cat, key, value) {
 841         try {
 842                 if (!value) value = '';
 843                 if (!treeModel) return;
 844
 845                 if (is_cat)
 846                         treeItem = treeModel.store._itemsByIdentity['CAT:' + feed];
 847                 else
 848                         treeItem = treeModel.store._itemsByIdentity['FEED:' + feed];
 849
 850                 if (treeItem)
 851                         treeModel.store.setValue(treeItem, key, value);
 852
 853         } catch (e) {
 854                 exception_error("setFeedValue", e);
 855         }
 856 }
 857
 858 function toggleCollapseCat(id) {
 859         console.warn("toggleCollapseCat: function not implemented");
 860 }
 861
 862 function selectFeed(feed, is_cat) {
 863         try {
 864                 var tree = dijit.byId("feedTree");
 865
 866                 if (!tree) return;
 867
 868                 if (is_cat)
 869                         treeNode = tree._itemNodesMap['CAT:' + feed];
 870                 else
 871                         treeNode = tree._itemNodesMap['FEED:' + feed];
 872
 873                 if (treeNode) {
 874                         treeNode = treeNode[0];
 875                         if (!is_cat) tree._expandNode(treeNode);
 876                         tree._selectNode(treeNode);
 877                 }
 878
 879         } catch (e) {
 880                 exception_error("selectFeed", e);
 881         }
 882 }
 883
 884 function setFeedIcon(feed, is_cat, src) {
 885         try {
 886                 var tree = dijit.byId("feedTree");
 887
 888                 if (!tree) return;
 889
 890                 if (is_cat)
 891                         treeNode = tree._itemNodesMap['CAT:' + feed];
 892                 else
 893                         treeNode = tree._itemNodesMap['FEED:' + feed];
 894
 895                 if (treeNode) {
 896                         treeNode = treeNode[0];
 897                         treeNode.iconNode.src = src;
 898                 }
 899
 900         } catch (e) {
 901                 exception_error("setFeedIcon", e);
 902         }
 903 }
 904
 905 function setFeedExpandoIcon(feed, is_cat, src) {
 906         try {
 907                 var tree = dijit.byId("feedTree");
 908
 909                 if (!tree) return;
 910
 911                 if (is_cat)
 912                         treeNode = tree._itemNodesMap['CAT:' + feed];
 913                 else
 914                         treeNode = tree._itemNodesMap['FEED:' + feed];
 915
 916                 if (treeNode) {
 917                         treeNode = treeNode[0];
 918                         treeNode.expandoNode.src = src;
 919                 }
 920
 921         } catch (e) {
 922                 exception_error("setFeedIcon", e);
 923         }
 924 }