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