js/feedlist.js

   1 var _infscroll_disable = 0;
   2 var _infscroll_request_sent = 0;
   3
   4 var _search_query = false;
   5 var _viewfeed_last = 0;
   6 var _viewfeed_timeout = false;
   7
   8 var counters_last_request = 0;
   9
  10 function viewCategory(cat) {
  11         viewfeed({feed: cat, is_cat: true});
  12         return false;
  13 }
  14
  15 function loadMoreHeadlines() {
  16         try {
  17                 console.log("loadMoreHeadlines");
  18
  19                 var offset = 0;
  20
  21                 var view_mode = document.forms["main_toolbar_form"].view_mode.value;
  22                 var unread_in_buffer = $$("#headlines-frame > div[id*=RROW][class*=Unread]").length;
  23                 var num_all = $$("#headlines-frame > div[id*=RROW]").length;
  24                 var num_unread = getFeedUnread(getActiveFeedId(), activeFeedIsCat());
  25
  26                 // TODO implement marked & published
  27
  28                 if (view_mode == "marked") {
  29                         console.warn("loadMoreHeadlines: marked is not implemented, falling back.");
  30                         offset = num_all;
  31                 } else if (view_mode == "published") {
  32                         console.warn("loadMoreHeadlines: published is not implemented, falling back.");
  33                         offset = num_all;
  34                 } else if (view_mode == "unread") {
  35                         offset = unread_in_buffer;
  36                 } else if (_search_query) {
  37                         offset = num_all;
  38                 } else if (view_mode == "adaptive") {
  39                         offset = num_unread > 0 ? unread_in_buffer : num_all;
  40                 } else {
  41                         offset = num_all;
  42                 }
  43
  44                 console.log("offset: " + offset);
  45
  46                 viewfeed({feed: getActiveFeedId(), is_cat: activeFeedIsCat(), offset: offset, infscroll_req: true});
  47
  48         } catch (e) {
  49                 exception_error("viewNextFeedPage", e);
  50         }
  51 }
  52
  53 function viewfeed(params) {
  54         try {
  55                 var feed = params.feed;
  56                 var is_cat = params.is_cat;
  57                 var offset = params.offset;
  58                 var background = params.background;
  59                 var infscroll_req = params.infscroll_req;
  60                 var can_wait = params.can_wait;
  61                 var viewfeed_debug = params.viewfeed_debug;
  62                 var method = params.method;
  63
  64                 if (is_cat == undefined)
  65                         is_cat = false;
  66                 else
  67                         is_cat = !!is_cat;
  68
  69                 if (offset == undefined) offset = 0;
  70                 if (background == undefined) background = false;
  71                 if (infscroll_req == undefined) infscroll_req = false;
  72
  73                 last_requested_article = 0;
  74
  75                 if (feed != getActiveFeedId() || activeFeedIsCat() != is_cat) {
  76                         if (!background && _search_query) _search_query = false;
  77                 }
  78
  79                 if (!background) {
  80                         _viewfeed_last = get_timestamp();
  81
  82                         if (getActiveFeedId() != feed || !infscroll_req) {
  83                                 setActiveArticleId(0);
  84                                 _infscroll_disable = 0;
  85                         }
  86
  87                         if (infscroll_req) {
  88                                 var timestamp = get_timestamp();
  89
  90                                 if (_infscroll_request_sent && _infscroll_request_sent + 30 > timestamp) {
  91                                         //console.log("infscroll request in progress, aborting");
  92                                         return;
  93                                 }
  94
  95                                 _infscroll_request_sent = timestamp;
  96                         }
  97                 }
  98
  99                 Form.enable("main_toolbar_form");
 100
 101                 var toolbar_query = Form.serialize("main_toolbar_form");
 102
 103                 var query = "?op=feeds&method=view&feed=" + param_escape(feed) + "&" +
 104                         toolbar_query;
 105
 106                 if (method) query += "&m=" + param_escape(method);
 107
 108                 if (offset > 0) {
 109                         if (current_first_id) {
 110                                 query = query + "&fid=" + param_escape(current_first_id);
 111                         }
 112                 }
 113
 114                 if (!background) {
 115                         if (_search_query) {
 116                                 force_nocache = true;
 117                                 query = query + "&" + _search_query;
 118                                 //_search_query = false;
 119                         }
 120
 121                         if (offset != 0) {
 122                                 query = query + "&skip=" + offset;
 123
 124                                 // to prevent duplicate feed titles when showing grouped vfeeds
 125                                 if (vgroup_last_feed) {
 126                                         query = query + "&vgrlf=" + param_escape(vgroup_last_feed);
 127                                 }
 128                         } else {
 129                                 if (!is_cat && feed == getActiveFeedId()) {
 130                                         query = query + "&m=ForceUpdate";
 131                                 }
 132                         }
 133
 134                         Form.enable("main_toolbar_form");
 135
 136                         if (!setFeedExpandoIcon(feed, is_cat,
 137                                 (is_cat) ? 'images/indicator_tiny.gif' : 'images/indicator_white.gif'))
 138                                         notify_progress("Loading, please wait...", true);
 139                 }
 140
 141                 query += "&cat=" + is_cat;
 142
 143                 console.log(query);
 144
 145                 if (can_wait && _viewfeed_timeout) {
 146                         setFeedExpandoIcon(getActiveFeedId(), activeFeedIsCat(), 'images/blank_icon.gif');
 147                         clearTimeout(_viewfeed_timeout);
 148                 }
 149
 150                 setActiveFeedId(feed, is_cat);
 151
 152                 if (viewfeed_debug) {
 153                         window.open("backend.php" + query + "&debug=1&csrf_token=" + getInitParam("csrf_token"));
 154                 }
 155
 156                 timeout_ms = can_wait ? 250 : 0;
 157                 _viewfeed_timeout = setTimeout(function() {
 158
 159                         new Ajax.Request("backend.php", {
 160                                 parameters: query,
 161                                 onComplete: function(transport) {
 162                                         setFeedExpandoIcon(feed, is_cat, 'images/blank_icon.gif');
 163                                         headlines_callback2(transport, offset, background, infscroll_req);
 164                                         PluginHost.run(PluginHost.HOOK_FEED_LOADED, [feed, is_cat]);
 165                                 } });
 166                 }, timeout_ms); // Wait 250ms
 167
 168         } catch (e) {
 169                 exception_error("viewfeed", e);
 170         }
 171 }
 172
 173 function feedlist_init() {
 174         try {
 175                 console.log("in feedlist init");
 176
 177                 loading_set_progress(50);
 178
 179                 document.onkeydown = hotkey_handler;
 180                 setTimeout("hotkey_prefix_timeout()", 5*1000);
 181
 182                 if (!getActiveFeedId()) {
 183                         viewfeed({feed: -3});
 184                 } else {
 185                         viewfeed({feed: getActiveFeedId(), is_cat: activeFeedIsCat()});
 186                 }
 187
 188                 hideOrShowFeeds(getInitParam("hide_read_feeds") == 1);
 189
 190                 request_counters(true);
 191                 timeout();
 192
 193         } catch (e) {
 194                 exception_error("feedlist/init", e);
 195         }
 196 }
 197
 198
 199 function request_counters(force) {
 200         try {
 201                 var date = new Date();
 202                 var timestamp = Math.round(date.getTime() / 1000);
 203
 204                 if (force || timestamp - counters_last_request > 5) {
 205                         console.log("scheduling request of counters...");
 206
 207                         counters_last_request = timestamp;
 208
 209                         var query = "?op=rpc&method=getAllCounters&seq=" + next_seq();
 210
 211                         if (!force)
 212                                 query = query + "&last_article_id=" + getInitParam("last_article_id");
 213
 214                         console.log(query);
 215
 216                         new Ajax.Request("backend.php", {
 217                                 parameters: query,
 218                                 onComplete: function(transport) {
 219                                         try {
 220                                                 handle_rpc_json(transport);
 221                                         } catch (e) {
 222                                                 exception_error("request_counters", e);
 223                                         }
 224                                 } });
 225
 226                 } else {
 227                         console.log("request_counters: rate limit reached: " + (timestamp - counters_last_request));
 228                 }
 229
 230         } catch (e) {
 231                 exception_error("request_counters", e);
 232         }
 233 }
 234
 235 function parse_counters(elems, scheduled_call) {
 236         try {
 237                 for (var l = 0; l < elems.length; l++) {
 238
 239                         var id = elems[l].id;
 240                         var kind = elems[l].kind;
 241                         var ctr = parseInt(elems[l].counter);
 242                         var error = elems[l].error;
 243                         var has_img = elems[l].has_img;
 244                         var updated = elems[l].updated;
 245                         var auxctr = parseInt(elems[l].auxcounter);
 246
 247                         if (id == "global-unread") {
 248                                 global_unread = ctr;
 249                                 updateTitle();
 250                                 continue;
 251                         }
 252
 253                         if (id == "subscribed-feeds") {
 254                                 feeds_found = ctr;
 255                                 continue;
 256                         }
 257
 258                         if (getFeedUnread(id, (kind == "cat")) != ctr ||
 259                                         (kind == "cat")) {
 260                         }
 261
 262                         setFeedUnread(id, (kind == "cat"), ctr);
 263                         setFeedValue(id, (kind == "cat"), 'auxcounter', auxctr);
 264
 265                         if (kind != "cat") {
 266                                 setFeedValue(id, false, 'error', error);
 267                                 setFeedValue(id, false, 'updated', updated);
 268
 269                                 if (id > 0) {
 270                                         if (has_img) {
 271                                                 setFeedIcon(id, false,
 272                                                         getInitParam("icons_url") + "/" + id + ".ico");
 273                                         } else {
 274                                                 setFeedIcon(id, false, 'images/blank_icon.gif');
 275                                         }
 276                                 }
 277                         }
 278                 }
 279
 280                 hideOrShowFeeds(getInitParam("hide_read_feeds") == 1);
 281
 282         } catch (e) {
 283                 exception_error("parse_counters", e);
 284         }
 285 }
 286
 287 function getFeedUnread(feed, is_cat) {
 288         try {
 289                 var tree = dijit.byId("feedTree");
 290
 291                 if (tree && tree.model)
 292                         return tree.model.getFeedUnread(feed, is_cat);
 293
 294         } catch (e) {
 295                 //
 296         }
 297
 298         return -1;
 299 }
 300
 301 function getFeedCategory(feed) {
 302         try {
 303                 var tree = dijit.byId("feedTree");
 304
 305                 if (tree && tree.model)
 306                         return tree.getFeedCategory(feed);
 307
 308         } catch (e) {
 309                 //
 310         }
 311
 312         return false;
 313 }
 314
 315 function hideOrShowFeeds(hide) {
 316         var tree = dijit.byId("feedTree");
 317
 318         if (tree)
 319                 return tree.hideRead(hide, getInitParam("hide_read_shows_special"));
 320 }
 321
 322 function getFeedName(feed, is_cat) {
 323         var tree = dijit.byId("feedTree");
 324
 325         if (tree && tree.model)
 326                 return tree.model.getFeedValue(feed, is_cat, 'name');
 327 }
 328
 329 function getFeedValue(feed, is_cat, key) {
 330         try {
 331                 var tree = dijit.byId("feedTree");
 332
 333                 if (tree && tree.model)
 334                         return tree.model.getFeedValue(feed, is_cat, key);
 335
 336         } catch (e) {
 337                 //
 338         }
 339         return '';
 340 }
 341
 342 function setFeedUnread(feed, is_cat, unread) {
 343         try {
 344                 var tree = dijit.byId("feedTree");
 345
 346                 if (tree && tree.model)
 347                         return tree.model.setFeedUnread(feed, is_cat, unread);
 348
 349         } catch (e) {
 350                 exception_error("setFeedUnread", e);
 351         }
 352 }
 353
 354 function setFeedValue(feed, is_cat, key, value) {
 355         try {
 356                 var tree = dijit.byId("feedTree");
 357
 358                 if (tree && tree.model)
 359                         return tree.model.setFeedValue(feed, is_cat, key, value);
 360
 361         } catch (e) {
 362                 //
 363         }
 364 }
 365
 366 function selectFeed(feed, is_cat) {
 367         try {
 368                 var tree = dijit.byId("feedTree");
 369
 370                 if (tree) return tree.selectFeed(feed, is_cat);
 371
 372         } catch (e) {
 373                 exception_error("selectFeed", e);
 374         }
 375 }
 376
 377 function setFeedIcon(feed, is_cat, src) {
 378         try {
 379                 var tree = dijit.byId("feedTree");
 380
 381                 if (tree) return tree.setFeedIcon(feed, is_cat, src);
 382
 383         } catch (e) {
 384                 exception_error("setFeedIcon", e);
 385         }
 386 }
 387
 388 function setFeedExpandoIcon(feed, is_cat, src) {
 389         try {
 390                 var tree = dijit.byId("feedTree");
 391
 392                 if (tree) return tree.setFeedExpandoIcon(feed, is_cat, src);
 393
 394         } catch (e) {
 395                 exception_error("setFeedIcon", e);
 396         }
 397         return false;
 398 }
 399
 400 function getNextUnreadFeed(feed, is_cat) {
 401         try {
 402                 var tree = dijit.byId("feedTree");
 403                 var nuf = tree.model.getNextUnreadFeed(feed, is_cat);
 404
 405                 if (nuf)
 406                         return tree.model.store.getValue(nuf, 'bare_id');
 407
 408         } catch (e) {
 409                 exception_error("getNextUnreadFeed", e);
 410         }
 411 }
 412
 413 function catchupCurrentFeed(mode) {
 414         catchupFeed(getActiveFeedId(), activeFeedIsCat(), mode);
 415 }
 416
 417 function catchupFeedInGroup(id) {
 418         try {
 419
 420                 var title = getFeedName(id);
 421
 422                 var str = __("Mark all articles in %s as read?").replace("%s", title);
 423
 424                 if (getInitParam("confirm_feed_catchup") != 1 || confirm(str)) {
 425                         return viewCurrentFeed('MarkAllReadGR:' + id);
 426                 }
 427
 428         } catch (e) {
 429                 exception_error("catchupFeedInGroup", e);
 430         }
 431 }
 432
 433 function catchupFeed(feed, is_cat, mode) {
 434         try {
 435                 if (is_cat == undefined) is_cat = false;
 436
 437                 var str = false;
 438
 439                 switch (mode) {
 440                 case "1day":
 441                         str = __("Mark all articles in %s older than 1 day as read?");
 442                         break;
 443                 case "1week":
 444                         str = __("Mark all articles in %s older than 1 week as read?");
 445                         break;
 446                 case "2week":
 447                         str = __("Mark all articles in %s older than 2 weeks as read?");
 448                         break;
 449                 default:
 450                         str = __("Mark all articles in %s as read?");
 451                 }
 452
 453                 var fn = getFeedName(feed, is_cat);
 454
 455                 str = str.replace("%s", fn);
 456
 457                 if (getInitParam("confirm_feed_catchup") == 1 && !confirm(str)) {
 458                         return;
 459                 }
 460
 461                 var catchup_query = "?op=rpc&method=catchupFeed&feed_id=" +
 462                         feed + "&is_cat=" + is_cat + "&mode=" + mode;
 463
 464                 console.log(catchup_query);
 465
 466                 notify_progress("Loading, please wait...", true);
 467
 468                 new Ajax.Request("backend.php", {
 469                         parameters: catchup_query,
 470                         onComplete: function(transport) {
 471                                         handle_rpc_json(transport);
 472
 473                                         var show_next_feed = getInitParam("on_catchup_show_next_feed") == "1";
 474
 475                                         if (show_next_feed) {
 476                                                 var nuf = getNextUnreadFeed(feed, is_cat);
 477
 478                                                 if (nuf) {
 479                                                         viewfeed({feed: nuf, is_cat: is_cat});
 480                                                 }
 481                                         } else {
 482                                                 if (feed == getActiveFeedId() && is_cat == activeFeedIsCat()) {
 483                                                         viewCurrentFeed();
 484                                                 }
 485                                         }
 486
 487                                         notify("");
 488                                 } });
 489
 490         } catch (e) {
 491                 exception_error("catchupFeed", e);
 492         }
 493 }
 494
 495 function decrementFeedCounter(feed, is_cat) {
 496         try {
 497                 var ctr = getFeedUnread(feed, is_cat);
 498
 499                 if (ctr > 0) {
 500                         setFeedUnread(feed, is_cat, ctr - 1);
 501                         global_unread = global_unread - 1;
 502                         updateTitle();
 503
 504                         if (!is_cat) {
 505                                 var cat = parseInt(getFeedCategory(feed));
 506
 507                                 if (!isNaN(cat)) {
 508                                         ctr = getFeedUnread(cat, true);
 509
 510                                         if (ctr > 0) {
 511                                                 setFeedUnread(cat, true, ctr - 1);
 512                                         }
 513                                 }
 514                         }
 515                 }
 516
 517         } catch (e) {
 518                 exception_error("decrement_feed_counter", e);
 519         }
 520 }
 521
 522