js/feedlist.js

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