☰

Next Page

使用左右方向键来翻页 [Ver 0.1.7.3+]

  1. // ==UserScript==
  2. // @name               Next Page
  3. // @author             Sunwan
  4. // @version            0.1.7.3.004
  5. // @namespace          https://greasyfork.org/scripts/36139-next-page
  6. // @description        使用左右方向键来翻页 [Ver 0.1.7.3+]
  7. // @grant					GM_getValue
  8. // @grant					GM_setValue
  9. // @grant					GM_registerMenuCommand
  10. // @include            http://*
  11. // @include            https://*
  12. // ==/UserScript==
  13.  
  14. (function() {
  15.     var checked = false;
  16.     var delay = false;
  17.     var next = {};
  18.     var previous = {};
  19.     // 下一页链接里的文字
  20.     next.texts      = [ 'next',
  21.                         'next page',
  22.                         'old',
  23.                         'older',
  24.                         'earlier',
  25.                         '下页',
  26.                         '下頁',
  27.                         '下一页',
  28.                         '下一頁',
  29.                         '后一页',
  30.                         '后一頁',
  31.                         '翻下页',
  32.                         '翻下頁',
  33.                         '后页',
  34.                         '后頁',
  35.                         '下翻',
  36.                         '下一个',
  37.                         '下一张',
  38.                         '下一幅',
  39.                         '下一节',
  40.                         '下一章',
  41.                         '下一篇',
  42.                         '后一章',
  43.                         '后一篇'
  44.                       ];
  45.     // 上一页链接里的文字
  46.     previous.texts  = [ 'previous',
  47.                         'prev',
  48.                         'previous page',
  49.                         'new',
  50.                         'newer',
  51.                         'later',
  52.                         '上页',
  53.                         '上頁',
  54.                         '上一页',
  55.                         '上一頁',
  56.                         '前一页',
  57.                         '前一頁',
  58.                         '翻上页',
  59.                         '翻上頁',
  60.                         '前页',
  61.                         '前頁',
  62.                         '上翻',
  63.                         '上一个',
  64.                         '上一张',
  65.                         '上一幅',
  66.                         '上一节',
  67.                         '上一章',
  68.                         '上一篇',
  69.                         '前一章',
  70.                         '前一篇'
  71.                       ];
  72.     // 可能会误判的关键词
  73.     next.miswords   = { "下一章": 30,
  74.                         "下一篇": 30,
  75.                         "后一章": 30,
  76.                         "后一篇": 30,
  77.                         "下一节": 30,
  78.                         ">>": 2000,
  79.                         "»": 2000
  80.                       }
  81.     previous.miswords = { "上一章": 30,
  82.                           "上一篇": 30,
  83.                           "前一章": 30,
  84.                           "前一篇": 30,
  85.                           "上一节": 30,
  86.                           "<<": 2000,
  87.                           "«": 2000
  88.                         }
  89.  
  90.     // 取得自定义关键词
  91.     getCustom(next, "next");
  92.     getCustom(previous, "previous");
  93.     // 注册脚本菜单
  94.     registerMenu("next");
  95.     registerMenu("previous");
  96.     
  97.     // 最后添加一些论坛使用的翻页符号
  98.     next.texts.push(">>");
  99.     next.texts.push(">");
  100.     next.texts.push("»");
  101.     next.texts.push("›");
  102.     previous.texts.push("<<");
  103.     previous.texts.push("<");
  104.     previous.texts.push("«");
  105.     previous.texts.push("‹");
  106.  
  107.     // 翻页文字的前面和后面可能包含的字符（正则表达式）
  108.     var preRegexp  = '(^\\s*(?:[<‹«]*|[>›»]*|[\\(\\[『「［【]?)\\s*)';
  109.     var nextRegexp = '(\\s*(?:[>›»]*|[\\)\\]』」］】]?)\\s*$)';
  110.  
  111.     // 取得并设置自定义关键词
  112.     function getCustom(aObj, key) {
  113.       var site, re;
  114.       var cKeyWords = GM_getValue("custom_" + key, "");
  115.       var words = cKeyWords.split(/,|，/);
  116.       for (var w in words) {
  117.         site = null;
  118.         if (/^\s*{\s*(\S*?)\s*}(.*)$/.test(w)) {
  119.           site = RegExp.$1;
  120.           w = RegExp.$2;
  121.           site = site.replace(/[\/\?\.\(\)\+\-\[\]\$]/g, "\\$&").replace(/\*/g, "\.*");
  122.         }
  123.         w = w.replace(/\\/g, "\\").replace(/^\s+|\s+$/g, "");
  124.         if (w) {
  125.           if (site) {
  126.             re = eval('/' + site + '/i');
  127.             if (re.test(location.href))
  128.               aObj.texts.push(w);
  129.           }
  130.           else
  131.             aObj.texts.push(w);
  132.         }
  133.       }
  134.     }
  135.  
  136.     // 注册菜单
  137.     function registerMenu(key) {
  138.       if (navigator.language == "zh-CN") {
  139.         var word = key == "next" ? "下一页" : "上一页";
  140.         GM_registerMenuCommand("Next Page " + word + "关键词", function(){setCustom(key, word)});
  141.       }
  142.       else {
  143.         GM_registerMenuCommand("Next Page custom_" + key, function(){setCustom(key, key)});
  144.       }
  145.     }
  146.  
  147.     // 设置新的关键词
  148.     function setCustom(k, w) {
  149.       var text = navigator.language == "zh-CN" ? "请输入“"+w+"”的关键词，以“,”号分隔开。" : "Please enter the "+w+" page key-words, split with ','.";
  150.       var result = prompt(text, GM_getValue("custom_" + k, ""));
  151.       if (result != null) GM_setValue("custom_" + k, result);
  152.     }
  153.  
  154.     function checkLinks() {
  155.       var link, text, ldnc, lnc, ldpc, lpc, num, digCurFound, linkNumber, found, tmpNode;
  156.       var regexp = new RegExp();
  157.       // 查找相应的链接
  158.       var links = document.getElementsByTagName('A');
  159.       for (var i = 0; i < links.length; i++) {
  160.         link = links[i];
  161.  
  162.         // 跳过不起作用的链接
  163.         if (!link.offsetParent || link.offsetWidth == 0 || link.offsetHeight == 0 || !link.hasAttribute("href") && !link.hasAttribute("onclick"))
  164.           continue;
  165.         // 跳过日历
  166.         if (/(?:^|\s)(?:monthlink|weekday|day|day[\-_]\S+)(?:\s|$)/i.test(link.className))
  167.           continue;
  168.  
  169.         if (/^nextlink/i.test(link.id) || /^linknext/i.test(link.id) ||
  170.             /(^|\s)nextlink/i.test(link.className) || /(^|\s)linknext/i.test(link.className))
  171.           next.link = link;
  172.         if (/^prev(ious)?link/i.test(link.id) || /^linkprev(ious)?/i.test(link.id) ||
  173.             /(^|\s)prev(ious)?link/i.test(link.className) || /(^|\s)linkprev(ious)?/i.test(link.className))
  174.           previous.link = link;
  175.  
  176.         text = link.textContent;
  177.         if (!text) {
  178.           // 若链接中没有文字，则检查图片的alt属性、链接或图片的title
  179.           for (var img in link.childNodes) {
  180.             if (img.localName == "IMG") {
  181.               text = img.alt || link.title || img.title;
  182.               if (text) break;
  183.             }
  184.           }
  185.           if (!text) continue;
  186.         }
  187.         text = text.toLowerCase().replace(/^\s+|\s+$/g, "");
  188.         if (!text) continue;
  189.  
  190.         // 纯数字链接
  191.         if (isDigital(text)) {
  192.           if (digCurFound) continue;
  193.           linkNumber = parseInt(RegExp.$1);
  194.  
  195.           // 检测下一个位置是否是当前页面的页数
  196.           if ((tmpNode = getCurrentPageNode(link, linkNumber, 1)) && tmpNode) {
  197.             digCurFound = true;
  198.             previous.link = link;
  199.             previous.found = true;
  200.             previous.pos = i;
  201.             // 再检测下下一个位置是否是“下一页”的链接
  202.             if (getNextLink(tmpNode, linkNumber+2, true))
  203.               break;
  204.             // 设置往后的30个位置以内为“下一页”的可能链接，以提高检测速度。
  205.             ldnc = i + 30;
  206.           }
  207.           // 检测上一个位置是否是当前页面的页数
  208.           else if (getCurrentPageNode(link, linkNumber, -1)) {
  209.             digCurFound = true;
  210.             next.link = link;
  211.             next.found = true;
  212.             next.pos = i;
  213.             ldpc = i + 30;
  214.             continue;
  215.           }
  216.           // 检测自身是否是当前页面的页数
  217.           else if (getCurrentPageNode(link, linkNumber, 0)) {
  218.             digCurFound = true;
  219.             // 再检测下一个位置是否是“下一页”的链接
  220.             if (getNextLink(link, linkNumber+1, true)) {
  221.               next.pos = i;
  222.               ldpc = i + 30;
  223.               continue;
  224.             }
  225.             // 设置往后的30个位置以内为“下一页”的可能链接，以提高检测速度。
  226.             ldnc = i + 30;
  227.           }
  228.           continue;
  229.         }
  230.         else {
  231.           found = false;
  232.           if (!next.found && !(lnc < i) && !(ldnc < i)) {
  233.             for (var j = 0; j < next.texts.length; j++) {
  234.               if (regexp.compile(preRegexp + next.texts[j] + nextRegexp, 'i').test(text)) {
  235.                 // 检测到“下一页”的链接
  236.                 found = true;
  237.                 next.link = link;
  238.                 num = next.miswords[next.texts[j]];
  239.                 // 若“下一页”的词语有可能会误判时，最多再检测预定个数的链接。
  240.                 (num == null) ? next.found = true : lnc = i + num;
  241.                 break;
  242.               }
  243.             }
  244.           }
  245.           if (!next.digital && lnc < i) next.found = true;
  246.  
  247.           if (!found && !previous.found && !(lpc < i) && !(ldpc < i)) {
  248.             for (var j = 0; j < previous.texts.length; j++) {
  249.               if (regexp.compile(preRegexp + previous.texts[j] + nextRegexp, 'i').test(text)) {
  250.                 // 检测到“上一页”的链接
  251.                 previous.link = link;
  252.                 num = previous.miswords[previous.texts[j]];
  253.                 // 若“上一页”的词语有可能会误判时，最多再检测预定个数的链接。
  254.                 (num == null) ? previous.found = true : lpc = i + num;
  255.                 break;
  256.               }
  257.             }
  258.           }
  259.           if (lpc < i) previous.found = true;
  260.           // 重新设置纯数字链接未被检查
  261.           digCurFound = null;
  262.         }
  263.  
  264.         // 找到“上一页”和“下一页”的链接或找到其中一个而另一个超过规定范围没找到，将不再查找。
  265.         if (next.found && previous.found ||
  266.             next.found && i > next.pos + 30 ||
  267.             previous.found && i > previous.pos + 30)
  268.           break;
  269.       }
  270.       // 通过以上方法没有找到“下一页”的，把第一次检测出来的数字1的链接作为当前页，2作为“下一页”。
  271.       if (!next.found /*&& !next.link*/ && next.digital)
  272.         next.link = next.digital;
  273.  
  274.       if (next.link) next.found = true;
  275.       if (previous.link) previous.found = true;
  276.  
  277.       if (!next.found && !previous.found)
  278.         checkButtons();
  279.     }
  280.  
  281.     // 检查翻页按钮
  282.     function checkButtons() {
  283.       var but, text, found;
  284.       var regexp = new RegExp();
  285.       var buts = document.getElementsByTagName('INPUT');
  286.       for (var i = 0; i < buts.length; i++) {
  287.         but = buts[i];
  288.         if (but.hasAttribute("disabled") || !(/^button$/i.test(but.type) && but.getAttribute("onclick"))) continue;
  289.  
  290.         text = but.value;
  291.         found = false;
  292.         if (!next.found) {
  293.           for (var j = 0; j < next.texts.length; j++) {
  294.             if (regexp.compile(preRegexp + next.texts[j] + nextRegexp, 'i').test(text)) {
  295.               // 检测到“下一页”的按钮
  296.               next.link = but;
  297.               next.found = found = true;
  298.               break;
  299.             }
  300.           }
  301.         }
  302.  
  303.         if (!found && !previous.found) {
  304.           for (var j = 0; j < previous.texts.length; j++) {
  305.             if (regexp.compile(preRegexp + previous.texts[j] + nextRegexp, 'i').test(text)) {
  306.               // 检测到“上一页”的按钮
  307.               previous.link = but;
  308.               previous.found = true;
  309.               break;
  310.             }
  311.           }
  312.         }
  313.         if (next.found && previous.found) break;
  314.       }
  315.     }
  316.  
  317.     // 取得相邻的纯数字节点，type: 1 下一个；-1 上一个
  318.     function getSiblingNode(node, type) {
  319.       if (!node) return null;
  320.       node = getSibling(node, type);
  321.       while (node && (node.nodeName == "#coment" ||
  322.             (/^\s*[\]］】]?[,\|]?\s*[\[［【]?\s*$/.test(node.textContent))))
  323.         node = getSibling(node, type);
  324.       return node;
  325.     }
  326.     function getSibling(aNode, type) {
  327.       if (!aNode) return null;
  328.       if (isOnlyNode(aNode)) {
  329.         try {
  330.           aNode = (type == 1 ? aNode.parentNode.nextSibling : aNode.parentNode.previousSibling);
  331.           if (skipNode(aNode))
  332.             aNode = (type == 1 ? aNode.nextSibling : aNode.previousSibling);
  333.           aNode = aNode.childNodes[0];
  334.           if (skipNode(aNode))
  335.             aNode = aNode.nextSibling;
  336.         }
  337.         catch (e) {return null;}
  338.       }
  339.       else {
  340.         aNode = (type == 1 ? aNode.nextSibling : aNode.previousSibling);
  341.       }
  342.       return aNode;
  343.     }
  344.     function isOnlyNode(n) {
  345.       return !n.nextSibling && !n.previousSibling ||
  346.              !n.nextSibling && skipNode(n.previousSibling) && !n.previousSibling.previousSibling ||
  347.              !n.previousSibling && skipNode(n.nextSibling) && !n.nextSibling.nextSibling ||
  348.              skipNode(n.previousSibling) && !n.previousSibling.previousSibling &&
  349.              skipNode(n.nextSibling) && !n.nextSibling.nextSibling;
  350.     }
  351.     function skipNode(sNode) {
  352.       return sNode && /*sNode.nodeName == "#text" &&*/ (/^\s*$/.test(sNode.textContent));
  353.     }
  354.  
  355.     // 检测是否有下一页的纯数字链接，number:页数
  356.     function getNextLink(node, number, set) {
  357.       var tNode = getSiblingNode(node, 1);
  358.       if (tNode && tNode.nodeName == "A" && isDigital(tNode.textContent)) {
  359.         if (RegExp.$1 == number) {
  360.           // 找到纯数字链接
  361.           if (set) {
  362.             next.link = tNode;
  363.             next.found = true;
  364.           }
  365.           return tNode;
  366.         }
  367.       }
  368.       return null;
  369.     }
  370.  
  371.     function isDigital(str, t) {
  372.       str = str.replace(/^\s+|\s+$/g, "");
  373.       if (t == -1)
  374.         str = str.split(/\s+/).pop();
  375.       else if (t == 1)
  376.         str = str.split(/\s+/)[0];
  377.       return (/^(\d+)$/.test(str)) ||
  378.              (/^\[\s?(\d+)\s?\]$/.test(str)) ||
  379.              (/^【\s?(\d+)\s?】$/.test(str)) ||
  380.              (/^［\s?(\d+)\s?］$/.test(str)) ||
  381.              (/^<\s?(\d+)\s?>$/.test(str));
  382.     }
  383.  
  384.     // 判断是否是当前页面的数字，type:-1,0,1 分别是要判别的上一个、当前、下一个节点
  385.     function getCurrentPageNode(node, linkNum, type) {
  386.       var tNode;
  387.       if (type == 0) {
  388.         tNode = getSiblingNode(node, 1) || getSiblingNode(node, -1);
  389.         if (!tNode) return null;
  390.         if (!node.hasAttribute("onclick") && node.href != tNode.href &&
  391.             (!node.hasAttribute("href") && isDigital(node.textContent, type) ||
  392.             !(/\/#[^\/]+$/.test(node.href)) && node.href == location.href && isDigital(node.textContent, type))) {
  393.           if (linkNum > 0 && RegExp.$1 == linkNum) return node;
  394.         }
  395.         // 某些论坛处在第一页时，实际链接和当前页链接不符，只有和其余纯数字链接的结构或颜色不同时，
  396.         // 才使用纯数字的“2”作为“下一页”的链接。
  397.         else if (!next.digital && (/^\s*[\[［【]?1[\]］】]?\s*$/.test(node.textContent))) {
  398.           var two = getNextLink(node, 2);
  399.           if (two && difDigital(node, two))
  400.             next.digital = two;
  401.         }
  402.       }
  403.       else {
  404.         tNode = getSiblingNode(node, type);
  405.         if (!tNode) return null;
  406.         if (tNode.nodeName != "A" && isDigital(tNode.textContent, type) ||
  407.             tNode.nodeName == "A" && !tNode.hasAttribute("onclick") && node.href != tNode.href &&
  408.             (!tNode.hasAttribute("href") && isDigital(tNode.textContent, type) ||
  409.             !(/\/#[^\/]+$/.test(tNode.href)) && tNode.href == location.href && isDigital(tNode.textContent, type))) {
  410.           var n = linkNum + type;
  411.           if (n > 0 && RegExp.$1 == n) {
  412.             if (next.digital) next.digital = null;
  413.             return tNode;
  414.           }
  415.         }
  416.       }
  417.       return null;
  418.     }
  419.  
  420.     function difDigital(node1, node2) {
  421.       if (getStructure(node1) == getStructure(node2) && getStyleColor(node1) == getStyleColor(node2))
  422.         return false;
  423.       return true;
  424.     }
  425.     function getStructure(aNode) {
  426.       return aNode.innerHTML.replace(/\d+/, "");
  427.     }
  428.     function getStyleColor(aNode) {
  429.       return document.defaultView.getComputedStyle(aNode, null).getPropertyValue("color");
  430.     }
  431.  
  432.     function openLink(linkNode) {
  433.       if (!linkNode) return;
  434.       var hf = linkNode.getAttribute("href");
  435.       if (!linkNode.hasAttribute("onclick") && hf && !(/^#/.test(hf)) && linkNode.href != location.href) {
  436.         cleanVars();
  437.         location.assign(linkNode.href);
  438.       }
  439.       else {
  440.         // 有些4D鼠标摆动一下滚轮会触发多下的方向键，故增设一个延迟参数，使它只翻一页。
  441.         delay = true;
  442.         setTimeout(cleanVars, 300);
  443.         var e = document.createEvent("MouseEvents");
  444.         e.initMouseEvent("click", 1, 1, window, 1, 0,0,0,0,0,0,0,0,0, linkNode);
  445.         linkNode.dispatchEvent(e);
  446.       }
  447.     }
  448.     function cleanVars() {
  449.       try {
  450.         checked = false;
  451.         delay = false;
  452.         next.link = next.found = next.digital = null;
  453.         previous.link = previous.found = previous.digital = null;
  454.         delete next.pos;
  455.         delete previous.pos;
  456.       } catch(e) {}
  457.     }
  458.  
  459.     function onKeyDown(event) {
  460.       // 不是左右方向建被按下或不到延迟时间则退出
  461.       if (event.ctrlKey || event.shiftKey || event.altKey || event.metaKey || event.keyCode != 37 && event.keyCode != 39 || delay)
  462.         return
  463.  
  464.       // 确保光标不是定位在文字输入框或选择框
  465.       var localName = event.target.localName.toUpperCase();
  466.       if (localName == 'TEXTAREA' || localName == 'INPUT' || localName == 'SELECT' || localName == 'DIV')
  467.         return;
  468.  
  469.       // 检查过且没有发现上一页或下一页的连接，则退出
  470.       if (checked && !next.found && !previous.found)
  471.         return;
  472.  
  473.       if (!checked) {
  474.         checkLinks();
  475.         checked = true;
  476.       }
  477.  
  478.       if (event.keyCode == 37 && previous.found) {
  479.         // 左方向键，跳到“上一页”
  480.         openLink(previous.link)
  481.       }
  482.       else if (event.keyCode == 39 && next.found) {
  483.         // 右方向键，跳到“下一页”
  484.         openLink(next.link)
  485.       }
  486.     }
  487.  
  488.     window.addEventListener("keydown", function(e){onKeyDown(e)}, true);
  489. })();